diff --git a/examples/tutorials/basic_ptmcmc_tutorial.ipynb b/examples/tutorials/basic_ptmcmc_tutorial.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..cdae281fac82fafb0075b484a2decc4a9a427fc0 --- /dev/null +++ b/examples/tutorials/basic_ptmcmc_tutorial.ipynb @@ -0,0 +1,483 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:35 bilby INFO : Running bilby version: 0.3.1: (CLEAN) 06cce8b 2018-10-18 05:02:54 -0500\n" + ] + } + ], + "source": [ + "from __future__ import division, print_function\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import bilby\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## This notebook will show how to use the PTMCMCSampler, in particular this will highlight how to add custom jump proposals" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## create 150914 like injection" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Set the duration and sampling frequency of the data segment that we're\n", + "# going to inject the signal into\n", + "duration = 4.\n", + "sampling_frequency = 2048.\n", + "\n", + "# Specify the output directory and the name of the simulation.\n", + "outdir = 'outdir'\n", + "label = 'basic_tutorial4'\n", + "bilby.core.utils.setup_logger(outdir=outdir, label=label)\n", + "\n", + "# Set up a random seed for result reproducibility. This is optional!\n", + "np.random.seed(88170235)\n", + "\n", + "# We are going to inject a binary black hole waveform. We first establish a\n", + "# dictionary of parameters that includes all of the different waveform\n", + "# parameters, including masses of the two black holes (mass_1, mass_2),\n", + "# spins of both black holes (a, tilt, phi), etc.\n", + "injection_parameters = dict(\n", + " mass_1=36., mass_2=29., a_1=0.4, a_2=0.3, tilt_1=0.5, tilt_2=1.0,\n", + " phi_12=1.7, phi_jl=0.3, luminosity_distance=2000., iota=0.4, psi=2.659,\n", + " phase=1.3, geocent_time=1126259642.413, ra=1.375, dec=-1.2108)\n", + "\n", + "# Fixed arguments passed into the source model\n", + "waveform_arguments = dict(waveform_approximant='IMRPhenomP',\n", + " reference_frequency=50., minimum_frequency=20.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inject into data" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/c1572221/src/bilby/bilby/gw/detector.py:1986: RuntimeWarning: invalid value encountered in multiply\n", + " frequency_domain_strain = self.__power_spectral_density_interpolated(frequencies) ** 0.5 * white_noise\n", + "14:36 bilby INFO : Injected signal in H1:\n", + "14:36 bilby INFO : optimal SNR = 12.09\n", + "14:36 bilby INFO : matched filter SNR = 10.88-0.37j\n", + "14:36 bilby INFO : luminosity_distance = 2000.0\n", + "14:36 bilby INFO : psi = 2.659\n", + "14:36 bilby INFO : a_2 = 0.3\n", + "14:36 bilby INFO : a_1 = 0.4\n", + "14:36 bilby INFO : geocent_time = 1126259642.41\n", + "14:36 bilby INFO : tilt_2 = 1.0\n", + "14:36 bilby INFO : phi_jl = 0.3\n", + "14:36 bilby INFO : ra = 1.375\n", + "14:36 bilby INFO : phase = 1.3\n", + "14:36 bilby INFO : mass_2 = 29.0\n", + "14:36 bilby INFO : mass_1 = 36.0\n", + "14:36 bilby INFO : phi_12 = 1.7\n", + "14:36 bilby INFO : dec = -1.2108\n", + "14:36 bilby INFO : iota = 0.4\n", + "14:36 bilby INFO : tilt_1 = 0.5\n", + "14:36 bilby INFO : Injected signal in L1:\n", + "14:36 bilby INFO : optimal SNR = 9.79\n", + "14:36 bilby INFO : matched filter SNR = 10.00+0.07j\n", + "14:36 bilby INFO : luminosity_distance = 2000.0\n", + "14:36 bilby INFO : psi = 2.659\n", + "14:36 bilby INFO : a_2 = 0.3\n", + "14:36 bilby INFO : a_1 = 0.4\n", + "14:36 bilby INFO : geocent_time = 1126259642.41\n", + "14:36 bilby INFO : tilt_2 = 1.0\n", + "14:36 bilby INFO : phi_jl = 0.3\n", + "14:36 bilby INFO : ra = 1.375\n", + "14:36 bilby INFO : phase = 1.3\n", + "14:36 bilby INFO : mass_2 = 29.0\n", + "14:36 bilby INFO : mass_1 = 36.0\n", + "14:36 bilby INFO : phi_12 = 1.7\n", + "14:36 bilby INFO : dec = -1.2108\n", + "14:36 bilby INFO : iota = 0.4\n", + "14:36 bilby INFO : tilt_1 = 0.5\n" + ] + }, + { + "data": { + "text/plain": [ + "[{'cross': array([0.+0.j, 0.+0.j, 0.+0.j, ..., 0.+0.j, 0.+0.j, 0.+0.j]),\n", + " 'plus': array([-0.-0.j, -0.-0.j, -0.-0.j, ..., -0.-0.j, -0.-0.j,\n", + " -0.-0.j])},\n", + " {'cross': array([0.+0.j, 0.+0.j, 0.+0.j, ..., 0.+0.j, 0.+0.j, 0.+0.j]),\n", + " 'plus': array([-0.-0.j, -0.-0.j, -0.-0.j, ..., -0.-0.j, -0.-0.j,\n", + " -0.-0.j])}]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Create the waveform_generator using a LAL BinaryBlackHole source function\n", + "waveform_generator = bilby.gw.WaveformGenerator(\n", + " duration=duration, sampling_frequency=sampling_frequency,\n", + " frequency_domain_source_model=bilby.gw.source.lal_binary_black_hole,\n", + " waveform_arguments=waveform_arguments)\n", + "\n", + "# Set up interferometers. In this case we'll use two interferometers\n", + "# (LIGO-Hanford (H1), LIGO-Livingston (L1). These default to their design\n", + "# sensitivity\n", + "\n", + "ifos = bilby.gw.detector.InterferometerList(['H1', 'L1'])\n", + "ifos.set_strain_data_from_power_spectral_densities(\n", + " sampling_frequency=sampling_frequency, duration=duration,\n", + " start_time=injection_parameters['geocent_time'] - 3)\n", + "ifos.inject_signal(waveform_generator=waveform_generator,\n", + " parameters=injection_parameters)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### For simplicity, we will fix all parameters here to the injected value and only vary over mass1 and mass2," + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "priors = injection_parameters.copy()\n", + "priors['mass_1'] = bilby.prior.Uniform(name='mass_1', minimum=10, maximum=80, unit=r'$M_{\\\\odot}$')\n", + "priors['mass_2'] = bilby.prior.Uniform(name='mass_1', minimum=10, maximum=80, unit=r'$M_{\\\\odot}$')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Here we create arbitrary jump proposals. This will highlight the necessary features of a jump proposal in ptmcmc. That is it takes the current position, x, then outputs a new position , q, and the jump probability i.e. p(x -> q). These will then be passed to the standard metropolis hastings condition. \n", + "## The two proposals below are probably not very good ones, ideally we would use proposals based upon our kmowledge of the problem/parameter space. In general for these proposals lqxy will certainly not be 0 " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class UniformJump(object):\n", + " def __init__(self, pmin, pmax):\n", + " \"\"\"Draw random parameters from pmin, pmax\"\"\"\n", + " self.pmin = pmin\n", + " self.pmax = pmax\n", + " \n", + " def unjump(self, x, it, beta):\n", + " \"\"\" \n", + " Function prototype must read in parameter vector x,\n", + " sampler iteration number it, and inverse temperature beta\n", + " \"\"\"\n", + " # log of forward-backward jump probability\n", + " lqxy = 0\n", + " \n", + " # uniformly drawm parameters\n", + " q = np.random.uniform(self.pmin, self.pmax, len(x))\n", + " return q, lqxy" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "class NormJump(object):\n", + " def __init__(self, step_size):\n", + " \"\"\"Draw random parameters from pmin, pmax\"\"\"\n", + " self.step_size = step_size\n", + " \n", + " def normjump(self, x, it, beta):\n", + " \"\"\" \n", + " Function prototype must read in parameter vector x,\n", + " sampler iteration number it, and inverse temperature beta\n", + " \"\"\"\n", + " # log of forward-backward jump probability. this is only zero for simple examples.\n", + " lqxy = 0\n", + " \n", + " # uniformly drawm parameters\n", + " q = np.random.multivariate_normal(x , self.step_size * np.eye(len(x)) , 1)\n", + " return q[0], lqxy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Below we create a dictionary containing our jump proposals and the relative weight of that proposal in the proposal cycle, these are then passed to bilby.run_sampler under the keyword argument custom_proposals = " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "normjump = NormJump(1)\n", + "normweight = 5\n", + "ujump = UniformJump(20, 40)\n", + "uweight = 1 \n", + "custom = {'uniform': [ujump.unjump , uweight],\n", + " 'normal': [normjump.normjump , normweight]}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:36 bilby INFO : Running for label 'label', output will be saved to 'outdir'\n", + "14:36 bilby INFO : Search parameters:\n", + "14:36 bilby INFO : mass_2 = Uniform(minimum=10, maximum=80, name='mass_1', latex_label='$m_1$', unit='$M_{\\\\\\\\odot}$')\n", + "14:36 bilby INFO : mass_1 = Uniform(minimum=10, maximum=80, name='mass_1', latex_label='$m_1$', unit='$M_{\\\\\\\\odot}$')\n", + "14:36 bilby INFO : phi_jl = 0.3\n", + "14:36 bilby INFO : dec = -1.2108\n", + "14:36 bilby INFO : psi = 2.659\n", + "14:36 bilby INFO : a_2 = 0.3\n", + "14:36 bilby INFO : a_1 = 0.4\n", + "14:36 bilby INFO : geocent_time = 1126259642.41\n", + "14:36 bilby INFO : luminosity_distance = 2000.0\n", + "14:36 bilby INFO : ra = 1.375\n", + "14:36 bilby INFO : phase = 1.3\n", + "14:36 bilby INFO : phi_12 = 1.7\n", + "14:36 bilby INFO : tilt_2 = 1.0\n", + "14:36 bilby INFO : iota = 0.4\n", + "14:36 bilby INFO : tilt_1 = 0.5\n", + "14:36 bilby INFO : Single likelihood evaluation took 1.670e-03 s\n", + "14:36 bilby INFO : Using sampler PTMCMCSampler with kwargs {'Niter': 10000, 'Tskip': 100, 'verbose': True, 'covUpdate': 1000, 'ladder': None, 'burn': 5000, 'NUTSweight': 0, 'AMweight': 1, 'logl_grad': None, 'HMCstepsize': 0.1, 'groups': None, 'Tmax': None, 'Tmin': 1, 'HMCsteps': 300, 'p0': None, 'neff': 10000, 'logp_grad': None, 'HMCweight': 0, 'loglkwargs': {}, 'custom_proposals': {'normal': [<bound method NormJump.normjump of <__main__.NormJump object at 0x7f2ee3cf7e10>>, 5], 'uniform': [<bound method UniformJump.unjump of <__main__.UniformJump object at 0x7f2ee3cf7d50>>, 1]}, 'logpargs': {}, 'MALAweight': 0, 'loglargs': {}, 'DEweight': 1, 'thin': 1, 'isave': 1000, 'outDir': None, 'SCAMweight': 1, 'logpkwargs': {}}\n", + "14:36 bilby INFO : Adding normal to proposals with weight 5\n", + "14:36 bilby INFO : Adding uniform to proposals with weight 1\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished 50.00 percent in 26.952440 s Acceptance rate = 0.1046667Adding DE jump with weight 1\n", + "Finished 90.00 percent in 47.835580 s Acceptance rate = 0.140667" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "14:37 bilby INFO : Sampling time: 0:00:53.551375\n", + "14:37 bilby ERROR : \n", + "\n", + " Saving the data has failed with the following message:\n", + " Can't pickle <type 'instancemethod'>: attribute lookup __builtin__.instancemethod failed \n", + "\n", + "\n", + "14:37 bilby INFO : Results saved to outdir/\n", + "14:37 bilby INFO : Summary of results:\n", + "nsamples: 4000\n", + "log_noise_evidence: -8086.279\n", + "log_evidence: nan +/- nan\n", + "log_bayes_factor: nan +/- nan\n", + "\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Run Complete\n" + ] + } + ], + "source": [ + "# Initialise the likelihood by passing in the interferometer data (ifos) and\n", + "# the waveoform generator\n", + "likelihood = bilby.gw.GravitationalWaveTransient(\n", + " interferometers=ifos,waveform_generator=waveform_generator)\n", + "result = bilby.run_sampler(\n", + " likelihood=likelihood, priors=priors, sampler= 'PTMCMCsampler',custom_proposals = custom , Niter = 10**4 )" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 396x396 with 4 Axes>" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result.plot_corner()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### PTMCMC produces the acceptance rate for each of the proposals (including the ones built in). This is taken as an average at a specified checkpoint. This is one (acceptnace rate is certainly not the only/even the best metric here. Think exploration v exploitation problem ) indicators of whether our jump proposal is a good one" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "sampler_meta = result.meta_data['sampler_meta']\n", + "jumps = sampler_meta['proposals']" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7f2ed97a0f50>" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 432x288 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.xlabel('epoch')\n", + "plt.ylabel('acceptance rate')\n", + "for i,proposal in enumerate(jumps): \n", + " plt.plot(jumps[proposal] , label = proposal)\n", + "plt.legend(loc='best', frameon=True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## We can generate the 1d chains for each of the parameters too and the likelihood of those points on the chain" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgoAAAHzCAYAAABBtDUZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsvXuYHNV17v3uvk7PjGZGIyECAxjNgJFtwEhAhINjMEhRAk4sY0k8jh3Fic3IifPlED5LgtixkG0CAgeTyzk+GuJ89jG2IyFj+QIxljA4MQcIuiEMkgCNbgghMRr1XPpSfdvfH1XVU11dVV3VXdVVu2f9nmeemaraVb2r3+neq9Zea23GOQdBEARBEIQRIb87QBAEQRBEcCFDgSAIgiAIU8hQIAiCIAjCFDIUCIIgCIIwhQwFgiAIgiBMIUOBIAiCIAhTyFAgCIIgCMIUMhQIgiAIgjCFDAWCIAiCIEyJ+N2BIHD//ffznp4e164XiURQKBRcux7RfEhD8SENxYb085YTJ06MrFu37iw7bclQANDT04PBwUHXrpfNZtHW1uba9YjmQxqKD2koNqSft6xfv/6I3bY09eAB2WzW7y4QDUIaig9pKDakX3AgQ8EDyF0mPqSh+JCGYkP6BQcyFDwgFKK3VXRIQ/EhDcWG9AsOpIQHtLe3+90FokFIQ/EhDcWG9AsOFMzoAZIkURCO4JCG4iOihlt3H8cdm/agpNl38ZwObLvjer+65Bsi6teqkEfBA/L5vN9dIBqENBQf0TTcuvs4btcZCQDw+qkUFj/4jB9d8hXR9GtlyFDwAMaY310gGoQ0FB/RNHzgyQOmx14/lWpiT4KBaPq1MmQoeEBnZ6ffXSAahDQUH9E0fCuZ8bsLgUI0/VoZMhQ8QJIkv7tANAhpKD6iaXhuT8LvLgQK0fRrZchQ8IBcLud3F4gGIQ3FRzQNVy+5xPTYxXM6mtiTYCCafq0MGQoEQRABYOn8Pjx06xVVX8rTNeuBCA6UHukBNLcmPqSh+Iio4dL5fVg6v8/vbgQCEfUzY94Xn0C2yMvbbWGG/ffc5GOPnEGGggfkcjnK/xUc0lB8RNZw8YPPVGQ6NNursHX3cTzw5AG8lczg3J4EVi+5pOkGjMj6adEbCQCQLXLM++ITwhgLNPXgATS3Jj6kofiIqqHeSACaW0th6+7juOuxl3E8mQEHcDyZwV2PvYytu4835fVVRNVPj95IqLU/iJBHgSAIwieMPAdmNROaVUvhgScPIJMvVuzL5It44MkDNC0yTSGPggd0dEy/COVWgzQUn6BraOY58Buzeg7NrvMQdP2mE2QoeAAtjyo+pKH4BF3DIBgFRpjVc2h2nYeg62eXtrBxhUmz/UGEDAUPoEIh4kMaig9pWB8fnneWo/1e4bZ+W3cfx7X3/RJz73wc1973y6bFXOy/56Yqo4CyHgiCIAKCHJi3F5m8fqklIB4JYcPHLxdm3r2vSU/0T+9/x9F+EVADNNXYCzVAE0DD+tvJEBHJKDCCDAUPoLk18WkVDdUvsePJDMKMocg5+nxKd2s2vz40gTt++GrVaowqUqGEOzbvAdD4YFEPVoGLehisKze6SSvGKDQSoPmlrS/jBy8cQ5FzhBnDJxaej68tvQyAtwZIkKCpBw8olcy+mghRaAUNtWluAFDkcjqWX+luzebh/zxoaiSolLj1qo1esu2O622XZv7kNRc0beAxS9prdoyCm5/Beo2fL219GY88f7T82SlyjkeeP4ovbZWNASsDpJUgj4IHZDKZlnkina60goZGX2Iq0yHdLSdlYOdZqJlPylt3H8cdm/ZUGTDXDvTi2YOjpuepT7BeM++LT5gec9ujsfCebTg5MVUr4ewZMbzwxcXlbTc/g+f2JMoGs36/FY88f9R0v9kxoPVWAiWPAkG0KLW+rFrty0zPrM64rXbNelLeuvs4bjcwEgBYGgnNxKoIkJtGpd5IAICTEzksvGeba6+hZfWSS5CIhiv2JaJhS+Onkb6EQ/YzGvwKsnQCeRQ8oL293e8uEA3SChqaPUVpj7cKqotYS2+cQ57dNyfEmjf3L7o7+ktbX3bNs6E3Eoz2u/kZVI0cu2Wpv7T1ZdM+2qFQsld10SzG4dEdR/H88BkUOQcD0B4LI50r+lZOmwwFgmhRVi+5pOJLSEutpymRMDIS7NDsrId6PThBWWL6By8ca9oUiBc4WXDrBy8cc/W1zaZZ7ti8B3qbIpMvVniYOIBUzt9gSV8NBcZYD4BBAEkAAwDAOV+rOb4RwAbO+bDN6y0D0A9gC4BR5dpb7J7vFul0uiWeSKczraCh9imqlbMezL7Ue+Mco1K1R6GvJ4Fn77zB625VUcvDA1RnQjR7Mai2MDOdflAD+pqFF59Bu4tduXmvZtMsF975eF3X8yO+yG+Pwl06w2AnY2yQcz6k7FoEYJCxqg/7Kk0bLb0ANig/SQC3NdtIIAineLlS33RYttjpl7pfsRmrl1yC2zftMT1+7UAvvnfbB5rYo2r233OT6QAWrv4erpuzZ8QMXftnz4jVPPeTDz9nGNNx+L6bLc9zksqoGtWNMPfOx3FuT6KhKQwzmv0/7Hcw4zLG2KBmexjAYs32dgBXQvY2qD/3mxgJKjMBDHDOZ3LOt7jdYTskEq0z9ztdaZaGQVmpT2TMBrAzBt4EwL/YjKXz+/DQrVcYfum6aSR8aevLGLjrCVx45+MYuOuJciqfXT51zQWG+z+x8Hw3ugcAeOGLi6uMAn3Wg9Fn0MxIAFDzfp2kMrpxr+rn2QuaXfzZb4/CYt0Tfz+ATUB5WqJi2kExKu61uiDnPAnZm2CJcq1BAFi5ciVWrlyJXC5XXtq0o6MDhUKhXEa0o6MDpVIJmYwsvOoSS6fTAOR/6lAohFQqBUmSUCqVEIlEkErJbsRYLIZYLIbJycnydjwex+TkJDjniEajiMfjSKfT5XPb2trK26FQCO3t7chmsygUCuVtSZKQz+fBGENnZyckSSrfQ2dnp2v3BADxeHza3FMymUQmk/H8nv79v15BBAWcnQBmROUnmFMZjm89vQ8fPD9OOtm4p8GFs7F17ylM5IA5CSDEODIFBoDjwk4gEuLIFhnGcsDsNuB/XHcORkdHfbmnJfN68d9fWGh4T1/buhObdp7A2Qn5/6CEMP76996L3507w7ZO//SfR/DMy8cxdwZHocRwWuJ4eu8RbEAGn/3dAVv3tPbGC7H39WNI54sYyTKEGdDXGcLtHzynfC+N/u/9x65D6GJZRNoZxvPArDhw4UyGZDJZvqdMJgNJkip0On7yNGZEga4okIhwlDjDqQwwIwZ0ROT37cc7j2DbS0cwI8oxsz2K/7PqOhQKBbSXUrioC+V7mhmX249m0liw7mf4xf9zTfmevrjkIsxABk/tO4WkBORLDLPa5HyViTxDuoCyTqkCq/rfU+9J+7/XGweiIY58iWFUArpjQFtY1cn6nk5mGNoj2u8IhomJiYY+T05gvMnzTmYwxhYAeJhzfqXF8V7O+XaLa6jeiVHI0xA9nPP7a7320NAQHxwcrNXMNiMjI5g9e7Zr1yOaT7M0nHvn44YFbhiAQzVcqcQURgGNF3WV8Mb41PN7RyyMjy3oww93vlku6RxiwB8vvMD3ID2zgMxwiOEflr/f9vTRwF1PGLrMw4zh4L2VZYSNns674mGc3d1mWDGyKx7G3vW/b6sfVqhpokZoYzKMPoP1zOurnopr7/tlzSd8/fSFtipj0Kg11VKL9evX71y3bt1Vdtr67VFQPQcrACwHcJtF01Wc81U1LrcdwKjiVQBjbKMu5sFT1Lnm9lIK6VCHbwFjbs9513s9J+fZaevlXL5f1FsIhqjka0svqxrs9QONUbGjEp8qquOnsfA9k6yNYok7ClwzG9D0+81c+ONSEeMmZaXHpWJDKZJW0wYqXqyoqcYIWGUBGVFvsGEr4neMAjjnSc75EOd8MYCHdTELAADG2CIAB21ca1g1EhS2AVhr1t5NtHPNYznm21yz23Pe9V7PyXl22jZ7Lt+pa65e6ikEQ9hDr+EDTx4wLensRjpcI7EBVs+rTgLXzOI19PvrLfBU7/tkx0jQ4/Zn8PZNe2oaCapuQTcSplWMAmOsRzewb1R+9B6AVVBiF6yuBeAMgJmaayYhxz14jjZQJqv8L/qRxtLI4iduXs/JeXba1mpj5W0wO2a0X32tyVQanR3tFfvUdh+edxae3v+OK54Np4VgCPtEIpVfb1YDbqOuZf3UgbomAGDsqXBS+4Gj+un2U9cYT5d8YuH5htfVBuctfvAZW69rhNP3ySg1sBZbdx/H0vl9Vfo1gt2BX6tbkGn2RIhvhoLiJdjGGJupMxaMDIhlqBHEqHC/7rx+yJkUnqP9EpqT4BjPs6r9ze6Hnf1eXc/JeXbaWrWxSnsCYHhsx5FR/HDn8Yr9qx99CWBAvshxURfHG7p9ajvtF4kbBVCmQwqjH6RSqYrIeas6Bo2m/pk9aRsVKaq3QJQWMyNE3TZb7RBozL3v5H2qx0gAUDb+9fp5Vd6ZqI2fUw87AAzpBvbFkAsklfcpngLAIJOBMdavFFlSsx1O65osR5OmHszmlJs91+x2P+q9npPz7LS1amPlbTA79oMXjlXtz5d42SCw2qenFVeLa0VWL7nE9Auv0XQ4u7EBgHtV/8yuc+idyYrVDg+9M+nK6wHO3qd66weYPRR4UY+AsIdvhoIysG9kjK1RfjYAGOacLzdoPgw5k0HPIsjTEipDyrUGlettbFYtBe1c84TiTfBjrtntOe96r+fkPDttrdpYeRvMjtVyoaoa2qXVF1gSkVisMk9/6fw+PHjrFUhEp772Qszcje8Eu7EBgHtV/4yuYxQL8OzBUXzy4efKx+vFjffJDupDgVY/q1UtCe/xNUaBc74LwK4abcrlnQ2ODUETz6C0rZkO6QXauebxVNq3Mrluz3nXez0n59lpa9VGLVGsR/3CMTpWq/JaumB5e6avRQQHvaEAeDfNYxYbUOQcF975eMUg60bVP/U6eswCBlVjoZFVKq96V2/578vX/Rzj0pRHTk2d1O+vh9VLLsEnH34Oe4+edmywE94QmDoKfkJ1FMRGH6MAyN6Ge2+Rv5iNjn38yr6KGAUAiIaYJkZBzsHX7jNDfS2KMwgWzfwc2ok7UI0FN2IU/KItzBCLhBo2Bqy4dqAXzx4craqDQVQyreooEESj2PFIGB276l29plkPrJQqe4X057uZ9aBFm4XRnYiCMeBMOl9+AlV/91gcU3/LdQllZrZHse4P30eGjIfYiTtQAxtVz4KIxkK2yJEtemckXDynoyGvB+ENZCh4gJHLk/AWK5ey2TGr/ePj4+jq6qrY5yV6r0gyky8f0wam1Tqm/tb6P86k81i95SUAzV2athl8aevL+N7zR8v32xEL456Pyd6dZn4O7UwlaNtoDYZ6swOcoD6lBwWtIauiVmVUUxlTBZp2CApkKHhAs4r1EN7RbA2NsjPcJF90VuFPBIxc+KlcEf/vo7JR9Afvbd70n524A7OAR+1CSIBsNK5+9CXkS+5MC6sLTjUao+AmRnf2+qlURQE1SnIIDmQoeMDk5CQZC4LjREOjKYNkOu9omqIZWROtlplh5u5Xyx7/7gVtTfscmgUz6tvYQf3/uPsnr5S9R+r0kVngrhkhBsw9qxMAAmcsGHHXYy+jKx7GuFTEnAQwOeF3jwiADAVPoABR8bGrodWUgZPiTFbFgNwiyJkZ+ikEoHZshdUT/FvJTFM/h7XiDpymFlpNpZktqGSEupbFtlfexgtfXFxeyrrZJYoP33ezrdfM5ItQPwUhxtH8YsVi0BUP127kImQoeEA0GvW7C0SD2NXQ6ZRBJl/E7Zv24O6fvFLledBnYbhJNMxs19LYuvt4xdOsE+oJnDTLAqgVW2Hl7j+3J9H0z6HRwlRuo74PTowFQC5W9MmHnysbChfP6fBkASYjLp7TgYvucm6YZChGwRQ3VvF0AuWeeABNO4iPXQ3rdecnM3mcSefLC1z9cOdxfPzKPvT1JMAA9CSimNkuD3Tq3Lb62+qY+lv7FTuzPYoHltlbqlidH6/HSACmBncni3VZZQzkixy3b9qDC+98HBfe+Tje9+Wfl69t5soPh2SjKEifw8UPPlO+B/XHyaJR2uvojYSueBiH77u55rO3dsph2x3X4+I5HY5f3ykXz+nAoXdSKNTh3Bmv719wWlDP/04jkEfBA9LpNNra2vzuBtEAdjV0a8ogky/i6f3v4Nk7b2j4Wo3wwJMHGg6icxo46aT4kDZYUX16N8t6GB0dDcTncPGDzxg+vT/y/FH8ZPdx20+HZtcZl4q4fN3PHf8vbrvjetdrOhjl9tc7zTErDkyQsWDI91842tRl0clQ8IBSyWwxW0IU7GrodI17K4IQbOhWH5wujezEWFCDFZfO77N09wflc2jl4h+Xilj84DPYdsf1DV9nXKr9nusH7Y6Yu3Pd6sqPbuBy11oKlxJibEOGgge4uTwq4Q92NdQXezLLerDzpBeEYEO3PCRO7sVOxoAeO4ZIMz+H+qd9tSaAHZoVK2BEKuduTMztm/bg9k17wAAcarBy4Oa/+CCuuO9ZdzpGNASNaB4QBHcn0RhONLSzfoBRmWktfiwgZsTqJZe4ksN/PJmpeno1C3Ssp1IhR+XTMQPwSV1mQbM+h0ZTAq+fStn2FASRvp4E2mOhuo0YDmDunY/j0H03I8JQV4wCfY+ao13YrBlQMKMHpNNpv7tANIjbGi6d34d7b7msKliRQf5SDspaEUvn9+GB5e9HT8L9jAGrQMevLb2soUQ4DtnQ0AZ5NetzaDaYqvvdCBrcuvt4U7+sPzzvLGy74/qG1hNQjbl6jISueBhLvr697tduZUIA7r3l8qa+JnkUPCAoc6NE/XihoVcrF7pNPf289r5f2pqysAp0dGPaQ11PAQjO53DbHddbrqpYy5BQvVHNvJun97/jyXXVKZla/y/jUhFz4lRHwYizZsSa/j1ChoIHhELkqBGdVtRQrSB5PJlxfdEoJ8GL+rbafjWKNigySBruXf/7hhkGdmIZvC7vbYRXgbWql2X1kkvwN5v2GJZyVsmXyEgw4uRErunTWmQoeEB7e7vfXSAapNU01MdIuL1oVE97FGfS9nLZVJd0iAEf6O/FrqNjrg2E2vUUzDSU34u9yOStn9HVNRJqYVa8SO8pqLcgk5fZMB2xsGFAozYY1WgBp0a48M7Hcfi+m2sWjRqVXHzRFqPZAbBkKHhANpulQBzBaTUNaz2VNrJo1NbdxzGZLTg+r8Rhuu5AX0+iXFPCSa6/tgiTkYZbdx/HHZv22HLjP3twtKKaoYqd/jjJeqiF2ZRMX08CF85KOFq74aFbr6jQ2CjIVhtY+8mHn3PVSNDSV2OqqTtGdRSCAhkKHlAoOP/SJIJFq2lo56m03idXN4o0WfXFTlaEUdaDkYYPPHnA0Vy/fhCuZSSoXogvbX25KusjEmL4+nJ7FTK1GNXqUAfzpfP7bMeHAFPpiwBw9oxYeeVKNb1Xv3CZVwtI2SnC1BamGIWgQIaCBwRpbpSoj1bT0E6gYL11HMwMDPUrvh4TQt+Xetz2Rho26sa3KjcNyAOrmTFRKHH8jTJIOzEW9LU69IP56iWXOF77AZDnui+663G8ce/NgQyyLVCMginNKL+thQwFD2i1+e3pSKtpWKuCpJNFo/SYGSHqYO80SNGtmhJGGtaTWaE+/X7qmgtsVZC0MiY4UNcUj1UmytL5fbj3iVdxciLn6JqAXN9g4T3bMDKZR5FzhBnDJxae39TywGacphgFU5pdn6O1HpsCgiTRf7jotJqG2joOQP2LRhmxesklSEQr6+2qg/3qJZcgGrL/ZBhmzLWaEkYarl5ySd1feo88f9SWI7yWMeFFcKI6hVAPJydy5T4XOa+oR3H2jJgr/auHLlqENzCQR8ED8nmKwBGdVtTQqzoOtVzjAGwvW13i3LU+GmmoXttO1oMRbkRidNdRzMpsQahP6eIy3EKtRzEy6d/nIBGpL0ahJxFFPMLq8rAQxpCh4AGM0dya6EwXDbfuPm46iDupr1DLNa4eqxV45+Z6F2YamvW13lUOnTKWyTtaPMnMSABkL8e2V952fVDUehj8osTNP4OfuuYC06DSZCaPw/fd7Jme9ZakFhmaevCAzs5Ov7tANMh00HDr7uNY/ehLpk/6ViWX66XWVMSH553l2msFVUM1TsEutXLmvXhyDgfAUD6lsyfDjOHwfTfj8H031/SiaEt5u43fRoIf00FkKHhAq81vT0emg4Z20hrV+gpuoa4lYbaozaYXj7lmmDjV8NqBXlde1w7NXFJcHVwP33dz1T2aDTpFznHRXc3xsJih75q2RkYtb0Gt7BRR0aa0NhMyFDwgl6O5MdGZDhraHazcHtSWzu9Db0fc8JibholTDb932weaZiw0a0nxPt3rfO+2D1QYDnfd9F7Tc+t5cg4x89Q9p+9tR6SyA05iMexOmbSF/fec2IWhsaDVRiBDgSCmKXYHKy8GNSvjo5lP23rUgfShW69o6DoXz+kwHRhDDI7SPxvJma/1Oo0YZUb3V+LmUyXfu+0DDZVPmv+VX9j2NoUZq/m+XTvQi1hEjCGQATjUwEqejeLru8QY62GMrWGMDTLGNjDGNuiOL1OO92va9te45hrlvEHG2KC3d2BMUOdGCftMBw3tpC42Ul/BCivjwy3DpBENl87vw0O3XgGTGZKapHMlUw9FyOH8/7Y7rjcd9Kzmq9vCrGbAZL1GmVqB0mg6w4yL7noch+672baxcDJT2dJJzMwnFp5v+r596poLcPi+m/Hym2OmK3oGDT+NBMD/rIe7OOdr1Q3G2E7G2CDnfEjZ1Qtgg/KTBHAb53zY7GKKofEi53yLus0YW6ZuN4tcLtdS6wRMR6aDhuog4kbWg1NWL7kEqx99qSpGwk3DpFEN9dkRTkolWw3AhRLHHZudVWi0KrDzyYefqyq13BUPY+/63695XTsFqK4d6K24vn6xLLtlngtcDqDVDnpGfVdpj1Sv9WB3akqdprB639wwEqZLBoTfhsIyxthBjWEwDGAxgCFNm5kAeq0MBA2DWsMDwDYAawE03VAgxGa6aOhVbQU7rwtUGiluGyZua2hm3BihekXMBsESr69CoxF2Vrg0o1b55whr7Pp69Pesv/ZFdz1eHnhnRHmVVwGQK33WWlCqWbxxr2z01JOKyQC0x8JI54qeLbzlFn4bCot1BkA/gE3aBpzzJGRvgiWMsQUGu0cBLGqohwRBeIJfRkq9GBk37dEQ8iWOfHHqq95uCWo/YzFU1HsyMhYibGogdIta9/zGvTdj7p2P1xw4613fIkjopxOaVcejHnw1FLRGgjrQc87v17ZR4gxGIU9D9OiPa+hV2mlJKtfoUQwO/XUHAWDlypVYuXIlcrlc+Smko6MDhUKhnGLV0dGBUqmETEb+R1fryKfTaQBAIpFAKBRCKpWCJEmYmJhAJBJBKiUH9sRiMcRiMUxOTpa34/E4JicnwTlHNBpFPB5HOp1GqVRCJBJBW1tbeTsUCqG9vR3ZbBaFQqG8LUkS8vk8GGPo7OyEJEnle+js7HTtngAgHo9Pm3uSJAkjIyMtdU+tqJPVPUUiEYyOjrp6TzcMzMAHP7+g4p6e+s2b+PcXj+HASA7ndrfhtt/pwwfPl9/P3jhHb1we9s5IDEUOzG6TtxNtCWQyGd91umFgBnZ8YaGhTplMpqZOiy7uxuGTZwAA4zmGbBGYk5DvcSLPkC4AZyvbHYk2SJJkeU8XzYojJ2XRHgHe1ckxKslLTreFOQolhtMS8OH+Tlx/QRxHz2RxKiOnUqpZEhfM6cX4+HjN/73LZzGk80WMSrLXwkwnq3ta9Pc/RarA0BkB5iSAEOPIFBjG88CsOBAJcWSLDGM5oDcOREMc+RLDqAQkk8kKnfraORIRjhJnVfeUzWZd/zw5gXEfK28B8iAOYAWA5QDWcs53aY71AxhVB3nG2EYAOzVTFdrrLAPwMOd8pu7aZwAMWE1dDA0N8cFB9+IeJyYmMGPGDNeuRzQf0lB8gqCh2Rx8iAEPrrhCKI+KFVaxBloeurX2PasehTltHKeyxqGPh5Wncf3r6uMnanH5up9bxiqEGfOkOuVhg+BEK4+CUftGWb9+/c5169ZdZaet31MP6tTCEIAhJZhxo2oIGAzu2yAHNlYZCjCenlDDcb1ZVN0ESZJ8/4IiGoM0FJ8gaPi92z5QNZjFIyFs+PjlLWMkAJWxBlt3H8fqLS9VTMcAcraBnXtWAyy7YsaGgrb2QaPxE2rAp9kg7YWRIE7lhil8NRQMpgQ2Kj9DGm/ATE2bJOQ4BiNGAfTo9vUAZWOEIAii6bgZDCgCdhYJs0JdEh0wXrRr/z03udXVMmaeg0Y8Ch2xMFK5am+FWfovg/GiY0EwLHyro8AYWwTgjGIQ6I+p++7XDfL9kDMjqlCmLPQGQS+A7S501xEdHfUXSCGCAWkoPqShfyyd34dn77wBh+67Gc/eeYMj74m6JPqIybTDwnu2udXNMtry0Hb22yGdK5ouv27EJ6+5wNH+ZuJnwaUdAIZ0hsBiAFs450ll/2ndOcshpzsCkGMYlNgElSHd9mLIHoqmUio5X76WCBakofiQhuKydH4fzKore7EI1teWXoZPXXNBeTGsMGPlJbzrjQ/gAO695TL09STAIJfTvveWy0yNJqs++I1vUw+c8yRjbCNjbI2yaxaAYV0dhCHleBLAAICNuuJJiyAbD1uUa65VKzNC9j4cbHaxJUCOFKanGbEhDcWHNBSbmXGO01LzHO9fW3qZ6aCsNRYG7nrC9nSE0xRgqz74id/pkbsA7LI4ngRglg4JJehxSLfPtD1BEARBNMInFp6PR54/6nc3morvWQ+tiJrDSogLaSg+pKHYjDbRm2CHJ554ApIk4UoAcy5OYWSy9hTIj370I+87VoN4PI6bbmosAJQMBYIgCIKogSRJ+NjHPla1f++b5kl1l59XFavfdNwwVsRYY1Mw1GpYhLiQhuJDGoqNWikx6ETDxsOo2X4RaZ07IQiCIIgm855zuqqMgmg4hPec0+VTj9yHph48IJET+YEUAAAgAElEQVQwLqhBiANpKD6kodj0/1YP3hgfr9p/7UCvQWt/aSWjwAjyKHhAKERvq+iQhuJDGorNP37iqiqjwOlaDoQ7kEfBA1KpFD3NCA5pKD6kodikUikyCgJCw4YCY+xGAN2aXUnO+S8bvS5BEARBENbs2rULO3bsgJsrIOtpyFBgjH0WwGbO+bhmXzdj7LOc839tuHeC4nStbyJ4kIbiQxqKjSj6bd19vGoBLKD+RbGcsGXLFmzatAlXX32169fWUrehwBi7BcCjWiMBADjnY4yxRxljt3DOH2u4hwISidCMjuiQhuJDGoqNCPpt3X0cdz32MjJ5eZXI48kMVj/6EsBQXmb7eDKjrIYJ142FZcuWYXR0FMmktwskNxLtwzjnY+UNxsphn8r+YJXVaiKpVMrvLhANQhqKD2koNiLo98CTB8pGgkq+xMtGgkomX8QDTx6wdc1du3ZhYGAA27dvx65du7Bq1ary32vXrsX27U1fELkhQ6H8TjDGugEkGWObjI4TBEEQRKvxVjLjetsFCxagv78f/f39WLBgAQYGBjA8PIwFCxbg1ltvxaOPPlpvd+vGlfwhxYPwMIDNblxPdGKxmN9dIBqENBQf0lBsRNDv3B77WTVO2gJAb2+v4d9+0IihMEu7wTlfxTn/odnx6YQI/+CENaSh+JCGYiOCfquXXIJENFyxLxpiiIYrZ94T0XA5yFFEGjEUtjPGbjA6oOxv/kRKQJicnPS7C0SDkIbiQxqKjQj6LZ3fh3tvuQx9PQkwAH09CTyw/P14YNn7K/bde8tltgMZd+3aheHhYWzevBnJZBIvvvgitm3bhmQyie3bt2N4eBjDw8MAgO3bt2Pbtm148cUXPY1dMAwrZYxdyDk/bHUi5/wQY6xHSZHczjk/zBibC2ARgBc554fc7y5BEARBBIel8/sMjYB6MxwWLFiAgwcPlre1MQlr1qzBmjVrytuLFi3CokWL6nodJ5h5FNbaOZlzvluplzBTSZfs5pw/zDnf41oPBUQElxlhDWkoPqSh2JB+wcEsUfUqxtgMzvmEnYtwzncD2O1et8RGlEIhhDmkofiQhmJD+gUHM4/ClZDTHV9njH2TMfYxbZ0EwhoR5tYIa0hD8SENxYb0Cw5mhsLnIKc7PgVgMYAfAjjDGDvNGNvEGPsMY+xC7QmMsW962VGR4JxKSIgOaSg+pKHYkH7BwXDqgXM+pBRRWgFgA4BRAFdDNhpuhGxEcMZYEsA2yBkOVzWlxwIQjUb97gLRIKSh+JCGYkP6BQfTYtpqESVldcj5yroN5fwLxtgiTBkOK0CVGMvQ3Jr4kIbiQxqKDekXHGquusE5fwoAGGMfB3BQzWjgnG9HpeGww6tOikY6nUZbW5vf3SAagDQUH9JQbEi/4GC74JJSdXGMMfZZk8BGMhQUSqWS310gGoQ0FB/SUGxIv+DgqDIj5/yQUjfhaqVughZbtRemAyIsj0pYQxqKD2koNqRfcKirhLMyHfEUY+w2xtgVyr6xGqdNG8hdJj6kofiQhmJD+gWHuk02zvkYY2wbgGWMsRWc8791sV9CQ3Nr4kMaig9pKDakX222bNkCAHjxxRdx9dVXY9myZZ68jqWhoNRK6Fd+BjR/9wPoUZspba/knC9x8uKMsR4AgwCSyvXBOV+ra6MWtr4a8hoS91tcb5nSty2QUzoHAWzhnA876Vej0Nya+JCG4kMaio0w+u3dDDz1FWDsTaD7PODGL8v79fsuX+Hqy+7atQv9/f1YsGABli1bhoGBASxatAg9PT21T3aI2aJQr0MecAHFEAAwrPzsBLBZsz3cwLTDXVrDgDG2kzE2yDkfUrY3cs5X6Y7DwljohVz3YQNk4+O2ZhsJABAKNbIoJxEESEPxIQ3FRgj99m4GfvrXQD4jb48dA7b+JcAYUMxN7fvpX8t/u2gs7NixAzt37sTGjRsBAD09PRgeHsaCBQtcew0VM4/CAOTUx42QV4b0Kv5gGWPsoGoYQDY8FgMYUrwNSV37jZCNAFOvAoCZAHr9MBBU2tvb/XppwiVIQ/EhDcVGCP2e+sqUkaBSyle3y2fktjYMhV27dmH58uXYuHEjent7sXHjRixfvhy9vb3YtGkTFi9ejEWLFmFwcLB8TjKZRDKZ9MRIAMyDGbcAWAX5Cf02xtgXGGO3WK33oC/pbJPFGiMBkL0YLyp/9wJYwxjr151j6VfhnCf9NBIAIJvN+vnyhAuQhuJDGoqNEPqNvel62wULFqC/v788rTAwMFD2FNx6660Vy06r3HvvvYb73cLMo7CNc34IcqlmAIBS0nmxMnBzyE/72znnh5UmGwDc6uTFtQM6Y2yBsu9+9ZgS96Ad9BdDU+TJCMbYIOT4hF4APWbTFEq7QQBYuXIlVq5ciVwuh1xOdhd1dHSgUChAkqTydqlUQiYjW4+qtZtOpwEAiUQCoVAIqVQKY2NjCIfDiEQiSKVSAOQlU2OxWHmhk1gshng8jsnJSXDOEY1GEY/HkU6nUSqVEIlE0NbWVt4OhUJob29HNptFoVAob0uShHw+D8YYOjs7IUlS+R46OztduydArpQ2Xe7p9OnTKBQKLXVPraiT1T2p/W+le2pFnczu6cyZMyiVSoG5p3w+j3w+j1AoBMYYisUiIl19YOP2DADe3YeC0udQKIRSqQTOueE25xzd3d3I5/MoFovo6elBsVhEoVAo/09zzlEqlfDDH/4Qy5cvx/vf/37k87I3Q522KZVKyOfzSKVSVffkBLO1Hh422DcGeXEoAGXDYRFjbDnkqYq6wi2VKYYVAJYDuE33mrt07RZBXtnSjO0ARjnnSeWcjdqYB921hwAMAcDQ0BBva2szjLCdMWNGxXZHR0fFtt49pv6TqeclEomK4/rX0AumP+50u9b1gPruyWq7Fe9p5syZ6O3ttd0HEe6pFXWy6kOxWKzQ0Ki9aPdkp8+tdE+qfkG4p2g0WrH+RCgUAhatq4xRAIBQtDJGAQCiCbAb11Wfr0G7zRhDOBxGNBpFOBxGKBQqP3yGQqFy26effhrvfve7sWDBAiSTSYyOjqK/f8oJr15DvVf9PdmlofRIVBoOi+q8ThLygD2kBCtuNBrYATwK4EaraQWDY9sgezqMrucZQsytEZaQhuJDGoqNEPqpMQcuZj3s2rULw8PD2Lx5M1asWIEXX3wRBw8exKJFi7B9+3YMDw9jeHgYyWQSy5cvLxsGyWQSBw8e9OIu6zcUDLCcEjCCMdajPv0rbFR+hnTtNgDYoPUwGF0LwBkAMzXXTGIqe6NpSJJE+b+CQxqKD2koNsLod/kKYyOgzgyHBQsWVAz42tiDNWvWYM2aNeXtM2fO1PUaTnEt/4Rz/jkn7RUPxBllgNcf69H8vQxyzMR2ZdsqrPN+neHRDzmToqmo80SEuJCG4kMaig3pFxz8TFTdAWBIN7AvhlwgSY0xWAQ5KHEHY6xHCaQsB0wyxvoVQ0Kdwjite43l8GENCsZY7UZEoCENxYc0FBvSLzj4tuoG5zypBBuqfpRZkIs3rQXKXoVtyrGNmlO3aP5eBNkYUPcNKddTKz1u5Jxr2zeFzs7OZr8k4TKkofiQhmJD+gUHX5fnUmIODOMOFA+BpUmpzVzQnGNVjKkpSJLkOP2ECBakofiQhmJD+gUHAWpkioeav0uIC2koPqSh2JB+wYEMBYIgCIIgTCFDwQNobk18SEPxIQ3FhvQLDr7GKLQquVxOjPxfwhTSUHxIQ7EJmn7xeBw/+tGP/O6GY9yI8yBDwQNobk18SEPxIQ3FJmj63XTTTX53wTdo6oEgCIIgCFPIUPAA/WIjhHiQhuJDGooN6RccyFDwgEKh4HcXiAYhDcWHNBQb0i84kKHgAeq654S4kIbiQxqKDekXHMhQIAiCIAjCFDIUPIDm1sSHNBQf0lBsSL/gQIaCB5RKJb+7QDQIaSg+pKHYkH7BgQwFD8hkMn53gWgQ0lB8SEOxIf2CAxkKBEEQBEGYQoaCB7S3t/vdBaJBSEPxIQ3FhvQLDmQoEARBEARhChkKHpBOp/3uAtEgpKH4kIZiQ/oFBzIUCIIgCIIwhQwFD0gkEn53gWgQ0lB8SEOxIf2CAxkKHhAK0dsqOqSh+JCGYkP6BQdSwgNSqZTfXSAahDQUH9JQbEi/4ECGAkEQBEEQppCh4AHxeNzvLhANQhqKD2koNqRfcCBDwQMikYjfXSAahDQUH9JQbEi/4ECGggfQ3Jr4kIbiQxqKDekXHMhQIAiCIAjCFDIUPCAWi/ndBaJBSEPxIQ3FhvQLDmQoeAD9g4sPaSg+pKHYkH7BwddoEcZYD4BBAEkAAwDAOV+ra7MGwDCAXuX4UI1rOmrvBZOTk2hra2v2yxIuQhqKD2koNpOTk2jbtAI49KupnXOvA/70J/51aprit0fhLs75/ZzzIcVAWMQYG1QPMsY2ABjmnG9RBvwBxtgys4s5bU8QBEEElCf/ttJIAOTt7/yRP/2ZxvhtKCzTGgaQPQGLNduDnPMtmu1tAFZZXM9pe08gl5n4kIbiQxqKTezYs8YH9MYD4Tl+J6ou5pwPa7b7AWwCAMbYAoP2owAWGV2ojvaDkKc9sHLlSqxcuRK5XA65XA4A0NHRgUKhAEmSytulUgmZTAYA0N7eDmBqKdREIoFQKIRUKoVcLgfGGCKRSDnFJxaLIRaLYXJysrwdj8cxOTkJzjmi0Sji8TjS6TRKpRIikQja2trK26FQCO3t7chmsygUCuVtSZKQz+fBGENnZyckSSrfQ2dnp2v3BMgFUKbTPeVyuZa7p1bUyeyeGGMYHR1tqXtqRZ3M7ikbn4NCKIb23Aiy0V4Uwm0I8QLapVOQxsaEvKcg6eQExjl3dIJXKAP9w5zzK5XtRQA2cs4HNG36ARwEMJNzntSd76i9lqGhIT44OGh22DGnT5/GrFmzXLse0XxIQ/EhDcXm9ANXY1bqNeODd481tzN3zwRQqtwX7wbuOir//fV5wOSJqWOd5wBf2A/s3Qw89RVg7E2g+zzgxi8Dl69oWretWL9+/c5169ZdZaet3x4FNaBxBYDlAG7THOqBEpCoYVT53Qs5AFKL0/aeERTji6gf0lB8AqPhd/6o0l0ejgMf/ZfADBhBhTO/Z8YVjIwEAJDGgLu7jc+ZPAHcewFQygF5+SkfY8eAn/61/Ldg2vtuKChP+kMAhhhjOxljG5VARKOBXTUERg2OOW3vGdFotJkvR3gAadgE9m4G/mMtkFE+nole4A82uPYlGggN9UYCABQl4EdK6JRgA0YziRbTzX3Bn90B7Pw2wIsACwNXfhr4yIMwNBLsIBl4PfIZ2cNgprtpH/zFV5NN8SZo2aj8APLgrj/eA5SNCz1O23sGLWYiPqShx+zdDGz9yykjAZD//vHn5WMuEAgNzQLveEkeMFqVvZuBb1wK3N0j/3aq6c/uQDzfxK/tn90B7PiWPEAD8u8d35L3u83Ym/73wSG+GQpKTMEZA2MBjLEezvkuVHsJegFsN7qe0/ZeogaQEOJCGnrI3s3yE3UpX32smHNtAA28hmYDhujs3Sy72MeOAeBTLne7xsLezcCOf0M6Pqd22+/8kez+V3/qSZ38l4XygGzEjn9zfr2amEyJ7fy2s/1NxE+Pwg4AQ7qn/cUAtmj2DenqICzGlMcBjLF+3XHL9s2iVKrTVUUEBtLQI1RPArd4f10aQD3RcO9mYMPcqYFpw9z6PSDd57nbt6Dw1Fem5uVVVJe73fPBUWI1Zsbv7m68zsK/LARG9ls08CjO5e7uaq+L6kmo6oLJ/ibiW4wC5zzJGNuoVFIEgFmQiyWt1bRZyxhbowz+/QAO6uokLIIcBLnFZvumQMujis+00VAfJ6DF5ZgBAPIgYORJ0OLSAOq6hqqRo+2/Ol0CGL9Pc68znn5gITkCvlUwisXQM3asep9ZMCCASDFrfICFLM9zVGfB0kjwmB+tmjKYjd6bAOHrt6EyXbCrRpv7LY4NQQ6EtNW+WVDZWPFpSQ3LqVrHADDUfFqqNQg6eV0zY8SIi3+v/tfS4LqGZkaOOl1i9B796U+8z3owGqS1qXtWbe2URDa6/lWfAU6/4WxQZuHKbavBHkBb3uT/JZIA8i4sQX3vBY1foxGsvGoBY5o8NjWXdDrdmgPNNKLlNFTnjcsuYZsuVatBUH99o3xxo6fwWrz0feCCaxoeSBvWcO9mYOvn5RS3Wowdk13IRrnyXq5NYPYkL43JA6HWWDBqq7rqzfpodn2zOX0rHLrQ07HZaCuMVx9wYiTUMEYIe5Ch4AE0vy0+Laeh0byxXWrFDOiNEG2+uJ2pBj21Ushs0pCGezcDj91Wu10FSuCeF6mPZp4Aqyd6fXqeWdtDvzIeUFkU4A61q4WDgbsUarAEdysZCXd3A7PnAX/1gi8vT4aCB4RCASkUQtRNy2nYSIBgrZgBq+C1el937JgcKKjGSKipY6Yw4Ko/r8g5r0tDO3PtteAl4Md/JffbjWkHM0+AnYGwkcHSbSPBISE7nhwz/J5W8IKR/XLwpQ/GAhkKHqDW2SbEpeU07D6vvoCpcKx20J2ZMaBOQ9QbqJUZlZ/qbT3Z8ylDQjEWHGvohpGgUpSMB+l6ii1N00WQ2nMj9Z9sVOyoFfAp+LLFHpuCQTZrEq1LCEPLaXjjl4Fowtk5iV7go/+z9oBm5nFQ5+tDTayQqMk5N9Vw72bgnnMr8++NUu28otWLLblENqqvyE8AkL0KTYY8Ch5QKBT87gLRIC2noTrYG2U96NMgtVkKtp/odUQTlUF9RlkPLARc+Wf1BcaZoQmYM9Rw72bgsVWouyyvW7RqsSUXKYRbKJjYTXyYgiBDwQNabn57GtKSGl6+wl72gtMsBSPe/8dTr1XrddXa9m6gScEz1PCpr8B3IwFwVisiFAFKVoarjVRXAQnxFjPW3aTJUxBkKHhAy81vT0M80VCbQpiYKe/LnAnW8rP1ZCkY8fov7Le98tPueRWu/HT5T0MNG3mS7zwHmHeTO311Umwp3mVdgyLWDuRcqCugx4usBwe0S6d8e22iEjIUPECSpNbKwZ+GONLQygC4+PfkQVPv7td+8Qdp+Vm3XOJOrqNmKrgxAO/993INBkMN6w2u1BcmMupr5zny8sK1uOozznTOnDE/Zvc1HcOAWQO+Vi6Uoj3GdRSIpkOGggfk8/6mFRGNY1tDfQ0BvQFQMaBYuIddqh3QMI1kKVTAq6P+rUpCf+RB+cduFcfu82UjTD9g51LA1s8BAPLn3lB93o1fdhajYFS5UO2rlprpmwDAgFuGnGtspYknRgIAcH/LGwPIh8kza0rYYWByg7TgRKz/MMb87gLRILY1bKSQkZ4gBLh5maVgZxnpy1cAaw8Bd4/JT95GhMJyP81W1SsVgae+Yqzh5SuAWzYC0Y7a/bVT3ljFjjeEheozBOvJWGkBmEAljptO0aXvHJuQR8FNFBd0Z2oM6Oj2b97ZrJxus6/n5Dw7bd2+Lws6OzvtNXRzcA/CaoJWWQpuYLckNKCZkvg3lL0xsQ7gIw/J51tlY4y9aazh3s3AT2+fKgOsZl7oPQROsJuuxovVXharantfn+ehxyD4dErT996DBhkKbqFxQUtt5yHu17yzVTndevpR7/WcnGenba02VkaE1ToE+v0A8NRXIElAPI6KfeV25biDN+WBxo2I/WhCvu43LtXFOozKkfy8OPU70Wt+TP1tlf5YCzvZEXru7oHtyHun8Qtmg3j5Xg3oPg+SJCEej0/tM0qN5KWqQk2OacRFb5bqNs2NBACQIt2IFyb87gYBMhTcQ+OCzkWUJxk/5p2tyunW0496r+fkPDtta61xb2ZEmB07+ry8+JB2/9a/BBgDijnkOucBY/sr9pXbad3Mjo0EZQAvD/aaoEdtf7RP8+prqL+tjpX7oxm03VoF0gonsQ1ueU7MsiWUqYlcTlcC2Co1cue3G/MqNIKRoTHNjQQAyH32V8C/DPjdDQJkKLiHVRlbkftR7/WcnGenrVWbWkaE0TGj3H2jtEC7qYIsLD+dmmY91Jgu+cal7sU6GOHE5V8PN37ZXv0FOyWh7WI0NQHIMQqP3QZ0zgMmbT7tu1XHwQ2sYjgaYe514pSDnnud3z0gNJCh4BaaJ6rO7FuV+33qR9X+Zl7PyXl22lq1qceYqTEwVGhoB14C7k46O0dLMwxKL1/DTmyD0ykQO1ikVjrSUFOoyTGz5xl7BdT4A68Xb7IDC8uBmW6uZ8HCwDpFa7f7/6c/QWc263stB0KGsh7cQhOZXJ56UMvY+tSPMo30o97rOTnPTlurNlZrDZgdqzEwlDW0SyMG4d7NcqyD13httGozFox+1h7yxqNhkv3gSENNoSbH/NULslGg58Jr5d9Gx5qNen9/+hNZCzfS67TvmVmGSj0o03K5XA5YNyIbC4SvkKHgFpevAP7wn4Du85GLdMt53n/4T83PetD0A2CN96Pe6zk5z05bqzZWRoTZsSs/Xb0/FJVd4wByka6qfaY0YoipQZpeu77ddPkHDZP3rqxhLeZe13h8gmoUaNnxLbm+gpkh4QWz58mDtmoIs7C8rb+/RtPr9Nf8yIPuGQt/sAEApmJM1o1MGZuELzDOW69GuFOGhob44OCga9cbGRnB7NmzXbseYQOXsx5Gip2YHZ6snfXQaJrmNy41CQJkcryDG1kPLCRPjajHus8PTsloN1jfa2gsjHTOw2w7MQrd5wN/8xtP+lDhnq/VthbhmL3VPO1Q71SB0f2YsX52fdMGikFg+D3q9RSNSDRoOK1fv37nunXrrrLTlmIUPKCjw0YxF8JdrFL6zI5Z7O/IZIBEorKtF1jFDaw91Ni19Sml6uAUpJLRbmCS/dCRfdve+W7EbpgN/Pr9ezfXZyR4Ed9RD076vm5k6u86YiPoezQ40NSDB7TcEsXTkKZpaBVf0ShWVSO1WSGiY+L2tr1MsRvvtVnMi3b/3s31Ldl9y8Pux3fUm1VQb9Dnn/7E8Wu69xl00GdtTA1RhgwFD5Akye8uEA3SNA3dDj7VUm8Kq4h85MGq4Enphq+h5lccC7nzXpsFQ2r312uYeWHQ1TFwA2gs6FMNpLQ5CLvyGYwmgFv+txLb5JCGjAWGcixVC0CGAkH4idvBp1rspLC2MgMftl7XIRwHPrbRnfda9WpYBRG6XcukUbQDt50BfPY894pSdZ7jbL+KmXEz9zq5/7c8bPxZsvMe6u//O39U+xwzbhmS06UbjX0JCBSj4AE0tyY+TdWwnpLJdrjxy5UxClr8SN1tMh0dHd69t0ZYlZsGGliZkxuXeW42Iwfcu9YX9leXqe48R96vYPgZNKoFoV28y0xv0zosFoGsjdSbaKi4WQg1VzdtsqeCDAUPKJVo1TPRaQkNteWvx461btaDCYHT8MYv1xejAJivCeE24YRF6qTLGXJfsM5IMdXP7oqeWoyMZi+N5Xq9QOpn8+jzxtVjAV+MfDIUPCCTyZBXQXBaRsNmPlEHjMBpqOrw2OcA1JH50MjiU3b5u7cDk4Loqn4VRrP3q8/antYzm+65fMWUd6qJq+aaQYYCQRBEs9AabgEZkKvR1OCo2i8wTo1m22tj6N4vt5/4A2Ds+x7MyBhbo/w8yhhbozu2kTHW7+Bay5Rr9TPGetS/3e+1Ne3t7c1+ScJlSEPxIQ3rxWyKobnF+XzXzywzJN5dGQB6y5A3wcgBwlePAmNsI+d8lWZ7J2MMnPP7lV2LAAwyVmXJruKcDxlcshfABuUnCeA2zvmwB10nCIJoDLPFpPym+3zzwL/php14iFpP/GZxH26st9EkfPMoMMZ6IA/mWjYCuEuzvR3AlQAGND/3mxgJKjMBDHDOZ3LOt7jYZduk02k/XpZwEdJQfAKvodM1IJo1UHtZ28MBgdfPLn/3drVREE7I+wXBT49CL4A1ildB+9TfA5QNiQ3aY4yxQQD3Wl2Uc55EtQFCEAQRPLRZDLUqNzZroG524N90QCCjwAjfDAXO+TBj7EqdkbAYshehasBnjC0AMKzsN0UxJkYhGyI9mmkMo3aDALBy5UqsXLkSuVyuvGJZR0cHCoVCuTpYR0cHSqUSMhnZhaTOn6lWbyKRQCgUQiqVQiaTwcTEBCKRCFKpFAAgFoshFothcnKyvB2PxzE5OQnOOaLRKOLxONLpNEqlEiKRCNra2srboVAI7e3tyGazKBQK5W1JkpDP58EYQ2dnJyRJKt9DZ2ena/cEAPF4fNrcUyaTwcjISEvdUyvqZHVPoVAIo6Oj4tzTf34TsUgXJtvOlbcLk4gXxjAZPwechRB91xLEs9nm6HTuDcCf3FB5TyMjTf3fy2QyGB0dDZ5OLfJ5ckJgVo9UPAiHAOiNB/V4RTyDyTX6AYyqxgRjbCOAnTWmKlxfPTKTySCREGf+iaiGNBQf4TS8uweWAYPTbP0B4fQTDCerR/qe9aDhUQA3mhgJiwAcrHUBzrne47ANwFr3umgP1WojxIU0FB/hNGz1ktoOEU6/FiYQhgJjbAPkeIRdJk1WAbDMXlDSIbnimVBJAmh6eiRBEIRjrGIQnAQ9EoTL+G4oMMaWAdjGOd+ubC8waLYMNQwFhft1HoV+m+e5itP5HyJ4kIbiI5yGl6+QFzXSL4s8e57/6zz4gHD6tTB+11FYBDnocLviCegFcCuAXZo2qoegKohRiUlYwDnfwjlPMsZO65oshw9TD5EIFbwUHdJQfITUMABV+IKCkPq1KL4poRgA25TNjZpDRrUPhiFnMuhZBNkYUM8ZUqo7JiHXXNjoRy2FVCpFQTiCQxqKD2koNqRfcPAzPTIJG8XDlXYDJseGAAzp2hqmQxIEQRAE4RzfYxRakVgs5ncXiAYhDcWHNBQb0i84kKHgAfQPLj6kofiQhmJD+gUHihYBcOLEiZH169cfAYCXX365+7LLLquqbOJk/7PPPjv72muvHfGux/Yw63Ozr+fkPCTgOfYAACAASURBVDttrdrUc4w0dPe8Zmto1j4IGk5H/ayO02cwOBru27fvYtsvzjmnH80PgKFG9wPY4fd9WPW52ddzcp6dtlZt6jlGGoqtoYWuvms4HfWroQl9BgXRUPtDUw/V/NSl/UHA7b7Vez0n59lpa9WmnmOkobvnNVtD0s/d8xrVz+o4fQbF0bBMYNZ6aCUYYzs457ZqaBPBhDQUH9JQbEi/4EAeBW+wXISKEALSUHxIQ7Eh/QICeRQIgiAIgjCFPAoEQRAEQZhChgJBEARBEKaQoUAQBEEQhClkKBAEQRAEYQoZCgRBEARBmEKGAkEQBEEQppChQBAEQRCEKWQoEARBEARhChkKBEEQBEGYQoYCQRAEQRCmkKFAEARBEIQpZCgQBEEQBGEKGQoEQRAEQZhChgJBEARBEKaQoUAQBEEQhClkKBAEQRAEYQoZCgRBEARBmEKGAkEQBEEQppChQBAEQRCEKWQoEARBEARhChkKBEEQBEGYQoYCQRAEQRCmkKFAEARBEIQpZCgQBEEQBGEKGQoEQRAEQZhChgJBEARBEKaQoUAQBEEQhClkKBAEQRAEYQoZCgRBEARBmEKGAkEQBEEQppChQBAEQRCEKWQoEARBEARhChkKBEEQBEGYEvG7A0Hg/vvv5z09Pa5dLxKJoFAouHY9ovmQhuJDGooN6ectJ06cGFm3bt1ZdtqSoQCgp6cHg4ODrl0vm82ira3NtesRzYc0FB/SUGxIP29Zv379EbttaerBA7LZrN9dIBqENBQf0lBsSL/gQIaCB5C7THxIQ/EhDcWG9AsOZCh4QChEb6vokIbiQxqKDekXHEgJD2hvb/e7C0SDkIbiQxqKDekXHMhQ8ABJkvzuAtEgpKH4kIZiQ/oFBzIUPCCfz/vdBaJBSEPxIQ3FhvQLDmQoeABjzO8uEA1CGooPaSg2Xul3JpXDibFMQ9d449Qk7nn8VeSLJQDApFRAMp2raMM5h1Qo1v0a//fgCLbuPl5+DT+hOgoe0NnZ6XcXiAbxQsOUVMB9/7Ef+98eL+/7zAf78fuX/pbrr0XQ51Ak9p0Yx44jZ/An17yrvM+pfmdSOSRiYbRFwwCAbL6IQyMpfPY7O/C+c7swtPIqAMCH7n8aE1IBh++72XE/OefgHLjn8Vfx9IF38NEr+nBpXzd++57tSOeKOHzfzTh6Oo1XT4xhw88P4NBICv+5+sPom5lAOFRt+GRyRYxn8+iIR3Dpuifx0K1XYOn8PvzDLw7gn3/5BgDg7fEsPnfdgOO+ugkZCh4gSRLi8bjf3SAawG0NXzs5gb94ZCcOjaRw9YW9CIcYdh9N4md73yJDwSPoc9g4mVwRe99M4uoLexEyGOjc4g/+8b8AAH9yzbvwwvBpbHv1JD73O+c40m/+V7fh0r4u/PvgB5DOFfDb9zxVPnY8mcG3fn0IADAhyWmXO4+M4t4n9uPf/uxqdLVFkckVMfjdHbhj8btxxflypV69V+Pz39+F0VQO45mp1M1coYR0bspz8KEHnq445y+/vxOvn5zENz+1ADfMOxsAUCpx9P/tE1X38I3tr2Hp/L6ykQAA9/3HfjIUWpFcLle7ERFonGq488gZHE8auzNPjWfxD794DR3xMB757EL8zsBsAMBH/+ezGMvQPKxX0OfQPv/1+juYO7sD582szDT45jNv4J9++Qa+/WdX4/pL5njejz/4x//CvhOyx+33Btoxu3emo/N/c3wcq767AzuPnKk69tWfvarb3oc9x5LYf2ICvz23F/veHsd/vT6CfLGE82a24+jpNDZ/7gMV5zzx8tsAgPee01Xe96+/Hq7ZJwD42UsnyobCqkd2GrY9cjqNdT/+TdX+o6fTuGCWf1kgZCgQRINMSgXcuvE5FErctM1vX9iLf/7j+Ti7a6okbU8iWjWvSRBesnnHMfyvp9/A33/sMvzORbPL+//kW/+NRDSMfV/9/Yr270xK5fPqMRRePzmBh556HQ/degWi4dohcaqRAABmH6fXT07gkeeP4Esfea/hNZ9947Tp9UNs6rp7jiUBAO0xeaqCK/uz+RK27HzTsp/arm179aRlW5XHdh/Hn39wLr75zEHLc77zXHVl5Q898DR+s34JOuP+DNlkKHgAzY2KjxMND7w9jkKJ456PXYqFc2dVHQ8x4MJZHVWu2+5EFIdPpxruK2HMdP8cvnkmjQNvT+C6d5+FiDKg/uq1d3D4dBp73kxWGAoAkMlXB97FI/IgGtYVP+KcmwYbJtM57DsxgQ8MzMIdm1/Cy8fHsOpD/bj8POOF954+cMpwfySeMNz/tcf34VevvYNlV56Py87rNmxjhtb4iIYZ8kWOqduQD6oGBAB86l9fwFeXXoq5szuQ0UwvaA2aosUDgp6P/POvHfVXy6XrnqwrrsINKOvBA8jlKT5ONHz1xAQA4Lp3n4WL5nRW/fSf1Wk4v9udiNLUg4d4+Tk8MZbBj/ccx4/3HMdrJyc8e51G+ItHduEz39mB/z48Wt5XUgY1bnNsS+fkufhiaSry/sRYBvO/ug1P7TuJsUweXHexP/v2i/jEw89jUiqgpBwLGRgVn/vuTqz78W/wveePlvd96eb3lP8uFow/G6dT1vUVetqjNe5KJl+U+/bLfadQKJYM35NfvzGCD3/9GTz5ytvIGhhSJSW4sdUhj4IHkKEgPk403HdiHF1tEfT1GD8BmdHTHsV4Jo9SiXsaKDZd8fJzeO8T+/GTl94CALz77E784m+u8+y16uWI4q1KSVMDnP7p99evjyBXNE/h27zjzarz9r89gWQ6jw0/34/XTk7iize9B7d9qL98/BVlTv5//GB3+QneyPnw81fk+f5F75ma0rj+kjn42uP7AACFfH36OR24/2Hba7hgVjt+YTEd8LlHdmLPl3+v4dcSFTIUCKJB9p0Yx3vO6XKc992diKLE5Sjs7oS9pyAiGKRzRQyc1YG5szub5lH4/Pd34bp3n4UVV51vq7063aDNw1ef8FUvwKe+9YLlNdqiIWTzJWhT+dX/8hNJeXXHe57Yh9kzYgCAi+fMQFG59lP7T+GSs2cAMPYoqGzfNzX1EI9MObmbOQb/718NV0wn6DEzCEqcgze1p/5AhoIHdHR0+N0FokHsalgqcRx4e8L2l7eWLsU4GM/kyVDwAC8/h5xzJGJhdCUi5cHXax7fewKP7z1R83/txFgGP33prXLevtZQKDqceggrA7x26kE1iCPhqcH/bza9ZHi++t4Y1RAwYk7XVDpkKNpWdTyZzpWzCJzyxwsvwPdfOGp4zMpIsMJBeILQBNJQYIwtArCYc77W4NgaAMMAegGAcz6kOz6o2ezhnN/vZV+NoOVRxceuhkdG00jnihXpUnbpUYyDsUwezs0MohZefg6LnCPEGMKMlef9g8Kq7+7E3jfHytu5wtQgr2bm2O2x2q7IZSPjr3+wGznF8NAGOP7JNe/CmXQOP9t7ouL8UxNyPIFdX1s8Esb3b1uIP374BZRK1VMi9yjTElaY6eHF7N4rb41VGF2f+65x2qPoBMpQUA0EAAsgGwP64xsBPMo5365sr2GMLeOcb1G2N2iNC8bYAsbYmmYbC5IkYcaMGc18ScJl7GqoPom8pw5DoVtjKBDmrNj4HPa9NY6l8/vw1aWX2j7Py89hsSQbCiHGAvdUqf9/emj76/jOc4cBAMPvyHELdj0KartSieNMOofHX54yBKIaj8Kszlh5ysGoL4wxPLbrTQy/k8JVF860TLVUpykKBjEmj5qkLRY0XhO1oJLb/Pr1kap9X/7xK3jfuVOffTXuotUIVNYD53y7MtDvMmkyqBoJCtsB3KXZXqC73i4AV7vbS4KY4tW3xhEOMVx8tvNUvG4lOjuZJkPBih2HRzEhFbD7WHURHb/gXHanh0Jo2tSDXfTdmfdbM3D2jDacPaMNC+f2ym1s+hTUdoVS9XoD2vuOhJil1yDEgHU/fgX/8vQb+PNvv2iYQTDVVr7S8TMZHB6xlz78v545WLPNI88bTzvY5fPfNx6WgrAWg9cEyqNgBWNsAYCkbvcwdMYBY+xRALdxzpOKh2JTk7pYhmIUxMeuhvtOjKN/dke5vrwTehJyABh5FMwplXj5ib1QdDYgu/E53Lr7OHo7YvjQu8+q2C97FKB4FIJjKIxn8zijK+L1rU9PPStxzjH3rifq8ChUH9OOj6EQM8xsUAmHGLoSUUxIBZS4de0B9ToP/PIwvvjzI7ZqB2jXTwmHmKPaBo2iLd/cqgTKo1CDfgCjRgcYY2olj1UAFgE4pMQy9KjTEs2kZPSpIoTCroZqxkM90NRDbfIaHXImT25//8Q+fODep/DAk/sr9jf6OSyWOG7ftAcr/+2/q4/xYE49fOj+pzGRNXe9q4GITmMUCqXqOgNaAynMGKx8CiFWOXhbGVdqLEHYQUyB9nJhxtB/Vus9rNkNCPUCYTwKNegFkOScDzPG1kKOc9gAYIvyU4US9DgIACtXrsTKlSuRy+XKudcdHR0oFAqQJKm8XSqVkMnI9fzb2+W62+l0GgCQSCQQCoWQSqUwNjaGOXPmIBKJIJWSXWexWAyxWAyTk5Pl7Xg8jsnJSXDOEY1GEY/HkU6nUSqVEIlE0NbWVt4OhUJob29HNptFoVAob0uShHw+D8YYOjs7IUlS+R46OztduycAiMfj0+ae3n77bXR3d1ve03haQqiQwfvObsfo6Kjje5IkCfN6gIl0GuPj46STwT2NnBnHRV0ljOcYYihgZGSk6p4OHjsB5DPYfegdnD59VvmeUqkUJEmq+55YtA3ntHN0RDhGRkYq7mlOVEKaR5FgOVzQLvfLC53+9f8eRW+U4yPvPwd97RzjeZT/14zuqZjP4bwOoC3MUSgxnJaAsbGxCp3OaedoK0xiZGQEM6Ic7RFgRlQeaTOZTIVO3VGOUpjjrFgOY2dOozcut+uNc3TGC2AFjiIH2oopzGAS5rRxZIvAnITcbiLPkC4AE8lRnNcut5/IyfdwUVcJmQLDeB6YFQciIY5kMolSIY93dXJc2FnC4ckQstlsWacLOzlOS0BXFMhMnMHp0wXEE+3YM3wCF3XJr3laAs7vAEKSbCieyjC0hYGumHx8JMsQZsBM5V5GJVa+JwA4IzEUOTC7Td4ezzHDezpb2e6MF5GMcMxJACHGq+4pW2QYywG9cSAa4siXGEYloDtWqVNXFEhEOEqc4VQGmBEDOiLya5zMMMzv6yj//7vxHeGEVjEURoFysOMGzvmQMu3wKGPsUc75cv0JSrbEEAAMDQ3xtrY2tLVVp+Pog6H07kxVEJVEIlFxnrqton8NvWD64063a11P2zcVu/dktt2K99Td3Y3Zs6dK3Br14cCZ03gzxXBJ30z09vZa9tHsnk4X4ziT5ejqqvZKkE7ADB7GG+Oy4zMUYxWaqK9xNBXGiTTDb5VCmDVrqoR2Pp93rIt2+9REFifSDMDU66rH38pG0R6LIMfiGJ4IVfTLTZ3+6Rm57v+nb7wMx9PKgGZyT5xzTOQZJvKANs+gu7uyzPHbGYZMuAOzZ88utz+ZYRV9UXVK5oB8keGtTBTdM2eVB9VRiaGrLYRxZTAuxmbgdB44lZWP/8MnrsZt/2fHVB96Z+HwZAgjyj28cDxX1hVAuc89PT2ITiRxZJIhGmJIQf5eVu/x8CQrt0/MmIlZs7qx88hoWSdAfvKOtXfijcNT8Q3jmr6pnJYqt0d128lc5fZ4vnJ7QtnuC4UxWWCYnAC077teB6fbk4XK7TP5SNX/f6PfEXYRyVAop0RqUFMkk2oMA+d8WNm3nTE2F/I0RA/nXB/f4Bl6cQjxsKOhmvHw3nPrm3oAqIxzLfKauASjgDq5jbxfPwXQ6OcwmzOfuihxeV4+HPJn6mFSKuAb214rl1i+cd7ZuOIC47UU9DA4z3o4NJKqCoDU3neIAb95ayolU+8kZ6iMS1jzw71Vr6UuzqSeOyoxnN1r/uSr9idX0PeL45zuaiNVdJoZd6FHGEOBc75LE4ug0oOpDIleAAd15yQZY5ub0T9i+rHvxDhmd8YwZ0b9X0rdiShlPVigGgdt0VBFPQAtqjGhX3OgUdL5qbl+fZntEleDGb3LetDej742wM4jZ/CtXx/CzPYoUlIRr5+cxJ9dO9fWdRljplkPY+l8ORsHmIpRmJQKeObAOxVttQNXSGMwfeWj7zMMbCxxOVDR7O269FzZ82FVxVGLeh39vTiR473ndOHVOostNRs/Q2FECmYEgCHG2DLN9q0ANip/7wBQMcWgGBbJZnoTgKl5IUJc7Gi47+36AxlVesijYEleeVrsiEUqvAsVbRSPgn6AaPRzqF0tUNIZKcUSR7gczOjNV7jWNtC/hqSkF373MwuxsL8XJc5tp+lZeRT0tRA45+U1TNZsqfQCaFeb1A7uF88xrl1RUt4z036xyt+9cW5p/PGqPzTXMj3L+DUb4Xgy0/hFbOC2IeyEQHkUlOmDRQCWKdtrAGxX6iGAc76KMbZBidztBXBarcyoeA9WMcY2ADgNOZWyx6i6I0E0Sr5YwmsnJ/Hp37mwoet0J6I4ENDVB4OAmvWQiIUxnjU2qNRqg24P2FpDIZMvIhGbSoFVpx6YRdZDoVjC/rdlbd9zTpfjqHXt/ehfQzVc2qKhch/MskL0MGb+dKp/DznkYkq1BsMQY+WBLMSqB2CuXNtqYFaP2fUoqOw+Vv0caHfdFaev5Sd+puEGylBQDIJdAEwrKVoN/Ep8gu+GQb0BI0RwqKXh8Dsp5AolvOecxir/dSWiGKOpB1PU2gmJaBj5ovyEqR8E8gXjGAUrDU+OZzH43Z1IG1Txm90Zx1c++j4cGZ3ySOgLBJWUOgrhkHnJ4P/v2cO45wm55PCGj1+GW6++wLQ/RlilE6qGQjwSRojJT5t260wwMFOPgn4/50AsXNvxrG3CTFIli2XtzEosM+V8efuMxHCWJszkjk17dH2Tr/PAkwdq9k/lqnfNxI4jU4W7BLITfE3DDZSh0CqEQqLN6BB6amnYSOlmLT3tchGaYon7midthFQo2p7vDTGGWMT9/3vVnd4ejyjbHLFI5fuUK089VHbWSsPXTk7gpWNJXNPfi96OWHn/ibEsnhs+jcXf+M+K9n/+7RcR1xTVOnByAgNzOiynHrRTSvXEoWgvq32Nb/36EH7w33KVwXgkVK7lYLtCIDOvzGi0346uWuPN7N+4VLIemPUeBb3ds+/tSs+b1b+m0evMiFcPd8H6xFlDHoUWI5VKkVdBcGppuO/EOGLhEAbOcl66WUu3ZgXJmZoBy2+++/wR/N3W39huH2JyBcAPW9Twr4eyoaAM0vliqWrgKi90pPsetdJQfVpfveQSXPmuqWQqzjmeOfAOkhm5/kMmV8KvXjuFbH5qEH7jlFznIMSspx60X+xG6yDUomgy9bD5xWMYmZRw8+XnYFZnHCEGJDM52ysgMsB8lNXsVw0vW4aC9m8GwxE4VywhYVHBVDUQVENDrWOg78/UduX0UC1mz4hXGxACuRT8LABKhgLRUmTzRVdqr6dzBUyYzIkDwCv/f3tvHibJWd95ft/IO7Ourqo+1Oqz1FLrRFJLjQTCoKMbAWIYZLeQYU0Dy9DyYg+Lj2mtjA3Gs4Pdws+s8ezsuBuvZ/2Mx2OjZmzvGo9sNQZsjMCS2phTSOrSga5uVVVX15GVWZkZ7/4R8UbGnRGRcWb+Ps/TT3XG8cYb+cvM9xe/8+Ul7Nk0goIHs6wbQlFYTJmi8OiZOWwcLeFDt+zqeWyzJeNzX34az762itv2hjsPoQSI+ACzeV2Wubbo+3nikjV/unGhYIzhtsuNys77bjK6DD7zVz/Eib+b1bpHinlIpkdp2bDoep6aZY6AsemRzDneMDOF//i+fdqcf7ywhj9Z+LGncSXGXGIUrP/Pe7B0Xbu9m5CmuB6MCBfPmkuPB2ZyPdgf030vWx0ZV3zyYfvjbDQVu2FTZsRzhSwKA4bfqldEODz+3ALec/zRUHx5m8rcUqDFzKEbtvV9nYlqOss4/+jVZezbMYGP3rqn57GNVgef+/LTlsyAMBBKn1AUzAF7+hLPZrG7fQ/FaUHcPaJrYk5i2kIjcw7JtBRxzlHIMbQ6PFAOvD72QX/fHMbFVMxhslbEZK2oWTycYMw5rkLvevAaZf+hW3bhss3dWB27d1RcbstYGa8uNWzHEfchFIaldYZJXYwC50BBkrT34v/822cc52SrbNhsy5CegNWIumJ6gRSFCMjn6W1Ngi999xXkcxL+zVv39m1RlOQWZKngeszbrt7S30WQzn4PjVYHz83X8Y5rLvJ0vAh2a7bDb44jLAh614Mefcqk+YnL7XvYcbAoeEFYkRigWRHs1l0OIC9JaHU6gRQF/Tl3/e7Xu+NybnhiFvdQzkvYPFbqrSjAxfOgt4Kof3dMuvdNMDfMYqpLRo+Xp2FxhrifRsc8H25Y2b/+jLXts3msXtuylPWQpFpDK1oEUIxCMnztR6/h5pkpfOTNM32PNTc3ZymXGgWa68HU8S9JZl9bRUfmhqdENyRJCWTU+/HDQotRcHA9tHRWDD8xCuKJOphFQVEUOrp0P7uFUGRGsIBFmfS6xW17N+ILj7+ISzeNKEqOwaKgWjg8dlFizCXrQf9/9cVkrYD9uzZgfnUds69Z2z4z0/ESsy5p+n1u89IfI3or6MfwI61//MQdePh7r+KTf/F9dVwbd0SW9IQESy5ReD4xELwwX8fs3CpuNT3dpJ1xtdX0UoosCk+pdR32bvGe+lnKS5FYFITFoFJUnmlcXQ8+FmNhUejH9SCKLgEOigKHFscQyPWgjvnv7r4aDx66Ftdun8BFExWYHqy1xS7nogDoWWm28UfffB7/5dHnLPv076FwQ4gF3E5JAGziPODccvrOq7fgzqs2a4qfcZzu+XaYXS5uMAZsGi1j81i3aurtl1sDbb3WWxh2SFGIgGIxPUFpw8JXnzoHAJZAtKDEJcM0uh6eOruMQo5h15T3Vr3lQi4Si4Io4SwWFnfXg/FcNxmKhbsf14Ostpq2u7bYz5hicQmS9SAUhZzuSZtzri6YVteDndLztqvs3WPrHRm/pj5p6zGY+nX/b7soOmIqXcXCeozYt21DFcfff6NttpA5mHG5xSwxE26trG3HUl+PlvL4xbdeZjk/S2oCZT0MGKQoxM9XnjyHnVNV7J4Opw99XDIs5iVUCrlE+z08emYez851nxb//uk5zEyP+KqLEJ1FwV1RENkAduZ9NxnKfVkUVNeD7O56ANTGUYw5Bg+6YVZmJNVioCyYXcQc8pKEX75zL37+v57GyxeUgMGfv905GPXWvRst/RvsbsMt+BGwWgAYs24T4zLdMdZxFETcR70N6Pte+rIoqH9FjYwO5yjl7awY2VEVEtQTSFGIgpWVFdsWu0Q0NFodPDo7j3tv3B7amHHKcKKabL+HD//hY6ib8tHf+3p/VQTLhRyakcQoGNMjzf0ehOJQzEmWRc5NhkLfcOs94ERRUxS6iobdQiqrC7rSOMr3Zbp+falrUZBVi4Jev9EUCYlh344N+Pv7b8clv/JXPccv2yycxid45S8Dc1WozG+hnetBG8vl7TbXUdhsilEABy7bPIpv25Rstk5K+SP6TjileGZIT6BeDwTRD996dgGNloxbQy72ExdJtppud2TU1zs48uYZfPhNu7XtG0f8pfhGZVHQsh4cLAqixXApL/n6IRULe5AiqnktRkHu6XqQGFNcD31ZFJTXDAzfODOP7ZMVg+uha1Ewmtv1+8zkJGZ775YsA3WM3dMjOP2C/QKtuR40xcZmXDGWOMdmHHHe5tEyPvym3fjadwzNgMEBbJ+selMUTNd1giwK3iBFIQLI9RAvX/3RORTzEm6emQptzDhlOFYpYDEhRaGhZg1MjxQNgV9+URSF6GIUKgVRwlm23V/M5/zFKITheuDdRdwpmJEx5Wk8SNaDqLTYMSk1CyvrhoVWb1EwY+fT/+L/8kbUSjnbOgR2WQ8MxuqMh27Yhq0TFfzul5+2vYZdp4euRcHFMoHuffzaO6/E0tISvv1qUzcG91wgyeoOyb5FIYj7KiwomDECqOBSvIi0yIpNJHVQ4pThRKWQWNaDaHZUdimt6wUlmDF8i8J6u0d6ZEc0R5IsT49uMhSLbxDXgxbMKHcbVNkpAmJhC571oPwV/UTuUutaWNMjlb9eU2xv2LkBl28Zs32a1t+H+B9jQFGXerl/1wb84sHLtNfdYEbda4e31UuvB0HLtDzJPtIjvWdHZEdTSNKiQIpCBKysuBc8IcIjqrTIOGWYpOtB1MrvV1GIzqJgdD1Y0iM7XdeDeS12k6FWwjmARUE0pdI38pJtbp1zaFkPQSwKQvHRnuZ1bg67gkviO6Bf+9zWQTtrijHrQbgLmKu1zjyK3SUtd28zMXPWTJUZKxFyWDuHep1Tv8elggQ1BVIUIiDJoJNhI+y0SEGcMhyvFBLLehBWALdmPV6IyqLQNpVwtqZHCteDNUbBTYb9WBR2TFaRlxjuet1FPVwPvK86CuZMAe1aumwLoPtUXLXrjujhCX7S0GPE3qLwdpcqnWZli8Nq+pc1pcOZbRuMxbEY4xZXSNgLe5Z6PSQJKQoRUCi4l/4lwiPstEhBnDKcqBaw1upoZvY4EU9xabUoaFkPBXfXg6IoGM91k2HX7+9/pdizaRRP/7u342du3unqetAKLknOHSa9IBZ0sfiKbArBxhFlob94oqIerwt0dFlahZJ07/5utpD+Nh7+7qv28/FQi8Ap68FNc9k4anQVdbjxM8m5w8U8XN/5ONIUvEDBjBFAMQrxEEVapCBOGeqLLm0cLWG50Qr0BGpHpZizzR8XrKXcotDqyMirJaIB4MlXl/HN2Xlt/w9eVgL+FNeD9xiFfuooAPpyw8rfLzz+Iu64fJOhi6IouAQEC0Qzn9G1XhgXwo8fuAw//foduGjcaymd2QAAIABJREFUGozqJR1Rf4j+mke/+B11DPf3yJoeaUfvrIeSqW5Hk1s/k54LLjkGSRhfZsmiQN0jB4x6vU51FGIgyrTIOGU4plMUTj7xIo49/GRoY0+PFPHoA3c4tsPWFIVif8bFKGMU8jmG0VIBEgN+72tn8HtfO2M5brxStDy1u8lQeDD6XSi2TpTBGPC7X34aX/3ROfy/P/+m7k4Ro8CCVWbsoi7oeneDPkZBYtg6Yd/Twu32JGPoAwDg3FITp58/j5/W1dFwGuPf/surcPzvZrFtg9LiUe/qcc56cJ6PWSGpmGMUOPdhKfB2XJaiFCg9csCQ7SKbiNCJIi1SEKcMJ6qK6fjUD8/is3/9JG7bu9HSkS8I35pdwMPffxX1ZgfjVXtFQFgB3KwOXihFVnBJRkGSMF4t4OGPvxlzK03LMeOVAh56/EV861njT6mbDLVgxj5Nz2+8ZBrf/fU78bH/9k94eXHNco3+YhSM59jVTuiFtwJH3YN+9o+ewEqzjVv2dBuiWcZQX7//Dbvw/jfssr2medHXPA82So/z/Lip90T4QYpZsiiYi6LFCSkKEUBtpuMhirRIQZwyFK6HBx9+Etsnq/gP79uHEZvANL8U8xIe/v6raLQ7GIe9v14LZuzzPSznJTTaHfWpL7xf31ZHRkE1SV+2edSxo+UX2UuWRy43GfbTPdLMSCmvFnwyXUONUQia9SAQb6dkUBT6n7ed62GlqTzF661DXq+kv0PHGAUftHUhdF958hxeudDAq0sN/wO5QCEK3qAVLQLI7RA9Ii3yZ27eGcn4ccpQKAo5ieE/vPf6UJQEoBt3sObyJCL29RujUCrkwLkSfCjSB4PyyoU1fOg/P4bV9TYWVtZR8/B+2PV6cJOhVnAppJXCzr2gNYViwF9991V8/+ULuGrruMMIvdHPNAzTuqYk9ain4D/g0y7tslvl0StNufuZ/IN/eBaAtYPlrqkqnpuv20zBZNFw6sWRAU0haAnwUOeQ7OUHk3rd5oNLhEpUaZGCOGW4eayEqVoRn3jHFXjdtoneJ3hEZDI0XEorh1VwSQSiuV3LK7OvreLJV5exa6qGO6/ago/dcWnPc+x+TN1kKPeR9WCHnaIi0vneoaYWfufFC77GtKRH6n6twyg81M2msKJ3lXipkwAA792vxDVM1orWGAXTuV7mX5Ha2nlOFpnj77/Rdnv3Ov4CMdNIv0p8GJBFIQIoRiF6okqLFMQpw2oxj8c+cSC0RUvgyaLQkg3HBqWknt9syUCfxhixKHzsjkuxf9ekp3MkxiyVGd1k2OE8FLeD4fqWHkZKjMJP79+B3zn1dOCxuy2TA8QouO6zxigI9IqC14fZf/UTu3Hv67djrFzAs3PGfV6CGc3kPFx5rGK/hHm9DpW88QZZFCJACtJphvCMSIsMuxqjnrhlGLaSAAClgvqU7xJkuKYFM/Z3v2VhUQghRVKsUb7eEhuLgpsMO3J4bgeg29lRjywbF2G/i5JZ8XHKenDDtbeCs+fBoCh4Te1kjGGsbB8L020K5TIf8xxgfe/M77FfGZqP7vdzL/ifbvLXbdUPadBlaEWLgGq1mvQUBpo4ukUOggyFlcBt8W62Oijlpb4VFc2iEEKKZJCMBOWJ3viT6iZDmfNAnSMdr2/TIVLEKHR7IQT7ydfM6EGyHryMq9smPgb6eAtTjSuPgZTGY741u9BzDPO705C71gIxHbOy5fS5FQpJr/d875Yx1/1Vj0G+WXBh9AMpChHQaIQbmUsYiTItUjAIMix7UBTWWp1QskbEk1kYraa1+AFfioJ1EXGTYUfmIVsUrK4H0T1SXMW3RcG8KBosCt7wFKOgH1dUmtS7HgLY583X/ZzaadJP2YKS1LFoD2aLgtNnxFIEyuE4h/IiAIBvPnAHbtrtzfUVJT93256kp0CKQhS02+3eBxGBiTItUjAIMqx4DGYMI1iqq5SEYVFQ/vpRFBisKYhuMuzIPFR3j53rAVDbImsWBX+Y/fphp0dqsQ+6scRb0tYpCmFVCQW8WTgEBWZfFluPk7LnvY6C/ZG/etcV2GJT6dIJvUulkGP46i/f6vncXuzZNBLaWEEhRSECKEYhOqLqFmlmEGRY1oIZ3WIU5L4zHoCQLQoBUunssh7cZChHEMxoiVFQ6yhoi0jAyDmtSFEf59rus7EoSDYWBfP76t/xoL+m93tZbnYwO6ekQ3ZdCMbJjJb7C2Z04l/9xIznY//7R99ovDYYdkUUZJ0U2f81TCGD4N9OK1GnRQoGQYblQu8Aw7X1TiiKQlmf9dAnPECMgliA9GZyNxmG7nqQGEyNLdXKjPoYBX+Yjw+7MqPmx9ddSLznf/39bkOoIMWinCweft7xU08vAgCeObesm0t3/8UTFUgSwyUblUX5na9z7nDZnZePCaC35YYxYN+ODYZxg8aiOJGGzAxKjwTwwkIdP/fHp0Mbb1Rax7Jc7H0g4Zt//vFipGmRgmazmfnCWZpFwS2Ysd1BpdD/80K4FgXlrx+jDtM9tIv/u8lQCWYM1/Vg9uXLXJlY0BgFgduTfy+KLlH9dre/aayE5+fr+MNHn9e2mbs6esHZomD868ZYAVhuKUW8RBt2vdKSzymD5NUPypVbx/CX33lFHb//rBBP55v+AulY2MOGFAUoT1xPvrIU2ngXV9p4aY3e2igo5SV84I27Ir9Oq9WK/BpRU8pLYEzJbHAibItCODEK/qsmaiZzziGpP9tuMowimNFacElYFKzWDi+YjzfEKHgcY/OYs7L79qsvwlNnl3Hb3k347F//CACwY7KK5+fryKlZHFO1In7y+osN54XxtlWKvX8fK3mlu0NOYlo7cb1LRMjvFw5ehgcffhJbx+0bY7kRVnqknnbSZRQjgFYzKDXkf/vIraGNNz8/j6mp6CLyiegZhD71jDGU8zlXi8Jaq6OVkO6HMC0KInjOjwzE07Gx34Dz+R05nD4P3esziy+fazEK1rnpabQ6+OB//kcsrK7j0A3bcOTNl9ger59tGB/Pa7aN4/c/sN+wTSg7eVVRuHb7BPJuqQEOOM1PbP/kO6/EN2fn8at//j3HMWSuHCwxYKpWwpnXVvH63ZM49UPF/SgsQm+7egvedvUWnNP1gfD6/oyW8/izj74Rd/9f3/B2ggPR/l4kr3hQjEIEjIwkH6VK9MegyLBckFyf8hutDsohZI+IzInVZv+KgniQ9rOOM51FQeAmQz8ti71d31qYSOYcDEa3iB1nlxr45uwCnjq7gr/5/lnbsQFTCeeIFiZRzDIvBQ+gVM5zr2+wZ9OIpU+L+ZbOqc04JcYwNaK4co/91Ou0/ebPx6axsqPy52TNYYzh+h0bbPf54WzIzarSBikKEdBsWlvhEtliUGRYKbhbFBotGeU+W0wDwFilAMaAxbX+XTZBCi7ZLcZuMgy7hHPONuuBG7IenJ4L9acZWglbsg38ux688qC6AGvvvct704+O4ufcUTXMK6d239y7eRRTI914CbvPRzdmgBn+OmF3m8YKmN7YtsG/28MraYh5INdDBKyvryc9BaJPBkWG5ULOQ8Gl/p8XcpJSvvdCvf/3LUgdBXGs/kfVTYbtCLIeZA68tLiGL33nZXD1/1vHK906Cg6/+Pqt9XVr7YduvQP9xpAmrrJjSskQEdUkhRIV9C0K462tqTEKopiVeUwRzKhH+Rw4W4vMikOY3UMFn7n7mlDGTBOkKBDEANNLUWi0OqFYFABgQ7WA8/UQLQp+sh5M57rxF99+CV/6ziu4bHN47iXGlGv/4Teew4m/m9W2v2FmqueiKRSIWjGH5+brmF9pYmqkZEmzMwYzhqspiNE6suIu6V4r5OsEWJiFEmZWHG0XeWb4E2g+fmaona876X0R9n1ICnI9RMCg+LeHmUGRoVuMAuc8tBLOADBeLeJ8CBaFIHUU9FkPAicZnnlNKeLzqX9xVdAp2l6fc0XxGq8U8IPfuBM/+I07ceynXtczPVJsvlg1Xz/23HnD8dqSrTeJh2xR6MZ4KP+3NevHHN/73lsu0/5vF1Nyz43bLecIV4LXudq5DPx87gT9Km4feMNOx30p8DyQohAFg2K2HmYGRYaVorNFodmWwTlCSY8EFIvChVBiFJS/gWIUdNscZaiuwLfsmQ4wO3tyjKHDOVodjkJOQrWYR7WYV3o9CLeI6Se/0ergiefP48y5FQDAHVdsFhM0HCfubedkDVvGyhivFHDVVvdmRn7pxngoFgWR6GDnr/eyKDqb/l3OMb0eK3S3cFg/D+ZgSMC7K2GqVsR4pYCrLx63ziOAQtavEjVRTXfdHXI9RMCgLDLDzKDIsJzPacVqzIgqiuEpCkWceW2l73FEemSQrAeuM544yVCtgxQqotdDuyOjYPKdO1kUfufU0/i9r50xjKE/zvwkuWOqim/+yh3hTdpmjs/OrSoxCjZvkF2tCOfxHLIe/LzvcjdeQ1S57HldrUS0vXIm+NS7rsJbr9xsuy+IdaDfj9N1OyYc96UhmJEsCgQxwLjFKIhsiDCaQgHAeKWAxdX+LQrC9RCkjoKXhYzz8LMGmOp6aMvcEmTnVMJ50eSm0QIyzWOHPlsru6druHb7BDaOlnDnVVu0rAdD/GQI0whyL5xzrcplz/EdXA/mz5LEXBTkAPcZ5L3Rt7C+bW+0Jen7hSwKEVCrDVZDkGFkUGSoKAr2MQqaohBC1gOgWBSWm220OjIKAYr0CLquB+/n2C2yTjLk4KHXIRDXX+/IKJiiMO16KohjDceZMjfifJKcGinhL37uFu31Wz77FXVO3WOU+/BWf6JXwSUv8EI3FZJ7tCgEiS8wE2SEMK67e7qGZ9UmWGmDLAoRMAgtioedQZGhEsxob1EQ20PLeqgpFR77jVPQSjj70BTE77TeouAkQ6ViYvD52SHGW2/LLhYF48rf6phiERzGTqJIqFtGgRfMp1+7fQK3X74J1253NrFbxlCrP3Hu3QoUtlx70U9uyO8fvtF2LDNhN5kKAlkUIqDZbGJ0dDTpaRB9MCgydCu4JLaHUZkRgFYKerG+jukRYyOhhx7/MU4+8aL2emqkiN+593rbpkXCouDnqd+uMqOTDGUevjlfmOqbbRk5h7xOs4Wg1TZaFLpWEW74mwTdrD99SqaP801Hf/CNO3H39dv8zUHuKpwcXHt/br98Ey7fYv/dFMf07ProcjdG60B00YyXbDJm5SSvDjhDigJBDDAiRkFJLzP+mDXWw41R2KBGbptrKXDO8bkvP431tozd0zXMrTTxrWcX8G/uXLPtAtpNj/R+be1YD7+2HOEHKWiuh3bHGszocK22bFYU1PmZXA8JGBRsrTl9VWT0lCnhfMz8yjrGyooi+gcf3O94nE1ZA9v97vPofYzlHP+neCYNwYypVBQYYwcAHOSc32+z7yiAWQCTAMA5P2HaPwPgPgAinHiWc34q2hkbGRT/9jAzKDKsFHOQueIPL5lcDA21gVOYWQ8ALFkWT51dwYvn1/CZu6/B+27agS995xX83B+fRrtjHzvRzXrwYVFAtw6AwFGGEQQzGlwPpkW2G6Ng/MVfN7kehFXCsi4koCl0n8yt27xgPtSLdcRSuTKvdL78r996AU++uozJmpcUQuu8vcwvKE7Bk57ODWcKsZAqRUEoCAD2QVEGzPuPA3hILPyMsaOMsUOc85Pq6xkAxznnB8V+APcDiFVRkOX+W+0SyTIoMhRdHRstq6Kwtq7cY1gWhYmq8sR39OQ/o6prIyzKEt9xhRLZLZ64zcF8gmAlnMW53cXGSYbRpEd276lqaqHsdC2z60FfywBI1hQtLAr6tduf6yEMlIv//dOvAQAWVnunLAv5m6/vt8W3X9Lw1B8lqVIUVAXgFGPsGAC7qJcjnPP7dK9PAfg8gJPq62MAjuv2n1D/xcra2trAPJEOK4MiQ1F1sWHTTjrs9MhtGyr46K2X4NyytRnT3s2j2DymPCEWVOXFHMwn0H7s+8x6cJKhUlQoohiFlozxiv3YlhgFc9ZDj46LcdJWZfOMri4G8+j/tyOI60FqK4qBH4Vx11TVoFAkURMh6IW89AJJilQpCm4wxvYBWDRtnoVifQBjbALAIQAfETs55+bjCWKoEBkNIsPhyVeX8J++egYdmeOFhbpyTCGc5CfGGI6+7fKex4n0QfNCKeABsh7Ej6651bP9+NEUXAIUi0Lekh6pXlf9+8y5FfzUf/qGJTvEMqcEH1N/4eBl+Nk/ekJzAwE+LQohvr9+PgbXbd+A0y8sot3jc+B1yCQyTtJIZhQFADMAFux2qEqCyDWZUV0QALDfLs5BPecIgCMAcPjwYRw+fBjr6+taNbdarYZ2u621qq3VapBlGWtrSpP0alXptlavKz+2lUoFkiRhdXUVjUYDy8vLyOfzWF1V8mKLxSKKxSJWVla016VSCSsrK+Cco1AooFQqoV6vQ5Zl5PN5lMtl7bUkSahWq2g0Gmi329rrZrOJVqsFxhhGRkbQbDa1exgZGQntngCgVCoNzT01Gg3Mzc1l/p5KnVVsrnCs1BuY42v4mydewGNPvYwNY1VsKMi4+4pR5NpraDQQ2z3JaxcwUeRo1FcxN6coC7PnW8hLDDvG8yi0VjFV4mg2GriwVvf02ZPaDYzkOZYXz2NOrqNQKCCXy2FhYcFyT1Vex/aqjEajEdo9FVurmChyrKysYvNFBczNzWlyWl5ZxZ4xGbnOOtbW1vDsi69gY6GJd165BdOjFXzp9LMAgILcwGiBg68tYW6uBNZew0ieY2lxAaxZ8PXZ2zMmoy0zNBqNQPfE15awZ0xGOdfB6uoq1tbWsHu0gxfBwVtNzM3NuX/2Lixiz5iM5RZDvQ2wpnJP5u/TwUtG8c0XljBVAvLrK1hcXNTuCfI6do5wVPMc22oc5RzHwsKCq5y2FNcxWuBAaw1zc3NYabQxVuCYLsmYm5vDxsI6JoocvNXQ7qFarWKyxDFZUpSLX3jblVhbW8Pq6iqmck1sKnM0OsCmirJf3NPmCkdeYlhaWkIObcyMckiM48KFCyiVStg1wpGXOBodhgvrwGQJKEgcLZlhoQmsLF0wyGljqYP8mAyZM5xbU9ps1/IcfO0CRgsc1Ty0OYfxG+GHLCkKbkyi66qY1MUsTDLGjpvcFQC0IMgTAHDixAleLpdRLpctA5vTq8ymTCEQQaVSUX6M1O2VirHpiPkaZoGZ9/t93Ws8INg9ub0exHuanJw0nJPVe6rOdXB2jaGFHKanJ/DcyotgxSq+9PHbLdeL655G6jksrjN0ciVMTyv9Fm787S8BAJ77rbuwllvAfJOhVq1gpOZ+j+Ia0gsNrLQZauMTmJ5S3if991B//ApexctrOdh954PeU6e0gsV15fFzoVPW7ks5p4JnliS0pAIqlQpy1TE8syTh37/hUsyvrONzX30eAMDzFSy3GHh5FNPT05DzK1hpM0xsmMSULt3Ui1yeWZK0/we5p0KtjmeWJOwsSKjVaqjVanhuJYelJodUKBnuD7DKpTa+QZsDAPDSmOEcMYdj77sZP//Hp/GNM/NoF0cwMTHRnVPpPJ5fYdg4lcOLqwwAw+TkpO2cxXjvfsMIVqQq3nXjDkyPlVGot7DUYkBTwvT0NF5rFbG4ziAVjTJaaDIsNBX53bVvt3ZP853ncK6hbF9qGc0Lyy2GQo5hbGwMMstjdlmZ4/i40j9i4/Sk1uBLOR7Q2zJGxyYMcnqtmcNzuvdspa0eXx7DcothuQXL+97vb4RXBqXg0gJUt4Qpw+FxqFaDOBFaHJFdBkWGZtfDueUmNo/5e5oIm2KuR4yC7L+Ec7fgUnebkwzlCGo464d7y2XGH/NukKJ6fVmcw0wNiIwBhEkGyJnnrGwLnvXgxGStiD2bHDq1ihgFH76HTWNl/OLBy7BpzKr8+JmXV0QMRNvms/xfPnwT/uP79nke6/c/sB8/ue/i0OYWJlmyKGgpkTpEiuQiY8zOLbEIKK4JilcghhFRTEkELp5dauCSjcm20C7k3GMU5ACVE+3aTLsRuuvZpeUgMwVact1h+sXXXEfBfH6cmIs/Af4qbppn7HYLTiIT53jtCGk7dsShgCJz55ULDcu+ciGHDdWCZbvAfFt7No3g1991Ff776Zcsx/7tL70FHsJvIiMzFgXO+WlYMyEmAJzW7V9U4xX0+2MPagxq3iHSw6DIUFgUmjpFIWmLgkiPdFYUuO/a+eanccBZhnbFp/rFUy0/dXL6rA6386JO6XPFRmm5ZKNi1o5Kb7GMm1PqJoiyz7/1k9f0MbZFdfF2Xo/9okJk1ArJzMYRZ8tLDGRGUVA5wRg7pHt9L6zpkO/RvT4A4ME4JqZHcijhSmSHQZFhRWdRaLQ6WGq0Hc2ycVHo5Xrg/szNgC6zQLeyOckwijoKLgYFbZtmUdDVidArROaCS5rlIdSZekOyUbyClNTuB8ZU/72alfP63WaDcvLYvU8GQhBeGmo0pOrXkDG2Ty2SdAjAAbWgkubkUYMS9zPGDqlZC/P6yoxqhsMl6nlHAUw5ZT1EiYgsJbLLoMhQ/Mg2WjLOLSkR0ptGk7Yo9E6PDO566G5zkmEkbaYNPRGsozPoYw90FgXbGAVTs6hEKjNat0VVcGm/qgBccdGYcUdbMedHsVCGXZnRq8vLcK7H46gplAnVfXAaLlaAXgt/EooBQaQVUUxpbb2Ds8vKD+/mxC0K4bseNP++l1LBEbSZ7m1RYLpmTwoSMwYzdu9B/Zuo58FeadHvcz3fx9v7rmu34uaZSWwaNX4uxRif+/LT6usQrBQ+VUSvpaAdZeVThvrL3bR7Ejsmq3j71Rf5GyQCUmVRGBT85qgS6WNQZCj6ODTaHZxdSomioFZmXG+7BTMG+0HXV212kmE0FgX7/+u3aVkPujLD+oVLu2dzMGMCzgez0gJEa9kwKwkAtBiFNOM1iPY6m/badorPaLkb/Dg9WsJn77k2tF4s/UCKQgTk86ky1BABGBQZar0e1jupcT30So/syNz3omTXZtpJhhzhPJ3q0Ss2XmMUmMmiYAlmDHWG/rALDvWjsISi3LDwlieLOyekcbuxMT2OC3DBJGJTnCBFIQIGxb89zAyKDBljKBckNNoyzi43UMxJWvOmpPAWo+DX9WA93jlGwb8i0hPDgm8Xo8CsFgVmr2BoLooE+0yb56Lf5uf8vmgbUw6DDBm1NUYoVPOr1v4mgwQpCgQx4FQKOTRaikVh01gpkbx8PTmJQWLudRR89XlAdxHxElQWtevByfdgjp8wxyjYPcUr20OZoi/covnjm090FzJ/B9565eZA44iPaRB3XposBr0gRSECisX0+9YIdwZJhuVCTglmXGok7nYQFHKSS5vpAFkPkji3u81JhlE0hdIvPE4xCrCNUehi1wEzKbptuxOcRC4+y9cD77jCdnsvi4SQey8LmH7vr73zSvzVx36i55ySVuj1kKIQAYO0yAwrgyTDciGHRltWyzcnG8goKOQktNomE7uKzP3/SNqlFjoqCgi/zbQhmNFm7voYBRFwqVgU9MGM6vwswYzx051WME0hjDWO5YwxJmGum+ahgrZaZ6a/TujfxbuuuQhXbh3LVGdKUhQiQHS0I7LLIMlQb1FIj6LA0FZXTPNTa5A6Cl3XQ3ebkwyjsShY52LYD6YpMcYSzt1jzGWTk+314OJ66GM8X6yvBbhSMILWKtAsCU6353LbiVprfEKKAkEMOOWChG//eBHLjTY2psj1IGIUzLEKHTl4MKOXssccEcQo6Bd8m19VxqzpkYB7toRYvJIwQdsqOzFXZowCp2n16jfhxAfeuEs5LsAnqlpMPu3RK4EVBcbY7Yyx63ocs5sx9hhjbGfQ62SRQTJbDyuDJMODV27GeCWPy7eM4pY9071PiIFCTsK66npoy1bXQ2BFQbfNPUYhbNcDs/1/d5tubqKEs8RsXRZpcD3YvZ9+5hHGnJkpvTVMd5FVKVMYLXtPi/7KL9+Ku16nFEN6z43b3K9nc+1e9RHSpGoFShZnjD0GYJ/6/4Oc87+1O45z/ixj7DSAUwAuDTzLjDEoxXqGmUGS4Udv3YOP3ron6WkYKOa7FoWOqZ4C59z2qdyNbsGl7liOBZcQfnqkp8qMdsGMBteDmJ/6N8lugS6FhLy8d6G8vyEEM/p1KYyWgtVPuWlmKtB5WSGoReEGKJ/zLwKYcTtQ7c/wvzHGfjPgtTLHIPm3hxWSYbQUcqzrepCNrodg3SPFud1tccYo9EKxKFhLOBuaQjnUA07Cim83ldjfs1Z4tQnMFiSLRYH7d/Ok6Yk/aoIqCrMADnHO38M5/30Pxy8COBLwWpkj0fawRCiQDKMlL+ksCqG6HrpjOcmQ8wiyHgyxBnYmBZsSzqbDLBaFUGfoj66iELDgkun9DfJux/kdDBKj4K8AVbbViqCKwvHehxjYB8Ba7HpAKRSSrXxH9A/JMFoKeQnrqsvBHMwoB6icKA7X/+A7yTCSNtMO/7fb1i3hbA5mdIpRiH+Rca/p0Hs+Yby/Us7ow8/4WquRxWeQQIoC5/yzAH6FMXabx1MOQrEqDAWD5N8eVkiG0VLMMbTaVouCLPNg3SMlq089zqZQvXo9GK8vYhR69HpIND1STEK3rY93bWZjzf9JITaFEu/5Cwt1AMBL59dM+5W//VhNvDLSI2Dy4wcu9T2XqOknPfIIgC+qWQ139zj2AJSAxqGgXq8nPQWiT0iG0WJMj+yuRh3OIctAzrfrQfmrX1ydZBhFUyjjgm9XcMlaR0Ey1VEwF43qpkeGOlVP9FslUj/lr/zyrbhq67j/QUy9HoLNw/jmPT+vfCb+7J9esj/elzsh2Jx61QjZNRVAqYqYwIoC5/w0gBuhWAq+yBibZ4z9CWPsbsbYmDiOMXa9+t9H+ptqdpBl+9K0RHYgGUZLISehpVoS9BaFjmpR8P8jbLUoOMlQiVEIF7v0N5i2dSszdgPnjMGM6vxCnlsOVaCAAAAewElEQVQQuopXsKwH/RuyeSygdS5Ck4rZYqUpZTG4eXpdI2jxpyjpq5cu53wWwEHG2AEA9wF4D4B7AIAx9gSA34SijHAMkUVhUFoUDzMkw2hRSjhbCy4pikKQYEbl758+9mM8emYeAFDmDTTYawCAf3HtVlx9sfJUG0mMgosLQWwT657BoqA7xtyIKUnXg7DyrK53tG2xZz3koitIZFEUHFwPYSkOvRTJtBPKryHn/BRURYAxdghKTMI9UNInz6vHPBfGtbJAuZyOMrlEcEiG0VLMd9Mj9QWX2jIPVEfh4okKNo6W8JUfndO2jeQ5VtoMjZaM11aa+PfvUerDKW2mo7MpONZRUFUEcbuWGAUHi0ISC8vC6rplm7+CS8z2/35gIcYoCN593Vb8+bdfxt4to4bt6XuGTxehPzZxzk8COAngPsbYPgAPAPgpxthOzvnzYV8vjdTrdVpoMg7JMFqM6ZFdi0LQYMZNY2U89okDhm0LCwuYnJzE7b/9VUMcRCRtpg0D2sQoQG8pUM3ckoe0yoRotjuO+zx5HkK4Fd42KithjHnFRWP482+/jHLBqIl2A0yjoVdBLttzoplKICLt9cA5P805vwfAWwGciPJaaYL829mHZBgtSjCjSI80WhQ6IZVYFjLMScygjETSFEr//x4xCpqZ23SeOS5Anx0RNzfumrRujFuR4eF/Bx17PWj7k49RSCOxOGI556cYY2fiuFYakPzaTYnUQTKMlmKeodmW0Wx3jOmRXHE95MLIw1dlmJMY2nqLQhRtpvWWAfsjdDEKyn8kxpDThcA7WVGSMDQUc9bPvz/XQwiw+L6DeuXNK0Hl0jt9Nti4URJbxBbn/Nm4rpU01Wo16SkQfUIyjJZyIYe5lSb2/urDePd1W7Xt7YCuBzuEDPM5ZlBGorYo2M1d2WSKUWAwKArmssn9LBgffOMu7JwK/hl2r0jopeCS97oSTkgFY7ZEmE/71vfWXlOQ/PY7d8AYs9Hl6/ff1rM5VBqg0O4IaDQa5N/OOCTDaPmfb9mNzWNl/PZf/wg/eGVJ2y7LSh2FMBQFIcOcJBkCJqN4YOvZFApWBUBiDAXdk7tdGWpxrl9+/V1XBThLf83+3v8wlldzjEIY3HvjDnzjzDyOvMXYomjrRAUA8L/eYexd+Ml3XonRch5//K0X+rquXqZ6hWfbhmw8kJB9NQLa7XbSUyD6hGQYLdsnq/jZt1yC8UoB5+stbXs7cB0FK0KGecnOohBhwSWnGAVTrwcAtq4HcxplWojdBSI7B1R6xax0jVcL+H8+9HpsGjU+BFSLeTz3W3fhX153sWH7xtESPnP3NYGv79Ry3NO5KQpuJUUhAsi/nX1IhvEwUs7jvC4VryNz8AB1FOwwxCgYglN5z+p4fumVDsjALIuWxBgKus+ZtaOh2B7/guHqeujz/FAm4Xuo9Cy6KZqKZ+jXMALIv519SIbxMFrOG9wCojJjGHqaFqNgsijIUcQoGNIe7PdrFgWtMiOQyzHLaZY6CqHN0jtORaO8n9//rHNF41N/PyMm3Q3WoEj2+PANdTDjMNFsNsm/nXFIhvEwWjJ2eOzIHJ2QghmFDHMSw1rL2H46/qwH4KEnXsS55SbOLik9DCTGkJesC4g5OyIJ7BazuJ/KeafV+6AeZDEVUZCmmZOiEAGtVv8fcCJZSIbxMGrqpBe0hLMdQoaWGAVEXUfB2S/9tadeM2wzBjOK+ZmCGRNYMfq1KISyynWMcUK1YrqWqzS5M6ImXe/8gDBMH6BBhWQYD6Nlk0VBraMQRgyBkGFOkox1FCKuzGg39v9x73V46uwy/u7pOTzyg7PaOXZplWno9eCeHunv/MBfJdOJ1VL60wgd8fEeXLp5BABwy57piCbjH1IUImBkZCTpKRB9QjKMB6tFQQ6tjoKQYd4UzMiB0B/TjT5o6/6bZqZw08wUrtw6hvFKAZdsHLEoo5ZgRm17EsGMTrUg4kMqVozXj/fyifG6bRN49IHbsWUsPa5PUhQioNlsolQK2FqVSAUkw3gYsygKgCyHszgKGeZyzFhHIYo20waLgvPoN+ycxA07bcojw+puWW1mN0U3lDoKIcQoRIn5Hv/ggzfiubm6YVvQOJOLxiu9D4oRUhQiYH09/EIhRLyQDOPB7HpoaxaF/scWMjTHKADx93rwQrWomNY552h1ZPzfX09nMVtvrgf3dFEvmBWFtLsDb798s+O+dM+8N6QoEASRGPbBjNxQiKhf8jYxCmG4Ngz0iFFw429/6S1YarSxfVJJ5+QcWG8rrpI7Lt8U0gT7x8+CXyv2H09gFlEWF9ssZ13oIUUhAsi/nX1IhvFgCWYMMetBH6NgbjwVuuuhD01hZqMyz7badpujG59w04y9myIRfNxXGE//5hiFtJFyA0eoUMGlCCCzdfYhGcbDZK1oeN0JsYSzkKE1RiHagktBnyLF4vr1p+c0xSaNT6SxzaljLOE8TAtz2iBFIQJokck+JMN42L9rA373vdfjV++6AkC4JZyNMQr6rIcICi7p/h/UayJO+8fnFvBPL5xXtqVocQwpy9EzaYxR+LfvvjoUt0rWIEWBIIjEyOckvOvarVrOuFbCOcQ1Qen1YLQohP1QbGyr3P/g9fX+GyKFTQrWad+EXd3y/TfvxIgaV5NGa09UkKIQAbVaLekpEH1CMowXEbzY4Ty0OgpChraVGfse3UgYBYb054kOk2l4irYQ05TCjFFI5fuYIUhRiABqUZx9SIbxoikKMocsA1IIJgUhw5wkGSwKiCBGQT/d4Cb67pndGIX0EDj2IugFQ2gzLQizKVQamzZFDSkKEdBsNpOeAtEnJMN4yTGdohCS60HI0GpRCD9GQb8chqGEdFtM9z9WVuHt/uOEhsk9ECWkKBAEkTjCotCWw3M96MdWgiSV1ZdzhNLGWo9xusHn/jM37wCgcz30MaeoiG1OKdWSgkwr60YIUhQigPzb2YdkGC9CUZDVOgph+JT1MQpA15wvR9FmWv//Poa+54btAHSuh4QXS336atxTyRXT0+tAjx/XQ0p1Hd9QwaUIkHWpWEQ2IRnGS15nUQire6SQYS7XHTufi6jNtKFkcT/jKH/T4Hr4kyM3Y/d0V2EOHqQZND8y3c/hg6IEeCGVFgXG2AHG2DGHfUcZY4cYY0cYY0d6jPNQNDN0Z21tLYnLEiFCMowXEbwoc8WiEEYJZyFDs0UhivXHaFEIPnfhcumkwPVw88wUNtt0MIzLyiG3KE4oLaRKUdApCPcDmLDZfxzAac75Sc75CQATjLFDDmMdAzAT6YQJgggFzaLQiSJGQfmZE5kPikUhZNdDCFkPeuQ0mBRMNFqKhWYthTUeiGhJleuBc34KwCl1kbcoCgCOcM7v070+BeDzAE7qD2KMJaogVKvVJC9PhADJMF4KOWUx/42//AGAcCwKQobFvDL2tZ/+GzCmWBSu3W738xIcFlLWg1CQ5BSmR4oGXmstf6nDQe8hV0xnm/d0O0SiIVWKghuMsX0AFk2bZwHsszn8AIBH1L8EQaScWimPBw+9Di+eXwMDcPf1F4c29juu3oLF1XW0OjKePreC//G9VzG3HK5ZO4xeD/pxhJsk9C6XfbChqgQ2pjx0IDa8SGZQ3qvMKApQ3AgLdjsYYxOc80X1/wcAfAHAjTHOzUC9Xqcn0oxDMoyf99y4PdTxhAynRkr413dcCgB4+Huv4n9871VDXYWw6WdtF+fK6fM8WOYWNWmKUbj7+ovxZ//0UuDzUyTGQGRJUXBjEl1rwwTnfLGXD1INhDwCAIcPH8bhw4exvr6uNZKp1Wpot9ta0ZZarQZZlrUAKbGI1Ot1AEClUoEkSVhdXcWFCxdQKpWQz+exuroKACgWiygWi1hZWdFel0olrKysgHOOQqGAUqmEer0OWZaRz+dRLpe115IkoVqtotFooN1ua6+bzSZarRYYYxgZGUGz2dTuYWRkJLR7AjBU93ThwoWBu6dBlJPbPa2vr2NhYcFwT2x9BXvGZIyU22g0GqHd09ryCiaKHDkGrC2dx1ypFeie5FYLe8Zk5NaXcVGVg3VamJ+fT4WcNkgNTJY45FYDc3NzPe9pz5iM5RZDs9kw3KPXz167sYqdIxwLTWC8CMzNzfm+p5VGG2MFjumSrM05yGfvM+/ai0/csQ1zc3OYKspoFDgunF+AtF50vaf1lUVsq3GUJRk7RzgKEsfCwkIqvk9+GBRFYQEAGGOHOOcnex0MAGow5AkAOHHiBC+XyyiXrRG+o6Ojhtfm/HrzU2elUkGlUtGOq1SM9crN1zALzLzf7+te4wHB7snt9SDe05YtWwxjDMI9DaKc3OaQz+ct4xerY3hmScK0nIPddz7oPZ1bL2JxXXk4qY1PYnp6LNA9FdaW8cyShGa+hlfqDCxfwNTUlOsc4pLTEn8JC00Gnitienq65z09syRp45v3e/nsFUZW8fzKiwCA5RYM1/R6T4V6C0stBjQly5yDfvbmmhKWWwzjk5OYHu3Ow24OxfMcL64ybJUlfO4Db0Kj1cHk5KTjPXu5Jz39fp+8kiVFYRaK5UDPJACoFoQZWGMYEkEKu+wbETskw+xjJ8OcLg0z3Gt1/9+f60GkcqqvU2S0FvEScfndC7n+2zmXi4pg3nvTjr7HCoL+s3BdyAG0cZIZRYFzfpoxZn6nJwCcVv+/D8CMGvQIAPuhpE8eBXCScz4b01SxuroaWHMj0gHJMPvYyTAqRSGsrIduHIAIUuhjUiETd4zCnsk8fufe6/DxP/124DFK+Rye+t/fjkIuzDdyQCIUfZAZRUHlhMm9cC+A4wBgdjmoMQgznPMHY54jQRApJWcqvhQWYWU9pDk9Uqsa6XOhDFqzIp+T8O7rL+5LUQC66bFhkyZrT9SkSlFQrQEHABxSXx8FcIpzfhoAOOf3McaOqR+8SQDzaqyBeZwjAO6BYmE4CuCEyIqIA7+BIkT6IBlmHzsZisJOYZvPw+r1IE7tZj2kZzFiMbse6DuYHlKlKKgKwWkAjlYAzvn9HsbRAhWTIJ9P1dtKBIBkmH3sZCjFYlHof5w0do8UNbB4TJpCWr+Dg1IbwQ8UsRUBIgWFyC4kw+xjJ0Ot70Pov/YhV2YUikKKNAVhao8rRoG+g+mBFAWCIIaGbuR+uKvdSKn79Fst9v8knEZFIW6LQlpJk0ziIp22nYxTLBZ7H0SkGpJh9rGTYT4XzVPxlvEy/vJfvwkAsHUieLZM1zWivE5TwBxj8VoU0vodHEY9iRSFCEjrB5zwDskw+9gqChHFKADA1ReP9z2GUAt4Ci0KltTNiEn7d9CXbDKuXJDrIQJEWVkiu5AMs4+dDNPUZMmOuBdjP8T93g3CdzDdnzbvkKJAEMTQkE95xU3JXJkxRYpNN3UzfUpMnAzj3af7W5NR0m4yI3pDMsw+djLMhVqhL3zMi3GaZqsVXBryGAVBmmQTNaQoRAAVCsk+JMPsYyfDXIqe0O1gKU6P1DJGYrreIHwHB8X6QIpCBAyCb23YIRlmHzsZihLOacVacCk98zUrMVGT1u9goPTQ9IgxEKQoRMCw5xkPAiTD7GMnw7QrCtYYhQQnYyJu10Pav4Npih+JGlIUIqBQKCQ9BaJPSIbZx06GaVcULOmRyU3FQtwFl+g7mB6ojkIEDIJvbdghGWYft6ZQacXiekjRdCWfBZe+9LE3YaXRDny9gfoOpts40hNSFCKgXq+jXC4nPQ2iD0iG2cdOhqm3KJhcD2myKZQLOQBAIefNEH3V1v4KUKX1O+hnzU+P9PqDFIUIkGW590FEqiEZZh87GaZfUVD+fvH0i4bXaeDDb9qNRquDD92yK5brpf07mCLRRA4pChGQ1vaohHdIhtnHToZpT4+smRpKpWm25UIOv/TWvbFdj76D6YGCGSMgjeYywh8kw+xjJ0Mp5RaFnMTwiwcv016nveR0lNB3MD2QohAB9Xo96SkQfUIyzD5ZlaFeNRhiPSGz8htESFGIgLT71ojekAyzT1ZlqLd6nHktnUWH4iCr8htESFGIACnljWeI3pAMs88gyHBuZT3pKSRGWuWX8jpQkZBOSWScarWa9BSIPiEZZp+sylAfl1BfD16HIOukXX7D5BYiRSECGo1G0lMg+oRkmH3cZHj5ltEYZ+IP/QJUUWsXDCOD9B3kGa+4RPknEdBuD+9TwKBAMsw+TjL85gN3YLSc3p8+/YPqR35iJrF5JE1av4N+SlgPSj+I9H5bMkxafWuEd0iG2cdJhlvG0512p3c9FPPD+zlM+3fQS2fPtDe28kq6JZFR0u5bI3pDMsw+WZWh/iF0UJ5Ig5BV+dmRpnbhQSBFIQKazWbSUyD6hGSYfbIqQ71yMMR6QmrlNxg2An+QohABrVYr6SkQfUIyzD5ZlaFeNxjmyoypl98QiYZiFCJgmM2FgwLJMPtkVYYG10Ny00gcIb/HPnEAi/XhrSeRBkhRiICRkZGkp0D0Cckw+2RVhnorwjBbFIT8No6WsHG0lPBsdAyh74FcDxGQVt8a4R2SYfbJqgyNwYzJzSNp0i6/YZINKQoRsL5OZrKsQzLMPlmVIQUzKmRVfnZkveASKQoEQRApwtA9cqijFNLJWKUAwFv8SFbjZMxQjEIEZNU3SnQhGWafrMpQv7ZIg7HOBCKt8vtvH7kZX37yLEbLhaSnEhtkUYiAQTKZDSskw+yTVRlKBtfD8GoKaZXfjqkqPnTL7qSnESukKERAWj/ghHdIhtknqzI01lFIbBqJk1X5DSKkKBAEQaQIsigQaYMUhQio1WpJT4HoE5Jh9smsDEk3AJBh+Q0gpChEQFrboxLeIRlmn6zKkPQEhazKbxAhRSEC0l4ohOgNyTD7ZFWGw1yNUU9W5TeIkKJAEASRIkhPGBwu3lABABy4YnPCM+kPqqMQAeRbyz4kw+yTVRmSRUEhq/LTc/FEBf/8ybdirJLtpTbbs08psiwnPQWiT0iG2SerMiQ9QSGr8jMzXs1+YSZyPUTA2tpa0lMg+oRkmH1IhtmG5JceSFEgCIJIEeR6INIGKQoRUK1Wk54C0Sckw+yTVRmSnqCQVfkNIqmMUWCMHQBwkHN+v82+owBmAUwCAOf8hG7fBIAj6sv9AGbtxiAIgkgrZFEg0kaqLAqMsQOMsWMA7gcwYbP/OIDTnPOTqoIwwRg7pDvkAc75g+q/ewCI8WKlXq/HfUkiZEiG2SerMiQ1QSGr8htEUqUocM5PqRaA0w6HHOGcn9K9PgXgAUCzJsybjj+OroWBIAgi9ZBBgUgbqVIU3GCM7QOwaNo8C2Cf+v8ZAMfU4wQLsLFMRE2lUon7kkTIkAyzT1ZlSK4HhazKbxBJZYyCAzNQFn4LjLEJzvlpxthBzrneGnEQitXB7pwjUK0Nhw8fxuHDh7G+vq61Nq3Vami321oZ0VqtBlmWtZQdEWgjzGOVSgWSJGF1dRXNZhOyLCOfz2N1dRUAUCwWUSwWsbKyor0ulUpYWVkB5xyFQgGlUgn1el07t1wua68lSUK1WkWj0UC73dZeN5tNtFotMMYwMjKCZrOp3cPIyEho9wQApVJpaO5pcXERa2trA3VPgygnt3vinGNhYSFz97R3A/BLb74IWydH0Ww2B15OTve0traGZrM5UPeUJjn5gXHOfZ0QB2pcwQTn/D7dtkMAjnHOL9FtmwBwHsAlnPNZ0xgTAJ4FcIdJebBw4sQJfuRIeB6Kubk5TE9PhzYeET8kw+xDMsw2JL9o+fSnP/3Epz71qRu9HJsZ10MP7CwNnwdwTy8lgSAIgiAIZ7KkKGgpkTpEiqQhdkG1SBw3BT7Ghl+zDpE+SIbZh2SYbUh+6SEzioJqGTAHJk7AlCGhuigeEUqCKbgxFvL5LIV+EHaQDLMPyTDbkPzSQ2YUBZUTproJ90JJgQSgFWqaBPA4Y2xCjVM4EPMctYARIruQDLMPyTDbkPzSQ6pUNvXp/wCAQ+rrowBOiTgDzvl9jLFjTEkfmgQwLyozqkrBI+pQx3XDnoxp+gRBEAQxcKRKUVAVgtMAHnQ5xrYksxqnkIoE5GKxmPQUiD4hGWYfkmG2Ifmlh6y5HjIBfcCzD8kw+5AMsw3JLz2kyqKQFK+88srcpz/96ecB4Lvf/e74Nddcc8F8jJ/t//AP/zB9yy23zEU3Y284zTnu8fyc5+VYt2OC7CMZhnte3DJ0Oj4NMhxG+bntp+9gemT4wx/+8FLPF+ec0z/dPwAn+t0O4PGk78NtznGP5+c8L8e6HRNkH8kw2zJ0kWviMhxG+fWQCX0HMyJD/T9yPVj5/0LangbCnlvQ8fyc5+VYt2OC7CMZhnte3DIk+YV7Xr/yc9tP38HsyFAjlSWcsw5j7HHOuafSmEQ6IRlmH5JhtiH5pQeyKETDiaQnQPQNyTD7kAyzDckvJZBFgSAIgiAIR8iiQBAEQWQGxtghxtgBxtjxJEr0DyOUHkkQBEFkAlUxeIBzfoNaofcYgIPJzmrwIYsCQRAEkQm4Ur33DvXlPnTL9hMRQhaFEFEbVu3nDmWmifThJjO114jW3pyrfUWIZOlHZiTT9KA28TvoV46c80XdZ+CeuOY7zJBFIQRUf9lRAPfB2gqbSCG9ZMYYOwZglnN+Uv2RusTUuZSImX5lRjJNB6ocjwG4H/ZyPA7gtE5OE2Y5cc5PAjjOGHsolkkPOZT1ECLqh3+Cc35f0nMhvOEkM8bYec75Bt3rAwDu55yTPzRhgsqMZJouXOTIOedM93ofgM+rcQn7AMxwzk+qHYPP648looFcDwRhwiGSegFKC3QihfSSGck0G6hyWjRtnoUSjwAY5TWj7iMihlwPBGFlEsoiomcRANSnGCJ99JIZyTQbzMAqJwCKnDjnDwIQMQr3AaAYhRggiwJBWBELix7x4zUJ6xMPkTy9ZEYyzT6TABZ1gY0nk5zMMEEWBYKwYrdoiEXG9mmHSJxeMiOZZh+SU0KQokAQVhZgjcaeAJTUrPinQ3igl8xIptlAS4nUIVIkSU4JQYoCQZhQi7qYf5QmAZxKYDqEB3rJjGSaDVQ52Sl0pxOYDqFCigJB2HPClLt9EMDxpCZDeKKXzEim2cAsp3tBckoUqqMQAmpKzwEoUbiTAH4TwClVOyZSiBeZ6arDzcAYREUkQBgyI5kmj0mOgKIEmOV4DMBjUANR1WwHIiFIUSAIgiAIwhFyPRAEQRAE4QgpCgRBEARBOEKKAkEQBEEQjpCiQBAEQRCEI6QoEARBEAThCCkKBEEQBEE4QooCQRAEQRCOkKJAEARBEIQjpCgQxBDBGDvCGDuf9Dy8kKW5EsQgQ4oCQQwXjwP4gnmjWlY3EVyubTtXgiDihRQFghgiOOenOef32ew6EPtkelzbZa4EQcQIKQoEQQBKh75hvDZBED0gRYEghgjG2D7G2AHTtqMAEnE9uF3bbq4EQcRPPukJEAQRD4yxCShP70cBMHXbEQCXqP8/ph56Rt9+WT0GABYA7AfwCOf8lBpb8HkoLZtvgLLg3wvgTznnJ9VzD6nnTqrX+U3O+WKva9vNVTefQ+p4C+Kv7nr7AByD4s7YgK5b4yCAJ0z3dQjAovpyQj3mfjE/giAUqM00QQwZjDHOOWe61xMAzuu36fYdBTArFmJ12xkABznns+q5zwL4COf8pLrgi8X+EIDTnPNZ9bwZAA9xzm/wcm2HuR4BMME5f7DHNg7gHtO8zwPYzTlfFEoC5/yUbv9xAMfEfAmCUCBFgSCGDK+KglACOOcbTNuPAQDn/H4xHoAbOOenTcc9BGUBP6jbpi3Wbte2m6vTfBzGtcxJVXDu4ZyfVhWgRZOF4QAUpYgUBYLQQa4HgiCceA9gcB8I5tE12QNQMhRszheKxAEo7okFKCb+SfP5HjmgjmHHrDrfE6ZtTpwE8ARj7CCARwCc0lsXCILoQooCQRBOTEDn/w/IQ1D8/icAgDHWj/9/Bs4KxgLUeAeBW6yB6jbZDeABAPcBOM4YO8k5v6eP+RHEQEJZDwRBGFCzDSagPJFP9jHUI1CCFy1P6ur4bte2YxGK8mLHJBRLhycYYwc454uc8/s55zeo7o0JXeAmQRAqpCgQxJBj8+QtlINTUBbPGfM5Nu4I8/4ZADM21gix0N/IGJtwubYdXwAw46BI7IPiTvDKQZv7ug9K9gZBEDpIUSAIAgBmdQvnhPq0vQhl8TymP1CNObCLSdCzoB6rLcYiWFC81ikJlmvbDahuvx+Ku0A/n6MAHgwQhGiu+jgDxQpCEIQOUhQIYkhgjM2oKYBgjB03PZnfB+B+U20BqLEFf8oYO8YYO6TuX1B9/PtM4x3SnbcIpS6B4TwoC/0xGF0Ilms7zVVNgXyMMXZUHVdkL9zvcN4+xtiEmqkxo87nABQ3xSPqGAfUa9tZQAhi6KH0SIIgCIIgHCGLAkEQBEEQjpCiQBAEQRCEI6QoEARBEAThCCkKBEEQBEE4QooCQRAEQRCOkKJAEARBEIQjpCgQBEEQBOEIKQoEQRAEQThCigJBEARBEI6QokAQBEEQhCP/P+KZ1zFLm9Z3AAAAAElFTkSuQmCC\n", + "text/plain": [ + "<Figure size 576x576 with 2 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "m2 = result.posterior.mass_2.values\n", + "m1 = result.posterior.mass_1.values\n", + "\n", + "fig, ax = plt.subplots(nrows = 2 , ncols =1 , sharex = True , figsize = (8,8))\n", + "ax[0].plot(m1 , 'o', label = 'm1' )\n", + "ax[0].plot(m2 , 'o', label = 'm2' )\n", + "ax[0].set_ylabel(r'$M_{\\odot}$')\n", + "ax[0].legend(loc = 'best' , frameon = True , fontsize = 12)\n", + "ax[1].plot(result.log_likelihood_evaluations)\n", + "ax[1].set_ylabel(r'$\\mathcal{L}$')\n", + "ax[1].set_xlabel('iterations')\n", + "ax[1].set_xscale('log')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Bilby Py2.7", + "language": "python", + "name": "bilby" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}