diff --git a/Notebooks/Colors_Run12p_spark.ipynb b/Notebooks/Colors_Run12p_spark.ipynb new file mode 100644 index 0000000..8b2d4a1 --- /dev/null +++ b/Notebooks/Colors_Run12p_spark.ipynb @@ -0,0 +1,540 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DC2 Run1.2 object catalog colors (Spark)\n", + "
Owner: **S Plaszczynski** (https://github.com/LSSTDESC/DC2-production/issues/299)\n", + "
Last Verified to Run: **2018-11-26**\n", + "\n", + "The goal of this notebook is to have a QA look a the dc2-data-access produced object_catalog (currently on Run1.2p) on the colors side\n", + "It also illustrates how simple and efficient Spark is.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read the data" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- magerr_g: double (nullable = true)\n", + " |-- I_flag_g: boolean (nullable = true)\n", + " |-- tract: long (nullable = true)\n", + " |-- IxyPSF_y: double (nullable = true)\n", + " |-- I_flag_y: boolean (nullable = true)\n", + " |-- Ixx_i: double (nullable = true)\n", + " |-- dec: double (nullable = true)\n", + " |-- magerr_u: double (nullable = true)\n", + " |-- mag_z_cModel: double (nullable = true)\n", + " |-- mag_u: double (nullable = true)\n", + " |-- snr_g_cModel: double (nullable = true)\n", + " |-- Ixx: double (nullable = true)\n", + " |-- mag_u_cModel: double (nullable = true)\n", + " |-- magerr_y: double (nullable = true)\n", + " |-- magerr_r_cModel: double (nullable = true)\n", + " |-- IxyPSF_r: double (nullable = true)\n", + " |-- psFlux_y: double (nullable = true)\n", + " |-- magerr_y_cModel: double (nullable = true)\n", + " |-- mag_g_cModel: double (nullable = true)\n", + " |-- Iyy_i: double (nullable = true)\n", + " |-- I_flag_z: boolean (nullable = true)\n", + " |-- snr_u_cModel: double (nullable = true)\n", + " |-- Ixy_z: double (nullable = true)\n", + " |-- psFluxErr_r: double (nullable = true)\n", + " |-- mag_i_cModel: double (nullable = true)\n", + " |-- Ixy: double (nullable = true)\n", + " |-- psf_fwhm_g: double (nullable = true)\n", + " |-- x: double (nullable = true)\n", + " |-- psFlux_z: double (nullable = true)\n", + " |-- Ixy_u: double (nullable = true)\n", + " |-- psNdata: float (nullable = true)\n", + " |-- snr_i_cModel: double (nullable = true)\n", + " |-- IyyPSF_z: double (nullable = true)\n", + " |-- Iyy_u: double (nullable = true)\n", + " |-- mag_i: double (nullable = true)\n", + " |-- parentObjectId: long (nullable = true)\n", + " |-- IxxPSF_y: double (nullable = true)\n", + " |-- IyyPSF_r: double (nullable = true)\n", + " |-- psFluxErr_i: double (nullable = true)\n", + " |-- I_flag: boolean (nullable = true)\n", + " |-- mag_y_cModel: double (nullable = true)\n", + " |-- IyyPSF_u: double (nullable = true)\n", + " |-- I_flag_u: boolean (nullable = true)\n", + " |-- magerr_u_cModel: double (nullable = true)\n", + " |-- xErr: float (nullable = true)\n", + " |-- IxxPSF_u: double (nullable = true)\n", + " |-- IxxPSF_r: double (nullable = true)\n", + " |-- I_flag_r: boolean (nullable = true)\n", + " |-- psFlux_flag_i: boolean (nullable = true)\n", + " |-- psf_fwhm_i: double (nullable = true)\n", + " |-- IxxPSF: double (nullable = true)\n", + " |-- psf_fwhm_z: double (nullable = true)\n", + " |-- y: double (nullable = true)\n", + " |-- Iyy: double (nullable = true)\n", + " |-- magerr_i_cModel: double (nullable = true)\n", + " |-- IyyPSF_y: double (nullable = true)\n", + " |-- psFluxErr_g: double (nullable = true)\n", + " |-- psFlux_flag_y: boolean (nullable = true)\n", + " |-- magerr_i: double (nullable = true)\n", + " |-- psFlux_flag_z: boolean (nullable = true)\n", + " |-- I_flag_i: boolean (nullable = true)\n", + " |-- snr_z_cModel: double (nullable = true)\n", + " |-- Ixy_g: double (nullable = true)\n", + " |-- psFlux_r: double (nullable = true)\n", + " |-- psf_fwhm_r: double (nullable = true)\n", + " |-- magerr_g_cModel: double (nullable = true)\n", + " |-- IyyPSF_g: double (nullable = true)\n", + " |-- Ixx_z: double (nullable = true)\n", + " |-- IxyPSF: double (nullable = true)\n", + " |-- psFlux_flag_r: boolean (nullable = true)\n", + " |-- objectId: long (nullable = true)\n", + " |-- Ixx_u: double (nullable = true)\n", + " |-- magerr_z_cModel: double (nullable = true)\n", + " |-- patch: string (nullable = true)\n", + " |-- IxyPSF_i: double (nullable = true)\n", + " |-- IxyPSF_u: double (nullable = true)\n", + " |-- IxyPSF_z: double (nullable = true)\n", + " |-- mag_r_cModel: double (nullable = true)\n", + " |-- magerr_r: double (nullable = true)\n", + " |-- Ixx_r: double (nullable = true)\n", + " |-- IxxPSF_z: double (nullable = true)\n", + " |-- Ixy_i: double (nullable = true)\n", + " |-- psf_fwhm_y: double (nullable = true)\n", + " |-- Iyy_g: double (nullable = true)\n", + " |-- Iyy_y: double (nullable = true)\n", + " |-- IxxPSF_i: double (nullable = true)\n", + " |-- mag_z: double (nullable = true)\n", + " |-- psFluxErr_u: double (nullable = true)\n", + " |-- psFlux_i: double (nullable = true)\n", + " |-- IyyPSF: double (nullable = true)\n", + " |-- clean: boolean (nullable = true)\n", + " |-- psFlux_u: double (nullable = true)\n", + " |-- mag_y: double (nullable = true)\n", + " |-- Ixx_y: double (nullable = true)\n", + " |-- blendedness: double (nullable = true)\n", + " |-- Iyy_r: double (nullable = true)\n", + " |-- mag_g: double (nullable = true)\n", + " |-- snr_y_cModel: double (nullable = true)\n", + " |-- xy_flag: boolean (nullable = true)\n", + " |-- magerr_z: double (nullable = true)\n", + " |-- psFluxErr_z: double (nullable = true)\n", + " |-- Ixx_g: double (nullable = true)\n", + " |-- ra: double (nullable = true)\n", + " |-- IyyPSF_i: double (nullable = true)\n", + " |-- psFlux_flag_u: boolean (nullable = true)\n", + " |-- good: boolean (nullable = true)\n", + " |-- IxxPSF_g: double (nullable = true)\n", + " |-- Ixy_y: double (nullable = true)\n", + " |-- psf_fwhm_u: double (nullable = true)\n", + " |-- yErr: float (nullable = true)\n", + " |-- mag_r: double (nullable = true)\n", + " |-- IxyPSF_g: double (nullable = true)\n", + " |-- psFluxErr_y: double (nullable = true)\n", + " |-- psFlux_g: double (nullable = true)\n", + " |-- snr_r_cModel: double (nullable = true)\n", + " |-- Ixy_r: double (nullable = true)\n", + " |-- extendedness: double (nullable = true)\n", + " |-- psFlux_flag_g: boolean (nullable = true)\n", + " |-- Iyy_z: double (nullable = true)\n", + "\n" + ] + } + ], + "source": [ + "from pyspark.sql import SparkSession\n", + "\n", + "# Initialise our Spark session\n", + "spark = SparkSession.builder.getOrCreate()\n", + "#read the parquet Run1.2p catalog\n", + "object_catalog=\"/global/cscratch1/sd/plaszczy/Run1.2p/object_catalog/full_catalog.parquet\"\n", + "df_all=spark.read.parquet(object_catalog)\n", + "df_all.printSchema()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "select relevant columns concerning colors (+some goodies). Add a helapix index column" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tract,patch,ra,dec,good,clean,psFlux_flag_u,psFlux_u,mag_u,mag_u_cModel,snr_u_cModel,psFlux_flag_g,psFlux_g,mag_g,mag_g_cModel,snr_g_cModel,psFlux_flag_r,psFlux_r,mag_r,mag_r_cModel,snr_r_cModel,psFlux_flag_i,psFlux_i,mag_i,mag_i_cModel,snr_i_cModel,psFlux_flag_z,psFlux_z,mag_z,mag_z_cModel,snr_z_cModel\n", + "27083536\n" + ] + } + ], + "source": [ + "filters=['u','g','r','i','z']\n", + "\n", + "# build selection by appending to string\n", + "cols=\"tract,patch,ra,dec,good,clean\"\n", + "for f in filters:\n", + " s=\",psFlux_flag_{0},psFlux_{0},mag_{0},mag_{0}_cModel,snr_{0}_cModel\".format(f)\n", + " cols+=s\n", + "print(cols)\n", + "\n", + "#use these columns\n", + "df=df_all.select(cols.split(','))\n", + "\n", + "#it will be usefull to add a column of healpix indices\n", + "import pandas as pd\n", + "import numpy as np\n", + "import healpy as hp\n", + "from pyspark.sql.functions import pandas_udf, PandasUDFType\n", + "nside=1024\n", + "#create the ang2pix user-defined-function. \n", + "#we use pandas_udf because they are more efficient\n", + "@pandas_udf('int', PandasUDFType.SCALAR)\n", + "def Ang2Pix(ra,dec):\n", + " return pd.Series(hp.ang2pix(nside,np.radians(90-dec),np.radians(ra)))\n", + "#add the column\n", + "df=df.withColumn(\"ipix\",Ang2Pix(\"ra\",\"dec\"))\n", + "\n", + "# put in cache (use count since it is an action)\n", + "N=df.cache().count()\n", + "print(N)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## statistics per filter" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u 1500076 N(OK)=683525 frac=0.46\n", + "g 1274607 N(OK)=687842 frac=0.54\n", + "r 898424 N(OK)=696089 frac=0.77\n", + "i 937069 N(OK)=695138 frac=0.74\n", + "z 891525 N(OK)=695884 frac=0.78\n" + ] + } + ], + "source": [ + "for f in ['u','g','r','i','z']:\n", + " dff=df.select(\"psFlux_flag_\"+f,\"psFlux_\"+f).filter(df['psFlux_flag_'+f]==True)\n", + " N=dff.count()\n", + " Na=dff.na.drop().count()\n", + " print(\"{} {:8d} N(OK)={:6d} frac={:.2f}\".format(f,N,Na,float(Na)/N))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "same with magnitudes (keeping same flag)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u 433267 N(OK)=433267 frac=1.00\n", + "g 492428 N(OK)=492428 frac=1.00\n", + "r 535617 N(OK)=535617 frac=1.00\n", + "i 539843 N(OK)=539843 frac=1.00\n", + "z 530983 N(OK)=530983 frac=1.00\n" + ] + } + ], + "source": [ + "for f in ['u','g','r','i','z']:\n", + " dff=df.select(\"psFlux_flag_\"+f,\"psFlux_\"+f).filter((df['psFlux_flag_'+f]==True)&(df['psFlux_'+f]>0))\n", + " N=dff.count()\n", + " Na=dff.na.drop().count()\n", + " print(\"{} {:8d} N(OK)={:6d} frac={:.2f}\".format(f,N,Na,float(Na)/N))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "same after fit" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u 1500076 N(OK)=420145 frac=0.28\n", + "g 1274607 N(OK)=483795 frac=0.38\n", + "r 898424 N(OK)=523131 frac=0.58\n", + "i 937069 N(OK)=527497 frac=0.56\n", + "z 891525 N(OK)=521904 frac=0.59\n" + ] + } + ], + "source": [ + "for f in ['u','g','r','i','z']:\n", + " dff=df.select(\"psFlux_flag_\"+f,\"mag_\"+f+\"_cModel\",\"snr_\"+f+\"_cModel\").filter(df['psFlux_flag_'+f]==True)\n", + " N=dff.count()\n", + " Na=dff.na.drop().count()\n", + " print(\"{} {:8d} N(OK)={:6d} frac={:.2f}\".format(f,N,Na,float(Na)/N))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "let's apply some quality cuts" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u 1476298 N(OK)=414500 frac=0.28\n", + "g 1252905 N(OK)=477701 frac=0.38\n", + "r 881003 N(OK)=516434 frac=0.59\n", + "i 919244 N(OK)=520803 frac=0.57\n", + "z 874421 N(OK)=515294 frac=0.59\n" + ] + } + ], + "source": [ + "for f in ['u','g','r','i','z']:\n", + " dff=df.select(\"psFlux_flag_\"+f,\"mag_\"+f+\"_cModel\",\"snr_\"+f+\"_cModel\").\\\n", + " filter((df['psFlux_flag_'+f]==True) & (df['good']==True) & (df['clean']==True))\n", + " N=dff.count()\n", + " Na=dff.na.drop().count()\n", + " print(\"{} {:8d} N(OK)={:6d} frac={:.2f}\".format(f,N,Na,float(Na)/N))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## maps per filter" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "amazing function to get (approximately) tract borders from the data (only superior minds can understand is beauty)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10645\n", + "4848-4636-4639-5065-5064-4637-4432-5063-4640-4433-4429-5066-4430-4638-4431-4851-4849-4852-5062-4850-" + ] + } + ], + "source": [ + "#list of tracts\n", + "tracts=df.select(\"tract\").distinct().toPandas()\n", + "df_withpix=df.groupBy([\"tract\",\"ipix\"]).count().drop('count')\n", + "print(df_withpix.cache().count())\n", + "ipix=np.arange(hp.nside2npix(nside))\n", + "pixborder=[]\n", + "for t in tracts['tract'].values :\n", + " print(t,end='-')\n", + " #create a map just for this tract\n", + " df_map=df_withpix.filter(df_withpix.tract==int(t))\n", + " #create the healpix map\n", + " tract_p=df_map.toPandas()\n", + " tract_map = np.full(hp.nside2npix(nside),hp.UNSEEN)\n", + " tract_map[tract_p['ipix'].values]=1\n", + " # for lit pixels compute the neighbours\n", + " ipix1=tract_p['ipix'].values\n", + " theta,phi=hp.pix2ang(nside,ipix1)\n", + " neighbours=hp.get_all_neighbours(nside,theta,phi,0).transpose()\n", + " # border if at least one neighbours is UNSEEN\n", + " mask=[(hp.UNSEEN in tract_map[neighbours[pixel]]) for pixel in range(len(ipix1))]\n", + " pixborder+=list(ipix1[mask])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "map for each filter (at least where flag non false and not NaN)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u 46.53281065406508 21.6152811401939\n", + "g 52.46409546132538 23.692179764865628\n", + "r 56.339223729883244 24.028730006252143\n", + "i 56.879464756084715 23.916217713593976\n", + "z 55.863545502367174 24.12504692541923\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAGrCAYAAAAxTLu9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsvX94VtWZLnzvtmMCOE0a/TQQkWgcm1CdNwpnJMSeAwnXfALyQwIiCF5A6Bkg0GMNSKuBvEC0tRDHIz87JchXEIoQCiLgzCGRmSEEZwCTsSW0QzQUA+gnmMwIJH6O+/vjWc9az9p7J4GWFpxZ93Xlenf2Xu9+997vfvd67ufH/Xi+78PBwcHBwaEzfOVaH4CDg4ODw/UPN1k4ODg4OHQJN1k4ODg4OHQJN1k4ODg4OHQJN1k4ODg4OHQJN1k4ODg4OHQJN1k4/JeH53nf9DzvHc/z/t3zvC88z1ug1g/yPO+Da318Dg7XA9xk4eAAPA1gv+/7f+r7/ld8318SNcjzvCbP84b8kY/NweG6gJssHByAPgB+9Yf8AI/gfm8OX1q4m9fhvzQ8z6sGMBjACs/zPvU8b5PneWUR4zYAuB3ALjXuabV+gOd5Bz3Pa/E8r97zvEHiPfs9z3vO87waABcB3HkFx2WxGM/z4p7nbfydT9TB4feEmywc/kvD9/08AP8IYLbv+zcC+KyDcZMB/BbACN/3b/R9/8ee56UB2A2gDEAKgLkAKj3P+7/EWycD+J8A/hTASc/zVqmJJervX/5wZ+rg8PvBTRYODr87JgHY4/v+Ht/3v/B9//8AOAxgmBiz3vf9X/m+/7nv+/+f7/uzfN9P7uDvz6/NaTg4dA03WTg4/O7oA2CcZAcAHgTQU4w5dW0OzcHh6uJr1/oAHBy+RAhKNJ8CsMH3/e9c7ns8z1sDYiRROOn7/rfU8gUA3cW21Cs5UAeHqw3HLBwcLh8fwg5SbwQwwvO8/9vzvK96npeoajNu62gHvu/PUDGPqL9viaF1AB7zPO9PPM/rD2DsH+aUHBwuD26ycHC4fPwQQIlyOc31ff8UgFEAngHw/4KYxjxcnd/VAgAZAD4BsAjApquwTweH3xmea37k4ODg4NAVHLNwcHBwcOgSbrJwcHBwcOgSbrJwcHBwcOgSbrJwcHBwcOgSX8o6i0WLFrmovIODg8NVQmlpqdfVGMcsHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJssHBwcHBy6hJss/gshHvcRj/vX/T7/mOjq2H+f87uc98oxVzr+crZf7f1Hjb+S/f0hPv/LfP99meAmCwcHBweHLuH5/pdvVl60aNF1cdDGYvOs/4Prgtv5/8vdf/S28D66Gh/cLvfR2bbLObbLPSf5/iu9DldzfNS16ux6RI25nGO40v1fyfjgsVyphX21j+dqIuo39fuM7+g3eCXjO7rnO/qN/76/kT8mSktLuzw4xywcHBwcHLqEYxa/B34f66ojqzDKIulqH7+7T/3KrKurcTy/yz6vzId9ZeMdHP6YuF7ZxeUwCzdZXAX8oR5OVzwZpMfptSkevY9Bav3+ODrClU9AD6jXty9z/PWGewG8G1r7+7p4AKAUi6z/F6FULx8ObOuPUvg77XXeqFIEscv/RwDACO/b4Q88IcbfRfsq9r8GACj3Pu/0eDQ++D693vaj8LYI+DsX6eP0nwkc//Ol8JfROm8ujSnFIv25vwkcz90oxRcptO4r52nMBv+XmOzdAwD44pwZ/5WbzP7kucj9M+S6LH8kAKDBe52O+bVF8B61x3+Rskh/fnD/vy++zJOFc0M5ODg4OHQJxywuEx0Fr+0xMgB4i9jyoXpNF+uaLuMzzf76xOPWtqlRlk66GROfYltt8fgMYNCt9M9xtfKsGN9JwLzAvwsAUOmdMBvr1Huz96oVH8Kc0+Pq9VUz/mE1/g31emMc+FQt36Nef2mOBxiiXvcB+lzpnDb4v9Sj2OrM8f87AKDW+wcAt4pjAgz7AcIM6F4AD6rl1fTyNXMc8RL6zPjhUnP8bMEr6x1zxXEvU8s/iqP0+9HG2iKUaot1hFq3C0B8Jy2vGFlojZ/j3aat6t0peQCATXgcm73fAgBm+l/XY1c3fo/2l0HXbz8GAwBu9BZ0eCyAsfLv/uASbdiYCHw/HvkeAKj0/wkAMOb1vfp4Zz9bYY1pewZIXEPL8blm/fc/pddTN9r7/LMHAP9fadl7Rh1GcYHe/vj5Sr3sjVH7/fsOD9HCa/4R6/9jj/ajhXFmnT/DLC86f3n71eMjfo99/Mes/096P9fL1xvDcMzCwcHBweGqwDGLLnB5vup4J9tWA+kzabFpvVr3p2L/v7RGR6WUflhqxq86XqyXvayO/KgjxPJt4c2pt9r/TxKff6PNSADg3dIMvVxZP8na1idGNOWkdwgYMIVWHvpXM+DhP7N3tqaNXjMTUfLvZD6W3fu82f7LA9bwof5H2Os9Qv/8nK7LhvFj9faDGAgAqEM2AGAdpiHLm6/Gq+v+2F4Y2Myi1t+BHO9vAQCJLX8CAGi7OcUM2Bh4fRJAeuCeWCO+r4/VayawfP50WuXZFrdE/B31eh8Q/1+0vOIlm1kUnTfvZ4t74poKfIYbAAC34CO9fRh2W+99eGU17X828F0/EQDwstemtz8OG1/1UwEAGS+cMSsFw1jufwAA6IXTAIAxNXuxItc+3ukXzPH+KMAe4lVA2wP2usR88c84hDCsuNL6f88gwzYuh1nE5S2YHTGgwf533bsT9PJvvc1d7j+KVRT6N+vlZLTo5XLvc/vYrhOG4QLcVwFRriazjh+6M82AE2rbXeraH4B5GDPN/X4lMMDc8AAQfyj8kC7tG9fLh8bFrG0DjteHJgsOfgLADjxibavwxmGCbz9I5E28qX2ite17P/oJ1pROtta9KmaVaVhnbbMmC8ZosTypDUGUpC22/i9bYCaNoUu2h8bv3TLG+n/m+Bf18nfxcmh81pYme8Vj8dCYWn+HXh7cWq2X295MscYljT4LAGg9kGpW7hcDPgjs+GNg+a7p1qrZi8WkMdIevj17KMY8uddeKR9sh+xN+Wt24Rvi+wOAgTiol59audradrQoC+l431p3TkwaPElIZHh/Zf3PEwUAzK4JT4DncxOt/1NmiO/80dBwYE3gf/lQ58t/u1lVKfZR8Jr91rjaFpe2xtTwR8aVHRNXk1J8a8RxAbjdpwljWjlNFvG5QPyewL6EnRecMAr9m/X3cQx99fqFieQOTGq3x1/rScO5oRwcHBwcrgocs+gEUUFte/st9ooTJkKWdBsFV1sPp2JCLlnhm1+YZsbugA1lRcZTF+Hz0nYAwJKtPwQAvDfOWH0fKTazFtNR4X1s7YKZRQme0+v64zCNnzwHEzeQNbgCRdb71gsTbHH7QgBAekITPgSd32BhQm9utM21Phm/BgCcbE4HxpJlObTWsIIh2GeNL24mNrAkrUSv2wTDahp23m+NHzpqe4hR4EFhsR62rdmGUel4CG9a61rak/Vya6Jtztb6O7BPB9MJ0hLc0z4MQbTOCFjhG8XyQ6HhwPTA/4fNYuWS8P7H1NgMY1iuccO0K9eTRHWzOf68NPt6V60kl+TRoiy97r6bjN/l7XM2Y71FJwUYSIZxxLdN+vtrGvBi7kxr3cv4rl7+Oewg74DqemLbElliuU69rlevLxnWwLDcSupW9/6Jfqv+aA/eRvvx4Fd5qFSMIpwkHY0gs9hYXIBJ99rusM6Yhf/OIqzLnmCtG5toXFovtoffdy3ZhWMWDg4ODg5XBY5ZdIHL0XeJZxvrIOmhs9a21gOpmJBv+/e746Jerpg529pWuzobu2Fbm1Pxil7udYH2P7vH8hCzYMR8Y96+iKcAAHmTa/HGBkq7ZF9qSrmx0F8sJuuQg6XLMBcjQIVLjbgrfNyNxE4Sb/4EAND2aXcMTdtjHcdcLNPLHIA+ofbVC6f1OkblFhE8Z8IgSETJ+Ges8RvwhF4+uTOTzn3UIbSAmMTJxm9a43Wqq4C/bBHKiilpoC+O6fUFg+1zSXqTrnu3hIs4O/VOWrle3BtjA/dFG4CywIfJGE6AnFTWDsOYUzajaBNhkzE9yKrdfZ5iXUNSdlmMAgDwpmFZeYVvAACq6hSzyM7S14UhYxjMWB84Xw8AeD8lNRSz8F8x1+/oFKIDmzBRB7uTAzGUxViov4PajPv0mMzFJ2l5/hlrfMvrPQEOY3Hqah4Q34gQmF14heo74J/CxzD3jsI2kYBQoNKT46Po9XFYCd4ADKsAgMPoD8COB03aajOMYFEfQMxCH+t94eMP4lozDMcsHBwcHByuCr52rQ/gekZXabOcLZSK9wAAZ+vvROtxZTIKo39zFcUqcvJNtg1beVmrjwKglE/GcJBVy77fEjyHdRfs9MQb8Fn4gFShXH09UBUbaG1qE656Tjd9GOZ4ZPolANRXDMCIQmIWGaBivDPoZQZ8qgwRlSGYmnZab3qrdRAAYG6SYRYcB+DjXovpOp4ShdgoSv+p3zIA+NTetkulEiWjRV/HwlErAJAlyJbuSZBVy3EV+I9ZhVEdoWDLHpO5pq5btwTDqnRRI6PEC2+TxxxhGeNJ9foSvazFdIwBMYvzvck07n7B0Ko9x4lR+CpMJjOhEm9Uxzb2Itq2ER25NfB97scgZKuAwPDWN/T6XyV9CwBl18n9P42lAE5Y+/Cmlmp28ZmInTxVR5lXQR+9ZHZverT/x/w+2LhQZQK2w4ZIjour2ymOaGhGoZC1lH5HDVPv12x0yStUCdiwuhglr5db4+OKxP7rRpM+/B9+H7V00Iq70JqB+DXuBgC8Mm4KAGCNR6ztN1iEuwMxC+8+c63iyjEQj8jOutaM4krg3FAR6Fpemr7gVF9NEo13mIHqIZoaU9uq7oR/yr4Jtk8ZqpfTA5Xcn+EG/cNlHM00EcC1Ilq62vu36BPYF9eLlwaEb8BE28OC8+MMb7+p4lJo/MxCk6K6uv4pa1tejB48Mijc0mrcHY8nbbLGM51fjIV6nZw02E3F+Aw3oKHCDnrHCk0eKQfQedKoqJ+NnFi1Nf60mOSCk4X/wCKUHSq21i3YYiY5PrTUper7bO6lA/niIAw4vXINzIQQDOj2N4sF42kmuYju+lymCLcjAKQcN5PGenUrvOFv0DUviemm3PiRJDtzYpgyPD7CLdog+E7r3+jtl87cZI1fkUlGyX4M0utk5b5MNQZUwNrOMsZ72cbH9jPPdsvG3wE2Zttp43eJSYknlc4g02P75h4Jbe+J09b/3/ZM3VF8UnB02M21w6/Vy3y/rh78FPLeUq69ASOs8d7bYTdUzH8IdetzaP8RkwTjepksnBvKwcHBweGqwDGLCHSWMhtfUwooYynHJwu2tnGw3p6VQSW5nyhL9xHswKr1ZLmumEJWWy9h+bBLaCLIAm9COsYcJ3fErExDnadjLQDg/tcp7XHWyPIQs2CFUQBYdq+tBdR2CEisss/z+Mg+ejlYZFdbkWcxCoCsU8YngWApANyn8x4J2eL/zyJSPrMD4/vVmwBzVuxoaHwwgCqDjuX1JcHhqI3ZAfQcb3RojP+ACUSmHzIppSfnZVrjZi6la7G6eZZZuUMwjJut4SgcvwIVO+3kBRmsZ0bBGIT9oWv01L2msG69XeiPT/1CzKlfa60riJl9jkaQYezGHgy31k0qN4HaFcW2mxMgTSoJqfrq1QVHA/l5u6z/qxYLCzxQhAgACO5DpMTGlVxXXJA8nU4L4L137QyBh1XlOjMpAHhGpJB/47xdFOqpavmjG7LwukffO1e4A0Ae3gIAneRRNvh55LxFv/eDA1TJufBseQ/a7CLmP6R/s51V8DOuNcNwzMLBwcHB4arAMYtOYMUuUuOh7TlnbN+4TE3kgPXP8IS2gOX2JkuB1rCNdDRptnER3fV2Tuuc/TpZKWUji7HAs4V3JLNgCyvvXvK/5r+7C1Wvk6UnGQVgxxuWYa5+P/v6bxLR+sZATIEL955DCbZhrHWsALAnkAbMx/WqKMSrbjQWb3mGXTC4FtPxDJ631kmGE4xxrK5/CkdifdER+nl2hZf/wCIgIPnQs3ejXn4kVD0JvNI6xfq/7fvGaV+4ekVofDAV+lf4ll7eFFJn6twSvdkPM4BVMGzn2Kl+1raNvSk+IDWjPkOCGQ/7WvH/Mk260LtbL/sHAunH7cCLeXZR3lPHDSN6IzPP2vZwXTXOZ9sxnwdRYz6/ho7/vVxiDneWnzWpsJykISRA3tutxtUR3Z+bvUTHASeKpNiUamIWviKba1So5gE/C/eXE7M4X2yOK6WOxi/I/gEASjp5CsQut4OKRFNrWvX4ILPAiVIsz/iOtaqz7zVKX+qPyTAuh1m4bKgIWJPElLi98U3ofPnamfRDiK2mgOsN+AxrMMMa/gR+ph9o7EaZVG3of/CHtg1j9cTBP1gZBN8+cig6AouUVfl/p9d5ZXQueXgDfUdSMJBvdsY+DNHBVZ7ktmGs9cBg8CTHx3SwVWVdJQHlNeQKqsg1E0FlM00gBWnbAACFK8ndllf0hjVJAAAS23WFd3kaBdILsE1vLgkULmSIwOg38RsAsILbQddavWdXdgPArEPlWHWK3ITTey8HQA+GigXkQlqt6lRmLlFuqIqnkDiWAsr3JSk/ymqgm7pW76vrcweatJHAkwVnMD2IGhxALgBgXuuPAQBLk54OPUziYo6JK+8Kj7nZL9TfBU/A2ajTk8OkU5Vqm5kkoiYmBk/wPLmPxTZrkgCABn89joMMjcwaqpXwhacvGJgHgCZQ8gfXdHhHfJzL7gYAuGkEJVNk7TIuRz/Lfv/c4iVYtpJcqnPfXQIAWDbcuFhZrWATaBIdhLf0Z/L5zq421/X9FHZf0eQiDThddySEDc8J/6JMlACAs7lJAICe3pNmpWhANafxpwCA0rs6duBc60niSuDcUA4ODg4OXcK5oQTCKbP3msUpKt1vNKClh4JCqiJ+WjvKrlgGgFcwRS8Hq2/Zkj4s8iplALdXIB1wLaZjr/cv1jqpOjtipx3NLhy1Qru3GIOE5hNbqVzxnVXRhOJC25KX72eL7P1Wet/UpPVYXWOn1SLdXKCkm8mqbl0rApMPBa53okm8z0mjc8/HPpRVkRuqT75d4NAXx7RWEluA3XFRW8nyWgKUohusep/pf12fu7zGXA+yeoE6Jz6VTKCgkALJ0tKsbaZrw9pMg7Ff72/aVtIE6jvOpHny/n/dStb7pb436dqCRSe+AAD43zW2XDyQ7vyEn4pVSuOLWZ5MAGBXHVv7KcfbdFosf3dyPF8DdkPtrRoDDIlbn9ngr9fLXIew8nwxPkxJUudkF05IJsPV+hUVszG0kLTD9o6wGe4X/4+xqItSKHrcHRc1a7sk3LJBK5+v9SAVmAbs30+wep2PTY55DkYhgJkq4wn8DI/BTruWzJvbtGqcKLWl6wGULuuYMVxrhuEC3A4ODg4OVwUuZtEp3oVmF+uVVTi6nymqChZb7YBmF1x0NhGbtKpqgrImu+Oi9uGzT19WZEtrh8GWlLR+h/p/DgCaYYzwvg0AaPR/gsZRPQEAz+PZ0H4lowBs1desiia9XF5BMQj20QPAHUlmOyD6PowHZua+GDrGZe1zrfFZRarSduX9wJtkzAwtMiq1QQuwbOfzgIrjn6yidNah+Wb8uUDO6nSs1QyoswpxxlwsxWysBGCusVUoyX2WOCtV5BTwefJ3CNiV0xzEnwZiFse2UvA2e5wp+kpIjKjEV/BeJoYhfd6l5+j1fZjvk4+7Bcmh9NuUJxUlmgHMPq6SIzKL9fjg9bZUbbm4cwi9ZnlTrBauAOBtBljEmAPnh0HnmY73Q31VJhSu0585dBd9j1zx3x3nMDVpvTU+HUb9mBlGEVbp7ZyQITH8vJ14wq1oAaAOYaEmZlWPq/R1GfTnJJPsC/VAD1oXVFKO0mjLyngHDaBi0s4YRRSu15iFc0NFIFrmQ+WM39PPVOYy5KShUtO5ec8Q7NMS2JL284+axfbYZdIdF/UNKoXeOGjH79uHISE3lP+ayVRhWXP+cezBMFTUB/L+Rbx36HzlGmA58E+h3QWMd4Tw39ktdyKEQK1Beb7J0lkb0ukOV68fbDdurtY3w814do3Kt/7/a3xPL/MPXaKo1c5MaksON0hq9H+ilzOmCmG74Hd8s3roHhCZPGJxwig7mN6EdP1wi8KRdttFtj1hDP7Bq7XWzfCT9PKt51utbQtTfhCqa5FV8XVP5oQ/dEbg/5fMYv6aXQii2rMnW5k4kbeyNjgcx4vsLDvptgzKwANh1+qyrSZwPWscuaH64pieLKRhwL3GGcUZFOi+iO5YeZ4mQxPMBjKa7cZPLJHfF8f05DX1vJEQn5dCwXSu1eh+oQ15Par0ewB7UqHe7wZZ/khdR3S3F85gC8LVWTg4ODg4/KeAYxadILLOQlrPOwKHsd5MzkeWkNUhNXZkwJWbCLF0M1tevXBau6SS8Yke/xvYctsv47thnSPBLKrHkWXJVlPBzj3g0g5Z6QsAlS9MQtZ85R7aQtS5fPwsfUwymMhW3qV2Yj+tO5T1Jq7L8nzDIpgJcfromUBgEgBmCbdCsC5j784xSB31Xug9jLNVNsOpyJ8Yqh2QjC5Ym9Lo/wTLMK/D/VsV2wBwIBFZ4+3qcr5mAJAz3naBAEDtOLvWoGCruf7y3BmDz9tW++MpJvXz1fNkpS5M+YFe9z38tV7+Fn5lvffMk6p/uiAhx/cbBpBZd9Ian5+9S++T3ZoS/rBAncUwIL+I3rMSxFxlDU1D4Lu4AZ/pwDB/L7LmaNtWEufs9pfkb1ua9LRV+wNAMwcA+Mon5KqrzKA07H0YohkL11k8LNKHG5rpeBrTiKnX4T483qr0uf7D6GR9kmLXgjyPZzVTWqHOczYMcw0yi6S2GRiWYGcldMYwXIDbwcHBweE/BVyAOwKdSpN/DOPP3qYmY+41NBah6uFB2B8uDmt8QC/PUGWpY1Xx2Wn00r78FnwDgF2xXNxIwVgtuy3ATVikb9mqFGcXtN1JE3nz3zAWvzCo2EKTzILl07laW4cdbgY25I9Vx22CpkENKWZNUk12jtLQWV44XcctBiZQ8HbmqBfxC5U18CpsydDHsRHIVLGE43Tghc3rUJxGcaBgqrDUDdLnjrf0eskCdRLAJHVBNtLnDB2/PVR9nzX+qGYXtTuJReSMqsbBUxRj8UD308ytRmuLv1MuNCxDiY7rDAYxC/ab98Jp/R1IP3wwuD8bK3UL3LfUuSx4iRjIkkE/hG+HoJC5VbAKpcu0FE8DAE6jJ4Ko8H+DdVDtRoeTf39dkZElz6pqonPKNymoXH3/vEpLbUK69vnz/SWv5/RxVBgJFaKRyRerthKj8EXoamjGL6xjXP3CU1gyf656b7gIkRkFQ+6/+1eJzTybZBQD5L3M3+fR3lQ5yAxDqgIktZnAELfkfTIxfC0Z15pRXAkcs3BwcHBw6BKOWQhEMooVcXpV9Wn+Xg/e39K4hvnp1tCs+iYdZ2BWMA8/1tpK1TUP67Gx3EOIwoJmUwjHBV4AQtIYoZahMEV5F9EtFOMoHzULxRXkH6+sIAudW28CpgcAp/ulo0n7/qNSUHsl0PhW1R806UHTt4B90dwsBjBFiLE0cp43vHB/KHuqpN2c+956ysqaGXsRZ1equIQtG4W+OIazyuLmgr2TzemhdFAGXdsfhdZzjw6pdLt6ZqDAkBVmi4DT7SqNOcFk83Aco2EnXT+p6zV0a8CkR7io7CK66eUhKRQDkNlOm3eSDEvZKEqFXt7+XUxMUNIpqhBNanIND7Codfsn6GwfjikswQ/19uPZdiZTVIqpxPndhoIy4+upvncuojySH05BBQzj4+PlFGAZa7r09xQ/GDiyCk3cxEOlrnpVwLBxdmvTghfM+S54gZhl7XzK3huCfdR3Q2Bs3ga9PDxJseXjFC/BGWB65nJr/NpTc/Ty/adIS8r7jXpe7INOL25NJE9BUtuMyIw+RqnKOC8FxYC+cj7MMK43uMniMtF4RlHJOqBgflTrM6AwZgJeksbzjyA1VzXQqbkT9VUDAACxfJo0FoxQWsxr2kK9rPnBCQC4UWk9ZewGfAqYc4ojByQlFV6YQO3Hil8wgdS8+WaS6AzsnpHunGAAGkLJe3Y7nf+LCfSgvQNNKGy2XXBSlFAvptNL645Ua3+APeHkr6SHSl6ROf4+aU3WeNmxjx9GFc3htF3GQixGoUq7bahXgWrRVZDdTzxZ7K0fg6RMmhijJo3EQaYmJbs3uZOC7hY5mcngO98nfI04Vbl6pzEy2AgBTNMg/n6OoW9oYucJpwXJ8Liofxy9LBj3g1DKMbtMx2IblvjU7o+TAgq9u3HOf8Eafxj99X1yJj/Z2kdQyyt47ux2Y62yYdiDzNftgPvB9cLndIFeyqYU6wkmG9QSYNZ8cs+OeKEKE+bT53OV+boLhWhTnt+1PVhDaj8Acj1yUyhuCbDqVLGeHFgvbEHvH2DJKZpc03srKXsu8h4SD51n6wEzUcRfU6+PAh/4tD+WGPzpTXPwZYFzQzk4ODg4dAnHLAQ4sCTdUZVFAUt6OIBmWmTLSVqHd5aT1XmsmKzE6i0PI3W8nfpZnFuG8ioqCuLmKvUgpoEDicD4wIEdhq4a5+ZKQLhoihUvWz8Akm77EABwN0wgvHK+fS4FVYbB5OUra/0Dsz1YSCeL5qQ1DVARXdYocsVwqmMyWrTGE2sn6c+b/4ZViQtApzACwMAkU8XOTEL2nQaAmkAAm8FpumdrAoWDD8b1YoVvtH8qYuSWKdyirOxBAB60hb+SptP32no8NdRnvRWpSOx/3hpfXz8AsRixRnY5ycr8YJB8RFWVZpkcuF6omlIXjVoVKmCUPcGfwM8AkBw+p2cvlA2tYd8GPeWqAAAgAElEQVSjS7aShex94aNMBaBj48Nu0WCasWQVJaKxEIOZEReayvuHU6j74pgex66ph1R16EIsxsGR9J1Oe51cZi9OmYmn1pPkufdtSpNFI1CRQcHrj3ArAOAW0P3u/4OHifNt9d5pPcLS4PxdVDaPxcw0ug+50G/VDSY199VWujfmJi0zjEKBv6+OGsEmPaRcs0o2Kr4IodJUT/3sI3Ivrjs4ZuHg4ODg0CUcsxAIBrgr/X/SyxzwuxN7sS2NAmHJ752xxresiE6RY2mM4vHGhxu0RGXKqpTc6Ag/xXeQgb+yV96lCqZORATLxppzY4uPNZb2Vo3RulUMGWxkK2xgwkGt9cRSBhwQl4VznC77CZJxB1vELJOhWFN1xcOohvLFizhF4j3n9XaAgvAyMQAAhubScd+HOu3X54DubgzD2UaVHplK55yaoaQe/Cdw1iMrnHs1VPi/0db4zPGqZ8WIp4CN6njXBKWF7Z4ZALXVbfuYYgmJN38SGs8xCI6/yAZSMijN4OvNRZEydTrYCAoAircYhlY5flhoO0CpzmNA7Xo5ODwU20Ofz585BPuwQMooA7jJmw//t3SPrQJZ37N6l1sFpYBJR+2Oi6F05U2YqAsRmYEev2CaWGzqQam460aalFyvN9+79Or/6ivg2kMedxdMwypmNrz/F/GUblzEkHE4mTINAN5nX4S+R6lC+2ErfR/JScTWYv5D4V4p4vecPJKeEy0NPbF2sYpRvI0Owc+h6y2F1k0WAkE3VIH3F3rCYDfA0eYsfaOVgVxJs4cLmmsX62LX+PxQZtKzrWbSCObKYxuAcDtpDf4hAEbXKMOzJw12QQG2flJBI1WyBnPTZSbT8iKaSFqQHCloyAFzfsAWjqKg9m4M0wHi1FjHFdeygjtp0llrW+vhVMxNovNj90j1vIe1OCMnCPAEcR/qTAW3ioNyZTkAbMgYZ+1/Hn4cOp59GKJdNKtfUBlQD8Lofb2pfvVc4lECQMkoyd7rDJ40OkMGTugJo58KSO/FGN14iifzX4iHda76LobDBPd/hies/eaMr9YPSL5PZBYSP7T4e91bPwZ7VXC5OEb3ZFCvSaLS/ydsBzXfGnOKJp5V9xZj47sF6rO6hd7DkuH7QddqGPboY6pG+PoFUbxgFfhZrjvPiSL10D1qSphMxbSfpKX3g5NGVpro+65cvPKalYkfY1MdTWrd7qB6DJaXtzTHDsRD59CyVhmRN8FOngAQV73VS7EoVHMRj/vX1YTh3FAODg4ODl3CMYsuwEqebPUl4xPdqvLOGmUZc8Hq84A/1X7/KlEcsHeeSYFNLLHdUFzdu3rcU7qmQ/buqZg/0Rq/H4NDbS9jPpeSN9kpqqBUW6512NtMrgpuSAQYC4pZUzJaQvUKstkLa0Sxm2k49qBCVbSerSdr33LX9LddfIWFK7Ctfay1riTXVP5yg6HKeZOMrlGuNdwK2lY00nVOuu1DHfwMogirsAA3htZH1ZEkbqTvp20bJcS3txnp7tp6RR9vFOfEumBT/NA2dvFJ+e8V6r54W5nCsibhLtEulrG7lb4zdn2cqc5Adp7SkOofrg8adoEs/209yOrfVFOI5P5nQuP0eOUuCupqdYS5vVWLUyzQwfpsVWM0GsRcO2o+xE2G+Hd0ugclDBxErq7wn7zAtNPdlU+0kZWXV4wsxOw0YvOZM1WqrSDX9y+mQDS3I1rjteqUVb6Hg9X9AHBsself/sbCcO/wILRcvz/SND/iJIoDceueAYB4QPS5K1xPrAJwzMLBwcHB4TLgVGcFoiq42Vrn1L83YCqp71yvmIXS1TnyIHC/ak6zMoX8pXswzOoDAQBn592JgqVkOXNBEFtne8eNQUACCTgOFM8nusEBSZmWGFS8xIy4XsxbTT5uGRsJ+nmnK20miTpxzM+K4qqogGxwn0cEJdrb+EjUcBRmrNTL0kccbN5TWT8p1GRqQpEp9GP1XkZxxnOhY5TV0sF00An+7aFmNrIPRlsZMQtmgm1vpoQKB7FNLHM8fIaPggxSPZXnBwCzYM6dj7UF39D9S9bDPicZ42JcOnITuvWjm03GSS6l2vbfHT0o8HumJkNrVHGCAGDHwACbPTJyPBM7KfZtZ0RyIJ2ZzsWwiGCKcEfpzoyf6nK1jiG/3zu32nEvNADHF9rV6JnrTaHf+Sm2muyDqNEFeqsWq6D9wnK9Xd4bY+qIrW3MJrbGelehlqqg5wbHNOYn3xTaHsSXoZ+Fc0MJRNVZPLLobwEAW0qp+dHD2I1j6/tZ7zuUS8p8f4J6ePycUX1ohmFPaLKQDxuWwOaq7SNb+6LfTvtht2t+vg4Qygrq0CTB6A8tGsi1Cedws3ZvcHYNU/5lmKsfGvKHPu1JynXnTm9zX1qit+nqYiVDUo3hwKf2/RaLHUIsg9I+WDyRM5N2Y1iozmLBVPPgKnhFVMk/SC99YiTpwS6EyfgZSjJI/qKs0eT9sytl2SnTTAcAvNujJRU4m4f3e2vSRzg5z54RdEdAAOBW4E3q9UYg4PXTEwVgHsCcJLEfg60Jg7aZ5jzcN3sctgKgmpODrR0/ZDlzZ27SMjwHEg6MajbF2FtD7tDy3FnaKDDilfT998Jpa5IA6AHIj876+gF6/ZLYXOu9jPIakakhJNJTiyhRITgxrMdUPVHyNZBgl+4KFCGjXrnUlCfW/w3dexsXFmi3YlYNnZMPD+umTLD2xa6yniKgf2ihUdjk5AJ+XYnZIUkUnrRk9YVxBQOX5tMkEQ+diUGUkOD1CueGcnBwcHDoEs4NJRB0Q0XRwXjcpKLW+v/d2jZgcbiW07tJ7FMw4JxCCpgFK5uPpJlGOlJfivsbcw575c5JwOh41GkAa+N6/5wKeQM+C7l4Tqj0zb44pq3fiUorqAXJGPPkXmv82Jc2aAuU6ywmN5L1i/2eDsjnxUx6J7u/eP/vK7eE7FUtrVRu9Zm0xlRMB91QOUUm2JivbN0qxQ4G4mAoSDtR6B9N9u6xtk3wb8fmqmnoEJw+z168dIRZRJFhQZXzlA9xNFCQq4L0jXbAnRteAabyeD8Ga2s3rbXZGt+237Aa1p5KTmpBSytZ8t9MMjUAYy2fGLASxFzP7rxTn0N5bsftbjnR4R1ko8yz7xcA8HvZzY+8Pb5mfPzZy2oMoyvLLbbGL1i5DLuK7Pa4D9fQ9zk214j7sevwGTyHh5+k7cNeovqQXjgdbhGssCE2Vt/z+TUH9fkG3WWFFUqEsfANVNWR1+BQtmEWj8AWf3xL5MTzNZMutkrPTkrw/8pcp/hP0CW+DG4oxywcHBwcHLqEYxYRkAwjkl1ss/2M/lYxRilMblxYoFd9p/VvrPH3JdUhiKgCLwa3jJQo2CkqY4MMY0ocOa+QNcbVsjLWEbS8Zero2uNUYbo9c6heJxvEsMXH++Xq14oKY+lJ6fOqrWS1DRxHkqccG1mMhSH9ooL6PVpPqak9HYDNLKQFL49FQjKLjYHmN3swPMQsZvpfx+oqVYyXLm6rJvWdBplFJox+1n5x7KpVamUzN4VK1BY8N6yqyjC5v8y0uLCuPw7r74jTZCWYXSwZRfGBlZiFswsoRTm2RGkUVYk4Qj6NYyu7cOcmXWU/T30HxTUmZpSVS7pezBgzcCLELKSe1rQ0imMdao7hMVB736YBqhLbxIdDzOI7Xjn+2ScrneMT22om6+0Dc6us8XOxTDNc7176fgoLTQJCkGH45zxU51FL4bwaSi1+MXem3s4y/Xp8v/DvOzvbtLUdARO8vhRIVGCUe5/rZRmzGO3lRI7vCOGiPNdW1cHBwcHhSwaXDXWFiMf/AlAaO7hHWd/sap0MvLfQbngyu30FEhIp6yg9oQkApVKyZcmWXHYGvcr+DezX34ax2h/McgV9Rh3HSe/n9sFNiXd43MOwJ8RwHk8yvvyeAZmHMcf3YkWmrf1vtbhUvnDOCCksXBFSRi3ZakzMYKZMkFUA0KwCMG1V92KMzoYKIh/7dKxCtqUNMgoGZf58Hlqfk6/iR5LdBaR+kp5UMZQ3U4FAtiYAVE5VsYoyyp3tk3tcbwvKjgDAgPUU3/rZFPo/G3WaWfD9Iou6YqNsVdhHsAOrlYTFh0I7isFtVblfxa5R+fgOfgrAZBoVi2y0bNhslxoYxcMnqnCoOdbhNiUbhUOHYjr19A7PxPPGtVKci5sOcaxi28rJOFhH8YztRYbZcmtYKFWdiorZaChMBwDMjRFLyqw26bHMKBhP1ayGl6oUawcRO2GWV40c5NXR+AXZ9Dkj8HqoedQJoefFGWSccj7dB7K8KQCgNaJi/kP4mk8X4nNPUK0vMdxkIdBZ7+14nB+UJpC1610VqKPsTbyYOVMHKYPB5CCCATdOZ/0GWqyALECTRTBfvRdOo5cKsOsU2vVxeo2YNHZgtP5xsq6TFI1jLMikHww/hAGgm5rYuuFiiIqzyycZLdotxNXAK8YV6kmFwbLuwd7cjPsCD62hse26+VNlPT2QS2Km0jsY0I3SNnqev6AIrPb+DTnqa8/JIB2j2nkmmJlUFpgZDsAkKnB2rZB1l82YOBV3NHYAMG6zSetNlzdZ43JYluwDISND7gMAEufaKgCp+e+Fakw4gA6EU1XP5XbD7EAKrxXs3xen1yH0WujdjUuf2gHuzB4mcTT9EC03nSJ31IBT9WDlfT7sbsfO6fHsbrt0RtUh5ANHM+m9bHj8IiBmCACNhSbx4xWuSVFf2ZLqH8JX3jBPHdrE3ApMUBPkpicLrX1Vv5QDrc2oXMiX0F33mJc1MlxLxCnZx3tTKi1PFBJR9Spfdjg3lIODg4NDl3AB7ghEMwzj2tjlz7C2sOU6Fts0XZVBY27vyJiLZdqlw1a4lEkOMosirNBBSbbIqzCkw6K8HJHSyzpGBbGNqBxnl4b32Uqukg9bb9Fqr2zZL8PckOuoJ07rFp85o6qt4weABfPsauChS036ITMjWTH8VLutACqh3VCiApwtf4Z0e/H1lu6CoD5WVCoo1sb1YqzQuHpkYBOgntcA0FrSQV/lQHpvn9rjIc0pZhgAMKnO7iF9NDsLYwLpmhmCxX4Pf21t24PheKV1irXu/STT7CmoAHsMfa2WrIDtVgypDFTdGWoXKpsfpRw30u3pmWTC/xyPWeOlwqus8F/ZSmyTG1xVHackiLGZJnV22ykT9F7Qm9jukkHUtOm9/alYhnnWZ/F3nYDP8Ox5cvt8mJKkj+O7eNkaP+BJcov1fekIjj1KRbZvvEa/lf0YrO/XW0SKN7PYvFPkturZm6rjWfYesH97B4+T5yFuFNg7RVSB3h8ryO0C3A4ODg4OVwUuZiEQxSjMzE7W/ldL/103QpLpqADFFjhQyP7n1fOe0ts3LDUqq9yidFgCWeZanwazIv36bEV/oizAfOxDbSdxkXdabUuxcmVQcAo4uYCc7olzz4f6aszFMn0cjKqaEVpfKAhppTJ64bT2sd8QaK50Gr0wN2GZXtb7aaf9SEtXSmcAJnZRC2BCjHSiOP6SjqZQ3KJkMVmaSxYBXmnYejtXaFvh9+MdbFAprZNVy1JuI9uKVGBG4Bq86UGHlFR278nBmej/FjGLfe1DrGNclzAN27NVX4g6u/ARAE42085O8k7bEkhOBcCuDNqH9IkPTtoPAJiGdVbrWwA4msD36nBt3XOMagj2hdKPuV9GVv5R2E1ECbo3i4rXDDheH2pwlNNMDC0n7aBOGqhVcjXFGc9haxIF/LnXytzMJQjC+8olAID/RTc0BFK976w7i6CCDjcnakI6XkkhaQ8+rrlYFooh9n3piPknEH+W14RjibNEMsCK3nbcI1U01WK27zfYsZ2ucC1ZxeXCTRadQH5Z8bPqy5wJwPZCaSnuYLAVAMqXzsLidhKKmt1O+eErEkxueEm7EghMoMBkMlp08DtdjZFBUHYT7cEwFKpnVoVnu1tqGwdrvaDEdCWAdyBFN5GJyuZhcB/sV5Mm6WreMTXmgcYVxAwZUM1aSrn60uUgA+BAdG2ERL+Ew9b7go2aAKAhlk6fV9+kx+kube0T9STE+kvnF1JEOmVxuOudnChu2nlJL/cZRS66shqKfnIdQlLZWbR+QH2fUSZ+zBybZs/Tg6bmgqXgpyfQ93gQA/U1GpZN7qgylOjveYGapGVjnoZGeuhvUu7QXjhtVW4D1PGQwQ2t2LABwkHX2VgR6rzH2VNBQ4jGrwy5c9ZlGs2lGYHOPkF1AgAob56LQWnkTuQGUHxPp6MJ5c1zrfEv9jY1ElzdDwCr6ijTiEX9GNJQ6NlIv4EjGd/SxgonXPD1X3tqjh7/8Cn6HW/q/bgez/f3QQyMFE0EbDdUoU9G13Qsx23enMjxEvH/oV6xCN7fX986Uc4N5eDg4ODQJVyAWyBKG0ozCoGZq1WjonpyMSVlkhW3MGGx1o1hK3G3sNCOtJP52fpmKpIeoveMTbDZyD6RsspWTTtu0Aqt0t0T1KORvbeZWbR9Gl11CgCJN3ae3vdqku26YtYBmMYvsu1kwUrbHdGnyNQasOtDBqWDritZ68GNmliNF4BujcngymHAWM3H2o3L4r2EO6zx3zjfhq/cZH+fMmgrmQVXO5+tUUHjdGIlSTe3oHWHCnLLWoz16pW5+hoAD9F78tLo3GVacLCKXrrPOOVWpksH6yA2b5mG2Hhy97CVrCvRAVTm28ygBGWW7hMAy70TrJHZhrGhOp4J/u16WaZbcyJEsM1r3SlTwcxuJcDcd7cmfWSNl8xcMoSn6lYjiKAC7GAYvTDdg10gKN2+rIepLC85RX6ogb2pejwdTZZEP2CnunMCCn+Hq71/C32elHK/0VsQ2h7nn9Ypsy7ILFwFt4ODg4PDlw6OWQhEpsyKRkKAYRWAaX/JMYmyhBLtE22oJ/VYqcB6RvnrG3bejwmjKDAb1eaRC4G4letzeEYHoPkzZcB4s/db+5hPlCLpNirGav2YrL6cNBNHCOpQJd78CaYmrbfWyUpytvIBYxXqlpIRkFZqVJEcYFd0y3TX+ubs0NjiNDslVwa/o/R6ggFXTqUEEGIWAAUoO8LZ5ogYywG7gY6VMRruI2VpZQGGYQLAxIRNweGhAkzJQk5uCXZeAmaON/dk8L3B/wGgICK2xtiA8LWwGMYH37e2lacZNsPMQlbnBxtt3dH6nl4OMgsAoUZUklHNrqMSbu+C+Z3uyrUVbL+Dn+Id0G+PYxZ5Gbux+wKl53YL/MaXLDUxEo7T1Nbk6RhVVJyClY75N/l7MQsFb6NTnXVwcHBw+E8AxywiEMUw8nxjDQZ1Yzgu8YgouppTb0zMrNhRa3wBtulMELb8pKXNljG/5jdXI5ZGFhbHQiQTCTKLCf7t2NNOxySZxfsBK1P7dj/1MDP2onUcH+IWPCfiEQClRC5Jo3Ucb5CWV7A96zaM1dlPXKBWMVVkgr3yjDV+F0biCZWqWtxMx1ObZpRUg8WNm5tNzIOZk4xZcNooI8P7KwSx3DdaHctgrExZEAcYdjUzzaRQrp4pYiglgUyrNxMtdVTALrZ8HButbY9gR8hPLlkZp1Yz5mxZizPj7aJJuU9OJWXsx6DQ9/O98yYWcEdKOFE2GLPwd5p00IkjK/Qyf7d8fnxvjjku0oIFweR2sKxNxnG6928y1WsLz/1AL7NGWtF5+syvNPiozaVr9THCLUv7g9JiWbLjFxitGU7ZPDv7K7b0kI6VMCOeXLMNM3Pp/pPfycF7icUseJeOjQslb/Lm6zFV/t/p5X/wbI2qKFzrPhYM11b1qoBSFavVpVwuAqJB3ZpfYDSqqonuzlaqZ57vo6GKaHFJvnk48sOIJwt+6Erant9sgnbBauSBOIg53m2XfRa1zQORmma7hEwQPEW7DrjqNiFQFwEAu9KG61RMfnjxjykqbVjqRfF5VYAmiyWvmAdzu8qBlw9HGXzPaXzH2u+EDNVyc2MiMIke0t0itHjub6f3cTpung9Ue4dD4/jYtoNST2djhXZv8X5lGit/76mryaViNXJiN9pDZvKo2DnbOnf5VaYW0j6ewM/0tQwG8qW+0x5Vb+F/08NZUIUyT9zDsUe7rLiugN2Vx2r6aalu7un9PazG2ykkCMjV11puvC4LXkTu/7qRlCrL7qJ9GBIK1t+Adr18KFMJDnJdRnW9rtxmBN2GQfDkU6R+UzxRAMDNoIlHThrJF1ppoQe9rMRsvKquUclS+g3uwkg9nlOs+druys3Xy+wGW3WvCYgHq+nP+S/oCSPf+0u9Ltsnd+XLXjhlm1EKmoAXoVQbqddbfQXDuaEcHBwcHLqEc0NFwHZDEbM44/83vYbpLQen2WqRwdaa8ybwlptiN3TJxz48gLetdU9jaYfH09DcV6dfMqTlv9f7F2tbqv8ELrXbgd/WjUbTKHGsXVjXtj8FZ0bZLo1pWKeXZwll0h0graZgRfZdwm0j1VPZRcHMia+dZFDSpba3Yox1jG2/TAFS7a9bM6I1KVo6nNmDDB4zWl+ic8+b/0aIWSzxPw1Ztv1WHtOtW9l19w11/A019yM1l9iA/A74/DjdeXPzRGxIoyjm5J2Kdd2oBjeZz2I9qjWYoa1jtpY58D8QNXo8t9fNrDuJbnfQuOeSyDW4uH1hKBWbLePZNRVQu0W3/0ELjyTtCBXZ8fezrG4BvPsCTb4aFllFeAAwCG+FVH1ZeVmeC+NZoQowWLFTWajJxXaMidnG3cW/N+lOk/pTAFB9wfzufqWudw/fpNkWwXYNboWRj2c2kYxP9LqPcKteDgbrmfFJNxTq4nqxNPvKGIJrfuTg4ODg8KWHYxYRsJnFAwCAM76xqDggx35htkzHYHsoiDj1/GaMSyE1TbagapsHYlcaWTHcCIbBPScAkzJ5Az7TMQtWfQUQbqeqIFNBZYFSccZz1rjynXYAGwAKRpkg6d8E+h9EsR9ZSLfk1A+tbZZUg0JU0aE+ngpxPNPj9Hogrlcl3mMzIu73AACtiSQ1kdRmtFiYUWh8P44glvif6uUFK02KbmrRe9Y4Lekgjkc2OApanZu932KD/0tr3eQqY/XH8u1mRvXem9jl/6O1TqrEBhVss7wpSGyxA/7yepQl2N/tHO82K0AN2EHqYIqzbBXKkHpH72Waa9tRvxCpMCzZY0eSLzLF+TspyyPHRO0bgC6GBYAJgVTVHn4fZG49aa1LHnlGL3PxJrOIE8gI9floaTfM+1ACJV0wS7HYqmIWlTFTFPkvXlj/KwrXO7Nwk0UEoiYLxgbf/MC4n/MZn0RrenpPWn2KAVtjR1dcf/B94LYfAUDoB9+W/DIK/Lus8TH/Id2BCzvi9NrBRAHYwma6qvsu80PnHHD9QNgR73R/Eqx9E9Sj6gjlPgV/i71wN7dIsGT49Ms7HofrB1d6b/BEvcC7sYuR4f03+OsBhBsPFftf0/f1YRU87o9S+K/Rsveo/UBOapuhDQ25zz4+Bfw5I8wyQtR4zpCMSpqo9P9JLxd4fwGAgtk8IXBgm3Gts6KcG8rBwcHB4arAMYtO0FmbVQcHB4c/JK43N5RjFg4ODg4OXcIV5UXgumEUnIaXHb+88TI+cRm+fxlruazYwoE48CDtj3247L+NghU7CUK0M9XHWBIHymh5qP/nACgtWPqL5WcW+HfpuA63s6z1/iEUNyr07tbHzO+V/vIsf6Q1vsF7PeSzLvEpeFzm3RAer3TAAJjvakocWK+WTwSK29YLI06db4n/WXTbV9jqAewfl+cufedH/Nes9/bzHtXny7EB+b0HtZ44ljbBv90oAwxQ53EoHnlt5bUHoMcUendrVV+ZXspV81xU6i9S8YSIxlQAQnE3GZe4HPivLQrFKjrDEf81fd2uBa7Xojw3WVwpTpRawWIJGbR6ocXkl7clq1x28QAPPXC2iAdOWCsu9KOW1dghSeYTpdDqEOozJxSauolghTAF2Sl7hicNzrcHSFiNwT/0ElWkyw/y5AQj+9HeSQe/SJTE9aLpYUz7G+r/OQ6228M5AQAAZvpfBwAtN0eTjP1Ak5NNzH9ILVFm0gT/9oD4N/REAZgH60olELnc/0D0TAvDf0c9+P53XH9WfWPH4825HAtt26bup1XYpdc1+j8BQJlp/F38QtW10Hnak4WRFT9mXTcAuPTpInRrse8rfrjPxkrzEN8bp40D4kBAVl72nObx60CZg3Ji4f1uEr3s/WH278hftAjrFtp1HIWNpksiT9iX8LVwkoaC/O6athr5EA5w44I1HOummM+TooU86cosMZlxBZjA/Ez/61pMUE7s3/ZGWOMXodTcH6qG5RX1HU+1AtzXZyW3c0M5ODg4OHQJF+COQKQbSroSAsxij7IO3gaw3rcF2T5svUX3SObq5IrCiVq0TvbZBoCzW+4EOD1fGfepsfe0VHaftCY9NmjBM8PIyjBaSlK8jq1jBks5S9lo2SypMM2uGQk24AHsWolgNa1O95UQFa4sXqg3BRsrwxYqbAlcK3k8qxupn7NswxqU55ZV55ynL1ObZZ/mFazjpNCzio5jeb6xLmXtwKY6uy+z5/mIxQK1FBVGFLGg0BYSvIjuoUr8bYKp3ufbNSNPY2lIXJBb9AKmtzsjAydCvaw3XphsPr+HLbse1YIWpvcRsqcYkby6xTnhsQB8cQl3pxh2+vDw6ojRwPTdprZC1q0EBTAvoTuWVdu1FF6++X0GXXH3b22A94X9m5YijHwPcA3QXCzTVdzdQU2bgqwCABZU0T00M/9FrWDAoqJVWw2riAuPVlz9NONK41Ke2dTrvM7CMQsHBwcHhy7hmEUELGbxtbi98fPA/zDMAgBmBpjFyapMDM3fDsAodSajRVsqIaupvTtay8iKTF1iLP4oFVj2p/I+WP30M9yAY6/3AwCUjSStHVk1y6qpucp62906LNSIJtiEBiDLPqg2y5BWtmRLHQW4OYAN2K1ZZ6uqWFmhuxgLrfdKBV6W4mZmoT7U/qzc7XpZMi1GsKuoGXwAACAASURBVL2rtGrZepTIybctY6uZ1KcRBlqgZks2Q4r6XoMMw/8rc3+NXbNBL/N3IdlRMB71qjg3ZhZZgg0+Hrgesj3pmcUZAADvm+b34A+0z++93obx3LmYdLr+TaiAf32DNRxvjItgGEpYYHr2clQ02xa8ZLesFrDk1A+Bf6V1klEAQK1v2gQwk/w/XgO+/3M6h4LxxOgkc2TGzW0DuuMinlEHVaJeJYNeUK/uCXUbDs3frn8v/Ls+trWfHh+/jFi5K8pzcHBwcPhPAccsOoFkGJaGUAfyBNJa3ls1Ri+X588KjZXZRoDdtGdgAlm23D40FwctJVfAztLgXhLc1vIunMC21ydb42eNNLo7rF/1PEjbv7J+EvrESOeIda6k/35tzRz6nNwN2irlFrHSb877Y3yC5DCz2BfXi36abcwczczCafRUn0/qqmPqjK5OerbN2jJwQqvMtn5Auj55Gbv19sEBn/5BDNSsgRvdyIZH9TUmprAkl9az1Xm26k4AQGJ/o0+1NOlpvSz3AwAn6zMtdVkARnUWwIT8ddamFiSHGMUX56Kz7gBgXMoGVDbTPTQ0bY/eB0NmsAFASe4zmsVwrEvGMII9KT5Bsr5PyrYQVWgYn663y1jSRXQDAGTUk95S6wP0vb7cVoySrXTf9RxnUsJ+qjTHWMF4bR3dXxuzCzC5WcVyDpsYSuEoYpvb2ul8Wz7qiWG9KwGEWZhkFqwKu9U7i3/2AxRHQbKsJa+Tttn0kct1DxJufwwAm+unWe8dGjOMlZmHZHmPev3QFa41o2C45ke/I+QkwXoxjOBDPjgmq/F9WkhX+0hs113fuF/xYfTXD6vObsD7RACXheQqXyDZ65PIRPl8exLiH/d+DMLYkfTjqKxRzX5rgCO59gOhskptu1k93AAgRg+eG/AZVtXYctGjsUP35k4PPQnDOLvzzi7HSHQXDYz4IT0GezE2m86FrwFPnFOxHkfUspwkZMdCwDxE964cg4FFNFnI4HewsRQALGimYLFOURZD2qan0ILQgOTrx5MujG0BcDM+kRLNbjuevN5qHQTAfvAxuEERADxwvh6A/bDmB9VBDNT3wPRcei2sITdTI+7S46JcX7yNJ407xPe7Yby55/naSzdlUEjw8zbzoC8bZ99DAHQDLUbbn5llLet+2Igu8iTByO+9S5+DrMcBgBxvtE4vZvw3Pwf/HDgGPo/D6I+m17OsbTxRAMDmnfT7XDJqLpbEyCAIumilm5SNrb44Bijx0d96mxFEqbqFFgltzOs1ZZbh3FAODg4ODl3CuaEEQimzA+JoqE23Vp1GL906kcHMQvaI5oBrVsY7aGhWgUXVmjMbdbpHNqP1sAkUckCWXU0tSEbl1EnW+KGvGAbClo5MDQ1KWrOLCgBWV9lBUCAsmS0RlIMGwmmp0gViSZ93oGYri5dWimAjt+T8Dn6q131DWNEAMRzG5EYy75lZDMeeUGOmOStNkLS8iBjLRdWo6i0MCh0b99sGgJI0ajfLrpis8UfRMO5++w3idAti5EaprJmEWC5d0/qVA6zhfYqMtPnJnUQ3EgedN8WbAUjXCjOKZZirkxZk8DUo+y4l4aWVzAgmKshECA4CB11UEvvF9eNEC9lQaBxsCX7pGpx7oRxBbOtR0OFnvYIpoXVBxVd5Xz0LE2lfhbArGACm4BW9/LZQmC7b+Xxo7KUhtsVf14MY38e4CftBSQ7MuLvjYiSjYASZRVCeHHCpsw4ODg4OX0I4ZiEQxSwYVbUmNfSymEU9We9ZsaM6lVRayKfb7QYw3RLIX3+2xvj5C3MpsDcav8CIqdSateAVU8zF1jFbfswApJUvfdvJAQudm/EU55tiLvneoEU5C6uwQ6XdMmRhV0mPJda2KP0eKb3BTWeiPptx5+tn9fLZkUnWtp6NnwSHozyjSC9LNgUATyCcxrtbBCSra0xjqZJcO1hfNlMxi9VH9bqGFwzDKJgfLrLrqMkPANTvtNkG0hHSAJPFZTKeA4QLIAHbl343fm1tG7GzKjgcFaNMWq0MzALAMwhb1mMQZrNAOP2bmYVslvVjzNPLeXjLGn/oAhX1rephmmXJ1qzLxHsB4Ne4G8MDrXClpplfZScGVOeZokFmGJX1hqnvilErVo695GMfipSoS8+d9JspHLUCKy7Msfab14Ou6TN4Dk2w7+XZj1YgbpMq3AvgXUTjy8As3GQRATlpGG0dghZXE7AC3PVN1rbK2DDdUYvrGuRDOFTBLSYLzp7hmxkA1mOqXp6lbmjul83BUumKkBPE7Gpq3LQxj6g+1xf0xbHQRLKs3bgq+iYc05/Hk8VF0W8cALZfMO4DnjT64pgW8QuCG9kEj5cfErmi7/S8gBusuNHuYgYAMzP+Wi+/0jrF2nZHUpNe5gDwUpG9FHRzNdSYSYAnDZ4sACBv9RvW+OoqM8lwTY3E3sZHrP8bM8wkwhlEADoUjJQd92SWGidbyDqV+5+1M8bWPWe0jwp3UrA7Z5SppTh4Kt8aP7C3mVTYDcV1ORvwRCgYvGDkD8y+VNCeH7R7MAwVVXYlfGN+T708Rn3Xdc/Sw/zF52ZicbtdUyMxMWGT3i/3Dg8KX1761EwUiarN/aG8mL5f2X1aWG/qSzhwzRPmQBzUhhdPkPIeDRpRcrJg9++AR+v19koxaVzOZOHqLBwcHBwcvrRwzKITSIYR1VYxCH+FsWq2Fw3Vy0FmAYQZhXSB6MBovXFVSHYBGM0awFhE7PZIRkuop3JJtQkmns+j1MZJIEXPdDSFxktm0fI+WYMbMwtC1c4LQQHg7AvGkurWQsdWkTYtzCyExlZhBjEEttTGYptOaeTAc2cW3dnGO4D9ZBDNLCS3jLS8K2psqzYr9ygaqog1pOZTdbxMI50s3FRlNcQkQsyipA15aeSCkdXPhVVqWaVMD834BfbWq1qbG9V9tM0Yb43z6ZpmrFTM4kGEmYWoSanIt687AAxS7hzu1c01KnId4zPcoFM8+bvuhdPYdorciH17H7HGJ6NFM9VuygU2HHsw4HX6nrNHGm2oEXgdAPAA3lafpWpkqvfCU88XmUCxXdVXZFTRufvVdF1mPVeOTe10nmc/p3NJ/ZphXtsT6HpOwzp82EqMIpgUIJnF2h6k19Ufh7WLOJj2Kl2F0g3KumMyMB5M9OBkDAC4GecQxJtefWhdZ7jee3A7ZuHg4ODg0CVcUV4EolRnWzdSamvSpLOhbdycfTuGhtQpp2OtVndl3aMnPRMUfriNLKek/rTf9IQmvY1VS+tO5QCnaN2LvU0QMBhAZYtRBlfZUluWOzcUUF4HSqVcjIV6PFeDb08Yg7zjtdb4gagJMQtGXY8Ycprt9NvCik0A4pHjgTBTKK5fhQkxir9wbEFqTgURy3gb9fuJfXFCQWFsRYfjmVUAJjbUJ/d4pA4WszvGhNV0XJubJ6J6J7HAx0cZZsF6UawTNRAHsRdkCbMKcAPM57NVrZH9bx0eN2CSJ9hX/yzKUINcACamwJZ9FKQCQG0zXdOCtG0Y2zu6srm2Kg8D84lZ8HcwHHtwaGQsNPYcbrb+n9ZO12oMesL3yGDNhrmXQucuivI4LgGVG3H285442MNWte2F0/gQxCyoF4thGN1uLNV9Phgy8USmEuvjUYqxzKC+KfqhcFzw17hbKyoEUSX2ydpcA56sx4D/Revi/zvybRaudczicuCYhYODg4NDl3AxC4EoRsGzfPw2NfP3R8i3zMwCAArmUUrf0KWURbHnVAHO9qaUz9StrQCAA48Cdb7d/4B7EaxLmKZ9y2Uqle/hU9VY0dseL7WImA1I/z7LPDBSc42C7a/wLQDGtxzcH2BbYOxjtj/fTmdkPX8AKK6I6CU3PW79K7u2yTTGrBilphbAyD0sbzeWIWCzr6b2dABA63FT1Lg8ZrO7OVWiLwfLdtxmVnGKMkNa4awXNSFXMYt50yi+ICCzi5jdZaNOx316JdjxIMlwsvLpfBu8u4CIdFhAdveDtqgB6B4nXDgImEwkRlCxFwBWNxs//Mw0e7ws2CzJp3iNZHfMqvT7R5ljZhYrcSjBThHO3HrS/BPoWgcAx6f0sf4/gQy9LGVF3mklKz8Ys5BZdrLfCZ/Dphr7d1SWa+RIFjSaVN8NGeOs992Ej0NZcxx3vITuetwbGA4ASHmy7bIYBeNaMwuXOnuFCE4W8kuLjxbBp456Ys816/OWUnpl1akRAGfb8jNjPbBit33TsiuhCKtQsIUmnF3jKai9B8NDlblNSNepk/yAYteNDNQV15iHAU8Y/JA5k0YPWJmzv7nKaFVxUJIDmFPxig6KM8aKh3pQL6qgYk+4B7jsvT0o8DV+6unJghH1g2e0tIfrMtrbTIC7rSnF3ngcYYhJQ9ZWcIA7BCk7ZZ7hKMi36yxGYwdmt9uTUHpCk17+LNC4qsF7PfRRsmUpuwwZWc3hk0m6WdTUJNgPtmGBugTA3HMAcHaereNVstRcC77uS2GEE3NbD+jlZ5Psa8WTZEuNCbgfzTMpt8FkitT1ZETNnbJE38PSRRl0/1RhCGqrlFDikHjovILaUHswHOkgzbaHa2hi73bPuchjB2jSSM2g8awzVods614HjEHVF8f075NTv1/2IppHdYIvQ52Fc0M5ODg4OHQJxywi0Gnzo8Po1A0VbF16B5q0xLeGMGbyd++yNn0Tv8HqLeQKyBlPVpC0rmUlL1szHFRn61GOkcxCp+Q2k6VWmUYB2G0Ya7k3ACo0YznuuUmUMvgA3taugKClKi1BtsAKavYAD8YRiR1i/T10vXdlDNFVv5JJBQsA+bNOVmUi6UFKDGCJct6PxIiZonp5kHqVMVk7PquD7ACwuUZZ9OnKUnwpEbGldvBbXjtOj5bMovXjAAPaaFRZs+YrN9Qd9wNNcURCXispkPsQHZN0JQWr1HNqzL0zM5cYJLsMl2KupZ8EAHMqjMuupFClDc+jMUeW9g1V2efXm3RwLm5jxltXnQMcsIbjvYXGXcjp3/ybuYTu+nvnIlHZiIrHXSmzeBi7dQX5JjwOAPhFq2FVQXaxoGaZYeEvEOPKmW9cjcEC1iDjAKKVZqNwrRkFwzELBwcHB4erApc6KxAds6Ain3iZsgAisucKvL8AYPuYpWU8PZca0Wuf/m7jB+aiMOnvnzmeLEBWBK1Dtt4f+7qlxRWMZ1xEdyyosAuIYoXCGn5TWbYqbBJkFYDd5IeLz04gAwfLKY5SVhzuU8CISk80G+P0Kvo9FGSYOEhQMfYE7gr5uLkQsBCbsDCBlotBBX5Jt30Y/kyup1xj2Bpbpln5R9FQTwHnipgJ0PI5sALw3mYqfMxb+kYoVfRWfKSv4e5WGjc6aYeOUdSr77EgTVmg801fkqBGmAVRlMfXq7CQ2EpFxWygLcEaHpUCrIsKa54P9e1Yiqc1U5h+gaRgpj9Gr91+7mPxeWoGVKbYx2n01GyAZTMqYhO1dEZJORV+bismZlGdl4O8A5Qye3ahresFAJ5HsQqon91YbNOsMUonbFkrMZf7kupQmU/XuQB/YY2p8H+jFWBl0kawSPGRJIpFyN/RnBrDqphRMGpfyEPx/DJrHTOoxVio70nG7f6Ey2IXper5Yge4r8++Fs4NJdBZNpT5vxTB2oFS0YP773xyebBezyZM1L2DeWKQbiKZAw5EByLlZMBZUwAwNiFMfwG7Wcz0BCHPXVESNdzqCS0zPqTmEEA6OcfK7e5fybNNzrzOkVcYiIOY7N1jf5h4AAaDwrI+hF0lJ2CyprjGgPE+0vXxsiAgd84D7AwpgBpL8UOIr7OsG5EVuoWNNIENzaCA5cF2mtz7JRxG9TjKCIptNRMwawK92kr7+2aSydWvrxoQOl9+KPJkMSfhZZR5dtBbXqvCfDtYXlE/21SGP0n3aOUuIwYYDAofQX/0U8dY1kh9pTnjBwDGXqi0xh/skYPB5+lB/2EKPegPw3z3H8G4/aaV2w/FN4ppIpYqA/Ie1pOEQpHqYievvxR45EmC8WqSLdcPGIMNCHcYfDUlLHueDCNCGWzeJI0TntQxyQSsj6TZEvUyWYG/12HYgzWB8+wMX4ZsKOeGcnBwcHDoEo5ZREAyjBCz+LwUKItb6ySziCuvQnUzVZ3mN1frPPgzEc1q2O3ClPkQBujceDlONpkBgH3tQ3Sa6ONJZNHLiu6988ZY42WaJ3u8WE8JCOfIpyc06eWf4zEAtkR10F3UWQotgDDDmBHXi0NXh5VaJfsKflaGqOloVMxDutIkuwBMT3MA2FtD14V7bAPAgnGB5k4/Mt8/p1BeajdB9tZJNmMp3BquGj+M/tpClf3YAVNbAdj1JCFmwfh53CyL1qw6ePymWLfGTtnk/twAsPs8Wdhf+eQLvc6/wbYXq3ubaumgexMASmC7YmTywcRAWjUA3IVG63+ppyQlzAFiFkEFBNnjXTY/4noSySgAu35HNjZiNxQ3y+IkCHl8sr6G1ZVZgr9byyUsTyOtMem6AoB+NcdQm0tMjo+/DCWOWTg4ODg4/NeDYxYCnRbl/VLN/NKyK4tb4/1ehmFsbCYrbnLzRuA4BZSl31mmwwLAnC0UWzgzPllbbzymCemhNqaSWbT9korPdDC2RliyqoisYOlGVFYp/2umnXIp9x3VsIcryZ/GUq2Vw5Dv5ZTC51opqPrTpP8ZZhRCdXZCxivWphYkoz1QrCZ7RQT99j1xWjMLhmQYsj0qHWwigmBNLgBoPWAYA6vSMphZtJYJViEWC4vCVeDBwLzsa9GQYet0ZXlTQscWlV6s8WaEIThasIqP7XP9orcZz8yCW9ECQFX5CGv82eJwQFqmhZfVm3TTnFi1Ne4ZUEykBM9pVir7vLDmGYPjUzfgM80oe4prdwQ2U5T3SLCtaoF/Vyjudws+xIgalT6dal9H+T0MBp3HUjytk0vKLiwAAHzj83NYmvS09V4ZEM/KJbbIrGMgDl52+ixw7VNoL4dZuGwoAS3tobMRfGBsPDywzF7Hbqj4aeAu3w6mbUibhMnHydXAjWBK8p/RDzXu7cwYg+2a/vMNm4wW7dpZ225oenISPZzPgiaLvSvVJCFimwVLRRA503ZRsGsrym0UhWB+uXxvE9JDD0c6/kC3vLvUhHqiVJ8fT4p7Gx/RDzAp2c6ZQBU76foVjqIHc1njc3rC4Z7m/RIOazcUVzTrOoc2APwMFYlB1gSgcHY/ZcOkLqFJgxtA1SIVWUvsKvOG+vsp4AwjZFhfMQC9Cu1e6izJXlE1G1lNTfTe/HQA1GQr1FiL+5eviAMfqN/yQyx3DoDzGLg30miEJgl+kOeiCjXnKZONH5BFWIGq42qSGK7eoG6R1LpWnM2mCePW88qdkgI0BMQfh8aMC5GTB2RgO7NOyXuow6+NmZtzBkjqn++ri+ius9BYLr5s5/MYOsp2U1bXPIy8XLsBFaPSO4FhgXlVZkLFMkhssb6R+m1nNb6vXY0M2Zd8Wg/KDkMrMK/1xwCA4Uk0GRXk0m9L1hhJF9XtPjWemvakmTSCEiDXepK4Ejg3lIODg4NDl3DMQiAqdVYzYGa794SHsHVQikU44VEKIjOMFiRjeT6xAbbkG9BXB+6Wj6dtMoWTLRVppZTX22msqTHjJtHVpnUqN7wOml1U1ijXU7phFYk32v2cm5COhi12OmBsvHEVzFY1DL1wWgfwWMOHYVVc/8dNAIB5sHtyS7BsdxDB4HSf/OM4uTPTWic1olgSmhtAJQSC4QBMXUk6dKtaZhbTE9aiPJAinLXkKBoW0PW4I8C6JKtgV0nP2GlU1xMTitI0YmZR0aj6g6f7QJMXOpcQWEdLEsJPhdVpHxowIxGB+LOWI89JO4juXz2njovObSXs5lBBMFO4FcQsBmO/ZhYFMbKqZYCbxf2gPFj1KwdAqajD9+m4D8FInPeH7ULaPGIa+uwizasNon/63p2KMYvyluD3wpjg3459oFbI0h0VlJxnhtFRvVLwe3kkaUeojoXrLNLRpF2/haomqSJ3onZDxSOPlBBVZ3G9wjELBwcHB4cu4ZjF5YKNzyjl0ghMepIYxoqXCrUFxcziIrprS5itH/bbtiBZL7OVerB9IJIyKRA7J8EUprGVfys+otciepVBXmlpn2xOt47x/Vb6/9WkScB4WJ8p9884jV762HgbW/YAdBEXYxj2oBx/aa3L8kfq5WCQvzyjCIvbKW1YBp77jKKLLtNpAZudbEwgzZ9VKNKpsnsr7JTVgvyNWg49cZCpUC9eQub4HlEIxuvYwuTGOFGVxQCMla8M59rCbDyiUo2ZRVagSA+PapPaIRKBQIwXsbcOoX4eFfulrlbMcsSd5j4NpNDW7szT58xxgSHYh+OZJAk+Deus8VLlVgviTjHNgOR3MbjVDnDLe8irIbZeUmRUbJesp8rwASDNNK/SMPqTI4hFTthFxzNw1MEQi+2oARcAbPZ+i9YEuyjv9lZTOJqe0ET7FYyCf5f8Oh1r9W+W02k7k/+H7LWkVIynndrcKaP4MsIxCwcHBweHLuFSZyNgxy7IYkWd6v14o28yehRkUZ7eh2qpOPGlCi1TwX0jZFaRzCYCKC2Q2QDrEck+BSzf0Q0XdTtH9htLn2rQ53oavXTh3MpWSoHkYr4oyAIltqalj3m01djBlkhghvFWiinwyvdshjHT/7pelo2Toj4/iLoIga4fi2ZMq4QFD9hWcOVKxSwmGWbBqrqMS9IPH/FZ1SvtBkCyJ0btqPD4E4H0Xvk9Wb1EgtlQCkP9P9fLMrWZr1uN+K6ZZTLqd5rmQ8tH2UwRsNkUYKelVq0fERyObo+cs/6/9P5NenlFtt2jZc7KtdhVlG+tG3LBsJBjPbKsbf1GHEPDrnRr3S0wWl+s+SSPu8Kz9a7818xvcfq45XqZJXCGJYSZPN9Px2qMnMmLudS++Km61QCAsuxiZIOYrE7DVSjOLUP5FqJ0rOu26lQx4rejS3By97e/BEV5brIQCAe4Hw8POiF++J1MGi+00I+KBcsAuyYh6ILhCup+CYe1UB1LiQP/P3tvH19VeaaNXqtzXhLQMzsiP41Emmj61oSxs1H4TQ2hPZhw5seHGjTYCEIPENoKgb4tgeJoIhsTHCmEOoUQZyTCFAQZiYgocDokelpCmPNDZE87JDpGQzUYfcVmdxSyPfN2nT/u536e+3nWApx5hxrmXdc/Wdl77fXxrI/n/rju6waqc+wX2n5M1Tc8Tzj8wu5HVqC/9VCcxS1qn/wdry8rpFnn5hAm6e1zGOBVTAxUU0u4jWtG42Rgksj179PLHILjh3UGdmOt07EvbPuMFszAQ0rkjrV+pGaROwY9yAtMFrfEzHU4mTbrc891ButnHUmZF/PAdtNcqajKDsWsx9JAaIcFCwGgIW5L2R/DuOBk8XhCLy5cYXfRO4LxgcmiWIRWZPdBwCZEsCz5kjVmPOMr7ASwrMiv2UoCgfVzq3UNjaw5cGuA+H5c/GgzXnqEdKL+AV/X38saDQB4LU7jfmtjJ7qqKCx2H54FALTh9kCl91Ts14oHHd4vrO/8v1uFqfdSCFgaMNyUiCXKWQVA1unILnofFxMpYvgJCuddN6YbT+E71r7k5OXK6G96sRqJMusjJESv8cP/bH/3jcugziIKQ0WIECFChIsi8ixCEBqGyhNmgdOk5jX/7/Tyi14nAONZAMBAvdPeU1AAYz/og4u8jJ7zHptUuGRV2N26Oosgwy7vCKuPPRa2uDikIZN9MizBCXHWxDmBMQELSoK1gXpARV/jcAxF3nRrHelZsOfCx9uxtwTZZWQBs5rsb0VCuS9J1OCaOFm3N8Eou25S1cULsBmVe+3wWnUZJasbWms0QSFedVTv2z2nnnSeqebuUR+qqFhm3scY+MQZAyEVXpT/CgAaWz4vV71XJmh57HdjRsBKZs/i9z82Rl/VGbLy+5Gl7wW+jiNxOuD57UyqRPUxILtSJcKbFcX6I9N8yf3dG6mv6qZAkoxxOkTfbEmSPJTqeL0+NgDY/OgS5D1Cz8Mc0ZTJ9Sz8M+r8OoGjVcQQ4II9IEixPYth2psJjBnssB0ALFLUbwCYnaZ7VBJFXLq1XP9P8E+B7bsebl3XX5p/zC2pPQsuzgOCBbCu5w0M3jBU5FlEiBAhQoSLIqLOXhR2crLhnUWo9uxmQWO9bwEgD+OXvmqTqhQSBqYLr+IHZrGuzI7Nc5P7rIx+bZmd6r5Jfy91fACjugmY+LJsOuQmLmVS3dV/OoLxeCP1VeszaT3L37K13NxrJ0v35UzTy9xz42DGZHT4lLNhD+OUR7HouG9kcDl/04ES9O0lq/eqMrJ4r0K/FesHjHrvTXgTb8A+bpfuCwAN3aZfwZmqoQCAEpAH0NFYor0MhtSI0kV8CvfHdqD5k+A+GB3LKUafu7YLne3quFVhWnk3XUPZ7Gnpu5RA3T3K9g4BYOYKlfP4sflsmYrf12C1zlVwgVpL7wzMzHFIC8Io1w192LMVtY7spTCdGjAaXzKvw+B8UFPSUKddWvHRR0wBHhfZrcdStMTp3ryn7YC1/vqqhdrTelJ1rJKWuCQDhHkUAFDnfwKobXBCGjAehYuHPzVeQYYRxMXq4dTci5+zRiwK5CxGgii5xwsKzfOmxrTmxQbLowCAZ4RHydvllsyueu5gRBSGEgit4FaJp0qfXFPpfruThn94FUqLabJoq1WMmcMAONfo9HoGzKRR204J7NziLmx02Dx37jXsi5IySrSOxxGdsC5P2sJpUqgt2W7YMFzF2pPOs9aXTZSkgFt9L9U8bMsxydLl8s0FW7o7DKnMJ63/pYT0NQ5z5wTGoGNvifUZny8QrNrdnZ5hhRMA09UPIN0fa9/5z+Bv1AN/L0iq2mI2yUJxm2SD2HQKF8qxkoyzzuX2hNa8dlaQjy9E7Fxp8NpRfxGQKJ/pGzpNvdOgpxjtevll0DmM7RWaVbMd0UQpUc/nNsF85OovXEUdOAAAIABJREFUvZKaqJczMilMsyzDkCykHLlM9ALh0ua3PZzUy77TZPEnwxfqZZ4sJIPsM0dcUhpCLV6QSVft2zawZLSxQgDrhZ3LGor9V0yx1pfPE/cV70cWJioD4wRuAWAIGq5hBpCBxYYVM7p+gh/q76scQU45WURhqAgRIkSIcNki8ixCENb86N2Vhk8e4HYfNpTZ3ylaeWy52sYhIBAZER4GVyefaiez9rXi0TiN66zVpWdRVEYUzVIc0vUArBu1MG7cdLZ62VJral+KzJuJLsqWYn2GSby6IYQ0hmhp6FnKWt8kJKrdBjDrTtTq5axCcs+HZphEe5/3M2v92MADepnbscr6iVJRizDNkZyenDbdftiz4FahQFD+WzbscT0LAGjrnmatj18bIys2OUhAGJlhq+t2NhqvorkqWF3s1ow09Zpx5MZYwAWaHx1O6MWZxYaO+4qqOGbPAgjWoFR6PzH/LLsWAdj8A92zGwA2pO2Wv8sy1gUStLI96R3tNn34aHEcH+Fq67PFInnM8uWMIxgf8Dal1S69ma2YByDoWfgPrcKy1aRJJokfTJXlZ4Y1szKvPKvbtLJHJOXUuS/7SYzWnsSF9Lz4uTiJ0Tp8K8dInj9gwrISkWcRIUKECBEuW0SehUBYzsKd5XetNFWtnVo0h+Bq0gBA7BaxTdGLJ7fOFpl6Hk4bVNgWjKuH07GrBNUVZDEzFdatFJZ4A1/VBWVPxb4LwPYmXM9CFv1xzPcG9KCjm+LT1fmrrfUPYRJOnKCK7evGmFaVrkeB9x7Ui1yZzh7ODszS48CNds4IN+zbsLc1OX0QqfdCrGUFt7nSZxiCQmU98ti+L5L9VovTvUTv5JyJq4YL2BRnWUAJAM0583WynRP4skjMtU7H4ljAs5AkADduPwYndCU4b1/mLLixFaPJux/bfMqFzVmuznMydH8Ptz/EeBzRBWvcKwQANmYsDhyPW/y4rp28zKE3n8FzsXtpG6phxn5MDTQn4us6OX1Qb5+92Dz04BGQ9/UW8vVvuGeGSz31H1qFo6spsc6FfYDRumIvsyNJubHMPFPJ/3rMeIju9dmMBQEK9FkMDRwPI6yJ2GMwXpvrmctoReRZRIgQIUKEyxYRdVbA7ZRnf6fiwgkfwD7ru0qfrN+l2ID1maSk+eAAFU8txPqAHIK0OsJUTNlq42Kk295NYjGoY5d3xBwb69E0VJAVxvIPX8Ubeh3JwJgX22rtJyym+phg3bAFyJ6FlMNgOir3BQCA0jH2uFyLDxGM+BukNiuKqiJ/bRT9FVjjSHoW7DnxeaYOZ1NvCED3h9D/w8hQcJy9HeO1Z8F5isL813Xhn+zVwd34uKixLYMs0ZJ0m9YXkhZ1ZQ4VajGleDr26O01ddM1qMtfrn8ntYkAzg/YzDEGd3Xj4wXswsuxScU+GjGA7Bw7n8KY6RvqdfZaVZzXeiNai8mCXi2sXoA8q5lllB/h6xRb0Ic5e1XXx7LzK796H9E1yMTHuHMh5dsWNlE+zfUqAKDodvKMYgf7tPIrQz47XwF5rGFWu973YyvRsZro2pwTkUWX7FEwBnqGa+kVWXzIlr8r2QIA01K2FzYw29DjG/aZfBTnX8Yr5tpLmIYb2+0nwpsw+PtYMKIwVAjCEtx6srhjLPBSIvR3lf4I/fDzjSLrAG5XUtWASb7dCQpl3a2E+cZ2m4pRv884fvwAagwAJRX2TXuVqIeYBZu22YhFVsUzAEyFeYF8B09Z37F+kATXTwDm5cmQlFoO2eRl9OjPkt5Ba31sTOhFfwyN8fFiIywnwwBuO9c5C1UYZQZMq9guQxUtKrUTrRz+acd4PQnJF7DbVlMm1HlC4IlsbOtJzCy1XyBhFfPP4V5Dz3US6DI8xknVdellAZqxhuhbzq1ZASOOl+pSk24NkL3P7h0u7zkGJ8bPpYfh+Qw7/Fm6V4RH3oONETBtaRmyDuUT+6vY5D6kfuC0rJXRvO32V5Wv2H3MAaC51hgQMnQblhgGYIU5C3MMhdcN8+oktuCqxCaYFzm30ZVgYyk9QMbcwKvDA+swGsoWYelWqqF5ey6NwY3P9YHnueeLHbpuRJ2NECFChAj/GRB5FgKfJ8GdOCbcRtfDOJRAeSmZS2wNS20maeXVJqnAiXWOOGTR132DFdoBgBPtRcgrJo0d3WI0DyiJk2fR1u5IZguLsKWCXOsjGK/d8ab2pdbq24qD1cOACZHIUFltr923U7ZoHR8jq1QmgwPWcohHISG9C8CmglYudIrcpGfBmGBM3/J3bNP1QgQAwC58e8wpgmN0tBqPSnowQ53GTLfjVW3BM6R8uFu4Vus5peIAcChx3mOVVjAjNcNY8dw8KAw8pqfT5w/npF7IPu93AIAJZtyLcuxkraXeqzyLzMdNInngo6vsbX3F0F8r/f8bANDcbjwKN/netkvc7/cl7G299yDKc3ZbH7U0m6LSzso8AMBtaSpQTR3ORkspPSPz0zRmklLOxJKOZIluQJZ6Qo0NF3EeQ6A5FcYNwP97lQBnB0RUiD9/b+RZRIgQIUKE/4SIPIsQhMp+3JEwyyEeBcP1LIAgDU9qHbGW/zSQ9XQuPSygOiste90a9aNMYISy7nrsQHJucRdO7SKzZ0oFyTiMxkmdJ+ECwCnFRuKBcxxMxzyESZrqx9/JZGNzty1Jkjnit7p3B1MtLVqr0/sDJxJ60f+EjJqXiku03o6kGS6D3cujaKHSKhKehYxPd/baVE5p+bJ3JZsCcaEjQybaF4Pi6EfeNU18Ro96zVpfXmv2MKRn4eYsONENGA8TADAmgVCI+yteaqRcWLaFpSvCIMeFKbbSs8jKsPNBkt7bsUvpXFWowtFdBSisOG6tb+l2OWmp2A/6Ap6FTAZb8ioAsO6fTb+YPmXobgZKtigPWo7jMfX9v9GzwGS6X5i2nZXRr1sDlzdTrmpDpamiXdKtcnmfeKalco9z3DJX84DxuPzfK8/CSFThgNPjYuoX3PSI8Xk8i4gNdVEo3ZqXVMeummvNQ12v/k5Sf8VDLV/wHHLgpPfE+KsBmWOuwi1Bm34J5GX0AKCXkcvjjxX0mZdEHt2guTk9+nueJBhSZNB16wG7e5uLtMPxD0OY2ByA4CShUBdfpl+UU4upWc0iNAb6bP+NEG97EySsqF88x4briYDH+51Ung6NsRgi600VlbXhakf0qbzMhKq4v7Tsg+4m12eM2hY4F7n+PGwFQBProY+pJudL+D0AoDW/WP+GDYjcuHoRJ903J4BnE/T3I+iaGsYhTELqoAqHjFMvqIEMIDNtlgF0dpOOUWH+69iTonLtG2I9AKgSnSfPU420/1PqDV5U1YZ4xVF9fi4616hJQmhOsfDhzjVU05CqMaGsa2Mfqu2fPymc7f8R+rhEJ49fuplom6fCTjXGiNMTmF0EDoAEFQHoSaO8crv+jMFhtqyKfkugEACWNG8GJjoGoyyLylN/pXI6Lx8mw83/Wci7dxkwRXU68N5xtv+vCW2kfpGTxoUQhaEiRIgQIcJFEXkWnxeHREhlUiJ8ne0AVLRCUlc5ccaYlbFDU03XgtpT7lEiPUsyfor6dqKtJkHWT2HxcR1OkCEWdqXZwjx1jKzCmjITwtmHu/SyayWzx3AtPtTWleTB6wSo6u0jFWlr8ikB3Co8Fk4Qaz2fTJHRUyAJaQI3y2F66gncorn0brUsEGzyVFL6ktb6+W2I9ctVzE3HKMxwMj0aYzOUCXjzhSOZxanDAIDbY68CABaNatDfnbyNejWPPmrCUYscFVFpjUu6K8OtFWiIL0I1rgmsdz4kW00YrSSHvMK27mmI55CHJ6nBANWaMNmicx55BYVbjmsPt9YJ9Z2vyVXg84NCSl2hZQVd//Ll+zGliTxcvsa5+7oMSUOBG14BZqy0BH79gOUxXxTXP24pGwNAS7doj3wsaLVzWFaHxboAvOrZn10PQxzh5P4xFf6dAK3gu7CMnqNFaMCmd0le1ycZK3hXAy2qnepu0PZnhLRTHayIPIsIESJEiHBRRAnuEMgE97lPKOY+9KjUeEqE/3BuAjO3kJXFDYnKW42lznTH9MAQTTNly5hVVmVh3ctCcfN9p53lofQkpLbb9MbYbEOn1IVaCvH4UV35zDiUNl6Bjn8rbCubgcVpu0jK2qaTzOxeYSvlAkB+ryh2u/5x6zvZc4A9BpnHkYlWV3uIK7L3CMlUuQ4XODJ2pE218YIM2odsiOQ2lmINLcDE9ycK2vOm2+yGDNuPlutl9ih6kKfzRG5bUNnCVF4Ttz+KxuGEWZZM4RBdpzNO0xQ5jgfmOfpj04NNuGqbjYeRW2nrl51KFugci/6s1XgJTEFlhDWiktfJzdtZBArlWciK9L5uoSZ8nlwYahLm+EURn3sNWnZR0ru6oh4N7eTF1hWbsXA9v6b2pdhQTMe0pJeeC+7zMmfv7kA/kDz04BqP7pOVKk2z6mPga+r7GdoT/SBwCoOVOhtNFgJhLCieLBiZgn7v/ZXtQhb53wxIOO9snW9+O05wzdfRHVRUR0wc/p28qdeCbt7ROKmrijkxehKj0dlM4QT3oe5PZ5mXf576cMSATvi1NM621s+tEpWxHCK40kxukm0jJbUBoEWEhl5SYnH3YI/+zK3cLvENIZ2bN8nJwpWDkHIL7stlD6ZbzY4A+wXlXgv54mTIcJHs/idZRBJSAK650bCmNlTZL0Y5WYQd/5I19rngwURwZ6Ia2e2At7Pd3Fc8WcgX8VVOyFHKqOtbTMiTy1CQe6yyZzZPFv1pM26u0bKt0twTXKcwVtzXbs9redy6E2MrjW126ds6VMuY0yrYTpMS1neoSWBhHYWCOByaLyZkHheWjZ+B3fo+4XtByrEwRuK0/owlSaYro+RVTAxMLn/mleNCWOWELeWkMVgniygMFSFChAgRLooowS0QJiQ49EryHlbCeBirEPQoGOxKdzQL7SRluA8cVP6oKIvgsBInDo9hXKDyV2oVsUU0DGetsJOEDClxW8ja3nq0tM4OXV+CxeN2ts7XyeA2ZSHX5dQEaLScWL4K/bhDaU1xmCWMctnm0TZL/HHaSmfPQq7PFukkHNKWpxR6Axwhv13G8mbaMG+PLcKzGKYtVzdZDhjq8anePE0kYA/jx6DaiBdwNzZ+SmKRG+fSX9mWky3M3Zih98vJ5iVQSec+z7Q0Paz+LksA6xL2AXHo7kQCOz+ab393JTS/v20vUUuzy95GX5L6bOs7o4e3BZOglS1WnQL4vlr6fT0eQ03dQ/YxTgBOLSfPM1avvM7NwqtQ9/WcXWT5b6uYgSNp8oT5XlqXWoaHY7buGF/HsHasL+MO/b3lUZwP4nBc70DuiyEr7+X6fO/IY3JFDl9QrlkW+rXXuvlrdE/gZiDx6/Mf5kolwb5qkNRZfB5EnkWECBEiRLgoIs/iYjicAACsAv2tK16GOmXSsZ5Ph/cLAORhaMpnJf0pbTxi8gayrs5JEOtYrdDEyS0ml+SnsNtbAjaFUcaPAVL7XJZhUyGzc06jr4usRrdy9lRrQUBJVeZJG3KW6n1yvLlRtFgFqJK3ME7VvR8oCmgGPkOuT1VTrkoo5ysAW7W1JE05HE5Eh0HmHiqTdix/W0UwXr4zSVb5wvj6QDX9MqzDOthJ3pqcR1Hf+4j+XuIhmKZPZ68gU3oiXsGruP28x8vQml/5QLKdqK/ZK5Rc+PIbA+sX+kR77kyKbcSpUC6ZvE3fH5xnugE96IPaDtcesuTUJyDvAjDexM2+ppL2rQnuX7aqBaAUA+icZ2QoqXJR7W4p0MJO3ss8xeoUeSw3xWwV5D2p6bg/RtfTUoAN8TjOSzIB0NRI92u8isbqDEYEmkfNEY20+H6V+a6+XfZ4lFc4ErmwSQ98jG2/ogZgv/A6znt8AHCXTxpod+HvAABjvW9FRXkRIkSIEOHyR+RZ/BtR09CA+urq0O86Wkt0UV7pPKHE+aqz4nZgSp1NtWP2B2D0pRjHME5bLhxznYr9ulhuBuxY7j3p57EuTday9DCyS03TGwsfATt3qZi48DrakhQLnxanHMEwnNUxeWYhNSRN8ZxbsJXGkEBbVUmZfd1yteyY8eY0WXnjM8w4Hui+GwCwIJ+8DotKGaKWcSBpU0XH4ZjWRZJsH/YePhBFcVzwyGDPYTRO4vQV2YHjvafrAABgYwG5lAcx2bT15MZMpisosott9pH/Zx688xRoFcaPW3RbgHJRbAlzo6aTGI2iOHlmUh3XRWsFeVel3e1aRqRhjbqO7B3MMHm7oiq1zd7xqFtL9xXn5iqrNloUbwDYI3pHjMywGWgPxx4L5OQkVZl7dDBK0m0YmkGeJ9+/V6EfYK/LaW0MACVVtpyNbJ3b2U6ssHrQ35rih1C/i3Io2RW0/XPpYYhNJ89mfYZRaOacGbOgZI6Nn8uPvObA8VwIY71v/ZvW/yIRUWdDEEah9deZBLe37DxVl4cS2FZKN/uceeIF/gP1l6mKj5sk7CupiQBI5wgAFpYanZoP1curpXcGpuTQC5uTwqcxMpBAlvpOS9O0HQ7nPINZOJcOr8oFEAhb1SbXoTJu11lIuXWX/nggeU+Qg999k/nH4cXX+Ob3TL+VVe8yzGVNCudBbr7pDujqLDXHg13dJNXRTYTKJk+cwK2uMp+5FN6CrlN6uasgN7Cvwtae8x63/7EJOXjfCr+vFvp/rJdlCM7twAgEz0VO5q3x8e7qptpeQSaA3fsrrMudlKzfkLPY+m6TuIZ8beVEsdqp0pfhVhajlC9reWwN3r8GjgUApvh/qkkYNwjq9DvOWLGsf3Vxve44ObPiab1vV2DxETyqt8FNxLh52A7cr8f9La8l9LhcJNTj4K0cHAnuiDobIUKECBH+QxCFoS4GVRHq9dNf/7se/G+RWeB92bEEJyUA5ZRs26I8jKTwMEQRM3sUDFmwx5BKmYtAmjknQCqiW1JztSQ4Y/7WnQCAp+fO1O0y2XJ8vysfWTeQ/HdXhm15F6S7tCVfpYqFNsQXGClrYYVbjWcg1G23A4jTIlu/p3BTsNJWjWd9LQw1U4D3Waw8qJZ2QffNVoPL8tXZfqBR1GcYohPt5So8xxbhDegJVBVL6mRbszg3h1LKGInTeky5mOtkwWidTGfUowZVSt68pJTCIrJQjqvns5Qke/+LwQp4/zdq7N4F4OSan35yph5nTtoPwWc6FMikAdbfOothmi7MYcuzGKq351KJpYfC2zqNkXqf/Lc5Z74eD6aWcuJXUpV5fK7Dad0ca7JieTySQYWe43BMU8MnZZxfBXkMTmCbuhXmeDcHvne9XqmLxeBq7X5kBdrBpo5lI6vY9izk791k+R5M12rDX/GpGO/zehj+KvUuWbkySnBHiBAhQoTLH1HOIgRhOYvMfhNPHcj6aejvNonCvdf8DXrZtWpkQo/BWlFA0DJirwIwidbGlIkHn9tztbV+29wivVzaS8lJ/1+Gwvsv1Ffh/Xy7reUtMA1teN/LsE5bijJxfWCXnTQuqVCNaZbfgcK1tB22SofirC7CC6AmATZm2RMAbO0rRuoY5Q1Y1oLjzSXFLwW0kIBgrJ1pklehX1vQHH9/BRMD0hgtzbNNMZsq8qqs2qiPb61DtX0YpsiMx6wd4w2dstn2xrgBDyCUg7uyA82P2LNYP2qh/mzpA00AgKNPxnUMf/4PyKNc9EQDHgFZ6euEVAyDrXbOhc3FFvwIawGYa/xByiT5mdqaTBLNd2F8vabD8jWeiv26QRSDj+sshmlF18Jiusade29FbLJdTMqehfwtX8MfY3mAliyT/a5nMdP/cuD6S4kWFzXvNsD7ufO8h5AlAKC5OJj7AigfyJCtk//VawhZ28ZgKcqLtKH+nbAmiwcS1neZj39sGrk4tQObsAoL7ecG3vVmWyVl5mWXeTOFnV6O2S+S0lZxY4v34L440azkg9PQa7+03s8x5avX9YZUd6uGOBqfmPsjkJz2ng1KPSdNSIj7fzPavGOmLkAxVKQOVOikwd3y1EuSfw/Y/aG5jzdvT1aB83LcN2XJ7suCr1OD/6EW62Op9FrvyuB5em8ZQbp6+lvp08Vo9j5Ctv9ta/0+72fY4FN59BKPihmy/W8bJthmta0F6q/QfJJV2ufrlNfgm97dfPwd/gso8ogx4f83Fcr4q5V433/C+q1MYFd6XwUAfb4t3luBa2YZRT1Oo6IxCX0sfBxyfyWwOw52ei8aEcQJ6u8L5hy3ldmhL1kh3exRoUi3/9f6s3UwHQabvN9Zv53pfxkuJOEjEIZ69y/1sp4s5Cr24wBMNxN8cw4xBx8GhfhG42TA4LjZmxM4HolVG9U+FycC30XaUBEiRIgQ4bJF5FkIhPbedjwLPJk4b1UyAPgb7YSut3ilsaamq7+HE9rSavV/DgAo9f78/AcmrE6uUzgfdRAga+86T/F12Yp1JMLPhwudW4QIf2h0+3+NfO97n3v9mf6XsdP7DQCg2acwGntUYfB/s8oQVbgt8qRE+MrOs8QeZp/3M8tbA8K15FZilQk7bVT7iDyLCBEiRIjwnwmRZ4HzeBQRIkSI8AXiD+lhRJ5FhAgRIkT4D0FUlIfwPhaDDSyPUe8Nucia4bDYOSGQ7CAA2Ob/WtMSmWnCsWAAASaTzKtYrCXBfgGg8zbN/psmlizYQlP8P7VWl9RPztPIvAqzlBiymIzX520e8P4xEFuWzKaw8WGpDWbftPj/r/5OFuLx9uQ4yv0CNmPLRdI7GGAmybEItETdmgjE0Fv9n+vcV2zgAWt1KZvB477Bf0+zt1w2kewux/fcFP9P9blIcG7A3X5m//cNzfzxBP19MAE8q5bvS9gbejZhPhPn5jLNwiDXccexyP+mVoYOxWG1T5VHlKy5LwKDtSgvmiwELjhp8M0OmBaY7k0vk+GCFejKf+/0fmPp/QDAGzBJONaeYVyt9abNpCHF0VyqKL+4XPCL8Qan3ajU/DEvzx/pY+TX70z/y1rum7HP/yUA4M6keeFwg8gSfxza9trHIGmgmoaptNc2+O9hP+zJIgv9+vy4xW0B7tPrn1D8Yq4TkJOFeTkrPaUTCVCpuXyZng2dJMxvicrs76V9P48pmo7K++pHFs74awAAm1AFgPn+Cpw4BUlmS8HCa0Fj0OG/gPmgl9xrPslW16ixYAFFicz+72NAVR7z5An8XE9W69L2+kcwXtcbSF0u89sj1rHJyYKvaz+CRkUYJP1WT840PDTh7FJf8vMjcZg/I6pqh/+Crg/hCUFqTi1y2pNW+iN0VYWhYvfrBmWu6GZ1u/i93vcifW9K9YJZTgtfFgGUzc/+3CvVy26TNADwWxXNuTT43WCdJBhRGCpChAgRIlwUUYI7BGGexe/PkEXwpad8vL+CLN3rdpHt2FxB4YjKhTuwocnWHlrSuhkNpWQJsYX0CB7VCpusXMnYj2mBffcjS1t6rTCVza6lc0JIfnNRkwVt4RKmlBqZdFcuHADuhq091bTXhDL2lZVa321CVUDxVHo8skAKABZ92oRNV1Bl8jXKupbry+Vln9qVsJmqb9LG4kr9mWxq5LbOTO6lCmTkAS1x8grmp423x0V/EuxZPA3ypG59sRMAMPWuFkv5FTAtVwFg+LtkEc8a1awVVl1JeJbaBoD3XyTd8qN3xTE5TVpJbRkkL/4YSDurpft+vX7miN/q5YFPyJvidrAjcTqgDCuVaa9zjrsVkyzLGbA9CvZ6GK9gotYOC/MspMcCAJ3iOvA5TMnfoz9zPeKOdiOr3lEcvB/5+QGAJb129WtljlEC5nthO0wRqavnJDXCuOFYUTEVFc7A7oDcfk2XuQePF1DjIi4i3I0Z2A46v595wWJY6WFozyKX1BSkdtpgr+COPIsIESJEiHBRRDmLi4A9CsaZFUPxmeo69Mv7aDJ+s2ImAKC5aVbAIkGBkQmQFuke1dzC9SyG4azeRlM7WfIzi59G/V7SHyoqU41o2kvQAbLEuL0mw7XiAY5N03qs98/eRN9eY/lmlxmrl4+RFWDLy7ZrzabZ6WcAANszjNXrnudInNaWrbb2Pj2/DEIW+i3vCCAr78QVJGd7W3vS+m5xezNGF79mfdbZeKv5x8mHSg2qpzPIY+hHllYKlsVb7FEwjt9VqJfZGh8Lkhr5CX5oyUfo7Sq4Taf6Wm+E/6ltyLFXAZjWsqy8Wp7/DF5O2X0n2KsA7La0nE9x5S3uxgtaR0uOMV8rPqduUI7hVKMRSMqushs1uZB5KACorhV5gLlBL931/Hq2mrGtnfsXAKAbKk3Dftz2Ll33Y6PIs8hCP7blkNcwp/s5AEBzN+WKKvMb0dlNyszcbOoeGA+acxYy3+S2g300/Yju75Ln5PcAW5YEgPYqACCh2sIkbCUeDe+AGo8HguMy2FVnozCUgBt+kknoejysl0964frV39gofi+0ZKpz7MZCRzA+8DDfL0JKDe12U5jC4uPo3EsvwfIyStBK6W53sji1psAk4Xkd/z7djCg7/x3ru772G3XP5uoy0rt5BrM0E4l1b+SDw53spmZQ2KMfWfrleU5NdvKl4IbMZnzagiNXkOAhv6g+FInfMPE33n92ewoAsKB4Q+j6rtz2gb3EJCosO657pMuwlVsNL5lB3EVPMp+kiCMAvBIz4RN+sU0d1WIm46QdhqqJG2n2+qQRIYwVUAgjdTDbWr+5zOxbhk86eukcCnPoOmWhHx2Ndoc8FkAEEOhodwN69MuTw6KyN/W6lP3Gy4r1X5BR5zKwUvXZKKlTemjdFF7NHPFbra3W826hvYFWAP+VFmuLadLoxlew410KN44ZRX2tl2GdDtExeIJoyK9CdTcJb1bm099DmKQNKDdUehojDWlDEQZi4/p006ttVeZekvcnAFQnaVLsjl+HG59T4SdBGAw0SVuWQADrzGdRGCpChAgRIlz2iMJQF0CT9ztdJ9AECgmdKRuKCcp6OKwM0FdKRX0iAAAgAElEQVR96sldh2WobVZexMFMAEBh5XEdGpDJR6avclKvgVtMvmf2X1hhwiaFZWYZAMqLt1sJP0B5FOfBKe9Z4C2ydHSb0j5jTHB4i9GfygJitPxbFVLJE9+nXlDWbwX9mYHd2luSDYUY7hhsvqJSey5MhZyB3dor4L/rsVSfJ3sWTxfP1NuVdRgAUHmv8WCmPKfCDyLMwB4Cb+sIxqNIOYTMxd/p/UZ7F8Occ5GhxGdi5N3JpkBD//gMAJKq5mPrA3kW3B+7FZNQqizdzngeAKAw2YPRGbR+h9JFj5cd1fta58iiZ6EfmVfax7YIm3RokvtQy8ZPHE5sV17VyfRo3cddJrYBoL7deDyskFyFTah1YzYw9NhDDl1XOnjszfanstCfzkIo/qtZZHLFOizDgCN+644FQB4FozW/GIC51jIsy+FBK1wc0vyIMaeRPK/uKtOcKj/5fvjxA4B6Jxz+FvBLpQ/1DU5wr0sY7yLkUR3sYajIs4gQIUKECBdF5FlcBIkTZB0kxpB1cMYbwHDlWUxQBWevqnXXpZchNptil0czbtPb4ASbLOZiC4ebwkj6pdvsZT+m6oYvb6kEZLLWbF87GGytsLqtxFsmfqrpl6r4+ZbYCf2djMdzk6anYt/Vn83ZZRc1MT10Eg7pQkGmaI7FMZ0wNedG64/BiUAy2801ADZdksdxATYH1nNpmABw4HZV9aycts7mWzG6kqx3Pk957hLPXE1x8jfO5AIwHtEJjLHGg/EoHgndDgBMiT8fOMb7nRyO7CciSQYAsDS9HiMzbNrrLOzQORHd+yMDaKmie6wRdl5F7ptzKLGCPp2rYM9C5nIYD8eMl3Eh1WNOyMu+J22t1K+Fk/wDvx6OjHH0jGRdo1rKfqis9i8Dx0fZeQyZizr6KeW4hm41ucHWquDxMjhPdvvHHfqzPxnuECL2CkIEiwEMQD9LsQl0rLemX7c8DgDaYz2CYtwI1UZV9Smb8H8A3v8TLLxTnBHdL+NyUI9gRAluAfeCSXfwayup1/PXvAOaW7FCTRZ9d1G8piBtHni+sTqL81CjmqRwwrez8VYUVtEk4b74voo3cGdjKwCguop+txszdGJOhkGOpO0HhROjhWXHtdSBhCs3ISuJOSz2esq8wOVLArBDMm63uNWoCbxoNp9YopcXjNlgfeeGjwCgune9Xt6XY+pNHhPkAgBo+5RqPBZfEd6NsO12u6FU5SuU5G1uXqw/y5xhep67nQ9/P9ww4LacoZCXTO67tQky+c1jdBbD9PUZn2En62UVsZxkOLns9gk/lzYhk/oMQ36oSddb62Vl9GM9llqfld8p6i7s1VEdrw9M0PLl7FY7h00kctKQza4AM1EAADIDP8W2YnvfMlwkj2vBp1TiP7Tv9/qzDfnfCW5Qge8tNkZ++HETVg+vttaR51m6Vy3z4zsOQB69C2LXkx6B7ObHVd/y+HlsNk1U+ykAvL8OmSwOJwAAU4rpLfL1Vb8CED5ZREKCESJEiBDhskPkWYRAzvJSOA4A/tk7EFj///Jjevm6dpuaV1L8kqaeTlQBqyWNxptoqLLDBeNxBEWNKjSi6gRyy4zHEmaRswXLSefCiqBn0elvxX14Vu9DYg+m4xbQPl9JTQQADHx0FeryKTRW2y6ov9n20HPicjnWac+pudVY8OWl26312UPaPG0J1r9MFdyLPm3S3y+9wq7WlhXIHEphzwIA7rmixVpfWqcun7+5eTE6K/Osz/I+PaWXh15pLEFXHM89fvfYXKtbehaM1HvX6uXc/Des7yRlNWybbjhPJqRfS6v6gwxzbC5FVFYwS6IFW/AHYXudMoksvSq+BtKjMPpShFMLRfZWGd/xUkrWJ9tv06FXhrwfmdp8DGMBAD24QXtrld1U2zMzf4tef09qOiTWxn4U8CyOYDzGqPt7v0MfrkeN9gyb16hK7hVt6OimUHBJPtVBTRNjdo1T2f4GvqprWJhiP/wBQ52XHoYrlHmgXYVKue0souZHESJEiBDhMkbkWVwAYR7GPd86gDVUNIpz7nG9Zz4pyTEWrquxBCCQ3JW5i6K9TtJ13IDW/2FID+PALke++npYlgpAngWDk5qMVzFRW486KbzZB7YqY0ManU+ov4/bl6Ahv0oXKXGBn9RAYtomFxP6j3k4+jJVZo/5lArZaq6o0+tLa5atQfZ6fvu/XQ0AGHrC17HfA61mDGpK7YItTryfxTA8Aoo9y7xDaEtbRQhozqfqXM4jLMO6gHU6HUbvaCvm0XleNxuxHkqOMiWWIanF7DFMwiFNDJgHspy/g6esdQDbY2A14rZeqqrPzenR1fms65TsNfcZF+8xpmK/9l64Yv12GAq1m4TPQj9qk8rLZGl6CMn4pMMHfRKIPUFjkJfRQ8fT/XUU5r8OILzwkr3SfaXkPc5OP6Pl1fmaSY/R9SwaY4v1vcPXTHpVbr5JPkec9zonaLXyWk1zdLd+G0Kq+CF+opev9lZY3/kjTS5sai95xNqzAALPbJSziBAhQoQIlx0izyIEYcyEPlVgc+29QOI5+7tv+kV6ubS73fquJP9lbRmydIRkuyQX3matP7PJqKHu3KtkCMYJeZHthlaS+YBh9ABESwxAWCt+p61zNbrA0Ag7axWF8LD8rbMtqSryhDqmAarqKs9/xqJMAkB23HgWnLfpbFf7yRtARw6dO+dSJPtGehZLasnrylxG5zswW53ng2JnYoiKSsk65sK312A0hZgtxNbpDswKV+hVngWzYdg7GInToeq6c5U3cG+Kbo6BguHg02E1U5bnkF4newWVOZtxSCkKtynqdP5yopbmrjUDz/H7IfgMb6RIy0qqz7JnoQsvM0WlnLp3CldQzqBzza0oWkHHdjJN4zE0w1jSrmdhSWMIzwIb1bJzv7B8CQCkZiva6eM+cJCMWClFAti5LqasAkZ/7ARu0Z+5LK7vwzDaDgllZsYsPGP9v0PoOX3gyHicwzCLFQgAA8fEs2X320JN/CGd85uIVwAAE2DeAzJ/qL0LqhuE99/Uu+YyyFlEk0UIrMlCdXHrW0Bjee33gMRf2+tbk0WvcuPVS1QmMk/15gEA4jknkGy2Jwn5Ip65liaMcUprqbp3fSAMdarduPwzi53mSu3zAy4tV9kCQMsu+6WOXyMI+SweFMuzbV2s8hybXgnYtRFuBXRnrwkhcFhEVtPKhx5wROkYHKUbAzh5Wf1iBoJJ3v3PlaPv3pj1WY3gk1qTxuEEANIJAkzdTI3LP1UoVOEM1lMa2D3c1L2wZNLBcE0xAEBXJnJL6SbgMetcbmoACtfaSeF3Unl6mWtFTmOk+W33Ldb62G3eBTNX0P2yc8185K6gfbpV1ZLuK8fR6pbI4MmCIVW6bdkyul7uMMhJ5kr70d6XH3zxvwDTDMoNK8n7jWuTdvYaavPMHHsClGGs8TE652vxof584EEzSUxpet767YGkCiF1AS0VFJpkQ7AHeaH09ZXK6EzcS/97z5nkd6QNFSFChAgRLntEFdwCgfAT94YG8LJPxVnzH9gZ+N0vPKoQlQlunRyuC1rXHD6wkKf+9gS/kl4FW4CxcX268I/daE5qZhe/bRl3ALVa3eaTCzG9ghLuuhr7EKA9d1mkOkKZgMoRkVpEHPrg0FN5fLuuLmdLVJ53R62thgpBLZTrsWV2citRJ5fmN8Hrdq6LjBAor2dmnfGumNLKNM8jzxmqbfZzpFhbeu8+/Vmbd8ze/uGEXtRVuypsUI8aVMEOn8hE7cBuEa4IWNUUBir6lfF+OlrNuLj3CXsT5SI8V7/GFEpyCIkxEqeNMoBKImsPY4ZvUU4BaK8CMLTbMHl7Rmi4DgAWJ+h4RHtRAOhIimse4pBxYWoY+Lh/hLVa3WCxKo+ehEOa5sqQIdlpMUpE72xXIbO8AcRzbNIIn+ek2CFUpeh6ckhwZs4O3BQj6nQS5FFyot7aZ54Ki3YNx1JQQSknzHVVvQB7FQCgORLPBVYbtIg8iwgRIkSIcFFEnoVAQKdlQeK8xVnW71rV3zeGwnvFtoKltcgx+ndSeVpuYmC7nZTmfAUQLP5xUVL8kvU/W1LZxcFmNZ3+1oBK7cwKFbt+Yj6K6lQSVvVDiMePGtqlUtAdQKaRyfjI1m+Yiv2akstUxc8wBJ1JFXfnHEgwxWHp87DS6pi55K2d2FqE7DrVPKiWNI3K61RPj9rZeL/OjrVzMRdgZEJm3UtyETueq8RL99L5McVxNE7q5kf53vdoYUJCexfuWG7GAp3MZCv+fYzUy+WV6tiaZyO7Uv1WdX/lJH8/sjRNtqRU9XtovUPH2Hn8uHjuHIahYa+S+VB5kOyyty1FWYD0ttzGPNLD2NlNtF72ME715mmvNe20HeVjkcdT6Y8I9S6y/W8DALhLSl+j6N/B+QihpozJ9jMi270yzVkrIucDH+Jaa/3mvbZXAQC3x14FQPRqeeyA7REzsUF6ULKRFEDjzusVNRkCABdZpgfsscqtMB6aHEfu78Fte1dhJfwtNslEYrCrzkYJboEL6bOMWkmJ6mvwAY55bYH1AOCJASNdnDps4jmFpeRuS063y9Fum2d0dLZtCQrqbbqAMJxmGPH+isMruBmu6J2sRGbIpLOVjGcmiPoJM17WZyzFwyrWcJVIiOqEtppcGuJ0HtW963WykVlfG8oWBHSRFmAzVqtGN1yvwk1oCnFS94SWDJgskFDiP+DrAEydwiuYiKdAmkLMrJmFZ8wkIcC1A/zwv99ObdeWFdcF+lzvwCzNdOMEeD1qdM0CC/dxpz75exYDPIdhesyTrTTe1aW0LSnuOPAqGRexyX2aucTaUbMydmjjRHfME4nwgY+uAgD4v6SAgvd/ngtMFjwRSjbaltRcAMD9sR3Y+Cnpfclqd54snlHxytJGE5ZrrlL96YvoWm/oWIAl3VQ/0pFP1+BhEaNqa7d1vTYULzAV3I0qOS06IE4ps5POMhm/ESRbnpPq1Z81xuyJZmna6JFtzAhOQvK5cxtLZc42oS9u6CQr693wpgxDJeyIILx5X2yiO0pwR4gQIUKE/xBEYajPiXdXUUvSa1Z+gP/hU8vHP/Ko7/LPfYpDjcZJzVevLFVKp62LdbJudD55FkPwmU5GP/2pilGonOnQxX6gUdCrmKi9kuZeY3m35ihLRyVfS9uNRVfo3wXAcLwLvbk6pMYuuGvFSwzDWa2nM76Sttu01yiaSg49QBYaW7rsNfX1miQfexT6+EQ18cwyE3oLlR9PKS9KsV65H3Vh7KSW4r4JJlzIHgWDqZPZOaexH6Rmy+q9km8fhuWwW+IGeqzD1M8A0PUWgCEccPMjDslNjRvPgsMdN6BHexQMt30rQB7F+fAZhmgrnO8dKVXOHgUjnnNCe6gc4kMdXfMe5OmKeQZ7FS50q1XlmLNsuPRYN3SYe01L5Cus1npQ43B3cVDtQHsUjPeCmmqSQvsQVge2ce59qvqHcv6PF5AUeltGCZbjxwCALZgLAJiHrYEq/RnYjRlVFENd2tVkbWvodWd0BTx7wTeEMFVWYaWhzlJEMOBhDGZEnkWECBEiRLgoopxFCGTuwo0fJiasDGgPtYp4OVMhtWexfDHwgNreJ7StmXFRpd1MFsm5++i7kitadbyYrewdmBWwuKUq6CIVty9tJg+gsDKkn8XhhFl2jPeiLW26urgoh7YhLWjWIAKMwqmL4xmmCEw2b2JaIuOGWE/gt/Lc3Mpct5LWBcfwNZ4Qy9vt6q/cnJ5AvqGpWfR/WJDQi9xWlQsjGW8JnSap7+Vasy/g7gChQCZVnxE9MACgr1UkhdVwZ04WPTeetM8ze4VJvLMHI4+V1VsZMk8l1WytJloC8TrT0rVe9BO50/tGcOVDCevf1lKzfVf5FwCWp35s/c/JaSCYaL8bL2hqeH0j0YZl5beb7JZeKucsbsXr6OkiT+LtAruBkeyVwoSBMxihPXkmjTQUL8LLytto7brT2saYgg6tDMAKDpX5jaFkAIs+C+goRb1nznuw5iyiMJTAhZofSdS30k0rJQkAO6ktpQtYjK4yqRK6yflw3kEY+hbtuyjepsMmC3LoJRomSy5xT9pO8nW23gogWD3KqN5CCcWGefRCmYr96FAvEObGx+NHrUZLAD3I3GCJwyGyg9tsR1LhNEbqxN8HKXrgOxspFFNYddxiwQDAz/Btvcwv1vGxIzocwxW23MFvoGe4qU/h8ZwNUzndoxhbeWbS4PACv5SyK982YRQFnigk5CTxBqhOhkXmHoapfdjhTAIA8PrHRdb/e4ZP0bUZXLORXfq2PWEAGDioJogC6Er1ePwoLgQOiekaE3Vdx+GYDtWwrEpYZ0LMpfsw2f11+EPswEPXqFx0+t0AKKwZQAGNM6sY1OSYhkE8ocnQlGs4HOg2ldksDb4H000di7AbwjojAsDO7nma7XV1N12f3Pw34J2h8+oGdeW78URfYJtMzDjj6nnAJqSUFuwLrPeKw0KjicW+r+REwZNEGAYrKyoKQ0WIECFChIsi8iwE3DqLRMIXn/0ZrXQI2oJKfaSsDaUDhTwf6Dm/NdAcVzTC1h3GInaMGA4HAcZCa8hZqi1ESRF1m+toizpMgmhCQvdP1qgXK9YoK/wH9OcreCuQzH1fJBE111ydugw3hCWBB3rsMEpn72hcl3M68Fu2Inkbw3BWeycMtkg7MdyE9Ejt3NIB0p4F14TkmPAMJzX79t4IvJCg71Xv8p3eb7R3wbUu7Fl8W1iL7AntxgxtrXOYaz+mBtqSLh9uJNh13YRCdtnb+r7CYTreKRVKfj15jyYU9KTzAJDkd3IehZDiW1RtihbNCorpyZAZhznr8TDuhCoScqKL1fmrsQx0vOverQVA1ryrtwUYim9DL4VGOZTZiklazJHrP/LQg7tjL1jH9DqCoca2vUShLSl7CZ1OKOsd5GkvoLxM1bV0G6ICh+N2Krn4BdiMWuVx5bdTVtq/gp7TzSeWYMaYbdb2pScvddf43mRhypGi13wYmFLMnusqrIR/s/IuvkbkmNpfBT2MweZRMCLPIkKECBEiXBSRZ3ERaI+CMRsmPs4ehQQXc3Kl7VqTiOTio+zStwPUuo52RYP9JFPH2Lny9OFUvdaqYYzDMczIIMu1ud0pJrKLqwm3JdDAofPdtutRWyvooZwg3mKqz6XlnznRlkWXeQdO8taov1noRzJpJ1Crq4wVmuFU2rrJZMCOq3NynfMkUgI9FFfa/57qzQNyaFnTcc8DV6fpQyFj/bJDqwTMGLG1ufnRJah/pBoA8M7w7MD6C8uoGIzpyNbxOD2E6uLLsC69zPosucaMa3KXWq7YrOnQeWEiYwo1XdS69qWCEkypU97LXqWgyp5xvln/6Ki4Xg7NVShU59B9JBPorlfwDGbhdtVemO8dzgdk579Dnp6ALPDMLTaV0vwbzl8xHXd1zHhs3BYYAOqKafxWp4icMhRnABgdKblNwORYdrxYqT+77q5u69h4ndO4C3eqHGFlPulXvYypgVzYSqxCQik8J26mvxvS3IjsSQx2RJ5FhAgRIkS4KCLqrECY3AdUgdc2n/SF5ly3G6+9T9bS2O5/stacmb8FOxuJasdSAFmxft1StF1ZXNcKzSe2YLlBPPo8bCsma/o7qb8BYGvXZOcYS57bPHJ8mntcSAvslPesXuZCPYaW4ngy02j3iDyG26viUNrEwcdmBL2Aedhq/f8YDMXYpaz2IyvQi0D+L9kubq8FhmzUc4uI1+s+AwrMIJItRi0F3Sy7h0albxJJTH/9ipBxKHTYaWHXc/6jO+GVKQZO/Dpr/XUwFi9LaQDA2tiPAABLkja3uS5uvIraNcILzLNWQ3nF9oBHIcdxc5ddVDe1oAUuZHtazkUwGrx/DaxvgXM/CiVlRrssjELrsvzYSwBg5anY4+RrkY+3LI8DAHa/O0cvLxi1wfouDz2ahfVMinJa5965Wn///Jgp1vqNWKS3v/tF2m7pXfv0ObBnJM+Nc1m8zub2JfAmrLTWc2mzgJEIYv0oIKLOXhYICAkCqPRt13Pb+yIskv8nAOyaBzdXtxo1mq7Jk8Zb5+mpDJhmOwBQFaP6iYZP7BAEo7mbeOTcYOncGDr+AnRakwQALPT/GFA3OScb9+VQNfOdaEXnljwAQGEvTTSySQzTAodmnNU6RDwxcNXrDejR25VhGn6weCJw6biAGYMs9AdeIHno0Un0xWmimT6fYV5o01IvWcc4UG8S6fG1Ns00nnMiEF6agd268rjao1BTs/cR4r7dVYmvWT+y9EuL6cBAUHNIIj9JL4SaOE2eV+MjHaphOrDs074hTqEkri9IYwjqdyl6bh79Ka/YHrovfim2tNoNropK2zC+gJLZWjo8CUyJUxiKx6W8lLZ7EqP1fct1PBt8YIl3PVwY4gRNLnLS5/PkkGMaQ/RzwGGfttuFHpQSHjwFuo65dV26Yp8nkPuxQx8bN/LylC6VP97T4S0mZMjaDZcsMX5Mq15e5lTrA8CAUbdHu5JKqHFqaiTpoTlJ98FmBKvdZQU3Q04Sgx1RGCpChAgRIlwUX4hn4Xnef/F9///7IvZ9IYSHoWy85bWIgAThq0qDetXh8N9zCCasQIrBvZ4BYE4vWXecMKzOWadpiVpvSSTXT7WqjKjKc7pVsC7cUAUnOQE7PMNgq3cPpuuiPJTRHy5MugE9obRKtliZCsvnUZmzWbvsTEn8ANdoa5o9kmE4q38rCwABoDRptLB0sdpaILmcBoKbTLnkAMCEZzZjQWj7Sw5ZcdMcGcLSlFyFmcVP61AgFxOOfuQ1IKlWUK1C67vJIi3Kf0X/lq/FEYzX47CkncJQNcXkidQnHzNJbxX9a2mebeTQv6YaUP1qO1qaZ/OGrfU7jpXoZklFcSVHnyzBgV3kpbGn0rKXfl9Ydlxrmi0BqcRuyP9OYJwkXMr0MJzV48Hjsxzr9HMQUAPoQaCP96k1BbqxEbclRk54WAsAakcZKipb+TXxh/QzyMeRN6YTgO3pSh0t9/l8+dM7cfoKuve5op09jGMYZ3qTK7ghKADwHxJehZIvSyhPwysLrj/YcEk9C8/z/t7zvOucz/4UgfrlCBEiRIgwmHGpPYvjAJKe5y0GNRBcAWA5IARZBhHCchaMt7xgMtDFygme9i6kNeuqu5bikI6rMrVwUoaywEQSma3weM4JbeHKQq/aVjvGOvQo7Tu79O1AQVCT9ztM8f/UWn8ky2YCAZXNPanpmBfban0maY3ct4G9iZMYrS3j+0H5DplcdXtmSMswTLrh4Y+J3rln+BTMSdI5cz8IKakRRp99bS1tuzh1GIDtJbAlzwVhna23AodUP5BJicC2ku3KXVN05sKck+jssfuH7Nw1XzeSYkmXwvhxnaNgjwLrVA6xyfxWtsR1pUJ0nqIAoeZVS7udl5C5sJmlqrHVMWPxuvpfeBJglYqWe9W21J/OvbcCN9vPAeXm7FxYGPie+Ex4uEy+QLHxJNnKj7+iCAg33AZwKuYBsz0u4tv5iSpqbdyhW7IWVtBfzqsAQYKAJD+whpPMjbkFjGGSLeuuqNbLY0ANpWYpeZvH8LDlrQHABv+9QH7He2ylyh0abHqxGpcLLjkbyvO8b4BEUjwApwF82/d9N5Lzb8IfUkgwjMFwIbzgd1j/z8Bu/SLu2GWap9RU0IuEXXJmX5zGyOBDjQsL6g0co2Tga6XmBTzW+5a1zgbftCqTPaMBevG7vZdlSEE+PGHV2YDtzsuXvxua4u/k53L55Y/LrfW/9K65FrlxSr7LY3VrHl6GSZZy4xqWdY+N6MfUDJuVtbNVhA8mJfSinmzbaYJsLqYxkGSGzl1i0uhRf1VevCT+kh7n+r3qpX/QrF7SZHc5/CF+okXttBz9LpE0/wQ2RC0Gd/O7Fh/q8XWvsVXZXi/CaEx+c7cv5qHcsnB2HcNVBpB1Frp+SKGhOCi7LjXB9OSsICuo9Tm8YI4/u8o2FqQsfkmOuU+4SZbb+EuKJPbjKr3M9w5XxY/EaV3zw7+Rgpl8znztxuBEYLLY4L8XCJ81FSkhy6MJ/dlgZUP9IRLcNwD4YwD/HcAVCC8ZixAhQoQIgxiX1LPwPO85AF8DMNv3/WOe51UBqAPwl77vr/33bvcPWWfxb/EslmYA3xwgz+KgMjE3Y4G2zC1LVBkdbh/tcxgW6K2sazBgKlUHdg/X/bCZDvg8KFk5tvEksDgROD72LvZgOgBgLYjXX5w6rCtfq3tNm0m3zqJdWIxMhZQehZsUlB7DZ07SPQv9AW9JqpDKMIEr9c2QiXxpUVbm2GGI3emguqqsE3HbX7JXIbFaSH678uJta4w3U7LCvp6A0TliVJeZ+oWJMMnuF3A3wiC9J1npnRULEgrcqnh5DVhXipF6IFhZrm4NglMBz7L7AELlt126sWzmJH/L17a6fZO1viUv/7h5FllFlq3yZONtuvnRWuXpVYkwVG0vje+2HHKPtmCu9rT2gWqNWAn45eElVjiW9yO9IwD4Pn6K+1QIjsdxQYa5z3icOdy6+eEl8B6zk9bSu19S5PQJiDwL/HcAt/i+fwwAfN9vBHF2QrSRI0SIECHCYMUXUsHted4f+b7/P/69v/9D5iwYF/IwlgqJqLMDscD3JWiz/u9sNx6G61m0td6B7FInDtt9g/nnVWMAbKukOZeTzXNUcVB942OhngUrqXJSlSmxy1M/Ns11ZlMQ+7Ucc4xcid2yazayK+jYmNrKllRHe4muHLeKoFR1MyeZuZ1q595btc6ULJRymzydwBhdMb1NxbZl8ZRbZPeOSKRzURZTKGMFfZiVYbfo5EJCABaFlr0L7lXB+5HJUJkHYJoz43WMsSq7AbJOGdfgA+u7kxiNO5upQKyykqzwzW2msGtRSYO1/o602TdXsve136ivgat4KwkGUqEV9ep+qlH3/K/pf+n9bE4bgobWIxOeBVe8swfIlGUAuD/mtOxeav8AACAASURBVESF0YSqb1d9YVQhamp2Noqes5+Vju7bNdWY82WP4FF9PkOUJyXzZJx4PqKK6Jbjx/q+YrLJ6Y+N+NXrwwutfUpCyqY2SkB3leTqz25L28WeyzLMta952Fwn17MAAH+L/R7x5pl1vki12S+kgtvzvDm+729Ty/MvsOrTF/guQoQIESIMIlwK6uxMACwQP+c86/gYxJPFhSi0YVifpr9LM4Dr2il2+X4xWTq3wVghHN8vKm7DLNgW15JWY1FzxzT/UzPZv32Xii8rg4itJsD0aOAObjVVD6F+sZ0jkN3f3ndyC0/Fvos5bIluV/yDFeZ7llQADDsIxa8CsC15pkcyOwcI0mK3K5rNWJzEwEeKfSI8C7eI7y18RXsWp5YrCpDKdi3pfkp3IWTchDf1OLAWUjPIs+jKKNBsGI5JD8FngXwKALz/Lg30xlGVgfNkNkx9Dv3N731Hx9PDuhq6YyBzEPNA8fg7uw1zZ4iTd5hV0qxj4k1J0waWe1zIPIUsXANM3wzu+wAAeFDdV4/7aNlCx1LeTZ3pusuoLGoTqgKUUsBoKwE/DXyX7KZKM86rhaF572LUlCnNsMPqQ05J1QTXlwWMyUaVA6kyDCr2GHh8puJlvT73LAEQyEGMHE4yPn21hg5eXmfGaHeb/eoqaDuF0SWv0W9VcSgX+sk+H/WryRORHgbDP2y8irCivcGOSEjwApCTRY1PD+QfeX9pjmMzfb9yAT18W/1OwydXvPzcnB6c2mtrTss+wbpqd42aLMYBcHOHE4y4X2uOoSK6CWXGnF0iBHFfQi+6QoIPiXagDBmuOOEIXUleP4cOpJifG0LaJiiR/DA9DXI2i1OHzWSh0JBfpZctOiUnShX1NFavwhbvXWv2lX9v4Fxmd1FtzNMFMwHQw33txykAwC3DDcU56R0M/Nb/DT3YH4+iyfMn+CEAoK7rLwN9nBejUS8vUsu8PhBMOstmOSxRnXrvWt1K9CZQjQ5PDFbPdlkprBituRUm9MS1ObqZlUxYO3JSdc8t05MbVy8/BVOlfQ/2WOvL8JIUX8zsp3Nwryd2i8iGfAQ4ce7Wjoj8ONOkAeBUo6PZDiBeZYeC7hRthL+Of7C+k9eCJ/XlIpTptpeV9PATbZQI9/7FR2EZ1XS49/laQafmRHtt67pA3Y5/eBW2FxM1fI53c+Cc/pcLQ7nwPC8LwDQAI0F1Fi/7vh+kcUSIECFChEGLS02dLQHwPIA3AJwC8GWQjVHu+37rhX57IXwRCW72LACgvtmxyCcLL4J1mgqMN4BjdmlJbHKfLg5jtdS+NcodzjPrcVUwIJKpquVma8V4Hd5gSygL5P7fuavV8igAWPLRbCFxuGMZ1gWqVmWSWoatODkv1XFdpLqM5a01mxSkZ8HgokIA9rgBQFewLCc2wew79YRt5W9bYazEsPDSvI93Wv8XDze3YYf3C73MNEdOljKGd5njKy3Yp5d/iJ9Y6+3HNB0OY0gPw22JK6m8PN6dSUG1HuGMy2EzLtUVtpQ4ADTMc2I6wmqvqzCW8CsiwS/xHIynJim9ld5XA+uyZ8GQLXSlvDrgqA6EVKUXrjhu/S+93zmNymOePmA0u5zmWvvipXAhrwV7bSw5L6Xzpae+FOut9VgzCwAaysgL+ynovOWzwqrMqcPZQc9iyypsn2sXnQ4WD2MweBYbAXzX9/2/4w88z7sXQCMC/cAiRIgQIcJgxaWeLEYCcEWV9gBKxnKQIcyjYFogl+009y7QnoSLU7UFWmtHW8QFA8A4Wj82wkTfAhYdT50DAEYgiMO2hZ2Ffu1ZcMtP9iyyK95G333O76cntHfxTioPgNGvkhawTLxzrwr2XIbhLF4rpphvSZoojlyYtDm9AF0Z6iRUF06m9AKGVjm2kWLkmbM/xsCDwqMAkPm4adk6cFB8p8ajqJT2eTJNx5A6mK3Hzc9VhtEJYMEYu/kN54XG4wjeGE4UyML2HrPChIS1viyeYugEaQHQA6IyM/WYej9QbxCZYGW46qpjM45pT0K215VJdMBoYclroi3zEWY8dG8MHDE5C25ixbmLg9D02NpuYghMyd9j9ZmQx/MjrA0UQ47GScxUj8hO7zeB83wq9l1aUNd/Tu92XSBXl6M8nUxoiZEpK1RL1zWqP4k4fZbZ2I+pxvoX6hmWCjBMXw6JN3GTXm598U4AwKK7KPG89F0S6OoalRv4HWByIKzdNqXsed16VmpwAeQxBhp0TUqEbnf2Vnod5s0l1dtcNZ5hMiqDDZd6svgZgCrY1ImF6vNBhwuxoPhBLsk5hLZauyIXD4RMHqy1cyzTSmgDwP70VOOuHrTDKFIMhXWL6kqX6dCBdJtdlo18OFwhQQDA4+rvRPoju7+NDYkJdDsPhawGZuHD8/0PEHOGefZu9fD42BG0KR2n6iYzqTSmyMXPnEwTx8DB4YiX2qGs1AtqzDLpIQaAqcom2X+iXE8O/BKVkuyhzaYGSLWOG9Es8a7XE8YJ3GKtL/WAeFsjcVqHMEao3s4AVeNLbMwwWk+sPSRZVG27aDxYHE+yojgJy2ORbL0NHfOI7FC0hSaN8+l2ASDpb67RmUj39/7GckytonFj8UceszE4oSeLMIbXheCKUgL2vbqtlM6FQ5+5KyiZfWpXgVY5GFNhxP9cogUGMoBMRUHkpL2aoDahKqBzJsX63Gem4N1TGD3qNeuzclGjIseU7zUGP4ufYYhu0MVMt6H+twM9uL15K7WYJ4/pAe8fcbngUk8WtwJY6HnejwD0ggh91wD4B88zAWLf9795iY8jQoQIESL8T+BSTxZPYZCGnD4v2PIbqvj/GfhMNws6UEtuKavDdqBEt6XkhFhsch/2p8naGJ1xUv/lUIpW/WSPIs/sm+W3G7FIU/244jhMtZWtpuVYp1uEatyW0IvTYrbyaidG61oGDkldhX5dcSypha5lJqm2i0GVx9wGEzDVuoyaKqO2m90UlBd3MbPi6UCTpA4o+vC4oEeXN6YTj+BRAKbOoq2A6I/rsEzXpFQXkzcjq5MlXBVR18NwwWPF4yOT63zdLwRZ08BhJx73sCT0wtL1aNpO1NoxQoJbV8hzf3UORx00Liu34QWCjbDk/0wRlTUKbLXvRDDRzeFQxsycHYE2utxfHjBJ/qwMun9zK7p0v20eP+v4pGS6aP4FAAeW07N4TiSHd19ByeTtd5UHvJ1Zo5pp3+jHRKVGEKZzxvvvQV6gqZiseWEiB1ftf+CMBUAhbd7DgWYVetus/i5IBNYfbLikk4Xv+397KbcfIUKECBH+MIiK8kIgcxZFToRMWvT7u8hyGV9A9MsjJ0oxYwwVr8smRozUYYq1F5W26VhochdR/yoryCpvTi7Gwvh663dNvaYHQEMOWTNL323C06Oo2Ix1hjhnwZQ+wEmcKe+ipoOse07eybisW3B0vnNnSG2mu2HHdC+0LSDYFEpXh8PuY8BwrVSdzAXRlhk9XbbWT9YNRE9gXSPAPpcG718D++KK97D+EK6VynRgwCjSvo+R2qtqdSqhX1LJcAC4VTXSAYxqMG+fx1ZWfDP1MwzDcDZwbNrDgD1GgJ3/aupWRYf5y/VnbtWz1JsKo9A2+LYWlqSiSg+hJh2k+gJA6iPhtX5kPCGXDntn9yFU51NDqYbl5ClWrjWqtm7PiEXYpHNEfBxs+d+ENwPn+W2RUuVk9jCcxesqd8IkANYcy8z7ONC69xE8inLvz6zPKv0R2ouZ02xrd0nPYrBSZ6PJ4gKQk4a/UQiAOVTuhHo3JV4HvDfoN7HpohbgsJ3ElglbvmmnqQd3OvZoZg1DThZ4kh4i/7seSkcRz585/vemngNAwnxh7Ipmn25oTtYzE+YIxuNAd7g8NgC05NPxLMV6/WLkJkAc8ilKmlBIc9zUbPC+uFf31ao8XSbPZZhFThiAPWnwZCFfBgeS91jrV8bNS4PDUDxZAAgICW5qN8lPKcHgThYMi1MvJtlSJ6kqJ4swnHEob3JidScLICjnzYKBgP0S59+6yW553MVi4rtGhU3cyUK+QOUkHSZNXuJTIpzv4aVfM60AZ/xqm7XuRLyKJc10rrHZqhKf63JGDAQmtOMi/MfH9CZu0hMRny9P5vJ6hSkccFiR78u25jsQr7QJFHKyYMNrBnZr6ZTKMhVuVfuWsvHPxEw9hjtZ4L0HtWw6Q9ZZDPYK7j9E86MIESJEiHCZI/IsQvDvbasqPQsGS3oDsCSrwxJggK3Nw3x+AFhSa4d0CuuOa8tVSo0zpHYPgz2L+S9SFXP9XWRV78YMLQJ3IeTmv6GtXXbnOcmPGUBL3A6B9CPLEuwDTIJ0N2Zg5xryUrJX0BhNE2GR5nZy8cuLt+vf7kmR0NHtsVcBOBZvt9GVqswnfabmZiVNzhbse9diYT55YdJqDwtDsY4Wn6cMozS1L7XWld5PvqIjd+Mrelm3VVXoLMsz+9lltvtaBXlMY3eR9dtQQR6l1MmSdGemtvK5TMV+Xbmdu4U8D8n/H59ht1odhrO6oRXL4Meu/0Cv6/ZN/62w2iUtlD2L1i6qZeDi742/qtTrSCn4lmayrnMrFWU2qYpluozOFUN6FlsxTy+z58T0W6a7dgqvU3oWTALgxDl7BX3NxpNlaXgg2Jfb1XcDgOwy82zLdr5AsK0xAOC9B83yBEeZoCehFwdrGOqSJbg9z/tzAHMB/AmA/x3AvwD4JwBbfN//+0u13wgRIkSI8B+PSzJZeJ73QwA/AtFmWwCkQH244wD+1vO8Nb7v/9Wl2PcXiicBrtniwioAOJ0mC4cttdEZJ3WSjGOnXKQ3G88gdcwp1OuCptQWVprtulLja2PUJnU1HgJCivLYo2CwVTYEnyGeT0qd0lp38xhz8DO0KDrn626h1G7owijGOizTsWQurGLPQhZaaV0sIYteXmwkUrk4MXMcFeodaCVvRrbqlDAy2gSmZqZwraZmyryHv4q8R29lUDbaba7k6j3xOmzpsmU7BJ9pRVmGbCjE2FBBSf4luzbrJlMMVjO9Fh9qee6vVBnPguXImS7b0P2w/k56cAAwNWN/IP8iLW9W7V2cDh/TC4EbYTGW/aoOQJCWq+GmPZ5UfydSYR5gnp8JaA8QJX6K7+vPmGbMOZlCnNTeLNPdJSngZYcAkF35ts7dsTdxqtsUt/7+KhWp/wbwpV9S1CC3zPZ+stCP+arjAo97tR/usZbk0PdckCo9isGOS+VZLAdwu+/7Xc7nz3uetxPAKwD+800WESJEiPCfFJckZ+F5XgrAKN/3fxfyXRaAU77vB/uPfk4Mtraq+nffA0qfJIaSVg4V1EXWhlqQsVlbP2zJM9VWxpWlJpCm2vXQn8K64zqGzK0/l+wVFtj0hHVssvEKK1KMvsvIHLhWoFRFXZIRzH+4tFepqCqt8TC6LWCzVqTl6NIY52IL7mxVyrBskQoiUUmp3Zb2SMr8ntVsc0tN/H59hp1vmP+o8bakZ/Ga0r7ULWVbZwf2J3WdOGdSnk8qtRPxqqaIcttNec7ueC9p3awLOhntYiz6Gm2WGKaHSMwMZOj9u+Mu2VEyF8HsIE3prKX7jAtPAZtJ1ebZsjB1/idwIc/T9UDb1ojYfk/wFLDMfvZa802Tr/miXxrfM6tTjjemvGvALoxkCiwzx+5XOiGrUaMbYkkqsSsx0v5xKb4znDTH2APh9Y9gvPZYGVnoD3gWvz+zCpOG77M+k+M52NlQl8qzaAGwz/O8RwH8I+wwVA3gNAgexNjiTBI9F1jXF3lMTj7LhFtehvk1J9y46vVoBoUZlmJ9oIseANNNrMf8nimnAd76lQAOJWh5Ev31JqzUE0btXX9hrf5OKk+HwwY+MS+V7pwbrPW2YN4FJ4mDUgcbRuYZMC+QjqRp3sQV6hxukRpEruS3BTVpZFe8rcNJTB64KfamaZakwLLxsQl9WJqmY+r/2nX6e++f7fDTa0YkWUtkt6gOf22td+imQxqTzQtuogjJ1GdQspnPnV/g8jzLW+1qegmmuLbsmm0myHFqX1IfibeVb+TUeZ8/hqmbuDX9urW+rDtxcaD2Ht05jif/Fu+twHq13pV6wnCpqv3I0teFwzP3r9iByjV0f5c00cTbtlBNIGKikBRevs8lecANqUlVgiW9diitIWeppmwzJH34g5QimwjzlUNYTI/+0t/7uhbK1cpKJm/DuLg9WYSFoACjwcX1OEwOaPOOaSP1i5w0LoRLRZ19AMARAH8L4AMA5wB8CBIQPAoSE4wQIUKECJcJLoln4fv+ZwD+AsBfqLDTlQA+uRw75M0DWZ2fl0J76GOiD36p2lhJ8S120c+F1EHXY2lAGnpOUliAIvrQt5xCE9xmNDZZUUSdIkCNB9TfX9EfdqMbsQgDrypJcKG3xH2+x6MdgF1IdovyjNiyn4r9uoCJdZIOdN+NKfl71DZsXadt8Rm6R3LfLjqPPtyIkgqyNrlV6UZUaSnujl30W0mvfBa2FvsRjAdKKalf3UqFbJwYB0xIqP5Nog1vxgKwSDUXMo71vqW9C5Zi18gEOEIhG0A9kkHFiRz6GILPdCiDQ05SDZU9NE7SN7cu1mHFq5QHwpZ6UUUbOvYqj+zXZHXytQZM5fOh9CSt/sv3UAmoh/VU7NcFiWFNodzmV4V1hkjBIZy4/5XQFrRcGMfesmv1AyZ0MwmHtDQ5h7dqmiiUVN+9OrR/N4dZV6uQ4FHcpotCX4nRuPD/kqLLkJRf1i9j74BDUACwJTUXACkiM/ieA4IqxjKcx9Xc3A4217+w7Dh7GLISfrB6FIxLqg3led5XIaiznuf92vf9f76U+4wQIUKECP/xuFQJ7i8D2AXKUXTD5CzyASQB3Of7frB7yufEHzLBzbRK/d1K6HIdthMTqgjJfxL40uv2oUl6JxeaAcDCYoqdu0qdso3kbJiEZ+fyW631MAIBCuLCtSZH0OTZ3AL/ZnMeb/+KPI9NMIVsLGXA2FYWVJo9idE6sSgbGwFO0ZqSjgCg4+rVOWTRs1c1HkfwAqjIrmWXkUBgz4LlQGTL1+24n9ZR1vIkHArQKu/Ds9qzYeudmz01xhZra7223bT3ZOkMaQlyPxCmNHMb3J3t81FYbLf+PJ0eiVQNjWnDWiqkezT9iM4JsFXNXpDM5bCFewzjdFydqahssZ9MjzZ9T0S+JPYD5UkqqnVsXJ9ej+md7M3I3hj82X5M1ffklGKy9hcpj+5HWKsL3fbhLv1bPkaZmGX9tI5mssJnVlIiemfvLMzMsfNv0utgz4K9zg3p7yM9YHs9L8dMQlzmCtiTmOGkP/lzIKgRJcF5QZmDk8SMNpRY65fAeJh8r7OCMQDc+oNOa33vr4I07Ab/Q523qlyoxuXJRGC9/9WK8rYA+CWAUt/39RXwPO8KAI8A2Ao4V+MywZt+MyZ5VJn6TZ+kr/GtDgDA6uHVgfWbWxebCUPIke9RL0qZaAOIfeOGoU4tFNWjV4YclIoONa0hps/CFeux0P9j+kxNGt6vV1oTBmBeDHfgZd2Xu3MeTUpzXtiNDVvsZHaT9zssUHMhPyiyl/bqGH3WkE+TUHWveSlywm+h+r1kPZVX0KQowwX6xe2L3tjqt22qmOUxPKwfdllxy/LshZwL5mp2PyhGaO0rBNwQCUorambx0wGmDE8Uct+xAaOjxN3Q7gPtRx6DvNb8Ar5drc/nHRsYbUKMor+5W4+TynxSd0M040c3x2cYYrF9ANt44SY8i9S+O70X9Xhz1ziXqcbQ12czPdI7m5Ww4uQB3Tt+So7Ztyv1Xe8NUecJZGSqzn1q0piWekmHmjjsIyXzGbenzMtckjQAWKKE3H1QIlCd/R5wnXqpt1bROW/EYh3C0kxBpZIuJ5mNT9C7YcMT72GJJ1r7KTDBwoDTt03uqoMOl2qy+DqAKSp3oeH7/qee5z0C4OPwn0WIECFChMGISxWG6gTwsO/7gca4nufdDeAx3/cLg7/8fPgiVGdZhRQw/Ydb/Z8DAEq9Pwdgc851r2TA9OMVdFa37Wm5T2GXFu8t5Pp20vaU9yzwgPotu62PJ4AHxTJg/r8Iuv2/BgDke9/7XOtzi9El3vU68RuqfRMG1sO5/vELrxfh8sfmBP1dkPhcq0vaKADEBh4wntxFUO2Tncsea2Y/kSvCNNEAACfUMY2hv/ys1npXam9M1yZtFMe/mJZb/Z/r5zzmtOHt9Lei0JsLwO7fHuZZuL+1iaG2d/GHDEd9kWGoxQBaPM9bCspRcM5iDCjhXX6J9hshQoQIEf7/9s4+PqviTvTfUdcEtRtE1wYigo0v4LUNKu3ytvcicfcDKKKCpaB0xdiuCN5rDRarIA9NdGUBdatI2yViC0ipoCIKtivovSVAe1GTrjXYGg1qEL0Wya5KYtW5f8z8Zuac5wkB62Nime/nk89zcs6c95eZ33seyFvWWaXUccAlmM7hGOBdTCLBh7XW2UnxD4LOiODORVqyiEQikT+XQ83Ajdb6j3zO629HIpFIxJDPFOUnAecAWbEVSqmJWuuVudfsPA5UohA6Q6JI63kPhgrrGSNeOlKzoUE9mrP9Vm3qZAxWxnPrGf1zb6s4AFtEf32h23Zap9xHfyPbC2lzBoZlzD7FHVP9H2fDkfaJ456VSW6jOpOV6iS8Zg36frMNq2MWHTJ4PfIf9TyOUyYFrtQAkeAp8TIDH3wYbo/Ndt/DMlm68DX6N659VhU1vF1MbGJOdz49OCfhvEzWPZilP3CeRWlvONHxg9fzr9G/ccdRpk2qFhd0V5dx+v2cz0lgn5ByquIJ1uEzKves2v6GNreDtL/JNc11PQ+EdfpXjFF/94nWzRddNe1HvlKUjwR+DrwCnKaUWgpcq7X+yDb5EdDlOosDJf3xSjzgYYETgBNvzzLG6Y1zUeXGD1v/r6Q7q7jeAVxbH8QQ2Bc3we3JeWUzfaR4WCQHkonlpNMQp93++sKsfDcz8Ab68CPnDNzN9jxzdBrycQmnX2kx/4sBcAHBdaz1rovpmucV+ngXzyLL5Ez66wtpmE2S1290sQjyAZSAlD/qebzFFwFcpzGozXcW4QdVlou7qCxLJiz3uM7NBLtTpd9l9lozHXYwB4IzvhrPZmr076nYmGoUPGfiHAEvwM8ydtq6aLr/fVxMeD9nWYdFSW/nBhT1eKMwxt20v76QhppUvE9dBmx9a7m3D0v0uB7IpsZkiWDuDz6AqedXasSHy9bM9CnFww4hPIfw/2n4uKbLcuVYs+TK3bRO/8pNSz174eYWf/1kwBM6pYhKWhhx81Y3rW6z7/rmub5070v295QDL67W2eQrN9StwEStdRmmEsOpwFqllDhYd60uMxKJRCL7JW8pysMU5EqpI4DlmPCxC4E3tdZf+KTb71QD9xUZV7JSgnEa5tnR1g6gOjt1tEQvS0Tp+k3jcAk6rQdd+V1mbCclUsFH8G6ov4SifiYo65wCI9qfTBM182zp0ZnJ1NahFCERs/15waVNT0c9h9lCw5HZw1ySWN6XpkSa6HD7kB3cFkoYwjXc66ZvTRX7CYvopIsOQXZEbpjBluP9dS8rqctaF3wwH0CPhb79jMqqRLvw+khEcK5rmuu4HrLXbAlXMQCT5XU9ydG1BGRCsjiVSG3rUwV6wiC+ikafWTbMMgvJSPhcVE2Ykfg/DI5LF9KC7CC88BqE1/7usmTwpnCvlTjAR2kD1EyZnmwogqV/9Cne6kuWhtcIYN+7fjS+/uhRiWNdwSQXdS/cV3Clm5Z2cg8v4mEesJkBJrHCHve0RB4vMO/AohZzPmcVmedL7suRfOCeGZHQi29u8SuL8PoqbBtqKoQNbrQZgHNIFl3VwJ0vyeIdpVRv+Udr/SEwEXgVkyXj8DztNxKJRCJ5IF+SxRLgVa3193Ms+yHwba31J+6oOiMojysybrL/0uyUAeBTZQAJCSNMdQBm1Lx6x+TEvPJ+vihKWCMCTPbWohPfBHwahMuKHmB1m0l7IJlGhVqGcL5N7VBTY0ZxsypuYkFLMlPnTzGBgefxZCKDJpgaE2nJ4gEmuQyk6ZFXLh1wpT7CjZKlvodITuGoVUZ0AL/mbxPbeINe1DSbkevgEpu5ttFLCP1LkzUawmJTImHUN/v0HLINIcwAHNbjkJFnmGsIkmU5F+FHyENSaVtCyUJ4OpBs0tcrrKHhs7j69cfUJo0Wg4f69BZbTit306rKPLMNE/om2ver2+nb/M0+Ny0FuQTJZ1Wzyp/bqAk+tjZ9nrPrF1BRdo89XnO9r601o+z+Q5/NKsIUSrE7pxiRYt1Sc/xjBm90krbUOgkl7TDfmUgXC442KXbkfi1p81JOyyMmHcqaCf6eSaoQkVx7ssvlIRMJMZTkQluebPuMAjNv60abC6vcS9t34ItrFb8WSBfAtt6+7vATqh6AufgcUodq8aNr2tu21vpqpdRtuZZ1FXKqoe7PmN8rMq7AjaRDlhdi8NJNPNeSzBu0qMi/dKF6YXy/ZYBRD4F/CeWDDtD69rFuWtKOS7rtFS2TXB4dqbLXrcCrbqSTEMIOSFKJy3E/yXlZBvGbg4SGl7y2AYAHek9yH97zSpKdRXvIyyZ5n8K8SlJdTIyJp/GiK5bzpk2wGH7M06ndi0tfyUrrHRYFSqfiHlXi61CHHy25DpL75x6m039jE+ATQUrH3K3gfbcvSaZYzSwGYZwLtmEKL4WJFcWoLixsvBl3ua0aIkyLLh23dBbfZb5f2Wocty4fweDFtsOQQPwfwcQJSTXhkfgCSWEnIbRcZ5MQ3mXUnGGOreIJL2e1l05entd1ZeU8gqnVns6Z1VB7dqJTS1O8NLX95RreNd8sp0oqyL1utzrzjlYNNe9LVk34gHGr1mddl55Bh5AeKO2il+tM5HxfaPODEOkkhJUbr+SZ8jPcugBnHdcgqbVQtgMctK2ebZemCtUHdFUvKCEvaiit9Qda6/dtivJc9G5nfiQSiUS6IHmtG9AhqgAAIABJREFUZwH8Wil1k9Z6MYBS6q8wPnxXQGq49XnB2yadYXvwTDN66sb7rnCKiLQ3U82tNkOrqHBO4SVWb0qqoR4aYQx1K4ouZ9zsVKnNK7IlndamHi6JrRi/ZTTW8kSxy0RbNdZLKjcX3ZY4NhllH8X7bp6oEgAGvVaf2OfqRZNRF5kR9sJms11JQT1RB/EBlhVMcll1NzWbEWtFyRK3zzRN+DKuImGIiiCkrPTXgJc+ICV1zLJZRpfa/3fY/0uyS38C1NcYaeCUCjPc71nvVScrWkzWVJHiLuaRrAI7l7y2get7G1dVUVsNoM6p1KRW9/6KXgHsomfi/zCF/MShNu338itpD7XhYybak5aiPtXcDMB9AyZCc7L9qJL1bLCqRpEwui825z5xwn2unKmM2s8Kno1QRSajdDGSjxhqy6XWXsDWWluwaqjPrZ7OOiuFrgA4JvmsP9A2KTtf1OaMm3wqdS/OKdhuSt+CewdGlD/mnpVNay9ItJ811jtZyDMZqtoWLvJpyPtPM+rnXuW2ZPJG8/5LjfdwGy/+sQ/9TrOqv5vtwlth0HDzTmWXkOq6EoWQLwO3MBy4Win1uFKqHNgOfAX2IzNGIpFIpMuRt9xQbgdKFQK/weSIWqq1zu1ndxB0ioFbeCRD4XBjN2j9oS1F2mR+pAA9+BFM8diXnUuojN6P4n22bDJGPXWc2ceaMmPPuLLN61Zbqs1or7jqZXZvNKVHxWbR2tTDlXAUwhHb7rWm/dSxZsTbi11ZBtfb3JDH6OlDQiOfM9SFgd5DE81RZ3lDnWTUNc3MKG1Nc7IGwd0lKffJdniTE6huviUxr7jEH1vaGUCMpgCuVEQwKxwFAuysydEe3D2Vey1MKbrfTd/7mq9fMqN30v12L90TenFIlqVNF6cKA8IueM1IqqN7r3Hz0obiUM8eGvzFEUKKNQmhQ0JYD2LD1EsS7Zhl5NV00SIhLRGG5yiSxSvBsZ3O7xPt027BITsbT4em5OhaSupCUDcDsjIzl1oj0KbG8/02guF7//lJp5SGtUYqmDj2Pnctxc7Ui11ZbsNbF41g1DRj6Jf24kzRp6SJptdMEu0dvU2R3n6Td8KvUyd4E6aSD9D9F28AJKSmrm7gzmtnoZQqAX4CdMdcpjmYfFG3WHfaT0RnxllI2oqQ1ht7+H9GJpdNHOs//g+3GB3WWUV1zmAWFrMBr1ICrxooXvyyq1NdOHKP24aoVHbWJ4u3FJe97NQ4IlIfxfsMtxXmxK9cHvotr3lvmmd7m4f+UdXA1TZUpvg621mcCpumDc46fyGd/qRYf5N/41sAjGl+HIA/lnij/TBb21sQxwHwhvGwsxAVlhB+qJ4JvvQbptgPYLKGFIOnBR+eed5IKRXnBFeVLqByrI/gTRtT5Rwh2QEL4XlB0sMmTPWuX80dzVve23vKhfEQoREdgqI8+M7inkCVJRUGhfp5g/w/sqmgsyhNOT2sCTqZUFUj9+Fv7dfxTkylxLCjCDurtIeZPMfd2Uv9RnNMleXmem9hSKKTECQqPt357Gw8HXbb7544Ug3zy6XIlxz/+xzFyo1GtSdeTXvpnhVLE3bW0mGGAyD9cbfkAYYhRP71ovvENxLNvnO7KRcQfnMOtTgLoQ7YCgzSWt+DUT8NBA4+sVEkEolEOo18G7gv1Fq7JCla62bgH5RS2cPzLsCBJBJsXdCDwhkpNVRfu/AYwNY+KbrKjFbXt43Oqiv8XMsAZzAVSUJ8twG2Tk265u2u/ZKbFjVIHQOcqmgnSclCpAowBkKAqwqWcGnLgwBcXPSIPeymrPM7e5CpJfwoUHy+lygAlk8b5/YphsVzU6PmkDASuqokWeP7Tr7jajzLiHU9o13pT4lyHsIWZpWYcB0ZVYejWlF5nGPHH88wkIlLrTF4kRkx3j3NaD4fYBJbV9lr29du4Hjvllw0zNyLirH3ULPWqMlCiQKSUsUzbUZ0OZvneLbgLMC72I4vWJ2Vb0tceesY4BIThmzqbaS2Ea+ZV2Z5b1/2RVRYUkv7A47MUp88VHAJl7QZVUk6DuYtvuhqgJ/VYkbXhVfv8c/wrGTmgVANeWwwqhYpQq77yTSxzMbriGQxn+8CJtbkuHSheHwUv0R4h6P2UO0E4rKalCzCXFuv7DGS8Mk9bA3s1cpLEuKMEhxCOk4kVOfJ/drCEHdMImHspXvOkryCOsy4JTv16jKYXleTbLQR9t5jnBi6T09KGCFd1YU2r52F1nqrUupY4AvAf2mt37Hz2ylnFYlEIpGuSL6yzv4VMBfvIqsArZR6E+PQmNFa/ykf+/4sCIPlACNRCHZUI7aI0AYhnFzU5KbT+uy3OIFxi03k1Zra9nP9hC6uA8rM9OKNJnq0fuMgN0oWwshWsZ28UmQklt29iygelIw2zQSq4IfuGuWm066nImFUq6T0JIitQiSLL7W9AsC1BX68ELqUSnDgi5iR99/ya+eCKplw08bHkF30cqPCmmmTEttPB0ymqS4wx1jHAPqMTRrCZVQZShb3FJhR5PS2e5wdSKhZNJ2F064hF8bRoX2T3UO9RyX+b+SULAN3SKhfDwMzAY6rNSPehqF9c698eVKi2FpibAarGU/Von8G4I5ppvTnVSxJRLBD8l5IcJ5IDk30dZKFXLfQjrE/V+Jwu+lSpIvVf/LxH5P2Hbk+OwE2p86tLywsuT7RPjTypxnCliwpomJtYPA/M6WBKGxD32tsFvfcarJGD1A17jCGSXD+SZiER0BL4cNmIpO9/64mUQj5slksBgYDlwMnAEcCf2P/H0S62GwkEolEujT5yg31DtBXa92SY9mxwCta6+7Zax4YnekNpRfMRV30MQCjSs3oYMOiwP1QarT3NT+jyh7iqZbhALReZfTD/R981umeRYe6uPE7bhOSTdSNkGunM2uoca8Q3XUYGJYeoYVFeb7f5t1OxXZyelHSnXFg4G8QjmAXnG+KRTz0uB/ppkf1CxsD7590Bs10bQ+SuYiGFCT1x6GeXQIYR/O43zyNifb9an2+owFDff0AOR+5tqKLPrfF68Nbn/YebHePTXpzr2e0c3PeucjYg0Ip4YTAJgRJvbecw+BFdVROM/aOUAqEZFqMMEeUuM9+YHNcjKs39pvQRTp09R1ckdTvb20e4tyKxdWaQr9cUmMIs5u9PUYkCmFQXT0pZ7WEu/QZA55x02k7gBBKoWFm3rT3XlmZr8MinkZheo2soLwAkTDO6mHuf/28QVTNTJ5n+MxeEwYAYrzXxLYmx7ua8e4dSkgUFvGoamg0dqrC499h378cZxbeb3427/KXb+bPg5Wt+7laLtmX33SLDknXWaXUG8C5WusdOZb1B57SWmf7Jx4gnRFnoRdkuzWOrlyT+H/DWt9pjBrrk69tqLXz77IzXoeyrdsIqW/0CfQkQlk+en1pcjEU1atMFHb/Cc+yqy2pEupeYEXx2f1YWGU+bpWN5uUoOvFNWpabS15WYfYdfpzTHc5RvO9erDrMS/ECZziVR5Yfeg73xv76QueLLmnaBUn3DNBa7T/cU+ffkWg3mse5YEfyo/hsv/5u+uxNDYllV424202nOwswEfUhmwb7iN5RW/09S3cWQvE0n88oTIX9REHSZzrsLITwQ1Wq/imxLIyzSHcWAIV9k/EerU2Bu3aQnj2rs7CEaskwBmNlbTIifOtQ05ENqvPR+7sHuGoDWW6v4XMjBnxJQT5q6UNsqE/GcUwt8/c3V06mb2LSkcsgp2V78JmwVRQT2CJC8s7MYIHb7hJs4j9eYENzUn22rsSkjb+T77giSdL+fY6ifm2y8wTfSQhSCKpw/B72/W/bWUz1y+el7OEzA62yWj6HNF29s8iXgftfgKeUUjVAPdAC/DVQBlQA7dfijEQikUiXIy+dhdb6TqXUC8A3gQswJuB3gd8BU7TWv8jHfj8tcqmh1AxbGnHBXLCDiPX3G9dG9bugvTVwOynDB+3CdfZ3BtQPNiOXwifMiLHw+HeApIqoptEEVFWV3kB1462J42lYdTZFFyWN2Dtn+1FwmD0UjOFTdILpDLMAi5vNSH9qyb1ufRkJL7IujufydFaaZiFnTW2gf0my3cKNxohcODBw25Rr9DYsbbkC8C7CoerpoX5Jw+/FezagrUZHWU3PC5zhJImKGjNi3FphGg1uDqS5J6x+JtBAbagx92xUxUNZbsmhGkpUZJIRdSDbnSQi+544zQdjTrIj170Yx4hZVDPKPjIb1G8BGKP+zkkX6RE3TV6SkIjywr57aH0320As+Zs2YCQLiVjf29bdpR8XHmc0xUONpCTu2XIeg6jnjgFTE8ffs8arECsrjNR07/crueaWhYBRl4ZsqL3EO38ck/1ObWg0BnFR54Zuti4NOMW5JYoUTW19zUSBV6/1KWlKnFOIBA6Cz8IsKrBv8lMqSUkWx5ssuoAr2ys4qQKcNTYz1s8aqU2m2W3A4Br7oA63C6/KtH9SXYy8uc7aDqFLdwqRSCQSOTDy1lkopY4DxmFyQn0B+C+MZLFGa/3HfO0338yorGLB/cbwq3rb0ZIkXG/CBwAFo2U3LaOsH+KKvLhUIWean3oGwcj9mGQGmmWVpV7ScIZEm54okapgu1VFlkJxRbJ+gIxgw7QFoS1iqDXRyWh5EiuczloMkGInycUA6pwxV1KNLLQZeFu398hqf/f8q7ih5V8AGE8wChZhywpO4oZ5MRtckzNGGINrd/Zm1fJIuEleZyWKwMRQON4GWa42xzSa9TyAcbsdMc3n+wJTMCpt0A2DCcWIfnHRI1luxulstWkky6zYksTtuqWpGAZml+uVkfPO5r5mxvJCmGkmx5Ub9+vtNufJpIIHsup7PMwlXIyx06SN3/okP91zkb3HgbF8wfdnu2kJ/BSkTsXu2i+5Ika7G01G4dCRQ5DntRvvO7uBqxEzdBNbs9bwSC4s4fIH1zB5iDl3uS6jStZzRkmybozQngvtwrFGknwneJdcBmRr6Jf3Zwgb2fKoyelx34UTbeuVbj0pdJSZCxrzPqoS+473zdiNZbpsMJ6QrziLcmA18B8Ym8UujM3iMuB2pdQ4rfVT+9lEp3AgEdwArrT0c6kFx+M7C+dkjRf1663RMSyZnQ6lyFE+evaqBa6T2Fp6lpv/DZJqHzGIH8X7OX3Yw6pj4DuGspK6rIjfFfgPQCjGS6RyOs9QqIKaGHxp0p5A68ptVbTmx93HP0wq+HhRMoX0SJ6gCWPQvuRR0zk8d6HpLG7p8b1EviKArWt99PuyCrNMOqzKkgWus5Ikc4VLAsNxYMuWj7/EkYTxBXLdQnVeRbNROxUeY1QZK9de6fKCdeedxDGex5NUqhNoj+trjS7j+wONkbds7DZXdEpUT9JRAKaTsEjHLh+yN1vsfop89LcYkQGmBTXRzbH6zv87e8xxVEqbVqiYZopBXYVxJJCIdfDPea7/i0tNfE0YDZ6OHQnzXkkH0rDqbPiZvaffyPjGT5rpFvuepeOKABf5HyKOIhJ1Hh7H1mZzX8eXrM5a7+42n3RCHARkwHRGwQvwI7vQfhsyp0LmD2Y6lTXK7N8+m5Ors/fVVcmXZHE3UKG1fii9QCl1MXAv0D9rrUgkEol0SfLlOvse0ENr3ZZjWQHwjtZ6/5Vg9kNnxlkAWdGjh/0qaL852bZs/jZXeGV3jZUsQgPZRcn2fYbuMJkz8fWlG1adzbIJZiQio9nruSNLzbFzoxkajytfzppGG1Fs1VCDJ2xyo/zFtclo1rD0ZSimi3QhbpiN5T2ZRdLQHkod9SpZ0mWiPikre2fYPj2yDKUbGdlfiTcUhxlU04xZ62tULxvbfnSuIHmJAFegR0irZACnlgI/QhfCGt9sLyRN49hkUSNxRQYYp77mpvXm3FlnwxiSF1t8TqnaomGJduExCqGL8r5njkssGzDCb/cWkqPwi/dsYEWPcYl5k2v8KHhqhXeBTZdTlbxRUsMdkoW07us9MdFeVE83casrISvP6spVVyYlijRWwigrN84LdQ8O5r5LJyaOo2rTPzN7xPcSq0keq+kscjEVlc3mnMpK6pz0VTnPSFXpzMQh5xRsZ+P5Y8w/8nr4ZMLM+4OfLtGpa6rOzNreoZZ19tdAtVLq6HCm/b+K7EzvkUgkEunC5EsNNQVj4XlbKfUyPs7iSxit/Df2s26ncSA2iwp9PN+y+lrRXUuwzgDqwLrMhSNoyQK727oz0o+sWgthlK5IFI5gsPpSUGZU3DvTBeTX3HA5XG3PRYKzJ3j32DTPtQzgrCIzkhOX2/N40hVQEsO85P4BrxuX31yGwtCgKkFRomufHOjN11lF76KWa5hWZEZyl1nDTgEfcB8mcOx9q/0N8zCJ1DZirC3lufYCprcZvbrkbgpH3OIeK1RVzGD0UCPFzK41gYOhwTo9Wg8z6cq16lWyy51fxViz75q107NyCP23lt+56dbuqVyamzMomyhIjKBDhnppKR0kVjRyNyPajEQYBq5VDjVuoytSx929aC89Rxg3ZCnzGtq2pAyrSBiHvaZZ1sPq1Wuz9eqLa4x0OrXiDrcNcT0Nsx6LW+ogTM6ksKCTODHItQZcJmJnTM4W1BKIRCFUX1rp3ouwMFbVJpPn6rERyXclzHZAky+/uz31grbcVcyImUlnhwS3pv7/Obw8wNyXSxMLjNNIaY3NOiuP01WZ9rfdRchXnMVOYIhS6jTgDII4C631H/a7ciQSiUS6HPlOUf57SNVV7MKIrrAjCSMd8Cb5eho4m4kVRscuQUJ9C5rcSKdXhbH3b7jhEm+36Gu3sdm64jzvt9t/sU8vMHmtHd2FNhGxd8joK3R22p5UQW69YQRcJ1k4za947kB2uo/Q1lBV7nX44nGVbp+2VwjpNAtSUyH0LroDM0o9n8eofs+4ZK442oyM97Z1d8FvUoUurMMxxSbjWcoVgJEwpM7E5Nnmmo2qMtd9PKvZQFKymN04n6rSGwDYONRIirOoZva5Rsro/5TNA2TTllDi9enyu4AZPsivwm44CMZ8iy8m9nlyUZNzqWtQNlnQsAxszgCglpvnL7QlCWE23L1t5h4Vnmldf5/vkRWAdlmRCah7nNGu2uLJE5rccrFRiZQ8rtaO8o/J4eo7XMPTyecqDCC8yQ6vxa41uHmbK886qXeqtgPZGYzvZZqrSyLP2UquhEcypsFFGde2TCfTq4Su1iIVyHtXPaLSSY0uYdPrwcon0i4TZ5r3eX3baPdctTySzFTUf8KzLlfWC3XnAKC+8DGN9vxCz8GdlybTx6Qra3Zl8hln8XWMR/LzwP1hSnKl1L1a69w6kS5OzdrpWemr3fvSBCvPNSqToieMQSyhipnnP1TF85NuhrsX2bKpt+9xsRfuA0VQC3q4+UnkBnrX/krnkfSQBaBqvv/gz15kXpxW6WUG2PgOoGLoPa6dqFSE9zkqy5gpncYo7aORhcdb2q+3fD7rszqcd47wBtibMTmwZlHtCvpIVK98oK5JuX0KtxQYVYq4fIYfpZoK0wlVNK5w89K+949xPsdhU3s3Jz++lc13sLEkqcoIVVs1i6wbcI5s6E8VmfVCo32IGNZnLzf3R1w5y0rqKBtr1C1hJ54uqiWdBsBzmGjjWTYX1vmsp8bWWZcCUFMneCN1fW1SzTWqzDsyyjNR0zjNdBj4qGuA6lQp2TE2W149A1jZbK53Y8nJbvmWVAH3UNV3bMrpYeHYa7LcjPvrC52C6THOT20rmSoe4NaWm9y1mVGUzFFWveg27+5u71l9/SDOKDPP2srZ9n2etZuWu1Lp7Pqan/c5yqngup1sQ8jehtJm4y6ccHNOc9XnR9GSFwO3UmoGJj8UmNRav1FKhS4h7RdqiEQikUiXI1+us43AKKuGQik1F9NBjNBa71RK/ZfW+gufdPv5cp09oKA8EYkhWfQICBOaTnzKjB7rGEC1DQQbN88b8opnpiQL655aOHAPrQOs1LDZqo02F1I4cj9ZR0UCF5G2bytsNlJD/wlGjTKJB1yOJ+EG/CirstaMwkcMNUa8k2lypUWrxpoRb6hySEsFK9WrpCnc+z9z5i8CE1UrhJlJ7y67KqvttY3/lvh/aumdbjpttE8XuQETdS3MIDmyDF1o06NUgOOakwF14Shx59pApfB6ohmzpt2Ulc+LwsCT/MRkLs0q/a6bDlOHC+NSgWJr1vrxlpM68QWt0oSj98oxgUSWkoBEZRciKfYBWpcnI+/DCPe0hFbdfAtrSpJqPwmsBFD/7ePkvksfdg4TokLawhDWqOxcZqP0VxL/i1v1Uqa4NP7C0pYrsgqWzSo10lD1vNv8eyzX4hifHXfxbPs8nQnpKsRi8G7kFHfuUlhsUdF0F6gpJJ4ddXjqjLyk21VdZ/Olhvob8OGtWus5Sqn/B/xKKfX3wGeSYjwSiUQinw756ix2Al8hSF6htb5HKfU+8DTOZNm1OCAD90UZqMsk54kJ42qYOCE5mgjTXayZaXT44y5dz+5Lv+TWCXFSBUZXDcae0PqEzTo6Msg6uiCVXylMHySG8gnmZ3bjfJdyIRd9hibtMGGOKDEoN9HXBdLJr9gDBuv/nrOmhauv0Gzahak9rq1fktVeDJtipLy2ZonTky8sTQbldWcvNSVGpyyjuMp597JwppEWxG1TjvXFltP4Fj8Gktl9ZRR7uR3dLecyZ0wXwlGhc/Ucu97+7ws0jVm0kTRSzEoYwhY3XBJ9/Gx1jJMu0tesosRfJ7FZjBu7PMtA/FzLAOdyvMJqetcHjgRStGnZOuMSOysQhSVjsWyzF7ucHl44vej3SFyk2OLeoBc97fUTd9dSO06UewM+n9clbGD0hcZ9dhS2eJjNPvscA7JcsdPlTYV0xtqlTHHL0pmLW5/vAcXJd7p63m1uuugqm4NLXJC9kMfUKithrLre2ShGTEi60IYSlZOki/z5Sw2VNo50bsu97OHkeme6KvnqLH4CnEcq05HW+j6lVBsu5V3XZH+dhhF/rVfTvKSITV9YWW8ekIll5uP1FMOdp8a4RvtRuV0nDIQQGC5fyVbxlE3YlvXSbJgXpH9OxWyMKHmSTZgcS+G2JJnb4FLjnSEvZPjRCfPzDB6b9MYZztNZBu6sdNoBre8eBUXmQ/1MiTG4hp3QG2XmnHvWmzYVZd6gHkZzp6/V/KAAz61WxRd2rOnI8LoHBwPQ7R/+6OI4hCc5z6lZzi16GoDj1u6jcqx5wUWNcj13uOOSD6VEco+p38i6MpPzqvDyQF24wEr2Nm11OHDIlRtKPHYkp1JYVVCSI46rMJ1Bf16gv/2wbrTeeTcX3eZyWck1rSkz6qdd9HKdxW2YqouJHGKpPIVD2OLudUFhMmI9jaRFl+dI8nXNYIHzHJT047Mv/F7W+uEgRjo3uYcmE0Eqsv0lXzjonKDKI8C+4HmXTgOA3eZeFA20kdjXsV8ky4GoZUdMeCwRtwEp9VwOdeuUPSaZ4BSbVHBpDx+5Lu/7+NSgoSuTrziLBftZtoJQQReJRCKRLk9e4ywOOZ7HZS4V0fQphmcZlgeXPuVGFmlVQi92JWI0wIwApb24U3J5Kx93S+azPK/HunYPrU/pi4moafA5eSDbZTFEjMDhiF0kHVEb1Ki3s1fEq1IoMT9yXUJJKZQo0lJB/wofa5KObwGvanIEUlZTXTJX5b5fHseMS5NCbZhracMqKykW+ghoOd60SgZgcb03po+pNeoncdGsXuvVHOlcUrkyAodIlPjd9txWtHjj9Joao16aVXGTmxdGQL+Rep4qNpo4h8ry6iypEGDnDUm//9DVe0292ZekSm9q6+ueSTmnUAJMb/8H/E93/UKjs6g1ZZkUVxKJB6Dcbncr53pJQmq8nzIXrs4AUG1drCsXZzsFCIVn7smqO//N1LsAuNTjlbX3cvdQ8248bP3Rw/fD5V2T7R//Dg0l5jr2bzbq3Da1EnIUYpBIeSERQd7FyVduqEgkEon8BZEX19l809lZZyt1UiBbOHuWmy6rMsFTMjpcwAxn8Ds2ZRROT4MZqW9pM9JDy9tGmhhcssXnf+pnlcs7fNKcj88y+tiTezQAxsAo+xJDsUT7dkSvAi8xpI8NoHZPeeL/53r40fs56uvJxq/fyLKSZEhNaFSVnE9u3zmMmZfgXTkbFp2dWCaGSYCWzT5gSr9nbQUnJZqj3mvnvqbcXosnvJzVJBxZhiN5gIW1/v6TQ8CSuhbCA7UVbloN8/r3WTq3bWBBS2CjKfL7+n5bcpQq9w7ghR02krjZn3NDed9Ee7HDQLbtaRIPMLs+pU0OgvQrZ/r7mJb4QpuOSA8zbDZZyK6FEkZfi81CckRVN97qJYpcpJxNKsuqnS1OankUFH7gJCLJJSbcwAIq640da2GZkaB/yjfd+ytS9Rm84PKy1Tf+bWIbE0uXupxa/a7eCcDiH8GX7fKhgYQh76gQ1oHpzKJHB+I6GzuLHOyvs7hb+y/LrLak6Nu3oMlNi9oi/OAODIxx6URlos4BL6ZLDEHhMe/nrCwnSOEXqVo3mZ/SYNM+hKoEOT5Xr9jSsqPYV2WzHiHjhi53qgb5kITnIik6wmPO6izqMiwrMy9u6JUDSXWTfCx20ctdI1G7Xcl9Wf77rwQftnTxnnEb12d1FvcN8IbFMHLbnFzwjsiH/mkoXpwqWOXaB9NhosAnUu/aiWQZjRdO8OrILIOmTbUNMKvcqGOesc/IUy3Ds9Qoofos7EBEtZjuLGrKcxezWrgq6OjwcTnVzGJcvekU+5fZlCfzzibtzzBqgu/M5flIOwAAPGSTUIYdRXqwsJ7R7l6L91R18y1ZMSkhI7S5RpvqbdGsYzR9Sl8EYOcYoxoqWr2bbgXZakRI3V/rBVU2dJt7R8IOOK1ODN/ZB66uSCz7w48gWcMPhgXjJpXyzmJBxk121TiLqIaKRCKRSIdEA/dBcq060ZUNlfKK69vMqPnFltOyRoCQPYKazj2q68FPAAAe/ElEQVRO8pAav76utE/sNLXEjJqXtlxB4UCbLC6I3BZpQAgN2O+kig617CiGsibAS0D19T4fUMssq8ax+aV20ctJOM+1mGP7YpFPPZ0mLTkIj9gNpkdlIeLueTq/5wQ7HhPJIkwauGTHtQCU9/OG/DAGBGzZVpub754BZrQn1zpnbXLwSf/2lw77GBkJqkTENEDr28cybppxaV2zyAwfR419yBnMiy5K3qfrdyzmequNUP2tGuq8jJMuxBdfJAvjgmyauaSURbuc66ZIqQPZzk14wzrAiHIfE3CRjWtIJxsMCY3v6ecrF1vahjCkwEgDUphLtj+ELc5VegE3dLitboETwcYczgwhIlE4jvEj9Z21SaN9y/hiuq1LZUxYFUgUqUSCoeS9q81ISy07vJpT8mbJ87S+JChoNCb7WIdJfaM6mP0fxnV4ljXmV6sjs1fookTJIhKJRCIdEiWLTwHRh7a1Hkl9jRmtD64wAW1him0ZcV3DvW4k3tduQySLpxnOcJ4GYPG8wC7QlNrpDE3L6yb1tehopQh9KGGMKDMjyy0tQ5ye++IiI724zJo3eMknTIudNnq+2XKCS3ntjz99YJ6yMl+YRvTYy9+b7ObdenQyQOs2bkpEQwtpQ/vGHWb49mw/b1w/Ep93adOFgxPtr3zNBEXd0XuqiwKv3O5tHX3Kjbuj5Hoasfgxd6/GlVmJQdwlz8y2Z4VBZVXTjDF6C0Mom2DOX0aqJ9C+ZAY46VF4LnBFrZ9tnqteQe4muY9C5cZ7WVZubERD+hlX3m45XH4llfhxq/a5eX0mJCP4Q+O3RGg3cLZ7DsMyo2m34tAete09cy+uP3ohYJwDxC4h9/VFvP1lQRBwCda5I+sMYJMytq0KbcTCitJFANTUTs9ufJd2AallpaZI5xcnmHshGXLBOxK0tR7pAhETGYyt9CLR43LfezY38kZJqdlIcBmHiV3+Qft7YfahFe417tFZxbC6IFGyiEQikUiHRMki4ECyzi7TzyOJl25wWdgN3Yv2shtjUxBPiRc4w+mZQ11xWtd+vnXHDNNhOAbiRnR3L/aBdJKNVXS0kt8pTHkwn++aiSJ/vOI+KMVciqp3O5uF1Ii4l2vcqHRI0ZbEMQJUNi5KHmM77o3ibij67MuPXgbA6rrJVGFKXUrhGIDfc3pi/Vv4PoPrTToJZRMqhUF8oocXjsKPlkNvFYDrX1tMeW9j75D8Po1BmVopzQqwe57Vac805y75nSSADGAa/jgGJDPbsKH+EidZ9S1oSixb3m8ck9WZiXkywoSktxeYXFFSknfDbGMHKava5kbm9Ru97eneVABo+CxIWVznnjpheZb9IrRZiHedMGKmLywlnFfgg/JyuVoLd7xXadoc7XX/cjzilhxmB84VBBkidkNpJWl2XE1O4Jl15tzOafydu3/yPIrEA17ClXQvT7UMz7pnZWXbnMvsxNKlpl1YHEpSgtlcb6cGlyJj87RlLoSqm80z3+27OSL2ujixswg4kESCk9WZ9LdVzuQhTxiTRyb9JccXeB9yiXYNo47TsQWjg6JAfWZa9cjGfuQocc2aUpNSe9xu8xHfWW8Ne2W+IxAV2Nk7Glx0uSDFhF5oO4OJ85OxAFs2lVM+wnxYpRrdW5zgPgiVpUaVsbDRJtx7JJOoZCbU1SZVQkh9o0Lo2a8xsehY9jpDuKitrucOBpcZ1VhY/xrMh60Jo17oi1EJlNducRXvxI10SW/z2529nG4LN4Z+/1/akTTkhgb0NfOs67FVuzzJeQljJwDHaGbb7UnVvRDptOQjvYUh9LGPmPjZt3b/QaLDCDmLOqgynVHoLCFFlHqVG9VUE32d0VVUQVtrTHzOVRVLuL7Nq5bAOGhIJ7eyJumE0adiR9az2cgprgNps/enliEsIqn6EVVS6FCw5Ghbg5vHXcJGQVynw1xVW75v4nmG3JKdmHGW/oDG9Mzj7Xv3diGjhibTrE8tvZO37ADph+nMnXhHAmFK0f1u0CYxNT/lm06FJZxr1cUP7AjcZsNaRuJJbn0YMrdBxp7OvmfMi6DKfZxNZ8ZZHAhRDRWJRCKRDvnMJQul1C3AZq11doHhzwObMzRIHd9UYE2uFOC76OWMhWFepLT4H47i0iK4GGDBj9oSQXGpIkwLZ8+iaJYZCY9os4Z2ejrDsBg/hZbtxS4vzuR6M8q7HMXj75n2q482roEn8FaWqkHE+zXPZxc/lEAsgFZrqy18zS9/3GbGPR+j/pEiUZDMoRNG+AKJEXJ1gVnnu4GkMN2qh2TUPMmOZNdzvpNO9mKK4XTnHZb3M+d3+Q6TOnsIW1zW3jBdNWDcRMvMdKK+eKsR4aR2N3d51Zuwckower8/QxrnFm23L2q/XfTy+7I5tiQVOeCyoTYsOpv+00wA3dZ5NuLfugVX3PAARdU28LLaSEYruZKJVblLvJbyklNhbao116LP0B3sXGXE0zDKXQoriYoufJbl2RGmk1Jf4rMfQ/Y1ay+PlmRFqG5ORrGH5WDlubqYR7KcC+qONhe5L01OWgufOakVH/7/EqWJeaLy3NRvMCOGWzP8qXZhjmqpc3qAvtRMK2v01huN+laVz3Eaja4qYXSGZHEu8GOlVG2HLSORSCTSJfjMJQut9bkASqmSz3rfnzrVdgQwy4wIds/+ElxtdKc1Y4wed9S6h7JSY2xnoDNwix77GjviupdpWaOpnRu9sUGkjOu5w9sociCjRzke9YV9ruaDUF/rDaPOQGhRx2n2Yc5v/HtmxF13dJkb+aVdHHPZKwBeHmqOo9d7ZlTb2tvMf+Fo7/a6u8YakyvgnHqj35cR4tZFIxg/zUgWe1OBhgDX1hpJof/QZxO/4EtcTioykkUut9wtIlIBZ/QzhvZxrPauynZk3rLEXs9k/SXPKfZZGG7/X46TEELX5AOhutYE1lUMNRLShrWXwEBzH3s2W4mxxBuWNyzydVUaZtv8WSJtindtP2hZnrK1kG2rcPmfKrxkthUjpYTBbhLUNm6Cl3DC0q0AK9deyWhbICp0p5Xp8LgBF9gIMOAW7zBbpk294HplDq5aHQk/yyTWlTQlTfTNCkgNESN66Egi0mbolHL6HpPj6cUefQDznp6GcVGXDMOC3qX8c2EFp9nN36NqhzFmZ5badpXwE+sdfUW7R9h1yWtuKKXUcVrrLLO/UqpUa51lozpQ8p0bSmjX0H1FJvHvrKU2GnP2baZWL+C0BDdCw9C+ifZPcp57YeQDKB+y27jZGXkX19hOpi+kygrTp2wHO5vtdt+2ocdS0GUY3iAuhr/WoDjh6pSYOwyfTM9+D6R4E8DKVcEHZWA6p02wrR9myCKV6C2MCs76eKWCcgHYHEynrkEYeRt2Eq+09M2xoSRhQZ8w/w9AQ+NZyfMCf18hSzXFjeE//2l+Zvx1+zsPtWpNGT+9OZNoJkWQdq8Noo0D/4msuuxh5cTh9veuoMFFqeMIwzRS0etTH0waw8EXBDLHGhxnup58cLzLxo63u/I7X9Oc9NYIBzHVqQqFs7jVdRKOII8WqUX95z9r7h9eLbx71ZeYOsGcj6g0RTUc7k+cJZ5mOA/uMfFAK3oYNdpbnOAcJhpqTYdcNtR4u0lxLYDyS41zxBC2ULXQdBbOqaMc7k8lt5xC1zBwd4XcUM8rpUaFM5RSU4Fft9M+EolEIl2QfKuhrgSWKKXWAncAdwO9wMq1XZxMRmVLF4H4O2vCTYlFNVWTqFhl/fADe2//2iYAV1AFslUqYqDtzl4eaEuK8zSRNareOaUfVNthZrpE5PBgerkdMo4PzkNGhcPMT2i4DFk5z0oUfe2MQuB5OwCxkcz9F9uMpFOT6cMBFuq3qKw305K5VGhoPMvV1ubpHIMaGX0XQ59pyejinecGx2pHzg31Z+fcD0BrtR9xV8y/J7Gspn46LRS3uy7JcAhnQAZoGGPP+QLgsf/MXnd56v/dodUzlf32pTm4wty7s69HOh9VKBm1XBdIaGnpSxiJl0pCyWZ7jnbA4sHXM3WrGX0nYn82J5uPmukNyhJxXjzWS0STZ9uSwlXmYqx+bTLqMCNZ9C8xap8wS+2YeUbFs25meWJZFk/knh3mINtd6yUcKcwkkkU6BgeMRCEoOU8bdR2mYQ+lWIABl251ZWMFJ1UAM64wBbcWvDabK1612z8pmS0Z3jy0Ddxa6w2YtO7DgBcxtaO+qrX+bT73G4lEIpFPl7xKFkqpY4AFmJyZd2IkjSuAH+dzv58WOW0W38g46aJ6lTFEpiUMwOUFAj+KkRHaA4t8EM/4acsS64USR9Hl1tXx6uKsER0AlycVzXc/ZSSXazcuyS7Cs1plbUOC/sxy+zsr+zicsTcY0Os/mXHGGdjo61z2BnxupbSr8LrS8xjTaIy0ZRXmWtXXD/K5mFZb0Wykvwdi5+n+lG1/7iDWlZkR6Jh6MyJ9Sp1D373GTLbvDBv4NMlsY9l8ryuXkWZlWTUL681Ji0G3gbNYuNhEQlcusoVxppn/l3CVz+xqY/cmj1nNHJsWdi4t5vq8oFzEuZ5gRorqX01A4DLtc2K5SO5T5rryoRJUJiP1NWNHc1lLUkxpaz2Sfb+0ynArp6tNmpoqI5VKOdWt68w2Bi+q4+5p9vlYbYMb38ZLjU32d7j9Xe5tZnJ/Es/USDqkauwMZm83rsRh5PucE0054J/rZxLt6+d5h4sLFhmX7+/mcig4LwMzMolZZfP9+5YlmW0HJphJKb4lDiYPcJkrXCSu2/0e3elWDY327eVBOycQzyQjwKTKGh5YWJHVdnZvm3VWGx/yMOtsV5UohHyroeqBLcBXtNYtSqnlwDKl1Fit9fl53nfeyOwwvtGZfublvrvNRN7eUXB9Vjrqpra+LqXH3rd6mpkX4tJo/5hvAfBtTOqO1SWT6f7yG6b99237XrA5mXmaYf8EkhlDvZjs1O4uv8qL1Law3Zopl3sVhX22d37Zfv1DDZTUc3rQqxjC2Iq6HcmI7IaabPWTUKlOYJw9NOkwr2CpW56OiA0Nx89U+VQNOxvNiXZPtV/3lK/aN7XMG2RXFCVjPvRF5iVcTtLnvz2mlt7ppiUxoJCOIgeY85h/yVdLLnFgTuqjpe85bf/HIY4HM81PmF5FChzd3NJ+rWmtFfdhCj3NOc9uSxuXrDnTFUwzHy83qPhycC7p+kI34jqH+jH2I34VWVkANtRfQnFZ0sAdFqRaVpU0Zj/UexSwAYCvK1OgKfM/ggaXJrffoB4ljV4wF0illzF5ClEXfezjn36Y/fFNF9JazXhGWp1W09eDmu32EVrOZfbfFazfYe7b6H7GOzCsP145JqlWmrjuPtQMMziorFwFwKTeNT4+5HOUmlzIt4H7e1rryVrrFgCtdR3wVbA+aJFIJBL5XBDLqnZAWhUVioqZaiNZFL1r1UUjiyl6wk7bxHwSNQuBZAHs7m1GoJJa+wVlrI/DekHGenJmrHYrE0gVYmZ7Esj8k5m+54dJcbeOAU6NtPo1nxJc/SB12cRIeF0wbVPnjCp/iA01ST94UYsBzChI1meeXbMArsok5jXo+9205DEStq4KfBxSxWcAnhnq1VbnNKcMz4949dvUaUkXz3sfreShCxMOeFxSu8FN9x2aqoEcxKqE0olIg+mR6KzahW46M8zP/zJJxp0KmVQUbyawravpc5ILb8+4yYkzzbUKI/nTBtmXggSI915d6ffxo9Q+rUE1E7hszq3zz4Hk3RK2rg3uS7YQBY8lT2qc9tJeqGqCZPS1nMtv1QYOBLlW26aVMVglfX71grk+UtqiNgTP9gw7Pcy+q5cD15n3q7Ik+dyuZnxCQgBY8vVrefnn5v0V1ecfVSun2kdnTz/z/N3PFLdOWrLgsXmAeX8yGXNdXpzTm5Xq1dzn28kqqANxnf3U1VBKqR9rrb9tp3/aXjut9TfbWxaJRCKRrsWnLlkopb6ntf5nOz2nvXZa69w5rQ+Az1KyEBISxhGZ5MIP7f/Dg/mBwbd4flKn+xxez99zthm5/MpGg/8dc5iT1se2Qzf7e7Q2ksW1Y8xQsGLdPa4IjD7JDxjUSfZ2WOPgmvk2VXXNeh+8ZX8zm+eSOdG2v8qfe1GrKXvacowZeVX9yej0F7TNoKXwh4nja9D3039jU/Kg+wVRZZvNCE3ShW+qvQB9nDleKWwkEd0AjWVeMgMoXfuGm5461kgFoWQxgOcS7W8LArBCd9Ceqeyqp/P7rMJPW9p8+0kFyRH0CcqP7EXCCCWL6wsSzfnrYHDu7gk+7bYgo/GaG3xW1/BZeuPLyVxFe/7DS1w/sJJqKFmMtPYL4Wr8/ao/d1BiGdfhnwmJBm8CnjcHL6NlgKVzJiRWlYwFqxnvsrZefr/R82emwFySpYf1c774UeYs+2slh22/z5YsYA56rdGgq33ifh0sfoRstpvrsbHESE5hGeC0G7sUhwIobTTPxu9POYxT7Wu555akY8lxjUEut1N82YJMJpmBOpfDTGdLFEKnSBbSUdjpT9whRCKRSKTrkHebhVJqBDARE4y3C/iZ1jo7Sf1B0BmShZBTwggli6fnpdbYR05mZXLPr/bz9eigr02FMc4LnHRulJQBF2TCmUmG+WVr9G8Si8apr8GZdvnz5jcZkBgIiEekBiD23Itar86SLACfmuG8THL+6zfCicYFZ4Q2YtgmtR3dYLNw9rf7rMvAALNuo04q5EvVP5k6GuByU+m1c1Fj5yTalypj3KnQx1Ojkj7F/fWFzuMmPI5R+isAbFC/decH0FIYZkX1um6RBufaa6VPnYv6g5luKTDLitraFbQTiITh9NszMrDAnF+x1d7uDjS8+kx7zZ6fwx+1ef6OU8alSr9ql500h63aDLllpC45l8DnXXLS8dPzYLh1y3ra+lyfOSzxfJhf/z700SZTq9TomKhPcuegl9rjmDIHrIeRO/5AslBn+esHuGuYJJj3s9TzmA5QFXab496of5mYXa7+IfgvsDy9lLTX6RXZvkDqso/9P6ekn/033VSua9VVJArhQCSLfOeGuh7z2VoK7AROAqYA/6K1Xri/dfdHZ3YW0FFFPVEOtdNJpJFOozpz0Mdxu/1A3ciBfYQinwbnBdNPttvq8083/DMculV8vpHOItlJ7Acb+8Ipc9FzbQc2Z07WsgOlq3USQqeooVJUAiO01s/LDKXUMuDfcZ7RkUgkEunq5FuyaAZKtdatwbxuwEta60+coryzJQshncvlQGp4S/v22u5v2Z9DwuU3D9v/S+LPuQfhs3Cwz8X+tvVZrnsoka/3TbZtfrt2zifoGllnM0CNUupUpVQ3pdRpmFQfc5RSh8lfno8hEolEIn8m+VZDiUVyIialpvRel9llys4/PM/HkRfSI4Vco5T2RhP7G3UcyKgw3FeubXW0bnvtc42Mc2+j/fYHO5La33EcLB0d94EcR3Je+h4fvJHyYI8nHy6WB3sv/tztyLYO5Fnb33F09Gzmfn8Otv2f97611z7X9OeZfKuh+hxIO631zo5bebqKGurT4PMgokYOPf6czj/y+aPTDNw2YeB64Amt9Z6O2kcikUika5MXyUIpNREYDfw90IjpONZrrZ/b74oHyF+SZBGJRCKdTacZuLXWK7XWk4GewPVAAfBvSqnXlVJLlFKXKKW+kI99RyKRSOTTJ9+V8rTW+tda61u01gOBc4BajMG7USkbWhuJRCKRLk2+vaESaK3fxERzL1VKHQ706GCVSCQSiXQB8mXgXoqtPq+1vjJXG631R8D/y8f+I5FIJPLpki/J4uk8bTcSiUQinUBeOgut9U/ysd1IJBKJdA4x1UYkEolEOiR2FpFIJBLpkNhZRCKRSKRDYmcRiUQikQ7JW2ehlDpJKXWxTUueXjYxX/uNRCKRyKdPXjoLpdRI4HlMPYs6pdS9NghP+FHOFSORSCTSJcmXZHErMFFrXQacDJwKrFVKHWmXx1zHkUgk8jkiX53FKVrrx8Gl+BgFvAusV0odlad9RiKRSCRP5KuzeEcp1Vv+0Vp/iEke+CrwJJ/TyniRSCRyqJKvzuJJYEo4w2agvRL4LVCYp/1GIpFIJA/kKzfUNe1tW2t9tVLqtjztNxKJRCJ5IF+5oT4APtjP8lfzsd9IJBKJ5IcYlBeJRCKRDomdRSQSiUQ6JHYWkUgkEumQ2FlEIpFIpENiZxGJRCKRDlFa684+hkgkEol0caJkEYlEIpEOiZ1FJBKJRDokdhaRSCQS6ZDYWUQikUikQ2JnEYlEIpEOiZ1F5JBGKdVNKfW/lVKHK6U+UkrV2b9Hgzb3K6VeCZYNOIDtzldK7VBK/VYp9bBSqrudf6RSaqlS6j+UUvVKqeHtrD9AKbXN7m+7Uuprdv4FSqm5n9LpRyIHTHSdjRzSKKWmAUdorf9VKfWu1vqYHG3uBx7TWq8+iO3+A7BJa/2hUmoegNZ6pt3fQK31FKXUCcAG4Kta649T6/8SuFNrvUEpNRr4rtZ6uFJKAc8CQ7XW73/C045EDpooWUQOdS4D1n7aG9Va/9IW/QLYBpxop88ANto2bwF7gYG5NgH8tZ0uAnbZdTTwNHDBp33Mkcj+iJ1F5JDF1oT/kta6yc4qtCqfbUqpi1LNb7UqpTuVUgUHuasrMRIEQD0wVil1hFLqZOAcoHeOda4D5iulXgMWAN8Llm0H/u4gjyES+bOInUXkUOZ4zMheOElrPRCYBNyllCq1878H9AO+CvQAZh7oDpRSNwMfAivsrPuA1zEf/LuALXZ5mqnAd7TWvYHvADXBsreAXgd6DJHIp0HsLCKHMvsISvxqrUXV8zJG1XOW/f8NWxa4DVgKfC29IWu0rlNKrQ/m/SNGXXSZVR+htf5Qa/0drfUArfVYoDvwhxzH9o/AQ3b6wdQ+C+2xRyKfGbGziByyaK3fAQ5XShUqpY4V9ZJS6nhgKPCC/b+n/VXARcDz9v+vKaV+arc1xXYAo+2ykRgJ5MLQEK2UOkopdbSd/nvgQ631CzkObxfwP+z0CJIdymlyDJHIZ0W+anBHIp8XfgkMA94HfqSU+hgziLo9+IivUEr9DaCAOuBqO/8k2h/h3wMUAP9u+hi2aa2vBk4AfmH30wxMlhWUUkuAH2qttwPfAv5VKXUE0Ap8O9j2uSRtGJFI3omus5FDGqXUWcD1WuvJHTbOXnc+sExr/dtP/8ja3ecXgQe01uWf1T4jEYidRSSCUupK4Cda6486+1g6Qin1VeBPWuu6zj6WyKFF7CwikUgk0iHRwB2JRCKRDomdRSQSiUQ6JHYWkUgkEumQ2FlEIpFIpENiZxGJRCKRDomdRSQSiUQ6JHYWkUgkEumQ2FlEIpFIpENiZxGJRCKRDomdRSQSiUQ6JHYWkUgkEumQ2FlEIpFIpENiZxGJRCKRDomdRSQSiUQ6JHYWkUgkEumQ2FlEIpFIpENiDe5DFKVO06bs9GGY0tLpX/azLPwL28vG99OUDjZzoG3Th9fefhPLNKBRh2mUsr9k/4HmMLTdxceJ31zt2/vLtf7BbOeAjkNr1MegTPOO/z621+Nj+3843V7bXOt11Kad7X6sQdvfsMnHqU2md5Ge/hh4A36htR5J5DMhdhaHLO8B/wvohnkMugF/Ffym53XUxnKE/bcQODw1LZsptL8FwWYKOmibbnNEjt9c23bLNBR+wGGHf0hBtw84/IiPKChs4/DDPuJIPuBwPuQI/HQBH3A4H3EkbYn5B9fmIwpoy9Hmo8T6B9cm2MdHH3D4hx9S0PYxh38Iqg34EJDfcLq93/0tawU+amde+nd/y1rt8o9gXyv8yf5+iBmufAjsA/6Umg5/P0xN7wMycDyRz4yohopEIpFIh8TOIhKJRCIdEjuLSCQSiXRI7CwikUgk0iGxs4hEIpFIhyitdcetIn9xKKWex/ipRCKfVwq11md29kEcKkTX2UOXVq31wM4+iEjkk6KU2t7Zx3AoEdVQkUgkEumQ2FlEIpFIpENiZ3Ho8uPOPoBI5M8kPsOfIdHAHYlEIpEOiZJFJBKJRDokdhaRSCQS6ZDYWRxiKKVGKqVeVEq9pJS6sbOPJxJpD6XUfUqpt2xMkMzroZT6d6XUH+zvsXa+Ukr9wD7Xv1VKnd15R/6XSewsDiGUUocDi4BRwBnARKXUGZ17VJFIu9wPpOtV3Ahs1FqfCmy0/4N5pk+1f98GFn9Gx3jIEDuLQ4uvAS9prV/WWn8A/AwY28nHFInkRGv9f4A9qdljgZ/Y6Z8AFwXzf6oN24DuSqmen82RHhrEzuLQogR4Lfj/dTsvEvm88EWt9RsA9vcEOz8+23kmdhaHFirHvOg7HflLID7beSZ2FocWrwO9g/9PBHZ10rFEIp+EN0W9ZH/fsvPjs51nYmdxaPF/gVOVUicrpY4EvgE82snHFIkcDI8C/2in/xFYG8z/pvWKGgS0iLoq8ukQs84eQmitP1RKTQd+ARwO3Ke1/l0nH1YkkhOl1EpgOHC8Uup1YA5wO/BzpVQF8CpwqW2+HhgNvAS8D0z5zA/4L5yY7iMSiUQiHRLVUJFIJBLpkNhZRCKRSKRDYmcRiUQikQ6JnUUkEolEOiR2FpFIJBLpkNhZRCKRSKRDYmcRiUQikQ75/6fOW3qZBHzhAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "plt.set_cmap('jet') #color-blind people should comment this line\n", + "\n", + "for f in filters:\n", + " flag=\"psFlux_flag_\"+f\n", + " dff=df.select(flag,\"ipix\").filter((df[flag]==True) & (df['psFlux_{}'.format(f)]>0)).na.drop()\n", + " dff_map=dff.groupBy(\"ipix\").count()\n", + " map_p=dff_map.toPandas()\n", + " print(f,map_p['count'].mean(),map_p['count'].std())\n", + " map_c = np.zeros(hp.nside2npix(nside))\n", + " map_c[map_p['ipix'].values]=map_p['count'].values\n", + " map_c[map_c==0]=hp.UNSEEN\n", + " map_c[pixborder]=-1\n", + " hp.gnomview(map_c,rot=[55,-29.8],reso=2,title=\"filter=\"+f,min=0,max=100);" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "desc-pyspark", + "language": "python", + "name": "desc-pyspark" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Notebooks/Number_density_Run1.2.ipynb b/Notebooks/Number_density_Run1.2.ipynb new file mode 100644 index 0000000..1a2b8a2 --- /dev/null +++ b/Notebooks/Number_density_Run1.2.ipynb @@ -0,0 +1,352 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DC2 Run1.2 object catalog number density\n", + "
Kernel: **desc-pyspark**\n", + "
Owner: **S Plaszczynski** (https://github.com/LSSTDESC/DC2-production/issues/299)\n", + "
Last Verified to Run: **2018-12-04**\n", + " \n", + "The goal of this notebook is to compare the obseved galactic number density to the expected one.\n", + "The latter is provided by Rachel's formula N(mag_i" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoYAAAFzCAYAAACjPchOAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAFtdJREFUeJzt3X+w7Hdd3/HXO/cCJRpgxhAQjCSAoUBFdBxmtNVQAUH+UMA6yiBSim2mDuAPHH81A8FirdNmKNYqVEBBAe1AmOlINQ6OXKAUrdYgGLBNSCDBkBAECUkhOZePf5zv5e49v+75sbvfX4/HzJlzdr+73/1sdvd8n/fz2T2p1loAAOCcvgcAAMAwCEMAAJIIQwAAOsIQAIAkwhAAgI4wBAAgiTAEJqqq/nlVvXfhdKuqRy5x/8+pqj/cY/u7quqHl3V7C/v9fFU9fNn7BUiEITBAVXVjVd1dVedvOf+aLvAu6mdkp7XW3tRa+84ebvcrW2sfXfftAvMgDIGhuiHJs0+dqKqvT3Lf/oYDMH3CEBiq30ryQwunn5fkjYsXqKr7V9Ubq+pTVfWxqrq8qvb8vVZVF1fVZ09drqpeW1W3LWz/7ar6sYX9v66qbqmqT1TVK6rqWLdt61L1U6rqI1X1d1X1K0lqy+3+i6r6cFV9pqqurqqH7TK+P6iqF2457wNV9azu5y8viVfVfarqP1bVx6vq1qp6dVXdt9t2oqq+t/v5n3TXe3p3+slVdc1e/52AeRKGwFC9P8n9qurRXYx9f5Lf3nKZ/5zk/kkenuTSbIbk8/faaWvthiSfS/KN3VnfluTzVfXo7vS3JznR/fyGJBtJHtld/juTbHvfYLfk/bYklyc5P8n1Sf7xwvZnJPm5JM9K8sAk70nyll2G+OacOVP6mCQPS/KOHS77S0kuSfL4bowPTfLSbtuJJE9cuE8fzeZ/o633EeDLhCEwZKdmDZ+S5CNJPnFqw0Is/mxr7Y7W2o1Jrkzy3H3s90SSS6vqwd3pt3anL05yvyQfqKoHJfmuJD/WWruztXZbklcm+YEd9vf0JNe21t7aWrsnyX9K8smF7Zcl+cXW2odbaxtJ/l2Sx+8ya/j2Lduek+Sq1toXFy9UVZXkXyb58dba37bW7uj2e2p8J3JmCP7iwulLIwyBHRzvewAAe/itJO9OcnG2LCNnc2bu3kk+tnDex7I5a3Y2J5J8d5Kbu/2/K5tB+YUk72mtfakLs3sluWWzwZJs/mP6ph3295DF81trraoWL/ewJK+qqisXzqturIvjT2vtjqp6RzYD75e67/9qh9t8YJJzk/z5wvgqybHu5/+V5JIucB/f3d+Xd7ObT+juN8AZhCEwWK21j1XVDdmckXvBls23J7knm9F1bXfe12ZhVnEPJ5L8h2yG4Ykk703y6myG4amZtJuSfDHJ+d0s315uSXLhqRPdbN6FC9tvSvILrbU37WNsyeYy88uq6t3Z/MDNH+9wmduT/P8kj22tbbvPrbW7qurPk/xokg+11u6uqvcl+Ykk17fWbt/nWIAZsZQMDN0LknxHa+3OxTNbayeT/Lckv1BV53UzfD+R7e9D3Ka19v+yGVU/mOTdrbXPJbk1yfemC8PW2i1J/jDJlVV1v6o6p6oeUVWX7rDLdyR5bFU9q6qOJ3lxkgcvbH91kp+tqscmX/5Qy/ftMcT/kc3g/fkkv9ta+9IO9+FLSX49ySur6oJuvw+tqqcuXOxEkhfmdOy+a8tpgDMIQ2DQWmvXt9b+bJfNL0pyZzY/WPHebH5w4/X73PWJJJ9urX184XQl+YuFy/xQNperr03ymWy+F/Grdxjj7Um+L8m/T/LpJF+X5H8ubH97NpeFf6eqPpfkQ9l8/+KOuvcTXpXkyd192s1PJ7kuyfu7/b4zyaO23MfzcnrZeOtpgDNUa63vMQAAMABmDAEASCIMAQDoCEMAAJIIQwAAOsIQAIAk4/4D1z5ODQCwXZ39IjsbcxgCM1F1Rd9DGL3Wruh7CMAIjPnvGI524MAmwTc8AhIm4dAzhsIQWBnhNz3CEUZBGAKrJ/Q4KCEJvRCGwPIIQFZNMMJKCUPgcEQgQyEWYWmEIXAmwcdUCUg4K2EIcycEmSuhCNsIQ5gbIQg7E4ogDGFyhB+shnBkBoQhjJ0QhH4IRSZIGMJYCEAYB8HIiAlDGCohCNMgFBkRYQhDIgZh2kQiAycMoQ8CEFgkGBkIYQjrIgaB/RCJ9EgYwiqJQeAoRCJrJgxhWUQgsA5ikRUShnAUYhDok0hkyYQhHIYgBIZEILIkwhDORgQCYyQWOQRhCDsRg8CUiET2SRhCIgSBeRGK7EIYMm+CEJgzgcgWwpD5EYMA24lEIgyZAyEIcHBCcZaEIdMlCAGOTiDOijBkegQhwPIJxFkQhoyfEARYP6E4ScKQ8RKEAP0TiJMiDBkPIQgwfEJx1A4dhucscxRwNqIQYBz8vp4nM4asnF8uAONnBnFULCUzLGIQYLpE4uAJQ4ZBEALMh0AcLO8xpH+iEGBe/N6fHjOGHJpfCABsZRZxEMwYsl6iEICdOD6MmxlDDsQLHoD9MnvYGx8+YXXEIABHJRLXShiyfIIQgGUTiGshDFkOMQjAuojElfHhE45OFAKwTo47w2PGEC9MAHpn9nCpLCVzcIIQgKERiEthKZmDEYUADJHjU7/MGM6MFxwAY2H28NAsJbM7MQjA2InEA7GUzM5EIQBT4Hi2HsJwwryIAJgSx7XVs5Q8MV40AMyF5eVdWUpGFAIwL457y2fGcAK8MACYO7OHZ/Cp5DkShABwJoGYxFLy/IhCANjO8fFozBiOjCc8AOzPjGcPzRjOgSgEgP1z3Dw4YTgSntwAcHCOnwdjKXngPKEBYDlmtLTsU8lTIwgBYDVmEIjeYwgAwNGYMRwQs4QAsF4TnT00Yzh2ohAA1s/x90xmDHvmCQkAwzCh2UMzhmMkCgFgOByXhWFvPPkAYHjmfny2lLxmc3/CAcBYjHhp2VLyGIhCABiPOR63hSEAAEksJa/cHP+1AQBTNKKlZUvJAAAcjTBcIbOFADAdcziuW0pegTk8cQBgzga+rGwpGQCAozFjuERmCgFgXgY6c2jGsG+iEADmZ2rHf2G4BFN7UgAA+zelDhCGRzSlJwMAcDhT6QFheARTeRIAAEc3hS4Qhoc0hQcfAFiusfeBMDyEsT/oAMDqjLkThOEBjfnBBgDWY6y9IAwPYKwPMgCwfmPsBmG4T2N8cAGAfo2tH4ThPoztQQUAhmNMHSEMz2JMDyYAMExj6QlhuIexPIgAwPCNoSuEIQAASZJqrfU9hsNa2cDHUPQAwHi1dsUqd1+HvaIZQwAAkgjDbcwWAgCrNtTeEIYLhvogAQDTM8TuEIadIT44AMC0Da0/hGGG96AAAPMxpA4RhgAAJBGGg6p0AGCehtIjsw7DoTwIAABD6JJZhyEAAKfNNgyHUOUAAIv67pNZhmHf/9EBAHbTZ6fMMgwBANhudmFothAAGLq+emVWYSgKAYCx6KNbZhOGohAAGJt198tswhAAgL0JQwAAkswkDC0jAwBjtc6OmXwYikIAYOzW1TOTD0MAAPZHGAIAkGTiYWgZGQCYinV0zaTDEACA/ZtsGJotBACmZtV9M8kwFIUAwFStsnMmGYYAABycMAQAIMkEw9AyMgAwdavqncmFIQAAhzOpMDRbCADMxSq6Z1JhCADA4QlDAACSTCgMLSMDAHOz7P6ZTBgCAHA0whAAgCTCEACAziTC0PsLAYC5WmYHTSIMAQA4OmEIAECSCYShZWQAYO6W1UOjD0MAAJZDGAIAkGTkYWgZGQBg0zK6aNRhCADA8ghDAACSCEMAADrCEACAJMIQAICOMAQAIIkwBACgIwwBAEgiDAEA6AhDAACSCEMAADrCEACAJMIQAICOMAQAIIkwBACgIwwBAEgiDAEA6AhDAACSCEMAADrCEACAJMIQAICOMAQAIIkwBACgIwwBAEgiDAEA6AhDAACSCEMAADrCEACAJCMPw9au6HsIAACDsIwuGnUYAgCwPMIQAIAkEwhDy8kAwNwtq4dGH4YAACyHMAQAIMlEwtByMgAwV8vsoEmEIQAARycMAQBIIgwBAOhMJgy9zxAAmJtl989kwhAAgKMRhgAAJJlYGFpOBgDmYhXdM6kwBADg8CYXhmYNAYCpW1XvTC4MAQA4HGEIAECSiYah5WQAYKpW2TmTDMNEHAIA07PqvplsGAIAcDCTDkOzhgDAVKyjayYdhgAA7J8wBAAgyQzC0HIyADB26+qZyYdhIg4BgPFaZ8fMIgwBADg7YQgAQJIZhaHlZABgbNbdL7MJw0QcAgDj0Ue3zCoME3EIAAxfX70yuzAEAGBnswxDs4YAwFD12SmzDMNEHAIAw9N3n8w2DAEAONOsw7DvKgcAOGUIXTLrMEyG8SAAAPM2lB6ZfRgCALBJGGY4lQ4AzM+QOqRaa32P4bCWPvCqK5a9SxiM9uyX58Sbn5Br8+j867e8IXVJS7ug8nsXfkfOz6fzLU+5JnnnFX0PE2BWVhSFdegrCsMziUOm6m3tT3NjLkqS/E0ekj/OE/PP8rb83J+8Mrkmed5lv5Y31K39DhJgRlY4U3joMLSUvMWQpnNhmV6Ty/LUXJ2X/NGvJknOy+fzy3lR7v/4T+Zhl30kn80D8p68vOdRAszDUHtDGMJMXP3UZ+QdeXpufNIFeVT+Oide97Q8Lh/MK+5zeV6Ry/PBPC6PPtb3KAHok6XkPVhWZkpe0o7nyhOX5wcv/fU8JtfmQbk1N+Si3J375O7cO0lyXR6Z36u/6nmkANO1pplCS8nA3q6sjbz50mfk3NyV83N73p5n5kG5LdfnEXlnnpxfvvXFec8Xvy3tvZaTAeZKGO5hqOv/cFhPzh/l+fmNXJdH5rN5QF505WtzLCdzV87NVQ96Vp57nzcmt/U9SoBpGkNXCMOzGMODCPt1wZV35H351tyR83JZXpNrXnJJ7pu78vX5y9yde+emXJgnPvP3+x4mwOSMpSe8x3CfvN+QqfjT9ra8JpflEbk+78yTcksekrtybr4/v5vzcke+KrfnR+qivocJMBk9RKG/Y7gO4pApaM98eT511Vfmga/5fD73w/fKq49dlhff+St53lf8Zl6VH82Db/i71MNf1vcwASahp5lCYbgu4hAA2I8el499KnldxvIeAQCgP2PtBWF4CGN9sAGA1RtzJwjDQxrzgw4ArMbY+0AYHsHYH3wAYHmm0AXC8Iim8CQAAI5mKj0gDJdgKk8GAODgptQBwnBJpvSkAAD2Z2rHf3/HcAX8rUMAmLaBB6G/YwgAwNGYMVwhM4cAMC0Dnyk8xYzhEI3kyQMA7MMcjuvCEACAJJaS18rSMgCMy0hnCS0lAwBwNMJwjUb6rw4AmKU5HrctJffEsjIADNMEgtBS8thM4EkHAJMz9+OzMOzR3J98ADAkjsuWkgfD0jIA9GOCQWgpeewm+KQEgMFz/D2TGcOBMoMIAKsxgxg0YwgAwNGYMRw4M4cAsBwzmCk85dAzhsJwJAQiABzOjILwFEvJUzfDJzUAHJnj58EIwxHx5AaA/XPcPDhLySNlaRkAdiYILSXPjic9AGzn+Hg0ZgwnwOwhAHMnCM/gU8kIRADmRxDuyFIyXhwAzIvj3vKZMZwwM4gATI0Y3BczhmznxQPAlDiurZ4wnDgvIgCmwPFsPSwlz4zlZQDGQgwemk8lczACEYChEoRH5j2GHIwXHQBD5PjULzOGmD0EoHeCcKksJXN0AhGAdROEK2EpmaPz4gRgnRx3hseMIbsygwjAsonBtbCUzOoIRACOShCulTBkPUQiAPslBnsjDFkvgQjAbgRh73z4hPXyogdgJ44P42bGkKUxiwgwP0JwkMwY0j+/HADmxe/96TFjyEqYPQSYLkE4eD58wnCJRIDxE4OjIgwZB5EIMB5icLS8x5Bx8EsGYBz8vp4nM4b0ziwiQP+E4KRYSmb8BCLA+gnCSRKGTI9QBFg+ITgLwpDpEogARycIZ0UYMn0CEeDgBOEsCUPmRygCbCcEiTBk7kQiMGdikC2EISQCEZgXQcguhCHsRCgCUyIE2SdhCGcjEoExEoMcgjCEwxCLwJCIQJZEGMJRCESgT4KQJROGsCwiEVgHMcgKCUNYJbEIHIUIZM2EIayLSAT2QwzSI2EIfRCJwCIxyEAIQxgSwQjTJgAZOGEIQyUSYRrEICMiDGEshCKMgxBkxIQhjJ1ghH4IQCZIGMLUCEVYDSHIDAhDmBvhCDsTfiAMYfaEInMlBGEbYQicSSgyVUIQzkoYAocjIBkKwQdLIwyB5RGLrJoIhJUShsDqCUYOSgBCL4QhMDxCcnqEHoyCMATGRzgOj/CDSRCGwHQJyKMTfDArwhAAgCRHCMPjyxzFmh36TgMAsN05fQ8AAIBhEIYAACQRhgAAdIQhAABJhCEAAB1hCABAEmEIAEBHGAIAkEQYAgDQEYYAACQRhgAAdIQhAABJhCEAAB1hCABAEmEIAEBHGAIAkEQYAgDQEYYAACRJjvc9AOhT1SUtuTNJ7fGVA57eum0/27cO7IA3vdNN7HXTu11vmfvf7Tp7/ty6023zrO50VTv986ltC9/PPK8t7Hq3y+y+7dTPB922yn1v3W/Sdr1/Z913a6nuP1Od3l2y+PNO5+22fT/XW/W+T9+9va+7j323JK0tfO2y6512s9t5B7nuLcnVrbWnBXoiDJm5O5P8SJJ7ZfPlsNP3LPx8tu07fc9ZrrugkhzbctXjW85bPJ0dzls8nV2ud+p09tj34u3vdt3jW752u+5Ol9m2vSXHTybHT+acYxubm+91MseOn/rayPHjJ3PsnJPdsE92Xxs5/uWfN09v7nrxvDMvd/r62697PFv3v/1ym9u3Xne3297puvu97e23sfNt72PcJ7vtGxs5fvJLObaRHNtI6mSSje4r3ffF8w66ffH04vZl7HsNt33PRrKxkdxzsvu+cXrzPd3Xxpbv2eG8xcvvtX3rtiuS8wM9spQMAEASYQgAQEcYAgCQRBgCANARhgAAJBGGAAB0hCEAAEmEIQAAHWEIAEASYQgAQKdaa2e/FExUVX0oyRf6HgdA5x+01v5R34Ngvvy/kpm7L7TWvrnvQQAkSVX9Wd9jYN4sJQMAkEQYAgDQEYbM3X/tewAAC/xOolc+fAIAQBIzhgAAdIQhAABJhCEzVVVPq6q/rqrrqupn+h4PMF1V9fqquq37u6lbt/1kVbWqOr87/Zyq+svu631V9Q0Ll31AVb21qj5SVR+uqm9Z5/1gHoQhs1NVx5L8lyTfleQxSZ5dVY/pd1TAhP1mkqdtPbOqLkzylCQfXzj7hiSXttYel+Tf5swPo7wqyR+01v5hkm9I8uFVDZj5EobM0ROSXNda+2hr7e4kv5Pke3oeEzBRrbV3J/nbHTa9MslPJWkLl31fa+0z3cn3J/maJKmq+yX59iSv6y53d2vts6scN/MkDJmjhya5aeH0zd15AGtRVd+d5BOttQ/scbEXJPn97ueHJ/lUkt+oqr+oqtdW1VesepzMjzBkjmqH8/zdJmAtqurcJP8myUv3uMw/zWYY/nR31vEk35Tk11pr35jkziTeH83SCUPm6OYkFy6c/pokf9PTWID5eUSSi5N8oKpuzObvoP9TVQ9Okqp6XJLXJvme1tqnu+vcnOTm1tqfdKffms1QhKUShszR/07ydVV1cVXdO8kPJPnvPY8JmInW2gdbaxe01i5qrV2Uzej7ptbaJ6vqa5NcleS5rbX/u3CdTya5qaoe1Z31pCTXrnvsTN/xvgcA69Za26iqFya5OsmxJK9vrf1Vz8MCJqqq3pLkiUnOr6qbk7ystfa6XS7+0iRfleRXqypJNlpr39xte1GSN3X/oP1okuevdODMkv8lHgAASSwlAwDQEYYAACQRhgAAdIQhAABJhCEAAB1hCABAEmEIAEDn7wEkwOnfpg8gMAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "plt.set_cmap('jet') #color-blind people should comment this line\n", + "\n", + "hp.mollview(map_c)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "compute the sky fraction and area" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fraction of the sksy=0.0007590055465698242 total area=31.31125581264496 deg^2\n" + ] + } + ], + "source": [ + "frac=np.sum(map_c!=0)/hp.nside2npix(nside)\n", + "A=frac*41253\n", + "print(\"fraction of the sksy={} total area={} deg^2\".format(frac,A))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "so that the expected Nnumber for ilim=24 is" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1968171.6800939688\n" + ] + } + ], + "source": [ + "Nexp=40*10**(-0.36)*A*3600\n", + "print(Nexp)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Catalog analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "histograms with spark" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from pyspark.sql.types import IntegerType\n", + "from pyspark.sql import functions as F\n", + "\n", + "def minmax(df,col):\n", + " return df.select(F.min(col),F.max(col)).first()\n", + "\n", + "def histo(df,col,Nbins,bounds=None):\n", + " if (bounds==None) :\n", + " m=minmax(df,col)\n", + " zmin=minmax[0]\n", + " zmax=minmax[1]\n", + " else:\n", + " zmin=bounds[0]\n", + " zmax=bounds[1]\n", + " df=df.filter(df[col].between(zmin,zmax))\n", + " \n", + " dz=(zmax-zmin)/Nbins\n", + " zbin=df.select(df[col],((df[col]-zmin-dz/2)/dz).cast(IntegerType()).alias('bin'))\n", + " h=zbin.groupBy(\"bin\").count().orderBy(F.asc(\"bin\"))\n", + " h=h.select(\"bin\",(zmin+dz/2+h['bin']*dz).alias('loc'),\"count\").drop(\"bin\")\n", + " h=h.toPandas()\n", + " step=(zmax-zmin)/Nbins\n", + " plt.bar(h['loc'].values,h['count'].values,step,color='w',edgecolor='k')\n", + " plt.xlabel(col)\n", + " return h" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "quality cuts" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "df24=df.filter((df.mag_i_cModel<24) & (df.good==True) & (df.extendedness>0.9))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "N(mag_i)<24=985414\n" + ] + } + ], + "source": [ + "N=df24.count()\n", + "print(\"N(mag_i)<24={}\".format(N))" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "h=histo(df24,'snr_i_cModel',50,bounds=(0,100))" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAELCAYAAAAybErdAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAGRRJREFUeJzt3X+w5XV93/HnKyAoJsgiF0rZtZfE1Yi2QbiBzWCNAQMLybh0KhloJqyUmZ2ipuo0VYwzJZG01diRylSZoUJdHCoSf4RtBrJuVzQ1BeTycwWku/5YuYHAmkXE0sCg7/5xPleO+z33x969e8/de5+PmTPne97fz/d7Puc7u+d1P9/v93y/qSokSer3c8PugCRp8TEcJEkdhoMkqcNwkCR1GA6SpA7DQZLUYThIkjoMB0lSh+EgSeo4eNgdmKujjjqqRkdHh90NSTpg3HXXXd+vqpHZtD1gw2F0dJTx8fFhd0OSDhhJds62rbuVJEkdhoMkqcNwkCR1GA6SpA7DQZLUYThIkjoMB0lSh+EgSeowHCRJHYaDJA3R6OgoSTqPYV8e6IC9fIYkLQU7d+6kqjr1JEPozQscOUiSOgwHSVKH4SBJ6jAcJEkdhoMkqcNwkCR1GA6SpA7DQZLUYThIkjpmDIckr05yb9/jh0neneTIJFuSbG/PK1r7JLkyyY4k9yc5qW9d61v77UnW99VPTrKtLXNlhv3TQEla5mYMh6p6uKpOrKoTgZOBZ4AvApcCW6tqNbC1vQY4G1jdHhuAqwCSHAlcBpwKnAJcNhkorc2GvuXWzsunkyTNyd7uVjoD+FZV7QTWARtbfSNwbpteB1xXPbcDRyQ5FjgL2FJVu6vqSWALsLbNO7yqbqveBUau61uXJGkI9jYczgc+06aPqarHANrz0a1+HPBI3zITrTZdfWJAXZI0JLMOhySHAG8B/mympgNqNYf6oD5sSDKeZHzXrl0zdEOSNFd7M3I4G7i7qh5vrx9vu4Roz0+0+gSwqm+5lcCjM9RXDqh3VNXVVTVWVWMjIyN70XVJ0t7Ym3C4gBd2KQFsAibPOFoP3NRXv7CdtbQGeKrtdtoMnJlkRTsQfSawuc17OsmadpbShX3rkiQNwazCIclhwG8CX+grfwj4zSTb27wPtfrNwLeBHcB/Bd4OUFW7gcuBO9vjg60GcAnwybbMt4Bb5v6RJGnxmeqOb4tVBt2B6EAwNjZW4+Pjw+6GJM1Kkinv+LY39X3sw11VNTabtv5CWpLUYThIkjoMB0lSh+EgSeowHCRJHYaDJKnDcJAkdRgOkqQOw0GS1GE4SJI6DAdJUofhIEnqMBwkSR2GgyTNowPt0txTOXjYHZCkpWTnzp1TXoL7QOLIQZLUYThIkjoMB0lSh+EgSeqYVTgkOSLJ55J8M8lDSX4tyZFJtiTZ3p5XtLZJcmWSHUnuT3JS33rWt/bbk6zvq5+cZFtb5socaEduJGmJme3I4WPAX1bVLwO/AjwEXApsrarVwNb2GuBsYHV7bACuAkhyJHAZcCpwCnDZZKC0Nhv6llu7bx9LkrQvZgyHJIcDbwSuAaiq56rqB8A6YGNrthE4t02vA66rntuBI5IcC5wFbKmq3VX1JLAFWNvmHV5Vt1Xv/K/r+tYlSRqC2YwcfhHYBfy3JPck+WSSlwLHVNVjAO356Nb+OOCRvuUnWm26+sSAuiRpSGYTDgcDJwFXVdXrgf/LC7uQBhl0vKDmUO+uONmQZDzJ+K5du6bvtSRpzmYTDhPARFXd0V5/jl5YPN52CdGen+hrv6pv+ZXAozPUVw6od1TV1VU1VlVjIyMjs+i6JGkuZgyHqvpb4JEkr26lM4AHgU3A5BlH64Gb2vQm4MJ21tIa4Km222kzcGaSFe1A9JnA5jbv6SRr2llKF/atS5IWpaVyDaWpzPbaSr8PXJ/kEODbwEX0guXGJBcD3wPOa21vBs4BdgDPtLZU1e4klwN3tnYfrKrdbfoS4FPAS4Bb2kOSFq2lcg2lqWTQhzsQjI2N1fj4+LC7IWmZSjJlOOzP+r5IcldVjc2mrb+QliR1GA6SpA7DQZKmsdQPPE/Fm/1I0jSW+oHnqThykCR1GA6SpA7DQZLUYThIkjoMB0lSh+EgSSzfU1an4qmsksTyPWV1Ko4cJC0bU40OlmsATMeRg6RlY6rRASzfEcJUHDlIkjoMB0lLjgeX9527lSQtOR5c3neOHCRJHYaDJKljVuGQ5LtJtiW5N8l4qx2ZZEuS7e15RasnyZVJdiS5P8lJfetZ39pvT7K+r35yW/+OtqxjP0kaor0ZOfxGVZ3Yd//RS4GtVbUa2NpeA5wNrG6PDcBV0AsT4DLgVOAU4LLJQGltNvQtt3bOn0jSsuGB5/1nX3YrrQM2tumNwLl99euq53bgiCTHAmcBW6pqd1U9CWwB1rZ5h1fVbdU7gnRd37okaUqTB573fGjfzTYcCvhSkruSbGi1Y6rqMYD2fHSrHwc80rfsRKtNV58YUJckDclsT2U9raoeTXI0sCXJN6dpO2hMV3Ood1fcC6YNAK94xSum77Ekac5mNXKoqkfb8xPAF+kdM3i87RKiPT/Rmk8Aq/oWXwk8OkN95YD6oH5cXVVjVTU2MjIym65LkuZgxnBI8tIkvzA5DZwJfAPYBEyecbQeuKlNbwIubGctrQGearudNgNnJlnRDkSfCWxu855OsqadpXRh37okSUMwm91KxwBfbGcAHAz896r6yyR3AjcmuRj4HnBea38zcA6wA3gGuAigqnYnuRy4s7X7YFXtbtOXAJ8CXgLc0h6SpCHJgXpkf2xsrMbHx4fdDUkLYHR0lJ07dw6cN9VlMvamPpdlhlXfF0nu6vs5wrS8tpKkRc9rJS08L58hSeowHCRJHYaDJKnDcJAkdRgOkqQOw0HSouFVVhcPT2WVtGh4yuri4chBktRhOEiSOgwHSVKH4SBJ6jAcJEkdhoMkqcNwkLTg/D3D4ufvHCQtOH/PsPg5cpAkdRgOkqQOw0GS1DHrcEhyUJJ7kvxFe318kjuSbE/y2SSHtPqh7fWONn+0bx3vb/WHk5zVV1/bajuSXDp/H0+SNBd7M3J4F/BQ3+sPA1dU1WrgSeDiVr8YeLKqXglc0dqR5ATgfOC1wFrgEy1wDgI+DpwNnABc0NpKkoZkVuGQZCXwW8An2+sApwOfa002Aue26XXtNW3+Ga39OuCGqnq2qr4D7ABOaY8dVfXtqnoOuKG1lSQNyWxHDv8ZeC/wk/b65cAPqur59noCOK5NHwc8AtDmP9Xa/7S+xzJT1TuSbEgynmR8165ds+y6JB14Dj300IG/BRkdHV2Q958xHJL8NvBEVd3VXx7QtGaYt7f1brHq6qoaq6qxkZGRaXotaTHwx25z9+yzz1JVncfOnTsX5P1n8yO404C3JDkHeDFwOL2RxBFJDm6jg5XAo639BLAKmEhyMPAyYHdffVL/MlPVJR3A/LHbgWvGkUNVvb+qVlbVKL0Dyl+uqt8FbgXe2pqtB25q05vaa9r8L1fvX8cm4Px2NtPxwGrg68CdwOp29tMh7T02zcunkyTNyb5cPuN9wA1J/gS4B7im1a8BPp1kB70Rw/kAVfVAkhuBB4HngXdU1Y8BkrwT2AwcBFxbVQ/sQ78kSfsog4Z8B4KxsbEaHx8fdjckTSPJlLuVFlN9MfZpLp9hJknuqqqx2bT1F9KSpA7DQZLUYThIkjoMB0lSh+EgSeowHCRJHYaDJKnDcJC0z7yG0tKzL7+QliTAaygtRY4cJEkdhoMkqcNwkCR1GA6SpA7DQZLUYThIkjoMB0lSh+EgSeowHCTNmr+EXj5mDIckL07y9ST3JXkgyR+3+vFJ7kiyPclnkxzS6oe21zva/NG+db2/1R9OclZffW2r7Uhy6fx/TEnzYfKX0Hs+tPTMZuTwLHB6Vf0KcCKwNska4MPAFVW1GngSuLi1vxh4sqpeCVzR2pHkBOB84LXAWuATSQ5KchDwceBs4ATggtZWkjQkM4ZD9fyovXxRexRwOvC5Vt8InNum17XXtPlnpDfuXAfcUFXPVtV3gB3AKe2xo6q+XVXPATe0tpKkIZnVMYf2F/69wBPAFuBbwA+q6vnWZAI4rk0fBzwC0OY/Bby8v77HMlPVJUlDMqtwqKofV9WJwEp6f+m/ZlCz9jzo6FTNod6RZEOS8STju3btmrnjkqQ52auzlarqB8BXgDXAEUkmL/m9Eni0TU8AqwDa/JcBu/vreywzVX3Q+19dVWNVNTYyMrI3XZck7YXZnK00kuSINv0S4M3AQ8CtwFtbs/XATW16U3tNm//l6p3OsAk4v53NdDywGvg6cCewup39dAi9g9ab5uPDSZLmZjY3+zkW2NjOKvo54Maq+oskDwI3JPkT4B7gmtb+GuDTSXbQGzGcD1BVDyS5EXgQeB54R1X9GCDJO4HNwEHAtVX1wLx9QknSXsuBeo7y2NhYjY+PD7sb0rKSZMo7vh3I9cXYp7l8hpkkuauqxmbT1l9IS5I6DAdJUofhIKnDayhpNgekJS0zk9dQ2pMBsXw4cpAkdRgOkqQOw0GS1GE4SJI6DAdJUofhIEnqMBwkSR2GgySpw3CQljF/Ca2p+AtpaRnzl9CaiiMHSVKH4SBJ6jAcJEkdhoMkqWPGcEiyKsmtSR5K8kCSd7X6kUm2JNnenle0epJcmWRHkvuTnNS3rvWt/fYk6/vqJyfZ1pa5Mh4Nk6Shms3I4Xng31TVa4A1wDuSnABcCmytqtXA1vYa4GxgdXtsAK6CXpgAlwGnAqcAl00GSmuzoW+5tfv+0SRJczVjOFTVY1V1d5t+GngIOA5YB2xszTYC57bpdcB11XM7cESSY4GzgC1VtbuqngS2AGvbvMOr6rbqnVN3Xd+6JElDsFfHHJKMAq8H7gCOqarHoBcgwNGt2XHAI32LTbTadPWJAXVJ0pDMOhyS/DzweeDdVfXD6ZoOqNUc6oP6sCHJeJLxXbt2zdRlSUz9K2gP7Wk6swqHJC+iFwzXV9UXWvnxtkuI9vxEq08Aq/oWXwk8OkN95YB6R1VdXVVjVTU2MjIym65Ly97kr6AHPaSpzOZspQDXAA9V1Uf7Zm0CJs84Wg/c1Fe/sJ21tAZ4qu122gycmWRFOxB9JrC5zXs6yZr2Xhf2rUuSNASzubbSacDvAduS3Ntqfwh8CLgxycXA94Dz2rybgXOAHcAzwEUAVbU7yeXAna3dB6tqd5u+BPgU8BLglvaQJA3JjOFQVV9j8HEBgDMGtC/gHVOs61rg2gH1ceB1M/VFkrQw/IW0JKnDcJAkdRgOkqQOw0GS1GE4SJI6DAdpifB+0JpP3kNaWiK8H7TmkyMHSVKH4SBJ6jAcJEkdhoMkqcNwkCR1GA7SAcZTVrUQPJVVOsB4yqoWgiMHSVKH4SBJ6jAcJEkdhoMkqcNwkCR1zBgOSa5N8kSSb/TVjkyyJcn29ryi1ZPkyiQ7ktyf5KS+Zda39tuTrO+rn5xkW1vmynjKhQR4yqqGazYjh08Ba/eoXQpsrarVwNb2GuBsYHV7bACugl6YAJcBpwKnAJdNBkprs6FvuT3fS1qWJk9Z3fMhLYQZw6Gq/grYvUd5HbCxTW8Ezu2rX1c9twNHJDkWOAvYUlW7q+pJYAuwts07vKpuq96/+uv61iVJGpK5HnM4pqoeA2jPR7f6ccAjfe0mWm26+sSAuiRpiOb7gPSgHaI1h/rglScbkownGd+1a9ccuyhJmslcw+HxtkuI9vxEq08Aq/rarQQenaG+ckB9oKq6uqrGqmpsZGRkjl2XFhcPPGsxmms4bAImzzhaD9zUV7+wnbW0Bniq7XbaDJyZZEU7EH0msLnNezrJmnaW0oV965KWBQ88azGa8cJ7ST4DvAk4KskEvbOOPgTcmORi4HvAea35zcA5wA7gGeAigKraneRy4M7W7oNVNXmQ+xJ6Z0S9BLilPSRJQzRjOFTVBVPMOmNA2wLeMcV6rgWuHVAfB143Uz8kSQvHX0hLkjoMB2mBeOBZBxJv9iMtEG/SowOJIwdJUofhIM0zdx9pKXC3kjTP3H2kpcCRgySpw3CQJHUYDtIceWxBS5nHHKQ58tiCljJHDpKkDsNBmoG7j7QcuVtJmoG7j7QcOXKQGkcI0gscOWjZGR0dZefOnQPnOUKQegwHLTvuJpJm5m4lLVnuJpLmzpGDDmjT7SICdxNJc7VoRg5J1iZ5OMmOJJcOuz9aXKYaBUzuIhr0kDR3iyIckhwEfBw4GzgBuCDJCcPtlfanqb7sX/rSl+5VCEjaPxZFOACnADuq6ttV9RxwA7BuyH1atKb6Yk3C6OjoourT3n7ZP/PMM4aAtAgslmMOxwGP9L2eAE4dUl8Wjb095RLgxS9+8cB96ocddhjPPPPMfqtP1ack7veXDkCLJRwGfVN0vlGSbAA2tJc/SvLwfu3V/ncU8P25LLi3X65TfaHPV326Ps2y/tNtsY/rmc8+DbN+FPD9/f2+87mu/Vw/KsnA/ytui73yj2bbcLGEwwSwqu/1SuDRPRtV1dXA1QvVqf0tyXhVjQ27H4uB2+JnuT1+ltvjBQu1LRbLMYc7gdVJjk9yCHA+sGnIfZKkZWtRjByq6vkk7wQ2AwcB11bVA0PuliQtW4siHACq6mbg5mH3Y4EtmV1k88Bt8bPcHj/L7fGCBdkW8TRBSdKeFssxB0nSImI4LIAk1yZ5Isk39qj/frtkyANJ/nRY/Vtog7ZHkhOT3J7k3iTjSU4ZZh8XSpJVSW5N8lD7d/CuVj8yyZYk29vzimH3dSFMsz0+kuSbSe5P8sUkRwy7rwthqu3RN/8PklSSo+b9vd2ttP8leSPwI+C6qnpdq/0G8AHgt6rq2SRHV9UTw+znQplie3wJuKKqbklyDvDeqnrTELu5IJIcCxxbVXcn+QXgLuBc4G3A7qr6UHrXGltRVe8bYlcXxDTbYyXw5XbyyocBlvP2qKoHk6wCPgn8MnByVc31tw8DOXJYAFX1V8DuPcqXAB+qqmdbm2URDDDl9ijg8Db9Mgb8zmUpqqrHquruNv008BC9KwasAza2ZhvpfUEueVNtj6r6UlU935rdTi8slrxp/n0AXAG8lwE/GJ4PhsPwvAr4p0nuSPLVJL867A4N2buBjyR5BPhPwPuH3J8Fl2QUeD1wB3BMVT0GvS8I4Ojh9Ww49tge/f4lcMtC92fY+rdHkrcAf1NV9+2v9zMchudgYAWwBvi3wI1Z3hccugR4T1WtAt4DXDPk/iyoJD8PfB54d1X9cNj9GbaptkeSDwDPA9cPq2/D0L896H3+DwD/bn++p+EwPBPAF6rn68BP6F1PZ7laD3yhTf8ZvSv1LgtJXkTvP/71VTW5DR5v+5sn9zsvm92OU2wPkqwHfhv43VpGB0sHbI9fAo4H7kvyXXq72O5O8g/m830Nh+H5c+B0gCSvAg5hjhfhWyIeBX69TZ8ObB9iXxZMGy1eAzxUVR/tm7WJXmDSnm9a6L4Nw1TbI8la4H3AW6pq6qs/LjGDtkdVbauqo6tqtKpG6f2heVJV/e28vvcyCuChSfIZ4E30RgaPA5cBnwauBU4EngP+oKq+PKw+LqQptsfDwMfo7W77e+DtVXXXsPq4UJK8AfhfwDZ6o0eAP6S3n/1G4BXA94DzqmrPg/hLzjTb40rgUODvWu32qvpXC9/DhTXV9mhXlJhs811gbL7PVjIcJEkd7laSJHUYDpKkDsNBktRhOEiSOgwHSVKH4SBJ6jAcpDlIcvPeXjY6yR+1yyu/sq/2nlab9Q3jk7wtyX/Z1zbSdAwHaQ6q6pyq+sEcFt0GnN/3+q3Ag/PTK2n+GA5aMpKMthvCfDLJN5Jcn+TNSf663TTnlPb430nuac+vbsseluTGdjOZz7ar5U7513yS7053g5UkF7Z13Zfk032z/pze5bhJ8ovAU8CuvuUuSLKt9f/DffWLkvyfJF8FTuurjyT5fJI72+M0pHlw8LA7IM2zVwLnARuAO4F/AbwBeAu9yzBcCLyx3TTmzcB/AP458Hbgyar6J0leB9w71w4keS29q2aeVlXfT3Jk3+wfAo+091gHfBa4qC33D4EPAycDTwJfSnIuvUtp/HGrPwXcCtzT1vcxejdJ+lqSVwCbgdfMte/SJMNBS813qmobQJIHgK1VVUm2AaP0biS0MclqejdJeVFb7g30vmipqm8kuX8f+nA68LnJa90MuCbSDfR2LZ0FnEELB+BXga9U1a7W/+uBN7Z5/fXP0rsfCMCbgRP6rvZ+eLtjmLRPDActNc/2Tf+k7/VP6P17vxy4tar+Wbt5ylfa/Pm8l0aY/u5c/wP4CDBeVT/s+2Kfrg9Tre/ngF+rqv/3Mx1Y1rcG0XzwmIOWm5cBf9Om39ZX/xrwOwBJTgD+8T68x1bgd5K8vK2vf7cS7Yv8fcC/32O5O4BfT3JUkoOAC4Cvtvqbkry8Xdv/vL5lvgS8c/JFkhP3od/STxkOWm7+FPiPSf4aOKiv/glgpO1Oeh9wP739+3utqh6g98X/1ST3AR8d0OaGyXsD99Ueo3d71FuB+4C7q+qmVv8j4DbgfwL9y/1rYKwd/H4QWPKXsdbC8JLdEtD+Un9RVf19kl+i99f/q6rquSF3TRoKjzlIPYcBt7bdNgEuMRi0nDlykKaR5A56dyDr93tVta0dU9g6YLEzqurvBtSlA4bhIEnq8IC0JKnDcJAkdRgOkqQOw0GS1GE4SJI6/j+AOkGvq/rQKgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "h=histo(df24,'mag_i_cModel',50,bounds=(15,24))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "desc-pyspark", + "language": "python", + "name": "desc-pyspark" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Notebooks/cosmoDC2_pos.ipynb b/Notebooks/cosmoDC2_pos.ipynb new file mode 100644 index 0000000..ce47ea6 --- /dev/null +++ b/Notebooks/cosmoDC2_pos.ipynb @@ -0,0 +1,512 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# CosmoDC2 v1.0: galaxy position(Spark)\n", + "
Kernel: **desc-pyspark**\n", + "
Owner: **S Plaszczynski** (https://github.com/LSSTDESC/DC2-production/issues/299)\n", + "
Last Verified to Run: **2018-12-03**\n", + " \n", + "The goal of this notebook is to study the galaxy positions of the full CosmoDC2 v1 catalog.\n", + "\n", + "It also a good way to learn Spark.\n", + "Note however that notebooks are really not well suited to analyzing the full-DC2 dataset(because of jupyter-dev limitations): **you will get much better\n", + "results running on interactive queues** see : https://github.com/LSSTDESC/desc-spark" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# reading parquet data" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "spark session started\n" + ] + } + ], + "source": [ + "from pyspark.sql import SparkSession\n", + "\n", + "# Initialise our Spark session\n", + "spark = SparkSession.builder.getOrCreate()\n", + "print(\"spark session started\")\n", + "\n", + "#usefull class to benchmark\n", + "from time import time\n", + "class Timer:\n", + " \"\"\"\n", + " a simple class for printing time (s) since last call\n", + " \"\"\"\n", + " def __init__(self):\n", + " self.t0=time()\n", + " \n", + " def start(self):\n", + " self.t0=time()\n", + " \n", + " def stop(self):\n", + " t1=time()\n", + " print(\"{:2.1f}s\".format(t1-self.t0))\n", + "\n", + "timer=Timer()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I created some excerpt of cosmo_DC2_v10 (full) data within a parquet file" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- position_y: float (nullable = true)\n", + " |-- dec: float (nullable = true)\n", + " |-- ra: float (nullable = true)\n", + " |-- redshift_true: float (nullable = true)\n", + " |-- halo_id: long (nullable = true)\n", + " |-- position_x: float (nullable = true)\n", + " |-- position_z: float (nullable = true)\n", + " |-- is_central: boolean (nullable = true)\n", + " |-- redshift: float (nullable = true)\n", + "\n", + "6.4s\n" + ] + } + ], + "source": [ + "timer.start()\n", + "df_all=spark.read.parquet(\"/global/cscratch1/sd/plaszczy/CosmoDC2/xyz_v1.0.parquet\")\n", + "df_all.printSchema()\n", + "timer.stop()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "timer.start()\n", + "df=df_all.select('ra','dec','redshift','redshift_true').cache()\n", + "N=df.count()\n", + "print(N/1e9)\n", + "timer.stop()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "some usfeull tools" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from pyspark.sql.types import IntegerType\n", + "from pyspark.sql import functions as F\n", + "\n", + "def minmax(df,col):\n", + " return df.select(F.min(col),F.max(col)).first()\n", + "\n", + "def df_histo(df,col,Nbins,bounds=None):\n", + " if (bounds==None) :\n", + " m=minmax(df,col)\n", + " zmin=minmax[0]\n", + " zmax=minmax[1]\n", + " else:\n", + " zmin=bounds[0]\n", + " zmax=bounds[1]\n", + " df=df.filter(df[col].between(zmin,zmax))\n", + " \n", + " dz=(zmax-zmin)/Nbins\n", + " zbin=df.select(df[col],((df[col]-zmin-dz/2)/dz).cast(IntegerType()).alias('bin'))\n", + " h=zbin.groupBy(\"bin\").count().orderBy(F.asc(\"bin\"))\n", + " return h.select(\"bin\",(zmin+dz/2+h['bin']*dz).alias('loc'),\"count\").drop(\"bin\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# redshift distribution" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "$z \\in [0.00038306356873363256,3.1929798126220703]$\n", + "18.3s\n" + ] + } + ], + "source": [ + "timer.start()\n", + "m=minmax(df,'redshift')\n", + "print(r\"$z \\in [{},{}]$\".format(m[0],m[1]))\n", + "timer.stop()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "132.1s\n" + ] + } + ], + "source": [ + "timer.start()\n", + "h_z=df_histo(df,'redshift',100,bounds=(0,3)).toPandas()\n", + "h_z0=df_histo(df,'redshift_true',100,bounds=(0,3)).toPandas()\n", + "timer.stop()" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0,0.5,'dN/dz')" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "dz=3./100\n", + "\n", + "plt.bar(h_z['loc'].values,h_z['count'].values,dz,label='redshift',alpha=0.5)\n", + "plt.bar(h_z0['loc'].values,h_z0['count'].values,dz,label='redshift_true',alpha=0.5)\n", + "plt.legend()\n", + "plt.xlabel(\"z\")\n", + "plt.ylabel(\"dN/dz\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# footprint" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "Build a high resolution healpix map and project all galaxies inside" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "timer.start()\n", + "import pandas as pd\n", + "import numpy as np\n", + "import healpy as hp\n", + "from pyspark.sql.functions import pandas_udf, PandasUDFType\n", + "\n", + "nside=2048\n", + "#create the ang2pix user-defined-function. \n", + "#we use pandas_udf because they are more efficient\n", + "@pandas_udf('int', PandasUDFType.SCALAR)\n", + "def Ang2Pix(ra,dec):\n", + " return pd.Series(hp.ang2pix(nside,np.radians(90-dec),np.radians(ra)))\n", + "\n", + "#add a column of healpix indices\n", + "df=df.withColumn(\"ipix\",Ang2Pix(\"ra\",\"dec\"))\n", + "#groupby indices and count the number of elements in each group\n", + "df_map=df.groupBy(\"ipix\").count()\n", + "#statistics per pixel\n", + "df_map.describe(['count']).show() \n", + "\n", + "#back to python world\n", + "map_p=df_map.toPandas()\n", + "\n", + "#now data is reduced create the healpy map\n", + "count_map = np.zeros(hp.nside2npix(nside))\n", + "count_map[map_p['ipix'].values]=map_p['count'].values\n", + "#count_map[counts_map==0]=hp.UNSEEN\n", + "timer.stop()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([1.07300e+03, 3.28000e+02, 1.66000e+02, 1.30000e+02, 7.50000e+01,\n", + " 9.60000e+01, 1.54000e+02, 1.42000e+02, 1.25000e+02, 1.34000e+02,\n", + " 1.24000e+02, 1.34000e+02, 1.06000e+02, 7.70000e+01, 8.50000e+01,\n", + " 1.11000e+02, 1.24000e+02, 1.22000e+02, 1.02000e+02, 8.30000e+01,\n", + " 8.50000e+01, 7.30000e+01, 1.04000e+02, 1.04000e+02, 1.03000e+02,\n", + " 9.00000e+01, 8.80000e+01, 9.50000e+01, 1.16000e+02, 1.08000e+02,\n", + " 1.16000e+02, 1.49000e+02, 5.23000e+02, 4.98200e+03, 3.53130e+04,\n", + " 1.32534e+05, 2.51273e+05, 2.56158e+05, 1.53594e+05, 5.84970e+04,\n", + " 1.67540e+04, 4.15400e+03, 9.72000e+02, 2.49000e+02, 8.10000e+01,\n", + " 2.50000e+01, 1.20000e+01, 3.00000e+00, 0.00000e+00, 3.00000e+00]),\n", + " array([1.00000e+00, 1.14340e+02, 2.27680e+02, 3.41020e+02, 4.54360e+02,\n", + " 5.67700e+02, 6.81040e+02, 7.94380e+02, 9.07720e+02, 1.02106e+03,\n", + " 1.13440e+03, 1.24774e+03, 1.36108e+03, 1.47442e+03, 1.58776e+03,\n", + " 1.70110e+03, 1.81444e+03, 1.92778e+03, 2.04112e+03, 2.15446e+03,\n", + " 2.26780e+03, 2.38114e+03, 2.49448e+03, 2.60782e+03, 2.72116e+03,\n", + " 2.83450e+03, 2.94784e+03, 3.06118e+03, 3.17452e+03, 3.28786e+03,\n", + " 3.40120e+03, 3.51454e+03, 3.62788e+03, 3.74122e+03, 3.85456e+03,\n", + " 3.96790e+03, 4.08124e+03, 4.19458e+03, 4.30792e+03, 4.42126e+03,\n", + " 4.53460e+03, 4.64794e+03, 4.76128e+03, 4.87462e+03, 4.98796e+03,\n", + " 5.10130e+03, 5.21464e+03, 5.32798e+03, 5.44132e+03, 5.55466e+03,\n", + " 5.66800e+03]),\n", + " )" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(count_map[count_map>0],bins=50)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "hp.mollview(count_map)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "where is the center?" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------+-----------------+------------------+\n", + "|summary| ra| dec|\n", + "+-------+-----------------+------------------+\n", + "| count| 3862614101| 3862614101|\n", + "| mean|62.32386776858061|-36.00731936059433|\n", + "| stddev|9.952789220855259| 7.756809170315573|\n", + "| min| 39.382427| -54.337822|\n", + "| max| 84.38016| -19.462912|\n", + "+-------+-----------------+------------------+\n", + "\n" + ] + } + ], + "source": [ + "df.describe(['ra','dec']).show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let us zoom now" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "count_map[count_map==0]=hp.UNSEEN\n", + "hp.gnomview(count_map,rot=[62.3,-36.],reso=hp.nside2resol(nside,arcmin=True),xsize=1500,min=3600,max=5000)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "hp.gnomview(count_map,rot=[62.3,-36.],reso=hp.nside2resol(nside,arcmin=True),xsize=500,min=3600,max=5000)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAGrCAYAAAAxTLu9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsvWewZdl1HvbtE24O776c+vXrnKbDZGA4wAADiBABkCBZkplMV0lyybRUJTHYpH9YJVmmZdGWSUq0SapsFymSEmWKAEUBA4IgiDTAhJ7YObyefjndF28OJ2z/WGvtc2/PAD0gYJNNnlXV9V6/c84+e++zz9krfOtbSmuNWGKJJZZYYvlmYv15dyCWWGKJJZa/+BJvFrHEEksssdxX4s0illhiiSWW+0q8WcQSSyyxxHJfiTeLWGKJJZZY7ivxZhFLLLHEEst9Jd4sYonl/0dRSs0opepKKfs72Ob7lFK3vlPtxRLLO4mK8yxieVBEKfXDAH4KwEMAGgDmAfwbAL+m44UcSyz/n0psWcTyQIhS6mcA/EsA/yuAcQBjAH4CwHcBSPw5di2WWP5KSLxZxPIXXpRSRQD/FMDf01r/vta6pkne0Fr/mNa6w+f9plLq/1BKPaeUqimlXlZKHelp5yml1CtKqQr/fKrn2JeVUj+vlHqB3USfVkoNKaX+rVKqyufPfgtt/Y9Kqa9zPz6vlBrmY7NKKa2Ucvj/g0qp31BKrSml9pRS//Edxp9USu0rpR7q+duIUqqllBpVSn1AKbXSc2xSKfVJpdSWUmpeKfUP+O8pvkb68t8rpXylVIH///NKqV/+dp9XLH85Jd4sYnkQ5L0AkgD+8F2c+yMA/gcAJQB3APxPAH2UATwH4F8BGALwiwCeU0oN9Vz7wwB+HMAUgCMAXgTwGwAGAdwA8I+/hbZ+FMDfAjAKsnz+m2/Q398GkAFwhs/9pXtP4M3wUzw2kf8MwFe01uXec5VSFoBPA7jE4/gQgJ9USn1Ea90G8AqAZ/j09wNYBFln8v+vfIN+xvJXXOLNIpYHQYYBbGutffkDWwD7rCm/v+fcT2mtL/K5/xbABf77xwDMaa1/W2vta61/F8BNAN/bc+1vaK3f0lpXAPwRgLe01l/gtv4DgIe/xbZua61bAH6vpx9GlFITAL4HwE9orfe01p7W+ht9rP8d+jeLH+W/3SuPAxjRWv9TrXVXa30XwP8J2ggB2gyeYcvmHGjDe0YpleJrn/8G94/lr7g4f94diCWWdyE7AIaVUo5sGFrrpwCA3S+9Ss9Gz+9NADn+fRKkRffKIkj7Ftns+b31Dv//Vtr6Rv3olQMAdrXWe+9w7F75IoC0UupJbvsCgD94h/MOAphUSu33/M1GtAl8BWQJPQLgCoA/AfB/A3gPgDta6+130ZdY/gpKbFnE8iDIiwA6AD7xbbSxBvqQ9soMgNU/x7aWAQwqpQbud6LWOgRZKD8Csio+o7WufYM257XWAz3/8lrrj/LxFwCcAPADIDfWde77xxC7oGL5JhJvFrH8hRet9T4oDvGrSqm/oZTKKaUspdQFANl32cxnARxXSv2oUspRSv0QgNMAPvNn6NJ3pC2t9TrI3fWrSqmSUsq9x6V2r/w7AD8E4Mfwzi4oALgIoKqU+jmlVFopZSulHlJKPc73bAJ4DcDfR7Q5vADgv0K8WcTyTSTeLGJ5IERr/b8A+GkAPwugDHIR/WsAPwf62N3v+h0AHwfwMyC31s8C+Pifxe3ynWwLFFD3QDGPMoCf/Cb3fRmUXzIJ2mTe6ZwAFDu5AMpD2QbwfwEo9pz2FQAuaGOR/+cBfPXP0P9Y/opInJQXSyyxxBLLfSW2LGKJJZZYYrmvxJtFLLHEEkss95V4s4glllhiieW+Em8WscQSSyyx3FceyKS82V/9FyYqb3VU3zG7Sf9P7iu0h+g0f7pDB6sunCrtj14pAADk7jrIrocAgMYkHdPcZGssRPEo5Us13yAmh+6hNrDv0nkuta+6dJ3TVHAadLHFucbtkRBBltpXPvdty0bqHtxM5TT1R3UUBm7SeZXj1H5m3UL9fJvu2SJmazvvwXHoGsui8379kd8BAPztT/0EsivUp6lPLAAA5r80C8vjOeOfQYrnrBP9LmP3sxrapnZzi5Y5v1vU5jhdSxe4VYXUDv2tPUh/8zMaiRr9Xj9KN83dcfkcDSuAOQ8AtKON+jJxZAsAsHNxzNxL5m/kdf5/GIEzqodoXjoDGqmd/jXRHqHzCm8BrZH+5wMA3bzMMx0butE2x2rTSTqnSMeCJOCn+ppHogrkV2gwKx8PogMBXTMwRukQ1XlKp7DHm+aUQyO7ND9eAlv7/Xl7iTfo/3YbCKkbcGvRmLsFaj9Rob/tnw3NseQmzUd+kY5VjgL6nrfd8gDNROlutX/O3AaQ3qL2rIDacFohOgW6IFGnY+tP2Sjc7e9PZ4Dnc1OZ/laO0jn+bBt6n3gfFc+PPdain04Ib5GQ0OEwrZeh4Rq6Pt0z+7tFc5/6Ab7nII+5QOe7y0moY3Xq95U8AMDLamTX6F7Vo/R8kjs8jirg8bR3uK3cooX6DP0u75F2gOZkNL8AULhNx/Yf6yJ/rZ/LsjWmkdyle2bWaQ52P9JCJkPfotoG9S05SGPXt3MYfoxyQDe2aJxnZtYR8gtZ79ICWL42TucnNJJbNAbnPOVftueKCMaofXudzg+yIVCkuUnfpIXr5XgNWUDI37C7P/Uz/QvgHSS2LGKJJZZYYrmvPJDQ2dlfI8vCaiskt2m/S3Aua3uQfroN2t0BILVNm6aXjXZShy2Q9liA/B3aodvDdMytR1qkaOHNWfpFpQPoBqloTpWuy2zQ+fmPRAwP7U+OAQAqR0jDAqK2nIZGa7Rfw22x9qttIEzovvOt6SbCZdK4tMNa9VgbQY20dGef+iPaYbcUGo1INN76pI1MmTSj2jQdq5/sUvv1SOUUawIAMqtsxbBh5mWBIEXHvWm61klRJ8PlLBL3aqdVoDXBc1qhY82DNODElg1vgPqTv0v3CXqUsw5bhTIXAODURZOmn+ktjb3vJs0s3CCtaeiSws55nssh6qO9mTRtSHupTbaW0hrdIepHZom1zYpGp9Q/ltY4naPTARJbNF+JPTondKkdOkGeQQC7yfdgyzI10QAAHB/Zwm47AwDY3CcNs9tIQDXp/jrFVqbLmmzVNZqwkjXUjjT47gidn1qLnmOYpGMDN+n/zQllLJD2kMxjZFH6aXC/eS5WLQQ8bZkNuq5TUma91g9GWrZboXGmdrmNfDRv3RI//2o0V91DkeUGAErxs264sAv0zMIuP4tMF94arf3CHbqP3dHIrtOY197H2nWL3+dx32jr1mW2LHLaWD97D1G/B65TWyrssRp5/fVaVW5L8zEFl62pyiGaZ+42Ko+3kb2W6mvDrAdE3g67E63r3uMAkJ6pIfm5AvXxaXrhHjq4hoJLc/V9w28AAH5rjciNr1+bMZbFzPuWAAAr+0V4Hq+hBbbQptoAL2XxQKgFetjeYIBTJ4is+HPP/Mv7WhYPpBsKeXpjrCEf2O433eVj0DrZQrAl/oLoY63ZlkpU6We6bAGga4Yv02JoDfHH9AMNWC4tyjR/BFwnAOiZoqppMbZm6OFW1wZhVWhKUyPyQaMXRO4PADuPhLBbdI9wghaDtRr5NtQQf53X6W/29RxCdpWI68u9k0bCo3uktmXh0c/8koIKaSx+ks/ZCc1iT7F57C/RypYNCIhM8sIdCx6/9PLydwdD82FwV/ham98OB0ju0K+tcWqvdjxEal1eZvSJdmA+pnZLNunIhWXzy+9WlHkpjbuKn+HOOQ2UaY6yq2Ika2TW6fdui792R+kjHS5mMfSmKAL84gTAbi9XLIDWqDL99TP9x0a/5mD3NP0uL36vC6cwT39rtG3j4gk4x1y9RgvneiEPq8vXnKyba0uXqd+NKbowyYxRtSOB2SRk3TYnNFSPxwug5yjzlr+HuapxuoPOOj2rzFrPWFlJkQ1Y5rYzqI1LNVmldRO6Fjr8fIYucf810OX3oT1CP5O7UR9FSWgdoU0AIaCq9EJYbX4WhcC0FXTYfXaV3SjJJIor1MfiHD1HywvQnM7w79wsr+HsvIPEJN0r4Kn1ckB7mO5VvEXtNw6w0lMIkWUlQTbK5J6F1iiv80XqW5BQaE/Teak9Oq8zEDlmhj5Mk7q4SJOQu+2iy5t5e5Q3VkfD4ucTsmvo1Ow6AODmlQNwHTqm+KN+/eIhWNPkstxu9xMVqEIX2KKP/p21EfP3XJ6+J3/9Iy8CAFqBi+duErO9bMqyUeXGorX3biR2Q8USSyyxxHJfeTDdUL/zP2sA0E0HP/Ye2kEvV4jwc6cVqYJPjc4DAP7gS0/SH0JlNPP0BgeuLCC9yWY2a03th2k3t+bTcE6SKtdZIPV68IrC1hP9Kp3VZpfPfGS6h6xw2x2YYJlmt4LK+bA3knx/3u3ZVeHu2catJVKfCcFWKLwsHds/rZEqs/bDLjjRgrPr0TMN2KrRNpBj033rHFk/4l7QNuDl2NpgBaYzGBrN1WVQQOKRPQQh/d6ZI3VShXKOQnaNtepJ7r+KNFUjfKg9HsCu00F/iLSswtWEOV+CiYk9C52R/sBiZo1Oao6HRt0R7T6xr0yfJLCdKnOg+S0f+0fZhcjWjJ9RxgXjkOJKliD3M8NrY/8E/T+5q4w2PnyZtfJaiPokaZ27F6K1IetCnpO4ZFQA2KxV6zP08LzVrBmXWHdpivGjMaXNmNK8NlQAtMjTaVyH9smasV5EmxV3pNUFmpOsTRepj+5gGxemifvw1UsUgVZs8YTJEKlNmivR2nPLQH0GPG9sxS5YZp2IZZF5lNAbezt5gNe39vlBBQpDLzs8TnZNsqvSLwRI7LL7iV18rfEQQ5fp98Iiac3r703DZQurw1ahzZ6tTkmbQH4wym7IRIBCnt7p3e0eHxkAdGwottATYxHwIPFynsfEFsuyMiAUEZl3FShjQbcO0lrOvuWatSw/2xMBdJLaGP2K23eselghzRzHYtGHiQhwYl+o0BzxPD5xYBHP3zhOx7jNoGNjeJQm5tQQucRPZiPi5DI3/HI54sCsNGjx3/zBfxwHuGOJJZZYYvn25YGMWWiGqroDbXzq998HAGgfJ9VCNPZTT85jtUVQxdOPLQAArtw6AIuDiOLrbI1pBBfId+e+0q91eAMhbN3vQwcAt8Laz36k5QGR5g4AnQJrv2MKOt2vkRRfTqHOPlPFKmxmKdL2dx6h8yWWkFlyUH6Sg5jlyDcvwcbaYYY4sobUHQBK1+mYwFMrs0B7uP9x2xK8H1RGm+2FlIr2658kjUv5dhQkO8hq+DwH0pI9FoXMUy0KoIY9Fg4AFG7ZaLNWmGHYod2OLCKBybYO+AZiadp9moIj4WYB549TcO/K8iQAYuRTHOsJ2GLx8nTT6oUAhUs0B9XD1JbTiAL4QQ8kNrXLcZeDcm/+/xEfpcusRXJsy22EyG6wdneD2k/uaTNmp0XPZy9NbWVXgf0T/MzmaeItAPXT1JHEGpulvPaClDbWncRvvHykTYsZVMo1UT7H63uJzMz6IbYiKpaxKLLj9OxazQReWyBTQXFgOcs+7yCwEGwX+u5ZeaYNaynVe0vUDoVmneoMtd9eJ+inSoQGwinvSH4xgi9LXEiO2Q0L3hT1I7FH1+UXLOyfoPab42ncK7nlfrh2ZkOhMc2W1ibNo1/y8eQxWiefr57qu14lA4wOkjbe9ujZ7e3k0TnB0N2L9Dc/A2OBzJyhOMPi6rBppz3KY2CwSWssNDEfkcJNG+0RiUv1w2rDpIbPXgOxChP7FtqT9EKeKlEA65nhOQDAtfqEiacenyTr4WNjVzDH5uZul55/3m7jl179EADgxy+8DAD4ndP/BgDwd27952hV7sGBfxOJLYtYYokllljuKw9kzOLkP/olDQBeURtfdeckqSkDX6WdsjWicOGjNwAAdZ+0lJvrowgDhmkK/HXfMT7ZMB2hFgAYfysAWAnaxcOGi/QKXdtmX/o4hU2gQqAxzv79KvvvJyLtwvis/Qit0hnoR6FARRqXx/GDIKXhFehew6/RiZXjgH2C/N2dZdJO1ShppslUF8XfY9hghpORDkf3DFLsK2ZocaKqjHZn/M/DGsn9fs1IKxiNsrAQcP8lIVEjdDmecpLOESQMALSm6PzMSgTHTTOU1+f+2F0Y2Guaoa3t4Sg5UHzRYYG0LXvXQZCjNs6eIs3RUQEuLU4DACy+zmeEDQBYe6TuJ3cZjeYChbsMVfbZP73uoT1ENys/yj5/npfuiA93m33uE13TpqCDBIYZutEcBQl+BrMRXFPmUXzSYQLoMAQ2/xZDuQe5/zltIOKtGYZwdyxjcblTZCl0tzK4cJYwopdfOULtCuqrq6AH6VotyXB7DgK2NtILNC+SAOk0lUEHJQ6S5T2cb6DS4verxdaP0lA8Bq/DkOL5FLcVGuvKmCcAcotsmY28/duTOEZa/okRKi1+/ctHMfDYVt85zS+MmtiazJ/LwJ7OoMbEi7Q+/DTN2ep3h7DS9LewSX20q/QzyAeYnKUYy/ptCrqUrllojrEVyHG41ohCc4bacEtkfcm3RG8loQdpLRReobG3hyPEnT9C8z45tWvGsPsiJdcZD8dkgBQnUrZmOdaSCqD5k6R1/7v48dNX8NwNQjkJAurvHv8afnfpcRoLJ/bZbgCfnwsYhaZzNI50voNnD5Kl8quP/s5fUugsi1NXaI9xRuacmKhRduLrq/TRkIn2tyMz1hqgB6LyXaQu08pLcyBUTESvEBoobuYGm7S5KKgrIh+D/eMRbLDvuMHg0w+/EEKMOglOiwvE8iNXjVznTXVReJ02PAkw2m3Av00bQoKDksl5Gl/1RAKt9/NGwNnMKlSoz3B7eYbQbvHHK4AJzMs9C3eBJq1n5Bi62C1GbSQq/W6R5rhlcP/2EXpzs5k2dvZ4I9uiG0hgtNdEl82rekwzlDmaAwAo3GGFgHMfnAV6Fo3pEKpD519bmgAATI32VhMlSeXoWevreXTG+e3kzcJpRdnFDsOZc2vRR2yQ3Xni5rA6rsk1kY0nv2ChNkvn9UKzqwf55WcocWadx5sgNxUAFOepPysfcKF4TQL0HCV/wq7Zxs2KNm+2TcvkD9VztHjee+E22gG90tkjlb45qO3fgwEGYPkKAbv7PIZmy9runGjBYQWpXefFkW+gus1faQnuNpwo0JvlTZzdek7TQocVJJufU2fSg5/mhysb5RSPTUe5ADf/5BidP+Vj6xa5ewyTQBoIRXFISj4Od3EBKF+g5yIw49lPhdh4T5r71D8Hyds2trfIdaNHxQdrGYVt77S8DwpNt//FlzwnS0cbpIjbiAaYukmd21kdi/Iwhtg9WKMxZSbrCDe55AjPlbPqmmxrizf4cITWyGe/9JhMH9oLdO9frH/YAAnctBd1hjPm7RGa5yPjtPku7Zbwwvos3q3EbqhYYokllljuKw+kZSEmZ3o7BN4Slwr9bf9UBJfs1Fgj8nhPtDUS25yA47IGdts1WrVI6TZpEDtnlAka94qYjiOvRpneIqJFRlBU/Tb4aHbRNtDN1kj/sU4J6AxzIHKazI7k8wNGk2ofI+0gNZcyfUuwMt1lxSQ7b6MzKBDhKLFq8/3MJdWgORAXQaekTbDejNGPtDXJ+B280UV9hi7afZImwd7jgG4PH5O+QdZExcrB5rEbfq5aFPDs5sXqiTT5kJVOyZjOrEfJgSLC+ZUuWwYu7HGscW17wHAPiWug06D/JwAgZA2NLcbsKtB8lO7llaiN+U8kDKTZ6phR0XVjHQOiEMssSEWuQ3nWzjM7hk9MwBHyDJ0WkNqle26do74ldwG/TdqvuJ+K1+iC+oyG2uEx5egZ+kM+OrPUOfH0VL2UgY5XmXuoMM6mq9IYGqIXJ+GQBl08HGVSC/dQl10rjhViq0LP8dwhyvKtdFNQCYaBd6NFLUwGgQARerxLPru5/CS7tFZd3Cthi11DFRt1dhOJD8CuWwjZkquep/GqhoMEZ7QXyIuCxgGxPqN2xVqvHXDQPcpZ3deoZasHcxKwtVt6w+E2lHnHJcHTTwOFK/QM0h+hF25zP7ImxE2sAnFDAwk2VMRK7owESAwyx9tyv6XXWszDYStJINe9kjxMZlKrRvdMH60g5LXc3Ka2spkumlU63m3SPLtpD8k9bm+PzrvVYZeBZyE9Idbs/SW2LGKJJZZYYrmvPJCWhQS3ul2FBLNaBvcgwEQzBYD8HGsMA9r4edNl2nnDRBQ3qJKbFNmlCJ4qPnahQ/DyIXyGQLZZmxW4qVcIkV7r51MKk4BXZG2Mtat6EQgd9ncvsRVzjrX3q0CdeXGCTWYpdaKEsdLXOXZxQCO1FSW/ATDxm8RoE4U/Jq2w1+oZeoXmocm8VJ1TpG2p9RTak+xD3aexl5/x4G5RHzmmic2n28BbHCDO0wB9tiy8vDacWsKj5e70cE6xr/3o+xcAADeWxzE+Qn71xmdJ0wmd0LDUdjk+0RnUBiLqs3YolBDhVgJ+kSY/dZs0Rj+rMfEqJ1kWqOMSrJRYAwAkOelr+0kfqSFqt71L5+em69BfIxV16qOECphbJWyk7thIHiUtr7lGczz6ojLPQIL1neeH4HFi4eAVHlNeguBRzEeAEM2JCGTQZd/54A0aZ+VUiMQQTcKj08sACLRx5Q7F5FIFehbXlybw0VPXAACvcpxuc4PW0NkjK7i5TmPw2/QM16sOJo+T/1pmpnyHrCF3rIVunTRp4bGqtZMoFsnp32zTsdJkE7Xnqd3SK9TG+ieYRXY5ZRL70OPuF3ZiWS8tNrlCVyO9RH3zigI6UNCs/GqhTfGUeS+bE/0WcZAERi7R/HkZToYsvN07UD/F63c+aUa/9ziv2y3XgDPkPqELFO/QtZWXaLzyyUnUgPqjvIZyDH4B4PD6NzFOBXT3+KpB6qMWXreaMhaI8FypUCFkOLJYFCKdjgO/zPZXL3/ahsRWOcn3djJilBbgDr+LSISoXmP8+sfeNkVvkwdys5CgWen9myjvsY9isd+ss3zA2qSFZ3eivwvVswnGdhSKd4QziY41x9m908NLNDBHD63Wtg1BoT/JCy6Ur7Vt8PmSae3lQ1gcOE0yMZ+8CEBEix6we6H8wQCZOXrgkg1qpXyEHLgafCli26s9yl9RDrSpHpdZfUYw/ezuGrIMmsjhy7qcj5BdU2iNROggumcAt8oLjxEy/lwe/jjj4N+keQ94Hr1hH5l1vpiDpn4uRJaRL7lFuvnGK7MAAP2QBtgF12TXXXLXQuUYPYvCW4z+GdHw2F2i1qi/KhnNX6J8zwsZAtWDPN978sGhQ14CyN/pX/KpDQcTv0/j3DvBAUt/wPBh3XmNEQWc+Y9CTyIK33P6J+7gJgdJg0vkC3SalAUNAElG7O2dkg1CocKKSZddjunhJtqr/Txnn/rn/wIAsBU6yCq67z9a+V76WzOLxAa7GjhPpf1Q5FLYe50mN8muodsrh4DjpHEcmqYNYvnVKdTa9ELYVn/w9tDIDm63aUyr5YFoyOwyAgd7624SrQkaQ4ldQrJW3//sVXQ44H55k/JgEo6Pzkv0gWodp/dHc0BXpQO0+GMr7wwQ5RblX6PxijsVAKwjtHk1yrSTDF+0sXO6/xlbHpC8QR/WXiUS4HUzLi7St7vIVBjlhPSSbAJAe4bdnG0bh8Yp92fhCo0TIx2ESXbpMZFgZtGJvid3aAw7ZyImCYfd6zY/Rj8Ng7xM7rLCOyTHEkBOoFLgfrhwjzIjwJ5x5KHDyoe0hR5X3bcisRsqllhiiSWW+8oDaVmkj0awQK/GmvYoa+Fs1kFHQUwplALAaIM+u4Z8AOECw/qEG2oowvXb/WzKyGyGhoo79QppItsPMS5+wsfuw+wK4gBccts2sMTOMOdKnNrG7iXS/E4/xbj4q7MAgBOz6ygPk4b5zAS5QI6my+b+/370Uer37SHDTokiQ0N3SEs8Pb6By5yNGpYFTutj+FXqk7hK8vM83pHIJSBMmdnX0yb7124wx9G2gsexseZRumeKYayZnsCl8Pt4xRDNqX5NrnRd7m0huEjm/ABf2piMsoALH6Os1OrcKNLXaQxSnEZcZX5WmwBqeoXdilNtk+tSZ2CDVees5q5C7RT1292m87MrkTVmaLqLlE8BAANXOOP7GM9114J+hZEEJ0gjvfHZ46aN1HvIPO36NtQ9loIwiFpJH2mX1utEvmaOL9rM7sra7FOf+WkAwB9+9F/hfyt/GABwc4fmbLpYQZlhzkn2gWVvJfD5DJFY2SdITdXXGV59bh+Nu9Tv5n8iKzx4PNKUi2la6NVhGtOt21NQ6R4rCpRjJMHXsBg912eeIHzxtSO0OP73E58GAPz+9uM4X6Dg+Iu3KWW+WXfgnGWfquD/JYeg5pocE3HJtIc1fIaPlp/i/oYKg2/yWk7TmKQ7ne/bg3eV3bfMQNA534OX7QounV1gkz7cRbJYRXO2PIXOWbomqNM6Sa26aH93te88+y5luIfpEPMr9D6LGzV7I2XANiJ+Tps+CdxeJL0FJJnNtnKELdBKxBMV8NoMz9J6SbyWh8vPuLlJVlXgWwh8BnOwa9J6ogFs9K/D5DC7c+/mTCD/3UhsWcQSSyyxxHJfeSAzuA//7j/TAGVOip/+3kQ5Pd1GuMtQNw46h4nIhy+BscLdEG3m+Kme4AQ/zqQUjQYA/AHWskKF4Yt0fOdhDlyzLzN/xzEsldIfP61N5uzMJPk1C8nIXGn5pLkUE7TbDyUb+PI8ObS9Fh177OgCKh1SLeauUlAzvWEZX7yUOnVOcRbSq0XT98xaFFRtjVGn0gzJTf8RaUaNKWWCv/4UZ4GnPXQ2SAMVyyKzqQysU4KwKbYo/IyGP0Zae+4GWTiNAwHSzMYp2e6JPSlgA+RWGLKajfzC5e9ieG8PfLB0lY7XmCyzt8hS/QjDQK8zzPSA7otRATDlLZuTby9xmxhrosvznFjkGgo9RZiCDJ3vcO0Nt6LQEjAAB6m9vDYwagmm05gj3h8gUqAlOx0A2gwycOdT5jkOvy7BVTqnNgskOKiuehTS5jKpnYa3TEVrUWpEpBdd00ez4JllAAAgAElEQVSxHs3YkhpdTg6zuEaMkmz5zRTCVD+jweFDEYOpxc73+TenDIR74CxlQm8tk1M8UWojZO6w9EmCm9aXC4b5WWDsARdDCvcT0AzNzQySZp90fTSuUEUzKZaV2rDfxuia4loqjcmIoVeO+YO+SSJ0toWkjH6ECQ2L14JhgxiKGJcFiBAktfEQSNnj/dN8o1DBGaXnmP9SFDv18v3PsXWwi/QiLa5AoNvn2RJ9YQi55X7LQj9Ug+NwyWe2HpIMxvC6DrTEU1YYjq6BwnmaiJ0Fegba0cgzfLrOiZmSwY8ezrXF//Jn/3JmcCsuFFS4CzQ5niQvolBUBJV0VOBom4ncTlgmC1hS8bUVzVGBC6PUnqAH8v2nLmGxSQv1tRuHAAAHD5exNkAfWd2QdEz+mJ30zO+SzWo5ITKv00PauUadDT+8jvVLZLKLG2TxvWSa/8DJS6Y/pSF6yK9cPQIr+3Z7sTErDIZMmNegRZMGzEdA2zSmgbPbaDHSxb9J/d95itEfaQ/+Vj/awr+bQ3GZXx72ujQmo83TZsqA9iH+mJYTSEhBJJ7SiecVauwCFCoSjwnX2k0HQZJe3KFr1Nf17+8izagmacMrhGaT8A5SG12masksOchw4LxyhsYy/JJj6MQdMfkZ1KBtRFQuEoRfzpq3QPJbYMHQp2umgAkGpXhPNE8SnC5dslGf5nyWfWp//3SIQS5mlGb0T2U2IrGUNelnorrIxbkIhQdEhHtuDbC/zi6kx+gjmr2YgcuVHTUXd/LLaVNUSegtpp4lquo782NI7tHzkSzm+kFtXBKZFI2v1aFzDl1YwsIOrf33Ti8AANZbBaxUqB81zuQuLFuY+D5yly59kR5UiYtxVU5mAFZCGozmsQa7CCVr/AD1cahI/d8DkM3SxlFbpPu0AIBzGDLLtpkeQfh0xhj5VKS5G7iujLKwx5yB7q4DjzdPqZQp81S4Y8FpCxBCmBYsQ3Uia7NdtEwWtdDwiBLq5TXsW0yoyZ8EPxNtEpKroxoOOsdpvv/bRz8PAIb4D39zDn/wElF1XDhLSIE3787AKdB8PHxmHgDwxlsEuHDTHvzuPZ9vDdSaXPqgJxhf4/yKIrNAVM7Su5Jcd8134t1I7IaKJZZYYonlvvJAWhZRtrDGwC3aQbdoU0ZmnY4V56MdszUoRWW0yaIV/PT2wzCmr2ZrIMmpl8+9dQYhZ2RmhkgdW5obw8wxMsc3r5OlIBTe9lzGaDpDgxR8EnMQgAn2dnYL0N/A6FtsDuLhaQoKLlQGzd9tpiMGm7vNdALHj6z3Xeuz3T2/N2kydxs1CvbtXh9Gnq2Y0hxpFttnxd+SQMi0yNYqaR+ZNYXWaL8WpoIIqx1wpm1ig8vI7igDDBD32NYjymhV+RfJYth/iA4qTxkeqvXvjyCf7XEap8OU3FARnPde6QyHJotapFtURqvyGFroqOgcqXN97CGa4/nykAEBmHN8ZUwbGZ9/iHHxVuR+Sm9G61BErCCnYZnf0+wiMVn1mwpbj9Hf7J5ys6KxNie4HwG7NLvKrB2b+b9qh0K4tf5FdOHCXdwsk6baZrcFJmViLDQ5t8BiV8zgqR1UG6Si7+/T+ZIpvvJiHniKTPMvvkl1ZJWnTADa6qnBvfn7NFCu4IsG1SGDW1XGWsswdDX7XVvoeP2fnUKKtOfGi8OoTvPDZtjx4NQ+mq9QQlPjcJS/40uxsH3qj+RFtIcihgXBhdSO+wbYIi7hQIoyrab6XIcAuZBTTNy4c4b+ll3RKD/F4IubDO/tj/8DAConoxKxUq5VvjnF2X3Ub9L34JfvfgIAcPQZshhuvnYQNlsub9w5aNqTKMFanWnfud9+x4FmGLOAddzdaJ0XJuj9b10fQG65vx8iYUJj4Nq7txdiyyKWWGKJJZb7ygNpWYimWZsFkgyjzJCiaPyE+4dtk9wiZRvdeqTNHj1PF7R8F41PUvygU+LALAeY7KyPxE3mkuGYtP1wBMNrT7MKw8lrvXBCkb/2xGV8YYA4u0OGctqIuF6qo3TP42MUHLx4Z9Zcq9jHjExg/JMuB2Gt2TaW98hqCNj66e6QljgwZ2E/x5plSSraK4SctV6dkbKWrIGXQlglniwublM9GSCxQ+0KV1boAD6rj60xDpxKwl46girWOZbiNCwDPa6ckhqt1Fb+RsLwaI3/Jxrn+vsBZ5gvqNKDTM7W4PsMp1zJmH6ICNxViloFKSAo9Kt8khSlrbdrg3oxA3CiYZLnNrXdcy1zeFUdmpfkjjLrTwpGOc3ob72cQ0IhHrgRTxgAVI9F60QC7drVaBztj0sJbXhr1oNV4wQvDlI7dWVgzhJ2u7Q0jWSK2shN0fpa3SONdPDAPnaXeb1w0H7vyjBybG122I8tOnZzQkMz9b0gtBP7kW5ZvB3NaWaLBt0cZR/+QA+YwY2sLpHGHPVDgAoLJepjEjAZ35Lwtrs6gNQ9Vri2YYAT0mGx2hL7qoe1mU/JRA9dmARkUNVjAQYvMRQ7I/DxyFYUD0DlOOBw0bP6bP97PnBkF9UarU1J4tN7CQMoETr8zquDQK5/Pu5+gWKhgysaboPOX/se7nfLhr9K8cVNSd4coe9Pq5IyIBABDLgNhQ4X0+oyq3OiG3HGiTclO0xtdHcL+FYktixiiSWWWGK5rzyQloVoE4lKxBEjrKmi7XVGAmSmODHpdrSDMmsC7r5CMJ3knkKS9QjRgodf4kSsQw4yXNtAEvYSVzJYK5DKkpTi9j3ak6AhdnapI19+44KZZJvPb03ZSI6xJsc+4tuarBsdKDjMySRaqm46sLucdCYoh60kwhr1Q1gznR6tNsnIJElM9EpvRz2IJYB9CxlOfGtwuVenYhk+rNQOaXnNMRe75+h47hBBIZvLjAxzLKP1SlJeL3OtJfdqs1XzviqSLzN0d5zOH7yk0S2QRST8X+1WAigznImbKNwhHad2ODRUBoXbnIT4/n1gl7Q84UySsqqqnEJmja5d2SZUSbYOVLMRNxGdryKLiJDKhq/HbWiDUkpwbmhjOmLtFRirn9PoMv/PDiPShMlWJ0OMzxBkssnoo+btAYRs3VmM9hMr2M74CFiZbbLVdODADpZXmPuBLUq3aqPFGY6SUGdt8TqYaUAxgk3W3LPPvonvKV0BAPz78hMAgFcXaV6CpoPCMCfPsVS3cuiwBSfPQIXA+vt4jpocY+G6HJ6fNAmRwhemvjoCfZYDNVVac4kDDT4/BzXD96xEpGZdgcxy0SGvmkVkA5EYePSRrjmU5oTR5N2UqeFSOEblSffKBDtObdqoHhVkZAR7Fyh54TCt8+FcA8s7ZBFJXRwpTzuQbmOAkxq367Rw2/MpFO5K73q4mxh5VTkq6ykag7b5fWPetXb37WVkpdDZ4bNrmL8+0XfMaUTJfmJBdwa0KRB2+iEqEHbtDgWV3INN7OfffVnVB3Kz6Azx4tm0zMvZZNK2gPMhVCuqnjN+kc3u4xF1t1ynApgKb8akLQkMErA9Nt3WqY1uTiHNhbskM7zInDjtYQWP4YzyknanPFNlz71CDz+94kCN95ujdpnOH7gR9UPM4sakxviL9ALWp1y+t2Vw5PKitNnsDT+8jy5jqp11+Vpr47aQWr/yEgJAgz+KwnflrCVRO04veOjSi9seCU01wZDtc6FRr+9kECY46M25FH4uqmQ48iq1v/EBpl9/Lo+9M9SWZHVrK8ogN7kDW0mTlyCwVDGroYDCLcf8DgCdW0UoKTa1xFDRM8yXA6B+lsZ3fIYgpSufj4KJMo+tiRDjL7CSMNRvfNdnAI/JC9u8sdr7jqlgl2Q3ilcIoLr916Y32F04oLA7QB+V3jQne5lhtOwWExi2DZgiT0JRvvH6OGxWBAJ+JskdBY950+7lOcqmOwh84cqmdk9koryJjw5dBgD864PPAQD+zvz3Yq9Da+jucsSj74yRC6PO/l7lKWQYQioQZU/unfcx9DLn4aS5SpsFZC7ReyDuxOAWF8g60jR+H8UBbifpw3P6x5JbtAyJp5QraExz/kzDQXY5oo4HAL+HQLJ+lUAjjiSPv8MXcPLRdTS6tHYEiopcVJgpM0Zf+A4TMm6+PI3mGdosEuwG9Eoh2kN2b7PoFjUsr39NiIvc6ihTw74tZIOWRnea10JXQBV8/dmooqK4xYKevUX484JBzxRTWvwsubxwnNoM1tNwW/2b7jeT2A0VSyyxxBLLfeWBtCwSHDDyirqv6A5AgVOAsnDdW6SC7p6IjlvMfaM4kJvdCLH5NO3M039MbVVnOIM7EyVGaSXuBYLRAVG96l2uG53YffsunZlLGFNz9DXSylY+mIH1RYLQpdjdUljkJK2kMgHDToGZZq97WH8vaTjZdbpXageoHWTtd6zfxSSFbwDAY1dIouyYsrESFHbcKEHRY24txVw43kiUYNjk+tnJ8SZCLqpS3+KOM5TW2XGNy0sSmixPGTpqEaGgrh6J/i5lbFUQlaX1e7QkyWyWBMrmEXbX1B202ZKT+uJeTsFP99/TW82a3501trSYTLY9HMIZYTiyx9pyz+VS/lU9Rj6n0LON20dOtAIgLdTtzDrcGQbGXqbTpKBTpkz9XnnWhbdFA0xt0MHMujZsxxLmtqROtB8lhPWOzPAMMaijfrpjNFDjpZGSwl8cBh7vryn665/+CLxhWh+njq4CAD5xjCjQ39odRpXdnLkBmp9SpoUNZnkWlmS7ZpuCQwIkGDxArpvatSFTY16yn5O7ylggrQM0UnHJ7VazJis5Oc/W7LhteNbCzcg6ETdhdo0tfq593h3xUT/JPhhmv3UqNmzm5ZL2xUoIAXi7kSYPRFYzABQ4SbDluRgtkBmztMZFrcRj8NQu9BrzRCWiYHr9GI3v1HGa25tL46ZU7cFRGvPCa2TSN2a0WSeJIn2jZob3sNvsd0U118ikWv36tOQ7GlZeywOS7OGThNRGOrJuxPuiJDF1tAMsvns3VGxZxBJLLLHEcl95IC0L4X5x6soEckbZJ97iPDblR6UrJXnJ8jVGLtGQN5+gv20+FWnl5UfZL8w7b+hqExAVceqRtRHco8F2B0Ok1kj7EToRP6fhc9B9/SlSAcde9bB3nM5LMzVCazi6z94gl5nkhLZOKRmxcHKJ0/aIxsnHF2gMvzULANh+gsaSGmrBv8vFjzJCK6Eh6qa0q08SvPLpqUV8+Q7xUWkuLDQ+tYeNpSgpUCTBheA91sJGmJJkMxyAVaN+54+yZtlIoWqRZjT8Bs8RWx12RxlOHtESQxdoPM6MmKwhJzKeoaIQsVnzq7tpdPM8b4s9tUtY45dSp50j0fWjo9S3xS9TrCKhgVaWtSv2/adHmlgbIQtEieW6yOyt0w0Dj0y/xQyfEXGsSfAaednGLuWymUJLnQGmQ7G0qfNhcde8nDLrOnedaVu22EopRq+pl+Og7T5gcTwN3NbuI1GSmpkr9kl3C0DAjKsJjln0FoNafm4WAHDh6D+k9gdbKOR7MgYBrMyNRnUm8tF7EzAnmMVro9Fijq2pNrDD8Qk26KpnPMOIiv3+esbeRgY6zbDrHnSqMAArhr160x2kb3JQn4PqBS6v3Oi4xrL0Brmk64CPAwP0kHYb9A5KaVn9uSF4nEiXnKDxrtwZhV2iPh4ZpwClF0bzOjzCJU6/RLGc2sORJRIyvFtnQyS26LndUBRQVskA9g2ycu/sMQSeQRV2RyFzjNamsAPfaboYGaV7zRbJErnkklXTHQ7Q5UTR9A2aCz8FZJ+m/tYuUt+0o2EX6PlIL32G+l84vYRrC0fxbuWBJBKc/a1/rgEifpMXTD7OaakeFwLFBZrM7YfooRUWQ6R2aWFsPiEFg4D8Ml1b/gBniHI+gtVRBiEhVbKqR6J+SLa2BB+T27bB6HeepYfsvFgwCCy7E33EHP5dqqeJud4e0SYD2WazPkwC3/Ms7YZfWCCfWms7gzMnyWVwbY6j0/wozxxfwa2XZ2leeLOwW5b53WW3i8PwqVY9aVaSkIyphgPNORGyAeozNbicSf7ExBJ6ZalRwnqlH7fd2Mhi8jBNiJj2NS6711qKXGXi6vEKoSEtFMI/nfONK0Xo5/UwF2BaSCJ9ntAt+zu8I7ctpEfJ5dBm7q6DTOBYrubQZKSUbCiqZZsP1PA4PbPt1aJ5pjYTCJq5q1nQh6l99zK9+G4Dxh3mFdhNWLYw+jqtp50z7NrjLiof8NktM3ZRgBMWagciYAUQIdOsTvQxkvXo5zRyi5IfQMf883WkXsr13as1FWXMF+aY1JH7mtxRZk0KBbshPUyG0Rebg7IqGZg63nsVpsXuWlANiVT3u2Hf89gtvHiTXpjJKfrYVVuR26N1t3+99I5TclK0G0IxbT0q/M5q4IeeeQEA8B/fOgcAGCuy0vLVKXRP9bvb0ukuShla8wMp+jmSpHF86XZEL59MR3kuCZfmrcvZ5rYdGjI/tyIZ0fw+NxW6XA9d81wd/FTPWFL8nFIKDDozYkoDjPjR17yniFlhksbVuUxIrO5QRF76XuaQurgwS+PMdJBOMDvDDr1fjhtgoEDzUanTxi3V+lTHwsQJSnN/8bt/4b6R7tgNFUssscQSy33lgbQsTvyTX9IAcOrDc7jxp+Q+MSyys1xXeikdwWNZs8+uRxh5gWg6PbTNAqMTN017SBuLQgoGJara5Fy4dYbVbnCJxNOOwd6L26g5oU093MIddgNUtAnqSkEfTHLp0JU0Rs8RpHGda3C7K0l4B6hTqQxp1f5c3sBcM9dJU3B6vAb6WdK4Wwzvc3rs+vYa0x1vR4VmTH1eliCpTZ8yGbpP6+YAwin62wTXzy7vkwo7WGiifJdMZJ2SYtKW0cLEFSgB4MoJjcQ0Rf5Dhk5mVyIWYXFXpddtA5W2ppiD6yadry2N7MNkNeyucznTPQfuEdLGFFsPTS4xqRoObNZefeYISi8m0Jpgc36NFkDrgGcsC4ctHaFuT6Q8wxemF6OAuASbpd+psoXmYXpWwy+wpcqKa21GGcsivS5wXW2gu1JvXZhpm6MWKufoYsNVldMIi/0wcbvUQeYV6lN9hpla14XLO3LfCmDAbivkGVix+700t5JDcO7sAi7NETZcarEHSY3B42whvEHPuvToFspbZCE4a+RakZye1FALnXJ/uePSzB7qTVqvmefpOe4/SnObvZk0llmODdfqIaBwhp7xSJYmJmX7uPG1w33tyvth2Rp//TgVY/rcHNHOfujoLay3aH10fJq/27dpoamsb/JOJEDfHfZRGCPLQywL6428sdyF/l++OZNnN7Fd4/yguYg2fvAGzcPas5xhXbFNG+KadLkGu5dTGLjLpZXFHW69c34UADhV29xfShADQPU4B9052z750D5SbCUJJ9eJYbImrm5MoJSj5x5bFrHEEksssXxH5IEMcIu8ceegxCQxeI19r41Ik3HZdWm3JYikMXyZdtnKYS5239DYFWbJ1ch6IFEQVUDglH5GobDAgbN7SGuS+9ok9A1fofs0J2yMvMJaaodZZ4sRr4+IsIm6p6pYW+XEoS3J2gY0wwDFKkAhNIl/jSNcUpaza63RNgLOjhWWSm83BXeQrRf2LVvnyTpQCvCuk3bY5aBges2BzVph7RTzEgGwV0grHJ+leEn5DWI5rR2PNCAp8KLtiI/mXskuW8AKaWH1g3KtBf8I9XF4gDS7rWwR9h4t0xxbOM3T7Lf3HOwtMW6T4yvhVBsHSuT0n1ul4hl5yUQeBlqcZGWVOXYyFTGSigWTWXSNhotDfC1zc4WhwkiJLJcttiwk5gJEmc1uTUOZKkpsRexwwag9hdYwzanUCkmvR/EDyeStzXDcpA3DDeXN9FR2at7z+i6lTRa1KVzE+mD9ZBeZO1wMjCHUlVMB8oscL+KMabGQrr10GBjq56oKMyHqrf6gdK94A1xSeIvHloqqSEksqnZlyJwnb+rR36S+tkYCw6NVOxjV9pgqUCzp6iJZA0ODdZQepkBu9UV+xs9Tv/ZPaHx27wJdydby1z/5MLoP1/v6aheYfbbimriBABeSGy5qKX4flxjCO9NDKqb7f65slJDKctY6J1QOje+jfJLWt9qO5kySVMMn6d3b4zhI7q6D+gRD9g+Si0DvJeDuCpcV/ZC5c+rKsB4LO3SYiLLnfXJKILw1gNoo/e3/+cCvAwD+66s/BgBIJ7vYvMoFZr4b95XYsoglllhiieW+8kBbFmN/6sDySSsZuEx+TT9FSSv1g4BuC42E0GYog4ZqTDHSxFNIM+tBfqU/Gc7PaARsPUh1MadBtCFAFOOQFP7ecpzlRxxzviBY2gORBioV8kJHEuPo782VHBxmk8xySdTq0QAuJyRJvY76AW3MnakZGvvqCkNdA4V/8OgXAQC/8sYHAQCJPRuaaxYkRRPmxLTO7QICrkYm6AtvLarDkS22+T6b+IXDnwQA/PzKxwAA9lEuGr+fhj1IWm+wz0y9vkLAGm57mJ+FbfXNJxDVh5A6CL2SKzXhMVvqPv8cPbRjjm+2Oa6TYWqS1TTKefKFF4t0k3yK+nWsuIW8S2P5w+ojdN2uHSHqGEoqbKEAoLnkqptizVIrrM8RLHG4p4yo1RRKEmYYLSljjVbZvd4epLayG6FJOpTYlleILBThxZLYRbcIU7o0VYhK8nqccDWQI010c30AtYM0D3bIFgXzHqUXEmiydixTr0KF3TO8FgQunorU5gxDg/0L9IxtP4KPytrfXBtAgtdmeIj6EbK1pCsJlDhB73CJntnl54+Ze+1zHMbhmhqjn5vH7gdmAQAtrq/iNBR2W/1xDwCoiYVznqyOuiPIKo3pL1D7Oz9OE5i4VIB3hyZVygGLFT7xUlSzQmJKrQMeZhlBt1OkewfNJMYG6V6bOzTAgGHmqLpocRxLkiI37w6bvool35ssem+JlsbZNga/RmMaHKB+7+wloI7Q711G9omVDQDNRxhmzmg01baQYUohQZO5Zyuol2nsP/RHf5/aKLJVVXOhht9egfMbyQMZ4D770xTg9tNA8S5DQ7sMf32EHlbxDlBYoo/EzmlajN1CRG8uWdXdQlSXu840QRJo1E/vm3s6f0IfpcaMjrKiN/v3Wj+roYfI5JPCJKXJCrpfp2BgZpMzveshyn+DTc1FepAGb18M4dT7DT4VRh8V2Sy6hSjPQziivBF++XZchBycTnHRGbsDU5zIExJDDnrbG0mDlRdJZLqGGjyVihbUyRHaWZs+Ld56lxZ4LhG5R269QbuQPdk01OqZHB1v8EZiJwOz2SWv0gtZuh1g9wTDOye4LKwbwuZMZgmSd0bZbVXwTHAyt8Qumw/uwLFpXEcH6GP+ocEbAIDfXn4PNvbJNdDZlTT2EGc4e/n2Bm0CiTdzsN5DAIHaLj8fKT61k4xKVvJ3dvx5hZ1zkulPf0uXleH9EZJByalxWtooJCOX6NNtdXxUj9Imt3eSHyjvWZYXufMM3fqjVdgXOWuYl2H4cA0Buyv9Dv0xeZfdKAc8FK/Q4u+wTuH0QH5lYxMwSKKq0GFXqVCJN453URikF0egqIOpBm5sEgnm3zv9VQDAV3YJdBJqhZt/TL+rR8jt8tT0ApKcHLXdjTLrAeDKcycN11P7aVJauu3os+pwdrS/mUF2hRW0J7l28hs0F1YANE4w8IM31uQXCshustLC5VeF883ygdo0u3gfoWfx/Scv4dUdWsM77NbOJDw8MUo0ARfL9KHY3KBvQn6wYcrMiqi2jRKX1ZXvipcPzZoRd1Fijt3FvXFsef3PV2HzWq5zadSpSQIYrL01YpRQoU4PMqGBegsQJZ3torHFmy0vTqnJXdvOIsX8abf+yU/FAe5YYokllli+fXmg3VCJClC4Q7vk9iP9CT7aBjYfI4ti+Apr3PVIQ26PkMa1fdZGi7NuvWLAP+mc3PMDJot25zwXdKlYcJg/SY7tPswZoIMtowmNMd9N17dhv5cTx/iYDi3cu41bJ0mlcu7kDM9RzWgkGpoTkyrCtrkTPbrwAAeud5kXKxPC2qTxCTQ3uWMhyRouDtE8+MyJ4xcDOJuSXcz3dFxYY9Ru+AZNiN0BXjvFsMc5DhRL/acOUH2ENbpZLulazmJwiqyzjsdzxtpeaztjgndWj1EjFoVIZtE1DJoCWUxx4Rt/qA3t9c/kXjmPgTdpLC8fJovuQ99zwxzv1Lnf7OoL85HLKZkkzbUxGQArtJ4mj1IgdWOL5sAabUOzhqY33x7sFWhue0RDHWTzleHFu08zo+9q0pT87JXGhJT/5WA9u4TSq5H7p32GNPr8VwtwawwNnmBX5ls5o6Hqd4BcihUh0NnOkDaaqIF09vCbCWwzwZZd4VICoUtzuzRL8zN47q5hzv2Vyx+g6zgzO7PkGHVUkiFfc6dxdJAsvqNZmtt/NkaMt7/wI8v4o5+lNr783/02AOC7Lv8gvIAz1G/Q87QAtC5Iej679niqO4PaZMA32L0UjiiM/k0qdib6/511CuwGLdtwJcksf3b+NDptzpS/Spp/+VQb4Fjw5iavBZ6X1JiPniR+um7bNhafBKURAAjFtKAf7dmuaSvJJYLbw/T8n5lexFqD7rXC14kFnxiJ/LgdMIfXeB3WV8naqbNLt7mWg8VWjOO+Awz37L09/8YSWxaxxBJLLLHcVx5Iy0I0USvQ2HqMNZxrpGmMfol8o9tPj5sA4T7DZAtLUcnF1Q/Rz9IVjdosNyyxvhrv8KPaFCzqDcgmyVCIArLvEPb524eIjuBzW2dwtrgGAPjdG48CANyEj9khsjw6w6R5r+9zYtOxGva5aL3QDyRfLsBP9+/riVrkX8YaaxZrTGXymAW/QL+b0p5pDU84/BnyCdaq8+M11EC+/GSZIZoRG4cJlrVHQlh7/aG5SOsPI0bXniBs/TJz2XCcpHCNzmmd8A3jqc/+++akQoqTyMTC8Ao6SpZiWK9WPBcrGYRCC/IM+a6tBSl2ARTu0nk//8LHaZvB0CYAACAASURBVC6c0MCRRXQpxLWblHwmBYOmT0Rq/4Uh0kg/X2Wd9EYeHoMBZL3UZiwEhziprdzD4skxH5/HkrwbFTWSkrK1g/Q3ibn1CRcrSu1a2D1AbVgMw6wdDs3zFzimW1UmiG3Gx1pzatU19BTmWCKEVRWoL1vXueh4ZonjTRucKLfmYescPb8pwk9g7aUjcKYYoDDbf2/vXAPpNENKbzGWcyw6/h9uEMjgcoVepL1fPQgXNM7frJIabyuNfJrm9vz76D36yvwRDDBv1RZDp2sPcz2JxWRUbpah5ck9YO4yP+NRXpvrNI+JtsIPfy/FWl7ZJVP+7tYQRj8tViNbeckUPl1/GACQXmc24IfIG1CppyO1mwPcFMymOc0scxzuXBN6451ZXqdObaJcoWJG5y7Mm79v1OhFbDLL8+0aXZ8faKJ1g+d0iC3iagr6GBcDe52+CfWZELlc9D4CQCZJz6Smc4by593IAxngfuxv/aIGgFQlGmiTC42kmTwwdBVUwLkXs3Rs7GILKhTECy2G5khUREjw7U5Dsowj1JK01RlQPTkXksnJ/y8GyIzQDtWqRy6KJCN1/PnoTZSPuYi7xx/pUoAEVwSTR3NhehVvrtALJXh4WBEn1dDrjMSp0th3fqiJziZtCFIgpVPSUe3qw9RHCYI6icC0K6iedLm3uBKjV06HJutbchLkIxP2fIPlA6VVlDUsRamsJH/0bI2QNzI32VMjmbO5DWqlYSPBaKn2FLsTdyMdR8/QR8N+i6sGprXJWu4+SSa222N+N1bp5SsdpB2/kOrgQ2O3AACfWjgPgArkeExeJ/xIikkSra5CfoERT/yuuo/tobrOmHp2FyRGmshzXshEnjayxT36sI3m61j/PH28Srepb5/5lV/Gxxj/vlWhOQjnObh+qAH7Ss7cC6CqdU6WlYlL9Ky9vEaKiQ9bY29/r6USYHI7Kg5UeoIAC1uMt5fqjLkFoD7bf31iL8oPkgzrbiFyW7ns0ZCNrzGpkHiE+tu+QpNl+QpHPkgfw3vBEUfzW/jsbfIdeQ1aUAcO7GDrBfqIai5ilUl1keSs5I0FUkZk3kdfVNg+3++azC0p456Tokm967fLHG+pVXYhX/SwdZ6z7nkZ1A/7SK8waEAqJDKiMrOm3laXO7ljGXefVFmUuuIADLpREHhuTZkAtND0dweAdJmO751n5Y/ZETI3kmiyAmFQiJ5luKkEydYd0PAlX0ZcYEKEOdw0lffm/+HPxAHuWGKJJZZYvn15IN1QrVHRZu0eGm/eLXlXbo5axkJI7r1dyxLoYugq1Gf6taXsBnOplFwDX9x7uMfE9sW8FEgn//14HY0qMzpysNnqKKAtFNiSaRn1R3FbAntVbghvk7RkZ5S05lduHEaaKbj9EXa7ZCJteftJ6ltmmMz1YrqDMufHBu8jNaizmYXLFssk48VFRjM13EiRf0CCt9gsGm0s5Lq+dtsyhZZKM6wxvkCqmnZg2D6n2bW2NDcGsBvPZS1Ygmxe14F4k+Se/moGusgTzn9Lly1juSXKHFDciSzAit1fHMY+0ESbExV+4BjVl95liGaoFS5yckmLa18fKUU5G7YUv5lt4fgYBWEXv04WgJSgtboKHnukSk9TadZ6OwkrR+M7MEbzsrxZgp/sx7CLNjyRqaD1QXqez/7oLXP8cJHuOZ2n+bvYOkT3BNBinimfQRK54QZarZ7EHpB2Krk+yW1xP9L/O6UQCXY5eefIsrR7+MKCLGcGG74wBUverXG2jDMWMhxsl3fGG/CNu6rDJcHdR6n/hU8OoF0la0qz2y04VjcQZYGNSyby9UMzKF1huCnnAK1VxqDYgs99maw3DWDrEL/bBxlre4OOtUvRe+z0MDck2QvRHuacBFnbDkzRo14ZuURjrk+xy2kl+lSOvsruJ4az1mYUskfoPWswQ0AzmzAgCn2I+1hLIs05S20p+8z9cGtWFPTmjGw/o9Fl6zXFrq/OaD+3HQAkrlA//JyGl3v7WBSzGxQv0neociL6dtgTzbed/40ktixiiSWWWGK5rzyQloWwvfaKwFiFXyVRjcoUSsnF7fNpo6UKjBDQCCdot2+EnLyXjxzwEp9wtyXYpwzXlGTaSlsJRMWDBEKZ3oqK2kjWbmrLQvs0q21l6pBm4yP/RspoEyHXDEj38PxLu8FAgJHnqU+1g6wNrlBwt/HIvokttDhSndmy0OEEI87rg75L7S8WR2HlSZMaHSarYz9dNBDOgH2e/8UjL+FP17meBkfLW9MMr9y2Yd+lAVZzEf1tcof0kVaWs4HZp2qXOigVOVOVa1HobADl9+svnZI2fl1JvOsVzX54sczcuaxZ1V9Zp8Iu+STN9Z1bEyZ7OD3IVtuVI3itTYljEn/B0RYWtilzbZh9+vU2Q5EvRZnt+w0ab2slQgOU01Fcqsnwy5sM05QYEQY3sX2RLLmXPkPP4LuefcYEiJ88S1THdpnnbCI0IAqJLSVHfQTs1/ceYYbUvRSy83SPxiH2cXPhm9T1NNpslQpEtL2XwibHttQ7eKxl7WcW6D692qxJEqzaxjcv/n15e8rvDTD4Jt+N34FwNQPFcGdp32nRL8OvRlakwMedFtDlKZVkwtAFwmTY1+82c2ZZXtIkq/bWx4BiLwAr+S4nvtZORuWD2xO0htaedkycQYL7AvIAgJUPUofySz2Z/l+ldRGcZWjrtm2g3v4y18HoKLTb/RaFSGMmwNAhskq7bzJ7s6tN8p5mrjed4Uke8qD36aMhcGq9E8VJm0e54JETAtV+UEeC46OtTAoHDuzg3coDuVnIxz9IANk1Nm8T/as9dCLXlOQCFOc9bJ9lXPYyk6mdCJG61Z9FKS9VasuKsNKMOa/mFBwJAjNNiMm+fHEAYFI/n7HVtQGYFwWc+RvkLGCf/QXsksrdkoAU0DnUj17AUhLdCQnuMv3EchJlrvInriz56Xp2VEilZ1pSjONu5JjSXLKN1x10eLPYEJqPcR+5OzT4+lDUxuoCuZ1yd+nYILv46tNAnkEc7RpdkPP6a2kDgCry4tcK25uEALOF0jznI2T3XWaVze7B6IUUwkHJcFdDPdTqdTq/O9VF/iq9NOUybZ6bDASArc2Hz7nBL1AO8LKyhuhPmdcyaD9GG1nAtBlSVKaZ1CaY2maXIxJRH4UWfXZiB8tbNJempjPn59z6tTOYeYte8M5IlAuUYVfD61w0PrvB7rZbEYJm53Gmq1nJG/x8r8hazN2lD0JjijO4R0KjaFhztEHYWQ2Md/quD5h6ozWmEcjw5Do/+sAL/b9fDEwGsWxozduk7RRXIiJOyQLvFqJNJSJgjPJFZOPJnWF/8u9Fm3PmKXLTba8VMXuIEGsbjCIceJVzK6a02fRzq5EbymkzFfspmmN55nbFgT3D1OfsNqz5BfjT9HtrmpW/nI/0pf7F3B5kV3aivzwAABTuAkGSGQeksNlotE6Kt5gd4eP0EfGDKJcmd54+4OoPh9Aa5YJF9xCPevWEeQf9DP9Ma/hcwVBo69MTLXziHBVOu3qOiBjnyiN8jouVzRLercRuqFhiiSWWWO4rDyR09txPEjdU/WCIoUsMFWSius4gw9k2FBIV+j2/QtqTn7GNlt8co924PRjB6qQ8pSl+NKJhcYDWOxypDootBMGQB6+TJlV4bxmbi2QrJ5gO3H0jZ9qTjNsgqTDyJgWWpC63WDBOG/C4H2JOp7Z6SOk4OOXuWYZcTgruhIzLd3ZcQzUt9w6dCHoqwWNnXwgRNdKbQoDHbp3BACMvcTDzgEDuAPte3jHu19A1D50BzivooW4XaKXkbRjI4mQD1iUuFMNtdkoaqW3xkfF8NLXJsBfopAQzw4Q2eTNJDnoHKaD4Ft2jMc7B0mMMHvAsKH6eYYH5vdZdJGr992wcCPDEo1Sy8tUXSMt/3/uuAgC+fOkkLNbadIme/7HpssHDF9P03FfLAwjZkrDZmgq5BnbqTtKUTpU62omaRnOM+ltYZBBAhkkjpyyj5afYa9CY1gY2bDF/kLeZhir1cw5JYN7uqqgIGKWOEGeRwMAn2V3FmflSXhUAugdpEdnrb89Y1642FkLiHA2qOcd+VKUx8QIzIDDNvfBjARGP1v4pXudly7huRBL7Co2D1HG7wRxIRR/Z4f7AbHOdXENOxTKWRZOvG3kxYmkQOLjwRznJACl+j9u3mCAwH8KuC4ScLahUVGs9xfB8IWEceT2EW5dCVWwR90DsRVqjEXw9YBfv2BGylupfHDOlESQj372wh+Aiaf5CmS9N+mNd5G6w1TgYwW/9hxgWz2stneuguU0flNQ6g2TYrWt5MOvq7s/8dAydjSWWWGKJ5duXBzJm0esHr0/1+yfTRDcDpxPCZ59hbZp24L0zQHqjX4tUAfkcAaDAJSbdBmvqi8pQiO9YnH3bU8yn06WOhD0F4iW5zs9zwSAFZJjxUjTF0AXu/gC1l9iP+iFitDq5VeT6NeUSrRN1tHfo/gcObfXNz3I4DHeJtIjmAbY2KjYcpjcWbXzkTY43TEU6Q+Eu92HJNtZabika8z4p2hi8ztrgHicGdUJkOYO8epDmO0hGiUsSJO/NoDYFhqoScwHq50gzz11isEFRGWpnzUF1WbR2WxkGWJvd96mdHo2YraQCxycaj7dQyNOz2iuTJZB4qIIuM+N+4BBZE3/y0jnTxkc/SP7ez1w/C4AK43gM75XCOHOVKYAtFbEsACDJRYD0jgQn3wHWyJZuettHkOgPRPppmpfhqx6W/xpbJTvRs7K4YFaXrYL0lo0Ou6DlGefnOUFxIGJXltiM3VLGUrE5iUt4zhK7lonNTDxHx/aPKHhcDlay6r18lJRa22BLkftXeEuhyWsou84sAMPKWBTG8r8bMSZI+VphE7bbCoVbHI/i5PwwZZmEVeGckrjRY8/cxkt3CHIsTMdAAc1JycRm6nPO7v67H/08fmvuSQCAe5RMB38/heGvUScbk/Rz4E5oLL/WEP2c/hLNe6doo3qQIbb8zQmTQIbHbIAt28o8H4cp0vWLTHe/3SXPB4AMEwjUdkrwOKgvTNeSkOpuJAyLdOEtOmfvbGDejcSiJB07BtocCgS9Qn1M7Wj4mfsaFEZiyyKWWGKJJZb7ygMZszjzcxSzSG1rU4TlXgntCLmRX6ZdufyIa5Kbsow+ak4HKF1lbiL2FRbnWPtoa9Rm7N5mkdzT2HqK2hPmV9HGd5/uwF2h7ds/yFz6t9IGZjh4lX6Wn4gQWrlFuvfEVwj9sfV4yVAuiHQGFKpnWXucp363xwNTqlJqXNSOcknUVRsJzrvrMhlvayKIeII2GD3BiBClI+hp+i61P3gzwOaT/e3bLW34sARamGdrLLvhYfX9NHbxk8PRhj5ELItJ5uNPOT5WXpridiXeoI36IjGXzmBoIJCiLQeM+CjccIyft8uIk+SeRoUQsyZ5T6wybVGci27AYx/omkTBTIrhhkqbRMFK5Z7CO/uuUZ0dpiHphVUKNNdqWqZ4lWiA4tvvFjWcdmRNAcD4xS7mf5CtxhajbIpScClq3kpQX8O6azTG5nHSoIe+noiYihlF5u4yVLmrTMKWzwVvVMM2qByBg4uVnahqhFzi1OVSrZ2iMmVPhVZn6+FIM5U1IZxsKohg7rLek7UQiSqNYes8J66yVVg95WPgMsPBj3Cspa2M5iz+/uKCh50zdK0kSIqF9v+y9yYxlmXpedh37vTmKeaIjMjIjJyzMmuurqqu7uoWm2SL5IYSvTJhGx42XkoCBC1seOGFBEOmAEO2N4Zgw14IlCWRoixO3WZ1s1jVVdU15TxHREbGHC/izdMdjhf//5/zXkSTWYB7k8D7Ny/iDXc499xz/+H7vr9zOoLLLWhlAXD7ysjH4JhKsVsKcW2RNKe+vs9MQEejcJe2X35Ev+uV7Tog6CaRNald1sjsjDb1SlLUDhcAekNoQrH8M76ofNyDkkL5saxTnjn8wupoHUOilIvff4L7H54d3ea6HYejq1LvtPHA8r+hkCWcpvpO9XrGREI3f+/5/SxeyIfF+7/1P2gAaM95Rg9pUKBBObzOC/MNZSC2Eu62lpTRXWkv8UTqKbO4iQaR3Jz9lR68TVoAM/tcNJvXSPPfZpK/yqGzo03VTjN2uzLdNCkPscpME/2PaQZJ0axL0ShyW9qEvpI26E8oC0s8xU8SB4ZLIQ8j0f6Z+kKZwrJoBPkthfIj+u3BNf5dzoIBMvssZV5jbkVKIczReARcvGvPOKhdp79FNrv4XeYh/MXsEIeFt3XkIOaUmtzo/hkCui9U6li9TVA+WUjiSoTijVFWcvR+Hd0d5mEwE1XSSoAFAwhEOE5pU/iXG0dgjVEG6F0YhSWnH6aR5qJrnBld3AFAn6O7P/chrUr1ixZUIXNNzfRRKtIK2WToadhImeZY2V3Zrj1GMRGq7M1F+N13PgYA/N//7jsAgHv/1f8KAHjp499Fb4PmUHrX3vxy/QSEka7aRV+sddrCx8VRcqt2/OTBG/BckoUZsCnHiIXqVN8xkFyxMG/ncIdZ2gJSGJS1YVNnqnQxdt5ROP1nEY8Dcx0WhRVuIe3ysMjsOIbP0Of7ubQWmt/uvkW/TS7QdUp/ljNNp/JPOY26FSP/lD5vL9GEefZDZuR3XXNvSYoKqQTBFkOsuwL51ZhkZy9xZS2w64t01Oy+TfM7OsjgeB+C/BPblTGzR38IGMTvavt3x6ah5b3GOXpL0r9hVuHgWwx2Yan/qGj5OJrPxW24mPk5n9/opUNn1jHO9u1/Mm5+NLaxjW1sY/sl2AsZWXzrP/kfNUBEvAz31G4ucoFJIIYH2kQW8z+lKnKcC7D7LfIsuqy/Eqc1vBZ7D5MsJX1gH8ESlstT2Ymslo2YaTjzgyM0Nyjvk1+jH3QWEjgL5NoGXzOTs2k9bfE+pPDVn46gmOUsXojfcEx42znNMt2B9SK8Gp97TqjiyhCwJNrIbjtGPbbJ0etwoxsxCXMnb8c4vHKyOVF3nqMwTm8IVM/1EvR3RlM2bnuo4RKbYRF3FDQ7uNK8CQASPvdXV8gl/Z3ZL/Df/vl/BAD4tW9Rk5wffUjqsIVVB/4PCXrouTQue/enzbGFl2jc/Qd0UkEN6LLXKUAHt6dx9CbrOv0R/W772y7irBwn6/uwWxUXYkx9SuNy8Canwx56JoK7+i7lJL++f9poWWWvEzO3/pQrtIXIRJ6iAOpXPaNwLHNTlHwze8romwnUtjPrGHKbSNO3Z1zD/pc0R2fWesYhQ6yFQQ3NmkTglp8YUghY6kEzQTK/zhLbb7UQHtENJlpFQdNCYGWMWisciSQK6d1Rd7awpk0EKh700WU7R0RSv8yp4NhXRuNJ2s2qBOjztT3eHmDyx2kDUCl/tg0AqL8xj+wORf+9KTqnJms+NS4mo0ASANlnDvqTFo4KUGRWfkzjvPk9Xlc+pO90pxx0pzlCZDJfestHmnEnkj5NVxPULjpme4BllAd1jSg3eq8kngVsCKw/VbeRhawh0mJBe0Cc4bYDS5SHbuzlTco12KEJFRzZlO3hd+nmXvtP/9E4shjb2MY2trH9/7cXEzrLcK/ehEJYGFWRFOJb4tm+FDvfLpvfSm4+8RlSWLLRiJB+BpPWA1u5vgkAWP1iEQDJfoS8OSlESs7Yj1x47WNNio4c9NLc4IajlGGAZHtRIH2cZ13z0D7F7wlxbCMwEY4UtaMgQfEOb0kQqKx5n79j8/6dV1j3KghMXUeK74MKS4fUXBNlCBHw4D/uoPDvqVaw/y73oMiFyBXot80c5dAztyla0q80cfU6RQP9/4Z0j5pn0qhd4EL1Enkw/h7rDM1G8A9Hp993zz3Chz+5BgC4u0Z6TR/8hoUl/9mX9Nn5V+iaPCrMYQrHTMM0J3I2TjaaiVlepbNw4iNUX5LuUNp4xAIVFXN6jskjz33IwIihhj53Pl4BQJBpiVQl3hIdK7fqw5WGTnNWzVgihBw5xMjskje895aN2ETWpvAsGYE8A0BhK0LTYWVejrijNM/pom1HKxGJSkabHQFAmUVwsx96aM8KUZP3vZVFwDn88DJdF/0og4Cjx9Ylcpddlv/QDlB6xPWuBZaaOaVMhNtY5uI7B5aF9cQUpffeovemP9fYJWQrlv+Eay79GO6/p78PX6ZIvjPHUdkU0J0SfTjS5MqvtwHuR1P4hAZXqojeb64Yz7+xYsfB9GnhKTEoa2y/yiE2N6Da+nWOsnccxFzbEkmXQTFBwDB3iViqLytzrqI8LY3UnEijNz0KevA6Gtk9GtPGGdquXHO/pQ3hVqywCmiX6xfcFAoXLItWanmtqwz5zQ6A3ihc+2+yF/Jh0Twtf2mERfMnADvZZfIAlpWc3VE4vMZFrzUOzWqj3wWAFHe2UjGw3qOHhAGPa5iLf5yhCQDRAl3BwQpfpLtDxW3+nRNp5Lc5ZeQcqzrBooN8FpKTBwoA09jHW/PNTSw3f3otMMclKQx9RO+V7rmoX42HDwOvXVsFANz66Dzakt4SxBSA6ms8btzQqXOQtXcZW4E5GGoth92AVp4yKEXQmXFMcdlhFFf/Ir/R9QwDGVu0qN/+s2vA1dHt/+iLlxBM0/cG9VEGcflLH+4HE2ZfAJBOW5a4mPA0erMxvOboeGsHyD2iY5NUnzskQCd8AkkDlB9pdBn7LtpArSUr/50a0mUL86ytxTLdKUZAhcXEMJVLN6WLY4QwI8glfmC/zE2NslYPTbYf5hVKT7jTYJoX4hkXrSUBc9B5log6gjhrOw6ac+sCqRovWtzQJxp6vua3uOsaI97SBwHqF0c2gaCu0JvmhyCnQ4dvjN33OH3WZ9DDgX3AySItjl6YV6ZoLDAhr6tR5AZe2+/QdVr8SRdhZdQREFRc0NBWoLBHG47THrQnjh15eoev0TXJVGNsv0fbLwjHyAfaS4wmYw6Q0weCr5hXxac5zFHIfUbXSlJxbpe06ADg6DJd48odoLjOztZSauT7AJDb4vYDrI6Y3beOhPC9JIWnlULMoBhp6NabUEZ005ifoPwZIzRzox/lP8iZlPQ3sXEaamxjG9vYxvZceyEL3Gf++T9ldxaY/YhDKw7P5MlbXEvQWpJUEzOAXQvNk0JhEqgTmlDi6ah4SBaZvYnMLlB7mZ74ospqdI9O9+HvHIN+Zm2bTylWiRcEWP2iDjOd3a5CYZ2LWHmGCq5GaCwxC5M335nTyPO5SCpBjjFVs9BgYX6Wv/JRu86e4n1pEcrHcFoj4oKusHbdrjKpqeQdcjs71azhEVQ+47aQjNPOHCSGoS6hS5S1zXjEBOs/mI0AhsIGm/ZLTnQMPDDUc0qiFCmo5rcSuP1jaaJIY+8NmwYBbGrNGShT8B9uQCWABkkFTn2tTRvdXpm9dtbHym5rU8yc/poOrnbOs21l+di8NlB+xAq7ogJwhbV5csDCh6xN1GaV4pyP1ikahyqRxU1U0FqGSVtFnBYr3wV6k3wcv0liT6v35k2qqXuaeTPPWJ+qZ+d386x4zY5Ji4gJPwcaxpUc5gmI7pbRU8so1C/wOHLhtDPHHrKnbUTO5tccy3ngYnZ2nee2b9uICow5XdUYFOwcA+g+lvvmeAG4tQSE3O995icctT3porNAkYjwQlKXaU4Hf1xCg3k5UhxO77kGYt9a5vl+G8jucSTHkPI+p3VLa32057jfd82SpIIa83ZiGQ8HTn+0T3lV0mjzyhS9RRa9N6HM/BZtK/mOM4CBvcp7iWczCnJ9nKHddRicUrlr0/hCK/jqfxlrQ41tbGMb29h+CfZC1ixMQbnloHuswukze7Rx1kFvdrT/ARa7pgFQb54JLTXXFOjECxbl2qD2C3KAUCjfYk+IvabSYybPVVNoCIuaPTy/aWGPh69y3nbXNd6DNH4p3+PNa228U/ld6nAAdmJQP2svmdQsJBLJb3LR70rKRkeh1QY6nq+vX2aocNU1hVN3pGEMvXS4b0N21TcELMk3V+5zD4AlD+kjIRo5ZnzE62lyQ/u4yMXyjguvJTlufolhGK3i4ZKKLNda9ND3ADSXLMmpdpW1cxqu+Z5ERt2MJTmlD0ahsALlleMFgK0fRvCzzHJ+TPNFPLTDNyNTZ+hO2PGUqEciEq0Udt+kCTXzFW1r6pYtNmomdlWvUyK59MTikydu8bFNyrXQ6J6nsKD4NSuNTgHNl+g3nLqG23KM3pbbkGK92azRVpJCe38+NP09JMoUCLDXVhi8RrhO5z6FrpO3YkRcV5GGRKm6hsvtQ/vcc0FPcUTV8pATXSKZthoo3WAIp7Dvue6oPaB2bbTe1FwhkAgAo9TbHirsS6Qt45kM9RYREp/X6OHo+3QdM6y7lFym196UMm2RRUerN7SmSKE7txuiX2KAAF9jgfQOip65H5qn6UQLTyMcXWG1Vya6BrUIrSXunSNTksfF7dv1R9pG9yb1kBYd1xJ3bQbleM00XbWEXiGadhbsOVTu8LrZlroWoJ3nBhTGXsiHhdjkOzvYvUFQFOkXLIxLwGLkZcF3n2ZsqPfUNgwJaqOhr8gyqMQyWgWvnqonZnGb+JKgDNU3KFelXSD3lFMaws8YGuE8F+pKazFac4JMGb3ihY0BghqdzO7bRfO+PCQm79CN6ISBuclaizy5plg8bN42gEkNMW6L1IANh6+z5DN3UXvjzTX87OPLfNw8FuUIzoBOYvIjFpl7OUYvtmkqAKhdFWSQHgl5AQDK3gAih5CwEF5vNsFgmn5QuM+L76yGd2wbs5/1cXCNzkvADJO36GlRfhji8Cr9NrPFnfuWQoOy6rxMK3jqHne0WxkgaIzmxby2ZfCrWdGmd6E3uK8xf+ZzkR1t+3tRD/A7wN4bLI2yawuikiKRgmWqxii0cgph3uX3aBv1lQD5Z3TyInM9dYOOp7EcoNegMZAxjl1gmtMsOwsMwqjoE7wDKaSrWKE7b/kPYq/81l0AwM//kq5/NEdzyX28hAAAIABJREFUwrubQtjiwj/fP/Vzrrl/BGm49xaQX6H7IIoZbdfmbn77nrn+MsanfpKgwQtqb8oyoAFKoUhauXZBCtJA5wIdU5uvnXYsB0nELj1Op/ktBy4jfEqrnCZ8qWzSZ4YF/n/Q0641r5HbHX1AqdgxDol07KO/O3wuLGvDbQ78IbV0cUL6ZXdEHBQAepOeud9FJFKu/6DoGvl2SbO6PWUchh5fO+lz7pzqItmkee0zuCLxbSpLGr/lnmk0VrT5HAD8VTtJxDH+JjZOQ41tbGMb29ieay9kZJE7T8WpnD/A4mtbI59t3JgHQKknYcT2+enstayUdW6b5bTPuCYUDI9ByybuRSbVIBLLxbUeGmcpLdM+S3F9k/V3Mvu2GGcKTBo4fJse9/l71iutXSNPYfYjjn4CCT199CbZWz4Qsbas2d7O27SN9IGFQorH3eEUwuk/HaB2jr6X8HYHBSAtBXwuIn9vhUKNfuIhs0J5n/ZT2pjqukgfjI7H0p9qbPyQ/hYMeViyn7dO0Vj1mYeiXZgQv7RGJ7D1Pfo/VXURD0WBABAVYmiGEk/foO93py0OXCSf+0WGrL7kmsZPYk4uQigigQwblpSj6rrG8+uctmkrKar7d1lK3BnWO2Kvrc390JsWEFE7z8XkGeudiZdcu0iFcsB6kZKC8NsJghpHd116lYZEAGmeAUBrkcXy8hafLxpiQR0Ic+KdcrpyCAben6XtZh8yuz+ASQkZeX7t4t4ccxGuUkW30aJj7JyKT2gbZfY0Dt7mceM2vIFv3ef4Nk9EFjHsz4dIbY/i+De/78DnFOPx4joA1M9xSmuGodwZu31JkcVTA2Qec/TCPAWJ5KOMNgKSom2mXZj7MuTXGrciLT+JUOVWqzNfch/3tj1x0Vhrz3kGzCG6VH5XOF3KRI8SpUQphRK3zo2Z61JfCYzHn9/klHSdzm/nlELlAb3XmrfZCcmKCLM9EbDG0N/9tKTUHaMXJtmR+gSG8lU8Dxctv8U91g72b7JxZDG2sY1tbGN7rr2QkUWzwR4ggOYu5R4VP131hLTQDIxXLdZZSIBpcq+b++SZZLft56JIqts0LLsp1+T5BZLWOJM2UYB4jJX7tO/DK655/ErBsLMyMEXb9iJ9r3N9gAzrFe1+lz001hHKbSnjMeaYuJd4OJH/bJ+yUtDioQVDOkzaHAd5FdNfRSYXLvbxH1GTn+SVJlLBaLHgB2/dQvM1GqNbuxStVfezpi1p+xwdd4rlzoNGjPrKqO+R3dEG/iuNqESHK05p4zUJKCG/ZnPcB9e40VHHnsvR91j2XWoQCxHAnqe/TT8MbmbQPsvtND8bLWZnDmNs/CrDI/m40wdWD6vDzHmnp6A4cSzAg+rrrLmz5piiYJ6j0/ymMtBtiaqCui3cSrFeCqJR1jH5Y/HetSLPE4CB5pYfi6KyMlBoIYlp1yoPVB6wd/q2a+aCeKK9Kfrd3M9ibH97lMHtNxVqRxxON5nNz8Vk1wGSKbpX5l8lJuA25kxBXHQI4oxGi4vqjBBGYVHwt8Bgi1AYIpU9qGj0Z0bnmuLCnkosMVIs8yQ4MfdTjwNThJZrF3HBPfdMIc6Mfl/FltQoBF3Rd4t9hdIqEwBbDDfWGrEQHRfo2DLVxMzJybsc9TIps/x4ACgajyZH1/P/4msM3qE6kNeh8528FaF5hg5OINmNs5JtsNsXsERnTpvmXmKOtEu+m0O4zNDcrq1Laq45evtWMl3qEkU+T5FYby9YheBvYuPIYmxjG9vYxvZcezFJef/XP9YAtd40sDuHYWyLjObYDQyczRCwSiEUN7dXu9yYfmYAxxvNe4v5fmyUVFV48gksNQOB8iaBhnOJ9ewfk6sTz1sBF48b3icu8Pq7DwAAn90mQRq/RN9LYhdxj+VG2iJD4Jp8bYl+hu6sOuFxCVyuO6OMRynELsBCMSUfX7/CXvnRSShiNBFC8XGc+QPyjLr/oIadDUJ+XblA+kz3n1lhJHeTXF2jbdNW6M2wJ8+eTmeZ4RpamR4KoqGUf+wZz7LIDasOrnsGZiya/q6p1di5Kw2o/JbG7ndpn0L26pynORHs+IYUmOJzzrxeRaNJ19h/SF5flNaoEEjIwBhb55jceMszOf/cDqu9zrnGy5fP4iFlEqmJZXbZqz1MDCk0dcjaP2fTJqoS5J2F49r6lUSz/Yoaksmg18GEnccCj83O03xsH2bgZrlOwu1Yw1MDqBp5xKnqaCMnFdtzkRpAZi8xkWJul3ZeP2ujQbnfJHLxWtbjj337HYGDFnluJkNlDRlvuWe1Z9FBYn5LYfHHFI4eXaJr11rmCDZta3mV+9yYa6uP7ffonKWni9S9GmeBydu0r9wzCsu23s9i5gu6LrVzdHDZfdumWc434MZOKrESI9LYaVBwTftViR4TT1kCLW9D7pWwoJFlJeTW6SE4t4wbQ4JTezbiFpN9d+YsUtNEckP3SMBRqczD5hkY5edH//D5pLwXMg2VekR3ZvN8ZAZPOqshkvwLkMweU9qq+YbhKhyG9GcBBnwDdH+Twmf9JVVt45TGFENnRTOHcN88MaVDmjCFUzZUE4lrHTvIFGkS9gqMae846EQs/zxDk34qT687tSJ8TgmdXaHwf/N0CeEhpQuOfAtY13x+2Zuj2G2lLb9BxNFKj+0EazIrVRoYqRgoPaFJLkXBVMM1DFWx3SdTmPkZvfd4d5n2fY3ABv17JdPoRhY0r6PRo/qpCf/zj1gQ7fLAhPpi/UmNPqcX4szJqSkpGOmn7HXUiLYOANQuOqh8LWnC0c8GUxHKc/Sk7LNEdefLSeA8rcpK2LE+cPRDes95PLqRMG9v8MOrPJcOgSaLsynmjvgtZeZJLGJ0RSmyWn7IdMOmZCS9KQ/zxiW6JoVHQ2kG6RYYANm9Uab/zKcwqUDhj3SHoL7JIesRsZCku5VGNM350io7MszQLz+2D6PBEIihuC7wW8HqJ8gw9l8exLIotU5rTN7kB/0Ze1/63AO6M0dvCfR0UALSzIOQbpGHr8XIPx5dIDMHCarXRvkvHkt996cS+C0aJIHftk5lTCE3v0pfPPohnZTXBQ5I8R69Ml3rydv2mmT32KFqJSaf2Z1mocKWpFETU/Q+uE7jXVyznlxvQnhhOGHSJ17Fw8oR/EDeVAai3GYFhww7Tkrb7cpDPbPnnGBw66UeCvnRKrYcmffJBKLjWOu/wcZpqLGNbWxjG9tz7YWMLKTBSPGOj84CP92FhMbtEJ0ISO8xxPU6eVIqVuhykdkdsIt2pG0Y/HPyNnoL9J3SXRfy2JYGI0gsSUhaL4rFEyEqGfL2+4rTV26Cnnh30v75dBuP9siF1syOfZaifasIiE7RNr4zSWHN//b0Pfzu65/QIR6S5K7WCg9vERlr5tcJd7n5EfW09lsWtmk9UWUauoiZEDdlYaACEQYsI7wzS19c/PMEfdbBkvaOiuGSQZEYoYCFM/YnlGE0i6cj6ZnMaoDuImtV3bPaQHKMohHUryiTljkuF+43lFGY7U5LyK/RmZfP+TzuWjXe3vbEyDaifILs5+RRetyMJ2kogNOPkuaUgnjiAd0z3IP9SNraAn6OxipivauwArgdDkf5sE0Dq1P2PLpTNLbtBYUBM6DF88484wZasxrOYDSl4Q6G1Fp5XPbfsAxy0/yKgRyVh5aw1T5loyXFEa7pkV0V//EkHNjra6SqIm9P2537WKPG2kpSNJY+585Aocky5Cbtcix1ClgAwuJfdNFYpjGTqFCFyqT4BLLcnXFMy2FJrc7+nI6r+zTAIbOzh9vpyv4Hk7RhAQWUvtiF5mi9f4ruwUHJMykkAZv0S9avzuyPQqKjjEdkXcC0FwhqDg7fYvjyql0nTLH5sYwZvQ6rv5rU9bO00a0SXS9p3zoo2XtEItbMnjapWknFlf8ije40n/NDOuejiyeVrr+JjSOLsY1tbGMb23PthYwsMuvsjS0mqFwmMlFTpDG5GtY9M7Cef40VIQ8cEzU0z7O0wpyLhOsL4slJMbtxMRkq1oomi0aW+x8I9LPPBdrpuTq6A9rnzDmqN+xul+E0aZgFBpfL9HG0RV6MZJQLq/Ta/9UGMKDv/4ub3zbn/Edr1Pine5exmWfbJ8bFv071g+SzstGvid2h/L0WD4S+L0Vwt6cMvLPOnknQcJHbOgY9nnINqUkgmuLxOBGQ2edxY30s7esTelT9Ka43NBVmPuL2pK9bldLSveHGIXTI4llKoThgzztJAfmndF1yO7SNnXeA/AYXLy/bCBSg5kLtuWNeVeKYGkhuk37XPGfd39wpKiBkAtZ3yrZx9z5FdP5FGrROIw3U+CA5elShYzxQq/HEYxUqU7SVnhhBTaN9nvbh9EfnV5xJ0GYilZy7ioHqG1z03Kdzyj8FauxViwdfXJd6AkxUMnmbPtz+tjKF0NwWHyuTxjIHCbKbFApVX8nzZw6ckLzUQZ6hwiXHqDpLbSPL0i6xD3TOMeDkwHrX+XV7/QCgco/OO8x6piVqvywtfZUBOIi1FpWBxReejoJTgkaMCve0kXugM+0YsmJQ5V4r0xQi7/6teQRtiWbpOLpTjo0yGQ/cmdd27PlwWmdoHKd+7tgWxCzn0Z1VNqKQ77/ThbPOkdOxFqpeG0gfMlQ6J7XWtAHP9Lh5WHrvmIwzbFRYfS1BYXVUcVm7Vnbm8BJ9JuPZPqWMivE3sRfyYeEKoGbovpcJK7hhp2FPLbVAC2uvFMBL8eq/TjFt4hLzEbCsXjGV2D7R7qG8SbLjwBCKQ3gAN6eQvkQL9sERTcZTpw6xuUYpJ682dMCcrph/m1bu/aalj0chf6/OgmuzHfztZYLn/Nu77wIAwk5gxuHJGlWRV87wU+BXWmg9o5RU6xQ/LLLayHNLKiiqMDpmxzPFNynaD6ZipDjN0uZt+E3LVs5ujxaR3QGxxAGg9EBABAmqXDxMhFNRp8FSsUWwmSGpO4ahbIrkQ89ECd1lIezO2M8EqTL7qTbikmUW/BOBQHeg0To9mhZzhtIi4Xu0+JeDEEfbVpdr2NaqEyb91OvwCVesQKDKMTP/T4IRXTAAaK5wn+ueQmGN3huew6UbInPNhWthig81hGpzCiw73YbT5wm4bzvp5dfUyL7qV/lBuOYaBvzBdWYI50O4z0aTC2nuYrf9HYXyXXpI5Ddpn1vve4gy4vjQ94OaNnNBHuayUAUNIPU5KwnwofodbRo0yTbqKyyjPtDmt/lNFpwMrU6TbCOo23knRezDl2hSF58MpTz56Vh4FsMZCCua5fn5O0Fbm8W8M0c7EHHPYdOeRXbJfSTWWrTOlhT349TQOQvP5ucZg4Zye4LwY0DBXYXGWeZG/JSeuq3TmiQgYOXW5WCdCKhfEra2PZbeO3QjD1hLzM1G8B7TA0r08+RhN6gkpl/9N7FxGmpsYxvb2Mb2XHshI4v2MsuAb7o4SqhgmWqMsnWTdALNPIH+Nnlebs+B5sRPNMmaPJMdqI/oSV65w/C312kbfsNBeIlC8Y5Dv8vOtBE++MVepxMBvfsci4v3MQlUFijaWLhMLkZrkEIwP1rpy6ZY6ruTgu5zOozVQQfbOfx+400AwKnXqCK299Ws6Sed3qBje+KQq/39q/fxwbuESxQ11gvfXcNqlcaKZWzgcAQTZiI0Eyl6cgHunmck0AVO2V7UJiwWDyn/jKOsADguJtQ87UA7zELPc9RWt2F05oD5FcyHaJ9K4LFOk0Cb/bYGHEkBWkiu7FP+ll3XLjhWL4hnt/cDErk66AfAKkUDMaur6iCG85T5FY84Urh6CK/O+kwue+33mSHeA6KFUc/YPbDnpPN0Hfd+qw+1Q95dhvHz+XVb7JWUTfkx91mvR3jyn9H3pv9f2p70Cc9uukPeNU/waSBm1nXC+liTNzVcvj6MvsXcTzktO2X5G8Mm0cAhZTkRnGM3eK2A6jt0Lod8H7kdoHGB4bysZtyZUybSlmsg6RoAqL/E96oU6xdwone0jEUSKJTvj6aVSqsRDq7Tecqcy+wPRbS8rewOvTbOKgOnHZQ4TXfoDWUN6HrmGBLbmXZPwK8b52B05SS7TbDw0bTixC3OYsSJ6VcultnXCJq0/703uVHTgbKtZCVdyTDZ+iVq8UzjQK/pqsI061UdXeR1i6dj+8IASuTYW5KnVYifsRS74U75JuvCt/FIa1wD//8GNo4sxja2sY1tbM+1FzKy+N4bdwAAfzWxYp52oR7Vdp/90EGbm78L3CwqxvAarN3yY87Hz5dMHj7HOlHFh+yNzcAUhYcZ3JJvrl0WD3PYuyZzTlFEsndUQNikD5p3LWxTSISDiVF1zeLtAIMVKRAz2zxSUOwWNHqstnmo0JljT4eLXwIR/WBwBflVVhvl+sSDnWkEAXtTG+RB+3OWBppcoVynekq1k0H5pE7P3Mca7XlmPjOjOGaNo/xWhH6JPEBRvy2uWv19YYPLWLl9haOLo9NPO9SaFgByWxzJ7YbIMrywzkq6klNOHyijtyQ2KFqGrXhNzh06iFM/jdDk1g/RJg+MshHI/IeU/N3fmERyjs6v/NVoQTHxgJCjktlZihgnMh38xsxtAMD/9PXfonPZShs1W6M5xXBWJ7TQxvYsjUv1qofcbdkHk9tY66s3bc+x+IgBBneK8ApWJwoAGstA5QF50KWH3HyrQ9d8f8nOX4/nXv6BD/99AmJIRry2zgCKtEZmTVRv7f7lHERRwO0qOPFoxCLw0LAUW8ivHP8Tq4wrzH3NkaPbV9h9b5QwCrgn+qR0Z7TppyKACWnp2p+OjLee4vk9eb2FzioVw6pvso4bs9l1ElsiJdcus1vK1MPCooAvlLlmAtsVfa/maVuEl/kYD+nSib5cv2JBC7UrPDel2ZgG4lcpHhys5s057b9K10AACG2GpyvfRmBhgQE6u44hvwosPbdq7zFTl9RSb9SmOP5NbBxZjG1sYxvb2J5rL2Rk8ZNPCR7iDBR8bpmq+YktHaW065leCpJnz2148Fsnc3TiMQiap/V98jDdO3kDdYsrTOb7qGSURQUF0n2FvOHCVy6a7xM0TyestdP0AXcUQdSvAP3FUUhh6tmwpANHOqJtdLUH3R29VK1zIVyBpUYnn/k51stPcwP59YU0glk6L8mXurfIgwnnYighY3Eu2Amtxx0w4fHokj1G8eSK63Tu1Wtp43rI92sXNRyOyOICHUeUpf+nvk5wdJlRU28y1OxxGZkn5PGLvMr2eykE5MCjzq1TCyzZEX9aQZu7BIrK77VvPcGdj0jjRCDRTp01qAouIo4yG1e5d8GBZ86l+jLle+uXYuRPU+6+mTBZkr1VvdRFMUvn/KsLhNH84mgJDg9qHMogaMSMNhNk3swXmsfRsQS8lvVAWyv0/cRjeQuGJ8cZjfQeQ1W5jpQ5sJ0JgyM7p1NHNBDdKbqQ1ausCly39TzxbnszQI/7V2juuoYUd/+rOcZbFtLXoKxRvCtQUo6MzkQG2SdaZgb+vOEZuZfOMh1slHcRn2EpFT5md4/23Z9IjKctiDDA1gikPlFY16aHjPRtaBFXFV7DRZIavcf3P5qHKF4U1hli/Zv2czleQS+1lhMDlU8xWsjtWpkZt881CIakugNg/13u3niDyZspmm+AhfCqxNavGjyXBQLstey95Z5lPa9iBrm10a6CUjcpfZK2yL5fUHbIPONOoFkgmeGB2xuFd/tzHehu7uSP/xp7IR8WU1+ICJhCb5kGwtsdTReExcSEwEY3CjZ0PGQ4YpTRiIsslMcpCtXnm/XlBsI9WkBKd+i9VE0buWMpNiXcZOfo9ciE5MnAXvxgl2ahsIGjCx3g2OIvN0JvUiM3x1i4dVqoXD9BFHJjlGe8kVwEgPchOO4LtABmV330OOMlOP7iA6DF9OuEz7dyRfDAwFaGfpB+yoXcocVFbqJwSp9g4IYFhiIONNpX6BgrN/hm2gcyR8wavcApqnn6zu63HJQecTj/ZwxSGCJXd+b5RjjThrpBD7WpRaoA9iO+uV9rIt6kyR6WT4pBuuxICK6//QsKvNHCAFFRitm8z1Ch+4A8gpi1k7Ks79VfLQDcD/sPnpDEu/uTEv555Qxt8Kzt6OPv0TlH87SN/dc4jTaU3hMFArevDEv8uKnIPuCHTZwW0YbK7p5cNSSF5PaVFQkcSusU/pIWatODne+Z9uKwpLpNd8lDQiy97ZlUhhxjmxex3FNlYKZzP6Ht1i4q6KcsOHlsLnldhdwVbtG6SZPB7cG0RDXaWjll7pfSE34AX2HYaQ/o5/jBzWKeuarlMEjK7vS/pD8yG01EZTqQvTfphg6OHPTmGLo7QdcubvpwOjI2tC1ZwMP8yYvTndaGp1RndrY70Gah9o5EtUDbV04/qWW+/x2N9gq3MNj3RsZsUMIJHlSYt1pZ8iDrzCnLPZtlsAnP6VH9iefbOA01trGNbWxje669kJGFhKAAkH1AaQuj1MlKpkkmQXeJw+NYWMdDLVSlYUtTIeaCnFujD89foFatO3+wjHha2I70mqpZrZzGeXoVVdDGVethOClyAXKTPYTcAEZMbWSAIhf32JsNv0Mn4AIIWW8pvMrNmDqe2R74NUhFGAhUMcOu3cOcOTcp6ov2DBQw/5fM5LzKDGEuVl+f3EbaI5fk9FXy7D7682vI7DFE8C5tf/2CQvk2jZGQ59IM95u81UG/QvuXArM0XgIsa1RIS9M/b2D/zVEIcpTVyK/T35Ke6Z6xnnj8/1ChuvkGN6lZDQBWV53+GV2Dx0/OIeTmRyKBLhanbZEv/5D8quGWqJIqcwYKMacygmcMWWTIdTwVw/0TcunbnHJMLloXObVKXnOYT0zasWG0qqRgnRjmtKRburN2LnSEeMeNhtIH1qeTqCBOKZSe0LmLomt7XqHMst9GT+s0K8w+TJsIQLSkCqsOiusMzeTITxo7eS0bWYpktttX6LACwuSXrOi6/IuiNXL7W07KQFCHtabEu5fxEG84zgDtO3SvcP0Z7fdb6DymeSWqxoOileCPckJVphevA5QYoNJY4bRvyUbYEpEIg37jh2Ws/GsGVWwL1FUhJXPngHXDXG0iM81pnXBIO93lNgcSaQ9HTalDPo4Jbf7WnDaVgrTTV4imODUqP/Q1gk3OSnDaWpp8OZFNy8r65tUdMw5HL0urVReao0WTnmsw5HonBe3Z6/I8G0cWYxvb2MY2tufaCxlZyNPQGSh0r7AKJhOgEoagFh74tpnMRfIEelcHSJjIJPUM7QHzf849MdgT3nvI1bIAmPmSPAZRatz73gC5R1If4cL1HucCfR+KE/zalBMyCLkBkDzZVWUAtPyR97pH5MG8dmkNziwxjL74koWasjESLmK7HFlM/OucUVrtl+ncpXDphFZxU9pxikcDAAPO7+8fUg3jvhvDd0cTyP/Fb/8Ie1zx7zImeP3nL5vPRVlUczG2s+Agw9Dj+qvsNikAPM6qT8dRuUPHsfrbRYTcrEdgyUmQ4Eh2ISKru1nj8UnOevITbmF5RmPpT+m4N7/vmW04PdZD4nrWQNRfFdD8Nveu4EZNlbtA9XvcFyTPHuNhEXGeIz+P6yN8p5Rvemi8T6FOzOTJ9EwHPfZAxaOcuKmQrnGEwLWLHhe1B9d7GEgvh4+5L0PfFjsrX9LOhKw2cT8yEFuRwWjPuujMcH8F9vYrNx0cvEzHYeoIVSFzWVkOIXv2J4AWtw1tL3KkPdT6oM6Kp9ltvoYJ4PA5H7xtCx+SyxdSnr/B96IPNM+yx80RQG8uOhHxSXSXOlSm7iIEPMCOqRS6j5Po6Lf0GhaIDDps2oWZTyKX0uHGX6rmozdFYySwcKU1+tOj8PWpn3kmiqmzIm36MZ1ndzFE7DAUn/W9MpUu6mWKiNwuR5FHyoyRSK+IrI3+BStxsOmbCNvlfQkB0gkBcDQT8PwK6lZzLL/BhNuCgs+RhOzD1GMiANHJyPCvsxfyYSFWXEvQuzD6Xnpbwukh3sNQuPjatVUAwKNDEhBqPS1CrmD9LHeme8pCa99RaHHKS7FAmHdgu63pCi2Ku+/xPlWE8ilG0TykVIXbUyZMLN3jdMGpNJJj/IrUJh3so7sXbDGT+RZe1TeYe9tAxaa85AbvzUkRT8NbH720vWlt0hmSytAsX725Pwt3nhbAUkAb+9//w6/Bf/1oZBsqG8H/DX5vlQqQgqkPDh10TjFbd5V7SS9G8BiJFE2zWNxvUPEuflwy/byF2dydUQin+OB4QQtqDg5etbh9ACguUMpO3ylj73XWFeKHUZzX8Jhro1gHTGTM1RAfYP4VeiAfns9C79JNnfmQxiM8C6R2GU3CxVIskFPSHuqo5HP6r3eYtuT1oVpn7T+n4zw/QQzyZ02eE59PGdFHt89IoEl1oiOcpEye/UCZ5j69CW6Cs2el9fOr9oGmjnW+NItNT6H/PqPIHjEKbiZEnKKNiKR99WVODfWBFM85eVD6TaC8yx37eDHSnkWi9VmEUIQYta8tYk8WyQ3PpIDlgSbH6ET2gSBpy8y/y6K1eOw4Wraw3edMpghcAjA9teustRQVLLNdTFIzZ69tIfyLORy39A4vttxRr/pGYlBTmnteS3p0+Q+BxjIdXP0iI836OZOqk+POHsTYeYd16PihVbhny8y9iAUvP6fXyv0Bdt+iOSl8kvTu6IN52DrziV3r9u0XMtxBs/oG3z/36YAaFyMEh99crnychhrb2MY2trE9117oyAIAMvconSCh6TDEsD8jODN+wvdtO1Oxl19Zw40SKbRO/5ie4nt/p8/bUgCntyIuSKd3PMQZjjK4p3ZUsDvtsUR5zN9PpmMEa2kMWzgXApwqOfv79N7We/ZzKaAHR6KUab1FwVTXzjsmrBz+HBhtGCNRhEqAQZk9eS4U9qYtkzNs0rk8+kMK1VIDQP2Iio3p36Iqef9pGd1bvOHl0bRVYV0blVq5BlHWNem4aVbN7MzRNqd6Go/nAAAgAElEQVSeJdh/c2QTyG8AR6wYa1IbsOk1waK31ig/4wzNXtlPaqaDZOoXh9ZRKRawMTZvU+/wzJmm+bzKzWq8Iw9BlX9zDIbudRRSH1LqqM9Q33DJcl56F7j51aQP7zZjW79LkUXrY0IF+H2SkQeAzCGz6hdclB9ywVrUR0+q0BtZ71QjgRNzamfCnq9tzcosd07PtBfsNqRR2MznLtJVLkafovtCGhhldxIDJJFCenfSMdsXWG2v4piGS2KadcD87cDwbCRVlt51kWbghKSfpm5wei6vzHGLNHiv7GBQGOWkuH2NXnnUz535gs6jdj4wSrS9qaHFgL+efTqqOosV0oeS7QJA4fKhkaTfu0HzpHy6hv4WASykzeuwTd6iyLPEjOnulGvS4P0JSZ858CSKYni+pLC7U46Bwh69wlD+2ZRNhzH4oTsUBAl/p38qNP+brAFPibCgLS/s6bHj9hNoNY4sxja2sY1tbL9EU/pYjvNFsOt/759pgPLwYWWUECO5xu7yAC7j7+KOfaIKY1oKy9oBgnly4Qa75DGm+f9+z4fmRvbuNHkOUdOHf8jbk6c3k3rUULFIsyLkxHwdnc/IXY65OBUVEmgOEYIqs5hrUnzESN5bzrPE+jJGfXTISZB8rSi1NpeVUV4VclviAVn2GoUdbXoHPNOoXeLxq3KR9X5kvHVpdHN0WRno69RN8mbqZzxz3KIKK0CBoKkxyEsxlceGp1t2V5uCtWg9hTllmNVphgzmNzS607LdY+MypZHi4zWtPIcIZ8Eya/uvM9kpUieisNIDZcZPPNgksEQ+lVj2LTCqmCoEtdShHiIw2jkg5yXnKRGjkOgAoPUm1YiCxxkMWIdIYLViYVEjnJQuXLSNhT92sfstVuPlfhrlrwLjzYqHLhDa/mSC7BaTFJnd7w40vA4XoPOsCsugCSfUpn4gsHQVa3N+mX0mplUcE2VUX+VB4sP3Go6JLCr3BX6rsfcWg0v4/ASi3bw2QO5BwN+nid6ad+GGEiXRNmoXXFOvqdzj9qi3KITa/e6UIc3aCHeofwnXSVrnaDxTE11kPiAgR+3loaI9qwd7rOCQ2VW2fw2baHYVHwOlxzQ5k0CaQlm1ACHvpo80ji7K+PJ++LjayzF8VoodTHEdc89FmmsPApN1i/RDvZfCa2/SovD1X1E2wB1YNQqj5zU03aXRkagBqAQYcP3o0T/6+8+tdL+QD4vz/+T3zEFL6NbgZi8yOaNSbJoNpRkJ1JvUdgLxjelU+vA8ujjysJj5GX2/dkmZQXfmmJn7NGPC+JClfyV0B4DmJbqYguPP7mo0l0avQ/fs0KoXyoXjAnbNMWxktzlUzDp2KfNPbUFUkCMDxmzHGVuMk4cFtL0ppZuXpC96szGmf84IIpnYNQ2vy0iwS8xo79gHjNR5ZQF0+zatNfsZjdXh5ZQ53j6nwKTHd/0Cpb+Om6Qa5CYJmhohM4hLzAnYf5nGtriWmONprHAxM6tNUVrneCH5mjkSKbtoSNHv8Cow+9ko4i1zYBdKkXcebvYk+5R+7plnrgFTlB8wcqugELC0zM735QnPacAnHvqvcY6JnYbcT/Oovc4ChQtEXql/QloZia8RnaExnSjT7w6elc2YZdet82I68HE6zN+QHtt2Avm868r9yHQOlB7Qbsc+mEUaR7gg9XOOKerKg7DwLDZpHDFBlzkHAYLaKL8BGEqzNviBxqguQX8BQPpAhkcjfSQFcXqtXXANQ1kQWzFLu1RuOsapkMJ4Zs/e91KElwV88YOulb+4+QQAsPc7V9FZoO8VOQXXWnQM0klxCtllSRC13EHmU8pXSoMhOEBxfVQB0e0nqL5E16P1BjkJ3lCKWhq3idJDfzJB8dHo2EgKPH2gjNMnczQqxshusCgiAyLShwlaSwysOcfHLyKELQ+a5V3W/8t/+NyHxTgNNbaxjW1sY3uuvZAFbgm14pRGg6WkjUjakHSvPCrlCexEJzHawZ0susv0xHXZY6haOgHOv/IMAPDgCdFw8wfKFJYNG5O32ZlPULrFekDsuTTOWvlikTR30jGCB6LYRy9SyArLCRbPU3vUZ/e4CLtrhee8oSJfc5nPoTHqFGS2XDTOMwab25gGR/Y4Je2SZ6nlzIGVcxfL7SXoVaQPMkbOEwAmb5PX1Fyi78Rp+/nO2zTgiWulkkUafsBkdr3YxdQf0xhI29bsjkbhKe1s73WOSppAmUP8jV9nfS72OuNAmShJPPr91xUcFnoL9kY93om7EZqLDInk6yOQUcDycRI/NcI3AGDk4P2mMp6ceJYA0OfUwT6PbXZbjbRMBQAnx4XIgQfvNnmi3RUbZQp/53CPCuGOXK/FgZnL+g+oyFrM2XnYZgn09IFjIhyXezWbHsuJHnIN6Y/t91wLHhAxTU7rZrccAwOVOaQi6+G2X6dIp36QgsdpKrc/OoeyWw4yexw9sCx5HFh4rKTI5DupmsLkrT5/ZnM+QZPGtl+yPaRFIDO7D94up0ovKhNFCGdDKyBdS3i7tI3ik5NRrT5DQJeJOx0UNxiQMS1Cfhor/5IBCKfpPel3DthIW/H4T92y2t8SEaXXjjChKnwckguml8FsBKhjenFdhQarA+QWaZDVpzaiFCa+pI57zsli9f5bgIqSkX0ZU0D562+uEDWOLMY2trGNbWzPtRcysoiuUUIubAVwmtxAnsltwkgs3/JMU3SBDSa+haBNf8IszMMItTbrr7DX5LJX6Q6AB0/Ju589RRXjvVQR2TvkFUgetv0WJXJdJ0GXJX9NXeNiF4fsfecmaMPdzlAbTnbGhotbm3don+KndedieFxg9z7P8TkpUySbvM0tWU/ZhkdRjn49cYc9qhnHsH+lEC2kJa9nvRTxVhvLrs2/smUOEjQl/znPUNFJyQFr07ReCoGZXQ3tMrntMie7n5ELlv46a/SlUocnvTyJzKqvaMOKP+4a7b8bG/l3UfEc/oqcU3FNajTW85LcdZhXaJ9hstJXFM0MStZTFMXY0mf0We2lyERJ/gqTA78qGnBDYZWLzmnrTSuGbgebltAnJrLeSWCLjWIS3QyanmlLKuMCWEKkuHzduRgFJuh1xNPl28Lt2gKtKJ0CtvmO5Msb13lSbdk5mvAYF9ftta2ds8cxeZs+P7rEef7PObL0gUxVsNvsoVcUslwcr5238w8AmrMEfQUsdDZTTRBlOOK/Tu9Nf5GY6+z2uPnRwYDPNwWP34vSwpyO4NdpJ+mqraMBQG0lDY8hs5k9gSxHSFwhAnKB/q4lRIpluV7qPckaja39V6ynLvuXaANnrEbc9JcCQKDvZPZ9NM4zs3qKI9zQQeFLjkAeU0TRZcVbfeQY3S2JmvKbgHYYYjspGnmxgXV7NcHa00v6cDQSfJ6NI4uxjW1sYxvbc+3FREP9/n+vAeC9M6v42cYZAID6unDie/ExtE1QUwbudvYPyW1b/42MyflJ7tddIi/Y82IMHhE0YfI6JUdrrQz6be75wBId8Qo3c3ESZNLkYXQ65MGotQzCGXpvaYmYXo7S2P6MaiCi9SJNXAaTMfy6yDfQZ6WHCk06TQsBHCiDLBKIXnfObku2a6QUQusti8m2goZFSAmpp72kkKbSiem5MPdJbEhZouIpeefyowSFNRq3/gSde3PRM9717Oc8LlPk3Ry8kSC/RufZn7T1mOIaXYPDlzhiyWkUnjgj5yceXaqeYPd7dBIzf0nb3f+VAebnKAqsd0ZPuL2XQ/4J1z04mukPEdrEU1cxjOqs3xz1p7w20LrI3jfLh0iDGmC0rmPQcjujHpxKgBZrdg13rhFEHBZpPmU/oTAi/G7D/vgrmo/pA43iU7pY9RXrzQqSRlBLTfZWUbA5dImMu9e6yH1JY9S8NopLzt0PTBST37DjIrBUaas6cUvDZ2TUwfVREml6XyGU21IQRy2gN2MRPcPbcrvKaCZN3KdIoLGcNjVHQWypCJj9nL3wvowjvUQZB9lt+u32exSFZ3c1clt0fp05Js3yPE41bI3z4GW6eKWHtmlYZts2HxFF3sY52q7UpMKcgsvRkdRLlNZoL9D2yg+5nvWqa74ncyM71JNCIn9B5anEShbJfWkaXtW1QWxJlDV1MzbQZ1kTUjULPTfqvkPBVY9Vm5/8/X/w3DDjhUxDKT6tD764gulPRbGPJxxj/LvTDvL3mB05MaTRMj26La9t0znS11esU8sgxV2r6m26qcLBEGdDioI9em96/gi1TyiFZL6VALkv6Yo/48a+Op0AM3zlGNKYv0vncTijTZpAFqrad7twN0YLYl4XqF2kv4Pa6DkFdVv0FlaqYP0B2xhFmre0ljSKq/RZi4vm+Q1tw9UD+9vaeTpOgT1KY5qgbhnd2VU6oO7kFCZvMyyZu4ZJyF985JrFSLgSTgQjjph/ymCASNkuaPJA5XRhWHBw6k/oe5s/YJjs5ynsnaJrIFwaSbUEoWVFC68ks2/HTY7D7QNZLro2DIiA/m8uA5Of0dWtvst6V6+3oHmhD+t0J2afegi4A9+5v0u64U/+FeHhW6c18k9HuSODojKd8jK3aWAE9hzv5pCT9NKCADocaI8WPmHopg7t+QnPIssaTnHKNTwfWSAKn2Ys1+aurErg7VvBzu6MpGRsykgWyuorysBjpcif2bJzRFKTfpu2tfeWFSaUJkJiwZFCmmG6vUmbBksfcdGdr1XjjIueFLv3aMxq52wquT17svtbepvu436FBku4IYmnTMpm7hObzq2xU+O1RRRRwW+wSCCn1twug1IKnhGBbM1JqlOh/RINVusyp5qKbegv6WnucZparrHbUwhzowXqxLcpceFQDXN0RBB05lP6f+cdxzgm4gj6nQRdjIphSkOl1K53ApTwN9k4DTW2sY1tbGN7rr2QkYVzh1hok5s2hJeIIsXh4/7rCvmt0d/1poEiM6HXf5OlnPswLUiFuBT8jLYfLSfo94+lIcoDBOvsbbDzU7xBf+wMJoE58jpyM+zifVJC7To3KeFtpbY9o90k3qwUe/0D70QP4eBRBuX7UrTjNNAUMHmTPo85EhFGcf1SjNID9ijZ40l8m5owWkKGlaxMikqirKA5pGrL0cDhFc8Quopro4Sj1ikPMRci3UlWyiwrk1oJ2rS9fpGVO12bFssab1IZqKew4ov3PUPQkkhEvK3OgsbemwxUGEr15LnwJ16tkaqfO+lF9Sa1ISsKudHt23ETclP5MTPLjzwMGB6rWH002c+ZqCdcsOOi3qEI6+bHxBzTywJhtMch12z2kxD5TdqetOEU016C3uvcPviJTa1Jekait/pZd4T8BsDMM69NEtaAbZMKAF32bH3+zKQ9hqW/eDoW1zT6nIYq36X3+hVlJOQ9Hg8BRmT3Y9TOSftQfm9LmW1PfcHb58OpXtfYmxAynD1W8biHz63NKZjepD+yfb9lz6H0hBuFNWPUr1rIKQD0WU02aCaoPKTwrn5mCEY6lE4CgNZCgGI0el925oTsqUzKyecItHZFQzPhtsBRW/Ocg7nvkM5aFNM5VQ+41fF+YKJMaQqVpCxLXBQZBIDSPAvkNmj7osoMwEDsJYpoXNHI85onGYUug1PSBwrd6W9ehhhHFmMb29jGNrbn2gsZWYjVzwMxSzv4nDed/4g+y+4o7Lxri7sAkN20RTIxpa2qqZE64Hxm8YGDBssJiNxH9rOskSsQD0lgmMGBawpWzXNc2XulAzTIsxBqvTPwTCHsONkudajgce1EtHBSDevmtRekeROM7pLDqp+Zfc5xX++i7pAHKi1fh3slSOQiHjcU0LhGgySNhdy+xuEVd+Q8tWM1gWrn6Xsi+9AvK0RZlssY0tL3O1w34MhPtJYEkggAjQv0XmFVIcfRYO2Kzd9K5CeAhWzvr8+zhnnrQZ0wZQvAhXVbrxET8uGgREVLwEYnG79iG8x057nPCJPVtAuEJRqX8k26pZrf7iKuUigkN5m/TGFZ7yADl5sIuUPn0li2/RcAWzPIbPgIRTOraomg0ndFrpPbI2gvAOS56D51g75TO2fHU0iF2lUn6nRi/ckE5bscQf0CEIyZ83WN0j2CEHfmqJiU3+Zcfs4xc6exQq+ZXaDyiHXFlnmu8dwo3weye9zcaV6aPSXYfZt+K/1InAEwwXDdGmstCczYiexcbyzTNibuJmgtsGYcR1I5rhn5HWUgsQIDn7gfm2gqzNslUuRrUgxVlTnsDKnuinZWqqqQYpKlRDp+zUXzAyba8r2am5LMgt2GQL7DgjYAFSEAisKv11EIuTSTX2MIb0+bsTy8yrXQxx668wyt/QEVfSoc1YTrU2befhN7IdFQl/87EhKMh0ThXvuV+wCAT+4QAPzUUhVbu6OhZ+WjFBr8sIi4kY7XtJLJUryTC9I4p1G+z+kFXjygrLZNaZU7q+VYTE9rcwMYxuiMYyaehJDD4bQsVnGGG/QkCpkdLhhWTqKbBJ8dZpXVL6pYNAlA6A/pwCUPnOaSY84vtyUicIzuOK8Rl7lv9S4L+D0F8ls0Rs1TjFqqKMO2lYeoXqa7NP1F1oTRpgd3DAScYpIUUGGD+xy/BeQ2OYXEN45wQwCg8IyRPsueST8JgkQsnB3ArdLxZrgpTHfWTn4ZDwEidJYjpLdH/SO/BdPPWb7vREOdBrkI67VOahyJxSmgvzCqGwRYYUm5nrktRg29Yc9j8ce0/facaxj+4rSIOaHCgLsKSurBGQIvieMxnNrzmxixKAuT7pHfhgWge451nGr+yLZyzxx4bT3y3qCoUFplSXUGIqjYIookdSmLtRMmOLxCC2xuhzk+gTKd7ALq/2QWuHQtMQuwpFHcAbD/KqemGITRPGPTt4K2Eoew8iA2HAmZ38X1yORQGkvCyOaHRRtm0ZX7Uyvbea/ID+QorcyDoHzPdCCjz/KBURxon2YRwAPXAFUK3BKguWxFAqcYmCPrkddV6HLzMOFchQWNVJVTWes8N5gN3i8qTN6lG1rWn8RX6DKXKLvPDdzec40jKibNwHKbdm269U//3nMr3eM01NjGNraxje259kKmofqXyO2bm6pje4dYkZ89IYyjyyzF6sYccJ6evIUifb83kUaSlrSVLbSKCYxQGN/5pw7k0TssL91cZo+xOjp8R+d9y/xlWe/c5lBjJIboxSnr3QnTO2bvJr0z1PSHo438umvgo9ldLsadTRl4pGZvTOB1w9aeG/J04xMfAyB46sRf+ub8yDScgUhZc0GsqlFnuG6c5/M6Io+qdXlgopLBLKdMngamGCwRicGEf6nALb4NNNPrAoUNBii8bNuHKi0FP0l98KacwEQDEn04kTKKtTLGPW6olNnwTPQjnmvzcgiPJecFBtxcdpDl9qGCURctoSQAupI6kDa2mRhg5qxmbzKousivy3FyymGbdu584pvUojB+U0caWY60xMOVAm31mmtkpeW4e1PaYO9LrxMCoDvw0V2jPNvgVZrzAuV1Oo6RPhemeG4LyDFXqHlm1LH02tpwewpr9Bo0NbpTHBWwIm17zkHiC+dmFPqZqiUmKvFb9Ec8YRVjRUmg+rYFgMx9SN9vnOFIcSk0cvV9kyjQhpszmObfcm/6ygNbpBYYeG/aR4qbWUkaVKywEaNX4X3xdY3TtrAMR1qoWkn9/W/RZNNpbk3Qc+HzvZc6FO5QgrmPaRPCKM/uAzvvsEZaQSJ/+k6UAYqsFN39DkUu6Zt5AygRE4ABADz9dUIvSOq78CzC5E0KKY+u0s2V21AmFWzm8iM7z3I73zwNNY4sxja2sY1tbM+1FzKy8B8zQa7SMh5d8Ijf4/4TQROo/Afymnpl8q78UKNH9SXjfYYFC7sTMq0UEaMMUH5Mnsv2u0y8+ypGfpu+J4S39BY9zVsLFUzcpe/vvkUbbS84xpOS6CQJLGlqUBp9XvcnEpTvsddxwJHIUCfYo4spPk/LGhUTT5PghvR3b4YVSfcc00Clyb0fVGjP++gl+juzQ6/dGYVU3TP7AoDW6QRTX9Hn1Wujxx1lYpTv8TE6dO69MwP4HG2Il+c3rFcjZELJr2uPCFcAjFKvdoDeJO+DwQzSW8KxpGQ7BqFlYkc5gYUKaSyBmqVBU09P6jTVz9lzCnO/OIXbWlQ2sklZr8zhsRLvXbsAczCR5t4Z/Qp95/AlhZBJivMfknfanXIMQSu7I9efTnD6S43qS5xr5+vp9hRym7T9Totw1+qdGlKHTGr8movr0pjouj0fyf2rhFjwANDpSe8XWz8qrgphjL6f3bcNsWrMGo9TluEfSAMvjmC9jjJtaY8uWuBEgZnKtRU6pyIrNXs9jfpZuS+5XjJwjCJzUpfGQQoDLsxmVyWSoNf9VzQcLoTHS9wz4n4GnVN87/HXc8/4GNsJwJGF1NMAIH0kbGobqch8O/evuNGRy+q933YN419UDxZ+GpqCuMO1q0FRYeIW1wsZItxkOHX2mWOg2+EBr2XzMZIDjlS4H4zsJy4kBtQjdZu9N1zkZwo8zuawzb4Mg3tIhbtXHpPyxja2sY1tbL9EeyEji8IbB+bvMncO6zFDSXRpurNAjiOA2nXOLXsJ0lusUy+yCa5FyxRvMRzvkpWcaM0J7Z++s/emY2B3ihEhGe63MOzpS47b7yZGU0byzUmgUGfvXvoHpLc5X3kmhFwWQRBpZ6i2wbouTgiEDAM13dE45+r2LZpHVHbThxo97kgmkEipg6QPrIZPe0nYSMDOu/SnRBsAsP8mvYoXmZEIYCOAFCQEfeG1bEgUSZtHtu7pEGFhVCk2t2m9HPFge5PKoIjqpJZh0C5OCPQnWO9/icKTwa0SctcpETz4iEKSLnvjetL2hRBU2cGrHmY+5zoW59V3vuUbeOTcp/S93bfogKa+ik0Pj8JD21JW9I0EcRbmrCcn18Xr8nzZVaa7Yp0hpf2KNvU0sDzDk99hpNeWa1BeVEej6OnoZTr3Uz/m8biXR68yOs6iLAxodJbogATiXHoMg5AqrnOvBobvFtcSE1FKrj7xPYOy8zq2hrfwofR5cMx48C6NCeIsu62w9R7XAXiO5phcK+MEkMorQDn1+lkaZ6klLv64iyd/N8Xnwp52VuDXDlqn6e/856xwXNXGM1ejXFK0Fj1U32CE0idMKoyB7iTts/yIayKRRlCj+1wHoz722f9zA53LlLLoTtslVSROCs/od/2yh/axuk7uqa1jytxxOo45DonuWqbbJtcn1h0Trcv9P/OFLUqKHEqUs1Byo+vF2lz5DWXuqW9iL+TDovUpVSy9joWqTfGEy/OCc/B6goNXOCXAs9cthOjxhMs85aLZVGIWN1mcBTZXuwSUHtDfAk/NbipM3uG2oVdG5Y4nb7XQWaAJKqznxmk7OZovsYxy10VlmSiZgzu0oIVcdMw+8dE4z3dZIukrZVIqMTO4J+5FBmZ4dIn2UX7M8ETfMkrTC/QwPcynUbgti/domiZuKgNDlofi8OIuPZhTR8rg6xM+9aM3uVdx1Tehr+gTJZ7VPirdkHQIb3SoX7k8CFVkFyHZj9u3wANJsUgBOEpruHxjxT+n6mdS0DhiVuz5X9vAsG39aMn0PO5wOjKoW70rhwv5YSkxonLiSHiMlmwtugZIIPPFCYHUwejDvHs6RGrbN/sAbJOnyoPYpDD3XqeTye4qDJjd3mLJdIHr9mZsalJSCLkNILspDyv6vnYU/LbwYNj54NavbtMx0uqpI3FCNCKRqz83ugCGOWVEIuWhNyy6KPpSKlJwvxx9QAnkul9wrOz6ULZDuFHRDDOsawFvXxs9LUmdRBkPM5/RBNz5dtFso8SQ9pgfXiFrHNUvJEbvSCDigH3gyb0tgIiBr1B4wG0OXIEua7TnmZHN1795zoPfYhFKZmm7DABpvb+I7F7Ix8vHnXMN/2JQGtKTY16SpLwlLdZNDcHGmQMU5oHGCn3xeMo18RT8CzSxBg9pXDpTLvKbdLGkwZkzsPNu5ue0kTglMGmN4hN8YxunocY2trGNbWzPtRcyspCQMyxqFB+yng574/ocCSCVcz3Ujqi6puonWwcKa9tvKsOwhKQQuNBUegi0TtNTuXRfm88aZ7hwxU/7xstUYBSiEgAcvcrknIk2Ls9S1evGV8TAyW04OPTIE86xJ2VIVAroXiEXffpHTPSZB4qP6WNJHe18y8Wpnwgzi8Zgl3WS1Jk2whq5oMNl3M7rFPdfPkV5pdqzOQBAFykTXUlhsfTQMd7vcD5BzllSGrmHNHjDbUglEtCu9bQFKrrwV/T/1nueYXoL+bD21gC5e/SDifucMkk5hqku+5Djyu4oI1sunlpuS6HBaZbH9wQDTQcdpIHOaRpb2c8ws11SSYVVxwAExCMWXS3tDLGXmd3dOJcY8pRAHWd/4sLr0TkLk9jsZ9Ix2kbD5Dkp2ooLJ4V8SqFIsVlAEgrNM0yGa0kEbQuhBkatWL/Kt6ABIc8N8gqdOWkQRF8XMEFYUCZ9UWeG/cQtZTx0GYPCmoOt9/hcOPo6usCM8gGQZshqwkPQXEmQYyXckOHlAoMtPQTa1NnUjG3h2ZCa8R578kspZA+EbHqsde4thco9upH9XdpI7TUrNd1a5gzEupDytCW3Fm2BXiDwm79K3y/es/NaYL0CREg1YtMGtvKA9l1bSZt9+trOUYnS9t8ehaw6PYWkMdoMCoABMcialLxH0UTnfhGyqkXTrJYb+0g8JugNDYtEU9Vr9AtJaQ6Kaqw6O7axjW1sY/vl2osZWQRWhsAov7LnPdhnl/AH9vFcucWkofksnMvk+mkm1GkArmg8MelHVE7DvDIeV4Y19Z3IMd6m8UQSJkz5yjYWYcdu6X/2sHGJqpjO9/iYNjLIbHALVD7+9ivkHZRv2CjokOGs2k0wKEthEbxPhd3/mrY3U6QDzvkUaTzYmYbKkAvT4xauTt2DM0f7uLM+j2HLnWmg3SRPKP0gbY5LCvPhUHsAIaK5beuxAoDuWc885MISOh0AACAASURBVKKzykYo/Yy29+xXWGeKlX29njLjnQxBgwX2uv0uF2EfWAJYyOMtEglB3Sp0jpAreX5IO0k9oB1kXj1E/5Ab14ibpGxNobtoC8wzX9JYdrmvgXiErQXrX/l8XOX7CoWnNLZHl+z1E30j8VLP/Fu6TrvfnTTfEahq9bXEwIrDY6rDE/cSOOFoDWyoZxKqr3C0kdKY/ykXMSdGyZBuH7ZB0FB+XMiHEr2JVlWYtYAN0So7ekmbvL4eas0aNEe9U59h4b1Je/9oUcj9WiFijS8hymUPRDXXM/sUyO3BNQ+TLsOAu3ysBceoLwtoRPYjZDcAePp3qDBVXEtsf4dj0heDooWgi5RG7bKFdWe4LuSEthZzWB5dNnsl10R0UZpbLg9sBGyUnz3qLwEAZ/8NTajqNYb1t/SIfBFAUZYAcUQXC+tUj8seKkRfkxZX+VDOHTD1yPe5ntH3ETNxNsfNxqT+1ZtQZj35JvZCakNd+Me/pwFeqPjwBeMv+kJR1oZiUowtrNlzlcViUFCmc5csOHLR/JYyqB9BC6X3SeocsCkECflLq30MeCLlH9BsC6dzaC3QAQj7tT8B9Lm4l9plHPUsFymVhsryYnto9XqSGS6OV1mcrBQhUxwlWvR26A5Lb7sGZSV5Fq+jzIInmjUGc76prDy3QVFZrLYsisMFzvaCTR3IeIr0tSyOvUs9ZO7acBywaZr+hE0B9bkRlNN34HNBPl6lAyo9AA7f5wNp8XjwAye9O/zg5pukONxpkM9vy96sgqXv84OnN2Uls4UPUVwfoHWKxlkWEEFgVe61cPAqHVuYlQefNjfdMIJNHgQdZqgvfMQcjzDB4Us0SILOOXw1QXqPC9C8iAp/Yfaz2Dy4W6zT5XY1GoxkkaJwZylG5aYU5ukzuRapujaMabPA1hMM8haNA9j0khNZBrw0fjp8WZt7ZOKGTdlkDkXQkDYsD4soo07MIZXYeSdKCDIn/KY2iJ3hArqkjEVjK7Nnu/PJ/X/EDYaKqxoBo9oOL3OR/5wlHUz8LODt8s9doLWEEfO6VixShDjTv6BPvDCzD15xDG9LCtidOYXK/dFUU+JZzpKwxUWnKb3vmHVkWCNN5qRBUvLYRTlltLvE2ktWjywssnM72wM2aBIkp2j+6UMZA4X8Oo3bzX821oYa29jGNrax/RLshUxDhUtD9ERWyzy6xp7fLXp7uHAoRer6OWDqJuPrX7bQTCPBzV6TMKfdHtDhvtySIgBsT2IJhYtPrQRo9hm5dM3LFd6oLYiJHDlgvWMp1qdm6HdxbB/wUcCpsljB2SXXLy4y7rvrwr1DkDnxCic45SCwUGBUD0oiCoHHGo2eIed/4t6A33PgN1l1dsnmiYrrzKZ1WeOGW5z6TY3WikA4Ge7naJPike9J6inKakQTrNTatzmkd0+vAQA+aFDf0/oFH5ohrTIykgrpTScmbSJtZIOGN4Lvp2PlYyhr5D+k0Gn/tym14bdGNaEAoN/wkNuhY2tzz+aJO1S9bazkjKct5nW08fyzu0PXmKHPM19wSnCC5+old+i39Dr/U6B4n/IJh6/Q3AlISBkH17yhNAu/nrb7F8nx4NAxEbPMCeE8HF1ykOLUikQslOqxHjwAo8Cc3U1wdElw+fS74iObspEIJF3VQ9BmjtAd+Y42RWCJShMPpn1send0+elXlNmG6E2FQxDu/DMuuJ+36d44y0V+Hp/GCpAwDyKcorlcuJUy6c0Uqyhsf49+V7zvIbvLxy9K0bMKOmBmNY+HE9vUXm5vNGKo3LUR18Gv0QClHlhoiagBxIEdtxOmKDIAgCzL9A/fl93Z0ahQuzZVJtucvJHAiTlVl+M1bJA2MOQWRqP8xNdonRlrQ41tbGMb29h+ifZCRhb5r+gJ2Z3RiGbIA9QNOhXDNk0Bg4KQ2uh3cQDsvWGJVGJCUpI2lYb97Fhv3HjoQ7l5ab0orR3DjEKW887iVaaOQjgheRl5Zn43LiRwBpLfZ09qneoNcdl2b3ntZWLMJNrBjdVF2hm3ZlUDZbwlaQsqhCAACI5G2bRxRqOwCh43ehX4phPaIvPTv03jeOqDxGj0C4y1O+uZhvTiEUtO//B6AnBU5E7YyK+5wo1ipOjM/R7croLLiqfSeF57Gh/+9BoAYIprUO5AoztF49u4TMfhtW1TJvcCefzdPYoUCg9dE4KI9zl9gzzM1oItPgvZ0ok1uqwGPMzuPXiFjq3wlI5t+9vk0vttbUhOAoToTSjTzEbmhtvVyFZHvbZUjXYw83mM2jnOG2shKzpoz1OXJ9EQk1a0lQdAjeGo4k3mti2jXaKB3pRVRhXvvrNM+yz+f+y9WYwkWZYddp6Z+WK+e+xLZmTkvlVl1t5V1T09M92cVVQTFEkNQIkiBhShH0H6kyCAEKDtQ4CgAQRBgv5ICRphCM0QM5xuzrA5vVZ1V3ftuVXumZEZGbuH76u52dPHvfc9s4jsztJMFzEJ+P3xCHdzc7Nnz+zd5dxzbnpGgEq0IMaLAZw9BkAMkwCK+FwK+Pq0Mw7yj9lLFYlY5cDnGos0hIk1zrkmRy/Xwh0B+TXRlBD9C1tnkXy9HEd2FwhYArVyh65181QBq99kLQdmAZDO8zBj4dRi7YsjvHWWEDB3LnPB8TGFuK1zY1PEbr7BGYK6jaSlOB14QJu77T2ewyJI5IwsM2/pPbrXB9P2GSBQ2F6MAdrnWoQTWn0SKeq3j4tImoJ2k88JkX72+patWaLZ7oJjeLekIXAw5RjBLwFFeAJIcNRT9Vl+lj2Xi4W0qwNA/jZdWEHpSIeuDoEKF197c/a70pEr+G9KIdDfpmDdtDd5us049IbN5wgV81BALUqonwFvmCyuZuow8ZtcNH+lje4O94Dwwz8l4jqDFMITsaYFNs1pgtya1RwWUrH2adulCwCprsLgDM1QKTC7fWXFdRilIZQTIj4TP47NtxWWf0AramuFTibdsA8jWVClaJpfd23fSYauydRHrin4yqSUPo7sHtA6S8e9eIoUvPbbeaTfpYeyaJIXnmgr6FOX4i4/gHx73P66LNKHhs5Y5AHbb9K4S4F+6npsA76H9i45CTBE3KhAK0VMPq4YwkYKue5II93kXpHsgT6LGc+MefsY71fbeS10FU5g+yek70AehHpP2dTLJXrIpTfsYigOUrRB1076M4BYeqOTMv0hwiAg1l1URgddHA9xcABLotg+HUGFXuLcZe5Xb9jrOHONFfDmHTNPnBHtd/o6HX9QcFF7kcYqxec7zitD899eZYfgocbml33+zcRho30yNEitDDsjw3m7iNU/o5v28hvkiLWDDB74M4l9FI810arTb+2+Rcc9/b69hrVLvAjwPDzxB/vY/RIt9AJ+GSwH+Hu/820AwD/733/bjIukq6Q7fshiSDqlsfRd7tjntFJ/Vhm0pGjZi8rlOGeBG8Yc2+v1tEVAFgm5B5feCbF/4fMvAZM01MQmNrGJTeyZ9lxGFmLuUBkPJMyIh85F24xCazWZctIpIOTiaPMMeStHvqPRm0kKIflMDe0MQ2S5H6Nxmpb4wkZoVvvcJnuCRwWjbo+tfo7ea//tEfrsefo3OX3WTSO9y2mFVrJwFXmA3qLtPt0miVg1NwTYs+itclE4G8LPk/sw5dNrf8TpsA+qpiAu6aXI08Yjzm1yIZeLzWGW+KcAW9D3egqbb9JBiS72/psBctyxzT9lIjnApuoWfkD7bx1Thzx9Ka43L46NANXWHlW/05kxOq8yrfQajUH9vPWgjbGLk24qZP81wVglzaEdmyLJMFChuco8YFVluaok6pxXZn7EqeCF2lt6EgR+HcY8Nklf5nYi7P0WfVB4TwqbCt2FLB+nTh53SxuKeuEBAmwROHsvebpjX5l0laRnOkfs5znWes7U9SGNc4FLN89q03+Cp4hgZfY53cGpkPyGxnA2uU2qban1596la7fzZbsz4S2TzvLSPXtuNdYJX3h/BK9NAx5l6D25dwdTDsp3GNpcPezHFtZobmhXIUr7vF0ybVW645oIXsxtu3jvY1LtSvH1u1uz0cTct2n86ufZ8+5nkbnEaQYej8a5AqI5+rLu883ap+O/9Y+r0FXeMZ+yt2l544r/LjGaNm/P4cxF4ka/fS12AQG4PQcjTsGJFHK2rjDkvhG5j6XQrR2bERHocrauDok7bb/mmi5wSfFJG0D7qGtINj+PTSKLiU1sYhOb2DPtuYwshDNHezDLndQgpEid34jQOco5X97Gayv0mdNIxfKv7eP06jPMr3GKC7vXe2it0pIuufmtN13TNCUWnia3ZhQ4GE6n+TfZM10rwuPf6q3Qb6fToWmuGUxLEZ62Gc2Ehh3UFtUjOHvCjMm/6TsI1uk4a8LFtEKeVxpAWOBc6CKzwj7MGq9eTApeSj89xznNlO35JxQyDWZyhzdiGxU1Zu+JsAs3T+1p09i1/6LUSeiz+XccCMY1eEAXbVhR8BgqWYgRxgpD6HiJD/IJnbcUFQFbP1Bjm2OXorNY8XFkmutk/KO09doG3BiZ3XLRYhEegaxK3cTrHC4KBjmF1C3aoHuU88E/CKG4yLj2DdpX5ZpQbSsD5xUYrgptdCTF5fZxjgS3gO4R+rt6g2GSn4UIhOGUX7tLyjAEt0/SuUx9LEAH6xd2V+09IJGfXCd5HU6pBFMsnVuEDM9TkYhd+H4KmRbNsVSLxbWYOy1K2bGS7v6dV9JY+j7Xwni73C59r7AxxqCSrO84I/0zhaiAWESxRvvYP+cZKPTey/ycWBig9FMRR6PtC39E7vWw7CC7T8fjDixL8PAGu9/S+1eJMPevaaLsvcT36jQ37t3x0Dvgoc+/H+FfvPPrAGDH59ftNSjfovNsXOLP9mMdxmztI46NkveTfr12bff949/i+/S+Z6JYn8EV5Xv23pPmTbmuQUEZBoTPY5PIYmITm9jEJvZMez4jC26K6S46BuUhHpK8DqqOkTgVSUqAIIRx687HUCLi2TH8sb+QRXGdVv79c8wvtK3QZzH36d+iZH5tjZK71Q9TaLwgNBv0kmo4hq4AIsN5O48CI5HEwxQvv/SZZ0SNRNhFP8oZ/h2B4Xk9xyBpxEQqNN0E+ieSnk5wZARvi85BqAuGXAcJs0CWua+idSuus3+B/pacZ5jWiDiHK/n6MmtodJZdDEtJCGp+a4zGaW5q42bJITfnpTsRMjVufGM6FBXZCFHy95m6RUMJpFi4p9ornqE1cQythDIwXRHTEZRb65TVnajeoYOsfz1A2GXEEEd0QVFjXGY6lrogfWgf3RUbLUkOONWxdTGpWz36OyGqP5EiiDQr0n+9eW2FkRipV74Vo6DhMZIxc4MIXU5xC5Szdt5FwM14AiPtLvmmXuA/YW0Mbt5zRjDb++tWtElqZamxHL9FNM3+lA5IaDnC8hjDCsujctGKxJUkkqSdCZQ7txNh95Wk59o7GmLzl2gSCb1Fezmu98BjwPeA11NG42T/AoWY/TllamWpAw2SKgSGTBki81AklwFL9yI1phP/awSvxhf3Vepm7S3pQyJJ+ccOBCsvdcaV3yeekqCaRbMl6Cw+p6MOqjdpUgQ5lo+9B9zJU+fdjBw31xEHKyO4l+jkh+/QBOi/1gN2KeoWgajGeXpNtR3s/k2ebKyzMc5rU6sShGa2bsenv0LHk32S4u1xqIH159lzuViI5batmpcIkghfDwDUT1sSMIAm0qiS3Ic7ANyeQDHpPRHvaa66cAImg+NUSJixGsbtNaLArhhiNo3Z9+giFZ7QE6W9kjY3+P6btFWUBoKvEbZxPGbYLRP+FT/OmIlaWKPXTFObYr1Y+UFgejqkT0AmUmdVG0hx9wQX67uuUfgbcSguN2TpHgkmAfaBlW4odJlYb/cV2+0sBWLhpYkXsAX3LTf81nHbeSwmaYDaeQ89fpDlHtm0lekL4eds4wxMOkcsxzj94UyE2Q/pvZ0vidqda/lxWNwpu4tDtv0GQ5zrCv4Wd6NX7Ml4zC81/FVCUEgfR6pl0ySyaHSP4JAeOgDMfkITyWEmxjBzeBvpRu/POWZBihfaAaDz91rAQ7pYzXM2VSa2xzxTpJD49LSC17cLvBTvBdYM2LScpPO8rkKKH9J57pzO7KfMtRCIZramMZiVtBl9N+DO/O6KA82EltnHdFKle475je4K91mwE+VX++jXuCfpLoM1ijYdJ13V2S1PWpxMelj0zf0dDZfv9yr36nSOEBcZbc/Q0vuCH+4ZCvPSfRZlyiq0V5PjV34YwmUiwzjUXGzuXfJyRvM0wQvr2vyWHFthY4z+LD+oGfa99Gf0WWfRwZD7tcDOQvk7Pmpv0smMSjR+wlDROQZEzPEkC06Utk6TWG/WQViliVr4jLaXZ5kztFIDn8cmaaiJTWxiE5vYM+25jCwap9l7X7crvFAsT39KnuDGL5djLKu8TUlj6R1aqfdeFClHZcLzIksMChzvjb91FT67KbealC+4f3sBhcdJqK1A0bRSMcEga6LFKys7AGjuvg02yOuUxq7uSmS5durSnOOYNJXLrJaRq0xEIZ7i1FXbzCNsldB08toBGq+T2+FK1y6H8u3jCkGR4Y536b3BjDLHJOyw6imQy+Zx9sCr2jTJiU40YBvNpGtcvPyEl837j1wgKB/2jCvMkdQAM8FaKi4DUV7+DgMKspGZH8b43/xjZRv8OJUQlIH+cdph5SMGM2Qt35KYMNmmWgoDFo8RScrWiZhoFHeGZ/cyaB1Pim5JeilbU4aZtXvUnq9EVb2TdDwOhxjRTysAF1Dzj2zTp8xXGVt3aD1WMfmve1SjdIchqiz2E48KnVHiaxjORBgXBE7LqY+W5S0S79Qd2XSPyATU2ItHKUDxU/Lg2ydpo1HJMWAOFOi9qR/xdR0WEZ5KHkdQ0NApLtZ+ZjXbzf3Ac1/YaqMUMOTzEy97VNFI8W/KcR/7Vo/Pe2zmnzwv0h2NxR+xNCwX3EcFBz5HFkIz3jnJzMg/foxoNpmyGOc9NFdZMpeFmjpL9nErEVHtBflfW7ErppXrLSqUP+U56SeP0X+lhsEWRZupmt1v/8iYj5ElYGNpKIl+DUNzHkjXkoCCn2eTyGJiE5vYxCb2THsu9Swu/2e/pwHKZWvFRUb23qOYMyert+QY+zPKrLR9ztemGzEWzhJ5E5ITT3WBM/8+ubW1AUcAToidDnkUjTXyJqqrlJgf/GgG/WUuZnoMV9s7vHL72wqZBn1eu0TvZfesh9k9x9Kft6z0p0Q/8z9hZsxZx3iGwqEvehmjClBc49zyvG0YlO0FxiiMoIMZW6eR6KG3ZIXvhXso1dWmaCzFd6HeGOe0oZEQDqzBjKXkkP3KMfjbynAVxZk4yw9og9pFLqDfteLzYpW7FO3tXk4ZbykuBiTwQSnMCijAjzHCjmJFUMlnCysrAExfoy8NmSm2ccpN7BuwOX+vb4EKcbiunLPMv+4ie/YzsYNluLN7J2fqF975VuJ8gzsljBfI9XcZpBCPCvJPOEoqAL1l4bs5UOO67ZgmTMNgG3OGDWSWj02NYbRcxDqnA2SqNC7uJxROO7GUd+orlLdvPCDXOL9u56hEFunpAdRNun9Gx2ieV01kYcd0cJk9/zUfAYMNyjdtZCHRQOUOA1Au0HVKdbQ5daOvkofhcVv+QZ/PnbZ3Ag3/EdUPG5emzHupDv1mihsIx4UU+tPcpMqw4fZRGx7nt5mjjn97MO2ZyL+wyYCMZddc++gkX3cuvocZO97TDMzZ+pKL3Eaynto5xTXIjouIGagzJRrH9E+Khi9O9uUEQHeZI8NuMuIC7PW7/j8+W8/iuUxDSZFtnFNGCcwZJ/HFo5KD7pEk4sg9EGoDQPtUCBQZ67yRrEAOZjQ++Iji4jdfpfzCXLZtFot/+NUf0n75jmgu+8jw6P/zb32FjitQ5oFZvUH7ba3ah1XIobhiuuYoDRSv0nFIt6x2KF0St5krXexfoAXMICBi1mGyuwGnL7yuMmGu5CY63BNQOFdHo0bnVLzGqY/ZEcDpKuG78fp2kRCTh3t33kF/kReQofRnAPtv0Njm7kk4zYvYojbcQ1KQVmNliNXk6d8+ZtFNBvOubGqt9Jj2IQ/zwYw2SKoho6bGM9x5+2kO3TM0CaTgGnnaCNdIL0P5NjAq0/WoXeQuY0a0DaaAsChqgaIhHcUI3iyTgCwS27/E23MBu3i6gQzDj3ZvUyexLkQI87RdsE4PYu1zMbuvEPRYGKlugQiSRpQeg70XPRTvMehhwaKaAHIQJPUmaY7cjkZ3kUEPTJ8v2tStk/acZHFxcnZlGJynh13UTuH8eepKbg6ZoYD7XDrnRnC5wK1qNKdH9SzyDIDwWAdd+KO0m1Q8BCjt5/aTqpLZfW2ALakO7X/pB7SIdVZyyNR5bF/iPo5NO2fbx+i9AXeIV+8EGM3R3E83aUB78x5yW8lKsdsPkeHx6y0ImwPNpfrptFFUzDG1feQpsxjvsLpiUB2jfIMvyC7lwwRkEpQiFNaT565CoHmByTNZ9TGzRd8PChrFG1ywztvCtUFe8mraOjdGap9Tl+d5Al6n8800gNaZp+SWf4ZN0lATm9jEJjaxZ9pzGVl0CbGKmauR4e6RNMSjv8V/hBGyW8m1MN55bUKxgqUEF+pmiUDSTQXt0D4+/C7xEUdpmwL4o+gyHcf/Ql7C/vkMGhe5wMS7H54YQDMT7d6vsZfwMGtSPKabkotOYQbwB8lIofhojKAgEqtc0KvYKCjTpgOqX7R0x8HUgQJt26a+pKu2w30avWtVKKGhfpE+zN7LGgCBiKeoUOPId+jzFntonWX6zYUfd7H5FYaIcjqqP6dRuMVe2DpLXb5gz028JQndl94NjdypeFyjKStwFFRZfjXkFMLQwoaFjr543wIOJL3k3c7x2MVABvybo1jEJnK6rRMKnSPci3AgS+uMAXBEIXxKvSX7uXjyYUahsCGe+IHI79tTGHNhdlpkVV+0P6RLjP3keZOtAQMWtOpzcb36md1/b9bexovvUgpr/yINQpbZkp2xRu18yp4DgMZZbXoihtNJjzTVdpDb4uvPBeOMHyDi3pzZP8uY/T/YXgUAjMrch8B7Sm+mkGG6b0lzjSpAbzHZlSzpt9I9GC3rwl9wesYnum/A8laN+8qkAwczHP1WrbBPmLbMzABxVgmgwqQf+R7eP5syxeDCuo2c1r9Gc0ZSl+m2RqaV9MK3X6OdltYik70Q08pGZKX7HCWvWGGuPHdft07xvL3noiUU6D2RpwW0k9yxsEzoxRhw5xwzN9z0oZm/yj9HUUT07mxCQAqgng4AGM66Brb8eWwSWUxsYhOb2MSeac9lgfuVf/w/a4A6aE3nNtcs6q+y2Mu1FNqvUB4zf528jtyWNgVf8bIb57RpypMu6Z5oYwTK6B1Ibnc4pbHy56wfsEdV4dEMuTz75zPI7XKNgGF2u5c90znpcP5Whw5SnDP3TEMgezBNhfwGM29WpLBsocFiTqgNz5FAZ/d+id23UCGV58LcPp17dsu1OX92VobMbZN/5BqvTfK7jfMa6QZDc7n4ndvWGHGxWTq+i2tWe6N1XJhARaxmhL1LychCQAdx6GyT4ZJL74ZIs0BQ8wTzP60HWP8aN2hxZCEaIO7AAY7Q74d12r5y1THNYZJ/l9qBdqw4lnRwt4554J45owHRW9IoM4RYwAN7l3ne7NvrULlP4zcoO6aBLXGdDgQUUoOKYvF85whHKXUrzdm4wM1qIrw1dAynlsBq05spLP6YzuHJV2mH2V1l4eLs3ldZuGr7NeuhGjaADjAWriTubJam1qBkO6clsggzQOWOzG8uxg8ibL9G10fEoKp36BibqykDTpDIovliAKdDx1K5yTXFtEQzFkBh5ENjtRmJdPqzyoxV5Y4gJ/gl1OjNJSPWoGiBLTLvUjynq1db6K7SIHTnbddzbkfqEfSF/E6IkOVaJZoWCVhvqOENeFy4MN6fTZljkuOIUgrlByzalJOua+6SX3atOBGPe/eIQvUmR+TnuT42y9H10Pr5UltCZJ8jcY0Vr2OfIwDQfJmiD9XxoLO0/7V/9F88s8A9iSwmNrGJTWxiz7TnsmYh9ALpRiwq4nVx7gfcPn8UUDXmQvoquTw7m2UUbpMXVHudVujcgxT6Z2mlHTeEipReig/J8wCAMENJdMmDA0Bvhd4L8kJXEaHGOfn592kbrwcoVgSrfMj6Bm0NcfMl1ykwT2dkI4q4iXcsXD/TVyPzu7tvJHOp6a0Uxvlkzn1UjkykIN5H5TORs9ToO09xLIxHRK+1yxrF+4wcYhhoqk+e1zjroLts5TEBoDeXMvQe3SXLOQUAhUdA/YIcB+2zccJDWhh3+Ro0j6csM6ZmVAyrhXk9BXA9goMsuENtGXy5HuGw3Gt/Vhvvt3XMM++JyyTwxNyWMnnyAcseiKpgb8FGAFFa9Bjs5+UHDOt9KWU84foLjA7jZsUwa9FHEs0MZpThsEozekU8QTUGioz66p9lZFVfoTsnuW177cQj7xwf87Gx3PDsGC6rIPb5+ucDB1mG+m59nbbP37WNo51jPM58XG6Mqbm7SMc4+9EA09eYbuZUMr8+mFamfiWRRbo8xLjDSKBKMspUY2DqM2matRh4qRtIVNtdjpDjeuQeK+sZbrX70UHUMArr9r6UuSxQ9SqAVJcb8KqsufH9PYyrdIzSUBemHbhDbg5kWhB/m6IEFYRQQ0b2BUJvAoynWZXxCDPe5nHIghydR24nQuNs8v4BgMZJfrZs0/9hTHVR4LFGh2dXo35R5hXX8soaveOW8gcAvG26xumWMs/Sz2PP5WIhD5zBpT7whC7EudcfAgBeqhD+7Pc/eQNqn2ZG+0O645evhGie5J04sYIiwxKzLJYzc41vnAdtU+AWKunybWVglTJ5pABM+6C/N99iqFsDmP0JP1i587O9YiVIpcPZ5WxOULCpgTxDa+DmVwAAIABJREFU6dorymD24zBAMX9DiOH4AbgQQoXJSZDZtwVLq69s9yWLlqQcsjs21JfX3IZjHqhyDfbTdgq5hszP9rxIH4TAHiUkHkwB+XVeJM5LkU1j8R1Og/GDxx3ZNJhAC6W3JkprtPh6Sue0doDZT/mBfYmuvxA/ejG12vYbLLL0IGuw7GK9RdtNKyb634X7nkk/9GNyvaI13jrDN2RHY+9LLHfLBXGBFvtbCtNXOMXEgIXmSccsbrKASM9GfH7lr3FasaYx8zFtWLlLT1tnOMbGV6mw7XKqR4qbaqSMZK48fN2BlcmVTuEmAzSWv63gDpJMBdq1YlBC5hkUU4YnSvTKRyX6ghMAlbtJR6YVFDA6TxOl47tmTGlfCtuvM00497yEvtWKF2nZ/BMH5QdMYLkgvF72N3pL4ixwOq8amLSvmKS2Bgs5Q3Yp9O4AoMbcMf+YntyNs3mMCny8TwQeS+e9fymP2Q/p4KKCwFhT6CxzqnkgYkYa3YWMGUsgliJVQPEBp5/4+IMzPTgOgwF+QA8F4f6KUhpD1jAv3rcJouw27ViusddRyG2yhv1J2l4csVQH5vn2eWyShprYxCY2sYk9057LyGI8w1S7qRAj7+kF+rm5JtpFWsVdl5fSKzG9RYYA9pdC5LljW3hjdl6m/9Mnqph/nzxQaforbFlPqX6WVmyfi9rNU47xCoWZthfzPoXCu3MsQlpggweiwOF0ZCCF0nmZbtjwWaB28XVeippGZnHTNZ5/9TN6r3FWG89VoHzFR/TFoOBgVKYvz35Mn+2+qoxYipxTbi8yXqSk6sRzTTeUCVQkLbbyLWBU5GiHvWrpBu+uRCb9VP4Bp2vOuIYpVhhYh1VLW27GiNMX/XkrLRm32kXp5uXxYD4qSeEBQPndrN1GJdMcAKWbANsdXXqX3t+/YPchkZrX1wYSPI7NR2nAEjCFCCrFTaKG3JZG58jTUwIqssAAw/kV23T/PJ2LN0gyGMTN33SNZy776s/DSNZKo57HUrebX9HIcMpOOuChieYdsCJWXtX+4GBaWFbp/+KaxrBC70l6zBkBy9+kf9rLHIEIYlXb9Jx0Xw9mI2R3eR/8U0ER6LPAlmGA5RtpnFPI7PNbklptp83vC724cHMBJJUMADuv0j533p7B9HUOZ2OMx9kGR1McYUhDIADsv0DPltwOp/+yjpmn3hZtk9scon6eQnNpHu4ssQhSTGZYoqrspzn0lmi7PkOnA46WsjtW+kDADKOyMpT9WLcTZGyYFTgdfpdBJMc9c29/HptEFhOb2MQmNrFn2nMZWZSu0lI6enuI7A6td9dvkqjI9Yhe4Wnkpinf2G3z0rrqoscCI6pJ+0g1HAxmk01Ckise+wp3f5eLXt/m/Ppp60l1WSZ1/qeiXXFYdnR0oY/+gLwJ8RIAwHuZ3Idqjo5n4wqR/BcfOibakMKl17eQwuXvMay2bNd58YzaR6UADExfpc92X6ftCw9cA3eUOkL9nOXTmf+AxY+4UlxYU4ZLqHmB9h/dcRNcQAAwdd3CQfdeSUZ5j76h4fQOiDC9xe7+kzz2X6b9xgWpDGsve/nzHwbYeoMjuL1kUyEQq3ucsZDBeG0CgKGGKD7QxhuLb5PqMpuo1EY2gcJdcrm2vkqIBvHGvZ5t7IrzRInEq3iz3eXDnFPi2QcFoOUnC/7Vzyxz7dzHNC4CYIgXPKev0E4a54vYfpNCRdFyiTxloymOCkwEWIwNCM+v4UwIj4uew2lbOBeTRlH9Eu1UfRrfCVnzjEZYYThniyOpmATo/iXOkwu8ExpFrj0NuJYk9SEn1InfBwA9PYIW+DfXikZlZbz2HNP9iKjROGPnrTBMN06mEjxegJ1DgynXQr1vWdBJlOGaWYfube0oeL3kdWmeoPt67CsUH9NvyT2Y241MJDTO0vZbb+aQrSXvESfgjMV9z9Qx5XVUAooP6LulR/TbW2/Q/+OcNs2qBoqtgQxrLEuDn3a1oYgRe/LLtM3UVX2o6fTn2XO5WBjRnj8pmO7PqZvJAdm75GHEXc+6ablTZv8VpaZ2X7PbCidPyIXIxhn5xI7kNgsX5TaBLqML0jvJ4Ys8Ko4Ctojk3fXN8ZrtciGCq3Sjb7v0ajAO2qa8BFmjPYXSI+4CXeYZqGwhbMApE58V7YQvCwCqVxk73ogMsuIg/w4de3L8iH8r+V6Ust9Nt+3ND1BqaPZDLtAt8g2zrc0CIkisQYZusOy+gzJTbIcpiwwqPBYcOm23/aolC2ye4HQEo2fcgZ0LcVy5hN39U/QQk3SQiDMB9iYdTSmkH/KZxHDxtZc5lxIlx8ffs4tfe4WOp/ZKCH+TU5eSQtgFOqxaJ70URk0vttiJQ9A8o1G+Q+/Jw0gs3dXINJKF4kwjMotQ4xTzinm2E1sl12hkalYfXKZ1dss1SCTp5E2x2t2gGEGPk9d/VInMIInGd/6Ri04leS7Ds/RE7i+nDCmnOGReT6E3c6BnJfYzpk+A00XVH2WQZoYCuQZe3y5kHRbtingxzz/WKD1k8MU5W9Q2IlziiLETM/YVqre5p+IMbZ/fCtE6RpNI8QCpUGPAaCnhlRJFy1FZo79A57n8fZpznSXPOGfxVGnHUNIzMi59OPUo3HflB/pQZ/jSu8yFdsIz5Kmioqgdu9haQIztfBcq+ZmP6XXvJetUfh6bpKEmNrGJTWxiz7TnMrIQAZ3mKWWouPumuMYexoZG+iZ5B9ITEA/FS/d4ndRAmZk6W8fpLQnb/B2NoEjexuwn5N5ufSmL0mfk3UuhqMaylpkGcOS7tN3mlwVbrU2XtnSqqn077AK1FVEjJ9BG0jH0uU9kTxsKZL/OxbiXPdPNqaKkdxJmlCky5rd+NveLYPcjT2GcZa+Nu8E7q4Bi77t4l0PygY1YQj/Zb6G0hbRK4Xfnq2NUPqax6q7Qe5ldhpb2gEyTu9wvMTfPE429lyiVV75P55tpOYZ6PWIv0uV0RG9eoSgRF3tszth68KI1LdGHbAvYInn1zth48pICc4e2h0W8ceHyCrPK9B9IX4T/xEOKU0UCsa69rOFwX8Kwyt6+NBtr61Wb/oC7QOMseGyS/TBOACx/l9M5Nx/Se7MXjHa1/Ga2EaHXEnAEY/AZIt4+NYZbpoERzfFUK1YN52kiWs/DqkKeIcVBk26ctAIqt2U+0We7r2gUryflOuOa1xIFlu5av9TfF2Imvo6z9jMRUBIm2mFFWfkBvm2mrwaGu6vPfTBSqO3Pq0RkLSYsvNOf8ljt01gIvBWgaA0AWisupm5xbwLD40PfRXabIqZslU7q8d+g8Svdt6nC+hnLiGzF1zhybms4Y+nXOQBtr2sT+c4+ZLbkrIMUPxcydTqezTfpmRanwheeu8J6jN8sJiIlkXZK2Os5VTrzqTagm89jk8hiYhOb2MQm9kx7LiOLODxQmrIKa/QqK258G5HSnPsgMJ278eKk5C/nPjpQb+jaPLFpxOvbQpt4n6KfIM1jgPU6w4ySxuOESe6/c4yhcNvxdZujJS4Ati6M4XQ4L11hj/uRZ/KvmR3amchfCjwQsN7+sGQhkCI6tH/WJkQHCyzaxDWgVMM1DUCd18ijKnzomy5U8aQkb5vbsJ6RNK1hrMznohkhvDdBHtg/y54/wyXbrqK8OGDqGZ1lFwPOwxcesyca88p2vsLF1a7InjqH4ICmMD6yUNt4NCZ54f2XeBxzDiJm7/RY40QABumWxtz73Fx5lLe3jrT5u3JDmbl5kCNqvDxElGY9jYwUee31P/EHVJ0eLpJHL7oMcXNGEXJ7dM32XmRuqJh402iG2WY5Sqnc8NB+i+aOt2/rCNKVfer3KW/fOEMnMPsR4A1oH6OCMPvaCFTur/mfRibvLhGgRGhBUZkGzT6PX/V2iFGRea7mbRYAoOsq+ih7DL/2n3hoH7X8WQBBo2W/Uv8R+Pqg6pimU4HHOuMkSAAAuqxJkdsKsPFLNL5Hvkc3SG/OMti2j9J22gUij0InKXQv/khqKYAWCgGee8OqZbqVOk9hI8T+OZd/l+9tniNOqMz9GY8YJZoa5Q/MAW2zKALNHlYVvK6NRgGq0w1W6dqmriQbE72+RmsVn9uey8VCUiXtmQi5R/LAkwcsDeD0tQB9pm6u3JNuU9d0KM+/R3fW1tsVExZL671BoeQccyP0mEiwemtsurPzT5KBmYqA2kWaaE8rIgt6YZzXyDI9RCcvuHJ5oCmMlriPhBWwnBs2fzbkYxtNh4dU+CTt0XhlBNVJEpVl92xRcu7HkqKg77VPACt/xjTnHEbHqbuLP2HUR86mUsYHgF9eH5i50uHvMp3Adz00TyS3kwUlu2tFleIm+P3dl7goPD68jdxozdOA20p2GSttz0uQT9JPMiq5JpUlQkeNyxqK55NOxX6MBXckhSChe/1yCFMrHXGR92gbvVvlQ8frrJL3oG7xCsu00eFObPDkGXPaKgzqdPK2DNNA6ziNaVkTVf7OKxlUb/N5sYpi45RraDXyD1kEac4WtWcY3FF7EYds51U6Jkn5jIoKrWM0kAVOTWWaGumOFKqFOC9A5yjN+dY5Go8MdxEPjg+RfSAFYvqd1jHXOFvyKvvswTWd/pUrNAalR2Psn0uOx3BawxskEWm9eZtqnvmUUUvcq6FdlTgvACit0T02rHqYvsZUHdxNP/VZgJARTOI4atcumgKOECDKOOuYdOIUo9W6xwsY8qLoCcIPBPoAbM/GkKldtGd7lhxOedZe0qbHRB7+Ml/CrDJd6CEv4O7ACn9JQb91IQCYzWHASMS5Gfpw7adHEg7us2yShprYxCY2sYk9057LyEJs7kcq5vnRe4ba2FOG94a1cuCMgZU/p5W/d5S4VqIMEGaevmb2px1DxR2mbC5BPECBpElI7g5t2CgEevMfBAby15+2kUCPOzINpJSjCdV3Uf2Aduj+O3Sszt0CslzY3voS/YC/o9B5k7vLb/n8+3wc+ymERSZHY83fYcyLb55irirG5M9+dLgIrkJgxPDE3nEhmbO5PelJ6LJ+eaoXYecVOunKPXJvO8uOIV1zR+w9Tgv5njLHKwAAd2jTVGKdFUsE2FvkMROOoA0rhDX9Cb0Opi0xnex3WOHO2E6E7bcYPszzxmvEhIPOUqtt608XTXpQeggGHqd6NmzXq5DkZT8po/sSjyGnfbSnEW2Rt64XaR8+9yl4BW2K18Ib5fWUiQI6x2m75gnLjyVpnP4MnVyqA0PFLWJd8cKu9JYYDqQZoPVmUio0c9s33qxwfvUX7ecpHmeTXqxr9Hy5V4QAzwIQSjfB586/CWA4Rwcw/aHF/2f3E4eBAXdjT92yYVm88Hr0m7uJ7YdLJXQXaC5KWky41VRovysZiNAFenNJjre9y0yd/zgy+xhW6IJWP+ujP0MDIgXm+hHHpLi72WRE7+9Fpu+p/iLlXeXZA8SjcIXpq3Sgg9lkWilMW7CLSKm6XceIXeUf8zmZPhFtomTp1fG3FbrHJH3HxxgqeCWaII6TvLeCcohgfiJ+NLGJTWxiE/sF2nMZWUjz1P4LyjCGSgNUqnm48UpqEplGgL2XyWvLxzieunMCN6T/xWMsPrC50CIXVwcV1xTwRGRHLChaGNvSO7Sa759LG0+rxJC4+lnXeO2SiyxfY8idC0j9JfNPCf9auNfC7uvksQjnVJAHogYX6TgPGvwW1WHcqxWEXOZw+5zzHMJQd0uuWApkrWOOoYsOykyxvG2nRpGhwr3lGP2zFIoDiZocMy7SVJTbjszf/SnpFKbty/dCtJh11MigTmsDKZWiswrNcBiP1IAXItuMV3uZaaM3FUZV62kBwM7rvK+FEQrvk5vXOmu9WMlLt/+E3GqdBrInCKHQ3ScPUyLAcUEbsRnpevZ3Fcq3uXC5I5w/jil2904wFJI7tMe+Nk1noa2lmvPaP8/7Yobh+gva0JsLF1LjhQjz79A+Fn4sAjmeiar6R2lizf6IKftXAP86HZBEv/kNbWoEArVe+LHtUhauKuGjGkwpUyiWY22cdtE5wSADnmsZZm+e/X4a7VXOl3Nkm24DrZPJ5kCRdh3HIvzyQ67b7fSx+TX68uJ3KMIYlTwLo+b7p3qLDmzntaewKJSUiZzQSn7WXXKQ32Sxs1j+Xs6vV7a1M4G+N8+w974pAAfX8q5xgb78YIxhOSnCpB1lBMIECi/Mvv0FbYAp/hO6QNPXQ9QuHqjJ8bRtH7cstRLFCPMxQPMUAPIPPagx7a+7Qse9fp1uuHINaF4K8HltEllMbGITm9jEnmnPZWQhHrEaa7OaincoSJkg7xyisAAIdQIAgynLCCr5XaFP6KyyXOasa9AC/ZhIiDRZiVc7nLV5WfEUu4s2vy+eXPO4ZdkUNEfkJvOIKozDXRmNAtu8JSyl4wJQupVEgnUfkHsTHRlBceOVyI7qR76pX0itQpp1wpw2+dLsnm1kKzzm32JnLc6bL+ckKJNMSyPDjU7Nk+SuVu6MMKx6ie3Fk+3NOiZ/LNKb5dtAk1l1JcIoPYzQOM00LC/S/lM13uexAUrv0EmM2DOu3A2xzXQMAj0ucL63u2AOH9VPuDlwYOGucVqG1HdoLAv8mXjUnWN2G+HhaZ7SCFdonHN/EstF85TJ3ae5MHyBE857dhvJQTsjIBUenq8AkF+3WhdDzjGnGg7MdWchojgdS/m6zD+LthNGYfF0nVCjx/WGxfcItxkyJ1KQgxFGkvNwR4AbyP44oj8ZxFxnehGvNszAMMDKdR8XYog6RgIK4jDdDtGfFolYaW4tGTnavS9RB944CxQ2uSbH3nv9HNcYOtpQaoimS7oN9JZoexEPEr2HwmZoUJCi1bH9Rs7cbyqGbpP6XHZHdC0Y/nrcyjsLy+6w7JimU6EHSbc1plhMrXmWvHtBYPnbCp0V2l7oOHYv29pISqhiuA7jdVVCmhgA/C0H/ZdoQo0Drm3FhLEk+hXKmv0LCgiePueeZs/lYiGW21QmDJUJNajaz2Vg93jQnZGL+Z8mOXYGFccUo6UYN3ecOLGbe3NWFY1fRyVtiqOjKdq+ciPG5MUm5HSZpiWhax+JdareT8LvOtxxa6COsIR/reMlszBJeKzG9iFnaNHvSN9HxkBxx4rFVioh8g/oOJustubM08Ry7+RMikw64TvHIhMiiyhMmAWO/OkOAKD2RhL32p+y1NAJ47koD1k3RuAn1yyUwt5pxIcQAPEvycNFHoBCHw5YvWpJtz357TGmfpIkUxN8vv/NLNJdTpnwQ68366Fyj7t5eYGvvaRRWEsG3f15frg8UhgwQWAcu+9fo4ux+RWGYY4jo1YmcFb3IS1s+YsNjH9KE3U4ZQn8hO8oZF1krTjNUbCcP15bSO+A7a/wHKrSRMlcsykYWZwLm3RupUcR+rNJnH3gO+Ya7F6mY5u6adMSwj0mFNhRSps0qDnvRylDgGio8mP13+ZF7u0ockf0Ax+ZmoWQAzBpw+3fHaD4p3Qzbr9u4eKyFrXY0Uu1FGpV2/UPWB333LYy4AvT/xLBkK/l15MTbOdlD6UHAg1m8aaya+4zOfcwY6HY1ZvJMSg90Kb3R7rA40SfkmYtrkdY/zVa9WeuMHS3ROcx9VmAVJv+Fl17b5AxC42cX7QsfPFAlh0lceacQEHvJFeQ7pkRyh/TSYTJyw8ASNeegvH/GTZJQ01sYhOb2MSeac9lZCEFY3ekTXOLmM9COeOMMsXUDL/XPaqxd4lhfvdl+wipLrsutzn9c5W95nnLbimrclgMDdxRTLqau0csW6Z2JVQNTXOTeKLDKaB+Xr4t6R/6L9VRGHL3bcQew9RHjuEjEi8r3VamU1qikwFDHAfHhkhtcmMcN+4NlwJ0z5CLm2WJyTHDdzMNCy1snjng2sNGO5EHPPgdUnOSwnxhXaCXChEXKEtcnNx5NWPkL4XCW7zywbQyYkT5DT73lvUKJcKQqA+w10BCa3XVj0mcctduK43cLncec4oityuRg4exL0VJ2j63E6F2nrupef+5DXUoNSV8YaOiPffucfodr+mYLnN/y3pqwSXK9w2YYluYabt3ywBHFHqeEBFBkDX79VjmVwvke2S7cB2G+u6+oeFW6bv+BzRRgqJNMRY2uNE0L8fjosUsuQJwGGcVMsJkwC+Pv84094UQLs9Xj+VYVQhT9J6+zoJfx+29IHBgsd6iA5U5DM2Urn4BR4Sr5C3H76rmm6xvvZdOMAoftN03GGSwwdc1ayPhvJxnDijci3Vtwp6HOwTaxziq53HPb0QmrdTh7nEBMwA2FSyd00HO8lFJ6tsdaAN3F2hu3Gov0MUtMLV6b+7wo3icVRYAw4zEox2WO1jUaHO0XmY+LWiNPjebCnS2VwJarzLqhlPTXT53rx+jN/8cNoksJjaxiU1sYs+05zKykMIbFaa5mDknRS3axh3ZJiVp8Xf7Cv42fT7zPoUbu29MmeYdMSm4ZupA+wTDQdkLqlzxDFVEqimUEPS9MK0RchE5SnHuf8XBeIq8Qm+fNgznRnC3yY0Vz8EUAM/2kP2MPEWB1wLA9DX2oDlaapwPUXp4oOmQc+PpjTSCItdMFtk9bFiMpsB79Saz8i5HKN0Tz9x6kd6XiBZgfLVix+Yc7S+qUW60xxFPbs3DzstJTc+goE3evvUrlIdNX6VzU5HlsGoxSCG76xzKq/ZWA2Q3mLl2UWgz6SWz5yL779EFVf8vhUlhRmHrTfrNPOt7PPllzgXft01qw2l6jVKOybXL+HVWI3jszY6mOXq4x3w97VjdiOlVvK4y+xDdBn/LQcARhcu8VdIA5610oa5RIjvq0zZOqEztqXWJLpBQZcDT8HaSYxsnGpZC5+h0HyuLBC99/D0K2/orNMHy91KGFqTDtC8qP0Zqjb48mpFB4Lld81C+y2PFdcBxTmEwz3xUl+w8kRpeWBL+CZ6X+QhpjmKlQVJ7wIBrgxKhu/e5Ge66htfn8V6n4wqzlrW5sE5j211UZizFeqIxs+2ZSESAKyrSpm4lEWWRNS8GM8pcT+GS2n0Nhmajd4TGJdWwdQyJIjvMpBxVAsx+n+co13l6p0eI3qf3AiPX6xjAjED3JRIZVpSpbez4HCmWgMKj5HkO+PmS31DmnOzzRyG3SKFlxLxbqhMDU/C9GMzTWAUzEdD+GTq8T7HncrGQwdeOVcpKc8FYUj6ApXyWouqoGsLfThZ0tAdThDWCIVv2Ao32khxFo4rF74sZPiDl2AItb+JvKXQyyWHOX8tYtbKpJEJpFN+Oe0gGM5YSXMU0gTvL3P3NEwiMrEjXFdJ1DkOlzbwQwqulEr8pT5woE2EgJHBcP1MaCN+jp4QopaVSIcKQHxILtGgMOpzuerOFxiblF9TQMTuRVJD/Id0AglBKN5XB72tHtoeJdSX9k9r3TEpAOHPiamobDwghU+I50Z/XyNaS16fAi6q/H5l0W7w4LcSKgrJ7mq63ELQNZhT6J+gqqU5sLh3INHQuDg0/10HTdwrQTCUtKLSRXY+RXqcxlfk4OBbA203e1F5PQTvsELxFjs+gZQvc44s8odhJCIoa0YogJmhf6QdZjE/TQKgx90jwgztMazMeUtwflw6nYLWjEXJvjttInm/xoWPGUsAmgxmFjKRGGUXosrKeCF8BwMwVOo7ai8qwAAzFidvXhuRyMGZGAO4sjxOIilJhdhfYv0y/L8+C8m167a6EQIkengMWMCottjHe5RVSgF6rfeRztIi39uieMsqAhSGckB1HRnZVPkpDHgaySDtDZcSpOtx/4m8xUu9YaASoBAOyurqDJ3s0MYJ+8vr7u2kztq2v0TUM6hnkkTRVTxl6fVlEvT7Nr8HpAVRphM9rkzTUxCY2sYlN7Jn2hUYWSql/AuB/0Frr2Hs5AL+ntf5P/rL7lZU6jiEWfpqZa+QljIou2ifFm2DobKDQY6z02jcoD6EdK2wjTvjUDQ61L9uwUSKGyLOpo+IGs34yG2V+y2raSuclQGkKAAg41B9oz3iUYvLbWPdNmD6gWjJy667BeBsa8oUeBk2u/h6oIQYlbbZzl8jrKPykYArVIokqYWzjoo1sRL/YCSwTrnOLfsdf16YwaPpDlpkHqps1MDzx2rJ/fxv1x9QV3T5N5y4ym+X7kYFY9tl9G8xF8JmqW1KNzkiZsaleT6YX2ici4ECfSvm2LfjLNYtHCgMWy4k8Ti9GVr95yLKZxYeOocCOuHDaPMvwyppCepO1y2X+xQ5Bop4QQEGYX1+la+DeIc9/OD82wAOT2lgOEHIEKuzEYk7bQ/o04fM1IxyWq02ssffb7lDRc3WhhgfvkwZ9MJWk69Uu4H+S1II/KL0KEDgCABYWGti5SUAPJ4bFFwliScEKbDZux77F2ten0qYfI27ZmvzFvS6GZyxjeosEihoUQ9RP03bTfF+2jrkmmpYoXzq6oSxQQdJ6o4qCv5W8VurvUrrOH6TRb7OEqs/7r+UBTj+p/Dj+NTreHH+2xxfvZuHAFgTkEBCAO5Tu+8iAbqSwLNdi5gMHu29zOvYJ7Xfr8TKmOKoSCd/BDDMEHI0QMQRe1bJy6uj3GKzR4WPzI7jDZDZlWGVwxciBV/jrE1n8JoB3lVInAEAp9TaAKwBKP/dbE5vYxCY2sb9W9kXXLL4K4L8C8L5S6lsAfgPAf661/n/+KjsNeGUczWhoh05h5iqt9t0YBM0UKVlQJ/Ij+Fv0uXibuW1toHCDIyxdyFFKpqaM5yS8Siq0Xcs7r3DTWoO7jddC07wn4kfjnPVAA5GAbNjilEh+SpFSH+nbFZwL0KkO0GX+HfE6huU0JIspkUJnlbYp3vOMhzvUNo8t8DtwoCcaHcW7rsnNSi4/U9eGJ19y+nETj27EHqDesAV0ia7af7yIzgvcBDdI+iWNU46BOAqzZmHNNkiKLKjXs3Bh073OkUa67qD0IRfJj/P3lnAIaim5/9AHfCKWTXi80sErx926NAQ4Gs3Nk9scxxuNAAAgAElEQVQ7leG89qqHUY8u1nibGx49bbijZG4WrmdMNJW9meQrEg4lABi+SiFd5pbFCP/2N94DAPzRlZdpDDIheo2YwhKAe1t5eDOU3Q4ZbLDzyRFIOTO/TrNjwIX8bM1eR5nL+68GcHlwNRelBXKNBWD2Ax6PE3wtOp6ZH9IINnUNaJxl4AY3rW2+TUfh72gDGjDXIKvh8TXAdPI6RZ5Cl7uvw0ysOZUjeYkeWufGQIb5mfgadI+KvoYVGxN4fFBQplNe2Bfq1+lmLJytY1Cn4597n7bZe0mZOeey3kRQjdDepTku19qJOeUi6yvReDzrIRbklXlWKJZXHVVteFe5kuLPbNQrJuOX3ZOiHpBlloP6BY566w4GKTp5ud+8xR6CLEfCTZ6v03zggYNzizuHjvNn2RcaWWitIwB/CGAHwN8F8D0Af/xF/ubEJjaxiU3sF29fdM3iPwXw3wD47wH8nwD+NwCfKqX+gdb6vb/sfoVtc+9lx1AFSHt98Qm5IY/+YQjnEXkCxYeMODhiV/suazQERRf6FHl3aihE/OxpvtBC9JA8vrFR3bIej+Rye4uCaHJQfMLIkIFFF2mGx4lUQ38hMtBN48KsMORt13qQTiTeikWriOU+yxgoofD1jIqHW/fFExmVLDutcOCIRWmge4RV39btPoSrRjihnIE2UL5RmaOSG4ysmNOGxqF+nrYp3dOY/oj2J/KRvWPsbW96aL6QZLxsn4rgsfJduEDeT+ajjPEUJb9vGuUaQOMM/R2UGXLZdYz3K96YaFNk9h20XiPEjcilOoHNj/fnmAalkUJUTub8R4y66d8vIcwJERnnjEcK+ZcpEe8F7NFPpeA9YpZX9pJNw2Zaw9vh3DyjlTzfjt8ff+dLtF/ef/p2BuoSRTiCisnsugg7FGIJb1CmrjGsiOfK6CNu5gsKaTN3xTN2Oy48ZhdWp/qJMQv+cA49RuxUb1kXd+cV9vx9oSZRJqIQkwa2/pEIlWtc2yhZOLrwIRn5YpETjSEZjSe945rrmW7KNXHgNGkc5NpK3XH+jS1sfUQkYDIWo4q2CEC+30wU2fbNtd55jZU1b1l6DYnCoB0z/wzzLgdho0oEl+G901c5ap9Thj1YmGiDQqyBkceswGzCu28HJmsg8P50W6O1ylkObgCUptXOstXrER61bA1IHxiXYOih+iOuY8h9dI9pQs71cO0Kd/b9Ep5pX3Qa6h8B+KrW+jr//ztKqX8A4F8CeIqo5uez2iWZsJHBeEceFyJXabCyV9JG21msdA8mBVO+Tqfen9dY/L8ZpneRu1dfpfxIcLeIiG/YUZpnbyVAk4P98h2+YTj2DzMKAy6SSgqn/dIQmjtDDSw0GwIBb1fiNM0DhuO5tv8g3mcx9Ql9ufYqbV+5evjSFdd4fF4bo3Cfb1LGo6tQYfdlZccBQPERnVvtBQWXRXtGnHbrnAhNMTrT4u0uKVSEF+cA3DjVUiY1IZTTzTPagAEkLJ/7gFNb4zGe8FipOX5abGTNTQzmyYmH4qZozwXgIE8kiHEb5yM4J+luzvyIgOuy2I0qgMtpC/PgdmLQ45hJX0Of+w7SucOFwBOnKJ9ytryDxogWhivbS+bzwnnqU/FcOolWlxeG+xbguHqSngxrm9MY8UTSB4r2g/kIaoOdCJ6Pg8UxUg3Rc6ZzaZyLUFiTVF3SIQiLIZZXiSZg8zNCTkSFEB539Y4H/KDcZHjySBvQg8wbd6BMH4bI32oXCOaYbpsLv85DOtbMvofmG9ydvS2pKYXdN3nS8MUezDKZ4TvKgBN2XqH3Um3Ly+Yxr1fhfs68d7BrfP3mPFDgXheGyUeeNvNIoOHVm/S9PZUFppNOy2BKIbdJf8ucVrGfkbTpzMfSI+EYrjEx7QF9XqijNM0lJ/Yzi0wFv3uZxcwepQwBo/zW1i9FqF6xhXsAGJYF/hpL7cV6kwQIIySX3uOsYbnosYDW8ASBGKa+65setM9jX/Ri8YbWOnEltNb/l1Lqe1/w705sYhOb2MR+gfYLXyyUUqta64f871GlPv/K9XlNvNvmGQe5Tdl/cmWfvjE2nCxjFl/vzdtjqdzntMu2QmafUx7cyNa5SamnsBJBM8RSBEmGoUJ+nfbR5/31Fjhd80AZoR0JJf3bGdMFKla4m7Id25zKGpc4BdJzTLgocple13oRYkHBigF154W/hn/zsYcBh93jCn0xveeaiKWzyp3EzPlTvqfN8EkjY/G2Z35zj+qsUCGw9zqne9rMfcUNb1HJRgEpph4/ciNA/SwzXh6gU6Z9sMe6R+6bM7awaLHOUY2ZS1SEa/xk/tA+yrc49XWJvle96iSoyAHr0WX2bSexRJ1uT6F0lgayw55/1h+hd6eS2MeQO2FdDaQq5Jndf0DHc/alHdypU6DcrbPErT9GY58iiJlZilRHDdpH5mQHWZ/28Xhnyv7IccoxuA/pe9knnD59qQ8cYBNFKoLi6FR4w+Im9PPlj7nT/q3uoW2c7BhqTF5v+ZPDlKQDhloHnBLEdjpR1AWAwWyI6odcQGW45v6L9nN3izuxOSLqvzRCymWBJS64Slos1Rnjya9wgZav2ahsm17rZ2lsRyWNEfOnucxmG3L6BekILhesu8t0/LkNB/1Fhvwy+KG9IikcoJ8R6QApOmsLtWUbn+pDrTMNelvSSXbcpfgeHc4EGxuVNEKOYuoMcRWp1shV5v6UZ0N2y0Of53LITZzCkDv2lYk2pj+jsWicck3aLErb7uBBVeY8H/XoL1eq/iIii6sAhF/4LmhED64YGoY0eGITm9jEJvbX3X7hi4XWuhj7+wtBWwlLJKDRYyqC5du0Yot4SpB3rMgL50FLa5ZNcu8SrVXZXaA/xdKZ7SRXR/6Ra0V+OH9LXgXTVAi8jotrvWVt/hYbvdCDCpiN9YOsOZ6QYaClu7Il0xWkgTTXCHoL9F7o2yKg1CqiNEH8AMtYK4W3MAVUP6O/d3+Fvbiik2iuAmzTUvNX+5j5l3Rs5bu2HiA2xXnTsQ84IdeGTid2hfymRu1LzNE/w1xM6/Zz8RR3TS5aIfMic099wNoOFY2MgRYmoahADE7JTra/o0z0JRa5Cv73i4n3Wqe4wF2PaQyUBX4dYXydvPvs+YbdD2tKOFyrMlQPoyJC9ohVlj7785vn4TGYwvrnKWTPUyPd3layrSh8WEALFL0K4/E4pzEucL2tY8db7NhlouZd+4RqIqlNz4h1mf1mlLluU7c4J/4ygzXu57DLMGrRBNOPsxidocK2DGP2Bv1o81xkJnj+JvNHVbW5H4R3TUWugX9LI6Nc68FCiPIRmmTzRYqu7m7O4egMHbjD1C/f+MoVAMAffPqb5lxGi7ST6kwb4V9QyOzGEtrCyxUypUp2ls6jmBtg5iRFUREf/+N6BUsFujnWt2muKS4MuF4Eh+tB4RyNQmo9je4RBhdw1JO5mjPnLPe/iCzF3eE0y7ZOfTaG4hAhvyHMsg5aAmxhk4hEKxiBqzRf16AUGXDE8nfoPckiZGuRAd20jtE96Q6AdEOad7kdYEabpscx13fSDGrozatYBPJs+7fCDaWUWgawBOCJ1nrjr7o/QQQsfLsHr8nKUBW64MUOd4+ezhl8uE/NmohSgMeQpKzAixXQZpEcKdrlWVAl1dNGlEjQCJ2jynQQC0ZaHsKCSgCA7lG6WZ2NLEoHhHQyDYs/n/2QbqadN8rmsxbTPrtC+OdammNZ+ATpAVhiMyl0OgGw/xsCLLcB3JBJ8bK7kr6IZAiMScErStmJL1xcaqxNt3h2R1ZienEtrY8RYXryyylMX0uqhYlmOgCMfkI37oDTeKmWQvfsMDFWbjrC1mN6mM/doPcEvRR5FuGRFT3kvCWEEys+4EU3C4xeY54r/sx/t4DBV+hB1rtL16B434HPN27hfZpXnWV+0Fa0SamkuWg7mgoxWhqZ4wWAaD+N4AktCC4TSYJ7UVRoUzuRx+imlQ7SH9JTN3qFjifidGj53SyefI0OyDnCPEBPclDsiwnf0WBaY+ldusbbjOwZcfHZq3lQq3TjlAt0seq3puDwMY0ZEdRbZeLBmR4yDLNqRDT+/pZjnC3pgE83NAZcOBWEnDxMVaDQekC5j/YsP5D7Lu7fodyKdEf/3pOvAwBObQ2R26RxPv9lapK49ifnTAqifoFeg8qBnGzMOu/NwnmLfn/7Cc2v1dUdhBGN1bFFQq2t3SBmgdmzO5hfpkfSJ/eJfFE7NqU6Yir53IaD4VQyTZRi5yy/GRmq9oAf0v15D/Pv0zh3F+gLqY6GJ13fbJIudIckLgXYccw/dgziijgBrO29bFNqki5ON+3fRqxtaQR3QPNUFh5xckdHkvfas+wL7bNQSq0opX4IYA3ANwE8Ukq9o5Q69kX+7sQmNrGJTewXa190ZPHPAHwI4De11l2lVAHAf8fv/8pfdqfT18nj2X8hh7FPcffCu+Sht09SCqJ8r4/II29GKMj7c7HO2Sl5jZBj5sf22SSEbupDOzx7LwtXkf08ZIieI12eBW14oAoPWMDGs+JBAvMcVq2Htv0We4yxny49pA/zG/Rj9bMZRG4yhZTd1yg+pr+7izYaAKggmP2UPDTDe1RWBuctOuE+Y/2HgY/aJXpPhKLCLMDs2Zj9lFNZvjIRTvlhki58/5yL0vVkkbR8l2RrAaDxEp1g5RM6yFHJRk6Vm5J2UXBH7K2XbfpJSGmlp0JgjfntENuvM0SQIxunByPoI8I1En0MzveRvkHe+mCevFofgP89mjP+Pv1m5coeaq8l8wUCZ0w3FRQDIXTskgju31+3UWHzxeR8co5yeuRJDi7T1c+/xx3FK3Y7/zt0jI1z9FkzbyMhscgDhmcppPjyScJCv3vvJMyWcsAMdfX6CoM6X1COLKLpAIqPIzvFGtxP0QGXZHLv/BCaeY6mPqJBHUwpA0oIOW0WMF9Y/loGY25MTz32zbhIeq3CtPjFW5R3iXJptF6k7/7kFoX7pbfqyP0B3SNj7rSPVuxNqLc5WntM11BkauO2tjGN3A1mQ2DWAJy12117Qqm96Rn6sJHOmShQrD8XJeRiASAd16Tn1KikPP1tB3svMIMv76q3bKnvpZNciuqd8yP4D7kfInaxZe6KNLRE9qm2LXD3j9I805cG6IwYcr5ujz/FGQLTSiD8WI5Geu0pyJOfYV/0YvEqgF8X+KzWuqOU+i8B1H7+1yY2sYlNbGJ/neyLXizeA/AGgHdj770G4Md/lZ02TtDS6wYarTPk4WbqlO8VbqFcrDLiDWkpnf9JF2Ao7+Ovk+edbjiGU0kxH1D5FnkMzV/uGc/FXSAvLpUew+Umq/5NoWill0xNYcQ0+KbIN6VReMS1kxodx/4FmxMtbNDxt5e5Aa4ZQR+IIqq3hghZsnTABfxh2W4j3pLIiQ6qDkLu0hbNC8DqWEjdQKB0KiJ2V8BCV72eMrC+UZ4hnEvKRANZLo6LA1t8pJHqMSPmsnXBmufpmCSi6B6Ncf7sJM+zcyyCO8teb507rGPaFVLs7noMhV46nEWNXJs3lvON15LE85TO8jALKJ2scey/PIXpDxlOe4q82voF2l6a+QCgd5Sjk42n30a5h+IiJuOCUUmbZtLeLO336P/koMGStv3ZZO4/3XDg36GJ3fzywLwXcPBzv0k8R187fRs/euEyAGCcO+xhS5TR7GQPf8Y23iO339l3AJEbXrL7EiGq+kWuf227yK9zMZUjaP+W7Y43+igx9PjcR0MeBxq35kW6aYoPulj6VzQejVOsg/LIg8+yuJHHkavKYcDd9pKjl4a28m2FepdgzNlQcvopzH2YzM9XmRn5SWfe1uwuc/HnsY8y80qJmJE7tMJWYpKdaJ+M1UBjJveXROuLP9Son+G5u0IDkufG19y9NPoLDEtnSHv3qE5kC+LmbzoYMEAgVaJzG27k4czQ3/oIMxWsZ40eyUFLr2UwPPr5WWe/6MXiHoBvKaW+CeAxgKMAfhvA7yul/lvZSGv9X///2akUfYKiwvSHB4rHTekKzcCvc0i4SQM3mMvA36a/pYjtDTX8HS6O5gRBQPtKpUKDElH3aXEJQ2DI6SR/P/lQ6i1qS8jHN1r5nlWyEyK8VNd2DW98xTXv0TG6BqWUE9I730WqTTdMgbtYo+O+CeclzTZmAZhUTxsFLkNJULbHFCY56QDYYrZFTljKg6nrdrvBW1QgHn9CDy8Jbaeu2W16C3w8hch0hrfepBvRfcKh+fIAg1W6OfQapRKLDxz0DvT1R3MjaEaTqV4yD5DdU5i6SeOy/qscfocK+6vJm1p01HM3fNvxa5Bs2vTf9KjmiTAD7L5WTR5HmQvF7bRJOYiIDwAUHjNeXjJxER0LAGTryeMJMwqNM4yC4Ttw821LJHiQNE67QOcoHy+jrqA0FBfYtzeo36PWXTBFyKUfctf9f0TjrssDZETsil+nZ9rYG/AT7SqlcVIp+2ARETBxVFKPMka8Km7iIAlbwEGKdQCYucYPtIqH9lEapEwzOS5aAZkmnfzcRyITkEaOe5YkJeP1ATXLD0XpP+GHafs4jMKfOI79WY3WKv1m6RHrsS8xsGBfocQp1d46rb7pijqsTa2tQyX3Q2/Onr9JScYeR+5T6sdmfvDCXb1Nv71/zkVxhW5CEVeCVlhdpVVobZMRYUxTE2cdUHdoezcD5N+jm7t1jvurYtdCr9JccO5xv0r1KQ7Fz7EverHIAvgj/nsOwBDAvwClinn64+nL3sQmNrGJTeyvjX2hi4XW+ne/iP0KHhmweOKpz2gZ99oUCzTP5JFhTpT6eYoK/FqI+3+bu2OZtM3ZAUqPyS3ZP5tMF4R3C8jvMhcLQ257S1af13Rac1fwcDZE/lHS+1UhEDG/TPcIvTqBNmG5NLhnuBt7VLL7bR7ncH4MPP4NFoBhPprOUWUIyqRwn+aoyh0B+R0uSucsoaFAHMVmP2Fa93nXeK6Swkm1reSnUCBHqQiaoY0ycYRyeeftsdEpnz5BcXftfhVj0WUWMZZlTjP1PUQ93kuFjqOTdpFigaDxEbqOxxb2zfFu1LjQCfKuB5GDtdN0ftUV+s39jbIli/OZ1JG9z/5yiBT3WkiU1z0RoLpIHl2H+y3+49/+N7jfp/Dyh4+IAXHQZcz8psbwG1SQ9f6cvPJhxabjJIU0zmuj8xyy1KZAfrVrU4cylyu3I9TP87Et0HGXbln+Mul2H86IcI0ykeKQxbLU2DVwytoFLkD3LOhAN+lvzf0hbUcjvSsiTHKNadtU22pCD0/RNRsCuLBC6IIbD6koHNVdXPhV4r7/5GMaK8HzZ3cBpQXmHEsncgTv70lfBr12V3JIt5IQ0XRTI+LIRqCrcb4wIeKbe59wrP2FjIFpiy3+KMSIRZXSu+Rd5zjVO5hOme2z+7ZPpL1K35UxztY0pm4d9MSlN8pJAFQAoL8YQXP04AxFuMg91AHfY14sf0ejzVr3ef7N7skAmz+mcXaYF01kBhoXtKE5lwJ68YFCgyUBpLdrdHxgohHNkgcqEii8QurJ4c79n2UTWdWJTWxiE5vYM+3fSlPeL9qmr3Ge77xrG0zKXCzj3KQUtQFg+mPyHJ0H61iKzvJ37am3VrhoLHxKIl3adBBwd6pEMCo67BWKV1G54RhZUhH26RxVpqgqzWGpjjadx1JAk0L3oOeYJjhz/N+6hdwOQQl7cwdBlEB2L5nJc4ca7SPcob5vOzrlOKevssjT29xpvWY71PObdKzNE46ht1YdGy0J9brACA2XUyaC5vRxrUbJ4vRCDwFD+fxrlCdVLGzfOT5G4SH/zcJOkR+hdIYihN0tGty1h7NwRdqSc/TFE1TUmSt2cPf2YnIwQmV4q8bs2R25TN7wo9vzGC0zlxCL52Tv+Gi1KKIQz+n/+P7XMPUpw4wZ0urGhn30KSXpeyfYG58boHeMayZDucbKXFtJtM7wvN19yTHiVCKuFXnA/Pt0bFJ7anO0px2b6xboZRirUUt0kG4p0y2crfM9MqBx789p0wHvsOTqsJsGuFPaf0A/MPs6FcrqXR8thqNWKlTIarVzuH6DDiq7w/fMdIiHv0/Frcy8LQbTudlj3HqL9l+9Gdlu52bSHXe3x9h+nb4k86u3rA0TQPX22Hw2KtN5yXwV87dHGFRpcKQWEacGFxMYbvFxZJiotWPvOxH3EqGt/VdCdLhGJdFbb5nBNbuuqYsV1kQOIcLiOeoG3rhHhbhhDtDctJkq0iD1f40inf6eFcjKNLgr/UkKgyWGnF+RCUi/U7mp0OZuNYnu46amaP+Oqw3nlDwsZe5oTxv4/OexSWQxsYlNbGITe6Y9l5GFiLrnN7TJsYtJrr5+xkN2n3Ozp5g24QGQ3aaVPL1I79XPWfnFwiN6rb8orKy22cvfYxoHF2ieZK/kkeSkaZtUVxt+pg4LLaUbFmLXYZRO4YHll6oyh494Utl6hPpF+m6VPZi9v3kW+S32APfYC/c8dJeSwiiSGx+VXEwz+qRxig4u3dJonKXt1r/OHhLnwbtHgKAYJd7TLpDlJiHhxOmsAtOXCZ2xs0ch14srhFF+ufIY//S9L9O4sfC9c6UIl6O0uMwsQJDB8AAyxPEtPtBpMpS45kAzJcb0W+T1tge2kSjDXvWAI65UdQjdTsqYNv6U8r7ZEhDw3NHLNjcuXmRpjREkrRDtlaQfNfehpS0R6czIj0NK6Xjl+mvPRpxxni2AtBQkNy/0Lf1pG73l12mOtlaY/Xh+CPdhEu4azQ0R1PjaNg77fKKn4u8wB1Yp1kDGr/PzTdSuktfbX6GDffKIUDe56Z7ZMPgBvRdeHJo8uZi/6WLIaCiJyEenGXH4kW/nNUNL4/oJm29TdCDRb39Wwd+W2iCjCW/ZmoYa0wHtXc4YxGCH74Fxlvbl10JkublSmglHRYUio6CG8zQ3hJNJRUDjNB8kR4BBScPjSNt5CrNIjxlscywUFmdUDnjqLf0ggn6Xxjb9Etc2UgCOs8gUI5j6HDn4TzwjGiVjFqU00rscwfEYhxxIe11laF7k9wcz2qAPNTe3Ys7y8BixKf7eyLGIsc9jX9hioZSaBvB3AFwEsdC2AVwH8Ida619IU15QUCak2r0sISL/fgSokK5+wH0Cm3//ogkrBfLpBLb4JiI/1WtSBAUivuFbrOJVWI+M4pxcpBzfkK1VF5n9ZEoo3dKGiC/DnEWdRWDqBj1V6mdpdhn+pQhY+qHMUL5xZhw0j9PDMOIFIf4AkmKc0KJrB9h9hemw+XhyuyFUmJzcrRO2p0IKeaNY/8bwJAvXMIHNuBDCUcnzu7FBPD+3/uIkHIbiBZyPSkwu3q0UUOOLqJh/zcfuOU7jPAV+2fw39FuygIc3cwj/Bv0tj9pIK6REtewKvSsFerdvtZX9T+nhMpjW9mZfo5dRyUWBFQ8zTRZo4tN2hxYmPKxIcdi1GuqxkxZiPYElD1jNsX5RY/l79N72ayyydDSA/5gXvHYy1Vgo99HLS48BH8dmxpDAyZz397Tpv5F+nJ7B2GtD599JsdjXug/3OEOhpbtbHph3StB5JsCT/oOxA80Ei0KHn2o4hzTPxdpnxvB4/Dx26vJPYuPDDoRwrWVrh4GR1dt97F6me6R6l9KixUehcRhLa/TeqMKLdTeEv0XvtVfpe9l6BHeUTFcV79Mkap7Om3tEJAfcgTIL39I7NA+mbir0eb7WqJXFPHuG0yHKt5myf+Pw6iKQ25krIbrr9HQWeHnuLqfN+zHBooE235P0o9Uyp331F0KTEs4yCKdfsYJlYkHPN5Bmm/6Lpdt2Do/5z7IvJA2llPo6iJ78P+Tf2AAd6n8A4I5S6le/iN+d2MQmNrGJfTGmtP78K8vn3qlSNwD8E631/8femwbbkmVnYd/OzDPPd57edN9cr4ZXc3V3qScNoEYhI2wsyYFlZPND2PiHRGCHLQIIwsggCwE2AhMOQiDjEKhRt1ogWlN1t7pKVV3ze/Xm8b47z/fMc2Zu/1hr7Z3n3ldUqaqv1E2c9aPerZPn7NxT5l7Dt771pYdc+xEAP6e1Pv9R23/2v/lFDZB5KZxDIi67L7LLlq5ZAm6FhQDtUQ4enqDPBB4KWHisaNeha90KogW7XZtNKVDVWJODyAmFOGuT4qqKBp/F/OsWrcYgAUmR1pRjtFThdHH7Gs0fIA0w4EzeMK6RZzpxA/NjjTpes30STbEzqkzW6+jlwcBr9ZQyRZ5EC3HGugj32A1lGF21SRgTCJ+4FTpjNslHXBU6ppFaF9jg4D4bu6xRPzKoq0S5dwyE8/EK2vfI5SX071Kr2k8D2RW21pgdWGk7zyIua2rNGdhysJFpT5T3abYaKN6hoG75LLsLGBLr9iKlZJsW+tllDiyh645XYcARfYE9cjnb7ecDM0cxdiElH7N848dKRN1+Y5UsqT9//h3861c+QfdibTJRViYRsMvFbbSihEzArovs6faEMhbx3gsWvxlb5wS5ilgk7PI5Zosl+VwXXvkK8arAtO38CdCjVwxNPwBiTZUsY3lm+rM9A9eUzHpZi+Id37jlWhP0HLtdbZ5ZsSxaE57xBkgd6twKuxArvkkirDLTQ3Y9QKxB15uTzP7Q47krKgNp7o7ZDGqppR2F4UpypYyvckbAHnZvj10OzXhzV8j3tvH9tI7p7dBYRG53cF46JWUD7HzL9rgtGxur2v0tIgwLsje1Ilp4wHLTqSAy9ww4EBrzIKHMtcv/108/3DyMyGEFuI+BWGYfJv+Brw9lKEMZylC+S+SwYhavA/jflFJ/S2ttVBSlVAbA3+TrH1m2PkGn5+g7LvI3SFMQbS+3zIHDvjbwuPpc5EwU5fE/ckwW71AbQVwZDTezEWlCAlCc2NPkIkVeG6hOsEbHo07tWq4niaE0Z11zXTQcU8CkZ/smfuEgbk918VMXbiujRaa2hUuf77kTmnGaco+RlZYyi0L7Ea8BLS70LklOWKUwzWsAACAASURBVEoZKLEUY4nVFWpnGf75PH0mENPUFtCdtDEQABh5B9i5yB3hILaeJDOvs2w5R1pn6LPkQsLEI2Sc/feKSPBnovlLUC6M2SJMYoVNvtXF1tNcrpMtPwEn9HMuxi9x0ibHgHoFZb4nWm0vq1A5MxiVzrIF6CeU0e6irLOWuoItqXEgywCIPtdLKZ+jfx97ZAltLme6sEHJf54boPMq/X07Rfhrj62PX1v9FDDO1kAnzmPRxnqQde9Mhihdo8/Sm5ywOcaWQB1oztL3xr5JbTSOqANBeH2EzbLQPiAC90ytxawmzJZikNTQE7R+Ao8WOHUYA2a/QT/YvsjstpdsNFj2XIF5mlLrTXQ4AC1AjvLZGEpc2Ez2stfR6HGcQ0ASjWl6fhIphdbkYD0YANh8mr4ofF6ZJQZQlLVJSJz4FrVZPanMWiXK3LftEM1paldYpAUQ05qycNrGjGv62PpesigkgO+1QhOsrx8ZfPW6HW32tVinqW2gwdBtoV4R6Y4+xBBwrKUq75B4TRueOLEoZA0T1XAgxeCD5LAOi58E8KsAdpRS9wFUAeQBzAO4BODHPk7jUy8zBj5uXxzy4AptNwD0MoMPTu2oa8xikeZcaNwy8uKWrErAbjhfgtm7Adol2hA9LkAkgczKeY0U053LC6V2zDUHWWbT+j6kHy0m+ivc5oNkWpkXpkhmFYjdZvRWxHknrg95YOTBd7sazenBTPLx93yTTyLmqBcpyywuLQl6pzeUKaDS5mDc+KUQHZ4byQINXUGv2AJEkmVM9+A8El6X8FZyoA8AUHqDX4BZSzwnD2ljzn5PXhYyd1HiRpHaT9fRvsHt8frXjwlqDFj+PnpplbiQUnpDI1EbzHYHgNwSLXyLC9eIyyzqVpRKaamtQfeAiJ9S5r4AUL9wkLTNXeBs9KY9PEeuU2PlM/aFkLnOG1AQSvmDN0yvRlyYjYPXR6+yiynkNeu7Bu0jYVmpMw0QoAEA4rt2L0lQV9y39fkQo1+nD9vM65VhospuCVj5PlaC2uwymQkNikjcT+JG23y+YNCMXlNqZmu0RwZfU46vjfvJuFtZenllnnc5NGrH3AMZ1h3Zo9ox89GOPPeS/2IOoyOAHqXNKXXFm3NamjA1vpOct1A/FSK1xkHvVRpTGFMmv0te/pLN3s8o4paLSOnVHjLr9H1ROHcv2D5K4Fxc5VBAsA800isoo2SZ+S7YuXN6f8KHhdZ6EcAnlVJnADwCIAugAeCa1vrOYdxzKEMZylCGcnhy2NxQt5VS22DorNa6fFj3Ej6dSpuGVLwXYI/zJcbfpu80nmlDbZAWJMG19kxoglgCX515hTSIXsEzgbHyaVIxelnnAPZa/j+34Jhgny/el4gyKdj9WMNSXTePckCc3Skq0EgysFj4olpTyuCsBR4bxqxVZVwDrHHv/vkWggd00R9lttR2zJjAUga2Pm/LwkpGsTDdQgNJniMJevdTymhawQzNkeonzQ+EJlpcYFvPWYz8fsmuhEjuUt86ozG+j9WkDc34pI/sfVpTfx9bbpCy5rZYJLVLo6ZGd/E2jc9yM9mcCulkt6DQnPYG2sitBGhO00DFYhCtLFEPsXeONMaotipFocQKg7L7SdZHWHNvvXzCtJfhQk5RDU8sW2FG7ueVsWiEITe9btdfAp2FhR72ztPgxUoWGGa8rtFm10Wav5/a0oZvqXiHrW+2wvoF258eB36x4xqAQBQuW2M32/ilwYJYXssxNN3CxZZddpBm62HjE/sADh6w8TznJPC2mv1aiN0Lwgotc6vMwkj2shQTSu4oAjLA7uXOuOW+ilUHLe7WnH2YhXU6d98yNwQMH1Z9hdiScLVxcJ0D+mE6gNOW3CX6XbzqGhd2lyHT8UZo3MHiCTEWtrJjEbdV9WTcPBOSnyRWRKKsD1yT8QN2/ZNlbfbmfumMOiif/8C4tpHDgs7GlFI/p5RaB7ADYAHkklpTSv0dpdRBzoqhDGUoQxnKd6wclmXxTwGcBOVVXIaNWVwE8LN8/S991Mazf4kye1b2iuhIsZYsqXntCZf/dZBbYD/fn6HjOHY3hbH3SBsQ7TC9GsmcXaPTeOMF5pZZCLF7gQNhkWQ7yabup6VEqASwbR9FC+pP2VKrvWmrikp2dG6B/t9AdIsK9flBrUk7VjsVK6ZXgNHgkmWG+bHPuL+aQWaDNYZNuk/1lEaeoZsSuBat3B/pI6zROOM1qz+IJi8wX7KMBi0FqcORvq9RYQZYGVPlnDY+dkl4GmNequakZy2oCg2uPRY3geLacWpr+usOpJEyJ+xJcln9uTaS16iTol1pD5j6FmdbjwwGOrOrGhWiBjPz7bU0tDcYC4nXHbOmMgei7dVn3QPZ6I1jtr1ocSQJnAvbsFeX/igDkqhwEaHsfRfNOU4KvSbts6a5YxMHBRbcGVU2E7cg/uyE0VjXOJNp5BL9208rYwFUOO6VXlMHEuEkqdDp2bjU+OvU78oZYPoPaa2CJFsgWddAeEXEEkjuAcWbpmX6b0Q9nXuJ9kLtOD1H8Zo2cSCRjecdU89CIM6dMQsplYJEmRXJ5AZizcE2+hltrMZJzsTfeppjUBsuOpO0BhJvdAINr8nxQHYRpDcVsqtS3Esg6pYHTLR3GV9zziZBigXQLXoGvuwaS1KsFG0g4fohyr7weo1dob6uv+BC8ZyapLxxbRgYOqPSlmUPNomjvPdS28SU/WHlsA6L/xzAca11BI2NPQBfU0q9C7I0PvJhkfHIt9MpJwEOsLoxDlKO0AZM34ujeFdQFPRUu+9TFKrNgSUJWEdRFGLeyoTHag7aY/T2FPy+VKKKlxX8s/TWcBbkTWvbkgOin9MWZcFIneakFEGyD56gkPxsNE/B7iQxc+UlIKZ2vHzQYCzeBOo/SLka3iUajMnsBKB5M9bP8YHmaKSL9DYK7pBNHiTpoQGAJAdcC3fptKgfS6Fwn8YiweCpV0ODWhG65sYUE+6FwOaznOnNLz2nZ6lc5AXUmnCMuyz7gL7XkwD9g6RFT/EDMPFWiOYUVzxcoLHsXqCJGn+3a/q/d57RMVPW3ScSJID6aUbVlXgzXOVM+7yGw/ke8gLK37VV0QTJ0s+HJidBqMrl5d/LwaScCx4+uxqa/ABhGZBzuTGnTD5JmwvuqADoMgtB/ygXAgocZK/TuJw2E9rxi230aoAE1w732B2mXWDvCX7ZLgo4gcfdU2acLa7xrj2NzecZ1bQtc6WNC3Xs8qDSlNoJUTk1uBfjVWD7otSn59yUGftgxjkHI8PB4URZGxesSOlWiO2LDB7gAlFRHUbuL7kM+fukhEVlhIP9sVaAbVdIEUVZgHFzeeye9ZMwVe46TAkvxa/6aWVADPL8pi9rVOflxc396QHy/Io717h9YdkoRBnplpQpjtRuHHymZX0MOjOu0aY6WAaR2DyiTTEqea8Je4WfVsg8+PBHwGHlWXQATL/PtSm+PpShDGUoQ/kukcOyLH4ewNeVUv8cg26oJwD8dwD+7sdpfPGLVGQlNqvRnyKtJFzlmtp8osqJHJVukXh/AMuJ0otqHPynnPqVUw6SJ8k4ai9Z6mSfA4victAOmw/P1JB8jQv0iHaYsqahBDWDdKSAE9cKlzrQO88FiBVIBQjX9zHQRdoo3AsQY3jh2ouDy5hd1ig/Qn8XGcPeieCyBTIrXDR+J4bRx0hVbL00Yb7XOMEFl7iNRDUwwWKRtU9TH/2U5UDKLVO/tp92zByJlSRww0RZocDFmyTw77W00YSrx2kOEveTJrtc79utyV0Vybmg79SOuUbjF94lCUTXjseNFZaK1EwWN5uY8+XHfeOCEWnPMOFjKjAkh1L2FLDuB7EAQk+ZjN9edrCt9JY2FmXvIfTZdSaczN+la60jPrIrg4FZP61N8D1zjVTSeEUby0YAHK1jXOBq2zPWmuyF+pk+XHY/ti+yebdD1l7+dBmNFvstNmmS3a5CiiGfjWN0SQVAkmupNzkTOsH+hL3zjlkX0dCrT3Ux8hq7RpnYEj12/zTtGMVSrB9VJltcxgY4AxxT1Ddqa+SmJaNsjzHEPaYwdsUf+Ewgq7H2QZh36FprU/JrKicdtGeojbnfk5wK+k7lMd/QiguDgwq1ASUEKWudtDmgnmL3d/NFehi96xmk13kP0+sN8WqEt45zJPbOMdhjsovktYRMh5HMKoMYGETQnHJNPoswIAjIQ/mIOio+UA4LOvsPmPLjJwD8ECLQWQA/qbX+ncO471CGMpShDOVw5NCgs3wgHMqh4LFf0GsoOAxnk2CpFJSvHXNRPyWOTNIIkpseFLtHDVQ11Mgu8vHK/4jWr0Kg/YAd5ALRPN6A5gS51gWGj+5ESldKUaBTTEW8mUBznlTb7F0LApN4wcYnGF45y7EO36oJEvDMrDhGUxx/hwvflzz0cmIlSYCWftc4qozfUwq7eB1AvU5jEa1WskC1q9H/Cv041RZ4rUY/J5BFaiq1q9HLsbbLAWsJmuUWNRpH6bNKhLlW+Kj6HDBObUiQUgOSQMnL1BlVJmAeu8JMtxHjStZWWDMbx0JjHYkEcaB+luY7tsdMpHu2P6Wb0hb962dDqIChjcLs2VemPG6wlua5Yl6gFBCmOdDJ4w3jGtkltqCYWbhTUmhzgN3flzjazyikdujv+jH6ML+gTTKjpT5njbvrmO9JP5yeGoitUX+icS7WcCOU4tvPhdFmMfKOh+qZweC0QKjrN0ZMNnfz6KCPHgCyi/aesj9ikSRPgCxcgYqmd7gYk05AFvzkF2nPhzELShF2ASkiNnIzRGvCMiQAFCOceJtLyUqiGce6OiUX6S1a/7jAe7UDp88FyJYHPQ7VE3ETa5NYR2fU7qn172GrNuajeJUG4/j+QBuF656xeoQVNhlJEnB4nVwF6Bg/D/ssyva0jy5D+EfOkFlTuT6KdbYypcBV/yjTv19P2gJRR6y1ItasuXffroF4FOI19qrk/whmBQ65+JFSqvQ+n8897POhDGUoQxnKd6YcimXBmdtfAXCWcy1+Wmv9a5GvXAfFMD6SiN/Z7VjIopyeeYZttiaB5Mbg8LoTAYpXhDuFTlWvZRPjFCsMgiTQCijdEFga/Zu5lEX11GB/XE67b21noB5hayNyXYqnB8+RU98D0K5z8tQuWxsPSD2L9Sz3EBLi/7bJfbuPcZ2KsjZ+ctEwJP1f+fYzYdct3Qix8yR/3xEdgdrPrDqGtyrg7og2F5W98x7OfIES8C9dokVIRKggBPk1wB7LhZDcDlONsJatQqB6gtEwRQsVljWItjHzDfq3yxZfixEfpas2OUviFMJ/BAC5+3Iv+k7lLBAwhcXIHKngBQDlB6TTuF221NZdC1Xmf4WnK7EaM1aeUGrsfbqHgJM9dy8IrFIZKK4aVESZcVcoY5hzKqVQvEHXpRaFWCTFG8r45LPLbFXNKWNlpDnu1csDrblBzVLQVrVTIVSJNlH8LiH1WtOAy89P5mXqv/jXgzjQ4bKu3hip9B0vCbct6xhB0vFWETSPFOVJVkK0xgb30dgV38S9mrNcsGjLoqEkvpTZEJiqY3z/EmvJLgNrP8qxym26qfjjx97VpuCX3KefBdyexCoYMlth9GRGmcREiVV6bYrnADaOktx0jbWzl+ZaIdPWIpEYl6Ac26MOqmd5LZSg+SIxmWO0YePXyHQORkNjsYqoAJh5idrd5mc3tsxUI8d9FK5zWeQ71gMg8T9ZC6c7GJ8DbN2expz7vgjRh8lhuaH+EYAvAvgHAD4D4B8rpea11hLY/qPZP/tEeHF0zJr2aeajyawzAdl5zwR7BCs/+xLgtum64mhptNKe5Eb0pthtdMu6l0S2XwiQZhKyfpXfrMf4iasmkL5OqyQwvCAZIjdLh0T4Kr2UuiWNuNCcS/A7Yh2LuyW1bbHb8kKVQzFWt+R13dJg8NPr2Jen8ClFsYVihkpAupe32cYxvqZdmJd/jaGr0YCumNudIwxjnnLMqiaZzwY+kODD0MD1MjbDWcgCw4SADSzdswSzCzcVNl6g+wpmX/oNZect/6DD/U4izfdPVplnqMU8Qy0PAbs8+pkxM86MVBrjeY81LMGeuBck+BmvKOP6ENgpALRO8Yt4jcabWQvhc9Etg2Xnf+pHXROwtHOqrQuT50pcPY4P5FaofYeL+ITxpFkzIZsL4xohk/4Jn5PJSl9wEK7SgyAvwtieZ9ZMxlt9kd70yWspFL9O39990m7OJgfMHQ5KJ7cco7AJfFjcUt2Sa7LLczcZKHIsZ17ickgI75Hb1cg0OF9qnNYwVrdKkZAdPsx9IkHbftZedyOYy61nmIONyYa2L1L7mRWNbsIqjgApAcUrtI6157lGdsFF/j16H4hrVDjltj/pw63L4W/52iwNPrv2TvvI3OPnoUT3zzPIY3sUGHmXIcVvk2ZSeghmVBTC7IJn3OVR6Hd7kp9VJhfNrmhzcLTHGDYuOWZ/hMJHwOEdFs8C+CGtdQDgN5RSbwH4HaVUTmv9s4d0z6EMZShDGcohyWEdFiGID6oCAFrrFaXUZ8EHxsdt3ItkaCY5q1OCtiITb2vsPkp/i9URFUnScXzAY+2+PzcY/Gqc6qPBsE2wJp25H0Pr3GBk0eOEwNiiZy0A5k7ylpKo10hDk1it21XoZ9mE5SztkRukUe2dt0Fwo6GNhgi5nGVsz1oRO4+zysUJb6J5148po1WJ2ydWV5h6zcIAAQvHK94LsPEca0QnOai+5BrNX9xyYQy4+ir54D71GUozvrFLNMy790agE6L1shWR0ugynbMjiUFt0SKVYd6scfKS07drFXUnCd+NuJNEA+8WbQZye4K0vt2L2jB/1k7SFyffsG2luC67I0HtRmjYeEV6hdBAjoVHS1jN/LTNzBZ69tyyg16B2th5LNIQb0mBSYrrJr1htb3mSebuasUMP5S4VMQajNdDtLjGuLgZcksh9hvo2gO8ujC6ypyyhZtQxrgsXbJcWJLRLjL1FZ7HR4HyeV47tiKeffY23rh3nO7FpV/DGFB7lCwEtyKlTVmLX9AGEr7xGaJDza4HSJTF18gWZcHu+QaPszMi7jxtgvtiRXZHQ8TvpHneMHANgMmSFiu8sBCgclrWeFCbdgLiKQMG2aZFktfp2XV7Fvgy/S0ab2OG+jrytmcSLk0W/lWFPifHynPcfqyLHnsBxJVZZ5BE6Zo2oJGp1+37ZftJhjLfl7niUUScCfJcKK1skmJEhMpePCfyPHeLCqXb/oHvv58cVoD7VQA/Ev1Aa70N4PMAXgCQftiPhjKUoQxlKN+ZcliWxV8DUNz/oda6wvW5f+TgTz689EfpNIztemicoL+zzA0Tsj9041PalCLsfI5wpOdnVvCtuxTxTSxwwlbd8i1l7+1L+z9bQ8zdB7XrFaA5YB3boe+HPWajdAE1z/i0vj36JSjVmuFA16JjNH6R7SeoP0HSJtb0IjOYvUv36jxFqlTVS9l6A0zjIIl42tHojg1Sf4QxmGCjxCxEK6sed5Fdob+FadZPaojmKlxSvUxoqAPe/G0y28JHGqaPXp40rn6f4czTTYSs4frLnLyXsVqfABX6hYPQzIC1oMZn2ki/djA5UcZU4wC+rH9Uc+xOidbEIIUxB7uPsSV3zX6vcYzW5ehXScuvH4njYRqozIVokZJEBdgkL6nbEWtro8nFOTEx94DbKCpTBjR9/yCnZpIDkgLD9doaldODcamdi8owCo+/EuN2nQM1EfyMtdr2Q22BaF0K+l01xvxVkdK0khR57cvnICG+xkmrkZbe4gJkknTKMSA/BcRag2PJLDSwe5ECQRNfJQRCd5Qy/LRji43lF2l+elnHJNDKvBdvWBZm2ZtSQKlxzMKFo5xVsbrEEFmTv8XFoUYdw9MkVB31E5aiZYT5oKrzdv7XPsV0Pzyf3dEQal+9jMYxZSCzPWHEvZYybL4SHJd4TJhwTPnd3QvCbgtk1geLWIkF1ZoJjQVt45JAZ5q+ILVlmjPqfQu99bMw3HcfRg4rKe8OACil4lrr3r5rdaXUv/s47cf4pRRkfBTeEN5qmtSdxzi4uQF0zpIvJnmZPF9v9o/BZZxzeJ5ecs2+C12hxR87QZGi2RTt8PubY2YhXJfdRoUeNB8EPruS4hHXUH+DjKbEHq3Q+GUfNa6KVT/Jmz5pA1AG/ZM0TRwo0OQ1lAn4+jUOuucD5O4MkhzuclW61IZj+i3Y9/KzfcQ2Bx9qyVfojGoTTBdpTyjE+ByQA6I9Yc3fyTfp6Wis0ou8dgoINnkQnu1/r8V1vNk8loBnFFEmwdje8S7CGD0oIVeGc2C5dSQ3QgLi0frpUmjIq9vA5vRLUoeYHqDinT6aM5yxPCaBSIXxt/fNd1cjya4SPxUz8wEAxVsacpCIq8RPu5FKeVbElSW5DDKP6UgRLEGjOH1tigC1+YHXcduvyZeZQ2xWuLMUqhka384zdC2x42KESQhb5B003GapLWXcFeltpm6PKaNcmbGLi6IUGiRYal/2OACMvEOfhREMiKFk5zEFSVvNUcj3uoWCQZHtfh8rbjx3QUIZ1GEyErSVPsoz0J5QB1A8Nd5PMseApZfvFh3zkhXEU/mszd3YPSLgDj5IboTYe4T+rjFiT4XaBJclp0sUvvieY3NkMpzzsO6Yg0/Ez1oFdoSrKEpuRWfMHspCgQ5lgQcjN+mPjediZpzSvqxBt6ThtgYp5hO7yngrRVGTOQpSOuLy/GA51DwLAG8rpR6PfqCU+kEAVw75vkMZylCGMpRvoxxq8SMA/wTAN5RSf5f//gUQ/cdHZpwFAL1E2ruDSMBHDbJPBo83kHmbjn4xw4q/lzJ0wRIQ33p+UBuJSr+aAJinyb/Dcfk5i2cTi0LokruzfcQ3BtWJdsk1GlGG61vnFwO0RwfPaaGZzi/YjEvhiEmvWQ4kgegpDaQZi771pxiCyEH4Vk4ZhlvBqPcX4yhxMSApqyiwUH/ER68n+HnJQ4GxLKqPU/vJpbjRftY+zdDGqg3GhgWGJXt0H/eNPBL7olO7zzH0suEiZii76Vr8ijWvEmX6O3StGS/aofzbPBIgs8zm9hG658Sb1BfABjjbY7Z4klgjBj5cD9Eal2JGPAdpBT3B0MYH3DlNFo92LU5dWGLLZ21NdcMztaPNXhy7JG48ns/Tji2Sw/1ojylDkZ9bFi1cLCNL3W1yDsZswFrYR7ulEFUGL4xelTwCeS40mjO87gVrKRg3iGT58pqn1+z+lH3QGQdKN5n+na2gzgggqquBirKx3yuG8FOD+7zwwLqvpChQ9QTDWDdCtOfoeoeDvclN60YZKDfMYxf2AnwPIRD679o8YMnLSJTt98UiEa+R06c64gDQHxGXtmc07s40fZa/6aF2gcEIHXrGBbafqFjmBe2KO9zeU1xk6Z0Au+cHX7nCgZW/pw2MPxq83n6S9yvD9GUtdFvZErp1gdoDWy8Muqbdjg2wy/PZ5ndm6n4cifKHh88eqmWhtf6nAJ4D8BcBbAKYAfC41vq3D/O+QxnKUIYylG+vHKploZRyAPxXACYBfBXAJ0A5GB+LM0o4a+I30kbTqjzK0FIO6Or7NigqWpwTAJkNLp7uWWsiz5m+xd+kI3jjGXKOpzNA/3HSLA176tWU1XQ4eNc4zr7Gume0K0ku64wqExw1mdnKamGi/QjvTWGhg82nSTUbuSpFfJThWBIILWIhdi7ud4qyf7XrGA0kiq40pT/Z/+4/QurweL6FbT2IR0hsxNCc5SDfmxxALQGQIvFcz0DKdlJwkrbTzDc5fvQokOEgoxQ/gsl0tXqK+MajhXhkXhwfyD6QzDEeEhek6WdtcpvTFy3fBi8lS7d8imM1+mBNk27BweRrlDCmQmaCHUujMTOYkJldpR/2Ch68JmelZyLaNwdHQzZEwhhQp7gtRjmOkN5lPqOI6pisDPJAAUB1XrRTtjQeAKnNQdgwABz9bd4fRYHm2pKi5bODpV87Y9rsCbGEUxsKWY5fiLVUOUVr2JwLEeN6HDJn6TVtYNepHQsDrh/nEcg6cvyrn1Po59iqmuGiVzsx5JZ9bmPwWawddZC/Re3X5+laZzJiPQpj64ZrGYu5dkr7Ju3fYCQ0RYzEaotK9SzHg9L878rBxNvavEKH+yvxt9rjPQOfF+kwE7Gfc+A1BuG9qW2bTCjz0hp3kWFQRHOG5zGSGCfZ87JmoQv4RbYUqoOv6n7WxjhMZvuqbUuguc05bd4ZycW46RsAVM6FA8XOPkgO2w31hwC6AJ7SWi8qpb4A4JeVUl/WWv8Ph3zvoQxlKEMZyrdJDvuw+DKA/0Nryr7RWv8HDnj/s4/TqJzv2Re20fzD8YFrAld0fGVoM4ITdDpPvOYaTh5BEngNbZgaN58dhGjGa0Dut0jLDz1BL1jtImDf7AACwx/0OyZ39WDNDADbTzom2Su9Jsk29jtSvlESsFrTIfL36O/KBdYSluLGOnF2yb8vSW6NI8pQEvhs/XRmfMSajARiXn5UyOm53fGMxg+mi4jVYZlRj1rNPs7JaYKokVKqiTKQ3hoc58jNwFhT8aZYUNSH1HZoC9mzBtiYs9XCBJbazym0pwbRT1woEZ0EDkisbmMy5TNcrjNSr9H46Hn9k3sHUUz1ubj53uaz1CGBMHptq705bOEk9iys0+nZ64Is8rmfoSfIF2Us4jJDYpvHfSjeE4Vb9FkrUj5MrNMaxy4yqwe1Zqdn94AgwqL7VSxh4UVrT2qokNevNjgPo5cUGkz3KfU1VAgkdga13/a4Qnpd2h3sTxjTSO4K5JOT/Z7voVvkipEch5P4Snvchcvzm9xkxGFGm+fY6TJ9SkmbqnWimQv9DFHB8DOVs89i8yiPL8d7n7/fn28jnqTPuk3u15kW0Bi02t2yB1eqzx07WCtHUIdiEbWOaQN3FyuscSQSY2GR9amfCpDcYPZdjtuMve4aaqHWGTJZnTL3r8n33gAAIABJREFUa7wLbynJ9+I4zyN9JO/QS6nB7zypmAhYOLpY+el1hdqpg/v//eRQDwut9c8/5LMdUNnVjy3lq2NIsdkfqzBXzQUiiGvdLkLNsm+nydmvx5QJSnVmLTC6cnqfO4efwzBmifgEDui1bIaobEapndt9pgFcH0ygaE0pQxctNbizN+LmZS4muLwkqyeSJv9AXnKZVcdkDUsuiD6IZrQFXWq2xq85qBIBVMAlTfmllNwSinPXPPxxzr5t2RpIBsbYmtYGINCvDW56wGbF1xiTrh1g6vV9lMk8j35SmaDqw65bdx4RQAJAcmfwB4X7oXmJpnbpB7VjEReP9HvSunOyG/Rg1eck6O2gdobAC1KkKFkJTZlbCVwLn1G8HiLWoDYkq1rGCtiHP72hzZyKSE3wzphGd4T7zS/a1JodW/0EH9hcSjO1G6ByanDBCws9zgdBhFrfEg5KoF1cDv2cVSAEegxtASJlznA2SkYqEkBn1+PoFVvS9mH7Tw79GL/wg4RzICo68c2YyQyXfKlqm92EAVB+njZAbJ0GkF5XkZLCJN2xAOCiTabWNN/H7dqa1yJhDCYnoaO5LCxDuf2sRmd8cKGOzJaxukT+PFMQKabNu0OzQuVmOOA96aM2Rg+watuJaT5OJ3ZnjbQFpS2/lexvKc2sMz5KL5Jv1/k6456hTRG3XmHQXeZ3XcOG4DBc1qlEACJCaZ7V5m/ZC1J6FRh0B3+QHNphoZT6AVBg+wKI+qMOKn70y1rr3zus+w5lKEMZylC+/XJYFOU/DeB/AvD/APh1DJZV/ZdKqb+ntf5HH7X99OsUiO4VLJQwyS6T+DuEB1UzCi5TMYu21zzhI8kanFeVhDZrbQjEtXOKNIJEug8sMoUwFx25eHwJqw1Sx/7cDEUuf/VXvpd+HzqYfJH4oheXidU0uWQ1gsmXWLPXITolCR6yZqHYHD2qDDyxZ0qGKgOdNNpeYLmGEsyP1RFrIARKt7X5rYiUVxSLQgL/e8/6GHt1cCskd63WLvxBKmIk7HyaNMDS60wHnVQmkCdSvAXDGCvwQTfipukwb5RQRANAb4R5tloM/esCmQVeM0nwmhOXlkJ+MRwYpwotWCBgN5GhkJ8BgqQkJrL2GycabMCa86Nvu6aQlOwr2UOtSQ9Q1B8podotKVPOU5JCG0cU2kdI8+wVZa9RW5kVawEINXx+OcTWk5IARvcSV5IEqwFrFSz96bjRLEVGrocmcCpwSgEzSCIZwDxRIOhngi1Wcd1J5nZ7OkRmmWG4rzB7bztELxc3vwXImrDMzWzZimWRtHME7kdzWmF/dry4HBtHFTK3SAvv5e13DJ8YW535ey46YzwWfrzEknJ8mx0tgd3UumcsoTgH7XsjnFBbduCx+yn/SUqd32lkTBfFrR0kIwFrdlsVcuTXa3fjiG3RvupPcuGl9Ri0Yy1sgKwUeWYl8U4STqMiUNfaSQvFlQTaHifbzX7VRY0BFGlm3G2PKePyEi9D52gfAVuxvRHah8K/1hnRxlX6YeQw6T4+p7W+ue/zLymlfhXA10E05kMZylCGMpTvAjmswyIDYO19rm3gYxIJijbUnrQUF4Vb7CvmZLv6vLKBZxXRZk9QkCN1X/iaArgd0cZY4+pH6jYwe2wqZTGXe6+RT/FfMyNk92lybCeTfSyt0zEuiWnd+Q5iK/S9zc+yhlb24GdJO0mvML9Uwqbni1bQFIqEcR8jl0lLEYoJt2MtA9FOJTlLtC7AailjL8cNxHG/eLse9h7nORqn+XG9AONfoh+n19nqebYNvUJ+UQm0Vc/K3GoDGwwZmuknXZSuDWqRJkEoppBhrVMguoDlshL2TtVXhoqk8nlSewvfIItRO8D6D9G6ZK4mpRsmdiL+YWF/7ZVCw5Xk59jv3HAw8ZYEJSNzIuGuF2ltM6+whRmHKcMphY7cLrD7CK8jhzH6J9vIXKV+EkMsdw5AN1KPQeasdtQ1gWLTB/ZnV84AAVPLnD6/CgBY+f2jaDN0MzlNfdzKZKF53yWP0ObQl8gK7oxpo51KDYVOSZmkMAPvnJZ96BiNWOI3vYJnkriEXsXxtYENy7yvn+fSr13Lc5YUuOZZ+1nxZWo//YDMnsbRMTNXYnnHmtrEi6QuDWBrvhg4NU9xa8paLjmO77ltmBiRBPn7HHtJb2hT/0L9v/TgOFMOfA4QF49TDLS8k0NpjOa0dYkaK5fIInE6DkbYcq6AE/Yc2yfhBOvnLBhGYkMeW03p9xIo36f3igA4+hF+bl+eqRz1a/eCZ+HxLN2xED7Ha8II5Y7D8R09yrVnIsgQSUj8MHJYh8WvA/h3Sqm/DeA9DLqh/jqAf/txGhd0TmoLqJ3hTNUsDWXrKQk6hsgu0V/yQPazHur7qtzl7rsm0NqYl+xiJhTsWPO/06Kdeuf3i0ize6N6h3MT+DBqZBPGzdWdZCx+0zEumG1+iefP72JvmX4bPkkbsLdD7fcmtGkvsWpdWBJolwzbRFkfICMUZEO85hj8eXRDdTmon7lN7QpCxOkpy0NUpWu5yw6yS/QS2vgEveGzuQ5wng7P7mXKlO0do8Mlcz1h5rF1lOYxjAMVrrYmeSriSmgeCZE9ThH8gOfR7VozW8733KkyKnlyLe6PqT75F68g4dK9fnf7IgBC8YjLqDPOB84kI0ncANlv0FNaeUzmUWGb3T+xIo1396kksguDj0b9U/SWOTeziduvHad2I243KcgVSPB4J2HGsl/aU5ZkTsAPyW17XYLOwomkQg1vdLASTncshGYeovA6vVV09uD9OlOcT+BoeIyGk6zg3AOY4LhB1vH6DCCb+Dt+Gmic4Xr2q+zO6ytzffZzxKJ49xbBuPRoD3ufZ3doi10gD2ImEL7NeULTbdrII9cDlM8Mck51xpUpsDX6WiRfhhWjfn4QQBHMdgxKqDnLQIG5Jpz3aI7kmZFcjF4BaPBzkIkc1oK8qt3hjPCRSBBcC5CEkWR7ijPZgck3WfGYcIxiJ64mFcLknYjkFsD9UojVZMwWpBBnF3O4Lx2kOxaY4lqiHD6MiSK+FkOfXW6iBPtjNJbcWBPNhcKB37yfHFYG90+BaMr/JShzuw1gC8CvAPgWgL98SPcdylCGMpShHIIoToE4vBsoVQSQBdDQWle+HW2e/t9/UQNU4lIoyjOLpLlIoLF+xDNmq8BOG8dsWUUpqNIdCZHaHDwzRdv3vAD99wYzm7WrTQlHoRDvFVijrzgm69aUHZ3rY/wVzoplbp7uaGh4kURrAp/6yQ3PYOilXGavFBoXk0juvmPyPEQTkSxSaCDJTLSdMYuLNzkoHPAVLSe5rQwTaGfcfl9cDskf2QQArG8Wkc6RSny0RAkX5Q51IhvvYeESVSwKMqzteSEUwwzzb0q5WR5T0VoW9QoXskn4CDYjvgYA+RMV9APSNv/e478OAPil5c9Tv9w+plK0Vp/O3wIAVII03mTe8pUmLdC9DYpWO26AeJwtPofdlYsFpOaojT6zCScSPlJx0r6+Z+oeAODVLWpzNNXC9fdoYWSNtauN2RPjetX+ehphWvxyyswHQPDK1NpghrXXjnBZsSsotcGBywltLS3WRLslhfYU5340JcdDGUvCZditKQ87FiC1yu4I3u5+Vpt7iBtK3Dv9QogU01wL8EM7tJ8BQCXYTVNsosJWssMulSAtLkQHM9+k9upHbX5Th2nFhbpdIJ1BTBk3cmOaNf+Sfb7kOe2OaJSuU5/qx/e5XbSFoQuLAnWO/x2l/SvWBwD0uQ76554mwErdT+DNO8dpHve4dEDRh2KPg05yJj57HrJLzgHuqfyib4LqwgelQmsh5O8P5lLllkI05oRfCjxOazXJGrhTZOEm3s6iLYXFJOP7eBvpNI2vsUgWg04FUPxukX5LsbRssY1mjebhwX/9v3xgpPuw6T7OIAKdVUpdFfryoQxlKEMZynePHBZ09iiAfwOKUdyDjVmcVEpdBvBjWuulj9q+gZ91lUlmEm1JAo2A9cPWOcktsavg9EPpJAAg1lCmfoBINkZqVv/dEsDaSe84c0QtJVA7a+MRgA1qptc1GhwkNQlZIVA+L/3R5vuiNRTfJVVDOGt6pRCiBkmsJXfXJW4aAA5rdJV0DF6RPvM7nFCVJZUkue5yoI8CrQDgLSSNxmL80jy29lNtNMtccIUTfJK7VtHYeYuyeFRao12m/mYnNgBYywIAnnqe9ICtFvmHi4k23luM1EcF0D9N/Ukme6jtUfzg+BFy2K/uFJE6ykFE1niU0nh0cjDyu16jGEZ1qYDp0/Tbt7YoODJftBjRXzz5RQDA703RAvzKvecxVyBrZrFMvmhnvAOHNa3njtKWnE1VcGmP0pevVig5azZLv7u9O47CbZpISZ5ToYLL4IhekuYnPt1C4g1ykEs2LXz6Xf6Oa/amQFx7eWU/40B0izPXJ94O0ZizDLQAQca7o6JV0+/cNpC7MxjZEUBB0HBtWVLee46vUOcYhFflvj1C8ycxNWqDg6v5EMkiJ5oxK3CrY53pcU6MVZK1HQLbTw1C2+nvwfhV4R79sXfOBl7DBMzvPLaSmifscydwXdnLYr35kbhNmKJxzpzYwdoaBRWcbWpYYku5Bw4qHNv6g5dtTVyXE3qdrtAIB9B1thA48S5/ghwldb/4UD6q6jGurcNWfuMI9lfCNaK0zUYXNtn2rEZ8R2I4bPFxfZj+I10DMnnhRTKzXnnnPLws9bt4gi3/1QK8UfpMSfJmxc6z9j98JOJQ3FBKqZcAvA3gb2mtW5HPMwD+BoBntdaf/6jtn/iHf18DQHo9MlAeRuMcv1TrnilA1D1DkxU2Y0gx+sjkVMz0keaqeaXP0AtwbYselMS9JLqjjPtnfHZqW6HxPE8+I4PipygyFb5XsBByXpjss/YpKd+kDRuO9+DsMLb7rrga+GVTsqbn2DuMAjpjzdfxd+gGmz/UNS+5gF/0mg8Sp+YZOpFwlmuBLyRNULB7lvu/wab4bBshtyEVtsKYzQuIutsEvdGb4brLu2ymj/bheIPBxunxKlYfjA185mTpFH3y2LL57NISvegzmQ6emaLPl5qWajrkgOL9JUokyd6gyWjNhAbBZvD2CY38PD3EDrua9lZpAM8+eg9rnCOzcY2TUjQQO0aBbXWJDrlTP3AfyxX6zUiGtm+tQ3P1V0//Hn72qz9KY4/UFQ9jtBalp+jw2t7NIeRDvHjZ1qsGSAko3qF5aE1GXBS8J+P1QUSQ17YuTMkr0Y4l0RMlILcYon6Mg5iMnpHAe2rTMUqW7E19rI1g9yGcKQCee+oO3nzzDPWb3Wmqe/DFouMhHM6JkRemir5SBLTEbi63rU22fXNaMovp/1tTB9t3+lQsLCqNeR/5O5Z2HrBzl1mz6CYhmdz9TBeaa66X3uBiVlPCYmBpe6SSJQBD7SEurcJdoMxkpYWbUuec2i8/HQl+88vX6Tim7rzZoyltXL8j73GuUEcOEseQRcph4fSBKuc4BVOkrJqXu9J4+tQiAODWjqVbGOX9uttk164Ton53H0koZ6/38xbBeOd//Zk/MTfU8wB+8CFV8ppKqb8BYO/hPxvKUIYylKF8J8phHRbLoCJHX3rItS8A+MguKMCWLO0VtAkyZrlMoXOVzbQXa+gFg9jSzEQTheOkVW9dJtdKbM9OQfmbhHPOm/wFILUl2ps9eCe/wgR8T9L/t+vsMimFcCepfb1IJ3v5xiiCrBT55kB40ofPwalKgvor/C1hIsSxk5RJuuJTf2I1GzgXSV1Noc205Qk2/ztHrTtNoKoBq2U6BngML5BSzAHXcI4vpBDrCRyZA/QRI0H4pdRUB719BGuiTfq1hAl+iktga3kS6bNkdbW2yeUU9mic77xzyrj4nnuS3Fc3/u05/MEsaf6ihTs9hRgH7lOSL8HasgR2AYtlD1IOfM51EQ0Ns6TW7nYyWNskLSvDVunUt1p48MO0T2RkN14/gdh8fWCcv3Th/wMA3O9N4Pd/5BcAAH/hxk9Q89kqql1ST6tdqwZLpm8vx/XeBWobeeqkpKjbDbHzOBe4aR5U8or3aG2rJ2xgXGDRArXtZ5Upo2qznVmLzFprWrjM/H4KAQd3BTqt0tTJN94+bQLKUi7Vz2joBO/hHXGLucaqEpeXY4K8IbaeG7RmnI6Dbol5t9jnsD/rnOaD/k1WA2w87w60AdhAvM8Wbu5Sgj9XB2qN599OGg4mqQUulgUAwz1VuG0z28vP0F52y2IVKkNuWHmGbjDyGtfirnpI8X7qjrJFN+oj5JIAsVM0UPdS3mRPKy1WBP3/yA0f20/QAsUZQlt5xOaAeZyrJWSA7mQb79wjn3emYAumL92cHJirxK4LriRtXHTipRh5Yhuby9aC/yA5rMPirwD4daXUzwC4DBuzuAgKeH9biASHMpShDGUofzxyKIeF1volpdRJAH8OdDhMAGiA8i6+zMyzH1mOfI4Mk0KijTgTGF36yiMArEby6NQ64pzhemmDgqzzo7vYbZP6IwVaOmPaaNFTb5B/PxpoE7+nlCAFgI0X6N8ww8HBTT6qI8p/yJmR8T3HFLsRja4fOczFopBi6plFDzg5ON7uyY7xuW5z0mGQDAwdugQg0/eoH+2pEAlmrA2iiToC71sm7VeMpTAG9IvC/yMao40DCHQxeSVttJJecTA+0SuGhvZZ+vUD3/8Ovr7EWZAcT8lep7nNrIVoT9C9rqydo3sD8Bg0kHvAmlcSSHCBoOqpgz5tU1ynyFxbEa1SYjMxHq+jNFAbtIy2nk3j+G/R9+79F8x7FNMY/BbwG5WnAQBv7x3FX3+HYizZJZ7AH63iwWv0mYk7tBS64weprAHSwHcfozv4z5IFM/nL1iLZuSiJWLwnlh20YgdpXptzdF14mvYnaQKw8EpfGb+337b3Egj3k58l6PE7HD/qxw++GuJVhe60hdYCgM4EiHEpYV8g06fpOdrNpUywXuCpwVgPHZeznGMWqAIAmdCxcHexgkseMpS0DqfPMYILdk+7Gxy/YjBArKGMVSVliWN1oHRrkFn2+JfILFP9AL1JilVVT0jwG5j8OifXFiwrwv4EQEmaDIp9OMvs0SjZNXeYlVYxX91zP3wFr3zzUQBAcstm/wNA5ZwLeUB9Xkcd0wi4rLOzxcy1kS01/hLds3KWLZyugiybcKwBNqbl57lYE1ufBQD5yX1p4P8ROTTorNZ6F0QkOJShDGUoQ/kul8OkKD8K4GkAB3IrlFI/rrX+1Y/atsA1C4k2Xr1LuNjJz1Li2MYaqe1+6OBemTLAEjE64e9uj6G9w3xHrDr6Y32kzxEaZqdNv62dphM4d881fm/hCqr8mSbSbzEk8pTUWWCEUEEj801qX6B9foQFq3WeEQ27SaTWGQUjfmzminH6QPUrBNd0WHN0lxLwc+JvZG0yGcJlZFH8Ct1EymXGq8okIgrff2dMI14Z1FhFi+/O9qC61qKgaxqtp2nQudd4TNlI8SCOw8x+gdBLtxangM6g9vv6P3kKigutFKQuRATZIoVuRIv0Mwoj10l7E34sIFIClxW7kRs8F67CzlP0Wa/IY6pb9lu1Pgij2frNI8DTpPX2nmUI77eyWPkr9IME6N9sqosuw1yXt2lP3F+mxL4zRzcRTtA6BlvU/u7fPI4EWwMNLn4T5ADN/v8eF3mavEh7dO3uOLwljlHdor20+EMBVMAlNJkfS7T32pnQ7BfREsOYtjxDKbs3vKM00f0V2lCaaSoSDxLI5Tme9gT9O5lrGKRZLxhcuycfWcDVAu1D4UU7P76J168Pmr3jk1VUUrQ/wj224KJf4P+J71H78Qf2mRLIuoxXOzYRVHz5AAx/lTDiJnZdg9SrPkF9E2qc5K5GZpNZZz3L+rr9JF3PrMkzwlr5mQy8NrM8sxWR3gpNbZM+exTcHhBnFl69TgOQolBSrhSw0HNMdBHWGXk1a7X80gVyqnTO0HqeGiX03LuLRzA+Qlbm5iYFoZSjoZkmRZilJz5HlHvrr84i1mJrfUlmXBM8F0Bix67nADotIpl4DzvXxx5+8SFyWHkWfxrArwFYAHBGKfXLAP5HrbXM2j8D8JEPi93bdAiU+2PQBa4S9e8psCMgscvxOYBhgfJCDpMas6doceo3mLRrLwbwfFUll4EzHVszSWMmSiUsAMadk2DzW6qT9SI0K5KVuvNsaIqlJB9ECLz4hZ3gYGbyNPMkVYpocNGUzBV6+IKkXXBxc+TvxFA7NejCkoBvrAm0OM7VPMJB8JkmnFcjzGQgviAAOPobDppTEsgfdG0AQOMTFKDLpLtobT3E1wEglvSNKS6gg+gulcxtOQwaM46pue0xXXe8qeG1pAKfhZSKCzDH9bzl8CifA0au8EuaKdzbRyxhk1QZyz/gl+5xhdERMru7X6NFf+K/vIo3v0quAf0oPay7iyWTjWyEXSx3r8xh+lX6KHS5wuIzCbM/pNqZdij4C1iOKgFQ5FqRQ9mVXAnXcPZ02T2Tn6L+1JfylkhuljOQVxM2w5fXUfkKIbsr3Wl6s/a58FdwroEmc3DFjtMcrJbthu0wt5oXo44t10r4z86+NzAFX/rm8xg7RW/pFCtg2XgXlRodFhcfuw8AuP1bp2nK1jQczgspn7XzOfNN2k9+hu4pWczRYlgCcBA38PvJ6Ov0RSnKFHrKgABkjntFbSrUCb196NJh6gRAi92h7UnLeiA1rON8//aEMgpJZpm5tRao3/klH4ldViAS1G4rHjcAjsQEjfcb755H4ToN0mBvvkDvox+98Db+zTc+SX3iIcfqDroTonDQh8vvEe9WogNsX2SXLSFooV0YyHxn2j4H5nnkdo8cpQNrq/7wZ/n95LC4of4OgB/XWj8B4DiA0wC+opSSI/gDMb1DGcpQhjKU7xw5rKS8qta6EPl/D8C/AunwPwxgU2ude7/ff5Cc/AXihtLKwj+FEtzdIO099LQpnSjm7uOPP8BOm07+1SVSdWO5ntGmOlwERbFG4KwlTVBQsZYcNmIYeXfQZBcOJxVGKKpH+GT3NNJF0vI6nH0ZS/iYHSFLYuEmaQqZWc5cbiSgGXqquV51cbqGWo1puTmDunDLNSyzQs8ubKthzJYilaAzSj3EFziJkKF54lIaueGjOUVjqlIeFmI1ZVwe4t5Knaug0aA2sm9Sf2rnaJxuyzGcQCKJbVv6UbSy7KK47Oz9s8yF1RlRKN5nS7FIN6+dUKZwjydU2DzO3EqIeJ3Guc2wU7drXV05TmDrcnJb7VSIsMCMm1c4CXFXI1EXa4ehkY/68GpcIKoqyVPgfmsTcJXiRK0pZSCT4mYYSbWwtEcurM4qaXCmgE0phOLse4ddZepIy1gBblXozvnZLPaRvUTfazzBVue1JFqPcwD/fpK/D/Qn+Hlgl6DK031mJypYXqE9LxxHmRUHo9/Pxbruc2IXL2HhhocmW5THJ2kB+oGL1Uu0X3226L2KZ9ybfdZ+sw9gJMlupdaE1cI7JSlsNfjuaU05ho1XmFSTO4DLgW0pfhV6CoX7Hf4NPQ/1I9Rm8Z6P9U/S3+PvcsLbrGM8BGKlJiSr+pjlixOq9d3HlGWs5vno55S1cBd5TOxizaxr7F2ga0Ln77U1mKLMuJDak/b5kHdTdtnuaUlO3HqWvjP+NtAZlSRL+kz2nJ+m+wK2jGwvZy0Q7yRZj/2eh3SGfuS/Sfuxf4HWdXKkZtyPb/3gz32gAn9YlkVZKXVE/kdr7QP4cVB+xe/jINv0UIYylKEM5TtYDivA/fsAfhLA35YPNJkw/61S6v8G8MLHaVy0GrfmIbZJ2lieyEERY+2jm1em4InIjZfnDYTPHbEYy3aZju1UiQOAwld/poIgGDxPWx3PavCRUo4A0M+GlnWW4x7ad9BZIiNKAnleByi/OJDcbiSb6xgW1uQGL8+0vZ7hwGhnzAaZm7NSdhTcL430DGkWzSprruU44tXBe/Weoe8szSehOIgpnPd6ro/8yzQvYjn13yohztNRf5LmL8lFpOI1oH5KD/SxW9Toc+JgWGTo4pKN28Q5700sjHhVY+fRwZKlpVshUjtsbXBZyD7TObQmHGNZiGPTa2uTrCYWRVSkDGxmi2lcaj76+cHHYOQdF825wT7u30sAsPskW6ATbfjtg49Su0Jzf+w80chsvkIB4+yRGpr1weB7EDgoXGboM8Ndw0g9jC4ztcr69DOUmAlY6HR/vG8K3bhTg3s5Kp95nthVvxE/jzhzHyWZP6izTW2O/9lldHYpxrH6ddL7UlsaYCR05r4t8iNzL3B0STjzk8rAr2VM9RMORq7SZ6K1S92H9qRGnrX8HGv2lbP22TaJsQqonmT4N1snhQVaz9RmB9ll8cXTteSONtaJVswzNUhZBgAon7dxO+F4E5ZfGp/tE/Wf4zGRWKVY2ulFzxQnk/09/YcWpt8al+RJhr1vavP30d+lL619yjNw3fQaNSLFqWJNWyRNAu2JXbvfUy/RHPjzQMDvNzENvNv0flmd85Bc4QX6wYPzsV8O67D479+vba31Tymlfu7jND51lIJsO1cm9pfzRXuMX8gtbdxPwuukQsp7AABdpQlM7Cn4jGDp36OXesCpwsFEG6nXadJrj9HLdP7EJrbHyZX1+Di9BF5fOE7tbySQ2OWXObeRXImhnxt0zwBA53VyCXhCivgH9GB2RzRwlAkC2f3TeWcER96kl22ZNyqULUBjCu7Ie+F0E+1FGkuKN1DnVBfNI/yAM51zymM0ylQDDc6w/sSFuwCANxaPoXqa+9YTnhyNHnNljb7MBZT4ofNTFi+f4MC1YN8BIHWXDgkx9bWjDFIsWqApwcgoeQlUTzlI7cvKya5ITohGN8/ZwE0cEOUPZu0WbxzM7u3nPCS3mCSSXU+14xbdYup+H2WUTiZEl+tzq37kRcy8SeWr5D9pna4hf43b4cNWEHWtO0WEXPHM4zPUvWcJGcW6Yr1mAAAgAElEQVT9JygDpTR644MFznsjAUqnaGJ2yrTW3krqwPMQsktz/fIUvDnqwJtrR7FfYkyeGVQYBbZbPPCdIKGQu083kOqG0RrOQp4p+Q3pNesyjHasygfOKB8a2TUu4hTzzPfEnZu/Z5WV0asMJMkqoxQKakkq9yW3HRQWuPY5E2tmNn34KQ4G894JUnQtiAG1E3qg/4BdA+Fsc3pAz1IwDcj4JW0QW9llena3nvZM3ou0W513TSXA3ArNd4MVPRUAXoeu7TwmWT7a8Ln1ODfCzHYIdDlfS1gmqA36huTgABTEB4AEg26ENaDSjRvCxg8jh5WU1wPwcNWZrn8suo+hDGUoQxnKH68caj2Lw5YgHZrA8O4kqamqydw5XQcO86o4nFGcXtcm70A0UT8DpJdZy3ia2grWWeVdyNi6vxzgvv9gArmxQTXWZQilW3fQmRzUAAHKwAVgaMbj2R4SbLFItqYEt7y2QoYx44I1j1c1WuO0VCaTXMPUsBZ1o0XITCRezyIpgTnJBu05yDPUT6DErSo1Fr9QRXyT2r+0RHTewZwPJXxUPas9SuDXcDdJcZ2HlBDN33OMRi7aTVTEJG9zwaV+Tpt5lqB26AFbT9F8CCtn+RGZF9svsUiaM0CPM6cnXx50Q/lpZbLBk7u0Fs2pBLpjgzUrQ89qzIJbl4JX6U2FCiFDkWR4Zd1JIMN7SOCf4dsFE5hbf53hjuIx0zCKtsxjMNuFPkeTGS7z/uNgvA4cuOxeyp0h6unKWh57b7OqO8+syjFtrEaP5zGTpeDm8ectzfvVy+xjSQfYW2dMv3AQ8Xe6eynEymy1icb9kBBo+FQd/n3aZEJDHuUVExeM1FHPXNFIb1KfGrMH1VqxGKTuNtX1FmuUv9PUZp699mBeRj8fQ/kUs0jfpY73Mw6q8xJU5z5KHSAFOMw9JlTiQVxZi5KnyulZFuY2W5ay/q0xhWR50HtQeOCjn6YOCzQ4Oi/CAyawaqen0C0Nvo79nDYQdtnrmRX6/14eaB5n19sqv78ykd+yxyK96hiLNrfMFpdY422gnf/wAKfDCnAPZShDGcpQ/hOS70rLYvsaHe1eX6Hb4QD3FdIOa+dFG1OmroF+iaKTlXPaFI8JPbE6bIAw4LKa7hipH6mjXfhvDLIyOjUPnW3y577+gLQyp3NQ8/YLnN29TdYLACSXRYONm+C4QO2kWFFmPTRaVXaVTACltdFEc8tco+F8wgbLpgZVvm5JozdHmrMUPEH7IABNChw17xYw9yon/7DW0Z4DCtcHy2q6HW0YSKVDUi8hyIQmIU2smX7Wst/KHIsmWJsHusxSm7nNkOKGjSlsfYG0z8TtlNECCwtdHi8FN9vTAdw2raNkBYdxGOvETw7OSz9tfdGVeWojWQmRXiFkQGuWmYIvBihd5rHzBOqIWqXZGqhx4aD8dB0NzsiUAkD9fIg2l/x1KzSBDc7Inj6zjbUFim0IX4/jhTg5Qar5epIsvsoq/Rurukiep738P5/7HQDAr+Q/gRv3KGAee0Dmb25DofMiWcc/ce4NAMClGkXqS/EWfn7mawCAv+x9AQDwxmtnTQlcYZPVvPfR9uBy0F7mtlfU6I/RmI4fJ2bk1Z0iAmZTLj/BEyS1nlKugTGXblm1eucC9Tc0Bt1gETEAaE3z87CmUbpL96wd4WJCZasNyzMgGrifcg5YsSoECvfpw50nGMLLQfP2hDJWiuGSqgFpKfXK/e+O2FLIhdvg/vO7xLXwXkTYqWvHB3Vxx4cBZKiQYygLEnDXhnXBsBNHdHnhQKvNS1samuuMaJet2rMNOMwIIHFax7fr1y0yJJvHG2toA7v9MDK0LIYylKEMZSgfKN+VloUjJQ9vZ+CvpQauuXVWHae76DG/T5tLlqqI770zRcf3/JkNlFvURr0x2JZ6qWTqTqTzpOm26x7ACIUSU02k2F+5/YSLDPPVa44BhAmgNcvxCKbjyN8lSgHAMruKhmR4kADjI+6nXVTn6VwfuzzInglYa0NQDltPH1zWkbkKmtuEwBL/Z7doNbSdJ0itk3hG7rZj0EqJiCaXXR0sNK+VpZrocbKPYq6q3kho0Gf+KVqz9Wm+TyIAeqxVnSVtNlPooHONtOmQ62Y4fbK2oiIJcgLRBWzSH2BpWPY+Q1/Mv5Xk+SE+qajEqz7qJ8j0k8p0hWvWTy4i2lj9iEKcwgZwOxbaLCU8OyXmYsr0oNcyeJisLYwhO0UQsE6bNoAfqRPyPbOk9n7LOw4AiLkBxlODcbJTuW382ItkPfzCze8HADSOJxDbpyj+2vxLAIC/8OCzeOZf/QzdixNGXdi6FOkNjtFwKVCM9hFeoD76EsMb7SK2SnO5XKM4TJAJDUeVaN6S2OdnLYqrDIHaasPP1NlHS+T0lOFUazFjtHZcpDh+FTDiKXuljfJZtk542jKbjKhyFcYu015rckzE64Soz8ozMbiuo1ft89TPUv8rp+2+inNC3cgVhUSV7tGYlUp59J1Y08ZAtp6kfsVr2tAAdRka7LYtU23pNs2Ln6R7Tn/xPvyTNKeLX6D5jleJQVruDwC7T7CF3rF6vrDsFr+cNvEUiRWiYq31Nif4iaegW4xaMR8s35WHhUiYsO4ZQ23MuQy9SG7C5DyZ9+V6Gl3GvsfyNIPLO0X4W/Rj4VURiu0gASQ4O7XJUFSdCjHzCmevNmmHCKV5d7qP7DLz3Ryne/eLIfK3B11Ae4+HyKzwoSLmMz+PvYhZ2JzmDO57oVnw7Yv80LlAiiGq1RMcSOMym9lFDeUz3TLDb6vxNJItm+EdFa9t3SztOXZHuNoQDQo5nldz4QTSbw6g8uHYnLGPYXeMcytiGp2z9MIu5egg2WtaUPrIJKWSV2v0UvWvFAYongHKHZE5WfkcrV2KPCAII2e7uLnUZBfh4r46nBGRcUo5y+p83ByyIsm90Ly0hJuoztm4saqy7hMecOtWES63GyQj1NAlBjTco/5Icaj89RhCBiNIfkYs18PCDh3mi5z5nUlaQGG9T+v5s2/8WQDAX3v6d3ExuXJgfO998l9Qe4r23C9Vjhz4juJIe+JECz4rVH51X6Gw23F0xvjAliGtHZzX9JKH1gkaV/IEucASv00HfuMYkL9GbbRmeH0CAhoAlptM1sTt2Kxob4Je+C0vifU059cwBD1WS6HO7hhRfJy+5eTSDgNE+OQMYi7yi/TMJneFh4quVedjKNxnTi4mfBx/t4/0Ww9oLBWKcAvABLDwb4F3d4sOFWCISOOoQpL3qSnkVAmNMiY5GoUH/Ax8+gRyv/EuAGBslqqqrX2vRmaB7ttmLIO4rZ0+kLhE45TnuTrvmLwgKbIUerYYlezzjjk09IAC/UEydEMNZShDGcpQPlAOhRvqsOXE//n3NUBBHCm4ItmL7fOkybprFpYXLUkqJrPwtQQJGzwSpklxObSP+MhxYfj6WdaeVmLwz5GWHDJFdeEm/a78lG+0No/vH6tZymzRMLSChSFK5jFrK1JsHrAaQxi3bjMnR/0ovJI0sL7wGLvllpg/CsDJ5yiV5e46qSSxWymMXqO+9djcluSozCpQPUP3zzLMtz4fGLZK0QDhAm5zEH4r7ovqEz2As4sTI9Sf3kYa4Mxth7m7nEV2HxztQG8yK/AkTUy4k0Bym5MIJ3keGw7yRGZqGEOF26pX0IYDS+7p9z24zIElGqv8mygrtGaoH5Pfos+2n1IGJivtBnEYRtzaKWmDtckjLfRatDDxVavZyX4SPqqNzwZQ7GaLVQZ1sv6RHtw4u004ac5bSMI5R+ppb5ksLXFbjj27ia33iEb405++Ytp5Nk/pxb+5SZHlm1eO4JHHad3//ZmvAgD+6jpxuC+3S7i1Q3shnSBVs9ZKGsviiVkivOoENLbVWh6VewQMEQCH0jZBM/0k+YbqjRR85rTKjNJz0btJloU/04PmPeTtsPsxsBa8lEIWN03jhI/UKj1vnSl2HfsKIQdykyP0bIc3s0bNNZTtwmOW95Fati5MgILbwixbO8llYSUA3LNJoZKlP/aetQ49pgF3e6GxBgT00B7nMYUw7LpeIzBztXeW30HinYtRNjld5+TGaQ64PwgQr4sr0zVj60lJW3bBxRoC0FHo72PXc7s26VB4zjpj2sC+pf8CUsk/CNFjC/rtf/4zH2hiDC2LoQxlKEMZygfKd2XMIsmF5IMkULwp0FO+dptrQCS0CeSUbgiHChCrW4gqALQmHXQmxGdNp3FqR/hXPKO5qIdAT0W7NgGsjI/R36H7lym3DV7b+gwrj9IPUuvegbKkLmu32tPIPaDP8g9INWpNxJBb5GD9uA3UieYUbHLRGb5PtC6A47I1UbKQXEmCEwZLQBuNvs2cNYltF72RwT4CQOEW3zMpAVEGANyLo3WUJ+Qm+b/nnt/Azjc5EJre55++nzQFnTJvpLjNCNUFiwqtRWFgkhIfiAMe01M4y6RmJUJrwTWfImsjlaaJaTfj5u/mDMVOwkSALvejyzVAnI6DFsdp0syB5DF7bvqdNDa+h+lgOBlOLaUQY6ukxvGj9KJlOu0yVYOMzdmOm3iH5sB4vxBCccEi0d7F0tirZwybbZs1/9PZLfzDq58HAGR/l+bbOQs82CP1eP6LP0Xtc+nfzz96E89MUaGqdzYJTttpxcFUSegFtGlurltOi+lz5HRf36a5Khab2NuheZaaXp+ev4s7VYqqrt6gCcxyAl59xibJxhqWNsPUhtmny+ZveyYeEDA9h9DLRKU35Rs2ZZct7U/OEyjg5ffOov8IWTjCixU+20d3hWMyBkhiqWyEb0meu/aoY/qmmBsuCjEt3aZ7CoWI42s0mSW5dJstRk9Z9uOVkNvSJlHPjJkt0cxaF0GCk+U6wv+lzFxlNqhdiat0S9b6lefa7WnsPM7Xp9mir1vm54BjfKUbHFN0gdFLNXxY+a48LIQnxR/vIUyQKyC3QJ+1x+yiSpGSPOPzM+suKqcODnnidUY17dCLZOMFajNKvCcPXTjVQ+YV2ni2uAr9G7udws5TbOYyCqiXt4FN4XLqn28hkeBsyntksvePUR/d9YQJjndLTHq3qk39YQl0JXdgqaFzg67E/kQfdy5RYFPqHMdaFuEjpHRxzoGonrEHj4ypO98F6kzq94CDoEmLYBHTXQ6cXlGbF7dkcze+PIUk37NWGjws0nsOMsSODacn3DzKoDikYFRvVCO96A3cU/pw9JlVLFxnJIPDDc+1UfgaPRXdB/y0PkLrmn07hW6Jr7E7KrPiWnAB50FklxwoX14SdC1a4S/NIIZelR/ulkL1Oa6VvMsumZNVNO/SS1ZcpIJaaU9o8zIqXrPZvYKhFw6k1ha9mOuP9tB/QB15b4dezG+MnTMV+0SSuwq9gFP8mS4+vk79+Vr/ERyZJya8BPNAPXFsBXf3aDLHkzS5nzrOhXqunUU9SW4Ud4UGv9fy8IlHiTvstcuUxv5W6GAsS2+044/Sgt7P0Sb1tuK27neDXXKBpfqWjPbsig28tiYG83hSK55x43aynHcUC6GZWtu7S+v5cp3quMfKLvpcYsBN2YPGnaJxuXxtskCR4O2vz5jviFu3N9XHzCyla+/VGSlXTZh8GadH/5YfF5eTQv4m/bY6LzXBlcktERCLUkQACdgDpDXO/FWwsvZpdmkuOIbZYb+4Has8tZini4gc6e/8VVr3MA7EmBstYHdi7bgozBq7F/P4sPLH7oZSSn1aKVX64G8OZShDGcpQvlPkT8Ky+AaAulLqH2utf/ajNGBMyJg9ddNbrInmmB57TKPNrqnSbfvbzhhbJWxCul1r2gm7aZ6tlL1HbQGa4jsMx0vZ7Ov8ImPBudZv9UIfbkPubwN0TlrAzHTa+y0P2VdInc3VqN+7cwc1CHFz1eYVOnOD2cDRsYiIhaGa9jvi0tAusPcoW1ocMBYNL7PiGGZWyQb37iTMOOunuTb1fc+4qaQ2sQke71k8t+QydMbtGKROuWhZnVENxcHdeE+CyaEJ6kq+jHukhTbjomO32HI5TubM/eVxIMc3GLNa5O6zUkeXXR+XScPvTtu61SK9vDYWlgQR+xkcoHMXDp/mfABwdWCvbOdZVWhtJSPXu1pEOPpwqHJqUw1mnIOy40X+f/beNNiy6zoP+/YZ7jy8eezu1/OI7kajiYETOICiRFGS7UhURYqkRCpFku2UXFFsxY4cpSy5oih2bJVjxalyYkl0JbFpyY4GShQpgiBAEiBmoOfxdb95vPN87jk7P9Zae9/7XkOEQTxQSt1VhXroe889wz77nL2Gb32f9NRICkI13D5eIbGxr9BOhOK7k9PwatIxT9sE+ymc8WIhllYpRTU6Vt21r6/OU/uyc5N83PGLWyiUOS3G22Qna3jhDmGIhakge7iNxS0KrYeylJb71Dmik/2T184CrCEt91Ury+NFvE923FVEzMZAD++XtvDlxFcowimd0ghZpsA5Q2mULDMot4pDiDMsvnuforFm1ofiZ9BN9vcphQkrVZu6RvvvTNnvM0n6rlWJw+foqLmDfdZpKgPFllSwX7Md3BJRZpZCc0+lF0qutzWWMmklyYg0prXtZF+ifUk/CbSzK2UbJoDMffp/kXjuZVkW6VnDDnxI/Uf1WbznkYXW2gFwBsDV9/rYAxvYwAY2sHdm36maxbrW+v96pz+OH6D8arOcABO+YvNhLqT1OE3dI+SBLibIY0itql26B61xbVb35iS5ebLyEne/dJRarpjEhjT0WE58ABh9yTPCKKaC6VgJUvE+3FY/yykAjHyBtmlMKhMhNDjaiBUdJJY4B8lRVeGshstRQ/buDmhmxl6DeK7xouWBkWhJ6hPdNNBM9MOGE9s9nDJc+G2Oa1MnSa3rvu2bE9aLEU8wqlsmz+qcCMvY82xO2u5vABg9sYXyq/1tvZ1S3NRBO3m8pQ3n6caWqkn4efYst/o78iNfG84uqYM0DgWIVfpdf7dttQLiRbkmhkdfAFL3OELMyJzQJoLqNQFYyL2oz9qaiFhmmc6ndNRFd4jrYrPcJCZhWMW3sGuBYSYjlI84fecIhziMAFuHKx+lm9g90TDHLHLEUGvG0eEu9Ijhr708sGGZJs/IOdbNuDtimHDFVtaGoRn8sb1G4cyXdzAhABYKHd9yUT7JOiqFfibY+r4I0RjzhY3QM15cyiP/NEdOaW6oGw3grTETMTd2pmP0u6VsBM3yyMMnCvb4L1LDY3iWxnirRmPgnysh5C769jkeo5qP4tc5vJCAb5+9wQacIoy66w6aPG2lOx0AGqfp/eNs0Kg2H2sh/mp/V79ArpMbWijNMPEq/a56II5EgcZqm0XBWh07d2R6iI5MkNHmGRGhpjBhmZMFOivPMAADzHg7tqeLhVLqSwB+Qmu92vPZeQCfBXD+LX/4rfb7CudAjtoOVym0SsivRzpQrMctKRCvrtHgF58Uft2GQu6ORRjQAehP7SDQ5ULhxx4jdbH/bvoL+KHXfxoAUL5H4XeCxUdq+5WlMWalNTXaBubp4Sme1vZ85BizVriETsyS7wmKAcoKIUkaxW0p061ZPdyvppVdiLB5kb4TCobmpF0oq1zIk5dM40AXYy+6/F0P6uMWPSBBhgvdC9qgzsSMHvZ93YMgob+96RfRPBbkWGZRoTXav6/NpSEoftn5Y5TSCKsxZHZ0wI98jdMvo8pM9tow8xycrUEzSZvoXLc8RjRVXCBNL5XWadaqLscMRl/QMEO32ti8wB3wXNgO+eKmv+yizQX8Rg+3xjAXOEvcrxLFbOFeUjCmh2RcGyK75adom+F92xAXolSiF0qcUybtnsWscdzmFeQlJ0SVmfsWyScImRinfJxLKbRYA9p02rvWaUlO0+RoZ+hYm4vDu9BKftlB5iC9xEv8ZnNcjajW/xoJeJH+xPsuI8k5mD95+n3YafHzNAH1c/Tg7UzXAUByooHVD1A6KXWIcoN63Xabl3jhq3IRPresUD7PKSlZIBIaHXnZl7n/6Q5ThJ9vwL9Gi5y8Q9rDGu3h/ryfalv5AVnkVLUn3ctraO2ATfsKzYyh3gBQO0Ybjr1Avy08xP1VeYUhRhrWp1kxcUwZ8r+pF4TWXb6zi0ZrhlGWix58Xu9arAmvIuwS/BK6nMySRv5OA2/X9joN9SqAN5RSP6zI/i6ApwH8iz0+7sAGNrCBDexdtD2NLLTW/61S6o9AkcT/DGAFwONa69vfzn7F28tdiiG1LjxE9Jl0QZaChCHwEysfs15vyBFDmNVIrfe7NF0mUAtKCZw5ubjr+JHEf+y5Bi3uRA6B4DAt2+KUxS8nUT0mRSn608lHRqxFuqTFMwmyepdgTO1UG7ElofGm7zIrIYonudOTO9STTKtM6Qm6vm5GIKIOanOM9w52uIwAysfpr5DkJQoRqjP90yOMK8M1ldpi722MPaSz1nvK3hOSQWDrYR4zT66J/laORuZeeE1pnFAAp6SCNdFcjYyXJGk36QAOL1bRYhhjVOLxuZVGlyGw+etM3SxkjSFQj2jyZBb4ODlYV5v/bp2PmyhMemNSS3Sc1Y9EGLrcD+WFAmqzEjFxwXJEoTHHtO+cojh1gricPjVxBf/k658EAIxMk7c8lGyhUGft9Rt0jl1OmcQ3XOJBA+AWOB0Z14ZfTCQ0taNQPsYghtsSUXI0u60Mb5rpU4lr0z/SzNAcTt20iSgp6ldeoQvILAGtU/3PSliOITVNA9Hm9KrLvT1zwgAI4OIHyW1+7Ssn8Iff/xsAgDMxikDOPfc3AAB3P/O/m+3/UYEK7n+4fA7L6OetmprbRmOKjlW7J9Twu+d0kz1uv+KaVKfe8cZT95MIRNr4AoWpmS/liO8JNm3aHo3gNPqzAJ1D9Ky3ax5iLKecu2CvefsuRUzyfDpKG5ExMQNAUVbbWzjZbB8UsPwRmhPCMuA2tZF8NdcSARUGo0w8b+UCBPzTGhFeLJ7oCigfTeHt2ntR4D4EIAdgEwQnfmuWt4ENbGADG9hfSNvrmsW/A3AWwHdrrV9WSv1NAM8qpX5Na/2P3ul+xaNLrUeGPbLLS5Dk8d1OD1/UeZadLMQMt5GYk+wi/wPk7lbb5K2Mp8mtvFGaxZV5atq5xtDIpzOnEFtjkfWM5Kdtw5lm9kvVsMJBQ5elJsKQ0ondOEiRPnTbaleuGLAiQ6bW8b4OdKFflrJ6wHq3TS6EJTckJ2q3Ey9MCtixbdd4V0LJLHBiwEI4wwSQ5OJ+5QB79OxoJtcd1E5RpNVmL781GRr4qjQ1Nme5iFvzDYePQIDdpoMwy1w8ZSu8E0xR2JW8JA1PvD2A2FXmw2IPMFEA6kwBK7liS78dGfijdJ5LgbHXYhVtZDLbq9yA1yMb2+LyiBQ6o2wXHjfjJWxNFdmb9FuBsS7ePQgA+Mr32SJx+QbBWWsthYAjIofrNpqjKxfAENdEOjnm7joU7YI9tkciaIaT15+kXHRQ4Rz9iQbwJk0CoYvPPp80Y+RtxviauImzpkytRTr5O8NAnPehuGDu5Ts4MU6d3vlYjysMYNovocVKUffKdJ1Pfteb+I31TwAA/uX+rwMAvvs/ex4AsNqtYdrrjyL+q0NPk7sJ4J/dfQoAMJRoYrPYT4zkPkEhcePqEPxNaUjrh5bThlxv4uKz7rjwCv2vweaEQoshx6lhGqvEy3nDphzy+AkX2tBVD6VzdE+ns+T6L1dyiE/TGLW2aY4GpQRix+lhKhzkqJebP5Wr4S9yjZUhtLl7AaoH6FoyKywNsL+HPp3fdRmuNyaKIZxuPxV7+ZiG2+6PKLUrUGuiKX+7tteRxSaAC1rrlwFAa/2bAJ4A8EN7fNyBDWxgAxvYu2h7XbP4Gw/47KZS6gPfzn6FriKzBIx9nYBWN3+GaB8qH6XSfxg4SNzqz3glNlwLrRWP8UNN873DTub3T70JgBhbwzZHCAI3bTsmbx+lyQvO3GLO/ukIeW7eE4RNb5TgMfBg4kWLOhKUkJUrJfZNAFBMV5C9FEd9R9Oeu5yAxzxXIrIiHq8baGSW2LPgBq/UmkbmPv2/MF9uPmb3KZKo4kE3p7XhqwomyGvKXoshsc0SmicZ4cNIM+fjBWCbm6DmGGnUI9DiM+toGGdk1cEK6m3yDl3OBbsNhZAdRj3FtZ9yDHoH0ribZu/31ayFkvriRSpzThJNCTunmmkBN/tztPVjHbjcXCfIscoBjUSxbzNkTtIHkVaoD3FItm7nl2aPtXLE0lWoA+RFepf7veXX7hzAyCtc67nAkVSrV3CHUVPHaQyCbgyFsxw13rf7KV0g71fkelvTIYYu0X7rH+4//9ZiFtFBeja85d2ZYL/cH2F1sxo4yCElo5sS6y6aB1mut8h1ukChxYJWedD5brcJofSlwmk0unRuj03Qif/xMxfxg08R5e+Rp38SALB/gsb2Q199HD/51DMAgH0xCtFOxtZRCOmeHcjSdo8NzeNUbg0A8EyOaEe2mSF34oqNJoqnpS4VwWN0Xbfd/8pTHcc00rWYeic60jLCXGY8Hq5Br7Ao0VX6Gx5v9e0HAG48S2FQmADATMXKIC8djH6FfitoJons3HZPfYSbFVVPYFQ6Sl+Ov8bR+5CHytDuqFgyFJJl0F6EGguVpVYFxi7IShjG5bdj7/pioZT6ca31v+b//6k/Z9N/9e0ea+PTbaw/QVhOt9n/3fifxbHxAX7phraHoHKu07dd/FoGlRUmYuOw/h8/8d0AAC/Vhc+qawErfrllFzGGD8aepcllhF0e0GXrBECHb6oowqW+aIuE0r0qGPzU6u5gr3YwNKpwkjpqTYQYvtK/bS9muraPw1uecKVT2hR15QU7fIlfjoctJbTm4ldm3jM8NmKqC2x+iunEuUu8w1xcvdFsdpzGpz6fN5NxZ7dp9OIQ+NIt3NndnTbQyRD51+iFI4U66WoF+hXyAKB0NjCpr8SOYqJaSBr4Y2qBvouVYmiPMijiIs2NTwef8gwAACAASURBVJ27jK+eoAJrq04DHlyjYmXqZAnRJr1sFetV57ItTByia55fs30iiTgdq36Utsu+QftKX49D0gSxTWEXhNETlw7nzCh5NoWNUXRHmFQy8M2YSerLmBeZHobkGzSno4fowdh3cBP3lxlKysXyymGN/FF6AZcWGQa+Ym+UvFhFn7s9ppC6y9DNWdsxX27TeCyVaXVuXqd9XfzwDbPNV/7No3Qe1wJ8Lv0YjeVEf9OTO91AMaCX6W89/VEan5KDD3zPm33b/c7tJ1Bn2HCMqd7HjlJheXs8DY8dgoDBHdrTCIp8z4RNgeHIftnBEDM8bJ+jv8lrCZP2VUK3X43tSsNoXuBLFzpI3WEYc9LORwPqWOV+kg7QHO1/OYuT050IDHihM0n3OrzioPgka9FfpwW7NsuO6acraC5l+Th0ZlsfCJG+tZvwNGDnqvA+fh8yKZd7P75r2z/P9iKy+BEA/5r//8ffYhuNd2GxGNjABjawgb039pdS/Gjut35dA4ATD5G4Ipq39J3AJP2aRn12d4jVyZG3IfDO5rg2noXh2OHmvO7xBroV7gadIYhjcT0Hh3mLZB8SWUSu9cyT6xb+JlBfKSIDQIY0ano4mazfItA8YTwNshojHF6LxOjYmw1UDtG1i0yiMNNqR5kUhRSKtWPp2aeeoNTd8muUuosfqyBg7esOcyxlb3umMNs6Qp7xkf0buLtKnrNEFj/82EsAgM+98Bhy0+QJVzY4Uqu7cKfIMwua/V5wcj5mPC+JyJwAaJ4kT0rgo7Gq7QgXkzC9tl8jHOO0SE/j2txpur56h+6dQD+jGAx3kpiKiFMJsJFlkI8w93k6qfWLnD7jLv/0imUb9Ydst1PAzV7pe9wZvj80+tY7I6ZuRpsUoqQpuwdbSL3R3/kcPErj2WnEgDIXOucsaVV1TfJrFvzgb3NRfba/EyudbWFumKKIZY4ASls2PeZUOBU3S96+74doX2dYanl3JJfmKLU5CQw/tg4AqLf784X1asJoqQu0dPr5Lu5/H6dZAmkcZMmBGBByNCBQ11jJMQ1y0vzqPVpEmgWcqk0WIEvRPCs3kmi3+J5t2nSby13Ocv9lzrktO3xpLiKvfSSCl+vPQOjlJNQsHWN0iKLI9XUu9jeszy333GvYCF5YspPrCqHAuPn4cuxuAgbgILxXiaWYgXDLu8DAad9XRsj06WM52mhtO49Umpv3luh51vEIigvc3mg/ACEox02kde/H/t63zEftOd2HUmoIwKcBzID6LD6vtS7t9XEHNrCBDWxg757tNXT24wD+PYAbAO4DOADgN5VSP6i1/vI73W+M6wjJ9ZhZqVMbO8RBRpTJzYpX4bRts5J49NpRkPyx5MTDBBcYKzGj0QCmvZ/aV8DGdaok12cs/xNgi+AA0GRqhcSmg9w9+v/CKa6dHGka7YJulaUZOSpI33fRYSipRCL5mw7qzAYrsoqbj6RNoSqKW94dgHidjPU4tdFb3O3GUgaKG4zAnmDzoqVBEHNVBDDPjeJh+YPbZ833DrtJJ46SrkEQuYaR1N/B9tke8QxDq8hZdtPa8Aw1D7DAzLZnKEZMwY+j4eTRMvAN2n/9INdcYhFWXqSbJbWQLkvSZm/48BpcwOeGpjChMfEKNzAmpWnJNjWKB5goWLih8R4XqKjTmOsaWVd1h7x9r0fyV2hbEtt8zJoyIANpzoy2k+b+MMkusl8gd7Jy2HqdtUXyGJ3RtvF+fS64doYiJE+RHxawXGqbI7qpXBV3vkLF18yjTK8cKQNCOHiW7lm1Tfe39o1xRBxFSM47ituot8m0OQCwsUXn5HONZnqYwvzqRk9hn+9d+aCPnURa7R7GYCPly3K8beVbKhy22lIO9TxHzlysX9vHXFEpGxHEpm1NpCPRhtSzbjOdS0/afusCO9euRsiQVm+Zt8tG5ty2L9Hzr1K2+VNEm8pHJEq1jroIhnlt24jamOS5xu+vMKWR5HpltE0f5u5Fhg5ILLvILNXDOWROUKS4tm1x8dVVmn8JroVl7ztGY0cvpPjcaFsnpeFU3n7dYq8ji38O4Ge01p+TD5RSnwHwmwBOvtOdplbpRqRXQ4MZNvvnm5FejkxPQMh461ZPcclvsnb3vEb5MIua7OhsHrrsoc33objGD0SujYhpsSPJAkhPRUwDMZHioj+xwzVsPcREhi/xQx2mDAlYlhEKLS4U5+5H2BjvP4/yqdCkt+SNqZIhnPX+Gz12iS5++aPKoI9MtybsJNl4ll6mcqqNvEY6zWkL/hsErkm9yAv8zosHENuBnmilpXtdIcFkbjevEjGW01am81hxp2qU4YWt4pgwXfTFU/c9aIfuhdCoe02NIi+yXVbbk/4ZwL5YY+MibhOhnWZ0TpY+K6zSTWyNanTP0/VpRq/M/OnugqDX1KhP0nk0Z4ToipFnK45RsPNYRCgVOmjdp8nQm2xLbPFiONSf5kotRAhSO8ZxRMPnvoah27x4JXq24dvocZ+IKiVN97XueZ8k+R4YviWmUbsdTJpu2OqrTMo1E8DhxaL0uVn6y/xlcfR0Ks8wuq3pmnnt8UGD8a4pMgfLtHgucGE8PtRCu8QqjvxstUaBqWc5BTwmlN88zzwgyT0xvWnZLCPAJC3qNB3oHaSSkhatV32DQvJW6Qf6tGUXNVn3h2lB870QHnecB9csWVk2R4t/a1G45IHkZRbOYjRmcsVqZcu7pVdETJwVue/FU8qk14ZucXc8KyvGSsqk+AQUokKLdDQCXZn+eQMAit8J3UoMftHtOw/AzhlxaqV/JpjtIH7t7S8We91nMQPg93Z89h8ATD1g24ENbGADG9hfUNvryOKzAP4mgH/W89lf58/fFXM73F2asfKUO028dhXaFboxTtt3ezw80eIVmGfkK9MBrZm5tJ0IDXxQPIbocSo6em6E1hVKiwT7d1A9AmBUIM48dROv3DgIAEit9hd+N95n02dSkB57Q2Plqf59xeYTBlOdWZQIiv49dM1eU2tccmQWg107sGOQ4iGCNzlddI7SGJ4XAafI+3Je50LnI0UEL5PHKvDOzjCL29QUSs9zbmK0Z/8cuk++SP8sHWUock4DO7qng6xGwBTihQ/T4BJz5w4QBnuFjXs5TLCHVnyo55DcG1Nao/zWMMNDi2F+V3P86vcFGHqevKvSKY4AxlsY+VMWXCrT+HW4i7xxwIXPGuM4a0tvwltVO0lpkPiy/5Zpv43HgCjB4liBFF6t3yaMwXHuFwmykdHqRs92kqYUvqPEpmOKrv39zUDifsx0NHfGdvOpCxhEzqt1LEAiw1TvZVsolghB5qbb9hGc6E8xigxrbFNhkpmL/RqlOZef7Onx4Nsq+0psW1Zj6ZWJfAIyAMDIFYZOTykoTocKC/PIfrrHG5tWJjR1kZ7L0q0Rc39GzxFbgxTjI61QWOMwhdkD/GwbVS4Q90WK2/J+kD4efk7rdlaJRx8mbF+DcD4pDSSp2R0bj0uUTP8OEpYTTora2gHS6/1jG6RZiqHhYNuhZzYc3n0/DaRcK9NbFuT7nyN/OfaWc/RBtteLxSMA/rpS6hcBLAOYBTAB4JtKqWdlI631k3t8HgMb2MAGNrBvw/Z6sfiX/N+7atWD5GF4DccUKkX0PVbjwqQGtlnWUPiIEmv2crtpzoMntamBmALjKDfFxD34O7ik4rcTaE6TB3L6LOFfK9yUVG5ar0l4XtTzcThcHBduGTqIcBTRP8MEF0NbCvkb/ccsH3Yx8ip7hTk61+SmNhFQRbq0V23xNjxNefVEgq7Fd0NUqlzgWqHzlJyqW/CRYrbM4ip5VCMzZbSD/qineXUIMXZiTBQ2wgXFms19jr1G51g+CiiDpuz3aqKZFipZLu5zHrebtePj+TTG5Qs2QnMYPtpeYM9eWanYTpWOn70SA44zWyuLZLU6zNu05iGxKXKWtItqj1csXmq3EoP7n5ILGGNG4WDF+ureaS7gVpiXquvA525nn4tR0bEAbYbTjrPXWy9TYXT/6TUsrHB+XKZMPYb6AW6aytDfRpo5yNoOPNbhCKR01XEMJFckTtsj2kjq1g4zu8Ad1ik50zHAEDdL+3IWkqZzu7mPts9dp99XHw6B12kuxGPC3aUMDLTXMs9zbYCfn/w8nf/a4y5wq39bFQJrH2PxozUBbai+7wGYgrHbAvRm/z6c0Da/eayU0/oT0jodbmvzTEkTvnKsx1+u0z1LJWheNVpxJO8zqGM/j3E5Dnj9UVh8zbd6N2wiiBXGeqI70W0ZttckOhWFc/bcdjI/J9cV8nfpWAt/hfex4qPL52ZguHmORBsauTv0/6WHuHaSDBHyNSSuWhi2AEOEkUHAFdWd4ee3sD1ZLJRSPw3gj7XWv7MX+x/YwAY2sIG9t7ZXkcWjAP57pVQRwOcB/DGAb+h3uQOwOaEw8Sp5tqXDtAJX9zPK5ROLmOXtlgqU24tfz9p8vaDkWgpV9l6VaLRyzjt/Q6G+X5vtAKA1vgPHB2D5GuXqh64phKyUJvw+gDaorCrnmG/8wXGMFhmOaO4Ae6QxhQ5zZ4iewPBVhfq05bkBgPQaEHLudOIV8iYiVm5rjntosbTkKMuNdrou1D1uYDzBOf8NQq8cP7eEtR1uhtYK3cvkWYo+BAUHnCN+hDzvBud+m0dDdNZp/1tHGNK5GEfuFEUsq8OUF04Ok7ef87toJ/rzsfuHS1gq0XbCZHq/PIzCOnP2sMet+P44Qx0ERW6aHOfE7EcBv8HRAGtduB7ds85IhNw833hmLm7Muig+yp42o3qSN5PYzlP04t6gMVJHLZ+M7FdzdBhb8dFhZE98Q9AoCpohp8Fliii6H6aDrrwyDZejQi38QQGQXGEKFdZSCHPcIDlXRu0ujcvMaRqX9UuTiCaZPoabITuBh/fvI+jQKyukpRlyDeDUSBFjHG3eKtH5rLVdgPX5tMf1gBlmKI2UoUGRoDDIaEQ5ugdhii4gueyizUFSjPsFVz7IEO4theWP8LVwlDT6qkaTvetgRDIEzMDqWxW3XmuOC1cSz73LETpZRmOl5dzA+7IRc6+iosB/5d4V1zkaSobIyq1lxFvupmd0QAKWeW3PdtDm72MbtA95rrs9vZSNSfqsPRHC54iv/ATLq27ullOWsa0/0UCQEag6syxv2veD1EclwmhMKYMO1Ayd9xJdhMyE2zzFrLo9KoZOTqBadMJuC2juf4Ae8FvYniwWWuufBQCl1FkA3wvg1wCcUEp9GbRwfEFrvfVO9x8xpDNW1oai/Of+1u8DAH7t2U8DAO5cmcHcKSIbE8x0+aEAqXnmVmFhml4CN+mgFart8kltYGZi6UXXFIrvbBFuPZq28qOpFZ5AIscZV1bXelNw/Fba1OEC8NTzdEztKGyfYejnDfqucC5CfLMf4rnxXR2MPU0PQ/E4bz9vb7xiuOvmVXoxzJ1fQeIR6rQt1fs7hSeTVdxcoQVPcYEz5oUQwUUz3uMNnHs/Cfg8f4O4kz586qbZz8v+ATqPNA2QHlc4nKfF4vktWoyanC4KNrPQszShQz7X+e4IuvwQgxeLSjWF5BBtN5alhW9xnq4pKsaQXKbf1sZov8lEgP1jVHj+KabAnm/T9pdnZxBd5DCekRD/68wX8Vicxu+VNt2DH1n8W3Zw+H15/gBd97X1KXSW6A2V4o7iblojwS/67OOUMwm6Ljq3hDGL5wRDOb3IwhfDByAXIxGYYq3vipPG/jN079YKtoB7ZJaO5fAbZ+0PDuDrj9J9OThF4760TeewXsvg9jp1sg9l+ym2AQDcI2Q6nEPfvIykT8SvKXgswiVw105emw5v4TdLL/M894GRS/L80H2qzyhMPEdjVWbSxb4Fgl+eCXammiOOkYoN0rtho7EKMyCwM1X5RANY7O8PUiEMS0PAKdjSGZvylFSkCBM1xy2Jps+cT0r3SKfO9ZM/RjFtnElZYGMFB6Xz9IOD03Qv1m7Pmpd+c4rh0T3a6MJHlVjm9GyoTbo8Vt6Rxo1pRMzZlbvM9PK5GMIjNJjeCk2s3B3LeFA/yA7vAU4dhwpjM2W8XdtT6KzW+pLW+te5gH0cwP8L4LsAvKmUekEp9d17efyBDWxgAxvYu2N7TvchprUuA/gc/wel1KPvdF/TR8mj8o8/ACcrYjvxCItvMvfRQQrTA8TQZOZXf5U7PtcUUqu0Cos8pYin+GVlOiyFXrx2MER6kTt42UFLMN15a1QbGVNhmvQa2hTrts+Kl6CgpXbMWa2NiwzH7aekAQCMveKYMLs1zaH7mnVJRS618hD9vXD8Fl6/R2kIcOh7/40ZhEMs7J4n72PuCHnvz1w7DodFcxQXTQuVFAJJubFDF97L4IV10l9V3Jj43FXWYw0VnCR9Nj5OQeOlW/uwvkhVQcVemOmI3lJoscSpy15tVPQBLqa+dotCr+xoHdUCefKr3B0tEEfARoiKabQ7WxksnuTB3d8/jpFWeOnSET4B2scPjE3gsXg/H3nsZAWd6+TBf+B7ifG02LHRmPAnNZL02cEj66Z7XTqgAQvBLp9imGzHphLdZn+k2BkPAb4Hkg7Dsj1mi0VtRjituNFxDU/X0WlbAVbcqLnkU0QR3aOxK2QT8Efovm+u0HeHfldj7TE+J+FFY0Ent61M4VmKyUHOFnUlBeM1tWkw9Rr9XGmZBYUaU2XnudFw5HpkhaqYL8pIHSeUSem0GcjhdDVCv5+9oHhSmXmU4gK3QNyDZtqkpqpM/z1yLULEKVsR8srMc6SzXxl4tKQE6Vr73y0qUuY6xVoT3GBacNHgdI5fcs32YveWmIl4NoDsJMkyvc4yRUHdlH02Opz27eSA9DJtv/U4z3NuJtWe3lUkTxQAv87gFfNmt9eUnaX0c/sNeibdFrAVvn31o70qcP+E/L/W+oE9FVrrl/bi2AMb2MAGNrB33/YqsvgY/9V4Fxvwdlr1d6eN/OX/kforAIBh9kyKF7omyhAqhtGrCjVKq5tGoLCnR0i45aNxZjIN4njyk+RZPvenRHbvNh3UjlIuUkSPhK4iM+/Br1kKADHJUwqETbs90qY7dGj6ILHsBGfv2e8tU6cynC9+haMpbhy7vDyDJ47MAwBWppjqouth6yp5ON1NGo+h95NHulTwDdOlWxSYqUI0E/WNRzceQnHBTLHMbHqOi+X1OKJWv7cMAKkxCslScS4UMmdRuDG8a1v3QB2TeS4Cz4/t+l5yxgkuMIYxbXi/2j3AA+cmuZa/cuuHaTvOvSc2HOAge2h8HX/vK5/Br97vh9NqV5sE7dOXTgEAkiyveWxiE1eXKGJN8e9wBNj4IlGcNMfpWJNn1+EdIwGf7ft0rck5inCzyRZq+7j4ukARTGzTRYfHG9v03ff8IIkEPbNyFMMJOv7NW4TDVskuHOZFWrxGkzrehRG4au7rH7v0fQ8BR2hjTKVSPP6gGgAXjjORkbh16va+1jj6Hr5G/64eUkiz0JYALMSCLGxxPCUQ9zaakxTtSgQg3v7ItQDbpzlfL6w5PuCE/fn6oZtA4Yx8zxGR4DNUD6MrP/9rT4aGBkPqL718U50R+kdinbbpprRhlJZieWNam3dGZ4rri8xILZFAr7ktgtsCVga6ca6JqN4PR5eCtdu20YBwzMW3XNTOUTTor/YXt7qpCDnRruBhr3+wjsTLNKhBluG355uIXaboxXd2n6fTfPuViL+UFOUP/e1/qgHqUhy9xMI1rCTl8CSoHe5ajpiiXRMNNXFbujAjRNwd63J3rDwkc4c2cSxPL9SvPs3KKNpiqqUjVgpNmXkPtVOMrOKXUWLNNeckHZ+qawvbstAItTVgQ+pY1RLclUgQzL7QplqmX0JeojFeNGrHAiNwkrpC22SWImw9At6eUw+M9Bh+xUfxLG0/Pkcpmc37w0aMZ/QNfiEPKbQY+SIPm3eBismNehw+N2GEvCAkU200b1CYO3SGinyyWIykmjg3sgwAWGvRC/OVl45h6hSlxlZWhSfeQXyFRWH4oY5N0gIU3c7YFJmIzoy2zWfxHWir1noaPtNhT7zMC221i266f5ELYwpuh/a38iSjnLbsQyU9CekZRmA9P2TSh72Lv/RNTB6kRePUCBWpn7tzFM6OBzf5YtoUjcWcjn35tlkTOsnsAd2UXdDE8QCABp/b6Kvcx7OPv1M2xSQWKzkmxSTPhZAqrr1f2ePzn9GHN7B+lxZxj1Na7o004qw7LiqKwneU3NCmD0p6gNojCmOX6L4IoimMcWpmO0TxGDsh64zOGnNMKlhe3Kl1jZE3aN5tPEHzS47jV2HQhJJWyixYJUpRsJSiunYskaU4i2EMCIe5X4FVCNsjEbJMD18p0stXqMnHXnIMUEH6IGqHuoizUyOLRZiwz02D54aksJ3AjpFcb+5+12jdCwuFLC7dlEZ6pX9xrh6KbDc338/sWB3hi/QsNVngLDHDCo5eaIgH7//s39ntOeywveaGGtjABjawgf3/wN6zAve7aQGjB9uTXawz3jvGND11Fs9RVR8pXkFTs+SVFcppuLcpT+VwY3DutoPyqQdHV2vPz6B1k4DqB5bpBwuftOGgsJ/6HLpXTnThMpWrJ97vJBB7jlZvKcY1pq0ISnqeI5Atyz4r9OUu9xOECW08kjhTZTeyvlnph6/TbwWKGNvwEGR3+wEmzJ2gMUpflgKqvf7tWxQ6OKNtjDEwYD1Jrlf+up0uktqZTNN1ek6EbsSeotBjt33Emf/p8UnC/3/hFqV1Oh0P59ij+8Qo5TSuzk1hZZk+9NfJjezTCM5zKouZTFMnKmhsM0wylP4JH1MHuRudO9bb3HOSWnaNfndtmjl28o6JIvwGRxu1CFX26EYu0W47POfqsxoua3Xrb7IL61i979w8F7r3K4A11IXCe32Brs2tuvALAnag37VHbGq08xCNabhE9yfytIkoBJqZWnUsAywDLdyORjdF51Y4K/fU3luJgEfeoGuvHLJpPLHtsxz5XdKGR63GQIHt1ybgsHcfNTi10bZ9BsIUazjI9ltgSLzaH8EAQH2KI1COSOqTnhG6WnuCtsndtttLgbs9pHD7R2nshZ1YrDGjTUQhz2XpZGQKxY0Zy/AAAEceXsLNG5Tay95h4aopbWDF0iWf3Fc1EYX0YUlPTXsIaI33j7ebCyDcAw6DE7ppbVLGYpIV8Jo2ehA4MADEK8JHBR4r+nc3rrD5CZZcvcOSsV1loOyXP0t5OvfTIbbmGBq8xVHKMqFleoW03o4NIouBDWxgAxvYt7S/lDWLn3vlxzUAfOH584hPk+sS+xp575IzbuwPjVcwLJ7UEevZSJ43VrFeoTTFCF+O2wFSa/0iOE4IVPexjCmnB3s9Aek2lfxzNNE2kpjCgeR0FTL3uG7AhTnh3Bm6ZptopIvUbSmjZyHwPX20ge4G89ywaIrkTaOYbSpqcxe421DGq1Yj5PPEOMpqzQSGC2d8iryN7aIVrolYoCk1UUejQgN84QjxYm017XZTaWapZbfNUxHeWCevrV4VMiba19D+EmLcWb1don14fohWSboZuRDZUdApzrXm6bxbRdrGK3oIU/15eJ3pwlsnL1zqGCKCo29kjHsk0MjUkmsKrNJIGeQ00lROQeEiQyIL3LW7poCPUl1Hzr/5tTEjdpU6SGMwmm5ghUVpugGDHpi3SXUc26DJnnpuXqM+I7w/fB48N9wWFUcBIPNq0vzOZQ++cpRrZguOEccpnHT6rjN5pIIG83eJLkPk2fmRXOMomfPrnayVsw1YQ8HpANklZgU+yeI6i9rMO5EllnkW5HRfrQcARq6HRv537Qnu9N5kr3/aPkejhCtB+ZiNnOUZbEw4JkqWZ696kP7tBApBVoAflok6N0+fbX6K9UwKNEeOnVk2kYXieaabrqnTGKGrUxXbuc8PYZcjjP0zBaywyJc0mKLrwN3BKxdmQ8SZZVpqXKNX6ZiVg66JXiXajJVtzUeuUyKL8mHHyAGHByjCiCo+PnzhOgDgtTVGOHxjyLDYNmblvrAYUio0z9n9n/7Fb1mzeE/TUEqp/wDgJ79dWdUvPvswAGDs5DaqDXrC5YUv4ZpfckxXZW8oLouEiNo0pxTSS/03VQqYqqNMGsUUmHqG1GvSfiuH+DtPQzFyY//DpDy2vDWEwOOXhBDm5bvwmvRZifWcnYacgz2Az7QceCVvJqjQl/fZYzS7whs021QENI/SQyHke9HBJnSZu1G36OmWAr3qOABPXhlP1wuRz3ARk2kZzo6u4msLlCO7V6KUytER6qmItMJGg95uC6v0nbMVQ/Jwpe9UT55eBADcfHkOY2f6GeKcV7PA4f6iNBSgOLUnndNIWyiLFgLGMqcj1+Jw+Vqkb0YsuaHgdCWsp+0FkdNrQU6jxcX9xEq/BjcAI5YT8UfjTy0j5BRcsWF7I0SZLMbzUPTND3wxxMaF/jm39UhkFkVI6uPu7vbuyjkLoHDau5/vte8X6hraRzpF/65VE7u2DXIaQ0eoOl1tUvpRXlh+VRn6fnkxR54VZMos96S35HsR++HzcpuWskaEmjYvOIgO0SrnzDPtBOdrEtsKPk8XGW+3qVCgzCXyd+hvewTY92Xax+oH+lOpbtsWuGUetM42sTHBc5+3nj5Oc+/+9jB8njsOk0y2JywTgoAq3NfycPmWJS7SmJXaNHm2np3GEINSCg/x/Mp0EfKpJZd5gIoOWpP9dEHVKh27kwMS/DgonliNKXt/q0QWYcSpVBjtUhBUgYOXP09c/fJsew/IHUlfSdhRpvfq7dhe9Vn8ylt89RSIM6qutf7lvTj2wAY2sIEN7N23vYos/j6AFwBcB/r0ZjyQpkXzQT96uyZcRds3R016Jr5jBXW6yoTzEsp5DRsim9U1qdG+SLH3xO+SK1A+JN2dIbzP0HJfu0+eV2zTNdC2FrcCCA48mAgwPrm7aKS4WBZxykQKTb0W4/MpH9dGojj+HIVLlRN29Y8V4bOfvwAAIABJREFU2CMux5ERDh4Wb+nO9oLHuUDHWsbTIxVsOJTuSX6T/tYfpQHSbRdTUxTsbTL3kDufwNYoeaMHjxLk878Yf85EFo0WDcLLrx6lMQiU6cfotdpWv+t++wUmxXrAzOsMawy/Kvw8u/snDH31Nm0TjHYNLLq3+1ZSQvECU7dfkVSZ7WERLe5uQhmMfv4u/a4XHJC4QF5k4xLBD7tJoPsNuvEiJpO7uGL4qkQXe/lGHiHj8d37FCEMH6D0VeVnFaLXGIN8ikAEuhY3BWvDQsCn0ZzQiBimGRti2duahzDTn4JrP9ZAxMV81+33GHU5Bs0R2k5Suj7jp9VtW/lQ8fJ75WxL3LifWcAuaWOxbi4yqeDMIXouimu5XbdezsOvWW3vfc/QdTbHEgbkUKf2FrQmu1h6ip5VIQj0D9IzHF7Oml6K5gRd71CujgJH2LpCf1eZTNFpKcOLFQzZuTY0TSFOeWGHfiuAIOQCN8Nq/cauTZC6EzMJjUjSw542nyXXmDr+EPcyJSO4LZ7Xko4qAo19nN5cllSzhXlL2jzivpx4wTFprc2HafvMUoT1j/RLA0vPyX+s7WVT3m8A2ADwK1rrBgAopb4HwM9rrTf26LgDG9jABjawPbC9Yp39KnM//TcAXlVK/X2t9e++W/sXBtZOPkL+GtOJ32Oabm7wqU+6fTk/AEhs245P8WZqoyHmmKX0F/6nzwEAfv6FHwEA+PdsnvfCaeqIni+OosKiN9Jpa2CbALoh7XiBJT11IW7ytYGkoI/WsZ2lfWRvCqyOvupM25x99iIXjG+PmDywyeXmOqid6KeQFrif03YQY3hsp0Hez9rliR7adD5trpt88NRtbLXoBNY44dvreyy/QgXAn63+OFrMGos2Fw97thPBoqBkayKK6aclH59e4vx9Dqg9S4I1EUcCfg/7qORc/ZKDjs8d1pxfDXsKRxJtdLlo567bWpWMleR7o5g2Hc4C9+ymYcavMcHj17GylK15lpvloQ6TlolYTmPzz2bhMGdXKNXebATFtN+dg3RhKf5Bsx1DW+4zF/Qn9xVRqrG3zIVUKdBHicgM9Jlpwl9fwTT0PN2zcB/tvxu4BhMaciRSW2dYJYD89f7u4cyiQo27LDVHy71CRIZNdtjCTUVoK7EtW2njHYcZvhkxab9W/cy2INhwV3iTRsSTpzkiImQAcPevMXS6prH/zyhCu/9pe/4eF+Il6tDbDHCJYRfGs7CaN59J460KpX4Y4vwpgnXf3KRoo7WaNhHFkdNUe5x+Xxl3yhRRrt6geSuE452sbcZTDBhqTURmrnV6S08c6UecIUitcPPkERslyrNenwtNV7m8r6RhV0VAm5smpakx8oHSEYY+swRte0hh+sv02erHOLLk38WLCu79B9Cmv4XtGXRWa93VWv86gO8G8GNMT578Fj8b2MAGNrCB/QW0PUdDaa3vA/irSqnvB/BxAPVvd58tRiuMv+giFBH6HK2erSGJHJSBAebuMbopAmoztJ3A9Lzq7vyd4vz38COb+NgU6UI+kaHuoP+h+AN48hj9//PxgwCAdo+kaJGFepwEJ4YdbcVR2NPEzTSGF+UX3CTG3lls1UeHOZ62tznXPtxBl6MAMI2HC+Di8XsAgFeucBcfu7+pqRrqlX70S5TUaKbpnPLctNYo7tZV9Pm81fEO3ICO+deeeBEA8Pn5Mxgeoxx7+e5w7+kjHOrCvctNS+wxOiMdZDNUnqqytoPAPKMeRJOIyfgVZdBkyXULp/SlTsNytor5t2JFx9BgCGtuZ8g23sm55e6wh5dT6H6Ucuf1NfLK3aEO/OsshCNsqAVtokERvwoOk/eevJxEnbnBhC8qfieL9ihtn74rDKaAdlkfhSVOa4IS6wDD3KCJT1FNZGMjD8W8XJF4n+P0VzVcZMbpsfnYKDVdvXZzDv/l9z5Nv2WM7c3KBG68QTxRUay/nuFONVFKcG6bxzu9og2CScaqOUfj6W35hj4mc5efrTFbFxLPvHZAwx2nsUlwZNmqkbcay3TQ2aZ52H2GIph8XaOT56jnEM01oeAoPdQ1fFuZe7uPOfYq/S2edk3DoDzjusdBTi9KAx79u5OFDQ3RD3tPLnm4PU8kbE0+H6/hIJqha1r+CnUkbrwvg2aTD8LRm8COvXwHWGBhsdme19s9ui/SMFw5F2DsmTiPG33mcjQ99KZnoNKtQ/2UQYCNKIRqqDmuzDWI5ea1qfUVT9B1Dt+IEMbps+HX+blhGqHScccc/+3YX8o+i+P/8J9ogCasYJJNHwR342pHIbVFH7aGBXaqLDcLLxbBcGQeFKEtFks9tYH1+/SAnzpJ4jdjiRqubVNXd7HcX7wNK77pVzBUwrEIiaV++KV2gS7zMmWuMRkZpz26KQ2MMxacRZugNDQvFkIkqIY7SFyhCSo03bIYxdZ8hIeYhnySFoaNaga1NVp8pMO5/QcUTjcnlOkkjS4w2V3KzqKt21yMdTScFqvDCVX1pk31mL4GTne19ndw9hiN282vUi6ozUJRKh4ikaIXU3CbnhIFwD9GqbeIoait7aRZLIzi4CMM6fUidJmYTejRo6pvHABJZaUXaF/VY12kJ1k5sMMLUCOG3Ah9VmGd7aGrnumwl4ezfYG2ca+l0T5M9yeRob/JL2YNzLQ1ah9qSZG0mJPH487vxKYyYjayQBU/2Iba5oPy/RdiRtVyDZAjPUHnUS8kjShUeIPOO/KAiKHVmXui8c6Yel+b+S3PSm1/ZNIgAvMU2u2Zr1rHSiDI2tGGVyzczywArybNsyRQVXF2EDjI3OaF4Qg7Klc9Ay6o77cQWwBmAQCAzhyNQfxuHK0ZJrlk7XD0kOqZDn9O8QX5yKQHJaXWmejCLfGNVOKM2N4kmfvSV9KcsIJl8fMESqgu5uCN0TWPDtEKVarRCY9m6zicJwj5NxcO0nl5Ifxn8nydPYssj33mHv0Vre4grxFjmL7MidZ4BD1Kgypd2ukVPscxq5QnYxArW9iwOf8ikFllZ4XvZ6LAvFsTjoH/v/6bv/Cd4YZSSr2hlPolpdTcXux/YAMb2MAG9t7aXqWhTgL4BIB/oJR6FsBvAfg9QUV9uyarptuDFBVtbYcb37J3d0dM1ceauHiQOo+vrFN0EKxldm0XZ0nH7u+NI8NdqfOrBwEAqwUKvelYfD4Syo8ESM4z/bLA2nIdAP2FRbepoLkjWESNxKsQbwEA/GXal1dTZn+9TXmNQ+QSpe9y5CL19lM1jLB0pojx1NYy8FgTeP02FepcXspVZLtwM3HyZLaLGcRucoc4N021R7XlpuKmxiR3Int1he4Md4YLMEDHcClg+mw5ackQ1T20pLM9Lg1V1rlJ8nm0Oyl0Z2m/1VnsssQiM9IOM9dTU/XRw/dabMtFM8PNWWt8jqPBru1KF9s4MUeSvFWuTm72pOx0t98Jm/ux27i8QrhOdctGm8JimlgVXW76PMjaLl2x9KWEgfyqJTo3pszC1qM2pSRd2InFmMGf95UoedM2ZwnFk03P7x6U4WvKbCfpiPEXxX/sKbhKxDASQQ1x2m/Jlh9lTgh7QoqlSMM4UDvNP2ZAROViG8mbdA0CbZdxCRM9XElrtI/JlwI0xxlOPSYwaSDPqeUmP5/CmgwA08cI7m7uWcNHyNrhLkedsScpEiiV08hw82lhjTnc7nvmzZjiediZaiCVoHm4tkyDJowCvdZpcCpxM43uhG0sBID2VGBg9JUnuWmWI53RoRrK9X6Ag7OYFG00k5VojgkLBHqajq0FGc5saPm3wtrjDKPl1LdIUUORPvnbtb0qcLe11h8DcBTAMwB+GcCaUuq3lVIf2aNjDmxgAxvYwPbI9qRmoZSqaK1zOz77EICfAPAZACWt9aF3uv/D/8//qAEgrPoGpueypy6RRTAeIJFjLiEuuH3i9HWUA3J/Xn6Nm8k6yvDXmLw9BwJhAhhlCFonLbw3Cm3u04kxNYGwZq49GRm5RIkEnA6JpgNA6QSPhbZepyRYJ1/k+sqIg07Weg8AwTzFW04v25x4nUXq2zsoBHQ8NF5Pd55Cl9wdmEKXzekKV4xClYuwIgerQtINACxXVWNGI3+Lx4b3JfnsWEmZZkJz3qkekXsuCjsMpY0SkaE/EbEX1VE4eZbcn9trBGPsbiYM2yxKdB+z8zYfH7Fok1OmcXdbNrKQhrDcMc47Xx9BNE1epGiBhMkIDz9M1KVCYVK+PYxjD9N53LhO4Uz+Gu2/etgec2amYMZ87TrVfxL7qebTWrTNYdjhvLkthS57il3WH8hd81HfJw1aUs/gOsW8ZzxGkeN1m8pooYy+IuzECvUP1XjcmF25I7BKjbiBa7KXOqkM1YZEfG2uuaSXFOqz/dFslIjgcWSh7tH+u2lt3FgpegvvVRi3zZICGGgc6CJ7iyMEvk9ybcPXNGqz/QVoaCDBkX5qgz5ce9w3EZNE4uJlt+Y6cBmkERVsbSM2QWGMw+dzcmLdfLdY6RfiCj8/ipBpTeQZKX20hXyO6kUFBrFIk5tX8tAd4TnK98zbjJlnpfRRmnM/fPoV/NvLF2mseDvRNQmaPhLzdL5diQ4iC/SQ50gaSJ3AcodFx+m8/DfTJmJtTtmoRsYod4FqlVuLVNjwyq6p61z/lf/6O8YNtevAWuuvAfiaUurnAfzVd+UgbQcO46Y/8MGrAIAXFym3MpurY/Nlagc9/n568BfrQ7i7wZ3YXITNXdxC86v0Yqod5RcP8zT5VQfFY6J5S8ccvhEZ0PPODtjsLQ+1OeH34c/u2o0yC/blIWIs46/TLGiOchqlps1+TQ9B0qahKgLjv29DTY+7vwUX35pQaPMiml0RVBGMSI2YnENrTJsYs3mc3h6pa/ZBk/SC06FzAfqppunYGqVTTErHC05yU5uFRiyxQQdqzEWIb1sKdoAWnIWVg3RN/FKMBUDAhWFJdwifU3zLQYspu6X3IV5UqO/noi4/kKX79HCkCgpRmUN97r5O769i/t+SspQ4CdkQWF6leTTChejiGXvBUhBfWaHFxUt04XBfS7vNqbWJFmJvUAG0foJfsLJQ+srOC06j1Q5YunApInfTch1UpAUA1ZVeGhdzf0jntn3GjnHiJXIOhIRSFkfPi9DhKrbwqKWXlEk/SgosVhJBIkvwV79A+8i8kUSNfCwo0agOFQ6cpBfvepnfXhsMWIjsAtJrbQZzmM5mcZx6zJy/r1FjtzJ719+1ncz5sTdYUOm6h+2HuFubX7pRtot0klOZl+j5v/46vfCDjDYvq4mH6ToKT1UNaKB6nu/dehxBmoEVZSGVZBDGuEaMVfE6LIdw9onbuDLHLeddmwL8uQvPAgD+t689BQBweAGfurCB0jy9r8SZm3wpQvkwp814HkpPhXbsQhkxoajnWrJAs3ieacLjtLAoNoooXG4e6OXN+1a2V4vFc2/1hda6BeDf7NFxBzawgQ1sYHtge9XB/b17sV9ja+SSfO+TryHtkcfw7BphpY9PUnHr8vysKSvf+wZhpVOrCt2TjNVnjdqtuyMwJUleZEVmFVXHhP29C7Dbon+UOa2kmY5SPFoASC6RR1D+UNPQIfvsIUce0OVu5BwXHsVjiFcjaPaSpZgVqwKK3Q3H0C9pQ1E8ygI9BWakdNoKOxx/RJ5G5XhkvgdsZOQ1FEZel+5lOtfaPqKHpnGjv0EGcNvszTAfkFChF9/XQfIe/VaiMK0sZDJzmwZS4JGZO3bqacWpEtfCL1NMxdzOK+MlCVeRRAD5G4DPLLlyLe0hbWCmAjOWdFC8qFGUMeI0R/ta3jwE01+lGL45m0b5EEOVdwxkvOCgzvhEfz9FGPlMC1usax5bYYBDxvYwxJiW2oIYrJRnmxl9UyuWdlsw9dWDNiodfo3TmyIP6gGLn+wX/kovaXRyDGnm9EV1hDt6h+vYLvBYMcS6OamMFytessh9tieBxAr3v9zlfpFjFgwgabluCljqElhEoMo4aWHXQ8/Ts1o6TcdMrHkmDVbhKCXi7v4g4xkmg14+qvZY/01IL2u0ubA9enk3QEEKueVjHAU3XdSbuxl8ASBRUGg9TCmqwnN0HX4dCFnMSMAMCkCNo9J4tZ8FILGl0DhLcAOfddFxBHAvUZQ39zTNk2cOfADV/Zy1GOn36DeLWSiOhEZOU/G9WBjf3UuxwD1MgYb2+kEygE3tDX+QABorq8MIRCOcryW1j1KVjcm8gSW/Hdsr6OyFvdjvwAY2sIEN7Dtje5WGekUpdQfAZwF8lru43zWLxhi+pyL80V2SD8xxE9mlawTV9EuuKTCJeEuvSSOLChXqZ+i3sQXyPkR3IMjbhr38ESqSrh7Ims8SC9xQx/Uu7WuTJ2+yd6UbHjxuZBMe/2jNdldLTl+kK/2qi9w98aTseUtuOclF58xqF62xB4Q9oFqHu0I/qJziwnLT5k1FMCixzoVGBTSZQVfyyCqw3nr5MeY2uppAZpk8kfok7U9EgrILvilmiuaB1wJmv8R5b3LaMPYm3btuykUns4M3qKMRMJAgVuuNLOh78TpljKuHFIavc4PRJEN4Gwod6fRmFtFAtEMSdgykUa81oU1N5s6P0I08/ptLKB+iGyKevOgsOB3YYlGP+Unutu7SAOZvKJM/3mXKjq1ETc3JqI/VFbARWqxsQRRx7qquzDmY+Cb4Mzr2xgUfwzdpu5WP9Xvj2/PDdpoI/Dqy+xPL3WCY6pRGcILma/5Zma++EYoSKdrGtI0upcGvOc51j+k2unw/vYbcHxvVCRdU7gX+3aiF08r2bgtwpcH1AZDopY9LrU/qjL2aMz3jf53dbx5TAYoI6KTPeoeEoa7JDQcN7k1t7e+HA6tMF7rGkNk8zbmbnz+GpIhHZTmyrITI8ZtwjWHgEeuxxL0Q/TAVatSdfl7EpjiKSNP15hZsRGBqSz36LSt3+YFOhkjNUiQhWKZGgcJ7ZyQyjBBvx/ZqsWgC+IcA/nMAv6yUeg7Ab4N6Lb5tug+xP7pyFt4yPZyFiB507wG8WPKSaY1po6zXdliYpuDAke5YfvElGFnVHraauZUu5w1GAiSWYrxfLjpxIVLlOoiz+pw+Qw9au2NnuCBIPA1AiN727T5fo5THOO3khkJiq3+b7TM+uo8Q8qYSoxSIPGidkYiol9GDKy85Rr9ZtIMDTsX5daui1xmlyeOXXNtxzufaHtFY/RD9dvgKHUs6nTtZBb/O58svtnZeoTlO28sLv3CSfpBZjQx1/NgbjFob3V3ATK1reJz6qrcFBWUfiq3zghzjFFXsLV7QAMZfgVmMypyS6+3tEEDBtb8zA58fdBkXr4dgT9BK7h2aWN4jdQRNOvfeZMfMc/RAr1/kIrakcZQVVRILMxEajIxqUEbVdh33vL3kRasiS4r5IEvfY213TucVLkTY+TYavaxRm+3fR/cB7G1Dn6EHo/v5fWhzh3DtEO0stt0zv6XmLUp1C3Ezh2V9TW5ok96MMxmhSAJ08toQ4Ek6rXjKphXlr1dx0eX+GJd7h6TY200B3RydW+YujUHnYhNRle5VclOul3tgthXamvuJ2BGrzu0eg8gDND/LQotvqG4yXSim0nE4xdc4oNA4xSm9YZoVY28GKB0VgILMV9pHux5DnGnWN1dokJMVhZUP9/e9TNyjf1XmPNMP1pjcPQ8cflZyVzy0xuj4wYn+NjetYPTE347tVZ9FqLX+Ha31x0G9Fl8BaVxIr8VH9+i4AxvYwAY2sD2w94pI8FcB/KpS6oOgaOPfAxh5p/s89Fn2Oo7HTPpGTCIBvwYkSoy3jgnNrwIKXIjs6ZQWrpkmU5q3DlCYOfoN38AMxYZejVkBHS5KdxkS2e7ppe2sU+SSWXBNAUqoqv2l3cU2v8rnXe/tqhScu42OKsfYUxtvIWR661MfuwcAuPkqpeBiJQcBC+MIV5B2CUIIALpC5ylcS9209Qq9suUPynCqpnaRwfgV13jfwmnT5EKg24FJUYiFCWV4fxozHMXUdntBhdM0HqmNCOl1OsfEGnlBxdM5Qw4pmHcpxoYxK1jjVC31tKQHhUZb0oTVA9bTFrABdI/4Ds+d+LZruLokTSTU8R0A2au0/8b76Bz7ursd28PQnKLHS6ChouPttpWZY0Jamck3UeP0gAQSEsGUj0eof5gGsttiPfRrcSNABE4deU2gdITTNzubiyNAM4X4J85Qa/jCoWH81hGi5f/Mv/jbAICf+NEvAQC+XjiC+QI9oosvU86kN+gQXfvyCW3gttUjD0hpSMqWPfowrk3vx05LrimUD/N2QgLg2udUeMmGbgCdIRoHtynPCBf+Y0AjZoEkAJD4Rsb0JFRO0n0c+yZ9mVqzkGUBXzghkFiX4zOh4fHWLi9c5kbmhQTKp/jaR3d3dQcXWJjpRtIIbMV+igrQ929Tf45T9NHha433SPmK5LNE8BWOeiQrAADRYRsx5J6lu1Q810+cCACa6eqdMYbH3/BRP/D2obN7FVk8cDZorb+utf4ZANN7dNyBDWxgAxvYHtheRRY/++d9qbXevfy+A4tVNBLcfS3sp0JZnixGRu4xu0DexMS/u4XCp0n9vT7N8LcMkCPGceP9ilUOA0nW9MveZw8zt9uDFprk9mhPXnDTFrHFs4zfTfB2oWm8kqKm1Bu0AtIfJPhvlhO9xdfGexrXmG4bcSDV78lJFNEaaePoATrx+XWqygUjCuAit3R8Npe5y7erdom/A0DloU7featQwT3PLaLr/SGX07FQW+MVOhHyN/h8ZzjHzNxZ3YRCepW8H6FTTm0AQYr+v32cXEEn1Bi6Q78tH+wvSDmhZXI1kVG9pyDOrnB2gesTAbDxiI086dpt4dTKe2oDbTXj0iO41JhlCDLTUof7Wsi/StGRQIsJ2syFx3MMdmDP1Fn1kNghOlM/rOEmOEpi0rME5+VbLR8BsxDEmS+sPaqNkBTrFyHyLOxWCsuVT9C91o0YVJUe9y+/cJYvTuPTl38BADD9MfJ0ny8Q3X09sOcXcNE2cl1Teyg+TJ/lbngmchOoskR+qTWN2v7dfqNEfBIppjY5A+ApbOf7X0npZWcXs0Jqq4vOkMBGuTbHNefakS4Sq/Td5Iv0mtk+EzcNqWGS6xgMXEivRZRxgIWla0eb6F5g19FmDHqC2YY3++tN7VEgwXXADt8Lr+wg5MZF56pgW+1DtvkV4k/P8pswjAONxI7X8fE6xkYJF73+JS5u8nB2ZjvIXGVAzh1+jgOFJgNJ4lt0PtmlLrRL+21NcW016rkn+sFR3oNsTyILrfX/vRf7HdjABjawgX1n7D3Xs1BKuQB+SWv9K+90H2d+8Z9qgNATDtMJZOf7vZTSUR/ZRVrJpeGtMeEgtyj8MozSaSt08v3NapLDTK9oQ28hKJQw1gN7ZK9AeFiEjgIAqg8xH/9izHjagtJQgTIrf3tcYJ7k1uRzDZyfICnH2UTJ7O9z16l1xWUIYCcXWdZJPp+RcxSRrK/nTWSxXqXtq8UU4mk6RjJOrpoIEjld2/jW5Ty5Cm09QM41yGn4TC0iHmabJTc/9NhVvPz5h9Br2gFCoSRg/QOP0WLi2QNAdpERMFllPEWhN1ChzT2n10XEimGPR33jGAmqRIXAyDW6vspBRgQxasRrRdg8x/l9YTwNrfhO7TDd5OSqZ5rlpJbUGbZUJhK5yJzQrs0pN1leNX9doXKkfzuJfiKPJE0BoElMM+imIwsNlWviGpOf7sC5wfed616xZIBUgu5n9TqFQfFthdYEw6I3+3Pd7bHQRKVCjRIra+Tu0zFqs8ytxl584ZMtjLBuw9Yd2r/8HrDjnVy32hyC4gt7SnJy7fUzVp9C5rxX6/dVnQA4/pF5AMDlNyk573SUydtLZEG8ZXSdG4/yeUhT4ZyNLCRS8OuAx0i9MGkbQGWfguJrcHI8VlI2euxpYJXnVxBgBkmnAV+QiBxwez3AI3lf1Oe6SC145pwAO7fDONBkyLfm+57IdDAzTJG8RBbSmOoEQLCfmWs3OKrtWKoYeaellh00ZvrlVMMpGhjdcpFYoxO48cvfmhvqO7FYxAE0tH4rIulvbQf/+T/WAE02lwcgvcSFRVaKGn8jQHuIVfEYg6+6FosccgE4e9s1k1s4a2QSRL42nbASMifKEcIdkMXCafr38A2N0rF+UsLmvq7R/TV6u4dCw4skL2dDAz0e4tGHiHnweIZe+J+79gjSX6MKt4T8QV5bFmmejPJyT9/zTAEsyFmepPgYFUm1vHi4n8QvuuaaezuWO6doxoeSPin6yDGnUaVHMxjo14n2SpaSO/Mw5RwKy7wwpWlgEteS5hwFb+/VNfyG3Efhu9IYe57GIRyhMagdoEpkc0QhWeBu4Dm7vaiQiUkhvzVq00qpNTvvBSQx/jpdU+G0axYLKdDKvXMCwGv1F1W1CzQepbFKvUjnFmQsIZzsQ8Y2d9umT8oMr0wue7ZTWd5BrJinuwrZMXq7VLdpDOLZNkLmHIrYYUq9mTQLXnyU7rW6bHmaug/Ryz9aZth4yUGc2ocMK4GMf3W/YxYv6RmK3YtbzWs+x3hJo8JCjVKM9vfRuXYDDyHT0Mc3hV5co8vCXELqJ2PWTdqXoTFHI2SSvtQtelBz9yJsn+t/BqU73u3YhSHLPUGlI775TBY5SRFmFyO0WT9bFov2dBfp21Jkps+UbWswKeHOLJ9Xvolmnc7N2WQWA4e6/QH74k5u2MVRFpPSedqHv+1BCbK6ZwhkvAUoUj0u0HYHwb7+xQJKmx4qf4Sds0sZA5kfOU65uK0lehbdXAcup7Bu/dK3Fj/ak5qFUupfvdfHHNjABjawge2d7dWL+0cB/J8ACg/47h1HFGJSoIli2jRNCbVycsXuXorYEjHEi8rQhRfP0994wQr/iNcujV0Tr0TYPM+dvtwQGbusTGOXhJdCi96YVIYpNOoRKRLvoMqwvewN34g17RIw8SK8dI1ctcsL1F7qASj3uGoRAAAgAElEQVSdJddGNIqDsQAuazaHXAj111litEMpCQDwWK/a7QD6LnmZ6TUuLCs7VpFpfLJjINrUEUcgbltZDe0kp4Ti7A0HDnJX6PiSluuFyfpMma7v0z5z8xEqh8Rb7/XyuZuXWVCjmEbpJMELD/3+7n5O4dqRcL54NjKpMjGR2vUayjReyTHlXgJA4ZSN9lLLzHQrKZaeer6kNesMiIj2tZB6vUcTlE3urXR/1/med1O7S4X7P76ACgst5WI0Vjdvsoi0b6O4+DJDRlsxdE6Q96iKuztRmW4L4WmKJnw/BILdj55APuOb3Ald3e1gmqbM/R2E3PGbYQbW0lLesDQboABHrn5XwfWlWU6gyDAsqOFhcpeFYbabieDyvka46XPru9pIsgiX7H/7nEKaGZwrx/rThWHCRm3bp2msRq8EWH0/TxADk+a/jQjJDRZSmmSN8lUPnWE+36YdD5HHTazzibR338exU9Q9u7GVQ5PTcuk8s/aeaWHtHlXAU4uSf1Lm2g1lP0eU8btxxHqkXgEgvm6bEH1hnBjvQafs4DLrnG7CZ0nWbU4nHjxNZG+Lm8NwT1V3XcNb2V4tFpcA/KnW+g92fqGUSgD4u3t03IENbGADG9ge2F4tFr+Nt0ZaBQD+wbezc6GykPZ/ANDs6TYOMTdO3kM3JQVRXr2z2nACzTxNvyuctrBRYVcdvUqeXRhzcPDz5P3c+37Ol+9z4Fc5T86smTupOABg9DXr8e5sHARsQU5E4gXmGwy75lrEWmMRhi7Traoc5oik7Jnz9jZsEw8A5D65jpU14q4XXQrtWljlJumvIM1F1lhFm32ZYnzK6WPRNee9KlBfhh5zs+CDaCL8GhB+kUKyLkckDworSyelUU6Z4rUUU1sTIUau0GerHyCPVUTmWyM9VB18qsOXHDRm+r3j0kNSm3GAdbk+vvaqRowjEY/zwukVQAoNUp8Qjy2z0kXpGI13gqM3bCdNZCt5Z+3bOlSTAiMzb1Wo0f0EFS5nkyzp2UzhkYnFvvMeP09RwdWtSZQWKM+sGYKcuhtDMkPztM2RR92JG/Gd7ztyGQDw+zcJJntmcg2v3qdiTsjiTS3PM+zIwgkmXr7U3ACifgGAYAiGS6i0RfcisekauHo0wRdcsRVufYSS8/EYHTO4mUPABdadc+GRh+/g8tPUaRj8EONrKykDJJFifXJNGWljNUnjV3aYUTceGaqTtIg8jXoYusm7O8Q1AAYp1CddNM/YeoqYaT4dtc9i7/sGAPJXOcpfyMNjBuiNCmNnc3YA61tck1nLweE6lginNWLCCOsic5DmhH6Wnt1OHgYkMfom/W77Ya6XpSMMvcmNhavS7Kmx/TjDkBfpwTQM2j22/BJFrLGGMmOE/2TXZrvsPS9wvxt26Df+Fw0AQ9eVeegrJ2mQRl6zU3DkKs2IlQ/Rm6w9GsGrCzEYbeO2tVHFkqKd8AwVL1pN7RaH/PG7iV0Uy1JUcuuOLfIx/j+1qtHhcDTDqB+3o9EasURpvdYeViZtIlh2FSpDL6yZgyaRbyPkEDZcZWIwg3NXiPGCVttnO8NlsZDinqRi2sPKfCeIk27K9iuYwnVDW1JGnjby0KZXFCrn6Kkee5Z7KZJWta5yjEN4TnekVi3SzKQBhzRSa/29A4lt+5LYaZEPg/QAP8j5a65JJ4pJsTqx6exCsvUucoYLywWy9/gYnHISBwGwqSvpqWgPK5O2kKIjAICLu3JfZCxG3lTYeqzfIRiZLaFapxfeuVlCw63W6UJ6O8TDNabJ3nbQOiaFZ/pdZ9juc+4U9U00AzqHratjpiNcelMA25cUZzEwKaTK9fSet1dVFhW2ZvchRWlBWQmtf2s2MPxWooboNhUCOU95OfPcdtoO/Ao/N6zq1njdEj1k5/l/FEz3uj7AoI0NGoMoEWFomt7E7h/RS7cxodA8SvclfYMmm6SmnaDHmRTkXiqCTtFzJpTzgEVQxbmYLgp/sarC/9felwbJdV3nfee93qdnH8yGwUoABEGKAihQpCVZeyDFkmO5FCWVRdYSJ5VUnHKVI5eSKke2pYrjJP6TH7IUxY4sVay4JFfkSI4iipIsSuJOiBsIgMQODLbZe3p67343P+45977uGaCHBEAEwvmqgJ5+77773rvvvr5n+c45tQ6zVW17DSnOJCC/Kybpx1uIIiubPMFFyDqOibccYORFNgF3kCpWJkOU+NjsJWEyYlU696BOjnkn9dZd3ErCL6gH/6S7g/tGRXArFAqF4ucIN4oNVQDwDQB/xuVUrysGjrLj6LKXpFKcfVJMFEHTYHmblTaq7CxNFAmN3nYaW7JkUGLpu9HjJYtOpE7ZvpLLwMJ+LnHJqZNTTJFrpQEzZiWY4XusSnlpvh+tFTvMQ4f94i25lSQfjZg5UgWguqF9kTfZFnoPWSmluMdu6/t2Hj0XrDq/tFO41auFg/4Tnr45t4+lmuOr24nGUGVzSu9pX7zHJJhQkPCaR/48Z7Bdah87wEuiFBk0pBgPl1o1jldOqHJeKaEn9501qHJWU5HGw6px+ZyKW/w42+OMSwMu5pRmDihv5fw/j3O6bS5rWglTLntsjs1Rg8damN/Dajw7SXvPRM7E5WjVPLaVjU2X2j217J2qookYdjqaDyygwJmNwdRG4eyXNhLS3EfI86S4kkWLS6YefMkSHMY2W35Io5jCxs1W0r540WdIzV3mwkK7WLubDp2Ee/bQBI8fO0aXyZkYRWO0pju+pq2Sk4tNOOd8FLhonYUdPsNy0BLih0HvGduf5EArD/r3J+BXNLPT3mepmHGSvGSMFsp3lIkQjVtNYWnJmlHMZMOZ1npZy597oInUHJuA5oQ2ilWY32f7HTiUQFVycE1zRuRYuV8htEgRseLmEM0eyQ7r22XYdJQot5uSlu/wMTJCcAlmUy6eRLBp+yymOReUjJWZ4odx0md8GH7OE3iEpi+ahYBaQO48jyP/5iVLtpgT4OOYKqPkLAguToU1ucy8caEG68GN0izSsCbJ7xDRcSL6DBFtvUHnUigUCsUNxo1ycNeNMZ8got8A8GEAvwbg3xHRowC+DOAvr6WuheSBKY+GKLADSPLUV7kU6ejBGmbeJI42vyo7reEA51xZ7EH6dHsWWAmiS8yESHMQdeFODng7H2DoGXE2231i60zPB6ixo20+YyW1VjGJsM9e8OKvW61jZSmHTN46/qrs/BJJs7ivhsyJjuuZTzrJSeiy0RpPTuiArazPcZ/nYEVqARsfsfdenPIZVwErhXSmiImSXlNJMruu3kdIsCAkfYhvJLNokHvFXneJ09hk5rxk3kq3BzwC3r5LLbtvYbfPAyRFnuISo0QKCxkgWbLSNODtyZWxCD0n7BjVRUsRWnDs/sTmHdYCn08pu1rKGn/MTtOVLVaiHzgRoN4jAY8x2i1n+QyG7LNOPT2MaLt93p2O3FQBKLCPDYvsNKkHCHrbS4TOSobkmQRqj4/ZvzfLOf3dDLxsPykyrkbEwr3t56yORi6qW1AbNG2ObMD6kgCgPEkI2P2yaOuLtfnXijs8aUAIHFnW1lLs/2i0CI1Re4Ldgzb676VTW5Fk34bQ3sEFgJKXksCifR9kejenavjgHivy/6DPPrR0K3A1KIjt/OEGe3HhsRyWy/bB5y+sloUXPmjfu/CVHr4nikVbx/xS/fK+2ysp7IxcEaZEe1kIZC8HqI6IRcP7DaOUPba012pL56aHXcRdicvXhpzxOlEmJ/nH3+2ItfpaP2f23cza9b4i0o96XxYALO4xLtdciTXuZk/knofcn2hBQdPnTVsPbqjPwhhTMsZ81RjzXgDbAXwPwL8FcOlGnlehUCgU1xc3SrNYJaIZY84B+AMAf0BED15L5yI1Dx1tou+UlQCWOSNpLUanXGE7rASmrQVTDR27SZgvIukOHfWiVHrJ9l/YQS6AbfxJuypf+gXOS7OpidQC578veu1gctjaa2cftXbkngpQ3cAsi752u2byXAqVTZwSgwOw4pKMMBuipMHsffYcVWajtJgmlz8bOO1LmESZJYPSuDgT7Idj9dQ9RVQCCNPLEXJz7N+5bDtrpQOUJnzWWMBrFoU7An+dkkE3JooItVWk04ETDZTG7PSLM5LkuqX94h5gw8+wJgo7yEnGrWw75TaOBAcl9Uz7Kn4yBs10bL5slgDPwGlT829gzW/ZS52Ld7OExgGJ1F8HzbRrgwDQ+yL7KvganbS3Bs34DXefdSWBHUtodnWfLi1Mn6d8S8W0eAIdyQMk9vgoG6HM1e1yJ33WVPG75FizJWZH9h+LnBQraPRGCPldEnZTIlZlsbhd5kvgr5Wl8ZfO+qoEjc2sshSZLbac4HMCK1vYb3S/zXNWrqXw3Yf3AwBGnmMK9XtaLji1spEZg2eY8SglTwFUmQmWP0voO2jngIy9UJ3DKpxCUZoU359BYnn1b4bz4UnwIWu45YnI+dgEJuFrvRD7lkJDjsoqNGoJ3iUTs5hwXZ3K1gZyp+xJpVyuw5FelCfkvefnn4ycNi3vMQBUJzjHGNeqkQy8A8drKI1fgWq4Bm7UYvE/rrbTGPPE9TpRZQNPCM4Ds3yHvaXTH0gi0RGN2soaEKeBXjlieWSbHm+hsLW9XZ0XnEI1jdSKfUizdr5i/LEWipvtoM/sX/3DJPRLicwMVwKcO2mzxWVi7byTkcuecubvoEGoj/E+/jGIEu2J8gCguqOOzV+XyFl7rrMfYjPTjsBNDKEIBw3jUxN3zLv8hRZKo+18++KmAAPH2xey5W0plCaYXMA1jBd3t/PWAWDgpH0W9d4APaxD1tmBLonz7L23f+anzZolIhfubqc2tifya2/ffyJyeaKyMxwFnuQcPX1AVuj7m6UglqfRDh+y7SsjsfgNHgJJWEctQpTnEpoihMykLb0ZAE3bp5wo+8VS0p0n2OyWPx+hOsIvLkfynnp5O2iTjLcILXKfhKW7hJLNTeox5/uA/PAAdc63ZSY4ult+qIqhq/csyf16LhAKe+wXieMRRElCds72NcAkiZXJwC14gkQZyE/LZbOzfBKrkD9of6V7p1u49KCdzDmO2ZF4nvIEoTrOcQI/s/E5/ceBhCNuMJnhbNItULlzdhwrnH47eyKFiXfZC7p0bModJtct9y7vQNC0pl8A6HnJL85NNkOtcJEqzGbQx4WLXJlfFr56TwWuvMHAUds8WW65nHSCsAqkWZiUH/jWJKevn2ygdcimCRCBIH3RP5PCdr7PCaHSBi6nmpsTCB0tXhbDxAohwXm5Gn3tz644lXbU+vXgRqUo/xc3ol+FQqFQ3BzclKR+RDRljJnu3vIKx7NUcPEXQkflG3/Urrwjz9vVc2lngKHDdhW+9BZZgQOkmK4nKtzcPYm2PE6Ap3LOv6MOU7X9ZlzOKS9tS56pAjtLqUkuQE8Q1ghJLjojBZrGv38ZF95vq5QI9VOkxOLuBnrYTFCe9EF5Qvmss2SRP5SGDYYHljfZ/ocfZ8drD2FlC2sZLGWnX/AmmJn72gsGVYZXywzlzS2URTDLMS15Dkh00BKGDttzVoYI/afs9QjtMA4hA/SxlDp3b9KZT6IYNVcUhTJrMEHLrDJqukJQMwHSC0IbZKlzpoFEpX1aNzjKPDsLlCbCtvaNnphjkTW0vjMtXHwrawFnWEu5FKNaLrF5kMeikfeaX23Miq7Ffp/HS2iMKTZlVUYCjD4j88Ruqw4S+l9mEyYHJDoHsPEBb+OPWym4Mpp02lpxG19X0s/j9BEuzMQSbM95oMnPUcYdADY+zH3wsw4l1VcPueDUKtO8s7ORz/fFjIjlHQYZNmuI+UQC+wwR0q9IaVmsgqTxl8C31BLQf8KO93ws2312VjIn870teu1ScrYNMi19eZvB7HfszbQ4n1c57+9XsjxLEGLtvhWYJSlKxtJ4BUhzCdwc52KqjpCL8K6x9N5z0b6L1YHABerJ8yTjTcYZnqOzbzJt5iEASB3yOcWyTKZpMq02ilkhxYEu2artvfA+KbhU8s76zIw/z+Tf2Ac0fUAqetmP1mor51Vxs4LyDt+k8yoUCoXiNeBmpQu/+1oOFqmi5zwheo/liy7ttD6ICtMVew+lsbDHrsIDR9jGGLOl5k+zc2rSOHuzlHvstMsCvlhJZThwQTmddNORg4GToCTIrTLm8y5J+caZd4y5YDwpZC9OtuEnE1aaBtDLmTXnYrn7MxfYKZwDLt9vT+ZrNPhrkVz64swqbA9dioNOLLyxhfGfsqQ1yGkfSoEr9iIIa74OhEizYZXlDQJmhpOuHQCMvNBAg7WMkRfstpUJCXbygW6Sk6m4LUJSaMs83ul5cpKQC9Tj9tXRCM37bMP6rB3QkadSbuxFe5TxKU0ZV6BK+ho62sDsXnvdUkqz3he6PGECkcKGjrZcoJTk2GoNNtH/fIrHQwL2gPSSlYglS61Ixn1nWljYzdoaS4KlTZHLFCyZcYWAsLIlwuhOm4Ds9HbOZbLkqdKpAvsKdjZAHMDWaKZ4bNnfkwVWtnLwW8Kee/LHJUy/26pdPReF2szazygha33MSBekHKdNVRNH38kA6aLttzYoOZbsvrAOrxXyYZceCJDneV1jEog44VtZ79uSIMegaVyKi/i5+09Zw37ADI7ZB+01DD4friIQJEqE/DkmF+REG/N9SUGi3jP2Plc2Beg71a6ZA147kjESjXjpLuPyrEm51lZmjYy0zwL581W+Z7t/abvtNE7DLm3mTMAzIep9EpBo90meMcDTy0sb7bGNXuP8lzLuPdMGF95jNQqxJMjvVnYhQv7C+qmzN2WxYGbUa8bASTZ3ZAIU/8YuEobzngw+yflYwlh0NCNoAJk5mTSr+3URjjyPwpmUcyI12TudKHknWYZfouTz/LBy5F6s6nDMgeoJGgCAvrMNLLydK1lxMrjyMkeIn0+h/5htlyxxTqP5hHsB5Ycvfv0SSSqTIV0wqA3L3pj5hE0lwprau/ckAOCFc1O4/L72lS9zLIMU5/UR3nfvWYPFPe33Ij/qiYo3swwcsy9EeSKNAqchl2p47hrSPjK4/6QdoJFDEU7/ba733fSLqIy3RN87hXiNtW/2bU30v9hRI5lNQ5IQD/DFrMqjCffSDb5sV6HZfX5wnSmGK9AVqmFMH/cvmhTVklTZhd0tZC7Z87lkbYzz7wFCPn+K2ws/Po4G0+hTBULm83aCp/fbe3PFmeDNlUEx4cxmYoZELMV27wl2rvJcnn9DzsXhyEImTtnsjHFJ7IQgkLtILr29ZA8ImknM7GMHKhf56TvGSTTJm0okCt8WWxLmHffP84sinzWgwT+6NZB7zmLuamY9+1Hm/Ohj/tnKO9jI2+vY8FwDleGO2t5cv7zc7HFjmZ/2YyULtcSa5GYjtxDUOeahh39oE2VyCUHFFNdzIkJlSJKF8ktLwOIuXiA7CqiNPV3FxQftg+ljc2Qr7d9zQ+0Cbb0XWLyH59Ci70viZGRRnHughV42BUrpABFQU0tNLO1YPxvqdTdDEVFIRJ95vc+rUCgUiteOm6FZJAD8LoDPvtYOilP2spfuNDCp9jrRgtq7llGb5pTW5TUorqzaphe91iBmGpHew5aXHiSuoJkFcrOttnalMZ+XamWq/Toys4Sei0LhZHPBWBJAra3d4GN2ha/3E4pb7LbCHUyrXfbtpMYzjI8pEElR1GLAl7iUfUEdTv2XSNSzL3La3F1A3zlRz5k+urGJ7DTXqxYz0WYCIjFXiAPa7mvm4PTb079sTzr+hJd+XelKzhKbngtWSVcAkGNywQrTKQcPk9PMqqPtbTd9v4Wl7Vb87ud4j+x8hKUd7e2EFtrMeGlW6LFifgGAKC3OTDizRaGjL8BrU5M/ZVr13pSLvYmjda/1bM/fyePI5IpEMVhlwoyXE21IHWc+Tzx+QuZCWPOmEqGsXo5FL0kqeYnQrQ4GjkwRL3Akkv/Y49a7urTHntxmRW6/p2bWxtMAQHnUPuPOnEWAL9QVlAPkt1tO+MJlfheXEq6wkWhtLqZmV4CpRyp8fvs+ZObqqI5wXrQpqX0NZOftxFu4y46tIzqUDaoDAR9r+42S5OKN3Du7pf3c8evJzPvcbaUptgDM+nZ1CZwe5/cvZbB0l92U4jK15Q2Bp13fxyntF4yPN6qLKYvvfWcaG16wFpNqrBy0xOhIbW8hLIQVcu9gdbM3XSxm2KR2yj9jR2vnc8tcK2xLOQ1uPdCyqgqFQqHoiluyrGocUuKw9zSvuJxhMczUnexe3OklHcl3JJkY41Jbk22uQpM1SSB/1oqiF95uHYGpgkGTnVeLu1iCYTvi/BsN+l9mBxdLMtVRg54OZ2miZpB52UpmQYUz4zIFMGh4B+Hoz+z1LG8JHXVumP0jEhwH+EyxzoEVePqvUETDqqf4ivNQMPKcLy0rdQqoFayi1lXHm05Kl0jfePZOQVKysSbJ5fyXojpxCJEgrPki93IvcSwwHUKkZdHUKiOrp9L83Unn4xg9yBH2D4ikSVhhiTLaaMWtqffO4tSsdQAunbcG4lZ/HbWNto/8UXttQdOea/TZCopTXH5z3op9Uz9oYOY+K6KvbJMMxwF6X7BzptRRjKmZNTCb7Pm3vcUyyJ8/M4WIneNCK2il7Dn7TgaYYSe85ObKzMY0Ec5plZkhVEbZN7Cw+rkI/VYy01JEqzQcQapokH+aHfRp77db2dR+QL2fXN4v8VVUmYpdH/Bie1j0WsHs/bw9Ejqw72/hTn4v+Bku3ZF1Dv8cB1muTAUob5BoZJlDtr0hcnM+f9E+n8K2JHoutZM1ypw9oD5g0DPN2hIHjEpG2Diqg4Gbw530ccAH0jkyC1HMb+gh76hkNe47LX7JBqI0k0zEJ3IpWuUoF+pyKwUQjxHV+Pcq3UL+HGfTZp/YwKEECrvb711q+gDeb7ge3JJlVUU1SxYD5M+236yk6kh9dQip3cy84dTPtaHIV7tiNkzPBZ/CN8OOIkOe1y0J5OKQJHriuBQ2wtiTcCm23fU07eS212a3ze5pIHWBq9tl5brZeTZgMHDEblu8kycB+Re9sINfzJPGvbgRR4FGJf5BWQpRvMfO3qEn7bbsQgvFBqdVOGnfrHofm/N2hM4B6RD4iS3jnT+1erqImSNRM5j5u9aEEB5Z/bZFfZzWnce/hiQirjWMk/YHuXKgiDo7+okJ/8vb064inSxey1vteA6+0nKV+io2bAWNfOQKT83ubY+OX9nV8MwqTqXxSm3cXePwETbFbU26H9uho2waGLR9FafSGH7E8jPm32Ez6JXHfCK5RKzueOci4bgGAdD/iL3PM7B2LtplAInRSYq5SApkGeR4kXBmA/JJ5bKxhUNMTGLuk8Vr9HFCcTs78l/yFCUxU575IBNF2MGcWly9GFMLzjIlQlZYhyOBuHYyb+qE0nFrPxl6keMg7vDtJH363L1ynHEOYnG8A14wqWzg5JUFE3OKt50ajTww/gObtmBx/wa5Tbe4yPW3ct7kLEkR0zOeoSbzSkw9zR7/Qy0CTc95/yyiNfzE8kMsploYf/+dC051OIkMCx/yTJZ2BG7RlGh6GZ/sjHFxQbWKPKfQLZ5zvCCnFgJnrpYUMGk2laWXWyiPrV92v1EO7j+7St/XXFZVoVAoFK8vbohmYYz5/FX2tXCNi4Wkkt70/QrK48InF/XbSs3VDWm38ouziiJyEqPECySqERo5oWmy2EFeUhp8/DwAoJGb4j5WRz72H/dOZ6H+icRdHg/QECYmj3bmbAq1EStuJDiuQFIip2dD55yOl0Fd2W+l9uQJq4rM3ddCdqN1oKbZllApecpo/gjn35mx/S7uuvKjTpSBhXtZWpK63AVfGEV45bnLxvHOhcq3fIfdN/4E0CgznZEl4/k3kItYTR63++Jj12zYbfNvtuJT+qU+0BCPywhrHdvKiNicU9lk22U5bfTi7tBF5AoVMpoCGn2s7UxaE2LzmD0+fTGJ+oinMQJAkG4hdcyOqTg4wyr5HEKMgcOcgCcRoDVhzVYSN1Md9bE0Yv6rbjAuoroxxTYKLrOauxg4SqQzFxwlLO/g6HI244k50gSrC1ulVozTaCujEh9iXAYDQ6yVMJmhsNO4XEwunXqNXBnbRn+7ZpksktNYiltkHnhnqZivmj0+T5i8Z71nmG48QpCBTtSY5JEgDP9MNH1q66s+YFAbtQNZ575MGLnI80zMqC2lkKXcrcTIdJYpBqxmLIWcJPYl4HFpxkxlYwftnLu8P+myBAzzeM6/EU4rSXHBr8JdfpKkuVxwvV/uHejnDA8NudYV47Qp0R5ESybjzdmC2oYWBl8M3D0AvpRrdgbOvLThaR7PAXKm5ux5ez1B0yY6BLxlY/RZf93N7M3XLBQKhULxc4RbkpkkOY7q/Uk0crIy222X32ylyP5TTVd2NccUuvlkwmkUQhlMxCSRlUm2WTIdMLMQobx7rO3cQdMgOy99iLNJaKc+YlrsySbw9lfROmpDhIHHWAJlB3FtyAfxSX/iz4gSQFS3+w984GkAwF8/dp+7pgoX0Mmf5MdpvOYkaGYBYulkdq8V71e2sBRf8m2r+60xNfXDnHMa9nMQZGkiuapfkVxXJoDEHPtyOOtXogqU2SUgUdfxYkhi6zaX7cAMnGg623Ijb59jM+Nz6wwxeaDMqZ/bMtTynz3nyUexnrK+E8kN1Yql/Y1SLFGWEk5ai9YQsqSvpbt7+XoIvecaq9qJr8JJm6kIVF5baotCoDbpiQeA+KTax3aANdZ6ntx8DdsZ123XbRIGl95hj5ESsVJoCLBZdwEguWyfU/8Jg7l97YF0Qums9wMrrLn0n/CasxAaJEq+57xxKdtzF8Smz87bMz7anZhyPfmod7YGTS7hetmOZ3Fj0jl05d1a2dpyudsko2qSyDmb3bOO+VJmftFyrEXTAdrfcwDIMBW2mSUMchnT4sbVsrNPrU/uGBcsyXmaOhMc0gcAAA5KSURBVP0mANB7BihutX/3Hffkmz4m4ixvaT9Xvddgdp99OcRfkr0QonNODB3i+6kZjD7Fz2KNAGMJEqQWECU4SJL9Kmc+xPdUCDF+z/pLC6lmoVAoFIquuCU1i8J2DqNf9FkWl7fYVV4C61qZhLOFDh/2Nrok53USelrQjBzVT/wMIj0lKga1AaYz8qqcLhikOBdOdYjpd8xQ6Zn24fnC1qhOtFDd4NlSwNoZOJ0AQcDSPitp9R6NNWQJ/ttP7QMA5C6FaBasqJitttuzWxlgbp8wNnhc7qwgPMdMow6+ZJQAek/a/vM/tW1WJgn9UlhqCwcVLRknxcqYSalTkE8jIEGL9d7ApR8obhUbNDNEGuSof4bHtjIYupQhIkFHoadrxgOjAJtlVXI8ST2B+lAL/Ufap7Xhr82eCMGA9R/QeS6G0+/nhvgAmrvL2D5pa4RGPFa1P93s2u36nI0quzNn25ysbMDZsmUTvfiSbycTMPsyS4yswdRGVhfLafYYTzlm7evSW1ijesG3FS1o/h7C4BH2i42tlvkkAFOk3uI2nxcr7jcSqrfkI8ssita+WitKL7cw90bJxmq3RUmg7ziPW8fcX97i2TkpyfKbC5Aq2nP0TtuHvLzZXlDfmTrK4+0Fv/IXCLlLtl1he5qPayDJ/jnRGmuc7idVtDmP7DZf7Ct/nvNX9bWPlc2rZa9thR9dehGo77SqyEKdy7fGBHx5fWRsWylfDCoaZq3zQsplKg4bXkMUGrIcK2PVf9xnxJX6FKWNcMEHEjjcd8bO19pALHUN/6YNnKijPM8FpZjhWR3091uXdCyH+H1eNFg5w6r/AXTFLblYSMrnyig5Lnc8P4pAivdUOE9T7rJx9LR6nivr9QWOBigTQvjcICC1zKYaptBVBkOXs0kgKnM8mjVopza3oTJGWLzfXkd6mif9djs5U8eyCDknk6jawZYSksxJby54W4oUM6pybiD5IU4PVRCctiYYoXSGyRYaGzhH0oo958hBNiFNEZbvkGRxbIqLmaYGjtsfWBMAhe0cd9AQcwU7xJeNT+DGj6IySi45Wz+nJl/a5Z9TlivxiZMvsxQhWbTXWJr0XMTqFnv+85zfx+Rsm96jSWdakcU2fyLh6lunFr1pT2C4ol1LkiQmDFr8grfYzJEAcPTprXY/05LDX7a/Xt9+8Av4n0v3I47fG/8hDjz7SQDA3Xssrfbw81scVVGirqUqXXWEHC9fBIfcJYOF/TwnLtqN44/a9ot3EaqjfM/H7RiIaQ7wcSfpJUJhFwsHnI3aFeOCp2vKYpFZaKH3rO13aWc7ayN3OcL8Pfb882/gcSkn0WkWScdorGKaEiFDioQBPgNCsmQcDTnBSSj7ztjFwATkYkZkcSmNBwDsXJDYhN7pdoHOXptfCIVqK/EZ9T5y0d+SH0nuI6iTu25xMMsCBHjadWXMOJOqJGesTdrnlZjzQl3v83YcawO+2FA8LXnhbjvekr5eTI21AUJhN1/3eTGtG2dOSi/Z4yojXO5gvuWSdErmhtm96VgMkieiyG+RGeZJd8b/hqwVU3IlqBlKoVAoFF1BxpjurRQKhUJxW0M1C4VCoVB0hS4WCoVCoegKXSwUCoVC0RW6WCgUCoWiK3SxUCgUCkVX6GKhuK1BRFkieoTL/W4mou8R0REiOkxEW7nNnxPRy0R0iIj+OxGtCqskoi1EdJCIniOil4jon6/j3Fc8hohSRPQlInqFiI4S0Yd5+28Q0Seu3wgoFOuDUmcVtzWI6F8CSBhj/gsR/QjAvzfGPExEeQCRMaZMRL8E4P/yIV8D8GNjzBc6+knBvk81PvYQgLcYYy5c5dxXPIaIfh9AaIz5HSIKAAwZY+aIKAfgUWPMvus7EgrF1XFLRnArFNcR/wjAPySiPbCLxsMAYIxZkQbGmO/I30T0FICpzk6MMfXY1zTWobV3OeaTAHZzuwjAHP9dJqLTRPRmY8xT3W9Pobg+UDOU4rYFS/bbjTGnAewCsERE/4uIniWi/0xEYUf7JICPAvjuFfrbREQvADgH4D9eTau42jFEJPUWP0dEPyOibxBRPP3xMwB+8VXerkJxTdDFQnE7YwTAEv+dgP0B/hSA+wFsB/DxjvZ/DGuC+slanRljzhlj7gWwA8DHOn7g18QVjknAai+PGmPuA/A4gD+KHTYDYHJdd6hQXCfoYqG4nVEBIFnVpgE8a4w5aYxpAvgrAK5oCBH9LoANAH6rW6esUbyEDumfiB5gZ/ZzRPR3rnLMPIAygG/y7m/Er4WvubLem1Qorgd0sVDctjDGLAIIiSgD4GkAg0S0gXe/G8BhACCiXwfwPgD/gP0Hq0BEU0SU5b8HAbwVwMv8/avsY3jSGLOX/33rSscYyzr5NoB3cvfvkWth7IJ1hisUrxt0sVDc7vgegLdxbfhPAfgBEb0Im2j9v3GbLwIYA/A4awWfAQAi2k9Ef8Jt7gLwJBE9D+ARAH9kjHmR990L4OIa577aMZ8G8Hvsz/gogH8dO+6tAL5/rTeuULwaKHVWcVuDiPYB+C1jzEdvUP99AP7UGPOR69TfDb1eheJK0MVCcduDiD4J4CusXfx/DSL6WwCOMYNLoXjdoIuFQqFQKLpCfRYKhUKh6ApdLBQKhULRFbpYKBQKhaIrdLFQKBQKRVfoYqFQKBSKrtDFQqFQKBRdoYuFQqFQKLpCFwuFQqFQdIUuFgqFQqHoCl0sFAqFQtEVulgoFAqFoit0sVAoFApFV+hioVAoFIqu0MVCoVAoFF2hi4VCoVAoukIXC4VCoVB0ReJmX4Di5mCEJkwdNRCR3dD52bbN/ef/ds3if3ceY2Hifcb3xbabjibxNqZzW+xv07l9nfvWsx+Etc+9Vl9X66ftu+l6zthZ2x6HHeq19pmOx2La9lPbfuNOY7cZP9QwfIzh/b4ffxzvo/bva+0L0NnG72/77j47+6H2awVAIP5OOPhC7SFjzPuheF2gi8VtijpqeDBxABSGAAVAGICCAAhD++sQEO+j2LYACAgIQvsZ22aCwOqpQWB/4EPeH/vbBP67IdjjiIAAMIHdZtuAj/Hb43+bsON7wN/jf8txAWLHo21bfLscj842QXsboH2bbWtWncttI98GsU/ZRvF9ZOwPKX8nAiiI+NPuC6QNAWEQgcgg5H0h75ftARmEFCEgg0TAn/HvMPx3CwHsZ0gGCWohIIMkf8q2EBGS3DYZNBFC2kR2H7UQkv0MECHF+1L8PaQISbTaP92xEUIY7tMgAJAiQgAgSQFCEAIQkhTyZwLhxLGRG/+mKARqhlIoFApFV+hioVAoFIqu0MVCoVAoFF2hi4VCoVAoukIXC4VCoVB0BRljurdS/NyBiA4BqN7s61AorgEZY8w9N/sibhcodfb2RdUYs/9mX4RC8VpBRM/c7Gu4naBmKIVCoVB0hS4WCoVCoegKXSxuX3zpZl+AQnGN0Dn8OkId3AqFQqHoCtUsFAqFQtEVulgoFAqFoit0sbgFQEQZInqKiJ4nopeI6Pev0O7vEdFhbvO163DeISJ6mIiO8ecgb/8VInqBiJ4jomeI6G3Xei7F7QsiOk1EL8p8ug79fYzn7DEi+lhs+3dj79AXiSi81nPdTlCfxS0Ason9e4wxK0SUBPBTAL9pjHki1mYngK8DeLcxZpGIRo0xM+vs/50APm6M+XjH9v8EYMEY84dE9G8ADBpjPk1EeQAlY4whonsBfN0Ys/t63Kvi9gMRnQaw3xgz9yqP+xHsvD0d2zYE4BkA+2ELexwE8CZ+J/qMMcv8Pv0lgG8YY/7i+tzFzz9Us7gFYCxW+GuS/3Wu8v8UwOeNMYt8jFsoiOi3iehp1gbW1EqugF8B8BX++ysAPsR9rxgvZfSscS0KxTWBiO5gTeAgEf2EiNYrjLwPwMPGmAV+Fx4G8H4AMMYsc5sEgBR03r4q6GJxi4CIQiJ6DsAM7MvwZEeTXQB2EdGjRPQEEb2fjzsAYCeANwPYC+BNRPT2dZ52zBhzEQD4czR2Pb9KREcB/B8An7yWe1Pc9jAAvscLwz/jbV8C8K+MMW8C8CkAf7zOvjYCOBf7Ps3bAABE9BDsO1SE1S4U64Sm+7hFYIxpAdhLRAMAvklE9xhjDsWaJGAXhXcCmALwEyK6B8AB/vcst8tzux8T0ZMA0rxtiBcjAPi0MeahLtfzTb6OtwP4HID3XofbVNyeeKsx5gIRjQJ4mIWQtwD4BvnasWkAIKJPAPhN3rYDwHeIqA7glDHmV7F2AVynQRhj3kdEGQB/DuDdsJqHYh3QxeIWgzFmiW217wcQXyymATxhjGkAOEVEL8MuCgTgPxhj/usafT0AXNlnAeAyEU0YYy4S0QSsRNbZx4/ZZDDyam3OCgUAGGMu8OcMEX0TVuBZMsbsXaPtlwF8GVjbZwH7Hrwz9n0KwI86+qgS0bdgzay6WKwTaoa6BUBEG1ijABFlYaX4ox3N/grAu7jNCKxZ6iSAhwB8kp3SIKKNLMGtB98CIGySjwH439zHDnYSgojug7X/zr+2u1PcziCiHiLqlb9hteCnYAWej/B2IqI3rrPLhwAcIKJBZu8dAPAQEeVZ4AERJQD8Ela/Q4qrQDWLWwMTAL7CVL8Aln3010T0WQDPGGO+Bf+SHAbQAvDbxph5WFvwXQAe59/3FQD/GGtoCWvgDwF8nYj+CYCzAD7C2z8M4NeIqAGgAuDvxxzeCsWrwRisOROwv0dfM8Z8lzXjLxDR78ASOv4CwPPdOjPGLBDR5wA8zZs+y9vGAHyLiNIAQgA/BPDF6387P79Q6qxCoVAoukLNUAqFQqHoCl0sFAqFQtEVulgoFAqFoit0sVAoFApFV+hioVAoFIqu0MVCoVAoFF2hi4VCoVAouuL/AUxzw7YtpCBYAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "hp.gnomview(count_map,rot=[62.3,-36.],reso=hp.nside2resol(nside,arcmin=True),xsize=200,min=3600,max=5000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "desc-pyspark", + "language": "python", + "name": "desc-pyspark" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Notebooks/footprint_Run12i_spark.ipynb b/Notebooks/footprint_Run12i_spark.ipynb new file mode 100644 index 0000000..f3c58d5 --- /dev/null +++ b/Notebooks/footprint_Run12i_spark.ipynb @@ -0,0 +1,702 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DC2 Run1.2 object catalog footprint (Spark)\n", + "
Kernel: **desc-pyspark**\n", + "
Owner: **S Plaszczynski** (https://github.com/LSSTDESC/DC2-production/issues/299)\n", + "
Last Verified to Run: **2018-11-27**\n", + " \n", + "The goal of this notebook is to have a QA look a the dc2-data-access produced object_catalog (here on Run1.2i)\n", + "It also illustrates how simple and efficient Spark is.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## load the full Run1.2 catalog from parquet file" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "spark session started\n" + ] + } + ], + "source": [ + "from pyspark.sql import SparkSession\n", + "\n", + "# Initialise our Spark session\n", + "spark = SparkSession.builder.getOrCreate()\n", + "print(\"spark session started\")" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- magerr_u: double (nullable = true)\n", + " |-- psFlux_flag_u: boolean (nullable = true)\n", + " |-- psFlux_flag_i: boolean (nullable = true)\n", + " |-- mag_y: double (nullable = true)\n", + " |-- magerr_g_cModel: double (nullable = true)\n", + " |-- psFlux_flag_z: boolean (nullable = true)\n", + " |-- psf_fwhm_u: double (nullable = true)\n", + " |-- Ixx_y: double (nullable = true)\n", + " |-- IxxPSF_z: double (nullable = true)\n", + " |-- psFlux_r: double (nullable = true)\n", + " |-- mag_r: double (nullable = true)\n", + " |-- IxxPSF_r: double (nullable = true)\n", + " |-- magerr_g: double (nullable = true)\n", + " |-- IxyPSF_g: double (nullable = true)\n", + " |-- mag_u: double (nullable = true)\n", + " |-- psFluxErr_y: double (nullable = true)\n", + " |-- psFlux_flag_r: boolean (nullable = true)\n", + " |-- mag_g_cModel: double (nullable = true)\n", + " |-- IyyPSF_y: double (nullable = true)\n", + " |-- mag_z_cModel: double (nullable = true)\n", + " |-- x: double (nullable = true)\n", + " |-- IxxPSF: double (nullable = true)\n", + " |-- xy_flag: boolean (nullable = true)\n", + " |-- ra: double (nullable = true)\n", + " |-- magerr_y: double (nullable = true)\n", + " |-- I_flag: boolean (nullable = true)\n", + " |-- IxxPSF_y: double (nullable = true)\n", + " |-- yErr: double (nullable = true)\n", + " |-- clean: boolean (nullable = true)\n", + " |-- psFlux_u: double (nullable = true)\n", + " |-- psf_fwhm_y: double (nullable = true)\n", + " |-- Ixx_g: double (nullable = true)\n", + " |-- magerr_i: double (nullable = true)\n", + " |-- snr_u_cModel: double (nullable = true)\n", + " |-- Ixx_z: double (nullable = true)\n", + " |-- IxyPSF_z: double (nullable = true)\n", + " |-- Iyy_i: double (nullable = true)\n", + " |-- mag_i: double (nullable = true)\n", + " |-- psFluxErr_z: double (nullable = true)\n", + " |-- y: double (nullable = true)\n", + " |-- snr_i_cModel: double (nullable = true)\n", + " |-- Ixy_g: double (nullable = true)\n", + " |-- IxxPSF_u: double (nullable = true)\n", + " |-- I_flag_i: boolean (nullable = true)\n", + " |-- IxyPSF: double (nullable = true)\n", + " |-- psFluxErr_u: double (nullable = true)\n", + " |-- mag_z: double (nullable = true)\n", + " |-- Ixy: double (nullable = true)\n", + " |-- Ixy_y: double (nullable = true)\n", + " |-- psFlux_g: double (nullable = true)\n", + " |-- magerr_u_cModel: double (nullable = true)\n", + " |-- IxxPSF_g: double (nullable = true)\n", + " |-- blendedness: double (nullable = true)\n", + " |-- magerr_r: double (nullable = true)\n", + " |-- IyyPSF: double (nullable = true)\n", + " |-- dec: double (nullable = true)\n", + " |-- I_flag_y: boolean (nullable = true)\n", + " |-- mag_g: double (nullable = true)\n", + " |-- Ixx: double (nullable = true)\n", + " |-- parentObjectId: long (nullable = true)\n", + " |-- tract: long (nullable = true)\n", + " |-- IxyPSF_y: double (nullable = true)\n", + " |-- Ixy_u: double (nullable = true)\n", + " |-- Iyy_z: double (nullable = true)\n", + " |-- IxyPSF_r: double (nullable = true)\n", + " |-- IyyPSF_g: double (nullable = true)\n", + " |-- magerr_i_cModel: double (nullable = true)\n", + " |-- psFlux_y: double (nullable = true)\n", + " |-- psf_fwhm_i: double (nullable = true)\n", + " |-- mag_y_cModel: double (nullable = true)\n", + " |-- objectId: long (nullable = true)\n", + " |-- Ixx_i: double (nullable = true)\n", + " |-- I_flag_z: boolean (nullable = true)\n", + " |-- good: boolean (nullable = true)\n", + " |-- patch: string (nullable = true)\n", + " |-- psFluxErr_r: double (nullable = true)\n", + " |-- IyyPSF_r: double (nullable = true)\n", + " |-- mag_r_cModel: double (nullable = true)\n", + " |-- psFlux_i: double (nullable = true)\n", + " |-- Ixy_r: double (nullable = true)\n", + " |-- Iyy: double (nullable = true)\n", + " |-- magerr_y_cModel: double (nullable = true)\n", + " |-- magerr_z: double (nullable = true)\n", + " |-- IxxPSF_i: double (nullable = true)\n", + " |-- psNdata: float (nullable = true)\n", + " |-- psFlux_flag_g: boolean (nullable = true)\n", + " |-- xErr: double (nullable = true)\n", + " |-- I_flag_u: boolean (nullable = true)\n", + " |-- snr_r_cModel: double (nullable = true)\n", + " |-- mag_i_cModel: double (nullable = true)\n", + " |-- I_flag_r: boolean (nullable = true)\n", + " |-- snr_y_cModel: double (nullable = true)\n", + " |-- psFlux_z: double (nullable = true)\n", + " |-- mag_u_cModel: double (nullable = true)\n", + " |-- snr_z_cModel: double (nullable = true)\n", + " |-- Iyy_g: double (nullable = true)\n", + " |-- magerr_z_cModel: double (nullable = true)\n", + " |-- psFlux_flag_y: boolean (nullable = true)\n", + " |-- IxyPSF_u: double (nullable = true)\n", + " |-- psf_fwhm_g: double (nullable = true)\n", + " |-- IyyPSF_z: double (nullable = true)\n", + " |-- IxyPSF_i: double (nullable = true)\n", + " |-- IyyPSF_u: double (nullable = true)\n", + " |-- psf_fwhm_r: double (nullable = true)\n", + " |-- Iyy_y: double (nullable = true)\n", + " |-- extendedness: double (nullable = true)\n", + " |-- psFluxErr_i: double (nullable = true)\n", + " |-- I_flag_g: boolean (nullable = true)\n", + " |-- psFluxErr_g: double (nullable = true)\n", + " |-- Iyy_r: double (nullable = true)\n", + " |-- magerr_r_cModel: double (nullable = true)\n", + " |-- Ixx_u: double (nullable = true)\n", + " |-- psf_fwhm_z: double (nullable = true)\n", + " |-- IyyPSF_i: double (nullable = true)\n", + " |-- Ixx_r: double (nullable = true)\n", + " |-- snr_g_cModel: double (nullable = true)\n", + " |-- Ixy_z: double (nullable = true)\n", + " |-- Iyy_u: double (nullable = true)\n", + " |-- Ixy_i: double (nullable = true)\n", + "\n", + "#columns=119\n" + ] + } + ], + "source": [ + "object_catalog=\"/global/projecta/projectdirs/lsst/global/in2p3/Run1.2i/object_catalog/*.parquet\"\n", + "df_all=spark.read.parquet(object_catalog)\n", + "df_all.printSchema()\n", + "print(\"#columns={}\".format(len(df_all.columns)))" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['tract', 'patch', 'ra', 'dec', 'psFlux_flag_u', 'psFlux_flag_g', 'psFlux_flag_r', 'psFlux_flag_i', 'psFlux_flag_z', 'psFlux_flag_y']\n", + "#galaxies=3.183404 millions\n" + ] + } + ], + "source": [ + "#select relevant columns (we alos add the filter flags)\n", + "cols=[\"tract\",\"patch\",\"ra\",\"dec\"]\n", + "for f in ['u','g','r','i','z','y']:\n", + " s=[\"psFlux_flag_{}\".format(f)]\n", + " cols+=s\n", + "print(cols)\n", + "\n", + "df=df_all.select(cols)\n", + "N=df.cache().count()\n", + "print(\"#galaxies={} millions\".format(N/1e6))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Look at tracts and patches" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "20" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.select(\"tract\").distinct().count() #check that all the tracts are present" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "According to https://github.com/LSSTDESC/DC2-analysis/blob/master/tutorials/dm_butler_skymap.ipynb This is OK. how many patches per tract?" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----+--------+\n", + "|tract|#patches|\n", + "+-----+--------+\n", + "| 4429| 42|\n", + "| 4430| 56|\n", + "| 4431| 57|\n", + "| 4432| 55|\n", + "| 4433| 5|\n", + "| 4636| 16|\n", + "| 4637| 64|\n", + "| 4638| 64|\n", + "| 4639| 64|\n", + "| 4640| 48|\n", + "| 4848| 48|\n", + "| 4849| 64|\n", + "| 4850| 64|\n", + "| 4851| 64|\n", + "| 4852| 16|\n", + "| 5062| 15|\n", + "| 5063| 56|\n", + "| 5064| 56|\n", + "| 5065| 14|\n", + "| 5066| 34|\n", + "+-----+--------+\n", + "\n" + ] + } + ], + "source": [ + "df.groupBy([\"tract\",\"patch\"]).count().groupBy(\"tract\").count().\\\n", + "withColumnRenamed(\"count\",\"#patches\").sort(\"tract\").show() #groupBy twice, rename and sort" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## (ra,dec) footprint" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 70, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#are there some Nans?\n", + "import numpy as np\n", + "df.filter(df['ra'].contains(np.nan)).count()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No so lets do some basic statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------+------------------+-------------------+\n", + "|summary| ra| dec|\n", + "+-------+------------------+-------------------+\n", + "| count| 3183404| 3183404|\n", + "| mean| 54.83667395418485| -29.98888578265339|\n", + "| stddev|1.9042840926002418| 1.6088311401323847|\n", + "| min| 51.74733347101702|-32.612948240756936|\n", + "| max| 58.36326016759801|-26.954299775954787|\n", + "+-------+------------------+-------------------+\n", + "\n" + ] + } + ], + "source": [ + "df.describe(['ra','dec']).show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will project galaxies in a Healpix map. For that we define a pandas User Defined Function to call healpy ang2pix function" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import healpy as hp\n", + "from pyspark.sql.functions import pandas_udf, PandasUDFType\n", + "\n", + "nside=2048\n", + "#create the ang2pix user-defined-function. \n", + "#we use pandas_udf because they are more efficient\n", + "@pandas_udf('int', PandasUDFType.SCALAR)\n", + "def Ang2Pix(ra,dec):\n", + " return pd.Series(hp.ang2pix(nside,np.radians(90-dec),np.radians(ra)))" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------+-----------------+\n", + "|summary| count|\n", + "+-------+-----------------+\n", + "| count| 35845|\n", + "| mean|88.81026642488492|\n", + "| stddev|46.58134006940346|\n", + "| min| 1|\n", + "| max| 414|\n", + "+-------+-----------------+\n", + "\n" + ] + } + ], + "source": [ + "#add a column of healpix indices\n", + "df=df.withColumn(\"ipix\",Ang2Pix(\"ra\",\"dec\"))\n", + "#groupby indices and count the number of elements in each group\n", + "df_map=df.groupBy(\"ipix\").count()\n", + "#statistics per pixel\n", + "df_map.describe(['count']).show() " + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [], + "source": [ + "#back to python world\n", + "map_p=df_map.toPandas()" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [], + "source": [ + "#now data is reduced create the healpy map\n", + "counts = np.full(hp.nside2npix(nside),hp.UNSEEN)\n", + "counts[map_p['ipix'].values]=map_p['count'].values" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "plt.set_cmap('jet') #color-blind people should comment this line\n", + "\n", + "hp.mollview(counts)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "from the previous mean ra/dec and count statistics we can zoom on the center and perform a gnomonic projection" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAGrCAYAAAAxTLu9AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXl8FfXV/99DiAEJJE3YRNOwyqIYCJTww2gQFBBxwQ1RUVQoKO5aUNEyKKhQd0XwgVasCOKGCyAgaKiREssWUQgNSxBF1piwKBji/f1xzvnOvQFFK336UOfzeuU1NzNz587+PcvnfI4XiUQIESJEiBAhfgxV/tM7ECJEiBAh/u8jHCxChAgRIsRhEQ4WIUKECBHisAgHixAhQoQIcViEg0WIECFChDgswsEiRIgQIUIcFuFgESLE/yI8z/ut53l7PM+LO4LbPM3zvDVHanshQhwKXlhnEeJoged5lwG3AScDe4ENwAvA+Eh4I4cI8W9F6FmEOCrged4dwJPAn4D6QD1gMHAqcMx/cNdChPhVIBwsQvyfh+d5ScD9wA2RSOS1SCSyOyJYHolErohEIvt1vcme543zPG+W53m7Pc/L9zyvSdR2Onme9w/P88p02ilqWa7neaM8z1ukYaJ3PM9L9TzvJc/zdun6DX/Gth7wPO8j3Y95nufV1mUNPc+LeJ5XVf9P8Tzvec/zNnue97XneW8e4vgTPM8r9Tzv5Kh5dTzP+9bzvLqe53X2PO+LqGUNPM973fO87Z7nbfA872adX02/Y/tyr+d5BzzPq6X/j/I874lfer1C/HciHCxCHA34f0AC8NZPWLcvMBL4DbAWGA3yUgZmAU8BqcBjwCzP81KjvnsZ0A84HmgC/B14HkgBVgMjfsa2LgeuAeoins+dP7C/LwLHAifpuo9XXkEHwzf02AyXAgsjkci26HU9z6sCvAMU6HF0BW71PK97JBLZB/wDyNHVTwc2It6Z/b/wB/YzxK8c4WAR4mhAbWBHJBI5YDPUAyhVS/n0qHXfiEQiH+u6LwFtdP45QFEkEnkxEokciEQi04BC4Nyo7z4fiUTWRSKRMuBdYF0kEpmv23oVaPszt/XPSCTyLfBK1H44eJ53HHA2MDgSiXwdiUTKI5HID72spxI7WFyu8yrjd0CdSCRyfyQS+S4SiawHJiIDIchgkKOezSnIgJfjeV41/e6HP/D7IX7lqPqf3oEQIX4CdgK1Pc+ragNGJBLpBKDhl2ijZ0vU52+ARP3cALGio7ERsb4NW6M+f3uI/3/Otn5oP6KRBpREIpGvD7GsMt4Hqnuel6XbbgPMOMR66UADz/NKo+bFEQwCCxFPKBNYCbwH/BnoCKyNRCI7fsK+hPgVIvQsQhwN+DuwHzj/F2xjM/IijcZvgS//g9vaBKR4npd8uBUjkcj3iIfSF/EqZkYikd0/sM0NkUgkOeqvZiQS6anLFwHNgd5IGGuV7vs5hCGoED+CcLAI8X8ekUikFMlDPOt53sWe5yV6nlfF87w2QI2fuJnZwIme513ueV5Vz/P6AK2Amf/CLh2RbUUika+QcNeznuf9xvO8+EohtcqYCvQBruDQISiAj4FdnucN8zyvuud5cZ7nnex53u/0N78BlgJDCAaHRcAgwsEixI8gHCxCHBWIRCJjgduBocA2JET0HDAMedkd7vs7gV7AHUhYayjQ618JuxzJbSEJ9XIk57ENuPVHfjcfqS9pgAwyh1qnAsmdtEHqUHYAk4CkqNUWAvHIwGL/1wT+9i/sf4hfCcKivBAhQoQIcViEnkWIECFChDgswsEiRIgQIUIcFuFgESJEiBAhDotwsAgRIkSIEIfFUVmUN3LkyDArH+JXA9+viu8fOMT8tjpd/r+9S1H7EMH3Pf1cU+dm6v+/Hiau70d06v2H9+Rfw4gRIw6746FnESJEiBAhDouj0rM4EvD9P+r0/p/93ZojRAVi98h6R3SfQoSIhu9X00+n4Ps2t1inx0etl6PTn2fJ+34DRCMRfP/TmN/0/X0/fTuvjZAPS3RG+9yf+Ps//7d+eFsWbKgH7IrZru/XxPcPVez+r/6WSYRZwX5J1LIW+mnlUetl/BCOyjqLXxKG8n29sdkZNe+Zn7WNEZ19+XCN7s/V/g//Ti/w24/8eTsZ4j8C36+rn3YhUlAHhxXkBbtbP//4C8h/We+Bwrd1zkr9XhBSCn6zOr6/UedVtuFaAw3lY9VTZHpgQ9Ryk6k6Ht//ocLu6O021WmHqKXf6nShrhsjZvsj2xwMUyoZTXZ4rwEzi2KXtWgGheP1n106rafb2niIYz8eKVgH339QplVHiJIVSGkkwD5fP7TGvbybDpTp2seAlvI5+2yZmqzjM+N/9FiD61OCCP1CcP7e0elqIKvSMdUCPtLP5TqtftDAGH28hwo1/m8hDEOFCBEiRIgjgl+VZ+H7Nwb/tNDWA4W7CMRFX9H1fniE9wtHsPhlGYSX6bwzdTrV9/GfEGvy7q8lzPXQufc7/VG/10jdfrUoF7mDTk15IcS/E0FoZ5hOHyOwFM26PlvnA1TXaUOZJPeB0sd0Wwd7FmaJRh65gVZ3LAVgtetLpBZm8kXgNGHNys7EFDyChLH1OjoFTmgmH03L9sAqRI4K4JOofa2l351wiH27RD5k6/fyADsdtXX6xSr98HGUp/PDyVt/8QjI1n/MWjdZxC04taxHn78BgNuLxuMt08f3SjsWff7a14MT5GOvGa8CcB7mlcGAkikArEppzAecEbMfN1WfJB/2RXsyq6M+p8Tu+GTd6f4T8f3NBx+Xb15XsU6vR04YiLI7QK5OmxJ4d+ZFlBC8V2rpdFfUc2/hKsO3WFjrP+FhhJ5FiBAhQoQ4IvhVeBa+31s/1QQaHWINs0Ya6vRp/V5gOVpCnM4eH+TGDsL5Oj0beDjy55hl5/I2l3vdK/1eVeA8/Tw+Zsl/W1Ls/xJ8vzfknRI78zJgj34una4f+hBcVYtF67Jb+xDJkGs0cqMftW2JPW+LPAzAdm+PW3YS6/W39N6bA1ysCyeZ9bmMAJk6Va8muVawyELeJyB9ACGw5Es/weL1luwOPKn+kF0pt/AwYE6P9fHrrNP5iAQhwAFftxXcm+556OGBOezmoOn3bjx1LCu0X9SH27rJzDKcN+M9po/xy8Ex5fxjDgC5RZpbWIiI0wMs0N+eAcNVFvGYtrqNXF2nNrAj2roHed7m65f7yDTKsPcLA48fgMXDoIcu7K/TJ3YSJGOKdWpUYfPwACbrNIWDFetbE3gZ5vU01Ol8pFEih/R0/t0IPYsQIUKECHFE8F/tWQRxR8UJZ0dZkauC+e3VMlgbu7pYapVi1sCjHAMEjYtzo75iUe93IzJ3GpfR5JqvZOZkjS03PQXW2iFM0H39aeyTED8djk55gu/mVftUrM19n0oMu86pn7P9d7+VhZZHWBuB2mpo7TCvUzyASIPTaPelNJ3brZZlkdeKKlu+A6CiWBrifdIx8DKn3XetbEKNW5Jx99pFRRKHf/2mK4U9BLBFLeOH42U6KVjfWfFvEngFA2Ry/cTHGO/pP876bSjHGSllez89TrOqzROAgPZqOZFsYIp+zjPv5yXqRMQl2m6N+OqfEvsAAP/TvB8AA2dPIa9nZsyy7BHLKBwpfaNa3lYc+5tb4N4P7olZ/w8Vj1DrczkffmMOgv+GTL0L7VoDX+g1q295np04i769nlPz7BZDymviAZQsVjpyVUQwPhr9ywk8FWNS6rY4FIV+OoEnYvmSTIL80gmV1p9PQIculmP7X4wy/BTP4r+8zsJobOp67olalKwDRBuCxJzdtF8oLbFzVMgiV2+QUalsGi4Uvk+QAedcT56qVwB/lqzmL+wMwPqc+kEib4durzZRA9Ngnf78eo8Qh4O+IOy5nBJh3xP64NbXeadGLbeX6AVeEE3ooS+cXJl6KREyNdFZFJ8BQLXSEr7blwDA+KyrAbjhmclwX+zeZP/9PQCas4Y0NgGwktYADH16JN89LUbIE8/dLV+wwetWgvtF3z/1N61nyxh5e0YS5Tm/gUcpS5D4zOZ98kLeqi+yS3iVEVM0fFaoL9Zq5bBYX3jWoftTne7DhaTqfChxoO3xtwOfA5AZkWdrNwUU/U7OAy/Ldn8/5kUAbr/xMb6skBdgrZU6ANaAFmMlGRy5W/bH2yTfq9a0xJ2PZD34D+LOYH6jrgA8PdVICTDxcp1eKNPIPbKtY24vo3yKXrOHdeVqqbBPj3mJTvvru/EEKMmN7oar58BCcDagdo6HxToo1NapDUoDarl3R/13JOS4xYMbtZHh6cwG4FIvk4ANYEZIpcQ7YKFP3y92RqTV0gQm6mMEBqzRvCt3+j2yCMNQIUKECBHisPivDUNJsspccrWeptQKrMd7ddoe53F0eVx4fisqJClXMun4IPlmBkEuUbRHxV36Kz12UTM5lk5Z8szxgRVraB+hSuI3AHxf/0+V9jtMcB9p+KVaHJcIDCiPXfhmfOBZ5EbNX6HTyt2xLwashnNAMLvlIElQ70c8jPVPnuSWFd8iicscbUR3Dc+7ZWtoDsCEisFuXtIkCWk5T7c2AdTDyH78PXozI2bXBlQbTy1jhH8pnkWLbWpt5hCEsBRe00gQfjozdhmv4QzXOkPEm9hakk6Vv8ujd+85Ei6aTh82laUBsC9PreQ3g81Ehuj9bEzexgRGtXYF39tTbNba+7bTPOmfMbsRxwE6aSPElUpZHcAk54GMOceXFS0nfCp4zfT1cKieg1bEZ0V9bXDPZ5UT9rrVvn9Eu/Xa9Z9AkPQ2Bq15Hb0IoFThne9UZ1VM4huyH1yGN9yuvX3ZvJpC4Bv9fKxOyxHaDHCyvsM+jb5/J+tUlv0SzyJMcIcIESJEiCOC/zrPIlYjplIs8oTzAis/KrlX5QmxKOKqVsSsnpxayvZZmhSMykdlZohpsWy0uBtVBgTfL5+pcfJs3Y/FwYBd5UxZr0m9tRyrccaCs8XE8TuGkiBHGo4KOUpj3TsILMXiqBUr5xqXEOS3zBO1/++CjIzFABSMkWuXcueXpMbFtt9uxSr+qV7DuSoLYQnx83ibPylX9Walaa+jCZsQC/2J6ZqzsPxofQLvQr2N+Pa7KF8s91rkWr3HUiCiPAnvUV3frPjZSKdwIPVSyYyXvBb1fCTGHme1HiXsmyCewv8Mk4T1WppyJ48AcL8mZGqzE/+FMTHHbpnQLlfMZMG4c2OXPQpobWBlT4ed8Fib62NmzaA3T3ILAJmXB0V2b00VKu5ybx4QEFIBBhwQSzvpZPXQCgmKD3N1WqzTRIJ7Qve7SsO9fF9cI3bfvkAozxDcC+aVtSCINuj9ErnDc1Rf83q8CyOBR+PkWiwSsYuDEuWWoI/arku8b4mWezGK7sJ/uaDvV5rgHhH1WakSXCSTLQRhJUt+NYXv8+TG+F4fmPj2krzbvvS31DlHXPDtr+ugUR8200A+X3bwmPXg1bcB8EiFvAxKFh9P4gXbAehTQ7j6i+jEd8qocrz5EP87sDvezns1ggdYQ08pM7+kpLO+SC08o8/gKxnnMprh8s8FMjkmzgoBoJTfAPAVDejO3JifXsOJACynLa1YFbNsFj2DeZbMbqjTLUBTDT9skRdh+ctBUnWiDhADU2ClEnZO0XdJnnAxyG4DjJPPJZ1U76gF5GTIG3DhRxpjiRo4qw2WjX2ug9ggF0uCkfqc3cg4RxDJzpAE/latF1hFK74cIgPO8fm6Y2MAew9b6OhVnXaDdkjVe6cyUTRYktSepbQDYNHUToCcx+ZIuOoP+yQ48qdq37t9e7qqnKvVkYYAtGxZzJurpdZphl60F2pr2K/UC+4FvcbHVNvPPtvJaIakhR1tng0WMwEttvcnqmFSCOuHiGVab79eoE+BA1Klz60SXrr3cQnnjfJ6EliwxTJJJDAS7LrYQJXcCAqNWWVstVMxba9/B8IwVIgQIUKEOCz+a8JQTvfG+e7f4mokTlDK6hYCSzEqrOAsC7Us428Vz6I8N8q5bSM/mdEkn4LnOhKDhjLJ7v4eeflnyT/1xbqpk/4Vt/F4zOorac0HykusUFN3u/eiHsd/TnnyvxX+TPU2swmSxoYeBPeCRZIKcZbiQYnf+dBhuFhvy3e2dbMvTpUiCbuuZvkCXMVfAXgJ4Xt2Z64LQ85HaKGtVZEWYNRSdQd8nREtI2T1AdXEy4nGZ95M/FM5NDYDfWNneQ0i0Es9llHxsQujPK5Hr7jBza6pYZOW6gU9yxCXyP1GnzejBQO8qjGnlCJ9yFbgkt17Z4utWmO1egXbcOKwz6RdB8CNG/7MxEbCPa+u5+zKba/zTF1ZvsOLVUy4HilLATgQkbhbV+aTvUEICP0bPQvACy9puKsqxJ+pz3uxPO/xDXdRXqrV2RZGnk9g+FcK2TGFoNJb3yHrph1H466xN5v3/g6ui0wDYNK8m2KXPR4JwlxYiKkWdFbGgt2Pi3VaCqy1TLt5FtFqxpULRX4cYYI7RIgQIUIcERz1OYugSttoY2YKFkHTWOoaFxPQ3gwPQ8sPxepYvUeqTV2SGgKvo1QG3oJ1WSReKTmIb/YIxa1TPaH25T15lrPGUk6QOGVrPnGJS7PKHuIu0vNlG3WzTNkz9CiONFyvAIs1X0yQ4LTr2oaAJquexdXTxvPCH9TyLNZlktclMXc792kB5b2powFJXKfql81jKCWZm3kKEHopwF1IIng5bVyy2+btJ4HNHCc/YonWSUKI+P7hGsFtrdRMesCl+ZI4j/xR7s1LhhLkAVrrVPMBr2+AizSFd9zqdQA0o4CiNVpQZ9u3OPyVwfmw+7Ynszl+g+Qe8hrJs9KQYqZtlAR4r3ThzBrV9TUuIuV3lZJyg2DXPPFiat2iXo3mPL4ckMIIhOgxaZtY3nsbVHGeinkWC+t2cEV75gz6VlgLlOv19OuNlX3dmkncseIGWILeJbX3QFxVefaGtHsIgAllg5x2rHtDXkxwnxgsj9A/ap4+/41nbyFrQS4Ax+lFiQys7fJG7jpZrV17gnN/oFHw20bxt1yrBTXWAk2Vzz9Hcxe1T8G/8d9HlDnqB4tAjkOnLdSdLqwHa7WCu6O+/F8jcCXt3XwmHIOwJq67Wgj0f14jNI1uzd9yy2YuFXf6yiaTmLBfkmNt60WLv0HfW/5CHMKoOoMP3PwltAcCTnjkRYgo0eEuzbTvPqRkQIhfBrknmk0scHOKqsrLMTNLGW0F2SReLAP3fq3CfuG2692TkdhLliX2kRdmlhMYhIYaLvgjD5Cr4ach+jY4kTV86/jygqwK+e5LcZfHhGoAmrKWx7Uw4LoMuQ+f3yrdtXIen0OCqunNW3y+fGEfdOkqI4cvhCD8NpCvEh1Zqtu3K4hu8a5GJs7QETOOCoqQ8/E/feSFP7yPDIDbC35L365/AWDgBt3ocEAWc0qFbDi7aBkjOz4AwIWlIvFvA+HSS0+Difrj2gdob78q1Lq/Uq2L4guvhEmLNTyj78v5CWdyfqEeoPFVBkBeXXmALdfs64v8eIIWRaagU91bRmpEFBjGrpGQZK9zZBSdX9aVK5Kmxux3n6TpFCfJDiwkSgR0vkZqdGCtk/W5W2QEmEi6rrMN3kDKy2tW0+T+bwnUIvT981k31TD5kKCOw6rpo8dZ+2yDXA/gVgs/KeVtR1Una2+dD48kwjBUiBAhQoQ4LI7qBLfvd4AWWuFYqBZfC5WULszF6ajUVm+jlCA5pdWd3Ua85bZbqsP2J2Xiw49LuvGgZato5SiOGzSz3QARCqzNDueCm5t8/LwSyrOIQfx+WFZXMnmTNEYy3rO+wWEF95GGtTetv3q9C6kYOrGIiWWSwI1XBuyAuk+7MIhpx73aQsp009jEI1ojUZdA/NFCjUaJ3ko95102QcI+dq0LZnV0Hm7iCeK5HDgQR70k2Z6FSt5BEthWFQ44D+NvZafxWNLtMcdSTCMXDnscoXB/RJDxns05MesfyzeuBuRuHopZlsYmd65G7A1CG1uqCh30vITguVnQUvbTcqqmXg4EoRX1SFy9A8A092MA5A+ELAsZWleB1oAWVq/S5HerIbjQoh9wDOT/nrBKpJi0lRn4YwD1tLzq8r6rkiwbvbneU/yN0wD4516pizmxxhpqava6LcsBeGrrzXw/uRKdVqnTNCUQidT3S6SFxy4LMe3VsFtOeRB+qtSb6rRu88gbqeSY3KgF/XVqJAcTm5wM7LB3t9Fl6xKE46Um5af2Hg8T3CFChAgR4ojgqMxZBE3OoxUbtbqzUHMXt3Z2S+o8LrHFZL6m6BpN6BXL5FzecRbgJZoNTE4Sr2ANzXm4xAfg8RRJeA5gEouQ4qAztUTzWNV0+Run6ZJA7fP4P5YQr1bEzDZdAGjLCjLH6f4Osb1Us+kgbeQQ/yrcfaIO4pZxjdlinmVniZufmb6AeDvlGieflH8TeVmSwD22ronOCzo+V0DrQRKv76eU2Ke52VFfT1f9p7t4mLXqPjzxklRkx/fYFWyoWCZ7XqsDQOKt290i8yjmvST5ifOvmOY8l0U7O7n17kdM+C3TJe69os+JXK37ZHhTTfRJDGBDWUMAXk4SDu3j3EZdpV1W13t4Z5QQlR3TPTWEynt/2X0kbpFge/0mkq+ZwYVUZmn6KqDcGehsVcyWI7wDtCCbXX9Ui/seuRaRSAbLNEeY2Vaej6zlueQP6wxAK8tZgFSCA74pOvcLFrUUFjq3J2lE4ZJyRznt+4bkYSwpDzgvIrGGWOErd55Cp1SJELytTcq+fzmqotsYsbk6/RTnUdx9tVyTuK176L1PtLv+UiES9e3yPnR5LPPozBPMe/2swOuKLgTtr2rXJyuF9lPzJnYT1K1bJf6yqHn2Pjly7ZpDzyJEiBAhQhwWR6VnETRFfxcKjRFgrKigAK/lNKXELhUrsVW7VRT5Qqd9Nn0gIPIMnzieoeAqxDQZVeazOym2WOltziNNNf2tGKm9BmYfKHqIsc3EjB2gpUEli6u5gqReM96XjSThBn7LcdTzY/chxJGAylq0D+ZU6aF01Fy1FNNhY5ZY92b1tXh7o+umakVzt5UJQylrUK7bVgMNQCdT6q6jYTc1mb21Z8y88ivV6huAK/JkiYSK9yyuw4ld1wCwaK94DyYTczofcke+FJNdnRXbhhfghSg9JWP0GOMpOUoi+U9JUqT2oprhF7sAOJynlu7bBIV+5m2Y3MafkoZy0w6hN52iXkfHSwuCWjL3PUEucKr2m4i3mP76gAGUVqGMMCUcdZxRwH29xQvL1EhB/obOrBIGLHMicpy3vz+eyJMyz1PDu1wv9XfVqlDjbSnyW3uJJobegMwNsr2e2ltiSboc03LauufYcjQNUj9h4VylJjXU/e4R5Jf2ZMv9ElPgqWylBXq/QPBsPx53m25/j7vHjDVpRbnR2zIvc8/iOsFMIze5plzRaljm/V5I0BFLPArfTz9ifS6OysEiNgm8XOfVjV2pV3Czt2wXUFwbp0tl7Vy9Q4/lWyd3vFBJz0aDfDopeAhvKpOHtGoFeJpPyustg1D2YN3+eTC0SF4q43tKE5zBJS8EYm5Gm1uNc6PXdBG9oFEqgBgmuI8crJexr89Ph+EL+XiNZh0byiSB/dTeL2+cRQmS4GzRZqOrwD61RK7tJynCdR7FvSzXC7lc+0u3YpWjwtoLpy3LqVlPPhdUU3K8SWYXAgdiaZgQCFP+ebhUel83Riidd+x41q1TkSWPbD4d3MBQp7kYLxVUdQPA4zvlBdU8VQag49jMU0jS3l7031CdqVwBBC82O+65dGe2aogP4jn3+3WayHGauB93EGg7KYZGRYc9G6iNcdwVTrpRe5Jb4zlNcFMVHliiiXal3JY0qoa9iY1QUNglnQYVcm1r7RTDMV6bUe5ucQw1KgmufUN1ZjbqEjOvqr6sN3Mc29dpHVQTIa6U8hunD2dV3WyBPfv05T3HbeQgfHyf3F9vPtDdDUIzNBRYsKYjVzeX98ibLjuuiBK53PNE1CDhwk/WnU//r01QZBIjmGqDiITBrRf7kUAYhgoRIkSIEIfFUelZ/DjEjL/+infcHEsOznzpEtKvkGzcCrUKn+QW55Zfply+yxB12Nu3jSeiZ8jCUfvjEqijCbHsSWJ1PjRBTMab9z/l1C/PjIj1lp+SQUekKKxcLa74ZvDJ+0fsgEP8AJy3OVkmH7+eE2jsqLdxXNZmdiSkxn7xUzi2tXilnvUkUh5mXafDExTlAexQi28cgY5SwWj1KMx7iKZXHnBfBODqc8bzwnzxZI1A0WGYWIWdWORky+P0i835J0s0PGThsAe5h68rdWtK1X7RDfiKBUUSYrq4mYRZd1OT4cppNaqtUcSf5GbnfV/3ung4jS/6jO0LpPisR1cxr4tpyQi9r3crxXWkeQyAby21rXK5GZhos2N82jQqXGjOzMfts+gxVFZoNfh1mTkcFqcJUaVmM/HeTtog3krKhn3sPU9s4Mw7JfS0d3RgE89IECvfim037W1CYn25CKZt9RS3cAUvAUFUYvWszKA1wWviAbYcocvWtQVtWWstEKbTx4WnDW82786DyAnprGFC+81vRhzLMUqLLvqDknAGBDpkH5+tHrF5E0s2iPIsQGm0NpQV93YGwPcz8f1Ybbp/FaFnESJEiBAhDoujuigPopsdWYJYi1B69Sd+ssQdu6dKX4FSkt3obYmli3nNJTEtBnwFYkl1YpGzzBIq5Hu18srZmCMxRdN3clgNc/rn6N4EOgvHLxRTa1mOZLWb719DjcnigUwZJL021o0ME9xHGr6vyqFzoorX1KK3PiVWdAUw932NI6cFq89pJtezxyax8B5KC3p1fuNSuRxU7AdBEd5vKvXhXbK1PW3qLY+Zt5kGbNsqVqFpjRl6M8MVxp1YY42bb8lSU3Z1fTaAfM3QX64WcjGNHK3X8hMTGOTWt8JSy99Fy5FY/5YpLwx0ekg56lnkbjgbXxUrbtfawce0uLE1cJEVnymFtuCVZiz3xPvvb0LRVoi3Ab4cpP0vBqp7koDkReRABX1xBX3rh4op33iDZoj3w95Gqma7WZ6xXb+NZ22cJLstimDP+hLau/4bRgqYtrEfOemywwvHSaK72ZAC1z72ziQSfiJ6AAAgAElEQVQpmhw190F3jsyJqHaj7Pc+U60F/HQReLIcEMAOpSibp1iVCg4QBwT30m08wdOaZ/q4unoWJlfUlIC6a57FlfUC73WL5TjmY82RfqxA71fS/MiSO1ZWqW5YVSh/RpI9uXd2dmu3qSEiMlYbMTdK+8UekGuL9E4sIxAPsyT1hbBaE1eLssRl/5DTARiVNZweK+Slsrel3LArE1qzO0dunMwl6ha3ruIEDacPEpG5mb4kFkNBwSMJrWuwW+PMgNGy/SUJp9x0xTVBZbNR6ZNwVcM26NsgcVfJEwxJEXaChWzas8Sxjsy4eIdz+QBJqp7wgj64lnfdAcvaqwhcC0nQXpQ+nberCqd/VYXcX8lxss3RFcNpV0OaApnc+UpauxqA0ytkEDgj7gP3ErTGSxZuTaaU3+dL+OnuLKkFqKCqC9FW7he9k1RHELGOfy2vXsbanU1j1t/eKBHT6n5sf8wmpJbYKpY1nJexpIiMf+i8pTot02kKHP+qDhI2jgVtsYP1XiQgixhMl/xUqDFJJc+1hqnWpHISBsXunIUNX+YyWr5eLDMvygWgWfoqd57zr+zgvrOvUAayR1pIBb/rulmI03WyqvqpSVe4Qci04eqyzb1jLIRpLLSWS4uJbJX39Yk95aVzP/e56+nk6p9wBxClHRWlK9fQlmto9UA9gk56vwxhGCpEiBAhQhwWR7VnISEoGzUzdarZtsuC9cx1r81OllTIKN86TizGuZsucI1WTEq6sFk6AC2WbOTLAeoWzxCL572s7IP249mF4ieX5FRzzLZj94p106rqKjbHiRv/ZXvZ1ipacVZSZa30EP82mKx3Mi6MYtXU5+YvcJTFZzXe4RVFXFihzi0SrrIGVlU2RFiRInTnMdzlfuLaJeKN7morRIh34s51rUQbX/0ZEISttoxuzL3dJdGZyxlAbNhnZ57s5Hs5cq9d5vSp4drn5Hc2DprvPIvPD4iXtCauOZmvivd6wyXi/bxTpBqsz0HTR8TFMq2ppqx1FcSDNaN8Bu+74zVv6RaVWu/ER6Slyn6O5Q9unywYF1vrLigcqc/SCOH6v3s/nG3aURaisoY+C6Fco3zxGrEpnw3xqiruend3x1Vs5/aU89e4vUYDVsB7j8h561wmz1j8QjhpoSTA75kqoaPf8Q897gnkXDRHj0/Cc9HX4vMk3f+KQlpmSULbKuGHZozUczHCCS/csHYyABl9FvMH1fiy69SalXyrZyu6Uh7g1nYP8ZByq00ZYintKJqryW4rn2io02oEUY99Goqf4gVtWO3NfiCHIPoylV+C0LMIESJEiBCHxX9BgruSTtQELaR7GVLmi9dRskRG1oysxWyqkBjtgDgJcj6+8zZOS5WY73dqceUtEPXHK7tOPChxWZPdjNnkyz+V2lRSA7SXDVFtD9DQtasyXZTUwSW7xuaLIqo/59/XtOTXCktwpxzo4+aVfCr3Qk6GWJMLX+oRfMFupWinTz3UxDaS69i9Oar407R8VgPXxP52ZCWMSxGP1TScDH/kfpeANhTTkDaabB9dcW/MslrPl2PG7t57Avuuxhvfx/5odAsDE5u1Y5oHJl772WjJSEcnuK9RfrHlIpq6RE+QqF9Dc0YRu2/t9y9ho9LFX+Fg+NbPQve//HaIt1pXZX66BHdVApVVDcP70ziImlsrKehVYU2P3lsu3sRZD+ax9w5NcC+U/dreLZE6SySvYp5frc8lV7S3QRU+TBDV2R6TJN+4bEBLMierdpvmlUsaVSNbm3L053k9pIAJ0VbN/MqNziDwVHZTM4Z6DTBZb5xpZf14JEk8C6uYH8RzdDv7Q1nREtvGxo3W4ypVCve9jYJ7wAoH90UIuMmy/4fKi4aqsyFChAgR4ojgqM5ZQDBK+r7IFjBYYtH1Iztci8uSL8SaLPiiY1AMpcZmz9RZNFIJ0HZKz8jbIp7FlFkDGXOOUNfM4jqPt5mTJuZG4kcyYmdb7PUVYIZ+VmbNW0O7UU+tiY7bgo5txrbIzeosMyoL7IT4xTCqoD9Brn/9Ievd9V+4UTV8VhD0Jbg3mFY5WTWk3pQLuaeq0KW9+t8R+Ux6VjjvcTGUfCluxldKMz1p+HoajrZOeiLD2hzJnX3AGVQoTdI0guKocHTuVXFyr2WVyP3y0IBb6cksADJuVFpea3hvkFjTZsV27F7gFF1NhNkIYcwK+k3cfr+a+XGBRZy5Tb4wv66clwT2OyvZJETu4mFHPTWK7T0JD7Ic7WRXCZkQMJhMcio9UHaLN2aPKdPOw+X8fE1BHE9skR+A3wiytsXOO6tI3cFTocbKWI8ruWwPBe1FriUjvyhmWY0V35PcO5banDlpNWhq8i+NJHxwATNcO93LC6R97NIMuU65dOba92WHp3RRKjxNaKdugL1fGu4v5g8JfwLg4QrJd/WaKzmidj0/dPRlY+BNp09wT47SqRXl1SZ4e49SF62YwAMxdeV9diP8cqblUT9YBHgMgPgdQl1L4Dtq65ld31BXqQpV6stL4KkyGQS6J83lA00yPjFLqmRdJelaGJb/NADFWRJ+OJs5rBoobqLjOUe5hOUqcBavD8c6bx71Ipqk0ps+Z+/HbGwkL59XNGvX0JfK31Ab6t8AraDesqZxMG+HCkQe4OCnYHEgNFjlRh00iqMkqo3O2TeYPqfc0Lvb6huwJ3QvkxdBs6TVuhtCgq/LNoZpO92lerMdw3eucrvj+zJIbOwi98jd056goK/24bXqZ2sOBHT8nRohQ6FSt9agx3MWmFaljR/nMNvx/WfWjdVOas1KbkZu5ucRie1/lP0/rk+S58FCMYfDVmWZ1tOoW/wbBOfttzpVnTRqgK+1FL7SXleNg1aa4J6s2/KjQrxna7itoJmcn1Z1i4jXLrB7B2g46pbvyVDu+1sTpAvSeSUywL2cdb7b1gcD5D1Qj62OPm/T7s3edFpghme1Wv8+7mdml9jzN6LrWNdrfFOcDLo1Fn9PqxzRnzoQF6drytA5khE8oqSBx8skHHVF0lQyTpXsv9MXs77fXxAYvhY2XUsgSLhjun64EN+vJN71LyIMQ4UIESJEiMPiqPcsXILbl+rVcqOYpW52VpPDYqgs9vgVDVi5NbZ6ukNz1WOpejpUleG74UZJlvdKf9O1aLQm9A4bIN5yhhJd4LYU8Map5Wd5pmeCcMUIRupxrCDEkYXvawb6yigSx3z13CyvnSzEB4CCE9R6K8a5+99PUI9CNxU58Zjgqemv08HQvoWEHFyidUYe8WrC90uSkGM9VU2N4wAZl4ulO2mqZHerUhHIiat+Vfo2VQhIgkYVxfLZksILoG5fCW/uWqxJ254W4CEQNLBwxBJElwnYESexnhNZw4kaGrNq8NMrJKFaq6icr2giXxD2MK26LaWDxt4sQT+SEcTWogdYBpw3VP+xe385jio7p5FWxz+qC+/nIAXbVwBf87fmJBUTJL3N03LnB7BC6bcTxL3vPmEuKZOkgu387uJR5M0Vqv0prOSkfKHV3pclkYU++6cHRbh6Hpuwzh37HxuKMu6DyMGlz97OvJ6yIwOXiFtT/gZU36PXI0m3VQhn5EijNXv+N/UUD+MWnnKJ8L8miWL1LHpS8LtKHkVnnb7MwYWJJwBLKlPyJ3GkEHoWIUKECBHisDjqPQtuHR7zb8sMVYKcm8lF3WWUX89JsrA9fP+FWIp3tbvffSdR+w6sOkcSVqv2yjSx/g727JCKrez0XABmbryAKZdIEuvK2aqCaR0MNxMk9NSie3tnN85/X6yZz4ZIzPykbeud3IBZdiGOPHxfrEk/T72JzuXQVHMVUc1mCvqq9WaOaHQ7BJunqQhvZoSyppLgrvWiWo7bguuYPkm9gQ2wsXdUXwKCRkrN+Sf9p0qPCktO/43TGInQqB+rq01+Nknvg/d6ZnNWP7UYLb6/GTI2ifk7LU3i7n1T3wraGRhD07zgJcF3G18qB5/XJZPsfHle/pIliYST8ta7Y7K89eKJknPrTG4gP6FInxzoo5kzszJ6BZP7UE97zJ0wTBWXezyjHoV5S0PA19D/BlWpPRvYpcZxqlJ/2Q+eekl591gxriB70jI+u6NxzLwibx9ZSuEtV35vVpkc9+6karya1Stm/YcThnFXV+HAP58QcKJN42tRkkiAWGtUgD4VkiPIay/78yGnc3e+3DQnvSjntOSZaq44cE6O+EkNNfmdRb5TEb5L81mlFckk5mojpES9l8zDOJNAxsbu19xyXNcu9YL8yj1vfwGO6sHCnzPCfW75dx0kNsotW61jCa+/pA16jexwJmQ0Fx/Yktp38ifWqPbNOqUSJNQQLZ9+/JUnVLp5rbnkCFMEcJxmX6WF/CEE7rZyx+t78xxp5qOI6FAtr7vNbeN0xO2/1JcbJUxw/xtgEb7EqK6HlhysRhCSMg77CTgtI/eE6GBRrX4JtcboIGHy20D6PHmoI9oZznsU0rvKvEULJHHdilVu/dWVtJhqs9N9vsAodUZkSYP3XpTwVlY1GTRqTQu+23fnWwCUTK1GyqP7Yo/Z7sdmUDRMP15qq7SlVPXN3G8a2sDISyTMYjpTENz7qVH7a/XBMYOEQc9pvr6zekSawTka49Hwkg0MjabCu9L3ibN1AHlhA2SpMbYz6gce04fq9le18ZiFjfbCSYPlhXxSe5n+JdKXrOFywuxF/x0y4Hcuy+MCLfHvkCQbnUd3F8KyCvfezOCsxnLuR6632Jpgd8+arjI7Maq+YnyWhJOWZgmJYSx/YGaOjIa95smIWdhNKsTXRb1frJJ8Nj35Zo+EB10tSq5OEwmYUnavnhAPX7yt/wgT1Pdr/qiA4M9BGIYKESJEiBCHxdFfwb1CvQtNQFZ5QniNx1Tbz748yYJVy1bZ4B2/IaOJWA8F4yT0cP2Qxw5yracskP7czboWUBlpbOJmhD54/p3qpyt9b3HvDDqOKIiZxwIcRXDXYLFsP4lrTXahWET9WvyP/KZnMsKhZ3GkcKgK7qZx4rt/nK/p0tqRoHGNeRHJBHpFlQgRke+iro9SrF9t1sslPw3phdv5rIWEQ0yLyazZp7jZ1d68rAU/v6GUm1SDyRLdv98rsZPHatzOwLESUh021He/cbOubzVAZ20LkpvlGrKJV2XX97pkc9ZCWT4xRzzulqziXm1+9F7Z2QBsS5JnZq0j7AfS2itoEzMf4JP9p7BZK7hfIhZnExjCnaPmZ7XQD3r+NijVtZCgdMWfEKxfrh7RWA3xRqXx8ZVW6xut9h6cmIOy6eVZ1LCVVa8bTbku21z45xqlA7/GxS48eNV+Uer9JuFY8hGvxKqu+2iTtAvKZjI7SeJ9mzkOkIiBvVc6FioVukUdp1BtaM0nADzAH2O8EhBFiWmthbaMRkpd+PQAxE/R1q9tNPb4heydQDydnxqGCiu4Q4QIESLEEcHR71n4yp27TLyBRE0w3lrj8YOUHb+hutP3/1OUauYjiFnShHVAMNrfWzHaWaLWrrI3bzp12uI7NZiqVbOrfgutTNjROnXeD3sXaHHQNrHA8tIyHU0uRxvSbPRe1uMJPYsjDT9bvM/EjttJrCHWm1VV37DueVir53yyTKpNKGHfjWqeWs8CzXulTyykn1bfm8Vdkz3uem7THgaf0JqP1L0s5TdAUMS1iE6sWiLW7HHt5Z6rx7aoHhTCiVy0V6zftBqbqKu0W/Mi4jjAVYjVaw299lDT3aemXGr36s085aquzeItJdkVmv1FreVtKsq0lXrO+raK4gT2u94MtuzDV7s59dhVmriO1oiyzrZ+pYprEM8D4N2oeZb/sDz9pTthdwNi8Nj+wFPJPXizrrvD9fq9TzbDKRbzb1Rp5X5wedqfATiDD9xs8+QsEbP9xUTq9BN9qXxdlKU5q/Kh8IUqF38WkZzEuWsW8Pfmch1NdbYRG9y5t0ZHwwokStElY6bLmZ6mecw0NjlP5YXXhfRQ7UyJkoxMGsGwj+S7LtcWxZL1L/55WnO/iuZHvi90C19VnPcMFtbAgBcnkf6gMjWUJ86FEFHX17ME4AJIHS3JOhMPG99fElM3xz3lhL+sZP8DzqB4hQ4SJpn8ZLA/b2uC7jyTVf5jIGhmZzt77jLHDy9WKpWnDIhYKk6IIwJ90fepMZ1Z+oJ34YBiD6bErr7viZSgV7eJBSoLpSeznSyHPfi7qenkQ6zDWnP+ybUa1kjma0A6n4G8aPu1l/DjOcw+aHe7aqV39RrfuG0ZrGnOalodJEbYk1lBrYbCjKLmJRt5JEWMIkugJrLbyc6cpb/5EiKbM5fuLrl7mho0H5PF2AIZeLtkmO47vKuDxNmmfBDVenqXho7ejeQC8Ci3M9+TEOyhJM0NfWzEmRs0VfI1tOv3Bztt32pe3sJX1XFCCeirAf8e8KOa2gE0jwiD7J80d50AB5TIjeC9TVAhr9M6w/a4yn2Tktyg29z9IJzyhnz+TJd1aL6Q/zddXjIZfSSmOYRx3LFGWHApTSXsfFGG/ObXJDtmlLHmrmEyH+s1/p+LRGalchgQCEJUO4BRGqS7+ODVfinCMFSIECFChDgs/gs8CzXRLSG2NmqhGW0mY/OkWg1ARMssvH1BH9yC/pIFMxrj6Xzo5JmtteQFvBnQ9CzUpC5uqwRINQtGaYE0Jkh2W/vmdrhy1BuaGXHeFHvCMNSRgu9LJjXlgFhxXZnvwieO1HCAgDpbrNMTcLToB/8k1Ol7XpLmR8+X9adBkgi+mcDea1zM1ekSA9ij2/2aZHK3Cj17WD3h7Ef3YO6k5f/W1vdbjmW+ilhZWKnoOalvaDzoM7IqVU4DrF8j9UNjmovOWVtWcIu6uRYWs+0PSpnANNVb76LhloZscGKB5lFcoWnqtix3ITXbZgO+4soM0xwXTLzU5Y7xl8QsIh6orp5ZfmFnN9/aROdyMGxbn10S1Er07qs6Sg/qg7cf1Pimgz7P+RXBNiwBbj3Bo70K34gLS4RuPLH9lW6ZZ8u6wrI08fjbpkq0YWQJXK2LG2lEYYNWm+cDp6gYYqPexYD02H6lj9BvLcz9OWmsaH5izPG2WSNeY0bzxe6atVdB0z687KjKx2nBik1rsufgt/fJBHVE/waEnkWIECFChDgsjnrPwqWzBquJcYEkk1bTivRpC2NX7QpogaoX1bgoo71YLM/UlWY1g8r+7JaNTJQY7eg4qRTPmfcxCy8RCl3O+x/LSnfoyj2hXqz4pGjdvKifLf7dFlfpPT7/dp3p/9hBhviXUD3mv6lc4QrjqkdFzJtdIdTGojFiyWdcvZiCP0gg+O5XJc8w6QpxH9evawXqWVjsP44Kl4i0BPMeatKv3l9jft+os92ZywKTwlV0IN9J5M91ZdeCVqxyHtE3quHUluUkN5dciCWzd5LqkuSWQDXNJ4Abkeo3U7z9DaWOunuGKuQOTpL2qoN4jr9yFRAU4q2ktWunagqpA3bCQvWw7YjMcygHRut9Xl3TfMPMej8EMoHO5loUyoPqtwTfJMwtNt8XJmvC3JLk1k9pfNT2lmmuozNRXkwlCbaB86YwsL0mrXR9lsD8NHFdMu8Rz8KPTi1pkryRJd434/I0J02W/Z7V/xxHKPi4QMIIGzIaMep1cXPSL1JKa6lNkp23eyciY/57JnKReq+mamw5pg85nTpZlowVbD/wWydR7vs5Oq30DvwFCD2LECFChAhxWBzV1FkpurKuKkK2q7JFRJkqihPZmCXMqPQiZUU9SZA/0BTBxMEwUK0d04i5oEyYHvcn3e3kOIq1U/rAeVMOZlRF9xSxfIZpRO2PWmbUtrdwWjnumOb4P3zAIX4Rlo+QOPF5vOPyBhv0elalwll+hoyMxQfFig3H8i3t1Yw0yxsCWQjzXGqyxy2zNpkmKzOI59yytqrZOkStfgi0gYy59da6y4IdKJacVreub8VIboB4Lqa0nFWpSDCOCvdb5nVM5hpHyX3xud8DcNsgsXyX0J5VFULT7RknZvW3VHd9LN5UmtCYqjcF50BP40RlR33Jz4PfLPi8UyMAqcOiVrBndzXobpM7Vqad9ZkcswRO0dXsDLQE+uj2XBRAGYwb0+qQvkneD4vTxLPs+GpB7DMNUA0impv0WsYu8j8K+m/E3Rdc92MThc1WvUbgxe4uk/dTvSQ5gP3qbSbwnfMaj0W+V4+tzrMwXapoNtTYBVqQrN5JnYs+Z/vZWgE8xyoSv/1JTY9+FdTZgFUtaS0nKd0D0k/UQcLeBdGtkJWhOrAvLFPxGauzuDfJB4R3fWaJVL3+LeU7ADZ2q0P6NN2uvUd0QJg+HDpGZICyMMO1l08Dy6HZtALsXdK/vVDpXugoo5eJ34X45XAS5f2FR5iWvomeynq4dqFoBc3JyWF4hrQhWzZQ9Jd2T6xJwQsa89CK2Sr9hTeZXLuUa+LkhWmUy9t43IUQVikV+q2lfbmu3TNAUOlrD3pT1nIMcj995GoZPnH1GIO3ClvjtHpiqKQ3WcPGBZKsz+kqLRW/4ViWVMgbclicDC4DmETKNrl/TIzQqse3UZee++XYByYESWqrVL5hkBAtbNBaRSv6xE13+wtC+Z1cqdl46jDYaglkDcsM1PvcnxLUS0QH3ZRlSqV3Ln5R8NJNTY1aYBpZRmd9O1iUq9OiaLpupe32idLwcj8qnAO+fSYI01kNS91LttK4UC98v2B9z0g0UbpcAP4lweeKd2QwOHfAK6xBjJRNZdqXO2kP+0rlPtm4Q641e+Qd3SFj4UG05ylc6fbpuah+6QAzyi4IujnmyTtv59ZUuFFXmGMHuowjhTAMFSJEiBAhDouj3LPoQaDFrPB12oqgH7GiJK2a+5xyoVrwzSCzUEyXx1qINXaumi5Gl4VgZJ+4fyBz+lZq2qJnsc8C2FhpD/OmZpJ9qY7uIsPDzBZdXJGfJS4P1YTb9yNRn71Ky6pFff5p3oj/mrith6ru9KvqsgOHWPaFLjshWOY0udT9j/6eX02XbQE/OXZ7frIu2wF+VW38dLLOWwvc5esxHXkKcR+muwr+jTmBfLhdi+IJkrlcvzGgN6YPk0TkxlkqaNQjsP4GKV97Pl3JQsgOZh2e327aQfLzRrVNYxPvuPBpsG/Wg/n6euOpjKu7yjxLmh7Lt5wWJ8VyQ7uKB1OyoBqL60ooZUCFxDxrrReP+7ZmAX90ar4QOQqymrnE6bP5Ep/ZniWW8UhGuDCbbat13EpH7zWsH12fxup+ae7W2lfjjwETrPXfD77jazjH17Csb8V8cfCJRuNO0e/ldcsku6s8P5e3F+LJC82uI/65St+1bS+BPnqpdmpIeOcYSNVn9G3dR/N4Ot+x0XkP194fuAzru0jpfuOhcmx+16jfUMdssohG0P8SwLruClOZmUsvoVk7IU6kJQkltig/g5T2EpwrKRY37LoMuXYzKnozKE4Oarf2N7iSKWzVyIl5fOaJ7nszxSX8sy96T85VwVkB/fthSf37+z7mSCH0LEKECBEixGFxVCa4PW+87nRLIF3nWpBTdJ2mRh6h7zQpvLG2hgt7dnCJy44Xqjpsd3hmkFhalliKbjU5BBn5rTENBD0ojp+twgKbonZO8xivjpRk+SULA1kEayZDDqzvJpbLdxpTbjm3WJa9DI2fF9GA9TdJ0VX604VOEdPi34OZwMJZUk3W6xypDrpcC6ouH/mmszDefb4zADfzJEWtxeq8fqUkv6zoage1WThatvX34aJns9K1soHfDxTub7eJb/HBTik0Kx8gtlnmDMnp7KS2o5JOGyNKmV2GzeT9AjkPT2eIOXnTk2JOLr0l6Odgsd3Lx7zJd4PFozhGPZAj4WEsGSG/9c77l1LYJT1m2ThucIVphrfm9qVDd/EaP6+07LuKBG6OE7XX6OY3Z1WIddcpTs7B3J3d3bJRqUK7HrpJ7qXtaYluWZ2FkrwakPO0m9dPuda5qoAU7aFY0d/npLn70NCGFSSXyfa+TYwtzlpWtRwvIpTvFl5gbZoP42uLzu3LZd+qVN3DBCVhdIhku/VHI8eSu0lJq1FO7cZmSigZpjm9VIJ+GqbJVA1H/ijXorZ4lVY5LW8e4zyhDSdp7m8PNTlphWSnL28jnsXTVa/jzwckOD90kpxTl0e4A3Z11zazT2h5Xg682l6fx0J5HnM1pH9qKcSrt7HrQf1eXnlAc7eWqP0Jcp7R+RSAuGBeYaPg/rJz1ZNZADFadUajtuf5lIpPeDJOQiHW2+IYvnPaXvZs2T2x+oVMR5PlLp1WJZD5uNHID6n4/uF1on5KgvuoHCwCNlQOOEaIBYA66DSbDyPCQrlb2SWjuNeFfWzQaB3VsmWGZtAsWfkYt7tldbbJQ3hT3TGcF/WSADjrUXlhLr4jg45FMgh92UyE6CYxwOlLXb/kBQC2t090rmZambi51fbJ9pNrl5IcJ6EM0+S5jOmuctdurtEMd2ENqzK3sMhS2juxOwulDWcUf9Ua1Gv5i/y2jnL9eNGJ3BnXH4IBI3dvZwBuqPGsW2YvWNuvTTuDl+qTqTcDMIa72F0h53JAnAwSNjCs5BR3LMY0a8JaRj0nT66/5ecJoR0KVt3fUu+DVcPbuRLhZf3lbfEHxroQ0qKoZLOFhCz8uHGpxjYOwPVZMtjaQ30TT7m6A9OBir5H+pXJm8zkwjkZFy6yjombSOMMTddaxfTcItFHr9tsI+OQzK+FJc7gA04aKy/RL4fKvVbVK6GesX4si2wK1SngK3PINJYK8pqRMbbI7RMQkDa2wbvahLJUdZRKSXbXLKVQRomHWtzK3cO1M5QZQ4b+oBp6MY2iTGPJFbQbgzAJ3rpHBovzj4/amN0KlRiEABFNLt+cIhnr6CSxaWpdOe11Xu2rg8WrMw/eBxNRsNx9GSzOUmaUyotPbAkDtYaqZIGMJCmTdaTcSaAWYeGqqriajp2qc5XajCA5r2G0XWNkgNoQ15ClGtOtrkbrmSxgIKIhlhZjkQrb7qG+KuTilwAAACAASURBVEORG7XAiE92PXM5YoNFGIYKESJEiBCHxVGZ4LamNqJbadRZm4rpeH5kGrORfqfGb6/HVmf5Xb9BrPwbGj3qXEKjztr/t/Cks4RH15UehhfzumuhaKP9+jskpGReBcBylZluwjrnRRiW0o7X1F88N0ks0DeSpB/nXLo7C7dUq4EnMMiFwVqsEA+qZ5tZfKP7cXmltjMrae2a2tj+X8NkJ5V8JyKJa3z+VbTiH/t/B0CXBMlEJkc149lWo67b1lvTpfQ9s494U1ZXsH7PiWSmC7P9cW1Fm0yp89KsDmG31hyYhQq4uoVj+I5ugzR0+MsdC6jUTMZRL4HMO5WP+Qg8uOEBALz14mUvrN2DBzNui/1ubQlpDE1/0B2TeXaPRMndm67Yc1HXzEGppdvrJtJxhdwrM9uIudqWFc6iHBCtNQ2cyXxuVm/DrOUz+IDbhooX9vj7YrbHUD2MP6pUVKaBr5Z8kVrBGZcXobdpoGVm0lNRCenLSuSaeE/CwpGqXqDe2N1LnnAkBzs+X+mb/ue4kFOeFklnD4JlL4pX566BSj/1v+dZxu2XLz+mHs7tj0CRJpKbKd2VLrjQ7+4kscyfvlMLMhIIWpBa0KEZQXMqCyFZeGwJ5GlSPTuqzqPjZn2WNXw2MKpYOqVIPQo7Z0UErx+rq+qG8yw+Uo/ovMkEvYkUtebKfZXRrIhvmx2rm20IyHvC3jGmPru2QmJPA+ImBeq+DXW6A1irobfFFoY0t+2XI/QsQoQIESLEYXFU5iw8b6LudD04SN9drO0Okc/pqpo5lmBaRCc3Qr+2Qfhy9zS6jwfzxbIcluUDQaJ7xIyxDOgticeaUVbqPYhFV+dOyTPsHR2MuTU2SO+K9S3E23iRq1x/AtPpqc43ZG9SOq3GGI+pJSbYaal/4+O9so9da8j37uQRsjfo+mq57GoWT36crGe5BSvAWko719SmQs22NIKCNGsPWVWDwF+TzNv7JS5de58kJz9KyuZCDXxbC9Dj2BzTOAeCpN2ZzHeWsSmdAi72P1w9nYcRC3AkI7hD+15alSoEhVGNRh6iW86/iGNGSBz77uOfCKxOtaC79nzHne89hZJUrd9uPVvmiuppZve8mG0VVzTiqjjJB5kOFMDkfMn5nJslAeo2Wi0dDdNteo7BPInkdVLeFyt1WZeW7jxblfkFvAnA8/R327h7q3iDPevN5p3Zl8ZsP69nJtn9fqAIKwlnCX85K8XNNis2e5J+zzyNyQSW6/1R21FLu6CZmOEZm6IsV7PkLQcQCMe6mH7BP5q5fiCZF6rukvakGF4K31WTZ6k0Qc7t8WNLXAMi41xsH5pIQoU8CF/HyXrpd8p9++UjKe6YzEMfuuEZV/HtlBVst3si+m3AxqGaoF+43e12SY7mJx7cx65hmgC/R6z3jWN0/RHbsUvkRx2zr7mKcpX6io828rXQ2jmRl+ByMs+0uE4PdyWvcVHMsVhU4PI/vIneHri8+Vpgh3oW1dSzaAMsFpfsxyj2/7UJ7mCwiK4BNR/yG53Wwo9IRs9eph3Id278TvVHNzgfDh4pEynhPkkSIjlVGQgQsGKKaeQ6al07ThKX24dImGkbdTmxTDKMm5KCwWLEg5pZVGbFnCE59NgkfvDCNHlxW1Obk/da+5RgsOjDdPpukFBASSO5eWdzjnthW9jMXNYJDOIrjQmYhEAfpruQVOXwyHMMdiGtiqjI5JQC8f+r1JdsYLQwnnX1soG1LtvcwGRYQjvWbZX1RtWTMJ7tc2tWuvBcsb6BltDOscPylLHzU6QKfgi+L+f20YiE+vrxInVGyAC/fqRcnwuZ4Sqxty/VJ7gUN4g3664ig/mS8OyW9ZYLV0Y3qbFkt53vTixyRkqCVmsbsaAu25z0hoVHsrct48u68hKfoEl1G8y3Us8ZK0YsGMbDZLyvbx8V2ts+OpE6S1QawLQu7CXZgiA0pSGYvKmZrhFR7Yi8oG4cqyKa64kdJIBdqfFMipPR9vb3hUc1p0sOPcbqBmNVU1jVEVqZJmLHYP5OrTdyVdpR/bYtdDNaf3t4rlTZA/QolN/Z3iKKTTZbjrekpzwXvykJXoifp8jL/BHudAO1odcKibMta9OSzLEyaL03VFhfZ5bk8Y7uW3YkqGeqWk22XUuT1Bu7yfY3kebCsYbp9OH6YRLqdgNTVdDbO4AaL5HWsCZFmFQNKiQGtyiuEz2GyTH3GyOJ7mjD95nWQ+XLyVHbM0LDjmBPDD/WjztMcIcIESJEiCOCozTBra1U/RMQkwmC0kXxNm6NjHMWYDSsctZCJkN41lFmBySJT2jJ19mc46xf4zkPYJLTfVo/RKzTRiVCf60zdw/lmkSst19MujYJKwKKoPS74a9cRY8EsRgmubiIYGyNP7iWn+bB7KGms7hSlNjes9Es952VKp1mVuceajJTk/tPa7hjMw24RrNrFyJ+vyVox2+8ybUDtdqLtTubcn6GeE4mgT2DC5znYVXuxgOvyzZnXZswX/wJgUqPbdfCY5MqBjBKZd/NO2nAV67/eZ5rfv1LUBzzX53he5z1u9LJzQUeRXo7rdbe2AQKxY0v3qlxF22q1SQruKfMS63NDhdCMsznTBeOm6BV0kZLPp2/OYFCC+ttr5vI8TdK3c4Dwx4CYGSaWI7P5t/BDVkS2zE6NcCwLj4AY1S2oM6wQMSuZIyGT4ZFhR5MPl8l87NnL3Ny4jeuCGT5gRgvIU+Tt99GslxI1dBjxEIwuX8tebCQ00OR/+HFG0Wg0Ok7LYFUW99CXoYDOBLCUGOtr4AeM+RZmdNbdmqpt5C+Ebk/6uTLMc/uKff7lQded57T7EvkwWvFKno9Kp7EBXdMBaBXkvyfuWG124/OyRJy9LrAeUaGeFDO3/p76lPbhML0rWneXom3DCKxnk1O6gvBc2/eRBlOk8pCddNyJPzbd+FbtGgp5JVdqUqnpSELx4gIoWmOmWfxzMChAT3WGr4VQ8AcNv2vZkdMpjz0LEKECBEixGFxlHoWlmf5gsCzsDbqkmXb6rhsQaXt7TzmmocYtXUTaa6tqmkEWRJ8EBOclpDFpxfRyRVxGb5OEavi277HcvwSsQ7jJ0uiu+kza/msjWS9Tpoi+YxnGML6umIZTdgvVqdRVrPId/kU1xKT51x6JqJ5j6oVFcyKE9PFrP35riIo8CjMgv2AM5wnYSqi5rmsST/RKZ5aAu3h1GG0VXfG9ucypsfIcgNunT9vHOS8E0PD1A3Ocn7bVWcJ3oo7z51b89o6scjRnEHi974f28AoFsVRny3Zu5r4HWfJRxUfcgn0ZnBft7sBeGCeWO8zul3Ad+1iqdMbS1s4Ty6uo9wbcb3kuq6jifPgTCL8r1zl6MvmsfRhumunefzv5Ltp/xD+5XLa0qOrWHtTFkgCM6tsWZCC08TyhrSGANyTdZ+TObffeY2L3fWb00Us7nZdllLnUbG0zcKNKKN0VUpjThqmFXuWgAZ8s/JNCtxSf3VBHSKyrXJ5RB4zR4p7klGrKFhPL3vhM+l6fPJsvTjj90GRmhXlDQbffkvptHaFh+4ETymq8Zrm4xIOYn/+PpJInU1i5VvuyWEB7LpULHMrcmyRv9F5FLd6l8t6VlFeFedp7VLHLLUnQXJfRRoaj9viJNJLuqjXphTa84YC56gHp+u06guuh5VRbNtEfVbdunMqxA0bn2NNW3HPYtOoHtEmeW9RB5JxytXWAph970Il7a7K3vUvQehZhAgRIkSIw+IoZUOZa9GQgDpbiQ11QSOWzhAaZrvXA6bCjReJyWLeQe/9M9yy/QliYRo751i+cSqb5n00ZZ3rcTEhRawBy3F8RQPXpvKPZWK5/jOpMZ8oG6vvYC04+63EQAEatxUL6YblYu61YhVL1Io8RTmDTVjH+YUif1Au3Tt5POlGZ5Hb/vYpex2A+olfOFVLw9+btHXW/W08HrNsFa0cPXM1gWbTqr2tYtZ7skYg4zukTALUyUkSJL2Zp13+xdhWi+jkWng2LJAczt0ZYqY+VzGIkk+PB+DeDDE7N5HGC2tE+TeyW8gZ57Z/xf3mSxVXAPBBnOhTPcsNdFbr0dhFD3MXi3YKzbBBqnhVll8ZwrO8hFiWD2yT67M3qQrjEoT2albbVfzVyXCYdWoeTxuWOwkV29Y6mvKCelwtdoqO06uplzgJFfPW7L55OOVWemveqEWhxKmHtfAZM84HYNoQiWMbu20ntXlQTfMTNU+yjbqOgfP4hbKs/H2It1C1UTLtsdhMUJBmBWZVgwK9ZtZrRT1XfxwM18/xyl7iRZw+0mc9xVtuuL+YGn/8Pua7XKjTGjgL2uixJ0V6OYkda/yTUaSuQ3eCvIcFClKhXBxQVpaK62W5MYBLVkRprwHb2wRMqWP3y7tgeUIbsrNjKcXvav7w7DG4/MzeNmI7L6j2PedN1RVNomUPAcPM6LdGsFoCrneVeSwV8OVU8Y6fUi9/VJlPvDDJqZkmz8NDNcTTXcOJPF0oLtf4FsF7xfqHWC8Ue9d0XpMfBFU0zyewRktf6LTELbFc76HwX9z8yEIOJ0Cyig0rNa/Ou/IktGYm16tMWnxnSbR+V5HEeNVHehPR3Tkj4QOO3yYndH5deVkY1783M7jxfUn8Teki4QJrWgOB/s/rWo39AWfQRF3HeL0Z6RlUORdMUG76jCIaz5ZBokjDHbd5IhE9N3KdGyQ6RHU7M/n02xfKMZ2Ss5LsbfIArK4r+/takrxkWrGKzU3kJW4vnLt42Olh2XlJ1ATdC69fT6+LXo2Z9x0J3FdD+IsWWnmKmymYKyf62e795TedclmgD9XvCwn71M9Y7waLzIzYeoWmcWv5GBksbLCbvrMP3ZrrgKphgOGMpl2Z0FdNHM8G7q7Md9+1waI7c7kq9a+6iVj96up8wwOzZZAY31Pug6v2v+jCSkbrXUJ7R2W2sFuavmGjRQft3E6edAM3DJDBfkCqvKXPXzGPNW0CqXOAISmyTk12u98yTbMxK3xeHSL6RRaes+2fv2Ie89tIPMfCepU/A8TfQhCSsESqhZla4pLHkX4cDEvGTpaJPwbKTdVcT+PiIRl0nFQQ87Uam78PNKeej93k3rpVuOUNqTw/wZOOeheUzeS5pOv0J2fFrL9wfQdy5okRV9heQlotNmykY6kIJi6ddxoA87t1ZWg/HVVMz0kHwDr372HjG0JpXV9N4jTZQ5eRq89jZz0f1rubt2GnhshSx8mgd94YAnFQK5f5FCpFUinSy9ssuq+4SpVfMGEqH1bI+8R00VokfUrxvoYAnFkjliiwiTRXX2H3d8qmfdyeoFKPOvgvvEe17x6BYJBoqNNvCcJOnXWaG/UrPzxY/BSEYagQIUKECHFYHKVhqNdlp5MvcvPqfy3Ju2PVDWvFKkfXNHxNsgvBTEf6Gv+Fa1wi2ZK1hg84wym5pqwIKIjPtBELYIZ6J/abZ/CBS6amb5Aq0L806su1S1Q/2TzkO2CXJgVrqTro5T3Fg7mKv7pwkRXKfUcCU4vkNy0ROeeNHLqWSZL06STxOqxCeyATnYdjxXNNWOsK9SwsdjNSnW5eFgSe07m8zVSuiDkfCex3SWCjcBqN+ET+yQLNZhp1NidjjrPEKxctmZItQKcaQfGjhX+WbhIrcmNa0KTotyVyTjekSAgvus+1XevXuNgVYVpy39ZbSjvmPqrHqs5p97Q3nRaThbSe5QZXrGmkgHNKhICQn5LhemM3ikoeXlwh6w2Pkxatq2jFaKQQ0VSHG08Tb3Ji3ysdBXWRZkTrsZVxGrayMJftzyI6ufNnIZi/cC0nzTCJWUUj2KUe9vj9sYuGNSJIMj8YtcAS0Hp7+5p0zgTOM2qrJcTTCDSV7HsWcoKgANB0vaIjoebkTYJl98Q2VM2cIbzaib2vZOA83QH1FBYO6EBtrTA7aZ4c72fdGvMBEoq88XdK+VUNrL19q1DjI/EQtneRB67OsD1BwtqKA02VtzVB0rmdTvOjllsy/gC8q6G0sy38pDWc77aEs/VVM36reKw3FEx21PGayUqx/SLqfZQnXnLiBXJP96kRFM9Zn/Ps55YFIUOD9QH/SwRGqWeRpzTw7HyC+J21d/oSYwj4vrmdByMsygsRIkSIEEcER2nOQlE6EU4WSYqLo/SFAP7IA3REgokW+63Ot85aPkbj9+toSlO1ls0CnIRssztzXdJzcxvJLLdmJVdVSEx8a5yM4hZjvn3JePLaZwIwudE1wW+bdn5lvX9w6p59egaWhVFgregrWp4jorHLZEpdsswSix8i1ng9tsboM4GovpqlfUBlOex3OrHI6V2dSp6egwEUrRGJi/Obi2d0Oh86r8SUVk3z6SUup7p6WH0zRNZiHU3cubc4rOljfbPnWJrUE+/HLKnLP3qTW0+VnAKSwiF973amzZJcDCnigVhOqZTfuONcFSX9Yha/kRhM6uFFgmC9NSCau+ICRraR4jez5EdMHuvolIsXZMScxxn0drkCoyx/yGnOe+yUFezj3/R6WG5rWt/z3XbsGKyo0c4jwLv00O3KvTe9og+t4sSzWL5T7rVLUl+lTW/xhKe+ql7nYHhMPYrOuq3Olruoi9NAMkrnquegld2b2hfC6KznNSDId9iuTcDpF41tpM2H7rGMNExWb62/ptpWTYL0fWKPzk8QDzT5nlKnTWYe+bbe8hwNXDGFi7vJibd7vilrHQ2+XzeRvHhx4e9Jy9akgnAH2JWtuk3nlbv9qVNLPc+qBL1eDfb/27DLEtaqQfXefriosspMVzjb6meNSjxZJqcmwMytQin+/+y9fXhV1bXv/wkkGk2ANCEkFTARSAmKBiGHcEssqVChBRULFihYUosHrHik1vpS7GV7xFYttVix4BU1VBC4yvGloYIFG2rwAA2UKAqUF5OCNrwkDRg0GiD3jzHGnHPv7Tn2dw6/+zzcZ49/VrLW2mvNNddcc47vePmOh1wlImjIknZ3PyalVEvzqqheJWHdgycLRLMgkkHUuHD3AWrhqJt+EVM2S9CKS+zTGfvf7x/A/5irlpBSI+XqhkcU5tiu40zJWWmG8sWP8mB7OQBFRbIwhJm0li1sWcHNZPAK8sFa5M7bXOoI28xkYpPBSNbyAbJIuOp4NU0cv1wG5sqO8qF31C9owid+wk9bL1B40zeKGPJatFMQcFEi9Tuzo3ZP5TeuHXWH8gEljdslX+I7hRKFcj3PsxAxP1kbbfK6YesLZA8S/HrqlBIJdjxA7Q2CwSPPCrb+1SkZnE1Lu5M6VgZXThexJXyb5/jZE0rQo4mrv5jzfX64T8M+lipqVT/dlW9U8kajTG59smQR2PmDgQz7pdQW39BPJkDnixsFBbcp79JNOiH3gey7onH3Mia7/jDTjU2wzzGZ2tXyTANHyyK3rb4EWuX9TO0rzsGfI4vBEDaxf6tUH0zJ16CHA11Ieke/Act+Df3iOmlkD5V2Han/ojs0Jk/GTeXu6xnYN9qBv+2BUsbNlpk3thJfzaFirsiR8WRZwM1kSD4NcNMxmRSf7CLZz7edepRLO8pMZu9afiPx+JYBb9UUwZMRmoktVnkAyRDe+m1Z0DY8JxP4vcx1ba57WBbgpGHSPwNLqqk7JQEFd3WUwIUP6eRMZL9WW9AbN8lqVPbkq05JMJNnBs08hji7V62XEKxXh5cBElwxRfNI7Jv6I19xJHrfOSZcS61rMjk2XiKpGpNlcVjUHgHgoQ0RqoeJwlb6TQkAueLfXuONh6VNh9SslKOLTMkPq9j8U7m/RTltesgrCEOGyxht+zdIiUlh2KOmrYJJ0PRcatSxf6LGvdvdx8QT3lqX6Svw6TqWXihmqGlpi5mlJvLfqhl65g1P+cCDmMUu6a12NHHfm7er3gNVxkjVPLPWVxBTFEQi/zE5Z8IMlZCEJCQhCTkjclYiC6vBHYkcJjJWTTQZomFYAZ6uNDpkceQK9UTthYN/Ewdqj+sUurXiGBp/+icpePPj/6F5CMn4MoUmNbgkyWGvrok6tGH3KB/erNo4iwCJiKTXXVpbu+ASjPpo4BuqEf9AVYejOLrjDv3FRnD63jSvPag20++NbexcJhqUi6k3UslKPJOn+ez74I2Oti2LviYAs3Q8VCRBD91nj7kJNBLWo1vbFhMP9fcG54+NObYAT60c9PG1O8WcY2aau10MqKdptpyHfOqcKa1hsyCu1MImWucqBbe131JxkvHoweid0/EcOxbNOCZop/WpAiMygmus0O0UfB9aRGzYp7bPwEd+cE+7V5XfVzpc6nlXL/mau1bqXEF+rS9lumcqGipo+t1G6auLs96ldpkgrX6To/MKdq4cSOoovcY6vUZxG5k9RNu0nBc0beHm2Y/wzLFyOX+mnr8LN24d+qoLbmIWGOvHkPvJvocWiKnt5P7P7vtXGg9FF7jO6NpMTkexFrx3LB+AC7r8zSGWxlMyiCw89ZeNP+DyLIl3PaoD7AI+4JA6fvesVdSgY2/woA1svqsMgKcfErvbqaTl3KQhs6s0x2NcId7Rr+Vm2xUEb2mCfmom6t4o/fnFtA+cOfS1WjU/vgB59yv/2CpNkiiWeevePG9qnrtbTMKT+j7N8vU3RvVH9nBFuD+60EfFWpzHLuL5olpfJRKJZpz4LEkgi4QkJCEJScgZkbMUWWjoLF+DMnXozIs+Z9Kgp1meZKtyaE+2SiqmKq4DrAShOcc6B1tLfFEH6r3X+MuZtm+aZgZoRK7XrvbiNXnTMHfgsy/tPPvdSeKJdBvw2rFpDIXE08AYmsjHOSqdFPvfpmw6HnWobWlnjwoMRezCa72mQacH9zcNJl+3GXgtvEy3FcFxa7/5Q7sSj9oKYcqzkoJs4a8fcIFzUNfpxQxZjGQtS9dLMEJqsWrN8zO9pmXvx7Thk3g0Y+15Cf/+6oJj9izlwfOB9Ous6Gfp8OAJTu/QbCzrq/AeZbq1GIyDONQz8OeKLNeW+nGi7elQqsiyLo3UwhhUcBKnradMkfd5cda7LtkvQy9iSIOD+H4xjf8oPpQ0XT+pFaJg5s7eT8OjWsnH7OyLg/ND/05sn1ofjMcjbQ3NzZ26n4b79LrWHkWdA4dWs+0+GYi5cyRM9jLe5rVHVTPX99hvwjb2NsrN2nbpt2ptqIJrpws6NQd6DYM8e7DKFVkS+v36vtG0r4rRmdfjQoIjM4gTxfNcra9iSxO8qvseOykPnNXxKHs0OGLgcH3HW0s9s/EV+pErqkrpepzZWRJJYL7E5qMZnJ8u/qiW7erbDI0ZVUQ/eyj2fqr2QEzZ5UgkHkQkkEVCEpKQhCTkjMhZGjqrJU77dHaai0W3lGSJz2IzJV6jbLAIqfPxjxza8UwlsvNSgmNlsinXOpwNwSHTXE3b2oGz+Tob/Rq8Nm7VqyrxWvuDwXkg9m/TFAYEx0wLt3uW4bVf80vYfarw2qChj1H+uNOqfqKNaMVrg6ZBz8SjgJcUcU1J8e0wLfkOvOg9e41T30zLJd52b8jPbN01+PcTVMY19OCihBozOJDVUx9PEtLMXv0GV4BRLRQHW0NYQXU2QPrT+uVev7tDhWrwVYoOKokuVRlKfzwa1FDK0wfToE9b9HVXpHj0ZW00H8oO4r+8Snzfl4uWf7pFIltyS/bT8IBq4wEaM+27YZUcOzTOJ329fejSqPMH3uXR9bb1pb49bjyrYqnvomFrUB90cbA1v4T1T2rwd0h7gV7bxnx6sN/GbUxF5G1bSx3gb9go979s6NveCJAqfdyTA44rqXSo+nc2in9n6vSFDl2Zj6t+dSFFo6PD6CuXSKxwr6nvOIoOK7XL8/6ZI8qtFdmD47F+X7dJ6grt1AQRTQqM3CYv+Zz7jrnQWpfA2Az1P1FEEV3Ghp5ZBxyazu8oWYLbuZyTJ7X6ZJ2eaH09D9+nNiZWtMEYnbtcpbw+WMv/s2iof0TOUjPUu9roLTC2XP7UDy3vGRmJHTnlMj+3JFnPZeH5jo1h7ThGh+3FYpT7QZ+C6EN9CAi8YuQofnJZqk1ckOQnBjMNZQC71BQ0X2G0/a4Gb/qwyaUVtwhlLpah2rSmux84M3Vrk+NS0AhIvwiFpRft49Pf5470mcANu3v59tgCEprAfNK0iE2IhQSFV4J91rbimGMv4Cf1wOF51RvCDWXFqQ7Q04UEW4jm2lMSBtp8NIPTi/VLt2cPK0faIhqaC23xtL5b8xltC02H1n/WB0Pw/EvhYpCvfxcG588LfgOu3wv61rJnmTpa6/RYD/wY6BG97VDszVy5w3WB2NrLP6tuB9+/gZpD8jBu4bOhP4R4Jzx4hcTMRZv8/l6jddF/QMKNKQ7aG5znzGxmyqrUhSccD9YHyUGbYtowuO+GOPLKlsps8ibIAx465hdDC/GuX6Ydni+bgqG17FktfRsZLXGykdUPMW60fHwvHhKCrL45Qvj4Ceey73l5kXs0T6RPJiTp+7f5NbIeIr4CAOAZ6i4eChHlnqpol2z0HA6xZaMwGbiw6yUXOnNc6kSZYz5tFc94Vk4jH58QxoaWTWJyunb4cl5ea8kuRD0nDxKtuIJ8a3X6t33/XYEdYt76z0oUJ8xQCUlIQhKSkDMiZyWy8El5c7xjOMbk0GHiCU7nGp+TUcC24dU3453MwbunzAylmTuhiWW+bmfgtNKiOaJe1f6T3rw//PqZcgC+v08TpNYluSIyUSGcphWaOco02GK8A3VAzDEgfZok8bQszoZZjURJuYQdRp65i8jjD0Uf24vTLKe8IU5kY6GtoZjaJ+QZSqcLrN/cWEJbpaCelDGCgi7I+oD6R1WTG6PjxpLzthMdXgqCHPL171DDBdHATTs1DTQMvbXQ4pHVzlm7/ZTEMTbVSJhnh/wTnH5JNWhDbRODa8QVr8f3d6hkleqzbEry55upydpm7y4/eIY63W7CaXmZlYr8tnfnykECB1ti2GH/ToZLqDM5cumF3nQZnd8FE9uhzEv39QAAIABJREFUTtum90kd00TrDkXEOj5y799Pwz515CbrA1aKWSJzxvs0jdHw2PLg2fKDZwCPqE76v9Nn6ZirzqbfyG16WMwjo/kd82vviWqHCwApx5sr7Zny8SgmFqW24vvAUFAyflwZ0p2Bf982ZuyzLg6eZVdwTozJy6RgZK2j+jepOPx92jQUNmV0cMAQsGa0Ny73h1K0r37ZKgmgv3PZdD7Y4Mf8lLInxEyeOU3GiSU33rX5MdL7Sz+np4kJti9/YcMSefheUxXl/UBQXvv7SSSN1nFr/R0iRlcQCSJl9/F5kkAWCUlIQhKSkDMiZyWySEp6SBpdfBeT/iQ8RMv3CRdTBw01+5ecXzknWGWSEas0gdPyNC2egTg/xguqppituxWv1ZjmEkbh2rHi4Hxi/h7SBqWhwxzRXHcZiqmTTap61/qDKxFhNskw5NNs7uXBfa1NB9XJmpviNWhzuKfjHNZTRgqyMAqII5svpKhE1LFOrp7FOa65ZgfvmXOAvoit1ziiGlaqj2MFMF/vX6XPuw6vqVobrchOHV7u1TG4Nwn6RI/HSb2fYfkqCYE2x7nJ/tpLfICAaasZ+L6ye4bvRxXulAofPtw2V/1GhjbCSp3mg6jQbYBgU2bINdrGdo5zWE6Z+qTjQLoohp/nzRNfdo7L1kisv4xovwvAojY4qR150iuAuX3Vf/EDfQflwW9cUpZu84NjudrHR5PindLmL0nFfwf629zJ+2l4Qu5VMF2pWrYWuXukFGp/lGt/hk5tGwd98GPYxqh9R614/0dzsK2MOW8UDsXc85gQNf3scaWmKcS99w4zNHChIc1fw/rDUM0UmDVI+Mh++Qul5R2GZ6I1lt00HMusEzNY3AZK+OzlFly52TYPMni3i/hAD6vT2UrQbqHEcWAZ1Ql4qpj9PxFE8Ze58v4LrodGZcZdp6d/DJTbWFdus7sKIzycJIM4EokdWF7+ny1+FInIG49UwvKtMpGUDoqOiiDHO0QrNZM7WmyyTob5ukhYZNUsHfRrOsd/TMnEOwp14GVOe5+mTQr1FwS/sUnfBupRoFRjK6rrZBvmBBiE7Bqcb78NWYZjIXiYPW7jwj7MTbgJ74KRQih4nzKifZ8KF0Fima4NG3sxeKh8KWU5Uuv5FMkumsS2Tw2ZDkDehH00ntDsW13sWlqyvbnAPvTAJGTBCM5JCZAuY7bXUFkYlj9wo5uwM/g7ANuW6IMPID53YAd+0rS+MlPIFNwi1fZgZ7to9G8Rs0vLQY1rt34PneD61bQd7ez/r5I/Bz8jfbaO4S6i6G+FwtVtC8TILmud075yojL4LYLsZ9QReumFUfdMzfiQki4SvWd1mZ9aNZOGo0HEEjCr6GfMf1RMQqW3xWSBp+LHRLJOOCW17GlRR7sesyJYlRuvd/1SOtqbJodNV66vJ/SFpuMW2bYeWk07jI7ytbFEWvAmPjO3WqDDCKIz34Gbn32Ehc23yz9V+K3e3i0SJnfjnLunt6uJMhc/7vJ1Gygvxg235ofikB717Q2uUJQzn72GS7U6rpN0Z6PiMmJBoF1NU5szixgyWxbUNyeJ0rDVcaB7+nwrG/BnLucarej4d/0WP+VcNqzSB9V3sVg5sM5LijhDuj3Sq8B72n9/KAwd47Ehff81SZihEpKQhCQkIZ8rZyWycFKzEJKFebV6pWhQpRNEC1p0bDqtGVZwx3Iq+gA79W/VVu5I8dqjLuJtLwRapym9yiWU/exfOVKrmp86vHpNV+fTdZfEZ1MuTfEaXZhlXqfbrmp+Omq4N8g0NY23IvidoZlR+PA4k2Q1/+Ti0UzIyVMuf5qJySiRB5dsYMs+YYz9Xm9hlX3q4EyHHl5pFBbMc1M/4YI00YisNrmZnBrHZ7mQP6fI7MWjH3Mw2jNVQv0D2rnWx7lADzFlGeNu+NttW/ViYUimIRY1mXRYcYLT1apRlkcfYzsewZnGWEg0WgNaXsj2X0b/6GM0E595PheHJD9xXNJw86BHAFyJVitqdJQsxx5rTs2WkwH7cMw9k5O9WcKVY03HI0mVxSemeSR8W/Qxaog2CwF76i/2HFmxvF7bcX0Qlm917Z4i7R6ZtpZVS9S2uFfHn5nkQpRgbR2DRwg2lg21hfxlOoYWXnq7/6bMhBmaCW2s2Zi4G2/KfDCwrKTGnG+BEEdh2PZo7qTvP/cLirXxN3ZTqLAeF21vNPARq7udBhEtP3B9ZjTaA/hQO/725Qt5ZNLNUcesmFifQPs3U/BavsyV48R+9nq9mIw7J0UACdWxmaxOt5EghDeyWNpdPu3X/+38CpMEskhIQhKSkIR8rpyVyCISsWZ/02sxGuZqvEFf7vIm209qqGWyaQ4p+DTNV3Q7zmv8YfgdQI/AadfD+KIgs7+EvW18TEpi9kupkwNBVnDBHHUA/lOR16ojul0K7DAeKtXG+iiiqME7bc3vkYzXks3B2kJ8sp9pjv2BNRpWW6h+hAy8nVZLG1gJ1UFs5WTvjoSSPuaIC488N9XX6HzxmMQ2duqizoIwJNGciHW6DZ2+9iym+Ya/M2S3F4eOTmu/TJn9JEtrhf+pQw+t1KNa4enmtOgQS+D0ijTfL2YbN5kFlGq/HwyCDkxTtd+F1XUtZPqzWFbNDr4I96y16/UFZcDCvYJex0x4nlAqV17PwAnyMr6oSG1PRjZH7lPEan4YzZZuqc5mQ6FmhK0J2m3a+kzRpFvWZDsfQXV9GQD9pkqoa4h4DjSK07RtXedop7i2DRBNfUjMM6XDnkrxcaSP1xK35MfxPzlkNDbYZ2Ohgc9ODjSJ6PazEl/tPS3AJ3sa6jAEXY1HryE3l40/u6e2eeD0anaRB3jU9uuKH/praHGyyHawaWeOxiS0KSJNuRq+2i5+CRsSh+lGp/2CEK4/pu//G/C8VpkaUyMXvrr4fwPyLc7fJy/8nt6egTZZnd15eYJAZmu/RHZBuZWtHar7wmGm4HrJ6pshImH05uv9r8pZulic1C1Qo1EtrTKZW43tdQynaYU6m10VNV8YCa1vzTyiyd/AD9RZQWSHypGqC50Zot/SOvnDTCH5ODhsETB7+gSV1myiTEUilsAPcoPJycT7o8qJpnsGMZ3YefYB2EhdA2gta7eAtOCec365DMpevX1dbKtgZxQJ6WkfCmUK0NIgX+TA3hvZtlvsFa0N8sXkDtWInJt6eU+bfcAv4Sc+6yOTMrwJxEZhHXQYJQvC3BxZeX964sfuw55eJMWBnjg03Z3vclgsxn8dfpIw00SY/zEvxd8fpB/dpKvb/sSTRdbptgfxNOdH8aZCVVr6FW3jvEESmZelL8byLbIn/NX1Y0HfWt9WfX8dFgdRPAANkDtSTIIN+b18uxzdS5Jvt4nWeN55cKDfZ88ZEhZauy0KSt9X6h0B1bv238CSav7SX5Sxbmli2tj2g1If1WRj2JSdynaYqG2zBWI70bkw4e/uJZ4csxCvINk1yvBBC7E0963AGr1ndXC+LTSxOSz4iKQRFr4UmhmVdzSyH4LUCQBSLJCtFxxNEoX0WLs4lm/cs9xFS71fLvPQu1zsql/+pFgCEayoWUlhlUSnAdf0FkW2mQwWbrw96p5Ji0UxmFOaxErRM7QUGESuh1W6YHSbVC9/rP7vLxImCTNUQhKSkIQk5HPlrEQWJpHIIiLzFbJpGN7vpsry/wEXeIeYCzJ7hWh0AbAKZo6TP01LNW2/T/C3aV7F8L+HXw3At5ZKbWV3n5N8NvHcvZZprSilOMVf195AGAJdoVsjbdsbXNfgfDUeSZh2ZRrvfLymvUYLIlMSFDsSDeby3lLhZeGq28kca/RoIk11F0jeAzjtenv65aR0FSQ3MktowyvXq9miB17zs77qj0cWZhIyLf8kMKU9qj0dpp3g0hxR5Z5gumtL9mgJKd2NlKfM6CoP2kSa1zDt2U4G9wycmFHb4JmA6BwEEAes9WXsF7IXr8HbOYXBecE9zISQg2jhzzVK/feMrGb3Pl3o6gycqcQIBB0J4NRqGc/gMqh3bh4YjzYfhIJn1PzZXBR1DVqCtoUOYnNsV+hWzW2tMzL9seCZWirEEe8c8qEpqYroe1YkRRfOAhmr2m/OVPvdIt+uRUbIqAhwOx4pWr+/hEP/mQ9qxvw6tSLMxX0P/X6rffXdgb5NMaHw2wpLmbRGSsvWPyvPVD/tPPJeFzNbaEp9Ur/Rm57UHUYb9zqMU1DCBnEsPz1sEjdulL8zN4hmf/mQ7Xx0rrzbiUgJ5p8UCsK4gWfZgoTuPqgMEs18wWeNK3p7Z7x8KzkdYYnGPVi+RdYkGKdW9svVKjB09Ma4cOT/qiSQRUISkpCEJORz5azM4PbcUBf4nXPFCXrvbMnCHMF6ytarVj3CVIHDeBXQCIc74ez7/ctka9pEMtElC0FQRET/Ns01CDtMzdciNRVq0FyBD3E1R3QF3s5rzTH7d8hxZfeM4MM7K3SbgbfvmnZtvz2J1/jWqE9nSmePnNR2PXiCJJAdpSv7H5cM0cwZoql92NyJThnioGt6QbmYyk5w+oW06HaESVeGKKpkc8+TPltpXqMY87+T9Rtixfwk5/ERF/C3qGPn8gmD2ApE8+2AhACb43b3MUEd47usYuluGQvX9l0edf5mSmiojaf6dklh5bJJH3DEHWpZrBq0jYO64HfmCD9IfDjtGvw4iWXjnU984mVh8B2azX2U35eeq36Pu4MQW+tvG38hCsoVDb0oT/qudm0wsAzV9v+MtoWhqNtjjqUTXaTLRLX1zHtVy1cOquxX/+oSKV/UakL9b93nvy8zpc8M/rcxamimvM3xW9n4Tsk/7pIqHbIYK/fMfOl9mu5QlGE+i6XeN7TnBkUxilaunFNJsY6vOzTSJXtXC0i0OHuU3OGN9kncuFnHk2Vrm2+zAHhU/x6m28Ow4ceD9Vbe3JDxiXT4vefKpGBjHzzf1jf0Bm/wFdd/L68WX0j7D2RsNO6HLMtHPKbbbgi9OtC0SZwzWf0+JjIxwQ2VkIQkJCEJ+b8kZyWySEqKaKO7Y+p1VbuoPMN+5xNstn1DoqB+e5/EC0QhESc9IIYV1KlqPYCDqp700X0teIRgCkOVbsfjNS6zE6YSz3dzEI8CNHKk4EXVfJYV+TA/QxbN7+IMpJZ4l4zX8kxDs2iXinZv561QhSHkabr3M965cQ5ZGHGP4Ji1YwhxiWDuvELi/DWZM97nOx0FSRgCMAbOS3mLJ1SNtLojb3Ep1ynEqtJOm6C2XdAwTaAr4gN6keu4WkOg5x0T5FLcZSu9tSFLNkoClKsnsK8nY3oLDDP/RzNf4MhqDVlV7T61699pbdYxsUv729BhH3x/h9xJ1reGQI7iEYuNBWOHfXU/DcsU4RgCTMUjEdOuh0h7Bvf+I8M1Ume9VtI5h0+dH2P/eq03sRTSF3iG2KjrHw3aEfqPbExalFDIDRXWUwmfA3wo8dJgn465vPtlwORwyDG6Gjr8EQ9TgiD+8awC4IZahcYvEDeGUhYcp22A+vqCqEULab88S/xuf1UOJYCGtdq35pupIl70fV15SyXrb7o6+lgm8KL+rSio+s6BPIf4nH4954ey7z6JNDtATyY2SR2WJPUfRG6CyJ3698O6HQAYC4eOnUeekzH6dzLYF0ON+wfKaDkh49AVQVJpXZcZz+gMfvzN98fOFLI4qx3cUOAWCSc/1G0XGDT93ZjzHwj+Pi/YmknKih7pBBWGHZq5YBbehGAfmMHouXi+G5NW/MucH+y3j0xDLfesVHicTDSRISC5GHXy5xBdNI4G7TBHp00MK5LiF7SjMPBVWfgct5JNBl0l1BPg6JPyoEfWXhjvFAyI+Jzpw46FJg1dXJoautPz/gPaDPkQTinUfoOvcKnWNzd+nGK28oLatcY72xpMOyVevsc7SjmyZ7kBkAnTqotN6CLv7HeMdotFwVBZgK0W84ddvVd7T70U2Rmc9yYZowXq79l3GQA9uxygbxcJcayMqAPfvuMaogv5gCygM4LjIO8nlrLbQkrBT2Q2AZYHx6wfNcDg7729Fzlds3sPBJOjkwHQ8pIuEjY27ac98IuXBU5sx4+xKt2GuTE2XkPTqI3lkJDPurVMNuECb2wBc5AJayRr49uu10y9o4nWl9R8WyGbtrs7+77XRW7wnA1s2S32npqTWuypWcyjv+5bzkMj7QFFsoqOsm21Dti66Fufz8f+mY/5/e88JAvOJYclNPwUye65nr5Pw2O3i1lq+YCevJJ5FQDXXiqp3CX+UkTMCv468Av9W9Nmpn8i4eAvnnsd80/8AICL02Teep7ruaJBB1RzTAhyBX7BTo3ZQty3eCYkYYZKSEISkpCEfK6cpWYoa3SS00DaX9aVV33VTAGNWCTpW6bSpeBLqBqKyERoysGrHR/r9jgUi7PUaZFTIGWiZnUb62jI+WRmGtPoQmQZmKE6LDoR9Uyna4IiPrEZselAlYX8KgrqT7zpwK6fj3d+VwXtsNBD0w7td3t90SPLgD+y+kJXt9gKI9GMRzOmEZtjHkgvUxPIGtFunxs31h3borrWn5UB+BYed8e66YvayqCoTGMQptmXlALUzpugN7/20Cuco9nlxV3EzLH9xAA+0VKVfbKibRo9OcAAhW1mhgJc8uEmVaH7n/BU6C07VFMPE/ZMDGXVEaexUoZ/97Fa/gq8VmjXGAOZZeKs/ahFUK+V3ASvOQ/rq6yv9cMZlrc+6lkaNnteotRCGd/np8tYbnqpuzvmEENFO8yPsT4YithLfHGiZvzYDNGGjrVxQwXOGt/RdBY5U6PRbn/AF/mufrQWsPDw1RL+nrq0idaJ+n3a9zYeH0yh/Zny4HHHKvCRhhnn59QBcAEfOC6r2t3ayCritW9Fe6lzm/j4NZ007JN8BX7/b6XuegA9Tx2gc6MEDdR3kzFhqDYsnpQ5Qz7a9uchSeuPRW7yXRWxiHBlUfj+db9wx6y2fIly2d2wzKNrGy8dMjRhc2xadDE1kLGUr3/b0E8FKirk3pF6/iNJOLgTkpCEJCQhZ0TOfmShfEzt23RhNB92AXClnvVPIbIwMYQxENimf+fr1v7vhFP9MpQtciZ+JbfQObPZLsWjAdPaR+HDZMuDfSbF8iiZ+aLBNN3R3dslLcRxL6D2fbhMt+24yizFZdHt2Bs8irl0WiB1hob1LjUaB//urWjU6XWiwfabvM0dO3Qqx/3dNCXQUMHb3luIT24bIRQR4P0GZsMuo8r5J6zuSD7vOQf43H3iX/pe78d59BOhUJ1xrhjdH1HG4G67P+R/9RX/xW/4DiDJmKZZmqY2VDW/VbunkNdXa2islZdXMLKWxlPip8npKOjtJB2d/8IoGJyd/yAeXZiWPR4Yr335QlCa1XwVBrBsbNThx4694xHElf40LTIrp5EPj8nLdUjhYDeeypsKwG0nJG7z5MmOtK7RdztEk9s26ZjfgfeFheHOdk89NvgWGVNbNg7zSHVNcI61uzg4Nj76vMizklQW2fwQM0vEu2vv9aHGu5mWJT6ohbVKZWH9VBm0sUy3B/HjKuyfcnm+MXkCbXOCZNun6kV975Unfqf9j17if2fvTNHQsRG+yFdnvSbfhN9fJ8iim1636MU97pnrewqyyDsgSPpnPWdxz2KFayGtiUWOmx9zPihQAXFVUPsn8UHeywMOIV6mHCNf4i88cUqepal/zHc3hXi6n1DCZMwKS8wVp4/RJYXy/7CDW+1LZTk8dr94pxbwPQBmLn5Kjp3Cw8pirald8wjRju1Y0aBqNypzcAtHszrH+8yOjwjSj2rw8g1s2Tws+tiQdj+BWJRTQDxHgxxr2q6DoZT4ql4Z4BYJFxf/IY5BzM6zQRnW8TaTUwu0LtCJRBcv44bav/ESTienBfeCnbsHeshbpcfm4Rc8myxsHb4DT+P+c40+Wn0hjRoZcL7SnVtUTyc+ZLp6XN9A6NHf5jKmacrqzb2F4+tTzuGZc6UK4mEtzHQPP7NOYLWaMoxOfQnfYYhG2zSsFrPMH0fLML+z732sVCad9FL50P924gLHc2QmsK4cZUpvacfSmWpDCE1J1t9hjXbjQLIvqhS/SJg1oVy3dTiFYViRmpWWeQ3iyr4yAKxA0tYTvmhO00HpgzF5L/G9B56TZ9Ea2a2VmQycrEEM+4YSJWOIr8DYgB/LxcSLKQJ1wT5zmJpiElDy93pWzHevINFF15b4PBdnssl609V+d2ImzZn4hcPG7Qx8/2nf5s3eRf0+MZd+pN/xU8vETjh48gZolgVy/0FdJMa2QYMumjET6+Ud/8y+Uln9Gy1YYzl87afSkP13Sifcep2vaW9jNO9Zzcf5MT7gwxaLsKqeBd30gie1pvdN2t9mnu3JAZfn8Ri3alP/7syHBTs1WtICYdbhF9QwH8amLnvHL4HNdZ+1SPx/kYQZKiEJSUhCEvK5cpaaoRZqo292Wkf7MtXsTKG6Bgf5kubp6ZUVeOe1maE6E+/gNkgbhKw6hziwbrZsTSsL6ZRN094b8z+QMkQd43M7RxcxCs9vxoe9blKkM7EAVmgmdmFnf/5Jhc09gqJHEG0SMm1pAPT7g3Ll1Orzqrac0vU4bbs6+/sDHYpP+LKUlmMADr67+sYVaf6YhfCqY3TquIXu0KeqtZsZ6osOj0u4K8Dl/Jnz3PsRyec991uD6WbS+ip/YJnGvm/4kXRkr5+/48vp1mrYq2rDqaOaGN1FsmNX1RtXJ56uXNt988hH3KGFy9RUYkgwVM7M6V2I1+jMZNOHIATWPYzIeDwqKZdNwbhan108V9/rLGnXb18czkNqB7OywekDjtByVAZRJE9ssSuZwM7HB0Y9i7vnZymVpW0wP6Y+vI3lHcQXfqrGm1Trgv327Io2CkbWukPmrP2yUrCuZKLTzM3BvXyJlEYmFd9/iiI6zD3B6Rk6xmwsvwADh4rmb+YtQ2EZ/J2Xd2syg6KTXkPfYf9WRRlhMTDg5gmPMDVJVP8SmzseAL6rf2u29rbCfg7FlB5Qa4OiiCPXpZN9g17QLLb7cQYQV5BoEhxSsJUj6SEsH3Ct6yvL1Zid+RMANjOY11dJh6eOUBPy3oAZwt6Pja9qPHo0xDfRDkAkYgRW8ZJwcCckIQlJSELOiJzdyKL0Zud4bN+iC6OVn2iCE/9T1sL01EXBr03FMp9FH3yBQvtxSAVrqMMczJmA2rFjC6qsw2suxkTbFTJHKH+NcdbMaoMK1ejMxmlaeS4eWRjqGILXUiPBMbNVmtZrIZFT8JplyK6qj5VeLrbWrLRGd6h+t6iUA/uKFmI+AICXv66aWn+iQmUBOlQLwjgn9RNad6jWo6VROZpC5oBoVtDckfvdbw0h7L/vEv+cWhKznzLi7rxpIJmL5BpXdPwjAG+cEh9H0wvd4xk15/nn7NemSGqlvsOJOJR01WzR4s7jI6eVVu4WJJKa20RrtT6LcTZN0/E1kzgNek/9xb6kqNncT+K1ZHu35veowmuFqgleO26572eizx/8oveF9SuRZzpwoictD2pYr73jauLrhli29kToN0H7w9BHIeQNV4f/EoUUNs664pP4zP81oN0zERf6d9xrkPgqDp8Qf8qANBmYH3CBS8I8HwmgeJVR5NeKyu38NWu10ZV4jTgslxvL0FyG16a12XeW+Czlh3dLKK7zuS326LdotsCTS9WJ/Ozyf3bHLF7k+OMpdC7Q5zMeqHPxDLCagPl+Txkj3Zc3eURh5/eHI+XyYjKOyceYcjNgn5z27aaLBE0eoCfXPyG+qpLpVYD49362RAmgYhmGj+L7qjLYn69bs2js2OMORSLP8R9JAlkkJCEJSUhCzoicpciiURq9NIunJn8bgBt/ocZAC7Q4F6eZJW3XZ1xcgfdZhEl5prJYWKohjU6gFeRQzUhUGo2uMmQxU9WFjCyfrGT+g6V4KojPSse3JLfAPpz75H69u1A7/Jw7mXJC4IYlIZ2uS3OIxqJnDA3s5GLeQ8q0XsR7gET6mL/gS+wGJPoIpMymJTndlyZa2e2vLeTqq6TkY+XjavtPDp7ZntPaPwqfCJjrw0jTZ8ZwFVmUywpgvp63VJWafLz9265bQ3yZTIuOGYG3Y9u1ygOqE7O/W1/PxfmZZs2WiKr5G+9x1f5MGmp7eW0tNl5wANE2YhOz5du9y4NjimbSN2lfDMn20Ud2/dTguta39rxdce+6qEQeeN+J3rSM0T41LTwM17X2GPLai+s3l9i3fpR7znt+KXGeP/tRoMla21yCqUcWU0eKP+ptLpW6C8AHx74IeOqVtYzkXC3de45+mKP5HSs0Is2qxm14YpR/buuDMNE0tlphftC2Kt1qhFrqrCZX8vcrCBJdtWoKueOivylDtdfxIufpt33nchvccGSS3DT7WwrRgxza4zGm/85BNNLThZP0eT9lJFLzZZ46qAbwZ88hpdQiyy8Sn8WkPS+zsEBCoSvUYfJvfJNvImRT5uMzH82SlTeTPkbHkyWORvBI0vyZbCMSMYj7H8v/u6GzxZpxGSTobvih0AEPq1AiwcPB+e6jPoTHiybdAevYt2KOZeEXF7tgZ1xK6UwzVVzjf2IvyyBiBvGFdMbjFxCDiwb1K6DhUgn5bDCz0nA/IAaXCFb+c/LlLoPcuJWsbOeWZcPInizhq0aw1nKikyMj+1IXWSwuR0w9+9ddwlcnyCBeq6mlPzzya1KP6YIawlyz4mmfptd4Om+7vpVcJR9aKrOjf1el2wie7yZf99UF97HzyvB9aX1brttkvJN5VJDfYJNtdcz5i3Dmwfnr73G3aj4ms6GrKw5+srWJwMZaLl4RsHYdxU+odu8G/PvWubBlgfZFMf6Z7ZwavMJg1zWzx70wpkS4pz/gi76NlkMT1j6PLVlqi9IUXIjqhrHaoGbftp+t1UVCw3079DlBWc4foi7VQie69T6stxJlpBMtzqSzZK/kIi3ZdLP7zbW3iBL320PyjdTkFNPp/HvlAAAgAElEQVRHM7ydhEqU9UGVbmvw78/Cdg8SZ5bpNcebwk6dUtI93Qwe57mkvtB3W9TvDtCTxa9JqCpddOcJ+FBXqOwCGRMLfwo3C5EAnTWKvkKDFA7180082i5z050vLuDp62ThMMf437iAf8mUENz1maJZDddB3bPggOvH+xCF7VAwV1kI+sv1arcMQpajGBnM/F1hB18FPncd+IckYYZKSEISkpCEfK6cncjCpNlzGVm4pMn7d2bSXTOW2fWK7u2HNz+Z4zrMsDPsa/h/L4I8wKu9x0GTw5y5apckHDHlIq91mkZXgdecLFwydMqaScXQxwycltqhv2DfG0897cwPJt/IWs3LLaJlGP2zyZbSL7vwREtkIw2e2iesrS/vEI0nc4g4jjPHv8+bJ6QIi3N6D2mn9egX9Ln0wovwWozyYbWUqbbcB4qWK5fUGlWv6/CZzWsCBzGINmzaoTnNJ+IT3kyz30t8EqQ5XqcE54XZ7q6gUMzvNr0HM0QjTh8iiKh32j5ql0h7Px2lXEytuPdRNFWf6QF9poC7q9dy0WabT2XQtEbHib3rTUHbTAwBjMInVFUF+2YFf4eSCuuOCU3p5C7ipPwLff2YCc1VxPxt18/3hwqK1DFPEVcWSaNeXyuNzRsq6vs5fMIX9AZvaULdF2h2pkzLjj+fjx2ijQwS82zNIBn8H/BFOmmkxXU5wvl9gJ4uPNolIlpbU2FmX8n4XrBG+b2n4cecvc9kvGlKTZ+Oph3/3axqkbDqn/a+nbF9ZZD9uFaSPdP7yPu/Iy0gdtNo7uPfTeGiLB1QagG4+SrQ6F8fnq9y11Cik/CAyuuu5CM1YY9Wr/e7XOyysx/bLn21YcBgfaRTDklc0yTMtR92SeEbHeW36/RBU7Ug2WXD32bLPgn0sLLDjIYjD1hDHgMgEjkzqAISyCIhCUlIQhLyD8jZiSxqxGk77k8beeimCAC/f1Ly7S1crfsvmuC3ev696lOYu5B4mo8SfDeY6mBJeUE9C6dObAz2WWKfaAss/RDK1Ek+T0PWygrik5tq8D4LU2wsmWYMjJks9mlLQjtFMvtO9AagZZNo8qXDf8/APKG1WLpVQnlT+whq6pf3Ns+oFbVhozKR9mgjtavUbWg9Ke3+tFW0xJ5pB1yNgfrNor6lFjb5BCAz5Zv2Dl4bNM6kMERXJfeu/TRoXQB33FDCSeJLeq7BO8lNi9yL9wMYAjHfxRS8HdvaEyafhUEGALkXufa2pEs/1qZmu7adrg4SDNXfUftgSK8KuX/YT8Oj8kwu5De8lznmxwY/MsCq77jXbZ7Vdn+dXqMuON9+q+26eegjPHOsHIDfNAoHVn7We+zZFVPgaBfR/GAxYomUHwbFvizh0cK77f0XlNSy+pgkzV3XRTp++e4buaqv+LZsvCRzKg7Vm1/louChzlFH9zQWs4jpUee70+pgQfOd0cfW4fsvmK1cQata1aT1/Q8u2sCW9eKfsLDgHz/+S4bdok5eRSkt26XvfjT1YaY8L0WY6p/0JWs/aBRUUPhNZWo9Buqm4d07opv91kbctND1OUHmp0h2tCbWV0fp6vrBZCtC5fJnLmcyy6KOdX62jUPlgjbePXVx1LEtq4bRa5yMo/37gmPOP9vGmZazMxrqPNoBxn28lBduEiI5ZbHm/W/IBLeXPgzrLs7upIGWwb0S77AOM4XDbO5QOgX79gT7zdlt1+in2+P+/K5fl+1c4osIdcVHFdkxc0wOkEkWfFZqJz50GahXDhKzwdtcRk/+qsdlNrdBWXcon245suBZzembi/yEYw7olK6aUb6uczyJXY8TFOeIvWxLQcB3FXNeOCmmT9HoDP0QS4f+3h1z1OdL9OMOK/HZIjANP8mF1f/MXFWhW1tI6vCLhF2jK35Bsj417qFReA6fUhkTRb03eyprW4SC9SElX/uoJsicD7PtQSYxMzHaez0atNueVRfdDmNP0DFZKLvbtut11wTnW3t1chz4YrVzcJoTtLL2egYXKenf14P3Y223tpkJZ4y/XvooeU8D0rZT/fjXiBJTDHIhe+pfow59hT+6iLvVQT10WyzM6R0uRvkajWdjc98hP4DOV/JKGy9Rju4K3Y7Fv08XANDmzDGtdfrt6jkpQ47TMVk+qpwu8p1+0HgBpzT4YnqOMPgtXCKZ+b+Y+n0Wa6LSw/wIkKzzc0/JRN/5X3XSXYwnKbXaTabw3YAzO5ev/rV7BFss7dlDKvNBaou2SLKQCPETNfUlc4rHEdOxOcmXrNTggaPQ6xZdLLYGSot9jwfFkR6JtPKPSCLPIiEJSUhCEnJG5Ow0Q6n0Zp/zMR95UvC3wbxhT2xBI0MhZ5X+kYx3cBsayAuuaPkVpjrmEM9S+z4eUcSatPbizFWh6cnCnM1kEva6KVqx1M/AkY2ihR/JbXea4uvrxRGZPfyvDlG8SzREvTrnFXGAAg8UfdvtP9xFnN39uogmOHf3T+XAAMlaBq+N1a8s5OQEjT0MHcoWSmrttGfqAy3zVENUx+4BelL/QGHUPgeTJ+I1RtUoxxUtZdVe9aabZlxMPAVzUDAoztxSjO9LCz0100wlLts9RTVTAJKVEOAWgRaNZLFzlZgg2zaJ5t9hvGYD701z95/1jOZqXOfDcJ3jOsM/l7NXqInq9N40Toc04dbGvcHf4NDVto2lrub09Kwn9FGu93WnrW9DogKTKt0OwZnKTJOv3vE1jyRsHA5QFL49yRX+MXPKILby45XiIB44QV7kBFZyzyGJ/+6ZI6jDNOMcDvN6vYRiW6GmnJzDrjzprSvlBXUok74tzqlhyzJFSeXank1B2zK0bStSaO0hiKJgsjrrX5JM6LbUzmQMF0RkBZfys95ziObZE2KJsMCFjMAWakW2LuBvDFy/kyj5MUQ0OCNSEH2IB0BjALiAvwEwmWX8XOGmobG99HG5H2Y1MERROLvePXN1gYy9zknbyGmX488YWZWOiStvqeT1WnnxDv3u7ewDZobYHJVwcCckIQlJSEL+L8rZ6bO4TnwWf3jJr5plmlVZfaWsyn35C9nDRW1KOqzPuGNhcBXzUxz/jH1Wm7UOr9a8r9uPic7+tn0gkCFG7cgo885Pty+4bCy3UT70elVtkbVqi1yM53/KEBtqbt4BGm5V57Fq+aVTxUdQvfprpJZKG0u6iN/m7VOXOm6qgl+qNrZaWU5b8RrlCu3TgDW1w1jVqvuneVQU0a2eM+mup1l+n7CHTprztHuc5cuUUdSQltn004GZes9FSf45DEWE3D/WR/mfccyQjaGNMMw21lw7Ivi7TrcZRPtPTOy6seGv6e3Qou3NCJyIxvVlNuPwmNZXyOwvYyi/43vu0La16kRJxqMu6yvti37Dt7G3UQbMpVmSOLqtvgR26T21P8bc8rwLsXU8Xea3eRCPBq1fNkHudPGPWUZzV3VybFk1DIr1GU7KS0/t+ndfXMnQT4Yk8IFHFhYy+mU2uiQyQxbvcrFLmmt6QcZj9gTvGzmyUn1a9n0s+ox2t+L9OzZebFyVA/kxBcU2dfftNSSlaL/0/t/zxq6rAGi3iHjgr5kaAJEk/p1rSvwxY4k4pCjbGGQBHhkgPoUv8gHNMZD4XS7mscMSMvtwN4Ep12gUTjcOce4nYhX587nycAfoycfal1aE6eolOtH1gGHD5SGs3knLmmwfcKJjIhLxnFn/mfwjPouzc7HoJ4vFp39LIkU/hrsWRQDvUBvPKr9YvKXPeHQlfqLP1213/GRvM42ZqLKQDMhYkbR8xhipmu7eQXwFtB7APK1UlawjLp0ookHAD/Z8/GRojs5K/IRZrttNRH2wgF+U8nGLRWuzOBtT0j8WavTg/MFzgqpoStFh5pm2g51dd3Qo1sViUZqfRFXGLV/q/jbH5g8QU8XXN1f5E0PKDZDIIDNp2YS2CJ+HYZP/LvwHbguVRRzNxPejTerNwTW0iqKbbNLxfaX7Uvs00XqHmjSe1EX0piK/OCus73CH9sGsNH99My/2gJTxagq4W/o4dV6Tq2rXsaOYQ9wkWXcB2b1lYj2yT01JK5L4X7PFRGLmiz1P6GI+qo2b8yRufuFWccyWDvo9+bri/UWj5rbUDnMO7dLhojg0quLzEedTv1IHp/VBHe699LpLFZQnREG5dvpyZ1IxWVh/q1s4WOfnltSJOtZqpB/7DfdZ0jv3Sc31vN7CGmCmIYD99dLuDqkyST6ac5s7NueUTHJNB7vBGl0UdbznTfaD0KK3epVI+zvxoRuHzafkQZte6O6fOYYmJGXWcRqyJOLoMf4FgP/Z9DBJ2pQjz8pN1zKSK9SElLdLWQvMUrUdlt43zt0fhDjxy5+IQ7vmXBlsHwdma6Pc6TVSJ4oueNGF8P0fZ7I3JqLEIs0mvfgyZdfJ3FS1QYNpdkDH8fKxnM7VyL5CiEz8/AUj4eBOSEISkpCEnBE5O5FF0ivS6NxrnIYY+e1dUec0k8ENPAvAoKQffMZVzPawGbSMoc+h0NW8/8Www5CFagXTyrymamjAMm5HEFdchTpgntkX1OSQitdcLVxzl76H0iSvOW9XM8C9Kd5RaTIDj2JizC0dRpwQFBA8CuCRimnyYaiimaFOqoJxEJ9xbFr7QTzCsefTvuh1yzvOEWoOvY84n+rvamhmbK7EKOI5s2rwWrtJKs6527ZYtPapd4k5ccmym30fGMApxqMXey+GwMLn1WOpfZpcTfLUKaoh35HpzUmG1uy5q/BObEOAY30bLUTz9Jo0OozyNbTBByzkDd3lTDWGLFIyPqStSp4vc6zSui/WrPAR7VAXvBfE5Fi9Wvr22tHCv/Ty1knRFOPArCJxwv/m1Hec2Sd1lC/ktaKLZPPfjhR8spj9Dukf+dDWNcZp1UZ2nqANoxw/h0/Y86giIBtr+j5Tio9TkmX1n0Wqd3/NmwBtDNmn2LUdtutzKursMPMEi3IkRnXGIfHgn271dbOtPUfWq/kq+BYss7nxUFZ0Dg3QoVTezan702laIAMjs0Z/fAKahsk+c0RnP+95w9qu0ud7XXdcBPxCf7pY9O83z/2yC7YxtNH3k92kPXoagKfvlH4fnSTvLucZfECGVaO93v/9+4tk7vjaaM9e+ZbSoV9mZVsD2rCkHfo9VzzwD5VTTSCLhCQkIQlJyBmRszR0VjOmR3m2V7PtWRbkl9jtslPJ1WJFDVXBNRqDv83JrbbRMRqKWgcMUXuguTNG4ROdbPUeIYtyeukRWl4QLcwlzNR/CSotE0zlJF67Mp9FqS7sI/Ca//ig5KUhEbt3Bh6BxJTQPH1HWjw9N8SX/gyp0zWRiZPBPQ1BhXxQZfq3aet6/cv5swvh7aZJi5sZ7DVyQxbW1tDJr1rkzS8+wsIHbo96FvKh7UH1tShqW3KTZzUNs3+BaIZce05DK2FfaN+1Lsh0fdW6SJ235cG5dl17T7PwzxQkJGZlSSc1NsqJWUFCm2nhqf1Fo69f5UmrrhonGdGvbb7WObab9iqiMC15e5K3uVfJZnj5VVTvirYKTBr0NDWaEbynPjqcumfHAzR1leua8zu1fxNzEHu2ocKi3oIE3j50KVenifN1eaoGKexIiY40R4MkbJxYn2lhpLZ1nWFC9PkFfWvRqG72rBJEkl0ifTWCdSyvvjHq/NPNafzzDrEQ2DvoV7SNnWslkKUxVXwyKQMUfdb5xNojTyjayPfX6zdOC0DdJL8/b14jh/Qala1XApL4mPdt9UtcrT88AeZu2dxFftvzOkHQFxw74qwMae8Jcvja/mraNIr+7S7iA919bl8O3yle9AuCssIAx29IofMFn5F1rZ9lls1XluD+PFz2jP5t4zEdvjRdPyYrC0s3iLnXf1USyCIhCUlIQhLyuXKWIgtVSSsegnvFV2EcK9/hN+6swveU18VxGgV0HE6mxu8zs2AffA/l6zYCz74t4YA3tEqoTNFtykz6xBAGT5cII2OC/TTvDzyVHmOIb8FzQkV0a5FBC/DUEfazGjxViGmzJ/EhlqZNhxz/hgZMo1+BRwN2fWM5vRevOVti14Bgn6GBkC01pp5KNw6zarOEJl1dIhppM1+gwzqNItquNmO1y3bIOMHpg2lRbV247HavQRuSO4r3DeTr1hLa0vH9aL8LOZli62AcxPsxlO6D3CTf9wYAG3D+DbNtn27Qtqa3e79OUGazYa2GMVfI5kh5Z8e39FFH8U+07lLk0gc65AbVdEDGmfpzrrpL0MZbfSXTq2F3L9/fOg5eba9iJsLQanb1ZjJc8lmKRmL95pRySXV8D/qo5rpD0OPvu3yNKzYqY7H5khw3VxvLn1At395FIY7N+LET4udLLztCy95oug6j4mAUVK/8mn8+IKXMh6rb30c2CwI4VNKNK6cqC+5WdZQtgsx57xPKzvpLo9ACBLQpYf0YlV4j32H/TRLltbNhYNSxCV1W0lnqPjFmtjgh6h/IdjxQuyYJlDpEjiT6ApedEsuGUYEcuS+d8z8R9PhmocCs/ML3yNss6KRPsQzgBzvezexPpBjGG+deAUCO1d36RoAqjE3oFz5Bz4lFXV+E922otC+HAxN7Ru2LRM4MqoCzdrGwwTM07gn2IoR7f2YAX7hIR405NltT8CYnKyzyNo44sKuaq0KnsE2wQVEWc+COu22p3lN+MGz6GseTY7D+U87xE7ZlV4bh1zGOYvKDfTboD+KdgAY5R+AXBDNX2KIxNjhm7Z+Gn3AsV+MP8hynSHZOuFO/FAdtFkfZdpPOnrZo7cWbw+yZ9JTDdGNKyZMA9NWwQIDTL6VFP3MQkpo9SMngMnSAH01yz3fPXVq5be2/+gl+Ucz2DrwD2p43Fd9XsXkWc8VUCEFRpjDP4jPIEE/v0PZX6Y5y/HuxxfZo8ANdrLJH/pUju2USzO6rJqlc6feU9I9d4Sobhh16nCDrLjE1vLZRqqdZBb/MPu/TVKqmqSBnZ8FusUnk9t2vl/IVv76cJWGbRlG/bXOpu396mfTBFfWboskhkYkVYP+qS/yYDxYLVyTJgiXyoXSO5vcsk4Wh0yAZwB8eS4+rtte2t7MPi3YVFWWzpX8JLUaOaNGxxdAU0WefFuR9aNZ93xwZa5bj8VrttdGFx1AHc2xRKP3GKl78Pu//ODPqUN7hI3BN9OnDNmyherpM3KUV0QWUfsWt3P+KBBJUXV8GQDnvofE1dG6Vdk8e5okCXeb4a7pjAUJWCI6G7q3hUPqM3GtDuVCZ89PgxtZGTb1IKoaPvyUmtaQbpX8iE/OIROo5E5IwQyUkIQlJSEI+V87S0NknlcznJqc9vvqnMgBGaaLZk/dNcY7WsedJLVxa3wJMK7DEO8/2SH9dqs1MswivGel97vzTfXxDi5lYMpQlGs1o9OQ807IErj974gZa0mPIjUYFobD3Rh8iPbhnaFYyM0HAUnttiYZMLpsUfewFvDnBtPIqvBap+3JLRCP9V+bwz/Wada2ZyAPnVLNtVWn0dTPwSYGWDDdDXsU9vecE7JoSgvwY/8J7x/IBfOavaX2VwbXSdQw2eGThHMujgt/YvtAEZpq2oYOQK0r7oHSkar5mEgEoNibipPgM7lw8i+mI41GH2po7+XKw1cSLmbIClGLsvuOzRIVe/pPAiavvuGjcJr5KdBnTxxtv8fesiY5sTBlx3NVNT08TVFjCZpfxa/WfjVH1i3zgTTtOs29jcJ4gkLeOicnr01YJCjldncbgcZq0+RPha7ry/kpXJMmZgbbjAy1igyoK8e+jT3AsDJUFn8HfH49Y63SbgUfkOm6/N3wBL566Lqo/mg5q+vWOFPJGCyz5oFFoYttWdHb9PHioPtMTSmM+fRd139K5wFBvJhwp1rKqpQpBJgEWs2BTh/qcj/wwnYxjPrQWIOUOaBfiV5I0Hqd2WIH7RsYc1rjbF/UHBXguO0nC563L4TLdt3+ADPRer+lHXIGbk44/L99s5w/aeLinmAHuWitJnIw6Dhr0E4mEtaajJRE6m5CEJCQhCTkjcpYii4gii4jTGH79WDkAFRozNo3Frhh672ylLTj6Cp7uwzj3eyAFkAIxbbwrXqsx6Q/D/iSq7WweiDr0B77qQuKeRagbtjw0zNtfzba9C28HNi6XkCNKtdJ+yzXM7ycDSb9bbe1L1aY7AO+LsWuZHbkZb6M1525+cH3TLMv13bckOT9GUZ44PGsfH0L2LepTML6esLJrrH1/DGQWazLZwYBkp0ZDcdWJbM8BeMeoOalHBfcIKSlMY7VnMQf3qHZBBuB9Pi/hbe2GpKytA/y+742TWMenHp1J9m36nFsv9L8Ly6OCT8AcD0WPyU5jDH1t/bXxHFVBcES/kfIeLREvnzoXZlyChKpWPn69Z7bVYIDUIZokuC6T0nGCjt48JOVvTxenkVkn/X1OR0EYX6CZnbXqENX25/Xd5dpqQRcLN0p4ctHQTa48qjnJ3z4kCOP03jSHGO6cLuG1vzp2q6P0sMJC4EOBrU5Gy0u+iJD1y5X3q+NaWWgBWBDDp1XhDznEOIToZEogd/h+GvapB7ohWiEeM/R5KtdeD0hSIIj/ZsMS/ahtLOl4bC9IQg0F3lc4Dec3WD5J/EeTKl729B5WuVQV9dr7Crg4Q36QYuPl33Dvf9ed4iTPopHsw3oTdVRXlki47pjfWYYfLsF023P9GLgrhv12tW4fhwq9xjc13L3zjDbQhMGk7+i33XocNOHyPyux+o8gi7PSwW0PHUmGDtOio0qsvu8f+QonEWftr4+UA/D9pKvxjm2Tg56zyRYJ++DHBn+beaEZNpwnJ3b8WIus6KhZ/sUb3YLQry3aCQb4CXsXQuwGflI0U8sa3GR4nsbnMwZaqrOjr1GHh/sG63WB6DX6HV+T2BajTfgP0Byz6To+WoH+MuBq71Y7wHY4kq5fhU3mO4jmWYIoAr+mo91920Ac4wP8cQgcyyeDZ3YROPjJ2RaG7cTXmDYz4Yokfy9bKHfgF+WA7t2JBQGM87uO1Gvqq907Pzjf5sSAhLD2Ce0jW5TuxZvl1DRQMLqWA8eiI1Pqa2Wm6l201y9MgzTDueUzggFM+kP1A2pCm+KjZizD24geGxp6+d/oZFi/Q+5Z37+QQX1lsYgMlQjCF7mObctkYBdNloe3WtmX5rzNoqHRFe2+0uUNPhruFzyQCKwPysTcc3GaBHdsWaM047Nw/ff6MjVf2XsC/y7mB9sK/du+t7vx71G/zws5wIXKrTWr9y/1cYWDajMlDBspypxxMW14aJRXqEwpM/PYGNBpwvEzPVJ8M7evUNJRtfC2XQfNWoUze060yak1aQ8pf9F/jEngXNDYAgpfVAfzcpzSsalEckzG/JMsEu//KZPuM0Q5WPOc9N+o2RtcVBaWgK7Xj7znh6TLz7C8CyDvY+n4+qTCM1aHO2GGSkhCEpKQhHyunJ1mqB8J6+yYnz/Pv/ArAL7DEgA+PSUOug+bO/HtLHHsLEmarL/8PWBFb8yx3Qf6qJpZprtMG87Faz22b4GnlyZZl31HvRIcM5WgnHgHale8Ftsn5lh5O2xKirpu6tgmOnURbcbVHD4J6YUK+w11WL5AQ3BdUz+aoUO+mjnWpPnz0PYZxjRNegVeozOtbAde6zbTQJluW/DaWsgma9eweyk6SB97hPPSBAW6Uqup+HDX0Hlszn27Z5hLYf1oqLAsOGa/s/bM8IcyJ6rJbFP3eN6tMURngoeSjENoRgkPUP2QaP6pqh3e0WWeO/ZQo8A7442yME/Ajd8fLvl1fKhvGHIdXQqcDsUnHN+R5YL8S86vXNnV7/3oubhrlC5XR399GSAmRyv1aaHT8w4JbPufOf/qnLFGtb1q1RRnDjM22/eO5dN6VEqDDu4trKxbVotmPGz0Gjbcpy/GxmMqHvkZMrYgj1n4MWToqoY4hJj3zC6y9CJWAMzYps/nY8fM+iBSlKpfQZ1HoIaItT3//qcBDNkjbMM8r8cKoPZ6KTVwWZMvp5y0nSjZdqV4us/lEy65a3/0wS5waLb8mfNvum8PvKsUdhdrdrfRnXMlYJYoq6TwIh69qkFkszq/XwUiZj23kFugXU1jHX5q7BLtMEUtMaP+Y/bZhIM7IQlJSEISckbk7EQWSQ8Ismj/Er/d/i0ABg14A4APtKp6Y2NXzwCaa0kp9XhEEZZGjVXv1WA6kfjCRXuBSrtGI/FinPUKJ5JTvPZr2nsD3jartm5XM+LeNK56UvmClohzLX18oIWvVi08F3IHiTbjsofDkFKzoVspyheS6FDu7wF4LfwFnL/DSlyerk6Lt53PwNuSd8Qc24HXxu8O9ptvxhBL6Bg3rdecx2GhIdM2x+IRgiE0a1eYDJev25agbYY27D7rfBuv3KMO1x+M8cWgvlvkr1UXcw29Zt79u6j/uvgBOlRoX61I8/fQ5yyauonafaL6Gd9S7VYPD64dJGHP5liu/MH1vm8rdBuGm5p2vSvYp0gpe6g66G+90CdQRpvVoWsbkTzp1EWIL+I7POt4qz5RHrUP9QV9zPkcivHvfco57FZip/r10gf9hm9zjntLxnxt87X+Rzb2DTWFBKj2PRhiDMeUjaWTxCfUpYpVAXAIw+Q6XuIeJEFu9yFp6+nSNPcdp7ykHFKjJCny03VJpEilWk7cJrpz2iunfVvUZ1FfmE3egeg6Fu9fJc7+7q81ee1eo+fbt0OS+Nmp1usXADn2XWpidaNE8pI1A1BXzyGZ0sjphvdDaB89osgiE1967Rp12rcfhiT1u3xpv8CgPfsuc30TWfqv/EeSQBYJSUhCEpKQMyJnZTQUiPd/AH920Q1ba4RrJanRbHVAV40SqNNSp/lvu9+6UAUAtkRd17HaJt8cnxDWDFGJfIDP0jmIL8mqcvI4RJTawbTqcrxWrxrX6Vlp7px1h0YE94Lhaet4EzFypgzxdRMatiqiMFtqWHfCbL8W8ZQOp+/We1hEivlhRuA0wI4jJMHwdAteCzHh4LoAACAASURBVDTEsgLfD+aDMORVikcINcE+Extp1gcH8b6QKcE5dg377Qo8gjBkYdr+3KCN+brtSnQyYyhd8dEqgTjtK5ZlF8gcr76Nk93jfndFjqDZ5tsyqN2sqEGffffYLzlEYdKhhyCRATl/dtE75mNgov+tCw229xoiC+uXeT7BzBBASuS4pxExX5v+LnOmT8h6BAmdPUUya5FQVqOw+R2jAfgyb1KsDarRi/yh8atSQREYOFycSh9zPp8g9SXePCFhvZYs+iZDOVInSNgh1hfS3DcVtQ/kXVZoI21M7MK/D/3dsJ+vcRxVxpr7kSL6LUEY/PdzHgdgwR13um/JaqLY+E15Dfe5p00TxlhmwzvXy7f1B77qrjez/Clp0noJhTU/z/tXZbo+6PVwwJ+iLLWlnxWVp8Mly2pRBEMl06rmVQOKSnbNk3sep163/lM0tHl1Ju47s2qV399eAeMldNbx0P0X5ew0Qz2Oa3T79TIZfrHbPgAalukEehTvHBphTqqNeDOR5VscBwyqxZqoZkCfmNKpzcTnTbjffQQKyZ1HKhlSGmKygBd1jg6VBW/GSMdNfFeOFiz+RuNXaNslg7zXUF8+srZ2SPQ1bOIsxE/EoWPRJhBzLBq8rwmeJZz8bYK3SatrcD2b1G0CH4IPd7WFKsy+NtORwftZ7fBgNPId9+RSVl2ns0T/4IDlutgiEPIZWdathQMvCI5Ze+w5g+xuV1f8pbQ4fiT6480nMfkkg+dsYMt6tRf08WGsHJXQY+O7ajzklYbTNTIZjhktppMPXY4PbD4mnD+tQzKjzXeh7CVuAcwe57mnorLWrX/tPeq7Tp92hMFpMiON1sSCbhx2zut9yqn2IpIZfQVvOEfxF/Qi6XzIklqhh/9pkRQU28xgftcoC4xllLcc1ICLpTDsfhmcbxwSZe70ujSmTtbiVUuUat5MZi34cWuKT8hwoO/230sGuAXSKNmrdFL/iPNI1ll6uJIm/ezr/+qva+PQTDdvJ3n9ziZp+05CaYJ3CntF7bpkj5iBKwuuZMzI16OOtW2G4/pcWQ8FB3TuaFTzUtYruv8Xwf3te1uLj5lR3TZyub9URJ/hAb3m7AEIlTow/C9C5vn6fWOccviflVdNmKESkpCEJCQhZ0TOTjOUls1sn5zkwt1G3CJaxFL86u8KoqBmKDYSzzl+iADQqSiymJsU78jtClQbZjTIa47u83BuJ8d0e5w2M0OFBZRMezHEEiZ/xTgn21rOc4hi/6OSbFd02yaPKMwsE5pYTLO0RwvC/nLfUMf413tFnwtek36JeL9/f3xCXCy0XoNHLHaNarymH8ujND/Joxm1uq1aNSXgnNJtftAO6xfTsnfhTWpGy7UY70wNQmUByAjMSlO6+7ZaKK69n8rg+QzxKdLY8ugw11/Zw4UZoLkxg6w8MeO0nBDUcHpdmhtiw0bLi/pthXgu15QP4+ubq+Sg8SOV4hGOvSu79wD8u9ZrHrn6Qt9G65ceeM1Zh3lquSDoi9Pe5btq4zE0sZsvOVOKObjv0AzMA/TkciUrshDa+VvvYfAgMX29jWR613ER+Vmi/lqxsZYaRRaFsOEBHZyKMPOm73IowI0T24aoMGC6dc+nwRITX1xBmfJonYqZws7nY2eS+h3f8AdiQrejxO5rBojL8d+nJcXlwDlJ8t180K4MsMn79ZKNLnPazEYpayFLHeGNin6zFuGyxbMMIaiDmwN4hGPvtQY3Btr0/NmKPh44Bpt9Ej0Ake1gSQJ/00AfAHZFWzb+q5JAFglJSEISkpDPlbMTWZhtfhouDf7ZA/8MwNLScgD65b3Nzq3Kk2OOw+JOeJ9CnW674x3bdmFFFmbzBm9DT4U4LimHXJqC6+q+1M5eMzb7+ia8jb1Kt6FNeoi05/X1YrjNLAuKv6hWezWvUDtA1Y5YrakKr10bMpqB8y803KqIwt7+SbyN2LpgCL7fDBXU4B2spvlZ+3e0S/lP8E7KOpzGnzpPeY7uUOQ1Cq8tmya1F98voXYViyxME+1BvL9hCnGFmZzUQdOaeEe166PPqGcRFcIJ0se670hywCV1i8Akx4s0pN2XqlVJ6iQoYioLPQqzd9YDNway79JQ2Ef1+mEIs43JdJyv4nvPKs/V5pmeg2usJmxukvZs6TEM+goT6a0/0qpNA3DI9uZB4gS9dZ/UJCH5pNSNAGb1FpU+Jf84W+4Tf023Od5hfr5+L3t+pKHH5iPa5a9v++r7FPpQ6DrdWv5ia9Af5odZhH/HEdn0ZTdLNoq/Y9ZQCZM1R72x7YJP1KtdN8SPIbuWoto1bw9j1MwNREk14kMA/2k3QoG2s+CnEhBT+WPhdepKo49xsbKn4GpPZKn78p1pvbhkjqCRlfptTTDy3Gvg+EPK8fS2zkc1uO8nReeOamsXkpgnzykyNRNWN0qbHuZHAFzdsh54jDMhZ6eDe2vg4M6UCWrsRZKxOp5VANxw3wvBQDUz0W+JXxjy8QxhJhbBPBnKlOzMJsexeHOPTbYHDb929r8t1d+FWbk2GZUG+81BbBNcCw4CZw6QReLT1nMcDbURFV7A33jzlESfGEeQm7iTgbn6nBOtrnhwTzP1mElpHvTrK1xWLja9KsizsLaFPE32LPnBPc2cpQvrzX0fYeHVtxMldbqNNXGBTF52z4PBfoPb1u7C4JidZ5NvmHltE0OZbsPoLDM9jIL0KUcIpWVvdvT7CCUZbz6bGew3J7xlzIftt37/LBOIXT82n4cgf2L9hXHO74I/1bLngaLo64NbcMaME/usjREIigiZiTQfZk6WansLHpJZLmWamm5bznOLBQsC36e9H1sQ7iZ6DIB/X0Pw77tCtzPxn56ZT20sJLdDndxrynBZtJZuvMn3pY65h0bfyl0bZQLMHKJmxRX6bP1hYJFoN81IZvmlvMXLWzVhQidfy2Va+7uxTlnYdqfM+AP37ATNdXBK4jX4hcNEiw7xTWiLrp9EynehUZ3XWa8FB4R1nkPaRwuDQxFbaF7z5zZNk5dl1PPd94jSFfmS/92n7T8B4BQduTopAsAVWp89vccRWvJFYYjMTDi4E5KQhCQkIf8/y1lphopUygoZGTWH8RdJ7cJOMSpge24S2yaIpjBoYm1wxEw6Vnc7RBVmojCHUB1UWRarssjOAzBiF+2+ZFU5TjZCV9XkqxVt9C+IN2804008pqGZJptKXA3hloPZtKSqSifh1lzA32jaG2NSKdNtNTBf22Ha9Ca8qcuyqs30tAZ2rhkYff6QNmjWa5TrvnvxSCgWGeTiNFwr9rO4cZpHAaaNm+a/A+/ANZNTaG4Js7BNu9PrDyuSztrw+Kh4J38Zvh/MwW1tvRvvuDQEMAA+0YI/bTU6JvKDe9oXUqHbdLyma/kQJ/Ex7KZVB7TakyZLYanltTf6c6z40lJV6AI+r2tHalGrJyb5Y2aeUzPTniuKfN/O9MemjhNd1ZiQK7drGvEK6Pdzpbz/rr7raliwRtXZKtm4PI1K/PXNbDSN+AJUqcSbQcOgDUNMhgor8WOgXDZ5/64MqQ95yLh5uDqRWyF1lJowq0V9v2vfrxyi+GpHcXSvshvshQ+KxLlrKNyeFXBjwujaAeFlAga+LnPBiaEdSOO0fwYgshQilhNhRYqU54kbYKPU+6LMzjkMWXr8Lc26vqwA3vNUU3Jde+QLAaMMU5PWrml5dNOw/K8gvFuGbg63dPMlaH/kr/fwxDnyhyHRpcDRRzgTkkAWCUlIQhKSkM+VsxNZRHSpDjhjLLxvymHxWZwo78BuLXv6XLtoV99OCr3IqrmwBe/HMNRhGnuQdOUyvncS120n39I/LiNOGoJ2mra6A69Fm//DtP0ITis1Z2x6mbepW7GczZRwZV9V0cTNwOvXKVQYQnyo6hR8opk52k07LG+HdaLh3jlIUNszfJcjlepgNS28D16zjClIkzd5l6vXYFm+LMYjCrPpG5rIJ9quDxISbRpomW7rgn2KejbsVRgRvgazg+/Ca/mhbwNEk7V2BMioozqi2wwV5OOf07RgA66FxGvL4XPYeZ/lk6kMjsWUSQ1rebycPCnqUMrMzwi/Bo8ULdQ26I+VTJA/LLR4ij/m+nY7vo+qdBuGM8eGjU/Da6yG5KqC6xkCMXTagH8vsWyy4LT8+rXSiNQZTbS+JOhhz+Pqj+mD22djJyXjQyZ0XAnAwmXqE9N3ctXwlx1qeEGLloRJkPZd/KxOeJK6jjvK7XvUc6BhqWm/O81xNTh0flZ/9y184SGtvtyurympH5TZ9KAcUY2bIEtzNy+z99QNLrLyOxbZagaO2/AJePo++zbV88dMmaeeRlDpRAR1Dk7bjOYj0neQFNNY+N3b/Xep25aqbLyl5L9X1+LsdHAnvSWNLryMMTvFkWf1i29/T178pouKWK1x1nOzNSzh6EK8CUk7sLwUKlbpPsvqtjfYD78AGH58C1c5x+Lz7SOBaFMQRBOnTQyOxUy2UXQYL8giZfWR3+MiV63O5QlUdadDf81C3psW3Y6DwfXs4x9LHPyPognReP/c3jJi/w977x5fZXXl/78PEIkmQhoSSRVMDEGCoqGQEb4SSxQqVKjiFxxFsGDFryhYtUWxisOxVStqRSsUGHGECopTqFjRAkUbanCAAUoq5VJuiSCGWxowaJDL+f2x1tp7n3NQp1Wm9vU7658nOc9tP/vZz97r8lmfdYxm7J3t6dDd8Ym5FPq8+QP9YhFXETAMAhM8d29I4ICT41fpeFwbDOwC3dozhWinRNfajGCBH6luNFscwzwUm/SWk0whn45fEPom7JuEd0mFmdPlssl9VoLSHx7wvkdznxT2i8+VAZ8H0bglOzndx/qqwbti3DXLsr0bLKQvN5eQXitzTFCZsG9uXFtdbgrBM4V08NYvFbpthl8MC3S7Ed9HpoyYW3Etvo0KwGIQSQHruPZbv1td9i0R594q7Ppnd1iIegKcYlix+1LGtpaU6Z/WPKDXSHPHWe7Vd1v9Upr1yO3EdNH6KEOJBH92HC0j71Oo9uBzKey7udK336jDTbo9DBVKUV4e6KhT9Nxb1V015Ylh8v8bM70bShcBtsPSa2SxOA8pLFV8TDSaTxpP8cg7+y6Wk4Qw7P/Cryh9cD2fJ6kAd0pSkpKUpORLkX9KN5STLR4a+HjTu+N2tWUHpRbEMg1qEDBOLQVzEwwPLSvDv1lQ+1S8RXEk2KdcUPO1+zpp6uW6FVDRLf74rDTvfrIAYFi8Z5KqLn3tGkBjGqHs3XS206CbNj3mfu/cWiJtayap3R/mHFTE36vJgEPub0fcZu3J8X1QO1lzMMpI1vzr8VqgWU6qiX408DSGlYhVZ5h3ekHtQ3q9KPHbVSTDTCfhCz9Z+7PwWqwFp63dQ/FWg4Mgp/kgs/1m7pTOeO3dtOD64HqmMWbi3SV2T/tSSmOwTttYjpPCsWo1PKxWQzG0HyjAiurucrLVu6YRZ601PqFjbgvOknjkeeFdum/eRHdvl59i7Q5yJCb0uR2AsTOfSSIoEDeEPrdZedoH7fdWsXmwunsq8O0AsbwWxB9P56Af7LcCvLVpri5zfe0Lrmu5FFPx/W3vSYfvVb1e4tVF5oKTPi7ps5yqmTroVOPetuh8PukjnoTnaoRu/bJ8sTQ6t/4jP50nLiZXE3xLLmW9pGjTqgNykedWS2dM53a0kgEZ72lQ+wUwIoh5StYwcAS+OJFNE+ZSeg+6aQXaCZrB3e2FwFC0fnkSbrX+EG8St7aWom08DDW3BLXLgbML99Jzu+R0nH7Gnrh9p2Z8zKlDFFp999l+h1l1iS7YL0FSlkVKUpKSlKTkc+WfNGZRKY0eUEb2XPXhz5Jg8IGhQhX8eNMx7nhjoYxGRsAqg7nKJq3oIEdyKvRIUxnU+khvAY3GKKvQWU7Hp2uaBIGJcrVKKswSaQYjVBOdrr+NTvPWTkjFbGI+4OF6fGBp3NpBYHBTam4nP39rXCsc9LCSpDKccYlbiVpHWBJVNfX2HarY/KZqnWaxzEk4B3z8ox6njXcZJmbHmrvL/H1NIzYf9oKgjdZ9DXjt13znOcFxVshpRsTf065bjm9rIreSXX8oXlsu0O0WnOXX8RaFlj7YJZlS3SzR4hgM0PubFrcQCj9Qy+ISsSw6vr2GLfvjo9zdWomaWvnmt8jsrlrvo6JNlv3kd1TO/lZ826zfF+KtMHvefXhGVoNhN/PPWjhE23OjWjoj8aquxW4G4fu5KGG7DpqM05hYeYZvl1mB5oc/SjJzsl1jFXHwbEDGdn3CcWYBFsdIz/krAI3V+i024t+FZq93GVvJOfowBmzZp+bKpfye2/gFAP2CDM3aTWoq2LiV0/mvgZ3pPlmh9RaTOAZT9BO/9Rb/m5se7Nkf0+0duGJGKzRO0a0UZuh7GaKB87RO+CD2d3RrVHaHcLxR7pvqhEBqgYNnyxzQoalMFPv3+wxPx/Y7IzepHHD/36ZiFilJSUpSkpL/RfmntCwefPDBGEA0eibp9YJMWtZSHJ97FOKaRb1j1zTo3L8+8JrXqkO+od5hPQrw9I/V4GB3VuOiDgetLVNKykpTF8CbCJo91+k8vyv0ofcmXoLEpp4vxJMbfcyprNwkOLxnOojqv5V2rihN5Y3fir9GM7x1YlDRJwhKrerWjK8KvB9ZEVvtO1SxeYVYFmlFSgEx3FBi0GS6ap0PqdZZFCB7Fmb79pjFYttAG0+i0sjDwy6DaFraaL3/pBbx7QfHQOxiC2HXmcZtCW1hcqSNgzHE04BYu62dFQn7ivDWUhjTsXdrWvOYAJVltBkKT46z8mwc1kPHIWsIZcObXfy1E/mu5uKtsBBx112/5416rxPxSlXr9s5gX4VuzeLtjUdjmTUTwHvj+LwK9G/rD4sjzQ3uaf19NDjexp+N2wCVll6gY2ljtrdo9Z4dh6xx6KArVB234kN7aM13kFoOXZepRj0nuL9aP1aS+E+UkLtYBqIrk1oYIM8M5ZSNK2aExjicVbCN5IJb0/29NisYs30PnKVgENvtak2c82945FUIibYkP51iul1WIe0+cAHHdFy1bSUwqurdBVIO2c4FyIRo46fTfJj8TyyLf+oAdzS6i+g4ecFdR8jA+G1JOSBFXMYqnrLVio/9STaX2+T1KJCurqNGWzj16ysK8ia2GC35hdBJJy2XaV2g25WQ9W3dp4HxdTHoG4m/5wASiAmDffWwdJnM9E2KLIKGN/87+J8qF+kiYaa+wRNL8RBE+6gX4KG7OpAsALu5NFjQ1om5u3l5iRu0Lm8icCEcz8sgToZC4zpdJAqC322yGq5bm8DL8e/C2pWOn9Bt3z44slbunz1OXI6nNxWerJrXi/1klKWTc16a71O9V9qggO9olrr0QndUuf4d5mrYuzUwgr2fVfh3p21Nix7kSIX2Uam0Y1z+eB56XWeJ6uBeIIF8m+iDRXTD3bI45D0uE1l6qU6YD2X7fsnxx7tFx957EeQOkYlj7widlfTZ+o//FQvyxAd4WTtJGHhrZn/XV7l3aLA0S88rxvetjaEy/8w2czR59JCHqj6sNZ5t4T5KsnIWgjAs6K2LROHjf2bb3eI2azSfTw6kjdP3t1D6uC07WI+M2Sx9UV31Zf/82PeJTpX2lIySla1qTncPyNDFsPY6nenvB36tj9RHF4kReN6n93R7GfBk8Dc47EvFz/xa6/id1sFBhd+2Vz6oeZOhlWV663HnmEf7XTx54fZgq3/3uSzE58OZLT/gYgRabwpyNQXxCiPI/HYnX4qk3FApSUlKUpKSz5V/bjfUU+P9j6q53PnfQllcHvgPTPsoj/wGmrUmTkrxWqRp4wW6rSY+8QpEs9pobiu7lgWQjuLdVaoZDWjvNbMZuo0CQy0pUDVSM++B9htE49+6Wx7q+JxAi7c2TiUugx3wWvtR4l0T9kxmmj4Rv6tLh0rWvFwW345MvAZt2spUksuvWrB0Et6NYO6lo75NmQs1oHunwgMr8AHaGbodjbcK7D5b8Jq/QWD1fTUZeYjjtRlx90wrPsiRBQmWn2nj6SSxyV720gLeWqamWZ5+Cwsivi89TkIkCvmvKJfRzGJ/rcT+2El8bXHw18zEWxu9g2MK9O9iaYcFe1u33EPNNL2XvYt6vKtRrbfs0vcdtNrglLmPq8Ww7Oz45wPoBHm9xIqxIkLGp1T1cHfSRqpG/5D0Z3q0jk+UR8vcHU3KDpGVIx3tuMrM4hkZPLNZUsuD/rCAeIKlBvjAex7uG2wyVSztM1rvprZGAtsD8yWTe7t23voD5zkLt38PSdhdMPsab0kmsPv+58TvOHd1R3wguGy8uAQr1VgqexHQ6SaqFkVU32/FLJ8jfaXl/PaAg0/Lny3MlRV+lzonVE0QwE3JtM1+n1kbN+AsnL3F0jm5/6oDdy2uPINLDuwGD14hJss7eLbhxREZR9FoDZ8mqQB3SlKSkpSk5EuRf+qYRRgoLPtvSbo5Q9k2m3PY0X3ci1VM3w9H1RowbWYt3scaQkNBtNty/btCtwXAxlP99YA4Nb6ZJuUdPeiPNy05LOxTqtqvacsWd9gJmxdJYLlJZ41ZLAceVZ98rfrcn4LMItXWjX3StOYivM/fgmVL8BaO+aILZLNmeVmSBVX4kz+zbbLCLkMWXNOEre9nBPvsOU2jDoKyDeO0jWZ1lAfnqTWTuWCve5aQD6thgZ47QPugQvrg+MIMBg4TVX7RIUkEbFiY62MJ/VUznqsxj+vedzGIuntFC37rgf6BRhvx7TEfe1jqE2ActNakzJqFAQbZ/jRrL/yyGk7wW4FurR8HxaBB769bowmpqc72Qfii4LxV8b/VVZ/l36M+097bfcJWz2ckcc1xa9VDbWVhXPubXqtjeTkcWS791vE1hRTP60KTMh2TagEer86gbm0ArQVvMYwguU7HKjwbsFlGFo+rJanULuv88x2fIfc5feyHzsD6k5Z3tdoVzZr5pNUlB1Sl30ISFDrzXhlf17yywBUpOrhciw9NOCIxBKBMLYXo9RBNrGehIY6K4KdsowlZBmV2fFvdbof1mtjXUa38ks4BDa0SBLv+CSjClmikfXC3V921bNrZrtbPX2MdXezGLIvFkXPwhTg+3bL4n8g/pRvK5VkAjNCvSAfcI7+V7NdRxyazqKlMIBYIanPpfqhQ0r/ShExu8G6aRJQOxOcTTNqdsNP+X4F/MWqSt2nvX75NurX4D8o4jWzxysNNODf10QpoVaP9enQiniZbGPT/jq+sYUNHRdKEvD3mfrKAqLmNwkksMb8glIeCdifu7xxcL1x4DI1VrtudwTF2LZsgikhyOaWNOMiR6bqwDtLXPjfiz0u47uhbHmP6AYHjOFSWvuPszu9TN1zfS5hFbBNadfCcNgZsVrLnzQKKdNEyCvdwktPz8m7Z5isS2qRuC88s3Du+qJtUafuQ09nwur6zMJMcSBt6kCPV0gejuwq4v56vOffJghuuce3v8rbmuFxa5tsL8m4Sc29ycGMn/w51rc3WVaMIunSTa5mLqmpFd//+HEDjCOzTfpiRsO8EpIH0J5kDy8ZlNckEmOn4dxV+q6XxylNuN3W3VZ1NWhtREqw2+OYHS/yYLAjaAcR2RTzVuE3q9+PflaQwMOENzxJnUJeo6aBL8dTxmm/RvjPENDge0W/q2T1ws6HNbHxpDgZX4pBP6wMOs/SYDM7CN3QgKsFh7BGIWIlxJSxcM6IjFxyQA06ZL99K/rCN1EQ0M13rrUejidC6lBsqJSlJSUpS8iXJSXVDRSKRccDDscB8iUQipwETY7HYLZ9+5ueJ1cy9x2dFKyTScirWNz2PtkrjeNSA0RXP4lhnV2kwa9Wp0F3zJUybMDdKAV6rqdbt2vAfdTlZ0DznQqitkL/T1cIowruCdBfRmLBpgteqZuj2XpyW8ty0RMpWvNuqWCidQ2lcLpr0hm938RaIBfb64rS73HdVC1utLoo7gVnajztVS1wC+eNV27xZtc1VR2B+QpnZwN1lbrPj1QH3lLn4TGO0867DW0aBBprbT9u2U9p25NEW/h08GonvgxASqC62Sa/f4/cX6Fbdi3WNZyUXY2qD11jtePDvw9w/dl4DkoEP5L0mweE9ea05vkQDvgOkD2pfL/TnqmVxWVd5GfVds3h3fzyd/YYVXXimn1hEr/WT9N7FT18FiDvoqn5CJjTpBglgDn3hWRbM8xYFEAdcyFygLsp71YVX6vel9VX33JYWcb8Dvq/3wZpF8gAlfdRPuBGf7a5leDfUXAA5OnYUDHB5viQPLJ5wlbeSLHO/DP+bjVGzdMNcBZuZFuBzaWzs9I/RJV/0+zX10sbe6lt9reg7NEySZ96MMhCEjAX23lV7X/hMTwqurgbgdNW8Ac46oN+WBZHfgG//m/z5bYXOri+X7XlXwLNqUdyskNjoYzBeDdspSut06/N4Nltt0379Jlt1hqoXNNh9pbqmzoBn1R9XeFgafFAzxFv0xAfCFXJ72oiPeKSlNkDHXM2qYucViRZ8fr7FZ8nJtiz6AssikUghQCQSuRjh+G7xmWelJCUpSUlKvlJyUmMWkUikCfAj4AcI80kf4I5YLPbSF7muz+Ae7dha9/9Wgs7TVH2+gD/R54BEk9I0seWxzqMZG5FC76ZRjfvv+1wJytvfFBXnxV4SBW3gdCZrhfWqG8ThO/qFx/hAK5cs0yBSbZr6phdALKLar67se+/zzv3cteqoXAYbR+XHPdNuheH+hXOZrimwtyNtvaH9XB8InRtszQddm7CvDWROVc1yqGqW3XGabm4P1d5nqmVRTbJ2vY5kPqdOR2COWhaJAfRivKWg5+VOfI+9b+o9Ao3VXd80Rbtnd5L93ul4n79ZIKGmaPEGvVb6AG9tNS7Jjj9vFV6szwog745thFK7rNC3LZ7eSSykxDoP4N5P2bMCtNjtimXhLNyVh8QSPWo0p0BjrbRxWIcpaD5/VgAAIABJREFUzJxwa9yt0kaoBTDnBLrVPigcn1wfw6yL/jsENlpxqNztuihDtPG33hSHfUkvj9d+d7cEigtaV8s1V/trmkW09tg3OK9pPM9QZU25AxxQLhZGepZo6K1b7qFmU3FcuxiEfx8GKDH/fSU+NmRW2UL8+1aLv3Dgn8lC4KBrquRAi1Mc2deC7CJJ3rS2Vk74Fvlj1UpeHQ9B7thvDacqc8OaGnk/l+Uv4q2t/eQAZUEeNmQKM1fI+7mnW7yGvp9WLFELwF0fKOkq/VukAZN5y4IKVApjbt9OYqh/WdWZsaVRAB6brRjdAvj3HjcAcPN2sSwiV+h8XQ+x23Wu0Th+tDtENcEwcqHGKWZFHNY3Gn2RT5N/eMwiFosdB+YhpUMGIZ/XqyfznilJSUpSkpIvX062ZTEaeBDxOv4S+AXQBbghFost/6xzP/u6M2IATWqvoba1qJZWKyB7j6h4C8/oSd+zNLZh5RDvh3NfF4fp91Vr380ZnKaJdIYu+S5SReuPfMPd84atoqld1O4PrHxd4AeD+/0HAO1UczidD7mnlwY+jF7qPTi4TDSvJ5uJ5nV/S0h7WHYnWhiPMpYNSmWw8mWFOTyB16AtkW0q3udrWphpaiNJgsfSjGStbWOwNd91tWzaj6pi84SSuLYVjv0z2x5QjbOceJkP7Z9R+hAtiZk+tI4LWwoGcWWNJgkpeiWtKEieM6tpC15rN81+EMk1KMyaacRbINXB9jod0wmlS5uUH3Kxhbh6Fg+pz90qqo2Dkv9Sqogb1XwzKGdD8OxmJVXgtOW060TDvbLVbxx31yW8DcB6dTIfoxm71Dq1aoRdhlS6eNsHh2TfGRli8W679HyvmZv1Nh3v1zekz2g8t5MpuNquyx5fwFuvKwTI+jgdruogRr5ZyytXyJjL7fae8+E3N0gQMECz5QyaOciZs/CD/cKHcWTfCUrAmiVXRDLflh1XT3INlbzgmcf5n6/qKu022g/rM4CG5WJNX9RLvv+VE3r6caJ9dlkfsZY+4Ew2zFYUmlk4bXCJkUyVMZR270EHJbY2Zg9VxutVZ1HYTa28Kvk+0gvqaJyklq19W83w1m3IDwaQDtGxAsuKPjDB/27xt/m/0T8KgnMk7jW+MdkouF/77JROMdj55VgWJ3ux+CMwNBaL/Tn47QbgyVgslvvpZ37Odb+OLBZrD3Fsh8yAhy4QI+mj5qcBkHuWx7/uV2TrQ0cfcYV5hvM8IBBEG/BbaQf4gPh5rKevJgs05xMAamraOf6k9v2q3DUALmYZ83tdLzfTj/ZP58KFCnGLKmnYzbFsznpE3CXP3iemqU0ou2lNzxVS8CSyRd/NU/jBZVxF64jn2QH/QezEZ0Lbed1J5qOySWMtfsKxSSYPv7jYx7wAP0HpNTIfVXdXNHidBbpv+F4XbHT3NNfZzuC65pZYF/xteSeT8BO1ttFlFi9v4Y5v30MXqtklfiGwRdFcYAvwbiVbKIuC4yyQWosHOST2cRt8n2YFx2hf3TNKXBRzGcST/MD9DX6xWH/gPOd+cpNHPW5SzLxT+tQtFpvOJ9pBJ5LBwURSrtsC3Y4J2qSKRJP5Cjp4IsMfb/fsjZsgL+ojE+t7ih+tfb3QjY+OJRLMPpWPWDNb3T4aJD8960M+ahAXsGVOp3eSsd2n5SJevT2+njh5JLMAWB/3DvZV6zYLn82t7bnqhZccK4PJWlXsNh04l8Z9X4vbd2u7iUyZLO8ib1SCy3FeoR8T04MdOtbS58izZLX096udKW7nwmG6QKw43y8WN8tiMfDZWcx7WAeRKS+zIh7KboqdBfvL8SUJVqnS0ogfy5MS5+mlbOPSuF9mBn9Hn/d/RyYYuWRU9kWT14WvApHgRbFY7Ej4QywWeyESiVSc5PumJCUpSUlKvkT50i2LSCRSEIvFqvXvwk87LhaLbfu0fZ8nLsCdM55YL1kQq4oVdrZDYWer8MVKDGJ5OZw3QUqt/pQfAcIbdQESZHpTVVjLAv+EU/g53wfgXc0UHcMTPK9YtNNVLTNTeM/GfGqKRZPOv160wz+9BBderfc3c7QlHBwp2sOupmI+WxGXM9nFCoXkGk/Pt6+uSC4tOhpvGZj2YTDZh4LfTGvLwlNHq5af3deb0U7LbwyOSQxiz8W7BCzobc803V83jospkXfL8QLFPEeR3Xv0EZikWpVp9o1414pK2hMBi6xltKuGnF3+vjuubqEk4OX1k6HmCuCE7R9AsjTgNfREt0iOv1dcoRlDOWtfmXYN0K+lmJSv7JaBcEHrd92+qqfF1Mq94z32TgvKYwKZQ9Vqq8glrfvBuH1HylucuO0jVDcb6TP9nZj12Ck+Ex4gd5iAHj4+JFbCtRkvu32/3P9duee+FpKEF0h2mz3UVasLaG2CchpyIdl4zMNbOKZVW7t6k+w+BT/Orb+vg459FLqrNO5NOqkFVZ/hYLFpd0qfXdvqZWa9ebO0NxgfIGWK9z6t/W5afzVxXG0AlOLegXFlmaRH62is11IG+3yfNmkTtImEa9pzWrJiXgyaaWdpGkDe/UFi5yRLBTQz6H0sTXA8n24UPFgag1VR/U/aHY1+mHTcP8qyeBdfBGILEIOkp4nhWeFTkpKUpCQlX3H5J6X7UCdc0Vj2bJZ1aRdfB6DkMbUs3sUn1NiifB/0uUYcoH0QnpyurHbXNf6Vu4/57KYhTWfr5cSyuJaXk47vrdSQE8ZEGfGEBM6n97ldDmqGS+N/9jJRl68//CLHmslaaeVfrfRrO7byiRZycZbF/6nwDx8WojHt2JZ89bn3PLKQpbNVTYrqviJ8zKJct+Y3HY3ToJ0WPrnQWwUWP1gOubcELKaBZHbe6xPAqoN7moaeEEBnH14znqHbznirZG7wm2me1m7TVrN8u0N47LDxUwCoUJ9uzY0aiKkPjgvVJOtHi1n0x1OLWCKg9XsnvAVlmmgt3q9u11iLjw1EVRt/SrXOsuB6oQVj8SK7vllczfBadbHfZ/70xofUhO6O7w+zCvXddey1xgWsV67u6a9r7SiQTVqpas8VLRg2UPpx5uQA0pvYxgq/y/VpYlIkxBfhWkK8WByr8wn2bfT3uujxpe5n9wz2nNXBOWZND9ftUZKtQR2PuUPe85aFtXEEQclXfXfz05LHsH0f3aF91yBmBuQN2UZtVbxjpUmer09z/NGEejB9SYYUh8+3UHnourfy+/T48QtljA4BZuuuct1e2ikG66LAiWMVJv/wALe7SSRyFnAm8H4sFtv1ha/3oAS4mYXrsIZKmXzfae6pec9lEwD5j4g5P+W+Yc51tIKLAHj42Dh+2VTMbEN4tNIv7uFj42i5UALbv+g3XI/p4SbxtepzsPtczDvOlWUU6aWsYjYS9D5b8fZ/5BuM4XEAWh8Wl9cTzWXR6MUSyl4REzuy3iilCUxYHbzdvbnrArSWXTtsDRtuVoSHndcXP9jtg7cPp5ETZjbnDdSFY5oO+kzcB2Kon6ZqOjduMZ8ffoG6E//BmgvMFoMC4vMe7DebIK0d9XjyNwumz8/1z2sTky2EM3BjwjLQm+pCvO075/uFwTLKG0leQPKC32wR6B+cZ88QBroTSP3iqu9p/oFVzLuq3RxevXFw/PHNSK5MFyJ49iX8NidYLOZr37fBL6zWNu3PtHsP8o1WfwRg5SKZaJt0DujFl5xFnBRAep5cv3VLGaM1M4v9s5j77yie+SCRGDCLeH4okDE3PPib4P9qvCKg42zYLVOYuUwXK+NRywHGJcxbhnybQzJSbwu+PxIz1iuCv4M0CDdh23tcjh/D1sc6hkqeXc5HiPtuxwFxJ3do+Re3OFdWaZGy9KAdiS64PLy71bZL8GPBjrMF6ijc9NdElks4RYE4U2pu9z8WCJ9YNJpYt8DLPzzPIhKJnB2JRN5G6A5fB96LRCKVkUgk/3NOTUlKUpKSlHyF5GRDZ38PVAH3x2KxQ5FIJBP4CfCNWCxW/vde1wW488ZTeItA1rb+TFUuYyi+DFSR92yS62DWcKnZPQ2hpprFEF7T6iFmWVhd36Ej5/HAVAmEmzWxnvN4A8nu3HVAXF8jWgrmbj85/BvCFzyZ21x7L1S+42uPiQvLXFvg3WEmv+A21m/uCkBVewnad478FxSp+WmaWg5eEzJtIwwUmkZswel9eAiqaupmFh9vOM1zVZnZ24gvdzlEYYGzz/dadSKLZx5eyzdXQjqepjzRZRa6l+yZGvEav2nc+6D9C2rif0fzPowGfKN/Fretxou1Z0DCMfh61xu+08UHGU0q8JZCIsV2mMEdurISqcmDe+UP0ezhecX++okS5oyYWBvWklzjeTRe68wJfrca3PUnqPdtf1vbQnbgAtlYKd8wCG/5RzVVxUn5Abnd3mPvZHXj9I/naYuziOy8fZD/kvbHy57hFoh7dyUDNc/lze7e4rJ2VwbHmgvLrJRyvNZuivcT+GvYWLNr5eAtFrOMGvFFrKzdj+LHQgJp68/uv42pOp/0dvVYoUJNnA23q5XfP7iGjU2zwiYFbbPxWhS0896ENs7x1xr67rMAXMlvHBOEMQg8FLnxM/MrTL4K0NmuwOUGn43FYg2RSGQsvhBESlKSkpSk5J9ATvZisRy4CM+1COI1/K8v5eqZsC0iSXguw1UZHg9d0IRT2gs/SprVF2kOb2hBpEnK+QS+3oVBYAu0Snrl1C58TdX2j5H73MsEV0xpakvRJnro+XO41sUnzlHVZ1XgJDWY7HlB+cYL1OqYqPjegUFGrJcW8Ql3INqNabimpZiWNZf4zG0T1ZJKeqjWtrWb22VJWSs3auAwcG9ue1CztkuBItVcVRtMUx6gIxtb+CCiPfIWvJWxLvgNRONMdKFm4TUv23edDxo637YFMLvjtLwm49RKWpsRr2mD10K34DS1DQ8E9T6ULdVpcQP887l7mWVkmh14K2gfXps17TCozVFzdXHcuXnPbKP20kJ/nG5dTQkroaqWYMkLy6maoC/X3v9cYKS+C+UvonsMjsrfDrZpGetZJJeZ7QRdSrT+xTxxzluZ2qrM7gzrIwHuF3ZLTK9J3iHPHVVzLgB7H/RAh0yNfzTUakwptEICBt6aCSG5F96aDeCp6/fLt8gCfJ/b+CoKnuFE1pWNHbOuV+HH1ZKEY8LvIywclZjU+gR+DMyQzVWb47PIAaZslXo6t7abyKbdHQDIfUZBITVfhwVqdVXrCfZOBuCtU2v3OvyYNAsttAZ1SDyI0OHewc+dp8KsQQa0JxoVKyMa3cMXkZPthpoCXI/EK3YgDqErgBcJEOyxWOzf/rbrBgFurWW9OiY912XMBn/gZfHnHenh/x7f8gEARvAshZtlRhjQXsw1y7wtXFzL8Mt/AYiLCYRW5Ew+iLuu5Ui8c+xibms6GfAvqzdvOrqEAh0hS+jtUFXz1ea0qn6v1F3P89kS/LxpdmA+DrX3pBjpvgHW2z7E+oQt+EVmPn5SNPeGmbv7iKdcACiF7O6CSf+kUdBZDTtzKewgLqkd++WZjykp3mmZH9FQq1+s5U+sI74iIfhAehnJRXAa8B+DTRAFMT8ZmuwMjrGsW50M8u7fRu2DOhFbUDpEl9iHeF3wmz2zuReG4xc3m4Ssjxvxk5ZNVKuC/eYuCoO71kYLkDbDT5B2n4bg3ASXScmw5VQtSqhctAS/WKwKXIj6XE2yZLEob/17ALqxkp/O/rG/P8hzl+vfiYtdbdAefSf5Azfy4TFBH7oxURFk7ts1qnU7Ej8pW5/Nx48Bmwh1QU4fWecq3TkQQzF+3JobtTPJiCsbN8uD40zK/D2S3Ipb8GMiBBvY+Fge7LPns2fRdzju+ft4mWsBWKYD4V/4bzojgIJ3tCxC/f4sjkT1u7VxFYIB7FlsZszBP3tj8JtuH9kgC9MedTn9iQvohrA//HTRj/0z6vj/LIryr4IbKh1QHkTOQOpOvQKcio8k/PNhd1OSkpSk5P9nclIXi1gsduPJuG40KitkdOhdWP6fcT51uU4ti/vx1U41wTTtTFjeWVwaxzQn8A5+zmu7/lUO0HpFxgM15fJhSfeu5hxmH5bIcsae43H7Hms72uVLNGi7Kihn4p77ANh2hqg1W2nHI8hvFkwfHBH31fpYIaURMW9jf5RtZF4MOlkp0YDMTN9e+miFUI5RCGUjXgMJNTDTnG1fbbA1l5Zq2R17rGHDTHHVWC1rgD2HRIsxyGzzdE8yZy4QF8Ctx1sWlmvQmFA8CTxUsJxkrXBhJJn4MJQx8bDU8BmcBbUv2JpWW67b+STnPBThNblq3YbZ2okQ0Tx835oLLoSMGhDB2tEdr0WGUM5q4kWfo+ruIMhrMjIooGVadTOc1nu8mbhN17cWF8l6ziNzgEKPF4rWnj0iyHbfKdDZ3F7qMtkU5NFou1uxjwuaauBbvVuf9DuFPxy4BPDFt5zUklyGFQ+7PrJKxrLVUX/9wBU0zM2Nf6ZwnIQEkQn5Ia6/y/CWnLmm5+Mtior4Z6IA/43YMUOD/Xb/6XDZ2zII3pqmJqtaig/Ne8S9n8JygZu3ytjPa7sFOHNGa5mI2rbawTbUpZsY1O9NvIvW2mrWl41HG+YbY9zXdiIAd+74KQBn8oFLCRjYxyL0MK+vXvgz8iz+J5Iqq5qSlKQkJSn5XDnZbqiTK2NawBPb436Kqbs6MgFXbtDJdDg8qTkArdXsaM1uhveUuMT8MaLdVz4hGvUFvMsORMOywNE0RtKvuXCeF7TdHrdvLd9w1NMWJD+Njxl7RhTAJe6MYDrzEZ6gPyBa2Y0xWf13keXKCE7qfJP88R1gp2pVeQEkUjUbY/t00p/koPdCnB+2Zw9Rg12WN/hENg2ybqi5wCVgmQaY2+c99r4en7ltPEOZOfU+A1a15SYjDnF8vqqgxvk0Wi2BjWlek4rqth5/DdNEt5DkO3cWRhm+zKtK7fC23k9uxxk0dg6kjVOtdoz2cme8dmcxjjYkxyyWB8csDI4DuZ/RZ5smuApv4ZhPXOGPTbIOcbwiI76N6fh2WzvC5zCLy/zmayPQWcdErY6Jerw1tVF+2z9OHuDIwhb+evpe6+48i/SH6uKexVkUzWKk50iBocYCGV9rFpVxTEusfgehzH5o8iM4sWc/UVa1gQE6aancQFb1kQHTuDDba9DWtxvx0NY5+pxFeC6uRIhzA54Py/YNCu6fAHt19wHf70/htXuzaovhrYf1gIREw7yB22g4JJ6EUzOk3MFHnCaQdOC01h9rs7ewrVQpzPurN2Cufruz8O/YYonrgmcxfrtwxi6QjQF0/sQFjsnC4qgr/6Wn88R8UUlZFilJSUpSkpLPlX9uy+KJ3ZB+DuAT6iJPBzSbysnkgLvdoOcqQQtUlJYDMH7pY2DKsqJpLU2/ZNVm3i0VTihDQ/VhEeP3y0p9VyvxGRoS4qfcyzAtnGTtGck0lyhjUs05buVPTMrLYT+rYpI4ePtqdb7OB65LYGjtjve/qvWQ/oRqK09l+zdrGlJvnF916Wq1KFQDbDL6EMdniKZbM7/Y/zZAtV9VqPZydjLiSgsGNazLJXuqsthuEf/38Z0ZXptNSOZqP6qKzSviiytRHzyDUViE6JXEeMajeJ+/9cugtIDZVremjeecoERpJ7zFkpPwOzjt7aaJkuH13MOjuewF9V1v0o4J4YyGeKo9QXsrZHP8qYxkzizgnvtlXD02bXzSPsefVU6ymHZcTRLax9BqFASQ6RpJ+iQvsEr1/aR19uVJn2wpqMBn+gjz8obVXRxLblWpdm53ICvBwrH2LCEOFguIBm2Wno4N4+666flJDhVY+7S6CEbiY1rWZxuD6yVYS6xL88dp/7cvqWLzWh1rFj8yl34ZfpyEY9SuH0KnzVIxK1PvXbukkMwxEg/au0Ink4WQO/49Qln85lWubxpnJXgDxsBlJTqu7tJxVYAbM5nVGm8q1ZhO3wjtfyvJqhav7cYKPlBz7rkb1fRaNYXoqi8HOnvSFotIJNIKGAicj0ShPwT+DMyLxWJfUlJeM/dxLnjwGvlDB8OD7e+hleb+FXWWr/niY+/wm6YSdLICR3U903lXqX6/WScLiVUN21MaP8mDcEr9R6vvxf0284C4i+a37O8Wmt6aS7GFIvebBb+v+pfFXMViOVnhvZMmyDXMVQW+Gtirlw72A9kmo7U48zytSD7wc1pWA3DK+L8403Q1MjGsXNTTk9zZh6Bv//jCBFIz4PjcjPiiQXae/V2t2yD7ua6z8guZu6X3IY5bJNQmMaVw/iDHVzbL76b5BQ3FnN5SIrSNBHxHCQuNk874hSB0R5jroDZhXwE+IGqLXdERGBrvykovrqOxMTuubVZj+aL7l/LWMv2Y7evJIW5BAuKzwm0xsSB1UbAvwPM/ViOgB/rKxNckXYAWx4uC92Pusf54SLE9U2/icigAmioUtWnxQape11kxzFcIyQqBolbS2B3pbbnnkPCXXZwhY+mjrqdxuKtAZmuXyWSe33WjcEaBz2HoG2ztt2rd5gB9rRhPcsB1z+7Wce3JbLOXBnSC1HE7tN+zzD8kvpqGtbKvJF8IQauOdvOBf+2Ler7mQBpHdqqyoBN9du/3qZsl47b/MKmGuaKfzz/aO0En/y2+KFXDnbl2YbevYZb+FmTa750n5+5VnS/vt9uofVP6rf0omehNQT0WTMXtJ8q+0/iY65Ua8CeHJLug5wbxo32XX7r57TW+A0gVw98reebPnhcGiR/O+MVX2w0ViUR6IZ/IUL3HLoSmfAiwORKJXPoZp6ckJSlJSUq+YnKyLItngJtisdivE3dEIpGrkVrcHb/wXXI8Xe/88WKKbUQ4CsccfoLnmwtyt+9Lkp28bXCeS4LrqJr/akr51p5KQglLNlqG9UotSBRSlFsQe2JLMfmu5DUe524Al8ldympXLMm0h1n/PdDVDDeeqSu0UPjoja8yoPjFuHu9WpBQmhKgFgp7xCfImVRt6k7VQtUiQ74h03ZNCy4I9oWuDBDNKzGoOof4DGbwWdVj8Ka9yvHKjHguK3AmfEOzXH8vU+QWwN4iCdClD1B31Kzs+IxWa5tt7bohf1B9wnH3BmUtzaVhzzEyzQUU825Rlt1lha5IjtVXt/rVNenFDl56Gh8BApJYmdUzvo0b8cHUkPvKxFwZ1u/FeArz0dLe43P0/+54C8DeSS3eQpkRXMtKc6p78EgbtVT3Be45s7SO4n/T7OQdh2QsNSzIJfdaec7Fq6/y7XbMvNLGmpeLfd/r+LJxuW3C+T4QbX3RgNf8EyjNn5swOh7SCjSMy3VuorJ+v3PNOKrutcH3/wcAL92t1v7IWPz4APZubeuYBtxY1ndRN8ez7W5Cs9I3nU1JB3lBe81H3R1OUUvPuQLNYuyED6CbNRsm8enxta8XuhIAxvBwmObu/ga3/zl3ADCVW5w7uyZD2jHduRZglXoNjOE69Er8cOtkvmw5WQHufNDZL1ne0P0pSUlKUpKSfxI5WZbFCuChSCQSjcViruJHJBLJAMbjyxF9Mdn3JGlRWWmtNOonulL/svkNri5F5WCBwu6greNesjjCt6ZXcugGWTMzDkiSnQWkd9CWDlqrwjSAKw+/xrjm4vwf/KtXAZhwjTjp+7CIlxWfmoXADq/avJjn2w+Pa3ZrdjsfuIlxUD1ZfCtjNJvokslamKkUrz2aljoOts0UGF7+MIW7zpPnHDfwPhBaGk5DYHv3LZsYr/WADz5m4WGPppUtxwfQC3TbDK/lW1DQLJeNuFhF9gINdDee5bWrMIENvCYG1CwKuIIUCtv6Dq2hkJft22kUDNaucnwMxWCP+/AxGTvOIJdZJNcz6O+fwdGE9Ia66aJxvpWlmmepWifVEWcVGovs7t5n+OuZ1p5OfA0MiC8PmvDlpfU9KGVLAZ4KIKIJ0rOPwp5nBiaeWSyJzwYeWrwOH6sIIb/W9Q3ESyau5sobXcX63UFbts3TpLI2QTDb3u0M2WxbeL67hoNFG69SOj6OYe29Lthn/RLQzxReK5ZK5etSF+KTfktprJSY0ksL1aKwONXCSDIDcV6ESwcK7cniLYGVBHHW6eZFGgQvgKq7dIDrO0wv8mVyHS9a36C87zjtZ/s+Q6bgnf68HyPghTkKiqnWj+s0PnKccdcckthJQ20On+TI3PRmS7FcLZg9kmmOCdvgsi9zLWM1kPlSg/TLlxWvgJPEDaX1Kl4CvgFsAw4gBWALkW68LhaLvffpV/hscRTla8cz9BWh5zV+lAeUIvwcqh1p4M2/Ev9I1TXtWa0j1Lib7qqbwkcZuli8oRnZyiG1/IwSPlTTcB/i8mrgdG5eqv4WBReMvSbq2mYLlE3SAKO3PwfApHMkiD2Ru9y+XyGB+Z8jxUpm7PDU5pVtZfK/ZPDqZBdCGbR/VgJhd+vi8v+qXgCgY8kath8oACCrpSxC+/fneCSQTfRm8ofuI5ugcoLjbF3rhG+HLTwb1e3RP80d32SEktjN94HZtEHyYbkCPLN7eneRfWCd/HXz+8gKcTHvuIXVBRttASrCT8QFuj2KX5Ds+iF3lp1rk1c17qPO7SFDcv/uVoxpLX362LzxxMk66DleJuycoED3vCpFVtgCEWZchwtq2Fag42+VKv3mLgQeBhHLLxhJMjliPX7Snxr8bu/P3mkYaLd2GNBhULDP+kon2ouGLXWK1bj9DwOCkGrfQeniDcm2MbheFP8b2mb7zfJn5uAzrPW3zL4aOF6bS1kPcTVVviwLQ/trq5z7dtsmXYT2BdfQ9qZFdeJ+qoWfpG2MFpNMHKiur/ThdTQukYXnooFKpvlwTxfMzswQpbJ2RaEbp8a7dfyhAHhgC7aN5ZAk09rTAP8+6gYAHuZ+AGo2yWp9T4cH2Uo76Za1csz1nZ+jt66stjBYobVF9HELhymXH3Ma3Y6JHt5ylrrMhv/PFox/GDdULBarAS6ORCLnAuchr7QB+HMsFtv8mSenJCUpSUmsyg59AAAgAElEQVRKvnJy0suqRiKRr6HQ2Vgs9tcv55oPa6NPZWhMNP9vKMNjW614NKhuAdOzRdszF1IpqxiPrLKW39CWHS6INHGMQhfvkc3eMzJ5Qmkf96tlYbW4w+ua+diWHS7oOUjVpvt5yLHUmrl4LxOcZWMZ3ybnsd4VUjGLodPNW73mYhpjUIzl34eJJmKWBZU4eGJeOwnCN+cTaraqb8rcMqHbwlwDZrmMCfZZEZktJKsXpsV3IrmEZjkCTQVYHg9P5ShO+7pomGp0K3om52VkBveslk3+QIXaDi722rUFUIuIL/gEDHxGOm3e5KHe3RK6xcwVU6DbnCPk52+Ve9S00/ZKIy5v9xsf8FWttknWIU5RjqzGrNP1ImneurDrWn93x2vjIWAgZD0F39Zi6DJETKh6vgbAttfP98F0GxOdgmvoM+UN0aD9twvJnKsavPEvpeP6KrON7tsY1FHXdqcViNZ+etaH1FXEc0iFsnewWn46JjpOXOP2bZiglPAhv5daYa587+uF8SysEG8pBla1WUJNSlXLX6dafgUwIoGHLKD6zu2j3FdmpYauuPRgq+Mqr4O07RjN+PiQDyADfKQZ2qekH6ZxjkK9a4MD7P0FFqP183kZMmd0DMoV2Jxg79hc5YBzL/1F/cthcbUhCCDmDPZw5THJrHeWxQygQoAy0eiJyNVE/mFlVSORSFokEnkkEol8gHyy24F9kUhkVyQSeTgSiaR9ziVSkpKUpCQlXyE5WTGL6UA7pIRqFT5m0Rnhg90ei8USPbR/w/XVsmh2P1uPiLZugW3T/GdzPYOYB8DFQe0lixeYBZLDfhfbuA/huTErAqCrqjMGcR36s3mU//C3gF/5lxzoBcD3Wz7j4K4Gw/uAM9mi6t4vNkpK+W3FP3Pw3CLF31l7dtDWFUwahcDfLtz9J44PV83J/O/lvj/ye4jGsGO3wB5Py/zI7bMaE+3b/YnNDyZnTAOiDSX6xJfj/e9hzYjyhN8sI3YLyWUhux+hf75ExBc8rEmT4TUTSjRQhNfGwroKplla4NIsnZzgeGMYjeIDm3a8tTmd5HKWWdDxJxo3mGzlL4/4Nql2mt9B+rgDm1g8TS0L1cqbFASWxbggIzoEC5DwHPZ8ZkWECYbWpxW6LcZp+Rf1UCvs9Z7uWZoMV+26IsNbiPbMJtP9NWxfk76HOL5Kx5XBQF2g2Lctd6xo48eONaVu/ln++SDuHTgL4WUFCozBcxvZ9Rv88e79m2a/ENJG+AxyQOIxFnexENESki3c6uAYhevm9/KatLMQZ6ieeqLEyDDGEXJ8AfSNkZknDbBEQDeGVgXXs/Oy8GPNrt/Gx0UsFrphk4y5mzpMct+98da1Yr+riZGTUFy0FfsddLafMlcDfF1jGwWbNKBaHpxUGwUgegL22X9kPYuBQEEsFjsQ/FYHvBWJRP6IWBp/92IBimmv8FWqvnnsbQCONRX89cOM4zdaW/tNDZAOYL4z8TrwFwB6scQtFjZhd1mhNOfvQt0IedMfK4b5rh8+wmRNu7xXTcMOLeVal/AHF2g3Gc7zjEMChLcVC7Ph44fvdvsPN5eM2OaHxWzMmH6c7yGZ20+OuhWA44My4qvPgbia1JWR6CppaDjNDWwaZAyczofx5HzgP742+OvbZDOaeDx+omSe4Deb7E70Zm0xqtDt0KAddp8ivNtKM73pdEQoHAhcDpYVno7/YEOXmk0+NkmXeiqI7DGK1FJ3SnppgHLRSSw960MWtvw2AHfwdNxjnMEe+t8iaJWrecX9flOVFqqyBSH4sq56XjPxVwxO2mfvYHSfx5g0Wf2fOscN/Im6zyYMdZPRyhU69nNwC45RtQAeWaTv7PI+gthjCCyerYucKgnHH8rwbrAB2kcL0/z52s69D6jLZhCeMNG2D8GLb4t2cP3rBpUL2qLvePBYzYd44HvkTdRFZZosKtmd9J0sPEsqLoJ3K5pyAT5I3hmPyktEgO3DfRe7OouL98iWFt5VZwqSvadGfH1rU4C24Pqv/6hfuUsvWCYKT/seGuR/WJWvLPzCp+8ut997qH7J3qe1/9Lhr/rSjM3h7Q4y4V9Ss9xloZv8nnIX9DZ3ldX4XktnN4dtVy3ga9S7xWJ0h8cAmDT0HniiAjjxIvG3yMnKs2gEddAnSx6fTuCQkpSkJCUp+QrKyXJD3YWEiZ8j3g1VAtwEPBaLxZ769Ct8zvVP1ep65fDab8UFZJBYy5yew2AHLTOTrylHeWi2uJqeGSLq72t8x0HPLNA9foWsylO6DXPWhgXGAf6NnwC4HIw/qj+iA39xEFiTG5nBJ4j1cKoGv8tGrgFVMqt6SsWlkskKElsKG/9TchaL76+R5/1mzGtaBbpdBxc9qy6JGmm34xKamuHhrqEFYNqVmcXVwTVNuzeN0f6H+LKTOzmxdEo4x65rweblCfv640338Jp6XJMxakUszHDBRkdyN1S1z9GBtTEncKck2ssFsml/R5WzLA2AMH3/CO/yMMuoNOZKw/7oDuHkscz/Xixh+gEZO1bsZ2ifZx1evnKmQD7JIbnmtWrZ2SPfp26dunMU+ps5fC8N+0TrNNedBTzXHzuPuif0eLUE0gvqXK6BsxA74TTi9GLNgN8nz8uCCPTXb71S63T3DdxndpyVaI3ix4tZH/3xat5Dcq30nL8KtTj+3nF11BPYAtpfW8XmeSXx7bYx0iy4vo33QVBYohnh0xQ6G8KSDeBgVuos4uHCIK4su4eda2OuAW9NhzTzamldlC+8WCtX9yS/q5gN12tA2QhE649lcUnTPwBSpgCEovxarWc66fV7XFOsxviRBvFUpGV6iL2J8XMZfx3A5ptL4tudAy+8INhnG5vGBwfe2mgVGUtUi8BFWv87ANHorqR7/iOhsxMjkch64LvIEHPQWeDGWCy26LPOT0lKUpKSlHy15GTFLNAF4eQuCoE/01ZhCzDfzWOueHlbPMyv4xAJZt5+tzgoyx7/Hc8jHFJmgUzpJuVU36GHsyzMV3gLU9mqKvEW9Sf+QmMYT3MHjyvu1mIp9WQ5OO2Fx4Rn6oGpP3JwW9tyjjawGbTLEovCGCk79lnDho0afDWtbR2s2q0O2wrxMx/PVH9zCMcMyzEmluY0334lXsuf46/vksIs6SsMhCdANKkM2mZa3qDgeokB9Gqc1tn+8Spt4jHOHSjW2qurxfRKH1BH4yrRXK0IUxzPlPmsQx4es4QKdOtz51xyk8mRnS1Ia6PaXrVevxSnWVqZypDDp7FexklhH9F43+YSN05cv1Ti34MFThXOXLflrCRHbMPOXBczWbBFfONlvSRBre7es/xzqj3eOO5r/mT1lxd2+HMST5iTYmBfvPJ4vDIDeotlYdxJR6z01nA8vNf4narxlqr6vxv7B1Tb9l7s2YrwNPjlYgHW8zX6D5Q4wBu7JVZ4fK5ahQWQ3VfjF2hMqaBOYMLgx1VwXTemDTAQgibM0i3FW9GJwWyIz2iXRrpA+LnjJS5weddFvMB3CeUSxJqYWXEr9IrbxceHTuXlDA0gdfJ8XRe3Eu1/6T4ZHBfny7zyMafypwMCzunKam1GFgtmKzAk7FOA+TBNIfaWCPwHLnHz1PcjYwGU18LEgok/5u+Rk1r8SHMsTvR7mxP9npKUpCQlKflqykmxLDRz+1Wgg+Za3BWLxf4zOGQ90OKEJ/9PRKGFHUet4R7lr+mljkejBriYdxziwOIZt/Nzbps9A4Auj4uzuAOb+AhJrjEtf49yQ30YOPwtea5wRy0ft5XjzS/49tLL5aA6qLk6N66pV9YtZle2aF8tNquGUSyp+QAl4zVW8aaecAaktY9/3L+S5bUqT4jryjbmDRN0SVjacW+N4gsUIUV9xGsn5bo1S6A7PqZg1w+QLM56OIr36xoyJRSDRJafYJ9p/oY4mYobfc6HvQU2lKoFpZqi86WH1zeZG2ilZcHvBlk0CGqB3/XubtHeqmq7+3aZ6mLaZn2EoV1nAD6R0uRtvun8zMb/BbA7AQUXV5rVUGgaB6Ecp+E2GSQa9ynph50FlSTdIa1crB+LRTVtdtTV3DA/9rad59Ozlzj7LYZSY3GNZjhNO+26oLSsXs/Fbcy3H8af7N1tJEhc1O0cSJvuk/ZAUE0ATIUm92pMaYu+p9b7WXC7astq8eW95JPyPmmU+J6968Yl2d4asLZV4Cytm67VolRVo30bu2tsxiypufh3a8q1jaUc/Ng3a2UQdBwoHohZT9/s+0Hv+dMlqpkHs+eb3aUjz80Qy7hDxib+qPELQ/OxCq7oJfyqS9XsNPh9PVmc2fIDQqk4VO7Rg4nSBgrUXLLY7Aimu9oW78Qkjvk4dxOJSNnoaPTvsyhMTpYb6mngV8BEBOc6KRKJFMZiMXNsfDEMl044G/p24c6BP43bZWbYLr7uJn1zEYScTCadWetwzVY4xNxRK+jmrmcLx+1tJzhXly1GL/X05GTfcF+WyPPZg+mmvInri8U1NYi5vtjJFXqgIiKZhF9GNbn7LiYylmfkHzOVG5AFIJCGdbJQHS46SHYbwVnXVetFMvEfW2Km9Rz8hFmh2yJ84C+EG04nXoybqVlwfVuU5uChnBawtByJcvzEE3JTmTjuqeAZrR1h8Z7E7Nsl+AXNRpvWL27bdYdzIV5eIpDSxelXcWSBBcx1knkqwqxGmSQG9pDGbVU35yRGcckqcRNc0Ufw7WeyixcZAsD+7upGqT4ribAxfbivZGhV1PYuElhlY9Fpvi81T8UK31w/cDa31Tyr/aLU48uh7A5xU72zWyaGf2v9Y17R2u7m+mzfT2Ge80rIHaX3tDrq90JpS3mWylkamC/Ai71PcyVuxAMnSv0xRx6S/iudqGR99bpYDILjNvm3EUVp7+Sz/eJZoY9Uo66znT4r2qRk4HIHEDEq7ikVP3DfwXObdJFYQLLYgjcaPyYSiTDDfB99ti4DK1kzuyz+OSshvZO8v2PF8u3a4nhb08kui7rHMcnpurfpBP519Wtyro2DIh8UN9fuhxNlrsmi3s07prRWZxRQib4XG/MFug1cq8eOydhc37RjXFAcoE3afjxB1xebdk/WYvEvQP9YLHYMmB+JRFYBiyKRyOmxWOz+k3TPlKQkJSlJyUmSkwWd3QOcG4vF6oPfcpGAdyWCiDr9087//OsrdHY0dHxGzEXjevr5bqkXPLb1BN7mEsBraAA/OPAkgDP5r+r1kttnsEqjoO7GSr6rNbXNXBzFJCZrxM94o67Aa5jGJnkL0wAJXJllc/50Mbc5G1iqN5W8QaKq3USnQlShf1HVwiMFsWRq7+U410vmcOGbaZchfEbr95/n2V2XqclSTbzWCN5KGERy8Hs53g0VZrMmFhYy908WXvsJIZGJ5UaN6XRBcC3TVstiMDWhVGhwr8wRyl80Ljf5nmFGtN2/IuGenf2zXN5DLYtpVyVbVY1+XFkSlbEIz+S7XFIjfot78gWG/QoDaK0UxA46W4vPZLc+sPuswmuz2geZZXtdZnCTIu+aAi0ApdqpsfHWTCimbKwytN6t9xwZc3WwO/bQrPQV6tabi7fyzGqrJpmh1cbBKrwFYCD3Snywu1y3y/FjQbXwJr3V9bQzw1sldp8C4jPTrW0ggIAggAuQ/ej73jWl0jZjB1v2y4FZrerj9u2ddra/ZyidEraVwb4wOdXaauNJn+miDktZWSXfkgNEqOsuLeegs06zh6plufwshvYQa/AvyuawsuZiMnOkvV/PEKCFeScu5h3ngZirA/ZUPuLVmxVjb2CJqG6vgy73y0N8E0lI3k4B1YqUaY6MnZWRSkCsus9KyvuHcUMB74DawyqxWGwvUnG6O3DaiU5KSUpSkpKUfDXlZLmh7ibZM04sFqvX+txXJ5/yt4gCwrIuZMMDojltH1MAwPdb/xyAc9jOOVr29E/KF3Ulr9E4VQN+qs2+WjWYH5VI4pXVJ7DAdRjcNH6nu3jKcbiYHFM/4fkztnHF8Dfi9mVR75LxwiDscqUK6L5CfMpRC7ytgi52kKE8G/C+VtWS8+/Y6AJc1s6qZaqu1sPKTuLHdlZBAUk1AJwmBT6mYBZALV7jCvluTBu0kWNaZRHev2uQy1DsGpXJu9L6q6a2oIXXuGuDrbKINlTGgwfYGbTRkpUG4S0WjYW4GgyLSpzfeZOyd6ZfFyS32b2Pwqbdsv+M1hLPsloKb3f4Jj3zDY0gMoQX+Y0GFs2KyH7ifbe/Ll2D3xs10FmK67cufaRD1u7+hguIG4Nq6S0Cs6zc8i33nDXLi901KlcHFoWJWlrWfvdewRfQMosn5EeyOFPInWVauELUm8w9JAmfoRyFkoliaVXNjif7Si+qo7FA+9au1YAfMw5SHJxk1myBbK5u+grPzRdz5qIhYo6vP3SeBOeBts/LXLDm9TLfbvuWLI5Rj49fWBzOwA/j8N+lBbhH4vtBz1u5qqf7No5Uyr1Hj5Lk3Wn7R1I4TGDUDkLd4133SH/cL4Hu9KwPuT1DYo9zGQgIBREI/DqRG+pjTvOWcyKgZA6sKZKGt71W7rmfHKre1Hdg31mnnkQHfTkFkE5WUt5mgEgkckosFvskYd+HkUjktS9y/Wj0Fd12BK1T3DhLBuVTpT8CYFy3+5xJtloJt8zkC+WqkpeYdkzwyvc3FQ6ncxwoG+fK2hJ8WRZws4zJZZr5vWz4xS5wPXSpkBgO7/kLd97IYnFNdd9Txc8Rd1n3bVIQCUNAHYX8mPxz8Ji0o2PTNVIcB5xLoKaymJpBMnG0L5HJ0CbCxlnZdOknJu2aev0S8mIwSCxNqwNc+4ASvmWR7IYCPzpChFSF/m0fk2XLbsEPaJ3P8sdvpOY7+s+J8iyGx/+U1v+gL9BkE4rRTYObXBy30KZCt+vyDuJW+v3+S2nVSmbWC7V+uhWuCtFUNS9Lu3KvfY/z+klAcc2D2lcFcHykTIq1A/Qe2j+PtLmPPhni8rQM/ptqZnrUWfBMdWM00JtImLccp0qtmSf3TO9dR2OjTsQ61Cof0MUg01+jYx91L83s4haQzEHyx7kZm1hTLddr11pm3c19g2zpCr2/uWmK8O8xMXN/QJBtrIiL4/MzKBuvrq/J0rYuEytZs6Isrt1Z6mqpqz6Tq0Z5Ny8I6V3HHtLf3+M/4vZtnlxCyShdeCbLAz83bzTDhkwBYOZk4UoztyvA6fpSc/tp8H752W5f2iRt//QWSSAKK250eGRzjvT3jAAAw7pOYUNXAaOsfLOn65fcIXKPZ/sI+GFAjaxGl+Uv4q0aQSRdrBnf9WRxTeT/AbA6JvNPV1Y7olNbVKoDf6vNKyGpqBP7Fs1lW+132Tz0C0Z5AIm5/dZVEl0ngzca/WIsSyc1zwJYHYlELgx/iEQi3wbe/ZTjU5KSlKQkJV9BOanFjyKRyK3AwwiI8RcIkXR/YEQsFlv4Wed+lriyqtHryT4q4Y+6qarFqRacfe/7NG0qloS5l1qxn4+UPdb4nV5xNrnXRG8/IJrMjJZD3b6bt4tqsu2cPAoXq4qrtYb4v7o9CkjtEbq9UAEI9tmyuTM1SN6Dd9inqvbQl8QCuX3wBG3+13gQdYsdE1riltWHPYTU3C078Rns1bo1bWJJgKVfLlpTetkJuITKVWuflOYDlsU6HuZGvJvKcOhFOHeFC66a9luO0/zT+6uFE832Jn4i/fZC4usVgwTxDe4a1W0zvHtAX1WXXmJj7yfHMe4OzBc4825aOw3NaOAN77635uu+JrUBBsKSm1bwaTjeGqgInh3I7L6XhuXqDgu5kDK13yyIOBwvAcwRiM/eNvdc6RF5D8G9XP/vw1klmZ1EI/6o4TTnrsrrJZbW2exgyzE5uVVTuenmraqrzYp4F49ZkfvwLiljXrUgeF98iVut8V4zrTg5d+Qo/h3rc9r7WTO7jP8aIoPygsPybb3b/ALHwXaBfm/2fzu2um65YZOYqRd1WOpcNSZhDXvn9lHpwCa3rzRIFrHvzXiUzlBAwjv7L+bKVvLRWub0JfyBHyJAmMeUkaHn4pXcd/kDAC4QHYksBuDK5VDVTbwBTyCM0oOYS4G6wQ1WvYszXW6OWQOvKcKlFfv4QLHyw3kegBncyNxeUtgMIaymqrNPwirZLjlaL50j0P3vHfCW2sfTxZqObIzB9An2K/D3U5SfVMsiFotNAS5CPp3dSObAhV9koUhJSlKSkpT878tJ44YCiEQiTYDrgdbAb4H/g+RgfDmcUTPaU2e+SPWJZ4+UwOIVTd9wK/t0jXgNYL4LLJlFMWP7bSjKjEnFEj/Y1VI0x+sPv0jGjOOyU6mBCn9V6zV4E0uMHOx/Ms3lD3zTBcAt6e81ruRSJIFp6GtiWTxzaKw7d+yIKICzjLguWPTNmqiHy7qJz/St+pD0H+juWS1Nzmu5njXrVAU0zdL87GG9Ciu52ggJ+YUyWlQTrdz0rfh9AZzBsZAiCU4AazL13uZTDYOrd6qFU5vmLYvwumYFJGjo+w+1cgytFlM6nQ95T3292zVmZdxge/l6ckC8M8kJT1tg9DCtB1AhmmVJLzGvdnEmDSEIQCW/ncQvaoqL/Y+23yClWQopHR4EiVVDTyv/mKcfD7KFgduuniF/XIfrlwZkbA57ZQovNhON9fdcJr8xk9Kmok0vnqeJovZ9dCYpSTCOR6lct3ZM0NeW4McsfJEpHRt5o7ZRO0HiOiVj46mF0/vX8UvlU/rFD6XwF5O85X5PS4Een6uxn0X0cV6ACR2EvflHux/litZv6CPITVfQzRUXe/EN+WYnXXGT9sWlTmu3JLePOJUXlY16135NUtUw1pEtLZi3U8zdeWr2xnZHWNFeOuSBcyQGuuTyXq5Qmc0r1TFlblixmJV0A+A/DkicIq0Oqs4RK8A4pPpPf4ttI/LcM4DP/N/NGT5RV+UK3nBW25OaDN4bsSYunAS/0RjLoHqJ1w2e1YpIqVi4M9RKfp4IN5pZQjLD7d8iJ3WxAJYhU3GXWCxWE4lErgCej0Qir8RisVEn+d4pSUlKUpKSL0lO9mLxCvB4TAMjsVjsDQ14T/tSrp6DR29orKJuicYunsWxRH5fqTJ+fOAB2rYUH6et4rPOGRjH8QOetynj13vBlORDus2G9y+XH8/ar1XWQl4iBU+YNhGWPDz3gPiW17dszzOKhtr2omgalohzz/ZJDmXzvVcESbL6v7uy+GuqKRocsA28tSjeoijs8Gf3964DAqdt1AdYs6mMvLHxFcqc5OBHQkBvkJhsxVo8GsP63fzvmVDW9Xdxl62s/hZrNpW5/YD3iWdCSYkiX/4lUHEtgc6U1BClpe94TYFc85luI9wuKzH5Lhe4WhXvIv76pVsFqcK4iLMKe/5EPKFL7+rrLSjTmhfCpAlagyCB8nLv5LNdH7Tvo5DcCSVcXSIIvae6/8i31WCa2n/G5UUW3jpVy+LI8hbctnOGPPJ1Oq6sW6pxSJ0f9ZJ41htcwXmtBFXUsaoagH8vuYEfHBJf++KBguK7vI0kbLERD782dNtGPLQ2scZJgMDacLUi8cYF56olWbup0L1bQzBdNkoGaduWO1yMcPgkQQWOZBorWnbRW0gMz3jXnuQHrm6MaeogsUbw7ziUX10h34CVHx1V9xyTs8XKMOvjdD7kRo0DWNLsjkNifV7WbYEbLxZDOXS4CS82F0vEkJE3HHiJ1S0FWWZccwaJ/123Mhc7SdNidwd7plHyilgBJbtku22UmcieFsgS6gYF2FiL4Vx/+EX3m8Hpra7jitFuF+NaRgG4dtTL3KSm+3Bl4ov8618A+eeLVso7qYtFLBZ77AS/7QP1Bf2dEo0qbr0YD0cs0K0O4h205cNjmiSudCmDWs5jVs1wAPrkiycsrM/df+RbANRNlS+nbnA6f1E8/tGITAwdYpmc9a/yyg5qMHunurHOGwxRRQq2GCEupHe42GV422DbRytnUptYhvi2c/JIlHqy/HPaZL0O507Iv2OjPvpf9fiv0bhFVzm73E6o3amLhE2KO3XwrMK7TGxyXIcPRptLohl+Ejc3jslUqMxR15QtLrV4F49um3RWV0zjKVRtlQkhbaEG4xcG3JLhYmHXq5ZNWTdZlB7mPq5Tnq6ZmwRWOazDFF48Ju6ZC5rKx1/YTibVbSPOp32vqvh2Hw2eOarb7rjJ3DKmq6YFC5r2x9Ys9dkU+F0De4nfZ94DQyl5XhfDTXpuufb3GP8srsxr9CwXTG/M0Xdn76QBuE5cdTaRNOewc7d1LBE47fcPPE1jrZ6raRbtu+mCNqkkOXs5h2RacZWO49ew4XWdoiwPYrl/dud2nIobT3ldRRmxbPa3Xu/PX06VjvzdZbLAm2sIfHDX3EZhCVvLObig9btJJI23MNXlFtn1PtQHrs/OYvSe5wA44wxZWK9ljnOHGbNB2I75mvZl32nGr487l7LxNG1tme/KNJs7avAOcf+82vZyt1iZzG06iO9tkMlguxIcFXas5cnLZJz+4CVxxbUbLEH92QxhBJLxbS7sJc170/7HEkTvom7wJw/7e0RVn3lf3WJ7OMMtOpdcs1iP2kA0eqK6yH+7nLTFIhKJXI4Ets8HTgc+RIofPR+LxX73GaemJCUpSUlKvmJysijKrazqs8A84suqzoxEIhNisdjTn3GJzxEN3m6cAQXD5W/dXFUiq/m7XMilTSWI/AICP/srWQzLlzTm/apSPcHdjGIyAO9rdvcZB8Ry+LBlOt3PUk3U6ie95DO7WmjBovOMMfZGQC2LWw6Lp+2UxuNc01LMyXsRCNsb9OMbqokUbhf18fRz5Lrv0MMlkY24WtxnKx/u6QPbphWmQ8874kFlS2erCrgR+v9ECsyYKb7jQFsfeNa+ci6IMNfe4JWdSUrUSx9XR+OchGxnu0YxXkMP6XpyNHhdqQWarPxp9Ag924l1t3STtrsZ8cF2u5a5vBIS+0YyzWna4zrcJ89JWxfktUz8bU9r8ZxOsBXt4DUAACAASURBVPkGse42U+J+c+1tFmwT+QfCrONq/VsNi/bXVvFUjUYULUsbqJrQPe44p6F3x/Vf3Vx1m+bBhrcL4m7ZcYHeqNSXzDXJ5EP275cOMXfUdgpctvrlNWIlM923x1l5Zp1uJBk8oP9vuKGLdxkSHG/wYnNpDYCLukpmtcF2zZKf0O92KtWBYq6komNbHLPCzKai7Rs79M/5vgseW9mAUzjs3rHxv73MtTx74DYAbm35TFwTz2M9/Fie/cFJYlns4GwXOD8F6cdfK97953zfWfUGcb1k8B+4+TGxEKvu8VBVu7+159W2l7t9+T8TSPODPxR1f/zPvFPlnDPtD/h6QvEtk1183VGNj1fEjFhQYiH0UIvCbO8fXA4DJsi8Yq7ujqynYLVYJe49lQMJVs/fKyeT7uPSWCy2MeH3X0cikZeA3wNfYLFISUpSkpKU/G/KyVosMuBTllDRzb4QkWA0KmVHo4+O91qbak2vThZnY+GoP7ukrO0HCgAY0vJFx/duiVuT637IvuzMuN/ebCmmwtfZRfYTm+Nvfhhfg8JKKRoy7S2IGkKwuZRqXdG8m6Mk+KM6wj/hFG7eI5rLoHMks+9OJgLCbmrcMKbJPFc+2mvXFkeogKUvq6pqWmF/0eIfGXKPq91hcYzGjdnJWrtJgPaMiw9YzE195419A6Jgu2fAp+TErJPeOIvCicYCMnPqWbpI228abzN8AN+0307+VIvRWCDS1QbAUyP0YZELjjp6lxAy6vpKtwWcEC5qwemaZsXx7dmHs7gsKW7z3BL/JYVxBgtiW/zFrJUl+OPb+H0dH6gGIPNepbMwS6o6sMjukM1WijizlXxilvTZp+UiXl0R4LfBAwuaJfwN8t4NWmtWT4iZMFXPAvXdg78txlEPK5/uSSgvZX0PgFuGdaNs6Zq4fWt6dmT/K/LQt139s7h9fVjk3uOVmt36By5xMQ17nxcEBBBd9cOwuEOfAJVvx088cKer22Hyf/k1ABs2dWFgh1l6LTnmwmPvMuseCasOfUOg7Wuu6BjXToAKxRsP53k0zODK9j77w6Hc/JZc94gaGWkZMHiPxDneHywWuln+H3Cme4a7dC5oze6gILTID3roHy94II7JaCbTpI0yFs9XxuKsKScuRvZ3yMlaLOYBr0UikR8jrH+hG2ocJ66z9rdLDh7JYiazPtEF/CmOzwnEBH35kLikBmSIHf3d7H93hY1+eUxqb7dtKsiGgsPVvDpYTM2rWi/2Fxoum9/oILhyg/7fEa5MqOZ2Ba+7jM83dcb5KHjJc/dIe2La7shaHww0KemxnKr53f0zJ8hNo+Krhd1XP5H0AnGlZbVUpFcYTze3iyGPwn02eTXis3vN9dWY5icca4ctDJ3wWcC2gMzBT8S6CLkay1PP8tcI3Uzm+rI2LQyuq9eyCaUV+93fNYtkUt/QrAuje8mLsf6OC2DHDwnSuh/kyE417sPFwiZP/c0+wuP7MrwbKsymt+sGz3tRB3HPrOz8TfltScQfkxhUz8Mt2kZVbs3v2WchS6dJg5bO6+uuYZxgNQ/Kia+NbO2aP7CbBtoXDI1vVyiZwf0TiQSbQZdRmiPToOOxU9DuLFFM8vN91rWN670vCz9T+eoVvN1TEEw2sZ3JLv58tQAtrHa0IROP0dShiiaskIZVduviSgGYvMy1VOoM+P+xd/ZxPtXp/38eY6IGY2cwlsaMm8lNacR8jS+KEJLIylqlUmmptJUslS0ftZS2VW1sWbYoJStJSSgy7fDDDpkUI/c7q4ybWbdFY5zfH9d1vc/5zKhtt529+T4+1+PhccY553PO+7zP+7zf183rel1lJ8yWbOKuKeLuraWuLwhKBljOlS1AW2hNf52OBm2UiXxOq6CYWUGvNEDKFliO1s3KyGjK6HK6sXmSLNi2eNXjC+e6PnZYBnXSmJMsnCTziSmmxhrRjeW8qBOLBdUh8H7bknuxrcvPwKgJgiywWtyLpg5wlRdLLYeK+sAe/hlSURncwxGa8llI5vZXyNr7EqJn3V5B941JTGISk5hUgFQoNxSA53k1ER3meLgY0vcR44YCiHQcJ3+YRhqylQyHb3VpkznEM2rH9+RdANYXXMq8ZmJ7DxgnPpAN48XkbHpqKwn3SQZ3/hQJdGXmbMNSJ+6YJGa0BbzG8DiDhot2kvu8BPZ+wGFSS0VbmhsnbpPmbHY8MKbh1CsWS+C1pL78QDUWK7xz3fIQN45q420zc9h8okVUvxxfJBppp4FLyFneM+oYucAQDTavEddQtd4H3O8qdVbNebe6O56GSk/rPqtzXZfA3RSuhwyidZo1YNbGQQLXi2ntpuHWDR1Ll02lJic48wu9V5gWfbf+rQy3vbMleL9o7gB3jartlI8qL+Rua6bPazWQIwTWkmnSg4O/TVNvwWYWPqPuHHPRhfJbmo9R5tdnWrs+6L5A3rsFS+dvHUzHpgL6O0cpAjaWShpu8cr6gXUXpmIPZYRDqK1hHi3HJkpgTWu/V+p8gjP3RDPXdnxUObwmXBFYBWYRtaNcVnzbgUGwOj1ulz6TmMu7SWfPKu0QLZPKk/EwSv6uqmVGDUjRdmCOg4GaFt6Ld5yb8KmpAkpYc2em3ueY+5aMi21Rwy4Ovm5MzcdKq9MkTgbZuq2qamt/dsle5NxyHyuIofa044HrWDy87MySSP6b9HMZ5eccDkAE96SJ1m7eiaGhesLmfnqqUNo/L7U3A9rJANm5Rq7bqOs+FFdD8RC1LLad5JykIwA8nyyD2ayCdZM6UXW4jOHxiePcvX6eLF6DeofEgvviAuFCm/dZb645Ivd8RcfGzXl+8D57qlWVlQx5KwGIRKziWnn5LtxQFU33cQEh6KzneZ8YfXlMYhKTmMTkv0cqCjrbAJiLxCh2EMQsGnuelw/8xPf9srGbv1sigx+mai1ZjXskStDJsnazWctvEXid+UFrhjCdr1ik+Dh0dVE7kdYFGoR4GcZMiQBBadahnZ7lo06i3r2ExDhMG5rGcHY/L3hay+C+cOJOV4xlYLIkkNXIK4E49UIa/b767W/p8AKfJl7orgfC4rlhh0a2logCsG5NJ6chZj6qyV+VxbJYfag9tbtK91rS4UIGkZkmAbz8T6KL1LAdzpwvGmm1VmptUJszb6qWqoFzVsY7Cy6+libSpau/PzSSGj0lmeQ7H7qwfPKeacu/IAi8aQTrDAmB5WFNDBQ6F4zdmi1BQarhrIjzqinvTVYxJw9KeVzHfWVMutd4QbDZpDMM7irJUPYebT8QBN9DPv8t88WiaHS3Puc1F7Bslvi5m98k7zWjaX65eIqT4xDfWfvv8VAiollEM8u0oR2B5aztGTQuYBid874ElM+8lhC8h92ycTUR0ilf+KeAwMJJl826uUGwuuVA8adbic4965u5drTVug3ranaC+7WmDNHQ7HVrOzEoW9pp/GhL6eEYFbBgrUpNDjuLIjyezPp+R82DFSt7Q1c1X9WqqtpT5oF6fOEsi1rF0llHh8ZTY6mOYc3va7RWzLiROc+hFGLcOkDiGufypWO6Nc3/Nqa7oPvvdwhT0dMaTPNXVHJgF2ONYHkwnh5SKOwvMia4Z7l1mmZnG4DDLGlgzCzpn6TBezl2KLr69NWfSTb26tL2ZNUsQy9QQABKGJwc7KvbGYBIpEi3ZUGq300qyrJ4Efgj0NX3/S9tp+d5CcDDyOfQ5R+9eCSiHdjMi66yRUBHHneWQkcAa2kLQO+xK9y+pF3qhzATXzOzSYRJUyMAvHDnID1lowvkTUUGTT+E6uE0cTwwQ6oTHb05hAIyjPQYHbDdCWhEFDN2tIecnxUXoDZ+hlT920grOF3GSrwIugxTIsFV0bQfJYtqcKinfJwLN6o7ZR/kz9IZWAfm8U9kcek+dqH77bIJGtwLT1Ar9VlqBUVmrJ+3NFGGswLPTTg7V2lew3bg8WhXkAsUN0kIPpBwXW4LsNokdj7BgqNB8m17ZDKolHVC6jwDxUs0X+E4rh1JWRpM31jf9YELltvEWRVmr1ICP3WttEz72H10SdfqNc7XWebNeHr3FzeYTcRVax5zE6XRS4+Z+yzdB0q/pvfYDUDOHplRfp92E7c+82rUcyY9v5fi4dpOi+da7etrCBZPnSPnvHMLlbKUg2Z38CxlaVtMQdoTqs7npBXlQQbm7qobPJ8tFpXOP0Fyirg3ThmzZs+gZviZX5ZxIZ6GV3cJ9cZzDUWx+iOXuYD1q4ly7EMtMDaQuexpWFu7RRrSntUuD2Oqcp5c37Wmqy0f3+1o1CPFcdoFzA3lWKX0lOAzAWUejyYD1T4zQsOLQ2grI1GszjGndL7aWFBLLrg+F3IniAIxrkDAFTub1XWuK3Mxr9x0pVCGQzlFifOhZqK8q/09pW8PH6zJLz8RssVOXSWhaXVpoNDMIlq2XJ/uEHWOVWAJcPAt/hlSUYtFNnDlWarknfA872ECipOYxCQmMYnJf4FU1GJRiCC23zjLsV5QDj78D0mjgZ86DdcCxt1DOGtzwVTRrM1CUh0JWK0JoiE1Zge1nxBzNVdZwjsqCRctAaG7cZmfi+nl/rZ8CMsUfthxlcP2OPFbtB6whVANFpGNOLvqvVYCS8wuFXjtdbzCaH4FBEG1rTQlrakWoNmtLo3DsGKrWhSmHapmXKnq15zJi66V3PqmXDZM6xh1vlGcL1va15nzaWML9HlPsS1fs5xX6kWqBQHcLXM1uKuUyM2v2sD2Q/LMJa+HXCsWXFZN/szJULvMtWNZ4OcTWBSm+VWjfP+pnFmZQJeBal29E7KudsumuLJq6mHXkwaRa49T2vK1DYJ62GnyDtaSHeUWAALrqm7QByY1Ew+z7yKxLB498bDbvyxfrLTamTrcZ+o1xhFkTqul4EqwhsX6YAnlssZZCWcqa1+aK2M75TieHC8V4tYAKH5T7xXyYnS8XgLhxsPk3j2BG7eoVoqje3flgztMZ3a+WGaVfiEWRtMU0dC3FjXlUoWc38hLgFj8XykDw+SGAopsymeAfJ8GG01bJu7Q3O6tHQT2wiJx+7VPWe3cpSbnJogbctYrt1Opm7Tj/RSx5Ab9OrCcC15Ni/pds1F7nBvK8jI208J5DSxvopQ4XkRyp04p7PXPRyTYXBLiz17STCyenttymJwhz3cvEkCnHoFF+0trgG73wb53lLvN3nEejL5eiBWfmC9B7xH9xXKZcSQg0TR5zdvDb/0hANzxw5my82Au5saIRJaX+83fIxW1WIwA5nueNxLIJ4hZtEIC3t+LSDAmMYlJTGLyr5UKWSx831/ueV5jpODohUhY6TjiZlugzLP/uDQbCcDOHT4tG0v1+fO0sMcfkQSorVzgkuEMeteG9c7aMHrh2uOOlwu0KT1N4OcMyXPczkjn+IyWHTRh+VDJpBqqVZn8ZPAsPjFANidaVeKDKp2BgKrYAnD7e6Uw65T4dxdU6afP9iVb1CfqtMFqOC0y/nzx2yYnS7dmsZ5Fa/Rmchs2TOromEvJK5NVvRt3zKylv1LTsZluOan3Dr811XqT0kXz2jKtNfHXqv84XFzHUL+mqVscZDvl+Zeq4eITrizs0JCVos9b+6YvADiwrwEr1vaOvm4TJBmwbDvs/3qNA680CPaFs8QRbXJ/lvjJi1eGYiEAlYPAZWGR+PTPLEmg0U2fRl2jxcDNnKtj0pI+U9WauXXPrAC2fLh28KOV+uyP67NP0Wc/P9TGlaFnKlvIqRblYnjW7qpNiinOK2O91Ax+u7qmPNPAFAFhZGWud0lzU+YL31GljifYqCVq4yqLFp6/u517t2cOywfz1xR5sWdeTyDrzmizsB6fO/BH2YS67CMbXOGxP3aX7ziZgzRbIEllWf3kWptLA8j40ASxvg1mvvH6S9hU1BIIWGFXjoGqvlhK7eYp15sagEc/iafGn2XsG7vDZzSl8JC8W4vbjEl+nE3IdScj809hopiH1TlOx/0KWAmhU2tmRGcKeF+G0hTMorA40hqCd2xxjCbRLAUgjNIAJw9HB75NijyJZEzy5fiYQc/Ca/PPeu7fKxUGnfV9/xAo525MYhKTmMTkv1oqkqK8AdAGKJdb4XneIN/35/zDFy+IyPZgBMRtKIghoLOqXn14y6EsDLmxmeZOyzMIG11wPvGOGp8g3Frloi/sJRpGp5DqcL3CaY1D/hWud/u85+WchQ92Z2unC6LOCyO1rNTq4F/L6n+wV7I7Zm3dsrQ1ncZqsZ5ZqjpeBFQWTcUsCpP91IEhqsXsC1BUxlx6Xk/ReFYsF6280jUn3DmW6Hf6dJyDoxqq6Njh6uxcqkgnvaXTVmtCydM13N9uqxp/p6e0/Tdr+w8TaFXhrVJclIzSazUhSPJTjetAVbEKaj/7Z0pLRRs0ipYmbOfDcaKVHliv1oPxHzUhiBWY9dEZWg8UWovdpeK8rh53jPOqieV5Oks5dvKS3DPteaVZ9HNWw2miLZM/BuDPpLJvqpYbvVOhzUvFxEnrUeCsEhdjuAhHq1IyWJ/drITXCWg57FkOQqWfKApJOao4P3Se+b0VaXZx4ibW1VUkjfXBL+OdNjuwq1gUc94RGG58u6OU7NZ2tJKxdObkOY7rK66nWD/x6UcpeU3PU0tu3/lBcS1LarPvrQnbyyWkXlgoH15+asDw2ne/xDruqjOJ7C7R/FJT4u7k0QQxDRYon1JnLVOczMGgyFSIn6JdjlgUswco59M9gbZd3FAGqdW4KCKFkjx5po49JJbzAw7TAoHU/4IJQFD/YnDX+aDxzgMD5Jt9n67c8oROcYpM29jlAtqly1g4OSUYT3IjifsBFHZWOpuEgK6keX85Nnu9IveMzfkbZMx6hSe3Al6zfv3km07/TlJReRY9kfJMu4ALPM97EbjL932bJafhyLy/hxwOzMSiUuXFUXrk1bQnm3VAAB98u7QPuzWa9UWcDNjMxG2UaKzoK71EDaMUHgBauIsH1wq51y+yH3SBMMN9W4ZrvTB3oiItex1Zxo7ExlHNXkwv16aWfBx1rB5fOBeVBRYBct7RmUNN/ko1T3AmVyaJfRsbRR0r7VGZSjrZ2aRx5pME5yY4XVUmwKpZAkpLTSxkWz8x048/rhNPZZ+Ta3RAWwC6G/S/Smarj9QdsXOHugTyPCY+KuSFD/78qeCBdCHOeSZEQ25iORRGXrg9dMwm0YN8Y67GgfkNIEs+mtS0oK8OTNVFwii2wvWk7HvRRcyCoSCLhDQnj/mPSzJC1VHF0e05TrnqeVW7FTsunkNh8q502ViRp3IZ2mE523dsgfluRJM9AlwUWiSsf84ncPfZYmF9moksDnYeRAXx5+y4OepabqEA2jYWt9G6dzq5AG3N62X8HshvEFxH32PtmxQ8MKsBi/bIy9qaJgpTCza7cW2V4PamyjirzjEaFmsnqU7WY8BSV1mvMZLFfN36N2neRiZPg7HP2iMfcd+011nZuJ1eQmDynT9a54j+Bq/VRUKhN6/HXcstt8lUNH+6YbhhUA/JD3mlWOC9Dyc94I7Ztzs4R651dFk8NZbLOKy9WOaCQXUWRsNzkWxxlwNUduatBgd17BwvEFfc8dzadL9bXGmm8DZuI7DtJqGPpXXoMn10Lhtv46kaMEVyzzi4gO8jFcUNNQEY5Pt+JvLJZAALPc87R49/v/p+MYlJTGISk3+pVAg3lOd5R3zfTwz9vzJiQNcC+gBFvu+fPULzXa7/c6TRnXGakCWoGfSukFQX2LZEqVe53tELH9ICQzMK76JElahjiaJuWpA8hSLaLRbz1UuWW76b3Zm2GjhPWlEGp1gv+PNoRhBEPhUnWoG5yuoYQQ3RcD0QGK5xQ12q9Xmb79lGRpo8l1lLs/Nvi+YVgkD73B362/iaWkHHTDGpr9aswzHvqKl6PHDFbHhH1fFmPmmNBQJpUMEqfE2Wmgrz90jgbUSaWBHVOe4gpU+WStJV8ZT6QXC5bE3tg9B8rAbQp4YC6KYlHw+d31n/tmB5RLeWYAfRSWtlGVbt/38JXTckZj04VxMEcOSZujUrJfz7w6Fji4iWWgSa5ZNljl0Uun6I9qvSa+pWyi1jMYT/HqHuh5MhkIK6I8n1AitqX5nfFRDAb7uF9lkbz1a4ymCe5iZ8OjRXvK763koCGKhpsx3lvLqNd7Fvvli9Gf21vOuqTOKbiQtrVLJ0jBUfu5tnXHEg+y668r4L6to3IhB4YbO1okq5+VLSNzNzjUsiNF6q1aXtXdLmL64SPqcteq35Px9MpVHS79NTxMVzc/Ec/poUXflrOd0YsF9e8nt1olmhV3m5RDQ6u2aoBtLz8tmbJeOp/gIZXzv71aXxDnm+HY1lspirBF9Z5DkX9nv6gjILtlE9VZ6hTYIk61pZgo4D36OrFxRfMokoB5a3Wt/VtcAMge5GIvvLnW/yXbihKsqy+Kvnean2H9/3TyNVbf+MDMG4CrpvTGISk5jEpAKkoiyLGcCffd9/5CzHngd+6vv+P7xQed5RafSUGoHvr5vsymwsWn9haSopcaLBb9kjkLdb06Y5zcWCbAdJdslvMzXpJhwrsADd26N+DMBboXotloY+ZJj+EZQTcHxQJTUgXgN/C7NFE4jjtNMojDPHNPaRc55j+iDxlxtPzrlJhxwVQDckseYzLmDdcuXxMa02zEKarn+bBlsZV4Mg6XzRMI4p/M7KcgLkrxcVvW2bHAclNCmlsitMb6UcTXaR7spCriy63O03eogDsySOEN9bYaF/qREFEQTEijAt3CgvlhBotvYs9rwzCeIpJrsJrCrTmi3+X41A+9XAYv+7ZzN/lZIlGRS51VFSk2UM7JwbHdCnJoF1EY5jWNxFg9Tx9xylZImarO30G4uEtPEher5ZAOdTnpnX7vM+NPpAoLm7i9IBga6WrKkRXA+oNOoEZzTmVOl+tVIsBnWQwDqy/twYuqf1rT3HEgIaFpOVuHFVd+xOt/t5rThwm4IfD+Q3CH6jCnr3puJ7X7YqqBUxqIPEBazWRKe8ddyVJbUoDAqfRxu+Vn+9WdrracOHRwS80jBxNwBb8lsH96uq1tdfxPpKarc3mg4GgrExA2dZ3JEiFs5visfgGUOGfmJHG8RT43O5rnkidiRKgl8RKQ6M0nuq0AhtuLM5CzS4Zt9s+yPriL9Or6vI9qjIrcWhtfvuGj3JHZoyS+HLPaWt7VNWl7MsIs0ADV86y+JwLiAAlW/jhPoulkVFLRbnAJXDvFBljjf4PkSCbrHoWcMhRtLulo6w4NOOE41JTZAPPlxs6NAJcT8dXyNBpN5d53G5IimsCMp9mkdxDl/z6jYJcLkisB0IPihZPziqeQs12pUI7xO4QbBoZxeXgVqkq0kWeQ4/bXw05jIrIoVhCJTKUFPNjhS4AGoYpZG7XEzv+FY6AR/UUXyYaHcCkNRtr6tN/bHixU0OH6lJ9UT5ivo4Yqygsp+5vo5R3QXxrcKXZfK2YDPvK5vahvk6K60hmPjKFm1qglu8eE1dKicJFgI7fyiB60rdIoOekklmzl23lJ9gq+EmtLSBmvWuxYG4CBcQd/fcRzAphibutGz97Vz97W49VjXUtvC9LZ9BCe1KT1emJFIj+A1Q91cywe5LbRQsFuYmrBa6bpnM9hHvPsGU8TpZDNdF4LWEwPWm96500YmATt5cSCt125ugbw3P34RgnFgf2yQa9rDaNS4icGvZghNut34Xg2+SRWP2qtvcMauR/sv1E5nU5i4A5mvHm7soizxaaYe8rPzePVjqKs5d3UWoFRbtuYZGaZ8Rli81KzyF/eQvL0OUCaR1LTMWVOqO28m+VTLD7u8gylOt4uN4lh5i/dEJsPpnCsyYMl7mhsv5wLE4XFUsi4W3CQo6BYsJQKeZ64J3Zh5P+9yKIaKIqshK3bcMvD46P+8u80C7Ydz9Mr83D+0eqMqWN0rzSaiPDYbvu1hUVFLe18DX33L8n0L3EZOYxCQmMfnXSIXWs6g4EUw4zW4rt+Ja9madlCLKSntWu6zsOfsET/449zv3iQW9jJ74We5yv100RcicGngr2OVrqVVVNd6tLNpqMz+DV7kegEmHIgD0Hr6C6c+Lm8MCdH0LljFS+WIebPYQABPHPgrAiYcD79zuKukAZCWuJ3frFVHPch5f0rarlu18R21l0w6rEmjJ+oaLP6nPsmrierPAtbHaPp54f0C/vFSYPTv2eM9ZDRZMrMP+EFeOHDML43N+6NpWqaNqv7MTnDvurNDQT+Kj/19AEKANK4emzWqQfM5D8u6i6kVb/sF2XMB1z3LVIlW77dj/PXLnaz+a9t6KoGxsKKC8J09/O1N33F/+HKehv4nrexck70lgPaiWbhos3QismdBzGousK0Clv5syabQ7z+DPte/+s/BagaOjPzC3QTmL0vXLKMrLQQLYawgIAURbIiZ5BO/HFPRaBLTz+n4ci29lgvcuhjOZbda4HID4dLGIeyQL6GTCobFUUVj3vATx0xSSyqVd5DvbqhfpkraUFVP15asR2zdTTPmFqwZR6aIADg3Sn58fkrFfbZRmzivj8r4Jjah2j+wzNtxJmyIUd5cXah6APlvepv4csRoj6lyvpbD6Cwt3cuEadcuF3qe1t+9GNUnCJsCPdPugbsOoVrNqsoi2PCGY70L32RL66XX3/V4bp3DZIUdDZ3w/EGpFBbhjEpOYxCQm/4ekwsuqVoRYWdVI5Ea4RikjVVOL18zSkoIaNO+g0MylEvxq3SOXjUWSTHbmfdHQItePcVBWszCuRZJtXmSIg7G+Xqg1EqcE7cifpKVWb9CU77PUAHxhzSCuIToZZj7XuniE+WhbHpHVP34/XJ0hvtm3d0lQZHrDwfx0h7B2sj2kHZiv2GCppu3lEWh7Yd4gdVk2Hyj9Yuy5n1PPsYkaZPHPpLpnN+nMSlcPJAwCAFh6pAf3JkoBhsfmh3ANa9yPRUzTTCcqixoQH71lLbcL7bPYZXCHpQAAIABJREFUQNnA8rVEl3A1MY3f7GbTrjsGv639qGrjNzcItGm7dx7lyo3a7yoNOcGZ+xOizz8MDwyTjOLHJj0StHW3Hrd3YO16P/R8YVCCZfNan4ViAQ7a3E9V6fsJuK/MSjpMKOFOv+sROl4Oho6ZBZoXumc4WxxkLJVJPgSCvg+Tnu6WTaeBmqU/LSCoqjtsJ2E5fKQmJ7eL9dW3jVgDfXgbgPfpxtsnpARy4wRJwHuPK6i9TF58ne7CEXUnUx0D7LFSiTNcGieJgwtXDSKzQ3TGPDUhvonMC5ckC0DDFXnajrMs3kgQdf+KObkUDypjWfA29ccqpMUC0VrwiDmwZLRcr33pavesa+MkGfN+HnP71s+RwLx7B+EaI2Wc80vuCwpRGdPDE2uFfXZcu2+3EsbP1PdfF+gZASAS+ebf/DuhszGJSUxiEpP/Q/JfGrMw2QDXimXR9nrx3390SCu3nV/iuGda9djofnEsRTSRbVmSPPP4kTH0S5QYhdF2WKziILUo1KXfKAm+fqKYhkoLn7lfTIki1VxTBgN3y98lqn3c8sQcHhotVAHm599PHaeZtyJoGwCVgxKuYa2jU2Px66Y2lt9tpjkb1quWma4nqZbYfMwGtmwtw1K7EscKO9BiPip5ZLl4Sk3+Cgh1ifVHzg6xuAY2nuu0QKNeeFEd800TP3OxjSgWV9PQq5bZApWeVx/986qpf0Kg4VqVuFYEPlyznIaGzjE46MrQMetS679wkp6xzhq8sx3R1CLWfoPwKsInaVSo6l5ZjbsqPHblI9HPdxFB8ttu3YYJWKuV2VYlmu6E0P+rwoasMtTIVaVGCcCGVUGSWP9MGYzzX1E4cNg4NJixWTN1CZ7djs3U7VCCuJe9z1zwZ4oC6lmC3j3Bb3LS9eWZxVMT9s2KrtFQrdUB1x8t2og1bRZuU7bydYIkgL6+Syz55xreRPvu8h0bt9p2mrhE0XPiJMZhUNu6HXYG9CpNtI3bPYFqo+WIwfV7p7FLyFkq7W7TI3hBVqnv9hytRxfO0VPr+NMh8mwXdg+spxo5irZ7Ay6YIrHB9bvUmpgISisFVlrCCmMmQZgtCKCal8Ols/UZykDExxf4jGv2zcbATTdJTHSWd/s3nvP3yn/3YtGxP4oy5YLrBUq3brYMht/dfYM7zQqZjOFx8mxC0w8xu+k6d94lmkNg7qhdpxpySRVx2dQvUBN0EJzoIAZZwpEzAKQYim8aYNVadbHYOzrJZZXbtkoIKHZQM8mfSpTA8leJIdpmveXrXOsGr23T2cUmDRDGNZFZMStRRl7u+CsCeK9NgOk4XP4HV4lJu9utMrgAoDaHOE47GHLHxu9H3RtgB9F8V19zTvCf3bKp2q6YpsOkcwzOaOR36Sm72bn+wqhrcA2BmyqcKW0LiDX3tdAxc/HYAlKLILBsYgHswwQTuE6EGcPynbtt3Y7L9N4elZ7UhWyfLGTJcdKRxdQP3EPWHeGvyNoRysx2C5lJZYKFI/ycurilvawwz6khmOfTMjEkvS6Llk2SQDCRtAotEiZ2ibN96acpT2lu0i5oTxS3loktILMJFmyT4brNg6Sf6CK7RvIc6iTs54f9ZVY0xcSkDkVco0rIew2Di96tQAwDUVzMJoZrboaRhTZVCHoKRcyoKy/BgthUg96Zwqm0qKomOOgieoxq7vnM5XT7JbOcm9hXlLm3EZcbMb2V9LEjI90FlzaXHJADXWQVqv3GcdJ2iXvraAOF1medhfxPXU/+i+BZsFvX144JUPd6hVvXlJ11r5L/z/EalxtWABGZwqh+Qv3yeUCW8XwdO8svvrvE3FAxiUlMYhKTvyn/3ZZF7nR4XGB6s5fKNuNuSUb56Z4XuDVNtA/Teidxv9PutyFuqJX7r+S6OgI3M3rzxxUnWVgllXsR7qOCZpJg04w9FFURStlGN6h6asHKd4KmbR4tpsU6sl0WuDGSXscrrENM5Z7zxH22fICovO1Z7VxTs7OFTvkwNV1mdbVmoq3kz2hH7bs1SGsuFa2EmTEupC3vUVrqgniSeoqWZ9w5lqCUNq7AUYLvjAgUlinxpP5KXF659wrcNPfaK+BxfcBfEC0FQZGkyLAxbrcVjEnpKiACSwj8knOp2kQ5mSxD6SICt0i6bt+EzP+nAcufBwFLgEq/PMGZmaL5Dxr2grvnnOUKrTUXT0hB79tVIZZ7RPNqymf8UnnoZzaWoOnTkx5wFoUFv7dVlc6t1uyAS+g0qy3pJ3sprqkZwmYx/CX4rRsfZd06oWtwES6RruhInejz9+GspZpx8l5rcdBRZH/1qFijP+RzVswXSGnH/sIDlnv4iuAaBv81d2XXDWwtasrZ5EznhMCdZ+/kabg6W8AXbbMDqv4/K/Pzvn4haLDe57U48Xkt7iCkRcOYRh8km9vcobVOSdJqwsYzbsxfMULMwcZTtnP7MnEFXdA9cNmOWyvlRedkRye1AhSflv4rzBaTIaMo8O8921Ssjn4KOhnHeDaoaWTAlg3NmnNJcRiQKhZD7UIxA29bLK6+oz0U+n068DIcrqMWdnPIaShgkMuKxXvhD8BxTlXvJZ0ar8m+XgbOqj/RS3T4af2MGgJnqe77i/RxpyRYWczflqxcIpHvZ1GYxCyLmMQkJjGJyd+U/27LQjlPwrJtkqrXB+H3rSQOEA4O5UdEo/dvER9w0X54CknbT1FNcH+SWBHvroAiRKtpJvFl2rz6Rx5GEujeXCqFVyzVv/L4Ulfe0QJuN/KSsywsge1RHnY0H0bcb8G71bR37K1Ros9wfKZqtdcEh4xN1ph0+/EmKxWP2jFtpTxbWpHjenLlLDWusWdSM6maDhAJEuVWPBSd+EQ1AoZR03pNkw7ReRjML2drT2o3Vetnq1g/SU3knQ2Mm8v7iYI93HY6VDejs17E4K5ZkD9fVXNLElOf+JntCc6vPmdqyJqwYKS1SdtYbcgB3i7qI+1Qfqyz8YB1H7OQO/gtANfM0hevfEPHX69drv5GalwhxSfVsggzKlg8wuIC9xCcY3EAtdA6ZS8h53CZAII9Rzdo20HGycFQR5sFGi69mdlfrLCNJ2QwV7pWYy9TEmjUX/il0rVu8LoT2VLQKNQfxTP0OdIDziSz3jgOi8ar496spVoEYyHMAgzUzd7pYnK/PCUPeqrKOXxWKG0rSJXvLOFzsZYPZFdj8DKtN6Ehx0IaUNhdxs57iJXUoPiAqxczaJdYKcqoQ0kGfJYYFF8CKPWqMU8zOI05dm8dGXPn8iV+rswFRy/SsR8HntUd0qDzi52GMFpx89N7ScyiuXopNg1oye37ZZ54iRsBuPTOD12tna1JRe5e5lHomihmZNIUsTDGZEVcjNDAJi+P/Sn37Zdx6CDNuq3UxMdvrgFuJZONbAOUu674bemgH/l/cDV5vq/8ly8WBAPUPuDXNYj0dLybJHq/rMGtuwZw5gdiTPlqZab0gflSlptNauUac9Km0G0KusvAbs9qJmrapZnRxp10OR+Qpw2xIPk79HIkgW8hE1UtDnLjqZcBmDdABrENrA+43J1npvK69Z3Kk+lNgYZdd0X9Nl0jyy9ys6sgd2PcS+6c1Vps3Ej9HKqnLsFICNetDlN7g5jChqQx14S5eJrgJvOc+TrptfIdaGCZsqNZRbsFXBMV6Hf3sXZEdLuI8oSDYXST3X+lbgcTzeMEzh116mQVzuRZjoR8mHGcph5S09v4hSpT6uqsG3Hbmb+ECrJbgH2EIFXMRQhE52dYvoS1zfo7i3KB/JzlPak2VLOLZ6hCEEIyrVsrwI0u2dLJNqEAbFkl7r8tJ1szuKvwMhkAIT1lNwD776/DzrsEUJD+7C73WyPbK/5LmfrchFBq9v7LUr+D9K0tfDZGlTupafZnrm9NRjCVq1OFLaChe1GSP1F7zHF89WB62nedxq7Dvy/6lt6LBONU0UW5DYMSQJeckg/ZiohdOHMnAxJ1cCoYKq+OfKcP86iglIAP75Rg+atcz9UZ0sbDGaL8VecY76WK1tRdyxyYQtiUzyioI/ODKYRWZxxwc8JKOrsSCSbXZYkLfCwT+FzJTe3deu39gKXAXJe6MP/6T3cEWfkaJI/cB7tUkWooVRl4e+aP8SKi4UUi4aSOv1/+5W4oz/Mu8zzvB//q+8YkJjGJSUz+cfl3WBYrgWOe503xfX/s97rSNZFAQ9ut28FqStbEaaeLbhPTufn0DVSaJtrga8PFhGsJ9FcI+6ZV0ZdvDqprBto74CjNTe4ufcb9vSJOXDC/3RioQ5NbCda5PXKDw/yA96t002aK+thGrY/2rKbdLgnSL2nYKfrZIHBtHMS5vIxJNz1BTvzqxLkcXyLa6dN1Jcejf4fZTquZ3UTAAFaEpuQvNQJXnbmc2oXuZfevSjQbKThrourTxZw8rJm5/QPeZdO+OjYVV9nm0kAj3vemugvMcmhHdC4CiFZrGrlptsaoOpwgS9+KS/6FQKM37TNdNiWLajhLIT1OtOvVtKcn70bdciBzWTZeqLT7jxN/2KoUAQqktNlPfkdxJXRvLNrnsmkB7bb1Y9sDOax7SN+fWQimoYdSazK6alGgaZkcr6UWRWc9aO6dXJzFcnG22Lsr8nuzIFN8kdYHqRQ6eLPVbzaXU3rCLtBaV0Yhf+aTBMdYbPJKB+E2+/Hat2FwGXaH2Z4bH/27zna7HVzXrN704Cdxam4k7JcA8HWpr7ha1+1GyLPnT1EmhPtCFAh2+WHgqTLu9wgOl2geTLywitOxnvRB7pDWJHwu96reUAbwibsrkTBT9qmhS9Nm4gZ+klFM0onCoLC1OES7HtK2G5b+DsAxUwMOEju5oXzX5/C1s+QMWNKheAPVk8SdbNBfgOeOSA7Xs4ny26Wl8lBj4yY4dloD4TS66lN2ovByGwvqQYkqH2CQ22TnkaJAq+T2Ip9I5PuVUzX5l1sWWsfiQmDz3zo3JjGJSUxi8p8h/xZuKM/z4n3fP0uGyncTxw21fVygRYZLXIJYFun6d9jnqpaIX6rBIcukBKzqYEQtjbUhSyNb7/NpdiO3qmeOEE3ovSly0ytycrm2k8QibkC24xjPjbwU1f6hpTP4ME78o+a3t0Bge1Y7uKnxNF05f6V7Fgc37Z1Exh9F+zHfrwXNhzONi+ZLctPg/tPdfWupevr0KrE26naQBJ8OrHaB05w9Xd35fdNE5d+NZMnn72kTPEReyIKD6AxXtVfbZufw8RF5lhcSJQC9mKsAYbI1C+0jJOt+M83ZMFdfoL6nmx59jllTNQvVQgNq3UzqcBdPcS8QZMefx5eumI49ryVlVucYr2nQxWp1vEk/V++ksUasS6nMciX+KcuBdYoq7v1YItiy5X3J7CoDpEgjrw0odHGG1tkCA3W8ZCsT3DNMvEna34e3uGiVvLO0DmIS/VKj3ykU0X2PZHvekyYq9dM77sffKrpei17rXVvtWXprYZxcX6CuX3OOe5YZzZVNORlm5wpU9bYjokGf/ESsw2qtDkgwH9z7jO95lJLjamsbEOIXPhyWb+mPbWR8GPNye1Y7y+IyLVxUf2wxWMjEEhjfCHXwEN0aMveS0DEz6IfBzk7RmYKN8va5Z/q0oVisNqY7bVtHiQbE49XPXzBdofAT9wTtOSKbNX/IpF2h1oPQQPeeVrUdPPeKjbluHwjXm33vM/ShHih42j3L7DXSx5to6Sw9++7NmlhPG1f+eRPCGNuPBTT/+W5tlLbRLAzAf0bnMDPkJwZME+f/rzZ8zVtELFPvW+TfVvzIXdzz3gNu9H3/i9C+TOAl3/cz//HrTpZGDx7pgo2tS+QFhoPNJhMUR7/jRGOOFcqo2dBM+IJbT93Cu4oEuvJPso38z7ffP2ILjA7yiJrCkS6wZrk8lg2Cj7xlRCzFXz+Ao4vjqXGnrpV99Jhainum1yZtppi5zqaMg/z7jL1MpBaHqD9DgdZlGENoSeBCWqttmweRV3WfTuzF/eSPpP0ng49Tz2cojrqkYKl8WI8zhmw9wSr9WVZtOHBnNZNrcZCn9ouNPKeOuGoseJfFeofisWzZy/mAtxAiuZqh6K5VSrO8Apuskznoclesrvjb9HG/NXeHSXtWcYl2li0WX3GeQ8jcW0cinefylXseez5DkC2gH2M02cRcbG3mbiZzoHzNFiR/i8A1db36VGzCPE2c6z8jcHyJm7hwmtJGaAEtw+l/zTmuvU2RjPhwffhWvf6f6w9D6q3x5Du4xdeM4mXHowv5yA/IzRX33aX5yjuh46ZaqwMcPyiawNtpAlgYdOI1t695mrjDNhe2YU1qpnsugI06w1/NWw7ZZ/23yyvGdLAxg2Q7QSe7sb3g03eUQuN/tC9GEiiAVnXgNVzA9+gNmh39hnxPiwZ0cQWIKh2TCXl3Wn3SrlLXkRZ4tFSQi7vDNitqpJIxGCKzo8+DwPs5TsF7ntKMT55+OyNHCb2GIwM8glt8woiZ4jXyzb2JIClvmagPXxleGD1IHzNYQF6/QWBh3j3RRZDu6f+Yywvru18fYAHsGSYLWHrzoN525Cd/Gw71n0AkuAHI9zzvx57I/QghxnMVfN+YxCQmMYnJP1Eq3A3led6lwEtI5Y3PEUujLGXa3yUBRfkl+N1Fg5uui6tlCbQFWqgm9elHoq3EUUqzAoHpHWimGlfOcUjUHymy7Nssi7vi4NnS6H0jqwR/1zC+N9U6ikYEx1IeDt3Hyq+aVjNTt7mAIH05pIGrpP3wVpL8wFwfq2nPpZ5oJZ/7ooEa107m/2wLyjYqlC7yo6BvrvGlP+Z5or1Figjqo2iBluI6VUnqIb6S95aKavciN7tA3rmqVW8qFbXpxriXeAfJ0g3nidysD9ZEXTxhyKfBi01D2kFj544zTXTZjj70byzEilaU6hGkYFQ3lvPikSEA1EsMIJot+VgfXdxRYQtjwEyxIsYMiQBwB1PdsbS1on1+mt2IU2rN/BzJFO4XInu6s1jgjpX+KkHTto0/dNqg1ShfuH6QOz+zjVgdFnzuFapfHi4sNcqxF4pYpv0HXO7+NnmLPs7KM4h1u/35wQkGHTHtNjE4pF5FWAWU4Sf84YPiCtu3o6EL4Ju0ZzWRV6QudN/rZey9WXidsyzs/jvriIsojlL+yGVRz1LNW6RvJxiPI7ODe3y6poxlMR529pLrmcWYNOokuU+KRWRWjEFVC0ml91glaFM315KGneh5lZjOkejS8aRTvmJpWFJ0W76UWoBD6NwPFPUaSB4UqZWeYvDuRIisjT4t0k//aAdzFTZsn2KkF+479i3TWy2Xya1ud2Se5yHVqzfRkpF5ood3zhLQRo7XE1csTq98Nqry/wTLAmRo1gAOIHXqqn776TGJSUxiEpP/NKlQ6KznefMQj10P3/fzPM+7E/jQ87zHfN//1fe+Qc0+tFoq/to7vf8FAi1hyEqCjFmVeqWfs6iZlEftPUO1jwxcbGBed8uAKVtPMpCyVgXAG6r0DRmK0zAialFEloKvSuZMZbH+0el4Po4TjbzjMoH8rdmr2tmcfI7epzrXg+KH9ZZC30vUBNEMzdXT27v7d3pCmXO7nKXB+mw3+nVpNFaiY5/qocgf9I9HKMfUupkWpC6VgOjPkVcV1tCHKd3v6sPSjtPJcc7PvxrZV0plZ4mUZandThMXcLXr1mG/83tbwLp/41f4oabRvq9BZzu/Pav5MvHcqOt+QT3H8WOWjkEie7CUeUPkHdu9D1GLFNUb52X3ds9eNov+da2u1Ye3mJokGf9GmlqNY9TRjl44X172oP4vuPjF9UiwaIH6qZ/bcxeN0j6LepZfM5KO22QsfJoh2rUlaT1Q8LSzhK0PHud+p2nXK5X+uaPOrx3PVeXnZaDWeFl9+UO60HuUjnkdj/5wZVMFvATxMPRWs/brxpt4v0g89g+mSNBtEy3pfr1kTHczZMjn0G6TWjSqEi+9TyzGp7iXj06JBfCrqmdcX0aU8igyTXcEmAou7KjWrkKoIwug0QKN6poVdJxyhbmWa3ShMTuC2IxKz205wb4ylsVXBDGIY1qNdfKp6AqoAEMTYcKR6H2dLUCfCBhLuXkPjkCKzRV6XmQ4RMyKsiRijQvSA65UD8VRnU+mL4bbNLnO08TB4idF1x7Ci+6Z39Y434yud4EYfqyceKX8bqYPQ8w+iua7+nuloi2LA8Alvu/nAfi+PxXBtFz7rb+KSUxiEpOY/EdJhVoWvu/fcZZ9n3me1/5s5/8jkv+M4ClvU2jcTNWkZ3YOEur2qm/83LgvHc3GE0NF9R89cwrKRMGAUWJRKGDwrHzxZ5Pd9scRgliEyS74g4KWhigq6ijQceMG3SmbcK2IGssVKfWy7tiIgxDOmS4xmmtYQJI10OrTGwDiJwSMq6rJNNq4T5yAiCbs2guidSlU9YUsUTul+JGc9zNNKvqIVsw4ImrSOCWcKTkobLXHkqtzlaptBvk9h6+ddmxxBItZVOeYsxjMiriEjyhVy2KHZuClUORiG/er2pRCgPSwfrNCTRbzCMvTCq+1doXlAR6jjVag2a+w11QKHexyxR6597tpV7j2W8GnSY1/Bojf3CwEY3ttylYie4Rm4fo0sSyM9iU9bbdLvDJaEcAh4i68SNTUar0C66b2fnm+WnUEEnmu+qkhKN+ZRR771ctez0iNNFbRhB1ntzy1TPBNb2ixnOUCU+7edSGvpQhiy6y9xfSilmJJ7T3mZ2e4cdJoi1gAxpOUXWcdv6kifdTTF3RigZfv0HuR0doGi9udhhKFsZoGvmd6bRe/srjQ10POoVuxoB8v7CF9VfwnRfatPel4owxN1pKP+c3E6GxSsxy2AJ72UQ3b7iqvg0844j4lHLGIxQVL4V19dx/rdkyIMNbKLUceDO3Tb89InrsBHRXweJvNIYvBQmp7/yQ3qz9PJpO9A5IcTNdk8vLbudqT92gT+048Gv1CrMZI5Ry+j/zTA9ye593g+/7L+vct33Se7/svfNOxvyVBgLsZn/gPRh07T4O2e4DOGi9scZ9MBr/jNscbk1dF7MAmbKf+VTqb2wgy3Hc9okm6VGwgH9VBP1nNxrGJEG8UQopWKx4ahGiS8nTAzoD504iS/mYmfw679J4Nbd/DIZjrHL3GbMCSxO2eVh+8KqyZrm4thVeyCyara2ykmsDuA5txMvhgdfzN696brkQXPRrNr5j/jmTrVu0ofVZ6WoblL5PH8lvNZ7CA6ymquADuM2pv302Q7W7uIXOnbKeJm+QMnnqM6m6yMPeWTZR/5DIXOP1hqMzYNI3qHy6VdocLBe0vkgnHKMgzM9e4Y5YjcTGbyrmhrI3ZrHXcXekOoB9Atu0DDudn9FLueiORqxa69he6mI7iSQe+cKJJugszutN3XDS+c8n4TrRU9rL6i3UC6ZXkjtefqmPadoUDsIpd3fNgbdIKDkRdd08zUZXqHTnA+kQZQ0aUee2RhexP1EkrT66fn5VBiyPyccRb8Fbj4humNHfMB/auP/WO09lmXYPw2sx2EZRoSk28BYXvwylDBUMEwl1IKlcUakUrizxb0bFOUJAt51nOSeuOW5igz2zJXem63Q2aFQLpYRCAPYpO6v07QFEZhocUcyWlguozTFJAyVeh8zrb9kGiKxGC4zbLvQ466vd+SEnpVpVCH7uHLqxv/Vi2fe6EElU+4zUJv6QlPHVYPvKbPJkMUrqAd7EuFjW/GUL7XQLcFWFZDCLQiW/4hnN84B9eLGISk5jEJCb/Wvm3ZHB/Xwksi5409yUYbJrL7yfIytpo7Kfs2CWZOy0aimWx5ZXWjl9ocLZkNj/O/VHZvBDUl36g49Nu2bujoUSWxzOunPn3QN7TwX/eLtPYDgSWisEZ/wARzSSNKK3OZk0CatEL5moQbqAV3tkIGVa61ZbfZNCEz4BPyRToxSHLYoVaFg0JEu8MLWpIzQah0o/qAsvtHrB4XrpV+q9/09nOJWFU341TyqOgjY13B02ikusgsA7+dOR/GZk4KerY9bzqXA0WHP6Mps7aMApxc21ls9YFni157mZmumJXr3AdEIyN8/iKxRr03rNVVLqkJnsdT9SGCQIRrjT0hKPuvj1NCJWe2zoSAP8rj86tBJY4VilPP+RSp0Fbol4VTjmI7CMa9bTkw5ULruSOfjKe7HcvcIuzwnoWyIs60VBCiuecPMPrieJ+HLRWKbnrwZJUUc3NqqrHF9Qu0Kw6czGqdbIhqzmVPXGuJPuBBWJlSQfN0+uqOzJnfFtXtMczstJVOEv7wDCFns87zt4Bcj17d2ZV1V58PFBHLfALTFILZIwYoi6pNSwRs5Kr4K7hawKrdwhyM2R8dsxTd656GIuzq5K0TazvDRniKkhnF4c82Zeh39tM/d6G3AcfK2jEPtOWQH/9xOdr1nj/O2G6tvM2hR5HQuS9EfMCaLKgJfVBkNi3joDerCx9RZZfmxc9sfIiWcF+C/SXlcidoWRgbY9X32fSHyU7f0xtJQI7uIuk0zKWf/bLGWUv4+TfZVlEied5NYGrEEP4c+Ad3/cPf/uvYhKTmMQkJv9JUtHQ2S7Igr0VCSM0AKZ6ntff9/3l3/rj7yCRyBIiS8cBsKWnRoDVBb1z7YV4tRSut0dVo+24gjWzTwvz6uEONR130znK12KcQsW5VZ3/+7e7JEAwu2F/l2BmXExLskTD65mXw4HxqnFtU8bLBpU4L0va4VkgOiTzVQMx5a0FMNAgghonyagT+oFpMJdAiQbH4qMVdPxJ0O5/1KLoFDqgvuRDCvPzOgXxFPOdH+yufDo91qHoWPwfiNLxQ3Y4uok7UkSteVv991nkOR+6cTFdy+uur0wsiBxfAJdlC/3FgEIBFqxJzXRB4PqF4hMfnzraWTNmpZjlAPDOKeGauqmKBFXX08a1w+CVs3bIOxzd+BHKSou4zU7j/8VYiX9NLBpL7TRJ8ptbKpQkmU11YG0M+LNGpQmkuAGFzkIwGG4YvcA2AAAgAElEQVQeWc5nXlYe6veAs3bChYscs7HGoE5Vkec85+RJd96gemoBPI+r5ZB5gwyUDS8357yGMiYTNurYVxaP1pW3BFHbG6Rvp788mNv2ywD0Fb76zgCJglfnOFu1CFizORJLWTSoC72nSXDALMS+ecuo306uV5QqlsUxRVfM7TXQWZkru3cGIMtb5JLxLMzk6HD+HILTmmVUJ0TpsVT08ZIOkOGJRVHsR6dtfUZTgcNDFIDiFTtBvzenvV8Nb/w66hLCQq191T9E7WPtPmrt1nhDpAAiGr+sUZZ6B7DqpyO7ECRH2v01AZf6B6IS9AAiQXXichKZGrJmVI78ySPRU5hxiDqruLIm5UW++XrfRSraspgC/NT3fUP043neAMQR0uwbf/UdJRJpFlSMu0YmtPgmEu1JT97FtmeUfqqZvuaLcLOy0Trvp45zV1ihFnNtfMhlUUFMEKy+IVjupIz9PA9qN1A3gFIEJ5wI8OWOB+plCYaHJd4QEKcht0wg7X0gIk3kqFVkmgmnTkYvTPYheA8SzVEjD+cGarLFSmdosHwaJL0qK8jCDDGUDyytRu1dcl3LyD2Pr8jZKjxBLZsKumnPUnmNe9KbMaqpjF5bLGpy2KF+PopihBOx3IQpqZK3sJkWzrXzXOpNADxc/ATXJ0nGtC0ChjyawIPMrSKTqE3ShaS66/4Boab/UeM3tB8DQH9aUyHr2x7K/8iZq0WbqkFpz2jj14L8D7Z6iEpF0UWbnuJeV1nPkFsQBLttMbJAdyGprEWQOpZ5XHvUcW7rHvJdgHOn5HRpy5ujdAAoLj93QmtXqe2FlwXB1oqNboFJ0Hc7ebpEjEdufM6RF+59WdxGt22cHZDQ6cTU+wZZDIpfrkpSTjSCqHfhCof2Cy/YOanyLJ3WitvK8lUAah6RMTTgCc1d6odDfZlE1D07Lgl+HH2IgqFpQeA/lMR+UFkIrL9HzhEU0PZBTVxOj7nDbhk3h5/povIbdUc5907n4Jp3qcvuudD3N1S5M+OLoEQ/97najs6hqoiWq/GUrgzZBDRrUaWyTfGzaWU/5WTttywSUWK/VYxP4m4/cC3vC89bRkP/Nz1N3yoVnWdRDzRDKpAFRK17MYlJTGISk/90qWjW2d8A233f/01o311Ahu/7P/tHr2sBboDIRnFD1V4gqrTxI2Wx3mkY65aKLyap216K79fykRqIantTjtNEF+WLJur7sgLf0Op3fKZlEk1L+R23uWImBtu8JqQq9d62gigJL/ChqoaRq3RrkEZ1Pby7DazApQXcIgOQLGtwcNmjy2GDaTjGQh4Ohqkiv3OYrMuNFu+DcXpM3Va+mrHeG7hck4XdRXXsW7iM3FQJIhokdi3Z7JwvxViqdhN96bxqEtAt3l6f25uKxWXB5s204F6eiuqO0SfEdbMzoRG1f3086tiQ+37LzBxNzUkJHVCU5B1Df62HxIqI7Hicmxo/r/vkHS6lh8tiflSjquby+ZBL2bC8I2H5fdfrGH5IrpGdLLpgU7by0iGppVwzWSwMY4c9RC1nTb3dQyyV9WQ5F5JZUptp4dxnrx4ScObUZOnHY1SnreqdI9Q63bjtf51bxrbTB0k0tg3rab1W/SKa5buwVXf3XLWHSz8WTYN5/q1Rz2y/O9QBkjW+aW4dgBp5GmpVF+WBCdXcMbMsHTX4DTgttkSH+dzD/V3mvpUUNem4cUPgarqKcnKTbmeF9tlrT9ftDv9WRhSIZZnfTPxLpVSm5RF5LisiZFZnt+JcV5L1hV5icd2ybQ5K8cXH+ixW7mrMMHhXXV/mpRvZAXapddGwl+48iXMP+eqe9dRKyC2AvXraj9R6n3ykfBZ4n8HwlhqPfYaWOZiDcytaW78puF1WDIncq7MfSg4za2IlAZB3t1w3UraC2X9GgLs1cLvneaOR/qyPGGJrPc9zRWp937+sgtsRk5jEJCYx+R5S0YvFdP1XcaIQ1PNCGa0AebRxdRBMo68ed4zqvxJHo0Enf8jnzgfeJVP8qpMRbeVyPuASZRE1FtJNXOygnGZtWOC145gNQaKcQm433Nfc+XfbaQlNGkFEg3Al6necoBpYNsFLiah/eNc8aGiWhQbBatSDzmWZLo03vx7s7SdO1EbDg2opJUrIH6+alINENoDi7uLT7TtGAxqVoSMS17nkYQEDPF5lDE/3lGzo459I8lYLLexTvekxp1lebFoey12mr/XVmgRRz5bSg1r3CZDA+i+VQoZ0Et//zS57CT5rJte192QQU4Djus+C2aZhAizSavcXKhvWBMbyWlc5zwo63bpnFnXTpG0Wv2jKVi5NFl1mxVq5Rr3sIOnPxpO1J1zi0gLRF/AZLxf+FIBXz7s+6rw2rHe+9qjCWJavqDDTKNixBkKNG6hv3jIOZIkVMPt5La7zfEsmrYgAsKGL6rXqS993uhHJEyUuVeNFsSaKh1blvWzRS4uyRacf/IR6jYcEt947QS5S50ixC/JuOizXb8FmDpVhCjbgx4OtHqJPKzFZIkNl7JdYQBfYovE0i9/FPxgEdW9Xjf4GshmxRSyLzF8r4qMLLn4xsqvEKny1zD9Maouio11SaXFGVZLeEm36YrUGUvS7mzwNRuo3u8UC3RfBVxa3sGTcVFzm+RYNQhgzQzcCq2S3PtNXwNVJ0eezDfroN+ur22CdHqsDnC+fWTkOqu8qfnsPb406XU6Ga7nYxPC9yL4rZrHwPG8osNj3/Vl/8+SYxCQmMYnJf7xUlGXxP8BDnuf9FXgHYTlZ7f+TAySRSCeX8WIwRdPGqnDKabNZV4nzb+mJHq5UZNVrZElfmD+IjpnC55O7Qy62o7EggqZwp9NOrFTkT5jj6giUTTgjA44mi+414z5xSnZmZVBnQP2Uk64rV0bAyl9w8ZNBwp5RcLQEGg7RfQboeZiAh8rck+/o9sdQv5WqLEqVdPSReGoMF40yon7biPlj74akZaJ5lahP+vPE2qTtlyShhPsE0XXVlMX88mA0ZYBp143Z7qq0vakQtRSK+A2SJHRVWbpP4HmG6fNtKnfsFwiv0qX80cVATKyWxk2Nn4/i1AJ571aW8tFwJhjw0/Uvk9FGay6sldhLfJOjHDokcGGLT7x06Eaq14ym+8hfLhbR2127svyqblHHzuMrZuTJc07PkjjDh1zmEF3m0zdepdfp735rY2lORl/Oe0Oeq+9GefEDtomlm5+RwZInJe5msY6hWc8yuVQSBdvHiRq8iZZM6SIxixHzRBt36JsMgrGjSLl1ZNPzEkkAnP2RtmmIbIrrVHVJqtb+r6tWIn6SjIXWK0SX3tCluUtqtYTEB5SqJZ3dZBfnR7UjfgAB9Yhay44i5yyw05en/TTATYYg5HuGyHectk3GqKdDaH+vOm5MWkXFEbt+7+J0Bq2vrN/ATUCJ/j3SuLP2Q4t+wd+A4DetvIcOZbOIzmYJRDKiKYIgGrl6WpMIsxVCG8kLcnYNEfYHvpsY6qrX5z6c1HKqlfXDP93EPUQkcrrcb/8eqZDFwvf9YQCe57VEjMLHgKae5y1HunqJ7/sHv/eNmnTmng6PAfB0vtSVrpUpl91xojGdE1YC8GSRzL7JKYc4Xqv8Zc6xwix1yzfJ6u7+0JMs7Zv96mzW0NXPTkmg+/4q0oaO9TZw7nGZkO/SYoDxiwk+Uh0NYyZAiQax7EOZq16Ot22hAHWGSVnB/pbROjY4nrNFIYs3KEV5GIZntMgaiPzxxBJa2D7NYvV10D+/GG5fSpR87R1AmbWZMkUmoCzyeDVNQACH0qQjLZt6LW25RRlcLMj7sTN/A1y+SR5Z7rc2uRceSmVYskQPO4fK4lqNccsQNnr0kUzmEY3aDy2WyGG3pLddvszaOZ0BeGKQZPU3bBMQ+FlU8MKNO10tZcupITnIebg3WwL0llE+gqlOSTDX5G9X3MdzXW6KautXnOsWQYNkm1zMJl5CAugzT9zs9s9J+EnUeZalvJxujPuRDJi9b4hv416ecgSCdUKwYWvbkgGdoq5VjWPYmrxmqEDKa3KYyR/dHnWeubuSOEmdO+W6lvV+267ZzGmm5WLVjRperO1vgwMPL57FK0myCH01IaCSv22jvKuLbe6ybSH08dV9tk0Wo3szJvJUjmowCj0fkx1xPF4zEUDEe70EuDAgZ5FTsqZMuDV4JnUJ3fu8cH0nTpNrRrrATP1GrtTtBuBKVbyOqhZX4254Tq97u35Hb+kiM/YwbNFuMHdUikHXw1IZtul3nmELpv7/XCBelbdVc8r+MJAwAaJJDfsjPbTztB86U76bSKS6bqMVoe8qFQqd9X1/k+/7kzSAfQHwJnAF8LHneWs8z+vx7VeISUxiEpOY/CdIhdN9mPi+fwSxrP4A4HnetxQv/Y6yPdcVlPHPE+RXC01ZXZTQm04FonG/1EwIlUqp7ArSnywQVaN79kKu5XUAfpIgmY5PKaX1NIbzvGqbLZRPZwenWVAsCVKWLDbriGowj0CxlVI0iuKuUMYbwraxgTbwrpqw4RI+ZoZGh+xVVNMpqQGd2qlFoVqeBal3f9aQS5KjSZZbjIbIE2e7oMguXbbPV89axqvBsRGFv3f3/Enia0BQGtQ08M204GcIH40FoD/nh879ZJTfxth6J1NdOVVLXlud3N4VLhqpVZ6GM40Jak5ZdvfGUIKfBdBrJf5FdpRC0zgl0lKooxUf2kwLlxxoCXJzWvV11qNJe1bRt0h8Di9/KkFql9zYL7BszCI60CWAm36oZUQbs8NZWsZI+/JGuZa3w6dRfwm610kQc3AyIx1Ve36rACJqct0b8g4sIB5mtQ1bLgN5LaptvY6IOvxU4gi+Giqu2itWCChhTpe+jMwRC7hYs/kfulMs9IePPCZJeMATqWKZ5TRr6/reytHOYKgrnWp9ekjf9c+SAmqBZ/dL5HpnnbqsLZOfma2WLlug9TIZtyVq+RWSykOdpE0Gjw5DdL3FokHfereY3ld8kuvcXGbhkEQ5ttd3/ZV6gc5E9FMpUrX9ylYwSaG+BjqNIAWQAAdf7qMQ2hKCxLs+5r7qAxFzmxma/nPIsGvY56msDhcDhtu4zTKzX4SjCr2vYQm9JodwNUcnq4fAb+Hh1VSL4vBmyotxgv1jlkVFBbhvtL9933/pbOf4vv+nirh3TGISk5jE5J8vFZKU53me8aH6vu9/Y02Lf/z6m12j03zxpJkFYMHPTovXOcTYg6kPAaKlvFokVsHVKaI5riWb3yiHgmmdFlCtxxcuSGZa7Zec57Rqg8R2PiKaWvxEAhXDYrb3EdSbUEbPQw8GAS5TMEwJOZfoJCXQxD0ru1AldGBjma1SC534USUSBinNiDF2Lofx2rZ0Pd14ZS/OIOCQUouoJCOoT2Ba3oDEVx2HlBUMevHIEABaJG7mEm2I+a7P4WsHaX5fkQhGfVGdY+V4o7bTxNW96LxVbp7UZC/PxMk+C5xfoPxUz564i6sThOZ3aamYRr3iFtNHI5G9Tsl7OlxF2rOJlo651tp1Ll86y8JAEqkUunhDpxViFQzpIpDefrxJsnKHLUbUz7W05SdEW6VX87azAiyQb7xa40oDkEDx65KCOWngXYxeINpxfj+xLDL3S4Q0u85K1q7tDMCSbHlR7UtXcyxOfNBPKn68iBQe1qix1fzYopbXx7R078eswVOc4/YZ3NVqruRmtXb1Nwzy243lLhH1r/qOl9LDafytFGZuhbGGMsMlB9p3VI8vaL1fR72Fa2y26IGLu5WoYpyZuJ4tO+S7jFfQweXJH7jYU56SLBl8d/OuNgHVzScEooiS51pJbOn260JfmX43pqnPfyQAmY6xMskh5HRE2XJdLLIeLnHUaoXQh4CexALdO4N9EbUGXJnVBBzkd4LGLUsI8T+ZWm/B/v1gITZfv91Kd/uokySQk5MxjtuzJeOZ/NuS8nzfv/lvn/V9xHjAO7DHk48t3d8NQLIiTvJ7ZZBZKG/psa3yAcXXOkqvlGhUzk+Y6wKiZxMzea0YTlP9qCCYXOKVM2ZtyM2TbcikqXDiDVnQEibKBH66FFLUdXRUB5ItGhsI6GosmBX5HCI6GHMGaVB7wbpgYOoA+ljpgxqfxLmmjJbc6gsDDFHzOaKD7Y1tEImOh7K7JmQYWirkkrJFwooTvZ4YVMh9sUhee9OUoI9ssvj8kHx1lyTLhNKSTQ5FY1KdYwH9u7rDivPqMzJbMsOt760NDyZMdC6vHnFL9bofO4r5rVVkEbAJrufwHBY9H+REgCCUzG1i4+AY1blJl+yaXaQh5nqK43RUZT9pak3W6sR6l8vu/5rHuR+AN08YgZnIOVW/pnijjNvfDQxKvszpJ8Fjc/VknooA8F7pFSzM7q7HpM8+irvEFZkahiTOvMSNbvIcPFPceWk6AH445HMX/A6P93D+EMDnWaIopVLoUEXjdGD7GbA5STiZrP5zdY4595Ndf55yct3Nbxg0Q4gP08aKL2ZDUXOHKnrvHQlKt1FFLImTvLdX9qV7MuDr+Pvdt3FtssyEX3NOVD14CBY7JhK4DO0DSsBBhupcoouE0SMsDb5bQyZtAiKWHaYupMhFuMncETZYw6qE7qVB8PwhGWRO1Y9bKcR5B4dcdAuOZWknBtcda0CUGTBJFcExWjfdZflXDu7v2Wd0EDhp1aAsF/6r742CMqlobqiYxCQmMYnJ/wH5ryx+5HnbtNHFGAYywxc89ypEM3mEh5yJ/RZXA7D40FWU5ElouW0P0bj+wACnyZm2YsHDFxkSxSIKEmT7Ji6cN399ndP2n1Mt4faGuFwHcyEdzYPq6poy15C5hDaErhfGW0dUuz/6Y8nj+DyunnM1pM3Q0phGezwbfDXtPbUwImsDXPgTqnlZAZZIQ3hXA2lXWkzSLBNwroGhw551mquJWRjjGO8C3AaJfWz9I2ABt8rR2s0DaY8yrVTcM8Xvi5ad1G2vO54aF2THG+W1aa6WtV2Tw4xX6KxZKS3Z5FwellF8gyvcGLhIfrtN0navzvgDsxTGeiVLgOgCVxaYt3feko+d28rGi6MWD93rdp5zORFmlRpM9vj22uitqDtGsqq/2NWYTxuK1m5un8x5opke/VE87eLED9lf/QxfUK9c2ds36ed4yqzWfMIusWbnNevt2nvLDMFmvje0I9ml0sYZcUOj7j06bwrPZYnLxiypQyQ7q81cX1MwFTmwiMw9u92V+gmC319xHgMmLiIsOx8U/rIdNOGKG8SiuPbl4J2Za9n62SjiAQalyXnmJh459bmgyJfCzafXGcxtzQWuO1+ZYi/zlbF53PEgocFwCs8R8KjZ420kcAEbnsDynE5AifpSLOciMhSpGQqBm6szjoHBXORFat2nPAnlSsSvwbEBl8tB6YR7zieGCQBhzJXPwpKVeoKZOoeIRObxt+S7uKFilkVMYhKTmMTkb8q/DDr7zxXTQM8FDXRt2yqJRnW2ixbn/0+wUObVEW24ZEQN2s6R5XjdVnHSX9l0idP8/lomG7gHS10g7TKkUM8CpxoEmu7MUcqUWgcH17zdeGa6AhbPVKujxjbwVdGOaCH2mcY0WQci+4OnAy0or8eXDgosHQvgvjBU2TVHBNk83kS93nDKiRFeJqmlEdkVxEn2jhZ4Xf15xRwYoNrXDMEbHySZyzVZzrRUy0o+VFqLnx+XRt6bKAmMlc4/waUp0m9mrc3eMwSQgGdWnGiDRT3k2J1Mdb5/80GP2fEbJjaWTGWrR2EswU3YzgdcDgRswzMY6jRt04hN2/8Nd/Hb/WJRrMnILNcvFl95nmEO7mqWpTHdLqcbT02VhK7xd8rLC8cALPMcAk04S2MsPRLEOpnPYHfO16Wirk5ueDsjxwmMNX+8mHU7BwRM/r/jtqj2pFLIoByJByzs1J2ykjBFLIqu90l8bzjTgoMan7piTi7jB8kz2DdgMOM1WZkOEmv9MpQZLkHvZzgiaWdRmDVmrL8jZzzHkqFyM3tPk34c4dM/iAV1wRGxqhrlCX9Zo/X7nDZ+j7IVj2Aq+TtkTGQ2FisoI20z2/Ll/bVKk7iRWURHh8dTI0tt5pmyuY3ZjlV5k1oWmzwZ05GHgUb6IBZbuApnpTt26NEE8YIwI7J0APEaA4k8GNpv4VGja5gCWDEljVVU1hBaZFTgPcjV2GPHKQR8YSN1a1ZTLq5krvN+vB++mclKqfsDRCIFfB/5l7qhPM9bANz8fcuqhmtw00ThBKOiz+k47D0XALxvkCBZ6E0QUNJJNLPpGpedW1ntQBt4PVjqAn9WPW87TVxBJKM3sGpgfXtYVSEC/o6dcPQZomTyqWCRKNJFIEVRF4eKoIaaw0a0dnF3nEk9OUMybu868hxPJYr5aQuZq49NH871IgBcqfdMAtLL0BNEFPk0eVrgBlup23Z+J3qO1ZGpH9E1Q191i4MFJc3l9NvSwB3RPk4mlxSKnCvCJs6hynfdntVMVL5rC1jPZSBxms4bziOwBduKUq3RFflp7nUTtV3/YR7hfh4jLJZVfQ9PudwHkyzWO1eaoZsgCIrbwvMWAdDdUFzmmvqQy/gqKlMGnj8yjHqJ4q94z1VhFrmFF8mZ1NMu5uTl/vJ89vFnOyKHINfljlTRQi7nA5cFbnI5HzjklctUV5nMSEesuTuU6tszT96x0ZSYy6cJ292z2wI+btcTTG8o56Vrn+aRxXVah66vRq5tsVjMVe5Yx3nqYJ0H8/4g5IyGOLMM9KRpJzkxRMEgq2Sxu7fLRJ7eIUABQ0OVHKwBVWVBmJQms6i5HMfNeMItDA4/kQNF6tO172yXTvwNh8HHuo5ebPlQqUigHJyrKRJaa40BwSEfQziNtfq7an6jwJ24QAPd9WCuKpMDNVh+SJkTtpfiQvYtbO3vE9zffQ7mMmsJL9wpK+utq3SV2Q0MNu4fC3R/jBQpBcsaOVvA+9+GhvI8r3z9SpGuCGfUCd/3H/6Gc2ISk5jEJCb/YVJReRZnkPBMAdG1/AYiwLmvvg+81vMmaKP74QI57+ttDCBdEx4YKOuRBUinvDKaatdIMPj4GuED6t51IbtU0zrMDwDJ4AVxY5i7xXIv7uUpR29dtuRqZW+Wy5HsrwbPiZxKJNwtWtLRmbKvRivwVdmwALcrglQFivSydfRiXhYsWiosZ70bKZavAzzxcrRl0a6+krb1wsET16pLK3sKLlfjkHqrks0f1RUwt5laXEuGdKKBJ1pnC13Wp4y/lbu2WiUckRFNxTSa8tDoqBKVANQieB/pun1Nt91gcA/BJ5oVsSnEJRWUIG3Ai2G+bGDfUvEbjO4xnqcOSV5DyWuaE98MMpQK3jKbc94RLT6p514HWe3SRoKsK3ZcRVK6qJkD4+ZqU3c518qryyQ7/97uojK2ZBOtNNrY+gnFLrYCNbg48SPVjHudCTRPDYxeu0bcYQuK+pGaUqg/FTfKVSx2NaN7b9R3rJj8MdkRZpTKy2oSJx1ah/3O+rFM+LkMdFaSjVGDG89loHPfmUVUSKqzHkbcoMSDqhmnp27h41Kxqms8LVr8+PtGu3uZ9WPwYQhck2bthb8Ps9omLn7UuXgK6miN712i+a5pmPn/2/v6+B7r/f/n2zab3LZhUjPDCiVzc8wvOlYKoXBwKhR15uDQqVQUyqUbHeWoTnXo0GnKTYqoJBTZib7WcTMqVu62VjJsx73NNu/fH6/X6/2+Pp+NpYzK+/l47HF9dl3X5/pc9+/XzfP1fGE/s0G6r+RzUBcoZB3J9dUp9NT2lU1mu7OGkPZU/zyiCt8V+U+kLKewcL9OdExj8RSubMuN58VC5+dt03/j0fxBfhiZdOI9DjyUz9eRn110sNT0q4UEIh7FQZhK7LxBVKyRovIxkn/SUG4jfJ8ZT/H5HrsVWB3ULal9PMAsZCu+KPVbxUDC9P8DYMPhqbO72OdN6i2+nArrUZy6cvt8Nj+6DsDzIB7N41rrYwCglOoC4K9a61I6zzo4ODg4/FJRXkV5qaz99ACADUqpcVrr4NrCnwyJuXkegAgeEOuTsxGZRNZZv5DZxqOQytlV/RNNIlSqL2OQjci9XNko+YxU31SqMMXqWANMYutgEiewRksccSOgOV66M5KSk9EFe5E6jQrpjk+juHaXsammqlNyCsZ4XgfTilWxtT9rUG8cVtyUhvMH3iwgcRYlMtpy+feHMgTPAGL5YyIXF3mDYSCNl0yr1mawlgtbSF1SUk18dDPHe1dNSLIbYernS/mcfDkAq8E8gqfbAUjvJX81LYAdnS9BOFugd3IBXB/MN0lp0Xx6EJON9TqWk8d7+K59Zt54S3dkVLjqqMlRLF/fI2DZifyKZn9k+37I78xGf5PwFTxZMA4A0D98lqGPGrwHcGdWRC08aWZ7THccyZ7FJ8XXlfhNyQc0xVZ0QqD070eJRANfhSTjUQgexGQ8DlImEC9sHm7Fi6BuxWLdy3G2wjpkczD/Fc5rpCMBqQisxsyIoTtnA1qg2huFAcvGZz+Do7XJ4v4ivJn5HaloPxyksfUFmhnvLpl7oG3qGm/ObQFTbPPiyBpv22QTJnEOtvtkmqZe3wYdUohs0BbsUYSAitgADEhbEPCb0Yl78Wgn0pIKaCEgeQy55+/1fWlt4DJvknkMDA79MQxXpxaiNBQO9uUB37NV0lM4cT6S3xfTlwDflyLDDgCez6uQd0KhTxBJvKr/4FozT/JBkjtNXdsFQcx2kHY1N6DyNvC0TCeiVJQbdVZrXaS1ngQq4h/A8uSVyviag4ODg8MvEOVOndVaZwHoqZS6GdQQMXjQ/hk4bPRcJO4s+ByJJgb84h9G2wVMzStklkHYCJgCmX2jmCqaSrS6SWlWddLPZ0lhj0KWmYb2kwDF1LgGX5IJmzchooQGUuEoIIzzEYnCZmOvYNtyIF7kODir4325wHAb0tjrqATb9ETyEsLoywFwkzRySeFtTAKdfcAU+uziL8yEL2ciV+cgLM2PsfDxxcAAACAASURBVGCNpXwOvJdonjPTfP0QpB3DWt+XhI3MorBtppPbNgzT8G+QbJhQSw/gYqSBvDDJYzyCv+ETTobseZlNNcsoNbIgXIuJk4sqG32rDq3I/RFV4ZG5U8zX9qzhbR0BPmp4IwBgs6IcxCDMwklNN8qETiXpsaYIby+r/vra2+7i+qelvl2sxl5s7i2XAQA6fvA+Vi4jRpD0cngaj6NFN/JsUhLIGxifTfmgcTHWSl6+jLylG1t/ZFq/9uUmFC2Qbhg4ouG1g1vFbkFTw0RbYUSNgH9yP4hBb1AVp+QwaiMH7w6ih6THLmL5/SXm73i24CH40RrrSsi2CIbNnWnyNtOH073TBmnYy3fqbLB6M9N122ITRss9dxVNOiz53GyvkFnrYc8Abz9F509yKHtZXS0NifiimB7oISGvmHlXjuEEgqRR+Jo1//s2q/HkUwIqFk5rC/IUq91baN+Wwp7n5zNsCAy1XR7KkdcDOaI2y/gePw4f8jQxDejTifJcUhxazNd3Oxqapl0xUfSsVPnbPhxJplysdaoOwVLuZFp2kV5pOJcS5e/Dijr9LHieJOWPAwfoNZr3MCUumV2JSxL/Y+Sup79DN+rg5bPMyzNM6Kx7YQaLWu1Zv3y42brBx77PmcH7w4xZbxqQ1Zc7eFWmRHrkknzs7EoPYINdHAMJtd3wPLnx2FWNXwFIzlB411hv8qfmRvJDaK/1eXp1Y9grK2G0VNvfWDDQ/71gCWTAVJ7LbzZpt8HUP8hLpUMivRZTvS52sJB3xwxYgTVJpjOyEYPhzAeuyrrxMcjGDTxCyWAxD7ea0FSt4aQQt289xxT2AOBwBUs3AUXA8jR6oTZPpFFrHetHFa6thsgu9Mgmh9CL85k149FqDdFMR2kqiFmGzqYy/I6DxAbw05Rl36ZwmLAJgJvYCGHpKwzrCHisGbbvAzJCBuNfACiZ3a0zvZkemES07rdG32y2Kx3y7o+fyIcUYkI3wzrTgLcerbAyi5LMnWLtW07o338BbbfnJgpt9Wg+13Tom8pttYZhKsbvpbfc27Xp5StJ8Ivz8pEeSReyxwy6wf+JBzDmKQp9yUvrb7A31Yuj+TPbbU+/cR+CsQVNTY92QduVFF7SawC1LugLB2HebWEdUQJSLX7lOhoMDre2cckYVhTMQbRVUeDBYvoKfiesnGXDzj5Rv2p9KeS0hZUYmg6HLYoOeo42P+MLJ3OYeNJKYKTIkcvzULJZZABKdMirZ69HMEW8Kg6jXRRR1EUWH4ANpTMzGynVgCKKO3veRPwclEsYSim1SSk1VikVW/baDg4ODg6/dJSXZ9EYFLmZoJT6D0iEeIGwos4uuInRs1TNunyHNZGfA1k2YiWiHmzXIXZzEQ2ksaWQKIlf0YWBtdYzT7MHYfJhLXBxPfL/DnWmudW+LUSDJexRsCVa+I79rtGQ4vCPt8vXq5dd21XpJS+UlwBDq/O41aroSr2TASItwx7uyMaAJ/LGD/D3OOntTYYNpUn1S1sYPZo9miySzlhm6JGiMHtRFbqkVebvw5Hn2QXO5G08DDCTk3okAvh8BiVUO/x3qUl+CpXzXryAu1ivWizGK/C1kZ9efj95DJGTyTvIe+lSm0wXNIIJgx1IDKzID2t7yHyWNq892s01CUJB+oj/h/tfomPuyjKiQpLYjUsMJXQ9r3/TZCsrLUm5kR0Bj0Mqh4rJvdsSQuGlJbndULiKrkyFQXThY5BtlVMZUux5DT4LUA4AgC1Hm6JNLFmWEm59EJPRH7PMdwDg9uZUhPhX/ANts8mC3xDTxPzmX2rbIj8/1HtA4iCKqex7ylrrUigoVPJQFGN4LrlQnSfRdey+jeIv4SgwzZUk7DM1fqBpt2sKLzmqVxQCY92LPP6+26ugVgP2+CXSvATo24v1peTB4GkLpOP3IUQl/4yrmZtiCz6KoTjljTnk6gb0fedQYGpfVnQeYUNfBk1g3xnigbDjdPV0YCo/S4nCF1gDzOCk9zD5Hkp6D/4kblN+Ppvxs7uzcR08iGcBkIIvQL3uAVIaFsl+8Tr3pdeDEQf4zrePk+Wfn4fySnAXaK2vAz26q0CvoD1KqRSlVIfTftPBwcHB4ReHcs1ZaK0zQYS0x5VS7QHcCWCRUuqA1jrutF8+LTg/gVBgUFjgorVECwttWGz0fQSLG1+P7q056yR6MG8BiUF5A6NXv610j0IMCxmv/STLohCK5UoRUou4jbhyK8VTv19BXtA0DEEVlqSQxPk2yXu0AzTHaNdIURdKytF46SihRCklbb3bEcUXMPL5QAR5KACQxB6LsWpehlXU5ETxrnpAHMvMPNeRZDl6rrDNj04uIi5xlSGUM9ozoYG1vLjwLrLR98jjaxXxJh1Mfhc6B345ilWcwO6Fhca6/sGXNTbJZZ80hoGcg/o89SkZSIOjmVmUMLk+dhnSi6nYbvUmSmqPaz7G6B1JU6tZL/U2irGrqtMJ8fc1GcEtRVuJnejrYyLn23vZeojVxlD8+xsOXjddux5bMyjTlNDbFrVJHmhkPLl3co7ikGk8oZmcabqm8md4EfcAsF7PbPTDF7lUSLcuKpBDuRC98FDMswHnxU8Plr4WVkH3czzLGjormpBq89KtJe28zWiGflGzS8wHKD/RpwMlaDv6sn6yv7cUUAozI56i1dvREN2X0PP5766sdzZ3ro31sxeZtbEWYhdSTvCZXjRz1HLKfy0s7oVpIVRZ+scscuFrxf6Avb/jiDjrtLVdwjTcukDGU7Sswzp+XwyCoeY25Wcgb3gEIlOJFitqvB3WEOW7qa/QbgGnBUZ3RcC9CNDz9lbgLNbDpvlT2aOQwt4taIqRmBKw/rYs8iZ+iK1rngtpH7vzzSvtisLgTZGtA54XwdNTN0E6HcprsChB5NVarwawWin1VwA9S37lTEBhCM/bDc+jU7u8PoUo2oynbNWCtAEYwEUGInD2ICZjQzK54PLANJ6bZTfL48iCUhJRIvX0DuwgIZAXxNLbO6DLNvr9mHhysfejJvK6kv8sL6WHCyYBUiGaTGyLtFm8keeBCdyd3OMb9cM1QLzUV3C4aspeW0shhCpxrL9YYwcXGVZ3pdv8nOncJ3gLgPTgyfXNl65ea2T7VxuNLBFMbMfhjgXbG9gXNiPvvkvNHZb/ZGTAss9wDb7IoeGtVzSNzlvQ1FQGP8iZ64bYYRg+CcPpxfrken4iI0B6X4B9MH1V4z059rX1S3oxf1rl96gRRWHCgc2nBm4LwIFWKQAoJCM6VNzNGzczN+M1DDJV0vKT7+0FxorBIWybozCNcGQQVb2JmBFxMA8RI2jwlIT0LtRH2/H0AnvtXmIo7eJanYkYa8JKMmh8gWamq+BDHKpIyxUzxgr9SYfCdCSYam6pkq6E46YOQ0Jegu8HRRpja+rWgWa+7K+EccJ9LDFZNjeensUEpBtDQGpfuixPNW/Do80qmGOh/TmGwmAdPMA+fJyIjt26z7zMR/2dBonFD1wfsF+A1Y2KQTae4sRvm64cjnqZmRe7gMZFvncAQFXekhBn4ykTcYisR2y5YdE0SORKH62jVolpGBMtPvQJeN7Ez0oYgOTA3luYybLk3irgvST6LEHRmsg1ZIDNPnUDgAZ30VSbnMsx0Lawb3TRyts/FfI28Lyg4zxDlNdg8empFmit82FFHxwcHBwcfgX4VTY/EtVZP14eTwnXZtgMAFiZ1h2xpoiBsBLXGf0n0Rtqr0Yb67t97YDV4e21ksN+1pm/ngEAPK5fyFpRC/XyyD2W9pP1CzKRGV4fgNXOafv2JqtqKQ1SfLUJHofBPG7NmnsL8AVbIEm8j4UFtmpUKoSnsCfQH1aWKJGT2SY5CGA1a0O1f4qm88YCt3Jybd9WSmZ+pY4giau/n0m2WWTpMX3gIIVM8r/0eQxc89KmFcvAL+uA+M5kLYuktLhlj3R7DE/PppLZBv2/AkBqpQNzqW91YTKn5sfBVmmzdVjhBnKvKkYUIH8P/76cv3wg4jY6+rjqmQCArR8wubixBraT0xvWmvzBW6PmYUkxeXx56y41+/hIbwoFLWPZT1E1bYgdJjH7R0UnN6kTcMkyquoW6u/LxcMxP4S8kz+tJw60zqXf7tlpDt7dQTzj9IZU9TwPt5me3VfkkQVYxFbo+OqPYuKuJwAAT8dRVvWR1OeR1IFIzWNBF/JxPGbqMd4soO1XTifPtV/iq5gzg3SuNiUTk6MufsC9rIEtoQw5tlcw1PQyF1TB4RJqtq9gqPEGpZJcvIjk4hlYFkLLJOS1HzWNdxScvJU2tIANh3WZmFpCT2lDQhO0XMm6XExKWRxzvVkuStEP55FU/puRPXD7YCLAmG3JbfslbFxZws/JgGbPRUn/7BeA1XPoPmo/lKgkuUwKiboPhu5+SNoQjIB5QRT6CgakfEPJu8avkCdePT9H90yYZMKx8u4Q9YDduARNua+qeGaLl/W1VPUUnn43FZ70PDgNzlvzI6VUi/LYroODg4PD+UF5haHWK6V2AHgdwOtcxV0u8DKJ51qLC3CkUAl1CpG1gMzl2N7kYdyON43l1IQtpDH6SxMPrskW2ieKdjcRwKRS6ljEoxjP1slUznV0BfC3SLL8xAJ7PfxOYzHKbx/6Qxhy/khJz3jxLKQce6TNEUzl9gp/DLFxzHlsJNw6HOA8Kzb7PAqAKh9HCg2YjcMF24DeXGwoUd32nP+4dYi1kmr9jmiKSbUBzbHiUS0oLtxn4xt4jauux1Ynnaaa7cgc2oX6eAxk/YrG0sudh5uGRR2aU/Fe5+ZEr5x41HaJycypDwDo12eRmccFq5STYFWxkzcxeaHwiFmtzhVEHmh3BV3DhTmWYro9lzPisvoRazwVdifPZdasZCCT5/t0psSjyCymZFFeJll4DRvuMLmnLzRZdAk+5VWhlPYPmY1VR5NQGvpgAR5rSOeq+V4yXefVBhpn0313f8xE3h2bgL4njqROxWpv1eFTU8woSMBGvHgp8cCP7gy0A5/FQ5iSPCxg3h14w7QjlRxNHyNXCnzL1v3nbHovT+uB7onEvvArBb/MVaziGcg+7gqpb3IIn7KmUSUcx4xcyiGmRQVW6/+++D/I+5K8uz81p3uuC1JN07CPhnO+IXs1jraj45sXfisA4O40dpeXAN2T+YFkr+D2de9aAodMRamgL8xzxK8QAIBiWrqQTZSvSN14FP4+NXwLrOFnMXpyE7TMJss/lHOgKhnImsRFu3u5FTI//3krIhC5khPP/Ox2wxJ8wPdaNl8D0eH6GpcbtQNRGB7fxd7fE0Ip+PJjvIofi/IaLI4DeBJUJPyYUupTkGO0QGt9FuU+AKTQ23BflaAS5MYAmIqdVUSDRtabjfG5VDauokmDuV/hG2a6SK/uUR/Qjfqh7YVj4MUB+mDgvGF8cd9Gok0Am59JMnIfkpC6dFIeqnEISGo8+HnAoaAmTgDwYjHgsavs8aCy5WWrCN6eXWuvtApRdqd7D4GpJB3WOGidUCCKk3Cm0VYKoKQepJPs4zVGMkKaIN3DIYR7fZ3TBNmIMVX0T2+ikJMMFkeW1jINnU6u8mXchcQj2eP7ANShG7/C/yik0r0hvdDqYxdeSiM5jgVMb+udOMs0XNo0mA9KKGcRsDII0tBunH3A6sylgWdPegN8czRQFK9NQwrTLF7WF17nwBLeT3AdjhylMEFxZXqkPj5oy40btKIw2yZ+C5xARaTzxWgRSi+UZEzH9BgiyYuhIS/RS7DbvBBEeLAzlhuhzBt3UexhXtytSP6e+qDPWE5MKZFWfy5tDEaCkvr3J9K8j9HRGEryUhIhwqbYgjlsfkg4qmniFsOaEnn0F3Cvkdr4NIcGhEbRdL+PXD4VGZ1izTmSY4qKCnxGBHmLLkWn3u+WugwArimgfdUJMGHVu7NpkMhK5Jcw9tkv8G319qju6HsHvwykqFzeQomw6gViRaUAT/F4M1YqopcB7VO5kkmeM5H1B0wi/CZJjP99q1mkfKr+sRm8fxIG48Eickk+srryMWTTOl0WpmJLr5KClwBwNb4w12LFQnpveSAVCQCYMJRiyJ5X9bTS5GeC8qqzKNZaz9RaXw8iPH4Cij5LrUVSOf2ug4ODg0M54FwJCT4B4AmlVDuQt/EO7Nj6k+F5LWDI95wU6vAsaxW93MUKzgk/fyhs4QTP2/n1ldjJVMve3chiVdXJkn0NKoAHDVCFtUDCPvEc+erbbzHenkNcTknQ/QuDcXUe+cNChZw6ZiCGvUz0u1W8DTkZTWDbK0ri/S2gBN3Vz9deFeRRhAHw2AX3En0LxMIRFp7INvsFA8WS6gVjLYk73w1LTKMoqUPokWOToJ9FU+JSjt1PY5QwlAjbYTusfo385vOwPDnRXmwMIIOs/1rdvi2x3bBGlKiuyi03sxFjejaLTlhAPYpEuiTk1Ajm3tnzFBffdAGOLOZqdPbGPg9l/Z1GGo/nUPK7fnQmAGDnB1fi+m5kuUodR/6sSEMlrtmN9vdGrjW4AR+bY/g4kk7yEnQ1yUup6ZBk9cN4HR+B6kIkXPR7TkgDwF/iyMS9FfOMqN+gTqQNdYTvplmJvTFgHXl5E4opdFvpSCEOVKcT8RBTlaV97NTZIzGwP3kiUj2etaIxHukY2OByPCaY/uQ7o+P4OD8CANzc6S3jiQrd+M+YjnrsMV3OxGTxTNAIWL6JaLfXN2dPoDVs6IixP7eKSZI3iqEbxYTsvgXyEumCRq4rpZ5APAr2rlcvBNqLZ8HeyuaFwNjJQd9LBt69nYUVJy438wDQ8yEJa9nXKIC7y9qks6wLYFNj8jIPJBPhpsOSz821wk7yLL7vVfIVmcvx2cOoWkJG35sDqJXM/ZE3e1FgncbPQXl5FqVm1rXWa7TWfwY4sOvg4ODg8KtAeXkWQ063UGtdcLrlZcHzZLfDSixLvbmL/Udi82KtjigEMuk7FUbY1EnXbmSaTwbJL/9fO7LO2r4FTOEiXal2LgIgLVDqcz7A49xaC93JFDyJfpDRvwGwg92Zw6hqqW1B2ApgpGg+vW1/OyVI7thLBjz2FIS6u5nXeQeA903Q+pcDHie450lCj7d/6wOA6YEjifEi25DFYyvrCzQzFp1YjN9Gk3tyL14wxyrJ686Vl+F/XJUs58PoH9WHrSYUtdrnYRPbghQYfSnRkJIE+p0HZ6LwCF2ZEC62+3yHVeCskEDX+GQjor1iqc+GOeKbigHql5IiNXG0v4KsZCniXL7jFpzMJDevRjQ10hrVbYJRtg0JYY7zASC+2yaUhlxEYVwOJU3uiCbyw8U4YJKX37A/m+s7GY9wxb+ovW5GM1OwJU1wZiDZ6G2Jd3cxeydd8QG+at0AflyOnZgIulZS+CiaXIClZAo1d1nHzmbZej7ey/G1+c1gHEMlkxOptZxOeJVOh41FPC+XktNSKNmy+WqTK1pYzOyKOJi8W044me8N0vagRzhb9zwplDdOM4r/AzBWft+5i8H1giVouO13A+A2qWO2kqLubeoJ61WLzsRW35ckryYecRNY2qt4+YNgyrM/5NNeTzfAlSsoL9Y8hV0MTm3N7doD3Yrpy0s70MPY5cFUbJzcgg+LSgL8xZP/ZGKBOsbexN9gimUl53e28hVAOXkWWus5Za/l4ODg4PBrwTnrZyFQSoUAGKu1frzMlc8EosExyDdP4tOixJgQZizKGslkzRzYX8PQBz8rJqu5VwjRgH5AQ4xkq1r6TyTB5hmC0QybTaOYxXG2SKhFJDVWl7jzRiQYmp5QYsVHOgTrUQg1V4WSvAdgVWQX+BgW89ijEOOnEmDjpRyH9QaAegMAuDVYles9gPvPYBVLjSR9AHicGDl6C9kUaW8noWlfYnSJbpCwaOJMMsiiJxYZet9hk4nh473hEAqL+Gj8Fr30pZA6wOD+BrDtVfPXRSIs4VDAsip19uPIdso3nNzPiZ6a2m5L2rwKFdL32y3HUnB5wwftTb5r9Xq6Zj1asfsYWgR8x1eLUyML0RPb1jcP2I8KyUexI4c8ydrRFNOvyxcjCauQFL0KgM1PVMJx3H2QFGJ/X50EEHZzQdZs9MdQPjHivb24bjTuaU0m8XyTnLGaWnex6yrbD5BqYbxS/U9GsVY8kVfX0Ikf138MVqFkG9ind5C40riGdIM98fbTeLovUYxE7kMKE1v7Lt6UTkTbTcYMUzQn+mkhbAbvRl3Urkw3en/2lt7HH01L3gbb6OJ9PyQSl6Zz2ak0MeNn4Ptekbj0DV4m8mJ7gRS+fPK8DZPUSzMY637iNqIzv6s74ep0dll8+a4eIuAmQQnJT+yEyf9lrfYxmvjwbxJvJn2n9Tw4TzI3hnI0McjGJyHX8WYp8HLP5EklaPfiTVREARaKapJEUGrY/fW8CTzVP7mNajDO+WDBvzkethvuT4AkfnwvoDc5OFSTH+QasC8C0TBrBHMy8+7j9HFbwPuOHrrIB0lzKlra1hUhQCQOoIFCQlIvSt9dbkON0XswZRI9FCPTKDn4fWKkccUn8wv2MKqaQe0ept+9KG6yD4bbnQ2M5Cvl8cv/C9judjJPMLqdPc5J7O2OjoN1rSVZLgm6fva7SZI5b2J7CA9hr35M30fNsRzjiuYczuxtRyOToB1TmaiZO9DQUGylJmBSMXHxC5+UYQ92QGgL+xIXimt3mNF51lrSgY4dS/Gr2I4ZyNpxRcDqhfurmeToyruIbND9NSIuLG7d1xIcZNCoYb+84Ws+QY1ge4ZzIlwGw+6xi7CqZhIAKzz45LyJ5oGNbU77tju3LlpwJyR50D84SG+Nz6pfY8JyQomNQyaSq0snO+L6bl1DFcPL2nXGZzlkyDwdTeevYtxB7AmSl7wdb2IQS7wXBz3aW9AEyQeJVBHG4+v+mJpmABF6bJ12FCbZgUZmv59iy6MAFTGp4V8Dttuqr633iDYVSISNSDD3hHTF8xsNL0TRtv7ydQoACvnJACmhqsXx16N7RGDdxKWj82y4VO5pRu2DeWaQyBvOie63baJbaO4GfsOJyStR8fvtMyL349+BTZPoy813bQtYH3l2P2LTKDm9IbEJWh4i8+2rD+hBujJ9p+3KxyHei319wntk02CUF0P73WVvKj6qHXiAIiVfCceNYbANPkNlHV1cbx2zNoLk938OymWwUEr9+1z/poODg4ND+aFctKGUUvkAXoWVKPIjBMBorXVIKct+FPzaUJ7H2eC/cfGKyGTPgk2WCoV23CGYQI4kVQETpopoT7u7P4JcycprT8JL4t/hJBjmwlgjmlUwJ/BRdtHNTQJYqJE5iDbz/MnuR3aRbk0uWzriWXidgFXs7SZJJCsb1vV9jad3wA67Qo/lbXnPAJ5YUHKWR8NWqnZCIL4FprLq7R98s6M5IS7U0uTJL5oivElcrSvHdAIV8Vw6JUubJlCo6hLsxop1lOV7qTXpEo1IfxUAUD9hq6mwl+3r3ymo1/jS3sae4qww6H7sRnMS8fLW5Db9cLQuMirTNoRYsAi98B+uFpZ9k/O/7Y7mNlwpBlsfSqwCQDbHEvZtqof05hS+mcc3ilQg18ABs11JtK/BNZi5iTzKJs2pcKsA4SbsJBa30I43pLWHRIS6d6OYY2usM5XQxcV00VqHkMvVGcvMshqgpLp4eID1IqKwH1tZRVYKE29mj+GJ9KfxTMKIgPNSFz9gC5u4oh4rKrU34GM8zp2wrmVd0AOoYarS/1v5d+a8i3f0CvNaVh6kG2xV9fZGdl2OfRk64wTHb0IQ6E7XwP9Mw6K9abbJ5txECtWIpHnliSdx6LFAcktBiGyzCKHFgdvdHVIXje9gEQmhi8uz0w74qBNXho+n+2D1hJZoP5eu46bb2Zt4exs29eXPr5BnsY2VZeM/ADQnlpWEreoCR+MofLs/nO7NH2BlxVumk9exNIGS2ZVwHB2yWSLdF2LeNIF+cxyTDK71UabHH6RQU34mR1pGAFgtYVlphnwc4k6fLhz1Y7ShysvK/wLAMq31e8ELlFIRgE8xzMHBwcHhF4/y8iyGA/hea72olGUhAMZprSf81O2XpjrreRwLTR5pZ0pcWopi/M1zxNsIhdHNCBtAo3LhfPI+dGMFvELLbp5DwfxpGIpL/0CuhKjD3qlpY9/gCtMfQDyLG8euRtZTnPTqR/HMp+fchwcPkmcRJsoRoniZAEMVNMm1IbCxTsbRJhUwOJxK+uekkdU+OtEDAEy6wzOtUyUzlPueT8tGLBeO7X7/QSSOKTqmeKEgHoVpsbqLjGzETbeKpc0nctxW5EF2wzbMkDxPKxjf8tDj3Gb2i0JzbGsHUay1LSvT4g1Y6QVOdOt6gOLckCiB7o+kREKtjCP4vjFZVeJZ1ESuUUGVpK3Ey/+KF/HIUaKgVqpMsdx9m+qheXOSrH2Hi8/WG24ksBFEXRRF1fbbNpjrM702uaT1kWl+SzSKGiZ+aejFEmcWhdftxY2Qt5RzZhJablQIZNA5iryBcmdVQyhuf7i4Kq4LoW2Ihf57fGokNIRym17cwqwnEOpyH8w3+QKJdT+Kx42HKL0u/J5FAdNoxdo/gBp4P5u45IXsoIftAmYl9AYADMimoj9hWkztNNDkrFr5NKhEwVfmidU8Fk+ZfRTvJwbZqM2emSTGJ+NBo8clyXSRPlmBG8z1F5q2X0PrSc6/PM/qyZ2xzBSYCg6jKmK3sSyHLx+Y14FzINGcAxFTezoAebakOG85cPRb8iy2h1Mh6kIjYQt4rCWl2dOZEAW7bCd/SIV5RqM6kkss90TWpsZENQeAFKLVov3VwGrh8Eqi1uYsTtfP4sd4Fr8ZiXKB53ED7UGwVbrMmUdrmGRqxFB6i3WrvsQkHouL6OpfG0WuXjT24hMeSVqzrtPimX3NQNOyM41Cb3Mz7GzUQ4dociUzcqwbLWg8kS9WE9jEmujLSLJ5BmxyVcJAtHEAwNMTiHnSD7ONHLpoz4we5QGgkf5ZgwAAIABJREFU0IN0I6tRgx6UQ0eAKL4hV3P+Xm6nwdo3WEjoqy5KDhaPAW9PoKRx35VcYSthrsdhBzkJmXWCSUrKIJDRlc7LCWVv3Kvl4XgZltkh7+slQNYYHmwfpOPNmGzPrdQCXKlof/J0S7MsJUD/mUJDEjp6IIue7vjYLeZc+QUBb2M++5ULaeem9LIifPLClsFgPvqYPt4SJmqKrabplgw0ggE5s3FyBmdQb7O3cpU69NJvWpm0of7no2oJ6SKJB54DqGHYR4La2IsxWTRSfxh7Y8Cy+ehjBrS5HFqretAmfr+pTklYMXYO+H5bDJ/PcI3Rrep4kGKwYQVAVm26PiKwOGw5JdIXd7re7KOEnDYiwQwWUTyQCBvqMKqaweXuVBp0N3Rogve5YCGJmQ6tC9ZhXDgx4iTcNoSti74H3zay+U3aUSgpAemGiCHnUUKTj+Fx9GRLLXI5n4902MQ239NTEweWqCfp0Y3jxTsRIEIJgBQQmC0lTMozxYQMbcgXka2573woGxmNAGwXuXguqmh0ta0fEsN4tWVGnQ7nTaLcwcHBweG3hfJiQx0E1QencDvVcwfxIjJgrVMJ5zysgfmBA+iCrwcgog5Z1Y2iSGfm01xbBVw4jfztxZcxj7S9BvbTNkS7R5Q6n1s4xriejfux5TwBph2kCTX1RaBiJRCo/TQ8aFkaoDnB3rq0woNBNJFkZvslG7CvK5k6GziEk9gJEEawTE0SvGOeqWI1my8AEZwBxHE1+Or4loaXL62aN8RT7KnF21tNuMggBcibxq57ClltjVP4vIyBaeWaF8fr3JxvvROJDNhW3Dj6FJ3bHKaM1sR+cw3i2QLLVBsQzzUs119EVnjXKLLst6Cp8SxwgEI+F8UeJ28RwJu3kcWdE17b1ADs6lUfADCkgOKRlfeexIYYOmbRenoQz5okcyOmiv6h+B0ck+ry6mT5SfL55H2VzZPXvCEd6KZlbVGlIYUYPp9HSc86t5JXUxWHTZL8yZdZvnzQPnSsTL8v1vvzaY8YS3RkLGkC3QHqgX05vjZhK1GTza0eZUI8UqshGlGdi5fhcAiFhKSupTXW401Q1fW1EZz0rn6R8e6E9ipEi+5LVuKjroHUz1vwvkmc3xzUXKkRdphre0eHfwEA7sdzRl1VvJ1XwofguewxAd99JoaS9zdUX4HFEX0Dli0r7ow7Q6he4ZOg2pEcRJvw1rJOFL6amP6EkYGeOoFaysYhE9cW0DEfiSD14680vRNex52opDwAgPBtDj0OVGNV5ST+rVX4cZiQ4QucsGJ8Xh+fR2Eg0swcgq8J61mIp3MW3/Dl5VmEgwIUS5RS25VSjyml6pfTbzk4ODg4lDPKiw11Qmt9l1JqBIDeAO4E8KhSag2I/Dn/rPe1CEYogKX8ebsvgcXFrvkZzDc9AuSvphjnVin2E8XTWbDV36t4ulqZ/MLKNRS/X3mEpod7VcULBfcCALLmUBz3M1yD4ng6zQMSFpjdWDuNkrutDlJyN8xPMmZj7KvGXMyTsRODI18MOLwJGI/HIh8BYBOWgj90XWjyKB22Mh3vDoDziGgvFFrpE7QS1qLnhLiuDaRF0j6KkmkoitGvgEq9340neqRoCV0UeQwHIsnyEwvwfxNqGL2bo7eTXZIdTi5JJRwzsevavmKufQmcvK5OJtJHce1NorJiPll0H4fbbP/vg9q9V9S18ChfoMIsLp/kXM1hVMUDa0iN1RTnNYfxRm8LJxGx4BwDAFwfToVhMTHZRi1VMHrHPxBZnzwuow0FIH8t3U9LOpOXsm9ePQRj07XMuWwN7CkK1G7aczv9v6cLsG0PF175YuPvvkLNEKSNrB9bZ1PuZn5/0rTasKMdGjSkGPfIXPI6ro36j/GIJG8wErTsmpDPzHVv6hNGEo/r5XDa1g+oi47sYUle74448gpqxu03107yN37Kr8yT+yUOmSbBLbmIbMQgk3NEzx2kfF3r6usxI4a+K0V/AY2m+PndCjoHEY3yMI1pvYnV6XmQKmnJ4wBWyXfpqA5GxbaGr2juoqN0/1Xmd0KdNPrtUYkTkMuu/1/4fB5GVbwx48+0bzgzjG9MkYsJAzS9g4CSmmnfFQLg/hq3DbLzxdng3fbG/WQeUQmUa85Ca31Ua/261voGAA1Asl+PwPKUHBwcHBx+BSgvz6JEZl1rnQ1gIoCJSqm2Jb9ylvAd67d/F2moYqJS63lF8DyOBzbm6qxGvVFhNauTLuXEgdCEagJBcjoUE5R5q3jKndiikGsKcISJ8xf803yVQ5zYH1kFzQqIYXIigsbrsCVkteABGDqoxGpTJ7fBjGzqfPZoDHkTn+A6EwMXxdBF2UQRTYxphg57yYJa2pgVLJFqlW7FEfFr/zJzw+/N1Ig8AD9aYb1pYymsHKGZzsOthgrZfQlZ4XO79sCzIUQFSQwh7657Bks3VAYyYojVZKQpAh0kAGR1SgvKWbWJovlE9tN2BWYKbkhoYmb1YlGwBbHkRkrR2EU+GmGFG+iab0priwpX0Wdh/WSjHo6zqIvE4f30Sum/sG89eQq3t/o33j96M/xoUzkNK49QnHnfMvYohGAUCvvk+YtDJV8karz+uLPk4viSHFlcy3zOn0b3S8TQPOqjAcpp+DGu4VhjyQ+PItdyM5oZy1rYRCKzIXk4P+ajT0DbVYCYYaLWLB6CnMfNaIbZnB+JM9oYFqKqO5yrRYXyClh1XdPrwgd/LwehDVepTP/vGdzAxvX5HBfXD8UtUZQfWcf3q9CCixBifl/YZ7moaZ496TGxDJ2xMZJo1JwGwgAQdX0hehqvSjyRRUd7IjmZHrAZHenZ9XyO4z3MIixN5sdgPiy1WiD30HcvAuw54U0uwGt7ExD4yMLzusDzluJsoLwGi1mnW6i1XltOv+uT5D3sm1fkW6NawPrYvgUn63DStftNNB3qWy4Vv/KM9AEgey8PMF+LOzu/jroH6SEdw8UG2dXrGNd+UTq9zGstOYJ9k+lNIO5/5cqUAN6Q0KSExs41Bz/Hvhha/33moF6Byb6XGz3w18YQla/A1y1GXnZ5/41AeAFVj1YewQOTVH4vAQpt62oAQFbjWiZxOextokJ+1Le94b/LC0Ie2knbPCxm3u2UrkQzbYX1JmzxRD/fCx7Apjnx+Aak61RbMu7xMC/pztWJFXAANZBRmwaVXgXEEFgccz0vuxitY+gNKxLijbdlYUo8/X4lnpeeQw/5ye8qm+t58jIrxX1yHRkJh7vROfZX2srLSGiTIswHAHVaUQJ64cGeuKY6hVdEhj4XNc39UeUquieOjOCGSq1hlQbkZTAOlq4pIooSDp0P6pkJBErb16dJhSQa7PKXRgJdyBiSOhLRu9qwvb3Zn2n1KSRzUZXj6BpCYcJ0ricRxCDbUFuFFNACG/FQzrMAgLuiXzPrSYJddKZmrSENrybtNphqdAkrdQpZZsKmIfA/l0BFnMAnuZSAHhJFg9cK3GBewPWrZwIAEpGGVSZtTDCGQCOUoLEWbq9mmjpdF0VGzma+t+OQaZ6X9rsorHN/3ETTAlnCYsUIxeRiMnyksl729Zqoz8x9MZyNwx2VG+L13DsBAK9Xo+kQPc0sf9FHHQ/GhCQ2aNfCSo7Le+jLFN+a8p7gYy+CvWfkHnrJr63+81BeEuXDyl7LwcHBweHXgvMi6qeUukxr/V3Za559iOfheaItEwZwYxEs5mlrLqv+DtalHQQ7T1xBGcV5navW78AbrSj0MSCVktm7O9TFBOagFrbiX1wC1NpFCdyn4yhp90iBlGNad75lGlkFsxJ7m8Y/Qjdsii14g7mn/gIqgKz9QbXJgpEipEl4GMvCyc2PmW6rYwHgn3UfQBgXDl35FFfIpQI1b+HkNEuUZ6K+qWiWZixSAdwofrtJXnbfRqGmjvHv4zGQ7PPSORQOu6aY1rkb/zZWb+YVtXn7cWafGkVSZeL2vKvwdSR5FpV3k0d0OI6svVVIwoBnmDTAlMU74v+FRnxhNjxE26/wIHMp9sBeT5EZD7XtWsW6DvbsAGARy0FvL26EsSHcDIjDJrNqRJlGr9fK+vr/kJlIx7VOkWfxLxY0WH5TD+NZ9G5HTvj+T2oaD3HnmisBAM0HkgtbY+ABpB0kqfd8JmHED99kFEs3HyQrOT/B8q+PHyUP7fYrSNNz7tq7jWdRozp9Lze3Jj6NsppXgLX2N6xpb6roj71B23p3ze0Y1Y4SplLk9kruUMRE0TWTSvXr21GB5Ke5v0f9KAo/3Y/nAAAjD05BdHW6J+U8y3k8jKroE0UuvIQOK+IEsovpvBwIqcHL6uNBpvg+x5XYO9fTOcMNsG81CRfbAm58zd6sPBfiQQLA1DiiybZBmgmRSfJ+I1ogbxaFFZc3pumoRDoXaUg060v4LAbZGB1FXbvkOs1GP3Nc12pKpo8aTPxabwbpwgFAteUUxX8gQlva/wHReor2TcVr4Jt63XswitwvURj6F9/86EdgS9mrODg4ODj8UnBe5D6UUjGc8P5JOJ3cx5nC82Jh+2JIDLUZT7cDl7FOhdQWvelrtpPM+Q+JP9+ngWTO7TO99tPEVrh2JsU/TQLzKqDNEKnUI0jcdGPe/8PHkYGFTDf+fTXWPkDUSZFjkH4SgKV6TmTdm0o4hpfuHxV4SNthacADONnYhaycTh++a5LkEnOvj0xjod8MUvt8CM9g2we0H2260f5LEVXW143R5gqa14RtgWzEmD4QYtFJDDgERbZ/hBAKPobJBzX44SsAwM7rrgRSSE+qeyxZ5tJGVPo+yDELRDLCu4fojH9/8S8AgAcW/NPE+Ru0ou1n5tQ337sm+jM+ptrYlsUqxtvZA2ErNbLP98hLJ8tyfOuf1lRmjk431qZ4UvtR0+R/xMr/xtcYaTe3rReJkSXoZnpQCF7HnSZHJfmDBDZN5066Gw1G8zldRlZ4WOtDKHyY72HJw0lyfRVsIypZVgMAdy0e+AT1azmBcKMrJRDV32cxytyvokh7EY6ZeyErizSTxMur024nrmPWiBxHalZHgGV4MI3P9w0w1yO+P1HPty2j+3JUZ0sVlX4jB1ADD3EOUe5HyTcANj8i981Gkzyy5/sztMPTWdR2FXtofx9JpOLC+ehtSBoPcw/gSjhuPP57ZtI2Wg5cbXJfi29nV5h/asDo6XijM1FtVRt+vc2H7/kVggVXC6IJrGfBBXtoBlv5SwjM154aF6Q21NmAkT3HVtiyZ2l5VOhbk0tV/5ZE04cRqPFkUMruXsXXhj3IEyn0f1gesDqOWA6iWVRr1xFMiaM00P159JC+GdnD3HgSjnp1JmW12gxMxef3c1Pt56f49l9U/2RwlAFrEIRWFKspZHIXXjMPvUhKr37lRpvUl3AOy+nENs8wYQVx7RtiO+YdJPaU6G4JCj+uZgcJ//3sG1ABAB8Dw/ZNgR9S21GAcBP6EAzNnWZ6OgfXNdS5dad5qPe9wMtCYQ0BcflDYQYVgYRWVn7dHU2uoEToH1Urs1xoE4F9+wKRqSk0KEl/wMqRXxfyiTEYhFgg1fq7UB/9uZWhP2ySywUkwvCJ8lH3pMtd1kwS24ofuMkMRlNYZXIebsXUD1h4M5DkRNd3HH/2tbWXn5jzXwrLfYMrzH0ikN7g/8G16CxNshlz0M8c14Lb2XrhZGzLdquxYT1fDNFHSyoE1vKALfdJqP1sBotJNFi8MbqPeR7GgKrdF6En/pFD7K6LqpBRUZBP57pF1EZzTsUIWYReeJQLjiS8dBGOGYNEwoUyGFyHVZjHle2yTgyyjf6U4CU1Cub9IU3aRDfqJdhnS47zCIAMMQiCmxhVg3mO2/I5W1totuuNOLP6il+kNpRSKkQp9VjZazo4ODg4/FJwzj0LpVQ4gGNnq/nRuQZJoYtlfjVPme/cKMwm1Qzf2ddwySAHtjUsy7LeRu66nqjQMY7CPpIwDkWxsQrFqnk5dzgKl9J2/9SfkmSvXsIm2p5J8DyrKGr3XQoZpOI3iaeJAKushu0n+nBhRjU0aPdVwPd3H7wE+c/zft+GQHwJxPamGIa0Oq1SZ79psSqKpBJe2Ln+SnCO0tar+KtvFrGNXqeaCUkJJAEc2y4D2Tl0Pk7u4eRujUJgVljA9pp0JE9g67yW1mIVddsDsNfMRrVsxSxb3BEj6Jzle5GIfY6Oc5CytR1Cl/D7ncFooSmD+RCeMf25r42mCvT1R1uhTWUKNUgoUEJUSfjEJEblPmiBjRiaQ+GTk7fRsQ/4ZLoJV4nXOesVorGG9TmEZlFEStgwmyzRKj334ch+JkcM4COo7zt+UXWTW6kGjEfZ/DWKTXXFEkO+kLbB4b4CnoU5xMk+mc9UZSEWADYRzUSRKj334ciewFLlClWO4eS4yoH7BlhvJ4Umt7/4b7M/4pmlc4xneVoPVKjPtVSLKgf8ZuyzGeY8i2cRjhMmVCaJ/P6YY+ZJUn17Hrm/X0fGmnBs0qMcLhoAfHkFhdmuUjt4Z7cB+J4/S+iI3w2h0SXpRlcBXvfSPQTPawHz/K7mbbQvhOdNLHX9snDemh+5tqoODg4Ovy2U14u7H07fVvVXC6KiCR1tN89jz2L7KpTMbVwNK6Ea6Vsmn1m76U3KH6g3v4IEL6/R5FlUxAk88DuuBOecSFifQ4bC+6qSHMsk3p+SXgVBLke1oP9XQ6yUwhm8bD8Q0o6Cp9tWsC7RDVsAXEyfQ9kQEdZuOpCVzOb6KvuLE4+SOuiR7VSQNqA5Vb3uxJXAm9Lsgs/VonjYqD9boHs2Y6fi2/QyTjqThBOy5jW2BVg8jwVSCZw32prB18dfrHWVb53uCECtdt9i38x6Ad/JXxdplu/OJe9owmpycMe3P7NE9wFcjAejya2SvMN6tMLKNNqRTonv8nqWEi3tTzfM4/h0ClAhJVBebZb6A+z544PiJHXhgGrYUIe/O64Ux3w1X4svOQ/X2LdMKOIJKFHwVgP/w2CQFpR4wpLjqoEDCAmlgr1msUTyyL4sBnnb2aqWwmL2VnpXno9PG5Li886byXs8mVEZ4NYpxivc49sn3s+5WZSn2B1b1+zHumLK5cQmZiDrZl5RaLSUckHWC41R8V7yhKS1bG3kGC9CPLlXMARrOAchBYA3RFIE4GFMQqebWKPM9s3CVep9/jSVp8dhohAG/G4oSgKKgvzSdZ/DW0fXqmRL1EIAH9HH9lIOcOpCv7OB8uqU918AT5ymreoxrfVPzpeczzDU6eB5HWAHi0yeVoMdGGS6GSY5jnd4Km4pYF/iXO8RCqBoOs/jLtk1o4D90/l3ZdCqG/D/qfdTJBTEVoiGGUA4WR8xNA/5I3h/5aHevwW2HZ48CNLa7imgBrGxcIAegCY6zFRnp26iuEHkVdzE5clLAU/iHP4MdyZP5cFpAnveOAMYwfuaBFvZKqgCO4A9j5LgY6lzL9WT7Jnn02CQcNRqoIQS/HYZ2BrB8x4PWOR5d2I8AkUAb/J9Fob8ek3dFtfBJsYlGVwRJ7A4jQf9tnReIoso9JQ36FJgVkopBxOMqr7Pwsfn+6pOHLAnOP1ezYYT35wXtKwl7DXgQbotDAmg5XHax+O4yDDptvUio+JPCyksegwXYe7guwEAzadT2GqTyod5RmqwhIDoPayFHbhX8XQGgKX8uDMJBOtg91te/nLNB4CSxQAih/K9VudSvncByyYazNNtQE9+FhfRj76l/266Kwoh4rPia9A5hMJtc9fTMUUm8PY9++x6oSXDRvZ5yzHHLgYdhZNkWXAw8zJ43ucltme3e6qB5MxxPhPcKafZdiGoy4ODg4ODw68Ejjp7FkEjvVje4mFs9c2LNss8L5AP7d9GsKVAQohinXzP836+NeF5EmuoBOFsG4vn+fHWyhOe/fZ58LwMXi+4bWyOz1pqw9PP4RVxByWhpYoFOGu677tCT7ZuuP/4TKtc2d0Mjz/0hz2n0ns4Cp73HH+Pz9ltrD6TDOAGtvOT2fafBZPAlfaTnveY8R5Mb3ezLyUrYr3M8aYPsqcpSeqpsQD3ckcf8aDYgh0XjTZPUNjx8wVMce4D6+gVyfrtzX6JGKZFYSn3SVVYTrN4Y5JQvRXWx8nxLZOTKqKbEtKoDc+T6yLbvx9oxMckeeieAB4Wr2sVTS4bbL/Elr93X9n2Id1T/YPm5gE1+Rr7QjxYKudoO39X9n88rJCWbOsdACL0uIbXs963JX7E23XWkpf8aiJ5GA8VP4u8CPYgirhT2Hz2/KsA3tofc3wln+3g5YH///xn/MfiF0mddXBwcHD49cF5FuUMz4vwWdxX8fTL033lnMPzqp5WQ0biqp638Sds28rD01SS8XnwvBVnvJ+EQ/x/SWPI8+qWyNlYWXoPyBDrOu2U2zjdb5/qPHleL56W9Bg9T5o1xfP/0+yyGew1fWc9m7MJ6z1uPYXHWsifyz4PnhcKXMZ5KU4feV1Ovc9lWdI/BoHW9kCe93q5W+FeF74uQphYnOLzXlgquBF5Ft6AX39U3XkWDg4ODg5nBc6zOIf4pXoWv3X4WSPEWAM8L/V0X3EoBZ4X+qO1hn4rEC/i1HT03wacNpSDg4ODQ5lwYSgHBwcHh7OCX6Vn4eDg4OBwbuE8CwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGC4cLGkqpSkqpVG73W6yUSue/93zrpCildvmWJfyI7T6rlMpQSm1WSi1UStXg+RWVUq8ppb5QSm1SSiWd4vsJSqm1/HvrlFJteH53pdSvX1/C4VcHR511uKChlBoOIFRr/YJS6ojWukop66QAWKy1nn8G2+0EYKXWukgpNQkAtNaj+fdaa63vUkrVBknB/k5rfTLo+8sBPKe1/lAp1RXAKK11klJKAdgAoJ3W+thPPGwHhzOG8ywcLnT0B/Du2d6o1nq51lq0MdbCSO+hKYAVvM5eUBfw1iW3AA3b0rA6uC2jJutuFUr093NwKF+4wcLhgoVSqiKABlrrTJ4VwSGftUqpnkGrP8UhpeeUUuFn+FN3wzaT2ASgh1IqVCkVB6AVgJhSvnMfgGeVUtkAJgN4xLdsHYBrz3AfHBx+Ftxg4XAhoybIshfU01q3BvWQf14p1ZDnPwLqEvQ7UFeh0T/2B5RSY0F9Y2fzrH+DmsGuAzV+/QyBfWUFwwDcr7WOAXA/qKe9YC+AuqV8x8Gh3OAGC4cLGccBRMg/WmsJ9ewEhXpa8P8/aEIBgNcAtAneECet05VSS3zzBoLCRf05fAStdZHW+n6tdYLWugeod+C24O2BmjdIg/a3g34zgvfdweGcwQ0WDhcstNb/AxCilIpQSl0s4SWlVE0A7QBs4f8v4akCNRL9kv9vo5R6nbd1Fw8AXXlZF5AHcos/Ea2UukgpVZk/3wigSGu9pZTd2w2Ae67iegQOKJfLPjg4nCsEN/Z1cLjQsBzU7PoYgFeUUidBRtTffC/x2UqpWgAUqJv4UJ5fD6e28F8CEA7gIxpjsFZrPRTUTH0Z/873AO6QLyilZgCYprVeB2AwgBeUUqGgLuF/9m37OgTmMBwcyh2OOutwQUMp1QLASK31HWWuXPK7zwJ4Q2u9+ezv2Sl/MxrAHK11xzJXdnA4i3CDhcMFD6XU3QBmaq2Lz/e+lAWl1O8AFGqt08/3vjhcWHCDhYODg4NDmXAJbgcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuEGCwcHBweHMuF6cF+gUOpyTW2nK4BaSwdPcZpl/j//+rLx06yKMjbzY9cN3r1T/W7AMg1AQ1XQUIqnKPkHaFSA5p84GTAtbf1T/ZX2/TPZzo/aD62hTgKKVi/77ySfj5P8v//zqdYt7XtlrXOK7Z7UgOapf5WTQZsM/ongzycB/AAs01p3gcM5gRssLlgcBXAvgEqg26ASgDDfNHheWeswQvnfCAAhQZ9lMxE8DfdtJryMdYPXCS1lWtq2zTINRJxAhZAihFc6gZDQYoRHFCCkQjEq4gRCUIRQ2M/hOIEQFKMiCgLmn9k6xQhHQSnrFAd8/8zW8f1G8QmEFBUhvOAkQooAVQCgCIBM/Z9PNT3dsnwAxaeYFzw93bJ8Xl4MHM8HCnlaBDJXigAcB1AY9Nk/LQr6fByAB9SEwzmDC0M5ODg4OJQJN1g4ODg4OJQJN1g4ODg4OJQJN1g4ODg4OJQJN1g4ODg4OJQJpbUuey2H3xyUUl+CeCoODr9WRGitrzrfO3GhwFFnL1zka61bn++dcHD4qVBKrTvf+3AhwYWhHBwcHBzKhBssHBwcHBzKhBssLlz863zvgIPDz4S7h88hXILbwcHBwaFMOM/CwcHBwaFMuMHCwcHBwaFMuMHiAoNS6t9Kqb1cZ+Hg8IuFUipGKfWJUmqrUuorpdS9PD9SKfWRUmobTy/m+Uop9Q+l1Hal1GalVMvzewS/LbjB4sJDCgDXA8Dh14AiAA9orZsAaAtguFKqKYCHAazQWscDWMH/A8BNAOL5788App77Xf7twg0WFxi01v8BkHe+98PBoSxorX/QWm/gz4cBbAVwKYAeAGbyajMB9OTPPQC8rglrAdRQSl1yjnf7Nws3WDg4OPzioZSqD6AFgDQA0VrrHwAaUADU5tUuBZDt+9p3PM/hLMANFg4ODr9oKKWqAFgA4D6t9aHTrVrKPFcbcJbgBgsHB4dfLJRSYaCBYrbW+h2enSPhJZ7u5fnfAYjxff0yALvP1b7+1uEGCwcHh18klFIKwKsAtmqtp/gWvQdgIH8eCOBd3/w7mRXVFsBBCVc5/Hy4Cu4LDEqpuQCSQM3ucwCM11q/el53ysGhFCgD8sZgAAAAeElEQVSl2gP4FMAXAE7y7DGgvMVbAOoB+BZAX611Hg8uL4HYfscA3KW1dsq0ZwlusHBwcHBwKBMuDOXg4ODgUCbcYOHg4ODgUCbcYOHg4ODgUCbcYOHg4ODgUCbcYOHg4ODgUCbcYOHg4ODgUCbcYOHg4ODgUCb+P+MvQ+pj4p8gAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "hp.gnomview(counts,rot=[55,-29.8],reso=hp.nside2resol(nside,arcmin=True),max=200)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tracts outline: \n", + "for each tract build the map and flag pixels with some neighbours unseen (for superior minds only)" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NSIDE=2048\n", + "4848-4636-4639-5065-5064-4637-4432-5063-4640-4433-4429-5066-4430-4638-4431-4851-4849-4852-5062-4850-" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#list of tracts\n", + "tracts=df.select(\"tract\").distinct().toPandas()\n", + "df_withpix=df.groupBy([\"tract\",\"ipix\"]).count().cache()\n", + "ipix=np.arange(hp.nside2npix(nside))\n", + "pixborder=[]\n", + "print(\"NSIDE={}\".format(nside))\n", + "for t in tracts['tract'].values :\n", + " print(t,end='-')\n", + " #create a map just for this tract\n", + " df_map=df_withpix.filter(df_withpix.tract==int(t))\n", + " #create the healpix map\n", + " tract_p=df_map.toPandas()\n", + " plt.hist(tract_p['count'].values)\n", + " tract_map = np.full(hp.nside2npix(nside),hp.UNSEEN)\n", + " tract_map[tract_p['ipix'].values]=1\n", + " # for lit pixels compute the neighbours\n", + " ipix1=tract_p['ipix'].values\n", + " theta,phi=hp.pix2ang(nside,ipix1)\n", + " neighbours=hp.get_all_neighbours(nside,theta,phi,0).transpose()\n", + " # border if at least one neighbours is UNSEEN\n", + " mask=[(hp.UNSEEN in tract_map[neighbours[pixel]]) for pixel in range(len(ipix1))]\n", + " pixborder+=list(ipix1[mask])" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "count_t=counts\n", + "count_t[pixborder]=-1\n", + "resol= hp.nside2resol(nside,arcmin=True)\n", + "hp.gnomview(count_t,rot=[55,-29.8],reso=resol,xsize=200,min=0,max=180)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Filter data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "most of data do not have any valid psFlug flag:" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total number of objects= 3.183404 millions\n", + "#object with at least one filter= 0.523433 millions\n" + ] + } + ], + "source": [ + "print(\"total number of objects= {} millions\".format(df.count()/1e6))\n", + "dff=df.filter((df['psFlux_flag_u']==True) | \\\n", + " (df['psFlux_flag_g']==True) | \\\n", + " (df['psFlux_flag_r']==True) | \\\n", + " (df['psFlux_flag_i']==True) | \\\n", + " (df['psFlux_flag_z']==True) | \\\n", + " (df['psFlux_flag_y']==True))\n", + "print(\"#object with at least one filter= {} millions\".format(dff.count()/1e6))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "does the densit map change for these?" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------+------------------+\n", + "|summary| count|\n", + "+-------+------------------+\n", + "| count| 20324|\n", + "| mean| 25.75442826215312|\n", + "| stddev|39.150379554127184|\n", + "| min| 1|\n", + "| max| 414|\n", + "+-------+------------------+\n", + "\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "dff_map=dff.groupBy(\"ipix\").count()\n", + "dff_map.describe(['count']).show() \n", + "mapf_p=dff_map.toPandas()\n", + "plt.hist(mapf_p['count'].values)\n", + "counts_f = np.full(hp.nside2npix(nside),hp.UNSEEN)\n", + "counts_f[mapf_p['ipix'].values]=mapf_p['count'].values\n", + "#counts_f[pixborder]=-1\n", + "resol= hp.nside2resol(nside,arcmin=True)\n", + "hp.gnomview(counts_f,rot=[55,-29.8],reso=resol,min=0,max=30)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "desc-pyspark", + "language": "python", + "name": "desc-pyspark" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Notebooks/footprint_Run12p_spark.ipynb b/Notebooks/footprint_Run12p_spark.ipynb new file mode 100644 index 0000000..f681eeb --- /dev/null +++ b/Notebooks/footprint_Run12p_spark.ipynb @@ -0,0 +1,798 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# DC2 Run1.2 object catalog footprint (Spark)\n", + "
Kernel: **desc-pyspark**\n", + "
Owner: **S Plaszczynski** (https://github.com/LSSTDESC/DC2-production/issues/299)\n", + "
Last Verified to Run: **2018-11-18**\n", + " \n", + "The goal of this notebook is to have a QA look a the dc2-data-access produced object_catalog (currently on Run1.2p)\n", + "It also illustrates how simple and efficient Spark is.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## load the full Run1.2 catalog from single parquet file" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "spark session started\n" + ] + } + ], + "source": [ + "from pyspark.sql import SparkSession\n", + "\n", + "# Initialise our Spark session\n", + "spark = SparkSession.builder.getOrCreate()\n", + "print(\"spark session started\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "root\n", + " |-- magerr_g: double (nullable = true)\n", + " |-- I_flag_g: boolean (nullable = true)\n", + " |-- tract: long (nullable = true)\n", + " |-- IxyPSF_y: double (nullable = true)\n", + " |-- I_flag_y: boolean (nullable = true)\n", + " |-- Ixx_i: double (nullable = true)\n", + " |-- dec: double (nullable = true)\n", + " |-- magerr_u: double (nullable = true)\n", + " |-- mag_z_cModel: double (nullable = true)\n", + " |-- mag_u: double (nullable = true)\n", + " |-- snr_g_cModel: double (nullable = true)\n", + " |-- Ixx: double (nullable = true)\n", + " |-- mag_u_cModel: double (nullable = true)\n", + " |-- magerr_y: double (nullable = true)\n", + " |-- magerr_r_cModel: double (nullable = true)\n", + " |-- IxyPSF_r: double (nullable = true)\n", + " |-- psFlux_y: double (nullable = true)\n", + " |-- magerr_y_cModel: double (nullable = true)\n", + " |-- mag_g_cModel: double (nullable = true)\n", + " |-- Iyy_i: double (nullable = true)\n", + " |-- I_flag_z: boolean (nullable = true)\n", + " |-- snr_u_cModel: double (nullable = true)\n", + " |-- Ixy_z: double (nullable = true)\n", + " |-- psFluxErr_r: double (nullable = true)\n", + " |-- mag_i_cModel: double (nullable = true)\n", + " |-- Ixy: double (nullable = true)\n", + " |-- psf_fwhm_g: double (nullable = true)\n", + " |-- x: double (nullable = true)\n", + " |-- psFlux_z: double (nullable = true)\n", + " |-- Ixy_u: double (nullable = true)\n", + " |-- psNdata: float (nullable = true)\n", + " |-- snr_i_cModel: double (nullable = true)\n", + " |-- IyyPSF_z: double (nullable = true)\n", + " |-- Iyy_u: double (nullable = true)\n", + " |-- mag_i: double (nullable = true)\n", + " |-- parentObjectId: long (nullable = true)\n", + " |-- IxxPSF_y: double (nullable = true)\n", + " |-- IyyPSF_r: double (nullable = true)\n", + " |-- psFluxErr_i: double (nullable = true)\n", + " |-- I_flag: boolean (nullable = true)\n", + " |-- mag_y_cModel: double (nullable = true)\n", + " |-- IyyPSF_u: double (nullable = true)\n", + " |-- I_flag_u: boolean (nullable = true)\n", + " |-- magerr_u_cModel: double (nullable = true)\n", + " |-- xErr: float (nullable = true)\n", + " |-- IxxPSF_u: double (nullable = true)\n", + " |-- IxxPSF_r: double (nullable = true)\n", + " |-- I_flag_r: boolean (nullable = true)\n", + " |-- psFlux_flag_i: boolean (nullable = true)\n", + " |-- psf_fwhm_i: double (nullable = true)\n", + " |-- IxxPSF: double (nullable = true)\n", + " |-- psf_fwhm_z: double (nullable = true)\n", + " |-- y: double (nullable = true)\n", + " |-- Iyy: double (nullable = true)\n", + " |-- magerr_i_cModel: double (nullable = true)\n", + " |-- IyyPSF_y: double (nullable = true)\n", + " |-- psFluxErr_g: double (nullable = true)\n", + " |-- psFlux_flag_y: boolean (nullable = true)\n", + " |-- magerr_i: double (nullable = true)\n", + " |-- psFlux_flag_z: boolean (nullable = true)\n", + " |-- I_flag_i: boolean (nullable = true)\n", + " |-- snr_z_cModel: double (nullable = true)\n", + " |-- Ixy_g: double (nullable = true)\n", + " |-- psFlux_r: double (nullable = true)\n", + " |-- psf_fwhm_r: double (nullable = true)\n", + " |-- magerr_g_cModel: double (nullable = true)\n", + " |-- IyyPSF_g: double (nullable = true)\n", + " |-- Ixx_z: double (nullable = true)\n", + " |-- IxyPSF: double (nullable = true)\n", + " |-- psFlux_flag_r: boolean (nullable = true)\n", + " |-- objectId: long (nullable = true)\n", + " |-- Ixx_u: double (nullable = true)\n", + " |-- magerr_z_cModel: double (nullable = true)\n", + " |-- patch: string (nullable = true)\n", + " |-- IxyPSF_i: double (nullable = true)\n", + " |-- IxyPSF_u: double (nullable = true)\n", + " |-- IxyPSF_z: double (nullable = true)\n", + " |-- mag_r_cModel: double (nullable = true)\n", + " |-- magerr_r: double (nullable = true)\n", + " |-- Ixx_r: double (nullable = true)\n", + " |-- IxxPSF_z: double (nullable = true)\n", + " |-- Ixy_i: double (nullable = true)\n", + " |-- psf_fwhm_y: double (nullable = true)\n", + " |-- Iyy_g: double (nullable = true)\n", + " |-- Iyy_y: double (nullable = true)\n", + " |-- IxxPSF_i: double (nullable = true)\n", + " |-- mag_z: double (nullable = true)\n", + " |-- psFluxErr_u: double (nullable = true)\n", + " |-- psFlux_i: double (nullable = true)\n", + " |-- IyyPSF: double (nullable = true)\n", + " |-- clean: boolean (nullable = true)\n", + " |-- psFlux_u: double (nullable = true)\n", + " |-- mag_y: double (nullable = true)\n", + " |-- Ixx_y: double (nullable = true)\n", + " |-- blendedness: double (nullable = true)\n", + " |-- Iyy_r: double (nullable = true)\n", + " |-- mag_g: double (nullable = true)\n", + " |-- snr_y_cModel: double (nullable = true)\n", + " |-- xy_flag: boolean (nullable = true)\n", + " |-- magerr_z: double (nullable = true)\n", + " |-- psFluxErr_z: double (nullable = true)\n", + " |-- Ixx_g: double (nullable = true)\n", + " |-- ra: double (nullable = true)\n", + " |-- IyyPSF_i: double (nullable = true)\n", + " |-- psFlux_flag_u: boolean (nullable = true)\n", + " |-- good: boolean (nullable = true)\n", + " |-- IxxPSF_g: double (nullable = true)\n", + " |-- Ixy_y: double (nullable = true)\n", + " |-- psf_fwhm_u: double (nullable = true)\n", + " |-- yErr: float (nullable = true)\n", + " |-- mag_r: double (nullable = true)\n", + " |-- IxyPSF_g: double (nullable = true)\n", + " |-- psFluxErr_y: double (nullable = true)\n", + " |-- psFlux_g: double (nullable = true)\n", + " |-- snr_r_cModel: double (nullable = true)\n", + " |-- Ixy_r: double (nullable = true)\n", + " |-- extendedness: double (nullable = true)\n", + " |-- psFlux_flag_g: boolean (nullable = true)\n", + " |-- Iyy_z: double (nullable = true)\n", + "\n" + ] + } + ], + "source": [ + "object_catalog=\"/global/cscratch1/sd/plaszczy/Run1.2p/object_catalog/full_catalog.parquet\"\n", + "df_all=spark.read.parquet(object_catalog)\n", + "df_all.printSchema()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['tract', 'patch', 'ra', 'dec', 'psFlux_flag_u', 'psFlux_flag_g', 'psFlux_flag_r', 'psFlux_flag_i', 'psFlux_flag_z', 'psFlux_flag_y']\n", + "#galaxies=27.083536 millions\n" + ] + } + ], + "source": [ + "#select relevant columns (we alos add the filter flags)\n", + "cols=[\"tract\",\"patch\",\"ra\",\"dec\"]\n", + "for f in ['u','g','r','i','z','y']:\n", + " s=[\"psFlux_flag_{}\".format(f)]\n", + " cols+=s\n", + "print(cols)\n", + "\n", + "df=df_all.select(cols)\n", + "N=df.cache().count()\n", + "print(\"#galaxies={} millions\".format(N/1e6))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Look at tracts and patches" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "20" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.select(\"tract\").distinct().count() #check that all the tracts are present" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "According to https://github.com/LSSTDESC/DC2-analysis/blob/master/tutorials/dm_butler_skymap.ipynb This is OK. how many patches per tract?" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----+--------+\n", + "|tract|#patches|\n", + "+-----+--------+\n", + "| 4429| 42|\n", + "| 4430| 56|\n", + "| 4431| 56|\n", + "| 4432| 56|\n", + "| 4433| 7|\n", + "| 4636| 16|\n", + "| 4637| 64|\n", + "| 4638| 64|\n", + "| 4639| 64|\n", + "| 4640| 48|\n", + "| 4848| 48|\n", + "| 4849| 64|\n", + "| 4850| 64|\n", + "| 4851| 64|\n", + "| 4852| 16|\n", + "| 5062| 17|\n", + "| 5063| 56|\n", + "| 5064| 56|\n", + "| 5065| 56|\n", + "| 5066| 35|\n", + "+-----+--------+\n", + "\n" + ] + } + ], + "source": [ + "df.groupBy([\"tract\",\"patch\"]).count().groupBy(\"tract\").count().\\\n", + "withColumnRenamed(\"count\",\"#patches\").sort(\"tract\").show() #groupBy twice, rename and sort" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## (ra,dec) footprint" + ] + }, + { + "cell_type": "code", + "execution_count": 85, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 85, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#are there some Nans?\n", + "import numpy as np\n", + "df.filter(df['ra'].contains(np.nan)).count()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "No so lets do some basic statistics" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------+------------------+-------------------+\n", + "|summary| ra| dec|\n", + "+-------+------------------+-------------------+\n", + "| count| 27083536| 27083536|\n", + "| mean| 55.07338013097766| -29.79419390003542|\n", + "| stddev|1.9014363884446157| 1.643124412278626|\n", + "| min| 51.74916962374651| -32.58858724482577|\n", + "| max| 58.36818361208815|-26.947017635210035|\n", + "+-------+------------------+-------------------+\n", + "\n" + ] + } + ], + "source": [ + "df.describe(['ra','dec']).show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will project galaxies in a Healpix map. For that we define a pandas User Defined Function to call healpy ang2pix function" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import healpy as hp\n", + "from pyspark.sql.functions import pandas_udf, PandasUDFType\n", + "\n", + "nside=2048\n", + "#create the ang2pix user-defined-function. \n", + "#we use pandas_udf because they are more efficient\n", + "@pandas_udf('int', PandasUDFType.SCALAR)\n", + "def Ang2Pix(ra,dec):\n", + " return pd.Series(hp.ang2pix(nside,np.radians(90-dec),np.radians(ra)))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-------+------------------+\n", + "|summary| count|\n", + "+-------+------------------+\n", + "| count| 38202|\n", + "| mean| 708.9559708915764|\n", + "| stddev|215.22373289498606|\n", + "| min| 1|\n", + "| max| 1658|\n", + "+-------+------------------+\n", + "\n" + ] + } + ], + "source": [ + "#add a column of healpix indices\n", + "df=df.withColumn(\"ipix\",Ang2Pix(\"ra\",\"dec\"))\n", + "#groupby indices and count the number of elements in each group\n", + "df_map=df.groupBy(\"ipix\").count()\n", + "#statistics per pixel\n", + "df_map.describe(['count']).show() " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "#back to python world\n", + "map_p=df_map.toPandas()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "#now data is reduced create the healpy map\n", + "counts = np.zeros(hp.nside2npix(nside))\n", + "counts[map_p['ipix'].values]=map_p['count'].values\n", + "counts[counts==0]=hp.UNSEEN" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "plt.set_cmap('jet') #color-blind people should comment this line\n", + "\n", + "hp.mollview(counts)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "from the previous mean ra/dec and count statistics we can zoom on the center and perform a gnomonic projection" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "hp.gnomview(counts,rot=[55,-29.8],reso=hp.nside2resol(nside,arcmin=True),max=1200)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tracts outline: \n", + "for each tract build the map and flag pixels with some neighbours unseen (for superior minds only)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "NSIDE=2048\n", + "4848-4636-4639-5065-5064-4637-4432-5063-4640-4433-4429-5066-4430-4638-4431-4851-4849-4852-5062-4850-" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#list of tracts\n", + "tracts=df.select(\"tract\").distinct().toPandas()\n", + "df_withpix=df.groupBy([\"tract\",\"ipix\"]).count().cache()\n", + "ipix=np.arange(hp.nside2npix(nside))\n", + "pixborder=[]\n", + "print(\"NSIDE={}\".format(nside))\n", + "for t in tracts['tract'].values :\n", + " print(t,end='-')\n", + " #create a map just for this tract\n", + " df_map=df_withpix.filter(df_withpix.tract==int(t))\n", + " #create the healpix map\n", + " tract_p=df_map.toPandas()\n", + " plt.hist(tract_p['count'].values)\n", + " tract_map = np.full(hp.nside2npix(nside),hp.UNSEEN)\n", + " tract_map[tract_p['ipix'].values]=1\n", + " # for lit pixels compute the neighbours\n", + " ipix1=tract_p['ipix'].values\n", + " theta,phi=hp.pix2ang(nside,ipix1)\n", + " neighbours=hp.get_all_neighbours(nside,theta,phi,0).transpose()\n", + " # border if at least one neighbours is UNSEEN\n", + " mask=[(hp.UNSEEN in tract_map[neighbours[pixel]]) for pixel in range(len(ipix1))]\n", + " pixborder+=list(ipix1[mask])" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "count_t=counts\n", + "count_t[pixborder]=-1\n", + "resol= hp.nside2resol(nside,arcmin=True)\n", + "hp.gnomview(count_t,rot=[55,-29.8],reso=resol,xsize=200,min=0,max=1200)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Hot spots" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "metadata": {}, + "outputs": [], + "source": [ + "t=df.filter(df.tract==4640).groupBy(\"patch\").count()" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "+-----+-----+\n", + "|patch|count|\n", + "+-----+-----+\n", + "| 4,3|37800|\n", + "| 3,1|68666|\n", + "| 2,6| 140|\n", + "| 2,7| 203|\n", + "| 3,2|47241|\n", + "+-----+-----+\n", + "only showing top 5 rows\n", + "\n" + ] + } + ], + "source": [ + "t.show(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "we go back to the standard python world and create a dictionary of occupancy per patch " + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [], + "source": [ + "occ=dict(t.toPandas().values)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "then fill a 8x8 matrix from these to see which patches are missing" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "mat=np.zeros([8,8],'int')\n", + "for k in occ.keys():\n", + " i=int(k[0])\n", + " j=int(k[2])\n", + " mat[i,j]=occ[k]" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(mat.transpose(),origin='lower',cmap='binary');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Loks like the hot-spots corresponds to **patches=3,1/3,3/3,5**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Filter data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "most of data do not have any valid psFlug flag:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total number of objects= 27.083536 millions\n", + "#object with at least one filter= 1.793273 millions\n" + ] + } + ], + "source": [ + "print(\"total number of objects= {} millions\".format(df.count()/1e6))\n", + "dff=df.filter((df['psFlux_flag_u']==True) | \\\n", + " (df['psFlux_flag_g']==True) | \\\n", + " (df['psFlux_flag_r']==True) | \\\n", + " (df['psFlux_flag_i']==True) | \\\n", + " (df['psFlux_flag_z']==True) | \\\n", + " (df['psFlux_flag_y']==True))\n", + "print(\"#object with at least one filter= {} millions\".format(dff.count()/1e6))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "does the densit map change for these?" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "map_p=dff.groupBy(\"ipix\").count().toPandas()\n", + "counts_f = np.zeros(hp.nside2npix(nside))\n", + "counts_f[map_p['ipix'].values]=map_p['count'].values\n", + "counts_f[counts_f==0]=hp.UNSEEN\n", + "counts_f[pixborder]=-1\n", + "resol= hp.nside2resol(nside,arcmin=True)\n", + "hp.gnomview(counts_f,rot=[55,-29.8],reso=resol,max=30)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## my conclusions/questions (2018.11.26)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- 6% of data has some flux values. 27M without, 1.7M with. how much do we expect?\n", + "- where is the uDDF?\n", + "- what does happen at the boundary of the whole fontprint?\n", + "- shall we move this dataset to `projecta`?\n", + "- tests on 1.1p? 1.2i?" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "desc-pyspark", + "language": "python", + "name": "desc-pyspark" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}