{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 1. Exoplanet characterisation based on a single light curve\n", "\n", "## Introduction\n", "\n", "This is a first part of a set of tutorials covering Bayesian exoplanet characterisation using wide-band photometry (transit light curves), radial velocities, and, later, transmission spectroscopy. The tutorials use freely available open source tools built around the scientific python ecosystem, and also demonstrate the use of ``PyTransit`` and ``LDTk``.\n", "\n", "The tutorials are mainly targeted to graduate students working in exoplanet characterisation who already have some experience of Python and Bayesian statistics. \n", "\n", "## Prerequisites\n", "\n", "This tutorial requires the basic Python packages for scientific computing and data analysis\n", "- NumPy, SciPy, IPython, astropy, pandas, matplotlib, and [seaborn](http://stanford.edu/~mwaskom/software/seaborn/)\n", "\n", "The MCMC sampling requires the [*emcee*](https://github.com/dfm/emcee) and [acor](https://github.com/dfm/acor) packages by D. Foreman-Mackey. These can either be installed from github or from [PyPI](https://pypi.python.org/pypi).\n", "\n", "The transit modelling is carried out with [PyTransit](https://github.com/hpparvi/PyTransit), and global optimisation with PyDE. PyTransit can be installed easily from github. First ``cd`` into the directory you want to clone the code, and then\n", "\n", " git clone https://github.com/hpparvi/PyTransit.git; cd PyTransit\n", " python setup.py install; cd -\n", " \n", "What comes to assumed prior knowledge, well... I assume you already know a bit about Bayesian statistics (I'll start with a very rough overview of the basics of Bayesian parameter estimation, though), Python (and especially the scientific packages), have a rough idea of MCMC sampling (and how *emcee* works), and, especially, have the grasp of basic concepts of exoplanets, transits, and photometry.\n", "\n", "## Bayesian parameter estimation\n", "\n", "This first tutorial covers the simple case of an exoplanet system characterisation based on a single photometric timeseries of an exoplanet transit (transit light curve). The system characterisation is a *parameter estimation* problem, where we assume we have an adequate model to describe the observations, and we want to infer the model parameters with their uncertainties.\n", "\n", "We take a [*Bayesian*](http://en.wikipedia.org/wiki/Bayesian_probability) approach to the parameter estimation, where we want to estimate the [*posterior probability*](http://en.wikipedia.org/wiki/Posterior_probability) for the model parameters given their [*prior probabilities*](http://en.wikipedia.org/wiki/Prior_probability) and a set of observations. The posterior probability density given a parameter vector $\\theta$ and observational data $D$ is described by the [*Bayes' theorem*](http://en.wikipedia.org/wiki/Bayes%27_theorem) as\n", "\n", "$$\n", "P(\\theta|D) = \\frac{P(\\theta) P(D|\\theta)}{P(D)}, \\qquad P(D|\\theta) = \\prod P(D_i|\\theta),\n", "$$\n", "\n", "where $P(\\theta)$ is the prior, $P(D|\\theta)$ is the [*likelihood*](http://en.wikipedia.org/wiki/Likelihood_function) for the data, and $P(D)$ is a [*normalising factor*](http://en.wikipedia.org/wiki/Marginal_likelihood) we don't need to bother with during MCMC-based parameter estimation. \n", "\n", "The likelihood is a product of individual observation probabilities, and has the unfortunate tendency to end up being either very small or very big. This causes computational headaches, and it is better to work with log probabilities instead, so that\n", "\n", "$$\n", "\\log P(\\theta|D) = \\log P(\\theta) + \\log P(D|\\theta), \\qquad \\log P(D|\\theta) = \\sum \\log P(D_i|\\theta)\n", "$$\n", "\n", "where we have omitted the $P(D)$ term from the posterior density.\n", "\n", "Now we still need to decide our likelihood density. If we can assume normally distributed white noise--that is, the errors in the observations are independent and identically distributed--we end up with a log likelihood function\n", "\n", "$$\n", " \\log P(D|\\theta) = -N\\log(\\sigma) -\\frac{N\\log 2\\pi}{2} - \\sum_{i=0}^N \\frac{(o_i-m_i)^2}{2\\sigma^2},\n", "$$\n", "\n", "where $N$ is the number of datapoints, $\\sigma$ is the white noise standard deviation, $o$ is the observed data, and $m$ is the model. \n", "\n", "*Note:* Unfortunately, the noise is rarely white, but contains systematic components from instrumental and astrophysical sources that should be accounted for by the noise model for robust parameter estimation. This, however, goes beyond a basic tutorial.\n", "\n", "## Implementation\n", "\n", "### Initialisation" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Populating the interactive namespace from numpy and matplotlib\n" ] } ], "source": [ "%pylab inline " ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [], "source": [ "import math as mt\n", "import pandas as pd\n", "import seaborn as sb\n", "\n", "with warnings.catch_warnings():\n", " cp = sb.color_palette()\n", "\n", "from pathlib import Path\n", "from IPython.display import display, HTML\n", "from numba import njit, prange\n", "from astropy.io import fits as pf\n", "from emcee import EnsembleSampler\n", "from tqdm.auto import tqdm\n", "from corner import corner\n", "\n", "from pytransit import QuadraticModel\n", "from pytransit.utils.de import DiffEvol\n", "from pytransit.orbits.orbits_py import as_from_rhop, i_from_ba\n", "from pytransit.param.parameter import (ParameterSet, GParameter, PParameter, LParameter,\n", " NormalPrior as NP, \n", " UniformPrior as UP)\n", "seterr('ignore')\n", "random.seed(0)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "@njit(parallel=True, cache=False, fastmath=True)\n", "def lnlike_normal_v(o, m, e):\n", " m = atleast_2d(m)\n", " npv = m.shape[0]\n", " npt = o.size\n", " lnl = zeros(npv)\n", " for i in prange(npv):\n", " for j in range(npt):\n", " lnl[i] += -log(e[i]) - 0.5*log(2*pi) - 0.5*((o[j]-m[i,j])/e[i])**2\n", " return lnl" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Log posterior function\n", "\n", "The log posterior function is the workhorse of the analysis. I implement it as a class that stores the observation data and the priors, contains the methods to calculate the model and evaluate the log posterior probability density, and encapsulates the optimisation and MCMC sampling routines." ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "class LPFunction:\n", " def __init__(self, name: str, times: ndarray = None, fluxes: ndarray = None):\n", " self.tm = QuadraticModel(klims=(0.05, 0.25), nk=512, nz=512)\n", "\n", " # LPF name\n", " # --------\n", " self.name = name\n", " \n", " # Declare high-level objects\n", " # --------------------------\n", " self.ps = None # Parametrisation\n", " self.de = None # Differential evolution optimiser\n", " self.sampler = None # MCMC sampler\n", "\n", " # Initialize data\n", " # ---------------\n", " self.times = asarray(times)\n", " self.fluxes = asarray(fluxes)\n", " self.tm.set_data(self.times)\n", "\n", " # Define the parametrisation\n", " # --------------------------\n", " self.ps = ParameterSet([\n", " GParameter('tc', 'zero_epoch', 'd', NP(0.0, 0.1), (-inf, inf)),\n", " GParameter('pr', 'period', 'd', NP(1.0, 1e-5), (0, inf)),\n", " GParameter('rho', 'stellar_density', 'g/cm^3', UP(0.1, 25.0), (0, inf)),\n", " GParameter('b', 'impact_parameter', 'R_s', UP(0.0, 1.0), (0, 1)),\n", " GParameter('k2', 'area_ratio', 'A_s', UP(0.05**2, 0.25**2), (0.05**2, 0.25**2)),\n", " GParameter('q1', 'q1_coefficient', '', UP(0, 1), bounds=(0, 1)),\n", " GParameter('q2', 'q2_coefficient', '', UP(0, 1), bounds=(0, 1)),\n", " GParameter('loge', 'log10_error', '', UP(-4, 0), bounds=(-4, 0))])\n", " self.ps.freeze()\n", "\n", " def create_pv_population(self, npop=50):\n", " return self.ps.sample_from_prior(npop)\n", " \n", " def baseline(self, pv):\n", " \"\"\"Multiplicative baseline\"\"\"\n", " return 1.\n", "\n", " def transit_model(self, pv, copy=True):\n", " pv = atleast_2d(pv)\n", " \n", " # Map from sampling parametrisation to the transit model parametrisation\n", " # ----------------------------------------------------------------------\n", " pvt = zeros((pv.shape[0], 7))\n", " pvt[:,0] = sqrt(pv[:,4])\n", " pvt[:,1:3] = pv[:,0:2]\n", " pvt[:, 3] = as_from_rhop(pv[:,2], pv[:,1])\n", " pvt[:, 4] = i_from_ba(pv[:,3], pvt[:,3])\n", " \n", " # Map the limb darkening\n", " # ----------------------\n", " ldc = zeros((pv.shape[0],2))\n", " a, b = sqrt(pv[:,5]), 2.*pv[:,6]\n", " ldc[:,0] = a * b\n", " ldc[:,1] = a * (1. - b)\n", " \n", " return self.tm.evaluate_pv(pvt, ldc)\n", "\n", " def flux_model(self, pv):\n", " return self.transit_model(pv) * self.baseline(pv)\n", "\n", " def residuals(self, pv):\n", " return self.fluxes - self.flux_model(pv)\n", "\n", " def set_prior(self, pid: int, prior) -> None:\n", " self.ps[pid].prior = prior\n", "\n", " def lnprior(self, pv):\n", " return self.ps.lnprior(pv)\n", "\n", " def lnlikelihood(self, pv):\n", " flux_m = self.flux_model(pv)\n", " wn = 10**(atleast_2d(pv)[:, 7])\n", " return lnlike_normal_v(self.fluxes, flux_m, wn)\n", "\n", " def lnposterior(self, pv):\n", " lnp = self.lnprior(pv) + self.lnlikelihood(pv)\n", " return where(isfinite(lnp), lnp, -inf)\n", "\n", " def __call__(self, pv):\n", " return self.lnposterior(pv)\n", "\n", " def optimize(self, niter=200, npop=50, population=None, label='Global optimisation', leave=False):\n", " if self.de is None:\n", " self.de = DiffEvol(self.lnposterior, clip(self.ps.bounds, -1, 1), npop, maximize=True, vectorize=True)\n", " if population is None:\n", " self.de._population[:, :] = self.create_pv_population(npop)\n", " else:\n", " self.de._population[:,:] = population\n", " for _ in tqdm(self.de(niter), total=niter, desc=label, leave=leave):\n", " pass\n", "\n", " def sample(self, niter=500, thin=5, label='MCMC sampling', reset=True, leave=True):\n", " if self.sampler is None:\n", " self.sampler = EnsembleSampler(self.de.n_pop, self.de.n_par, self.lnposterior, vectorize=True)\n", " pop0 = self.de.population\n", " else:\n", " pop0 = self.sampler.chain[:,-1,:].copy()\n", " if reset:\n", " self.sampler.reset()\n", " for _ in tqdm(self.sampler.sample(pop0, iterations=niter, thin=thin), total=niter, desc=label, leave=False):\n", " pass\n", "\n", " def posterior_samples(self, burn: int=0, thin: int=1):\n", " fc = self.sampler.chain[:, burn::thin, :].reshape([-1, self.de.n_par])\n", " return pd.DataFrame(fc, columns=self.ps.names)\n", "\n", " def plot_mcmc_chains(self, pid: int=0, alpha: float=0.1, thin: int=1, ax=None):\n", " fig, ax = (None, ax) if ax is not None else subplots()\n", " ax.plot(self.sampler.chain[:, ::thin, pid].T, 'k', alpha=alpha)\n", " fig.tight_layout()\n", " return fig\n", "\n", " def plot_light_curve(self, model: str = 'de', figsize: tuple = (13, 4)):\n", " fig, ax = subplots(figsize=figsize, constrained_layout=True)\n", " cp = sb.color_palette()\n", "\n", " if model == 'de':\n", " pv = self.de.minimum_location\n", " err = 10**pv[7]\n", " elif model == 'mc':\n", " fc = array(self.posterior_samples())\n", " pv = permutation(fc)[:300]\n", " err = 10**median(pv[:, 7], 0)\n", "\n", " ax.errorbar(self.times, self.fluxes, err, fmt='.', c=cp[4], alpha=0.75)\n", "\n", " if model == 'de':\n", " ax.plot(self.times, self.flux_model(pv), c=cp[0])\n", " if model == 'mc':\n", " flux_pr = self.flux_model(fc[permutation(fc.shape[0])[:1000]])\n", " flux_pc = array(percentile(flux_pr, [50, 0.15,99.85, 2.5,97.5, 16,84], 0))\n", " [ax.fill_between(self.times, *flux_pc[i:i+2,:], alpha=0.2,facecolor=cp[0]) for i in range(1,6,2)]\n", " ax.plot(self.times, flux_pc[0], c=cp[0])\n", " setp(ax, xlim=self.times[[0,-1]], xlabel='Time', ylabel='Normalised flux')\n", " return fig, axs\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### Priors\n", "\n", "The priors are contained in a ``ParameterSet`` object from ``pytransit.param.parameter``. ``ParameterSet`` is a utility class containing a function for calculating the joint prior, etc. We're using only two basic priors: a normal prior ``NP``, for which $x \\sim N(\\mu,\\sigma)$, a uniform prior ``UP``, for which $x \\sim U(a,b)$.\n", "\n", "We could use an informative prior on the planet-star area ratio (squared radius ratio) that we base on the observed NIR transit depth (see below). This is justified since the limb darkening, which affects the observed transit depth, is sufficiently weak in NIR. We would either need to use significantly wider informative prior, or an uninformative one, if we didn't have NIR data.\n", "\n", "#### Model\n", "\n", "The model has two components: a multiplicative constant baseline, and a transit shape modelled using the quadratic Mandel & Agol transit model implemented in ``PyTransit``. The sampling parameterisation is different than the parameterisation used by the transit model, so we need to map the parameters from the sampling space to the model space. Also, we're keeping things simple and assuming a circular orbit. Eccentric orbits will be considered in later tutorials. \n", "\n", "#### Limb darkening\n", "\n", "The **limb darkening** uses the parameterisation by [Kipping (2013, MNRAS, 435(3), 2152–2160)](http://mnras.oxfordjournals.org/content/435/3/2152), where the quadratic limb darkening coefficients $u$ and $v$ are mapped from sampling parameters $q_1$ and $q_2$ as\n", "\n", "$$\n", "u = 2\\sqrt{q_1}q_2,\n", "$$\n", "\n", "$$\n", "v = \\sqrt{q_1}(1-2q_2).\n", "$$\n", "\n", "This parameterisation allows us to use uniform priors from 0 to 1 to cover the whole physically sensible $(u,v)$-space.\n", "\n", "#### Log likelihood\n", "\n", "The *log likelihood* calculation is carried out by the ``ll_normal_es`` function that evaluates the normal log likelihood given a single error value.\n", "\n", "### Read in the data\n", "\n", "First we need to read in the (mock) observation data stored in ``obs_data.fits``. The data corresponds to a single transit observed simultaneously in eight passbands (filters). The photometry is saved in extension 1 as a binary table, and we want to read the mid-exposure times and flux values corresponding to different passbands. The time is stored in the ``time`` column, and fluxes are stored in the ``f_wn_*`` columns, where ``*`` is the filter name." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Filter names: u, g, r, i, z, J2, H2, Ks\n" ] } ], "source": [ "dfile = Path('data').joinpath('obs_data.fits')\n", "data = pf.getdata(dfile, ext=1)\n", "\n", "flux_keys = [n for n in data.names if 'f_wn' in n]\n", "filter_names = [k.split('_')[-1] for k in flux_keys]\n", "\n", "time = data['time'].astype('d')\n", "fluxes = [data[k].astype('d') for k in flux_keys]\n", "\n", "print ('Filter names: ' + ', '.join(filter_names))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "First, let's have a quick look at our data, and plot the blue- and redmost passbands. " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " fig, axs = subplots(1,2, figsize=(13,5), sharey=True)\n", " axs[0].plot(time,fluxes[0], drawstyle='steps-mid', c=cp[0])\n", " axs[1].plot(time,fluxes[-1], drawstyle='steps-mid', c=cp[2])\n", " setp(axs, xlim=time[[0,-1]])\n", " fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we see what we'd expect to see. The stronger limb darkening in blue makes the bluemost transit round, while we can spot the end of ingress and the beginning of egress directly by eye from the redmost light curve. Also, the transit is deeper in *u'* than in *Ks*, which tells that the impact parameter *b* is smallish (the transit would be deeper in red than in blue for large *b*).\n", "\n", "## Parameter estimation\n", "\n", "First, we create an instance of the log posterior function with the redmost light curve data.\n", "\n", "Next, we run the *DE* optimiser for ``de_iter`` iterations to clump the parameter vector population close to the global posterior maximum, use the *DE* population to initialise the *emcee* sampler, and run the sampler for ``mc_iter`` iterations to obtain a posterior sample." ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [], "source": [ "npop, de_iter, mc_reps, mc_iter, thin = 100, 200, 3, 500, 10\n", "lpf = LPFunction('Ks', time, fluxes[-1])" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(IntProgress(value=0, description='Global optimisation', max=200, style=ProgressStyle(descriptio…" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\r" ] } ], "source": [ "lpf.optimize(de_iter, npop)" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "lpf.plot_light_curve();" ] }, { "cell_type": "code", "execution_count": 59, "metadata": { "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "", "version_major": 2, "version_minor": 0 }, "text/plain": [ "HBox(children=(IntProgress(value=0, description='MCMC sampling', max=500, style=ProgressStyle(description_widt…" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "\r" ] } ], "source": [ "for i in range(mc_reps):\n", " lpf.sample(mc_iter, thin=thin, reset=True, label='MCMC sampling')" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "lpf.plot_light_curve('mc');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Analysis: overview\n", "\n", "The MCMC chains are now stored in ``lpf.sampler.chain``. Let's first have a look into how the chain populations evolved to see if we have any problems with our setup, whether we have converged to sample the true posterior distribution, and, if so, what was the burn-in time." ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " fig, axs = subplots(2,4, figsize=(13,5), sharex=True)\n", " ls, lc = ['-','--','--'], ['k', '0.5', '0.5']\n", " percs = [percentile(lpf.sampler.chain[:,:,i], [50,16,84], 0) for i in range(8)]\n", " [axs.flat[i].plot(lpf.sampler.chain[:,:,i].T, 'k', alpha=0.01) for i in range(8)]\n", " [[axs.flat[i].plot(percs[i][j], c=lc[j], ls=ls[j]) for j in range(3)] for i in range(8)]\n", " setp(axs, yticks=[], xlim=[0,mc_iter//10])\n", " fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ok, everything looks good. The 16th, 50th and 84th percentiles of the parameter vector population are stable and don't show any significant long-term trends. Now we can flatten the individual chains into one long chain ``fc`` and calculate the median parameter vector." ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [], "source": [ "fc = lpf.sampler.chain.reshape([-1,lpf.sampler.chain.shape[-1]])\n", "mp = median(fc, 0)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's also plot the model and the data to see if this all makes sense. To do this, we calculate the conditional distribution of flux using the posterior samples (here, we're using a random subset of samples, although this isn't really necessary), and plot the distribution median and it's median-centred 68%, 95%, and 99.7% central posterior intervals (corresponding approximately to 1, 2, and 3$\\sigma$ intervals if the distribution is normal). " ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [], "source": [ "flux_pr = lpf.flux_model(fc[permutation(fc.shape[0])[:1000]])\n", "flux_pc = array(percentile(flux_pr, [50, 0.15,99.85, 2.5,97.5, 16,84], 0))" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " zx1,zx2,zy1,zy2 = 0.958,0.98, 0.9892, 0.992\n", " fig, ax = subplots(1,1, figsize=(13,4))\n", " cp = sb.color_palette()\n", " ax.errorbar(lpf.times, lpf.fluxes, 10**mp[7], fmt='.', c=cp[4], alpha=0.75)\n", " [ax.fill_between(lpf.times,*flux_pc[i:i+2,:],alpha=0.2,facecolor=cp[0]) for i in range(1,6,2)]\n", " ax.plot(lpf.times, flux_pc[0], c=cp[0])\n", " setp(ax, xlim=lpf.times[[0,-1]], xlabel='Time', ylabel='Normalised flux')\n", " fig.tight_layout()\n", " \n", " az = fig.add_axes([0.075,0.18,0.20,0.46])\n", " ax.add_patch(Rectangle((zx1,zy1),zx2-zx1,zy2-zy1,fill=False,edgecolor='k',lw=1,ls='dashed'))\n", " [az.fill_between(lpf.times,*flux_pc[i:i+2,:],alpha=0.2,facecolor=cp[0]) for i in range(1,6,2)]\n", " setp(az, xlim=(zx1,zx2), ylim=(zy1,zy2), yticks=[], xticks=[])\n", " az.plot(lpf.times, flux_pc[0], c=cp[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We could (should) also plot the residuals, but I've left them out from the plot for clarity. The plot looks fine, and we can continue to have a look at the parameter estimates." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Analysis" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We start the analysis by making a Pandas data frame ``df``, using the ``df.describe`` to gen an overview of the estimates, and plotting the posteriors for the most interesting parameters as violin plots." ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
tcprrhobq1q2logekuv
count1.5000e+041.5000e+0415000.000015000.000015000.00001.5000e+0415000.000015000.00001.5000e+0415000.0000
mean-1.2699e-041.0000e+000.64200.50330.06623.5299e-01-3.14910.10051.4491e-010.0995
std1.4644e-041.0025e-050.05440.05130.04312.6672e-010.01780.00079.2026e-020.1428
min-7.3853e-049.9996e-010.47540.21210.00051.5027e-06-3.22040.09759.4794e-07-0.2310
25%-2.2826e-049.9999e-010.60300.47240.03411.2556e-01-3.16160.10016.7525e-02-0.0143
50%-1.2753e-041.0000e+000.63890.50810.05552.9634e-01-3.14920.10061.3617e-010.0935
75%-2.8113e-051.0000e+000.67700.53980.08865.3754e-01-3.13690.10102.1132e-010.2069
max4.2591e-041.0000e+000.87500.64600.32449.9980e-01-3.08270.10264.7495e-010.5487
\n", "
" ], "text/plain": [ " tc pr rho b q1 q2 \\\n", "count 1.5000e+04 1.5000e+04 15000.0000 15000.0000 15000.0000 1.5000e+04 \n", "mean -1.2699e-04 1.0000e+00 0.6420 0.5033 0.0662 3.5299e-01 \n", "std 1.4644e-04 1.0025e-05 0.0544 0.0513 0.0431 2.6672e-01 \n", "min -7.3853e-04 9.9996e-01 0.4754 0.2121 0.0005 1.5027e-06 \n", "25% -2.2826e-04 9.9999e-01 0.6030 0.4724 0.0341 1.2556e-01 \n", "50% -1.2753e-04 1.0000e+00 0.6389 0.5081 0.0555 2.9634e-01 \n", "75% -2.8113e-05 1.0000e+00 0.6770 0.5398 0.0886 5.3754e-01 \n", "max 4.2591e-04 1.0000e+00 0.8750 0.6460 0.3244 9.9980e-01 \n", "\n", " loge k u v \n", "count 15000.0000 15000.0000 1.5000e+04 15000.0000 \n", "mean -3.1491 0.1005 1.4491e-01 0.0995 \n", "std 0.0178 0.0007 9.2026e-02 0.1428 \n", "min -3.2204 0.0975 9.4794e-07 -0.2310 \n", "25% -3.1616 0.1001 6.7525e-02 -0.0143 \n", "50% -3.1492 0.1006 1.3617e-01 0.0935 \n", "75% -3.1369 0.1010 2.1132e-01 0.2069 \n", "max -3.0827 0.1026 4.7495e-01 0.5487 " ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pd.set_option('display.precision',4)\n", "df = pd.DataFrame(data=fc.copy(), columns=lpf.ps.names)\n", "df['k'] = sqrt(df.k2)\n", "df['u'] = 2*sqrt(df.q1)*df.q2\n", "df['v'] = sqrt(df.q1)*(1-2*df.q2)\n", "df = df.drop('k2', axis=1)\n", "df.describe()" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " fig, axs = subplots(2,3, figsize=(13,5))\n", " pars = 'tc rho b k u v'.split()\n", " [sb.violinplot(y=df[p], inner='quartile', ax=axs.flat[i]) for i,p in enumerate(pars)]\n", " [axs.flat[i].text(0.05,0.9, p, transform=axs.flat[i].transAxes) for i,p in enumerate(pars)]\n", " setp(axs, xticks=[], ylabel='')\n", " fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "While we're at it, let's plot some correlation plots. The limb darkening coefficients are correlated, and we'd also expect to see a correlation between the impact parameter and radius ratio." ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzAAAAMwCAYAAAD/CIUbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzde5TcdZ3n/+enqrpuXVV9q+pL0qE6CSEEYRUJCoLDMgjLiCgq90HHIbsoAoPszg+YBUdwlWHVIw4gKJdlAAUGj4wDAsIwCwrMIARGFoEgJOnOrdNdfa2uW1dX1+f3R+f7tbrT3emEJJ1KXo9zvid01+1TZTynXnl/3u+PsdYiIiIiIiJSDTzzvQAREREREZG5UoAREREREZGqoQAjIiIiIiJVQwFGRERERESqhgKMiIiIiIhUDQUYERERERGpGr75XsDeFo/HbUdHx3wvQ6rUq6++2metTcz3OkREREQOVAdcgOno6GD16tXzvQypUsaYrvleg4iIiMiBTFvIRERERESkaijAiIiIiIhI1VCAERERERGRqqEAIyIiIiIiVUMBRkREREREqoYCjIiIiIiIVA0FGBERERERqRoKMCIiIiIiUjUUYEREREREpGoowIiIiIiISNVQgBERERERkaqhACN7RUdHB8aYaa+Ojo75Xp6IiIiIVAnffC9ADgxdXV1Ya6e9zRizl1cjIiIiItVKFRjZbWarsiSTyflenoiIiIjsB1SBkd1mtiqLiIiIiMjuoAqMiIiIiIhUDQUYERERERGpGgowIiIiIiJSNRRgRERERESkaijAiIiIiIhI1VCAERERERGRqqEAIyIiIiIiVUMBRnaKDqsUERERkfmkgyxlp+iwShERERGZT6rAiIiIiIhI1VCAERERERGRqnFABBhjzEXGmNXGmNWpVGq+lyMiIiIiIrvogAgw1to7rLUrrbUrE4nEfC9HRERERER20QERYEREREREZP+gACMiIiIiIlVDAUZERERERKqGAoyIiIiIiFQNBRgREREREakaCjAiIiIiIlI1FGBERERERKRqKMCIiIiIiEjVUIAREREREZGqoQAjIiIiIiJVQwFGRERERESqhgKMiIiIiIhUDQUYERERERGpGgowIiIiIiJSNRRgZJKOjg6MMTNeyWRyvpcoIiIiIgcw33wvQPYtXV1dWGvnexkiIiIiItNSBUbmXTKZnLHi09HRMd/LExEREZF9iCowMu86OztnvM0Ys/cWIiIiIiL7PFVgRERERESkaijAiIiIiIhI1VCAERERERGRqqEAIyIiIiIiVUMBRkREREREqoYCjIiIiIiIVA0FGBERERERqRoKMCIiIiIiUjUUYEREREREpGocEAHGGHORMWa1MWZ1KpWa7+WIiIiIiMguOiACjLX2DmvtSmvtykQiMd/LERERERGRXXRABBgREREREdk/KMCIiIiIiEjVUIAREREREZGqoQAjIiIiIiJVQwFGRERERESqhgKMiIiIiIhUDQUYERERERGpGgowIiIiIiJSNRRgDkAdHR0YY6a9ksnkfC9PRERERGRGvvlegOx9XV1dWGvnexkiIiIiIjtNFRgREREREakaCjAiIiIiIlI1FGBERERERKRqKMCIiIiIiEjVUIAREREREZGqoQAjIiIiIiJVQwFGRERERESqhgKMiIiIiIhUDQUYERERERGpGgowIiIiIiJSNRRgRERERESkaijAiIiIiIhI1VCAERERERGRqqEAI/u0ZDKJMWbGq6OjY76XKCIiIiJ7kW++FyAym87OzllvN8bsnYWIiIiIyD5BFRgREREREakaCjAiIiIiIlI1DogAY4y5yBiz2hizOpVKzfdyRERERERkFx0QAcZae4e1dqW1dmUikZjv5YiIiIiIyC46IAKMiIiIiIjsHxRgRERERESkaijAiIiIiIhI1VCAERERERGRqqEAs5/q6OiY8fT6ZDI538sTEREREdklvvlegOwZXV1dWGvnexkiIiIiIruVKjAiIiIiIlI1FGBERERERKRqKMCIiIiIiEjVUIAREREREZGqoQAjIiIiIiJVQwFGRERERESqhgKMiIiIiIhUDQUYERERERGpGgowIiIiIiJSNRRgRERERESkaijAiIiIiIhI1VCAERERERGRqqEAIyIiIiIiVUMBRkREREREqoYCjIiIiIiIVA0FGBERERERqRoKMCIiIiIiUjUUYEREREREpGoowIiIiIiISNVQgKliHR0dGGOmvZLJ5HwvT0RERERkt/PN9wJk13V1dWGtne9liIiIiIjsNQdEBcYYc5ExZrUxZnUqlZrv5YiIiIiIyC46IAKMtfYOa+1Ka+3KRCIx38uR3SiZTM64ja6jo2O+lyciIiIiu5m2kElV6+zsnPE2Y8zeW4iIiIiI7BUHRAVGRERERET2DwowIiIiIiJSNRRgRERERESkaijAiIiIiIhI1VCAERERERGRqqEAIyIiIiIiVUMBRkREREREqoYCjIiIiIiIVA0FGBERERERqRoKMCIiIiIiUjUUYPZxHR0dGGOmvZLJ5HwvT0RERERkr/LN9wJkdl1dXVhr53sZIiIiIiL7BFVgRERERESkaijAiIiIiIhI1VCAERERERGRqqEAIyIiIiIiVUMBRkREREREqoYCjOy3ksnkjCOoOzo65nt5IiIiIrILNEZZ9ludnZ0z3maM2XsLEREREZHdRhWYeTbbQZU6rFJEREREZDJVYOaZDqoUEREREZk7VWBERERERKRqKMCIiIiIiEjVUIDZC2brc1GPy/zQhDIRERGR6qQemN2ko6ODrq6uaW9LJpPqc9nHaEKZiIiISHVSBWaKHU0Fm+kCsNZOe832ZVn2PbNVZ0RERERkfpkDoTJgjLkIuGjbj8uBd4A40Ddvi5o7rXP32R1rTFprE7tjMSIiIiKy8w6IADMdY8xqa+3K+V7Hjmidu081rFFEREREZqctZCIiIiIiUjUUYEREREREpGocyAHmjvlewBxpnbtPNaxRRERERGZxwPbAiIiIiIhI9TmQKzAiIiIiIlJlDriDLOPxuH0/J62Xy2XGx8fxer14PMp/B5pXX321b7Yxyu/375cc2Hb090tEREQOwADT0dHB6tWrd/nx5XKZXC5HOBye1wCzo61/OnRxzzDGdM12+/v9+yUHth39/RIREZEDMMC8Xx6Ph0gkMt/LEBERERE5IGkPlIiIiIiIVA0FmP2QtZZMJkO5XJ7zY8rl8k4/RkRERERkb1OA2U32pQCQy+VIp9Pkcrk9+hgRERERkb1NPTC7iRMAgHnrkbHWksvlCAaDAITD4Tk/1rnvzjxGRERERGRvU4DZTSoDwHQTwnZlKth0z+OElHA4vN1zVoao2traGZ9juvVoOIGIiIiIVAMFmN3EGOOGhj1ptkrPjqoos4UfEREREZFqoABTZSpDytQzaSqrKNNVXpzwUy6X8Xg8836WjYiIiIjIztK3132ctZZsNusGEqfSY4yZsfG+XC5PeowjHA4Ti8UA1LAvIiIiIlVJFZg9aHds2Zqur8Ux05axmR7jhB9rrVuBERERERGpJgowe4ATXJzRyrDrk8lm62uZqfF+R70wxpj31bA/deuaiIiIiMjeom+fe0BlBSQWi+1ypWNXKzgej8fdZrYn6MyY/V9HRwfGmGmvjo6O+V6eiIiIHMBUgdkDKisgToiYaZzxVJWhZbbtYwDj4+Pk83lCodBeqYQ472GmkdGabLb/6OrqmvMIbhEREZG9SRWYPaCy0R62b8SfTWV1w2m6d4JQ5QWQzWbp7u4mm83u0fcz1dT3JweWZDKp6oyIiIjMGwWYneD0tJTL5Z163HRbrmYKNcFgEI/HQzAYdHtVpquuOGsplUqT1lQulxkZGWFkZGTSc+9MiBKZTWdnJ9baaa+urq75Xp6IiIjs5xRgZjE1sOxq70dlJcUx03MVCgXK5TKFQmHGdQDk83nK5TJ+v59yuUw+n3d/39PTQ09Pz6TnVt+KiIiIiOwP1AMzi6mn3u9outdMjDFuT4uzHWym55ru91PXARAKhYCJik2hUHB/DoVCtLS0bPccu7p2EREREZF9iQLMLKZ+6Z9pbDHseGLY1IZ8p49kqul+P134cCaNTd3O5vF4iEajc3re3WF3nHUjIiIiIjJX2kI2CyewzGXCVyaTobu72z33ZarptpG933WUy2VSqRRDQ0PuFrJKe6PvZUfvW0RERERkd1IFZi+ZqQJirZ2xcuEED6fHpXJcsvO7UqmEz+cjGAxuN9J4pjHMswWa2dYjIiIiIjLfFGB2E6dC4lRYrLVuVSISicw5FFRuyYI/VllKpRLlctmdUFYoFAgGg9TX12/XB+OEnUAggMfjIRAI7IF3jPveKt/3gcgYcxFwEcBBBx00z6sRERER2b8pwOyCcrnshgynIjK1wpLL5ejp6QH+2K8yk2w26/aQVFZNwuHwpCoLQDqdnjSRrLa2lmw26z7GuY+zxlKpRD6fx+PxTAo4laHn/RyCuad6a6qJtfYO4A6AlStXak61iIiIyB6kALMLppsKNlU4HJ40DWymZvep27ymNuxXThtzHu+MWfb7/WSzWfx+/6SzYyrPiPH5fNuNYJ4uBDlmWuf4+Dh9fX3E43G8Xu/7+wBln9DR0THjuS3JZHIvr0ZERERkbhRgdsFcRhI7h1A6567kcjmGhobIZDI0Nze74WDqc1WOXHaqI06VxdmS1tvb697mVFjK5TLhcJhoNIrH43HPiAkGg/T09BCNRgmFQu42tMbGRorFohuQHPl8flIFyAkzfX19bNmyBcANZlLdurq6dLCpiIiIVJ2qCjDGmE8BHwOiwPXAsLV2bG+vY7ZxypWmbgdzqiK5XG5S1aO2ttadGOaEhqnN907QKJVKhEIhotEo8Xicvr4+SqUSo6Oj7vNVngkzPDzMwMAATU1NbtAplUoMDAyQSCS22z7mPHbqOuLx+KQ/RURERETmQ9UEGGPMUcCPgK8CZwC3Ag8ZY5611g7v4LHz0mRdWV0xxtDc3DypQb/S1LADTKqOVJ774kwd83q9JBIJ9/7O7dls1v0zl8tRLpfp7+/H4/G4oWV4eJhgMOgGGCco5fP5SQMEnAM8jTGTKi86/0VERERE5kPVBBhgOfC0tfZR4FFjzJeB04BxY8yTwLidYT/M1Cbr2bbN7OqX8emec2pYqRyL7GwtcwYBVFZNnN9ba7d7XmeLWblcdkceRyKRSWOV169fT6FQoKmpiebmZpYuXYrP53O3gDlb25wLoLW1FWDSMIBMJkMsFpu0dufzmbolbkcUckRERERkd6imgyxfAhYYYz4GYK39MfAa8AWgdtZUshcYYyZdTkXFCQjwx/6S3t5e1q1bR3d3N4VCAWPMpElluVzODSeV1/j4OL29vYyNjVEoFCbdp1AoTHo9n8/nPmcikaBYLOL3+8nlcgSDQVpbW0kkEjQ3N9Pc3EwoFCIUChGLxQgGg271JRQKYYxxKy7OxxwOh/H5fBSLRXp7e9VLISIiIiJ7xT5dgdkWVhYAaWvt08aYV4HjjTED1to11trbjTHHAf8fcO28LnaKyu1jzpf/YDAITO5jCQQCZLNZtyk/m83S09NDU1MTxWKRpqYmd4Ryf38/3d3d7v1h+x6ZQCBAJBJxw0w2m6VQKFAqlfD7/ZTLZYrFovu4aDQ66aBMp/clk8kQiUTc7WjOVjTnNZ0tcb29ve4gganjlCufV5PLRERERGR32GcrMMaYU4B/AD4A/MwY8yHgYeBg4AxjzAnb7voykJv2SeaJUylxxho7lZdCoUBtbS3RaJSFCxfS0tJCPp93Q4kz/tjpWdm0aRNr1qyhVCoB0NTURFtbG+3t7cRiMQKBACMjI4yMjAATwcLn8xGNRonFYng8HnK5HIVCgeHhYVpaWvB4PBQKBTZv3szw8LDbK7N161ay2SyAW4kB6OnpobOzk5GREXw+36QtcU6Iqa+vn9Sv4zyncz5NPp/fWx+9zLNkMrld5bDy6ujomO8lioiISJXbJyswxpgE8E3ga9baJ4wxOaABeAO4DvhvwHXGmB4mppKdNl9rrTzU0unzmDpyeGp/y0wHWzpTwurq6mhsbOSdd96hUCiQSqWIxWKEQiG3kb6mpmbSYZmVDfbO6zhbwzZu3EixWHSDUiaTob+/n8bGRpYsWUIwGGRkZIRgMEgoFGJ0dNR9jpaWFnf0slN5qWSMIRgMkkql3DNinMDm9Pc4lSfZ/3V2ds56u3qhRERE5P3aJwMMMAS8AhSNMYcDfwM8AZwEXGmtvd4Yczdw5LafN+zsC+yugxmnG3nsjBpubGx0t3vNdFp9OBymra1tUgXD2U62fPlyBgYG8Pv9bN68mWg06gaVfD6P3+93z3ZJp9Nks1k8Ho+7LSwSiZDP54nFYpTLZerr6ykWiwDU1dUBuKOdBwcHCQQC+Hy+SVvFKreYTcdaS1dXF4ODgwAkEgn3tQH30M25jJ0WEREREdmRfTLAWGvHjDEZ4DzgWODvt4WWo4GnjDGd1trngU07+9zO9K7ddTDjdIdaer1eWlpaGBkZoaenh5aWFqLR6KQ1OL0hU6sxoVDIvc3n85FIJOjp6XGb/8vlMrFYjEwm4/bMDAwMUF9fT11dndt4Pzo66k4ky+fzxONx/H4/fr8fay1tbW3E43EKhQLFYpHx8XF8Ph9NTU2TKjAw+XBL58wap+qUy+WoqamhoaGBeDzu3tfn87lBrlwuu1WcyorV1DNoRERERER2ZJ/7BmmM8QBYa/8GuBi4HXh+2+9eAX4C7HLJZHx8nFwuRzweZ8GCBTMezFjZjzIb51DL2bbGVJ7NAn8MBNNVNfL5PENDQ6RSKTfolMtld4JYV1eXG2KampqIRqNueInH4+4UMicUZbNZisWiGyKcBv+amhp3OIATNpxtcLW1tZPChdMT44QaZ4Ryb2+vG4qSySRer9cNXqVSiUKhgMfjIZPJuOuabjqbiIiIiMhc7RMVGGPMcqARWA2Ut/3OWGuLZiIZrDLGbAI+DnwCuGlXX8vr9br/+u+cfTKdyq1hkUjEHRO8M1vPamtraWpqorOzk/r6euLxOLW1tdNWbRyhUMjd1lUoFAgEAng8HhYuXOhuF/N4PO50M+c5EokE/f39bNmyhVwuR3t7O5lMhrGxMTZv3uyOPU6n0/T19fHuu+9SU1PjHn7pbBXL5XLbbfdy+lycyknlGgcGBiiVSvT19dHc3IzH43EP7HQe4xyGWble5+fK11B1RkRERER2ZN4DjDHmc8ANwOZt12pjzD9Ya9MA1tqbjTEPMNEHsww401q7fldfz+PxzOnLcTAYJJPJbNeAvrNbzzZt2sSWLVvweDwcdNBBAG6VA7Y/ANPj8ZBIJMjn8wSDQQqFgjvRywkGTjUlm83S2dnpVnYaGhpIpVIA/OEPfwCgu7ubTCbD+Pg4iUQCj8dDIBCgXC7T19fnVkgymYwbLsbHx93DLp3ABBPVHGe9lZ9LLpejVCqRy+XcRv/a2lp3YEAsFpt0lkzlwINKU0OjiIiIiMhU8xpgjDE1wDnAKmvti8aYzwPHAFcaY75rrR0GsNaev21rWa21dmRvrK1QKEzbgO5sOYvH4zv8Qu400Le3t3PIIYdMuq/zWOegyEpOX4y11p08ViqVSKVSjI+Pk8lkKBQKbojI5XJs3bqVXC5HXV0dQ0NDDA8PE41GOeKII8jlchxxxBH4/X4GBweJx+PugZWV28IGBwfZvHkzhUKBjo4OhoeHCQQC1NTU0N7e7o5g/v3vf09zc7N74GVzc/N2I5Zh+/6g6QYezHZ/EREREZGp5r0CA8SYqKy8CPwT0MfEWOTzgB8ZYz4KjFprfwfslfACM3+Zdhr0AfecE5j+C3koFCIej7No0SL3gMqWlhYikYh7AORMj63kBId0Ou0OAxgeHsbv9xOPx/H5fHR3d+Pz+dytWxs2bHDPfVm6dCljY2MMDQ25W76KxaIbzAKBAPF4nGAwyLvvvsvGjRsZGxvD6/WycOFCfD4fmzZtIhaLsXXrVoaHhwkGg4yOjgIT1ZKWlpZpRyxXvrcdBRSnn0hEREREZCbzGmC2TRv7PnCZMWattfZ5Y8wLwELgU8aYe5k45+XBvb22uXyZnvqFvHK6GOD+99Qv9s6WK5/P5/a1VE4lKxaLbNq0iYULF1IqlRgaGgKgra2NcDhMb28vo6OjFAoFN9hUPu+GDRsYHh7mjTfeYHh4mMMPPxy/308wGKS5uZloNMr4+Djlcpk1a9ZQLpdpamrC5/OxbNkyd2iA1+ulvb2ddevWUSgUsNYSiURYsmQJCxcuZGBgwJ0sls/ndxjERERERETer32hAvM8sBz4wrbG/d8ADxhjLgIWWGt3uWF/T5taYagcNwy4/x0Oh4lEIm7zvcNpZO/u7narM21tbWzYsIE333yTbDbLihUr3KleTqByxh83NDRQKpWor693m/yHhoY4+OCDSafTrF+/nrfffptiscjixYtJJpM0NzczNjbG+vXrGR8fZ2hoiEwmQ11dHQMDA3i9XhoaGsjlcjQ2NrJu3TpyuRzGGPf3wWCQaDSK3+93e2QCgQDZbHbG7XTwxy1klYMIdLChiIiIiOyMeQ8w1tqCMeangAX+xhhzKDAKJIDMvC5uJzmVl6mHUlpryefzk76wO8Enl8vR09PD2rVrgYntWM7Y48HBQUZGRtzQUyqV2LhxIw0NDe6BlENDQ6TTacbHx90zYQA6OjpYsGAB4+PjDAwM0NfXRyaToaGhgZ6eHt5++22WLFmCz+ejUCjQ3d1NIBCgr68Pay3WWkZGRujq6mLp0qUcfvjh1NbWsmHDBrZu3eqGMmf6WD6fn/bMG8Dt93F6dpyDNys/BxERERGRuZj3AANgrR00xtwJvAV8GSgAF1hre+ZjPbsyznfqNDFjzLTN65UHVRpjCAQCbv9Ic3Mz6XSadevW4fP5KJfLbNy4kWAw6E716uvrc89zGRsbIxAIkEgkCAaDDAwMsH79ejKZidwXCARYvHgx8XicDRs2kMvlWLNmDX6/n3w+z5YtW3juueeora2ltbWVwcFBtzHfGMPQ0BA1NTVEo1FCoRDZbBa/3++ORXY+p2KxyPDwsNvTAxNhq7+/3z0YszKwOBUYJ+g5W9A0PllEREREdmSfCDAA1toi8Kwx5jcTP9rZT5Dcg6Yb57ujiWPGmBmnbDmVBye8VN7HGEMsFnO3mA0MDGCtZcmSJQQCAYaHh8lkMm5wAdyzYTZt2kQ+n+fQQw8lEomQSqWw1uLz+chkMrz99ttkMhlaW1tZsGAB6XQav9/P73//e/7xH/+RF154wW3Ef+eddzjuuONYvnw5S5YsYXh42A0gPp+PjRs3up9Da2sr0WjU3TI2MDBAKpWiubnZDTrpdJqenon8mUgk3PfvhJVAIOAGucrPRE38IiIiIjKbfSbAOKy14/O9hummZe1oBDD88Qt6qVRiZGTEPdHeqTY4X9wrT7UvFApkMhm3Gd7n87Fo0SJisRgwMUygqanJPZOlpaWFpqYmstksY2NjjI6O4vV66e/vJxAI0N7eTjKZZGxsjPr6enp7exkbG6Ouro4NGzbw2GOP8ctf/pJAIMAFF1zAl7/8ZR577DG+853v8NRTT3HhhRdy6aWXkkgkGB0dZenSpWzatIlMJoMxhqVLl9LQ0OCOeo7H42zdupVQKOQ+Jp1OEw6HaWlpcSs6zrk1wKT363xuUz9vEREREZHp7HMBZl8w3QQy58t1MBicsVndCStO5aGtrc0NO06VwQkvIyMjbqN8LBYjEAgwOjpKTU0NhUKBnp4eSqXSpGDgBIHh4WHGxsYYGxujUCiwceNGenp6aG5uprGxkf7+fvr6+ojH43g8Hh5//HFefPFF/uM//oOmpiauvvpqLr74YpqbmwE44ogjOOecc7jiiiv4+7//ex5//HE+9rGPceSRR1IqlbDWUigU8Pl8JBIJGhoa3IMvC4UCIyMj7mfk9XqBiVDi8/lIp9OT7tPS0jLp/TqT13a28rIr2/xEREREpPopwMyRM3FsZGRkUrN65YGUTqXFOSdmajO/82c+n6erq8v9cp9MJt375fN5hoeHGRwcpLGxkXA4zMjICENDQ7S3tzMwMEA6nSYej9PU1ATA6Oio28wfi8V46aWXWL16NevWreO9994D4D/9p//ELbfcwhe+8AW8Xi8+3+T/6ZcuXco///M/88gjj3DnnXdy//33c99993HMMcdw7LHHcvbZZ9PU1MTChQvJ5XIMDw+TzWZpaGgglUpRLBYZGBigpaXFDW3Oew4EAgSDQTKZDOVy2a1MTV3Dzphum5+IiIiI7P8UYN6nHW0tq9w65dxeKpVoaGggGAzi8/nI5/MA7ojh0dFRGhoaaGhoYGxsjLVr1zI+Pk4+n2dsbIzBwUE8Hg/j4+MkEglqa2u58847Wbt2Lb/97W8ZHx+ntraWE044ga9+9aucdNJJHHrooW7FyOl7mcoYwxlnnME555zD5s2befjhh7nzzju56aabePDBB/nzP/9zrrjiClpbW8lmsxSLRQYHBzn44IPZuHEjxWLRbeTv7++nsbHRfe5CoUA2myWfz+Pz+d739LEdHYopIiIiIvsnM3V61v5u5cqVdvXq1Tv9OOdzmtrMXzkiuFAoUC6XJ20hA+ju7qZcLlNXV0cwGGT9+vWUSiVisZhbySmXy6RSKUqlEplMBr/f71ZcnOpKLpejr68Pn8+H3+8nm83S1dXFTTfdRE9PD0cddRQnn3wyJ598Mh/5yEfw+/3TvpfR0dEZqx/j4+MEAgH353K5zL/8y79w66238qtf/YqamhpOO+00vvSlL3HEEUewbt06kskk7733HsFgkOXLl5PNZunu7iYWixGPx91zbGBim10ikXCnrDnhzhlisK8zxrxqrV050+27+vdrPjh/f/f316wmO/r7JSIiIqrATGKtZXx83O0fcfo5nNuMMdsdXun87EzeikQi220hSyQSpFIptxfEWsvw8DCjo6PU1dURi8XcMOLz+QgEAgQCAd577z2am5tpaWmhsbGRd955h1gsRk9PD16vl5/+9Kf86le/4rDDDuPnP/85RxEAhTYAACAASURBVBxxhLuuQqFAoVCY9n1ms9kZt10NDw9vVx05+uijuffee3nnnXd46KGH+MlPfsIvfvELVq5cydFHH83xxx/vnl/z3nvvub06fr8fj8dDLBZjYGDAHe9cW1tLJBIhl8vR29sL4A4FmOl/F/W7iIiIiAgowGynr6+PLVu2ALhBBHDDS6XKRvLKLU3TVWYCgYB7bkttbS0dHR0UCgXq6+vJ5XJkMhm30b2pqYne3l73IMv6+nrWrVuHx+PBWsvbb7/Nz3/+c9577z0uu+wyvvGNb7ijmh2V4WuqmpqaGaszXq932jHRAEuWLOE73/kOX//613nggQe49dZbuf3223n22Wc55ZRTOOSQQ3jttddob2/nuOOOIxqN4vf7GRwcpLe3ly1btlBfX++Gp3A4PGnE8kzU7yIiIiIiDgWYKeLx+KQ/ZzO1/6W2thZrLdlsllKpRCqVcs9FiUajtLW1kc/n3YMcW1pa3Olk4XCYxYsX4/V6GR4eZunSpQwODlIul+nr62NgYIBgMMiLL77IrbfeSmtrK7/85S/5z//5P+/Jj2Na0WiUL3/5y6xatYpHHnmE733ve9x8880sXryYI444gkWLFhEKhejv7yefz1NXVwdAXV0d8XicXC5HLpcjEom4nxtMVIacYQiV1O8iIiIiIg4FmCm8Xu+kystsdnRejMPj8RAOh91RyF1dXQSDQRYuXOhWTpzpXDDRhxIMBmltbWVoaIimpiastfzP//k/efHFFzn33HO58cYb5xSy9iSfz8fZZ5/NmWeeyRNPPMH3v/99Hn30UV5++WWMMRx11FEEAgG8Xq+7BS8cDhOJRNxparlcDo/HgzHG/dycSW1OmNmVMct7kzHmIuAigIMOOmieVyMiIiKyf6u6hgJjzMx7o/Yy54t1ZcUgHA4Ti8Vobm6mra2N5uZmotEogPuFPRgMEo1G3S/otbW17n83NTW558d4vV56enooFouUy2X+7d/+jVWrVnHfffdRX18/X297Ox6Phz/7sz/j+eef56mnniIej3PZZZe5jf1jY2Nks1my2SwbNmwgl8vh9XoZGhqivr4ev9/vVqECgQCpVIqhoSF3Otu+zlp7h7V2pbV2pbMlbl/R0dHhbn+celWO7xYRERGpFlVVgTHG/BnwX4wxDcDfWGu3GGOM3YfGGlU2+TvN/aVSyQ0uuVzOPStlZGSETCbjhqByuczY2Jj7+J6eHgYHB93zYtrb22dszN/dxsfHeeONN4jFYixZsmROjzHGcOKJJ/KrX/2KE044ga985Stcf/31tLe34/V6qampcUNJJpNhaGiILVu2EA6H6evrA+CQQw6hVCrh8/lm7YuRuenq6tLULxEREdmvVE0FZlt4+R7wFDAO3GOM8c0lvBhjLjLGrDbGrE6lUnt6qZOEw2F3ZPDg4KA7jWx0dJSuri7WrFlDV1cXALFYbNKX9paWFvfn/v5+Ojo66Ozs3CPrtNby1ltvcc899/DFL36R5cuXc8opp3Dsscfyl3/5l7z++utzfq7m5mYeffRRjDHcdNNNeL1ekskkyWSSFStWkEgkWLhwIQsWLMDj8ZBOp8lmswwMDNDf3099fT2JREITx0RERERkO/t8BcZMjMSKARcC11hrnwSeNMY8Anwe+McdPYe19g7gDpg4p2NPrHO2HJVIJMjn89TU1DA4OEhTUxMej4dkMklTUxORSAS/309vby/5fJ5kMonP53P7X5ypZuFwmDfeeIPx8XEymcysJ9k7E82ms3XrVqLRKKOjozz99NO88MILvPLKKwwMDADQ3t7OiSeeyFFHHUVnZyc/+9nPePzxxzn66KO5/PLLOfroo7d7znK5zMKFC92fFy1axEMPPcSnPvUprrvuOr797W8Tj8eJx+PuhLXW1lbS6bR75k1PTw/t7e0EAgHK5bL7Hmpra2cMMzNNTBMRERGR/dM+H2CAhLW21xjzd8Bb26ouJWAz0Lo7X+j9fBme7rGV55c428JaWlrc38diMWKxGNZaOjs7efPNN8nn83g8HqLRKJlMhnQ6zdDQEMPDw9TV1dHd3U2pVCIYDM46Ktk5OHI6g4ODPPjggzz00EMMDAyQSCT42Mc+xkc+8hEOOuggjjzyyEn3X7VqFQ8//DD33XcfF1xwAStXruTiiy/mhBNOcN93qVTabj3HHnss99xzD+effz633XYbZ511FsYY8vk8uVwOmJhM5vP5KBaLBAIB8vm8O33NafBvbW2d8YwYqS7JZHLG/58lk8k9VmEUERGR/cc+HWCMMacCvzDGnGqtfW7KzW+zbQucMeZTQJe19o29vMRZTR2zPN3vw+GwW51ZtmwZAIFAgGKxSDQaJRKJYK2lt7eXjo4OrLV0dXXR2rrz2W3t2rXccccd/OxnP6NYLPLxj3+cL37xi3z0ox91v1Ru2rRpu8dFIhEuvPBCTj31VF566SXuuOMOVq1axYc//GHuvPPOWQcKfPrTn+a73/0uf/3Xf00+n+eb3/wmoVCIUCjE6OioO23M6YHJZrP09fXR2NhIW1sbkUhEvTD7kdkCiqppIiIiMhf7bIDZFl6+BfwT8BFjzPOAtdaWt93FB/iMMWcDNwCnzM9KZzZ1zHLl4ZaVvw+FQjQ2NrJw4ULy+TwDAwOMjY0Rj8cpFosEg0FqampoaGgAJr4E7kyA2bp1K1dffTXPPPMMgUCAU045hf/6X/8rS5cu3an3EwwG+eIXv8i5557LI488wvXXX8+XvvQlbrvtNpqbm2d83MUXX8zmzZu56aabaG9v58Ybb2R0dJR3332XYrGIz+fD5/MRjUYZGRkhGAxSW1vrVq7UCyMiIiIijn3ym6Ex5gTgRuBSJhr3Pw80WGvLFWOUh4D/DlwCfNpau25eFjsN5zBLmKi8OP+y7FReCoXCpN87o5Q9Hg+hUAi/309NTQ2bN2+mt7eX+vp6Ghsb3Wlezz333E6t58Ybb+T555/niiuu4Le//S1XXXXVToeXSn6/n3PPPZcf/vCHvPvuu5xyyin8+Mc/ZnR0dNY1nHfeedxzzz2cdNJJbNmyhWXLlrFw4UJqamqora11g0tbWxswMUHL+RxFRERERGAfDTBAB3CRtfYla+2rwFvA97f1v4xvu887wDBwsbX2rXla57ScoOL0eTicM2JmO1He4/GQSCTw+XxkMhlyuRx+v58FCxaQTCY57bTTuP/++xkbG5vTWlKpFL/4xS+44IIL+B//43/s1sMv//RP/5SnnnqK448/nu9///t89KMf5Zlnnpnxfd177708/PDD9PT0cM4557B+/XoARkdH6evrI5PJ4Pf7WbhwIT6fj0AgsNvWKiIiIiL7h30ywFhr77XWvmyMcba43QKMAQvAnUz2B+BP9rXwAjMHlcozYrLZ7HaTy8rlsltxiEQi1NbWkkgkSCQSNDc34/P5+JM/+RN6enpmDApTvfTSS5RKJT772c/uhne2vfb2dn70ox9x5513Ui6X+cxnPsP555/Pxo0bt7uvMYbPfvazPPbYY/T393PppZfy+uuvk81myWQy5PN5fD4fw8PDBINB6uvrCQQCbN68ma6uLjZv3sz4+Pg0qxARERGRA8U+2QPjHE65bdoYTDTsLwS+Cly97eyXwXlb4A5UBpXpVDbx+/1+BgYGaGhoYHBwkFKpRLk80eaTSCTcrWbhcJiamho++MEP0trayv33388nPvGJGV+jp6cHgF//+tcEg0Hi8bj7uw0bNrgjk6fq7Oxk8+bN096WzWanbfKHif6Yu+++mwceeIB7772Xp556imuuuYaTTjoJgOXLl7v3XbZsGf/wD//Aeeedx3e/+12uvfZayuUyHo8Hj8dDqVQiHA4TiUTo7+9nzZo1DA4OUl9fT7FYnDTJSo3fIiIiIgeWfaICY4xZbow51hhTY4zxWmvttioLxhiPtTYPXAZ8whjzkfld7fSMMTNeU1VWaAYGBuju7mbTpk3uCfSlUom1a9eSzWbxer3uNTIywvDwMCeccAL/+q//OmkU89Srvr6e+vp63njjDY488kgSiYT7u2g0SlNT07TX2NgYwWBw2mtwcNANGVOvkZERampq+Iu/+AseeOABDjnkEL7+9a9z++23UyqVtrv/SSedxG233caLL77IbbfdRiKRoL29nUKhQG9vL6Ojo3i9XhoaGjj00ENZuXIljY2NFAoFstnsjJ+tiIiIiOzf5j3AGGM+B/wzExPH7gYuMcbEtoUYz7bGfQ8wADwJrJ/H5e4WToXGGENTUxNtbW3uqfTBYJBcLkcqlWLjxo2MjIyQTqcZHh6mo6ODtrY2jj32WMbHx3nggQdmfZ1MJsPbb7/NypUr99I7m9Da2srNN9/MZz7zGe6//36uvvpqhoeHt7vfmWeeyQ033MBjjz3Gt771Ld59910AYrEYfr+fkZERtzLjNPqPjo6SyWTcKpWIiIiIHFjmtIXMGNPORB/K8UAZeAG43Fo7/X6iOTLG1ADnAKustS8aYz4PHANcaYz5rrV2GGDb6OR+Y8wN26oxVafyUMvKyoHX66WlpcXtA0mlUixatIjFixdTKpXc5vZUKkU0GuXQQw8lGAxy7LHHct9993HFFVfMWIn43e9+R7lc3uUAs3XrVtavX+9WgCorIz6fj8bGRpqamqZ9bE1NDVdeeSXLli3jpptu4uSTT+YnP/kJhxxyyKT7XXzxxXR3d3PLLbfg9Xq56qqrWLZsGX19fe60tp6eHnw+H+VymdbWVrdXyAmCGrMsIiIicuCYaw/MPcADwFnbfr5g2+9O3g1riAHLgBeZOPOlDzgNOA/4kTHmaGDcWvsaUNgNrzcvMpkMPT09tLS0EI1GJ91WKpVIp9Pu+TA+n48lS5aQSqXIZrPkcjlaW1spFovkcjk+8IEPcNppp3Httdfyhz/8YVJ/SSVnyteujEwul8t85zvfobe3d8b7eDweTj75ZD7/+c/PeJ/PfvazLF68mG984xuceOKJ3HDDDXzxi1+cFLq+8Y1vMDQ0xP333080GuXyyy8nGAzi9XoplUosWLCATZs20dPTQyAQcN/PyMgIxhgikchOvz8RERERqU5zDTAJa+09FT//gzHma+/3xa21Y8aY7wOXGWPWWmufN8a8wETD/qeMMfcyUfV5cNv97SxPV7X6+/vdcFNZYaivr2fDhg2k02nC4TBjY2NkMhnq6ur48Ic/DMB77703Y4Dp6OgAJhrznbNV5uqVV16ht7eXv/zLv2TZsmWMj4+7zzM+Pk6pVOK1117j6aef5sUXX+T000/n8MMPx+v1bvdcH/rQh/j1r3/NJZdcwte+9jWefvppfvjDH1JfXw9MbKm76667iEQi3H777WzYsIGrrrqKhoYGfD4fXq/XPczTCXuRSIRIJDLrSGoRERER2f/Mde9NnzHmAmOMd9t1AdC/m9bwPPA08AVjzJ9Ya8ettQ8wMTJ5gbX2Jmvt1t30WntUuVyesT8jEonQ1tY2bbUgFotRLBapr6/H4/GQSqXo6elhaGiIRCJBY2MjCxYsoLGxkUgkwvj4OHV1dQCsXbt2xvWsWLECgDVr1uzU+7DW8vjjj9PS0sKJJ57IQQcdxOLFi1m0aBErVqzg8MMP50Mf+hAXXngh3/72t2lvb+fBBx9k1apV/O53v5v2ORcsWMDPf/5zvvWtb/Ev//IvnHbaae5UNJjYSnfzzTdzzTXX8Nxzz/HDH/6QTCaDz+cjEolQKBTcPqFUKkVfXx/GGG0fExERETnAzPXb34XA2cBWoBs4c9vv3jdrbQH4KfA68DfGmIuMMX8BJIDM7niNvWWmAyxhcuP++Pg4PT097pkm3d3dpNNpNm/eTLlcJpFI0NLSQmNjI4FAwA02Ho+HcrlMb28vNTU1NDQ0sG7duhnXE4/HaWpq2ukAs2bNGtatW8cnP/nJHQaEZDLJtddey6pVq0in01xyySX87d/+7aRw4vB4PFxyySU8/PDDdHZ28slPfpINGzZM+oyuu+46LrvsMn75y19y5513AjA0NMTmzZvJZDK0tLSwaNEiYGIENcweHEVERERk/zKnLWTW2g3Ap/fUIqy1g8aYO4G3gC8z0etygbV2+2/B+zBnO9N0B1hW6uvrY8uWLQCTvpA3NDSQTqfx+XwkEgkAAoEAGzdupFwuMzg4SCAQIBKJ4PP5OPjgg1m7du2027ZqamoAOOyww1izZo37M0ycfO8cmDlVX18fjz76KJFIhBUrVtDX1+fe9pvf/Ia333572seNj4/zV3/1Vzz33HM8++yz/OY3v+H444/nxBNPJBQK0d3dPen+11xzDTfccAMnnngi1113Heeff75729e//nVSqRQPPfQQLS0tnHvuuYRCITweD4VCgXK5TCqVIhgMEovFJoWX2c7fqaQRzCIiIiLVaa5TyBLAfwM6Kh9jrd0tVZhtz1UEnjXG/GbiR1t1/5zu8Xjm1FAej8cn/VlTU8OSJUsol8sUi0VKpRLZbBZrLf39/ZRKJfx+P7W1tQSDQd577z0WLlxIU1PTjIHCsWLFCu699173jJkdSaVSvPXWW5x66qluhWOu/H4/p5xyCkcffTRPPvkkzz33HC+99BInnngiCxYsIBAIuPddvnw5119/Pd/61re49tprOeyww/jQhz4ETHyOP/jBD0in09x8880MDAxw6aWXUiqV2LJlC83NzYRCITKZDL29vYRCIRoaGgiFQju1XhERERGpPnPdQvbPQB3wDPB4xbXbbeuBqbrwMlflcplCoUBzc/N2gcLj8bgHTsJEmHC2lA0NDTE0NMSaNWt477332LJlC4sWLWLjxo2Mjo7O+HorVqxgdHR01q1mlV5++WVqamo4/vjjd/k9NjQ0cP755/O1r32NZDLJE088wWWXXcYzzzzjbpuDiSED/+t//S8CgQBnnHEG//Zv/+be5vP5uOOOO/j4xz/Ogw8+yP/9v/+XbDbLyMgIwWCQ5uZmyuUy+XyeaDRKIpHYbrubtdYNgiIiIiKyf5hrgAlba6+y1j5srf25c+3Rle2nZuuTgYkQ41QSGhoaCIfD7gjmoaEhisUiXq+X2tpa2tvbKZfL/PznM/9PcdhhhwHw6quv7nBtxWKRN998k6OPPnq3jCZesGABq1at4uKLLyYej/OjH/2IK6+8clJPTltbGzfccANtbW2ce+65k4YSBINB7rvvPo466iiuv/56UqkUsViMoaEhQqEQ9fX1xONxYrHYduHF6RUaGhra7rO21qpnRkRERKRKzTXA/NIY88k9upIDRDgcJhaLuX0yzshk58u009+RTqcZGxtjaGiI/v5+fD4f4XCYcDjMQQcdRH19PcuXL+e4447jK1/5Cs8999y0r3fooYdy8MEH8+CDD+5wbblcjnK5vNMjl3dkyZIlfPvb3+av//qvyWQyXHvttZOqLfF4nEceeYSamhouu+yySVWaSCTCP/3TP1FbW8stt9zCQQcdNKnXqKWlBWBSGHE+w2Kx6H5uU9/nbCFSRERERPZdswYYY8yIMSYD/A0TISZvjElv+3167yxx/+L0yTgVg3w+TzqdJp/PUy6X6enpYXBwEI/HQ2NjI4sWLWL58uUkEgkikQjBYJBoNEpnZycej4cvf/nLHHzwwZx99tnbNcrDRLP6F77wBX73u9/x+uuvz7q2QmHinNCd7X2ZC2MMxxxzDD/4wQ84+OCDueuuu0in//hXqK2tjRtvvJGXX36ZW265ZdJjW1pa+MEPfsBvf/tb7rrrLpqamhgeHuatt95yJ7jl83n3/vl83u0bam5u3q5hf2qIFBEREZHqMWuAsdZGgSjwurXWY60NWWtj1tqotTa2d5ZYneY62jcUChGLxQiFQuTzeUZGRhgdHSUSieD1eonFYtTV1eHz+SgUCiQSCcrlMrW1tSQSCY488kguv/xyRkZGuOuuu6Z9jc9//vOEw2Huv//+WdfiBJjKZvvdLRQK8dWvfpVcLsc999wz6bYzzzyTM844gxtuuIHnn39+0m3nnXcep59+Ot/5znd45plneOedd/iP//gP3nzzTbLZ7KQ1O9vLpgsvMBGmKkOkiIiIiFSPHY6lstZaY8y/G2OOtta+sjcWVY2mNoo725TK5TIej4dwODztF2ZjjFsJCAaD7vatcDjsPtZ5vpqaGkKhEB/84AfJZrP4/X4GBgZYvHgxJ598MnfffTdXXnklNTU1k7ZH+Xw+Tj/9dH7xi19wxRVX0NfXx8jIyHZrcc5k2bx587RrTafTDA0NTfv+4/E4v/71r2f8fDZt2jTp56OOOornn3+ehoYGjjnmGJqamgD4yle+wmuvvcaFF17IXXfdRWtrK4cffjgAP/jBDzj++OO59tpr+d//+38TjUZJpVIMDw/T399PU1MThUKBUCjkfqbZbJZwOKyxySIiIiL7ibn+E/SJwEvGmLXGmP9njHnDGPP/9uTCqp2zTQmYtd/CGONeXq+XaDRKNBrFGMPo6CjlchljDEuWLCEej1NfX09NTQ2xWIx0Os2WLVsYHBzkqKOOYuvWrTzxxBP4/X5aW1snXZdddhmjo6M888wzHHrooaxYsWK7ywlPzkGaU69CoUAkEpn2Wr9+PZlMZsbLOYjTuT7ykY/Q1NTEs88+S39/P16v133/N9xwA4VCgeuuu45SqeQ+prm5mbvvvpu1a9dy1113EY1GaW5uplQqUSwW6e/vZ3h4mL6+PrdRv7u7m0ymqs5DFREREZFZzDXA/BmwBPhT4HTgU9v+nDdmH/8ndWMMtbW1RCKROfVbTG3md3pj+vv7yWQyFItFCoUCGzdudE+5j0Qi1NXVEQ6HOf3001myZAk//OEPp33+ww8/nGOPPZb/83/+z4zb2pw+kspDL/cUn8/HySefzMjICM8+++yk2xYvXszVV1/NG2+8sd37+fjHP85VV13Fk08+ySuvvEIsFqOhoYGtW7cSjUbx+XyUSiU16IuIiIjsp+YUYKy1XdNde3px0zHGtG1bk93XQwz8McjsqN8im83S3d1NNpsFJvo4nKb9SCRCOBwmGAy61RFnm1RLSwutra00NDRwzjnn8MILL/DUU09N+xqrVq1i/fr1vPDCC9PeXiwWASY1xO+KsbExNmzYsMMQ0dbWxpFHHslrr73Gb3/720m3feITn+Css87i4Ycf5sknn5x021VXXcVxxx3HzTffzKZNm9iyZQubN2/mD3/4g/t5WWsJh8O0tbXtlpHQsuclk8lJFcnKq6OjY76XJyIiIvuIqupiNsb8CfCMMearUD0hZi5KpZJ71ktl74tzmCVANBqlpaWFaDTK6OgouVwOj8fD2NgY/f39nHrqqRxxxBGcffbZvPLK9u1Kn/nMZ1ixYgW33nqrG5QqffjDHyYajfLoo4+SSqV2+b10dXWxbt06Xn75Zd544w0GBwdnPEzyuOOOo7m5mb/927+lq2tyJr7kkktIJpNcc801lEol9/c+n4/bbruNfD7PE088QTKZpK6ujnK5TF9fH4VCgXQ6TV9f317pfzHGXGSMWW2MWf1+PrcDXWdnJ9baaa+pfzdERETkwFVVAQYYAQaAZcaY/w4TIWZ+l7R7FAoF8vk8fX1921VAcrkcqVSKbDbL6Ogo8MdJYaVSiXK5TCAQYMmSJdx+++20trZy5pln8vvf/37S89TU1HDzzTfT19fH7bffvt0a6uvr+fSnP43P5+PBBx9kYGBgp99HqVSiu7ubxsZGkskk6XSa119/nZ/+9Ke8+eabk4KIs6azzjoLn8/HlVdeOWm0ck1NDRdffDHvvvsu991336THLVmyhDPOOIOnn36abDbLIYccQiKRIB6P09TUtMOtZHOdEjcX1to7rLUrrbUrE4nE+34+EREREZnZPh9gnAqLMcYL5JgIMa8BS40xXzLGHGyMWbCD59hn/4Xc6X2Jx+N84AMfYMmSJYRCIWBiG1k0GqWpqYlEIkFtbS2BQIByuczAwACZTMY9lT4Wi1FbW8sHP/hBvvnNb1JbW8vnPvc51q1bN+n1jj76aD73uc/xyCOPTHsuTCwW47zzzqNcLvPQQw9NChRz0dPTw/j4OMlkksWLF3PMMcewfPlyyuUyTz/9NHfffTf//u//ztjYmPuYuro6/u7v/o6enh6uvfbaSSHn+OOP52Mf+xjf/va3t5ucdvnll5NOp/nxj39MJpOhv7/frUo5ISYYDE67Th1mKSIiIlKdzL5ewDDG1Ftrhyp+vhb4GZAArgIOAz5nrX3dGGN2VJFZuXKlXb169W5f544+x5m2MWUyGdLptNvob60ln88TDAbp7e1lZGSEtrY2PB6Pez/nwEsnzAwODpLJZNyzTXp6enj11Vf53ve+R21tLU888QQLFy50X/OZZ57hsssuw+/3c9ttt006uPKnP/0p4XCYVCrFY489RjAY5FOf+hSxWIxnn312xkMuM5mMW33xeDy0tLRMes8NDQ1kMhlSqZT7PhYvXowxhg9+8IMsW7aM1157jUceeYTjjz+eU089FYCmpibi8ThnnXUWl156KX/1V/8/e3ceHlV9Nv7//TkzmX0m2ySTSQJJIICiuEEfl7ri1ta1Vmu1amtxKy6tj0rrUqu/R2kfq9RWaF1arAva9ge1li6ubRWtG1qrFSuIGLZksk4yayYz5/P9I5zzJCRBVCAB7td1zQWZOXPOZ4a5uObO/bnv+4pB7+nFF1/Mf/7zH5588klSqRShUIiSkhLcbjcdHR32lrvh/r3S6fSI7a238O/4utZ6xkiPb6/P1yellPrIz+bOYFd5HR/loz5fQgghhNiKOTCjSSl1PHDhppqXdq21SX83tAiggBnAP4FD6B+2OWrfcD5pnYXVncyq1bAyA8lkkkQiYW8nG5iVSaVSKKVwOp20tbWxfv160uk0ZWVluN1utNbsvffezJkzh1tvvZUzzjiD5557zp61ctBBB3HHHXdwzjnn8Mwzz3DNNdfY6znzAYdHkAAAIABJREFUzDPt9s/HHXcc11xzDU888QTz5s3D5XJRVlY27OuYO3cuWmvy+TxFRUVDamisGTMWa2sZ9G8Va2xsZP/992ft2rW8+OKLTJ06lXHjxpHJZJgxYwZf+MIXWLhwIeeeey6VlZX2ea6++mq+8IUv8OyzzzJ9+nQ6Oztxu90kk0kKhQLJZHLYJgqGYUhxvxBCCCHETmjMbiFTSh0B3APcp7Vu3RS8ACwEzgceBq4Efgw0KqWG/2Y9xlldyqwAyJofEw6HiUajTJgwwf4CPvDPSCRCRUUFdXV17Lvvvhx88MFMmjQJv99PWVkZPT09TJs2jVtuuYXVq1dz9dVXD7rukUceyZe+9CUWLFjAihUrhl3b1KlTmT9/PoZhcNlll9Hc3LzF11IoFAA+1YT7448/nmAwyGOPPTZoK9k111xDX18f8+bNG3T8Mcccwz777MM999xDV1cXXV1d9gBRh8OBaZpkMhlM0ySRSJBIJLZJ3YsQQgghhBgdYzaAAaYA/6u1flIpVaWUOkQpdQjQAoSAC7XWvwb+Adystf74FedjiNba7gzm9/txOBwEAgGCweCw2QO/34/T6aS4uJhIJEI+n8fn8+F0OvH7/VRUVFBUVMSBBx7I+eefz0MPPcSyZcsGnef73/8+JSUlzJo1a8TgpKGhgZ/97GeUlJTw2GOPjdgNSmttBw0fNxs1cNCkx+PhlFNOoa2tjeeff96+v76+nvPOO4/f/va3g2p3lFJcddVVvPvuu7z//vu4XC6czv7EolUbZGWt1qxZQ0tLy6duEz2W1NfXj9h6WClFXV3daC9RCCGEEGKbGssBTA6YrpRqAP4MnAX8GjgSOE9r/YRSyqG1TmmtP16l+RhiBS5WLcxHFZUXCgVisRh9fX12F60NGzawevVqNmzYQG9vLx0dHdTW1lJWVkYqlWL27NmUlZVx3333DTpXWVkZDzzwAF1dXZx11lm0t7cPe81oNMqCBQsIBAIsWbJki2v8JLv4Nm8UMHnyZKZOncpLL71kd10D+Pa3v01xcfGQ4ZZnnHEGoVCIp556ing8TjzeXzIVi8UGnduarWNtx9sVNDU1jdh6WGvNhx9+ONpLFEIIIYTYpsZyAPMakAG+Cjyktb4cOIH+wv0jAbTWhVFb3TZi1bwAdiH/lrS3t9uDGxOJBOl0mpqaGiZOnEhNTQ1NTU28/fbb5HI5GhoamDx5MsXFxRx66KE8/vjjQ+a/7LvvvjzwwAOsX7+es846a0inL0tZWRnHH388yWSSP/7xj0MCFasmxzRNeyvZ1tq8tTL0z4fJZrO8/vrr9n2BQIBzzz2XZ555htWrV9v3FxUVcfDBB7N27VqUUuTzedrb21m3bh0tLS3EYjFM06SqqoqKigp7S5kQQgghhNj5jNkARmv9DhAHTgaiSqmA1vpt+juQuUd1cduQVfMSCATsWhgrKzNcNiMcDlNdXU1NTQ3BYBCfz4fL5aKhoQGPx0N9fT3jx4+npqaG4uJiAoEA8XicE088kVQqxR//+Mch5zzwwANZuHAhq1ev5sYbbxx2yCVAJBJh5syZrFixgjfffHPI49b2sXw+/7EyMcMFMOPGjaO6upply5YNOtd5552Hy+Uakk06+uijWbFiBYVCgc7OThKJhN0YYcOGDaxZswaATCZDc3PzoG1rQgghhBBi5zEmAhil1BSl1MFKqaJN814A0Fp/D1gKlAJXKKWuoH8r2dABJjupzYv44f+yMplMZsiWIKUUgUAAh8MxKODRWuPxeIhGo+yzzz4YhkFvby/t7e0UFRVx+OGHU1NTwyOPPEI2m6W3t3fQ7cADD2T+/PmsXr2aq666itbWVnp6egbdEokEEydOpLq6mj/96U+89957xGIxYrGYXQNjGAZaa/r6+igUCvZtS/L5PP/85z8H3d58802i0SixWIyHHnqIt956i7feeouNGzdy1FFHsWTJEl5++WV7/aeffjpOp5M///nPBINB/H4/kydPJhAI0NfX94m7xAkhhBBCiLFl1NsoK6VOA+YCGzbdliulfmXVtWit/0cpNROYSP/Mly9orVePeMKdzHBfrDdvrTzQwC1nfr9/0GO5XI5MJkMqlSKbzZLNZunu7qa4uJiioiKOP/54HnroIVwuF+FweMh1zz77bDKZDFdeeSV33nkn999//6BBkD09PQQCAQ466CAuv/xyXn/9dW677TYcDgdr1qyhuLgYgJdffpl169YxY8YMxo8fD8Bzzz037Ovv7Owkl8sNO6tlzz33ZMWKFfz5z3/moIMOsu//8pe/zJNPPsnSpUs59dRTgf46nS984Qs88cQTfOUrX6G3t5fy8nJCoRAVFRV2cwPr2I/aqieEEEIIIcamUc3AKKWKgDOBWVrro4HHgXHAHKVUsXWc1vqvWuv7gGu01u+OzmpHn5XlGKkQ3ev1EolEGD9+PIZhYBgGpmnS3d2N0+nkxBNPpK+vjz/84Q8jXuOEE07gjjvuYNmyZXzzm9+kr69vyDHhcJhLLrmElStX8uSTTw55fP/996esrIyXXnqJt956a4vbyQzDGHYLGfRvSdt777159dVX2bBhg31/TU0NhxxyCH/4wx8GbQU7//zzaWtr45VXXkEpZc/Hcblc+P1+u/vYcHNhhBBCCCHEzmEsfIsLAZM2/f0x4I+Ai/6tYiilPqOUOmDT4zt90f7WsLIsm3f7SqfTJJNJDMMYcUvUwMAlFAphmiarV6/mvffeY/LkyUyZMoVHH310i0HFGWecwdy5c3n66ae56qqrhj328MMPZ5999uGhhx6io6Nj0GNut5sjjzySCRMm8O677/LCCy+MWDRvGMYWt5hNmzYNh8PB0qVLB93/5S9/mWQyyf3332/fd+yxx1JdXc0rr7xCNBrF4/HgcrnI5/PEYjHi8TipVIpUKjVkPaZp2l3dhBBCCCHE2DWqAYzWug+YB5ymlDps07DKF4A3gcOVUl7gUGDjpuM/fo/enZBV2L/5Niefz0cgEMA0TTuoME2TVCpFPp+nra2Nzs5O2traAHA6ndTX1zN58mT23HNPHA4HRx11FC+99BLf+ta3tvhl/bzzzuOaa67hd7/7Hdddd92QY5VSXHzxxeTzeebMmTOkKN7hcDBjxgwOOOAAWlpaaG9vJ5vN2o9rrUmn03aGZCR+v5+6uroh7YD32GMP6uvr+etf/zromueccw5PP/20vX0um83S1tZGMpm058OMFBxuTRtrIYQQQggxusZCBmYZ8BRwrlLqcK11QWv9CFANVGutf6y1bhndJe5YhmEQCASGZFlM06StrY14PG5vh8pkMvT09NDR0UE+n6evrw+3223XfoTDYfbaay8MwyCdTnPKKadw1llnsXDhQi666KIRt28BXHHFFVx66aU89NBDfPe73x0SxIwfP54f/OAH5HI5XnnlFTtwsiilmDRpEsceeyyGYdgzWgqFAt3d3fT09OByuZgwYcKIaygUCqxdu5bGxsYhj1VUVAy55le+8hVM07SzTB6Ph0gkYrdQ9vv9IwaH1v2SjRFCCCGEGLtGPYDRWmeBRfR3FrtWKXWRUuprQAUgvW4HaG9vp6uri76+PrsGxpo2bxWsl5aW4nQ6KS8vtzuV+f1+8vk8qVQKpRQXXHABl112Gb/+9a8599xzBw2LHEgpxXe/+10uv/xyHnnkEX7xi18M+VLf2NjIj370I1wuF3//+99Zu3btkPOUlJRQXl5OIBCwMyLZbJZAIGCvdyRtbW309fWxxx57DHmsuLh4yPDNPffck3333ZeXXnqJ0tJSu8bGCkgMwxi2BsYKGq1AT7IxQgghhBBj06h3IQPQWncppe4DVgAXA1ngHK11bHRXNrZYncPKysrIZDJ4vV6UUnY2wTAMux4lGAzidrtpbW0F+me4mKZJNpulvb2dr3/96/h8Pm677TZmzpzJXXfdxX777WdncQa68sorAbjrrrswTZOLLrpoUAAQCATYf//9eeedd3jppZfo6uqioaFhUAYpl8tRVFREMBjENE2UUhQVFZHL5dBa09zcPOxrjsfjQP9Wss23kTkcDtrb24dsX/viF7/ITTfdRGdnJz6fj/fff99+LBKJ2O/VSKzg0Ofzfax5NkIIIYQQYvsbEwEMgNY6B/xNKfV8/496t9+/s/kWMqfTSVVVFclkcthWyj6fzw5UtNa0t7fz7rv9TdsmTJiAz+fD4/GQSqXwer1ceOGFlJSU8NOf/pQjjzySb3/721x33XXDtjS+/fbbcTgc3HnnnVRWVto/WzweD263mx/+8Ic8//zz7LHHHnzzm9+0j/nLX/4y4utsaWlh2rRpwz62aNEiwuEw06dPH/JYTU2NXZA/sN3zmWeeyc0338yf/vQnzj//fIqKijAMg1wuR3Nzs72NbKQgxsrSiLGjrq5uxMYVw9VICSGEEGLXNWYCGIvWerfoNPZpDJwTM5BSimAwSCqVoqenB5/Px5577gn0Z2/i8ThlZWX28R6Ph5kzZ1JfX89vf/tb5s2bx5IlS5g/fz7HHXfckOt+61vfwuFwcMcdd2CaJvPmzRsUxLhcLm644QbuvfdeFi9ezJo1a7j++usHXfPjWr9+PXvvvfewj5WUlAD9W+tqa2vt+6urqzn00EP5+9//zuWXX24HZB988AGFQoFIJEJ9fb19vLRVHvu2FKDIkFIhhBBi9yLf2nZCVoZgpC9uVrcywzCIRqPU1NSQz+cxTZN4PG4PuczlcqTTaTsbc8MNN+DxeDjppJP42te+NqQ9MvRvJ5szZw5LlizhiiuuGNRZzFrbJZdcwpw5c/jPf/7DJZdcwptvvvmJXmcymaSrq2vY+hfAHpw53DrPOOMMVq1axZIlS9iwYYO9ha2iooJx48YBEIvFaG5upq2tTQr2hRBCCCF2EhLA7IKUUhiGQTKZtLuVDSz2D4fD+Hw+SktLmThxIlOnTuWAAw7gyCOPZMGCBZx//vksWbKEo446inXr1g05/xVXXMF1113H448/zuc//3n+9a9/DTnmuOOO46677sLn83HNNdewbNmyLc572dyGDRv4xS9+AcC+++477DFWfcpwTQhOOOEEAN588016enrIZDI4nU4aGxspLi7G5/MNanBgvU+bnz+VSkkdjBBCCCHEGCIBzC7KClisgnTDMHC73YOyFd3d3TidTqLRKBUVFcyYMYNp06Zx44038vDDD9Pc3MxRRx1l19EMNHv2bBYtWkQikeDkk0/m0UcfHVL8P2HCBH7+85/zuc99jldffZVFixYN6Rq2uXw+z1NPPcWCBQtIpVKcffbZTJkyZdhj33jjDfx+/7ABjtXZzOl0kkgkeOONN1i9ejUbN24klUrZHcZCoRAlJSV2bZCVidFa09raSjwel25kQgghhBBjyJirgRGfjjUg0u1220MurRqPjo4OmpubqaiowOl0UlpaSi6Xw+fz2d3MrFbNwWCQu+66izlz5jBz5kwef/zxQXUmAEcccQTPPvssN954I7/97W954403+M53vkNDQ4N9jNfr5aqrrsLlcvHUU0/x8MMPc8ABB1BbW0sqlSKVStHW1sa//vUvEokEnZ2dJBIJDjjgAE488cRBNTabv85XXnmFI488ErfbPeRxKytTW1uL1tqeq+N0OonFYoTDYTvAMwzDrhuC/pqYZDJJd3c3wWBwSK2REEIIIYQYPRLA7GKsGSaGYZBIJACIRqP4/X7KyspIpVL4fD67Bsbn85FOp/F4PKxbt47u7m4cDgeVlZWUlJTw/e9/n9tvv53jjz+eBQsWcOyxxw66XnFxMT/5yU9obGzknnvuYfbs2Xzta1/jjDPOGBR8NDY2Eo1Geeqpp3jttdd47bXX7MdcLhfFxcUEg0EmTJjA/vvvb9e9jDSjZu3atcRisSHrsVi1ObW1tUycOJFkMkksFqOjo4Pi4mIMw8Dr9drtqAfO1bGMNFBUCCGEEEKMHglgdlJbKuCH/g5jm3cry+VyeL1enE4noVAIt9tNLBYjkUgQDAYxDAPDMCgpKaGkpAS3200mk+Gb3/wmjzzyCBdccAH33nsv55xzzpDrXn311Vx44YVceeWV/OIXv+Ctt97ipz/9qR2IVFVVAXDppZeyYcMGOjo6CIfDlJeX09bWRjQaHfb1tLe320X3Az399NMAHHPMMcPWqFgBjMvlwuVyYZombW1t9rBPt9tNW1sbuVwOl8tFRUWF3TrZ2kYWiUQIBALDrksIIYQQQowOqYHZxVhZA4fDQTAYJBgM2sGO1Z0M+jMNvb29xONx1q9fj9PppLe3l9bWVl5++WV6enpwuVzss88+HHTQQdxyyy0cdthhzJo1i3nz5g177XA4zIMPPsg999zDypUrOeyww7j11lsHdSpTSlFbW8u+++5LTU3NoPktH8dzzz3HpEmThmxrs1jXTKVSdHV10dfXR21tLX6/H9M06erqIp/P09vbS09PD4lEwq6ByWQy9PT0SO2LEEIIIcQYJAHMbmTz7mRer5eioiKcTicbNmygtbWVjRs30tbWRjqdJpVKsW7dOjweD42NjSxYsIAvfelLXHvttXznO98ZtvWwUoozzzyT1157jS9+8Yv86Ec/4tBDD+XVV1/dZq8jmUzy+uuvc9hhh414jLX1rL6+3m63XFFRQX19PYFAgNLSUgKBAFprTNO0t95Z74vT6SSfz0sQI4QQQggxxux0AYxS6kCl1NA9RWJEA9sB+3y+QcXr9fX1VFdXUygUcLvdNDY2su+++1JZWWk/P5fLkc/nSSaTXH755Zx77rnceeednHTSSXzwwQfDXrOiooJ7772X3/3ud/T19fGNb3yDH//4x+Tz+U/1WpLJJN/73vfI5/McfvjhIx5nrSufz9sBTGlpqT3Usre3l46ODnp6enA4HHZ2yqqBsd4nKeAXQgghhBhbdqoARin1eeD3QINSyrHpPqmw/ghWdmG4bILT6SQSiRAMBiktLaW2tpba2lqCwSB+v5+GhgbGjx+P0+nEMAzKysq44447mDNnDi+//DL7778/P/jBD0Ystp85cyYvvfQSZ5xxBr/85S+ZNWsWsVjsY63famn87LPPctppp/HEE0/w7W9/mwMOOGDE1/s///M/TJs2Da/Xy7///W96e3vJZrNkMhl7G1lfX58dzCWTSbsGKJPJ2D/Lx0sIIYQQYmzZKYr4NwUplcD3gXO11s8rpdxAgf4gbOsnJO6GBhb2t7a22lkQq2jd7/dTU1Njz4nJ5/Nks1m7lsY6h8/no7y8HIBLLrmEqVOnsnTpUm666SYefvhh7rjjDo444ohhr//973+f6dOnc/PNN3P00UdzzDHHUFlZSXl5OQ6Hg4kTJxIOhykrK6O9vZ1Vq1axcuVK3n33XT788EO6urqA/sL6hx56iBkzZpDL5YZ9vfPmzWP9+vWcdNJJAPT19VFfX09lZSWmadoF/alUikgkgmma9Pb2EggEME3TzsK4XC675fJI7ZyFEEIIIcSOtVMEMFprrZRKAe9orZ9RSkWB25VSaWCVUur3WuuVIz1fKXURcBHA+PHjd8yixxClFH6/n1QqRT6fx+l0DmkXbAUz4XCYTCZjBz0ul8ueCxMIBOjq6sLlchGPxykpKeHUU09lv/3245e//CWnnHIKZ5xxBrfccguRSGTIOk488USmTp3K4sWLeeGFF3j11Vft2SvD8Xg81NfXc8wxxzBlyhQmT57MtGnTtrit64MPPuCnP/0p06dPZ6+99rIbGTQ0NBAMBslkMiQSCWKxGE6nE5/PR1dXF4VCgba2Nvs+v99PLBZj48aNAMO+ngHv7279+RJCCCGE2JHUcC1oxxKllFtr3auUMoBngKeBvYDngTiwB/2B2K1ATn/EC5oxY4Zevnz5dl716BvubbCGXFr1L8MxTXPQtqmWlhZWr15t14d0dHTYbY3Xrl1Lb28vJSUl5PN57r77bh555BE8Hg833HAD559/vp25aGpqGvZ6vb29vPXWWzgcDtrb2+ns7KS0tJTGxkZqamro6uoato0y9Nfm1NfXD3p9Z511Fi+99BJ33nknVVVVVFdXU1dXZ7eJBigUCrS3t+PxeMhms3ZQZ/0cDodxOp2Ypkl7ezvhcNh+rsPheF1rPWOk931Hf76UUsP+W+9OdqX3QCm1xc+XEEIIIcZ4BkYpNRPYUyl1v9Y6rZS6DrgEKNNa37vpmGOA87TWwxdh7KaGq91QSn3kXJPNAxufz4dSikQiQT6fRylFKBQiGAzidDrp7u7G6XTidru5/vrr+fznP899993HnDlzWLJkCffccw/Tpk1jypQpI15z0qRJuN3uYR/r7e0dlC0aKJ/PD2rDvHTpUp5++mm+/vWv4/f7yeVyrF+/ntLSUjo7OykrKyMYDNLb20skEiGVStkzcCKRCG1tbcRiMQzDIBKJ4HA4tph5EUIIIYQQO96YDWCUUp8DbgMu1Vpb1efvAX8DblVKXaW1vgMoBSqUUsVa6+5RWu4uKxgMMmHCBLq7uwkGg4RCIXu7WSAQIBAI4PF46OzsxOPxUFNTw4033khjYyOLFy9mxowZzJkzh6uvvvoTz3zZGplMhquuuoo999yTE088kWg0SiKRQGvNxo0b6ejooLS0lOLiYoqLi4cN8Kz6HuvPzW36Lf9O1fhCCCGEEGJXMyYDGKXUPsCjwIVa62VKqXL6vzi6tNYPKKXWAzcrpfYGDgZOl+Bl+7CyEaFQCI/HY28JS6VS9PT04HT2f4RM0ySZTAL9WZODDz6YI488kgceeIC5c+eyZMkSHnzwQaZNm7ZN16e15rnnnmPu3Ll8+OGHXHbZZSSTSUzTpKysDI/Hw4QJE2hubiaXy9He3o7X67WzOsXFxeTzebs72ZYyLpu6uEk1vxBCCCHEKBqrv032AL8FqpRSM4BFwB3A35RS52qtnwWOBG4CDtda/3u0Fro7MAwDr9dLNpu1h1dawx5zuRzJZBK/309tba0d7FRXV1NbW8vll1/ObbfdRnd3N0cccQT333//NqlXyOfzLF68mIMOOojjjjuOd955h9mzZzN9+nTGjx9PdXU1kUiEmpoaCoUCdXV1dvbIygQZhkFFRQUlJSUjblMbaFPzgB3e8a6+vh6l1LC3urq6Hb0cIYQQQohRNSYzMFrrV5VSRcAZwC3AdcC99GdbHlVKvaW1/hcwfGW42OYymYzdMczv99tf/tva2sjn8xiGYXfwyuVylJWVEYlEePfdd/n85z9PQ0MDP//5z7n00kt55JFHuPLKK6mpqSEajdpb0rZGIpHggQceYP78+axdu5bJkyfzrW99i+nTp9uZF6fTSVNTEzU1NeRyOTvIKi0tpVAo0NfXRywWw+fzYRgGHo+HtrY2ysvL7YzScDZtOzM/5Vv5sTU1Ne0yRepCCCGEEJ/WmAtglFKG1trUWr+olDKBZVrrJUoptWk72RNAarTXubvxeDwkk8lBdSxWEJPJZHC73aRSKZLJJE6nk3w+TywWo6qqCqfTycEHH0xdXR2LFi3i0Ucf5fTTT7fPU1RURDQapbq6mqqqKjweD1prTNO0Gwdorcnn8yxbtox4PM5nP/tZZs+eTV1dHRs2bKCpqYmKigqi0ShdXV0UFRXh8XgoKSlhzZo1dHZ2kk6nCQQCJJNJcrkcra2tdvBkzcexsjGGYdhd26xGBkIIIYQQYvSNiQBGKTUFKAOWM+A33Frrl5RSrk1/10qpM4H9gcyoLHQ3Zm0fy2az9iT7TCaD1+vF7/dTKPTvrLIyGu3t7ZimSVVVFWVlZaxcuRKlFF/72tc4/vjjWbVqFS0tLbS3t9PW1kZHRweGYfDOO+/Q19eHUmpg62IMw0ApxdFHH81nPvMZGhoamDJlCh0dHXYwYhXpFwoFvF6v3WBg3Lhxdn1LW1sbkUiE7u5uKioq7GArmUySSv1fXOz3+0mn04OyTmJsqqurGzHArKur48MPP9yxCxJCCCHEdjXqAYxS6jRgLrBh0225UupXWuueTVmXnFLKCZwNXA2cpbXeMIpL3qWN9EXQGh5pZSMGbikLBAI4HA77T5fLRSaTIZ/PEwgEiMfj5HI5TNPE4/HgdDoZP3485eXlmKZJTU0NU6dOxTRNfD4f7e3tJJNJkskkSik8Hg+pVMoOjt58801WrlyJw+GgpKQEpRTBYJBUKkVvb383ba/XS1NTk73uaDRqnyuRSAD9QzqtYCwajZLL5ewhn0qpIa9ZjE1bClDk300IIYTY9YxqALOpzuVMYNamLWNfAg4C5iilfmR1FtNa55VSCeA0rfX7o7jk3ZZhGINmyAz8cj+QNfzR7XbbWYuysjIASktL6ejooLe3F4/HQzQapampCcMwSKfT1NXVYZomPT099PX1kc/niUajlJWV8fbbb9Pd3Y3L5aJQKJDJZOjq6qK4uJja2loKhQJFRUXkcjm01nbdS09PD6FQCNM07QYEJSUlxOPxIcX8VkYJIJlM4vP5PnJujhBCCCGE2LFGPQMDhIBJwIvAY0A7cAJwFnC3Uuq/gITW+rHRW6LY3OYBDfQX+sdiMfL5PC6Xi1AoRDKZtAOEVCqFz+cjEomQTqcxTZOSkhI7K5NMJkkkErz33nu0trbS19eHaZq43W673XFLSwtKKcLhMJWVlTQ2NmKaJkopCoUCDoeDlpYWiouLaWtro6ioiIqKCgzDoLm5mWw2a683m83i9XrtrWNWcwKrRTQgAYwQQgghxBgzqgGM1rpPKTUPuFwptXpTkf4LQA1wolLqAeCzwK9Hc51i63i9XrszWVFREYZh4PP5iMfjdHZ20tHRgd/vp7KyEqfTidPppLe3165NsbaPpdNp/H4/qVSKrq4u0uk0RUVFlJaWopTC6/USDAbtzlzFxcX09vaSz+fJ5XKUlpbaQyytQMrv9xMMBoH+hgTZbJZ8Pk8qlSIWiwHYHdGsLMzm2SUhhBBCCDH6xkIGZhkwBTh3U83vVY6vAAAgAElEQVTL88AjSqmLgGqt9Y9Hd3lia1mtlK0ZMX6/n7a2NpqamuzAIxAIYBgGpmnicrloaGjgww8/pKWlBa/XS319PeFwGNM0+eCDD+jq6sLr9eJ2u8nn8xQXF1NRUUEikeDdd98lFosRiUQIh8Ok02lSqRR+vx+n00llZSV1dXV2lmXglrBUKkUqlSISidjDK63AZbjskhBCCCGEGBtGPYDRWmeVUosADVyrlNoD6AUqgOSoLk58bFYQYLUitgr1XS4XuVzO3s5lFdR3dHQQCoVQSjFu3DhcLhfFxcWYpolhGHR2dlJUVAT0Z1qKi4sB7AyK2+22576YpklfXx/BYJC+vj58Pp/dUGDNmjV4PB5qamrwer120GJtGxNCCCGEEDuHUQ9gALTWXUqp+4AVwMVAFjhHax0b3ZWJrTXcoEWtNQ6Hg6qqKlKpFNlslo6ODsLhsL1FLJ/P4/F4qK6upre3F4fDAfRnSAKBAIFAAJ/PZxf+Z7NZEokEJSUldkCTSCTIZrPU1NQQCATsIKq3txe3200mk8Hj8dgdx7TWgzIsMiRSCCGEEGLnMSYCGACtdQ74m1Lq+f4f9Q6feC4+OatdbTqdJh6Pk0wmqaystO/3eDy0trZimibpdBqAfD5vP5bNZu22yaZpsmbNGnsYpRXIQH9mJ5FI0NHRYTcLmDJlij2k0jAMu3GAaZp2wFRTU4NpmvZjMtdFCCGEEGLnNOb2zmitCxK87Lx8Pp89HNIKVLTWdHR04HA47M5isViMtWvX2oMsob/jl9Xu2Ov10tfXR1dXF+3t7fb5s9msXb8ysN4mFArZ1wuFQoTD4SHr8Pl8hEIhO0PzcWitBw26FEIIIYQQo2PMZGDErkEpRWVlJel02u7ilU6nyefzFAoF3G43hmEQiUTsuSxWRsQajhkIBIhGo+TzebLZLOFw2D6/tRWsvLycbDZLd3c37e3tVFZW2t3GDMNAa23PdrFmywB25kVrba9RKTXk582l02nrHGMu6Bcjq6ur2+Iwy7q6ui0OwhRCCCHE2CMBjNjmlFKDtmhZgYzL5aKzs9POmli01naXMiuogf5sSygUsutirPusc1kF/ZlMhlQqRUlJyaCCfCswshoCDMy8DAhI8Pv9Q37e3ICWypId3Il8VHCypeBGCCGEEGOTBDBiu7MCmlQqhWma9Pb2DgpgLIZhYBiGnYUJhUJ4PJ5BxwzscqaUIhKJDKqPGc7AQCaRSAD/F5CM9KdlYGZme9bN1NfX09TUNOxjdXV12+26QgghhBA7GwlgxA4zMPjYnGmaZDIZ3G63XadibQUbyMqkZDIZ+xhrQOVIrHNbtTfQP7TS5/MN2jY2XIDyUZmZbaWpqUm6oQkhhBBCbAUJYMQOM1L3L621Xf8SCoXsLIjWetgv9daxMHJQMfB5A2trrPkvVvDyUecZKTMjhBBCCCFGhwQwYpv4NLUEhmEMChQGnmu484507ObntLZ/WdvQBh6vlNqq8yilBs2MEbuWLRX5S4G/EEIIMTZJACO2ijW/xefzbfPJ9R/VAWxzw233Gm59H5VhMQxDgpPd3JYCFCnwF0IIIcamnTaAUUopLUUDO8zAYGBbf+nfFnUmw61Ptn8JIYQQQux6droARikV1FonJHjZsbZnMDDw3B93PsuW1jdSYf5ItmeWSQghhBBCbBs71bc0pdSJwC+VUr9RStVuuk/2eewA1nar7fHF3go0lFJ2JiWdTgMM+Xl7rm9rr/VJ1dfXo5Qa9iatksceqz5muFt9ff1oL08IIYTYbe00GRil1GHAbcDFwPnAD4FztiYTo5S6CLgIYPz48dtzmeJT2tr5LNBfO5NKpbZZxmR7bzmTVsk7F6mPEUIIIcamnSkDMxP4vdZ6GTAXMJRSNyil9lNKhbb0RK31vVrrGVrrGRUVFTtkseKTGZiNGe7ngbaUMbGCm48TMGyLLM7bb78tWZbdwJayM1u6SeZGCCGE+PTUzvIbYaXUCcBlwPPAFcCvAB8QAn6ltX5uawr7lVJtQBMQBtq366K3DVnnlhmAOcL9DqAw4PFtscY6rfWgKHhghg+YAnRsg+t8XKPx/ss1t70hny8hhBBCDDamAxil1DFAXmv9d6VUBDgc2Bdo0Fp/ddMx/x9Qq7X+xsc893Kt9YxtvuhtTNa57eyoNY7GeyHX3LWuKYQQQoiRjdktZEqpIuAHwK1KqUO01jGt9f8PzAcSSqm9Nh26EsgrpVyjtVYhhBBCCCHEjjGWi/jzwMvAPsD1Sqkfaa3/Dmj6twVdvqku4lDgLK11brQWKoQQQgghhNgxxmwAo7XWSqk/A48BdcCVSql9gW7gF8AEYE/gi1rrVZ/gEvdus8VuX7LObWdHrXE03gu55q51TSGEEEKMYKzXwHwOuEhrfZpS6mfAJcCNWutbRnlpQgghhBBCiFEwJmtgBgynfAb4l1LqYOBo+jMvM5VSh8gASyGEEEIIIXY/Y2ILmVJqClAGLAdMrXVhU0vkvFLqQOD7wCla66VKqUuB9VszwHI44XBYyyyGXZ9pmhQKBRwOxzYZcml5/fXX27fU5rasrEzX19dv02uK3ceWPl/yf5f4ND7q/y4hhNiZjHoAo5Q6jf7BlBs23ZYrpX6lte7ZdMiXgSla69cBtNYLPs316uvrWb58+ac5hdiBTNMknU7j8/mGDLPUWtuPbR4wDHze1gYTW/McpVTTls4xbtw4Xn75ZbLZLACBQGDQUE4htmRLny/5v0t8Gh/1f5cQQuxMRvXXxJtaJZ8JzNJaHw08DowD5iiligG01kkreFFKya+1dzPpdJqenh7S6fTHeswwDAKBwMfKhGzpfB9HZ2cnsViMWCz2qc8lhBBCCCEGG/UMDBACJgEv0t9xrB04ATgLuFspNYP+YZZvaq2Hm7gudmE+n2/Qn1v72La+1tZyOByEw+FtvjYhhBBCCNFvVDMaWus+YB5wmlLqsE0BygvAm8DhSikvcBjQMorLFNuZaZokk0lM0xz0d+jfduX3+4fdfqWU+thZli35JFmb4c7hcDgIBAIAJJNJxnKnPyGEEEKInc1Y2JK1DHgKOFcpdbjWuqC1fgSoBqq11j/WWksAswsbuHXrk27j2jzw2VY+6XnT6TSxWIzm5mZaW1vtIGZ7rVMIIYQQYncx6lvItNZZpdQiQAPXKqX2AHqBCiA5qosTO8Rw261G2nqltSaZ7P9YDCyQtwIf6/5txTqvaZofKzPj8/mIRCIkk0ny+TzJZBLDMIYNYLZlFkkIIYQQYlc36gEMgNa6Syl1H7ACuBjIAudorWOjuzKxrXzUNiqv10s6ncbr9eL3++0v+h6PB4fDYR+XTCZZs2YNXq+XqqoqlFJ4PB5M0yQQCOD1etFa27dMJoPb7aa3t9f+0+v12sFEJpOxfx6OFUiZpmkFSFsVaSilCAaD+Hw+2tvbyefzxGL9H2e/309nZyfr1q3D5/MxadIkgsHgR55PCCGEEEKMkQAGQGudA/6mlHq+/0cp2B9LPklb4o8jk8nYGRSv10tbWxv5fJ6SkhL8fv+gY71er51lSSQSpFIpO4AZ2HJ54DlTqdSgwKiiomLQ45tfw2LV4Gitrdf9kZ/LgcFGOp0mkUjg9XqJx+PE43FcLhcul4uOjg7S6TSRSMS+/vZ8j4UQQgghdgVjJoCxaK0Lo70GMdS22KK1pYyH1+sFwO12E4vF6OnpIRAI2IX91vF+v5/q6mrcbjeZTMbOkFiPd3d3k0qlCIfD9jmz2SxNTU0UFxeTSCQwTZNUKmW/Fq/X+5HZGCuQ+aQCgQB77rknzc3NdHV10dvbS1VVFel0mpUrVxKLxaioqLCvvS23wQkhhBBC7ErGXAAjxqZt0RZ484yHFUhYAYrf7yeTyZBMJslkMhiGQSaToaKiAqfTaQcayWSSbDbLunXrKBT6491wOIzT2f9xzufzg4KbbDaLaZp0d3fbAYpVh1JSUoJhGKRSqUEZIOv5n3brllXfYl3XMAw2btxIa2sroVCIpqYmEokESinC4TDTp0+np6cHr9dLUVERkUjEfl1CCCGEEEICGLGVrBbDn4aVEbECkba2Nrq7u8lms/j9fiorKwGorKykp6eHtWvX4vP5BmU+kskkGzZsIJ1O895776G1xul04vP5KC0tZerUqRQXF9uZnEQiQUVFBRMnTqSkpIR4PI7H4yGZTNpB0eZr25qtZVvLet+sGiC/38/+++9PW1sbLS0txONxWlpaKC4uprOzk5aWFrTWBAIBJk+eTFdXF3vssQdFRUWfah1CCCGEELuKnS6AUUopLYM1xqzhamWs+9xut/1zR0cH2WwWwzAYN26cnWVIJpOEQiGcTqcdnJSXl9Pb20s+n8fpdGIYBl1dXXR3dxOJRAgGgxQKBTtb4vF4iMVirFmzBp/PRzQaJRgM8sEHH5BMJqmrq8MwDDweD1prUqmU3TwA/i+Y2R5DKA3DoLS0lNLSUsaNG8fKlSvp6Ohg4sSJdHZ2smHDBrq6uqipqSGVStnvW2Njo9TFCCGEEEKwEwYwQDEQH+1FiOGl02ni8TjJZJLKykoMwxjUiri9vZ2ysjJ7i1hRURFdXV3U1taSyWTI5/N0dnbicrkwTZONGzcSCATsrIl1TDKZJBwOs/fee+N0Okmn0yil7IxOPB5n/fr1NDY22tmepqYment7CYVCQH9hfzabtc9n1aBY29ms4GZbbCXbXD6fp7m5mYqKClatWkVdXR3BYJB169bZ82NcLhctLS309PTQ3d3Nvvvui8vl2qbrEEJ8cvX19TQ1NQ37WF1dHR9++OGOXZAQQuwmdqoARil1PHChUmq21rp1tNezu9lS4ktrjVIKr9c7aPaJ1ebY7Xazbt06+7FcLkdVVRXxeJxMJkMikQD+r2uX2+3m/fffp6mpieeff558Pk88HqdQKBAKhTBNk/Hjx9t1MH19fXbWx+FwUFRUhGmaNDc3EwgECAaDTJo0ie7ubqqqqkgkErhcLrs+Jh6Pk8/nCYVC+P3+QYEXfPqtZJvr6OggHo9TWlrK9OnTMQzD3hoH/d3VrIyTz+fjn//8J2vWrOGzn/0sgUCAbDZrv+fhcHjEAEuyNkJsP01NTSP+vyitz4UQYvvZaQIYpdQRwD3AxR83eFFKXQRcBDB+/PjtsDphMQyDiooK0uk0Wmu6u7tJJBJ0dnaycuVKqqur0VoTi8Xo6+sjlUrhcrlYt24dK1eu5MUXX2TDhg2sW7eOeHxwos3hcGAYBn19fUOu63Q6mTFjBpdffjmdnZ1UVlbagU06nbZnyaTTaZqbm1FKkUqlSCaTeL1eNmzYQCgUIpPJEI1GCQQCgxoXbOnLyNZ8vjZ/fjgcxjRNXC4XkyZNIpfLsWrVKqLRKFprurq6aG5uJplMksvl6OnpIRaL0dXVxcEHH4xhGCQSCUpKSobUCQkhhBBC7Mp2mgAGmAL8r9b6SaVUFTABcGqtn/+oJ2qt7wXuBZgxY4bUz2wnVq2Lx+MBsLMxsViM9evX09nZSWNjI6Wlpfa2qD/+8Y9s3LiRZ555xm4tPGPGDD772c8ybtw4KisraWhoYNy4cVRVVdn1L62trWzcuNH+e3NzM3fffTe33norF1xwAZFIBK/XSzabBSCXy9nDLD0ejz3g0ufzUSgUKCoqIhQK2c+DrW9c8Ek+X06nk1AoRE9PD6FQCLfbzfTp0wEoFAokk0l6enrsv1sZquXLl1NSUoLT6bSbHljvt9j1yC9fhBBCiKF2pgAmBxyqlGoAlgAvAKcope7SWt8+ukvbfWmtSafTeL1eUqkUGzdutOepVFVVAf2Zk1AoRElJCQ6Hg3vuuYe3336bZ555hlwuR3V1NbNmzeK0007joIMOsrMl0N96efO6j7KyMsrKypgwYYIdbAAcd9xxfPGLX2ThwoU0NDRQV1dHLpejo6ODtWvXUlVVRUVFhd0kIJFIkM1mcbvd1NTUMH78+C22LDZNE2Cb7cnaPMOz9957UygU7KGZhmHQ2tqKw+Ggq6uL9vZ2Ojo6+Mc//sGkSZM47LDDOPDAA6mqqqK4uHhbLUuMIfLLl9G1pRoX6K9zEUIIsePtTAHMa8B04KvAQ1rrHyul7gF+r5R6R2v9l9Fd3u7JqhPRWmOaJuvXr7dbF0N/oXxvby9vvPEGS5cu5cUXXySXy1FXV8c3v/lNvvSlL22z4vQjjjiC3/zmN5x88sk88MADFBcXM2nSJNrb2ykUChQKBfL5PC0tLVRVVdmDMq2ifdM0icVilJeXD9u2eFN9imPIA5/QwAyP1XFtwoQJrF+/HtM0cTqddkDT2dlJR0cH69evB2DFihW89tprRKNRjjnmGM4++2ymTJliNzTYHo0HhNjdbKnGRQghxOjZaQIYrfU7Sqk4cDLwd6VUYNN9iwHvRzxdbANWtmXgl2Mri+D1ekkkEng8Hnu+ypo1a3jllVd4/vnn+dvf/obP52PWrFlceumlTJ482T5vb2/vNlvjscceyyGHHMLbb7/Nf/7zH8aPH09tbS2GYVBSUkJ7ezuGYdjbxaA/yLLqYWKxGICdPRpo02stbLPFDsPpdNpF+TNmzGD8+PEkk0ncbjepVIra2lrWr1/PjTfeyB/+8AeeeeYZXn/9dRYuXMj06dM5//zzaWxspKGhQbIyQgghhNgljckARik1BSgDlgOm1roAoLX+nlIqB4wHrlBKJYGvAL8YtcXuJkzTpLW1lXw+D2C3GbYCGujPKJSVldHa2sqDDz7IX/7yF1atWkVtbS1z585l1qxZlJaWbve1XnDBBXzjG99g+fLl1NTUcMghhzB16lTcbrfdwSyfz9PW1obP56O5uZlsNsu4ceOIRqOUl5cPe95NHb3M7bl2v9/P3nvvTTqdJp/PU11dTUdHh71tbtWqVbS0tHDggQdy1llnkUgkWLZsGb/73e/405/+xBNPPEFlZSXHHHMM5513HkcfffQWt8UJIYQQQuxsxtw3G6XUacBcYMOm23Kl1K+01j0AWuv/UUrNBCYCU4EvaK1Xj9qCd0Jb0w55c9YXaqfTidvtpq+vj/Xr1+N0OjFNk76+PuLxOO+//z4333wzb7zxBjNmzGDhwoWcfPLJrF69mg8//HDIXISenh5eeOEFe/BkU1MThmFQXl5OOBwmGAwyYcIEKioqqKioIBqN2l/IDcOgoaFhyFqPOeYYSktLWb58OZ/73OdYt24dkUiEQqGA1+u159FYLZ2tYCybzdqF8dbcGmt72Y5qR2wYBsXFxRQXF9Pd3U1paSmGYTBhwgTa29sxTZOWlhaWLl3KFVdcwfvvv09VVRWzZ89m1qxZvPLKKzz77LMsXryYRx55hNraWk499VROPfVUpk6dOujf1spADUe2nwkhhBBirBpTAYxSqgg4E5iltX5RKfUl4CBgjlLqR1rrbgCt9V+BvyqlnFrr/CguebdhffH3er0YhkFzczNr1qwhGo3ancF+//vfM2/ePEzT5MEHH+SUU06xn7+pAJ5UKsWvf/1rVqxYwerVq+0tWwChUIj6+nq01nzwwQe89tprdhcxy4QJE7j99tuJRqMUCoVha2dcLhdnnXUW9957Lx6Ph66uLnsujCWXy9HS0mJ3OHM6neTzeft6sViMRCJhBw/BYHCbvp+bGy5gCIVClJaWUigUqKyspK6ujmQyyX777cef//xnrr32Wvr6+uznbty4kcrKSm688UbS6TTPP/88y5cv5+c//znz589n+vTp3H///XZ9khBCCCHEzmhMBTCbhIBJwIvAY0A7cAJwFnC3UuozQEFr/QbbuR5B9AceVsvhgfL5PJ2dnfZMlkcffZQHH3yQadOm8cADDzBx4sQh53rzzTe5+eabicViNDQ0sN9++9HY2IjD4WD69OmUlpYO+iKvtWbdunWUlZXR1tbGunXr+PnPf86FF17I7bffzpQpU0Zc93nnncfPfvYzFi9ezHHHHWfXllg1OqlUCr/fTy6XwzRNysvL6e3ttQM1v99PUVERnZ2dgwKfHckwDOrq6uysmFKKqqoq5s+fz7/+9S9aWlrsY//973/zne98h0wmwz777MOXv/xlZs6cyZVXXklHRwePP/44t9xyC6eddhq/+c1vqK6uHpXXJIQQQgjxaY2pMd1a6z5gHnCaUuowrbVJf7vkN4HDlVJe4FBg46bjpT3MdpZKpWhubqatrY1kMkkmkwH6i82VUrz77rvcdtttPPjgg5x77rk8/fTTQ4KXTCbDz372M2bPnm23UV60aBE33XQT55xzDnvttRdlZWVDshBKKbxeL/X19XzmM5/htNNO45577qGoqIjZs2fz8ssvj7juKVOmcNhhh/HCCy+QSCRYu3Ytb7zxBhs2bCCXyxGNRqmtrSWfz7NmzRpSqZT93N7eXntb3I7cPjYcp9NJRUUFJSUlHHTQQcycOZNzzjkHrTWPP/440B+8zJkzh/Lyci666CJaWlq44YYbuOCCC3j44YcJBoN84xvfYNGiRTQ3N3P66aezatWqUXtNQgghhBCfxpgKYDZZBjwFnKuUOlxrXdBaPwJUA9Va6x9rrVu2fArxSWmtSaVSQ7IOPp/PHkzZ19dHIpFg0aJFXHvttbz88sssWLCA+fPnD5rLorVm8eLFfOYzn+Ghhx7ipJNOsrM0n9SECRO47777iEaj/O///u8Wjz3llFP44IMPyOVybNy4kdbWVpRSlJeXEwwGiUQiGIZht4Jubm4mlUrh9XrtWp/i4uJRn3Lv9/uJRqNUV1czefJkvvrVr7Lnnnty88038+GHH7J48WKy2SwXX3wxX/nKV3j44Ye5/vrr8Xg8XHPNNRx++OEsWbKEAw88kF//+td0dHRwxBFHcPLJJ/PUU09Jm1ghhBBC7FTGXACjtc4Ci4B/AdcqpS5SSn0NqACSo7q4XYBpmqRSqWG/tGqticVibNy40c5I+P1+IpEIpmmydu1aVq9ezdKlSzn22GNZunQpX/3qV3nrrbc4++yzB53rtdde49hjj2XWrFmUlJQwf/58rr32Wrtj2acRDoeZOXMmsVhsSI3MQCtXriQUClFTU4PT6cTj8RAKhey2zV6vl1AoRFlZ2aAsi1KKcDiMy+UiHA6PagYGGNRIwDAM3G431157LYZhcNVVV3HCCScQjUb54Q9/yIoVK3A6nRx99NEsWLDAzsBcdtllHH744Tz33HMsXLiQb3/727z66qt87nOfY6+99uLuu+8eta1yQgghhBAfx1isgUFr3aWUug9YAVwMZIFztNaxLT9TfBQr2wBDWyGn02ni8TgtLS2Ew2FM0ySRSLBx40ZWrVqFy+XiL3/5C/fccw81NTW88sor7LfffgAkEgkAkskk3/ve91i4cCGRSIT58+dz9tln89577wHwwQcfsGjRIuLxOLlczu5eppSir6+PfD7P8ccfz+mnn77FTljRaBSA9evX09jYOOwxr7zyCv/1X/9lH9va2ko8HqekpIRUKkU6ncbtdhMMBgfVwABks1lM0ySbzY56BmZzFRUVHHzwwdx0001cd9113HrrrVx//fX85Cc/4Xvf+x733XefvSXv6KOP5qijjuIPf/gDDzzwAHfccQdaayZPnsyFF16Iz+fj97//PbNnz+Yf//gHv/zlL4cd4imEEEIIMVaMuQyMRWud01r/Dfgq8A2t9T9He007O9M0MU2TQCBgZ0KsoKW1tdUucM/n86TTaTKZDKtWreLJJ5/kP//5D3fccQd33XUXRx555KDgxfLiiy9yyCGHcP/993PZZZfx+uuvc+655+JwOEgmk9x5552cd955PPfcc3R0dNDb24vT6SQYDFJVVcXEiROJRCI8+OCDLFy4cItbm6ygZO3atcM+nkwmefvttwFoa2vD6XQSj8ft1sn5fJ7u7m67xsTpdA6qd7GyMwO3xI0VDoeDiooKDjjgAP77v/8bt9vNrbfeyqxZs0gmk/zoRz8a9N4ZhsGpp57KY489xj//+U/mzp1LeXk5c+fO5frrryeZTHL00Ufz8MP/j737jo6qTB84/r0302cymWRSJgXSICChiIuioKhrRQUJCNjYVRD9KcVVUdFdBcS2IE1FERQBFVFRLGDXVVFRxA4I0gMhfXrPZO7vD5y7iQlF10Lg/ZzjgWRmbu4dbo7vM+9TnmbIkCFqnZMgCIIgCMLh6LDcgWkqMcRS+GVaW/wHg0H8fj8Wi4VgMIjRaESv1xONRonFYtTU1KDRaEhKSiISieD3+6mqqsLr9bJy5UrWrVvHddddxz/+8Q98Pp+66xIOh7n66qv59NNPsdvtjB8/ng4dOrBixQri8Thr165l2bJlNDY2YrPZyMzMJCkpicbGRkKhEDqdjqKiIgByc3MJh8O8/PLLrF+/ntNPP520tLQW15LYJdizZw9JSUktHv/uu++Ix+P07NkTn89HcnIyOTk5ZGRkqAGaLMuYTCZCoRAmk0nd8ZEkCVmWsVgsv9m/x/+itRS25ORkSkpKcDgcFBUVceutt/LQQw8xbtw4Zs6cyfr16wmHw3z9dcu4PykpiY4dO9K3b182btzIxo0bee+990hPT2flypV06dKFb775hpSUlP2ek5gTIwiCIAjCn+WwD2CE/12iFbJOp0OWZeLxOH7/f8uJNBoNLpeLaDSK1+vF4/FQVVVFJBJhzZo1PP7444TDYebOncu5557b7NjffvstN998M9u2beOUU07hwgsvVFsu79q1i+XLl7Nz506MRiMOh+OgOxqSJPGXv/wFjUbDxo0bATj33HNbBCmJupX97cB88cUXABQXFxMKhbBYLPTu3RuTyUQ4HMZisWCz2YjH481S6uC/jQxMJtOfXv+yP7IsY7Va1XSw22+/nX//+98sXbqUM888k1tuuYVrr71W3alqTXJyMr1796Z379589dVXvPrqq6SlpVFeXs5f//pXVq1ahcPh+AOvShAEQRAE4eAOz9WZ8JsKhQiimQAAACAASURBVEJ4vV6cTqe6+2CxWNDr9cTjcTQaDVqtlvr6esLhMOnp6eTl5fHRRx8xbdo07HY7n3zyCWeeeaZ6zGg0ysyZMxk6dCiBQICRI0cybNgw9Ho9gUCApUuXMmPGDOrr67n88sspKCg45HQsSZI49thj6dGjB1u3bmX69OnqvJmERBrVgQKYkpIScnNzKSoqokOHDlitVnXhb7VaMZvNWCwWrFZrs+YCiTqhYDD4K97tP5bFYqG4uJhTTz2VK664AqfTiSzLpKSksGzZshbv2/4cd9xxDBs2DI/HQ0pKCj/88AOnnXbaft9fQRAEQRCEP4sIYI5QiW5j8XhcredIT09Ho9EQj8eRZZlIJKLuPlitVgwGA9FoFLfbzdVXX82UKVM477zz+Pjjj5sNjfT5fFxxxRXMnTuXsrIy3nzzTTp27AiA1+tlxowZfP7555x++unccccd9O7d+1elHJWWltK7d28+++wz3njjjWaPKYqCVqultra2xetqa2v5+OOPycjIUGtrTCYTdrudlJQUMjIymqWLmc3mZudnMplaBDWHK0mSSE5OprCwkAsuuIARI0bw9ttv069fP6qqqtTUvUPRpUsXLr/8cjXAraio4IQTTuD111//na9CEARBEATh0IkA5ggVCoVwu93qAt9sNqu7FjabDaPRiNFoRJZl/H4/JpOJaDTKggULKCsrY+3atdx///0899xzJCcnq8dN7Kh8+eWXzJgxg3//+9/q44FAgLlz5+LxeBg/fjxlZWUtdl2CwSA7d+48YPvjphKpY8ccc0yz769du5Y9e/ZQVlbW4jU333wzwWCQ888/n7S0NHQ6HTqdjmg0isViOWhamCRJh/S8w0k0GiUzM5M777yTSy+9lOXLl1NUVMT69et5+umnicVih3ScoqIiRo4cid1uJxgMEo/HueCCC5g6daqYFyMckQoKCpAkqdX/8vPz/+zTEwRBEFrRdlZowi+SGMYYi8XUrlKJXZlYLKbOeTGZTDidTu655x4GDx7Mu+++y5gxY9i4cSM33HBDs9qTyspKLr74YrZs2cK8efMYNGiQ+lgkEmHevHnU1NQwevRoiouLW5yTy+Vi586dBINBXC7XQa9BURQ2bNhASUmJusMD0NjYyNNPP01ubi4jRoxo9ppXX32VF198kUsvvZTs7Gz27Nmjdl/zeDyEw2Gqq6tb7Eok6l7a6iLdZDKRkpJCSkoK06ZN46qrrmL79u0UFhayceNGnnrqqUNOJ8vOzmbdunWMHj2auro60tLSmDRpEtdff72YFSMccXbt2oWiKK3+t3Pnzl993Pz8/P0GRgUFBb/Z+QuCIByNRBH/EUqWZTIyMgiFQhiNRhobG9m1axfRaJRoNIrZbCYzM5NFixYxbdo0KisrGTp0KFOmTGk1+Ni8eTOXXHIJPp+PxYsXc/zxx6uPhcNhlixZQnl5OaNGjaJz587NXtvQ0MDevXtxu91qobzP58PhcBwwtayqqgqPx8OVV17Z7Psffvghu3fvZuLEiWg0/72FnU4nN9xwAz169GDUqFFIkoTNZmP79u1qbUd9fb2aWte0wP3n83HamkQqnKIoyLLM9OnTWb9+PZ999hmFhYVs2rSJJUuWMGLECHQ63UGPZzabmTdvHueeey4jR47EbDbz8MMP43K5WLhw4SEdQxCOZgcKfkQXP0EQhP+NCGAOYwfaDVAUpdX/CTatfUm0CZYkidraWlwuF1qtltTUVHw+H7feeivz5s3j+OOPZ8mSJfTu3Ztdu3a1+B/vhg0bGDVqFLFYjBtuuAGfz8f7778PQCwW45FHHmH79u2UlpayY8cOduzYob42HA7z3Xff4fV6MRqNGAwGIpEIsViMvXv3otVqcTgcVFRUtLiW9evXYzAYKC0txe12A/uCoWeeeYaCggJ69OjRbCfllltuwel0Mnr0aAKBAO3btyccDuN0OpEkiZSUFHJzc6moqGhR35L4ui3UvRxI00Cmf//+yLLMp59+SkFBAVu2bOHJJ5/kiiuuUFP59ifR1hr2vSfV1dVIksQzzzzDqlWr2LZtG0lJSRgMhhapdmIQpiAIgiAIvycRwBxhQqEQ1dXV6pyXxNDKRKcxq9VKbW0tU6ZM4bXXXuPKK69k5syZaqrYz1OEPv/8c6699lpsNhuXXnopubm5atAQj8dZuHAh33//PVarFb/fz5YtW9TXhsNhamtr1UAsFAo1G5Lo8XgAaN++PSeeeGKzn+t2u/nwww85/fTTOe2009TvP/nkk9TX1zNjxgx69eql7pa8+eabPPfcc/Tv35/MzEwqKysJBoOkpqbSvn170tPTsVqtWCwWDAZDs7kv8N+6l7bmQHU6//znP7nsssu46667WLJkCaeccgqffvopq1atYsiQIQcM1l599VWi0SiRSISGhgY18FQUBbfbzcCBA5k/fz65ubltPugTBEEQBKFtETUwbcyBajXi8TixWAy9Xk9qaioGg4Hq6mp27NjB7t27aWxspLKykqlTp/Laa68xYcIEZs+e3eogSIC33nqLq666CofDwdKlS8nIyGh2Hs888wzr1q1j8ODBzRaxiqLg8/morq5GluVfNUvk66+/RpIkTjjhBPV7Pp+PRx99lD59+tC3b99mz7///vspLi7myiuvxGw2EwgESEpKIiUlha5du5KWlkYwGCQcDmM2m9tUgf6vJcsy7du357777mPixImsXr2a3r178/XXXzNnzhx1EGlCY2MjGzZsYMmSJTidTnw+Hw0NDSQlJTWbIwTw2WefcfHFF6s7Y4IgCIIgCH+UI38Vd4QJBoNqd7Gf75aEQiFqa2txOp1Eo1E0Go3abcxoNBKPx3nkkUd45ZVXuPfee7nzzjtbTUNTFIUZM2Ywfvx4OnfuzNNPP90iCHn55Zf55JNPOO+88zj77LObPRYIBHA6nRiNRrKzs39xvYTH4+Hbb7+lpKSk2TT4OXPm4HK5uOmmm5o9f82aNXzyySecccYZKIqCzWZTh2aazWai0ajaSvpQZ9EcKTQaDdnZ2dx7771MmzaNTz/9lGOPPZaamhpmz56tBiCNjY1MmTKFRx99lO+//x6dTofVaiUtLY2UlBQMBgPhcBiDwYDZbCYej7N582b++te/snXr1j/5KgVBEARBOJqIAKaNSaSDNe0uBv/dfTEajbRv357MzEwyMjIwmUxUVFQQi8WoqanhmWee4cYbb2Ts2LGtHl9RFB544AHmz5/P8OHDeeaZZ0hLS2v2nNWrV/PWW2/Rr18/BgwY0OIYiZa9GRkZv3inIxgM8vzzzwNwyimnqN9ftmwZixcvZsSIEXTv3l39vtPpZMSIEeTn59O9e3dCoRCFhYUcd9xxpKWlYbfb1XbRR8vOy/5MmDCBuXPn8sUXX5CVlYXb7WbWrFnU1dUhyzI9evQA9t1jer0enU6ndk1K7NJpNBoKCwvp378/0WiUyspKTjrpJJ577jm17bIgCIIgCMLv6ehdzbVRkiSRmZmpznJJSNS+VFVVUV1drXbUStShOJ1OHnvsMUwmE+PGjWv12IqiMHv2bB5//HEuueQSpkyZ0mL3ZOPGjTz77LOUlpYyfPjwVndwfm2HnYaGBpYvX47X6+Wiiy7CbrcD8NFHHzF58mROPfVUbr/99mbne9VVV7F3716mTJlCx44dKSkp4ZhjjqGxsZGKigpcLpcatDRtcBCPx/H7/Ufdgvvaa69l8eLF7N27l7S0NEKhELNmzaK6upohQ4bwj3/8A1mW8Xq9+Hw+9b0KBoNotVq0Wi2yLPP8888zZMgQQqEQJpOJESNGcO211+J0Ov/sSxQEQRAE4QgnApg2JFH/Avs+JZdlWV2U6/V6zGYzLpeLH374gc2bN1NbW4vBYCAjI4OqqipWrVrF6NGjW+yoJI49adIkFi1axCWXXMKkSZNaBCJVVVXMnz+f7Oxsrrrqqv3WzjQ95i+5tlWrVlFZWcmAAQPIy8sD9s2eGT9+PCUlJcyePbtZ2+Qnn3yS1157jXHjxlFWVobD4aBDhw7Isoxer8dut6tBEOwL8rxeL6FQSG2bHAwGD/kcjxSXX345I0eOpKamhuTkZBobG5k9ezY//PADHTp04LbbbsNoNBKJRHC5XLhcLhRFwWw2q/eETqfjqaeeYuTIkVRWVnLMMcfw7LPPcsYZZ/D111//yVd45JAk6WpJktZJkrQuMZRWEARBEI52ogvZn+yXtEpuOqsksfuSWJRbrVasVqtaq1JYWEhDQwPBYJB27drx9NNPI8sy48ePp7y8vFkqlaIozJw5k4ULF3L66adzzjnn8Pnnnzc7F4/Hw2OPPYaiKHTr1o3Vq1c3e7yhoYFIJAKg/un1etUg62DeffddNm/eTJ8+fcjJycHv9xMIBHjppZewWCw8+uijGAwGNT3tm2++Yfr06ZSVlTFmzBjKy8vxeDwEg0Hsdjt6vZ4OHTqQkpKivseJ98xoNKrv69HaQatHjx5cc801LFiwAKvVSlJSEnPnzuXMM89kwIABGAwGNBoNwWCQxsZG9Ho9kiTR2NhIMBhU2yzHYjGSk5P54Ycf0Gg0bN26lT59+jBlyhRGjx7dIgi22Wx/xuW2WYqizAfmA/Tq1attTlkVBEEQhN+YCGAOQ4qiqG2Qmy4AdTodoVCI9PR0tTYhUZwfj8fR6/WEQiFisRiBQACdTofX6yUSibBs2TIuu+wy2rVrx9atW9Xdk0TNy8KFC7nkkkvo27dvs10OgGg0ypw5cwiFQvTs2ZNIJKIGKQmyLKuLU4/HQygUwmazEQ6H1RqLY489lu7du7eoQ6msrOSNN95g6NChamOBYDDI3//+d2KxGCtXrmxW91JfX88tt9xCXl4exx9/PF6vl6qqKsxmM1qtlsbGRnQ6Henp6WqKU+L9SrRdbqttk3+JA6XyjRkzBoDBgwdTVlZGamoqgwcP5qWXXsLr9TJv3jxyc3OJxWIEg0GSk5PV45188smtHjMWi6HT6TjuuOO49dZbWb16NQ8++CCpqam//cUJgiAIgnDUEilkf7LW2iIndlqaFunDvoJ1j8fTrM5AlmVkWcbv9+NyucjMzCQnJ4esrCxSUlLQarU8+eSTRCIRJkyY0OLnz5w5U615aS1tLB6PM2/ePLZv305RURFWq/Wg15Q4RnV1NdXV1SQlJTFw4ECOPfbYFsHL3r17eeutt+jTpw+33347kiQRi8WYMGECP/74IzNmzGgWvMTjcUaNGkV1dTX9+/cnGAyya9cuPB4Pubm5dOzYkZycHDIyMgiHw0dtmtihKi0tZe7cuWqgeMUVV7B582ZGjhzJu+++i0ajwWq1qv+mB0sLbGxsZMuWLfzf//0fb731FmeffTZ79+79Iy5FEARBEISjRJsLYCRJ0v/Z5/Bbaq0Ww2QytdryNz09HYfDgcFgUHddEvUvVquV1NRUdWDl7t272bZtG19//TUvvfQSgwcPpqSkpNnxVq9ezfz58xk2bFirwQvAihUrWLt2LZdccskhf5KeOE44HCY1NZW8vLxW625cLhfvv/8+aWlpzJgxA61Wi6Io3HfffXz00UfcfvvtzTqRwb5Wym+88QZjx44lPz8frVZLXV2d2jUrOTkZs9ncbG6JwWA4pPM+Gtntds466yzWrVvH2WefzaJFi+jduzcFBQVMnjyZ6dOnq4NLFUXh1ltvPeDx2rVrh8lkYvHixUyePJmqqioGDhzIxo0bf1FNlCAIgiAIwv60qQBGkqS/AldJkvTLBoscxhLBStNajKapTomuWQBJSUlYLJZm3cacTifV1dW43W51aOVnn33G119/TW1tLU888QQNDQ3861//avZzw+EwU6ZMobCwkDvuuKPV4KWiooJXX32Vvn370r9//0O+JovFQk5Ojhq4tHZsv9/P22+/TVJSEhdddBHJyckAPPTQQzz33HOMHDmS4cOHN3vNpk2bmDRpEgMHDqRfv36YTCZSUlLIy8ujsLCQrKwsYF9dkNvtVndmxA7M/mk0GrKysnA4HOp8oHfeeQe9Xs+wYcN45ZVXmDp1qlp7FI1GD3g8nU7HO++8Q2FhIdOmTWPOnDnU19dz/vnn89Zbbx2Vnd8EQRAEQfhttZkARpKkc4HZwHeKohx4FdWG/DxYURSl2SR7t9tNKBRq1gI4MbDS7/cTi8WorKxkzZo17Nq1S62BcTqdTJ8+nTVr1rBw4UJKS0ub/dzHHnuM3bt3M2nSpFYHTcbjcRYvXoxer+eyyy77Ra2RE7U5en3rm2WRSIS3336baDTK2WefrQ6rXLZsGfPnz2fIkCHccMMNzV4TDAa54oorMJvNDBkyBIfDQUlJCaWlpTgcDrp06YIsy+qOVGuzchIURREL6Z9JtEq+9tprmTp1Kt988w0//vijmko2btw4qqurmT59+gGPk+h6t3TpUpKSkrjrrrtYtGgRDoeDyy+/nJkzZ6qd9ARBEARBEH6NNhHASJLUHXgWuEtRlNWSJNklSUqXJKnwEF9/2LcibZpKFgwGqa6uxufzodFoMBqNarcx2JdKZrfbyczMJDc3F41Gg8ViwW63U1JSQn5+PqtXr+bTTz9l8uTJDBkypNnP2rlzJwsWLGDAgAGcdNJJrZ7Pe++9x8aNG7nkkksOqe7lUHm9Xt555x28Xi9nnnmm2ub4gw8+4N5776Vfv34tdoQUReHqq6/mm2++4frrr6ekpITs7Gy1IUDiPUi8R5FIhIyMDHJzcykqKmpRrP9bt1BuC/fXwSTeO1mWuf7667njjjv4/vvvWbt2Lbfeeivbtm3jyiuvZM2aNYd0vPz8fJYvX47f72f06NE88MADnH322UyaNIl//OMfLZpACIIgCIIgHKq20oXMADwPOCRJ6gXcDVQDJ0mSdK+iKIsO9OLDuRVpay1+ATUdKtFBK1HHkdiBSRTDO51ObDYbsiwjSRK1tbV88sknrFy5kkGDBjF69Gjq6uqa/bxbb70VrVbLoEGD2LBhQ7Pz+eGHH3A6nTz//PO0a9cOrVbLJ598AuzbIWptRyNxXgdalNbW1rJx40a2b9+OLMuceOKJWK1W9Zhz5syhU6dO3HfffSiKQkNDA7BvN+e+++7jhRde4JprruG8885Dq9WqdS5arRan04lOp8NoNKq1Q7Isq2lpP5dI1/utWigfzvfXoWp6/8myzFlnnQXAPffcQywWY9asWcycObPZINH9ufHGG9W/n3rqqbz11luUlZVx0UUXccMNNzBr1iy+//575s6dS15ennovZ2Zm7veYv3Y4qiAIgiAIR542EcAoirJWkiQtMJR9wcvt7FswnggskyTpC0VRNhzoGIerxMIskUqWCFASQwObPg77FphZWVlqe9tYLEY8HkdRFPbu3ctXX33FjBkzOO6445g1a1aLYZMvv/wy33//PWPHjqVdu3YtzsflcvGf//wHWZY588wz0Wq16mPZ2dkUFra+6RWPx+nbt2+L73s8HlatWsWbb76JoigMHTqUkSNHkpGRAezrQnbFFVeQmZnJ66+/rs6xSVixYgVTpkzhtNNO45xzzmH79u106dJFfS8cDgexWIzq6mqys7MPqTXy0dBC+WB+HhAk6qsS+vTpw0knnURpaSkjRoxg0qRJzJ8/n/fff5/Zs2fTpUsXHn74YYqLi5sd529/+xvl5eUAaqrYscceyzfffMNzzz3HY489xvz587n++uspKyvjqaeeUv89BUEQBEEQDsVhn0ImSZIMoCjKJ8BzwChFUR4BGhVF+Rh4Ezhi8lGaTotP1L0kFugVFRUEAgH1E+tEHUdDQwPJycnIssyDDz6I3W5n0aJFLbqYeb1e7rzzToqLizn//PNb/fmbNm2isrKSfv36/U+LfJ/PxwsvvMDEiRP5z3/+w/nnn8/LL7/MrbfeqgYvXq+X8ePHE41Gefnll1sEL99++y1XXXUVvXv35rLLLmPPnj3U1tayfft2Nm3axO7du9VUsaysrKN2KOXvRZIkLrroIj7//HPsdjsDBw5EURQeffRRKisrueCCC3jxxRdbfW1VVRVr165l7dq1+P1+/vKXv5Cens7VV1+Ny+XilVdeIRQKcckll7Bp06Y/+MoEQRAEQWjLDssdGEmSOgFpwDpArbRWFGVNogOZoiiKJEnDgZ5A63lNbUhi5yWRKmY0GgkEAlRXV2M2m/H5fITD4WZ1G/F4nO3bt1NZWUk8Huehhx7C6XTy0UcftZqOM336dGpra7n55ptb7MzAvq5j33zzDYWFhXTu3PlXXUdDQwOvv/46b731FtFolN69ezNw4EDOOeecZs8LhUJMmDCB3bt38+ijj3LMMcc0e3zPnj1cdNFFpKamcvHFF+NyuUhNTSU5ORmNRkN9fT16vR5Zln/TGh2hpe7du7N27VpuvPFG5syZQ+fOnVmwYAEPPPAAN954I2vWrOHuu+9W791du3axdetWbDYbjY2NfPfdd3Tt2pXzzjuPiooKbr31Vm6//XZWrFjB0KFDGTJkCIsXL+aUU07BYrGIdDFBEARBEA7osNuBkSRpMPAK+1LFngDGSJJk/ekxSVGUqCRJGkmS/gb8E/iboigVf94Z/zYSOy/hcBiz2Ywsy2pnKJ1Oh9lsxm63Y7fb1Zkv4XAYl8uFy+Xi7bff5osvvuCJJ57g2GOPbfVnvPLKKwwYMIAOHTq0+nhlZSWNjY0kJSX9qpkdmzdvZtKkSbz66qt07dqVu+66i9GjR6v1PAn19fVcc801fPXVV0yePJm//OUvzR7/8ssvOeWUU3C73cyYMYPOnTuTmZmJxWKhtLSUlJQUjEYjNpvtqE8F+6MYjUYeeeQRlixZQnV1NWPGjOGee+5h/PjxvPDCCwwePFhNHauvrwcgLS0Nm82Goii4XC40Gg0LFy7kwgsv5P7770eSJFasWIFWq+Waa67h888/x+/3/5mXKQiCIAhCG3BYBTA/1bkMZ1+a2BnsC2TaAbdIkpSi/LSqVhQlBviAwW219iUhkSam0WgIBAJEo1F1SGUieHG5XGqxe0NDA0ajEbfbTSQSwe12k5GRwdq1a+nZsycXXXRRqz8nGo1SW1tLx44d93suvXr1omfPnmzdupV33nnnkNsMRyIRPv74Y6ZNm0Y8Huemm27iuuuuIycnp9nzFEXhww8/5O9//zvbtm1jxowZLebLLF++nLPOOgudTsfUqVPRaDR4vV6i0ag6sLNLly6UlpbSvn17NZ1O+P1JksRll13GokWLaGho4NJLL2Xw4MEsXLiQ3bt3c8EFF1BfX0/37t3JyMhg+/bt7N69m5ycHPW+02q13HvvvRiNRqZNm0ZxcTFLlizB6XTyz3/+k48//phdu3apwzMFQRAEQRB+7nBc/VmBxCp7BbAS0AGXAEiSdIIkSccoirJCUZStf9I5/mYSOy8VFRVUV1dTXl5OKBRSa2B0Oh1arRZZlrHb7Wo9TCQSIR6Pk5GRwbfffsuPP/7IzTffvN/0m+rqahRFaRFU/FxpaSknnXQSP/74I+++++5Bg5gdO3awfPlytmzZwrnnnsuUKVNaLcreuHEj11xzDTfeeCM6nY4FCxZw6qmnqo+7XC5GjRrFiBEj6NGjB4888ggdO3YkEokQDoex2+1YLBa1u5jD4UCjOSwzII9okiTRuXNn5s+fT0NDA8OHDyc3N5eVK1eSm5vL+vXrKS8vp2vXrhx33HH06tWLzp07Nws07XY7Y8aMYeXKlTzxxBN0796dRx99lHXr1vHkk0/y/vvvU1NT8ydepSAIgiAIh7PDagWoKEqDJEkzgXGSJG37aebLx0AucIEkSYuBvsCyP/VEf0OJQvv09HSMRiMGg4F4PI7RaCQlJQW9Xk9dXR3BYJCKigpkWcbj8WA0GtXA5sEHH+Skk07ivPPOU9scN22dDKiF0mazmcrKyv0OmfT7/RQXFxMMBvn222/ZvHkz2dnZ6HQ6IpEIe/bsQavVotPpqKqqYu/evdhsNk477TTOP/98tZYnob6+ntdee41169aRmprKLbfcwqBBg9BoNOqn7KtXr2b69OnU1dUxatQohgwZQkpKClqtVp1vY7FYCIfD+P1+AoGASB37E+n1erp168aCBQvU1taXX345jz/+OIMGDWLHjh14vV66dOmidrFTFIVQKMSHH34IQM+ePenVqxf/+te/8Hg8nHjiiUyePJlJkybR2NhI9+7dicViJCUlYTAYSEtLO+A5iboZQRAEQTh6HFYBzE9WA52AET/VvHwELJUk6WogR1GUWX/u6f22ZFnGbDYD+9oUBwIBdaBgIniJRqNUVlYC+3YqADQaDfF4nMmTJ2MwGFi8eHGzlsc/L2xPDMEsLi4mHA6TkpLS6vlccMEFanvl9evXs3TpUgKBgBo41NXVEYvFANDpdIwaNYqysjIkSeK4445Tj+PxeHjwwQd54oknkCSJiRMnMmHChGbn5XQ6ufHGG1m6dCndu3fnwgsv5IILLqChoYGkpCS0Wi25ubkYDAZkWcbpdAL7Fqsidez3daCAoH379gA4HA5WrlzJggULWLRoEa+88goTJ05Eq9UyceJEdu/ezdNPP03Pnj0BePHFF5ulhl133XXcfffdzJkzh7S0NMaOHcvWrVt56qmnSEtL48ILLyQjI6PVdt+CIAiCIBy9DrsARlGUsCRJzwAKcJskSZ3Z1yY5A2hzFb6JWhaTyXTQRXc8HleDA71eT319Pdu2bcPr9ZKZmYnX68Xn81FVVUVJSQlPPvkk33//PcuXLyc3N/eAx66qqgL2DcjctWvXIZ17165duffee9Wvt23bRkFBAZFIBL/fj16vV4dFNk01e/HFF7njjjtwu90MGzaMW265hW7dujU79muvvcaYMWOoq6tjyJAhnHjiiRiNRrxeL8nJyaSmppKVlYXBYKC+vp5YLKbuSondl8NDoqnC/PnzGTRoEA899BATJ06kQ4cOTJkyhblz59KvXz9GDH/LQAAAIABJREFUjx7Nv/71rxavNxgM3Hzzzdx5553cf//99O/fnwceeIBdu3axZMkS7HY75557rppOKYJWQRAEQRDgMAxgABRFcUmStADYCFwDhIHLFUWp/nPP7NAlApd4PK52VjrQwjsej1NbW4vH4wH27cwk2gYHg0HMZjNms1nt9PTVV1+xatUqxo0b16IQvjWVlZVqAPC/kCQJg8Ggtsxtyuv1MnHiRFasWMHxxx/PfffdR2lpabPn1NXVcdNNN/Hss8/SrVs37r//fjp27IiiKOh0OoxGI1arlaysLKLRKOFwmEAgQDweJzU1lczMTJEudBjq06cPycnJ9OnTh2effZbbb7+dk08+mT59+rBgwQKWL1/OhRdeyBlnnNHs3y8lJYVbbrmFyZMnM2zYMN58800WLVpEWVkZs2fPxmg0ctFFF1FbW0tGRoYIYgRBEARBODwDGABFUaLAfyRJ+mjfl8qhtcQ6TASDQbxeLxaLBavVetAhi6FQiFgshtlsJhQKEY1GiUaj5OfnI8sysixTW1tLTk4ORqOR+++/n9LSUu66665DPqdoNMqHH35Iamrq/3p5LWzdupXrrruOPXv2cPPNNzN+/PgWRfbV1dWcddZZbNu2jf79+zN8+HBycnKoqqoiEolgt9sxm81oNBpqa2sJBoNkZmaSlZUlPoE/DCXucQCbzUanTp1wOBwcf/zxPPXUU7z99tt89dVX3HXXXbz++ussXLiQTZs2MXr06GY1WBaLhdzcXDZv3szHH3/M+eefz4oVKxg8eDDTp08nIyODU089lVgspjZySLQaFwRBEATh6HPYBjAJiqK0yX6qiYDlUFLH4L/F/IlUrMQcGJPJRGZmJrIsU1lZicPhwGazsWXLFkaOHIlOpzuk8xk/fjxr1qxR03madgD7XyiKwqpVq3jsscfIzMzkpZde4oQTTmjxvETwUl5ezoIFC+jTpw8+n09tH50Y0un1elEUhaqqKnXOi8PhUB9rWjMk/Lma3uOSJJGZmUk0GqWkpISbbrqJU089lSVLlvCvf/2Lm266iZycHF588UUqKiq48cYb1fbfTzzxBOFwmHvuuUfdTbTZbCxdupTTTjuNOXPmoNPp6NixIxaLBY1GQ1FRkZq+KAiCIAjC0eWwD2DaKlmWW00Z+3lNTKJrl9FoxGw2qzsNidSzxM6M1+tVuzIFg0GCwSDFxcWHfD42m41nnnmGiy++mKlTp2K1WtXi6l8rEAgwZ84cVq9eTa9evVi0aBF2u73F82praxk2bBjl5eXMnDmTgQMHUldXp6aNHXPMMeh0OrV4v7y8HFmW1UYFifcLOOhOlvDHkSSpWTApSRJpaWnU19djNBr561//is1mIx6PM2PGDLp3787YsWN5/PHHueWWW7BardTW1lJYWMj48eP5+9//3uz4DoeDBQsWUFZWxvvvv48syxQWFrYYjCoIgiAIwtFF5GD8wYLBIG63m5qaGjV4qaurY8OGDUQiEbXew2g0qsXs0WgUp9OJx+MhFouxefNmAIqKin7Rz05LS2Pp0qVkZWUxceJEvvvuu191DdFolE8//ZRx48bxySefMGrUKCZNmrTf4GXIkCGUl5czYMAACgoK2LFjBx6Ph6SkJHX3JS0tjeLiYiRJwmKxkJ6eTufOnUlJSVE/4TebzaL+5TAnSRJGo5GkpCTi8TiFhYVMnTqVcePGsWHDBl544QXGjBlDRkYGdXV1lJWVMWXKlP12GjvllFO47bbbWLZsGQ8//DDbtm0jFArhdrvxeDyHPGxVEARBEIQjh9iB+QMoiqL+3WQy4ff7icViBINBjEYjPp+PvXv3qs8zGAzk5uZiMpnwer243W51Ie9wOPD5fMC+AKbpsZvaX2pZTk4OixYtYvTo0UycOJGnn366Wftjs9ncaiASiUTYsWMHixYt4vXXX8fn85GXl8ebb77JiSeeSGNjY4vUrurqaoYNG0ZFRQUXXnghJ598MlqtltraWsxmM+3bt8fpdKIoijonJC8vD5PJRHp6OklJSeh0OhG0HGYO9O9hNpsxGo2YTCZ0Oh1Op5O0tDRKS0sxGo0sXryYefPm8eSTTzJgwAC1Tmrr1q0tZhcljBgxgi+++IIPPviANWvWkJmZyfr16ykoKKCwsJDU1FRkWVYD3V9yvoIgCIIgtD0igPmDKIqipkJlZmY2S4sqKSnBZDKRkpJCfX29mkoWi8Wor6/H6XRiNBqRZZkdO3bwww8/oNFofvV8jIyMDJYtW8bQoUMZNGgQl112GZ06dcJqtaIoCnl5eSQnJ5OcnMyPP/7IypUrefvtt/H5fNhsNsrKyigrK6Nfv37NZs801bTmZdy4cfj9fiRJIikpSV20KopCenq6GqjV1dVRVFRERkaGmlYnCrXbnqbpkw6HQ90lufjii+nQoQPz589n6NCh3Hbbbfzzn/9staPdz4/3+OOP07dvX9577z30ej0OhwONRoPdbicSiai/S6I+ShAEQRCOfCKA+YP4/X6qq6vJyspqURuj0+koKioiHo9jMBiIxWJUV1erHbnS0tKIxWLU1NQQiUTYsmUL+fn5Lbp8/RIOh4Nly5Zx991388wzzxzwucnJyZxzzjmcc845lJWVHbRxwNatWxk8eDDl5eXceeeddOvWjQ0bNqjXkZubSzgcpr6+Ho1GgyzL1NXVUVdXpy5ME92txIK07Uu0E8/KyqJ///4UFxczZcoU7rvvPp599ln+/e9/07179wMew26389RTT3HWWWexa9cuFEWhS5cuaoe+SCRy0ECoLfppgO/V8N8BosIvV1BQsN/5V/n5+X/w2QiCIAj/KxHA/IYOdWhl0/azRqORYDCIXq8nEomoKWXBYBCbzUYwGCQQCLBnzx6qqqrUxdpvsZjJzc3l0UcfJRqN4vP58Hq97Nq1C0mS8Hq9eL1eHA4Hffv2RafTEY1GDxi8xGIxZs2axV133YVOp2PKlCn07NkTrVbLGWecoX4Sn+iqlqgDMplMFBQUkJycrKaOJd6bX/K+CoenxO5ILBajqqoKvV7P3LlzmTlzJuvWrWP48OEMGjSIu++++4D3V2K20IQJEzj++OPJycmhoKAAt9uN1WolGAwecZ3JFEWZD8wH6NWrV+v5osJBJYJeQRAE4cggApjfUNPA5Oe7LIn5FU27aJlMJoLBIE6nE5fLhUajITU1FYPBQDwex+VyNWurbLVayc7ORqfT/abFyzqdDrvdjt1ux2KxtFoDczA//PAD48ePZ926dQwaNIjzzjuPfv36YbfbCQQCRCIRYrGY2kktwWq1kpycTCgUwmw2E41G1aGdCa29ryKoaTsSKWWJ+UapqanodDq6devGtm3byM/P5+WXX6aqqoqHH34Yq9W632ONHj2ayZMns2fPHr755htg385ETk4O7dq1IxAI7LcWRhAEQRCEI4MIYH5DieDEYDDg9/ubLa5/3nI28Xej0UhDQwNut5tYLNYsLSwQCJCRkYHBYKCurk49RiQSIRgM/oFXtn+xWIzZs2dz//33Y7VaGTp0KBdeeCE9e/bEbrcjSRLhcJjKykp0Oh2dO3fGZDJRW1sL/Pd9iMfjWCwWddelqdZaKB8oWBQOT4l73Gw2k5OTQ9++ffH5fOzatYvq6mrefvtthg8fzoIFC8jLy2v1GBqNht69e1NVVYXb7WbLli3o9Xr69u2LLMsi9VAQBEEQjgKHFMBIkmQArgNOBhTgY+BRRVHCv+O5tTmJT5r9fv8vWlzb7Xb0ej0Gg4FoNEpaWpqaRmY0Gqmurqa2tpZ4PI7b7cZkMlFZWfl7X85Bbdiwgeuuu46vv/6asrIyBgwYQG5uLjk5OciyzM6dO2loaECj0VBTU4MsyxgMBjIzM2lsbESj0WAwGKitrSUWi2Gz2VrdTWltpo6YC9P2pKWlqX9qNBp69OiB1Wpl48aN7N27l6KiIhYvXszQoUOZN28ePXr0aPU4ffv2ZerUqSQlJdHY2IjRaGTNmjWUlJSQlZVFNBpVA2KxEyMIgiAIR55D3YFZAviAh376+hLgKWDo73FSbd3BFtdNh1eGQiG13gX2zVhxu93Avk+bXS4XLpcLg8FAXl4eBoOB5ORkNm/eTDQa3e85RCKR/T4WDof3+9pIJEJDQ0OrjzU0NBCPx4lEIsyaNYsZM2aQkpLC+PHjGThwIEVFRcRiMfx+PzU1NUiShNVqRaPR4HA4KC8vZ8+ePWo6nE6nw+VyEYvF1OGdiUGeB7O/QaHC4Uuj0ZCZmal+LcsyDoeDjIwM1qxZQzweZ8yYMTz11FNcfvnljBgxgquuuorU1FT8fr/6up49e6IoCkajEbvdjslkYvXq1ezdu5dOnTpRWFiIyWTCarVit9sP2OxCBDiCIAiC0PYcagDTSVGUph+H/keSpG9/jxM6EuxvcZ0IXOLxOH6/X61jsVgs6PV6QqEQJpNJHWSpKIpaM1BcXEx2djbhcBiNRqPm+u/PgYqh95eqBft2g/bXzUlRFL766iuuvvpqNm7cyPDhwykqKsJgMFBTU0NxcTHxeJyUlBQAsrOz8fl8aLVa7HY7BQUFxONxdSEbjUYxGAyEw2H1PRGByZGrae0ToAbvVquVM844A6PRSG5uLl27dmX69Ok88cQTPP/880yYMIGRI0eqBfonnXQSWq2Wbdu2EQgEaGhoQKvV0rFjR3Uwqs1mw+v1YjQaD1hTIwiCIAhC23OoAczXkiSdqCjKZwCSJPUGPvn9TuvIFAqF8Hq9WCwWrFarumi3Wq1EIhF1Ae/z+QgEAmrAY7fbyc3NpaKiAo/HQzQaVQOgP6qA3efzceedd/LYY4+Rl5fH2LFj6dixIyaTieTkZBwOB4FAALfbrTYhqK2tJSUlBZ1OR3p6uhqoeL1enE4nmZmZSJKkDve0WCwiJewo0nSnUpIk+vXrp6YTRiIR5s2bR05ODnfeeScPPvggN910EyNHjsRoNHLcccehKIraHGLv3r0YDAZcLheRSERNVwsEApjNZsLhsCjuFwRBEIQjxAEDGEmSvmdfzYsW+JskSeU/fZ0PbPz9T+/Iktj1SAxobGxsVFsoJybR5+bmqrswTqeTnTt34vP58Hg8mEwm6uvrCYVCAKxevZpTTz31dz/v9evXM2TIEHbv3s3ll1/OmDFj8Hg8+P1+CgoKKC4u5scff8RgMBAIBIjFYlitVmRZRqPRqIMpE8GbRqMhFosRDAYxm80Eg0E1kBMdxY4eTXfbFEVBo9GQnZ1NPB7nrLPOorGxkc8++4wePXpgs9m47bbbeOyxx1i2bBkWi4WPPvqIrl27IkmSOjtJq9VSVFRETU0NJpMJnU5HXV2dutspivsFQRAEoe072A7MBX/IWRwlZFlutoBK7EhEIhHcbjfbt29Hr9eTm5tLPB6nvLwcWZbZu3cvtbW1pKenk5KSQo8ePdizZw8XXHABs2bN4qqrrvrdzvmdd97hsssuw2KxMG3aNM4880wsFgvZ2dk4nU7S09Oprq6mpqYGi8VCYWGh2mnK5XI1mwEC+z5tt1gsagvkxPea/ikc3RKBb5cuXUhPT1d3KxVFYePGjZx44okApKeno9FoMJlM5ObmEo1Gqaur4+OPP2bHjh0UFhZSWFhI9+7dMZlM4v4SBEEQhCPEAQMYRVFaH10s/GJNC/cTuy9erxeTyYTRaFQL9xNCoRAWi4Xc3Fw6derEBx98AOxbtJWVlXH88cezZMkSxo4dy3fffccDDzxwwLqXX2rz5s0899xzTJs2jdLSUv72t79x7LHHkpOTQywWQ6/Xqzsp8Xgcq9VKIBCgoKBAnVMTiUSQZZlQKKS2TQ6Hwy3mvEiSJOpehGbsdjvxeBytVkv79u3VejCNRsPw4cOZPn06DodDTQmTZRm73U4sFiMlJYXGxkZ27Nihzh7q3r07FosFRVHU4FmkkwmCIAhC2yTmwPyOEsMWE93GvF6vWrfi9XqpqqrC4XCoRe0ajUYdIqnT6dQ5MGazmY4dO+LxeDCbzWqK2bhx4wCYP38+H3zwAXPnzuXkk0/+VQuzeDzOl19+yYoVK3jjjTfYvHkzAAMHDlTTdDQaDVqtFq/XSzAYxG63U19fTywWo7GxkfLychoaGujWrRtmsxmNRqOmzWVkZBAMBvfbIEAQmkqkk+l0OiorK/H5fLhcLiRJ4ssvv6RTp07IskxDQwORSITdu3eTnp5Oeno6JpNJ3fHbsWMHfr+fjIwMdZBsoqOZSCcTBEEQhLZJBDC/EUVRWnwvGAzidrvx+/3qlPtE8b3JZCIlJQWDwYDb7VZnpFRWVqothQOBAIqi0NDQgF6vV4OH8vJy9Ho9KSkpjB07lh49evDiiy9y1lln0bVrV/7v//6PwYMH7zdlJnE8n8/H559/zqpVq1i1ahV79+4lKSmJfv36ceqpp9K5c2e1o1N2djbp6ekA6q6RLMsoiqIGWnq9no4dO2I0GtXi/ASNRkM8Hqeurq5ZK90E8Wn40a2135/EbklaWhpWq1VtaJHYuQwEAgQCAZKTkwmHwxQVFZGUlKQGNomA+YcffsBms2Gz2dSW3Ym6swMR96Twe8nPz9/v/ZWfn8/OnTv/2BMSBEFoY9pUACNJ0plADFitKErjn30+rWmaopL4tDfRVQn2dfNKTk5Wdyc0Gg0ajQa328369eupqKggNTWVzp07I0kSDQ0Nak0JoLYhBtBqtdTW1lJSUsKkSZN47733+Pbbbxk7dix33HEHV155JVdffTVFRUUA1NfX88knn/DRRx/x6aef8vXXX6uDAM855xxSU1M5++yzMRgMhEIhbDYbkUiEgoIC0tPT1dqVeDyOJEn4fD41aAmHw2pAlijE3997kfjez1N5EjtWJpNJFPMfZVpbzAWDQWpqaqipqSEvL4927dqxevVqKisraWhowO/3U19fjyzL6HQ6nE4nXq+X1NRUTCYT+fn5GI1GkpKScLvdbNmyBYPBQENDAz169CAej5Oeno4syyKtTPhDHShAEfegIAjCwbWZAEaSJC1wHxAFJkiS9IWiKLE/+bRaCAaDeL1eYF+KSnp6OnV1dWo3JPhvsXqibbDZbCYWi6EoClqtFqPRiMlkIjMzk5qaGrXFsE6nIxaL0bFjR3bv3o3T6aShoUENdHr37s2ZZ57J9u3bWb9+PXPmzGHWrFmcfvrpVFVVsXHjvsZxer2eE044gZNPPpm8vDxKSkpo37692n42MUzT4/FwwgknkJmZqaaAud1udaBleXk5SUlJlJaWkpWVpc6xSfD7/VRWVqptltPT06mpqVGHXf48lafpeydqYoTE70BFRQWhUIj8/Hw0Gg2bNm2ioqKCyspKtVYsFArh8XjUWjNFUdi2bRsFBQX4fD40Gg0bN25stgOj0WiIRqPqHBkQaWWCIAiC0Ba0mQCGfTsvnwHdgX8CDwAfSJIkKQfJBZEk6WrgaoD27dv/rieZWMDrdDqqq6vR6XT4fD51ynxKSopaA5PooJSYTJ+fn09+fj6wbzGf2Gnx+XwYDAaCwSCSJFFeXo7X68XtduNwOCgoKKC8vJxAIIAsy+Tl5VFcXMyJJ57Iiy++yJ49eygsLKRbt26UlpaSn5/Ppk2byMjIIBwOE4lEKC4uxufzYTQa1bktjY2NSJJETU2Nem0ej4fGxkZSU1NJTk5WF36SJLW6+Eu0fE4ME0yk/WRlZWG1WpsFPG21G9kfeX8dTSRJwmazUVJSglarpV27duTl5dGtWzfeeecdGhsbaWxsRKvV4nK5CIVC6g6gwWDAZDKpKZxJSUnqvdiuXTs1hczn81FfX092dnabu+8EQRAE4WjVZgIYRVEUSZJeB1awbw7NDZIkdQeSJEl68EApZYqizAfmA/Tq1evAie+/kbq6OqqqqkhOTlaDF6vVqhb0y7JMLBYjHA6rhe45OTkA7N27F5fLpdaKJHYsErsg8XicXbt2qR2WrFYrHTt2BMDr9fLdd9+h0Who3749gwYNQlEUjEYjNpuNnJwc6urqaN++PRkZGUQiEerr6wEoKipCkiRqa2vRarWEw2EqKirIzs7G7/erzQQqKirUwEuWZaLRKNu3b6d9+/ZqQAP7dlES6WuJxWFWVpb62M9TJZrOBWlL/oz762hhsVjUgCMSiWA0GonFYrRv355gMKjWi3k8HjVdLJHOaDab0Wq1NDQ0kJeXh9PpBCA7OxuDwaAW+huNRvV3NCkp6c+8XEEQBEEQDkGbCWB+ogBjFUUZLEnS8cAs4M7DqR4mkQZlMpnIyckhLS0Np9Oppq5EIhG8Xq+665KoN0kMctRqtUQiEVJSUtRdDa/Xi9frVYvpf/zxR2w2G3V1dTQ0NOByuXA4HOj1evx+P+3atVNTwaLRKD/++CM6nU5NNdNoNOTl5VFQUICiKOrjJpNJTSOz2Wxs2rRJTXGTZVmtuUksFh0OB7FYjDVr1hCJRJAkiaKioma1L8nJyc3en59/LQgHkvgdCAQCanqhLMsYjUbsdjupqalotVri8ThGoxG/309tbS1Wq1VNd7RaraSmpqLX6/F4PNTV1fHNN9+Qk5Ojpmkm2i8nAmxBEARBEA5fbSKAaZIm9i7QW5Kkk4AzgCeAv0qS9B9FUT79I87lYIXmTdOgUlJSANR2wzqdjnA4DOxLC0sUsic+Cdbr9WpbYqPRSE1NDR6Ph3A4rE6rdzqdRKNRbDYbBQUFVFRUoNPp1JqSxO5OUlIShYWFeDwejj32WAKBgFpnA/s+2bbZbMC+oKK+vh6z2Ux1dTV6vZ68vDw6d+6snlsi6Ers+iQmmzudTgwGA0ajkdzcXKBlHZAg/K8Su5SJP61WK5IkkZycjMlkori4GLfbjdvtJiUlhbS0NHXHsrq6mq+++gqDwaAG/tFolO7du+Pz+fD7/WoDCkVRRBG1IAiCIBzmDssARpKkTkAasA6IK4rS+FMQE5MkqTcwCbhQUZTXJEkaA+z5vc8psfDf3+K8aRlOIohJfK++vp5oNMru3bvR6/Vq6lUwGFQDk4S0tDTi8bhaAF9ZWYlGo8FsNhOJRNQcf6PRyN69e4nH4+pgyUgkQiAQwGQy0dDQgMfjQa/XYzQaycvLIxAIYDabqaiowO/3I0kSdrudrKwsqqur8Xg8ao2KxWLBarU2G1SZCHgsFoua6qXT6cjMzCQlJYVYLKbu5CTeh8R7IBaFwv9CluVmv2+ZmZnU1dXh8/lwu91YrVaSk5MJhUL4fD4ikQhJSUnqhweNjY1YLBbS0tLYuXMnPp+P7du3U1xcjM1mw2g0NqtLA3HPCoIgCMLh6rALYCRJGgzcC1T89N86SZIWKYri/ekpw4BOiqJ8CaAoytw/8vz2V2jedLHTNIUqscMSiUSIxWJqjUhiQGWi8Li6uprKykp10KVOpyM7OxuLxUJjY6PadlmWZerq6vB4PGoHskSNTENDA9XV1XTs2JGGhga8Xi+1tbXodDpkWSYnJ0dtN2uxWNQWsokdFJvNRnp6OkajEYvFou4wJf70+/1q8NW0AUFOTg7hcLhZG9qf77yIxaBwIL/0/rBarXTt2hW32813332H3+/H4XDQq1cvnE4nW7duxe12Y7FY0Ov1AOrA2FAoRH19PX6/H0VRyMzMxOPxqDVq4l4VBEEQhMPbYRXA/NQqeTgwSlGUTyRJGgKcCNwiSdJ0RVE8iqL4gS9/er6sKEr8tzyHWCxGXV0d6enpahewn52jujhvGqgAzYKWxC5N05bJtbW1RCIRnE4n8XicTp06NStar62tpbKyknA4TEZGBhaLRS1a1mg0agqay+UiNzdXfU48Hqe+vl79uYmuS4nXxWIxamtrycjIID09ndzcXLX17O7duwkGgzgcDrKysjCZTCQl/T97bxojyZbd9/1v7kvkUrnW0rV0V79+2ww5HDZJmQIJ0gIsSpT9gRRFkBhCMmm8gUTQgA2DBuEP/mCbgCFo+JV4tAkKMklBHzggbEgyIGDAGY4Nmj3iDGf45m1dXdXVteS+R+5x/aHq3HczKjIrqyurMrPq/IBCd2ZkRtyMuDfinnvO+R+3yjmgPJ18Po9QKATDMNDpdJQqGhkt+jkhj5JToj7DzAqXy4VMJgOXy6Xkup88eYJMJoNOp4NyuYxcLqc8L1RINRAIYGtrC4lEAuFwGB9//LGqd0QyzOTR5JpEDMMwDLN4LJQBc04UwBsAvokzxbEigJ8F8EsAflcI8RTAQEr57VkbL8CZetjx8TEAYHV1deJndUMFwIjRQqpG9FpKqYyQUqmEV69ewTRNvP322wDOVpSj0SiOj49xdHQE0zSRTqeRyWQQj8dVEUiK0adE+2azCcuyIKXEysoKHj58iM997nMAzoyxZDKJFy9ewO12w+PxKO+Ox+NBoVBQtVu2trbQ7/fVb9FzDgqFAo6Pj7GysoJoNHohqVr3tlDOAXAx7IdhZgWNvXa7jW63qxL1TdNEq9XCgwcPIKVEpVJRMszf/e53USwW8fjxYwQCATx48AB/9Vd/hUKhAI/Hg8PDQ/h8PgBQ6mYA1yRiGIZhmEVjoQwYKWVfCPEVAL8hhHgupfyGEOLPAWwA+AdCiH8J4CcA/PFNtSGVSo38OwmncLJAIKAS6ikcjJLzk8kkXC4Xnjx5Ap/PB7/fj1AoNBIetrq6qnJmut0uLMvC4eEhWq0WLMtCOBzG2toaPB4Pms0mPvzwQyX/Go/HVSJ9NptV8sbBYFCFzwwGAxwfH2NnZwd+vx/JZFIpm0UiERVC1m63VZtSqRRarRa8Xi9M00Q4HB4bShcKhZSSE9fVYG4K6lsUBpnJZLC7u4tKpYJEIqFCI7/3ve+h1WqpkMp2u41Xr14p9b9QKKQMcyoU6/F4lIof92GGYRiGWTwWyoA55xsA3gTwK+eJ+18H8EfnxQLXpZS/c5MH93g8l3peCHvxRvJM5HI5VbQyFAohn88rrw6FYD1+/FhNsvTaE5FIBG+//TYODg4O9JqMAAAgAElEQVRUwr7f74ff7x9RQCsWi4jFYirhf3NzE8lkErVaDe12GwcHB+j1eiiVSvD7/fihH/ohBINBfOtb38Lp6SkMw8D6+jrW1tbw8uVLHB0dYWNjAxsbGygUCiM1MjqdDjY2NpTimf7bpZRKOEAIoZShGOYm0WsGBYNB5fXc3NxEvV5HLpdTiwGdTgfb29swDAOffvopLMvCxx9/jGw2q9TzKLST+nW73cb29rYKH7tMfZBhGIZhmNtj4QwYKWVHCPGHOKv58ltCiLcAdAGkATQnfvkW0PNehBAXXuseCMoBSSaTAKA8MACUd0NXLwPOJmadTgfNZhORSATZbBYul0uFkL148QJbW1totVoIBAJqEreysqJWkA8ODuB2u1UCcyQSwWAwQKVSQb/fV3KxrVYL0WgUDx48AAA8ePBAiQ1QCE2r1VLyzLVaDeFweKRWxiTJZPu5YZibgMZXPB5HtVpVHpiVlRX0ej185zvfgWVZ8Pv9yGazaDQaCIfD6PV6WFlZQb/fR6vVQqlUQrfbRTqdVrVlstksDMMY6eccUsYwDMMw82XhDBgAkFJWhBC/B+ADAF8G0AHwJSllbr4tuzhhH5ewT0gp4XK5kE6nVViWLrNMcfaUGO9yuRAKhRCNRpFIJNBut1U+TblcVnVeUqkUMpkMVldXVb4M7cfv96NYLCIUCuELX/gCLMtS4TC7u7sqD8fr9SoJ5nQ6rSqdx+Nx5dkhOeVUKoVwODwSWkftNwzDMdSGJ33MbeDxeJQU+MnJCQAoI3tzcxMnJydKEINCzqjIrN/vRzQaxeHhIbrdrsoT6/V6ePXqFWq1Gp48eYJQKIRms3nrtWLOPc/vAcDW1tatHHNZ2dnZwcHBgeO27e3tW24NwzAMc5MspAEDAFLKHoCvCSG+fvZy9gn7V4EmLHruB3lcgDOPCqkcpVKpkbAwYLynQgihQrbi8TjC4TAikQh2d3dhWZYKR/N6vWq1+OHDhwgEAiNKYK1WCy6XC1tbWzBNEw8ePFBJ9IVCAc+fP4dhGHj48CEKhQJyuRyGwyEePHiAWCyGRqMBAFhbW1OhYWRM0W/PZrMjEzfyzkSj0UuLejLMTUF9Us9fE0Iow51CwSgc0+PxKGOg0Wjg8PAQhUJByZV7vV4EAgGcnp6qcdzpdGBZFjqdzq0KU0gp3wfwPgA8ffpUXvLxe83BwcEFjzbDMAxzN1lYA4aQUg7n3QYdPfZefy2lRC6XU7kuepgVMH4y3263VeJwMBjEcDhURhDth7w0VC08Go3C4/HANE2cnJygVCohEAggEokoA0RPwk8mk+j1ejBNE9VqVSX8e71eRCIRJTEbCoWU+pg9v8eJywwU+7limJtEz1+zLAv5fB6DwQCBQEDldFEOF/X3UqmEcDisRDVWVlawsrKCeDwOIYQydAKBAIDP1PkYhmEYhpkfC2/AzAt70q5TEq/+nhDigoIZ1ZQgQ8KpfowuV+xyuUaMoEwmg0gkoiSLqcp4uVxGJpNBMBhEOBxGo9FAKpVSFcXb7Taq1SqazSbS6bSSbz48PES73cba2ho+97nPodPpqM8DZwYHKTPZQ2T0NusFLtlAYRYNMl56vR58Ph/W19dhmqbadnJyomo89ft9dDodrKyswOPxIJlMYjAYoFqtKq9NvV5XYZqcwM8wDMMw84cNGAf01VsAY5N47WFhbrd7xPPSbrcdw8aazSZyuZxKENa3Ock4k5HjlIficrkQiUQQj8eV+hfVtIhEIggEAvB4PKpGDOXZkByyy+VS+7csa6S9utHC+SzMsmCapvJqksFNY6PRaKDb7Srjm7yaJG5BdZO63S5evXqFlZUVRCIRvHz5ErVaDbu7uxfCQxmGYRiGuV14OdEB+wQIgEqs18OlnN7TodCVw8NDVCqVqeKzyQhyu91KBYz2VS6XkUgkVDw+JfjT5IxCzY6OjpDL5ZDL5VCv1/H8+XPlefH5fMjlctjb21P7Ju9QOBwe+T3NZhMnJydoNpuX/laGWRRCoRDi8TgMw0Cz2VTeFwBKPrxUKsHn8yGZTKLRaGBzcxNra2s4OjpCu92GlBJ+vx/5fB57e3v43ve+h+fPn6NYLM7xlzEMwzAMA7AHxhHdaJkULqW/pxsnunHx6tUrvHz5EltbW/iBH/gBhMPhkf1QYjCFkNF3KeTL6/UikUig2Wzi+PgYrVZLJSJT2BgphpEhsrm5CcuykEwm0Ww2kc/nkUwmEYvFEAwGx9ZpIW8MeV10KCeG5ZCZRYfGJRWS1fuyEAKnp6fY399HJBJBMplUoaC1Wg25XA7FYhE/9VM/hUgkgmq1inw+j3a7jXA4jEQiMcdfxjAMwzAMwAaMI5NyOwaDgUqypzh6OxQ6ZhgG3nrrLSSTSaTTaTWREkKMxNaT5yQYDCpFsm63i0qlgpWVFQSDQZVEnEgkUC6XMRgMYJqmmqDpoWBerxePHj1Cu92GYRgjOTlUtTwajTomJOthb4ZhXJgA2uECf8yioued6Tx58gSDwUAJWFDtJZJN9vv9ODw8xMbGBlKpFAzDgNfrVbVjqEYM93uGYRiGmQ9swEwJeViKxeKI0phTsUa71HI8Hh8JY9E/EwgE0Ol0VJ5Jr9dDt9tVhksmk1ETJMqvyWQyyvChZGMyuHTvD9VxWVtbw2AwUAn6dLzLpI+nSdLX83mi0ejVTyzD3CBOHsNAIID19XUcHh6iXq/jrbfeUnkv29vbkFIiFAqp16FQaMRbQ2OMhDL0McowDMMwzM3DBswVsSfZO9V3oXArqnZPxsS4zxBULK/dbqNSqWBtbU0lDNsNpVAopN6r1WpoNBqIxWJqH2SAkOeG9m9PxrevJLOyGHMfSKVSyOfzME0TH374IQzDwM7ODra2tuByubC/v6/y1zqdDiqVivJgrq2tqfwa8oTymGEYhmGY24MNmDGMCxGxK41NqoVCxgJVs6fPjFP3CofDyGQyjvt0MpRcLhfS6TQCgQAKhQJ6vZ5KtqeV4nK5DMuyEI1GRwpv0r/XVRebJsyMYRYNj8eDt956SxkvUsqRsNCdnR0l5tFoNJSx4vP5kM1mVSimU74YwzAMwzA3CxswY5h2Yj+p4KM9lMxp34FAAM1mEz6fD61WS4Wr6EgpYVkWDMO4MFlyuVyqCCapplGIGIALicz2ZPzLilFeBntsmGWl1+shkUgoQYxOp4PBYIBCoYBsNotsNotWq6XyyHq9Hl69eoV6vY5oNMp9n2EYhmHmBBswY7jOxF73sDgVr9T3Tbks5CkBcMEgMk0TzWZT5Zi0Wi0Eg0FlhOjFMCk2n4wZ0zSV98UJnoQx9xX7AkMoFMLp6akahxRSSWIZ/X4fpmmiWCwikUiM5J1xQj/DMAzD3B731oC5TE3sOhN78rDo3g97CBgZKU7J/HbsBo9TKBn9PxgMqnAXACp0zUlsgGHuM+SNHA6HKBaLCAQCsCwLsVhMjadAIIBut4terwcA2N3dHVEUBM7GOyf0MwzDMMztcW8NGF1NbHV1dab7DoVCKnGfVnMneXRoskRJ/Y1GA8BZ6JoQYiTh37IstX8ykHQoL4YUx4QQkFIin88ro2ZcyNu08Iozc5ege8Hq6qrycuoCHCSbvLKygk6nc+H7JJxBCf200MDjg2EYhmFuhntnwNDE364mNkuozotlWSqUi0JUnLwguhKZaZrI5XIAMOK9oX+pYKUe5qKHk9Hx7Spog8FAteW6XDfxn2EWBSklAoEAVldXkclk0Ol0UK/X0Ww20Wq1kE6n4fP54HK5UKvVcHR0pAQAer0eUqkU3G73SEI/jw+GYRiGuVnunQEzHA6V7OlVPC+XhV3pRgjwmRdGZ5zksv17pHJmnwyR8eHz+VTOjF2eWW9vq9VSKmjxeHxmK8LXTfxnmEWAxgjliekG/mAwQKvVGlEb83g8qNVqKtG/1WoBOKvPpIt58PhgGIZhmJvl3hkwbrf72hOLaUKoyAtTr9dVjso0ExshxIgKmT3ROBwOK68KMRgMIKV0NIbo31mGsnDiP3NXsI9J6ttO3tN8Po9gMIhut4t0Oo1IJIJAIKDGnp5nxuODYRiGYW6Oe2fAkLLQdZgmRMRJ+niS5PI4nL6jSyS3Wi20Wi14PJ4Ln7MbGpy7wjCjjDPG7eOOasJEIhHEYjFEo1H4fD7U63U19sbdF3jcMQzDMMxsuXcGzCyYxpOiSx9fRfVrGrUwvSClvU2T4Nh8hnk99EWDZrM5ohgYCATQarUQCARGPkvwuGMYhmGY2bJUBowQ4ocAuABIKeV/nFc7pgmhcjJypjFOnPJkxkH7clJGmrZNDMOMx17TSUqpxDX0kM5yuYx+v4/t7e2JoZwMwzAMw1yfpYlnEEL8DID/A8AvAPhXQogfm3OTRhgOh8jlchgOhwAuVrwnKeNqtQrTNMfuJxQKqdotBKmJ2dXK6vU6isUi6vX6xH0SuuGlSzwzDOMMjTMaX7qaYL/fRy6Xg8fjQbVaRblcRrFYnHOLGYZhGObusxQeGCHEUwD/AsA/lVJ+XQgxBGAJIZJSytIU338PwHsAsLW1dSNt1OvKkIqYDsXQXyZlbI+9H1fDxV4LhopV6vsZB4e0zJbb6F/MfHDyntD4abfbqNVqaLVaiMfj6Pf7F2TZB4MBDg4O4PV6AfB4uy47Ozs4ODhw3La9vX3LrWEYhmHmxVIYMADCAH5VSvkXQog1AL8OYBPAjhDi96WUfzDpy1LK9wG8DwBPnz6Vkz77uuh1ZZyMB7si2LSJva1Wa8Tw0fftcrku5NlIKZW0smEYjvvmkJbZchv9i7ldaDwJIS4YHTRuUqkUwuEwEokETNN09IIWi0VUKhWsrKyMjDdO7H89Dg4OLkjWMwzDMPePpTBgpJR/BgBCCC+AXwbwm1LK94UQfxvAnwghviWl/O6sj3uVSYbH45lYV8aeNzOtF2SSFPK41WG9EKbTvlkGmWFeH5JFB6BqxJimidPTU7hcrhEPrL6woY9f9oIyDMMwzOuzFAYMIaXsn3tcKkIIl5Tym0KIPwXQu4njzWqS4WQITesFmWRsjJNY1gthMgxzc9A9IhQKYXV1daQuDDB+YYO9oAzDMAzz+iykASOEeBNAAsAzAJaUciiEcEsph1LKCgBIKS0hxD8C8EUAzZtox6wmGU6G0DjD5LqhJVQI8yrSzbM4LsPcR+we0lwuB5fLhWg0OvY7VxlrnF/FMAzDMBdZuJmqEOLnAPwpgP8ZwP8O4NeFENFzI8Z1/pmwEOLLAP4HAP9YSnl0E20hI+OqE3qqFUEqX07KYuOwqx5dBVIrGw6HV1YZu85xGea+YlcbBEbHv/1eYFnWVGqEhJTyfSnlUynl03Q6fWO/g1kcSIrb6W9nZ2fezWMYhlkIFsoDc57j8osAfu08POznAfwtAL8phPjnUsoaAEgpW0KIOoB/KKX8ZI5NdsTucblKzslVvD72ujJ0XH3CdBPHZRjmIuMkyvV7wbRqhMz9ZX9/f+y2q3rWGYZh7ioLZcCcEwXwBoBvAvgqgCKAnwXwSwB+97z+S11K+ce33bBpQz+uYwxcZuzobbAXvdQrg+uVwmdxXIZhxkOLCcDZGLUbKIFAAM1mE4FAAPF4nEM1GYZhGOYaLNQTVErZB/AVAD8nhPgJKaUF4M8BfBvATwohggB+HEB1Hu2bNszqdUPPrtoGPTRNCKGO6/F4buz4DMPgQmiPvpgQj8eRyWTgcrnUmOx0OqjX6+h0Ojw2GYZhGOaaLKIH5hsA3gTwK0IIIaX8OoA/Ok9mXZdS/s68GnbbYVaXqZex14RhFgP7veF1VQcZhmEYhrmchTNgpJQdIcQfApAAfksI8RaALoA0bkhtbFpu22C4inoZwzDzQx+XzWaTxy3DMAzD3CALZ8AAwHmdl98D8AGALwPoAPiSlDI335bdLrxqyzDLB49bhmEYhrlZFtKAAQApZQ/A14QQXz97KafXBL4j8KotwywfPG5fn52dHRwcHIzdvr29fYutYRiGYRaVhTVgCCnlcN5teF24OCTD3E947L8eBwcHkFLOuxkMwzDMgsNP1huEi0MyzP2Exz7DMAzD3BwL74FZFi5TDGMY5v4waeyzd4ZhGIZhrgc/PWeE04rrTdaDYRhmcZk09tk7wzAMwzDXgz0wM4K9LQzDTAPfKxiGYRjmerABMyNYeYhhmGngewXDMAzDXA+ObWIYhmEYhmEYZmlgA4ZhGIa5NXZ2diCEcPzjOi8MwzDMNHAIGcMwDHNrcK0XhmEY5rqwB4ZhGIZhGIZhmKWBDRiGYRiGWQK2t7fHht8JIbCzszPvJjIMw9wKHELGMAzDMEvA/v7+xO1CiNtpCMMwzJxhDwzDMAwzUzhRn2EYhrlJ2APDMAzDzBRO1GcYhmFuEvbAMAzDMFeGvSwMwzDMvGAD5opYloVmswnLsubdFIZh7hDn95SFuidPMlIAQErp+HdZrgbDMAzDXAdx39z8QogCgAMAKQDF19iFC4AbwBDAbVgxr9vO22YZ2jmLNm5LKdPjNp73r9YMjnNV5nH++ZizxYWz/pWkN4QQ7wF47/zlmwA+uoV26CzCuOY2fMZ12jHx3sUwDLNM3DsDhhBCPJNSPp13Oy6D2zk7bquN8zgXfMy7dcxFYRF+O7dh8drBMAwzbxYqXIFhGIZhGIZhGGYSbMAwDMMwDMMwDLM03GcD5v15N2BKuJ2z47baOI9zwce8W8dcFBbht3MbPmNR2sEwDDNX7m0ODMMwDMMwDMMwy8d99sAwDMMwDMMwDLNkeObdgOsghHBJKa8kZZxKpeTOzs6ln7MsC8PhEG63Gy4X23nMGd/61reKk6RIp+1fzPxZxDE+qX8tct9axHPJjLKsfYtZfC57LjLMTbBUBowQ4j8D8J8ASEop/2sppXVVI2ZnZwfPnj279HOWZcE0TYRCIX4gMwohxMGk7dP2L2b+LOIYn9S/FrlvLeK5ZEZZ1r7FLD6XPRcZ5iZYmieNEOLvA/gXOCvk9lAI8Q0AmMZ4EUK8J4R4JoR4VigUpjqey+WCYRj8MGYu5XX6FzN/lmGML0vfWoZzyTAMw9wdluJpI4RIA/hnAP47KeW/llL+5wDyQoi/Pc33pZTvSymfSimfptPs5WRmC/cv5qbgvsUwDMMwF1kKAwZAC2fel/8ghPAKIQQACeDxfJvFMAzDMAzDMMxtstA5MEKILwIQADpSyq+dvz083/ZtnBk2EEL8XQDPpJSluTSUYRiGYRiGYZhbYWE9MEKInwHwrwD8AoB/I4T4sfP3xflHvAD8Qoh/BOB3AUTm0lCGYRiGYRiGYW6NhfTACCGe4ixk7J9KKb8uhBgCsIQQSc3LYgL4HwHkAPyslHL/use9rKjnZ7YTwzC3CY9NhmEYhmGIRfXAhAH86rnxsgbg1wH8BoCvCiH+y/PPfB9n4WTvSSk/mFM7Z45lWWg2m7CsK5W3YZiFgfswsyxwX2UYhllOFtIDI6X8MwAQQngB/DKA35RSvn+uOvYnQoi/APBXAP5TKeXJHJs6c0zTRL1eBwAYhjHn1jDM1eE+zCwL3FcZhmGWk4U0YAgpZV8I8ftSysp5wcpvCiH+FIAlpTycd/tuglAoNPIvwywb3IeZZYH7KsMwzHKyEAaMEOJNAAkAz3BmnAyFEG4p5VBKWQHOClaeJ+x/EUBjjs29UaggHMMsK9yHmWWB+yrDMMxyMncDRgjxcwB+G8DR+d8zIcQfSCnr514XSwgRBvAlnBWz/GUp5dEcm8wwDMMwS40Q4j0A7wHA1tbWnFvDMAxzNeaaxH+e4/KLAH5NSvl3APwpgE0AvymEiEkpLQCQUrYA1AH8Qynl38ytwQzDMAxzB5BSvi+lfCqlfJpOp19rHzs7OxBCjP3b2dmZbaMZhmHOWQQVsiiAN87//1UA/xcAH4BfAgAhxI8JId6WUv6xlPKTm27McDjEyckJarXapdKtDMPMl+FwiFwuh8FgcGEbK0zNn2muwWAwwOnpqeM1ZBabg4MDSCnH/h0cHMy7iQzD3FHmasBIKfsAvgLg54QQP3HucflzAN8G8JNCiCCAHwdQndUxLcsa+zAVQqBYLGJvbw/7+/swTXNkNYlhmPkwboW3WCzi+PgYxWLxwndIYco0zbH7ZSPn6lzlnE1zDSZdQ4ZhGIZxYu45MAC+AeBNAL8ihBBSyq8D+KPz+Nx1KeXvzPJgw+EQpmmOTdxMpVKwLAuhUIiVaRhmwUmlUiP/6kyjMMUyulfnKudsmmsw6RoyDMMwjBNzN2CklB0hxB8CkAB+SwjxFoAugDSA5qyP53a7Jz5MPR4P1tfXZ31YhWVZME0ToVAILtciRPAxzM1wG33d4/FgdXXVcds0ClMso3t1rnLOprkGk67hrOD7LsMwzN1i7gYMAJzXefk9AB8A+DKADoAvSSlzsz6Wy+W6sQfYNA9JXvFl7gtOfX3RJpIso3t1Fv2cOfUxvu8yDMPcLRbCgAEAKWUPwNeEEF8/eymXLih93ENSf6COW71ctIkdw1zGZX3Wqa/fxESSx85yclPXzamP6X2R+wvDMMzyszAGDCGlHM67Da/LOOPE/kB1mrjxCiGzbFzWZ51W6m8iZIvHznJyU9fNqY/pfbHZbHJ/YRiGWXIWzoBZZsaFVkwzaeNYfGbZeJ0+exPhRzx2lpObum6X9THuLwzDMMsP+8+nhHTtdQnRSfr3+p8QAoZhTAxXoIcuhzQwi47er8PhMIQQI/39tqF2ALjy2GRuhknnnO6hAObSf+z3Wu4jk5lUrHJ7e3vezWMY5p7CHpgrooc90KTpOnA8NrNsSClVn12k+kizHpvMzbCI12lR+/QiQMUqGYZhFgk2YK7IrMMPXjcOnA0fZl7ofTYUCi3MxI9Dg5aDRbxOi9qnGYZhGGd45ntF9LCZaej3+9jb20Ov13PcHgqFEI1GHR/mkypeT1PhmmFuAr3PLlI/nHZs0pjs9/s30o6rVKqfB7fVvnHn+ar30NtgUfs0wzAM4wx7YG6Yw8NDfPrppwCA3d3dK313kndmEVcxmfuBnnOyiP3wsnCg64zJaVh0VbTbap9+nh89ejT2c4sQvrXofZphGIYZhQ2YK/A6D9rNzc2Rf+28rpGy6MXkmPuBPvFbFC7LsbhsTL4O09R6WhSoXYFAAM1m88bCUKc9z4uWE7OIfZphGIYZhUPIroA9tEBKiVqthpOTEwyHzuVrvF4vHj16BJ/P57h9UggZwywSFHq0CAm9TmFQUkq0Wi0EAoGJY4rGpNfrHbuvq6LfGxZdUZDa1+l0Zh4qpfcR+3km6DpRPwoEAnC5XAgEAjNrx3Wwt49hGIZZPNgDcwXsK6umaWJ/fx/NZhMulwvZbHbsd/UVWvoueXJotc/+wJxmZXKcV2haDxGLASw39j5j7w+zDMm5SQU+p3ZO8ng6JV3b5XmnZRYhVYvudXHipouKjrsG9s+YpolGo4FQKIRIJOJoOOh9YZr71HXua7Ps53x/ZRiGuRnYgLkC9tCCUCiEnZ0dmKaJVCo18bv6QxHAVA/IcRMM/WF+3YftosfrM1fjJsNxblKBz6mtTtup79NqvT4GDMN4LW/mLH7XMoZ03nRR0XHG8zSfsTNOJWycUXCd+9os+znfXxmGYW4GNmCugRACsVgMsVjs0s86PRT1/0sp1eqxYRhq9fyyiR3Fsb9u+MUyrhwz47nJ60kTXloh7/f7ODw8xObm5oUwoWm4rK1O252MmteZEOsso/GxqExzLu2foXC7SX1Wv8bTGAXTjgPykPh8PpTLZaRSKbjd7pkZ/3x/ZRiGuRnYp31FhsMhcrnc2JyXcejSoU4yoqZpIpfLIZfLjY1Jd4rx73Q6sCwLnU7ntX6PHq+/6PKvzGRuW82JVKYODw9f6/uX5Yo4jZNx+RJXleWlcTwYDF6r7cx4BoMBTk9Ppz63V80ZmiZvcNp9kjF0eHiI4+NjFIvFqdowLbqxxvdWhmGY2cEGzAScJvTFYnHqB91VkkFDoRCy2Syy2azjg1lKiXw+j2q1ik6no1YifT7fzBJguf7BcnPb129zcxOPHz/G5ubmjSU+2/erG+y0bdLnx3GVcTyJu2b0z+L3XOfc0vUbDocj19E0TVSrVeTzeQCYmUgCGUObm5tYX19HIpG4kX7M91aGYZjZwiFkE3CKu47H42i1WkgkEo7f0WP0i8WiWoW8LCRBCIFIJKL20Wq1RlbSTdPEYDCAx+MZCaMgz0mn07l22AOHOyw317l+r5NsTCpTANBqtVCtVtFsNpHJZGaWsGwPGXMKJbIsS4Ug0USX2jHOK0M5a5flrl2lfdcNQzs3GsaeOMuy1G+9KWbxe+zndlzfcnqfjq8bUXTdm80mBoMBTNO81rm2H5fum9lsFq1W60KI4iwS8Rfx3iqEeA/AewCwtbU159YwDMNcjaU1YIQQQt6wzqXTZMnlciEYDKLX6znG/dMEqtvtwuv1wufzXch10cN8nMJ+ponz12s5kEfmunAuwHJznfoV15246hNMUuV7nQmffTzYJ370np7Ib1nWyEKDPtEddz7cbjey2ey1Q+1mnfANwD1u+3A4vPbk/TJm8Xs8Hg9WV1fV63F9y+l9Oi7lpNA1FkIgk8mMKDnamWRo6NuuWntrFkbdIt5bpZTvA3gfAJ4+fcqa0QzDLBVLZ8AIIdaklCdSSnnTRoz+0HEyGJyMD5pAWZYFn8+HTCYzsk/TNFEul5HL5bC9vY1OpzPyWggBy7JgGAaCwaD+uy8oMdllmBnmdbnKxHXckKMJpm5Q6H2WQmgymQzcbud5+iRlMns4kcfjQSaTgZRSLSwAQDqdRrvdRjAYhJRyxEjRx44TlmWp745ro84sJ6bnbRqbXOd2u298BX/a33OZBLaOLjSi9x29z+nvB4NBFAoFZYTStRVCjG0bXVf9XqpfP91bB5wZIvbjAs6LAIvoPWEYhrnvLFUOjBDiJwH8B8PDkjAAACAASURBVCHEPwMAMmJu49j0YPd4PCr+2imumVYKE4mEMl5M01Qx3YFAAP1+H5VKBcViEcFgcOR1u91WK9jjfpp+XBIFsP9Ny12L4b9vjLv+FIY47XW9SiL1uP5GE1onOWOqmbS3tzcxN8KeoO3U10OhEDwej/L2kMFBY4bCgpzG0GW5CO12G/V6He12+9LzMGvOz/3YC+ZyuRamlshVcjrGCY3YRRrICGm1WipcFoC6Hpfd10Kh0Mi91L4tGo0CgFJ7NE1TGTDjxhH1p9fJueF7K8MwzM2xbB6YBoAygDeEEP+tlPIr03hgbirWd9zKnB7mQg8xCmvxeDzY3NxEOBxGKpWCEALb29sjrwGMeF+mPe7rwHUKrs8ixpLf9nW1e06cVrGnqZnkVGtJ/9f+vmVZyOVyyGazKodsEpeNHRp3k8bfbbKIfQu42j1o2s+SZ83lcikjlkLmprke9nupfVs4HFbeOicv4azheyvDMMzNsRjLeVNw7mkxcWbE/EcAu0KIfyKEeCyEWJ/0XSnl+1LKp1LKp+l0GsBsVscmrczpD69oNIpUKqVWjTudzsj39Hh8fTVZSolGo4FGo6FWCq9akXoSlBRM4RTM6+HUv+bNNFKz10WXFL/seCRSEY1GlZFuWZaj4pT9e06S4+SlvKr8t9P+qB2UIE/em0VgEfsWMLpIc9kaktM5d4LuaY1GA8CZ50a/ztNA91IKH6N7aK1WU/sNh8MjXkKqwUUevVl5TG5jDDIMw9xXFuMpPQXyjI8A/D8A/j8Afwzg5wH83wDSgDJypqLZbOLk5ESFE8y4rUp9LBQKIRQKwe12I5PJIB6PA8BI+AVNoEgBp91uw7IsFAoFnJycjNSGmRS64TSRmzS5s08EmbvDZWEvs5bLnWaSag/ParfbKJfL+OCDD1Aulx37tJMsMk0MKcE7Eomo3JXXodVq4eTkBI1G40phd/edZrOJo6MjnJ6ezkR2mHJcqM/qNX90I3McThLMVF9rf39/5D6q91e6pxaLxdeWOnYaT68besYwDMNczkKHkAkhPgegD8Alpfz++du7ALIABICnAP4KwI8D+M5Nq5JNi2maKBQKAOCY8A9gpPI0Tezo9WAwUHHgkUhkxEOiJ8Q6HdcesnBVxR3mfnATcrmXYQ/PovyvbreLfr/v2A+dkvpp8tlqtdRYqFQq8Pl8E48/TgGQJp36xJWFMaaDjMZoNDrxnOny8nRPtIsrkAGQzWYRDofVQg7lzlzWX50kmKm+li61bWcWio4cLuYMCdOM27a/v3+7DWIY5s6wsAaMEOLvA/hfAfy/AD4vhPifpJT/FsD/BuC/AvB3APw3AEoAfkYIkZBSlqfdP62MzbJmhv6QpocmhSUAnyWP6jkCUko1odM9MdlsFvF4fORBL6VUtWUoDE3HySCZZKQsorQnczvMwnilcJ1psee3uFwux/yvadoppVThj81mE7VaDeFwWI27drt9YbJsN4ba7bbKuaACsp1OxzHfYha1QJYdu/KYYRiqDtA4VUZCl5f3+/3qO7q0cS6XAwCsra0p5TEKc52mvzoZInp9rXHo6mavez/kxSBnJhkot6S/wzDMHWUhDRghxFMAXwHwj3EWLvYrAP4ugH8LoAkgBuA9KeW/F0KEAfyFlLJ+lWNcZ/LutNpGD29d3rXZbOLjjz9Gp9PBO++8MxJzTZDMK71PE0K7Og8ANVGLRCKXSoAOBgMUi0WkUqkRY2ka+MFy97ms/0/qK8PhUPUtt9s9Ij08SQXPaZ8ul+uC1LiOnnxNf+R5sSwL8XgcqVQK7XYbiUQCUkrl0XQqhgh8NskMBoMq98HlcsHtdo/1ItjH/GVjaZa5atdlVsaX3QC0GwdORSAJXV7eXoyXtqfTabUARPdFl8ulCpPq91o79J79Gk97z9MLB9v79ySor/NiEMMwzO2ykAYMgBSA/0VK+RcAIITYA/CrQgiPlPI7QohflVJWz1+3brtxTqttZIToRfSAsxCyRqOBUqmE3d3dC5M7muhQ4r59tdAp9GyaByXlJwC40io5w1yGvW+RwQBMXoG+qsS3jm64UDJ2LBaD3+9HqVSC3+9XxWXHhQQ5eYD04oiT2nbVFfZFCimaVVv0c3AVbxlwsRCl7v2m1x6PB5ZloVgsIp1OKy9Ms9lEpVLB6ekpVldXsbq6euH411l0sRtefO9kGIZZfBbSgDn3rKxpb30bZwpklCEZBFCVUg5uvXEYb0TYH9KWZWFrawvFYhFer9exMrg++XNa/bUXYMtms1NNQlKpFCzLQiAQwHA4dIw7Z5hpoPwE4GwCbM990XNaJoURXYd2u41cLgfLspQH0uVyod1uK3lyJ0PFqR1278g04+mqK+yLFFI0q7Zcdg707eQt0/uCkwGp709fACKPXrvdVveydruNRqNxab7NJMYVH9b/dcrtuopXhmEYhrl5Fs6AEUKIc8WxE+1tD4AH55v/CYBfEEL8AoD2oiTuE/pDutPpoNvtIhwOw+fzwbKsC5XBnZLy9ZAcvd5Fs9lUMrS6rLI+udRDGlwuF5rNpiokB4xWRr+JiSZz9zBNEycnJ2i323j06BEMwxhZmSbpYVLOGwwGI0nTkwyIafteMBhUIUapVArlchmDwQDRaPRCrpgd+/FuwzuySCFF82qLPeTssuvucrmQTqdHjBf6Pi3cDAYD1Ot1BAKBSw0Jp+NRmG+z2UQqlVILO7pBZM/tklLi4OAAlUpFtYVhGIaZLwthwAgh3gSQAPAMZ16WoRDCJaUkj0sbwB6A/x7AfwHg16SUV9e6vEHGrezpDzuSLNYf5pSkapfutCf8k8FCRhChJ7/Svun9Xq+Hfr+PTCaDXq83sgLrpO7EME6EQqGpikSSN4QMZ7vRTIybRE4yQEjtqtU6ixilXIpparbY+/p1PRL2ZPa7ynVzZ+zneRrDUb+HkWcvEAio697pdHB6eqqEF+zo9+Fms3mhyKnu5cnn80owZVL/Nk0TXq8XKysrUyvuMQzDMDfL3A0YIcTPAfhtAEfnf8+EEH8gpayTESOl7AohsgC+BODnNUnlhWGcQaDHeuv/p88bhqGUlBqNhlqFpPoHBCW01ut1tZ9Wq4VAIKBWpn0+n0pGDYVCquZGp9O58ICmdvh8PuRyOQ6NuKdcNkmlCWEmkxlblE9X/YpGo2qC6PP5xsrW0meKxeJYQ4fQxxZ93+PxqAku5cToHki9bSRRPi4XZhJO5+e+GP+XGRyX9R37eaawWlJnJMN1nHFExkyj0cDe3h78fj8ikQhWV1fHGhL2vuLUJhJY0UNzJ3mHAoEAfD4f1tfXL9wjWZ2OYRhmPszVgBFCeAH8Is48Kt8UQvw8gL8F4DeFEP9cSlnTPv5/AvgTKeWH82jrZTit6tonOvaHOXC2ythqtdBoNBAOhxGNRgFA1T9w+o5dwcfjObuMxWJxZEXRMAy1cqmjP6zz+TwnrN5jLpukOk3W7VGbeqiPy+WCZVnw+XxKXYyMakIIgVQqhWKxiEQiccE7aIe2+f1+RKNRZbhQnRAnDyRRLBZxenqK9fV1xGKxKc+K8++n87NI+S03yWW/86qhePoijF5/57LvktFDBkI0Gh272GJvMy0E0WKP3WiKxWIwDGOiUUohuPb78eucA4ZhGGY2zN0DAyAK4A0A3wTwVQBFAD8L4JcA/K4Q4scAVKSUvz2/Jk4H5anYJzp6XQk9v4XyBvRt+moxrVR2u12lUkbfodoIlmUhGAwiGo2i1+shn8+rQpihUAhra2squZrQH7pXLUbI3A2cZGft8t7jtuvKeUKIC0n8ZITrksb2fXQ6HQwGA5TLZaTTaQCjY4MmmJQ8nUwm4Xa7VZ+nekiGYYyEGhFUU8nn82F1dRWJROKCITUNTr9fl3bW5XfvMk6phlcx5PRClVSYt9PpjOQAUg0ep3NJ9zzDMOD3+9FqtVQ/oWsNXFwoooKndlltv98Pj8eDZDIJ4KIQBfVdPQ9xnDdx2nPAMAzDzI65GjBSyr4Q4isAfkMI8VxK+Q0hxJ8D2ADwD4QQ/xLAjwP41/Ns5zSMy0Uhg4MeuK1WayQumyZDsVgMx8fHKJVKSKfTWF1dVeEJ9hAb2gft2zRNpNNpWJaFcDiMTqcD0zTh8XhUOJquoqMXiBNCsOflHjMunEqfRNoTsO3KefrklsQjKNRRnxjSKnYwGFTyuL1eD7lcThn9eu4X8JlkM01eCVIeIyUyACMr5O12e0R4oNfrXepJuur50eV37+Lq+2WhclcRB7AXqiRjlBZcSEKZjmVXiuv1emi321hZWYHL5Rq5h+oKdbFYTN3zCCqc6fP5VOghee+63a46Br1vFxCYZJwsklgDwzDMfWIRPDDfAPAmgF85VyD7OoA/EkK8B2BdSvk7823edAQCAZUgbH/g0cNwMBgolSYdynsJBALIZDIqL6bT6cDv96vq1WQEkUEUi8VwenqKaDSKdruNcDiMtbU1+P1+FAoF1Go1pbCjq+hkMpmRSeZdjuNnZoM+mdWNEgAXJnvUR8kTSIn29nob6XQahUIB1WoVhUIB29vbIyFiAJTnJBAIqAlwNptFPB5Xn9MLIOr5OHre16SVcqf8B3rPXtVd566vvus5K7p64usU6SRBE31/pmkq0QfynunbdOPwnXfegWmaSCQSI3lTwFk/zGazIxLMdE+zLAulUgmNRgOtVgtra2sjhrXf71dGM/CZAa338fuS88QwDLNMzN2AkVJ2hBB/CEAC+C0hxFsAugDSAJoTv7xAdDodAJ/lo+ihJfQwrNfrqFQqCAQCFyY9LpcLsVgMsVhMTcJ046VUKinDh1ayS6USer0eut0uqtUqer2eWpU2DAONRkM9kO0qOvZJKMNMQi8OqYd56aE9gUAApmnC7/fDNE1UKhV0u108evQIkUgEPp8PLpcLXq9XGePpdFpNOvVJKdHr9RAMBuHxeJSnkMKPgM88Pq1WC6ZpKsMcODN0SHhgUuK+0wSV3pukpjZu9X3ZErvHtdcuHGI/N8D0nichBCKRiDJidUETCp2le529yKUQArFYDNFoVHmkyTjV5brpNf0BQKFQUH2o2+3C5/ONtIu8NwCU58bn8ykjmP6ltjAMwzCLwdwNGACQUlaEEL8H4AMAXwbQAfAlKWVuvi2bHnuCfblcRi6Xw/b2tnr4+3w+FItFGIahqk1LKVVYDU0e2u02yuUyqtUq4vE4PB4PGo0GIpEIgsEgqtUqarUahBBqJfrg4ADA2STr0aNHCIfDiEQiaDQaCIVCiMfjAD4LDdLzafQE12AwyGpkzAXIAGi1WkoCmWp2UH2iTqejJqcUFgScrWoHg0FVu6VSqYzkIpBBZJomSqUSstksQqGQSvInRT3DMNQk+OTkBJFI5EL4o26Y65PuSSpT+tilUMtEIoFoNDrigbHvZ5xxsmyJ3ZPaqxuuusKhvs2JcYUf7YYJKdKRYUtGMXDRYJRSwrIsRKNRDAYD7O3tYX19HbVaTRk+Ho8Hg8FAXSPqk/F4HI1GQ+VckSc8Go2O9KHBYIDDw0OVI3OZQh7DMAwzHxbCgAEAKWUPwNeEEF8/eykvLscuMPbq37lcDpVKBeFwWKkx9Xo9JBIJdLtd9Ho9FAoFBAIBFAqFkbjtUCiEfr+v6rhEo1G0Wi0YhqFWfb1eLyqVCrxeL8LhMLa3t5Ux0mw2EQ6HlQoZ7ZfixvVJip5PQyzDpIuZHVcpLKlLIFPitJ5IrytGZbNZ5SV8+fIlvF4vfD4fksmkEqbI5XLKGKGQJeCz3Bdif38fhmHg8ePHAKDyXqgqO4lVjAuJnBQGpI9dPecmGo1e2N80xsmyhZZNaq9uuNoVFSf1lXw+j729PViWhbW1tZH96f3MNE0lfELGi14vS8duLLdaLTx//hz5fB7pdBqPHj1CMplU4bM+n08t9sTjcayvryORSKBQKKDT6WA4HKoFGyGEOjZ5bPQaRU7oIg7L4GljGIa5SyyMAUNIKYfzbsN1EUJge3sb4XB4RN1LV0siFSUqYGmappoQrq2tqe8nk0m1sujz+XBycgKfz6cmcvTgJE8MrSzqOTEkHkCQIhAANWGk2hqkCsQP5bvFuDCh4XCIg4MDeL1eAJ95EMcZM0II5XmhCR9N9AGokCNKltaNEp/Ppwx1Wt22LAtut1uFTcZisZFikzR+SHWPxtCjR48AQKlWXbZCPq1RQccLBAKOBs80+1m2xO5p2ntVoywUCim1sWn3K4SAlHIkJExH966RxyUajeLo6AjJZBKxWEz9llarpXIIfT4fDMOAz+dT6nf9fl/lJGazWRUuR981DEMJDVC7aFyQCh6FTAIXjdllCCM8zzN9DwC2trbm3BqGYZirsXAGzF3B7XYjk8mMyM3qq4o0CaQQFTIc6vU6qtUqVldXkclk1CQyGAxif38fx8fH8Hg8SKVSI8YJTRLT6TQajQbq9boSFgBwwZjZ29uD1+tV1czpgX3XlZXuK+M8B8ViEZVKBSsrKxfqC9mNguFwiHw+j1AopHIQ9IRo4LOQsF6vh0ajoSS+9dwC8pSQtzCVSiGdTqu+SBM+Cu2xK5C5XK6RBP3rqInZcbvdyGazkFLC4/GMTKRfJ3n9rnBV6ehoNIrHjx9fasDYr8uk60T5hNSHqH88fvwYw+FwRJ5+bW0NPp9PKTOapgnTNBGNRhGPxxEKhfDRRx8pbyEZ1uFwWIkNUG0uy7JGjPxms4nj42Osrq6OLe66DGGEUsr3AbwPAE+fPr18EDEMwywQbMDcADTRoRVqwDkBmCYEtM3j8aBUKqFYLMLlciGTyai8lHa7Da/Xi9XVVaysrKDT6aDX6ynDhcIuKNegUqmoBzM92HX5UJLDLZfLKnxDXw3VZZZ17nq9i7uKfQWdriN5HBKJhFLdApzFHYrFIl68eKHCIil0jPqXZVk4PDxEv99Ho9FQ+VvUv3O5HJrNJlZXV5UBQonbvV5PraDb68HoidZra2uXGiI0+SR5ccrFsTOpLztNpK+iRnVXx8m052Aar45+nQGM1HIZZyDaJbxpP+TRJoOE+mW73VYGl2EY6n7pcrmQTCYhhFDhvFSPqNlsIpfLwe/3IxAIwOfzKSM/GAyqMZJKpZQn0e61XrYwQoZhmGWDDZgbgB7yhmGoRGD7qiUZOaQ0RgYG1XOhEARdBSkejyMcDivDY39/H8CZ+z8ej8Pv9yOXy6HT6aiVxv39fXi9XiQSCQBQnhm324033ngD1WpVPYALhYJaXaeH+ubmpqqUflcnZfeBcRNKj8eD1dVV5f0DoPKyksnkyOQ/mUwqeWQyRqLR6IgRTVLd8XhcTfBoYtpqtZTXhSatm5ubKJfLqs4H9W99kqqvtpOhZC94CZwlYJdKJQQCARwcHKBer6PdbuPhw4cXwoCcXgPTJ/vfV5zOgX7OAEztpaLrTPe6SqWCTqeDdDqtcpt0gzYQCDiqJ7bb7ZFaMpTrR94YvR/ncjlIKZUYQSAQQLVaBQCV5N/pdJQyGkkvP3jwAPF4HIVCAalUaiTx38nbsmxhhAzDMMsGGzA3gD2u254AC3z20NNVd6jgmmEYGAwG6jvValWFP9AEjo5RLpcRDoeVOECz2VTemmKxqJTMKLTHMAw1WaVQC0r+1yVJ9boxNFlgJZ67i95n8/k8Tk5OAGBkoubxeLC2toZGo4FOpwPDMEYS8nX55HK5rIyXYDCI1dVVNanU626Qt4SMI8uy1DigFXXgs1A1p3oyg8FAKZzlcjlEo1FsbGwAOAsJM01ThRHp35skn6y/R0wbhnaXucwzBWDq0Cld+IHqwTSbTdRqNXi9Xrz77ruIxWIXiv/q6ol+v1+FGJL6XavVUgswJBxB36F6MXSfBD7L/9PDKePxuPJwr66uwu12I5fLKWEJfVywYcswDHP7sAFzA5DSDq1EOj3g6P+6B6ZQKODFixdwuVxIpVIoFosolUqwLAv9fl8l7rdaLSSTSezs7GBra2uk+B997+joCFtbW/B6vchms0oFKpFIIJVKqUkfeWs8Hg8ikQiEEBBCYHNzEwCwsbGBwWAw4kW6b/H/9wF9xZjCypLJJABc8HiEQiFkMhk0m000Gg0lXVupVJTSU7PZVKFksVgMwGehiaVSCYlEAr1eD9VqFYeHh6rWC/Ut8tbQpLbRaKgcrnq9jlAoBL/fj0ajgVwuh3q9rsLFSMGPVt51KeBms3mhrofTuHTymo7jKipuy8Sk36Vvm3Qex6H3KdoXFSQtFArodrvI5XJqgaff7+PFixd4++23VR0hUk+0LGukhozf78cnn3yi7sOZTAa5XA7JZFJJ0QNnYZOUf0j3Qp/Ph7W1NdRqNXVfBM76I3mxqbgqKZixt4VhGOb2YQNmRtgf9vqqJD3k9e20kkkrzMPhEIPBQD1Ug8EgSqWS+guHw3j8+DEGg4EKwXG5XIjH4/B6vTg4OMDa2hqq1Sq63S5arRa63S76/T7+5m/+BsCZsUTenVKphO985zvwer3w+/1455138ODBAzVBJSnRwWBwQUaVH9Z3G71oJADUajV89NFHeOONNxAIBJTwxMHBgTK2gTPp3IcPH6pq53/913+NcrmMVCqF09NTpUpF3o9Xr16psCFK8Ke6IXoC//HxMbrdLrLZLAqFAp4/f47V1VUAwIsXL5TkMRU6LJVKMAxDhVzS5JtCgzqdjnp/nJeF+rvulRxnnFDOBHkILuO2FKquexy6hzmdA/v9jaDzd5khp4cJUls9Hg8ePnyIlZUVVCoV9Pt9PH/+HOl0Gv1+H7lcDoZhYGtrC0dHRygWi3j77bcxGAwwGAzQ7XaxubmJdrsNIQTa7TZWV1dxeHiI09NTNBoNbG1t4dWrV/B6vSrcjMIX2+02dnd3kcvlUKvVEIvFlBrd6ekpIpEIdnd3VW0ZgO+FDMMw84INmBlhDz2xr0rat5OUMeW4dLtdlTdDictPnjxBIpHAixcv0O12VTgM1Sbw+Xzw+/344IMPsLe3h3w+r5Rx3G63KsbmdrvRbDbh9Xrx8uVLCCHQ7/exsrICl8uFXC6nwinskxL7vyyzvFxcdxJrWRZevnypQso2NzcRj8dVyJfP51O5WmTcUDgi1dIIhUKoVCoQQsAwDKyurqJarSoPC3ljKNRLNwQajcZIW2gyrUuQ06SZVsT9fj9KpRLi8fjIRDoUCqnQTMoDGwf1d8qFAGYXQnlbClXXPc6kc6DfF6ZJ7Nf7IRWkNAxDSREbhqHyn/r9vkrCp8Wazc1NGIaBzc1NlEolvHjxAoVCAdvb29jY2FDy8b1eD5ubm2i1WshkMggEAohGoygWixgOh3j16tVIWO3x8TH8fj+i0SgymYwKk/R4PDBNE/F4XBnbJPH88OFDAM5CF+N+M98rGYZhZgsbMDPCSeVJrwKuK3uRtyaXy2EwGMDn82FjY0PlshweHqJarSIWi2F3d1dNPtLpNEqlEoQQSt2pUqng5OQErVYL7XZbqZvt7+/DNE08efIEw+EQT548UTHdpNoTjUYxHA6VmECv10Or1RqpXUM4FbTj1cfF5zqTWMuyUCgUVE4JqTSVy2VleDx//hzdbhftdhvr6+vweDyo1+vw+XzweDzY3t5GLBZDPB4HAHi9XhwdHcEwDGxvb8Pn86HX6yGVSqmwL51wOIz19XWlKtZqtbC9va1+y8OHD1VOF+VExGIxNUm2ez07nQ5OT09VoU3C7kHVZYN1hT6nsCq7it9l3FbOxHWPM+05cDqOffJuz5PRC1JSIct2uw2/36/yVGg/dJ6TySQ6nQ4SiQRWV1fhcrnUHxWdJMMnkUjA4/GoPvv2228rb1I6nVa1uB4+fIhoNIpsNotKpYJer4dKpYJKpYLDw0McHx8r73Sj0UCtVoNpmlN52pZBSplhGGZZYQNmRkyT4EtF/giK+R4MBqhWq0ilUnC5XNja2kI4HMbKyoryuOh1Cnw+H4rFItxuNz755BM0Gg0l9dlqtdQ+j4+PUalUlNwtVcSmiQUVx6zVaqhWq6ptkUgEhmE4hojokxV7/Y27FP9/FyDDGbh4vaSUE6+XlFKpO5GBTQIQ3//+9+HxeGAYBgqFAjY2NrC7u6sMXyEE8vk8SqUSIpGIMl6klDg+PsbHH3+MYDCIeDyO4XAIj8cDv98Pr9erKqLrZDIZRCIRDIdDlbMlhEClUsFgMEA8Hke5XIbb7Ua328Xu7i76/T6azaYKuUyn0xBCIJVKwbIsBAIB5c0Bxifv28e1U7jYVZP7bytnYlbHsS/G5PN5DAYDABgbiufkkabFE6oNRLlI5OGhfKlMJqNkj8vlMp4/f45mswmfz6cU6T7/+c+jVCohmUyqfq17iUOhEIrFInw+HyKRCEzTxMHBAWq1Gt58802cnJzg8PAQm5ubKleQ8gfpfupyuXB0dIThcIitrS3EYjH0ej3kcjkVwjvJs8LJ/QzDMDcHGzAzQp8Mjgsd0EMyaAWS4voHg8FIbD59hmRn4/E4Xrx4gXq9PlLnZWVlBWtra+j3+yiXy3jx4gX6/T4Mw0CtVlOr5XobdZWnWCymYswNw1BFMvV6BtNIzDJ3CyGECkHs9Xo4PDzEw4cPYRgGMpkMwuEw4vG4CveJRCL46KOPsLu7q6S4Q6GQWk3/8MMPsbKygnQ6rXK5SqUSPv30U8RiMVU1nQyD4XCoDKBcLoe1tTVIKZHJZFSImGmaapL64MEDfPjhh+h2uwgEAshkMhgMBiqXgcLVaPJMCoDkWeDJ5nTQ4giJI9jvA3TvswslUCFfMmpcLpd6z+VyoVKp4MMPP8Rbb72lvudyudDpdJDP5+H3+7G9vY1er4dAIKC8KyTRTbkq5XIZGxsbODo6wt7eHrLZLLa2tlSYbL/fR61WQzgcxptvvgm3241er4d6vQ4hhBJ+ODo6whtvvIHBYKAknTOZDA4PD1GpVFAqlZDJZBzPkX6fZM8LwzDMzcAGzA0wLnRgXEiGxRZ/qAAAIABJREFUXmwSOCsY+Mknn6DVaiESiSASiaBcLuODDz7Aq1evMBwO0Wg01Arw7u6uWsE8PT2FlBJf+MIXEI1G0e12IYRAIBDAs2fP8O6776rQIFL5icVi2NjYUMnX4wyVqxTyYxaDq1wzu9pYt9tVXgpaRacclWAwqCZoBwcH+Oijj1Ri9Q/+4A/i008/RbPZxMnJCTweD/L5PFZWVhCLxeD1elEul1GtVtXq92AwUEZ0KBRSE8Vms6lEKUhFqlKp4Pj4GL1eDx6PB69evVKGUrfbRa1WQyqVUqvv/X5/pKisLt+rn5tp+vRVw8XuGrqh5+R9mNTf9AWcarWqPGPBYBDD4VBJZLvdbnz44YdKqCEUCsHr9SqJbjKQC4UCqtUq2u02otEocrkcCoUCisWiqv+SzWYxGAwQDAbx1ltvoVQq4eXLlwgEAojFYmg0GqhWq8pbNRwOMRwOcXx8jOFwiEQigVDorOhvr9dT3nF7qCPgXMCYDRiGYZibgQ2YG+CyYm96yIVTUb5EIgGv16tek6KS3+9Hp9OBlBLhcBixWAyxWAw+nw+JRALRaBQfffQRIpEI1tbW4Pf7cXp6io8//hhf/epXUavVUCwW8dM//dMIh8PodruqVszm5qZjOI2unmaXoWUWn6t4FhqNBvb397Gzs4NYLKY8daFQCI8ePVJS34VCQXkyqI4L7b/X66FcLiMQCKDdbqPT6aBarUJKqRK2A4EAhsMhgDNlsO3tbeTzeRXWVSgU0Ov14PV6kclksLe3p8KCSLzi5cuXcLvdqFQqqNVqqg0PHjxQcszpdFp5N10ul5IbJ4OMQtUoL20ar6I9nOoueySdft9l4XKT+hvlyzSbTSXEQMVL33nnHUQiEayvr+Po6Aherxf9fl/JFJNBTSGybrcb7XYbR0dHqtbWxsaGUlAslUrKOxePxxGNRmEYBgzDUKIpdD+LxWJKRKVQKGBlZQWDwQBHR0fo9/tKNpn6FRk0wWAQ3W73gvIkFTC+r0butGxvb48dN9vb26pQM8MwjBOvbcAIIf6dlPLvzbIxdwV77LlT3DhhrzpuWRbK5TLW19dVvD4pNFHhQFLXoYdxLpfDj/7oj+L58+cqZ6bZbOJzn/scfD6fkgB1u93weDz49re/DbfbrSaqqVRKqUpRxWvgM+OFVkspjp1C3ZjFxz7hpElpMBi8MHkgNTHTNNWkrtVqjdRyIVWwQCCAwWCABw8eIBAIoN/vI5VKIZPJIJvNIhQKKbnbfr+v+l+j0VCyxx988IHKs1lfX1ceHgr32tzcxMHBAY6OjlCv1/EjP/Ij8Hq9+O53v6sKZyaTSRwcHCgDe319fcQzkEwmUSqVEAqFlOqYfdGAwsnsUueX4aQsuMwGzaTE+2nHO937pJSO54P6GJ1rKlbq9Xqxs7ODdrutFMdisRg+/vhj5fWi8NaVlRW02228ePEC5XIZ5XJZGa87Ozv49NNPcXp6ilKphNXVVaRSKVWc9eHDh9jY2ECv10Ov11MGcaVSQTQaRTweV4VXQ6EQdnd3MRgMcHh4CJfLhZ2dHeRyOQBnuYJkBI9TnmQFsvFMMlCWcfwwDHO7TDRghBBfHLcJwBdm35y7iT1uXIfCWTweD/b29tTqn8/ng8/nQ71eR71eR6/Xg9/vRyKRgBACvV4Pp6enaLVaKpmVkqJLpRLcbjcSiQSGwyGklDAMA5///OdVAbhOp4NUKoXhcIh8Pq9qwNgTlGnFlIwvfWVxOByiWCyq2h3M4mOflOpGK3laMpmMqo5O/ZOuP+WitFot5PN5JfaQz+cBnKmMUZ4C5WhRgcF4PK7CvJ49e6ZCbRKJhEq2p5owVNclkUggEomg2+3CNE385V/+Jfb29rC6uorHjx/j4OAAgUAAvV4PUkr4/X6V+0LeHvLO0IQzl8upwpi00DCtHLDOJKn0ZQwdsrf/unlBTudT99QdHBwgHo8rD8tgMECxWFRGcKPRUJ6NYDCIFy9eYGVlBUdHRzg9PVX1XsiY7vV66t7ocrmUJ7pcLmN/f1/lvqRSKTSbTVWwslqt4tNPP4Xf78cP//APo16vq+KqpAxJnhYqiOnxeJTi2WAwQKPRUFLQAFitkWEY5oa5zAPzlwD+DGcGi5347JtzOUKIHwNwLKU8nMfxXwd9IkArS/rkPxwOY29vD8+fP1eFAClOnGptpFIpHBwcwDRNnJycqKKXhmGoCuTA2QSTklHdbjc+/fRTeL1e7O7uIpPJ4NWrV0pBanNzE0dHR2g0Gipmu16vIxgMwjAMJSebyWQcV5aLxSKOj48BYESSlllcqC+SYUIeQKpHZBiGKvhYKBQAjF5b+0R0MBio4qimaeL4+Bg+nw+7u7vIZrMolUoAgFwup+q20Eo/AHzxi19EMBhU1dBdLheKxSIePXqEUqmEfD6PtbU1JWaxsbEBn8+H9fV1GIaBVqsFn8+H733ve+j1eiocqdVqodfrqd9FtNttNBoNVfdI91BddcJu924tuxDAJCn4WeyP9hkKhVCv19WiDvBZ/anBYIB8Pj+SD9jpdDAcDvHo0SPVxygkcX19Hfl8HqlUColEAs+ePUMikVD3QfIeD4dD5WnZ29tDJBKBy+VS91kpJer1ulIjoxDelZUVeL1evPvuu9jf31fiKTs7O+peuL+/j2AwqKTwx/12hmEYZnZcZsB8H8CXpZSf2DcIIW7dgBBC/D0Avw/gF4UQx1LKoRBCSLue75yxh2IIIRAMBtVKopQSH3zwATqdDoAzmdjNzU0AZ4UCPR6PWp3O5/NoNBp4+fIlSqUSEokEHj58qIq+ZTIZ9Pt9VR262Wyi3W7D6/XC7/djbW0N7XYbUkoV+pBKpRCLxRAMBvHuu++iXC6rfJlSqaTUp6iGAin9DIdDFTtumiY8Hg8ikQgSicQczjID4IKU9WXQpJTyPmii6PP5UC6XVb8zDAPZbHZk8k9GrpQSHo9H1SSSUqqwHPp8LBaDaZoolUr/P3vnHR5Xdeb/z51eNKMpmpFGslXckGWM4xJK4v0lGwgk1EAIxGFjk+B1CMSAQ8nCUpyFALvUbAwJBrwbQkwSihNDjAMEWDqhmOaOehmNZjTSaHq9vz/MOYxkSdjYxgLm+zw8WJp27tW5d8573m8hm83KrkgsFqO+vh632008Hsfv9zNv3jwymQxer5dQKER3dzf9/f0MDAzITqHNZpPjbWpqor+/H41Gg8/nI5PJ4HQ6pf2teE0oFJLHJmykjUYjNptNzm1hUlDciRLX6d5Sf/Z1wX8wUDx/Rup79ua1I+li49HpVFXF7XaTTCaZNGnSMGqf6Nr09/dTUVHBF77wBbq6uiQtLZ1OS12K0+mkq6uLYDCIxWLhtdde47XXXqOxsZG6ujpp7LB582aMRqPMmhFBviJ0VTjn9ff3k8vlZF7Q4OAgAFVVVZSVlTFp0qRh+huz2SytoUWQavE5KXVeSiihhBIOHD6qgFkJjPUtvnz/DmVsKLu+Ab3ANcD3VVV9TlEUI5D/YHz5j3j9MmAZQG1t7QEe7ehUEkHdqqysJJFIyEKgoqICRVEkB1wUC8IVyev1ygTpzs5OHA4HdXV1mEwmzGaz1NZ0dXVJZx0hatVqtVJDs3PnThkAJyxuRUic1WpFp9MRiUTQ6/UMDQ1JuptGo5H0IIvFQjwelzoF8W8huP684pOeX/sDortWHFAqFvNizooiWbg0CTqh2LVua2tDq9XKOSpeL3bMY7EYVquVsrIyGdAqwigNBgNbt24ln8/j9Xrx+Xw4HA5pW9vf3y+dqYTmS1DMTCYTgUBAupbZ7XYOPfRQaa8r5q3Qv4huJEA6nQZ2UZhSqZQU9IvjTKfT0rxgIhQjB3tujaVFGFngjDT+GEvzJ95T2G9ns1mZuRKLxaioqJB6JkVRpHOdMHYQ+pdcLkc4HJb3IUVRpN7FZDLx7rvvMjQ0hMvlQlVVysvLqa2tlRs82WyW1157jUwmwxe/+EV5T41EIpKGu3PnTsLhMOl0moaGBqkNMxgM6PV6gsGgdLqz2+0lrUsJJZRQwieIcQsYVVUfAlAU5aejPS5+r6rqrft/aMPGoSqKEgM2q6r6lKIoPuBmRVESwE5FUf6squqOcV6/GlgNsGDBgn3q1oyV8VKMsZKpo9EoZrNZ5gcU563ALnqL6JII2o7P58NisRCNRmlsbGTy5Mly4RmNRtHpdITDYfL5vPziz+VyqKoqqWOhUEgWNcLFR4xfGAV0dXURiUQoKyuToZZer1cGy4ljiMfj0j5XLFiLbWk/j8LV/Tm/DjTGEvGLv6Hg9YvFqOhMCAc8Qcvy+XyEQiGqq6vp7e1lYGAAp9NJZWUlJpOJgYEBent7cTgcNDQ0SNG0cHKqqamR1rdikSl2vJ1OJ/l8flj+kMvlQqPRkMlkCIVCcrdcBCIKYwlhPCD+LRynBFVJHKder2dgYEAaVpjNZlmcCX3DaOdtLIH+gRLwH4y5tTfHIp470vhjLM2feI2gKxbPO0B20EQ3WbjJiWI0k8lIbYzL5cJoNNLU1ER9fb3sgAi6otBFVVdX43Q6ZZEhOjHNzc10dnYyZcoUdDodiUSCtrY2amtrcTqd1NbWksvlsFgsDA4OkkgksNvt0t3O7/dTWVmJz+cbNl/ENfN5uw+WUEIJJXyS2FMXsgXAF4H1H/x8EvAc8EnSyJJAg6IolwOz2KXNGQQagX9RFOUXQOZA08n2RKg70oWsmPMvuPki+8VkMsndYbPZjMfjkVkCiURC7mgLLvakSZPYtGmTXFROnTqVpqYm8vn8MPvQfD4vaTdiB7pQKNDX10cmk5Gp6tOnT5c5M21tbdTU1OD3+3E4HPT29hIOh6XFskigLisrG1W0/2kXMX9WUbwgFX+j4uJTiKjFTrnodggdjKqqGAwGysvLaW9vR6PR8O677xKNRolGo4RCIdm9O+SQQxgYGEBRFLRaLR6PRxoCiE6jKFaE41NlZSWpVIpcLkcwGCQWi9HT00NDQwP5fB6n00kikZCdQLEgFa5lg4ODdHd3yx1xjUYjNwBEp1FY9sKHnaViRz2xUBYd0JH4KIF/LBbbzQDj04riY7Hb7eM+dyyhfjH1cCSSyaSkKYrzbTQapUW7yAQqpsS63W5isRgGgwGr1UoikSAajZLL5airq5PvXVZWRiAQGDbvKisr0el0DA4OSrG96BqLQnbTpk1s2rSJN954g2OOOYbvfe97pNNpOjs7icfjeL1eXC6XdLkTro0Wi0VeQ6JwETRMcY2VCpkSSiihhP2PPS1gKoB5qqpGARRFWQk8qKrq0gM1sA8+xyY+U1XVgqIoVwDnAq4PdiZRFOUYYLGqqukDORaBvRFniiJE8KQFl3rkLrfQJIjuiBBEC2vOVCpFMBjE5XLR1tZGKpWSi7H+/n6cTiehUEguQqurq4lGo/T19cnPdzgckrpmMBjo6emhq6sLjUbDkUceicvloqOjg97eXsrLy5k0aZIMuxRfxO+//z6Kosj3Ewu/j3NuSjiwGK1ogbHDBIv/jmJxaDKZpA5Go9HQ399PLBaTbk7C2lZRFCoqKvD5fOzYsYNgMEh3d7fUcwmnMkFBFAVSNBqVVrZarZann3562CJ4aGhIOowJbYqwa54yZYrUMAhaj9VqHWYvLvJqxOcYDAZ0Ot2wHXPhUgbIYxK2ysWFSikDaXSMJdQX57EYwhhEuNIVCgX8fr8sZsPhMHV1dTLzqtgx0e/3k0qlcLvd1NbW0tHRIWmyQ0NDxONxUqmUpMiGw2FpYFJfX09bWxt+v594PE5VVRXvvPMO27dvp6WlhSuuuEIWUhUVFbz66qu0tbWxZMkSzGYzqVRKOqYZjUY5XywWC8FgUDqeiXu6yJspNpAQc/Lz2KEuoYQSSjgQ2NMCphbIFP2cAer3+2iKoCjKt4DFiqLcDLz8QWdlO/AMcK2iKBerqnoL4AQ8iqKUq6oaOZBjgt27K+NBLBwtFovMMCjutgByQSToY2L3UVgiix3AaDQqcy/EjnhPTw/d3d3MnDmTmpoastms3FUcHBxEURT5fn19fbS0tGA2m5k2bRqhUIh0Ok06naasrIwZM2YQjUZlCKEIDdTr9ZhMJoaGhgiFQuj1erZv305tbe0w1529PTcl7B+MRfcZrWgpDlEVi6lMJkMwGJRFjEinF4WNzWaTlrCFQoGBgQESiQTJZJL6+nry+Tw6nQ6n00kmkyGdTqPVarHZbJLm2NzcjFarRVEUqY1xOp3AriBLs9nMzp07aW1tpby8nGnTpuF0OslmszLXyGKxMGfOHAYGBiTFJxgMyiJdr9eTz+flcQQCAfL5PPF4XFIsKysrMZvNUpshijtB2/T5fGMWKsKZbawMJJFVIoqqT8sidbT5I45lTzYixjIuEF0YUagWd/kEtU+cn2AwKItH0VUDZPbQ5s2byefz6PV6aR7icDiwWCw4nU5pGjA0NER3dzdut1sWpul0mtbWVqmv2bZtGz/5yU+IRHZ9VcyePZvFixfzla98hYULF1JRUcGll17Kr371K8LhMP/yL/+CwWAgGAwyMDBAf38/8XhcBp8K+29xvMJKWXRiiml0I7ufn5Y5UkIJJZQwEbGnBczvgH8oirIOUIFTgd8eqEEpijIduAnoBk4ACoqivKqq6oCiKA8BHcBKRVEOBY4CTv8kipe9RfFu98jFj/gyF4w3g8EAfEjDMBgMhEIhtm3bJkXFOp0OvV7P5MmTZdifEPc7nU5cLhctLS309fXJbJdJkyYBSJG2VqulqqoKj8fDzJkzpftZe3u7TMUWOpj6+nomTZpELpejv79f2jtXVVXJRXDxQkQca2mX8ZPDWNSm0YqWYiiKgsfjIRAIEIlEZE5KMpmUc0v8/YqzYBobG6VWKplM0tPTg9FolDots9lMfX093d3dJBIJwuEwqVQKo9FIfX09iURCFuEOh4NMJoPZbKaiooKpU6ficrkwm804HA62b98uAxUtFoukRqZSKRKJBDabjWAwiN1ux+/3YzQaCQaDsgjLZrOyKyNML+LxOMlkUi4si2mbQkszWqHyUd3FYjOETxONcrT5sz/c1EQXplAoYLPZhuXKCPcu8ZlGo1F2yIaGhmRor6Diief6fD5SqRQDAwPDiqBEIiHvc+3t7eh0OkwmE7W1tcycORO9Xk9zczN///vf+Y//+A8WLFjA5ZdfzsKFC3G73dIsQuC2226jsbGRCy64gI6ODm6//XZpMiH0f7FYjEwmIw0FQqGQDGgt1gUW3weLvw8mwhw52AYRJZRQQgn7gj0qYFRV/YWiKI8D//TBr36gquqmAzcs0sAPgPeAK4Ez2WVG9pqqqnHgGUVRnmNXZyiuqmrfARzLXmHkAr6srEx+QQqRqaqq0oZTVVU0Gg3hcJhYLIbRaJShaSLQT1BvhLA5mUyi0Wiorq5GURTef/99Nm/eTH19PUNDQ/JLPJvNsm3bNpqbm6WQORaL8dhjj+FyuSgUCvT29jJjxgw6OzsJBoPU1NRgNBrlbrvZbKa/v192YkTxYjKZ6Ovrw+v1SovTj5veDaXk5Y+LsRbWIm9jPBcpsVBNJBJyXgqbYRFyKoobk8kkF2hCoD8wMIDf76euro5sNktHRwcWi4VcLicpX8lkEqfTSU1Njdwtj0QipFIpnn32WTo6OtDpdPj9frq6umQXMpFIMH36dObNm8eXv/xlenp6pG4in88TDoelOUU2m6WhoUHu9ovskKqqKmndHIlE0Gq12O12ysrK5PEIGhwgHc6A3Towe7qoH/n3mOgF/Vjzp7gz83HGrarqqO8tNmwExcxutzNlyhQikQjJZJLW1lby+TwVFRUyUFWcd1FYhsNhuYGi1WpJpVLy3unxeBgcHJT0WEG3veaaa3jppZc47bTTuOeee2SBkclkyOVycpNI4F//9V+ZOnUq3/3ud1m0aBG//OUvqa+v321TSqfTkclkqKyslMV4cXFWfMzF3c897XAdSHyazEdKKKGEEkZiTzswqKr6JvDmARxL8Wd1KIoSVlU19oHeZiVwxgcPv6woSq2qqh1A64Eaw8ddeIwmZB/Jpx9J7xHBk7DrC7W1tVUK6qurq2VoZTqdJpPJEIlE0Ol0kh6WTCbp6+ujurqaV155hU2bNhEMBonH4zQ3N3/kmBsbGzn33HMpKysjGo1KO9uBgQEZKieoP729vSxYsEDa0cLw4qOkg/lkMd7CuthxbOQcFrQbAI/HI4tksTAbGBiQ1JjijtuOHTvYsWMHiqJQW1vLc889x+uvv47X6yWZTMpMoPnz56PX64nH4+j1erZt28b27dt5++238fv9vP3224TD4WFj0mq1+Hw+ampq0Gg0rF27lvvvv58pU6Ywd+5cZs6cycKFC8nn89JcQOhnenp6MJlMGI1G2d0RnaFMJiO7AEKDJqhrIx2xRnZGBTUpkUjg9XolBXSswlBRlGG76hPd2GIs2udHdZLGoi4W/15QyAwGg9Q6ieeKAsJoNErdn81mI5/Po6oqkUiEUChENpuVz0+n07hcLioqKsjlcrS2tvLyyy+Tz+fp7e3FZrMxffp0HA4HWq2WdDpNIBDghhtu4KWXXuLyyy/n6quv3u1a0Gq1o97jjznmGJ5//nlOO+00zj77bK6//nrOOOMMacgiAlwBqfkqds6DDx3Jiq/BEtW2hBJKKGHfsccFzCeND4oX5YP/XwtcBRynKMp3gOMVRfkiEDtQrmMfd+GxJwv4kTx7YfXq8XiIRqNYrVYMBgMGg0HuOmazWVRVZdu2beRyOaZMmUI+nyefzxMKhXjuuedYuXKlFPdXVlZyxBFH8MMf/pD58+dLEan4LOFK1tvby09/+lOuvvpqli1bJouTaDTK0NAQDocD2GU7GwqFpLBWaHpGoyYV7zwWU3P2t8VsCeNDZJsIPYv4ncjf2L59O3q9npqaGqkFEaL5TGaX5M1isZDP54lGo/T29sod8lwux+OPP86vf/1rSRUSUBSFmpoaSRnbvHmzLHhNJhOHHnoop556Kk1NTZLmWFlZOSzUEKCvr49HH32UP//5z6xfv56HH36Y6upqjjzySM4++2xp893e3s62bdukTkZ0BT0ej6Q+Cptx4aSXTCalQUFbWxv19fWjLmKFta6w9BXuZnuKT2tB/1HjHqvTWvz7oaEh3n//fex2OxUVFfK5xR1ooe8rLy+Xzoytra3SSEEUQcL5y2azYbVaZbjvtm3bcDqdeDweysvLZWdj1qxZvPPOO5x//vm0t7ezZs0azjrrrL0+DzNmzOCll17izDPP5NJLL+WJJ57gtNNOo6amhtmzZ0vzgWQyKWnAolNZLOwf6fpXQgkllFDCvmFCFDCKohwCuIDXgYKqqvkPihdVURTNB/qWSxRFeRmoBk4W7mQHCh934bEnu2vFPHuLxTJsoelyuaQtqNvtZmBgAIPBQDQaxe/3S2eyuro6otEoyWSSV199lZaWFs455xyOOOIIjjjiCGpra8csFgTfXOCoo47izDPP5Oabb+aEE07gwgsvlA4/6XRa8rxdLheZTIbBwUH6+vpobGyUQlvYfVdW2LEWL3AmQjjgZxUjz7/INim2EB4aGiKXy7Fjxw527twpQ/iExkQ4zBUKBWkM0dHRQXNzM5WVlVRUVJBKpXj11Ve56667OOmkk/jTn/5ET08PbW1ttLS00NHRIbuIDoeD888/nzlz5jB79mwaGxslZasYuVxuN2tur9fLOeecwznnnEMkEmHDhg2sW7eOxx57jO7ubq688kpZVGg0GmkyUV5eTiqVAna5SoVCIXK5nPxdMRKJBLFYTIYUjoTFYpGFmFiE7w0+rbvtHzXuse6Pxb8XWTB6vX6YmL3YgbH4s8S80Ol02O126uvr5f3G7/dLM5EdO3bI93M6ndhsNiorKyUlrVAo8NJLL3HJJZeg1Wp58sknOfLIIz/2uXA6nfz1r3/lsssuY9WqVWzevJlvfvOb8vNVVUWr1TIwMMCbb76JqqocdthhzJgxY1hG1mgF30SnGB4s1NXVjfn9VVdXR1tb2yc7oBJKKGHC4aAXMIqinAZczy7BfjfwuqIo/6uq6tAHxUvhg+fNBhqAr6uq+u6BHteBXHiM7MCYzWaGhoaIRCLDsgRE8F9xhoZeryebzbJz506y2SyBQIA33niD//zP/2TFihXyM/amMVVbW8vTTz/N8uXL+d3vfkehUOD000/HaDRK69lkMkk4HJaCZ7/fT319PYFAgPLyciKRiNQ9wO6CcrHgUFWVWCwGfGirWsL+QSKRkIWwCB81GAzSzrW5uVkK3oPBILlcTj4uHLSEM5nIKALo7OyUtDGj0cjf//53Vq9ezbRp01izZg06nY7a2lpqa2v50pe+NGqBAqMXKXuK8vJyFi1axKJFi1i+fDl33XWXHJPX68Vms+H3+wmHw6iqKt3SRDK7RqOR2q5cLofZbMZsNg8LdB0NiqJgt9tlAGcJuyA6raqqStc1EbArrn273c6hhx4KDL/Wi8NEg8GgdE0U2iexwdPS0kJFRQWqqpLJZNBoNLL4EZ+XyWRIJBI0NzcTiUTo7+9n69at3HzzzUyfPp3169czZcoUSfX6uNDr9dx2221897vf5Sc/+Qn33nsv4XCYCy+8EJvNRiKRIBKJ0NXVhdvtlsW0z+dDp9PJeTc4OIjRaESv1wMTn2J4sDBegVL6ziihhBLgIBcwiqLo2SXQP0dV1RcVRfk2cCRwmaIoN41wFutgVxZNz8EY6/7EyA6MKJZERgYgv8xzuRyFQgGv14uiKHR2dtLZ2YnX6yWbzcrF4r52NsxmM3fffTcLFizgkksuYfv27SxatAhFUZg8ebJc1ArhrE6no6WlRbpXFQoFPB6PdACC4Xas4ksnHo/j9/tJJpNMmTLlUx/6N5FgsVhkx0UUku3t7fT399PR0UFnZ6e0xhb5GMItyul0DkuiT6fT0o7Y5XLR2NiI0WiODcNNAAAgAElEQVTkpptu4plnnuHoo49m7dq1kmL4SSGXy7F+/XqOO+44FixYQDKZpLOzE1VVcblcVFZW4na7ZS7I9u3bcTgc+Hw+BgYGpPWyyKcpLy+XVDJx/Ql9jJizo9nfft4XUaLbJyhe8KEtdXExI67vkYWO2WympaVFGowoiiK7KcX3BIvFIjuCRqORbDZLWVkZTqdT0tBgl5bGaDTy3nvvcdttt/GlL32JP//5z6N21fYFRxxxBC+//DK33XYbP//5z3nmmWe46KKL+Na3vkU+n6exsZF8Pk9PTw/Nzc1MnjxZhl+KnC9hwCKOr/j/JZRQQgkl7BkmwpaiHZj+wb/XAY8BBmARgKIoX1QUZY6qqpHPQvEiRMNC5Cp+Fm47gvctFpBiQWUymbBarcRiMdLpNFarFafTKd1z9nWHEXbtbC1btoxnnnmGVCrFLbfcwiuvvILZbKapqYn6+nqqq6ux2+0YjUa5m2+1WqmsrJQ6G0HVEbuxI0X+NptNLjxK2H8QgZKiiBQWwW63m6amJg477DApcq6vr5eZKZlMhvfff59cLid3iUWXrbu7m97eXjQaDbfccgvPPPMMy5cvl052nzSeffZZenp6OOWUUygUCnR2dhIKhUgmk9TW1uLz+chms7J7KAJXhe2tx+PB6/Wi0+lkkQcf0pr6+vpk4KGAxWKRifRC0P95R3HnQFAQxe9GOz/Fj6mqSjAYJJPJyM6yw+GgoqICi8WC1+tl6tSpeDwehoaG2LZtG7FYjIGBAXK5HA6HA0VROPTQQyUlMZlM0t3dzS9/+Uvmz5/P+vXr93vxIqDT6bj00kt54403mD17NitXruTiiy8mGo3i8/mYOnUqNTU1fOELX6Curg6v10t9fT2TJ0+WGTVis0BsXpW6eyWUUEIJe4eD2oFRVTWrKMqtwHJFUZpVVX1eUZQXgBrgREVRfgssBB44mOPcnxCce1GoFIe5wa7FUjqdlrbFJpOJcDhMT08PhUKB+vp6vF4vbrcbh8PBli1bAEin08OKGKF5GGsMY3Vsstksc+fO5YUXXmDJkiX86le/IpFI8OMf/5ja2lqy2azMAQkEAiiKQldXF1/4whewWq0y82MkhU1RFAqFAtFolEKhQGVlZUkPs4cYjw4o7JAFUqmUzKUQHQmRVA9IC+NUKoWiKGi1WuLxODqdjvLycqZPn04sFsPv96OqKk6nk02bNnHXXXfR1dXFXXfdxRlnnCENJEYiHo/vZkkrULxjPhJjBUQKCMrNQw89hNVqpaGhQX6W0WiUXUHhriboboK6GIvFZNfF7XbT09ODy+WS9tHCiUx0Ykaed7FDLjowo/1NxnLmGomJ2L0ZTYsx3rwbmTM08ncjX1v8mLC1ttls1NfXSwcysZgvKysjkUjQ29tLX18fqVRqWAaLMB9RVVVSAd9//31uv/12GhsbeeSRRzAYDMOcEoUpxWgQtvWjQbinjYba2lqeeOIJ7r77bq644gq+973vceedd8ruitPpxOfzYbFYSKVSVFZWYjAYpIU0jN05n4hzpIQSSihhIuGga2CA54FDgO9/INx/Dlj7QchWtaqqtx3c4e07RrMZLnbmAoa5GxmNRtl9gV1CZL/fTyKRkPawQ0NDcicTkNQfgbF0CICkEI0Gkefi8/n461//yooVK7j33nsJBAJcdNFFeDwe6urqMJlMZLNZuru7SafTvPvuu7jdbsrKymSHSOh5RLaNcHyKx+M0NDSg0+lKrjz7EYJnn0wm0ev1hMNhKioqMJvNMhtF/H2j0SiZTAaTyYRer+cvf/kLOp2O7u5uotEo7e3tpNNpgsEgPT09uN1unnrqKY466ihSqdSYWhadTjfuY2PNS71eP64+RqfTkc/nWb9+PU1NTezYsYP58+fj8/koLy8nm81KswuTyYRWq5Wp7WVlZZKGJOhOQmMmbHyHhobQ6XS43W45L4HdCpLxiqyPm4E0EbC3WoyRdtHFvysuhorvfUIzI/4GOp0Oq9UqNSJ+v19aXguqqnCHs1gsMuG+ra2N9957j7KyMurq6ujq6uLOO++krq6Ov/71r9KSvhhj3e+A3YIsizHefBbi/XPPPZfjjjuOY489luXLl3PdddfhdruJRnf5zFRVVUm6XTgclpSykVlDJZRQQgkl7DkOegGjqmpKUZTfAypwuaIojewKsvQAsYM6uAOAYnOAYs54MVccIBaL0dfXJ7s0wpKzubkZVVWpqqrCYDDIL+b9QSEbCb1ez69+9StmzpzJZZddRltbGzfeeCM+nw+TyURvby+xWIytW7cCu3YkFyxYQC6Xk52Wvr4+yXm32+3U1tbS398vHYXg07fYm4goFAoEAgFpE6zRaGQxk8vl6O3txWAw4Pf7GRoakqGPRqORX/7yl7z77i5fDIPBQGVlpaRaNTU1UV1dzbnnnivTzg8Wnn/+eYLBIMceeyz5fJ5EIoHL5SIajcrcGr1ej9vtJpfLyfR3IfoW154oZMT8M5lM8jyZTCZZZO1tQTJWcONEtRIXhYYI9RTna18xMucqkUhgMBgIh8Pys2w227DPEo5lqqrS3t6Ow+GQXRmRSZXNZunt7WXnzp2kUimmTJnCwMAAq1evxuv18vjjj0u78E8aDQ0N/O1vf+OYY47h6quv5kc/+tEwDaAwsIjFYtJoQnSiSxs4JZRQQgl7j4NewACoqjqgKMrdwBbgR0AK+BdVVQMHd2QHFqMtkMTiRuTBpFIpuru7yWazVFZWyo6Lz+eTVAxABr7tbyiKwvnnn8/06dP5/ve/zw9/+EOuuuoqJk+eLOkbdrsdp9PJlClTMBqN9PT0EIlE8Pl89Pf3U15eLvMbksmk3HUVWhoh7i19kY+OPXFuSyaTcsfXbrfj8XikGL2np4fu7m6qqqrQarWUlZXh8/n405/+xJo1a9BqtTz00EN85StfwW63SwH2RMO6deswmUx84xvfwGQyyQWiMCLQaDRyYSiK/ng8zrZt26Rmq6GhAZvNRiqVYmhoiGQyKXf80+n0MP3G3gqsRwsVFde40DzAxHGbGjk2u92+X67B4vMmPiOZTBKJRKiqqsJutxOLxSStLxqNyvkdj8dlN22k81s0GiUSiaDX66murqavr4/LLrsMm83Ghg0b8Pl8+zz2fcGUKVNkEXPPPfewePFiampqAOjt7aWmpkYef1dXF7DrWhVzpjj0UlGUkr1yCSWUUMI4mBAFDICqqhngGUVRntv1o1r4qNd82jHeAqmYDy5CJQcGBohGozLZ2uVyUV9fj16vlwuAA4Vjjz2WZ555hjPOOIPly5dzxhlnsGjRIrkrX1ZWRjKZJBaLkc1myWazDAwMYLPZSKfTUoMhqDliR7bYMWuiLOwmEkQXKxKJyEX6yEWyoEPBroyE4nMejUalpavRaJT6l8HBQX7zm98wY8YMHnzwQerr6w/C0e0dNm/ejM/nk4YRFosFt9stF8hOp1OaX3g8HkwmE319fVI/IWiMxY+LLo64BkXiu1hE7mt3cCzK6ETAgRpb8RwV7ylCb10ul7zuDQYDbrcbi8UiQy1F4S1ye3Q6naT/iY6zw+EgHo9z2223oSgKTz75JLW1tftl7PuK6dOn87e//Y2jjz6aF154gZNOOolMJiMDO4V5hDAsEAYuwiJa2KALrRCU7osllFBCCaNhwm3tqKqa/zwULzD8iz4ej0v6mNghBwiFQtTV1eHz+YjH45jNZlwuFzabjYGBATQaDfX19bS2th7w8TY2NvL666/z7//+7zz22GOcddZZrF+/XuoIenp6GBoaIpPJUFFRgdPpJJ/PEwqFaGtrk8YChUKB9vZ2urq6SCQS0sWohN0hrLRFWN9o50lYCQudSzAYpKuri7a2Nt58802Ghoaw2WxEIhEymQyhUIgNGzaQTCZZvXr1p6J4AVi2bBmtra28+uqrcuEHSIeq999/X+5WazQa+vv76e3tRavVymJFvEaj0UiqmNBd2Gw2qcuA4dckfGgFvDcZS6II0mq1uznyHWwUB0juLycsQc8T50gcv16vx+v1Eg6HZZCusF232WyyMBWFVCwWo7m5mZ6eHt566y3a2tpkh03Q/Z5++mmWLFnC9OnTP2JUnywaGxu58sorefnll/nb3/7G1q1biUQivPTSS7S0tEjXvEwmQywWk/dFs9ksc7+A0n2xhBJKKGEcTLgC5vOIkfajiqJI+oUQ55eVlWG1WvF4PFitVtra2mhtbZUZHs3NzZ/IWG02Gz//+c/ZunUrCxYs4LrrrmPNmjW43W5cLhe9vb1s2bKFbDZLRUUFkydPxuVyYTabyeVyMgdmcHAQnU4nd2ZLNInRIXIwqqqqsNlswxbAQl9hNBqpq6ujrq5OJn4PDAzQ399PPp/H5XJRU1NDPp8nl8vh8Xh44oknOPzww5k7d+4BG3symdyv1MbTTz+defPmcc8992AymTAYDPT398uFYD6fx2AwkEqlZPDqwMAAgUCAzs5OksmktPiGXZ2HYhqjKG7E2Ittf+PxuNTNjGYTnM/nCQQCozqzfZqxt8dVTEsbWeyJYlx0XkQhEolECAQCxGIx6TyWSCSktsloNMouhKD5bdq0iWw2yymnnHJAjntfcfbZZ+Pz+XjxxRdpamoCdjlN9vf3U1FRQWVlJS6Xa5iYX3QGHQ6H7L6X7osllFBCCaOjdHecABA5E8W7baJ4sdvtMjF82rRpHHHEEZJCIxZqNptNivs/KdTU1PDEE09wySWX8PDDD7NixQr8fj9NTU1MmzYNn8+H2WzGZrNJzntLS4sU8Gq1Wsxm87j2piV82KUbbede2B0nk0nKy8tlqKTdbueQQw5h0qRJNDY2MnnyZCorK7Hb7USjUd577z22b9/OsmXL9vt4s9ksGzdu5Ac/+AF1dXU0NTWxYcOG/fLeGo2GX/ziF7S3t3PDDTfI3epoNEptbS1VVVWkUil6e3t5++23ef3112lvbycej1NZWUljY6Ok7cCH2qJ4PE44HKatrU3ufgttV7GOA4bvihd3ZEKhED09PYRCof1yrBMFxce1Jx0oYXUci8VknpB4nclkwuFw4PF4iMfj7Ny5k5aWFlpbW2UH2W63MzQ0RCAQIBqNUl5eztSpU2lqakKj0ZBKpYhEImzYsIFJkyZxxBFHfFKnYq9gMpm49NJLefbZZ3n33Xc57LDDmDlzJrNnz5ZdvkwmI40URAEtrvdS4VJCCSWUMD4mjAbm84yRXPviXApA7k6WlZURiURQVZVcLofRaKSrq0vuIAcCAUk9G2/ne3BwcMwd1f7+/jEDClOp1G4uP1dddRVz587l3HPP5eKLL+aaa67hi1/8IuFwGI1Gg9/vl7kNVVVVaDQaSYUS3YOPKrwmEu3mYGC8fJHin0XuiUiij0QilJeX09/fL0Muu7q62LBhAw6Hg1NPPXXMeSDMIUZDOBweFhKoqipvvfUWjzzyCOvWrWNgYACHw8Epp5zCm2++yZlnnskpp5zCT3/6U2bNmjXqe6bT6THzYwA5zq997WssWbKE++67j6OOOorjjjtOFsRarZbOzk5ZPPf392M0GikvL2fSpEn09fVJu2Sj0cj27dtJJpPU1NSQTqflXJ0yZYqckyJrBNjNWrm4sKmoqBj2/8/KnC0+rpHuYgIj56fIuBKBqn19fTKA0mQyEQwGSaVStLW1YTabqa2txePxUFlZSSQSYdu2bSiKgs/nk/cMkSGl0Wjo7Ozk5Zdf5te//rXMl8rn8+Oe8+Jg0pHo7e3FbreTyWR4+eWXcTgczJ49W+a1jOVsJqiyo6FQKLB06VJuvPFG7rzzTu68804aGxvJZDIMDg4C4PF4sNvtsmsqChiz2TyupXgJJZRQQgmlAmZCojjsUgj4hQWpx+OhrKwMs9ksxdsNDQ0A+P3+vXLiyefz/N///R/BYFAuAIUmRfw8c+ZMJk+ePO77nHjiiTz99NP88Ic/5KKLLuL000/n3/7t33jllVfo6+vD6/VKK1GRcSP0B+OFyJWwC2PZ+QpHMpPJJJ2cxEJv27Zt0tFJFMIVFRVUVFTw/PPPs2zZso913kUxumXLFtrb22lubmbjxo20tLRgNBpZuHAh3/72t/mnf/onaTbxm9/8hrvuuosXX3yRW2+9leOPP36fzsdtt93Gq6++yk033SSTz61WqxRAB4NBamtraWxslMV+a2srmUwGp9OJ0Wiks7OTVColrymLxUIoFJI0R0F3Eue8WBcjFpvibyAW7sVZTp8VaLVaeVxjmY6MnJ8iRNLr9UpBvsjWCQaD+P1+mesSDofxeDzU1tai0+kIh8PE43GmTZtGZWUliUQCv9+PVqslEomQz+dZu3YtM2bM4Oyzz97n41NVlS1btrBx40bWr19POBwGwOVysXDhQg4//HBOOukkvF7vXr+3xWJhxYoVXH755WzdupWamhqGhobo6upi2rRplJWVSQc8UaTtTRZPCSWUUMLnGaUC5iCiOPANPtzZLXanMZlMw9LL7XY7JpOJtrY2CoUCdXV1aDQa7rjjDvnl+1HIZrP84Q9/4M477/xI7YzBYOC8887j/PPPH3eHc+rUqTz//PMsX76c3/3ud0QiEY444giSyaTsuIjdU6/XK2lxg4OD5HI5ad9bwu4YuXAszhaBXYvq9vZ29Hq9FKv7/X5UVcXn81FWVoaqqvj9flavXk02m+Wcc87Zo88eHBzkjjvuYOvWrbS3t9PR0TEs4Vyr1XL44Ydz3nnncfzxxxONRiWVDXbNnwsuuIBjjjmGn/3sZyxevJjTTjuNG264YdTAwT2B1Wpl7dq1fOlLX+Lee+/l7rvvxu12U1dXh6qqDA4OMjg4iFarZfLkyVI0nslk8Hg8pNNpdDodLpeLyZMnSyH5rFmzpAhdaDWKrz34sAsjnvd5mrfFneLirunI+RkOh4lEIlKzBx9m7YjurtPpxGq1EggEqKyslOdV6OY8Hg82m02agAih+0svvcSWLVv4wx/+MG5Y70chGAzy4IMP8sc//pGtW7diMBj4+te/zqmnnkosFuO5557jueeeY/369Vx55ZUceuihfPWrX+XUU0+VmpY9wbnnnstNN93EXXfdxXXXXSd1MGVlZUyaNGmYqYTIbxo550oooYQSStgdpQLmIKJ45xIYtoup0WjkAqmiooL+/n5qamooLy+npaWFHTt2ALtSnsUXXltb2x597l133cWqVas49NBD+fWvf83cuXPJ5/Pk83nC4TBWq1XmYqxZs4bbb7+d3//+9yxevJjly5fjdDpHfV+LxcI999zDUUcdxQUXXMDAwAAnnHAC2WwWr9dLb28v4XCYQqFAdXU1iUSCbdu24Xa7mTp1qgx9+7wsCMdCcWErck6KOy9i3ghBuclkwmg0kkwmZeFrtVolpUx0HO677z4efvhhvvKVr3DIIYd85DiefPJJLrvsMnp7e5k5cybTp0/nmGOOwePx0NjYSF1dHTU1NcNSzkUWzUg0NTXx+9//noceeohbbrmF5uZmnnzyyY/N9Z81axa33nor5513Hhs2bGDhwoVMmjSJmpoaqbvo7+/H4XCQy+UYGhqiurpaZou4XC7ZKQDkAlnshAuXrJHjExoFVVXlfP28Y+T8LKadifMlOld2ux2v14uqqlL7J85zoVBAq9VSW1srO8F6vV5aiRsMBv74xz8yb948TjvttH0a8wknnEBbWxvz58/nyiuv5Dvf+c4wWuS3vvUtCoUCr732Gm+99RbPPvssv/nNb7jzzjv5wQ9+wGWXXSY3EMaDzWbjggsuYOXKlXz5y19m5syZ+Hw+mpqaiMfj9PT00NfXR0NDA3V1daPado+8H5RQQgkllFAqYA4KihOwYTglw2QyScEr7NrxbWlpob29HYvFgslkQlVVampqyGazlJeXk81maWho4KGHHmLp0qUf+flvvvkms2bNYuPGjbsVCw6HY5gGZt68eZx11lmsWrWKW265hd/85jcsWbKE8847b1RqmaIoLF26FK/Xy6JFiwCYPXs23d3dDA4O4nK5JAUuk8lgNpvlTvzepJ5/llFc2I5GJRHzRWToCLeiRCJBIBAgkUiQSqVIp9OUl5czMDDAqlWruPvuuznyyCO59957x/38cDjMRRddxIMPPsghhxzCmjVrhrmVjdTA7Cn0ej2XXnopkydP5ic/+QkbNmzgxBNP3Ov3EVi8eDEXXnghTz75JLAr3HXevHnU1dVht9tloGokEpHBqWJzwGq1Eo1GCQQCcoENSIMMUQSNhY+bETMRF6P7c0yqqkqtnHgvUVSL6x52FbqbNm1Cr9dLi/BkMkk8HpevE2MSuS+5XI62tjbOOeecfdrkyGaztLW1cdFFF3HFFVdIDcxIaDQaZs6cyf/7f/+PCy64gHA4zE033cSaNWt49NFHueKKK1i6dOlHjmXFihU88MAD3HHHHVx00UXU1dWhKApVVVXE43EymQzZbHbMzstH3Q8+bxDnb6zH9nQjr4QSSvh0Y2J8g37OIL6QROZBcT5FIpFgcHCQUCgkKQVOpxOTyUQ2m5ULsfr6eurr6xkYGCAcDnPYYYfx9NNP093d/ZGf39LSQmNj4x4vAo466ih+//vf8+ijj3LCCSdw1113MWfOHC644IJhdKJinHzyyTzwwAO89dZb3HjjjRQKBbxeL1arFYfDQTAYBHYtGEXQoEajkeGL0Wj0E3VVm0gYzZWuGGLxLKxWi/89ZcoUqqurOeSQQzjssMMwmUysW7eOu+++mx/84Ac8++yz4+a+PProo8yfP59HHnmEFStW8MQTT+x3q+XTTz+dadOmcf31149qSbyn0Ov1TJ8+ndbWVmkA0NPTQ6FQIJfLUVFRgcFgoKKiAr1eLwsasRgWdr8mk4nKykoqKyuxWq2kUikCgYB0FCsUCsTjcdLpNC0tLWSz2VEdufbEpWukZfpEwJ6OSRxfPp8nFovJa7T49319fQwODg7LfAoGgwwNDckgVvGZWq0WRVHIZDLD9HHl5eWk02nS6TSRSIRgMCgNAeLx+MfSoxSjr68PYK/DL10uFzfccAOPP/44NTU1XHTRRRx//PFs3bp13NdZrVbuu+8+AoEAr7zyigybjcViNDY2MmfOHOmyNho+6n7weUNbW5ucdyP/a29vP9jDK6GEEj4hlAqYg4DiLySxeAiFQlIcnE6nZXpzPB6XHP3+/n66u7vJ5XIytTmdTqMoCscccwyqqvKHP/xh3M+ORqP09vZ+rPC3mTNncvfdd/P222+zdOlSfvvb33LWWWfJxcpIFBcxP/vZzxgcHCQajbJlyxZeffVVenp6MJlM5HI5enp66Ojo4L333qO7uxu/309fX9/nsogRAYOjLWiKF8mpVIpCoUAqlZJ0Ma1WSzKZJJFIoNfrefvtt7n22mv54he/yKpVq8bUDYRCIRYvXswZZ5yB1+tl48aN/OxnPxvXGezjQqfT8Ytf/IKdO3dy4YUX7tPfuKmpiVgsxqRJk6SAXBQwoiDW6XT4/X46OzvZsWMHoVCIzs5OaZQhri+bzYZGo8HtdlNZWYnJZKJQKMhMmB07drBz5062bds2aibMnhQCE3ExuqdjKr5X+f1+WlpaiMViw35fLNgHpBveSG2H2+3G7XZjMBjYvn07wWCQdDpNLpejubmZwcFBIpEI77//Pn19fVI7AuxzAdPb2wvsot9+HMyZM4fHHnuMG264gffee48jjzySf//3fycWi435mvnz5/Pzn/+chx9+mPXr1/Puu+/yzjvv0N3dTW1tLalUimg0OiyLSGC8+8G+QFGUZYqivK4oyutiQ6mEEkoo4dOCEoXsIEB8IcGHdCCTySQXpHq9nmw2K4XCFotF0rU8Hg9dXV2Ew2GSyaQM4/N4PBx++OHcf//9rFixYlhgXzHee+89YNduYmdn526Pd3d3j0kPisfjVFdXA7B06VJcLhc33ngjJ598Mrfccsuo4tZ//ud/Zs2aNfzwhz/k6quv5pJLLqGuro6hoSFZoAwODjI0NER3dzd2u52GhgY0Gg2ZTIZEIjEuVeezopcRO4ij2SWLx4TGRSyUhBOd2WwmFAoRjUZxOp2Ul5dTKBTYsmUL1157LQaDgd/+9rdyMQ7Q2dkptSsvvvgiP/3pT4lGo1xwwQX86Ec/IpFIjDo/ALq6usacI4FAYExr2XQ6LamRc+bMYcWKFdx6663U1dWxePHicf+WY1FnZsyYwcMPPywd+IaGhmTwYaFQwOVyoaoqkyZNIp1Oo9VqpSW5TqejqqoKi8VCPp+XrmRarVbmkYidf0BSKwXdaOSifyyXrmIUX/sTBXs6puJ7VfFCe+Q9rNhsQry/xWIhmUxiNptRVZVsNovT6cRgMGAwGLBYLBiNRrLZLFqtFr1ej9lsxuv1Eo/HGRwclIWHx+PZzf47kUiMK+ovtgUXxiVWq5VIJEJnZ+eYf7NQKCQLp5GYN28ef/3rX7nlllu4/fbbefjhh7n//vuprKxEVdXdOjzLly9n48aN/PKXv6SxsVHOsWAwKIteYWggzqO4JorvDfurkFFVdTWwGmDBggWfv52iEkoo4VONUgFzkFHMpRfi4EQiIekWIidALDLS6TROp1PSybxeL4VCgc7OTo4++mhuuOEGNm/ezIwZM0b9PEExmzVrFjabbdTxjCVOjUQiw/IJvvOd72Aymfj5z3/OhRdeyPr160ddCJ100kk88MADLFq0iJtvvplrr70Wu90uxdTCNnXSpEkymbq9vR2bzSY7AONloXxWIHayxd+7+FhFF6CsrEymxyeTSbmgcbvdsvOg1WppbW3l/vvvZ/v27fzlL3+hrq5ut8/TaDSsXbuWlStXMmXKFO6//34p7h/vHI83R4xG45juYqJwEFixYgWtra3cfvvtTJ8+ne9+97tjfuZYi9NZs2bJ4k5VVbRarczvCIfD1NfXU1ZWRlVVFQ6HA7/fT01NjXS/E12rYntkjUaD0WiUIZqld9YAACAASURBVLICer2eWbNmDTvvI8/LRCtO9gWjZQ6J46uqqpIFnLiHFXfSxGutVis+n2+3rBMRainCR00mE6FQiEKhQCQSweFwYDAYSCaTVFVVUVVVhd/vl589MifFaDSOm51SXHALo4lp06ZRXl4uKZijIRQKjdmFTKVSVFRUcMMNN3DqqaeybNkyli1bxtq1a0ftmGg0Gu655x4OP/xw7rjjDq655hpp820ymaQldyKRkGMsphiLjYvP0hwroYQSSvi4KFHIJhgURcHr9eJwOGT+hNVqlbu+gUCA/v5+7HY7DocDm81GJpMhHA7T1NSETqfj/vvvH/P9t2/fjl6vZ9KkSftlvCeddBLXXXcdb7/9Nt/+9rfHDEAsppNdddVVvPPOO7S2ttLV1SU7C5MnT8bn8zE4OCjzIITGZiQ9R1CpcrmczD+ZiBALjz0Zn6DyALtRkUQyvNVqlXka3d3dDA0N0dPTQyAQkDu3g4ODbNiwgQcffJCrr76ar33ta7t9Vj6f57rrruOqq65i4cKFUrD/SUJRFP7rv/6LOXPmcOmll7Jly5a9fo+ZM2cCu7QvQpTf1tYmC3VhbDA0NERzczNarZbBwUHcbjcOhwOz2Sz1MGIXfnBwkP7+fqlBE8VjMpksJaV/AFG0FBc5o1HoxPkSBV8ul8Pv98vOqlarlbqjTCZDR0cHHR0dhEIhBgYGaGtrIxwO43A4hnUp9gW9vb3o9fqPbeM9Gg4//HBWrVpFS0sLP/7xj8fUBtbW1vLf//3fvPLKKzz88MP09/fT2toqNZEwOsUYdu/4CezNPaaEEkoo4bOCz/e38ARF8eJA0H7MZjNWq1WKjZ1OJ4VCgUAgQDabxWKx4HK5+OY3v8natWvJZrOjvvfOnTulnez+wje+8Q2uv/563njjDU4++WR6enpGfV5xEbN+/XqGhoaYPHkyFRUV6HQ6Ojs7aW5ulkWcCH7L5/O78fRHaocmkii6GHsj2i4W54+nSUgmk0SjUUnzevPNN9m0aRPRaBSTyUR3dzf33nsv3/zmN7n44otHfY9rr72W//mf/2HJkiWsXr161G7cJwGz2cw999yD1WplyZIlu1GDPgpTp05Fr9fT2tpKdXU1U6ZMobKykvLycrxeLyaTCZvNhlarJZ1OE41GyeVyMkBVo9HQ399PIBAglUphtVrR6XRkMhmCwaCk6AlKWmmRODZEVy6Xy+12nor1WqPBbDZL62qPx4PX6yWRSJBIJDAajbhcLrmQF9kyHxddXV14vd79XoQuXLiQ//zP/+Qf//gHK1euHPN5Z5xxBt///vdZs2YNzz77LK2trYTDYakRLO40i/ueMOsYrTM6EY0hSiihhBIONEoFzATHaLu/hUKBnTt30traSnt7u6RgmEwm5s+fT29vL+vWrRv1/RobG+ns7GR/iza/9rWvsXbtWpqbmzn66KN56623Rn3eySefzB//+Ec2bdrEunXriEajDA0N8dJLL/HGG2/Q3t5OIpHA7XYTi8WkG1Qx1U4sQsvKyqioqJjQi8uPI9oWCxdh5auqKoFAgO7ubnnsIghUCKadTieJRIKuri7+53/+B4PBwK9//etRF2nvvvsuDz74IEuWLOHqq6/er8Xsx4HP5+Pyyy+npaWFV155Za9eq9frmTlzJsFgkIaGBvR6vdRPFQoF7HY7lZWV1NfXU11dLelMgkImMl/KysqkxkWcV1HE5PN5gsEgoVCItrY2+brP6663cGUTlDFVVYlGo/T19RGJRGhra5OuZH6/n0gkIrV6Xq8Xn8+HxWIhHo/L6zaZTFJRUUF1dbXc1JgxYwb19fW43W5ZAI1HX9wTZLNZnnnmGQ4//PD9dTqG4aSTTuLHP/4xjzzyCE899dSYz7v99tuxWq28+OKLckOps7OTlpYW+vv7pT5w5L1gNExEY4gSSiihhAONT20Bo3xWhRAjIKhDwkI0Ho/T1tbG0NCQ3K0MBoM0NzfT19fHrFmzmD59OnfccceoX3hnnXUWhUKBRx99dL+P9dhjj2Xjxo1otVq++c1vct999406hhNPPJF7772X5557jksuuYR3332Xnp4enE4nNTU18gvb6/VSXl4+LJdGUIKCwaB0kBKhnxNxB/LjOggV76qKjksqlSKRSEhHplgshl6vZ+7cuVRVVZHL5QgGg/z973/n7LPPHpMis3LlShmwN1Hw1a9+FZPJxF/+8pe9fu3cuXN58803sVqt0qFPVVWCwSDhcBhA2o8PDAzQ3t7Opk2b5IJ706ZNZDIZMpkMyWRSanUMBgO5XI7Ozk7C4TDt7e2Ew2H6+/s/17veI49dXJPRaHSYA1koFKKlpYW2tjZSqRRms3mYnsPv9xONRgkGgwwODkoaWSgUoqurSxaZgUBgXIevvcETTzxBOBzm29/+9n55v9Fw/vnn09DQwPLly2W+0Eg4nU7+9V//lZdeeomysjIcDgepVIpgMEhfX580MIGP7rAcKJeyEkoooYSJjE/dHU9RFBuA+hn31xWidUByxAWFor6+nilTplBfX4+qqsRiMSlIVlWVOXPm8MYbb/CPf/xjt/edPn06c+bMYd26dQfEovjQQw/l6aef5vDDD+eCCy7gnHPOGVUX873vfY/bb7+dxx57jHvvvRebzSYpY5s3b6ajo0Omb4fDYTlWi8UiaXTFrk+ftR3I4mMym834fD4aGhrweDxSsD80NEQ0GiUcDsv58fjjj5PNZscsTl544QU2btzI0qVLcTgc+zTGlpYWrrnmGv785z/v81yyWq0cc8wxPPbYY3tNI5s7dy7hcJjm5mY6OjpIp9N4PB7Ky8tRFEUuro1GIx6PB4vFgsFgAKC/v1+64BmNRrlhIPKIhAOgy+Wirq4Ol8uF2+3+TM65PcXIYxfXpJijNTU1WK1WKioqmDJlCrW1tRQKBaLRKO+//z47duwgEAjIAE1heV0oFHA6ndTX1+NwONi5cydbtmxBr9djsVjI5XL7bOBx3333UV1dPaoubH/BaDRy7bXX0tbWxnXXXTfm8y688EIURWHVqlW4XC4qKytRFEW6s32W728llFBCCfuKT5ULmaIoJwKLFUVRgYtVVe1SFEX5LBYzxeJNi8WCyWSSlspixy0ej0uti9lslgGQX/7yl3nyySdZtWoV8+fP3+29v/71r3PzzTfz4osvMmvWrGGP9fX1jclT7+vrGzPzJZ/PDxOu/sd//Adr167lnnvu4eWXX2b16tXMmzdv2GtOP/10urq6uOmmm1BVVboNieBOcUy5XI7e3l6Z5F2cKSEWQSaTaTeXsonUpNvbKVpMHTGZTFgsFkmpSyQSshun1WopFAr09PSQy+V4+OGHOfHEE2loaKC3t3eYM5Oqqlx++eVUVlby1a9+la6urjE/X4T9jYZ33nmHZ555hhdffBFFUXjyySd54YUXOPPMM8nlcmMWIOOljSeTSY477jgee+wxnn76aY444ohhj4+3uyzsu9etW0djYyM+nw+3243f7yebzTI4OEggEJDp8G63G6fTKfNEkskkdrtd0jSFC15LSwvJZJKmpibq6uokVVOj0QyjNI72t51Ic29/QzjkwYfHLpyxxDUoHhMuisUdlHQ6jdVqxel04na7Zf5LIBDA6/VSWVkpNUmKopBIJIhEIpJKmsvldhtTPB6XtuCjoa+vj66uLp599ll+/OMfy84c7ApGHIuW1tnZyeDg4KiPZTKZMee60+nke9/7Hv/93//Nsccey+zZs4c9Lgq+7373uzzyyCOcd955DAwMEAgEcLvdmM1mhoaGsNls8l4gzul4+CzPuxJKKKGEYnxqChhFUf4J+C/gR8APgBuBf9mT4kVRlGXAMtj79OUDDSHUH+nxX7z7pijKMBGscEEqKytj2rRp6PV6FEXh5ZdfpqWlBYvFwle/+lXWr19PKBTa7ZiXLFnCqlWreP755zn++OOHPRaNRsfNgXE6naM+FggEhn156nQ6Fi9ezNy5c1m5ciWnnnoqP/vZzzjvvPOGLUZXrFhBJBJh9erVVFRUsHjxYr785S+Ty+Vob2+XgmuR7aHT6SgUClRVVVFWViYLvWI9wni5MQcCB2p+JRIJBgcH0el0WCwW2tvbCQaDOJ1ObDYb+XyeTCYjF3kbN24kFApx0UUXoSgKer1+mL5lw4YNvPnmm9x66614PJ5x7VhHK1RTqRTr1q3jgQceIJ/P8/Wvf51TTjmFJ554gr/85S8EAgGWLFkypsg6FouN2fUxGAyceOKJXHrppTzxxBMcffTRwx4fL1Bz3rx56HQ6Xn/9derr6ykvL2dgYIBIJCIXz6LoE5opjUaDqqqk02lqa2vlnBRWv06nk8rKSux2u7zmxppXB9Lie6Leu0bLJynedCnuGgtTCmEVLHQvYqPEaDTi9/vJZDIyzNFgMHDIIYdIK2Wh9VMUZVTNVllZ2bg2yjabjUcffRRFUVi8ePEw04ry8vIx73l9fX1jUjEDgcCY11A2m+Xqq6/mqaee4rLLLuPxxx8fNm5x/i6++GLuv/9+7rvvPk4++WTy+Ty9vb3E43HsdjvTpk37xO9nJZRQQgmfBnyaKGT/DPxZVdXngesBjaIoVyqK8gVFUezjvVBV1dWqqi5QVXXBvjrYHAiMZz8qvujEF7mgvojnFPP2TSYTHo+HmpoaTjnlFADuvPPO3T7PZrNx/PHHs379+jE7KvsLs2fP5n//93/5xje+wS9+8QsWLVo0bHdfURSuvvpqFi9ezAMPPMA999zD888/Tzgcpq+vj46ODiKRCOl0Gp1OJzUOAhaLhbKysmE5Cp809uf8EvbQqqpKMbnYca6rq6OxsZGpU6fS0NCA0WiUXPlUKsXTTz/NvHnzWLhw4W7vm8vluP766z8yb2U0FAoFnnrqKZYuXcpvf/tbpk2bxo033sjixYspLy/nO9/5DhdeeCFdXV3cfPPNMix1b1FWVsbRRx+91zQyk8kk82Dq6+spFAqy+5LL5Xj77bfJZDLo9XpSqRSxWIze3l66u7sJBAKyqyWusVwuRyqVor6+HpPJhMFgkILz0XAg9TCfpnuX6E6JboZwbxP/FvcyjUZDKpWip6eHjo4OAoEAvb29ZLNZEokE7e3tbNu2Db/fT3l5OdlsFpfLJTdqPg6y2Sx/+tOfOProo/n/7J13fJPl+sa/b5qkadOk6V7QRQtlHEDBqiggICrKEkWGDBcgBz3KQRQ8ylZAcSDjMAQRVAQUZbvgICAKyBBQoVBW6Up3mzZNm+T9/VHf55d0MRQFyfX58AHelecdeXPfz33d1xUREfHHnPwF4O/vzyuvvMLRo0dZvHhxrdu0aNGCQYMG8f7771NaWupGT4yNjXWrWFYXT/DAAw88uJ5xLSUw+4E2kiS9COwEzgIhwDPADXDtNva7cpzrUjfKz8+nqKjIjfqg7KtWq4WxZdeuXenYsSNBQUH07t2bJUuWkJubW+Mz+/btS3FxMZs2bbqsMaenp7N+/XoOHTpUp/eLAoPBwKJFi3jttdfYu3cvXbp0cVObUqlULFy4kN69e/Ppp5/y0UcfsXv3brKzs9FoNERERNC0aVOCg4MJDw8nLi5OzEpKkoRKpRLmn9fKI+CaqLjCNSCs7glkMBjEv1UqFUlJSSQkJBAYGCgqIPPnz6/1GixYsICUlBRefPHFi1YdUxSbnn76aWbNmkVAQACvvfYagwcPrhEE3nTTTUyaNAmtVsuzzz7Lzp07L+u69OrVC7PZzJ49ey5pvxtvvJEDBw6gVqsFZayyspJTp05x7tw5MjIycDgcohpjMpmIiooiLCzMzZG9oKCAvLw8UaVxOp3k5+cLJcDaoCTRTqfzugouZVnG6XSKiYPqUsmKGa/FYsFqtWK1WsnMzOTUqVPodDr8/f2FWpzBYCA6OpqwsDCCg4OBqipgWloa58+fZ926dRQUFAhVvkvF119/TU5ODgMHDrzs8127di2zZ89m586dwmjyQrjvvvu4++67ee211+pM7KdNm4ZarWbVqlXEx8eTkJAgjIYVjyyouh6FhYVCoeyPxJEjR5AkqdY/tZngeuCBBx781biqKWSSJLUGbEClLMubJEnSA62AbbIsj/9tmynAUODba7UXRqGDQRXNxpWGoUD5UQ8ODhbBrzLjmZSUREZGhlDuUjjjnTp1YuPGjfTv35/Nmze7VW/atWtHixYtmDJlCrfffjvh4eEXPd6ysjImTZrk5vfi7+8vqgMJCQkkJSW5/fBJksTgwYNJTk7m8ccfp3///syZM4cePXoAVZSzFStW0KdPHz788ENkWebhhx/G398fk8lEQUEBqampNG7cmIYNG4rgUpn5Ba6pJtfqdBsFrtRBhZ6jzMLm5OSIhueysjKCg4MJCgpi+fLlrFu3jpkzZ9boM3I6nbzyyivMmTOHe+65pwZlsDbk5ubywQcfsGnTJgoKCoiMjOT555/njjvuQKVScfDgwVr3a9iwIc899xxLly7ljTfeoFWrVsKY82LRtWtXfHx8+Pzzz2nXrt1F7xcQEIDFYuHMmTOYTCZMJhPR0dH4+flhs9kICgoS37HIyEg0Gg1eXl6CSmS1WgkKCkKlUgkpZqXfShGSqKtPQkmii4uLReX0ekBZWRkWiwWj0ejWp6FMxFitVrdqDCCut1qtFr0uRqORwMBAsY2yv8lkwuFw4OXlhVqtFgIhmzdv5r777ruksW7atImQkBA6dux4Wee6fft2PvjgA7RaLd9++y0qlYrY2Fg6derELbfcQkJCQq0TB5IkMX36dLp3786DDz7IihUruOmmm9y2iYqK4sUXX+Sll17izjvvpH///sKDSKHThYSE4OPjIwRbFCPQPwoVFRXXVfLtgQceXPu4aiswkiR1AzYAo4DPJUl6WJbl1cAcwCJJUrPfNk0B7JIkaes41DWFuhRnvLy8CAsLw8vLi7KyMiE/ajabUalUREZGCi6/4kLesmVL/vOf/7Bjxw7eeOMNt+OpVCrmzp2L1WrllVdeuejxybLMvHnzyMrKYuLEiUybNo0nnniCFi1aUFBQwJo1a5gyZQoDBw7kpZdeqmFq2aRJE9avX0/Lli0ZPnw4CxYsED+cOp2Ozz77jF69evHRRx+xatUqiouL+fbbb/niiy84ePAgKSkpooG9pKREuHpfyCvhr4JSUas+LiX5VOhJynpXE1MlybFarZSWlgqpWWUfi8XCli1bmDFjBr169eLZZ591+wyr1cqwYcOYM2cOQ4cOZenSpfVWqA4fPsy4cePo2rUrH3zwAQkJCUydOpV3332Xzp07X5RMq6+vL2PHjqW4uLhO2kx98PPz46677mL9+vV1mrHWhtzcXMLCwoTceEVFhTBE7NSpE2FhYcIXRlFvU+hiFotFqJbFxsYSGBiIVqslJycHnU5HRUUFdrud3NzcOmlk16NSVPVzdn12S0tLxXfTx8dHfGcVg1q9Xo+Pjw8Gg0H8W7kfZ8+eJTc3l8LCQnJzc7nlllvo3Lkzo0aNIjY2lldfffWSvuc2m43//e9/dO3atd4+mbqQmprKggULaNGiBStWrGDmzJk8+OCDOBwOlixZwrBhw3jwwQeZPXt2rQ3/ERERfP755wQGBtKvXz+2b99eY5sxY8Zw4403MnHiRA4dOsSJEyfIysqisLBQ0IRVKhWBgYHYbDa3yShXXM/+RB544MH1hauuAvMbDUwPPA2MkmV5vSRJtwIrfut1WQQ4gdGSJDmA24EBsixX/GWD/gPhWo1R6BLVG4SV2fnKykoxU6fX6wkJCaGiogKTySQCsjZt2tCrVy9ee+01HnnkETfqT6NGjRg6dCiLFy/mueeeuyiqwNdff8327dsZNGiQMIO74YYbaNeuHU2aNMFut3Pu3Dm2b9/Ohx9+KNSpJkyYIGZfAwMDWb16NU8//TSTJ08mPT2duXPn4uXlhbe3NytXruSxxx5j+fLllJSU0L17d+Go3qhRI7cfaKU3QWl4t1gshIaGXjVUsroqLQrdJj8/v4b4gHLPXWevFblkb29v1Gq1MDh9/vnniYuL491333U7Z7PZTN++fTl48CCTJ0/mySefrPOaHD58mBkzZnDkyBH0ej39+vWjU6dONGjQ4LLOOTExkT59+vDpp5/SrVs3oRJ2sejZsyfr1q3jwIEDNdTI6oLZbBbBcVZWlugXUKvV6PV6UVVR1Oy0Wi1Op5OcnByysrKIjIwUjdx6vV5QnZxOJ2FhYWLm22q11jrz7apK5oraBDquBVzMuOs65+qwWq1kZ2cDCBNLSZIEPaq0tFRUFzUaDZmZmdhsNnE/lPtlNpsZMGAA06dP53//+99FSyF/++23lJaW0rVr14s8+/9HSUkJb731FkajkTFjxqDRaEhMTCQxMVEkxvv27eOHH35g/fr1bN26lREjRnDnnXe6Hadhw4asW7eOAQMGMGTIEFQqFX369BHr1Wo1S5cuJTk5mXnz5vGf//wHk8lEeno6JpNJVKcUKrFerycsLKzGeF3fN/WJdHjggQceXOu46hKY32hgFkmSfgSMkiRpZFn+XpKkAcBqIAN4CbgDaArcL8vyib9swFcYtQXASuBgsVjQ6/U4nU7S0tKoqKjAYrFQWFgo3KybNWvGo48+yubNm3n55ZdZtGgRNptNzEQqM/Pz5s1j6tSpZGdnU1BQUOtY9uzZw7Jly4iNjSU6Oprvv/9erCstLeXIkSPi/0ajkcGDB7Nr1y4++OAD1q9fT9++fenYsaMIiB566CHsdjvvvvsu6enpzJ49W/xQz5gxAy8vLz788EOcTidjxowhMDAQh8NBUVERXl5eaLVaHA6HUOoCBL3iQjPhf1aCU50SVn25Iv+s0EWgiipWUVEhqCNKb4XT6cRsNuPt7U1JSQnjxo2joKCA999/H5vNJsQRUlJSGDp0KGazmcmTJ9O+fXt++eUXt3EdOHAAWZbZsWMHGzduxGg0cv/999O2bVt0Oh3Hjx/n+PHjtZ5TYWFhnRLMisfK7bffztdff83kyZMZO3Ysfn5+tcrfKnA6nSJhUxKe7du3k5iYCFCvRK7D4cBsNovvgquqWH5+PiaTiQYNGnDy5EnxHVGeMz8/PyIjIwkKCsLhcAipZKWvRblvrvdLcUivD8q9ruv7e7Xj9wbCvr6+REREiOdbkbDW6XQ4nU5UKpVQlsvOzsZsNuPl5UVkZCRGoxGHw4EkSXh7ewuDR5vNRrdu3Vi2bBnTp0/njjvuEJ+nSIrXhs8++wwfHx9iYmJqfW7T0tLIy8ursdzhcPDf//6XgoICBgwYUKOHRZZlMjIyUKvV3H777TRu3JgtW7bw+uuvs2bNGkaNGlVDOe7f//43M2fOZMCAAbz++uv069dPrAsODubf//43M2bM4I477uDGG2/k/Pnz6PV6/P390ev1QhFNoRLXNrnl+vf1hpiYmHq/XzExMZw5c+bPG5AHHnhwxXDVJTAuyAK6AOup6oHZJ0nSEOBtoJcsy5/+paP7E1CdV179xawEWWVlZeTn52MwGFCpVBQVFYkkRKVS4eXlxT333MOKFSt46qmnaNasmThWREQEQ4YMYcWKFUydOpXo6Ohag0WbzcZnn32Gt7c3/fr1q/EDuWfPHiIjI2vsl5ycTHx8PCkpKSxZsoSvvvqKAQMG0LRpUwD69etHcHAwH374IQMHDmTp0qUEBgaiVquZMWMGer2eRYsWUVFRwejRo4UqkVKB8vLyoqCgAJ1OR3x8PEaj0U3x6K+GUlGrjfKiBLSu/RNOp5OCggK3QFqn04km6NzcXPR6PUuWLOHbb7/lzTffdPPy2blzJ8OHD8fb25uZM2fStm3bWsd1+vRptm7dyq+//kqzZs148MEHxT1V1LvqQlZWFgkJCbWus9vtop/qhRdeYNKkSSxcuJApU6YIX4vaUFFRIdYplbaffvpJLKtPRlmppAQFBXHu3DmaNGlCYmIihYWFnD17FoPBgN1uR5Zl1Gq18HxxOBz4+fmJ4Lq0tNQt2VCkuhU5YKWaozQ314XqiaqSnF5M4nO1oHogXL0ic6Hz8PLyQq/XU1JSQnZ2NmFhYRgMBtEb4+Pjg81mo6SkBIvFInr8lEQiKCiIiooKsbysrEx8B4YMGcLMmTPZs2eP6JNS+pWqw+l08tVXX9G+fXvh+1MdwcHB4nNcsWDBAs6fP0/37t1p2LBhjfUnT54UCbYy5ocffpgjR47wzTffMG7cOO69917uv/9+t2rquHHjeP/99xkzZgzFxcUMHz5cHGPkyJF8+eWXTJ48mSlTphAYGEhOTo5ICFUqFaGhoUIcoXqSKUnSdV15uVBycq18/zzwwIML46rjNChKYrIszwd8gQWSJPn/VonZCRzm6k68/lAoAXBtP84KDcnX15eAgABCQkKEUpdOpyM3N5eioiJkWWbYsGEEBwczZsyYGsH06NGjsdvtvPPOO3WO45133iEvL48HHnigziC0LgQHBzN+/HhGjhxJWVkZr732GmvWrBHjuPvuu1mwYAFHjhyhV69enD17Fqj6sXnppZd4+eWX2bJlCwsXLqSgoAB/f38yMzPJy8sjMzOToKAgwsPDCQkJEQpd1xKUXgKlKmCz2XA6neJvs9lMZmYmJpOJsLAwvvnmG1atWsWwYcPo27evOM4nn3zCoEGDiIiIYOPGjTRp0qTWzzt69CjLly8nJSWFHj16MHjw4CsyY9usWTOee+45UlNTmTlzZr1JUXXcfPPN7Nu376K4/LIsYzabiYiIoGXLljRv3hyr1Upqaio5OTmcPHkSf39/QkJCRA+BokaWk5Mj1MUU2V8lyFb6CZQgsbqE98VAafBXPu9aQfX3zuVIRTscDrKzs93uu0J9VJIYg8EglBSh6tlXqVRUVlaKXibFONNoNGKz2RgwYADBwcFMnz79gmPYv38/2dnZF003U7B161bWrl1LixYtaphQ1gdJkmjZsiVDhw6lffv2bNiwgeef7QLSrAAAIABJREFUf579+/eLbXQ6He+99x733nsvkydPZtasWeJdqFareeutt7BYLHz99ddu4iqlpaUUFRWJe3A99l154IEHHii4KiI9SZKaSJJ0qyRJGlzGJMtyv9/+/zbwmCRJo4AOwMVHQn9j+Pj4YDQaUavV+Pj4oFarCQwMJDk5mbZt25KUlIQkSciyTHR0NA899BA7d+7ks88+cztOXFwcffv2ZcmSJbVKIm/fvp3169fTtm1bGjdufFljlSSJ5ORkpk+fTseOHdm8eTPvvfceFRVVrUv33Xcfq1atoqCggAceeICUlBSx38svv8zMmTP59NNPmT17tqjA5Ofnc/LkSXJycmjYsKEI+KFq5rWkpISSkpKrrrFfgaImB4jEy8fHh9DQUOLi4oiPj0elUpGXl0d2djYqlYqSkhLeeecdbrzxRt566y1xrO3btzN69GhuvvlmPv/881r7V2RZZvXq1YwaNQpJknjyySe57bbbruisZHJyMiNHjuTQoUO8//77F30vkpOTKSws5MSJC7NDS0pKhE+Q0WiksrKSwsJC0RsGUFRURExMjEh0GzduTGxsrKDo2Ww2zpw5I5r6oYoGWVZWRlZWFlAVXNalRFYf/g6B5uWcgzKBotVqxX1QxCtUKhVnzpwhMDCQgIAAYbqqKBkqksparVYkkAaDAYPBwIkTJ7jtttv48ssvsdls9Y5h48aNeHl50b59+4sed2pqKm+//TYtW7bklltuuej9XOHj48Pw4cOZMGECOp2ON954gw0bNoj13t7e/Pe//6Vfv3689dZb/Pe//xXrEhMTmTJlCp9//jn79u0jLCxMJNbKM6g8o3VNbnnggQce/N3xl7/5JEnqA6wDpgFLgFGuxpSyLPenyvclhKq+l56yLNdOwP+boi5lGUWyVaF1+Pr6otfrBX2jvLwcq9WKJEk4HA7uvPNObrjhBv7973+LoEzBc889h9VqZdmyZTU+X+ltadWq1e8+F41Gw9ChQ+nZsyc7d+5k4sSJIllp27Yta9asweFw0KNHDzZu3Cj2Gz16NPPnz2fLli1MnDiRmJgYEhIScDqdSJJEeno6+fn5on/k7Nmzwqjwap35tlgsZGZmintbWloqZv4rKiqE+3t0dDQtW7YkLCyM1atXY7fbWbVqlQimS0tLGTNmDE2aNOG9996rVbrY4XAwe/Zs3nnnHdq1a8eQIUNqpcVcCXTt2pV+/fqxd+9eDh8+fFH7uIo0XAiK8pOPjw95eXniGZAkibCwMEJDQwkICBBKTlBFWVO8S4qLizlx4gSpqank5eVhNBrFtQ8NDSUyMlIEkIrHyaXAVZ3rWkV9leC6EBwcTIMGDYiJiRH7KVXjkydPkpqaSlpamuibUiZhVCqVSEZzc3NJS0sTyajJZAKqpLCdTucFKUMWi0WIXlwMKioqmDFjBn5+fvznP//53clBUlISr776KrfeeisrV65k9+7dYp1arWbWrFnce++9vP7665w6dUqsGz16NG3atGHhwoUEBQW59RBdSeNUDzzwwINrBX9pAvNbxaUf8Lgsy12oSmQaAs9LkuSvbCfL8lJZlqcBg2RZ/vmvGe1fB+UHy2Kx1JrIVDeQs1qt5OTkiH6JJk2aEB0dTWJiIoMHD6a0tJThw4e7HadZs2aMGDGCDRs21Gje7tu3L2q1mn379v0h5yNJEvfffz9jx47Fbrczbdo0Jk2aRFlZGU2bNmXz5s00adKEJ598kldeeUVQUJ544glmz57Nhg0beOeddygvL6dBgwZotVrKysrIy8sjPz+fw4cPc+TIEaEgdS3MfCvUGqgKbOx2u5DK9vb2RqVS8emnn7J69WqeffZZ4uLixL6zZ88mKytL9AxVR2VlJZMnT+aTTz6hX79+vPLKK5dVSfg96NOnD35+fqxcufKitl+xYgWJiYnccMMNF9xWmYUPDw/HbreTnZ2NWq0mLi5OyCJnZ2dz7NgxMjIycDqdFBcXk5ubS0VFBTabjUaNGomZf0XS1+l0Cvlyg8HgRvO7FNRlWnq14/dK8rpKvytQqsYJCQmEh4cTEBBAcXGxaOx3Op0UFhaSnp5ORkYGWq2WoKAgDAYDJSUlwn+lQ4cOQFUDfn3417/+BVAvPdYVy5Yt4+zZs4wZM4aAgIDLOu/qUKvVPPnkkyQlJbFw4UJOnjwp1qlUKqZNm4ZWq2XixIniGfHy8mLs2LGkpqaydu1acnJysFgswpT4Wq/oeeCBBx78XvzlFRjACCidkJ8BGwEtMABAkqRkSZIUd76/hVTypUKhbwC1zrwptAzXRtGQkBBiY2Np1KgRYWFhVFRU4O3tTaNGjejZsydbt25lzpw5bsd56aWX8Pf356233nILWsLDw+nevTtHjx6tU6HsctCsWTOmTp3KnXfeybvvvkvXrl35/vvviYiI4JNPPmHo0KEsWLCAe++9VyhsjRw5kilTpvDRRx/x5ptvCrfq/Px8LBYLGRkZgrqiVqsxGAyCRucaRF4Nfgl+fn5ERETg5+cnAjsfHx9xPy0WC+np6Rw9epSPPvqI5557jq5du/Lyyy+LY6SmprJo0SIeeuihWhv2bTYbL774Itu2beOf//wnTz/99F9COfH29qZTp058//33bjPNteHIkSMcPHiQIUOGXFTVQklgNBqNkJtWKpIqlYrc3FzOnz9PamoqKSkplJeXi+9LZWUlGo0Gu91OSEgINptNNPO7ztor1c7LuXbX6oz5Hz1uV3NLu90uKi5qtVr4xEDV/Tx79izHjh2jsrKSyMhItFotx44d4+eff6ayslKIgNSlhqcgJiaGJ598kvXr1/Pzz/XPfeXl5bF27Vq6detWp/jF5UKj0fDss89iMpl48803hVcXQFhYGGPGjGHbtm18/fXXYvn9999PYmIiM2bMYP/+/ULUQ/mjqBd64IEHHlyP+Eub4WVZrpQk6U3gaUmSUmVZ3ilJ0i4gCuguSdL7wG3Ayt+2v7amMP8gKPQNZZZSMetT1LbKy8uF0V5ISIjYR1HmUfZT3MpHjhxJaWkpEydOpH379rRu3RqomtUbOnQob7/9Np999hl33323GEOfPn3YsGEDmzZtqtXNuri4mPz8/DrPITU1tc51rVu3pkGDBqxbt46+ffvSvn17OnfuTHx8PEOHDuXjjz+mbdu2zJkzh1atWtGvXz/S0tJYvHgxfn5+DBkyRFAs/Pz8CAgIoEGDBpw5c0aY5lWXs63Ln0XBn0H3kSQJHx8fysrK8Pb2Fk7b586dQ6fTERISQkBAAL/++iuvvvoqjRo14t1338Vms2Gz2ZBlmTFjxqDVannwwQdrSCXv2rWLDz/8kLNnz9KjRw/Cw8PZtm0bACdOnODQoUN1jq2+e6nX6zl48GCt66Kioti5c2et6xo1aoRWq2Xx4sUMGzbMbZ1GoxE+RF988QUAd911l+D611f5KCkpAap6JDQajUhIsrOzMRgM6HQ6EhIShIRvcHCw8IHRaDRUVlYKJTOoCihdqy2uylmXk8BUV/S6Vl5jf5Qkb3VRBNflisSy62d4e3uLfqWoqCgyMzMpKCgQib7JZMJoNCJJEmlpaciyLJLS2vDUU0/x/vvvM2PGDObOnVvju33q1ClOnz7N9u3bcTqdJCUliWpzRkYG586dq/W4NpuN06dP17ouLi6uRq8hVHlmbdu2jf79+zNz5kwx6dS6dWuio6N54YUXCAoKEj4yH330EZ06dWLKlCmCHpqbm4uvr6+4lq7vr0t5b0mSNBwYfsENPfDAAw+uQlwNal47gSbAYEmSJFmWdwAf/fZyjZRl+a36d79+oATorspISg+MxWKhoqJCSG5aLBY37r0kSdhsNry9vQkKCuLpp5/m4MGDPP744+zdu1dIb44ZM4bvvvuO5cuXM2LECME5B+jQoQPffvstjz/+eA0TtW+++abeINNVhac6iouL6dixIw899BA7duxg586dZGdnc+eddxIbG8uqVat46qmnGDhwIFOnTqVPnz4899xzlJSU8PHHH6PRaHjllVcoLy8nPDwck8nE999/zw8//IBaraZz585ibMrfFxOc/RkmhKWlpWRnZxMaGipkZu12u5DelSSJZ599FkmSWLNmDYGBgWLf9evXs3//fp5++uka96O4uJh3330Xs9nM/fffT8uWLd1maw8dOlSv3Kpr0KYE3EpwFBAQ4EZhc0VmZiZRUVG1rtNqtXTv3p1169YxatSoGmNWpGx//vlnGjdu7CZRW5fzuOv4/Pz8iIuLIz8/XwS1TqcTh8OBWq0W8rNKUq8kj4CbV4lSaVHO15XedzEStdWDSFdp22sleQF3U91Lhes1UK6fn5+fG/XJ398fu92OzWbDYDAgy7K4zkajEYPBQE5ODgUFBXh5edGkSRMhGW+xWAgLCyMtLe2C/Tl+fn688MILjB8/npSUFO655x639Wq1Gq1Wy/79+0lMTHQz9C0qKhLeK9Xx1Vdf1fmZmZmZdRoDJyYmcvz4cd566y3Gjx+PSqVCq9UycuRIxo8fz+rVq4XpZosWLVi6dCkPPfQQ06dPZ+LEiWLC6nIpjQpkWV5ElTE0kiRdOw+mBx544AFXAYVMluVy4EPgJ2C8JEnDJUkaSlXTvqXena9T1KYIpEiRKsGvYhSnzCzn5uZy6tQpzGYzp0+fJi0tjREjRnDixAmmTp0qjqNSqZg+fTqFhYXMnDnT7XPvuecevLy8WLdu3RU5L41GQ+fOnbn11ltJSUlh3bp1WK1WmjVrxtq1a0lOTmbcuHGsWbMGSZKYOHEi/fv355NPPmHevHmcO3dONPJHRETQtGlT4ZGiVKRKS0vFjP2FGquvBPVHadZXEhSFxuZ0OikqKhJVgPLyck6dOsUTTzzBuXPnWLlypVvSUFZWxvjx44mNjaV3795un5GXl8czzzxDTk4O/fr1o2XLlpc0RofDQWVlJVarFYvFQklJCaWlpUL97ffggQceQJZlPv20dhsnp9PJvn37SE5OvuhjKhSywsJCsrKyRK+A4r1SVlYmEhdfX19ycnLIzs7GZrMREhIiqjEK5bB6UPpHq4jJsnzVKeRVfxb/SHqlcv38/Pzw8/MTEyqhoaGYTCZxXRVZ65ycHM6ePUtJSQlarRaNRoO/v7/o81Ooog0bNrxgD4yCQYMGkZCQwLRp06isrKyxPiUlhfz8fG699dY/5JzrQ0BAAI899hi7d+/mgw8+EMtbtmxJhw4dWLVqlVtlp0ePHkyaNImPP/6Y9957T8jHFxcXu71LlH97UDcUo8va/sTGxv7Vw/PAAw8uAX95AgMgy3IBsBh4DegMdKKqYT/7Lx3YVQplllgJvsvKyrBYLPj5+WEymVCpVNjtdvLy8oSXQmZmpgjalIbkrl270qFDB9599103akfz5s159NFHef/99/npp5/Ecn9/f7p06cJ3331HZmbmFTk3SZJo27Ytd911F5mZmSxdupT09HRMJhMLFy6kffv2vPTSS3z22Wd4eXmxdOlS7rvvPubMmcP27duxWCykpKRw9OhRYmJiKC8vp6ioCLvdTk5OjrgOxcXFZGdnC7+J2gLJKyF/6+qDYbVasdvtwgMjLS2NnJwcjEYjMTExvP3222zbtk0oh7nirbfe4ty5czz11FNifwCz2cy//vUvMjIy6NGjB0lJSRc1roqKCsxmM6dOneLXX3/FarVSWVkpZoeVsSsJzeUG3mFhYXTu3JnNmzeL2XZXnDx5koKCgktKYBQpbrvdTnp6Ojabjfj4eAICArDb7ZjNZk6cOCFMExW6niKOEBISgtFoFIGgK+qrwl1uoF9WVkZ2dvZVpZDnmqz/nsS9tmuiJI7Vezaqq7P5+vqKaodGo8FisXD27FnsdrubB09ISIigCV6oB0aBWq1m4sSJpKamsnz58hrrv//+e/R6/SUn+5eL3r17c/fdd7Nq1Sq2b98ulj/++OOo1Wqef/55t+2ff/55HnzwQV5//XUOHDgg+oSysrLEu+Ra7LP6s3HmzBlkWa71j+I/5oEHHlwbuCoSGABZlitkWf4f8DDwmCzLtZPsPagBJdBW/AF0Op2oxkDVj7diqNe4cWMiIyMJDw9HlmW6detGUVERAwYMcJOIff755wkJCWHo0KFuSUz37t3x9vbmjTfeuGJJDECTJk3o3bs3FouFxx57TPhJzJs3j1tuuYUXX3yRPXv2oNFoWLlyJR06dODtt99m/fr1ZGRkcP78eX744QcOHTrEr7/+KqR1lYC1rKyMjIwMzp496zab6RqYX4507IXg2qyvNDEr96lhw4bExcWJPpKPPvqIsWPHMnDgQLdjWK1W5syZQ58+fWpIW3/44YeYzWbeeOMNoqOjL2pMZWVlnDhxArPZLHpEfH19hcmgTqdDr9cLukp+fv4lGzq6okGDBpSXl9dQuwP4+OOPAS5pJnzHjh1AVXJUWFhIRUUFJSUlGI1G/P398fPzo2HDhhgMBiGMYLFYyMvLw+FwiHMpLi4mJyfHLciuL5i/3EDf19eXsLCwq0ohzzVZ/z2Je13XxHV5fapsBQUF2O12vL29Rd+fkviUlJRgtVoJDAzE39+f5s2bc/z48YuuCHfp0oUOHTowffp0NyUwqBID8Pf3/9MELiRJYuTIkTRv3pz58+eLJDw4OJiBAweyceNGN9qtJEksXLiQFi1a8NprrwmzYl9fX/Eu8SiTeeCBB9cTrpoERoEsyw5Zlj118EuAMpOZn59PRkYG+fn5hISEYDKZ0Ov1+Pn5odVqhRN5TEwMkZGRhIaGctNNN/HII4/wxRdf0LNnTxF4GI1GVq9ejUaj4f777+fLL78Uy1944QWsVitTpky5oLLP70FUVBT9+/fn/PnzjB49Grvdjk6nY968eURHR/Ovf/2Lc+fO4ePjw2effcbNN9/Mq6++ynfffUdMTAzx8fFERkYKmoqr10RoaCjh4eGCZvdnKUUpVDYlaFZmpouKirBarQQHB1NUVMSiRYvw9vZm/PjxNY6xbds2SktLGTp0aI11Z8+eJSEhgRYtWlz0mLKzs/Hy8qJx48ZC3lZJehVIkiQqPUoF43Jw6NAhli9fzm233UabNm3c1p08eZJ58+bRr18/GjVqdFHH27t3L++88w4PPPAALVu2xNfXFy8vL7Kzs3E6nURGRvKPf/yDqKgoYQio1WqRJEkIX1SXr3ZNzuoL5i830JckSZgyXi3eMK7J+u9J3Ou6Jq7L60tyNBoNgYGBREdHYzAYiIiIED19BoNBNKzLssyAAQO46aabGDBgALt27brg2CRJYvbs2QBuJrBQRY/NyMjgm2++ueRzvlxoNBoGDBhAaWkp33//vVjevXt3fHx8anhy+fr6Mn78eM6fP8+2bdtEz1xmZiYlJSWXLTLhgQceeHAtwvO2+xshODiYyMhIgoODBc1MoXTExsYSHx8PVP2QK34X4eHhPPbYYzz99NNs376dQYMGCTpZkyZN2LRpE02aNOHRRx9l69atyLJMo0aNmDRpEiaTiddff51vvvnminH5Y2JimDRpErt27WLGjBlAVVPuf//7XyorK3nwwQexWq0YDAY2btxIcnIyixcv5sCBA2g0GvR6PQaDAYCgoCBMJhPe3t5uwZO/vz+hoaF/2gymQvcoLS3FYrFQVlbG+fPn+fnnnzl16hSlpaXs3buXHj164O/vX2P/9evXYzKZanUXT09Pp0GDBhc9FkW+VlHmqg+K8llAQMBlBd5FRUVMnTqVBg0a8Pzzz7sFW7IsM27cOHQ6HZMmTbqo41mtVkaMGEFkZCQTJ06ksrLSLch1lVJWoATnISEhwizRarWi1WpFkO2anNUXzNe17mqQ6L7SqM9ct7Zr4rq8epLjcDjIzs5Gq9WK5MVms+F0OoU5r9VqFUm+MgERGhrK/PnziY+Pp1+/fvWq6ikIDw9n0KBBrFu3zq1/pm3bttxwww188cUXdSqLXQm0atWKkJAQoQ4IVb15DzzwAKtWraph5HrvvfcSGhrK5s2b0Wq17Nmzh8OHD3P27NnfVRX1wAMPPLjW4Elg/kZQjONUKpVo6MzLyyMrK4uKigrUarUImJX1arWahg0b0q1bN8aOHcv+/fvp378/RUVFAISGhvLpp59yzz33sGbNGlasWIHD4SAkJIQJEybQqlUrli9fLpqmrwT69u3LI488wvLlywXFKD4+nlmzZnHw4EFGjhyJLMsiiWnTpg2vvvoqu3fvJi8vj7Nnz5Kens65c+fQaDTk5eUJozybzUZwcDBeXl5X1C3dtclWoXtAVQKh0+nQarVYrVZOnz7NRx99RE5ODg8//HCN41RWVrJlyxa6deuGRqNxW2ez2TCbzXWqgNUGs9mMWq12Uzera/zKM+Tt7X3Rx3cd99q1a4WpZnXp6t27d7Nt2zbGjRtXQ52sLkyZMoWUlBQGDBiARqMRCbzJZCImJgYfHx9ycnIoLCwUfQJOpxODwSCUnBSJ3pSUFIqLi0UF4vfgWvV9uRT8nnOs3vuSm5srKse+vr5YrVYyMjI4c+YMZrOZ0tJSVCoVkZGRREVF4XQ6hVeSzWZj2rRpGI1GevfuXa9cu4Lhw4ejUqlYsGCB25j69u1LQEAAixYtqlM6+Y+GSqWiU6dOHDhwwE26/JFHHqGkpKSG2IVWq2Xo0KFs3LiRQ4cOkZWVhVqtJiYmBm9v77994uyBBx54oOBqkFH24DJQX6CtGPHB/0vTKlUZqApGFYqNwWDAbrcTGBhIt27d8PPzY8qUKQwcOJAtW7aIptrPP/+c0aNHM3/+fCRJYvHixRgMBu6//35eeeUVZs+ejUqlYty4cbVWDQYPHiwa5qEq2VIqI3l5eezdu7fWc/H390ej0RAXF0diYiKTJk3i1KlTJCQkYDAYGDNmDG+88QaJiYk88cQTALz33ns8/PDDzJgxg9LSUrp164bVahV0MaVHyMvLS8wkl5WVieWXa1iooLZqlKsUr16vR6/XY7fbRSBXVFRERUUFdrudjRs3EhgYyF133SW4/4qb+c6dOykoKOCuu+4SimpKMnDmzBmgqhekvLycEydOkJWVVesYlW0VVPeQadasmdv/lX6nmJgYEhISakjRKigoKODGG290WybLMrNnzyYrK4v33nuPu+66q8a1GTp0KE2bNuXJJ590EyVQUL06tGvXLubMmcM999zDfffdh8PhEH0VFouFgIAAzGYzBQUFotqoBHYlJSV4e3uj0+kIDQ0Fqp5HtVrtVoG7XBnt+iS6rxbK2O/F7/GIUZThlOvq+o5SqjElJSX4+vri7++Pr68vJSUlqNVqrFYrWVlZ+Pn5odfrRUV4/PjxTJgwgV69erFz504iIiLcPtM1qG/cuDH9+vVj5cqVvPTSS3Tt2lUk5W3atOGxxx5j8eLFLFy4kK5du9b6PgP46aef6qRS/vLLL25mldVx7Ngx8e/Y2FicTidr1qyhY8eO+Pr60qNHDxISEli8eDHdu3d32/exxx7j9ddf5/PPP6d79+60bNkSLy8vMTEFFyf37YEHHnhwLcNTgfkbwpWioVarRU+DQuPQ6/WEhYURERGBTqcjLS0Nq9WKLMsEBwfTp08ffvnlF7p06UJ2dpUQnJeXF5MnT2bWrFls27aN7t27k56ejpeXFxMmTODpp5/m+PHjjBkzpk41F9e+iktNELy8vOjXrx8hISGsXLlSjOuZZ57h7rvvZurUqXz33XdAVZ/OBx98QOvWrZkzZw5r166lsLAQs9ns5mUSEhJCSEgIOTk5nDhxgoMHD5KZmelGxaiv4fhSoFRdvL29hTKcoiJUUlKCwWAgLCyMnJwcjhw5Qt++fWuldG3atAkfH59azUQzMjIAiIyM/F1jrQ6bzUZBQQEBAQGXVX3ZtGkT27dvp3///jWSF4B58+aRnp7OG2+8UaOqVBtKS0sZNmwYMTExPPLII0J9TK1WExYWRmBgIH5+fqjVaiEprszW5+XlYTabRRVRSY6Dg4MJDQ11SzAut8pwJcQfrjb8nnOsfl1d31F5eXkUFxdjNBpF31JERAQBAQGUlpbicDgIDw8nLi5OGI7a7XYkSWLIkCGYzWa6detGQUFBvWN45plnsFqtLFy40G15VFQUy5Ytw2QyMWzYsD9FmSosLIyGDRvy448/imWSJDFgwAB+/PFHUlJS3LZPTEzkjjvuYMeOHYSGhmI2m4XipK+vb61qeh544IEHfzf8fX9hr2O4Bhf1cdUVR/rS0lJ8fHzIzc3F4XDQvn17JkyYwKlTp7j99tvduOWPPvooK1eu5MyZM9x1110cOHAAQKj7VFRUMHbsWPbs2VNjXJIkiQD1cgIfnU7H4MGD0Wg0rFixQlB+3n77beLi4hgxYoSoJBiNRjZv3kyrVq1YsmQJ33zzDRaLhbS0NI4cOcLPP/8sEgmNRiM8QFzVtuCPowNJkiQoTRkZGaSlpZGVlUVhYSEqlYrQ0FBCQkJYu3Yt5eXloprkCpvNxubNm+ncuXOtM99XIoFxOp0i8QsJCbnk/Y8cOcLSpUtJTk6mb9++NdafPXuW+fPn06NHD26//faLOuZLL73EyZMn6dKlCw6HQ1y7qKgojEYjERER6PV6goKCREJTWloqHN4bNWpEgwYNsFqtOBwOiouLKS4urvEduRIy2h7Ufl2V91RgYCBRUVHExsa6NalXVFQQEhJCeHi4m+FoUFAQFRUV+Pr60rx5cyZNmsTx48fp1atXvT0hSUlJdO/enUWLFtX4bkdERLBs2TKCg4NZsWJFDcWyK4E2bdqQkZEhvsNQRZ3VaDRuVDcFTzzxBKdPn+bEiRMUFRVRWFgoKsnK3x5cGjweMR54cG3Bk8D8zVFbAG61WiksLCQnJwedTicCd8XgTafTceuttzJ//nwqKyu57bbbWLhwoahCdOnShc2bN6PRaLj33nuZMGECpaWlNGnShDfffJOoqCimTZvG9OnTaxjNKQmMQom6VJhMJu4v1/edAAAgAElEQVS++24KCwv5+uuvATAYDLz33nuUlZUxduxYt223bNlCXFwcH3zwgUhgsrKyyMvLQ5ZltFotWq2WoKAgvL29MRqNSJIkKi86ne4PC2JLS0sFPUar1RIbG0vr1q2FnK7T6eTrr7+mV69etG7dusb+O3bsEMlEbRWhvLw8ANatW+cmiX05OHXqFMePH+fYsWOUlJQQFBRUK7WrOsrLyzl69CgbNmzg7bffZurUqURGRvLss8+6Ja179uzhqaeeomvXrnh5edWqtlYdJ0+eZODAgcydO5fOnTvTpEkTbDYbJSUllJWVCXlk12oLVBlcFhcXu3kgWa1WMjMzMZvNnDlzhlOnTpGbm+v2eddDJeWvQG3XVXlPVVRUEBYWJp61vLw8jhw5wvfff09ZWRlqtVoYkVqtVtLT00lNTUWtVpOUlETnzp2ZMmUKu3fv5rbbbquTmgowevRoCgoKGDFihFv1A6qqIsuWLcNoNDJv3jyWLVt2RasxCk3NlVoWFBREjx49WLVqlTC4VdC7d280Gg07d+5ErVbj7+9PeXn5H/q+ut7g8YjxwINrC54emL85auOq+/j4YLFYsNvtwvcjKCgIg8HA+fPnKS8vx2g0ctNNNzFv3jzmzZvHqFGj+PLLL5k9ezZGo5HmzZuzdetWpkyZwvz58zEYDAwZMoQ777yT6dOns3btWj7//HN++OEHunTpIqg8Go0Gk8l02edz+vRpNm7ciNFoFDP2DoeD999/n4qKCvr37++2vTKDe+edd4oZdpVKhb+/Pzk5OZSWlhIWFkZwcDAFBQV4e3sjy7JINCIiIkSvzqVA4fnrdDrKy8tFg623t7dIFI1GIxaLheLiYkFp6tmzJ1988QW//PJLjT6U2267jU6dOrFx40aGDx/OrFmz3NY/+OCD5OTksGLFCr744gsiIyOF8/mlwsvLC51Oh0ajQavVCtEBV1RWVnLy5EnOnTtHeno66enpbo3IJpOJ22+/nYEDB4oEbceOHcyePZsffvgBk8lE7969GTx4MOHh4XWOJScnh1mzZrF48WK8vb0ZOnQoDz30kHimwsPDRZKlSGUDQgzA29tb3FsliVSU6IKCgoiNjaWsrEz0Ynjw50N5P7lWP51OJ1qtVvjBKN9VV5EHg8FAXFwcPj4+xMTECIUym83GwoULadeuHaNGjWL8+PE1nuHk5GSWLFnC+PHjeeSRR+jcuTOjR48mLi4OqDLMfPzxx9m3bx+7d+/m4MGDhIeH06ZNG/7xj3/8YcqLv/zyCx9++CHh4eG0bdtWLN+0aRObN2+mQ4cONZ7NI0eOUFlZSUREBHa7XagJKtfycnq3PPDAAw+uJUhXSv72akXbtm3l6rNt1xtkWcbpdIrGdpvNJjwEKioqKCgowGq1snfvXry9vWncuDGffvopkydPpkGDBixevNjNw+PQoUP885//5Pjx48THxzNs2DBatGhBUVERq1evZvPmzcKcTnE/d4Ver69T+tff35/k5GSys7NJS0vjm2++ISAggKFDh9KwYUO6dOnCqFGj+Pbbb3n00UeZMmWKqFCEh4fz8ssvM3PmTIYPH07btm3R6/UkJSUJb4ny8nKCg4NRq9UUFxcTERGBn58f6enpWK1W4uPj3RIYlUq1X5bltrUOlqrna9++fUJIQaHxqVQq7Ha7UPJS+jPS0tI4ceIE0dHRREREkJmZSb9+/VCr1fzvf/8jPj4es9ksKlZOp5N58+Yxc+ZMwsLC+Oc//+kW9EBVcLNgwQJOnjxJUFAQrVu3rqEytmbNmnqfkerJkwKHwyHu4a+//orNZkOSJIKDg4mKiiIwMJDbb7+duLg4AgICgKrnbf/+/axevZqUlBTCw8MZNWoUAwYMEAGrogbnCovFwpw5c5gzZw5Wq5U77riDPn360KZNGyG0oFariYqKQpZl8Qwrz7aPjw+yLGM2m0UyClW+N4oXj+INowR81b1v/mxIklTn83U9vLuU3yOn00lOTg5FRUU4nU4qKysxmUwEBgbi4+NDSUmJ+H6FhIRQUVGBt7c3VqsVu91OcXExJ06cYPHixXz66aeEh4fz+uuv07Nnzxr39aeffmL16tUsWbKE8vJyOnfuzN13302HDh344osvRHVj//797NmzR8zGKzLcivS263Gri2JUx+TJkzl8+DAHDx7k9OnTNGjQgGHDhgkKa2ZmJtOmTePGG29k2bJlbt/fsLAwxo4dy9y5c5k7dy56vZ6oqCgcDgfR0dGEhYVhsVgwGo1uzfz1PVuSJMnXWyxwKYiNja2zChMTE1NDFOV6Q33PlgceXCl4EpjrEK733DXYU4I/WZY5evQo+/btQ6fT0bx5c7RaLZs2bWLevHlkZmYyYcIERo4cKZKRrVu38uOPP7J06VJyc3O54YYb6N27N61atSIvL4+RI0cKt2mtVuvW0K+oQSl8Y5vNRllZGWVlZZSXl7vRoaKjoxk0aJBIQFauXElGRgbTpk1zkx2WZRkvLy8SExO57777SEhIwGQy0bRpU2JiYkhKShKyusp1KC8vF30eCr1OrVa7VTEuNoGprQJjs9lEkFVcXEx2djYnT54kIyODhIQEGjdujEajYevWrYwbNw6j0ci2bdvw9vauQbk7cOAAI0eOJC0tjUGDBtG/f3+3bRwOB88//zwnTpzAZrMRGxtLUlKSOJeLTWBkWcZut1NSUkJJSYmY5TUYDLRo0YIWLVrQqFEj0dzvqkLmdDrZs2cPa9as4dSpU4SGhjJmzBj69u1bQwzANYHJzs5m/fr1zJw5E7PZTK9evWjWrJmYaTeZTISEhBAQEEBeXh7R0dFufT9K8qjMuKenp1NeXi72z8vLIyAggMrKSnQ6Hbm5udjtdmH8qsCTwPz5UCZXcnJyRLLv5+eHj4+P+P7k5eWRmZlJbm4uoaGhNGrUCB8fH8rKysjOzsZisYjJGYDt27ezbNkyjhw5wr333susWbNo2LCh+MyUlBRx3CVLlrBp0yby8vLQ6XQ0atSIm266iWbNmonjFRUVceTIETZu3Cj6bBQZdm9vb7Rabb0KZIB414aGhnLDDTfQoUMHdDodDoeDjRs3smPHDrp3787bb79dQ+ksJCSE+Ph4WrVqRa9evdDr9SQmJuJ0OgkJCRGKk9UrMJ4E5sqgLkrv9QRPAuPBXwFPAnMdwvWeuwZ7er0eh8OB1WolLy+PwsJC/P39qaysRK1Wc/78eY4fP866devYtGkTt9xyC/fccw/t2rUjNzcXPz8/bDYba9eu5auvviIvLw+j0Ui7du3YuXOnSE4UCtWFoNPp8Pf3p1mzZsK4zt/fH0mSOHbsGOvXr8doNDJ//vwaru6yLDN37lxmz57N+PHjCQwMxGAw0LBhQ2699VasVqsIYu12Ozk5OWI2vri4mFOnTgm5Y5PJJCguXl5eB2VZvrG28cL/JzDV4XQ6RUBcVlZGRkYGpaWlmEwmCgsLCQgIoKKiQviT7N27lxdeeIHQ0FBWrlxZQxYWquSAhw0bxq5du2jevDljxoxxa7R/55138Pb25vjx46SmpopkTUmm6oNWq8XhcOBwOMQyjUaDwWAgISGBvn37IkkShYWF5ObmUlhYKJTeoMrbIzc3l7KyMiIiInjggQfo0KEDt912m9s9SktL4+jRoxw8eJCTJ09y+PBhIf3crl07hgwZgtFopKioiIiICKKioggODhbqU6dPn6ZRo0ZuM9SyLLtVYJT+L8UQsbi42E3kori4WFCPPBWYvxaKdHV+fj6VlZVER0eLxFy5r4WFhWJ7RVVRmSRQDC/T0tLw8fEhODiY/Px8ioqKWLBgAevXr0eSJHr27Mm9995L586dyczMRKfTiWM6HA7279/PV199xYYNGygtLUWj0dCsWTOaNWtGVFQU4eHhzJ07V1BDlT4su91+UefZsWNHWrZsSXh4uHjObDYbH3/8McePH2f48OG88MILtVLAzp07R8eOHfnPf/5Dx44dBQVYed/GxcXV+uzWN/niSWAuH54ExpPAePDXwJPAXOeo7nWhNC0qy8rKyoRSlt1uJy8vj8jISObMmcOaNWuExKder6ddu3Z06NCBDh060LJlS7Zt28bq1avZsGEDZWVlhIeH06dPH+68804hyVtZWUlBQQGyLFNZWSl43U2aNEGn01FQUOBGg3A6ncyaNYs333yT1q1b88knn9Rq3JiRkUHz5s1JTEzk7rvvFrSnVq1a0ahRI+x2O2q1Gh8fHxHYKopGFRUVHDt2DH9/f3x8fEhKSkKtVmM2m4mIiDgsy3Kruq7njTfeKP/444/iR025jvD/AbHiVaJQy/z8/LDb7ZjNZlEJysjI4IsvvmDu3LnExMTwzTff1NqjYbFYWLNmDWPGjEGtVgtfi7i4OHJzc8XsbWZmJjt37uTMmTPk5uaSlZVFcXExOTk5Qro2ICCAoKAggoODxUyuIi/cvn17GjRowKFDh9i7dy+HDh1iz549NXxmQkJCaNiwofjTrl07HnjgAby8vMjLy+PHH3/khx9+4IcffuDHH38UcrdeXl40bdqUuLg4brjhBpo3b85NN92ERqPBbrdjtVoFbUyplJSUlJCZmYnBYHALBOuDck8U1StXd/iroV/gek9glPeP2WyutSpW3UMGEH1kyiRMUVGRqPiFh4dTXl6OVqslPz+fjIwMJkyYwO7duykoKECr1XLHHXfQs2dPevTo4VaZAaioqGDXrl188sknrF27ViToGo2Gpk2b0qpVK1q3bk2rVq1o0aIFarWaU6dOsX//fs6dO8fp06dJTU2loKCAzp0707t3b1q3bl3jWcvKymLw4MH8/PPPTJs2jdGjR9d5fcaOHcuSJUv48ssvKS8vp1mzZkKC3dfXFz8/P8rLy90okb9VpOucfPEkMJcPTwLjSWA8+GvgSWA8cEP150EJGOx2O9nZ2RgMBvz8/CgsLCQzM5OzZ8/y/fffk56ezrFjxzhy5AhQNcufnJzM7bffzk033UReXh6bNm1iy5YtYvbfz89PeD1ERUURGRlJREQEJpMJHx8ffHx8sNvtBAcHC4rbhAkT+PLLL+nfvz/Tpk2r03X+3//+N4sWLRKu25IkERkZSXR0NFFRUUI6WavVEhcXJ3pgsrOzhUyrQptq0KCBOOeGDRv+JMtyTYmw39CqVSv5u+++Q6/Xu1W3qgcTyjVVKj+K0o1OpyMkJITs7GwyMzPZs2cPkydPJikpia+++qqGAILFYkGtVpOamsoTTzzB/v37gSrO9s0330ynTp247bbbau0v8fPzE82/Sk9BcXExRUVFIigsKioiNzeXn376iZ9//llUcRITE0lOTiY5OZmmTZvSoEEDIiMjqayspKSkhMLCQgoKCjh+/Dh79uzhhx9+4Pjx40AVfeYf//gH8fHx3HzzzbRo0QKTyURubi5JSUkkJCTgdDoFjaesrEwksUrSpwS1CtVIq9USHBxcI3Cr7fl2pfZdLYmLAk8CI4u/XZP/+prSlWQUEBXUM2fOEBsbW8OE0mazkZKSQmhoKLt372b79u1s2bJFSCW3bt2a5ORk4uPjiY+PF7LbJpMJh8PByZMnOXToEIcOHeLAgQMcPnzYTSGsQYMGJCUlERMTQ9OmTWncuDGJiYk1vreuz+evv/7KoEGDKCgoYNGiRdxxxx3CQLg67HY7CQkJNG/enJkzZ1JQUEDDhg2Ji4ujoKBATMw4nU6R0EFVpd1gMNQ5+eJJYC4fnv4YTwLjwV8DjwqZB/VCkiQxq1leXk5YWBh6vR6LxYLBYKBVq1Z07txZ+DScP3+etWvXsmfPHs6cOcNrr72Gw+FApVKxcOFCFi9ezNatWzlz5oxQrjp79izffvstWVlZFzRgU6vVvPrqqzz66KNu9CZXFBQUsGTJElq3bk2zZs2w2Wyi2dfX1xebzSZ+2J1OJ4WFhZhMJsEdVySDQ0NDyc3NFct/wwU5IgodpS63ckUytjq0Wi0qlUoE7UVFRXTv3h1/f3+eeeYZRowYwapVq2r9zEaNGrFt2zZSUlLYvn0727dvZ/PmzWL7iRMn8uSTTwKwfPlyJkyYcEEamTImk8lEixYtGDt2LG3btuWGG24gJibGbbs+ffqwadOmWu9fSEgIoaGhPPLII9xyyy20a9cOf39/jEajEEhITU11uyY2m00kK0ajUQSprqIIer1eGJHa7XZyc3PF5ysu7dWb812vvV6v/0toYh5cGMp7B/6f5goIRTLXhEb5ozT1K89GbclOeno6mZmZ+Pj4cNddd9GrVy+mTZvGjh07WL9+PcePH2ft2rU1JLVbtmzJ/v37adKkCU2aNKFfv36Ul5cjSRKZmZn89NNPHD16lGPHjvHrr7+ya9cut969++67j3fffbfGeEpKSujduzc6nY5169bxj3/8o14a2p49e8jOzmbIkCGYTCYqKirIzc0VcvBqtdotkXdN2IHaX5ge/C7Ul6B43i8eeHDl4ElgPLgouNJsFNqTImuqqJfZbDaio6MZMWIE//rXv4TXxnfffceTTz7Jr7/+yuDBg+ndu7fbsQsLCwVVSFGMslqtWK1WzGaz4L6XlZXRunVrWrZsWe9Y8/PzqaioIDk5mebNmxMSEkJ5eTlZWVlYrVYCAwOJiIjAarWSmprKyZMnxUypUg2BKlqTq2SrK5WlPijBg2vw7Dq7qSQ0rlUAp9OJ6f/Ye/Mwueoq//91a9+rupaurk5vCUkgLJJBUEFBZBlkUGaAL64jPiOjKOoMyjw/l1HHhREdHXDBGYwoMIo6KKiPso/LSAQcthASyNrpvbu6lq59r7q/PzqfD7cq1Z1O0p10kvt6Hh7Stdz63O1zz/mcc97H56NUKvHiiy8yPT3N2NgYFouFCy64gAsuuICdO3fO+7uKokgD67rrrmNqaoqdO3fyt3/7t7z88svycy+99BKKovCpT31K1vk4nU68Xq/8LxAI4PV6m2oDBO0cx2effZa1a9dyxRVX0NfXJ9PzRMH99PQ0fr+fYDBId3f3PsdyYGAAo9GI0WgkFosRCASkupPWaRHHTKTGCce0WCw2HU/Y11nRHnu9T8bRQ+s5055XEZlr/YyYr1oRKWK9vb2yJ5XD4WD9+vX09PTIqE0mk2HTpk08/vjjPPDAAzz11FM0Go19xDREZLe7u5tLL71Uvh6NRpmenmbHjh3ccsstbNmype2+TU9Pk06nuemmmzjttNP2eyyEY5XJZNiyZQvr16/HZDJJJTbhlIvrPZvNEo1GxTw2/+qQzqIjmmPO9/7xEKHR0VkKdAdGZ0GIWgFhODqdTiKRSJNCjjA2xcNTNMj0er0LaoJoMpn26SLfWgNzIAiZU5vNRk9PDxaLRRbMRyIRGo2GLOIOhUL7qP0cDEajUTovrcazQGtgiP8bDAb8fj87duyQksDBYFDWsRxMmpPJZOKMM85o63g5HA5uvPHGOb8rjLsDYf369XzmM5/BarVKdTubzUY+n6e7uxu73Y7ZbG57nE0mEwMDAzKaoo2SAU3XVev+zPVeO2dFe+x1jg5az9lCzutc59hsNrNq1aqm1wwGA263W0ZUANln6rTTTmNmZoannnrqgMZsMBjo6+ujr6+PX/7yl039kdpxoI197XY71WqVdDrNypUrqVQq86ZO6hwZ9uecDAwMzHnOdOdGR2d+dAdGZ0EoitL0gNQajcCcD0+xQn4kCAQChMNhWbezbt06EokEgUBARpJWr14tFatgNl2ltafDgSAcjUajgcvlOqCV/nK5LB0uUYSvqioul+ugHIrDjaIosh+H9vowGo2yZ8t8jpg2mrIYzqTurBybiAjwYiIWaGw2G7lcTkabxbW73Ljooovo6urC6/XKlDpgn+PicDhwu916xHGZMp+DMp9zMx+646NzvHDcFfErihIDhoEgEN/Px5cDx9I4DYCR2VzsBmABqntfa038tgDWva/XAXXv91WgApgB+973KprvKXs/I7atfW9/Y2wdXzv6VVWd0yPbe30VgZn9bGe+McDs/hn2fr/aZjsGZvfVwuwx6gSm9v6mYe/3lb3/LjJ7TIQX1GB28UJs16B5XWxb/Ft8p532dSfN+6n93lz7tb/juz+OxP1wOH9zzutLM3cdTpbD/HM4x9BuDjAA/jZjMLR8RnxP0O7eMjF7L2ofvOIeswClvdsw7/2Ondk5rLL3705geu92rHtfE8Vs7e4p7bh6tdeWoigfAD6w988Tge1tvn8kWA7XnJblNJ7lNBZ4ZTzzPhd1dJaC486BESiK8szRoJqhj3PxOFxjPBLHQv/NY+s3lwvLYd/1MSy/cSwly20fl9N4ltNYYPmNR+f4YvnFxnV0dHR0dHR0dHR0dOZAd2B0dHR0dHR0dHR0dI4ajmcHZsORHsAC0ce5eByuMR6JY6H/5rH1m8uF5bDv+hheYbmMYylZbvu4nMaznMYCy288OscRx20NjI6Ojo6Ojo6Ojo7O0cfxHIHR0dHR0dHR0dHR0TnK0B0YHR0dHR0dHR0dHZ2jhuOukWUwGFQHBgaO9DCWJY1GY86mbY1Gg2q1iqqqGI1GTCYTqqqiqiqNRgNFUTAYDNRqNRqN2XYEBoOBrVu3EgwGWbFixUH9br1eb/tePB5nbGyMnp4e7HY7FotFjkc0fazX63KstVoNk8nU1Bis0WjIzyykWV2j0eD5559PqqoamOszB3N9zbf/7T5Tq9UoFouYTCaMRiOKomAymeR7Yp/q9dmWFGazmbGxMZLJJOvXrwdmj83BNussFArs2LGDgYEBXC4XlUoFu90uf7NarcrtW61WeV5E81BFUVBVVX7WbDa3bdS5v+Oiqmrb86r9/oGc3+XAs88+G5+rn4I+d82yv/Paet3M93ej0aBWq8nrsl6vU6lU5DwHYDKZMJvNVKtVJiYmSCQSrF+/Xs57c41RfL/de5s3b6a7u5tgMEipVEJRFMxms9yeqqry3+IaN5vN8nVxPx0I811bgUBA7erqolwuMzIygtvtpq+vD4DBwUEymQydnZ1yn9LpNKVSSe5DNptl9+7d9PX14fP55H6azeaj5t7TOXj0eUtnqZjv2jruHJiBgQGeeeaZIz2Mw4ro1Cy6S7ere8rn82QyGRwOB6VSiUAggMlkotFoUCwWsVqtFItFcrkcjUZDvic+73K5KBaLjI2NyQfY5OQkl1xyCe94xzu4+eab5xxfsVjEZrO1fS+Xy7Xtyv7973+fj3/843zyk5+UDlJ3dzeqquL1ehkfHyeXyxEKhTAajWQyGSKRCOFwWG6jVquRSCTkvu6PvUbNvI0E57q+5qo1E8fd4/HM2V08m82SzWZxu924XC52797Nli1b8Hq9dHR0kM/n6erqIhAIMDU1RTqdZtWqVRQKBVRVxel08rnPfY4f/ehHPPHEE3Kb7ZwGgXBC27F582bOP/983ve+93HGGWcwPT3Nq1/9anp7e9m1a5e8XlwuFxaLBZPJRL1ex+PxyGsMwG63Uy6X8fv9TcZoo9EgFotRKpVoNBr09vY2XYt2ux2DwUA0GmVycnKf86o95oVCQX4eZh23eDxOMBiUzt9yQlGUOa+v42HuqtVqTedHizDeW8+h9j3t/eR0OuXf4t7K5XLUajUsFguh0OwzMZPJyGvFarUyMTGBoijUajVKpRJWq5WBgQFisRhf+MIX+OlPf8rvf/97SqXSnPdQPp/H4/G0fa9UKhGJRLj22mt5//vfz/DwMKVSCa/Xi8VioV6vk0gkWLlyJTabje3btxMIBOjq6pLOV6PRkPuoZb7reb5rq6enh9tvv53R0VFuvPFGzj33XL7zne8A8O53v5uHHnqId73rXXKfHnjgAbZt28bHP/5x3ve+9/G73/2OK6+8ki996Uu89a1vBaBcLhMKheZ0YJbbvadz8Bzv85bO0jHftXXcOTDHI4VCgUwmA4DL5ZIPa4fDIR8iwqjMZDJMTk6Sz+fp6+sjkUhQq9Xw+Xy4XC7sdjuJRIKOjg65UtloNCiVSiQSCZLJJD6fj0qlQq1WW/J983q9FAoFUqkU3d3d1Go1MpmMNHx9Ph9Wq5WZmRkCgebASblcptFoUC6XF+TA7D1WB9tBvi3iuIv/z/cZm81GLpdjxYoVFItFXC4XZrMZp9OJ2WyWq75er5dyuUw6naZarZJKpRZzyBK73c5JJ51Eb28vK1euJJVKYTQaCYfD9PT0kEgkiMfjOJ1OrFYrmUyGSqVCo9Ggo6ODYrFIMBiU0TzhaDcaDSqVClNTU/IcrVy5kmKxSCqVko6pOJ+t51WgKErTNQ6zkbuJiQmAtk6PzpFlIedHOLalUmkfA14sdlitVvL5PAaDgUQigcViIZVKSQegVCrhcDjk961WK6VSiVqtRqFQwO12UywWZWS5Xq9js9nmvNYOhlKpBEAoFCIej1MulzEajdjtdpxOJ36/H7fbjcFgwG6343K5KJVK2O12Of7FxGg00tnZeUjbmJ6eZmJiQi7IaBcOpqencTgccp90dHR0DgXdgTkOaDWStQ6NeIAriiINzWKxiNlsls6LyWSShoF4yCcSCenQKIpCqVQil8uhKIpMNxMr3POt5h8sYjyKohCJRHA4HAwODhKNRgmHw4RCIUwmk9w/sQKbz+exWq2Uy2WsVisejwe73d60ug+zUaFW43cx0TqRTqdz3t8xGAy4XC5yuRzZbBan0ynTO+x2O6qqkkwm5d+KolCtVsnn8zgcDtLpNBs3bpw3je9AEMf2qaee4u1vfzu9vb0Ui0UKhQJms5lAIEC1WgVmncRgMIjBYKBQKJDNZjEajdLBNRgMdHZ20mg0SCQSVCoVTCYTJpMJj8fD5OQkmUyGfD6P0+mUK+jFYhGn03nATojf7yefz+P3+xflWOgsLsFgsOn/QNO9KZxSaO/0GwyGpshLIpFgcnISs9mMyWSS12I8Hgdm54N4PC7nhFwux8zMjHSQuru7CYVCJJNJEokEGzdupAaGRn4AACAASURBVKurC4vFIh2QA8VsNhMMBnnxxRdlOpwYn81mw2g0yuiSwWDA7XbLuUjMFWJea7cYdTAoisKKFSuo1+tks9mmY1upVOS4BUajsWmBSiwAlctlXnjhBXp6eli7dq18Px6PMzg4iMvlYvXq1fs4njo6OjoHiu7AHAcIA1gwnwFgNBoZGBiQaUDlclmm4Kiqis1mk+k9wlkIh8OUSiUqlQoul4tMJkO1WiUajWKxWKQxu5iInNpiscj69evJZrMkk0kymQzd3d14vV5qtRqxWAyHw0Eul5OpFzBruIj0hnw+D8ymlwhaHbzFpp0TOReNRoNcLifTwWB2/GIlU0QttOl+iUSCXC6HxWLh17/+NVu2bOGee+5ZlLGHw2He//73s2HDBq688kre/OY343K56OzspF6vU6/X2b59O16vl87OTvL5PDabjUqlQr1eJ5lM8rrXvU6mj8HseazVatKpcbvdOJ1OPB4PhUIBmL2OA4EAiUQCq9V6UGMX9TqVSmXeFDqdI4OI4GkpFotN94rWgJ8LsRDh9/txOBxyQcbhcMhrVTg6qqrK689sNuP3+0kkEphMJtxut7xXN2zYwAsvvMC99947Z33LQvfxhhtu4DOf+QyPPvoo4XCYarVKX18fZrMZi8UiUzCF0w+zEdhEItGUOncg88h8jIyM8E//9E8ycqutWUin01gslqY0X6fTSblcls5NR0cHMDuHms1mGfmG2fnLZrPJmrl2KcE6Ojo6B4ruwByH7M8AEKuY4t/a1U/xoDeZTJTLZTKZjCyAtVgsZDIZ7HY76XQamF21Ew+5xUQ8YEdHR8lmswSDQQKBAD09PXg8Huk8ichQMBiUD91arUY+n5fGQalUor+/X0ZjBIudoqFlIaljgkKhQDQapVgsSiPAYDDgcDio1+s0Gg2Z2jc9PS3PldPpxGQycc899/Da176WK6+8ctHG/9nPfpYf/ehH/PSnP+X1r3+9dJwAkskkO3fulGkw0WiUvr4+Ojs72b17N+l0ms2bN/Pa176WcrksU2QURcFms8n0GLGPsVhMOmgHmvbXiji/uhF19HAw50zMYY1Gg3A43BT1y2QyeL1e+RlRvxeNRlEUhcnJSQYHB3E6nbjdbhqNBt///ve56667+Lu/+zsuv/zyQ96nD33oQ9x666384he/4MMf/jDVapXp6WlZjxcIBOT9IBYAEokEU1NTwCvpdQcyj8xHPp+X9XFr1qzhjW98o3wvlUrR0dHRFOHR1hQBciEin88zMDBAJBKR96qIzvp8Pj3yoqOjs2joDoxOE63F5trVT7PZTCaToVgs0tPTQzgclgXm2hqMYrFIf38/yWRSRnFmZmbm/M1cLicL/1tJpVJSTUuLy+XCarWybds2ma4mUjB27dpFLBaTaVbDw8PYbDY8Hg8Oh0OKEGhX8YWxLFjqB22rEzlfQ1mbzSZrl0QqlRhrNpsln8/L1KtAIEChUKBYLGKxWNiwYQOTk5PcddddlMtluc1sNjuncALMX8RfqVQIBoN8/OMf5wtf+AKrVq0iFAoRDocZGBggGAzKNBuhTCeU4Hp7e2VKzPj4ODBbw2K32/cxxoTxI8QjhLHkcrmw2WzU63VKpZJMu5kL7bHVpiAdShNfvQB5fvZ3bOc6fu2+J86ZULNr9x0hBCKut2Qyid/vp1KpkEqlpIJiuVyWjo1QOHQ4HExPT8sI8llnnYXdbqdarVIqlbjnnnu46667uOqqq7j55pvldagVpGglnU7Pe434fD4++tGP8vnPf56rr76aSCRCo9EgGo0SCARkiqRYMEokEni9XmA2vU57HLTX88Fel2vXruX+++9vek2k2Yko9tatW+V7iUQCgF27dpFOp5vUyVRVZWxsDKPRKO9VmJ3HWu9FHR0dnYNFd2COQVpVxw4ERVHkg0VIjAKyNqZQKEjZXofDQTabJZ1O43a7GRgYYGpqSkYMgsEgVquVer2OxWKZ8zdtNtucxrRIJWrHwMAAe/bsYfv27Xg8Hjo7O8nlclSrVQwGA2azmVKpJB+aoh5HFMIaDAbC4bBMMXM4HIeUGjIf+3tYizE2Gg2Z0uZ0OjEYDDKtRhhnwrjRGgMiIqGqKhMTE9JpuOuuu7jiiis499xzm37P7XbPm4Y1nwFaKpUwGo189KMf5f777+eb3/zmPp8JhUJ0d3dz0UUXcfLJJ8uIjNvtZu3atTL1TRybVkUwrYJYMBgkn8/LKNSqVatwOp2Mjo5iMpnw+/3yGmlVKlvIcV+MGgKdxaH1HLTWvwhnRassl8vlmJ6eprOzE7fbTTweZ2hoiEajQSgUolKpyGiLNgVTpNaKmr3R0VF6enro7Oyku7sbi8XCf/zHf/CDH/yAq6++mttvv70p6tdOBUwgoopzYTQa+eAHP8i3v/1t/vu//5vrrruORqPBqlWrUFUVk8lEoVCQwh2ZTAar1SrnhMW+VlsXcATi/ujv76erq6tp/OJ9h8OBw+HAZrORSqVIp9PyvhXnSY+86OjoLDa6A3MM0qo6Bs1OzUIfftlslpdffpmOjg4ZARB1Iw6HQ0ZnRkdH6ezsxOPxsHLlSp588klZW7JUKWQw68BMTEwQiUSajAWXy4XX66VUKpHP51m5cqVMuWjNpxeKRFNTU9KhORIIQ02swgJEIpEmkYVQKCTPISAjLcKxqVQqVCoVisUibreb73znO1SrVb70pS8tyZjtdjtPPvmkLJSemJhgbGyMWCzGxMQEGzdu5Hvf+x4bNmyQjpdwKi0Wi0wr0a4ga+uQhCMn5KNtNhvJZJKOjg4SiQQzMzN0dHQ0nXvt+bXb7fsVY9hfDYHu4CwOB3sctedTzDlaJbp2CzQOh6NJmENIeYvPCyUyh8Mh00lFbUwqlWJychKAe+65h9tvv72t87IYuN1u/uEf/oF/+Zd/4ZxzzuGss86iUCjIiLK4L5xOp7zXxQJHZ2fnYbkeRfSqVRJajE17v/p8PqLRKJs2bWJgYGBOGWkdHR2dxUB3YI5B2uVFaw01h8MxpzGhXfkuFArU63X54M7n87hcLmnoiQaSgUAAj8eD1+tl9+7dsmhfpBEtpQOzceNGstls076FQiG5UiteE4ZOu3z6dspHhxthqLlcLulEafPfFUWR50wodgnjXVVVqTA2OjqKoigMDw/z4IMP8uEPf5hVq1Yt2bgVRSEYDBIMBjnttNOoVCoymvbb3/6Wt7zlLUxMTHDmmWfKaJjD4aCzsxOHw4Hf75cCEYVCQda7iHMmtmUwGJqUjjo6OigUCqxYsaLpGtaeX62xO5fBt78agsUqkj7eOZjjKOqetIXfdrt9HyU6ITEsnBaxEFGr1cjlcjJSIuYArahJNBplfHycrq4uTj31VMbGxqhUKtx///3cdtttXHXVVUvivAiuu+46brvtNh577DEuvPBCwuEwY2NjsoBf3B8Oh0Om4wqp58NxPY6MjACzzpYWcV9qHRi/3y/rXiqVikwn1u8bHR2dpUB3YI5BWlXHoNlQm8+YEIa0MCJFfQPMPqyEypRIw+rr62t6uLrdbllQPjQ0hMlkWhIVMlVVGRoakqkfmUyGlStXyj4GQprU4/E0paG0pp/AK8pHYnWz9f3DgdZAE78tpGBFOpdQI8rn80xMTMhzWK/XCYfDuFwu1q5di8Ph4Otf/zoAn/jEJw7rfmg5//zz8fv9PPHEE1xyySXEYrGmruKhUKhJYU3UwYhmhqKmIRQK7eN8aIv5tWpi2uJtYczOZ/DtT9BisYqkj3cO5jiK2idRZC9qnUKhUJPkuTDqhcqY+I6om9Iu2AAyNUtEAoWD4Ha7SaVSTE9Ps2HDBl73utdx2223LZnzArOOwUc/+lE+97nP0Wg05HU+MTEh69BEXVuhUJCNeQ/X9ShqXVrT4YxGIxaLRS4SiXEKQZT+/n5UVcVsNh+xOVVHR+fYRndgjhO0Ts18xoR4UAnDUqiQAbIGRhgW4qEvuldHIhEpnRuLxfB6vVSr1XnrXw6Wu+66i0ceeYT3v//9RCIR2ftk8+bNdHd3YzKZZCd4oS6Wz+ebcuXFfmqdG61jdzjTh9rliYtzISIw9XqddDotBQkymQwzMzNUq1X8fr80zMLhsFRPOpJpHEajkVWrVpFIJHA6nRiNRpLJZJNTWa/XGR0dxW63yzGLKI4o/C8UCnKFXfxfazi1Q2v8zpXfvxAWItmrs38O5jhq56LWtE/ttrRRGaCpt1MsFpPzmCCdThOLxeS8JJpYer1eLBYLXq+X8847j2eeeYZyubzkzoJwwC0WCzMzM0SjUbmf2matYp46nPLfQl2sXc8bbXQeoLe3l9/+9re85jWvkaIJoqcO6BFMHR2dxUVfEjkO0TZEE8pW2kJ3UexqMBiIRqNSulPbUyEajfLcc89Jxa+ZmRkpTZxKpWQTyaVwYLZt28anP/1pzj//fC655BIymQyKojA9Pc3U1BSpVEoaw2IVHmZVg7LZbJPClnBahHHg8Xhk6pYonhXF5ocbraEmVmBHRkaYmJggFArR19cnm4xmMhlSqRTDw8OkUilpeIiozZGip6eHiYkJxsfHGRoakp3WR0dHSaVS5PN5KQMt0sJSqRQul4ve3l6pLAc0ybICspdHO8S5FNeyXr9y9KEtvBf35VyfCwaD+Hy+pkiBtpBeSI5Xq1UKhQKlUkk6tuVymXw+z/DwMMPDwyQSCd7ylreQSqW47777lnw/4/E4JpOJvr4+rFarbEKrqiojIyOyyWWj0SCZTB6Set6BIiLarXOgUHHTzu39/f1Eo1GpKmk0GvH5fBgMBqxWK7VajcnJSdLp9JI0N9bR0Tm+0CMwxzlzpZNpu7+LuhdhbM7MzJBOp2Wzt5NPPhmfz9dU43DKKafgdDqpVCqL6sCUSiX+/u//HofDwfXXX8/Y2BgwW7+yevVqcrkc/f39FAoFOjs7SafTTQpqBoMBg8FAvV4nHo/j9/ulEpE4BiJ1y+VySenlI0mxWJTdsYU0tMViYWRkRKr/hEIhNm3axMzMDGazWUpPZ7NZ2WTuSNDT08Njjz0m5Z8jkQg2m43p6WksFgs+n0+mihWLReLxONlsFpfL1VTsbzQasVqtMnojahtE/UwruvLRsYM4l/MZ7uIz4t4FpOMjamFGRkaks1wul2WdiXB0PR6PXHBZs2YNp59+OnfccQfXXnvtkjrAiUSCQCDA7t27ZaRSpLRmMhmmpqbo6+sjn88f1voXQEaAWh0YEe3SRoNEb66ZmRl8Ph+FQkFGV0XPsK1btxIMBlmzZs0+ac46xyYvvvjiQd8//f39DA0NLe6AdI4ZdAfmOEWsZItVzXaSn06nk+7ubpm/LHLJG40GkUgEv9+Pz+fD4/FIg7ler9Pb29tUzGk2m+dNexC1DHOhlfv9zGc+w5YtW/jCF77ACSecgMPhoKenh+7ubpkulUgkqNVqcqWvXC5jt9ulDKjT6SQWizE5OdlUJyGMIO2q7WIZLoeyaiokZO12OyaTiVQqxa5du6Qhs3r1akZHR2Uvi87OTnnMRF+GduPZn0E4F2azeV65ae3q6ooVK8jn83g8HgYGBggEAqiqSq1Wo1QqkUwmcblcsu7F5/NJw7JYLBKJRACkQymOg/j/gdKaFqhHZpaGxTyuWmGR/W1XiFqIOUso96XTaQqFAlarVTrD4+PjeL1euQBQLpflHGKz2bj00kv5yle+wpNPPsl5553Xdh/b9agCmupZ2qF9Lx6PEwqFeOmllwgEArKn1cqVK0mlUkQiEYrFoqwxWaomrO3uabFAIhQoBaJ4Xzh9gBQS2blzJz09PRQKBakAZ7fbqdVqBAIBQqGQPE9zod+Xxw6VSuWgn3/6daAzH7oDc5zSWu/RSms/DXhFyldr4JdKJWq1mlxhC4fDlMtlstksRqORcrm8aBGYRx55hNtuu43LLruMc845B4PBQFdXl1w9hVnnRThP4XCYarWK2WyW0qiiAFhEJSwWC/F4XKp7CYfmcKxwao8x0PbfImKkVX7L5XKyGWR3dzdGoxGv14vL5cLv98t+MHDkU8iEUZNMJlm3bp28lvr6+pieniaXyxEIBMjn8039hJLJJDAbWRN1CLlcTjpHc63etrtuteiqYkcf850z7UKM0WhsqvUThf2BQACr1dok6CD6QYk+S/F4HLvdLlMvAT70oQ/x3e9+l+9+97ttHZjFIh6PU6/Xsdls+P1+urq6iEQiuN1uOjo6yOVy8j4Wkah8Pi8jy+L1pSqSF5F4LcJp0S5M9ff3A7ONg61WK52dnYRCITk2t9vN6tWrl2SMOjo6xx+6A3Oc0k5OWEu7gvf5yGQy5HI52X8lFothNBoXLYUsn8/z4Q9/mFNOOYUbb7wRj8dDMBhkYmICRVHI5/OUSiXpSAlVNLvdzrZt25iYmJAOlSgGFyv/iqJgMBhkse/hMmy1TiQg1d+EelJXV1dbsQGtCpNYATYajTJaJvqnwGwE5kjS09MDwJ///GdOPvlkaVwaDIZ9alhER+9MJiPPQyqVkspljUZDNlBtNBpks1mpzCSKiffnmOuqYkcf4lxp5ypt3yRxvYhUV2HIx2Ix2dCyq6uLrq4ustkslUpFOsLCgcnn8xSLRdk0VciXX3LJJfzsZz9jbGxMXsuLTSKRkDU8IlrhdrvlfjgcDhkxFf28Jicnm3raaHtGLTZOp3MfB0ZI42vndtFQdteuXWQyGXw+X9OzQyzGaO9vnWMTRVE+AHzgSI9D59hGd2B0JFojWUgKtxZbil4dgHQAYLaJmaIojIyMkEqlZI8YYQgcKg8++CDj4+N8+tOfJhwOyw7Voj+Ky+UiGo3icDikvOf09LSUSxWrgaFQiGq1Kg0fl8tFJBJpcnjg8DQw1DqRwhARDowQERD54+J1oKmjuHBgRMGyw+Ggo6NDvr9UPXgWijD6otEosVisKZVEjE3IrHZ1dVEqlZoEGERqn6iTEQZqLpdjeHhYdlQXvXP255jrqmJHH+KcadNQtH2TTCaTFNsIh8My1dVms+F0OqUDJOayUCgkIzKVSoVqtUq5XJYOdLlcln//xV/8BT/96U954IEHuO6665Zk/9LpNCeddBJdXV1UKhVmZmbw+/3S+BfzwvDwMP39/bL5rkjN1UbFlwKHwyGb6wq0845AURT6+/uZmpqSEaJW9nd/6hwbqKq6AdgAoCjK4VOd0Dmu0B2Y4wSxcicM8taO5cJgrlQq1Ot12SSxUCjI1UAh42uxWGR39EQiIVfUVFVldHSUcrnMqaeeygsvvEC5XOaNb3zjIY//7LPPxmq18rOf/YyBgQF8Ph9er1eKBoyOjjIyMsKpp54qH6ozMzOEw2H8fj89PT1ytdBkMknHSnT0NplMTZKgS5Fq1JrepF2FFKvJIi1OpEvFYjFpDJhMpiajQGzParXK3jwWi4Vqtcptt91GX18fF1544aKM/WARzUGnpqZ45plnGBwcZMWKFU09OGw2GzMzM8zMzJBMJrFYLJx00kly/8xmM9PT002dyR0OhxRrEIXGoBfvHy9oDWGn04nNZpNOi6h5AaRxLxZjstmsTCUTaWSZTIbt27eTz+fJZrOccsopGAwGpqameOKJJwA499xzl2xfBgYGSKVSTU490LSINDU1xfT0NIFAgEgkwsqVK+UcoW00rG3au1i0W8ARqXYiNVdw1lln8bOf/YyhoaF9enBp57zDqaSmo6NzbKI7MMcJrQZ5a8fyaDQqi+6FmphQ5xIPoLGxMcbHxzGbzaxbt042lbNarVJlKpvNoigKFouFX/ziF/h8Pi688EIZqTlYenp6+PCHP8wtt9zCFVdcwYUXXihXZiuVChMTEySTSUZGRlAURfZ0EHKf2loc0SNEOHHaFXxBa6qRiMgcCq3pTdpj29rIUjQDFTU6Qg3O4/E0GSyTk5OUSiUpu+pyufjud7/Lzp07uf/++4+4MS+Uw0qlkuzN43a7CYVCDA0N4Xa7KZVKpNNp7HY7kUhE1lCJtLFisUgymSSTyRCLxQiHw4TDYbxer3RiYf/1LzrHDq2OqsFgkMIPWjUysQhgtVoJhUKUSiVSqRTpdFo2uvV6vaxdu1amIwqnJhaL8ac//YlLLrmEk08+ecn25fTTT+fee+9tWixqNBpSkrhYLFKr1Zr21+1243Q6m3pYpVIpcrkcnZ2dB3z9b9u2jbPPPhuYTQv7z//8T7nPqqrusz2bzUYwGJQqkIJzzz2Xu+++m+eee46enh6y2ay8Z9ulIgs1yGAwOK8wiI6Ojk4rugNznNBqkLcWhgsD3mw2s2PHDkqlkmyYKB6QJpOpyTEQPVVE/xeLxYLL5cJoNJJIJHj++ee5/PLLsVgsh+zAAPzzP/8zv/jFL/j2t7/NeeedJyWdrVYrZrOZQCAgH+qiv4OQetYinIVAIMDMzEzTCr6gNdVI4wAetGXcmj7R6tBof0+kjZlMJgYGBmR0prXRaCqVIpPJYDQa6enpIZFIcOutt/Ke97zniEdfBMFgkEqlwqmnnkpXVxcmk4loNEomk8Fut9Pb24uiKLJmKhqNkkgkpGR0rVaTK765XE6mCmo7kovCbG2anc6xjZh7xL8FogGkSBONRqO43W4ZEahWq3IeE4saogalVCoxPT1NLBbjySefJB6Pc8MNNyzpfrzqVa/ie9/7Hi+99BJvetObgFcK4T0eT1MvFuGktzb01DbzFCm1B4LD4eCMM86gWCzy0EMP8fvf/146MHMpqnV3d7Nnzx5UVZXvC3GV3bt3oyiKjBK1NiIViL5QwD6LSDo6OjrzoTswxwladZ7WuhZFUWS0JR6PY7PZSKVSsoGakNJ0u91yFa1YLMrC+Xq9TqPRwOfzyYjBiy++SDqd5vLLL6dUKu1TBKolmUzOKUdaLpeb0qa+/vWvc9VVV3Hrrbdy/fXXy5SLYDBIb28vlUpFplVVKhUCgYAsHBXd3RVFkYavMA5aUxpaH9iaou+D6sAmHvLaiI7WoWn9/XbviciYqqoy5ayrqwufz4eqqthsNt71rnfh8/n40pe+RCaTmVNAobU7eSvzyVq368otEJE4LX6/n3w+TygUkhET8Tm/3y8jYOI66ezsxGQykUwm8fv9UvpWOMHtomGiT45ISRPHrN3qsWB/aSxLUfu03FJnltsx0BrDsK9SnxYROYbZVDGXyyXPvbhGXS4XnZ2d+Hw+Go0Gfr+fYDCIoijYbDZisZiM1CSTSSmt7XK5eOyxx3jVq17F6aef3iS2IZiZmZHqh62kUql591M735144okAbN68mTPOOEPug8PhwOVyyeva5XJJxbV281UwGKRUKh2UQEVvby8333wzuVyO5557jpdeekkeQ5FavHnz5n1+M5vN8txzzzU5H+vWrWPbtm0kEgkpi57L5Ugmk/T39zc5VyLFNBgMNu2TLp+ro6OzP3QH5jhkroeDkEQWKT7xeJxUKiUlSsWKWqVSwWQy4XQ68fl8jI6O0mg05AMonU7z4IMP4vP5uPjiizGbzfOuiGsLVlspFApNUp0XXXQR7373u/nxj3/MmWeeKXvAWCwWuWI5OjoqH/QWi0XWkZhMpgWv8rUeI2HUHCztjvl8BeXa91RVJZfLSVU4u90uC5jFsZmZmeG2227jueee4+677yYcDpPL5eZ0YIxG47z7sz8DYq6+Pna7fR/Rhs7OTkZHR6X088jICNPT03i9XlmfUK/XZYNUr9crC7NF7Q/MqjWpqorX6yUQCDSJLiiKIgv/S6XSfiMwwjBeSpEGnYNHqzImFj9az5U2ciy+I/pO2Ww28vk8HR0dmEwm2Weos7MTl8slIxa7du0CIBKJUKvVSCaT+Hw+Nm7cyK5du9iwYcOcIiSiDrAdqqrOew1q75/169djMBh46aWXgFnnRjgtU1NTuFwuwuEwRqMRp9M55/W6v3t6PkwmE5FIhGQyycknn8zQ0JB0LgwGg4xwa6nVarzwwgvs2bOHE044Qb7+hje8gTvuuINUKsXo6Cjr1q3D4/GQyWTkwoVYVBACK/o9qKOjc6DoieLHIOKh3xppafc5rdKY3W7H6/USCoWk1GipVCIej8uiWFHsLhyYcrnM9PQ0ExMTjIyMEI/HqVQqbNq0ibe85S2L1gNGy0033URHRwd33nknsViMkZER2ZhyeHiY3bt3Mzk5icViIRQK0dvbS2dnJx0dHTL1LZvNLovVcBGNWMhYxHmNxWJEo1EZkZmYmKBcLvPDH/6QN73pTVx99dWHYeQLJxgMEo/HKZVKFItFqtWqlLNNJpPEYjHGx8elZLKiKCSTSXl9ivqscDhMJBKRogvCEBLOnugHJIzX+a5/kb4nFN8O97VwIOf9cHOkxybqVlKpFIBMY22dr0RvEeEYi8/BKymYiUSCaDSK1WolHA5jtVqZmpqSixqVSkXOlclkktHRUTKZDL/+9a8ZGBjgsssuW/L9tdvtrF27lvHxcYAmMYJsNivrcbTX81wqkYdCvV6XTWe3bdsmt62Niv3v//6v7Iwuottbtmxp2s4555xDvV5ny5Yt0vnz+/1YLBYqlQrxeFyKygj1OB0dHZ0DRXdgjkEW+mAQRpxohiYeivl8nlqtJvOvTSaTTBWzWq1S5nZycpJcLofJZJKrhel0mq1bt5JOp7nyyiuXZP/8fj9f/epXef755/nDH/5ApVJhfHycLVu2sGPHDtnY0ePxyNodh8NBpVKhUCgwPT1NNBqVx+dIGmwLPVdC5rlSqeBwOIhEInR0dDA1NcXMzAxPP/00ExMTvOMd71h2q5mdnZ3E43EmJyeZmJigVCpJOWtRXO3z+ahWq7jdborFouwfJJTw4JX8+bmMN1ETIIqwW69rEaHJ5/NSAU3k5x9uI2o5G29HemyiaF04qaIGr1AokEqlpDEvzqW2OaXAbrfL9K5cLiejdWI7uVwOp9NJd3c3LpeLVCqF1+vFarWyefNmnnrqKf7xH/9xn/q5peK0005jiKAKyQAAIABJREFUamqKZDIp51UhZOFyuahUKsRiMTlHtc7di0E0GmX37t0EAgEKhYIs0Bc1MLVajR07dvDYY48Bs4tZoVCITZs2NW3n9NNPx263s2nTJsrlMqlUimQyiclkkhF8Ef30eDx6TyYdHZ2DQk8hOwZZaLO+1qLyWCzG8PAwvb29eL1euQrYaDRIpVJShlnkNE9MTODxeFi7di3JZFLWsjz77LP4/X4uuOCCJdvHK6+8kuuvv55iscjKlSuxWCwMDQ1Jw6dWq8m0pWAw2NRLRNS9aAvAj1R39oWeq5mZGRkVc7vdeL1e8vk8RqMRi8WC3+/HZrPx5JNPcs011xyOoS+Y0047jWq1ytatW+ns7JT9OUQvDofDIdN9PB4Pfr+fVCqF3++Xho7BYGhSjavValICu9Vhm08sAZDbEMIIR8KIWs4NNY/02FoV+YSimOj5UqvVpOEuzqvoMdTd3d1U4K6VHxcr/2I+cDgcnHjiidjtdiqVilwcuPvuu/F6vVxzzTWLIj6yUMxmMzt37sRkMrFixQqZ/ubxeCgUCk0F+kvRTyUUCjExMUF3dzdAU0Nc2Ld2EmD16tU88cQTjI6O0tvbC8yqmK1fv15Gw0ulEpFIRN5rYmFC78mko6NzKOgRmGMQUfA5X5G2toeIWPFsNBpNXeqFPK942Pv9fkKhEH6/X3ZDh9lc8Egkgt/vp9FosHHjRq666qolSR8TKIqCx+NBURS6u7sxm80MDAxw4oknylVVq9VKrVYjk8lQqVRIJBJyvG63Wxq+R3IlUDzEW41wVVWbUt0CgQArVqygt7dXnlehvhaJRHC5XFxyySX88Ic/lLn0i8X4+PghRadEH6Ddu3dz6qmnEgwGcbvdUiZ5eHiYVCqFyWTC7/dTrVbx+Xwkk0mZ+qN1eLR1DQtZgRar8UKu2uPxEAgE8Hg8snv74Y5azXXelwNHemzahqXwyvlzOBwyWme1Wmk0GrLIXcxbrQa9mAuFEEhHRweATMsqFAqyp5TL5WJiYoJnn32W9773vYdU83agTE5O0tXVhcvlor+/n/7+fqmM5nQ6pQCGzWYjm83K5q+LKRderVbl8dWiKMqcYhiifufee+/d5/Xt27djNpvx+XxSQdHr9UoHUkdHR+dQOKpmEUVRzlEU5f8pinLxkR7L0cJc9TCib8DIyAipVEoa911dXbKg3mKxSHnkzs7Opt4l4oHk8XjI5/OyaeTzzz9PsVjkne9855Lvm9frJZVK8dJLL8leDw6Hg2KxiNFoJJVKMTw8zNjYGJVKRa5gtnKkDbZ2FAoFotEo0WhUpsGFw2EMBoN0bIrFomxgGQ6H+cQnPoHb7eYTn/jEoqTDpVIprr/+el71qlfxb//2bwe9nc7OTk477TT+9Kc/4fP5cDgceL1e+vr6KJfLTE1NMTg4KFNNstksY2Nj7Nmzh2QyKSMw5XKZWq0mpa99Pt+c6lTa9BpxrYq/nU6nTCsElm0tyvFCawpnu1oX4dCIf5fLZamk53a76e7ulveHdhsieiPSsjKZDJlMhsHBQQYHB9m2bZu8xhRF4fHHH6dWq3Hdddcd1mMwOTmJ2WxmxYoV9Pf3UywW2bNnj4wSCkesVCo1zQuLjdFolMdQnI/5HBiPx8MFF1zAfffd16RceMYZZ0hVy5NOOklG0sS+iPOj33c6OjoHy1GTQqYoyl8CtwH3AB9XFOWtqqr+cYHf/QDwAUD2ljhe0KZHiRVFIbkrVsBNJpNUdTKZTKiqSr1elwXWiURCKtKIqI3dbqe/vx+YlbAVxsTDDz9MX18fp5xySpN0sijIbUcikaBarbZ9L5vNzvk9p9NJLpfDbDbLHjSjo6My1U1VVYLBoJTrrVQqWK3WfaRaD5XFuL60ETEhHS0UlsSYYfZ8xmIxmdpSqVQwGAzU63U6Ojp4//vfz9e+9jUeeughzjzzzDnlqdPp9LxSyb/85S/5/Oc/L1WJvva1r7F27VrOPvtsKpXKnE3n5iosfv3rXy9FF4TDKKSurVYrPp+Per2O3W7HaDTK5qiNRoNarUa1WsViscjIS7lcbpKk1qJNrxFjicfj8phpI21HMn1wIRwPc5f2HIgFCCFtrE39FH9D8zkWksjC0IZXnFgRTRaqX11dXbLvSL1elylN4pp85JFHuPjii1mxYgXFYlH2mWqHUAgDePTRR3n55Zf54Ac/iNVqpVAo0NXVNec+a69BVVWZnJzk1a9+NcVikd27d+NwOEin0zJSKLBarTidTiltLyIxYj47kHlNe2319PSgKEqTVL4Q3SiXy5TLZVm8D7Bnzx7577POOovHHnuMDRs2cO6558pxKIrC9u3byWQydHV1oSgKJpOJer1OoVCQKWqt96OuDKijo7MQjgoHRlGUEPBF4AZVVR9UFCUPGBRFWaOq6s79fV9V1Q3ABoAzzzzzuFryaZfPLvokiL4B2lVsYQwnk0nZ7blcLpNOp2U/hZmZGZlyZjKZpGzp1NQUjz/+ODfeeOM+D/350rMqlcqc/RTm+67P56NQKFAulymVStKJ6ejowGw2UygU6O3txe/3U6vVZK+QuSSbD5aFXF/7eyBr6zsajYZMeRINH8PhsIwaBINBotEo27dvx+l00tvbSyAQoFgs8q53vYtf/epXfPrTn2bjxo1zSsAKZ7WVVCrFZz/7We69915OPPFEvv/977Nq1SquuOIKPvGJT/DAAw/MGfmAWUesncF34YUXcvvtt/PUU0+xfv167HY71WqVdDqNx+ORTos2L75arcqIizgmoVBI9gUR/XC0Bpw41loJalE/YDKZ9vms9v44HEbTgf7GUs9dR8JQnKvHkjgH2matrQ0QtYa6w+GQBq/2PWh2cIrFIul0mkajQTqdxmq1SjnlUChEvV7HbDbzwAMPMDU1xb//+79Lh0ebftaKaND7r//6r/z85z8H4Omnn+Y73/nOvBLLQNN9KQQTVq1aJZX5PB6PjCgLGXXttVwqlTAYDIfUuFV7bZ1xxhmqw+HA4XDI/RULVSJd+MQTT+S3v/0tAGvXrgVmIzZnnXUWK1as4He/+x2XXHIJMHsuBwYGGB0dJZ/PS0EAu92OxWJpakQrzpuIlonjrqOjozMfR0sKWQp4GqgoinIq8GngWuB/FUW5/oiObJnTrh5GGMtaFS4hW1oqlaQSzq5du2RfGJvNRrlcliuiou/L1NQUkUgEp9PJvffeS6PR4G1ve9uc43n55Zc555xzeOc738ntt9/Oyy+/fNBpBF6vl3Q6zapVq6hWqyiKgtVqpbu7m0qlIovCW7s/L0daazPsdjuJRIKXX36ZHTt2yBQ/UQjb2dnJihUr6OnpoaenB6PRiN/vJxAI8MlPfpLt27dzxx13HNAYHn30Uc477zzuu+8+PvrRj/KrX/2KU089FYfDwW233UahUOCGG26YM6ozH+eccw4mk0mqxo2NjVGr1QgEAnR1dREKhSiVSgwPD8tUE5H3HwgEcLlc1Go1ueIMyGtWpArNdR3Z7XZ8Ph+hUAhgn/Sk/dWL6SwtredApIm1ymK3nl+tWppIQxMRu1gshtlsllFN0egyl8tJmWKHw0G1WpVNeX/5y1/i9Xp585vfvKBx79ixg6uuuor77ruPD37wg3zjG99gx44dXH311ezYsWPB+z85OQnMdqI/6aSTWLt2LSeeeCIrVqzAaDTKqOvw8DC5XE469kCTdPRiIZoDC7SRrXYoisKb3/xmtm/fzuDgoHx93bp1/PnPf2ZoaIhsNisbY87Vg0lXJdPR0TkQjoqntqqqVSAHvBO4F/imqqrvAS4HblIU5Q1HcnxHG1qJ0UwmI9NrTCYTNpsNr9dLtVolkUiwe/duueI3PDxMOp3GZDLR1dVFIpEglUoxOTlJo9HgD3/4A2eccQZr1qxp+7vlcplrr71W1nfcdNNNXHzxxVx44YX86le/OuD98Hg8pFIpLBYLHo+HUqmE2WxmamqKXC6H1+uVEQ2n0ykdreWIMNq0/U0CgQDr1q1j7dq1dHR0NNUyOZ1Ourq6CAaDFItFpqenSSaT5PN51q1bx8UXX8xXvvKVeVPwtHz5y1/mPe95D36/n4cffpiPfexjTSIMa9as4Ytf/CJPPfUUP/zhDw94/1wuF2eddRabNm1CVVW2b9/O+Pi4TAUTaUKtq90iygLI/jfFYlEKT4hVaKGSN9+xFUpmWileneWHqI8A2spiC7QGr7buKRaLsXv3bkZGRuRr4n4SKWVCmlikNO3cuZNHH32Uv/7rv54zaqnlf/7nf3jve99LNpvlzjvv5GMf+xiXXnopP/7xj2k0GlxzzTVs3bp1QfsrHBiPx0Mul5NzsMvlQlVVGbHo7e0lHA7T398vi/sXc3FG1NQJB6a1BmY+3vSmN2GxWHjkkUfka+vWrSOTyZDNZgmFQgQCARkRE2nHWsd0OdYi6ujoLF+WfQqZoigGVVUbqqp+SlEUC3AdsBVAVdVnFEX5EUfBfiwHRPMwu90uC/JFREWkkqmqSjqdlk6LoiiyiWW1WiWVShEMBslkMnJF2+v1csstt7B161Zuv/32ecdgMBiIx+NN9RdGo/GgHlrj4+MEAgGsVqtUJCuVSnR0dEhDWKRliYf9ckasTAp1ISGnKlaXhTMiinlFPwttke3Q0BBWq1XmpcdisQWlzP3oRz/ioosu4s4778RisewjoQqzdSwGg4FkMnlQ+xcOh9m6datsfGoymXC73SQSCakqJSJmgOzZA7NCAKImSLviLNKMtEX58yEiieJY66kqyw+t7LWoY2qnMKZNFdSmjNVqNVwuF4FAAIvFIpvXCkPf7XaTz+dJpVLkcjlKpRKDg4Nks1lOOumkBY1xdHSUSqXCN77xDc4880z5+sknn8wdd9zBW9/6Vp5++mlOOeWU/W5reHgYgEgkQr1ep1qtykauQjYZZmWWhYGvncu088ZctWn7o16vy/o0sXAh5huz2SxrFD/0oQ+1/b7L5WL16tUyVQxmJZZhtr+McM7i8bh8/gDLuv5MR0dnebMsDX9FUU4E/MAzQGPva4qqqhVl1tK9VlGUMeBc4CLg1iM22KOI1oJlrTqTMJrr9Tp+v596vU4kEqFUKuFwOHA6naRSKarVqlT+GRkZIRQKsWPHDm699Vb+6q/+ire//e1z/r7VauWee+7h17/+Nbt37+bss8/m7LPPxu12EwgEDmhfarUaf/7zn7nssstkCoiItCiKgsvlol6vy7qH/SHyy49kAanWcGt9oLfWMolamHg8Ls/b0NAQMzMzRCIRmWIiet7MRzqdJpFIcM4558wrff2Tn/wEVVW5+uqrD2r/xsfH6e3tpbe3F5vNRigUkv03RDRFm0ok0nzE9de60qx1whd63kqlkuwNstipNzqLQ2v9Si6XkwsUcyGMenE9rFy5sqnxqTDMZ2Zm5PbFtVUqlUin07hcLsbHxxc0xssuu4xPfvKTPP74400ODLwSufD7/Qva1s6dO7FYLASDQTo6Opienpb1IaJgX8zD7dDOG4fikJdKJVnTCMjFA5vNRrFY3K/4Set7ovfL5s2bGRoawufzySaWogZJ3Ls6Ojo6B8qyc2AURbkS+DIwvve/ZxRFuUtV1QyAqqrfUhTlx8CngDXA/1NVdc+cG9SRiAeF1nBrZzSL5mnT09PSuPT5fAQCAcbGxjCbzWzdupVYLEalUuEjH/kIHo+Hb37zm/s1Ivv7+/nIRz7S9JpWoaxQKGC1Wve7krh582by+Tynn366rI3o6ekhEAiQSqXweDyoqrrgXgnLQY1qvuZ0wriHWectkUhgs9mkkpeqqrjdblatWkU4HCYej+N0Ohdk0AhFoZUrV875mUqlwk9+8hPOP/982bDuQBkbG+P1r389NpuNVatWEY/HqVar0lATEssC0TW9XY2KVrXtQGhtkqiz/BARU5j/nhCIxYdWh0d7fhuNBolEglqtJqMA4XAYu93Onj17cDgcrFixQiqU7Y/Ozk5e85rX8MADD3DDDTc0zXtiPmvtpzIXu3fvZtWqVU1poqqqSlloMb/ZbLa28+JiNLU0Go1SeU3c31NTU3K79XqdWq0mnZuFIHpz7dmzh61bt3LKKacQCoVkPya9kaWOjs6hsKwcGEVRzMDbgWtVVf2ToihXAa8D/j9FUb6mqmoaQFXVdymKYgCcqqouLMn/GKM1J7k1gtAuoiAeGPV6XT4QRXNAIdVbr9cxGAxYLBZsNpss2BZqUEajkdHRUXK5HC6Xi7vvvpsXXniB733vezidzjnrENqlJAlmZmZQFIVGo8Fpp53GVVddxRe/+EUAmRPeyh/+8AdgVsJTyA77fD4ymQz5fF6qphWLRVlfoUVrcDQaDRqNhlTbESu2ixmR2V8OuVjd1EoDixQScU7Ee2NjY6TTaSltLQx8MU6ReiUUu9qRTCalwSNy9f1+PzMzMwD7fO/hhx8mHo9z1VVXkU6n51xdzufzbY2sarXK1NSUlOvevn27VDwS8shin7XHRCgwiXOTTCbx+XykUilZt6WtC2qtn2il9RgfLHqe/sEz33EX955ASCS33sdaBTqt7DLM3g8Wi4VcLofVapW9hUSBv8lkIp/P43Q6ZeS2XC7jcrkYGRmRxeaAVP9qxxve8Aa+/vWv88c//rEpVWx0dBSYVSkT6betaOejHTt20N3djcPhwGKxyOaP5XKZaDSK0WiU96W49gOBgLzPtNf0waKqqoxMBoNBjEYjk5OTUrIcZiNFrb8TCoXYtWsX8MqcIf52Op2ccMIJxGIxVq1ahclkkrVrlUpFzuvCYW097zo6OjrzsawcmL14mI2s/An4BRAHLmO2gP92RVFeC5RVVd0EHJfOSztaIwjzRRREEb1Y4dM2pxRSttr88GAwSCqVkkZjsVhkYmKCQqHAD37wA6655pr9Fr/OtzooHCvx4Lvvvvv41re+Jb8numdrefbZZ1mzZo2UF85ms8TjcSqViiwKFzUiIq1Eu+quNXQbjQaxWEweJ/GZpYrIzOVcahFN4FKpFOl0Gq/XKzuQa3ugZLNZZmZm8Pv9dHZ24nA4MJlM5HI5wuHwnIaNtk5I5LqvWbMGr9cLIP8vuP/++1m5ciVXXHEFtVptzmNiNBrbXgfDw8Ooqkp3dzeDg4Ps2bOHNWvWSJlWIQcranmEAVUoFDCbzbKQe/fu3Xg8Hjo6OqTohDi3MGtERaNRYDaFZT6HXmf5IfqHCMR9IKLA2voobZ2McHZTqRSVSkU24RXzm3DyK5UKpVKJVCrF4OCglFifmprC6/Wybdu2prkqGAzOGeV729vexre+9S2eeOIJLr74ld7KYvzd3d1zRkDFPdJoNNizZw/r16+nXC5jNpsxGAxEo1F57wsFNZPJJBcvYLamrLVu7mARCyTCsevs7JQNPlevXs2mTZvo7+9nxYoVTd+rVCqy1kUcN/G32Wxm9erVPPnkk1SrVYaGhmRvnGq1Ku9dh8OxrAVWdHR0lifLKodir9rYLcCViqKcq6pqA9gIbALOUxTFDpwDTB3BYS5LWiUoFypJabfbpbyokFEuFouyNkE8ZCwWCxaLBaPRSD6fp1Ao8JWvfIW+vr5D6tKu5fnnn1/Q52q1Gk899RQrV65kdHRUpmyUSiUp9SyKYLVqa9qoQj6fZ3BwUBrJ8MoxE0b1Ukl6auVfW9F2EBd1IaIuRUSXTCYTLpeLRqNBLpdjZmaGwcFBRkZGSCQS1Ot1otHogupfACk5O1fKy5YtW3j66ad573vfe9BGkra4V1twXCgUZJNKYcBks1kGBwfZsmULExMTNBoNeU5Ejr7o+SOOYbFYlJ8Lh8MyPUjQTnJXrKy3/q1z5BDnQqRNiX8LZ1UglBSF4S5EOoQzMjIywsTEBNlslnw+3yTuUSqVGBkZYXx8nGw2K7cTCoWYmpqS9WP7w+12c8EFF/Cb3/ym6TvCwWi38NLK6Ogo5XIZj8fD7t27GRsbk4tFbrcbr9cr7/Ndu3ZRrVbx+Xx0dHTI49NOoe1gEaIJXV1dUh1NzIFzRdfnY82aNeRyOSmPnkgkyOfzmM1mAoEAHR0d2O32A04F1Tk+6O/vl4sarf8NDAwc6eHpHGGWYwTmceBE4D17C/f/CPx4b9fgblVV9YL9NrTmE7f+rV2BFpLCVqtVGn7ZbBa3243FYpHFnD6fD4vFQkdHBzMzM4RCIYaGhggGg/zXf/0XQ0NDPPLII1LV51D5v//7P/lvYeS2Y/PmzWQyGdauXSv7OHi9Xnp7e2k0GrJYVxg22giMFrvdjtvtJhQKNRlDgqVaEWzXXFSg7SDu8/lwuVzEYjHZvToQCOD1emVqjOiVYrFYqFQqZLNZEokE09PTnHPOOQsaTywWIxgMzhmZuPPOO7Hb7fMKNOwPkVazatUqVq5cKYuqs9msTAcS+fWiHkakMXZ1dUnhCJGqI85roVCQBp54Xau6JpwS7TE/kGilzuGltaGruA9aG5Bq62TEdSCkhm02G7VaTdZPiYizzWbD5XLR29uLx+MhkUjgdDplJFrMH1NTU/T09CxovJdffjkPP/wwTz75pOxCPzMzs2CRCJG+edJJJ8k5qKOjA4vFIo9BNBqlVCrhdrsxm8309fVRLpflPLGYvWAMBoOMHIlI5qE4MCIak0ql6O7uZnp6Gr/fT19fHz6fT/7GXI11dY5O9tprHzjU7QwNDc33G4e6eZ2jnGUVgQFQVbUE3AO8AHxKUZQPKIryXiDEbC8YnYNAuwItnBvxEBSpFkKeNxqNylVPv98vozGxWAyHw8H4+Dg///nP+djHPsbrX//6Qx5brVbjpptu4sc//rF8WD799NNzfl6sDIoUMkAqcQWDQTwej6wPEc6L2WxmaGhI9jiw2+14vV5CoVBT75XDwXz9DrQry9BskAtpZeG8dHR0yH0Qhprog5NIJBa0QqWqKk8//TQnnHDCnJ+Jx+PYbLZDemBolcWE4yLGK94XUtEi6hQOh2Uqm6hV0PZ0EXLIornnQtIURb3AQqKVemRmaZjvuLY2dF1Ir5N8Pk80GpXRyUgkwooVK6QhbrPZZHRmZGQERVFkalg6naZQKEhFvAOlv78feKXgHaC3t5darcaHPvShpnqadojIjaqqsrFmKpVqquvy+Xz4/X7sdrusBxLO3WL3ghH1QCLCA6/cu/trYGu32/fpO7V27VoARkZGOOGEE4hEIoRCIbmg1C5aqnP0o6rqBlVVz1RV9cz9f1pH5+BYlkseqqrOKIryPeAlZvu+lIC/VVU1emRHtjxZSH5/u1V/8dAQeddWq5VYLEYsFgNmCzTdbjd2u10aCIqi8OKLLwLwN3/zN4c89kQiwbXXXsuTTz7JNddcw6c+9Sle/epX8+CDD3Leeee1/Y4wzLPZrDRwRX57PB7H7/dTLBapVqvSOBkbG2NwcJBGo0EkEpHF+vOt/C113US77QsDXaSGiP4XZrOZcrmM3W4nmUzKGiSfz0ehUCCfz5NMJkkmk/zmN78B4I1vfON+x/CnP/2JwcFBPvaxj835mRtvvJFLL72Ur371q3z5y18+qH296KKLMJlMbNy4kfPPP182tVMURTqfU1NT5PN5ef7EdSjS5cSKNMwaduL6FdEnLdragNZzt79opUCPzCwN8x1X7bnQ3pfa8wnst+5DvD48PIzZbJaLM5lMhmQySW9vLz09PVKeuFar8cc//pEzzzxzwdEXgMceewxFUTj//PPla+9+97uJx+N885vfZHR0lLvvvlsuqLTyl3/5l7jdbh577DFOPPFEWUgv6trE/S/+EyprjUYDn8/XVNMnutsfijNTLBZJp9NMT0/LlFKREtdaF9fKypUree6556SoCkBPTw8ul4udO3diNps54YQT5LxXLBYX1KNKR6cdIr1srvfmi97oHBssuwiMQFXViqqqvwfeDbxPVdWFFUgch8xXUyFot+ovjOVqtUqj0WBmZkZGY7Sd0Q0GAx0dHRiNRnp6epicnMRkMi2oSdt8bNq0ifPPP59nn32WW265hZtvvhmPx8OFF17IQw89NOeKn5D7nZ6e/v/Ze/P4OOuye/jcs6+ZfSZpkqZJdyht6cJSCkiBalnKpr5CRRBBxJ+iIsKLoLjg+8LjgsAjgjwsKj7gghaxLVuppcWytZbQ0DZtkqZZJrPv+3L//ojXxT2TmUlaUigw5/PhA8xMZu71e1/Luc5BKBTif7LZLHK5HAYGBhCNRpHJZJhLb7FYMG3aNNhsNg6eGhoaoFarubpfjokc1/eCSt9PdD4KyGkmhozkMpkMrFYrzGYzB3gGg4GDHbVajX//+99wOByYN2/euNvw+OOPw2w249xzz636mfnz5+OKK67Ab3/7W3R2dh7WvlqtVpx66qlYt24dd0xoMJmCLq/Xi/7+fgwPD/NMgsViQT6fh06n46o8BbF0/abTaQwPD8Pj8fB5lDqzHy6O5BzUxxmHc1yl55P+OxaLwePxQK1Ww+VyVUwytVoti1rkcjk26CXaqcPhQCwWQ2dnJ3bu3HnIHkcbNmzAkiVL2NQXGF1rr776ajz88MN4++238alPfQp79+6t+PcajQbnnHMO3njjDYTDYbhcLrS3t2PmzJk8mxgIBACAO47xeJzXZlq76Ji8l7WK5Jul0vlAqSz0tm3bmA5ajvb2dhSLRRw8eLDkWMyePRuRSIRnkci4mNY2KiZVW4frqKMSDhw4wOId5f+QOWwdH20clR0YKURRrN23rqPmTEUllFM3aDhWoVAgn8+XyJVKh6QNBgMymQx6enowZ84cnl0ARmV5a1Wpyx+sf/vb3/D9738fNpsN9913H0488USuuJ922ml45pln8Nxzz+G4446raK7Y2NiIwcFBtLW1we/3cyeDBvgVCgVaWlpYZjedTjPdjKgXJJVMCY1UXpfUcejhOp6J23iQHnPaVul5o/dTqRS8Xi9/xmAwsCxsOBxmRa7m5maWNyU6VWNjI/x+P7oo5ubuAAAgAElEQVS7u3HGGWewQ30leL1eZDIZrFu3Dp/73Oc4MCTQTAlhzZo1WLt2LW644Qb85je/qao4F41Gq1ZVV65ciVtuuQVdXV1obW1FPB5nBSmr1Yrp06dDp9NBqVSyt006nebzKQ166XhRQEd0F/oMbR/Jg9dCtS5b3afiyGC84yo9X3TvqtVqNDQ0lFx30WgUXq8XxWIRRqNxTPCr1WrZ1NXv93NnIJlMst9UIBCAz+fD008/DUEQsGrVqpJ5vlAoVHVbX3vtNezduxff+MY3xvjHRKNRLF26FA8//DCuv/56nHPOOfjLX/6CpqYmACiRGj/33HPxxz/+EQcOHEBHRwecTicP72s0GqTTaRQKBcRiMb7naS2WKrEBo2s5yY4fynoliiIikQjfa8FgENOmTUMmk2F1yH379mHTpk3Q6XQ49dRTIZPJ4HK5uCNPdLgtW7awaMKiRYswY8YMbNq0iecspbRR2n46ZsDEnmP1+Yc66qjjqE9g6qiO8sH8iX6+nFZDXhv0sCR+tVarZSliYJTuoVKp0NnZiU996lMlyjHSoLHabwOjSmF33HEHfve732HZsmX41a9+xXQIwrnnnovvfe972LJlC0455ZSK/OgZM2ZgYGCAq/lSmWSNRgOlUsnc8EQiAZ1OxxVKGgqn7aZ/Vwpg6SErHRo+HNB3EzUMAPPXpdBqtXA6nSXzHoIgIBqN8mwSMJpsOhwOlrUOh8NIJpMYHByEz+fDypUrmY5SCQ0NDfjDH/6AfD6Pq666aowCWXnQr9frceONN+LWW2/Fc889V7X7VktR6Pzzz8d3v/tdrF27Fl/4wheQzWaRTCZ54NnlciGfz0MURe7y0XdaLJYx8ro0C1AsFuFyufiaFQQBcrkcer2eK3KVKEd0P9SiM9Ux+TiU40q0L0pMpedSqVSyPwzNXkgH+ynxIdnvpqYmjIyMQKVSoVgsIhwOw+/3IxgM4tlnn8Upp5zCMy0EmjupBJrTu+CCC8b4IhWLRej1epx00kn485//jFWrVuGBBx7Az372MwAoKcqsWrUKBoMBW7ZswTHHHAOLxcIdnXQ6zX422WyWr2upPDOtXVLqqfRYTAR0z2QyGQQCAUQiEdhsNiiVSiSTyRJPsGQyiZGREU5wqDBEMu7USaK1YO7cufjjH/+I/fv3w2KxIJvN8rlzOp0l63slymcdddRRRyUctRSyOsbHoVKc6PPltJpAIMBywg6Hg305EokEB8Y2mw0ajQY9PT3w+/04/vjjD3l7N2/ejLPOOgu/+93vcO211+Lxxx+HzWYb8zmdToczzjgDGzZsqEop6OjoQF9fH/r7+5ny0N/fj1gsBoVCAblcDp/PB4/Hg2g0inQ6zbxrKWoN1NO2TCaNaCLfJx1UJ2qFtMtAnTI67zSkDADr168HAJx55pk1t0MURTz++ONYunQpZs+ePaFtX716NRYvXox7770XwWBwQn8jRWNjI04++WRs3LiRpZNnzZoFo9EImUwGn8+HXC6HXC7H+0idIao8ExKJBNxuNye/LpeLv6cctehkdZrY0Y1yUQvpuczlcpyUEqWKkEqlEIvF4PV60d3djWg0img0yhQyvV4Pq9WK1tZWDA0Nobu7GxdffPEhbdtLL72E+fPnc1elGtra2nDFFVdg7dq12LNnz5j3pTQyuVzO0u8075JMJhEIBNjfxul0HpH1SqPRwGq1orGxEeFwmGdeqEhGSaJOp8OePXvGyE0LgoDW1tYSChkAzJ07F8CoEmFPTw+2b9+O7du34/XXX4ff7+f78v0UUqmjjjo+/KivFh9iHOrDSupzIgXNU1itVu4KULIzMjKCcDgMt9sNlUqFt956CwCwYMGCCW9nMBjE17/+dVx++eVQKpX44x//iFtvvbWmbOY555wDn8+HHTt2VHy/vb0dfr+/RP0nHA7D4/HA4/EgEokgGo0iHo9DoVDAYrHAYDCgra3tkCuTtRKcQ0Wt7yNDzXA4jEAggHA4jAMHDsDtdkOn06GjowMul4vFFaj7IJPJYLVaYbPZsH//fhx77LGYMmVKze14/fXX0dfXhzVr1hzStt96662IxWL44Q9/eMj7DowKP7z11lsYHBxks9Fiscido2w2C6PRiEgkwtciBaaVePLUeaNujBQkr6vRaKqqlE32+a1jclGezEu7w5TcyGQy5PN59n4CwLN71IkZGRmBXC5HJBKBz+djdbBQKIQXXngBcrkcF1xwwYS36+DBg9i9ezdWrlw5oc9/5StfQUNDQ1XPrAsvvBDBYBCBQACpVAqDg4PIZrOw2WwwGAzsXk9rFxU1ygtY7+V6ltI2C4UCd2WlCYwgCGy62dfXN+Y7pk6diqGhoZL5xTlz5gAYPda5XA5qtRpGo5ElryfTx6aOOur4+KCewHyIMZGHlVSytNrnyb2aHjyJRAKpVAqJRILpFlTRpIfleAGyFDfeeCPWr1+Pb33rW3j22Wdx8sknj/s3K1asgEqlwksvvVTxfarqbd++HTabDXa7nZW6KChuaGhAY2MjHA4HD8ErFIqjtsqXSqVYvtpms3EXggZfXS4XJ33S80EqZMPDw9i5cydOPPHEmr8TDofx4x//GBaLBeedd94hbeOsWbOwZs0a/Pa3v8Wvf/3rQ97HCy+8EIIg4C9/+QvsdjtMJhMHqQ6HA62trYhEIti/fz96enogk8lYwYk6gj6fj+cb9Ho9U+h8Pl9JEkPVeqq4H63nvY6JgfxcAHDXhZJcaccun89jcHAQ6XSaKaWZTAaRSATNzc1oa2uD1WpFMBhET08PXnzxRZxxxhlVlcLKMTAwgMsvvxxyuRyf/OQnJ/Q3JpMJX/7yl7F58+aK6khnn302lEolXnnlFezfvx+vvvoq9uzZg1AoBJVKBbPZzMUXKe1xMruHGo0Gcrmcj7HFYkGhUEA6nYZWq0U8Huf7tLGxEXv37h0jm9zW1oZcLlcyRN3c3Ayj0Yh9+/ZBFEWoVCqWM3e5XDXFVOpS5nXUUUc11J/oHyFUWuwnQjMjdadcLodAIMAVMb1ez10bi8UCo9GI4447DgDw6quvTmib/v3vf+OZZ57BV7/6VXzrW9+asOOyXq/H4sWLsW3btorvr1ixAscccwyeeOIJAKOJSS6Xg0ajQXt7O0uhUtVdWrmdCD6Ih6ZWq4XZbGZvGofDwQGXlPOeTCbZm0cURUSjUQwPDyOfz8NgMNT0s0in07j88svR39+PBx988LD8F77+9a/j/PPPxy233HLISUxbWxs+97nP4a9//Ssb9NHQMYkmqFQq6HQ6po5lMhmew6KZJLo+qQMjDWAJWq2WJZgpMa+rHH24UN51I9GG8i6cxWJh6mh3dzd8Ph+8Xi/y+TyamppYNILukVQqBZVKhb///e/weDy46aabJrQ927Ztw1lnnYWDBw/i7rvvPiTJ5bPPPhvA6PB/OTQaDcxmM98LJG6Rz+eZNkYUSVqTpWIkkwHqcNH3mc1m+P1+iKLI/jOULM2fPx+CIODVV18t6bbMmzcPcrkc27dv59dkMhnOOOMMvP3221Cr1TCZTDznQ9RQKjYkEomStfdIK0HWUUcdH17UE5iPECot9lKaWbVqlkKhgMvlglwuh1arhUqlgkqlgkKhgNlsRjQahclkYgqDxWKp2hkpxx133AGbzYYvf/nQTXmXL1+OvXv3wu/3j3lPLpfj9ttvR29vL37961/DbDZjzpw5mD59OlcBDxw4AJ/Ph0QiAa/XCwBjhrhjsRi7wRPoONLcyfuVyJTTZShI1+v1iMfjTItTqVTcqSH1IK1WC6PRCLPZjFAoVPH7i8UivvrVr+LVV1/FnXfeedgmpEqlEo888ggnMffcc88hHaPbbrsNuVwOP/3pT9m/JhwOo7+/H93d3QgEApzY0AAzJZ/5fB4+n6+Efy8IAhwOBzu2S4+nTCZDPB6H3++vSlWpV3mPXki7a2Q+S/eGFNlsFsViEcPDwzyYb7FYOPEleqbP54MoivB6vdi5cycef/xxrFq1atyuJQA8+eSTuOiii2AymfD8889j2bJlh7QvHR0dsNvtFRMYYLSb4vf7YbFYMH36dDidTjgcDjbcHBkZQT6fP2K0RxI1IDVIs9nM3RhKYOj+0mq1WLBgAfx+PzZs2MDfodPpcMwxx2DHjh0l99PFF1+MkZERvP766/B4PHy+isViSTcJQMkzrD6jVkcddVRDPYH5CIACMOL6Sxd7qWSp1+tFOBwuefiT7wgp9Wg0GthsNjQ2NkKlUnECQGZmGo0Gxx57LP75z3+OG/Bt3rwZL7/8Mr75zW8elmEZBdhbtmyp+P6KFSuwYsUK3Hvvvdi+fTuKxSLPQ5BUZz6fL6neUjWXghi32w2Px1Mx6QNwxKt/dO7KOwPlvhc+nw/9/f3weDwYGBhAOp1GNptlWtXAwAAikQgUCgX7NpT/zve+9z0888wz+NGPflTT92UioCTmoosuwu23345bbrllwt2NGTNm4Etf+hIee+wxfPOb30Q+n0c+n0c4HGaKX2NjI1wuFxobG5kKRApJqVRqjMM5UYV8Pl9JRZjuCbvdXnUOpl7lPXoh7a5lMhk4HA40NDQgn88jFovxNafRaGA0GmGxWCCKIrRaLUKhEHsN0d+RaWU6ncYDDzyAeDyO733ve+Nux8svv4zrr78eJ598Ml544QXMnDnzkPdFEASceOKJeO211yqunSaTqWRon2bhfD4f9u/fj/7+/jHiGZOZfJtMJhiNRhYLkSYwCoWCjXQJLS0taGtrwz/+8Y+SeZjFixcjEAigt7eXX1u1ahWcTid27drFqm7hcBjxeJw7SfTdBoOBn2H1GbU66qijGuoyyh9SSBd0qXQmUWYSiUSJbGwymeSqPc210N8ODw9jeHgYZrOZH4QWiwV+vx+5XA5yuZxlPW02GxYtWoStW7eir6+PH+TFYpHnTOj/f/SjH6G5uRmf//znuapXCYODgxVfnzJlCgwGA15++WVccsklY97P5/O44447sGzZMtxzzz247rrrShIU8nkxmUws0TsyMgKHwwG5XI58Pg+j0cgPTDqmgiCUuL8fjqdCpdcqfUc1GV9ppbNYLLKpIxl2xmIxNhfN5XLw+XxIJpMwGo3wer0QBIEliQHgT3/6E37zm9/gmmuuwdVXX43+/v6aQU81E1EA8Hg8PIvzwx/+EHq9Hg888AD6+vrwgx/8oKqqGRkJAsCdd94Jm82G//qv/8K//vUvfOc738Hy5cshk8mQy+UQCoXQ3NyMcDgMs9mMQqEAnU6H9vZ2FjIg0KA2SU0DYGlXqfx1uXgDyYdXoxfWOj7jzZ3VwoclGHsv+1Hrb+leoOMPjK5b9Fq52a7D4WC5ZOqq0XluamriogXJ9s6cOZPluUmCORAIoFgsIpvNwufzobOzE8888wzWrFlTMxlxu93w+/248sorMW3aNNx5553cGRwZGamqQBYOhysWbRYuXIh169Zh//79mD59esl7RqMR6XQaQ0ND8Pv90Ov1mD17NkwmEzo6OpDL5cbINZevH4d7bZE8tUKh4I630Whk0RZaoyORCLq7u/nvbDYbAoEA7r//fnz605+GUqlk+flnn30Wl19+OX/2kksuwYMPPohVq1YBAM/VkJktqa4ZjcZx9+Nw78066qjjo4N6B+YjgPI2eyW5ZOl8hZRGRf4C2WyW51+y2Sz8fj/i8TgGBweRTCbh9/tZ7WfWrFkAgI0bN1bdpnXr1qGzsxPf+c53Jjz3Ug65XI7Fixdj8+bNVT+zcOFCXHrppVi3bh1SqRQEQWBJaPJB0Wq1HLzSgL9Op4PZbEZjYyMrGZVDJpPBYDAc0eHvcmU4Sj6Bd2VFZTIZjEYjVCoVc+VnzZoFm82GYrGIxsZGWK1W2O12OByOih2Y9evXo729Hbfffvukbr9MJsPNN9+Mb3/723juuefwta99jbt1taBSqXDrrbdi8+bNcDgcuPHGG3HLLbdwwCiXy5FIJODxeOB2uxGJRBAIBGA0GuFyudivCHi3W0VDwRqNZkLdoFQqBY/HA5/Px8e5jvcPNJRf3gEtRyUlMofDwV4jFPhKO3Ok3OX1ejE4OIhQKIRkMgmlUolisYhHH30UoijitttuG3cbv/GNb6BYLOKee+4pmUU7HCxZsgQAsHXr1jHvNTQ0cDIyf/58LFu2jK9njUaDxsZGNsCkdYIMPg9nlq0cGo0GOp2O1x+TycQqj5QwUGeboFAocMYZZyASifC8olqtRktLC3bv3l2SaHz2s59FsVjEK6+8gsbGRrS1tZV002KxGKvL1VFHHXWMh/oT+yOA8kC7klyyNAggFItFBAIBfi+RSGDPnj3o7e2Fz+eDXC7HiSeeiDlz5iCVSmFkZAQymQxLlixBW1sbNm3aVHF7crkc7rrrLsyePbti5+RQsHTpUvT391dU7iHcfvvtEEURv/rVr+B2uxEKhSAIAux2O7tw04C3SqXixO5IJycTAVEkaDuknH96sEejUcRiMSiVSigUClbvyuVyPAjf1taG448/Hk1NTRU9Wt566y0sWrToiOyvIAj44he/iLvuugtvvfUWzjnnHAwNDU3obxcuXIgtW7bgpptuwpYtW3DNNddg27ZtsFgssFqtiMfj3E2i6nksFsPQ0BB6enoQiUQ4iKPjGI1GxyiSAWMHwrVaLRwOB1MnJwsfh5kaaffqcEEJp8vlKqG9Vhrcj8ViPJMmVZYD3nWAV6lUfMzj8Tjkcjmy2SxMJhO0Wi3S6TR6e3vxyiuv4J///CeuvfZaTJ06ter2URe5p6cHP/3pT2t+dqKYNm0abDZbzQRGpVKhtbUVLS0tMBqN0Ov1yOfzPAMXi8X4OGQymUlV2Eun09zBbWhogNfrhUwm445seQIDjKqMLViwAO+88w6v09OnT0ckEkFnZyd/burUqVi+fDlefvllnrek4lIgEMDIyAgymUyJ/1VddKOOOuqohg9dAiPU+8PjolqyUv5AoMplLBZDJpNBKpVCMpnk4VEa5C8UCti9ezd27NiBAwcOIBwOQ61WlyjNSPH3v/8dvb29uPnmm7lieLhYvHgxgNqqZ1OnTsWMGTPw7LPPIhqNMoUgnU4jFAohGo3C6/XC6/WiWCzyLNB7DcAmAgpmK71WKcCVcv4DgQA8Hg8GBwf539RZKxaLUKvVcLlcHIATFS6TyZQokRG16nB4+4eCc889F/fddx8GBgZw1VVXTfjvVCoVvvvd72Lr1q1wOBz4yU9+grfeegu9vb2Qy+XQaDRobm7m2QUa0u7v70d/fz8HcZlMBvl8nqlq5YPe5YaWgiAwFa58pobul8NJQj4OMzWHu4+iKCKZTDJVzGg0jqEMlZ8n6pRJ5zGkJqdEnwyHw3yvpdNpBINBhEIhyOVyzJgxAzabDel0Gk8++SS0Wu24ymO///3v8dJLL+Fb3/rWIQ/sV4MgCDj++OPxxhtvjHnPaDQiFovB5XLBarWylH0sFsPOnTvR29uLgYEBPg5S+eF8Pv+eA/5EIgGfz4dUKsXFnVAoxJ13AFXX8xNOOAEWi4WfCdOmTYNMJsNzzz1X8rlLL70Ubrcbmzdvxquvvgq3241MJsNS0USRq2U+W0cd46GtrQ2CIFT8Z9q0aR/05tUxSfgwzsCYAIzlyHyMQYZ9Op2uaiWOKvvxeBxWq5UrYE6nEyqVCgcPHoTFYkGxWIRSqYTNZsO+ffsQDAahVCphtVphMBgwNDSEm2++GQMDA3j44Ycr/tYTTzyBadOmTdgjoRZsNhsAMLWiEjKZDILBIJYtW4bW1lZ4vV4UCgW43W7mY1NASsF/IBDgCu57pYXUQqUZl2pzL8C7nH8KSrRaLaxWKzKZDMLhMM++UOeM5lwUCgWKxSK6urrQ3NwMlUrF32k0GtHc3FxSDT1SOPHEE3HjjTfiBz/4Afr7+9HW1jbhv124cCF+8Ytf4Oyzz+ZKrM1mg9VqRTqdhkqlQjqdRj6fR0tLC3ceqdNIlEHy/Smnomg0GsTj8ZJui3TWSAoKoICx52g8UDfho6ycdLj7WOvaJ5SfE7VazZLu0vNE/+1yuXhwP51OI5fLcSBP9FCZTIaGhga0t7ejWCxi1qxZNX1f0uk07rrrLsybNw9f+MIXDmkfx0OlLgbwrkIiFZPIrLanpwderxdGoxFWq5WPOdHnotEor3HA4a9n6XSaBVBisRiy2Sxmz57NUs7AaJJDAidSyOVyNDc3o7u7G6IoMo3slVdeKfncihUrYDab8Y9//AN2ux1NTU0wm80Ih8NobGyETCbj+U2iC0qpotK5zjrqqIZajI16Dfyjgw/VSiAIwicB/I8gCM4PeluOJkykGiqt7FO1WTpbQcFysVhEJBLB4OAgG47l83lYLBYMDQ3h2muvRSgUwvr163HxxReP+Z3+/n7861//wmc/+9lJWSjowVmrEvfEE0/A7Xbj0ksvRX9/P4aHh5l6RcGMTCZjVaumpibmXx/pILOSDOh40qAUcJHilkqlgt1uh0qlgtFohNvtRjAYZF8LmgeJRqM4ePAge/UQBEHAJz7xCWzZsqXmcP5kgRzNn3766UP+W+qIqFQqDsRIWUyhUMBqtUKhUMBkMrFBHiWlmUyGxSQq0WroOEm7LZW6lQDY5f1wro+Pg3ISCV0cajA5EVnc8nNCXiGkhBWPx/keoTVMp9MhnU5Do9GwNLdKpUJjYyNLAOdyOVazs1gsNbfzkUcewdDQEK677rpJP49S+psU5MFC6oLUfSkUCnA4HHA6nZDJZMhmszzzQ9cpeXm9l/VMOkcHACMjI1i+fDmA0c6ZXC5n0YVKMBqNPE8JAO3t7ejq6iqZyVOpVDj33HOxY8cOKBQKPl9er5cLTLFYjJUHaT8rdWQ+DlTNOuqoozo+NAmMIAinA3gQwEOiKHo/6O05mjDRoICkRAuFAksnJxIJWK1WzJkzh9W5fD4fPB4PBEHAlClTYLFY8MILL+Cyyy6DyWTCpk2bcPLJJ1f8nT/96U8QBAGf+cxnJmXfKIGhIKYchUIBd999NxYsWIB58+ahUCjAbDbDYrFgwYIFWLhwIVcMHQ4H7HY7pk6dygHyka7mSWWsK71Wi0pG8wHkJE7qcUQZa29vh9FohM1mQyKRwL59+7B7927MmzdvzPedfPLJiMVi2L1795HZUQna2tqwaNGiw0pgiKKiUqlgs9mQTCYRiUQ4+ZDL5TwzQdS4SCSCVCoFtVoNmUxWVTSCVKwmMu9CQfRHOQn5IEAO7OMdVynllYJ0jUZT9Rwnk0l4vV74/X74/X6kUimIosj3j8lkgiAIyOVyCAaDY9S8pIjH4/j5z3+O008/HUuXLp2U/ZZC6qciBdHqHA4H8vk8+vr64PF4WDilsbGR73eij9F3KRSK9zwLI5fLYbVa4XSO1gfdbjeOP/54CILAtLJyzywpqOAQi8UAjNLIRFEc43tzwQUXIJ1OY/v27Ugmk2w6SvN8yWQSKpWKzzvNypTPdX4cqJp11FFHdXyYKGSzAdwliuJzgiA0AugAoBBF8eXx/lAQhC8D+DKASRnEPBogfYhIA2J6vVAocEWSHmpEp/J4PMhkMjCbzWyWaLPZOFAOh8OQy+UcGD7xxBP41a9+hSVLluAPf/gDB5ZSjIyMQKlU4sknn8SJJ54IhULBXG2gdks3GAxWTb5yuRyUSiXC4fAYg8ZCoYDnn38e+/btw5133ompU6cyfYjmdyh5KT8W1aSOx6PiVcJEr6/y35TSacr3nwI9qsICo0E1qXORuV2hUOBAJhaLIZfLYe7cuchms4hGo0xXOfbYYwGMeupMmzaNpVqroVaARwPVlUAUk7PPPpuH+ltbWwGMBm7Vjmsmkynh18fjcZhMJmg0GhQKBfYpAkYpRclkEgcOHIAoirDb7WxuSJ0YQRCQTqehVqv5e5PJJGKxGHQ6HQwGw4dC7vijuHYB1WVw6XUp5dVut0On0zFVNh6P8/A3zbzkcjmk02mYzWY4nU6mEgYCAdjtdrjdbu5cBINBmEwmLor4fL4SyuX9998Pv9+Pr3/96/D5fFU9rEKhUMnfSUFKepUQjUZhtVrHrKHZbBaCICCTyfCAPs0HaTQaiKLIXRqdTldz/ZgIpNdWS0sLotEoFAoF368DAwNYuHAh1Go134/FYhHBYJCLAFqtlmWVaVv27t2LYDCIjo4OaDQarF+/vmTuQK/XY8qUKejq6kKhUODjRGa96XQaOp0OjY2NYzrX1HXR6XRVaYx1ieU66vh44MOUwGQBLBcEoR3AUwC2ArhAEIT7RFH8Wa0/FEXxNwB+AwBLliz5WPSbyRcDeJdrTnxirVbLizxRFfR6PRoaGqBQKJBKpZiO8/DDD2PDhg245JJLcPfdd8NsNlf8PYPBgH//+99wu9246aabxvCkp0yZUnVbjUbjGE8EAjmxFwqFMZ2MYrGIX/7yl5gxYwauv/56yOVyntmhwXeDwcAUk1ocajK2pGHVQ+GRT/T6kj486VxQYEYJJyVP+XyeDSsTiQRMJhN3HeiBb7fbuWqbz+c5kFiwYAEUCgVsNhsnMFarFVOmTMGuXbtgs9nGuNaXo9bAv9PphMlkqvheMBiEXq/HxRdfjLvuugsbN27E//k//wcAanZH5HI5y0TT9yiVSmg0Ghw8eBDJZJKr6XQcC4UCB6FkiEeVab/fj2w2C5VKNUY6XHouagU0hxvsTGaQ9EGuXUcy2BvvuGu1WkSjUUSjUWg0Gvavkg6q0wA/MBrE0udcLhcraPX398Pv98PpdLKpaSgUgt1u52tRo9FwIhIOh/E///M/OPvss3HSSSchEAjwHF45dDpdVSoaqQVWQrFYZHUxKeRyOd8jJPtMghTpdBoKhQKBQIBn3gRBQCAQYPPOVCp1SJ5V0mtr/vz5IhV+5s6dC+Dde/mkk07C5s2bcdVVV+Gee+5BMpnE4sWLsXTpUrz88svsuWQymfDmm29CqY9MrmoAACAASURBVFSyxPWCBQvQ2dk5Zj395Cc/iccee4yTJjqearUaHo+n5D6XQpq0GQyGMd9bp5PVUcfHBx+mBOYNAIsBrAHwe1EU7xYE4UEAawVB6BJFccMHu3kfLKgCTQF6peFk8tWw2+0wGo3I5/PsTE2Dk3a7HbFYDOFwGI8//jg2bNiAG264AT/84Q/HVYR56qmnYDQasXLlykndN+oMlePll1/G9u3b8fOf/5xldqnzIK1YUtBDXYNK/HOp0ef7MXxNCnA0fEv+NMDogzkQCCAUCiGXy8FoNPI5tVgsHKgBo4F7oVBAIBBAV1cXlEol+/RIIQgCTjrpJPzrX/86pId8sVjE008/DY/Hg0KhwNtKfhrkyTFz5kzMmDGDE6apU6di0aJFeOSRR7BmzZqqiW85pMEMVdQtFgssFgv0ej3z5lOpFJxOJ5LJJPR6PZRKJdRqNQ9A5/N55PN5yGQy7jLq9Xo2Pqy0n/Uh4SML6nBqtdpxg2wSaEgmk9ypoHuF6LLJZBJ2ux2CIECtVpcIOlCS0NzcDJfLhWw2C4VCgcHBQRSLxaodxgcffBDRaBTf+c53JnfnJRiPQgaMig9YrVZYLBZEIpGSIpTX6+Xv8Xq90Ov1cDqdhy06QZDL5VxIUSqVcLvdAEYpoaIoYnh4GFdeeSVeeOEFbNiwAVu3bkVjYyOcTifkcjl3O6Wqi4sWLcKvf/1r+Hy+EvPZlStX4tFHH8VTTz2Fz33ucwBGBVtkMhnLyBuNRl4PCHTcPsoCGR8FSLt7ddRxpPChSWBEUewSBCEMYDWAfwqCYPjPa38B8KF2vpqIith4f0++IcC7Boh6vZ4DeOkDs1gssqM7zQQUi0X4/X7EYjE0Njaiq6sLTzzxBG666aYJmR/29PTg2WefxUUXXTSpnhoAODAtx0MPPYSmpiZcdNFFbJ4YDocRiUSg0+l4ZoRMDmt1AKR0hMmqPEspaeWg86HRaJjqRB2YYrHIFDii+dFQPykxhUIhpkvRYPO+ffswe/bsqrSWJUuW4K9//SuGh4cnvA9/+ctf8LWvfe2Q9runpwc6nQ4//vGPccEFF+COO+7Az35Ws0nKkF7/Ho8HiUQCSqWSg1i9Xo/u7m4YDAZYLBaejVAqleyNYTAYYDaboVQqEQqF+JxTEkgBJJ3nSvdPHZOPWgpklEBqNBrI5XJO5qmLQetUJpPh5CUSiSCfzzPlic5tLpdDd3c3J9eiKHJHY+/evQAqUyTD4TAeeughrF69Gsccc8wROw7pdLpmAhOJRBAKhWAymXiwHnh3houkoVtbWzlJkyb+0nVnomuZTCaD1WqF3+9HOp1GY2MjJzDNzc2Qy+Xo7+/HypUr8cUvfhF9fX3YuHEj9u3bB5/Ph1WrVjGVmSivwLsy+Nu3b8enPvUpfr21tRUnnHACXnnlFSxfvpyfQTKZDJFIBH6/H0ajEU1NTWO2sz6bdvRD2t0TBKHeFqvjiOCoLDUKgjBbEISTBUFQCoLARGJRFL8H4BkAFgDXC4JwPYDPAXjrA9rUScF7HUakijO5zpe/R+otVIGmOReiW7S0tMBkMkGpVCIYDCKZTOLgwYMAgK985Svj/v6BAwdwzTXXwGAw4Nprrz2sfagF4jyXY3h4GMcccwyampqgUCh4+LOpqQkGgwHhcBjJZJKlVCngr4Ry5Sjq2LwXX4Va55UexCRnLaWPJZNJBINBpvoplUrE43H4fD4Eg0H261Gr1Wz4qNPpkM1ma85J7Nu3DzqdruZ8Sznmz5+PU089lf9foVCwrC11R6TX3EUXXcQJw6JFi3DeeefhpZdemnDXZ3BwEMBo0BQOhzmpJvnkUCgEt9uNaDSKYrFY8r1arZYpJVqtlhM7aecwkUjA7XaXVIlr3T91TB4qGewSaJ0ihTjqUCaTSZ7VokF1YHTmZXh4GIFAgGlVfr8f0Wi05DWDwcDD/01NTejq6gIAnHTSSWO2YWRkBOl0uiTQPhJQKpXI5XJjXqfEmuiy0WgUQ0NDGBoags/n46IFCVlYLBa0tbXxd9H6dTjPE6KlkucSdX6AUUENkm4ntLe340tf+hIsFgsn/sCopPXIyAgrkc2YMQNWqxXbtm0b85uf/vSnsWvXLgwNDSGdTvPMZUNDA3ta1VFHHXVUw1HXgREE4WIA/x+Aof/886YgCI+JohgFAFEUfywIwgoA0wEcA+AcURR7PrANngS8V98IKV2skhys9D21Ws0UCgrYKLgPBALw+XyIRqN4++23Ybfbmd9cDcPDw1i9ejUymQyeeOIJroZOFnK5HMLhcEUeei6XgyAICAaDsNvtLANNMyTpdJppJYlEooRiMh7KudaHg4meVxrAp9/S6XRMtxBFkQeRM5kMD+zLZDLs378fJpOJk55AIMDD+uUoFotYv349zjrrrEMK0ufMmYOnnnqq5LVIJFJzBkY6vHzCCSdg7dq1GBwcrOm7QaA5nnnz5kGlUrGfS7FYhNPpRDAYRFtbGywWCwYGBqDRaNDY2MjUtWQyiWw2i2QyWbETSN3OfD7PlEKdTsczQXX62JEDFQmqqe4BYGNGtVqNhoYGZLNZeDwe7qZSgWFwcJDlsm02G2KxGNxuNwwGA0wmE9MONRoNtFotjEYjTCYTnnvuOZxwwgmYMWPGmG2g5OlId+B0Ol1FEQyaRUylUigUCpg7dy4XZgwGA6xWK6sTUpeduo7S7T7c5wn5wNDvSTspJpNpjBcXqZNJqWHt7e3Yt28f+vv7MWXKFMhkMpxyyinYuHEjz6QRVq9ejZtuugn79+/HsmXL0NDQgGg0CofDAaPRyPcwibwQlbaOOuqoAzjKOjCCICgB/D8AviSK4pkAngbQCuAmQRA4YhJF8SVRFB8C8B1RFI+8LuwRBvG9D2Vxls52VHuP3KqlgRm5u/f19eHAgQPw+/1IJBLo6enBwMAAzxoMDQ1VDYYJfr8fF1xwAfx+Px544AHMnj370HZ8AqCHZqUEJpvNIpfLobe3lxOUYrGIPXv2IJ/P84M1kUiUeEdMBBORph4PE/UDoQBLqrRE3Ri9Xg+73Y6Ghga4XC4OaMg1OxAIwGw2o729HcFgsOrA8ZtvvgmPx4PzzjvvsPfncLBkyRIAqOg8Xgl79+6FyWTizqBMJkNfXx+y2SzL5CoUCk66aXgbeLeTQnNQxWKxatKaTCbZ3V3qy/Fe3czrGB+kJFXpOFMnJpPJ8MwT0Sf7+/vR39/PUukulwszZsxAOp1GPB7HyMgI4vE4+72EQiH4/X6EQiGEw2GsXbsWu3btwmWXXVZxu6hTN9kU2HJI1dOkoASGzGlJuGLKlCmw2WzIZDIlSorAu35F0mv8cH2IyCg2EAggk8mUJDBkNilFKpVCOp0u6eharVaYTCb09fXxa6eccgqSySR27txZ8vdtbW1YuHAhdu3axf481IlOp9Po6+vD7t270dXVhb6+vnFnMIG6N0wddXyccNR1YAA0AJgJ4BUAfwPgB3AugEsBPCAIwlIABVEUdwA48q58HyBqLcJSp3AAHLABYOqTQqFANptl53LS+Q8EAjw0rtFokMvl4PP5+H1BELB7926sWbOm5KHhdruZHhSLxXDFFVfgwIEDeOihh2A0Gpl2Vgk0eFoJ1YzdAGD//v0ARhMK6QMVGJXeVSgUTLXQaDQIh8NMPVKpVIjFYjAajUwloWM60SHiyYT0fJKhIgUk0gA6FotxAppIJGCxWCAIAv+9XC5HR0cHm1uGw2FOWhsaGirKw/7v//4vlEolFi1aBL/fj+Hh4cOmS/l8vqo0tGQyWdKFI8+WLVu2YOnSpVVdyPP5PDQaDfbs2cMiBHSNx+NxJBIJtLS0MC3G7XazlG6hUODqrtlsRj6fRyAQ4Iq6VKJZJpOxjDIp5dF1QSIX0gp3oVCA3++H3W4v6SzVOfjjo9qxo/NK3VKpozydFzonOp0O7e3tTOmkDkE4HOZZsFQqBYVCgZaWFlgsFqZo6fV6pmT5/X787W9/g1KpxLnnnltCr/L7/VCr1bxGZbNZpksNDg5WlQzv7e2tukYEg8ESw1QpaM6jPImJRqNsWklrYiqV4k5HMpksWQdoxoUKH0S1PZxrk44viSxYrVYcOHAA2WwWw8PDEEUR8Xgcvb29fC5pli4cDuPtt9/m79JqtRgZGUFvby927drFKm9///vfuSBkMBjQ0dGBs846Cz//+c/h8Xh420mymWYARVGEKIrIZrOsTlatEFVrzqqOOoDRxLnaPdLW1lbT8qGOowtHVQIjimJOEIRfAPi6IAg9oihuEQRhK4BmAOcJgvBbAMsBPPGfz39syyyVVMaKxSI8Hg+KxSLTKLq7u3nw1eFwIJPJoL29necnGhoaMDIywkOcWq0We/fuRSKRwHHHHVcy9K5UKqFSqRCPx/GVr3wF+/btw4MPPojly5ejr6+vprt1rapmKBSq2jkgTJ06dcz3FwoFltJMJpMYHh5GY2MjRFHkmR5K1MhDhY7TexFNGA8TCSAqyVwD7w7hSqlOJG8KgB/gOp0OhUIBiUSClZWAUYlj+iwJGUSjUfz1r3/Feeedx5TA5ubmmspgtW6tfD5fNRFRq9Vjvnfx4sXo7OyE2Wyu2tEi4YJ9+/bh1FNPhdFoRCqVQnt7O1eZY7EYX3/ZbJZnXmhegrqYVLkn8QeNRsOBmVSJTBCEqueKXqdkD8C4dMo6SlHt2EmVwsp9TMppfHK5HEajke/hhoYGvjfI0NXn86G5uZkT0mg0imw2C5fLBYPBgHg8jilTpmDbtm1YuXIlGhsbS7aTqGZ0TbtcLk7Qw+FwVR+YYrFYVRREq9WOGUAnWK1W9Pf3j7kX0uk0jEYjAoEArFYrMpkMvF4v1Go1lEolJ2Rk6iqKIh8r6XpyOIUXmUwGpVLJppEOhwPvvPMO1Go1Fi1ahEwmgx07dmDGjBnc2X7++ecBgGX3qdhF609XVxcuv/xyAKPS7rt27eJijEKhgFKpxPnnn4+f/exn2LJlCxobG0v2kWiApIA2MDCAjo4OpgTXokxPphhLHR8t1EpQ6tfMhwtHVQLzH2zBqGnl5YIgCP8xqvzf/8jyTRFF8e4PdvM+eJDmP8nJUmBWLBY5UFAqleju7oZOp2OeOCn35HI5ropRwOdwODgo7u3tBYCKSjzJZBJXX301du7cifvuuw+f+MQnjui+BoNBAKg4P5HNZtnwrqWlBblcjqknmUyG+eLlsqXS7tVkd1kmikoJKACmuUkDcvK/oIozVW9peDabzfKgc6XOyJNPPolEIoGrr776CO9VZSxduhS//OUvEY/Hayaq0WgUw8PDOPbYY1kiVqfTYcqUKUin0yzjbDabWZUqkUjwdUxV5IaGBk4K5XL5mKpsuekroZLMMl13E5nfqaMU1Y6ddBaGOmK15mMAjElSnU4nKyeSfK9MJmPBEq1Wy8P78Xgc27Ztw8jICC699NKq2/t+UcjIoLYc8XgcjY2NkMlk8Pl8PJxvMplgMplYiIX2U9q5nQx5YZ1OB5fLxYmZtONNxaNgMMgJzMGDB3m9kiajTqcTarUaw8PDbFS5ZMkSvPHGG+jt7S3x/Jo7dy6mTZuGzs5OrFixAjKZDN3d3TCbzVysaGpqgkajYfNKMqQFxnZZjkTnvI6PD2p1Z+j9eofm6MFRl8CIopgWBOEPAEQAtwiCMAdABoADQOVe/scMFJBJVbLowUbVynfeeQdDQ0Nobm7GMcccg2KxyIu+XC7nAX6p94hcLkc0GuVBajI0k+JrX/sa3nzzTdx9991HXK0HGO3OANVnYBQKBVOtyMiNui1UoaPkjvafKvofpMqNNPgoR7nwgnRQ12azcbcim82y+VtPTw+/L4UoinjsscdwwgknYP78+Udwj6pj6dKlKBaL2LlzJ9ra2qp+bt++fQBG+fZer5dNVnO5HNRqNTQaDasbGY1GhEIhNvWjqi9Vkinho25WLQEHqQdMeXJDik91HDrGO3aUtFRCuS+PWq1mcQ5ygh8cHEQ2m0VLSwvLkdNnYrEYYrEYstksRkZG8Oijj8JsNtdcs97PBKYSLY2G1gVBwNSpU2E2m9mQNhQK8UyjtFtFmAx5YSoKxONxyOVyxONxvg9oXaGCEjCawFBXO5VK8WdJJjocDmPnzp1YvHgxFi1aBJlMhjfeeKMkgREEAeeccw4eeughfPGLX0Qmk0GhUEA4HOYOcjabRVtbG3dbqHtaVwysY7IxXnJS79AcXajJnxEEoUEQhP9fEITfC4JwWdl79x+pjRJFMQTgIQD/BWAFgDMAfF4URc+R+s0PE2jAnIa7K0knNzQ0oLm5GbNmzWLHZuJ4q1QqWK1WNvkLBAJMSYhGo/j973/PNB4puru78c9//hPf/va3cf75578v+/r888+jpaWlYgU8n8/DarXC4XBwd4loJlarledJ8vk8fD4f3G43PB4PMpnMIYsmTDYqiTDk83mmAFJCCoAdxLVaLRQKBRoaGphGEo1GodVq0dnZCUEQxggppFIpDAwM4Mwzz3xf90+KxYsXQy6X4/XXX6/5ObreDhw4AJ/PV9JpJJ+ISCTCdDCHw8F0MelgfygU4ko8DXiXCzhIzUOlUuN1HB2gzqrP52P5c5obI5jNZkyZMgWtra3IZDJMC6WiRjKZ5MH/PXv24JOf/GRVyhcwOu+iUCgOSWb8cGA0GnneRQqn04lwOMwywk1NTWzmaLPZOFGXdpSla8h7kX4n0YBkMolQKMRGtQTqakg7R4VCoUR2nkAdHJVKhRdeeIH3ee7cuXjzzTfH/Paxxx6LXC6HSCTCnZeGhgY4nU6ehZHOLEnnpuqCG3XU8fHFeBHcowAEAE8B+JwgCE8JgkBPgLFC+pMIURSzoihuArAGwFWiKP77SP7ehwk0AyGXy0sCXYJWq4XZbMbUqVPZ4Exq+kfdCnJSt9lscDgcMJlM+MUvfoFkMolf/vKXY3533bp1kMvl+MxnPvO+7OfOnTuxY8cOXHfddRWTjUKhgEKhAJ1Oh7a2NsyYMQM2mw1arRbBYBBDQ0Po6+tjk0Kj0QiXy/WBV+7IODEcDpcEzYFAAIODgzh48GDJg5kq0LQflMj4fD4MDw9DJpPh9ddfx0knnTSGd080s2ozK+8H9Ho9Fi5ciNdee63m52bOnIkZM2bgnXfeQUNDA1KpVInhaiQSQTab5WCqWCxCq9XyEDNJ79psNlako9dq+SNRR47ujXpQdGRASftERhep80J0SVLqo3PrcDjQ3NyM9vZ2yGQyiKLIHTdgdBYrGo0iFAohFArB4/HgxBNPrPmb77zzDmbMmFEzyZkMmEwmiKI4RtVrxYoVePXVV6FQKNDa2sreKD6fj5UUA4EAX7dSTyPpmnI4fmL094VCASqVimfHKEGhYyL10XI4HJyE0XOG/lsQBLS2tmLnzp1siLlkyRIMDg6OMdKlNapQKPA8JjCaNM2ZMwcqlWpMV6xedKijjjrGS2Cmi6L4/4qiuFYUxdUAdgB4SRCE2hPXkwhRFAuiKH7sI4pK8pC1pJRJUYmoClSxp3/HYjF4vV7EYjGmKf3mN7/B2rVrcfPNN7MSlPT3N2zYgGXLlr1v8wAPP/wwGhoa8PnPf37Me0QNoiFfGl7v6enh6qZCoWDuNFU1KyV87zeqGSfabDZWUSp/MAcCAQwNDWFgYADAaPDQ3t6OKVOmIBQKobOzExdeeOGY36oUYHwQWLZsGTo7O8coyUlBdJJNmzZxENbR0YFZs2ahWCzCaDRi+vTp0Gg0OHjwIA4ePMgBndvtxsDAAA970xwRzURRd4buF6n8LNFvaBCa6DD1ZGZyQMedqJDSa7ua7G01aflMJsOGpkSlIu+qQCCA3t5e+Hw+GAwGtLa2oqWlhWmHE0lgxpOOnwyQyIWUjgUAZ555JnK5HHbt2gW5XM6USfI1AqqbgUrXlPdCjSWT40gkUvIb1OGkYwmMrkF0f0gLJLTWtLa2Qi6X87A/Sapv37695DelRRa5XA6lUsmdNVLRJJYAAC68ES201nOwjjrq+OhivKhGLQiCjBIIURR/IgjCIICXAdQn5d5HlA8iE72mXI4UGH2gRyIRxGIxfsjEYjEkk0mmRxA/nPT99+7di3vvvRdz587FFVdcwbMnhB07dmBwcBBXXnllRUlkt9tdVTaU3q8GURTH0DYOHjyIF198EZdddhlEURwT+FJgTlXAQCCAVCqFYDDITvFTp07l+YlAIIB8Pl8yNHykUKnCLOX0S2dcyuWR29raWF5ZqkZmMBiYPjIyMgKLxcJ0jscffxwAsGrVqpLgMBgM8jWTyWRKAiav11vzfFWTjgVGHcul7tvl+1lJ3eyYY45BoVDApk2bcMYZZ4x5n2SUV65ciXvvvRfr1q3DySefzCp5/f39EAQB7e3tPPxtsVh4BggYNTb1er1obGzkiq1arUahUEAymWR6jSiKrHYkPf7S8yIVeqgUEH7cudDjdVGk71eTSAZK1zUSEaHqv06n4wHuRCIBv98Pi8VSMvcGjF471I2Nx+MIBoN871ssFrz55pssx1ypYu/1epFMJjEyMoLW1lZ4PO8ylYeGhqom3dT9qIRMJsOqaOWge2dwcLBEEe3YY4+FVqvFhg0bcMYZZyCdTiOfz0OtVsNms/G1XigUWGKajg/J5tvt9pJreqKgewIYXVPpd1OpFPr7+yGKIpRKJbxeL4u8yOVylleWgqSfSe5948aNaGlpgUqlgsPhwMaNG3Hsscdi0aJFAN5daywWCxfHEokEQqEQ/0Y0GmVbAFIXNBqNEASBqcJkdFpLXfLjft/WUcdHCeMlMM9gdAblRXpBFMXfCoLgAXDfkdywOkpR7q4sHWKUKsAA78rckloTPfypA9PQ0IBEIsFVs2AwiPvvvx9erxePPPJIRdnQdevWQaVS4ZJLLqn4fjwer9mZkVIPyiGKIlpaWkpe++///m8olUp89atfrRgIkEIPAPZBaW1thV6vZ8WeUCgEp9PJcsRUnfwgHmLSgFiqhFUOEh+gZCedTnOXTK1WMz89nU7D6/VCJpNh06ZNWLx4MTo6Okq+y2q1ciBD1CpCa2trTRllUjWrhFwuV+L1IgV5OJTjtNNOg1KpxPbt27F69eqK36lQKHDaaaehoaEBXV1dnJB5vV4e+KZzS/QwQRB4eyg4LTf1o+/I5/NQqVQlqm7SQEc6VF6eZNZxaJAeM+naRcE1vV9+nOlcOZ1OGI1GPh9UZSdp3aGhIZZJT6fTcDqdbACZyWQQjUZhMpmQz+exd+9eLF26tKocssViYRGMRYsWlci122y2qsp5wWCwqlRyMBgcs6YRiDpGMzvS43TaaafhjTfewJtvvglBEGA2m9Hc3Ix8Pg+dTodAIMBGntJ1RNphPxz/EyqW0Pwdea6oVCrMnDmT106DwcDqlKlUCi+99BJaWlqg1+uxY8eOkjm8dDqNhQsXYt++feju7sb8+fPR0dGB1157DcFgkNcJeg6RCE04HEZnZyd2796NWbNmweVyQRAEhEIhxGIxno+R+uDQPsRisZriEHXU8V5Q95A5ulAzgRFF8SYAEAThhgpvP0Cvi6L4iyOwbXVIQAu19KEnVdiSdmCA0cozuRrH43GmI2QyGfj9fshkMigUCuRyOWzevBlPP/00brjhhopKVYVCAWvXrsXy5curBgGHglwuV3Mmw+/3489//jM+/elPs2RnpW0CRpXImpqaIJPJIAgCWlpaOKilQV6NRlNSnTySoAp/+e9Uk02uBEp2aPupa1MsFll8gSrVg4OD2LFjB3784x9X/K6jhUKm1WqxYMECbNmypebnlEolzj77bGzduhXt7e3YvXs3isUipk6dygPNgUAABw4cYMNJ6lyRAh8lONKBZrvdjng8jng8jv7+fk5mpk2bVmKySCgPgspVseqYOCoFlOUdSepkUBAdj8dLzF3pfqD5PSoGEHVMpVLBYDDAbrczFZCC/c7OTtxwQ6VH2LvYvXs3gMrKi5MNKhyQWaYUK1aswHPPPYd0Oo2ZM2fC5XIxZYyOg9FohFqtLknCq8ko03D+eLQykmsHRgtg5LMkBc3GEEhhjmia1FGRwuVywel0orOzE8cddxwnMHv37uXPUEfKZrPBaDRCqVSymW80GsW0adNYXbBYLCKXy5VcH0Q3pA6MtLBXv2frmEzUPWSOLkz0rl4C4DqMGko2A/gKgLkAjP/5p473AUS3qDSkSTSxRCJRkrwIggCDwQCz2Qyz2Yx4PI5YLIaBgQEEAgH09/fj3nvvxfTp03HbbbdV/N2tW7fC5/NNimzy7t27cemll+LVV1+t+pnHHnsM2WwW1157bdXPUGBONKhIJAK3243u7m6IogibzcbGiUTF8Pv9h0ytOFQQXakcFMTVepCSCpnU06Kvrw+pVAq5XA6FQgGRSASFQgH79+/H0NAQ/va3vwEALrjggqrfCXzwCQwAnHDCCXj77bfHDC+X48ILL4TH48Edd9wBm82GqVOncqJOx5E6ShaLhYNeADzYXCwWuXNHsrANDQ3IZDKIx+MYGRnByMhIzU6TFIlEAkNDQ6wSV0cpymdZqs22EKRD2KlUCh6PBx6Pp8Sskt7zer0IBAJIp9Ps+0IKVXSPkycMmeKq1WoYDAbs378fhUJh3PmX3bt3o7Gx8YgrkAHVZ2AAsFrg5s2bIYoi7HY7ZDIZcrkcz3jpdDr4fD4MDQ1x4ldNRrnWM6Mc6XQayWQSnZ2dfJylIOoWgYpLtbrrgiBg/vz5CIVCGBgYgM1mQ0NDA/bs2cOfoW56Q0MDz9h0dHRg6dKlmDdvHt+zkUgEOp2OZ97K70U6BrTG1gf966jjo42JJjB2AItEUfy2KIrfBrAYQIsoij8URfGHR27z6pCCBjjLq2k0F9HV1YWenh74fD7EYjFOVshA0Gg08kOfZir8fj/6+vpw2223Ve0OvPjii9BoNDj11FPf8z5QRX3btm1VP+P1FJWnYwAAIABJREFUeqFSqWp2K+hBl81m4fV64Xa7EY/HkUqlOImhB3q5tOqRhFwuP+wh2kAgALfbjeHhYeTzeU5CqUpNUqNDQ0NcXd65cydmzpw5hj5G2LVrF4Cjw0X+9NNPR7FYxEMPPVTzc5dccgkuuugiPPLIIwgEAkzhIdEDm82GtrY2tLa2slADSSITKJjR6XQwGo1s6Nre3o5p06aho6MDTqeTA9ZCoQCPxzNG2laKVCqFWCxWD4gqoDxQrhY4U0dAqVSWVNUdDgcHxFR8oOve6XSira0NdruduwBkVqtSqWCz2SCTyWC1WmG322G32zFr1iw0NDTgxRdfhFKpxAknnFB12xOJBDZt2lSxg3AkQFRI8j2Sgq7L7u5upNNpjIyMIBqN4p133imZuYnFYjVn2AjVnhnlkPpSRSIRZDKZMckQee0QlEolBEHge0YUxYoJ66xZs6BUKtHb2wtBENDR0YHe3l6eLaLzvnXrVl7nkskk9Ho9YrEYcrkcd9doLoeKEB6PB/l8vmS+rZJQRx111PHRw0QTmKkAspL/zwKYNulbU8dhQSolSxU6onq53W50dXXB7XYjEAjA7/dDoVDAYDCUBHC1HNJfeeUVLF26dFIM3s4++2z85Cc/wZVXXln1M9dffz1kMhm+//3vV/2M1PU5Go0il8vB6XSiUCggFAqVVNYFQYDT6eRq7ZEEUdkOBVJ+f1NTE1paWjgwb2pqgsFggCAImDJlCkwmE1wuF3cm3G53TYPKxx9/HM3NzTj55JPf6669Z8ybNw+rV6/Gvffei6GhoaqfEwQB1113HdLpNCe6BoOBxRiIehMOh1mMgswLKVkHwNRKUrMijr1SqWRBB0qE/X4/hoeHq3Zk9Ho9Ojo60NTUVA+IKqA8UK4WOFNiEwqF2LMnHo+zl49UOQ4Au8+rVCqo1WoUi0Xk83k+tzTcTqamVH0vFosIBAJ44YUXcM4555TMtZTjySefRCQSwTXXXHOEjk4pBEHAqaeeyl2WcjQ2NiKZTEKlUqGxsREKhQIWiwVarZYppE1NTWhvb2dqWbWuIHUsJ7Im6XQ6WK1WNDU1wWazjREoKE9gotEoRFFk6llPTw/27ds3Zp/I0HRkZATAaJJWKBTw0ksvAQA+85nPYN68ebjzzjsxODjI92UgEEA4HEYul+NnTyaTYWl0QRBYWloqN01dl/KOTB111PHRwkTv7N8DeF0QhB8IgnA7gNcA/PbIbVYdUlBVKR6PV6xqEt3CZrOx+Zler4fBYOCgYN++fUin01AoFFAqlVCpVEin00xjqDQHAAChUAhdXV1YtmzZpOwLGZrVCihaWlrwzW9+E88++yw/5MpBCczs2bMxf/58tLe3Y2RkBIIgsCqR9EFa6UH+XozfJhOJRAIjIyPIZDJwuVys1kMmneRzEQgEuCJps9kgl8vR39/PQ7Xl6OvrwyuvvILLLrus6vl9v/GDH/wAhUKh6swOYdmyZXC5XNi4cSOCwSAymQx27tyJoaEhDppyuRxCoRAb/CWTSXg8Hg6Kq3VKdDodnE4nnE4nJyNWqxUmk6kqhYiSH6PRWA+IKqD8/qoWOFNiY7FYWEmOquTlFfNyrx4yOKSAOR6Pc0AdDofh8XiwZ88eDA4OYsuWLXj44Yfh8XiwZs2aqtudSqXw2GOPYfny5TULAZON008/HQMDAxU59SRIkM/nkclkYLPZoNfr0dbWBq1WC71ez2s8BfmT1RVMp9NQqVQwmUxj1NfKExgqJKhUKhaSicViFVXbHA4HAoEARFFEU1MTdDod1q9fz39///33IxQK4b777sPw8DDkcjkKhQJfK0NDQ3C73Ugmk2hpacGcOXPgcDig0+lKlOkA1D2d6qjjY4IJEeP/I5+8AQBxiL5YN5Z8/0BVS5Ih1el0JcG5z+eD1+uFy+WC3W5HKpWCWq2GTCZDS0sLV6M0Gg1XqjOZDERRZHnjYrGIbDaLUChUwn3euHEjRFHE/Pnz0d/fX7ULMzAwUHO2ody8TApRFNmckLB8+XK0tbXh9ttvx+mnnz6mkkvbTRV1aVXdbreXOHNXQ7k0tRSTPZBXbRagWCyWcLnpc1J1nVwux8lmJBJh9SHyU2hvb68YNDz88MOQy+U488wzS6RhgdFhxFrHphI/n0Bc9Eqgynq1fZ05cyauvPJKPPjgg/jsZz+LBQsW8D5SYEo499xz8eSTT2JoaAihUIilsEmQIp1Os8Gh3W7nqrzZbOaqbaFQGJO80VxYsVhEoVDAgQMHYLFYoFarEQwGJyT2UB/YrI1K1ztJvxMNKBKJoFgs8pql0WjYPFEURV5r6DWLxcISy8lkkj+n0+lgs9mQzWYRiUQ40X/ttddgtVqxYsUKRCKRitv56KOPIhAIYPXq1RUpXQcPHqwqKT48PFw1cYjH4zWvkeOPPx4AsH79elx22WUl75nNZnR1dTFVShAEng9Rq9UlNKlsNstS8ZXEQyYKURSRzWYRj8fh8/kgCAJ3NwcGBiCKIj87SEb5nXfeATCaPAaDQT7nBw4cgNVqxdSpU3lYnyieXV1dUCqVaG1txbPPPou3336bPWauuuoqPPjgg3A4HFi5ciXsdjtsNhvi8TiUSiVyuRwymQx0Oh1yuRxL5isUClitVqbcymSyMfLcE0H9nq6jjg8XJjzZK4riDowaWdbxPoEWVCktg6q/JHtJD36dTscVsmg0WsJpJjnR5uZmdmvW6XTweDz8MCLJTJPJVBJI7ty5ExqNBsuXL8fevXvHJBoEjUZTU0a5FkWtv7+/4sDot7/9bVx//fX49a//L3vvHd5WebeP30d7S5YsyUsecRzbZJAQILyElRB2CKWQMsoo8AIFCrQQ4FtGKVAI4yUh5WUUSBnlB5QVoCQQCLxAIGSSRZYT7yFry5ZkS7Kk8/vD/TwcyZIsJw44VPd1cQGyxtFzjs7zGfd9f57Bvffem/R3En46nU40NzfDZrNhwoQJjFJGFd1sm1KqNfXBBMdxaY+F9DvFxcVJFWuhg45EIoFarYbNZmN6Ho7jsG/fPgDAlClThqxfJBLBxx9/jDlz5qCmpmbI51LlMhOy0aQ0Gg3Gjx+f9m8NDQ0ZrxGiBt1yyy1YtmwZFi5ciA8++AAcxyEajQ5JYH75y1/i73//O7799lucc845KCkpQWlpKdRqNTo7O5mWgNZNIpHAYrGA53kMDAywNU/tugmdiVpbW9HY2Iiqqipotdok7VE+oNl/pFs7CirJXIGCfxoyCoAlJ0qlEmKxmJk39PX1MWE+MHgN0rDHvr4+1rkkhz673Y7t27fjyiuvzGipG41G8eyzz2LixIk49thj0x6zTqdDSUlJ2tf39PRk/Ftra2tWQ4CJEyeitLQU69atG0JdKykpgdPpRFlZGXOepPs5DaykezwF/0La3f6AClxUJCPXPplMhvHjx0MikWDDhg3YuXMnc2qj+0+qm9rAwAAcDgdMJhMmTZoEYPC3v2fPHmYmo1QqsWfPHmzdupXpky655BJ88803+Oc//4lJkyaB53mEw2E2Q8ZisbDZPolEAgqFAiKRiHWqhA6ZqdbdeeRxsJG3WP7xkedCHALINJWaKBYSiYTNI6CqnN/vR3NzM5shQoGZVquFTqeDVCpNosNkohitWbMGRx555JAA+cfAlClTcMYZZ+Dpp59Ocq0BkGSj2tXVBZFIhPLyckYJo409HUhzAiBnfvhIMZwLE4EoNUQVS51aHgqFGGVQp9OhoqICMpmM0QKVSiUqKiqGvO+HH34In8+Hiy66aNS/24FCo9FgwYIF+O677zJSBIHBLpzJZMI333wDn8/H6EbRaBSJRAIymQwcx6Gnpwetra1MTNzX18cGtwqr1cBQZyKbzYaqqio274OCqzxGH0QRUygUSZoicqaSy+Vwu91DKFF0zvr6+ti5pJkfnZ2daGxsRF9fH6vEU2IaiUSy0sfeeustdHZ24uKLL/7Rg1zSwXzzzTdDjCNIyydcB6F4PZFIIBKJIBaLMYfJTNdsrvchotySVowSAKEOhgpk9FsazsFP+JlCWiAwGNDJ5XJ89dVX7DkSiQT33HMPotEoPv74Y2aTHo1G4Xa70dnZCYVCgf7+flaEs9ls0Ov1Q4pQI9H+5DH64DjuGo7jNnIct/GnPpYfCy0tLczIIvWf1tbWn/rwfpbIJzCHMIgmplQqYTabodPp2EZOvGThJkNzA6hSJRaLWZUwXQIz2vqX/cG1114LnU6HW2+9NYmaRJQQm83GJtS73W4myiatiDB4TU0OhFqiXDf6XJGrfalWq8X48ePZORHOuCA72e7ubrhcLmbRTN+nsbEREyZMSHvuXnrpJZSVlWHmzJkH9D3i8Ti+//77UXfemj9/Pmw2GxYvXpxxzSUSCc4++2ysXr0ajY2N6OjowJ49e5hhAzkWkTlFa2srAoEAC5DpfAsTllSdhVQqRXFxMcLhMKti5zUuBwdCUbVQU0QdRgrKyW2OoFQqodFoEAgEYLfbmQ18c3MzGhsb0d7ejqamJrS2tiIYDMJgMGDVqlWor6/P6CwWj8exZMkSTJkyBUcdddSPtQRJOOGEE+Dz+ZhTIMFisQAYpHEGAgF0dHQw5zZKIORyOWQyGaOTZrpmc70PUWeSXkNaF+GAZDon9LfhEhhh8pOawEilUsyYMQOrV69O+v2Xl5fjhhtuYPrHqqoqFBQUwOv1wu/3o6+vDx0dHVi/fj26u7uZriYTRvu+nkdu4Hn+OZ7nj+R5/sif+ljy+Pkiv1MfwohEIqwaB4BNnJfJZCgvL0dRURHjkatUKni9XuzevRtarRYmkwlms5lNQ05H+3n99dfB8zxOOOGEH+9LpUCv1+OGG27A2rVr0dHRwR4nXrrNZkNlZSWr1JGQs7u7G7t372ZVzEQiwehzAIY4JI1kXkIuGKl9KQUgFGALAxOaLN7R0QGHw8Fcm/bs2YMJEyYMeU+fz4dvvvkG8+bNO6BgfNu2bbjxxhtx22234eqrr8ZXX301aoGATCbDVVddhc2bN6O9vT3j884//3wEg0Fs3LiR8eGJ9ggMBqImkwlKpRKxWAwulwvhcBgikYgFUMKEJZ0zUd5udWxAqVTCYDCwbiSBEh4KrPv7+yGRSGC1WjF58mSYzWYkEgkW5La3t2Pt2rW48MILM1bgv/rqKzQ1NeGmm24alSr9119/jZdeeolRW3PBkUcOxnZbt25NepzmxIjFYkilUkSjUXR0dDBtTzgcTrtO6TCS+5BcLmf3PyqKCLV1tEfQvTeTNoggTGCIyiWkm5144olwOp3YvDlZTnveeefhhBNOwJNPPolYLMYKbTqdjmmoNBoNotEoent74XQ6WWEnGAwm3aNG+76eRx55jB3kE5gxilwcsoSBF3GjyX63v78fBQUFzM1GJBLB5XKhpaUFDoeDJT+rVq1CUVER6urqkt7b4/Fg8eLFmDNnDttofyo4HA6o1eokvjkFCnq9HhqNhgWwVM01GAzQ6XSsmitcH0oOhIEL8alHwyoayJ3CQF0COs/CAJseKysrY9+FOOocxzHtTCoaGxsBYMg5zRUOhwMLFy7EHXfcgVAohOuuuw4GgwELFy7EnXfemdUCeSSg5DkbTjzxRMydOxcvvPACvF4vTCYT08rodDqUlZWhoKAAdXV1KC4uZs5EwvkvqRhuzUOhEOLx+BAXo9TX5TGIbFXubGuW7jyQe1QgEEh6jVKphNVqRUVFBcxmMwoKClBZWQmlUomysjLYbDYUFxeD53l88803AJC1c0yzrU499dQD+u59fX34n//5H/zlL3/BG2+8gXvvvTfnYFkqlQIYqheiglQ4HIbNZoPBYGCmJGazGRaLJSkJz7bGud6HxGIxIpEI+vv7oVKpUFVVBQBJ5gdFRUUAfjBksdlsWd+TtE7AYMHCZrOxwaIAMHv2bGi1Wrz99ttJrxOJRHjkkUfg8/mwaNEiBINBWK1WBAIBdHd3Q6VSYcKECSgpKYFGo4FKpYJMJoPL5UJPT0/S+qcmcPmOTB55/HxwSCUwHMfN4TjuJI7jxoYn7EFEtsqRcMOi/5bL5WxApdvthsvlgt1uZ10JpVKJyZMnY9y4cfB4PMxy9v/+7/9w5plnDqnk/fWvf0UoFMI999zzY33ljNi4cSOmTp2aNE1+YGCAcd6dTifcbjdkMhlkMhm0Wi3Ky8tRWFjIhqTRZPZMVUuiZuQyHG40karJEJ5b4ryLxWKYzWYYDAY2zG3v3r2MSpUK6lCk08ZkQyQSwcsvv4zLL78c69atw6WXXornnnsO8+bNw5IlS3DDDTdg3759uP3227F48eIDrmpSIJPN4pnjOCxZsgRqtRr33HMPpFIprFYrMyAgCmU4HIZGo4FGo2GdyEAgAIfDkaQlEHbi0p1rOh8ej4edFxpyGQgE8pO90yDdvUpI1/T7/XC5XEMC7FAolDScERj8HTocDtjtdvYa+i3QMFJynxOJRJDJZIjFYigqKoJOpwPP86yin80W+dNPP8Vxxx13QAYejY2NuOGGG/D555/j4osvxu9//3ts2bIFd9xxRxL1KhMyXf+0HkVFRYhEIqiurobBYGCOa6nPH62J83K5nO0jtbW1AJDkLFlaWgrghwSmuro66/uldjRra2sRDoeZHkChUGDevHn46quvhrgkTp06FWeffTb+8Y9/oKGhAU6nE36/H93d3eB5HjabDSaTCRqNBsFgEO3t7YhGo5BIJEnnNDWBy3dk8sjj54NDJoHhOE4KYCGABwEczXFczg5qhyKytf7pJuzxeOB0OuF0Ohl/X61Ww2KxwGw2o7i4GAaDAQUFBejv74dUKkUwGERrayu8Xi+WLl2KcDiMm266Ken929ra8OKLL+LCCy9kG9lIEI/H0drayvQoB4JoNIrvv/8e06dPT3o8FotBKpWio6MjycKZzAZo4yIqEW2QmSgXuVItRhup9KVQKITOzk44HA42sE0YCPT396Ozs5MFEZkSGI7jWMAxHHiex5dffonLL78cL730Eo499lg899xzuPjii9l6isVizJ07F88//zyOP/54vPjii5g3bx5Wrly539VMovsJE9N0sFqteOKJJ7Bu3To8++yz4Hmezf0IBAJwOp1obGxkw+x6enrQ2dmJlpYWNrhVyMEXdipTQeeDhOVKpZINuezr68tTzdIg3W9HqOWiGR25BNgKhQJWq5U5wvX397P3IvpYIBBgXZrW1lY2pNfj8bAEiLqW6dDU1ISmpibMmTNnv75vPB7HSy+9hIULFyIej+PRRx/FZZddhtNPPx333nsv2tra8Nhjj2W1jqf3AYZe/xRcO51O+Hw+2O126PV6RKPRtJ3B0aJA0tp1dnYy6pgwgdFqtdBoNIzKO1wCk4rS0lJoNBpmrQwM0sV4nse777475Pl33303enp6sGzZMqjVajawOZ3JA1GnzWbzsM6TP8V9Po888hh9HEpJQAzAWgBTANwF4H8AfMFxHMcPE0FxHHcNgGuAQZHgWEKmQ6c5IDTrQAiaA6NQKJg7Dc0BoNfK5XI2+JI8/CORCEQiEfR6PRwOB1588UVceeWVqK6uZsGk2+3GAw88AI7j8N///d9JnOVsok3a1Px+P55++mns2rULMpkMNTU1qK+vx7Rp01BdXc1oE0LI5fKMdqTr1q1DNBodksBQByYejyMSiTBxLyVrNMgTQFoqXuomR7NB9gep19dIOPVCu2uiDQpdx0jc3NnZCalUCo1Gw+ZhAGC2wUI0NTWhrKwMPM+z56XC7/ezSu7XX3+Nxx57DFVVVXjooYcwceJESCSStJQUnU6HOXPm4Pjjj8crr7yC2267DS+//DKuuOIKmM1m9PT0wGq1ZlqnpLWhAI6uiWzUrPPPPx9vvfUWli5diuOOOw4nnngiWy+aEaNSqZgDXWlpKRQKBQvuACR1KsliO9WRjs4Hz/PsvJA9eGFhIVuz4YTD2a6BkVwfP+W9K9fvSMUCIYQ2ttQVo/sW/Tc5Kwofl8vl4DgOZrMZ4XCYJZnxeBzxeJx1XmKxGNrb2xEIBCCRSNDf3w+73Q6ZTAa/34/6+vqk60nYbfv4448BAMcff3ySpiYd6LoiuFwuPP7449i5cycmT56M6667Dmq1mhVIKisrcfvtt+Pxxx/HzTffjPvvvz9toC+kiEql0qTCCv3+jUYj/H4/PB4PSktLIZPJWDJjNBrZmgvvIft7bdlsNiQSCUilUqjVavade3t7UVNTw677yspKOBwO5gjIcRxL9oWW/LW1tXA4HFi3bl3SZ6pUKnR3d2PTpk1sBtS0adPw7rvv4oQTTmD0UJvNhtLSUpx11llYtmwZLr74YshkMtbVi0QiCIVCiEajKCkpYZbagUAg67DZdNcqIdv1nnczy+NAkLdYPjg4ZDow/05SVgC4D8A7AP7AcdxNAH4/HKVM6IhBlKJDGZTciMViJm6lSnRPTw8cDgf6+vrQ398Pr9eLlpYWNDY2orGxEZFIBHq9Hn/729+gUqnwxz/+Mem99+zZgw8//BCXXnppxkA0E3bs2IG7774bjY2NmD9/PmbNmoXe3l68/fbbuOuuu3D55Zfj/vvvx3vvvZez2HX79u0AkDaBkUqlsFgsmDRpEhtEKJFI2DA2qt4mEgk2LyQX5KI/EmIk11c2DjYdq9lshlarhVwuRyKRQHt7O+x2Owu2hEjXgWlubmYc9lzwySefwGq14vHHH8fEiRNzek1NTQ3uu+8+XHLJJdi7dy/uvPNOfPrppyPSh+TagQEGr/m//vWvUKvVWLJkCbq6umA0GqFUKlFUVITa2lo2EyQYDCIajcJisbAOHLmRpTqN9ff3w+FwwOFwZOwQUHL7UwQxh9q9K51FuZDGI6TwpHtcKFRXKpXs3AGDhYjOzk42cDeRSLAJ9QaDgXWYGxoasuq/Pv/8c4wbN25EFEvqUt50001obm7GH/7wB8yfPz/tPWX8+PG47rrrIJFIcPvttw8R6RMyXf/0ffV6PaOOkT1+JBLBwMAAlEolEokEAoHAEL3QCL5T0rVFznA1NTVs0GbqcOKKigq0traC5/mkOTzCdbBYLBl/K2RQILSVPfXUUxEMBpMslQm33HIL+vv78fDDD2Pfvn3o7u6G3W5He3s7Mzehwbok6qfObF6rlsdYQd5i+eDgkElg/g0ewO94nn8RQCeAxQBUPM/Hs7/s0EEuIkOqVgqf4/V60d3dDbfbzRxZTCYTJkyYgMrKSma53Nvbi/Xr1+Ojjz7CrbfeitSg6Mknn4RWq8VVV12V8zHH43GsWrUKjzzyCDQaDe677z7MmzcPl1xyCR566CE8/fTTuO2223DyySfD5/PhH//4B1asWJHTe2/btg2lpaVDxOpEA6IZORaLBRaLBWVlZbBarTCbzZDJZOjt7YVGo8nJsYdwMHnSqe8tnFNCLkzUMSBRbSwWY1qmnp4ehMNh+Hw+AEibZDY1NWHcuHE5HY/H48G2bdtw4oknZtWipINIJMKpp56KhQsXYsKECfjHP/6BJUuWoK2tLafXjySBAQY1AY8//jjWrVuHV155BV6vF8FgkHUWgWR3uf7+fqYFCwaDzOxBCBKHW63WpL+lapFIY0CP/6eLgDMJx0nXksmhKhOFhx43mUxJFtgul4tpYWg4qd/vZwlqdXU1LBYL68bu2rUL4XCYDVtMRX9/P7799lvMnj075+/a1dWFe++9F48//jhsNhuWLFmCWbNmZX0NFQQsFgvuuecerF69eshz6PpP/d2RFX4wGGS296FQiJkclJWVscS8ubkZ3d3dB6x/oeu5oKAAYrEYpaWlkMvlQxKY8vJyBAIBeL1eAGAGKeQUR++RCRKJBDqdDh0dHYxiXFdXh5qaGixfvpytCaG2thYPP/wwvvzyS7zwwguMDtzQ0ACZTAaDwQCJRMK6dWKxGMFgkFnP55OYPPL4+eKQSGC4H8o5qwBs5TjuvwCcDGApgNkcx/10g0pGGbkEz8JBfeS4pNPp2FAzAlmNGo1GlJWVwWAwYGBgAH//+99RVlaG66+/Pul9V65ciTVr1uCaa67JyB9PBc/zeOKJJ/DZZ59h5syZ+POf/4yysrKk52i1WhxzzDG46qqrsHjxYlRXV2Pt2rU5vf+uXbvSznLo6+uDQqGASqWC2+2G2+2G1+tNqrC73W44HA5mq5srDiZPOvW96XxTEEA6JuK00wwMChR6enoQCoXQ1dWVNJmc4Pf74fP5cu7ArF27FjzP46STTtrv71RYWIgFCxbg6quvRnd3N2688cacAgc6J93d3Tl/1gUXXICzzjoLL7zwAsLhMKLRKDweDzo6OuD3+1FaWsqSOplMxoTfiUQiKcgSHkO6ORrhcJidl1S3v5Emtz8H56PUhEW4PrlCSB9LR+EUzoihz1IoFIxGJpVKwfM8JBIJenp6huhA6uvrWVB82GGHpT2GL7/8EpFIJGf9SyAQwIIFC9DQ0IBrr70WCxcuZG5cw6GwsBCPPvooqqur8cgjjyQ5egmRqhWka04ikaCpqQnRaJQNb9VoNKz7RN87XWI+UpC5hc/nY7RMg8HACiUEojESZVihUIDnefT392PKlCmYOnXqsJ3KgoICDAwMYMOGDQAGz/28efPg8XjSdmEuuugi3Hzzzdi4cSMbZknHRVonWg+j0YiioiKoVCr09vYyvVQ+kckjj58fxmQCw3FcLcdx/8VxnJTjODHP8/y/tS4xADMAfANgAc/z1wB4F0BH1jc8hJBL8Cy0/O3r62MiY2CwqqdSqVhANjAwAKfTCalUCoVCgVWrVmH79u1YuHBh0qYXDAbxhz/8AVVVVVmnV6fijTfewMqVKzF79mxce+21OdkQT548mdHZhoPT6Uxr17l582aMGzcO0WiUJTJCx6JAIACVSsWMDBwOx5DqXiZQV+dgDDRMdcWh8y08F+kG/hUUFECr1aK0tBQqlQrhcBhSqXRIsEBc2lwTmNYG3wo1AAAgAElEQVTWVmi12owapJF8r+OPPx5z586F1+tN0k5lwrx586BWq/HnP/855+Ce4ziceOKJ6O/vRyQSgVarRSQSQU9PDwKBAHp6eiASidiU9mg0iv7+/qxBXjoXJ4VCwc6L8HxQMpP6+8yWpASDwaxdibGKTF0oYHB9NBoN+80R1Go1iouL0+rJcu1sUteB6LFOpxMulwsqlYoVYuRyOdrb29HY2Ain04lEIgGO47B+/XoYDAZMnTo17XtTspCOepkOy5cvR19fHx599FGcddZZI+5SarVa2Gy2JE0eYcKECdDpdEOCdpVKxSiP0WiUWRDrdDpGjySdX0lJCaxW66jcqyKRCOLxOCQSCQoKCqDX64ckXXTd072bqGPCeTHDgYpuwq7UlClTUFNTg2XLlqV1B1ywYAGmT5+Of/7zn4hEIkwrI5wR1NfXxwpYpM+ha46oiIdyESGPPPJIxphLYDiO+yWA9wH8BYMdlhs4jtMJhPq/AnAUz/P/AgCe55/ieT43zsoYRGrgk8m3X/i8VMtfhUIBo9EIlUoFvV4PkUgEqVSK3t5ebN++HQ0NDdizZw+2bduGV155BXPmzME555yT9P4PPPAAOjo68Kc//YltDsPhiy++wIsvvojZs2ePyNGnrq4O8Xg8aSBhOpCOh0TUBHKdqqurY5U42hRpIBsFnVarFX6/n9myjrVqnLDyDIDx2ikgp6SLAgWiy2UC8WkrKytz+vz29nbYbLZR03fQucplVkxxcTEWLFiAzz77DJ9++mnOn0GJSEtLC7xeL+RyOYqLi2EymSCVSpkWSiKRsEAwXReOAnRhskJI15mhQJ4MAIT4OdqzCpOWVKcrChyDwWCSRXWm9QFyK85QNV+hULDkyOv1wul0IhqNsvNSWFiIRCLB7K57e3vR3t6Or7/+GqecckpasxDgB5fCXBwSm5ub8fXXX+OMM87YbwMFsnU+/PDDhyQ/UqkUJ598Mj755BNmaAEM6kQSiQS0Wi30ej2sVit0Oh2kUimkUikSiQTsdjtisVja7uH+QCQSwWq1sntuKBRCQUHBEAoZfQehg5pSqczJNprAcRxsNht27drFjGE4jsOFF16Inp4eZrKQ+pp7770XTqcT7733Hhtg2d3dDalUyjouzc3NsNvtUCqVbC4UsQnSUXeFCc3PoVOax6EHEvin+yfXffw/FWMqgfm3VfIFAK7ief5kDCYyNgC3cxynBwCe54M8z2/69/PH1PHvD3INfITPEw7po6BAq9UCGAwc9+3bh61bt2L37t1MYFlSUoJly5YhGo3i0UcfTQowNmzYgGeeeQZXX301c4YZDrt27cJjjz2GSZMm4ZZbbhlRAEzT44V2mulAVfxUnQ4524wbNw4NDQ1wOBzwer3QaDRQq9VsfgoFViaTCcXFxWyTG8tzPEhU3traCofDAY/Hw/jvHMexYCVTN4k6MLkEXDzPswRmtDCSBAYArrzyStTV1eG+++5LmgeSDRREkxYoHA4zbZDH44HX64XRaERBQQHGjx+P0tJSmEwm9npKEmm2hFAwTuLfdBqPbPM2sgXnGo0mY1diLEOYtKRL6FKTmmzrQ/Qx6hpTkMjzPBOix+NxuN1uZofd3t6Ovr4+5nhlMBiYLoaOh9zMVCoVvv/+e7jdbpx55pkZvxMVZ3Lp/j777LNQKBS46KKLRrRuQrS3t8Pj8aSlwQLA6aefDrfbjY0bN7LHaMBrR0cHZDIZ5HI5o0KKRCL09PSgpaWF0bhGAxzHMYv9LVu2YPv27ZBIJMMmMMCg7iwUCuXc4QbAXBJp6CgwaAxy1FFHYfny5XC5XENec8QRR+Dcc8/F6tWrEQwGsX37dqxfvx7r1q1j18yePXuwb98+uFwuRsMT0nJTqbvCfffnWITIY+wjL/Dff4xFG2UdgBoM0sSWAXADOAvARQCe5TjuSAAxnue38Dw/dkrp+wna/DPRW+hCJv4z2SMLgyzig0skEshkMjZ8jyxJpVIpPvvsM7z55pu48847oVKp4HQ6AQxWIn/729/CarXi+uuvR2dnZ8YKaXt7O7MLXbp0KRQKBS644ALs3bt3WIpMKrXMaDRi48aNmDBhApRKZVoKU0NDA4DBDV1IK/j666+hUCgwdepU5qpGm5TQ2pXWTywWw2KxIB6PIxwOsyrsj4lcqnqxWAy9vb0wmUzMdIACPplMBrVazf6fvh9RpggNDQ0wGo2Ix+Po6urKeC47OjrQ0tKCQCAAuVw+JJnMVMEGBjUrmTZ50prs3LlziA6BbHBTcfPNN+O6667Dgw8+OMQVjyB0OSLRPwl2KZmnWRGxWIyJekOhEJRKJQYGBtDe3o6SkhJGq+R5HlqtFgqFAv39/YyKRIEOXc+0htl+q0J71tRznc269afGcNax2SxnyQ2R/l+4PsIEhcwPgsEgu3eRTXUoFGLrTtbCGo2GWWDL5XJEIhF2ryPra7q/+Xw+BAIB+P1+fPLJJxCLxTjuuOOGXJ9UDKHExel0ssc6OjqG3BMoOJ41axa7D6XC6XRm/B3E43G0t7fj888/BzAo6m9vb2d/pxlNhx12GMRiMd5//31WdKC18/l8kMlkTBSvUChgMplQUFAApVKJgoICxOPxpN///nZSeZ6H2WzGxIkTmf2+QqFAV1cX2tra2DHZ7XYAg8YGTU1NTLsHDN4XhEl6IpEYkgARysrKUFJSglWrViXNbhk/fjw2bdqEP/3pT7j55puHvG7+/PlYsWIFNm/ejPHjxyd1V9VqNbRaLQYGBuByuSCTyRCNRmEwGBg9rre3F2azechvmYaEAsjaIcwjjzzGDsZUAsPz/ADHcYsA3MhxXCPP86s5jvsaQCmAuRzHvQzgeACv/6QHOooQevgDyTakZJVM1rAajQYejwc9PT0Qi8UQi8XgOA4+nw9OpxNisRiTJ0/G9OnT4fF42LT2aDSKZ555BtXV1ViwYAG8Xi8LUJ955hk0NDRg6dKlMBqNiEQiMBqNaY91z5490Ol0CIfD2LNnD2bPns1mHLhcrqy6i1SaQ11dHb7//nuUlJSwzTMVVOWrqKhIMhX47rvvcOSRR7LKbEVFRVKQQ8EPJXlUYafnRCKRrAH6wUAugYXX64XD4UBxcTGsVmvSBHKxWAypVMooOnT8qTMPurq6UFVVBa1Wi8LCQtaZS0VhYSETz0+ePHmIpWy29fF4PBk7PIFAAFarFcFgcEhnx+PxpA2Ijz32WMydOxd/+9vfcMkll7AOnRDCAJO+U19fH7RaLdRqNbt+aD0UCgUcDgerYkskElbVLS8vZ88nrZNSqYTFYmEaAwqkhYLzXBOR1Hk3hyqyfY90tCVKaPr6+ljXhqraGo0GOp2OJYu0riqViq072VzTukejUUilUuZ4BfyQOPX396O7uxt79+6F2+3GuHHjsHXrVhx77LFpRfbUgaPzTskAMOhuJ/ydxONx3H///SgpKcERRxyR0dDE5/NltGIOhUKora3Fiy++iLKyMsycOTPp7xToazQaTJs2Dd9++y1L3okiqtfrYTKZmF0+x3EsEKf7MBU2DhQcxzFLcplMhvb2dqjVavj9fthsNna+qQNjMplQWVmJ6dOnQ6vV4o033oBer8eJJ57I3nP9+vUZrfij0SgmTZqETz75BF6vlxWwrFYrJk+ejBUrVuCiiy4acp8pLy/HhRdeiJdffhn19fU46qijIBKJoNPpEIvF2LUXj8fh8XiSrPR9Ph8GBgYYXS513cZyoSGPPPIYirFIwVoN4BMAl3IcdwLP83Ge518DUAKghOf5xTzP525bdIiBKER2ux1ut5vZ69ImGovFoNVqYTKZkEgkIJfLUVZWhvHjx6OoqAgikYhtQmQvu2rVKuzbtw+LFy9O6oSsW7cOS5Yswdy5c3HKKafkfIxbtmzBwMAAjj766P3+ntXV1ejt7U1LFSBQ4CLUfASDQWzduhU1NTVsPodEIgHHcXC73Wx6dTAYREtLC5xOZ0Ye/1gDUd0osBI6XhG9iSrHmebotLS05DzfgigoVA0eLRQXF7NKba646aaboFKpcPvttw/brRJSyAoLC6HX66HVaqHValnSSuYWLpcLzc3NKCwsRFVVFQuUaIAiBWZklmC1WiGTyVhH4OeQiPyYELrqAT/QzKhDKhaLWZBIHS5a95KSEpjNZla5j8Vi8Hg8SCQSMBqNCAQC2Lp1K8LhMMRiMaqqqphd+Pbt27Fz506cccYZWY+PEuFsFLIVK1agtbUVV1999YhF+0IMDAxgy5YtOPLII7M+78QTT8SOHTuYHoTu9f39/Whvb08SoZPInoZHjua9jKi3kUgESqUShYWFQ9zeqPsppJCJRCKUlpais7NzRPrC8ePHQyqVYufOnUmPz5gxA3K5HM8880za11188cUoKirCypUrkUgkUFhYCLvdDrvdzn73PM+zIoxarYbRaERlZSUsFgujIo4lLWQeeeQxcoy5BIbn+TCA/w/AVgB/5DjuGo7jLgdgBnBo2fjsB+RyOaPCkGWu0F7XYDDAarUygbLf74dIJEJxcTEKCgqQSCTQ09ODvr4+lJWVQa/X4+2338Z5552XJLSPRqO4/vrrYbPZsHDhwhEd43fffQetVova2tr9/p4UeGQT8hNdTSjiX79+PeLxOA4//HAolUoEg0GEQiFWybVYLDCZTMx1Sujylcky96eEcA4M2V5TkEBmBPF4PImuQjMxUgP9eDyOzs7OITbWmeBwOCAWi3O2zM4VJSUl6OzsHJEY1mg04u6778ZXX32FVatWZX0uBW00uV0ikUClUrG5L5QUV1RUsBkhfX19qKysZBRLGpaYOgxQJBIx4S9RnfLIHamueqm/OeqSUkJOM6tIq2cymZgJCVHKyJDB6XTC6/UyLU1BQQHq6+sZHRXAsAkMHUcmEX84HMYrr7yCKVOmDOmajBQ0kyZ1CG8qjjvuOADAmjVrACRrYJxOJ0tiALBZOZRkjOa9TKlUQq1WIxAIwOVyMftxIU2OErrUAkpZWRnC4XBSt2w4yGQy1NTUoKGhIekzVCoVfv3rX2P16tXYu3fvkNepVCrcc8892LRpEzZv3gyJRAKj0QidTgeLxQKdTodoNAq73Q6PxwOHwwGRSIRYLAalUgmv1wu73c6YDkRvDAQC+d97HmMK2QT+eZH/GExgAIDneR+A5wE8CmA2gFkALuF53vGTHthBglAwTCJVAEM2fQAsGFAoFNBqtTAajYw2I5FIEI1G0d7eDq/Xi4KCAjQ1NSEcDg/hE3u9XrhcLlx11VVsw8wVLpcriVawPxBWXzPh888/x8SJE5O6RsuXL4dSqcSxxx7LaGLk9y+0UTabzSgtLWUUo9S1HCvVt9SKtRA094VsZOVyOSwWC9RqNfR6fdKUcmDwejEYDKySOxymTJmCeDyOt99+e9S+DwDU19ejt7d3WJe5VFxwwQUABgO/bDjssMMgk8mYNoEE4uRSRcMQtVotxo8fj/r6epbcAz/Y9MpkMrhcLnR3d8PpdLJzIHTY+k+Z9zJax57qqpcKSh4BMO1SIBBAU1MTenp6kuaQkCVzRUUFjEYjoxdNnDiRdXWoSNHb2wulUskorZlAbndTpkxJ+/cvvvgCfr8fl1122QF336gLOZylOSUnNMOLxPCU4BH1lRJ2mkA/2mYkdM7IFIWOm/SSdIwikWhI55zMEUZ6/UyfPp0NQha+lpLHTGYgF110EUpLS7FhwwZYrVbI5XIoFAqUl5ejqqqKuRGWlZWhtLSUrSMNBk415yDWA2nj8shjLCCbwF/oXPufmtyMyQQGAHiej/I8/38Afg3gSp7nN//Ux3SwIHTvIb0LdVXIVUtIIyCRstBlhcTL0WgU8XicTShes2YNNBrNkLkIFPjujzNSKBQ6YK5wY2MjOI7LuLnv3bsXu3btwtlnn80eSyQS+OCDD3DMMccw2pNMJkMwGMTu3bvR3NyM1tbWpGA0FbSWQkHxT4l0c2CAwSDG4XCwYK6vrw89PT0sgKGulHDqPcdxOOyww4ZQMjJh6tSpmDVrFt5///1hHeFGAqIWkltcriDtQzZaITBYhT7llFOY/SwN9pNIJKyLwvM82traEAgEIJFIGBce+KErEI1G2dwklUqVpLPJNO8lGw5lF6Mf69gp4QgGg2yeFVEkvV7vkCSUkiGa+6NSqVhAT7oGYLAgYrFYsiYdiUQCr7/+Oo477riMm/vy5ctRUVGRMcEZCagbkUlTSNiwYQNEIhGmTZsG4IeZKl6vlxVmotEouru7maaL7OIPBmiuElF3acYYMHi/tVqtQxzQhJTBkcBkMuGYY45BU1NTUuFF6GyXDiKRCOeddx4+++wzdHd3QyaTwefzQaVSobCwEAqFAgMDA9BqtfB4PMzsIRaLob+/nxm/0GdZrVZotVqmo8kjj0MB/+kOZmM2gSH8WwMzNsrlBwk0TTmRSMBkMqG6uhpWq5Vx9IUamN7eXng8HgQCASZOJDoGWcIS17ylpQVbt27FMcccw2hJBOqA7E8iMloJTElJScYA8V//+hfEYjFOP/109tj69evR3d2NGTNmsO+r0Wig0WhgMBhgNpths9nYUMt0VcrUtfwpNithtTtTxdrj8cDv90MikaCmpgY2mw2xWAwulwvBYJDpXITORsBgd2L37t05W5pedtllKCwsxNNPPz2iYXTZUFhYiOrq6hEnMPTaXDpI5557Ljo6OrBt27akahTB5XIxZzyRSIRwOIz+/n7s27ePJTw0/4XoJaS3ADLPY8qGXOacjFX8WMdO58Jut6O9vR2JRAJmsxnjxo1DaWkpBgYGEA6H4XA40NXVhe7ubkalJavczs5OOJ1OdHZ2guM4yGQy+P3+tEYgQnz11Vfo6OjIOKi3o6MDu3fvxumnnz4q2iev18uG7GbDhg0bUF9fz7rRdG+ura1FXV0dJkyYgJKSEshkMojFYni9XmZGMtodZZVKhfLyclRWVjIBfmoXpKysbMh9RzjgdKQg0w6hbm64BAYAzj//fMRiMbz77ruscLVr1y7wPM/otFu2bEFbWxs6OjogkUig1+vZfBih/k2j0aCoqAgGg+GQ/P3mkcd/IsaUC9l/Iij46uvrQywWg8FgYJUvoZCY7HPJYpQ6MUQzCIfDTA9jsVggl8vR1dWF77//HvPmzUvaCNxuN9sseJ5Pmpre2tqasQLe3t7OdCcDAwNJFCGHw5E1ACYrUPrMvXv3or6+Hi0tLVCpVKySSt/7gw8+wIwZMyCRSBjf+t1334VMJsOcOXPQ1taGeDyOgYEB1NXVseCLEhJyphFaugI/OCXRc36KzYqq3cAPCWQ8HmdGA0IqmEajgVgshkqlgtvtTrIbBQY7VSeccAJ775qaGoTDYezcuZPZsKaD0+lk63rRRRfh6aefxl133YXrrrsOBQUFaadhE+x2e9L5EkKpVGLfvn2YMGECVq5ciW3btrE1puQ6HSh5LygoQFdX15AJ4KkJyqxZsyCVSrFy5UocfvjhaGxsZK5r5EKk0+lQVFTEfie7du2Cz+djtKSCggKWvPT09ECv1zOHrOFoJOkC3GxWymMd6RyYDuQ7ZHut0WhEX18f0yaR9mJgYCBpSKNYLEZRUREsFgtkMhkrPOh0OmafS4Ucp9MJm82WcZZQZ2cnli5dCoPBgEmTJiUF5c3NzZBKpfj444/BcRxKS0sZjbG7uzvjtR4Oh9Hc3Jz2bxzHoa2tDTqdLu1z6LuQ0P+Xv/wlu+aJsmU2m9m9nroL8XgcRqMR0WiUObrRvUTomLc/oCTIbDYzo4CioiI0NTUlJRdGoxFbt25FZ2cn05jY7XaIxeKkPYHsjNNBrVbj+++/BwAmuN+1axdLKqgDZrfbk7rMwKAOp7i4GMXFxaitrcW//vUvHHHEEZDJZFCpVAiFQpDL5SgtLYXVakUsFkM8HmcdPUqOhEkfz/NJ+8FIr/282Uceefz4yCcwPzE4jkM4HEYsFmNzXJxOJ7PPTJ2joNFoEI1GwXEc64SQFqanpwcdHR0IBoMwGAyshXjCCSck0Q2MRiPbKISuV8BgFTKTLsViscBsNmNgYAA2my1JxN/Z2Zl1Qnx9fX3Sc8PhMI455hhMmTIFPM8n2WWuWbMGTqcT9957L8rKylhA+dFHH2H27NkoLS1llfXCwkLI5XK2JlQ1FzpMZVr3H3OwoHCDE84boMdJ7xIKhdgaEw2QaDbE36brhOhWwuRwxowZAAYT0XHjxmWkmdTV1bE1P+qoo1BbW4vbb78dzzzzDBYvXpzVRrmpqSljtXtgYAClpaU46aST8NFHH8HhcDCRck9PT0bHM7LPtVqt6OrqGnJuUhMxi8WCWbNmYePGjYxCIpfLodfrmSC8oqKCzYIg0TdVxYluqVKpIJPJoNfrIZPJkqbIj0ZQQsWJAw0uf2wc6HFne41EIkFFRQVL2Onap25zaWkpCyZJw9bT04Pe3l4YjUY2F8vhcCAajcLn88Hj8eDoo4/OWJCIRqNYvXo1Lr300iRTEGCQulhQUIDt27ejrq4OdXV17G8GgyHjNevxeIZQcwlutxuRSAQWiyWtKyC54X399deIRCI45ZRT2GPULafBkqRRpJlF4XCY3aOF80wO5PriOC6pS282mxEKhVBTU4NAIJA002natGlYuXIlTCYT6zC1trZCoVAk7QFSqTTpvi/Exo0bk37jJpOJ7W/AD10ZpVI5hO7X39/POj1XXHEF/t//+3/YsGEDDj/8cEilUqYRkkgkKC4uhlgsZntoIBBg+2aqNlJo/50OpK8cbfOEnyM4jrsGwDU/9XHk8fNG/lc4BqBUKhkFyuv1orOzE21tbeyGKXSgAX4QfdLmrlarIZFIoNFowHEcXC4X+vv7sXXrVshksrQ2nrmI6NOBXncgwT+Jr9PN+wCAd955B1qtNsnaedeuXWhpaWFzB2gqfSKRQGdnJwv+0037HmsgyoJwE6SEy+/3w+FwQKFQQK/Xw2w2M143OTTRwMuqqqoh1cna2lpIJBJW3cwV06ZNw1NPPYWBgQFcd911ad1/RoL6+nqoVKqkCeO5wGw2D6uBIZxzzjloaWlBNBpFVVUV61pR8Eg6F7/fD6/XC61Wyyq3er2eBSJmszktdWQ06DnptCVjUeyfekyjoYnJtn7C+VekSyCLeJvNxhzjSANINsN9fX0oKCiAVqtl54zOezYK2bJlyxCLxXD++een/XtbWxva29vxX//1X/v9fVPh8/mG1b+sXLkSCoUiaX4K3WNNJhO0Wi1KS0tRWVnJEhyhacloOiumni8qpqTSxSihEHLsI5HIAWlyCgoKEAgEmDscJbPDXX+//OUvodfr0dDQwOaiSSQShMNh8DzP9DvUeRGJRHA6nXA4HIyVkEgkGGU3E2UtkUjA5XJlfU4eP4Dn+ed4nj+S5/nsHuJ55HEAyCcwYwDCzZx4+VKplAn1hSJvstZVKBSQy+VwOp0seFcoFKioqIBSqUR3dzfWrFmD6dOnp+Ulp1KYckE8HseGDRtG/LpUNDQ0QK1Wp61shsNhrFixAmeeeWaSIHT58uUABjUee/fuRV9fH1wuF5qampKqh4FAgGmEDiUxJiU1kUgEwWAwaZMkhzmVSgWr1YqioiIYjUZoNJohQj25XI7a2toRJzDAYEL57LPPAgDuu+++jA5AuUAikWD69OlYv379iM5DYWEhG0A3HM466yyIxWKsWLECPp8Pvb29rFNDHSTqtvj9fnR2djL7ZGECSa5jNJeIhLyhUCij21M8HofD4Uiah5EO6bQlY1Hsn3pM2TQxw313SoayrZ/QTtnlcoHnedZVVCqV6OjowN69e1khx2w2o7CwEBUVFey+WFpaCp1Ox6yYM3WAyWnvyCOPZPbtqcf76aefguM4HHPMMSNZtqzw+XxZg3rqKp9wwglJ91O6N9fV1cFqtTLrfK1WC7FYjEAgkBSAjxbIIY4ML/x+P4xGIzweT9K1Sp3blpYW9lgkEklLV43FYmhra8NXX32VVRNHiZ7QhlmhULC1yASVSoULL7wQK1asgEQigVKpRCgUQnFxMUtiPB5PkvGNSqViNvsAmL6qv78/6XxFo1E0NTUhGo0mdb/H6hyxPPL4T0M+gRlDIBcyq9UKo9HIXHrUajVri5MAORqNwuv1orm5GVu2bGHTrsvKymAymfDII49gx44d+M1vfjPkc+LxOF577TXYbLYk+li243rnnXfwl7/8Bc8//zxKS0sxadKk/f6ePp8vSUQphNfrRTAYxBFHHJH0+M6dO1FeXo6ioiJGWyAqCdGoiE5Hc2AOtTkearUaVVVVbJI40R1oOjww2K0zm80oLy9HeXk5mpubh1S4J0yYgMbGxhF9Ns/z+Oabb/DnP/8ZPT09rJt3IJg7dy56e3vx4IMPZhy8mYqTTjoJsVgsp4GWJpMJv/jFL/Daa69h7dq1cDqdiMViCAaD8Pv9AAaTE5vNxgS65HSWCnL0IzG/sOuZLmBxu93o6uoa1nAgnRnAWBT7px4T0TDTXQPDfXehxivT+gk7y5SU0z2BEp+BgQEWPBYUFKCoqAi9vb1oa2uD2+1mWrznnnsOIpEo49yW9957D21tbbj44ouH/C2RSOCtt97CypUrMXv2bGZlPBqYPHkyVq1ahQ8//DDt371eLzo6OnDssccmPe5yudi5UKvVkMvljEIqlUohkUhgNptHPZAmLVIikYBMJkMsFmP0VKG+0Wg0ori4GGvXrmWPaTQaeDwedr6am5uxfft2/P3vf8eHH36I77//Hjt27Mj42QUFBVAqldi+fTu7VxxxxBFYuXIltm7dmvW4r7zySshkMjz33HMIBAKIRCJsNhi51+3duxe9vb3M3dNisSTRx/x+P+LxeNKA07a2NuzYsQMtLS1IJBLQ6XQZ96088sjjx0f+lziGQG5k9N/CGyVVhsgqdmBggFUsiStN4vwFCxbg/fffxyOPPJLWceftt9/G7nGYG+sAACAASURBVN27ceedd2adNO33+7F06VL86le/wl//+lfo9XrcdtttWLRo0QFt9IlEIuPnZgqanU4nioqKWHJXVFTEOOHAD045Go2GdWPIhvhQAU2D12q1LGjx+/1wuVzo6uqC1+tl3Ymenh5UV1ejr69vSKfEZrOho6MjZ+pTS0sLrrjiCtx2223w+Xy4/fbb8eSTTzLKyv5i8uTJuOmmm7B582YsXrw4p+M57rjjcOutt+KNN97ASy+9NOzzH3roIUilUixfvhxVVVXQ6/VQqVSQSCTw+/3o7u5GKBSCRqNhxgTk2ic8HiGVjBJgYOjvkFBYWIiSkpIheopcsD8OZwcbIzmm4b47JUNEbwUwhEpGnWWi9lAXhTozCoUCJSUljA5Eon+73Q6HwwGJRAKdTocNGzbgk08+wY033ojJkycPOZZ4PI5HHnkE1dXVOO2005L+Fo1Gcccdd+Czzz7DmWeeiauvvnokSzYs7r77bhx99NFYtGgR3nrrrSF/p+5pqsajra0NlZWVaGhoYMOKyUafKKQHo3tHnchQKASPxwOZTMYoxsLrguM4nHzyyVi/fj0rrNTV1WFgYACrVq3CRx99hM2bNyMYDKKurg5nnXUWxo0bl9FQBPihYxsKhbBt2zYAwO23346ioiLcfffdWWmlpaWl7Dy+/vrr2LdvHztenufh9XqZzpSuN+E9gExTxGIx22cTiQTkcjlMJhMzrqH1GWuzxPLIIx2yDcH8ucyIyYv4M4BEfcOJwUcTQiqL8DgAsPkwQtoAz/NQKBRMCNvZ2Yn//d//xbvvvotHHnkEN9xww5DPCAQCeOKJJ3DUUUfhzDPPzHgsfr8f1113Hex2O2bOnImLLroIsVjsgINaYDCoGC6BSWeLq9fr4fF4GD8aGKQzRKNRRKNR9PT0IBqNsq6S0PhgLAWLucDj8TABr8FgQElJCbs+gEGK1MSJEwEMUvJsNht7La2Jz+cbtkrr9Xpx6623or+/H3fddRdOO+00SCSSA6KPCXHqqafC5/Ph5ZdfhkqlwsMPPzzsa2677TZs27YNd955J2pra4dUqIUoKSnBn/70J9x222347LPPcNxxx6Grqwsul4vNDwEGZ95otVrwPI/u7m709/ejqqoqSQNG3U7hZO7i4uK0OjGxWMxsZv/TMNx3T3U0C4VCsNvt0Gq1sFqt7LdIgWAwGITDMTijmIJFcigji2SO49Dd3Y2WlhYMDAzAarWir68PCxcuRF1dHe644460x/Lee+9h9+7dWLRoUdJ9PBQK4eabb8Y333yDc889FxdeeOGo3yPkcjnuv/9+/OUvf8EzzzyDo48+OknQTwlMqsi/ra0NhYWFsNlsUKvVMBqNcLvdLLGj7iIlgKMJhULB5qUIXcRS12bOnDl49dVX4XQ6YTAYoNfrUVNTA5/Ph+rqahQXFyMWizHx//bt24fVyBQWFqK2thZ79uzBJ598glNPPRULFy7Eb3/7W9x444146qmnMjIGrrjiCrz//vt48803MWHCBBiNRnR1dUEikbCudlFREaMt+v1+9PT0MBZCNBplYn+tVov+/n6IRCJUV1fDZDIxipzdbk9KXEZ7/fPIY7QgpHim4lCLhzIhn8BkgJAGkYtgPRvdheZ9pEMikUj6m9Di0eVysUqbQqGARqNBYWEhmyrscrkQj8eh1WoxMDCAxx9/HO+//z4efvhhXHLJJUOsaAFg4cKF8Hg8eOCBB9LSjLZt24Z4PI6lS5fC6XTimmuuQUVFBXp6emC324cMMCMQzzgThNW3YDCIeDzOPp8sggGwzbm3t5fZBptMJjidTtTU1MDhcCAWi2H8+PEoLCxkxgZut5vNiJgwYQKKioqg1+tZtfLH3GjSXQvZrgHha8i4QaFQsGF+CoWCOY8Rr16j0bAEZseOHUn0GQous020b2hoQENDA5577jm43W5cc8010Gq1WLNmDYDs8xeIvpMOGo1mCFVk4sSJmDlzJlasWAGj0Yi5c+emfa3QBemee+5BQ0MDfvOb3+C1117D4YcfnvF45s+fj9dffx133nkn3n33XcTjcQQCAZSVlUGtVjPLXYPBgEQiAY1GA57nEQwG0xYoSAtAHZt05/PnsgEMh2z3tVyuZwJdTzqdjtn/ko6jrKwMxcXFMBqNrMsgl8tZtdBisaC3txdisRjV1dXMhevWW29FV1cXVq1ahVAoNISmGI/H8dBDD6GmpgYGg4FpMHp7e7Fo0SK0tbXhqquuQlFRUcahbw6HIyNVTi6XZ9SaxeNxtgazZs3C6tWr8eGHHzLL88rKSuzbtw/AoKMe3ed5nkd7ezsmTpzI3PH6+vpYR5bneSiVStZ9Hi2KLM/zjD5JVtSkCQMG7aSp2wIMmr8UFRWho6ODdeJKS0uZrjEWizHqFr2XSCRi/08zmVJBWr+FCxey5Oi8887DG2+8gd/85je45JJLWGU5Fb/73e9w7bXXYs2aNZg5cyZ4nodarWazwagTE4/HmeELOWJSt5ts12lfpfuDSqWC0+lktv9EZaYxCJmKnMPd9/9T7iN55HEwkE9gMkBodXswQZu08P+JFlZQUAC5XM5uovQ8ulnG43GYTCbI5XLcdNNNjDZ2ww03pJ3j0dbWhueffx6nnHJKWmcyYLBD8+mnn6K1tRW//vWv2bwRYDC5qK6uTvs6i8WS0VIUSJ4DQ8EJvTfP86yyRhuySqWCyWQCz/OQSCRwuVysQkb0E5PJxGbjFBUVsQFvtEZms5k9fywinS0nzbbQaDQYP3485HI5e47D4cCWLVtQUFCAiRMnory8HAaDAS0tLUkJWk1NDfvvqqqqtJ+9YcMGfPjhh+js7MSll16aZGMNgOlw0qGzszNjC9rj8aStzl999dUIBAJ49dVXUVxcjJNPPjnp76FQKOk8KZVKPPPMM5g/fz4WLFiATz/9NON5lEgkeOqppzBz5kw88cQTuOKKKxifvaysjNnkEi/earUmUXGEHT0S8lqtVgSDQaajSg1Qfi6Bx/5+j1zm5AipNpWVlSwxIboYzWiizpdYLGb/lkql8Hq9kEqlzFK8o6MDvb29iEQieO211/Dee+/hlltuwYwZM+DxeIZU+JctW4a9e/fiueeeYwWUQCCAhx56CF6vF3/4wx8wbdo0dHV1JdkEC7Fly5aMVf9AIJCxI93V1cUC+8LCQpjNZtZZAQb1Ww6HA1arFWVlZex15LRGRR2iLBUWFsJisTD7b51OB47jhrX+zRX0Xj6fD+FwGIWFhZg4cSKjCpeXlw+hDJ5xxhl4+eWXMXfu3LRdyuXLl7N7wcaNG6HT6dh9o6GhgdlDp6K8vBxNTU149913MX/+fJhMJpxzzjl477338Oqrr+LSSy9N6xZ32GGH4fLLL8fSpUsxY8YMnHTSSSgrK0NPTw96enpgNpuZXXM8HodUKmWmOdStDofDkEqlCIVCzDSB1sdoNCIQCKCgoAAymYxZjY/V/SWPPH7uyGtgMiCd1W2uGM4mled5BAKBjIMfiS4WjUYhEokglUohFotZZYzsYePxOGKxGB599NGk5CUTHnjgAYhEoqxc77Vr12LTpk045ZRTsiYkBwLiHadDOgqZz+djA9yqqqpw5JFHsnkQGo0GcrkcwWAQZrMZkyZNgtVqZfNzqNo7FvnKJGQWdjvIZY4EtVSRpPWiwNDtdkOlUmHChAnMlppAdLLu7u6Mn/35559jx44dmDt3LuvkHEyIRCJcfPHFOPzww7Fo0SJs2rRp2NeMGzcOjz32GHbs2IHf//73WYPmqVOn4ne/+x3eeecd7Nmzh3UrKQD0+XzMmY6SWwqg6ByQ8xJ1PskhK2+bun+gLovD4WBDTCORCJxOJ9xuN3Q6HYqLiwGAaVuAweLFwMAAQqEQGhsb4XK5mHOUTqcDz/N46qmnUF9fj7vuuivtZ8fjcSxatAi1tbU4++yz2eMvv/wyXC4X7rjjDkybNu3gL8K/UV9fj127diXdh5qbm4cUGKgTNHXqVEYXC4VCzEFLo9GguLiY2UtncnnbXwQCAfh8Prjd7qTuSrpE97TTTkMikcDmzZuHfd9oNJpVAyOETCbDySefjO7ubtY1KysrwznnnAO/34/XXnstLbsAAC699FLU19dj8eLF6OvrQ1NTE3bs2IGNGzdi3759zDlPLBajrKwMOp2ODT0uKSlhw0OBwS6S8HxFo1Go1WpmFOJyuWC32zMOT80jjzwOLvIJzEFAMBiE3W7PSLPp6+tjG3s6MSaJYGkOgEQigcPhYFWfUCgEqVQKrVaLDRs24Omnn8YVV1yRNXnZsGEDli1bhhtuuCHjvIQvv/wSX3zxBaZOnZo0g2W0kU0DI3SGIdBkapPJBKPRiEQigTVr1jCP/46ODjYLxmq1QiKRsM3d7XbnvMmT9uFAk51c53xQQELiZWDQjjSRSCS54RDMZjOmTZsGs9kMu92Ozs5OVFRUDElg9Ho99Hp9xgTmrbfewoYNGzBz5kw2ZPLHgEQiwZ/+9CdUVFTggQceyGnWzOzZs3HTTTfhzTffZBbPmXDPPfegrKwML774Imw2G4xGI/r7+xGNRhldjDqqVPVXq9XQ6XSQy+UssabiAmk25HJ5XrQ7AlDnRS6XM9cmcqdSKpWwWCywWCxJlev+/n4Eg0F27/T7/ZDJZOy3kUgkIJFIoNfr8eqrr8Lj8eCFF15IaxEPAB988AEaGhpw6623snvKhg0bsHbtWpx77rlJQ3h/DBx22GEIBoNJFNyWlpaMCcyUKVPg9/sRjUah1WpZt1aoLyI6ZLYOQK73ong8DoVCgdLSUtZld7vdLOBPl8DU1NSgsLAwp1lPI0lggMF5VhMnTsT69evZHBqbzYZ58+bB4/HgxhtvTLu/SqVSPPnkk+ju7sYTTzwBjuOgVCoxMDAAv9+PPXv2oK2tja1Lb28vnE4nvF4vu97a29vR29s7xM6diktGozGjiyC9L9HUDiUXzDzyONSQT2B+AhCNxWq1spugcKOhTUosFkOlUmHfvn1oamqC3W5n+gOZTIaioiK8+uqrKCwsxMKFCzN+Hs/zuPvuu2G1WnHjjTemfU4kEsFjjz0Gq9WKX/3qVweVIpMtgVEqlRCLxUmuM7RRFRYWQiKRoKWlBZ2dnWxmgFQqZe5RwvfR6XRMJyPUFmUKRkdrPke29xF+PonyheYMtEkK6TD0GpFIBKvVCrPZjHg8jnA4nLa75HQ6EQ6HkzQlhNbWVixatAjV1dUZtSgHE2q1Gg888AA0Gg2WLFmS02t++9vf4pRTTsHChQuzusppNBrMmTMHDQ0N8Hq96OrqYtXrtrY2dk6Ebld0TDR/hyrcxcXFLPimZJgEwPlEJhm0lhS0UWAYiUTY3AyZTMaoThqNhgmlqetSUVEBjUaDUCiEvXv3Yt++fQiHw2yt3W439u7di507d+Kdd97B7373u6wd4pdffhnV1dVJ3Zddu3ZBLBbjrLPOOrgLkgZ1dXUAgN27d7PH4vH4EN0OUX8p6SotLYXNZhtiRx0Khdja0f8fyD0tHo8z4w65XA6FQsG0RsAP2kQhOI5DdXX1kEGXqSDjhZE6V5500kkoKCjAypUr2bpUVFRg/vz5aGpqwoMPPpg2QZg+fTquv/56LFu2DDt37oTBYIDFYmHdpGAwiK6uLng8HvT09LAZUjRE2uv1IhqNsmJZanGJOjE0GFdI36X1HknhLI88fmxkcyjL9s9Ycy/LJzAHARQEZRL/cxzH7HIJmSZ20yal0WiYhbBGo4Fer0cikcB3332HOXPmZDUaWLZsGTZt2oS77747o5j9/fffh9PpxKxZs9gQwIMFGgiWDgqFAocddhi+++479hgF87FYjFlhVlVVoaamBnK5HDKZDGVlZcztKBaLscobUS8oIKBgNFvn60B1T5neJ90059RBpbRJUoASDofR3t6Ojo4OOBwOBAIBcByHoqIi2O12rFixApdddlnS5yxduhSRSAS/+MUvkh7neR4PPvggZDIZzjzzzJ9snoHJZMJ5552Hffv2se5aNohEItx6660IBAJp7WgJ0WgUb7/9NubMmQOZTMb0RAqFgnH8yVq7r6+PDe0Dkm19tVotGyoqNPKg+TL5oCQZqd1O4If5L0qlEgaDgSWD6QoIdB26XC7I5XKMHz8eJSUlbD4HOT+JxWLWoTj66KMzHk9nZye+/fZbnH/++UnX+Lhx4xCPx2G32w/GMmQFFVKamprYYyeddBI+//zzpIGg1Bn69ttv2VBV0gKR9W+qBbiQ+pga0Od6T+M4jlGVjUYjDAYDKisrmZ4utctLGO4eEo1GsWbNGhiNxhF3vaRSKU477TSEQiF8/fXX7PHq6mpcf/31+OKLL/Dmm2+mfS05GP7xj3/Epk2bwHEc6wSGw2GEw2HIZDJUV1ejpqYGlZWVMBqNrOOq1Wrh9/vZPYISGWHHi7q46WY8pRbO8shjLKGlpYUZUIzkn0xmJz8VDqkEhuO4SRzH1XIcV/9THUMuNKN0MxWGayfT0EohJYK0MKSVIUoBMLgxbN26FR6PByeddFLG9+3v78cDDzyAyZMn44ILLkj7nHA4jJdeegnTpk37UTLsgYGBjAkMMFhB27JlC3M1owQmGo1CIpGA53lYrVaEQiE22NPn86G1tRXNzc3weDwA0mtMKFBNt6EfiO5JiEwzNdJNc6ZNkD6Tji8YDKKxsRG7d+9Ga2sruru74Xa74XQ6WfL15ptvgud5XHnllewzIpEInn/+eZx66qlDzuUHH3yATZs24eabb87JWe9gglzFaObDcDj66KMxefJkPP/88xl/R99++y2CwSBmzPj/2fvuMCnLc/37m152yu60ne27sBQpAoKIFClqJBZyxESNGoyKxiSmYCxoPCnqOceovxj14CFR0UQhQaJoAlJFioggwlJcWIbtbXbaTt3p3++P9Xn9pu0uC+qa7H1duSIzOzNffb+n3M99T2eUJVJLGjduHIxGI+sUJJNJ5gkBfH4egM+r2cKkhoLvYSfuTKR3O4maRx1G4XGlIJy6X2azGWq1ms0UhEIhxGIxJJNJhMNhFBcXM1poRUUFq8SPGjUq5/Y8//zzEIlEuPbaa1Nep8/kCsa/SFC3QpjAXHbZZXC73SkzJNSpqa2tRSwWg91uR2dnJ2w2GxoaGnDq1Cl0dHQwQ0a6hsmENb0wM1B/H4lEAr1ez7rcBQUFAHqTBalUmtI5EqI/la2DBw8iGAxi1qxZg1pXCwsLMXnyZBw7doxRhgHgxhtvxJw5c/Dcc89lVYJTKpV49dVXEQ6H8eKLLyISiSASibACRHNzM7xeL8RiMWKxGCKRCMLhMLxeL6RSKTweD+vwk02B0AsmF4TsifTjnt6pHO7kDmMYZ4evjQoZx3HfBPAEgA8BTOA47jc8z2/6srdjoPLKpFCiUqlSPpOLN0t0iXA4zP6GKGTFxcXo6emBSqWCRqOBx+NBIBDABx98AACYPn16xoOL5h9+97vfoaWlBb/5zW/Ya3V1dSkJxJYtW+B0OnHbbbehvb09hZogRHd3d05pXp7nsXv37pzHY/z48ey/qQJGD3O5XJ7CDa+srEQoFMLOnTtx3nnnpXSqqPMkEomYR0okEmG0h1AoxAb8KdAktSPgc5W3L7v7QJ49er2edQRyyfOqVCqWrOl0OiQSCRiNRtYVCAQCaGtrwz//+U/MmzePuWADvfMtXV1d+N73vpfyYPf5fHjqqadQXV2NsrIyHDhwoM9OgrADlo5QKJSzc6JWq7Fr166c79F1l0wmoVKpsHv3bpSUlEAkEuVUewJ6q7E33ngjHnroIWzevDmlAp9IJKBSqbB161ZIJBJMmjQJ0WgUVqsVMpkMYrGYqQ+JRCI2yE/+QMLzIHSIF87M0LkjVbhcLvWEfxWVMoJwPUs/ZnTNAkihxApBx5XoYxTMqdVq9r0WiwWxWAwul4u50NO9mkgkEI1G4XK5IBaLUVhYmLLmtba2QiaT4cSJE3jllVdw3XXXQSwWM3pTS0sLeJ6HRqPBoUOHUroBzc3NOT0T7HZ7Tk+k/Pz8nAm4UEaZkJeXh0OHDuHgwYMsIReJRFi/fn2KCmBpaSkaGxuRn5/PJOw5jkM4HIZCoYBYLGbS6gSj0Zjy7BgMhDRbp9PJJPUrKipw7NgxFtALQQF5tiSiqakJx44dg9FoRGtra8oaH4vF4PF4cm7L4cOH2X+rVCrI5XJs2LABF1xwAaqrq7Fr1y7MnTsXR48exX333Yd77rkHarUaer0+xYT28ccfx09/+lO88sor+MlPfoLi4mK2BsjlcjidTni9XlawkEgk8Pv9iMViiMVi7FonyWSFQpGRePQno0zw+/1obGxk4iLAwCwahjGMoYJcEubC9/vynznX+FokMBzHTQXw/wAsAbAfwC0AFnIctxkAx/N8n6UMjuPuBHAngAy52DNFLnnl9JNKPHAAGYG0kHtP3EL6G5IZpcFD+q14PA6tVsv0+JPJJD7++GOMHDkyq7SxUqnE/v378frrr+Omm27C7Nmz2XtSqZQpMIXDYWzatAkTJkzA9OnTsXXr1pwSuj6fL8UwUYhPPvkk53tAqrQvABQUFLDXQqFQiqQmGRfabDZMnz6dLfIej4cZikkkEkilUkQiERbk0PA68HllUEiZE849nItOC6Gv60vo6yIWi1k1j2ht5L1gMBhSAhKRSASZTMYkUymJI4foAwcOoLOzE7/73e/YcCzP83jppZcwZswYzJ8/H++++y67rl577TVEo1Hm91JdXc2qvdmwatWqnO+1tbXlvI9aW1tzUkWi0SjziQB6k9rGxkYUFxcjGo32Kd2sUqlw/fXX44knnsCaNWtSuo48z0Mul2P79u2YMWMGTCYTVCoVPB4PysvL2fyQcLaIguP0+1Z4rwoNF4mKKExwvgxvoXO5dp0NhEUY4bolRDZZcEK2BIe6Wn6/HyqVCiaTiUmlWywWOBwOxGIxdr+r1WqcPHkSFRUVGbK9CoUCMpkMTz31FPR6PZYtW5ayRpPi2KRJk3Dy5MkUBbKPPvoop6QvSR0DvWslx3HsGgqFQjCbzTk/ly6xPGHCBOzevRuxWAxyuZx1F3bv3o377ruP/d3o0aPR0dEBs9mMZDKJWCyGgoIClrTR/4TdwMHM7aVfW8K5xGQyiUQiAblcjurqanz44YeorKzMOOdUIEjf12QyiePHj7N7TjjTCPQWovqilAkVOsViMUaPHo0jR46gvb0dOp0Oo0aNglqtxs0334wVK1bgjTfewJIlS9DT05MiFnDZZZfhZz/7GX7/+98jPz8fP/vZz1BUVASPx4OOjg5mWMlxHPx+P0ty5XI5/H4/tFotenp6WFcxPZEXHMu+jjOAzxkVw/SyYXxd0V9y8mUX7r4uFDIjgMd5nv+I7y1p1AOYCEDUX/ICADzP/5Hn+ak8z0/NpcA1UAyUZiTkHgtpQkJpUWEFnP6G2twOh4PNorjdbni9XjQ1NcHtdsPn84HjOOzduzcnfSwYDOLBBx9ESUlJysMxHZs2bYLX68UNN9xw5gdjkIjH433O2VitVpjNZlaFI1pdLBZjD276PEnjAv3T+4TH/mwH9YXo6/qigJeoL+m0NpfLxQZKhaCAm2hLPM/DZrOhubkZkUgE7777LiorK3HJJZewz+zZswe1tbVYunRpykLS2tqKXbt24fLLL09JIL5qjBs3Dna7PSO4yQWVSoUbbrgBGzduzFBY6+rqwuHDh3HZZZdhzJgx4HkeHR0djHZC1wslw0JfJSGy8dqF56wvCuIXgXO5dp0NBjJL0Zesby4qE93bgUCArQsVFRWs40JBX1dXF+x2O5qbm3PSx95++20cPnwYv/jFL5jBbTrGjRuHrq6uAc1eEZLJJJqamvDhhx/iwIEDGYP3AwUloEIe+dy5cxkVmEBu9MI1QyQSpUiqU0JJ8t+0T2eyrvV1bWm1WowdOxZVVVWwWq0s4M/yHVm/e9++fYjH49Dr9SmeS4NV5TKZTDAajaivr0/Zx5KSElx11VU4ceJEzs7v0qVLsXDhQqxZswabN29GY2Mj3G43VCoVFAoFysvLYTabEYlEEI/HodPpmCJZR0cHGhsbWUJFs3N9CbTE4/GsFDGz2YyRI0eisLAwhTY8jGH8O6CiouKciwN8Le6gz6hi2wQvHQbQw/N8AgA4jstduv2KkCvRUSqVTIEsWwVGyGcmvi7x9cn/JRwO4+DBgwgEAjkTmCeffBKtra144oknclaKg8Eg1q9fj0mTJvVZjT/X6G8GhuM4TJo0CTU1NQBSh/jJp0AqlUIikTDOfDweh91uz6rLL5R1TVd/+6JBs020D+lD+wUFBdBoNOyBSdsL9LZj9Xo96zTpdDqYzWY4HA7s2rULd955J7u+eJ7H888/D4PBkMH9X7t2LRQKBRYtWnTO98/n86U4dJ8JyH/m008/HfBnlixZgng8jjfffDPl9e3btwMALr30UkYlkUgkSCQS8Pl8sNlsjLKi0WgGpEpHoHNGnkLC7sy/CwYySyGUBaehz1yzfxQIulwuNvwfDocZ9bOgoAA6nQ5VVVUsGfH7/bDZbBndXKD3Onz66acxefJkXHPNNTm3ka65bJSnbIhEIjh48CBsNhv0ej2i0Shqa2sHFYir1WpmaEmYN28eeJ7Hpk2fs6FHjx7NOrN5eXks8RFSlw0GQ4r8NxldKhSKcyLfq9FoUFlZibKyMkyYMAHAwO9Tn8+HLVu2QCaTQaVSged5OJ1Odq6FogVnAurYHDt2LGX/ZsyYgYkTJ2Lz5s04ffp0xuc4jsNjjz2G0aNH46mnnsKBAwfQ3t6Ojo4OeDweRKNRqFQqSKVSRKNRNgtEtFOv18sSFqI20jUuBCXwLpcrayIvFothsVhyKnAOYxhfd/SlbgbgnIsDDPkEhvtsz3meF5Z/JABKOI4Tcxx3K4CXOI5TcUM8qiCKBSkdZavA0CyARCJhEw+z/QAAIABJREFUgS5xZltbW+F2u+H3+7Fv3z4AyOrjceLECbz++uv43ve+h2nTpmXdFp7nsWLFCgSDQdx0003ndkf7QX8dGKCXmtDV1cUG9Om1RCIBp9OJ+vp62O12dHV1oaWlBQ6HA3a7PSV5oeCU6HxfpnoU/TbJ9pKvS/rQPgX/brebJas0uEuyyVqtFvn5+dBqtSguLsZbb70FsViMJUuWsN/r7u7Grl27cP3116cIQSQSCdTU1KCysvKc8615nsd7773HZrHOFCQPOxBTS0JlZSWqqqpw4MCBlNdpyLigoICphVksFuTl5SEUCrGgQihfzfN8hiqccN+EctdqtRrhcDjndTRQv42vG7LtF9Fo0pM+oSw40ZyyKf7xPM+KMjKZjM0mJZNJdh9Eo1HI5XJ0d3dDLpfDaDQyCunYsZkaLlu2bIHb7cby5cv7rGyTlK9wILwv0HWj1WoxYcIE5OfnM3WwMwXP85BIJCmSxBMmTEBhYWFK94Aowa2trSkiCBT4CmXXabhcIpEgLy8P4XAY3d3d6OrqOutrMRgMwul0MrpdtkF+Kq5QtwjonbEkqi/HcWyeBACTfh8MqFtCaowEjuOwePFiaDQaVshIh0qlwnPPPcd8Yigp6ejoQDgcRldXF3p6etg+u91uxGIxtLe3Q6lUskSMjgupGQpBhQ5KLrMVKAdSMBnGML6u6Evd7IuYjRmSCcxnSmMzOI6T4rNt5DhOuK096KWRPQDgBwDu53k+xA/x6GGgzsnUyrbb7UgkEuju7kYsFoNYLGaVn9raWpSWlmYdfH7++echl8tx99135/yNt956C/v27cMtt9yCqqqqs963gYLn+T5llAHg1KlT2LhxI2644QaIRCKsW7cOAHDFFVdgxIgRMBqNbCDcaDSitLSUVcZMJhOjkgnnkKiK+0VQyLJBOCtB1ft0kDSnyWRixn4UkNA1IhKJmDM5eTV8/PHHmDRpEvM1AHo55cK5KYJYLMZ1112HTz/9NEWK9FyAgrhcrtj9QSQSYdasWThw4ECf/i7piEQiGTMQ1IncvHlzCtULAOPFW61WSCQS1g3LpgpH6EvBLltgcq48hIYasu2XkL6UDiHFLhftLBQKsbkkCmhpiF+v1zOfK7FYjEAggJaWFjidTqxfvx4ikQjf+MY3Mn63ubkZCoWCdVhyYeXKlZDJZLj00ksHtP8WiwUlJSXw+XzYuXMn3G43KioqBiU1f/ToUXR0dGDmzJnstWg0CqfTmWJoSfM4brcbnZ2dSCaTTOWNkrNQKITu7m7mXUTXpEqlyqlINlBQYu92u9HS0gKlUgmr1YqGhoaMvx07dizi8XiKmMGkSZNQWVmJQCDAEhm9Xg+lUon8/Pyzmh2jdTS9i6NQKFBYWJiS2KTDarVizZo1aG1txapVq1hX0el0orOzE2q1GhUVFSzYam9vh8/nY0m5w+GA3+9nipDp4QYlmzSvJUykv8pi2jCGMdTRX+cmF4ZcAsNx3LUA3gbwGICXAPyI4zgtz/NJSmJ4no8AsAC4GcD3eZ4//pVt8Bkgm1SyEEKqk0QigUgkYoZwfr+fectotVrY7Xacd955Gd9ht9uxZs0aLF68OKeq09GjR7F69WrMmjUrxejtywAFvX0lME8//TTy8vJw1113AQD++te/YtKkSVAqlYhGo8jPz0cikWASyqTglpeXh7y8PCY3DHzuRyFMFr4MCplQgjcX31lYPaWOHDmVGwyGFBM1Gox2OBw4cOAAEzogiEQijBgxIqu7/ZVXXokxY8bg1VdfzWpIN1gMljomxLx58xCPx7F3794Bf8bj8SA/Pz/ltdmzZ8NoNGLjxo2QSqUwm80oLS1ldJvy8nLIZDLE43GmPETCGORRIkS2ZCW9eybEufIQGmrItl/0WrZETjhDlIt2JqTh0PC+VqtFXl4evF4v2traYLPZkJ+fD5PJBJlMBqfTie3bt2POnDkpiTuhtbUVJSUlfT7w9u3bhz179uCmm27qUzBCCBognzp1KgwGAyorK1OSjYEimUxiw4YNMJlMKV3xEydOIB6PpyRelJx3dHSwWS+67hQKBbumJRJJSkcR6O1GmM1m6PX6QV2LlLyQ2iGphVVUVGStoJLM9f79+9lrEokEN910E8RiMZxOJ+LxODQaDVNS/KKIEqT42Rcuuugi/PGPf8S+ffvw1ltvobCwkBWPCgoKmAAI0HsezGYzo/f6fL4UM1wgdzeSkJ64AMh57wxjGP+u6Ktz0xeGVALzWcflegC38zy/AL2JTCmA+zmO06UN7P8DwLU8z2fX9R2CEEolE8hYzePxwG63o7u7G5FIBCaTCXK5HHl5eYxyxXEcZDIZPB4P6urqslYbV65ciVgshu9///tZt6GpqQkrV65EeXk5fvjDHw76YUJa9mcKSmByVTD37duH3bt3484774Rer0djYyM+/vhjjBs3DpFIBIlEAmKxGDKZjD247XY7mpqamDyu2Wxm/hIkjEDD4lQd6+uhcy7QV7BLyBUki0QiuFwuRmsg6qFcLsdHH32Enp4ezJgxI+P7Jk6ciEOHDmWl9ixduhTRaBSrV68+Z/tItLizQUVFBSorK7Fz584B/X04HEYoFMpIYCQSCa655hrs3buXVYojkQj0en3KrABVU1taWuByudj5Sad1UPBN76dTP3ieZ6aCQsW7Ic5iPWNk269cUuSkKOb1etlxIQipaPRdJN5AAaTD4QDHcQgGg3C73XC73eA4Dl6vF6dOnYLNZsswZyW0trb2qYLY09ODFStWoKKiAosXLz7j46DT6TBp0iRUVVUNavj68OHDaG9vx8KFC1NmIMgDZsqUKew16lBEIhEYjUY2L0Qu8KRMRkkMdRQJZ3MthkIhxONxJBIJRl+VSCQoLi7O2oHhOA7Tpk1DW1tbCi1PrVazTpLD4fhSKFMqlWpAz6Rrr70Wjz/+ON5880089NBD6O7uhlarRTgcZmIKJDwgkUjg9XrZukPyy9ShJZ82v98Pu92OeDyeslYQ7RRAzoLWQLzlhDjTvx/GMP5VMRRllLUAqgF8AOAtAE4AVwK4EcD/cRw3HYCH5/n/+uo2MRN9ZYr00BZKJQeDQSiVSrhcLjQ0NCAajcJisTDp3EQigfz8fJbQkC+IRCJBe3s74vE4Ro0alRJEBgIB/OlPf8KVV16JaDSaYdjW09ODe++9FzzP49Zbb82q6+/1enMq+DQ2NjKVlQMHDiAYDOKSSy6BVCqFxWLBggULch4DepgKExh6TavVwmq1gud5PPvssygtLcWyZcugUCjw2muvgeM43HTTTczzhSrmNExtt9uZ+AH9PwX9RGUxmUwIhUJsEHsgXj6DxUADByG/PZlMsu0LBAIseVUqlXC73WhtbYVcLmdKQNOnT0cikWDqRECv/PTq1atx6tQpjBs3DhMnTmT7N3nyZNTV1WHlypVYunQpOjo6+qRbZJszIHR0dCCRSGQk4kBv1dJqtWb9XFNTE2w2W8brEyZMwDvvvIPDhw/nFJOghIXoagaDgQUBxLG/5ppr8PLLL6OmpgYWi4XNm4XDYbS0tCA/P58NOpNUeSKRYEFIIBCAwWBgkskUaCaTyZS5B0qAyS9JeB4JQ5zNyjCQdWugIJW/YDAIlUrFOqK0zsXjcTakL7zegV6flmg0ing8DoPBgGAwyGbetFot9u/fD5FIlLVjzPM8WlpaMG3atJxUxOeeew5dXV249957MwZGxWJxzjWvrKwMI0eOzPrevn37cPTo0azvFRYWYuLEiQB6742nnnoKFRUVuPXWWyEWi1nSQdeqUKJYKpWmUKXsdjucTieKi4sRiUTYMaXiRiQSgUQiOevkmRJTjuMglUrR2toKrVaLUCiEvLw8dHd3M58twpgxYzB69Ghs3rwZp06dSnkGXHvttejp6cGaNWsglUpx/fXXs3vq0KFDfXbBcvHl6fzS9SUEPR+6urqydvh9Ph877t/5zncgl8uxfPly3HDDDXj00UcxY8YMlnjQML/ZbEY0GkVeXh48Hg97tnAcB5fLxe77QCAAp9MJoHd9oASerBNUKhVbRyjxpDWUEhL6LND3vZcuaS6U6k9fu74qCCW6hzGMLwpDqgPD83wMvX4v13IcN/uzjsse9KqOzeE4TgngYgC5I68hBGElRuiREIlEGA+2oKCAKWNRq7q1tZW18Q0GA6MUGQwGjB49mlUu0ylka9asQXd3N370ox9lbAvP8/jDH/6AlpYWfOtb38pKwxgI4vE4Dh48CJ/Ph3g8zoziBgqa0cj2gNm4cSNqamqwfPlyZhz2xhtvYPbs2awaSMFNIBBglUadTscCEEroKEkJhULgOI79Hpm9DTW6j1CVKZlMQq/XM/8JEi0IBAI4fvw4ysvLM3wXgF56BAAm8JCOu+66C0VFRXj00UcHrQQkxLnowADA+eefD4lEgrfffrvfv6UKaTZ65Ny5c2E0GrFixQp4PB54vV523skUVi6XM+phNBplXYFoNIpoNJpVDIJmZWjQnEzvTCYT1Gp1RgVciK/DcP9AB4upw0LdgHSQwmJFRQXy8vKY/DElLxKJhKlkAZ9TySQSCaLRKJs5iEajqKqqYoG6TCbD3r17MXPmTGSTku7s7EQkEkFJSUnW7T558iR27NiBWbNmfanzfoT33nsPTU1NLHkR4uOPP8bUqVMzglWNRoNAIMCUsZLJJNra2tDc3Mw6zX3NZA0WQjn/RCLBaJckfpCtC6PRaHDxxRdj165dKUUNoJfb/s1vfhONjY1Yv349Tp06NajO/UBAwT8F9/1h0aJFeP311xEIBPCjH/0Ie/bsYcaVJCSRl5cHo9HIpPuj0Sib5VEoFIjFYnA4HEgkEuw5TYbT6YpwLpcLHR0dcDgcTOhiMLSy9PNOz7qurq6sKpxfBYQS3V/1tgzjXxdDKoH5DLsBbAFwC8dxc3ieT/A8vxpAEYAinud/n6ZI9qVjoC1cYRAtVDuiBUgulyMSiaC8vBylpaUoLy+HxWJBaWkp434L/QHC4TAikQijQgkrg/F4HC+88AKmT5+eVXnszTffxO7du7FkyZJBcbhpvw8dOgSPx4OJEyfCYDCgqanpjFrZuWZgeJ7Hk08+iaqqKlx33XUAemd1bDYbpk2bxgJHj8eDrq4u+Hw+OJ3OlMArm1yx0ECP/s1x3Dk1sjwXoIeewWBgDz+v14uGhgbWrVOr1Th48GBW+hjQWy0uKirChx9+mPV9pVKJhx9+GDabLcXperAQzsCcTYCuUqkwfvx4bNy4sd+5GpoJoOROCJlMhhdeeAE1NTV46qmnIJPJEIlEWMAH9JpwkiiGTqdjr8tkMib7mg6hIAAVHoSdr74Sua/DcP9AxUWCwSDq6+uZclM6RCIRNBoNdDodLBYLmy8wGAzQ6XQwmUzo6elhlWoqRkilUhaQud1udn44jkNPTw+OHz+Ourq6nDLgFFRnS2ASiQT+67/+C3l5eV+IjHh/SCaTeP311zM8m4BealVTUxMuuOCCjM9R54PjOOj1ehgMBmbQ6Pf7WUJ9rv1EhMmsSCSC0WhEYWEhk3Kur6/P+rnLL78coVAoqyLhxIkTMWfOHNTV1eGNN97AH/7wB7z//vvYunUrjhw5Arvdfk4SfEpgzkRUZPLkyfj73/8Oq9WKO+64A8899xxaWlrg8XjY0L7b7WbPGI/HA7/fj2g0CrfbjaamJng8Hng8HjbHSEaX4XCYCQQ4HA5mtKxQKFj3m2hlwo4a0HdRIf28f9neVMMYxlDB0IngPgPP82EArwOoAbCc47g7OY5bAsAEYOBSRV8g+gtKaPGhOY1kMpmidkQKY1TNpLYvfZ9Go4FarUZrays+/fRTVqVxOBzYuXMn3nnnHYwZMybFcXjdunVobm7O6L7EYjE8++yzWLVqFWbNmjUo/jfQKzt64sQJuFwuTJgwAVarFRUVFSyhGigo8BFuO9BLKThy5AjuueceFhhu3boVAHDhhRdCq9VCJBLB6/Uy2g+p8AjnFCKRSAp9jCqbX/WMQi452vTXaF8aGxtx6NAhtLe3Q6PRMAM+u92eVTobAKOXZBvkJ8yfPx9Tp07FJ598clb7Q9QWwtGjR89qqH/atGnwer1YtWpVn39H149Q9UiIK6+8Evfeey9Wr16N/fv3pwg8+Hw+2O12qNVq5Ofns8o20Hvc6ZqkzgqBzonf72eVbwAphYhcwUZ6t28odmT6ExcRQqlUsgQb6DvQosFnopQJA22RSIRIJIKGhgYcOnQIgUAAI0eOxKhRozBixAjodDo2c/Dyyy9DLBbjqquuyrpN5KFCQbYQa9euRW1tLa677rqvJMCz2WxoaGjAf/zHf2QkGidPngSArI70arWaqRF2d3enBK0ej4d1aoXHnv59NtcWJbMikQiFhYWQSCQIBoMoKCiAWCzOmcCcd955sFqtOSXVZ82ahV/84he45ZZbMH/+fOh0OtjtduzduxdvvfVWVonmbKBjuHfv3oxrjmZuzkQQBOgVInjttddw6aWX4g9/+AP+7//+DzabDR0dHejo6GAqeEBvAU6pVKKyspKtA4WFhaioqGAiAl6vlymI5ufnQyQSIRqNwuv1QiaTIRwOIy8vj3UgyeCa7hWS36eiQjqTI/1+o2uD6Ltno/I2jGF8nTDkEhgA4HneA+BPAH4HYD6AeQBu5nne3ucHvyRkoyBRUhKPx9liRJUbkUiU8vetra2or6+Hy+VipnrEHz99+jTq6+vR2dnJZChDoRAaGxvxxhtv4I477kA8HseTTz7Jftvv9+PRRx/FlClTcMUVV6Rs61tvvYXNmzdj0aJF+PnPf37GAXwkEsHWrVvx2muvIR6PY8qUKczNnbjQA23ZA59XS9ODDaI0CalRxHFWqVSMMsRxHDPzlEqlUKlU8Hq9KXKiws7XUEFfcrQUqJHDMynbUDW7sLAQIpEIUqkUarUax49nF927//77UVdXh5/+9Kc5tyMajaKhoSFrB2OgSCaT2L9/P9xuNyZOnIjKyko0Nzczqsxghkurq6tx5ZVX4oUXXsCGDRty/t2ll16K6dOn49FHH82ZxPznf/4nRo4ciWeeeYZdmyQvC/Q+8OnepHmWQCCA1tZWOJ1OiESilPuE7m2e57N27ijIzDasnJ44D8WOTLq4CAVJJNRB+6RWq5nqlFD8gGgrwuAqFAqhqakJJ06cYAIb9B1GoxEqlQp6vR4ymQx+vx+nTp2C3W5nsw3t7e1obm7G7bffjn/84x944oknstLHNm3ahGeeeQZXXHEFW5cIzc3NWLFiBWbOnJm1y/FloKSkBDKZLOtMx9ixY8FxHBvkF4LjOCQSCaaOJZVK0dDQgFgsxtbD9M7Z2a57FCDTc0qpVDIKn0ajQXl5edYZNtpeq9Xa57NAKpWitLQUF110ESZPnoybb74Z8+fPB5B7FjGZTKKzs5PRonQ6HYqKirBp0yasWLEiZeZpxIgRGDduHFasWIHNmzef0b6r1WqsXr0aI0eORF1dHaOK0bXf09PDZlaEpsMkBELrCBUDurq60NXVhWg0CoVCAZlMxmZfSOJaeL+kd3npmNDf0Hnuq1v6RXTkhjGMoYyhOMQPAOB5PgpgB8dxu3r/yQ8ZyQ2RSJSx4BK/FQDzIqHkhdrJVNkiqkNJSQkbviQXa6fTCafTyR70EyZMQDKZxNNPP42XX34ZF154Id544w1WAa2vr8f3v/99OBwOvPrqqymLV0dHB9asWYOZM2di6dKlZ7SPkUgEdXV12L17NwKBAC644ALG8yXQXMGZcG5PnToFmUyWoRhEx1M4WE5/Ew6HIRaLYTabkZeXh7a2NqZEJZFIWOCl1+tTKuTEQRZ2Yr4qCKls2V6jqqlKpUIgEGCeDwqFAj6fD52dnbDb7RgzZkzWamVnZyfWrl2LpUuX4tprr825He+//z5cLlfOLk5/iMViOHnyJHw+HyZNmsTOUVlZGY4dO4bjx4/D6XTiG9/4BsrLywf8vRzH4de//jW6urrwq1/9CiaTCRdeeGHG3ykUCrz00ku44oorsGTJEmzevDlDkUwqleKxxx7DDTfcgFWrVuH2229HPB6HSqVCeXk5C9bpXgkEAlCpVDCbzWyQWQgyM9Tr9SnVTQom8vLyWGBCwgG5kO06+Koh7CgBqVV4YfIiFCvIVuUXimPQsTYYDKzaDHzua9TT0wOe52GxWJBMJpFIJNha6HQ60dDQgOeeew5bt27FI488gh//+McZ60xDQwPuvPNOTJw4Eb/4xS9S3kskEnj00Uchk8nw0EMPDchELRqNYs+ePUxEQ6g2pVAoIJfLUVhYeEYVbpVKhYsuugjvv/8+fvzjH6fMwBgMBkydOhVbtmzBfffdl7H9lPiUlpbC6/UiFotBr9dj7NixTGYfyDx/g722SNadFLgoOeB5nvnQ5Epg6PeFXdmBwG63QyKR5BT+oLWvs7MTBQUFsFqtmDRpEubMmYN169bhv//7v3HXXXehrKwMIpEIt9xyC/72t7/h8ccfZ7M5A4VYLMayZcvwwx/+ELNmzQLHcfB4PMjLy4Ner0d3dzcKCgrAcRz8fj+0Wi2jO7a0tLAOrlqtZol4QUEBIpEIG7DX6XSw2WzQaDSMAm0ymVK8qGjdp5iBrBOEMzLDMszDGMYQ7cAI8dkMzJBJXnKhoKAAWq0WBQUFTAqXuPfC2YxoNIpIJIKKigpWyaEHs8lkQllZGUpKSlgVXiQSYePGjXj55ZexePFibN++nXUpNm7ciAULFqC9vR1r1qzB1Kmfz8vxPI8VK1ZALBbjzjsHJgYSiUTQ2NiIN998E88//zzeffddqFQq3HLLLViwYEFWZRMa1h0oTp06hZEjR2Z8F3kfCL+LgmOhQovJZILVakVVVRULJMrLy2G1WlMeAELn9KFQ7c4lR0uvUVJMAZ5Wq0VpaSnjTEejUfA8j4KCgqwJzGuvvYZEIoHbb7+9z+1Yu3YtrFbrGSUXhFgshnXr1mUkL0Avl3vGjBmYPHkywuEw/vznP+PNN988o+6cVCrF008/jbKyMixbtiynGIHJZMIrr7wCj8eD22+/PesMytVXX41Zs2bh73//OxobG5m8KVEMxWIxKwIIiwwU/Alltg0GA4qLi1FSUsIG+smviTjsJpOJmfX1ha+aypgNuTj1tJZlEymgdYtMDonHL6TUiUQiWK3WlFkjEv7o7u5mRR6LxcIS9lgshmAwiP379+Pdd9/FHXfcgYceeijj93t6enDLLbcAAP7yl79kbOPatWtRU1ODn//851k7N+kIBAL4+9//jk8//RShUAidnZ2oq6uDzWbDnj17sG3bNmzYsAGvvfYaWltbz+j4LliwAG63O+v1fPnll+PIkSOs+EUg2jEFuQUFBTCbzUyJjIpjwvMm9OAZDIRO8hKJhFEuxWIxlEolRo0ahfr6ejbHmA4Kus8ELS0tKCoqyukLRspfZrMZHo8HtbW1aGhowMUXX4x7770XIpEIzz77LBOTkUqleOKJJzBy5Ej88pe/xL59+86IUvftb38bZWVlOHDgANRqNZNKdjgczKPL5/OhqakJfr8fOp2OzcO63W5EIhHwPM9k/GldD4fD8Pv9aGlpQWdnJ6LRaMpaQx1c4PNiARU1gc99wITnfKDiG8MYxr8qhmwHZqihv0WQWs7RaJQtLnl5eVAoFGwmw+l0stctFgvjObvdbhYs0IOLEqC//vWvuP/++3HJJZfg6aefht/vh8fjwYMPPojVq1dj7Nix+J//+R9YrdYUfvLKlSvxySef4NJLL8Wnn36asq1NTU2ore21zyF6TGtrK+PtymQyWCwWmEwmaDQaNDY2orGxET09PRmqYyRo4Pf7+5yrqKqqQiKRQH19PWbOnJkiZapWq1lXikwGAbCW+okTJ+BwOMDzPGQyGVNvA8CoYyKRKMP4aChVu/u7fuLxONxuN/R6PdxuNwsONRoNeJ5HcXExlEolJkyYgK1bt8LlckGn06GjowM8z2PVqlW46KKLIJfLWYB18uTJlLkGu92ODz74ANdffz2rauZC+iBsIpHAoUOH4HK5UFxcjFAoxDj8QhQWFmL8+PFoaWlBbW0tTpw4gYqKChQVFUGr1eLgwYNZf89qtTIvmFtuuQUrV67E3Xffjauvvhrz58/HpEmTUv5eIpHgvvvuw29/+1v85Cc/wYsvvpgRuD388MNYuHAhNm3ahKlTp8Lr9UKlUiGRSEAqlTJ5WKPRCJfLxaRPVSoV/H4/gsEgjEYj68o4HA72GQBZDR6BM5cf/qLRn1RyOmh/KYmLRCIZBYdAIICmpiaUlpZCJpOB53mWCJJoifC7iFbmdDoRCAQY5YZ8X+LxOLxeL5OgffHFFzFy5Ej8+te/ZnSZxsZGSCQSxGIxPPDAAzhy5Aief/55AMCxY8dYENzZ2Yn//d//xYQJE1BSUoKampqcyTDQ28k5evQoEokEqqqqUiSViZIaj8cRi8XQ2NiIt956iymttbW1Zf1OtVqNmpoaAL3XSX5+Pl5++WV27VDXkPxf1q9fzzqnRB9TKBQoLi7GqFGjIJPJYDQakUgkcPr0aXbcibIkPHdnA0rAyUiX53l0d3czL5hYLIZPP/2UCcG0t7eza4NU/U6fPg2gt3OZa6A+EAigpqYGPp8PhYWFGXN7nZ2dSCaT7J4ViUQwGAzw+Xyora3FAw88gBEjRmDEiBE4cuQInnrqKUycOBHTp0+HWCzGzTffjGeffRb33nsvCgsLGW3N4/Fk3R6FQsH2/e6778by5cuxePFiTJs2DZdddhkWLVrERHTi8TiTYqcOjdvtZs+3/Px81lVPJBLQaDSMrkoWCXTPqNVqFBQUoLu7m1HLSBqZEhbqhgrXGjIcpWQy/b10nxkSD+rP3XworVvDGEZ/GE5gzhGEbXxqxWu1WojFYhYkKBSKDDUsGurV6/VsvsPj8SAQCKC5uRkPP/wwJk+ejJdffhkMkbvcAAAgAElEQVRyuRwOhwN33303PvjgA1x33XW4//77MwbifT4f3nvvPRQWFuKCCy7I4MTW1tYiPz8fdrsdNpsNsVgMUqkUhYWF6OnpgcViAcdxiMViKV4xsVgMFRUVKd9FlI/u7u4MKo8QY8eOZb81Y8aMFJ8RopLQb9BDnky/Tp8+jZ6eHnAch/b2dtTU1ECv12P06NFMbpSkh+n4k8JbNsO9rwL9PRjcbjc6OjqYkRztL8dxkMvl0Ol0kEqlTDq7oaEB06dPh0qlwo4dOxj1SvggS6c6rlu3DiKRCFdddRX27NnTZ2Wagi+gN3k5ePAgXC4XJk2aBJvNllN5y+VyoaCgAHK5HGVlZejq6sLp06fR2tqKiooKJvWc7XOkqldQUIBly5Zh9erVeOedd9DS0oLx48dndDe+8Y1voLGxEX/+85/x5z//OYMmOX36dCxevBirV6/GwoULodfrUV5ejpKSEkQiEUilUlYxlkql0Gg0yM/PZ/QyOg88z6OhoYGZqJrNZkb5GMwDfygFCX1ti3BNS/87mhtyu93smqPAK5lMsgIDBcHhcJgFXOS/QyIKpN5EQfMjjzyC9vZ2bNu2jQ1mC7f1kUcewfbt2/Hggw9i3rx57H2tVot4PI5Vq1ZBKpXihz/8Ift8LuPc9vZ2fPLJJ+w+o8FtAs0vEqjA0NDQgMLCQlx55ZU5jyFJDwPAwoULsXr1arjdblRVVbGO8+TJk2EwGHD48GEsWbKE/T0dN0q0KUkgvyKhB4mQ0jbYa4vnedbppjWUhGWi0Sh8Ph9b3x0OB+v2l5eXs+vEarUiGo1i5MiR4DgOJ06cyLnGULcCAMaPH8+OB+HQoUPsfZLZBsD8aMLhMI4dOwaRSASxWIx4PI5PPvkEYrEYkydPhkqlwiOPPIIDBw5gz549WL9+Pd555x1ceOGFWLBgASZMmJCSlJNnCwAsWbIEVVVVePPNN7Fhwwbs2LEDzzzzDC6++GLMmTMHU6ZMgVKpxJEjRxCNRlFRUYHq6moEg0FoNBokEgnodDrWNQ+FQuw9muGRSCRwOp2sIGIwGOByuZh9AInQCO9Bel2YVJORKflaZXvWpVM7hzGMfxV89ZHdvwiErd1s+vxqtRpWq5UlB8LP0RxJc3Mzk1qsq6vD/fffj4qKCvzlL3+BSqXCgQMHcPnll+PgwYNYvnw5fvnLX2YkL0CvaVsoFMLChQuzLmiRSARHjhxBbW0tlEolzj//fMycOROjRo2CXC4/o4eg0MirP1DFPptZIXlECL+H4ziUlJTA6/WiqKgIPp8P4XAYcrkcUqkUbrebVYlpISe5appb6Esp7qt0M0731DAYDLBarbBarcjLy0N5eXnKsW1paYFUKmWKRUIa2Zo1a1BYWIi5c+fm/L14PI7Nmzdj2rRpA6LUEBKJBPbv3w+n05lBG+sPUqkURUVFKCwsRDwex8mTJ/Hxxx8zL6C+IJfLceutt+Kaa67B4cOHcdddd2Wl7ixduhQzZ87EQw89hF27dmW8//DDD4Pnebz44otQKpWQy+VIJBJwOp3w+XxobGxkVVK5XM46BCqVCjqdjnUPkskkjEYjKisrmUrgUEiMv0gQ3S3bfhqNRowYMQKlpaUZnhSBQIDNaNjtdnR1dUEul7N5GKA3gG1paYHZbGa0s1AohH/+85/YtGkTli1bliEHn0gk8Mgjj+Ddd9/FvffeyyhkQqxbtw719fW46667UgwXs8Fms2HLli0seRnI+aRES6lUorOzEzt37hyQp9Ill1wClUqFd999N+V1juNw0UUX4aOPPkrphlEn3uv1wuPxoLu7G0qlEkVFRTCbzcjPz2eiJecCVNF3OBxwu93svyk50Gq1jHaaS+WQht4HqkbY1tYGrVabkbwQIpEIS1CEIMVAMpWMx+MsQa2pqWGKYQqFArNnz8by5cvxq1/9ChdeeCGOHz+Oxx9/HD/60Y9yioVwHIc5c+bgmWeewZEjR/CnP/0JU6dOxcaNG7Fs2TLcdttt7HyJxWKIRCJ0dnYiFosxiWsy/SR6OIn1aDQaVFZWspka6rBQch8Oh5mgC8m103MgmxUDzZP1JYP+RfgFDWMYQwH/2k/gc4hsJm7ZZCxzGb2lc2GFHHsylXQ4HPB4PDAajXjiiSeg1+uxZs0a5Ofno6amBtdeey0UCgX++c9/YuHChVm388SJE3jjjTcwderUrE7HLpcLdXV18Hq9qK6uxpQpU9hg4mBAFZ2BDPIfPXq0T6d2pVKZ8T06nY5V644cOYLDhw8zB3ry7dDr9TCZTKy9L5FIYDAY+tTG/6rVoEh1zm63o6enBxKJBBaLhQVDIpEIwWCQVVypk1FUVASZTMYSGIfDgT179mDx4sU5eeQAcPjwYXg8ngyVuv5w7NixQSUvBI7jmIKRwWDA8ePHB6wQxHEcFixYgB/84Afo6urC0qVLMyggIpEIjzzyCEaOHInbbrst4/opLS3FPffcg82bN6OlpQVerxfHjx9HfX09bDYbo4q1tbWhoaEBTqeTiVMIFceoEk/Up/T7W6hCeC7kbL8MUPeX1MaybW8unj1drzKZLMXDIn0Ohvj9zc3N8Pv9cDqdSCQS6OnpQUdHB6MbnT59Gnv37sVjjz2G8ePH48EHH8zYllWrVuGdd97BT37yE9x2220Z77e2tmL9+vWYN28epk+f3ue+t7W1YdeuXTCbzZBKpWeUjJI3i9Vqhc1my5o4p0OpVGLOnDnYv39/RrHnwgsvREdHRwodLZFIIJlMQqFQ4OTJk6irq4PL5WKzQx6Ph1GMzgU4joPJZILBYIBYLEY0GmXKfCTzT8+UbNRR2kcAKd5lucDzPKOJ2Wy2jKSHEhOZTJb12UTmxETFor9NJpN45plnMr6vuLgYV1xxBVauXIlly5bBaDTilVdeSek059qnq666CqtWrcKxY8fw+9//HiKRCPfddx8OHTqEoqIiSKVSeDweZo1A/22321NEZYRobm6GzWZjfjM+n48V8YjGSoUTINNMl9DV1cVo6fF4nMUe6X4+6YWI4fmZYfwrYDiBGSDSA056TVj5CAaDaGhoQENDA1vMKKghkGEhdV2oWkTDl16vl5l7PfzwwyzY37ZtGxKJBP7xj39g3LhxObeTFMpyqUwdO3YMyWQS06ZNQ0lJyVnTWYjj3J8yT0dHB95//33MnTs362+SIdiIESPYa1u3bsX+/ftx2WWXscCeOie0oAOfDzgqlUqWzEgkkj7NKrNJYX+ZUCgUbPibKpfCwXAATIoT6A2QiZJAs1YA2PB0f0HDQDw+0kFdwcrKykElL0KIxWKUlpYyxa4zwZgxY/D73/8ePp8P77//fsb7arUav/3tb+F2u7POYQmNUVtbWyESiRiVgySqe3p6IJPJ2KwRXWfRaBROp5NV6IXVUUIymURzczPa2trgcrmGpIx3NlAST92obNvbl0Q0XbN+vx+dnZ3suCiVSjZoXlBQAJ/Ph9bWVpw6dQrJZBJarRYVFRXgeZ5144qKinD69Gl0dnbi17/+dVbhgN27d2PSpEm46667su5PZ2cneJ7HZZdd1u++UyI8f/78QdMAad6rvr6+XxNQoHcNpE6fEHRcha97PB5YLBbo9XqUlpbCaDQiFovBbrcjFAqxLtC5AnXbIpEIS+bdbjcMBgMsFgtKSkrgdrtx/vnn55xjmzJlCmQyGV555ZUB/d75558PAPjggw+wbt26lHkZOif9FQGEPl8ikQhjx45FV1cX8xBLh1QqxYwZM3DPPfcAAHv+DgQ6nQ7f/e538Y9//ANTpkzBCy+8gNdffx0GgwGlpaUIBoPo7u6G3+9Hd3c3+5zf72fXttCcmBILpVLJim4UQwQCAfaco4REq9Uy0RyhPwzQW2BxOp3o6urKMM7OBqH8+TCG8XXFcAIzQCiVSlgsFlgslgwjO+GDRC6Xs8A0FAqhra0Nra2trDoSDAaZEy+1nWkRocCU/C1o3gHobduXl5ezbk029PT0YNOmTbj00kuzBqw8z+PEiRPnlHrQ0dHBVGL6wmuvvQaxWIzvfve7Wd/fvn07ALDgw+v1YtmyZRg9ejSWLVuGcDiMoqIiTJs2Deeffz5LmGpra5n08pno4AtVv74K0OwFBfP0wIlEImz2x2w2M+loGoQvLi5GNBpllAmVSoW5c+diy5YtOdWBAGDUqFGQSqU5PWSywWazQSQSsdmUswXNTQiT1IFizJgxKCsrw3vvvZf1faIb7d+/P+M9ujZlMhnKyspYoqvRaGAwGGA0GplEaywWg9PphNvtTlENkkgkUKvVbGhaLpenBPDRaJQpOH1dnLEpiTcajVm3N5FIMCpMNBrNMNWjRC0QCCAYDCIQCLCCjlKphE6ng0QiYfROnU7H6E8cx8FgMECtVrOk/dixY8jPz2feIELEYjHU1dVh4sSJOfeHZiYGkqxT0nCmyXQ6qqur2YxUX+jo6EBNTQ3mz5+fMY9TX1/PxCQAMNNDg8GASCQCg8GAsWPHsrkKSqwBnNMqek9PD1PHGjduHMaMGQOr1QqtVotAIIBEIgGLxQKbzZY18C8sLMSNN96Iffv24cMPP+z39yZMmIBrr70WCxcuBMdxKYphHMdBKpX2SzelfSeaWX5+PiZPnoxNmzalJBG5PpdrNqovFBQUYO3atfje976Hv/3tb7jvvvtQX1+PlpYWNDc3o7u7m4kwhEIhuFwuOJ1ONDU1oampCQ6HA0ajERdeeCHOO+88aLVadj8JaWcUWwSDQdZpAXrngIhyKfx/el4ASDHOHsYw/lXxb5fACNuyZwKRSMS47/Qgp6o//VutVkOv1zPTPIPBwFrcJ06cQHt7Ozo7O9HQ0ICDBw+ivb0diUQCkUgENpuNSefabDbIZLKUgfn6+vqMAfp0bNmyBcFgMKcPCPGbhYOxZ4NEIoGuri6YzeasEssEp9OJbdu24eqrr86ZgG3btg0VFRWoqqoC0Duo63A48NhjjzFJV41GA7PZzB5ywWAQXq83ZXE/l/gi52SEyW86PYCuLeGshcViQXl5OaN3CB+83/zmN+F2u7MG7wSZTIbq6uoBJzCkOFdaWjqo7k02uFwuiMXiQUk4cxyHefPm4fDhwynCEgS9Xo9Ro0bhwIEDGe/RQ50GzmOxGJqbm9HR0QG32426ujpotVpotVpIpVI4HA5Eo1Hm46DRaJjML5k+RiKRlE6LRCJhNEbg847qUAZV3cVicdbtdblcaGpqQjAYhEwmYzNmbrebdaWoKkxdK5qBoG6iXC6HXq9HdXU1SxrD4TDa29vZMDypIG7fvh1XX3111qCytrYWkUgE48ePz7k/VBTI1r1JB93TZ1vAKCgogF6vz+lQT9i6dSskEknW5KyhoQFVVVXs+NP1XV5eDrPZjKKiInauRo4ciREjRmQ1sjxbyOVyprCVn58PtVqNYDAIqVTKBAXImynXWrNo0SJUVlZi5cqVA5qF4TgOZrMZU6ZMQWdnZ8pxlEqlzCMoG4g6BqSex8WLFyMej+Ptt9/O+buUGA0mgQF619Mnn3wSTzzxBHbs2IFly5Yx4ZJIJJJiPJmfn4+Kigp2j6hUKjYfSP5UtP0mkwlVVVXsOSl8BhEdk6S1k8kkO0aRSAQajYbN2lD8Qd8rLDzQtU9KqOnvD2MYXxf826mQJRIJJlWYjr7kT5PJJDiOS1H0UCgUcDqdiMfjjNoj5K729PQwbXxaqGj4MxwOo6SkBCUlJbDZbPD5fBCLxazCNWrUKHg8HqZiVl9fj/Hjx7PK1+nTpzMW39dffx2FhYWQSqVZvUJITlkmkzHuebb9zFW5om0nUKVJLpcjGo1meBkQtm3bBolEkiGfTBCJRNi9eze++93vIhaLYfv27VizZg1uvPFGlJWVwW63w+v1pjxc8/PzIZfLYbPZmIwzcYhJQcrtdsNoNGZNrgYSXBLFBsjtFJ0OOvfp35/+GsnL8jzPlJhokJYc33meh9PpZF0Zn8+XYvoXi8WYJ4tKpcL69etTAjyXy5WiFlZeXo4tW7awKiBJ3WbDJ598Ap7nIZFIMszraHYiG5RKZdbrh+RYTSYTo8UJoVarUVdXl3N7tFotRowYgWQyibVr16YEgnK5HFarFRMnTsS2bdvgcrlSKCjkZt7c3Ayv15sifNHe3g6fz4dIJILq6mr4fD5Eo1H4/X42R1VVVcVUgIQmqcLfpyoqXS9CJSdhcHW2czGD+bxQRjU9YO9rzSsoKGABl0ajSZETFolEzKCPlJSCwSB6enrgdrtZFzEYDLJ5BaPRyIJOCrICgQA6Ojqwd+9eBAIBXHbZZVmld/fs2QOgN8DLJl3c3t7ORB7a2toyZqXSEwyiXDY0NPQZJFO3PBuMRiNOnjwJnU6HpqYm1NTUsOSpqKiIrYehUAg7d+7E+eefz4Ja4fbZbLYUiV9aIw0GA+RyOTweDxQKBTNJLSgoYIPiAFiRrC989n6f2Rq5zZP0/6lTp5BIJNh1EwqFMGLECMjlcuzatQuXXHIJu3eEWLJkCX7zm99gz549mDFjRtbfCofDKbRXg8EAvV6P/fv3M08mCqZDoVDKs47neaZgByBlLiSZTOL48eOorq7GBx98wIoQQO8gPd23dK04nU6cPn0aCoUi5zORPpsNV1xxBfLy8vDwww/j3nvvxfLlyzFhwgRIpVJmQgn0doaocEizmu3t7ZBKpcjLy4PZbIZCoQDHcSgoKIDL5WKznsFgkCmVtbe3w+PxgOd5mEwm5hGmUChYbEMJj1D+XBi3AGAqqaSEKnz/TIxahzGMrxL/dgkMDeieKUjSlpSyKDGJRqOIxWKQyWQsmSFXbmoHW61WOJ1ONvBHFfaysjLwPM/kQ/V6PVwuFxobGzF9+nRotVomtxgMBjFq1Ci2CMrl8pRFtaWlBXV1dbj11luh1+szujU8z2Pnzp0oKSnpk+5QVlaG6urqrO/5/X6MGjWK/XvHjh1QqVS4+OKLoVKpsGDBgozPNDc3Y+XKlbjxxhszvDwIBw8eRDgcxjXXXAORSIQHHngA5513Hq677jrmchwMBplTejKZhEwmg16vR1lZGRwOB3OQBnoXYLfbjfb2dgBgEs1nisH4yORKkHPp79MDh+Q3g8Eg8vPz2aA4KeyIRCK4XC5W1ZTL5ZBIJCgpKYFEIsEVV1yBHTt2sAQW6D1fwmvE7Xbj3XffBcdx0Ol0OR/K5G+g0+myqtz1xZvOz8/P2mFxOp1wOp2YO3cu85AQorOzs0+qmsVigdlsZr4eN954I3uPup8zZszAunXrUr6LqpQWi4XNcYhEIlRUVLDjFA6HWXAtFouRn5+PoqIiVhkVJq9isTjl33SeJRIJO/cUbOYKCEhalaTUha+jjyCTpHUH2tmh36EqbrZtSf9+YaIjlUpTBDfoPqC1TygZn5eXh7y8PBZIUoJOiV8y2Wv0R8IbarWacf7FYjE2bNgAk8mEefPmZe34HTt2DBqNBlOmTMm6/4WFhex6Hjt2bFaalhButxsikQgjRoxg/kPZkEgkch6znp4elJaWQiKRMGND6vbpdDomJPD2228jFovhBz/4AVtbaU3q6elBZ2cnxo0bx14jjy4qWtBMHDm0cxwHt9uNpqYm5hLfXyfhs/mm3G1yfL5G0XnkOI6ts+TdE4lEMGXKFBw6dAharRYXXXRRxvo4c+ZMNDY24tVXX8WiRYtYV12I0tLSjFnOGTNm4JFHHkEikUB5eTl4nsfp06chl8tRWlrKiiAkBGE0GjFmzJgURkFbWxtCoRCqqqpQX1+P/fv3Y9asWezY0fOLrtPy8nKMGjUKPp+vT7pVXwWsiy66CBs2bMBtt92Ghx9+GIsXL8ZNN90EnU4HpVIJsVgMn8+HeDyOwsJCdv4kEgnrfgJIka6mgqZer4fT6YTRaIRUKkVxcTHzeSH6pslkglgsZlQzKnAJFUWzSaIL1x86h8OUs2F8nfBvRyETiUQDCgBytVSpMkQPcKJWeDyeFAUskUjEgoZgMIhoNIq2tjZWXSwtLWVKWjqdDpWVlfD7/aitrUVTU1PK4k4JR7bAj7B161aIxeKsFAWgt+LodrtTEpCzAdFAKisr+zyea9euhUKhwHe+852cf7Nv3z4oFArMmTMHDzzwALq6unDHHXewYFA4p0B8/Gg0CrfbzQKnvLy8lHkkg8GAoqKiPmeG+sNg5mTOJEGmbk1eXh57mFBXjwwqNRoNZDIZM1+kbUkPWBYtWgSPx9OnIhLNDxw+fLjP7Tp8+DBLrM8VHA4H5HL5oOhjBI7jMGvWLBw7diyrId0FF1wAAPj4448z3rNYLEgmkyguLoZIJIJer2eJLs/z8Pv97H5UKBRMBvhMqBXpa0Mu6dJcCnj9BZmUIA0Uwg7iQGRU+6MkCSlnQr8l+m6aQSMBDbFYDI1GA7FYjNbWVnR2diIej7P1QqPRoKqqChKJBPv378e3vvWtnDMphw8fxtixY/tcayKRCOv29AdKZM8FiDpMBZN07Ny5M2dhiKr+wiCfuuylpaVQqVTw+XxsgJ/MkA0GAxPXGAgt+rM1qU+9Z7VajcLCQkZblclkrHCSSCTYvGZZWRlqamr6LGT8/Oc/h1arxZo1a/qczROioqICl19+Od577z3mg0VdPK/Xi/r6ejaPNn36dEyfPj0nHVoqlWLChAnweDwsIRTibClk6SgvL8fbb7+N2bNnY+3atdiwYQMTtSABFo/Hg08//RQOhwOJRIJ1u4DP7z2n08nELYg2FgqFkEgkmMIpnZfm5mbU19fD4XAwqh8VB8gHjSCcD6XjKvShAzBoz7SBdPeGMYwvAv+2F10ikWDO8+lIJpM5VTyEgYlIJILJZIJer4fBYIBOp2MKWBSQUms8Ly8PPp8PdXV1aGlpYfxy0nrv7u4Gz/OMHiE0emxsbASAnDMwiUQCO3bswLRp03KaSZJ2/7kayG5qagLP830mVU1NTfjoo49w9dVXp5jBpWP//v2YO3cu/H4//vKXv+A73/kOk+wkOda8vDxWqZLJZCyJEYlEsFqtGd4cRMfrazbni8BAE2Tgc88M+gwlYoFAgFXOXS4X7HY7jh8/DofDgebmZgCZD965c+dCq9XinXfeyfl7er0elZWVfUqHkohENrWkwSIWi6G7u5spfp0NZs+ejWQymZWDX11djfz8fEY3EsJisbD73el0MglTi8UCq9XKOjV0DVHiEgwGU4L6XAmNMBmlDkwuY7lcCnj9BZln2j2m3yE6VzY+vBDpEsi5gmKe52G329Hc3IympiYWLPl8vgz/Jeq+lJSUoKqqCsXFxQB6CwwmkwnBYBAbN25EKBTCt7/97ay/Fw6HUVtbm7ImZgNR2gZaoDqXAh5ms5lV2YXw+Xw4fPgw5syZk/VzR48eBdA70E4gahV15ome29zcjBMnTqCjo4OtezKZjKlS9YXPjkmfWU66l5nJZEJ5eTksFguzAGhpaWEUtmyKf4S8vDwsWrSIqU8OFIsXL4ZOp2NUZbVaDZ7nWXJYUlKCioqKARWmSkpKUF5enlV04FwnMEDvPr/00kuYP38+/vjHP2LHjh1srkev10MikTAZbCpwOhyOFOPlWCwGjuNQVFTEuj6xWAw2mw0dHR04deoUWlpaEI1G2UyZQqGAz+djRR2tVstMnYXy7tkgLKZQMnOmczAD6e4NYxhfBP5tExin04n29vasaipCl9v0qmW60lV61VH4UCSdfqEjvNVqRXl5ORQKBfNJIPqYwWBg1UMh7Yk42LmSE5I67WvA1efzsSD/XIDM6oRu0+mgYDsXD5pgt9sxduxYtLa2gud5XHzxxaiurkZ1dTUCgQDa29vhcrlYR8TtdiMajTIuPQ0XD7TSN1QgTIaFtCJSJHK73fB4PIxmQ54wADISM7lcjvPOO48d81woLi7uUzqUuoW56GWDAVUCz4V4RFlZGYDsXhMko9rS0pLxHvm35Ofnw2w2MxWxgoICKBQKOBwO1NfXM7VBomgAqd2LXF0KYTIaDocz/oaSBqKAZRua7y/IPJPkmL4v2+/QPgjXH/p+ogn11Ykh2mNnZyc6OzvhcrnYtZzuv0Q0WqlUisLCQqZmRsmY1+tlXQhyd09Hd3c34vF4v0qHRJ0ZCM6EijcQULKfrppFHZNchSO6joVUPTrudL1arVYUFxez42W321lyLeyAnUuQIhYZSVKgbLVaUVJSAgAp85DZcN5558FkMvW7JgmhUqkwe/ZsJshACoxWqxVVVVXQaDRndN6IyZDesT1XIg7pkMvl+NOf/gSNRoP6+npotVq0tLSgvb2ddU7IC47iAqKNeb1ehMNhyGQydHd3M7qwVCplMtGFhYUwGAwoLi5GQUEBixnS7z2KUVwuFzo6OnLK7AuLKYMVhRhId28Yw/gi8G83A0OgCk62So6QL3qmCxy1fQGwxKa1tRUlJSVQqVSQyWQwm81sjoMGWUmXnT6by7yrLwxV1aOBHEPhtnd3d8Pr9UKhUECr1UKhULDB0kAgwIb54/E4CxxpGDebSWaumYOhBPIXUavVsFgsLOgjwYJTp06lqMZkw0D2baju/0DR3/bnutboc3a7nUmc07GVSqVsEJ0EExKJRAp/nL5XuDYIIRzup+8S/s1QGpKl7SLBDuLR97ePBJVKhcLCQhiNRoTDYUaZFc4DEQ3GbrejoKCAJTQSiQQejwcajQZ+vx9SqZRVwb+u6xtw9tue7X1KeqkSP2rUKLhcLphMJgBg8zG5BCMGA5qDEg7Qk1Q4sQXo9weCwWxPehFQqVQOOkH7KmTy5XI5pFIpKzqRcfSYMWNYkbOxsZH5YiWTSTQ1NaGtrQ3FxcVobW1Fe3s79Ho9FAoFu0cMBgMzME0kEjCZTBnnne49IFWOOxcdmIocwP9v78zD9KqqfP3+KpUKCRmBJMwhDKIyKPOMSjsgII2oICCIoNCCF1qltQH7aqs4tDMo4gQ4IjigNA4oToCKiogMFwMRH0hJFy8AAB3jSURBVAQR09IQMlQVSWrdP9Y+X52UNabO9FWt93nOU2eqb//OPvusPa2998jf/VCMpncvCMpg0lZgMhejwcgy4ywDyQ98y1xQhprdKiuIzpw5k4ULF3L//fdz11130dvby+LFi+nr62utBwNuLJYvX84TTzzB448/3mp5msxsuummrQHtXV1dbL/99qxZs2a9hUEXLFjQaqHKWpyyXq38+4L1xwLUXXjMky/U5gdIP/bYY6xdu5Zp06Yxf/781orO3d3dw/Z4BSNz1113sWDBAh599FGeeOIJFi9eTEdHB4sWLWoNXF+2bBlz585l9erVremt84XEfBrKD3zP/PWzGX4yV7RsNkJoxiDZvH3LnjGb4SrTO23aNLq7uwet9GfujkMVulesWMHy5ctZunQp3d3dLFq0iDlz5mBmLF26lGXLlrUq6FOmTCnUjWeisXTpUubOndtarydzDeru7m5VkousHGe9+R0dHSxYsIDp06fT09PDjBkzWj1cTV+gtSn09PSwbt06tttuO3bYYYeW10B+kP306dN5+OGHeeyxx1ixYgVz5syht7eXnp4e5s6dS1dXV6uXNF95zE+08eCDD7LVVlutN+FKX18f9913H4888gg77rjjqHom85WZPJlNaHIDYDA5mbQVmKHIV1AyVxDoL2Bmrmcw+OxW+ZmrOjo6Wq2PmQGZNWsWq1atYsmSJUC/7/S8efOYPXt2VGDwqVIXLlzYMtxr1qxpDUzMClyzZs1qjTUCH9uTn8Y2P1ZgQ2YTq4KBM8NkBeC1a9fS1dXF/PnzkdQqTGdjSYINZ8stt2TevHmtdUi6urpYvHhxy+Vi2bJlPProo6xevbrVQzpcIXHg+YGtmAOvj3ca5SLp6Oho2bmBevNT046lUNzd3c2DDz7I/fffz5o1a1p2LSv0zp49m97e3taaI9tss02h7ooTidmzZ7fWI9pss81a7oA9PT3rVZI3tOV8MKZPn97q5e7o6Gi5Cff09LTGag41rXSwPtlUx3vuuSczZsxgyZIlrZ6YbFbF3t7eVkU+m4q8q6urNaY2+zYy99TsOKtI/OUvf2m5YObHo3Z3dzNr1iy23HLLlsvfSPT19Q3aONuk3uMgyKMmZahVIOl/gAeBzYDBBgN0AlOBNcBafJzQwO7RznRttHQCWdPFuvR7WbNjH9CV+73Ml1T4wLg5wP8kHVNy/z8tp6M3XcvCmTbgvl7A0nF2Xblz2bylK3PP/1S6vib3e2uB6el/s3BJ928CPJqur0v3rEtbZ/o7Jf1uV/rtLE7y8btmwPFg8T/YudFcG+qdj4VFZjakD0VKX6vGGc5Qz5D5Q/Sl/WyUfS8e/3+nP03kfScMf8f5dzEDfxek+7P30pn216Z7snSSNe9l6QpgNvAE/l4thdlFfxruTufJ/U8WfpaGOtK2Nl2bknv+vnSspGka/d9Dlm7X0v+9ZmlWud/Px11H7jezc2v5R//tfBz20Z9uhnsvw7lQjHQ9z5DpK2e7yibT20F/uhrr/2fv8Sn8XfTlrmW/TdrvxO1GX25bk7u2CbCc/neVpZPsN7vwb6Arhbcx/emuh367qRTumhRe3i5OA2am/XXpWmdO73zgsQHXptKfNrN01ZN7ng78+8jSafadTKHfZufTX/ZcmZ3Mvol8Oh4pLQ7HWNLWwN/vSM+b/zY7098sHxD9diaLl8ymZHlBR7qW5XnC4yzLH7qAWfj7njrI/SvxuM3yn2lp686Fm9m2TF8nHu+96fcyezgVt9Wr0/ns/rytmgLMA5bRn+b6WP/dDIyrLI/tZf20PzX9T+8gcWv027HB8sWBtihPlu4HMtY0MrDsM5rfyvSsl7YknQGckQ53BpaMQUcRFJHXR5j1hwfD2a3JVoHJkHSbmQ0+arRBhM7iqEpjHXERYU6sMJtCE549NDRPR5k07RmbpKdJWqB5ejImSz5RdZhNe9+TdhayIAiCIAiCIAjaj6jABEEQBEEQBEHQNkzmCsyn6xYwSkJncVSlsY64iDAnVphNoQnPHhr6aYqOMmnaMzZJT5O0QPP0ZEyWfKLqMBv1viftGJggCIIgCIIgCNqPydwDEwRBEARBEARBmxEVmCAoGU2S1b8my3MGQV1Mxm9sMj7zaIm4mdxM9vcfFZgBSNpO0py6dYwFSY19j5IWStpo5DubQ1HxKWkWgFXopylpP0nbVBVeCnML8OesyqBKmjLyXUFQDJKmjXxXJbRV3jQe6rCfw1GHbR2KOmzuaGlyeWQCMmnswWBEQssh6QjgUnwhrcYi6UhJl0r6v5L2M7OxLmhWCZKOBD6BLxDXWMqIT0lHAZ+TdLWkrdO5UjMaSS8GvgUszgr4FYR5KHCjpLOgmgw1PeeHJH1e0pbpXNlhHiXpPZIukbSZpKkj/1d7I2kPSXtJ2rNGDc+X9Nw6K6ySDgNeK6lrxJvL1fEi4LOSFtSpowrqsJ8j6Knctg6jpXKbO4KeF0p6u6SLk56+OisxknaVtLOkZ1QYZuV2qg57IOlASS+X9IKqwhyOqMAkUuXlvcC7zOzhAdcaE0+S9gc+DPwaeBK4XtJL6lX1jySDfxHwUTP7+4BrjWkxKiM+JR0C/BdwCb7S8/ugvJZEOQuBtwMnm9lN+KrKUP43vgL4X2AnSW+CcltMU7r6IHADvvL2FZI6Sw5zL+Ay4FZ8lfePA0e2W0/tWJB0OPAl4BXAFyXtV4OGqbhNvgjYV1LnCP9ShobDgY8Cd5rZYKudV6XjOcCngM+Y2bK6dFRB1fZzBC112tahqNTmDkcqN30IWIJX7m5OemppVE16rgLeDFyevt+yw6zcTtVhDyS9ELgS2AX4eqpI10rlGUITSQWRs4B7zeyX6fjVgIBbzexXkjoa0tOxFfALM7sSQNIDwPslmZldr7RTp8DUKv7vwI/M7BZJ84CXAL3APWZ2dxN0JsqIz8OAb5nZzZL+CrxT0tuA64EHzOzJIh8gtcCtwuP2Rrl7wQclrQbul/QtM7uvqPCyOEmtTavxDPV2YH9JpwK3AKvN7JEiwwRmA6cBF5rZ94DvSfom8DLg6qLCGoSdgR+Y2XXAdZLOBI4E1kn6HrCuIWm5ECTtjRdKXm9mN0laB/RJ2tTMHqtQylq80rg7cCFecf1pVbZD0u54Yeh16VveFM8TZpnZn8oOfwA7A+83sxskbQ5sD3SmAvVE43lUaD+HI9m5lVRkW0ci2cFKbO4otMzHy03nmdkNwFclfUPSQWb286p05PTsjTdGvhpvkDwZeLGkG/AZd8sqv9Vhpyq1B+ldvxP4VzP7bipvdEjayczuLyPM0dCYnoW6kLS5mS0HLgb+KOljwI+BxcDmwPclHdKQygvAA4Cp3wf2OuB8vLVh74YUpP6OFyhXS3oz8EPgYOBQ4MuS9miITignPm8D9pB0PnAz8CAwHzgX2AOK64VSv2/+arwF7HzgA8DP8HjfCHiVpGkF9nzNATCzdWa2BPgFnmFchVcmbsCft8jetvnpO30v/k1mjS9/wb/TMrkV2FLSgQBm9im88HAysHGD0nJRbAycliovWwBnA/8HuDYVliohxet3gf8EvgG8UdI5wL+qGleNjYBrgM1T4ejLeMXuhirjIfEUsJekxXicvBLvGTuvYh1V8Fv8WS+gZPs5SrqpzrYOizlV2dyRWIV/DzdKmprCNWDHisIfyGbARWb2q2Q7HsArFaU2Ptdkp6q2B08AvwGekrQrcAFwOvAzJVfGOpjUFRhJzweukrQTXmm5BdgB+KKZvdHMzgfeBRxRo0wk7ZS2LuBOYApwvqSOVMv/Nm5YD6pZ59Mk7YK3SHwS+CNuXK8wszPM7GzgOuDAGmUiaXtJO0qaDtwFTAPeMp74VPKBTYe3AZfjBcEfm9n5ZnYu8BDeOlRIl7/6ffNnJAN9Ad4ys4mZfdrMrsEzuu3MrLegMFt+t+p3rdweWIiny71xd4KssF9EmIcDf5b0XDO73cx6zGxtunwv7kqWjVPZbbzhpd/KfH1faGYP4IWqgyU9HcDMPolnIv9WRHhNwsx+lnqdpwInAm8xs1Pwiv37i4rj0coB3mBmV+CV1Y8AM8xsXekBm/0a+AJeILsRt12n472A7062rip+gxekT8Lzp3PwfOlMuVtlWyPp2ZKeIWlHM/sO8DlKtp8j6GmNg63Ktg6jZbAxHTtQos0dQc+ecrfaxWb2k9SQtSaFewdesUHSi1KvZSWY2ffx7zTjDqA7sxWpp6K04KnWTlVqD8xsDbASOAFv1PmYmZ0MHI3bwoOLDnM0TNoKjNyf7+PA1sBzU4Hoh8CbzeyjuVun424DtSDpGNwX/SK8hv9y4HXA03Df7EXp1o2AbevQCCDppXjCvjhtp5m7ZZ1pZp/I3TqNGidJkI9vuQrPIN+Lx9m/AHviXb9jjk/lfGAlHWhmfzOzr+Hpa0WuoHMfsFYFDAbW+r75q9PpJcBPgN1TzxfAPGC+ChivoQF+t7lWrcuB1+Dp9I248d5R0iYFhHk48G7gWty/eIrWH5PWCXRJOg6Pj1UFhJn39f2apGfjaXtH4JgUD+AtoKsH/ZEJQMq0LjezT8tdaH8OfBuvuJVKrhX5RuD3kg4A/gn/bg/LesNKDL8DID3z1cDpZnYp7i54C/B93CW2EszsHrwV9GhgC0kz07mv43lU25IKXP+N9/R9S9JJqYJwCbBS0jPTrYXZzxH0HAN8PjViZOkws627lmFbh9EycExH1pj6WdzmfpGCbe4Ieg5PYb4CuEZpbFwunqYC05I9voyK8vosfDP7a+50J7B1yjNOxSeFmFFkD1VddqpKe5CzhecDr8cbp7OxTrfh+X49w1HMbNJtwFHAPXiLyi54T8Eeg9x3It6a/oyadG6GJ5RnAjOAVwG/w1uhunAjdgXebXkPsGtNOmfgPViH4K1mL8aN7gUD7jseb8l+Wk06D8Vb7HfFW68uAf49XZuNG+bPjTU+8QruJbhrwXfwCjEpjE/ghvwy4G5gtwKeY3fgceDl6XhT3H1gq3T8T3hv4hXAH4pKF8AZ+LgIcLetA9O2Y4qzw9O1jYHZBYT3HLwVbX9gL+BXwGbp2pT09xTg4RT3zywgzPm4y9gR6fjfcJ/8zYAt8cG8PwG+Cvy5iPdZ95bs4AF44SOL1ymD3HdcsodbVaRB6e93gT7gJen4bGDbKjTkrnXl9jM7Vng8jELHfwCfwXsEzgH+BOxQdxrawOcUPkPld4Gj07kDgKV4QWkKXlj6TJH2cwRNOwH3Az/FGw33z6XDjZMt+FnRtnUILXunMPZLcXUK3vIN8Czgm0Xb3FHouQc4NB1fBOwDbJq75614RfPmIuzxCHoGsxkduevT8JnjLkg2fZeSwizVTtVhD0Z4znNwd9qn4T3S/w/vjSvtXQ+ps45A697wCsDz0v5U3F3opHScvaxD8cJoLZWCpGErvJV383S8OfAVvJZ9JF7rfTredVhLAkq6pidNe+WO98ErBP+Szr0YL1SP24iMQ+cxwLm54wPSO56djqelj/KoscZner7D8Faxb+P+2qfiPtsvA94G7FTQc+yL94S8Ac9Uvo+7utyHz5RDShuLgAUFxt+peKV5MT4G5BK8EP9afCxI6/spKLxXA/vmjq9Iz9mZO7cfnqkWklkme3AJ8Hy8ovu/eAvTX3NxuzU+KUXhheiqN+BYvJD0oxS35+S+h470d2PgTOD3ZXy/w2lI12dmtqWmeMgy7k68EHlnWXZspLhI9xyG98J/hJoa1wp+5nfijXNT0/E+eEHsn/HGmULt5whatsXHa87Fe+Q/gucTeZszJdnAwmzrEFoOz2xOOj4Yr1h1puO5Wbqs6D09B9gv7W+B9wB8AbgJeE06fzTeSFhquhyN3Ur7v8QL2OPWU4edqsMejDLMr+D58S2UXFEdVmtdATdhoz+Dfj3esphvZZtKrmWhRo3vw2df2Qt3U/oUXrB7RwO0Tc3tvwmvbG2djmcALwU+ko43AraoSWf+vWZGbire+/YT+jPOTcYRxuHAN9P+pXhLzNtKfKaDcJepJ/CZYDrxHrCHgWeVFOYueOH+bcAb07nd8BbLI0t81izD3hPvIds2HQt34yj0O03f2edSxvf2dG4fvDJzSFnPWfWWvoGrgYPS8cvwxpx3A3MG3HsCJRQgx6IhXe+oU0OyaTvW/T7S9UoKrhWkw7PwwlC+MHgI3su1dQ16ZmZ/yVVi0rlKGy3yeSb9vVUdA69VrGkq7tJ2Rjo+CPgb7imyTdm6xvi9XgA8vcow0/Vx26k67MEY47YDn5Gx8jSYbZNmDIykI+QLFb5P0iaSpljy4TcfkHs/cKES5oPSqpwydKDO9yd/1o/irQhvwlt8zsRnHNlfUm0LREo6GrhY0hfTGI8rga8BH5G0tfm4jB8Bz04DM3tsff/UqnV+PunshJZ//6P41JNrJJ2MT4wwY4y/P5QP7GdJPrAF+9wO55t/M94bM+5xIINhg/vd3oW/98JXKs/5NecH7G+FF3gw5/GivtMRfH1/g/fE1LagYknMxt1mwMcZXY+7p54ArdXHn2FmV1l502WOpGHvNA4JK282oZE07Jvi4VozW1qShtHo2Ef9C4uWPpFBmeS+70vxBq/LJM2RNDXZsjupwbfezFamMsBKfBKfdcCLJH0Y+IGkWUXa9MEYbkxHunwqPplKoWM6RoMNPTauz8weqiifH43depqZvcfM/lBRmGXYqTrswWji9tlm1mdmKwoKc4OYFBUY+cJYH8JnDenCu8WOHFABuArvFp5iqXpZNYPovBJ3obnIzE7CXXUAXoC38NeSgcmn0fskXnD9K+7KdArevf1rfK2MA/Ha+0x8gcg6dV6DtxCdDZyitHo7Pgh3laS3A+cBV1r/gPihfnNnSQfIp42cYuarIKdC9n7Az/F58c/Ax4U8PN70lA+T3IQSZvZLfPArScfxuMta93jCGximclNBmtl/pDDnAefIp4s8AXcvKjTMLG7TtQ4z68an832+pH3HG97AMElxm97nU+n4dPnseqfjbmUPFhFuE0gFkQ8Dx6p/qvhb8HFHh8pn6TsQr7TWqeEQvLGhTg0HUWI8jEHHwcAj6f5a8qnxMOB7a5U/zOz4dPxR4DRJZ+Nu3GsH/6Xi9WR2Ln3/lmzOcjM7D3gRnp8db2Yryoj7weJG609Y0o1PDfxWfOKZt5jZ6rLSwRBxMwXAzB5Pf/vkA/b3xNemKZ0x2K3C9NRhp+qwB2OI29Ls8Zios/unqg0f6PTO3PE1eIv5C3PnNsN9ORc2TOePgRek4yn4GIvbKclNaJQ6DwOuyh0fDbwf95Wcmf5egY8veXaDdB6FuwScg/tWz8ELpPcwiokFaJgPLCX55o/0nLm4rcTvln6XiY703t6FrwtTxXM2wte3rA137XwD8GnS4Nx0/qdUNDg8NDRPR0nPNprv7TTcRfVrRdiyDdXD+uModsMLbKVNIDAGLYWN6RivHkoeGzeCvsq/kwizeTaonqnPqucPwEGSdjF3g7kXeAZwlqSfmc/j/ndJz7MK1hfYAJ1nS7rJzHolLQWOs3LdGEbit/jqyC81d6m4LrWUH4VPOHBxaqnpMK/RN0Xn9alF6yhgnpktlfQp4Ds2wmrKqVXseNxl6+eSXobPUPMWSR8wb6lbmcLMegzG1Y08mjDBXawkrQCOHW+6GEOYPwZ+LKnT+l28yg6zD3hM0nvMe2OqCPPElGY2tpq7y8vAzHokfRlfx+B8+To3vfhsbCtDQ3UamqSjaMbwvV2e7p9mZqVNUz1aPYk/A3taSavcj1HLf+NjLYtyi9pgPWa2StKT+GyYla7GXsd3EmE2zwZNWBcy9S+MtQP9q+b+p6Rr8SmTj8O7GE/I/Vtpq7UWoPNEADO7uY7Ki3ILe+EuYZ8HDlRaE8N88cdufKwOlha3aqDO64CenM73mNlo3Z+a6ANbhm9+E/1u82H2VBRmY3x9y8TcHeQzwH/hPWvPA15lZn8LDdVqaJKOEhiNLcu+8dLXGhqFnn0kPSs1TpVSeRmDljLGdIxXT9lj44alju8kwmyYDaq7C6iMDZ/S9iF8IcG78Zlj5uLjA14CbJTuezfeah06h9d5DD7n/IH0uy3tAFyIz1BxXDp3Ou6iVfhMQSXo/BBjnPIXH3t0HWkmKtyl70TczWg6vqDY5gU/02jCLHTWlwY/Z9uH2fQtxUEt329oaK6Ogp6lUd9bk/TUYefbSc8o9Fb+nUSY9W+1Cyg4ogdbGOtAfKHKMwbcezY+MKn0ueXbVWcKf+DCXgfQ7wO7Pb42yK/wAesPAbtPVJ1MEn/UCLN5vr6xxdbuW9O+tybpaZKWJuqJLbbBtgk1BsbMDFgp6TZgtnw6xl9IeiVwjaSnzOxKSVvgLQynWg3dn+2iM9GLTxxwNz648jgASb8xsweAByR9HV/0789Wfld7bTptkvijRpjN8/UNgnanad9bk/Q0SUsT9QTBYGRuNhMKSWfhC8+da2ZPpnMH41M0vsLM/lT2IMEJpnOm+dz4M4F34F2KX0uVrm3M7KE69WVUpVNSFz6t6pn4eIyPmdnvivjtCHNyhBkEk5WmfW9N0tMkLU3UEwR5JlQFRvL529P+1fgA49fTv1jh5cC7zOxPoXNsZJolzcGne16JD/Q7Aq+ErbQGJKYqdcpnWjMrb3G9CHOChxkEk5WmfW9N0tMkLdA8PUEAE6ACI2lnYBPgNnwl2HW5a1/FZ8a6FV8r403Ac8zs4dA5ep25SkFramBJvwS2xMfwjHsRw4mqMwiCIAiCICiWth4DI+lY4D3AX9J2m6QrM3csM3ulpNPwAuyz8EJsHZWCttc5oFKwG7AYX2DzrtAZBEEQBEEQVEXb9sDIF1v6EnCxrb/YUi8wcPGn0hfGmkw6k3vWxnUM2G8XnUEQBEEQBEE5tPtClk1bGGsoJorOKhf2Go520RkEQRAEQRAUTNtWYMxXef8wcKykQ5Lb0C34mimHSpqOz57xSLq/lq6mCabzYKDWlVjbRWcQBEEQBEFQDm3rQgYgaSPgtcDuwJfM7KZ0/qfA6Wb2xxrltQidxdIuOoMgCIIgCILiaetB/O2y2FLoLJZ20RkEQRAEQRAUT1v3wGS0y2JLobNY2kVnEARBEARBUBwTogKT0S6LLYXOYmkXnUEQBEEQBMH4mVAVmCAIgiAIgiAIJjZtOwtZEARBEARBEASTj6jABEEQBEEQBEHQNkQFJgiCIAiCIAiCtiEqMEEQBEEQBEEQtA1RgQmCIAiCIAiCoG2ICkwAgKTtJN1dt45gYiEpFhYNSiVsV1A2kl4h6R5JfZL2rltPMHGQ9AFJf5B0p6RrJc2tW1O7EBWYIAhKQZIIGxMEQftzN3AscFPdQoIJxw+BXc1sd+A+4Pya9bQNUbgI/gFJ20v6naR96tYStBepNfxeSZcCtwPTJV0k6feSbpW0MN23SNKPUqvTjyRtW6/yoM3plPT5lJ6+LmlG3YKC9kTShZKWSLpR0lWSzjOze81sSd3agvZmiLT1AzNbm265Fdi6To3tRFRggvWQtDPwDeA1ZvabuvUEbcnOwBfMbI90fKuZPQtvvXxdOvfxdM/uwJeBi6uXGUwgdgY+ndLTk8BZNesJ2hBJewGvBPbAe1yiES8ohFGmrdOA71Wpq52JCkyQZz7wbeBVZnZH3WKCtuVBM7s17T8FXJ/2fwtsl/YPAL6S9r8IHFyZumAi8pCZ/Tztf4lIT8GGcQhwrZmtNrMngevqFhRMGIZNW5IuBNbiDXrBKIgKTJBnOfAQcFDdQoK2ZlVuf42ZWdpfB3QO8T82xPkgGA0D00+kp2BDibQTlMWgaUvSq4GjgJNy+WUwAlGBCfI8BRwDnCLpxLrFBBOaX+Dd6QAnAbfUqCVof7aVdEDaP4FIT8GGcRPwUknTJc0CXlK3oGDCMGjaknQ48FbgaDNbXafAdiMqMMF6mNkqvCXgjZL+uW49wYTlHOA1ku4ETgbOrVlP0N7cC7w6padNgE/WrCdoQ8zsduBq4A58LOjNAJJeKulh3PX1O5JuqE9l0I4Mlbbw8aCzgB9KukPSZTVJbDsUvVVBEARBEATrI+kdwEoz+2DdWoKJRaSt8RM9MEEQBEEQBEEQtA3RAxMEQRAEQRAEQdsQPTBBEARBEARBELQNUYEJgiAIgiAIgqBtiApMEARBEARBEARtQ1RggiAIgiAIgiBoG6ICEwRBEARBEARB2xAVmCAIgiAIgiAI2ob/D2qnD89/kTUMAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "corner(df[['k', 'rho', 'b', 'q1', 'q2']]);" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Calculating the parameter estimates for all the filters" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ok, now, let's do the parameter estimation for all the filters. We wouldn't be doing separate per-filter parameter estimation in real life, since it's much better use of the data to do a simultaneous joint modelling of all the data together (this is something that will be shown in a later tutorial). This will take some time..." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Optimisation: 100%|██████████| 200/200 [00:02<00:00, 87.28it/s]\n", "MCMC sampling: 100%|██████████| 1000/1000 [00:11<00:00, 89.11it/s]\n", "MCMC sampling: 100%|██████████| 1500/1500 [00:16<00:00, 91.86it/s]\n", "Optimisation: 100%|██████████| 200/200 [00:02<00:00, 87.13it/s]\n", "MCMC sampling: 100%|██████████| 1000/1000 [00:11<00:00, 86.85it/s]\n", "MCMC sampling: 100%|██████████| 1500/1500 [00:18<00:00, 80.95it/s]\n", "Optimisation: 100%|██████████| 200/200 [00:02<00:00, 83.37it/s]\n", "MCMC sampling: 100%|██████████| 1000/1000 [00:11<00:00, 88.44it/s]\n", "MCMC sampling: 100%|██████████| 1500/1500 [00:16<00:00, 92.95it/s]\n", "Optimisation: 100%|██████████| 200/200 [00:02<00:00, 88.20it/s]\n", "MCMC sampling: 100%|██████████| 1000/1000 [00:11<00:00, 87.33it/s]\n", "MCMC sampling: 100%|██████████| 1500/1500 [00:16<00:00, 90.66it/s]\n", "Optimisation: 100%|██████████| 200/200 [00:02<00:00, 91.09it/s]\n", "MCMC sampling: 100%|██████████| 1000/1000 [00:10<00:00, 94.95it/s]\n", "MCMC sampling: 100%|██████████| 1500/1500 [00:15<00:00, 98.03it/s]\n", "Optimisation: 100%|██████████| 200/200 [00:02<00:00, 89.07it/s]\n", "MCMC sampling: 100%|██████████| 1000/1000 [00:10<00:00, 94.65it/s]\n", "MCMC sampling: 100%|██████████| 1500/1500 [00:15<00:00, 97.55it/s]\n", "Optimisation: 100%|██████████| 200/200 [00:02<00:00, 91.29it/s]\n", "MCMC sampling: 100%|██████████| 1000/1000 [00:10<00:00, 91.93it/s]\n", "MCMC sampling: 100%|██████████| 1500/1500 [00:15<00:00, 96.43it/s]\n", "Optimisation: 100%|██████████| 200/200 [00:02<00:00, 86.03it/s]\n", "MCMC sampling: 100%|██████████| 1000/1000 [00:10<00:00, 95.92it/s]\n", "MCMC sampling: 100%|██████████| 1500/1500 [00:15<00:00, 95.03it/s]\n" ] } ], "source": [ "chains = []\n", "npop, de_iter, mc_iter, mc_burn, thin = 100, 200, 1500, 1000, 10\n", "for flux in fluxes:\n", " lpf = LPFunction(time, flux)\n", " lpf.optimize(de_iter, npop)\n", " lpf.sample(mc_burn, thin=thin)\n", " lpf.sample(mc_iter, thin=thin, reset=True)\n", " chains.append(lpf.sampler.chain.reshape([-1,lpf.sampler.chain.shape[-1]]))\n", "chains = array(chains)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "ids = [list(repeat(filter_names,chains.shape[1])),8*list(range(chains.shape[1]))]\n", "dft = pd.DataFrame(data = concatenate([chains[i,:,:] for i in range(chains.shape[0])]), \n", " index=ids, columns=lpf.ps.names)\n", "dft['es'] *= 1e6\n", "dft['k'] = sqrt(dft.k2)\n", "dft['u'] = 2*sqrt(dft.q1)*dft.q2\n", "dft['v'] = sqrt(dft.q1)*(1-2*dft.q2)\n", "dft = dft.drop('k2', axis=1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The dataframe creation can probably be done in a nicer way, but we don't need to bother with that. The results are now in a multi-index dataframe, from where we can easily get the per-filter point estimates. " ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
tcprrhobq1q2esblkuv
count15000.00001.5000e+0415000.00001.5000e+0415000.000015000.000015000.00001.5000e+0415000.000015000.000015000.0000
mean1.00032.5000e+001.75423.8867e-010.67230.5880752.41359.9996e-010.09770.9222-0.1105
std0.00029.8327e-080.28001.5103e-010.18560.152330.61145.7900e-050.00330.11640.2117
min0.99962.5000e+000.97641.2905e-050.24880.1694651.36619.9974e-010.08960.3356-0.6162
25%1.00022.5000e+001.53763.0082e-010.51990.4725731.85969.9992e-010.09500.8448-0.2644
50%1.00032.5000e+001.72244.3035e-010.67260.5549751.44909.9996e-010.09780.9226-0.0911
75%1.00042.5000e+001.97515.0224e-010.83060.6828772.70791.0000e+000.10010.99940.0503
max1.00092.5000e+002.47496.7992e-010.99990.9997885.30341.0002e+000.10771.26500.6549
\n", "
" ], "text/plain": [ " tc pr rho b q1 q2 \\\n", "count 15000.0000 1.5000e+04 15000.0000 1.5000e+04 15000.0000 15000.0000 \n", "mean 1.0003 2.5000e+00 1.7542 3.8867e-01 0.6723 0.5880 \n", "std 0.0002 9.8327e-08 0.2800 1.5103e-01 0.1856 0.1523 \n", "min 0.9996 2.5000e+00 0.9764 1.2905e-05 0.2488 0.1694 \n", "25% 1.0002 2.5000e+00 1.5376 3.0082e-01 0.5199 0.4725 \n", "50% 1.0003 2.5000e+00 1.7224 4.3035e-01 0.6726 0.5549 \n", "75% 1.0004 2.5000e+00 1.9751 5.0224e-01 0.8306 0.6828 \n", "max 1.0009 2.5000e+00 2.4749 6.7992e-01 0.9999 0.9997 \n", "\n", " es bl k u v \n", "count 15000.0000 1.5000e+04 15000.0000 15000.0000 15000.0000 \n", "mean 752.4135 9.9996e-01 0.0977 0.9222 -0.1105 \n", "std 30.6114 5.7900e-05 0.0033 0.1164 0.2117 \n", "min 651.3661 9.9974e-01 0.0896 0.3356 -0.6162 \n", "25% 731.8596 9.9992e-01 0.0950 0.8448 -0.2644 \n", "50% 751.4490 9.9996e-01 0.0978 0.9226 -0.0911 \n", "75% 772.7079 1.0000e+00 0.1001 0.9994 0.0503 \n", "max 885.3034 1.0002e+00 0.1077 1.2650 0.6549 " ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "dft.loc['u'].describe()" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "scrolled": false }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "with sb.axes_style('white'):\n", " fig, axs = subplots(2,3, figsize=(13,6), sharex=True)\n", " pars = 'tc rho u b k v'.split()\n", " for i,p in enumerate(pars):\n", " sb.violinplot(data=dft[p].unstack().T, inner='quartile', scale='width', \n", " ax=axs.flat[i], order=filter_names)\n", " axs.flat[i].text(0.95,0.9, p, transform=axs.flat[i].transAxes, ha='right')\n", " fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As it is, the posterior distributions for different filters agree well with each other. However, the uncertainty in the radius ratio estimate decreases towards redder wavelengths. This is due to the reduced limb darkening, which allows us to estimate the true geometric radius ratio more accurately.\n", "\n", "Finally, let's print the parameter estimates for each filter. We'll print the posterior medians with uncertainty estimates based on the central 68% posterior intervals. This matches the posterior mean and its 1-$\\sigma$ uncertainty if the posterior is normal (which isn't really the case for many of the posteriors here). In real life, you'd want to report separate + and - uncertainties for the asymmetric posteriors, etc." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "def ms(df,p,f):\n", " p = array(percentile(df[p][f], [50,16,84]))\n", " return p[0], abs(p[1:]-p[0]).mean()\n", "\n", "def create_row(df,f,pars):\n", " return ('{:}'.format(f)+\n", " ''.join(['{:5.4f} ± {:5.4f}'.format(*ms(dft,p,f)) for p in pars])+\n", " '')\n", "\n", "def create_table(df): \n", " pars = 'tc rho b k u v'.split()\n", " return (''+\n", " ''.join([''.format(p) for p in pars])+\n", " ''.join([create_row(df,f,pars) for f in filter_names])+\n", " '
Filter{:}
')" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
Filtertcrhobkuv
u1.0003 ± 0.00021.7224 ± 0.30800.4303 ± 0.15140.0978 ± 0.00360.9226 ± 0.1157-0.0911 ± 0.2264
g1.0001 ± 0.00021.5318 ± 0.20740.5061 ± 0.08150.1000 ± 0.00260.7736 ± 0.1631-0.1171 ± 0.2952
r0.9999 ± 0.00021.6777 ± 0.30520.4081 ± 0.15710.0970 ± 0.00240.3780 ± 0.13980.5081 ± 0.2058
i1.0000 ± 0.00021.6349 ± 0.25250.4199 ± 0.13620.0984 ± 0.00240.4344 ± 0.16330.2664 ± 0.3313
z0.9999 ± 0.00021.6708 ± 0.27700.4267 ± 0.14570.0990 ± 0.00190.1173 ± 0.11680.4344 ± 0.2758
J21.0000 ± 0.00021.1794 ± 0.13320.6068 ± 0.04730.1011 ± 0.00120.1445 ± 0.14330.2421 ± 0.2392
H21.0001 ± 0.00021.9466 ± 0.16680.2091 ± 0.14500.0957 ± 0.00120.1087 ± 0.08950.6933 ± 0.1973
Ks0.9999 ± 0.00011.4920 ± 0.14390.5119 ± 0.05160.1001 ± 0.00080.1360 ± 0.10310.1037 ± 0.1635
" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display(HTML(create_table(dft)))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---\n", "
© Hannu Parviainen 2014--2019
" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.7.3" } }, "nbformat": 4, "nbformat_minor": 1 }