diff --git a/SGD-Example.ipynb b/SGD-Example.ipynb new file mode 100644 index 0000000..28e7024 --- /dev/null +++ b/SGD-Example.ipynb @@ -0,0 +1,284 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "21a12036-3da1-42a8-9952-9693b8291f05", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from sirf import STIR as pet\n", + "from sirf.contrib.partitioner import partitioner\n", + "\n", + "from cil.optimisation.functions import SGFunction\n", + "from cil.optimisation.algorithms import GD\n", + "from cil.optimisation.utilities import Sampler, ConstantStepSize\n", + "from cil.optimisation.utilities.callbacks import ProgressCallback\n", + "\n", + "from img_quality_cil_stir import ImageQualityCallback\n", + "\n", + "\n", + "# engine's messages go to files, except error messages, which go to stdout\n", + "_ = pet.MessageRedirector('info.txt', 'warn.txt')\n", + "# Needed for get_subsets()\n", + "pet.AcquisitionData.set_storage_scheme('memory')\n", + "# fewer message from STIR and SIRF\n", + "pet.set_verbosity(0)\n", + "\n", + "def initial_OSEM(acquired_data, additive_term, mult_factors, initial_image):\n", + " num_subsets = 1\n", + " data, acq_models, obj_funs = partitioner.data_partition(acquired_data, additive_term, mult_factors, num_subsets)\n", + "\n", + " obj_fun = pet.make_Poisson_loglikelihood(data[0])\n", + " obj_fun.set_acquisition_model(acq_models[0])\n", + " recon = pet.OSMAPOSLReconstructor()\n", + " recon.set_objective_function(obj_fun)\n", + " recon.set_current_estimate(initial_image)\n", + " # some arbitrary numbers here\n", + " recon.set_num_subsets(2)\n", + " num_subiters = 14\n", + " recon.set_num_subiterations(num_subiters)\n", + " recon.set_up(initial_image)\n", + " recon.process()\n", + " return recon.get_output()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fc7ea384-a57a-42a6-8f35-4fe9826279e6", + "metadata": {}, + "outputs": [], + "source": [ + "def construct_RDP(penalty_strength, initial_image, kappa, max_scaling=1e-3):\n", + " '''\n", + " Construct the Relative Difference Prior (RDP)\n", + " \n", + " WARNING: return prior with beta/num_subsets (as currently needed for BSREM implementations)\n", + " '''\n", + " prior = pet.RelativeDifferencePrior()\n", + " # need to make it differentiable\n", + " epsilon = initial_image.max() * max_scaling\n", + " prior.set_epsilon(epsilon)\n", + " prior.set_penalisation_factor(penalty_strength)\n", + " prior.set_kappa(kappa)\n", + " prior.set_up(initial_image)\n", + " return prior\n", + " \n", + "def add_prior(prior, objective_functions):\n", + " '''Add prior evenly to every objective function.\n", + " \n", + " WARNING: it modifies the objective functions'''\n", + " for f in objective_functions:\n", + " f.set_prior(prior) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6b5020bc-a42c-455f-89de-dbedc928dffb", + "metadata": {}, + "outputs": [], + "source": [ + "# https://github.com/SyneRBI/PETRIC/blob/recon_with_metrics/metrics/NEMA-IQ-CIL.ipynb\n", + "import tensorboardX\n", + "from datetime import datetime\n", + "import numpy as np\n", + "# create a tensorboardX summary writer\n", + "dt_string = datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n", + "tb_summary_writer = tensorboardX.SummaryWriter(f'recons/exp-{dt_string}')\n", + "def MSE(x,y):\n", + " \"\"\" mean squared error between two numpy arrays\n", + " \"\"\"\n", + " return ((x-y)**2).mean()\n", + "\n", + "def MAE(x,y):\n", + " \"\"\" mean absolute error between two numpy arrays\n", + " \"\"\"\n", + " return np.abs(x-y).mean()\n", + "\n", + "def PSNR(x, y, scale = None):\n", + " \"\"\" peak signal to noise ratio between two numpy arrays x and y\n", + " y is considered to be the reference array and the default scale\n", + " needed for the PSNR is assumed to be the max of this array\n", + " \"\"\"\n", + " \n", + " mse = ((x-y)**2).mean()\n", + " \n", + " if scale == None:\n", + " scale = y.max()\n", + " \n", + " return 10*np.log10((scale**2) / mse)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2002475-9d52-4795-b9f3-61bec44eb748", + "metadata": {}, + "outputs": [], + "source": [ + "os.chdir('/home/jovyan/work/Challenge24/data')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fe04a664-e85b-4a1b-a299-3812d8d22c6b", + "metadata": {}, + "outputs": [], + "source": [ + "acquired_data = pet.AcquisitionData('prompts.hs')\n", + "\n", + "additive_term = pet.AcquisitionData('additive.hs')\n", + "\n", + "mult_factors = pet.AcquisitionData('multfactors.hs')\n", + "\n", + "initial_image = pet.ImageData('OSEM_image.hv')\n", + "osem_sol = initial_image\n", + "# This should be an image to give voxel-dependent weights \n", + "# (here predetermined as the row-sum of the Hessian of the log-likelihood at an initial OSEM reconstruction, see eq. 25 in [7])\n", + "kappa = initial_image.allocate(1.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8e53cf71-21b7-47e4-97c9-8c98ec045b59", + "metadata": {}, + "outputs": [], + "source": [ + "# load the ROIs\n", + "\n", + "ground_truth = initial_image\n", + "roi_image_dict = {\n", + " 'S1': pet.ImageData('S1.hv'),\n", + " 'S2': pet.ImageData('S2.hv'),\n", + " 'S3': pet.ImageData('S3.hv'),\n", + " 'S4': pet.ImageData('S4.hv'),\n", + " 'S5': pet.ImageData('S5.hv'),\n", + " 'S6': pet.ImageData('S6.hv'),\n", + " 'S7': pet.ImageData('S7.hv'),\n", + "}\n", + "# instantiate ImageQualityCallback\n", + "img_qual_callback = ImageQualityCallback(ground_truth, tb_summary_writer,\n", + " roi_mask_dict = roi_image_dict,\n", + " metrics_dict = {'MSE':MSE, \n", + " 'MAE':MAE, \n", + " 'PSNR':PSNR},\n", + " statistics_dict = {'MEAN': (lambda x: x.mean()),\n", + " 'STDDEV': (lambda x: x.std()),\n", + " 'MAX': (lambda x: x.max()),\n", + " 'COM': (lambda x: np.array([3,2,1]))},\n", + " )\n" + ] + }, + { + "cell_type": "markdown", + "id": "1613c02e-6475-4d3b-9ffb-82bc703ed115", + "metadata": {}, + "source": [ + "## Using SIRF Objective Functions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "38959d1d-4694-4369-b317-2dc8088216e0", + "metadata": {}, + "outputs": [], + "source": [ + "num_subsets = 7\n", + "data, acq_models, obj_funs = partitioner.data_partition(acquired_data, additive_term, mult_factors, num_subsets, mode='staggered', initial_image=initial_image)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ba81c1b4-3714-4c34-89d6-e5a745ec9470", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# add RDP prior to the objective functions\n", + "step_size = 1e-7\n", + "add_regulariser = True\n", + "if add_regulariser:\n", + " alpha = 500\n", + " prior = construct_RDP(alpha, initial_image, kappa)\n", + " # epsilon = initial_image.max()*1e-4\n", + " # prior = add_RDP(alpha, epsilon, obj_funs)\n", + " add_prior(prior, obj_funs)\n", + " step_size = 1e-10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "69b2fde4-7d03-4342-9ec7-3ed0360604b0", + "metadata": {}, + "outputs": [], + "source": [ + "#set up and run the gradient descent algorithm\n", + "\n", + "sampler = Sampler.random_without_replacement(len(obj_funs))\n", + "# requires a minus sign for CIL's algorithm as they are minimisers\n", + "F = - SGFunction(obj_funs, sampler=sampler)\n", + "# ISTA default step_size is 0.99*2.0/F.L\n", + "step_size_rule = ConstantStepSize(step_size)\n", + "\n", + "alg = GD(initial=initial_image, objective_function=F, step_size=step_size_rule)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26477d50-ac4e-4f11-af08-b873bb417597", + "metadata": {}, + "outputs": [], + "source": [ + "alg.run(10, callbacks=[img_qual_callback, ProgressCallback()])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0dded5f8-3bae-46aa-868f-452e0e5bd763", + "metadata": {}, + "outputs": [], + "source": [ + "from cil.utilities.display import show2D \n", + "cmax = .15\n", + "im_slice = 70\n", + "osem_sol = initial_image\n", + "show2D([osem_sol.as_array()[im_slice,:,:], \n", + " alg.solution.as_array()[im_slice,:,:]], \n", + " title=['OSEM',f\"{alg.__class__.__name__} epoch {alg.iteration/num_subsets}\"], \n", + " cmap=\"PuRd\", fix_range=[(0, 0.2),(0,0.2)], origin='upper-left')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/metrics/NEMA-IQ-CIL.ipynb b/metrics/NEMA-IQ-CIL.ipynb new file mode 100644 index 0000000..8a81571 --- /dev/null +++ b/metrics/NEMA-IQ-CIL.ipynb @@ -0,0 +1,805 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "superb-imaging", + "metadata": {}, + "source": [ + "# PET data case\n", + "\n", + "Tested with CIL 21.1.0 and SIRF 3.0.0\n", + "\n", + "The data is a real dataset of a phantom acquisition at UCL on a Siemens mMR. The phantom is the NEMA phantom (essentially a torso-shaped perspex box, with some spherical inserts). The data is freely available on [Zenodo](https://zenodo.org/record/1304454#.YJU7xbVKg10).\n", + "\n", + "The data must be downloaded and put in a the directory pointed by `data_path`.\n", + "\n", + "Parts of this notebook are taken from the SIRF exercise [reconstruct_measured_data ](https://github.com/SyneRBI/SIRF-Exercises/blob/master/notebooks/PET/reconstruct_measured_data.ipynb) from CCP SyneRBI." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "designed-mobility", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import sys\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import sirf.STIR as pet\n", + "from sirf.config import SIRF_HAS_Parallelproj\n", + "\n", + "from cil.utilities.display import show2D\n", + "from cil.optimisation.algorithms import PDHG, SPDHG\n", + "from cil.optimisation.functions import KullbackLeibler\n", + "from cil.plugins.ccpi_regularisation.functions import FGP_TV\n", + "from ccpi.filters import regularisers\n", + "\n", + "\n", + "# The data is prepared as in the SIRF-Exercises reconstruct_measured_data \n", + "# change data_path to point to the directory where the data has been downloaded and unzipped\n", + "data_path = os.path.abspath('/home/jovyan/work/SIRF-Exercises/data/working_folder/PET/reconstruct_measured_data')\n", + "os.chdir(data_path)\n", + "sirf_data_path = os.path.abspath('/home/jovyan/work/SIRF-Exercises/data/PET/mMR/NEMA_IQ')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "lasting-syracuse", + "metadata": {}, + "outputs": [], + "source": [ + "# file names\n", + "# list_file = '20170809_NEMA_60min_UCL.l.hdr'\n", + "list_file = os.path.join(sirf_data_path, '20170809_NEMA_60min_UCL.l.hdr')\n", + "norm_file = 'norm.n.hdr'\n", + "# attn_file = 'mu_map.hv'\n", + "attn_file = 'umap.v.hdr'\n", + "# output filename prefixes\n", + "sino_file = 'sino'" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "cooperative-pierre", + "metadata": {}, + "outputs": [], + "source": [ + "# redirect STIR messages to some files\n", + "# you can check these if things go wrong\n", + "msg_red = pet.MessageRedirector('info.txt', 'warn.txt')" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "monetary-lodge", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "INFO: CListModeDataECAT8_32bit: opening file /home/jovyan/work/SIRF-Exercises/data/PET/mMR/NEMA_IQ/20170809_NEMA_60min_UCL.l\n", + "13000000 events stored" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "Processing time frame 1\n", + "\n", + "Number of prompts stored in this time period : 13043732\n", + "Number of delayeds stored in this time period: 0\n", + "Last stored event was recorded before time-tick at 500 secs\n", + "Total number of counts (either prompts/trues/delayeds) stored: 13043732\n", + "\n", + "This took 13.63s CPU time.\n" + ] + } + ], + "source": [ + "template_acq_data = pet.AcquisitionData('Siemens_mMR', span=11, max_ring_diff=15, view_mash_factor=1)\n", + "template_acq_data.write('template.hs')\n", + "# create listmode-to-sinograms converter object\n", + "lm2sino = pet.ListmodeToSinograms()\n", + "\n", + "# set input, output and template files\n", + "lm2sino.set_input(list_file)\n", + "lm2sino.set_output_prefix(sino_file)\n", + "lm2sino.set_template('template.hs')\n", + "# set timing interval (in secs) since start of acquisition\n", + "# (the listmode file provided is for 1 hour).\n", + "# you can vary this to see the effect on noise. Increasing it will mean somewhat longer\n", + "# processing time in the following steps (but not in the reconstruction).\n", + "lm2sino.set_time_interval(0, 500)\n", + "# set up the converter\n", + "lm2sino.set_up()\n", + "# create the prompts sinogram\n", + "lm2sino.process()\n", + "# get access to the sinograms\n", + "# acq_data = lm2sino.get_output()\n", + "acq_data = pet.AcquisitionData('sino_f1g1d0b0.hs')\n", + "\n", + "# use a slice number for display that is appropriate for the NEMA phantom\n", + "z = 71\n", + "\n", + "# uncomment to show the acquisition data\n", + "# show2D(acq_data, slice_list=[(0,0),(1,z)], title='500s', cmap='gray_r' )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "optical-thought", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Last stored event was recorded after time-tick at 499.999 secs\n", + "Total number of prompts/trues/delayed stored: 3506594\n", + "\n", + "This took 5.51s CPU time.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "estimate_randoms: trying GEHDF5...\n", + "not a GE HDF5 file. Using ML estimate from delayeds\n", + "processed frame 1\n", + "Starting iteration 1\tKL 1941.92\n", + "Starting iteration 2\tKL 142.99\n", + "Starting iteration 3\tKL 5.14518\n", + "Starting iteration 4\tKL 0.218351\n", + "Starting iteration 5\tKL 0.00904963\n", + "Starting iteration 6\tKL 0.000365185\n", + "Starting iteration 7\tKL 1.62128e-05\n", + "Starting iteration 8\tKL 3.8093e-07\n", + "Starting iteration 9\tKL 8.08076e-09\n", + "Starting iteration 10\tKL 1.15392e-09\n", + "CPU time 33.12 secs\n" + ] + } + ], + "source": [ + "# Get the randoms estimate\n", + "# This will take a while\n", + "rand = lm2sino.estimate_randoms()\n", + "rand.write('sino_randoms_f1g1d0b0')\n", + "\n", + "# uncomment to show the randoms\n", + "# show2D(rand, slice_list=[(0,0),(1,z)], title='randoms 500s', cmap='gray_r')" + ] + }, + { + "cell_type": "markdown", + "id": "greater-hello", + "metadata": {}, + "source": [ + "## OSEM reconstruction" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "martial-concept", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %comment\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %sms-mi header name space\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %sinogram data file\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %sinogram header file\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %study date (yyyy:mm:dd)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %study time (hh:mm:ss gmt+00:00)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %patient orientation\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: end horizontal bed position (mm)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: total number of data sets\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %supplementary attributes\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: isotope gamma halflife (sec)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %supplementary attributes\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %reconstruction diameter (mm)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %scanner quantification factor (bq*s/ecat counts)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %decay correction\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %decay correction reference date (yyyy:mm:dd)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %decay correction reference time (hh:mm:ss gmt+00:00)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %number of reconstructed beds\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %decay correction factor range\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %scatter fraction range (%)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %acquisition start time range (sec)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %slice duration range (sec)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: slice orientation\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: method of reconstruction\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: number of iterations\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %number of subsets\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: filter name\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %xy-filter (mm)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %z-filter (mm)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %filter order\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %image zoom\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %x-offset (mm)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %y-offset (mm)\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: applied corrections\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: method of attenuation correction\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: method of scatter correction\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %method of random correction\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %total uncorrected singles rate\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %image slope\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %image intercept\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %supplementary attributes\n", + "\n", + "\n", + "WARNING: KeyParser warning: unrecognized keyword: %axial compression\n", + "\n", + "\n", + "WARNING: RadioNuclideDB::get_radionuclide: unknown modality. Returning \"unknown\" radionuclide.\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reading manufacturer PET normalisation file from norm.n.hdr\n" + ] + } + ], + "source": [ + "# Acquisition data stored in memory\n", + "pet.AcquisitionData.set_storage_scheme('memory')\n", + "pet.set_verbosity(0)\n", + "\n", + "# attenuation\n", + "attns = pet.ImageData(attn_file)\n", + "asm_norm = pet.AcquisitionSensitivityModel(norm_file)\n", + "\n", + "# Setup image geometry\n", + "image = acq_data.create_uniform_image(0., (127, 220, 220))\n", + "image.initialise(dim=(127, 220, 220), vsize=(2.03125, 1.7080754, 1.7080754))\n", + "\n", + "def get_asm_attn(sino, attn, acq_model):\n", + " \"\"\"Get attn Attenuation Sensitivity Model from sino, attn image and acq model.\"\"\"\n", + " asm_attn = pet.AcquisitionSensitivityModel(attn, acq_model)\n", + " # temporary fix pending attenuation offset fix in STIR:\n", + " # converting attenuation into 'bin efficiency'\n", + " asm_attn.set_up(sino)\n", + " bin_eff = pet.AcquisitionData(sino)\n", + " bin_eff.fill(1.0)\n", + " asm_attn.unnormalise(bin_eff)\n", + " asm_attn = pet.AcquisitionSensitivityModel(bin_eff)\n", + " return asm_attn\n", + "\n", + "# set up the acquisition model\n", + "if SIRF_HAS_Parallelproj:\n", + " # use a GPU implementation if available\n", + " am = pet.AcquisitionModelUsingParallelproj()\n", + "else:\n", + " am = pet.AcquisitionModelUsingRayTracingMatrix()\n", + "\n", + "# ASM norm already there\n", + "asm_attn = get_asm_attn(acq_data,attns,am)\n", + "\n", + "# Get ASM dependent on attn and/or norm\n", + "asm = pet.AcquisitionSensitivityModel(asm_norm, asm_attn)\n", + "am.set_acquisition_sensitivity(asm)\n", + "am.set_background_term(rand)\n", + "am.set_up(acq_data, image)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "raised-deviation", + "metadata": {}, + "outputs": [], + "source": [ + "# setup OSEM\n", + "obj_fun = pet.make_Poisson_loglikelihood(acq_data)\n", + "obj_fun.set_acquisition_model(am)\n", + "\n", + "recon = pet.OSMAPOSLReconstructor()\n", + "recon.set_objective_function(obj_fun)\n", + "recon.set_num_subsets(21)\n", + "recon.set_num_subiterations(12)\n", + "recon.set_up(image)\n", + "\n", + "# set the initial image estimate\n", + "recon.set_current_estimate(image)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "interim-jewel", + "metadata": {}, + "outputs": [], + "source": [ + "# run OSEM\n", + "recon.process()\n", + "osem_recon = recon.get_output()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "plastic-creativity", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2oAAAL6CAYAAABHOqX8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9eZgdZ3Xnf6rqLr13q9VSa2/JsmXZlld5wcbGZhM4xGGHQMKSmMwwJmSM4UnwzyExDMEDyRgzmRgCIYCHOHgyEwgEAtiAjcEG28Lyblmy1Vq71fvefZeq9/eHcH3PKfVtrrpvq69a38/z6HmObtdb9dZbb713qe/5Hs8554QQQgghhBBCSNXgL3QHCCGEEEIIIYRY+EWNEEIIIYQQQqoMflEjhBBCCCGEkCqDX9QIIYQQQgghpMrgFzVCCCGEEEIIqTL4RY0QQgghhBBCqgx+USOEEEIIIYSQKoNf1AghhBBCCCGkyuAXNUIIIYQQQgipMvhFjRBCCCGEEEKqjAX9onb77bfLhg0bpKamRrZu3Sr333//QnaHEEIIIYQQQqqCBfuidtddd8n1118vN910kzz66KNyxRVXyNVXXy379u1bqC4RQgghhBBCSFXgOefcQhz4kksukQsuuEA+//nPx6+dccYZ8oY3vEFuueWWhegSIYQQQgghhFQFqYU4aD6fl+3bt8tHP/pR8/q2bdvkgQceOGr7XC4nuVwu/n8URTIwMCBLly4Vz/Pmvb+EEEIIIYRUO845GR0dlVWrVonvHz/h3NTUlOTz+eN2vN9EJpORmpqahe7GnFmQL2p9fX0ShqG0t7eb19vb26W7u/uo7W+55Rb5+Mc/fry6RwghhBBCyAnL/v37Zc2aNcflWFNTU7Jhwwrp7h4+LscrhxUrVsiePXtO+C9rC/JF7UWST8Occ9M+IbvxxhvlhhtuiP8/PDws69atExHv1/8IIYQQQgg52XEi4qSxsfG4HTGfz0t397B07v+cNDXVHrfjlmJkZFLWr/2vks/n+UVtNrS1tUkQBEc9Pevp6TnqKZuISDablWw2O82e+EWNEEIIIYQQMP2Dj/mmqalWmprqjvtxFzML4vqYyWRk69atcvfdd5vX7777brnssssWokuEEEIIIYSQWRJFkURRWAX/ooUeioqxYNLHG264Qd71rnfJhRdeKJdeeql88YtflH379sn73//+heoSIYQQQgghhFQFC/ZF7e1vf7v09/fLJz7xCenq6pItW7bI9773Peno6FioLhFCCCGEEEJIVbCgZiLXXXedXHfddQvZBUIIIScMQeL/Wt4ym5KgOodjQUqKEkLIosG5ojhXXOhuVEUfKsWC5KgRQgghhBBCCCkNv6gRQgghhBBCSJWxoNJHQgghhBBCyImPc6E4Fy50N6qiD5WCX9QIIeSkJ1lvR4stynnDK7dez1zzwCr95jvXvLa57osQQggpDaWPhBBCCCGEEFJl8IkaIYQQQgghZE5ErihRFTguVkMfKgW/qBFCCElwrBLDSsv+qtk2v9r6QwghZLHCL2qEEEIIIYSQOcE6apWHOWqEEEIIIYQQUmXwiRohhJyQVFIeONf2SSfEhe5PNTOTQ+ZiPm9CCCHHCr+oEUIIIYQQQubEkTpqCy87XEx11Ch9JIQQQgghhJAqg0/UCCGkopSStiV/F5vrL37VJJOrpr5UOxwrQggh5cEvaoQQQgghhJA54aKiuKgKpI9V0IdKQekjIYQQQgghhFQZ/KJGCCGEEEIIIVUGpY+EkEXGXG3rS7UPZmgTlXHMxeNCNf+UGuvjNYbJ45c6LrbzZrDddyXbz2e+mj6HcuanSGVLPhBCTjpc8ci/haYa+lAh+ESNEEIIIYQQQqoMPlEjhBBCCCGEzAnnilVSR23h+1Ap+EWNELLImKtki9LFhWehxzp5fC0J1EIUSArdcZMKlitPnOsYaunkQl8PQgg5OaH0kRBCCCGEEEKqDD5RI4QQQgghhMyNqCgSFRa6F0f6sUjgFzVCCCmB59XEsXNTC9gT8pvxVFTaodM6MJYrV9TbLbQMcCYn0nLdHcvZ90znSXdIQgg5HlD6SAghhBBCCCFVBp+oEUIIIYQQQubEEdfHmWqOHr9+LBb4RY0QQkpAuWM1ULqQtJXdORXN5k26VIHo5HGqiYWSYc51PCidJISQcqD0kRBCCCGEEEKqDD5RI4QQQgghhMyNqCgSLbz0cTG5PvKJGiGEEEIIIYRUGXyiRgghCw5zdkpzvMaj3HyvhbhWi21+6HNYbOdGCCGVg1/UCCGEEEIIIXOD0seKQ+kjIYQQQgghhFQZfKJGCCELzkJIwU4UyZnuZ/K3xaSN/rEym/NeiLGq5DGT5Q4W+tqXe/wTZb4ScjITilRFDbOFKl1SefhEjRBCCCGEEEKqDH5RI4QQQgghhJAqg9JHQgipKuYq60pK2xYTM0kdS8lHZ9ruZOREOv9y5I7VJuUk5OTFi4riRQv/DMijmQghhBBCCCGEkPmCX9QIIYQQQgghJzW33367bNiwQWpqamTr1q1y//33l9y2q6tL3vnOd8rpp58uvu/L9ddfP+O+v/GNb4jnefKGN7zhmPrEL2qEEHIC4kmqxL/A/CuNU/9m1wP8m09cmf/KbUOOD0HiXznzxZthu1Kv8/oSUjVExer5d4zcddddcv3118tNN90kjz76qFxxxRVy9dVXy759+6bdPpfLybJly+Smm26Sc889d8Z97927Vz7ykY/IFVdcccz94hc1QgghhBBCyEnLrbfeKtdee628733vkzPOOENuu+02Wbt2rXz+85+fdvv169fL5z73OXn3u98tzc3NJfcbhqH83u/9nnz84x+XU0455Zj7xS9qhBBCCCGEkEXFyMiI+ZfL5abdLp/Py/bt22Xbtm3m9W3btskDDzwwpz584hOfkGXLlsm11147q/Z0fSSEEEIIIYTMjagoUgWujy9KH9euXWte/su//Eu5+eabj9q8r69PwjCU9vZ283p7e7t0d3fPuhs///nP5ctf/rLs2LFj1vvgFzVCCDkuVMJGHPtwcrzsh0tZpC+GfKBy7N9naqOZz/HwVKTyDr3Sb+HOFdT/wnnrT+nzTh5zNrmM+MDnmbmv9z3X63Ys+yCEnEjs379fmpqa4v9ns9kZt/c8u0445456rVxGR0fl93//9+VLX/qStLW1zWofIvyiRgghhBBCCFlkNDU1mS9qpWhra5MgCI56etbT03PUU7Zyef7556Wzs1Ouueaa+LUoOlILNJVKyc6dO2Xjxo2/cT/8okYIIYQQQgiZE54riucWXvrouWNTnGQyGdm6davcfffd8sY3vjF+/e6775bXv/71s+rD5s2b5YknnjCv/fmf/7mMjo7K5z73uaNkmaXgFzVCCDkuVEJetRASrcUsCyt1bjPJVI9daud5abR2WrZXriTRqUh9AJnxw4g+B12mISq57/KZa5ty5bRqfLxMHPoC+ZJz1hzAlRxTvW9btsJbEEkxIaSauOGGG+Rd73qXXHjhhXLppZfKF7/4Rdm3b5+8//3vFxGRG2+8UQ4ePCh33HFH3ObF3LOxsTHp7e2VHTt2SCaTkTPPPFNqampky5Yt5hgtLS0iIke9PhP8okYIIYQQQgiZG1EkElU6J3aW/ThG3v72t0t/f7984hOfkK6uLtmyZYt873vfk46ODhE5UuA6WVPt/PPPj+Pt27fLnXfeKR0dHdLZ2Tmn7ms859wJ93PpyMjIr2sW+DL/xVYJIYScXFTW+GXuT9Rmgz4HLUWqxBO1uXLsJi6eeqLmiR5PPlEjxOJEJJLh4eGy8rMqwYufyw8+/VZpakz/5gbz3Z/Rgqw+81+O6xjMF3yiRggh5CSllCRwbl/MkjiXn8U+5voFSrfXX16C5IYltqtkX5KUI4NMtFBj6ESPZ+JLl6dc3ZQ01JUcDxFnXDVT6vXZuEsSQkjl4Bc1QgghhBBCyJzwoqJ40cIr3bxo8TwZX3hrFkIIIYQQQgghBj5RI4QQsggo91fc0hK4uXGiuHomz1lLB+dT7liKmY5z7IW1bQ5gqTy90jmINkfNKxFTBkkIOT7wixohhBBCCCFkbkShSFQFYr1qcJ6sEFUwmoQQQgghhBBCNPyiRgghhBBCCCFVBqWPhBAyb8yUN3Uy5rnMNB6lan2VO06lLN/L64M3g2196dpcmuTvnnO1+58N5dROS/almiVClSxRsBDXg5CTjKgoUgWuj0LXR0IIIYQQQggh8wWfqBFCCCGEEELmhBeF4lWBmYi3iMxE+EWNEELmjUpLrBbaIryUpGU28sQkpWzVS0sSS7cvtz84jrVlnw0zfTAoNW7lfqCJfvMmIlJe6YETSY5byfk+m/Zo4+mPS17iujlcn9Iy2WobW0LIicDCf+0lhBBCCCGEEGLgEzVCCCGEEELI3HBVUkfNUfpICCHkuDNX+VQpKVlSDlfqjfZ4OeeVcuubidnI5I6XHK3UWJcrl5yrI2apvlQ7pcbt+J+DkcYedfhy+pa8x06k60AIWSiq4GsvIYQQQgghhBANn6gRQgghhBBC5oQXRVXhuOhF5Soxqh9+USOEkGOm2mRM5Tr56XgmN8Vjldd5if9Nv29Xlivh0a2OD8dLWjcbWebCf/Cx6OtbrrvkbMYU+/C8tHodYiDnchU4zlxZ6PufELJYofSREEIIIYQQQqoMPlEjhBBCCCGEzI0oFIlmUngcx34sEvhEjRBCCCGEEEKqDD5RI+SEptpypaqZcn/lK2cMyx3ncnPH5sps9lXJXxxd4n/KyrzkGMyUI6dZiJIAJwrHa34l0XOnVG5fJY6PfTiXn/aYqaDFtCiGI+p/1fSrenI8ysnzI4Sc7PCLGiGEEEIIIWROeFEoXhVIH6vBebJSVFz6eMstt8hFF10kjY2Nsnz5cnnDG94gO3fuNNu8973vFc/zzL+XvOQlle4KIYQQQgghhJyQVPyJ2n333Scf+MAH5KKLLpJisSg33XSTbNu2TZ5++mmpr6+Pt3vta18rX/nKV+L/ZzKZSneFkGPkRJGiHC8b8ROFcuWfi822eza/Ws61P7OZe6W2S9a50dudKHN8oaSH5RwD65mn++nZ32ed02tdqdpDMx1nYe+rYjho/uKpjzXOrOmzqas0t5ICM++rnPcYStvJCQbNRCpOxb+off/73zf//8pXviLLly+X7du3y8te9rL49Ww2KytWrKj04QkhhBBCCCHkhGfeXR+Hh4dFRKS1tdW8fu+998ry5ctl06ZN8kd/9EfS09NTch+5XE5GRkbMP0IIIYQQQghZrMyrmYhzTm644Qa5/PLLZcuWLfHrV199tbz1rW+Vjo4O2bNnj3zsYx+TV7ziFbJ9+3bJZrNH7eeWW26Rj3/84/PZVUKEcscTlZNpPBZanltKnjgT+vfAch0cT5RrWkkp6Uz7no1jaTjtq+LsvjwzpxC7ks6OR+2xqijPcTTZ/3KcScu937Bvz6tRLxcTW9n//6Z9HQ3fE0j1QTORyuM55+btDv/ABz4g3/3ud+VnP/uZrFmzpuR2XV1d0tHRId/4xjfkTW9601F/z+Vyksvl4v+PjIzI2rVr5cgHgIWfEITMP3xTJiIL/0VNM59f1E4W5vOLWnnH9EqUSXAzzq8T5drN9YuanrvHfr/N/YvajHs3eyMEOBGJZHh4WJqamo7LEUdGRqS5uVl67r9YmhoW3lB+ZKwoy6946LiOwXwxb6P5wQ9+UL797W/LT3/60xm/pImIrFy5Ujo6OmTXrl3T/j2bzU77pI0QQgghhBBCFiMV/6LmnJMPfvCD8s1vflPuvfde2bBhw29s09/fL/v375eVK1dWujuELBIW8y+mMzmzLebzLsVMT0+O11O0Ur/Wz+ZX/IV+8lcNlPtkpxTzVxy91JMdz1NOzM7el3N/GjQb5uo4Opunl3Obu85NzXD8chwpZzrPuT3tI2ReoOtjxam4mcgHPvAB+frXvy533nmnNDY2Snd3t3R3d8vk5KSIiIyNjclHPvIRefDBB6Wzs1Puvfdeueaaa6StrU3e+MY3Vro7hBBCCCGEEHLCUfEnap///OdFROSqq64yr3/lK1+R9773vRIEgTzxxBNyxx13yNDQkKxcuVJe/vKXy1133SWNjY2V7g4hhBBCCCGEnHDMi/RxJmpra+UHP/hBpQ9LCDmhqJy8qHxmU/y21HpWrgvebAoiHy+5ZzX3bT6ZqwxxNhyvcZveGGQ295hz+bl1peLMdQxnkkG6EnGpNWMmM5Jy751y1qCZ+lnKlXMx3KPkRMWLnHjRbIrLV74fi4V5r6NGCCGEEEIIIeTY4Bc1QgghhBBCCKkyFr7YASGEEEIIIeTEJgrLzyyYTxaR6yO/qJETjHJzg0h1U+51K6cQbfJdAX/zVHtXMg+l3GNqFsJWfSbmal1+ojKbfLPFcN6lWDwfTuaXcgtel/rEOdMaUW5R+tnMw1L3+WzKEBBCTgT4RY0QQgghhBAyN1yVPFFzi+dHK+aoEUIIIYQQQkiVwSdq5ARjNrbIZGGYSaZaru11qWs6069l+NvsZkQl59HxkiGVJ+X0Sti3u6PGs5y+VcO9V033fDmSWZG5y35nsy8yM6Wkg+WsWcnt5vOX/HKud+n3SN9HrdooGq1Mlwgh8wq/qBFCCCGEEELmhOci8Vy5P1rNbz8WC5Q+EkIIIYQQQkiVwSdq5ASDro/VjKeWFCfFo/4KypUHlZIhLbTsrtx5ONe+JaWKpWSi5f2CefQ1KUU5boon0703VxnibH5hrqQrYLmUK0mu5DGPF+X2czZy67muU/M5hthfabljcp1ZPEYMhJzo8IsaIYQQQgghZG6wjlrFofSREEIIIYQQQqoMPlEjJwClXevKl3KR+UMXlS5O+/qLfz125ktSOFepUaXlSdO7MZYvQZo/udSJz0zzsNyC2XMdj+M1nnM9Tqn5NtMYzlViebx++Z7Pa1DOOlXueliuu2QlscfxvAyO6PLzdExCSDnwixohhBBCCCFkbkSRSLTwro8SVYP+sjJQ+kgIIYQQQgghVQafqBFCCCGEEELmBp+oVRx+USMnAHjwW305aSeKNXWlKbUQL8R4zPSmcOwW9vPHTMdfPA5Vx5fZXNNy2izmMiCzObdyz7/ce3E2uXAnOuWWBNBjU255jpkoZ022rztXOMb2hJD5gtJHQgghhBBCCKky+ESNEEIIIYQQMie8KBKvClSHHqWPhBxPqlkWRilI9Y1BJaVcs6FcOV61jduxshDnuZilcZWgclJQXQrFVaRMRDl9S4p8ZvNh63jMieM1D5PjPpvrW0r+rcc6eRy00Vb94iK1RbWlIRCyOKH0kRBCCCGEEEKqDD5RI4QQQgghhMyNKJrdg/BKQ+kjIfMB3aUWnlLXYCb3sflEHxfHrLwsq5KcLHN3NudZSno1E4vnDXf+qdw1sdK2cqV+M63h5fQteS9Pf/8vPHbueuq851cSWI6L7WzcJUtfX+fyait8ZEwFS0yLYjg4w3EJIbOF0kdCCCGEEEIIqTL4RI0QQgghhBAyNyh9rDj8okaqiJNFMlZtlJIr6dePl/NmUoIzvTyn+hzHZiNDOhkpp+hxNVKOLNtL/K8ceW41zI9yrkm5/az0+VTrHLH9smd9vNaCUmv1/BU01+tuUuoY+M1xHEbDZe2PEPKbofSREEIIIYQQQqoMPlEjhBBCCCGEzA1KHysOn6gRQgghhBBCSJXBJ2qEHDMnYhmBUnkTIqXP4XidW7njOV/9mU1Ox2zaLBTJ0grTkfz1sZrP51iZae5r5vq7pR3D8stGlMNszkH3Z6bryfzKyrIQ43a8jqnXEju/dV6a79XHceTG57tTpJpwoUhUBWuH4xM1QgghhBBCCCHzBL+oEUIIIYQQQkiVQekjIWVxIsodNdXQ54WWWM31+LOZA7ORnJZLqX37ia10WQN9zJmkIXOd7+VK9eYfryzppx0br9z+exhrz6szf/K96d9eA782jgvhqO2Dy6k+pOM4clNqq5mum/5bqd9hZ5K56vOeadxK9WE+7+UTfQ1eDExfLuUIuCaRmzguvSHVhxdF4lWB6tCjmQghhBBCCCGEkPmCX9QIIYQQQgghpMqg9JFUiBPJBa8U+hySv2GUcnA7WeQ4M0nB9FjN5HQ3X+NTnrStfBe8UsynRLKcfSX3p2V3kMk5V0i0CM3/ykOP6fQSEi0pdBW+tp6HfWsJoJYGHvmjmnva5Uu97pydk6X2HfgZtY19a9Tn6vv4W76one5smzCalOmIonzJ4wRB87THjFyN3sO0+xKx42Ov+0y/yZa61rORDs2n1LfUcSi3rD70WJV2iiSLENZRqzh8okYIIYQQQgghVQa/qBFCCCGEEEJIlUHpI5kDi0EWUkqqU65E40Q971KUkn8mZQTlyh3ncszkvpX8zIMU7GiHsYWWWJVy0Uu2L8dZcKY2uCbOuALOhJbwKZdCV16xZit3xDa+kl4e3QbXVDseFiNbCFdLByNXLPF66d8WU4EusltQr9ea7aII+y51ni4xHjXpljjOFeHUmElBqlgoWgdH38uq/ijJppZlJu6rYggppZZlptVxLHY8wgjn7ZlpqKWgyX38ZqdILRc9sg89buVKjOb6flFJGfFs7uUTlVLS1oU4t8XwmYHMCKWPFYdP1AghhBBCCCGkyuATNUIIIYQQQsjciFx1PM2KFs8TWz5RI4QQQgghhJAqg0/UyBxYDL9YLIZzOFaSdvbIN7E273kpzXzZLM+0X2VL7sZn2O5YKddSvPR2pXK3Zj5OOXOvnDy2mbfTffNUjpjJ/ZKiaZNRNvF6u7Rq3xAsj+OxsMe0z6v8s2IIm/pSlvUiNi8t5SPfrCm7umSbYqTt6DE/cuGIOqa19HfqONoeX+fZeb79DXOy0Kf+p3LuBJb+Nek208ZXeWE6r02XAUjijPU++lkMx6fdJklKXTdt3a/beDNMKWPvr/L8kjl7c8VTHz1mLu1QyZyqk3GtF7FrarnrSTnMlD+r/zZ9nvHR0LqfkOngFzVCCCGEEELI3IhclZiJLJ4fZih9JIQQQgghhJAqg0/UCIk5WayDkxITJdtTcqf5ZTYSnNlck1LHKfc3qvJ+GnQJ6eD8gX5rmaqJE+emZW+BX6O2w3XX1vYiVi6YUX9LqfYT0WAc1wZLTPu0sv53KS1JHIvjbNAgpdDbtcqqOF4S2eP0+r1xPCKQX9b4TXE8GQ6aNgUlv7RyS8g6A6/0W2N7ZnMcLw9XxnFXsN9sl1dlI5YFp8bxQITtsr4dg4JD3/QYeEpGqWWQ+nURK1HUpRC05NSfSXrpMirG2JjyApKQSKt9W9lv6XtsZrmjOk4JqZw9znyu1YvtPWE+SxyUs++ZZJiLbawJqQz8okYIIYQQQgiZG1EkElUyF3K2/Vg8X/YpfSSEEEIIIYSQKoNP1MgipVwZxckit5jpPCvptlXuL2n6N6K5Hj95TL3vUtLF2WQ7z6bPxz4eXtltcA5WsmrlYkEAGaJ2NtSSxijh6leTbsF2SsaYiyDH046LgdqviEhebRd42TjWrpFZz8r+lrk1cTySHorj7uJzcTykXA1FRKbC4TjWEs+MkhRquaaISFHJ+FrS6+JYSyS1dFNExPMwpj159MfL4PXmaKlp0+Cw71D1rcGDLLMg1lk19CA3XO4vi+PnUk/G8UjhUBz7CYmmPm8t8UxKJEuipl7Kb4njpEw1cpj/vhqb8QKkqIXisGlj5YoYD9/DnNByyyNt1Lx22rnSzjfbSN0XJSXJ5TqwlvuecLzeR0od53gdv5L7Xszvt4RUDn5RI4QQQgghhMwNSh8rDqWPhBBCCCGEEFJl8IkaWaSU+2vK4vnVZWbm7zxLF6+dSR5YSbll8ty0jK8cGWS5+57JsWx66aIej6MkjUqOFqgCz9q5LykF85WML1IFyX1TuDlr2qSVxLE+BXneUkEh6a5ol2kTKnlg0Sl3SLXvokxfbFrEyu4KolwB1bkV/ETxa/1upIZdF9auESvBSwXoz3jUH8cj+QNx7CdkctrdcbTYHcd5JdVLjmEqUG6Z6rp15Z5QbezbacrHPrT80zhqJlwfz3Dny3RkPEgxl6Q7pt1GRCRSc7RRjdtAYW8cN6VWmDZagjrpMAahkh3qAuIiCTmrki5qOW1SbqndKrULZaSKowcJaatzuii7cp5U98XRDpJaIqldLKeXXv56S5meansfmY3csZztypWClsvJklJAFhu33367/PVf/7V0dXXJWWedJbfddptcccUV027b1dUlH/7wh2X79u2ya9cu+ZM/+RO57bbbzDZf+tKX5I477pAnnzwiX9+6dat86lOfkosvvrjsPvGJGiGEEEIIIWRuRK56/h0jd911l1x//fVy0003yaOPPipXXHGFXH311bJv375pt8/lcrJs2TK56aab5Nxzz512m3vvvVfe8Y53yE9+8hN58MEHZd26dbJt2zY5ePBg2f3iFzVCCCGEEELIScutt94q1157rbzvfe+TM844Q2677TZZu3atfP7zn592+/Xr18vnPvc5efe73y3Nzc3TbvNP//RPct1118l5550nmzdvli996UsSRZH86Ec/KrtflD4SQgghhBBC5oaLRFwVmIm4I0/URkasbDubzUo2mz1q83w+L9u3b5ePfvSj5vVt27bJAw88ULFuTUxMSKFQkNbW1rLb8IsaIScE1ab5R95SaQvs40WQ+H9UItaUyvVIov+m8tC8xDGNJfgMeWl6byq3R+87FdSqbewSXVS5Pb4g/yZQ+VCtmQ2mjc5bGi4gd2vShx19Y2DzlpqlLY61hXyg3jI2Z1bF8aEi7PhFREbSeHMclK449tR5LndrTZsVbgn2J8g3u6AGfTs0Ze3s+wXHrZdT43h39pk4TnvWnr83B3v9wM/IdLgZcii1dX9ren0cDxetlEWXPMiqXLrAIWcuWaKgQeXTDUdTcbw8xFj3BIekJGpaT0S4vmtSW+J4f/Ex0yRfHI3jZD7fi0QqZ/HIdjifnI9rXadyIINEnp8LVFmCaCKOp/Kw9E/mZDZkkUc5VRxC+xB99hKlJbSlvy1bMRv0fT6bvNr5XLdnkz9Xqj8L1TdC5pe1a+37zF/+5V/KzTfffNR2fX19EoahtLe3m9fb29ulu7v7qO1ny0c/+lFZvXq1vOpVryq7Db+oEUIIIYQQQhYV+/fvl6Ym/Eg03dM0jefZH1edc0e9Nls+85nPyD//8z/LvffeKzU1Nb+5wa/hFzVCCCGEEELI3HBudgbLlebX0sempibzRa0UbW1tEgTBUU/Penp6jnrKNhv+5m/+Rj71qU/JPffcI+ecc84xteUXNUJOCBZaSpL8RamS9vozHadciaKmlCV/Ke+k5LvKDBLHF3vl7PlriaOROyrpYjbdpptYq3plDa9tzbWVu4i12tfb1QaQDUaJazMZQgKnpZRawqet9kVEfId9Rx76OS59cXxP/km1Ly3jFEmJkmIKZHv7C5DdTQU2d2BQ2cnXucY4fjDXiY0SU2CTrInj85eiz8W+TXG8x3/WtGnMrIzjJsEx82nISr3EXNG29ee7rXH8kiWYHz/sW2faHEpBZnpGBFnmqJIRHvZ6TJvHBGO6WiBhrZXpfwVOJV7XlvpTylK/y8MYrEqdZdqs8iEtfSF4Po778rux36ItpeA8zLGCst0fVpLE2sR812Oqyzy01aE/Y0U7HuP5w3Gs534mhcT95NzTEskoyqsY/Txa2lpqfS1VkiO5lszXelhpZmPPX22ye0IqTyaTka1bt8rdd98tb3zjG+PX7777bnn9618/p33/9V//tXzyk5+UH/zgB3LhhRcec3t+USOEEEIIIYSctNxwww3yrne9Sy688EK59NJL5Ytf/KLs27dP3v/+94uIyI033igHDx6UO+64I26zY8cOEREZGxuT3t5e2bFjh2QyGTnzzDNF5Ijc8WMf+5jceeedsn79+viJXUNDgzQ02BzlUvCLGiGEEEIIIWRuRFUifZxFHbW3v/3t0t/fL5/4xCekq6tLtmzZIt/73veko6NDRI4UuE7WVDv//PPjePv27XLnnXdKR0eHdHZ2isiRAtr5fF7e8pa3mHalTE2mw3POnXDPskdGRn5ds8CX8uVQhBxvKBkpj3LHaTbSR90a7a30yW7vKec7Z9zufrMkUkQkm4acrj61LI5H811mO+2k5ylJYl0aber8JaZNk3Jj7HDQzQ87OAQWEi6cB3xI2LTLoJYXhok2o8p10al33RUOcrw+D+6Dg4W9pn1jGnK6ojrPXAiXxubUKtNGO01qDoZPx3Fy3PX4LHOQQeo+L3U2P2FMyTxHfUj19BhEiU8aZ3gdcdwZwaVwRDlnhgmHQS0nbRJc06KH42ipooh1atTXylfn3RZBupl11qXxUAC55UiIXAvtspjkTP/yOB5S56MdPhujRtNGj0+Xj2s/FkK6GCXcGLVEUrtt1qZwDVs8OycmBfLN3inIN7OpFsSB/VV6ooi525zGnBjK4wOWlhqLJNYD5Tw5k/unxq4Zs3GaXIj3h+P1/jSb9Z3vl3PDiUgkw8PDZeVnVYIXP5cPfCErTbUL/7l8ZNJJ6/tzx3UM5gsWvCaEEEIIIYSQKoPSR0IIIYQQQsjcOIGlj9UKv6gRMm8snoWi8sxVDlPagc26LuJv2qlRS5UkWTBXSxJVwVvfh+tcSjnQHdmfckmMIJ0ayR+QUtQr98FG5XhY7+Bo1+esHj6jilx3C+RbvT6Ok3O2+HSTBxniQLEzjkfVGASJQsfaKVLznIPcsaikbL5XujZNpMY9UrKwpNNka9QSx2sycPIb9dAXLdcUEVkWQS7Z68ORMu2mL2QtIjLiY9zGZGja/hQTBZ4fVYW106q4uHaDLCYcOjPKVXNQjVtG8PpAfo9pszJ7dhxnHersTAgkmrvCh6QUYYg+6ILTzSkUjk7KLesifT445gGHouG5wBaN1ZzrUEz7kD8Ux92ePbdxFU8VcK10EfeVmVNFU6vGarUq5P509LM4HlPOkCIiTapItub09BXoZ2a3+dvAJIqgp1OtcawLa+t1Ien6auWOpVxnkyz0+8PxOn65DpJ0miRkOih9JIQQQgghhJAqg0/UCCGEEEIIIXPCRUeJVBasH4sFPlEjhBBCCCGEkCqDT9QIOWYWwtZYU+ljztf5JPvvSsSzyVvQr9rXnWrjqZ/VjD2/K2277XvIi8mkYR0eqhwkbS9+5G95dXzsuykDe/Bav9m0KShL/byDffqUykfSFu2/3nnMsA8b8sv8c+N4T2HINDnoXojjtMqbala5a6Fn85byEXKyfJW/llJ5TzrnKJghR01b5bdnzojjMddntnvG+1Uc75jC8VMqJ2zYHTRt+n2Mj1PXusnHuY2IzbcbKu6PY20hr48zniilMBkgN64utTSOVwlyqkaDEdNGz4MVEWznC8r+PZu113d1iO0OBOinr35T1Xb0UWIepwTn4Kk22jY/49tjPiYPYt9qvul9jUY9po3OaeyLUHqgVdD+yqaLTJtnRzDH9qWQV6bzMPdHT5o2bcEpcdzksO/kOWi0Pb+eE2Eax293602bplrkiB7IPRrHgY+cPU+QlxqqvLokUYQ7w65etrREedb/iy0/q9zz+c3r/rHtjxw3aCZScfhEjRBCCCGEEEKqjIp/Ubv55pvF8zzzb8UK/LrpnJObb75ZVq1aJbW1tXLVVVfJU089VeluEEIIIYQQQsgJy7xIH8866yy555574v8HAR75f+Yzn5Fbb71VvvrVr8qmTZvkk5/8pLz61a+WnTt3SmNj43S7I6QKOF7yQM38PLr3Ere9k2KJLefKbPrvJf6n5ELKAr/cTGEtL9L70jLI2uwa06YYQpKYUzbigbLnj5wdM207H/jTywC1vFFEJBDIxwrKMr2gZFWRZ49zSNnEL3Xo9/3hI9go8fPbadFZcdyehpRre7QLx0zY0TeocgEFwXhoa/klacj0ekJrdx6pcZ8qDsXxgJLqrQg2mTZFda5+CiexNILUcKeSR4pYWaWWAaYc5viyaLlp0+RDzjrgdcdxxkNJgCCbTrTBj426/MGIKh2wNlxn2tR66MN5rYgfHlAS2tD2bdzDWDdEkMp2C+SrNV5THDd6sJIXEekXlGlIC661liquCO18D9SEGVGyWy23LHh500bLKnMezqfXx3geHrXv50udkhGra61LW+gyAiIiU2qs04L5ttaDhPZwaq9tE6JkQirAGOjyCd3eC6aNlki2ZU+L48EC9q3lzcnyHBp9x0bG0t/Kiz0lF7Z/05LImeTjJ4uFfbnndrKMR5UTSZVIHxe6A5VjXqSPqVRKVqxYEf9btuyIht05J7fddpvcdNNN8qY3vUm2bNkiX/va12RiYkLuvPPO+egKIYQQQgghhJxwzMsXtV27dsmqVatkw4YN8ru/+7vywgtHfr3as2ePdHd3y7Zt2+Jts9msXHnllfLAAw+U3F8ul5ORkRHzjxBCCCGEEEIWKxWXPl5yySVyxx13yKZNm+Tw4cPyyU9+Ui677DJ56qmnpLv7iCyivb3dtGlvb5e9e/dOtzsREbnlllvk4x//eKW7SsgMzCQ5mev+9O8j5Th/VeKYYP6kjr+JUjJPX22R2EbJx5yR55W+Hlra6Ur9FqX2O5XvtX9Sf0sHLXG8JLs+jkeL3aLxA7TRskgt6/ISfdFSyDYPsrlcAPnboanHTBvtNulSSq6l2jdEVnLWGkBi9fMQjnY55ey43jvbtOnxIKHTUszJaCiOBx3W7KQUtGgkX+hnLoS0rs/fZ9poSV+opKD7Ctvj2PftW1ZzGjK+gqCfe3MPxfF+z8oY69NwKZwqQian+6ndKUWs3DEpYX2RzsDK6ZqVZLN7ENc+rSSvWbF92+s9P+2+k3PnRbTUUcSeg76VtCx0n/+caVOrxn047FZtcA1qgyWmjZ7/2gWzRjD3GiLrzDjm4fpoOWsxwNyZdMOmTdqDdLFBXfsGgeRzyOs3bXLemEzHVDgUx9rBVUSkNbsxjjPK9VXPFS0l1S6aIiKTBetgGrdR60dBHV9ERMw6gXlgruGM7zsLIYOczXEq2bcg8X/9/ulKbDef77HkKCh9rDgVf6J29dVXy5vf/GY5++yz5VWvepV897vfFRGRr33ta/E2npew03buqNc0N954owwPD8f/9u/fX3JbQgghhBBCCDnRmXd7/vr6ejn77LNl165dsfvji0/WXqSnp+eop2yabDYrTU1N5h8hhBBCCCGELFbmveB1LpeTZ555Rq644grZsGGDrFixQu6++245//zzRUQkn8/LfffdJ5/+9KfnuyuELCDHS+6oWWjnq5lkKsm/HcEl+6yKQlvwBN5PFL/VDmqeluQpSaOvHNcyKVuIOqMKCjcFqii02m8qUeB5sjgQx1pGpSWAWponItLqQbY3JCgAPFaAFHN5zWbTRhfJXh/BNbHOQRLZ7Vsp2FMOzoRa1rXS2xDHEwm52HlyZhxv9yG/nHS2ePSL1KasNE4XHW7JQpY5rl5Pyvm0vLAQQV6YVg57OTXOIiLDSvq3JN2BNuoauIQGRl9HLTPTMtWewk7TRhdYDtU11YXCG4I20+aw1xnHo6qAtpavJgs35wrIv9aFxuuVvHAiwjVIntsa5YbYK1CehAnHQc24Kgiu5YG+ul+0TFbEzn9TYDpAf7oDe331vTCmCminI8zJZD/1fHs2gCtnRwR3yBZvqWkTBBi3dcrhcmcaZYD0fXDkOJBcjkT4IVnLcZcrl9V23zp87sngHtEup5pUYCXJYYR7WY91GGEMnUu+V5SSRR6vtX42x6mkRDOpZyulxFJuv17G/MW5fHJjUkmcLPxHD5Hq6EOFqPgXtY985CNyzTXXyLp166Snp0c++clPysjIiLznPe8Rz/Pk+uuvl0996lNy2mmnyWmnnSaf+tSnpK6uTt75zndWuiuEEEIIIYQQckJS8S9qBw4ckHe84x3S19cny5Ytk5e85CXyi1/8Qjo6jvza+ad/+qcyOTkp1113nQwODsoll1wiP/zhD1lDjRBCCCGEkBMUF3niopnqwx6vfix0DypHxb+ofeMb35jx757nyc033yw333xzpQ9NCCGEEEIIIYuCec9RI+TEodIWx3p/J4dFsLXGT56zzksr14Ja5aKpvBJf5flEUT7RAsdJpVpwdNVG225r+3kRkbSPXJjxyOZ7vUg+Gjf/X11zQRyPOVh1N/jIn8m6WtOmO4RNurY/b0pNnxcnItIo2N/zPnJuzo7Oj+OUs8t6jyDnZomsiuMRbyiOC561K38g/Hkc6zwoz8PYnu+9NI6fFljoJ4nUPNDntjE63Ww36CFP6ID3TBzXBjaPS1Orrq/Om9IW+sn8Kp0b15heIdOR9ewxh4sHp90umZemCZT1/imZS+J40kPfJhI5f2tVjlnOQw5Tn0Mpg8ZgObZx9twKgntBn3e9moe+Z/NDM2peRinkdE6FuB61vs3jrBXkbk0JjqP7szSyBmGnqGvVo+zxuz3kZ6YT+UQTHso5FARtHpVfoP+JfLN1IXI3Bz3k/Ol5PJqw1z9NcP8c9DvjWNvw53yc21kO97uIHd8owD2r15awaMs6pBO5sXF7tZ4dvYae6JTKV0v+rZz2SaZ/f3GJNdRTJR9cyRxoQqoHflEjhBBCCCGEzA3WUas4827PTwghhBBCCCHk2OATNXKSU2m5o+ZE9IctNR7lyVScKDv8o9qEJf4GyYqXkGV5Ss6mJWuhkh76npUUNtesj+NI2Vs3K6v9SQdJlJYtiYjUCGRvDUriFapzqwvOMW16BRKpFlFyOjVMXeGzps1L/JdPu123sksfT9jmR+pnwrRAwvO4B+lhsnRArQeJVU6VCNB26ePFPilFTYD2eWWb/4SSn0WRlRcFqg+6n1qSuDfoNG2GivtlOsYLGIPlmU3mb6+rh3zyoRFI9XbJr6bd15G+QZLYIpDn6RIJaWfHMFRlHmoCzInJCMdMWuU3+pDXRiqzXUtjc+GIafNciHIDzRnYwReVlXtOzYklstK0H1fy0ayy/l8VoXRBb2DrmGbV9dkqkGg+m94dx0npZ6jkffq+vEAuiuP6wN7L+wqQMY77uH+HlDS3wbNSUi0XrnOqbIYHqfC+8HHTZre3I471vVDjwbCsSV0bEZGd4UNxnHaQUq73z4vjPRHm1LPBE6a9lplquaMuGdEXWXlxXpWaCHyUoPB9Jc1L3FfOLLulHhmcKO87yX7O9b241PuL3Zdz9joQUu3wixohhBBCCCFkbjhPpApcH0+Y3yvKgNJHQgghhBBCCKky+ESNnOQsop9dZk2pX7/mKkUpLW3xlPzMKXlisviJ72OJ8pWMqT0L6eFYwsFNo+WOzREkjnVKBrU0WmLa9PuQHo74QzhmCJncoeCAblLSHVJL1jZ7LzF/2+t1xfHh6Pk4XuVDzlfvrPtgs0O/n5C9OAcfEqsG12TajAnkdX3hC3GsnSbP8y43bbJKgpqLcH0ekwfjOFJuao3B9O6JItYJMK8kYuPFXntMJSnMh9hOSwoHintNm/8zhmuVV8fRElotAUwyLOjDaAESvDCVlHJiHi7x4JxZ9CCJ7C3sNm3GC9i35+E30ZlcJ41Esoh5reWa2o2xEFjZbqPDNT2sHCUDdczApU2bfoGsscvtimM/Uu6pSo6XZCrC/NrjY1+1oXVjHApwj2yKNuIPapkpOOvgquWofQLnyzof53m6u8S0yXu4dpkI59rpw0m0zVnJ6JByFtVS3V7BfX66h+N0CvYlIjJVHIpj7SibUbLsGuV6KSISBpA7TuUxV7SjbeDb+rLFcEj9T//OvhicEyr5XjzTvkpJ+vlZgFQn/KJGCCGEEEIImRMseF15KH0khBBCCCGEkCqDT9TISQjlDqWZzXiUGs+Eg2MJiWWgpGmBbx0cm7Kr43ilOyWORzzIupJOkbpI9MsyyhUwBxlTv5I0JYvsZh2kT2PKRe+x8Mdx3OpvmO5URETEVzI5LRkb9AbMduMyFMctAeR0XSHkZ/lEsebW9Po4XuFOU23gKFlIrdZNpEVJPidVgeZlDq6CO1XxbBGR9RHcFbXMs05J67TjoZbmidhiz1r6mPYhh6tLyPZGi5AeaqmgUz+N5kNbaFz//6zUVXHc6eF8msQ6/AXqba81aonjyRSuab9/WDeRYeV2eVgVKg8SDpualJrLrcr9b9Jh3KIZChrXpTA+eu4P+ZAQTiUKXo8J/lZQfe4M0Oe0Z2WMoXIWbAkwd7RDZ9KRM1IumHq+7yvAfbQxY+WFKeWk+ajAZfGU6Ow4Hk/8dLwh2hzH+/090/Ytua6cmcG4PZHHddSuj52RdW3U7pDtbl0c6wLiWjq5VHDviIhMKom0Xn+0S+uaYItpoyWn2ll1JKdl1faxQH12PY5ZgDTWKafJmYtkV/L9biYn4FJPVOZ6/NkUyZ6JUu9Xi63QODmR4Rc1QgghhBBCyNyIqsT1kdJHQgghhBBCCCHzBZ+okZOQ4yV3XGiJZbnHn03ftExE/3SlnB0TMhVPScF8JTfMKje0bGAd+nTx2H0COVuLQCpY41uXQ1/17cFcZxxrh74mtzyOB33rPmhkXurUlqliyxPRoGh00WxdpHeJa0X/vV2mTaOgjS5E3Rigb0W/2bZR0kNdgPsc76Vx3O9s33YXfxnH2kExyCh5YmgldHt8SCkni9if7+k2cPurTfRz3EGCpx36tPNm0RRHF2lOQaI4pmShdaroeFfRFg3XksIRJSncEl2ozmWPaaOlh1lvejdDLa0TEWlQ18RXUtvWCE6gvSnrBKqloXXKrbNBMFZa/pZEu0YOZdBGS1mTBdHTgvnmBcrpUUlRdV9ERNpU0ezlEf7WpQqvJ10wdbF0LbFsyGKccgnZbsaD7DWti9Sr5WetszLVF5SLpC5EP6nm8V5/p2lTm4OUcrWn7jEHB9ZhZ8fdd7imz4VwNj3bf1kcR970kkiRRBH0EONW9DFO9VG9aTPsQ27ZoPrp1+BjWbIgupZVrqrbGse9OUhb8zMUr3dOX8dKygZL/81Ta71LuHqWptR719zfR0v3h3LHiuC8I/8WmkWU1cInaoQQQgghhBBSZfCLGiGEEEIIIYRUGZQ+EkIIIYQQQuYE66hVHn5RW5RU2sKWzI75GveZcs/my2I4mOFveDDvq5wf37e2956y8U4HyNdIqVwNne8iIlIbIL9JW5kPFPfGcdL22nfoz5g/LNNxuLg7jptTq8zfmpW9vbZyDxzyfJq9FabNUHQojp3KyRpTY1AvS2wbgR39yBRyZiKVR9KUtTbgvuC4KcFY56Sg4inTRlvdr02di765oThuDuz5FFQOUnuA3Dzd53Z/YxzXOZtbqPP+9L50nuA6127aHFLW8qc7lFXY7u6P48Czb1kjIfqjxy0K8C69LLTnNqJyJQ8Ict50nuEWZRkvIhKqd/3HvUfiuMbDPE7mtWl0+QSd5xeqsRGxOXe+uq9qHI7TrHLMDgnmsYjNHdPj0ZJaG8fLwjbT5hnvV3Hcp+auzsPUOaEiIgMOeZz2fHDMdKLUhr5/QzVfdzrkUC7zTzVtNgnywvaouTekSz549jhDKm9P52ROCPK9NnsvMW32eE/HsS41sduDjb+nrketZ3MyVzvcI7kU7j993ddlzjFtxtV10Dlvk8WhOI6czQ3UY1pQOXf6Hk8Ftm9hpNcDXfZC73v+8rP0ccrPVytl9T/391R73IXOIyfkN0PpIyGEEEIIIYRUGXyiRgghhBBCCJkbkV8lddQWzxNSflFblCyeCXpsLGYZQ7nnNhsJS6l9l7fYekoq5JSkKRVYqV++AClVjbLk1/IeLaMSEVnmINnqlhfi+FzvijgedFbe2OtBluUpGeRUBOlTfQoyt2axUrAh14O+qfE81W2I41+EPzZt9P7M68qSe8jvMX8bKxzGcZRkrSkLudcyb71pk40gE530Yek/IZDd9YZWDhc5yA33Fx6L44wqhVCMrARvSRrjPuSU3NGhP1pWuiSy13pNiPa9PuzC9XgUEnNVyxp/Gd0Tx07JDtent5o2Yx76oMsqDOs+y3LTZlRJLHVZgqKSiI15VnK6X1n816hyASMCiaeWn4mInO4uiOOUsvTPq7IEB4NO00bLDXXJgw1K8trtYR43+Hbe6dIQWo7a41A6IEgIac6Xi+P4khbcf08MYdy7w3HTZtJHH/pzz8dxYwZW/02JcZ8SLVeEbLc+hbnTV3zBtEkHkMrpMRj1BuI452wZgAklfdRSW10u4AXvSdNGz38tfV4d4l7U8tdJD/eeiEi3h/mhSyGkfZQkeDiyZQTaI8hJ02pO1QUoLfF07oemjZZyNqUw1lGE87RSx4T0UEnY9Vo9v+kS2Fdp2eFsjzmb93zdRt8LtOcn1Qmlj4QQQgghhBBSZfCJGiGEEEIIIWRuRF6VSB8XugOVg1/UyAnOQsgYFkJiWcnjlCs5wXh63gyuj0pal81AnlRMyKXSKUi5tMSxxofsR8uGREQOSyf2LZByOYc+j/tW+lSrZEQNEY7ZpeRK6yLlZOhDbpZkVLkK/iyExGsmN7bAxzmM+qMl9236nIb8UrsPHlbHFLHujE1Kbvh8+HAch5F1UwuU82TKg3RyqQ+HwTCw56PHrbfwXByPOLhTaufOQspKJzXa4a9HIBFr9dea7YYcnDM3BJA4Lnc4z0NKaihiXQ6zAa67lmjWedZ9tEXgNlmbxnkWRZ1DYvlIq3FbFUIad0Y95uSvJgZMm0jdV3t8yFG1VK/Os5LRjEAqpx1Hux2khh1BSxxPRHbujwr6kBac9yY13/uVdFJE5NJ6SBRf2g457q8GMQ+7gv2mTZuS7U2mIT+dCrFvF9hPStoRUs/xOoGL5amelbYGEdadQ95QHC8XSFP3ydO6iTnvceVsmvVwrZJySX0/jxS74nilhzm6UkmFH3GYxyL23KYijEd9gPtay4FFRDrVnFgTnRLHKwRzMpW52rTZ5XCfLw9xDcIsjh+KvZeHcvviuBAOYd/qfimGdk7YT7nzJUksd78zbVdJd8jFnDpBTmQofSSEEEIIIYSQKoNP1AghhBBCCCFzwjlPnFt46aNbRA9F+UWNLCIWm9yxkpTr4KgLkpYeT+0k1liDIrV5JXdMKWmciHUm0zQKZFDakU9EZLwAqVtrGsWadYHnCWeli7ow7VoH1zbfg/xrRDkWDihHvGR7LdH0lStha2aDabPFnYV9G/dAjEdebEHkOuUUuV6174yeiuMg4YKpi0fvjR5XfYZErDljHQszXp3aDueWdrjWUULQP+jBoVLvb7xor8+LJOVWuiDwQLEzjrVUcSohWW3zcK10f571nonjycg6fGr5ZEEV+tZufxMJKWitkhdqF8qeANLLkYRkdXkIh73zmyCBe3IExzw9Y2WMG6Dok/8ziDZ1HiRn+hqI2GLtqx3mx9M+5Kd9DtK8M1ShZRGRCQep3bPejjgO1Ny/oMa6MTZnsJ490qeKMKv7/8zEcQYdZMS6YL12JZwK7bXS7p1aajjuYU55/mmmTYuS4JrXHa5hVs41fzvsQ76Zj3DPTai5myzGvTQF6aFeTw4op9mD6tosc/Ye6/Mwd6aUTHUsxH30fEJerCW4Y+peGJahOF7ulpk2jUr6nFP30ubojDje6Vt3yaVZFKYfLkK6PJmHrNtX7pQiIk7te+4FoufzvXM2+9bbYU4a9+IZi3ETcnzhFzVCCCGEEELI3GAdtYrDHDVCCCGEEEIIqTL4RY0QQgghhBBCqgxKHwkpi4V+jF5Ki1+u1f5M/Z/eet/T+3Y2h8lTduWlSOakNWSQk6HzV0b83mlfFxFpSsOCOutq4lhb6qfE9kXnZOlcNp1HonOqokQuXlblrzQoG/GCj7yNJc7m+RzwcA5ZQT+7VY6LzsESEWmNWvC3AMccUfkvOVVSQESkXVlyd6dw3bQ9eLuzx1nqkB/VrezbTw1wDs9ENk+v0SnrbpXv1ZLCNexzsP3WYy4iMub60F7lu+i8vFVRh5RiwEc+kS63kFUW6SIia9R4FATno/PIWtJ27j8ygPnS6SPfa22I/pxaa48zUcQ+fjGCuZdV5SSaMjWmzTPDuGd89ZvoWT6uzwWttm8/7cVc3Osh12qlsnbf5++K40OJnE59y7614bI4fnYUuXTfzf3CNHmNe0kcr6pDP1/Zjr5NFu1vuv88gHm0yiFH9bC/N46LkS3ZUKPKc+h7zlelP3pdp2nT5+G4y731+IMatiWJfLP9bkJthmtQm0IOYY3KExQRyas2Oq8tr8of6Lm7zyGPVESk2UfuWEMKeWU51T6Z37ksUNdU5ZuuCs6M47HE/a8Z8JBjtsy14PjSYrbrzMHSvzGDXMuGOtwvvROPi0WVZlEfE53JA5/pvWem96hKoo+j38fKLS+AvzlTcmWmPi/0Z4HqxkUirgqkj47SR0IIIYQQQggh8wW/qBFCCCGEEEJIlUHpIzkBmMmCd/E83p6ZSkpJvMT/fvP+klLHtJIxacvoUYEcpxBZ2c7wVGccZ9OQIQ3nIbtbmtmom0ijtMbxoJJItkaQ4A3KIdMm5yA3mighkdSSpCSnKqvrA8H+OF4RQap00H/BtFkdwd5by+FWK1v0Ds/at/spjHuxRNGXrLOyLi0JDNTyXSO2FIJGyx21BO/ZCON2iqwybXZ7uCZ1Sjqp29crWWggiTIC6tqn1NxZF50exxc2Wuv1ninIlQ6rvtU6nNvSsNW0SStp3KuXY6wyPmRMv/cSK/X79iMXxfGBCVzTJ4a0fbxpIqNFyD/fvRr9eagf551O/Oy5vwgZ71JVgqKgZFnPDFvZcbdgjg8KZJnORxst5+vzYLcuYuf1f0zg+Kd7mJ9aqigi8lQO8+OnBcgtWyL0+dXN1ib+4kyHavN0HOvr3pq20taBAmSRTakVMh1agihiJbW1Ea5vTnA9xhPlF87ycP/+MrovjqfU9WjJ2vm+NEJZgu4A1/RwQUl4lfS51rdzV5eTaHc47ykf5zMZjJs2Y6Jk3kqpd6D4ZBw3p2w/dYmPjC4zofrcFNq+tddASjkRKdmuh/s6m24zbXLqvD0tLVXX1x1VDkfPZf234/UejWNauWby+KXKzpSbUnCil+qZZ5xXHa6PVVDLrVLwiRohhBBCCCGEVBn8okYIIYQQQgghVQalj6QqsdKF4gxbzoZSEo1qZq5yC7Sf2bExmvbVTNrK9rSjo5Ya5kPIewpF6+Co5ZK5gpLgqH0HnpXQdYdwuNso58Wxdn2cKFg3tUI4imMGjYiVhKc+gNRHyytFRFrV+PQq6WFvAFmnlh2JiOQ8yKKWezhmLoIErye0sq62APvYryRJSx0kZ71K7iki0qrkaAf9PXGcFSuRLIWnfps7HD0fx6P+wHSbi4hIV/hsHK9MbY7jTRFkqns9Kz/VcsdNck4cF9X8Gk/c1lqCq+WODRHG88Jm68a4sQGyt6kQ90VLBuMepAumzbXX3RHHX/i792DfbZjHu0asK+D6Bszr8zow7g//7Pw4TiWUNm9sxz5+fHj6NWwgb183DpsCee+QQJKo5YCZhDT24uC8OG7NYJ07NIUxWOoadRNpy2Ti+PncI3GcCzAe3xqxUuG8ciM8JcQ82OlbN0RNTdA07et6rui1RMTO16VKqveU90wcdyjZsYjIiIPDZVuAvx12z8VxV8H2szYFOeySSMk8lWywvwC5c1LWHXjqo5QKe/M45pKEFHR1tCGOPeXgquWfg0ouKiKyOn12HGtH2D61tjQkXHC1C6ZxsVVurNnEtQnUNSmoNb2o3H9dQqZq3zvKeb8q17F4JqY/jv3MkDzOb37/9xJOyK6klJMyyCTOeeKqQHZYDX2oFHyiRgghhBBCCCFVBp+oEUIIIYQQQuZG5B/5t9BMLw46IeEXNVKVVFbuaGUMWmJV3WKFyskd9cNzPyF9jFxu2u08H9uFieK1WhoyGUK25ykXvqRcsqgkNOkU5FerUmfFcU9xt2mTUQWOhwTHGYjgxugSK7KWO+qC2c0CSdPp3uo4fspZedETAmnbRSnIug7k0f8Bf8i0GfMh89yvutPtQS6lXdZERA6qMaxTcslDHsag1rMOblrW1CK26PaLjHi2b5MyEseRkvA0+JB/Jot+64LeS1Rh7IJYh70X2eBWm/+f6qFod10Kc2J/AdK2vZNTps2ZjSgY/VpVFHpZDfp2bquVgo7kMR5NGczRnUMtcRwWrJxW8+7X/jCOezrR55XDdtzblkAams9DKnjt6XDHzKTsmvWTA3CU9D0l6wxw3VfUWnnOkimMY08eY71aySB7vEEpxYC6T5/IQ456npIAvpAoKr8nHIrjc70r4ni/h4LmY87Ki7X0d0JwzHMcZK77lFxTRCSt1p2U+uhxhporT3idps3hIqSDz6bVdVTL4XOeLdasC8uvilDgeVhJl8eLdh51hjviWDstptX9ptep0UShce30WBuiTT4NeeBIsdu08dR9sSTCPbbSwRFzUOzaNKJcQdeEqtB4oN06rZRbS2UHi1g3VwaQMWtXURGRVg99OOBDZjqui0I7+2E8KumkO5/ywHJkiDO5PpaSTtr10FdjGDnt3lndnyDI4qAKvvYSQgghhBBCCNHwiRohhBBCCCFkTrjIE1cFddSqoQ+Vgk/UCCGEEEIIIaTK4BO1eYf2rceP6cfa8xJWu276PJuFZya74nLn0fS/Itm8PJuP4ClLfKfy1ZzOR5Aa0TRkkDMzXkDeRH0aeWCFyNo36xy1mqAljpP5HpoNEeyxn1e5KO0+csdygc116i8iLywQnFvew3XPRRiDMc8eP+WQYxKpoW5QOTZdnj3mcIj8k94IOWYZX+WlJS5NvUMeVNZhfGv8RvW6tV8vqGu3NEIOYK+Pc9D5eyIiKZVruDFCns2IjzIGYSIndKlrieMlKeRk9RRxTQOVdzWVyHE75GE8LvSRv1Mv2Fedb99+fjyOnKj3r0SOjP418dC4zfObCHFvv/zcHXH8yo3IHUtfYe3o3WOq3yMoA9C2Fjldk1MJi/PD6M+55z0Rx5vesz2O8+e+xLS54K5/juN/+/Q1cdxfRC7PgRGbP3cwwBgMRJ04pn9lHNeqOZEV237Ew74nHHLZhkLM/YPec6ZNg8Cy/Qn5RRxvDi+M41NrTjdtHs6jn4G6Qt0qj3SVtrkXkaf9J+O44GAt/1yEebAyWmHa+CqPqzZCnlCzKjGwPG2v1fYIJT2e87vwB3Uvr8icJZqh8GAc61y6sQj31RIPuWttiZzMglpbxjzkhBbVelpMWPprDjjkgelyBTpHV0QkVGtys8oT1Hlxe4M9pk2zKunR5GPNGBDco8myKL2CNaTFx3mnsjjO4KSdR75a68rLVyv3b5Wz7Z9536X7FqmSD/NbOoiQo+EXNUIIIYQQQsicYB21ykPpIyGEEEIIIYRUGXyiNu9Q7nj8mH6srYSv2phJolHqb+X9UuQlyhLEe0pIcDwfUipPSalqM5AhRYkxnCxC4hT4kLMVI0hEwkSbTApSPy21mQghL1rnn2PaPOcgLcsVISkaz0DCMxb2SSmWO1h/73fPxnGPwMI62U/dt0ei56Z9PYmv5LVpH5KkjIqbpc20STksv72esnkXXA8/8VvawQDyPF/ZY19VC/v1gdwq0+Z5NT51SnqYU3LLVV6TabOkBn07ZwnG52c96NtwiNfDhJz2wjTkjr15bHd2M465c8SO+2k+5GTPjWA8uyex75rAXoNtKyHFHBtRcri1mCvSOaKbiFNyuobPvyuOa2tw/D2v/Lpp81Q/ZHxNOyG7Pe/2v8RGf/Eh0+YX91wVxxsyGN9dBdw7tQnp4tW1kOTdrazhCyGkpaNKshpEtoxAVsl2lwnKA4wI7vnfbbzMtOkcx753qbXgsAfL98KUlXgFSrba7OGa5gTXNO3ZuXu+nBvHP49+HMdhgH0/4/3KtBnPQ1a9IgsZ9Cke7qUtLaaJHOzF/O/0IcHb4DC2A4lyAw2BvTdfRMsQA/VxSUsdRUSGlW2+llvX+rg++cDKAUM1Vqt8SEuHpCeOk2UEphzuhScyj8bxSof7P7meaVllU4A1fb2y99eSWRGRoioL0lXEutmgSnXUZKy0daqAMbV29lYCP38c+3tk6fYzbTWblARCZg+/qBFCCCGEEELmBgteV5wqGE1CCCGEEEIIIRo+USMnAeVKEo6XjGE2x5mF3FFLj5RkRksdRUR8D8tAJg3JS1LuqFmipG2jyvGwOQX52OGpp02bVACJlHZD03KabveCaaP7ECgZ0kQE+dhYvsu0WVMLt7rOEA592u2yx4fUsNaz8rElyq0uL5A4FVS8Llxj2uwJ0M/hIhzkRgqQKiZUbpJzkBvllRNgUxrSrVPdBtNmpwdHO09d30OTpd3HLqjB+OofGUcnIVPd4/WIpmcKboiPHIbU7lRvZRzv9iELXRvZfu7PQWo3rhwyRwuQnO73rKyrPcTfGtM4t+2jGJuL65ISTex77dan4vhHX3xDHF91u51Tqa3Xx7G+E9xX/jCOPe/lps3LNsDJc8mSoTgeH3wE7cfsfXXJtp/G8XODb4zjZUM4z84xe930Xb4sxHU7JQNZZ2deOSEmJtWQB5mZlrxtlPPi+N/Hd5o22hXwkpp1cTxawGw5IKOmTUuE6+D76PXLGnFu24et5O2wmmPrffRnbwg317X+FtOmNzO9A+OvfPTtuX57/w75di6/SKRmf72zbopaYqy3Wx1BUhh5WKsPec+b9to5c0RJF+sFEm0/IZ1eG0F6eMjfG8dNWiKdWDPGwunPbcTHergu3Gj+9lgImWlPcSiOwwzWrBqx45FSHw218+S4ugZJKXjgY32PIqyVWk4/uzQELeEPS25lqfT7tz6u7o9+1jGTm3K1Ok2TEwF+USOEEEIIIYTMCRa8rjyUPhJCCCGEEEJIlcEnauQkZyFcm8o7jpYxWqepaNptRKysURevDgLIg9JBvWmjJTm54oB6HbKjpVkrp9FyR+1yqOWO2g1SRKQhBSmXlgr1R5D9JItkl2qfV9t5CXc5p2QqrT6c7w4XIdVrU8VrQ2flZ7owti7aG6prMOhZJ0EtCcqFkIlpp7oliQLA+zyMlZaSnhKdFscNKbtE10S4dnVKvrWiFtulEz+/1agp8sIYxkZLvKKEbGe37IjjFg9y1icFEsANSro16pW+bvscJInh5Bn4Q+IHz84ActS6ofVxfHETZHZvP3WvbiKXvvc/4vjfb39rHNcoKeruj9mC15tu/GQcOx+D5b33i3G85T1WYuV/+b/Ece4Vr47jzOPfxTa3fsq0iT4PKWVDGv1pSkMitq7eXt8u5XC5tRHn/ewoJJ6+Grheb8i0X6vcEDuVK2jRw/k0qULpIrZA81OTmCxrlUtrcn6Me0o2F2H9+N4oruFSdY+LiAypAstdIfqdVdK6Pu+gbiJZD387w2G+PS24l7VLooiV5Ol1ottHEWdd1FrEFnzXUtB1agx2KFl2g7PnNuxwbtqpsRioNTghFRzxhuN4RYR1aq8Hyaousi0ikklhfS+o9V3Hh9R9JCLS4W+N43q1fjxbfADno9ZWEZF2h/VIS8adKmyfDawMWb+PjCs5uqfcS7UE380oY5z+/W7h0ItVKRmkpbrdpucP1lGrPHyiRgghhBBCCCFVBr+oEUIIIYQQQkiVQekjIYQQQgghZG6wjlrF4Rc1cpJTTTb8Vu9eKi/NPAhP5Gdpq33fRz6CzktrTtm8h77cLpkObaefzK+oDZDnovNAmrLIZ9oYnWXa7Jc9cazz0qaUZXSyJEBNqgV9UDbPGZUXN5noW28BeVS6XEB9Cnkl2mo/SWOEnKYpQX+WKPvpwcTljFTuhlN5GNpSfMobM23CSOX5qFycx9z9cZyNbB7ImdF5cdzg41o/M4G8uILYnLsGZUI/JrDNrxOcT6/Xbdro8U05HKdF5dkFah6O+EOmfUsEm3ad49KvjnO+l5gfquSCvnW6JzHYuweUdbmIbHkMZRKu2X51HBf+6o/jeODZ9aaNt39fHEenI4dwqvdncVy//CrTRv7oHxHnDmNfj+JaDV/3cdNkqOeCOF7XjHM7OIHr0Tlm34L1irF9FLljZ9ZiHvw814n+Jz6N7FF5YG9ruDKO+3LYbkuLaSL39yIPa1SQC/eYysnK+zYH0fewVuUc2tQ6zJuDwT7TZqnDtVoTYGwOeX1xHCbm7oBDeYvnlIW9ziNb4qw9f4+PHLEJwbiH6l4OEr73I0XkVKVSyKl6KEL+my5BMajs8EXs+qjX4EI0qV63a/VYMBTHNR7GTeelHQ6f003MeqaPOVRE/p2XEEqFqvzJSmX9vyZ1dhz3O5vXtjd6XKbDU9e9xrO5n5GHa1eXxjEnCj1qG50baHPUbE5XuTb8C0GpfLXFkxNFqosq+NpLCCGEEEIIIUTDJ2qEEEIIIYSQOcE6apWHX9TIPLEQtvfVxrGed1JU7ZeIQeA3Jl6ZXpitLbDHQmtn7SsJXcqDHE5bNk+5UdvGlA7AMddFp8dxUvo0XDik2kAyom38XWj7b0oHOEgHtY1/sgyAlgdlPMjMloWQLtUI2qQSkhVted7rw0J7wEE+OqLkWiJ2PBoy7TIdLWJfdz5khDVKMjakZIe1npV1LUtDOnSggPHIKbv0w54d93URSisU1HbDSgpW5+w8qhP8f1zZiPcqu/GlIeaHlkeKiEwqu/58Ef1s99GXrtCWOFjmQd63uQnjOVzA9Un7dn7UtqOchPuPP0V/TlN29BNW1vkft74+ji86+wkc/ytXSTnUZHEd992FcgOrLnrKbvchnOvqb/4ojv/1c7Dtfypv78VNKcyJfh9z7D61XXuE4z/v22Pq+29VHcbgoXFcw7E+e62HBddK2/ivDFfE8S7/SdOmGGIeTPlYG9Jq/VgfnmrarErj/tlbwLUf8CA7XOk2mDY9ynY+pdapcR9z6hSxZS/GIqx1db4tRRD3X+1XRKQptTKOB0PICLM+9nU4gORVyyhFrPS5JQWr/aUOYzjq2/mecViDOqMdcVwfQJ6YlDEWlMx0rSqP0RM+i/ZpOx79+efj+CFVomCFj7l7itti2uzyHo3j5gDncDj/rJQiH+KapHysU1oGOZqDfNVPlEiITBkAfZ/r99Hkh++FLanjqY/QR5cbKNXvk/XzEJktlD4SQgghhBBCSJXBJ2qEEEIIIYSQOcGC15WHX9TINFRCXjCbNiejPAASL1/JhkREXEKe8yKekox4CScxLRlpya7Ddurh+WRkHcv03zpS58dxg5IQ7XQP2eMomcqqAM55tRH6pmU6IiI1AaRtw8q5LpOCvC95Pjklj0v7kDGGyiEsraSCIiIblfyr24dcqU7Qt0EP+90YWCfBXqVgWaJcDrMOMswt6dW6iewqwt0x5XBNtdRwyOs3bRqUW12tQ982yjlx3CNdps394SPomw+51joHOdxpqXNNmwP58TgeVI54b2mE62JT2koKe6ZwHfaNQ/q0RyDB066Ru8KHTfvWVEccr02jP8vVeNZ69u1nRQ3Gt19N/T85byf62WgluF07cK2XDkJaW5xAn2vahkybyy7aHsepGhxo7EM3xXHDZ/9KSjGu3CGXrMJ4pP70C2a74I5r49j70y/H8Yd33BrHQ3dfbtrsnoBLYBhg7pwSro9jLVVsEZyniMg6dS/pa5jzlGSuttW0yY/jvvLUh5sJ5Yxa7yUkhMqgVkvWtDz57IYG3ULq1OV+dhjnORXhXhwKBnQTOS3EetTtHYxjfV8OJ5xiWwTrQaRkotpRstfbb9poF0jtPKvXmcEIbYrR9GuziEhNGtJSz+EaNEUtZrsBtTZpN8XBAuSBKzLWGVXLJZ8Kfzptn1MJSeHZqVdM22ZKcK1Wp9abNq54XhznlTttWt3Le3P2PaEps0a1wb71+pxNY60tFO29LOq9yzPSei0prK7PBU7NKW/G9+/q6jc5saD0kRBCCCGEEEKqDD5RI4QQQgghhMwNVyUFrxfRQ0x+USO/RhdbXqhikyfKnVU5iWagXMVCJRcREfGU42GgZX+qiGomsAWRNVlVRLk3j8KpxXDcbLem9uI43uDg0PWodnpLTImN/oVxXBtBjjOq3P6aE25sewvb1f+wkEcO8pEwISmqVw6KWqKZVeftJwuFR7gmdQ5jsCdAwW0t3XwyssV8cz7Gtz1E8dk1aexre/S8aTOqJIHaKU4XBj4t4YJX6+NvPYJrMu7b66NZoVzxVghkbn+wEefw6ICdE4cGMG4vV1KqJRlc1N2jdgzX12N8Dk5gvo+qAsJLBXI47bQpItIQoW9N6hoMKgfJ/cpRU0SkOLk+jvNqwn1r12lx/JYznjFtOs5Esfb773tpHL/24d+WUmT+73VxnDv/ijiOlCQwWbxaU/sBzInU75TcTAoXoT+RKpK97yDGKp34PLOpHvf5GR5knStrcT1+2otttNRYRGQoglyxpQgp1qke7qPBvJW51gdYZ3rU2hCqa5B1tabNqECiuEwVsu71cP/+Ytw6o167GpLAliHM0V51vySd83QfzpNNcfyg97Bqc4ppM64Ky28SyL8H1bo56S01bfKqEHxG9Ue7Q+r1pzbVYtprd9bhIiSadQHOOedNmjYZNaZNylnRDzC/zhLrgjmk1se9et0Mcf8P5azrq5dFv5cGGKueKTg4vpBZZdq0inK79DAnsg5zqi27ybTpy+E9plHtb0rJ1wMlyyx6dp3Tkn5nxl3LIJPvt8frs8pvfs9PpirY84H0OBVg3SyGNg2BkOmogq+9hBBCCCGEkBOZF+uoVcO/2XD77bfLhg0bpKamRrZu3Sr3339/yW27urrkne98p5x++uni+75cf/310273//7f/5MzzzxTstmsnHnmmfLNb37zmPrEL2qEEEIIIYSQk5a77rpLrr/+ernpppvk0UcflSuuuEKuvvpq2bdv37Tb53I5WbZsmdx0001y7rnnTrvNgw8+KG9/+9vlXe96lzz22GPyrne9S972trfJL3/5y7L7xS9qhBBCCCGEkJOWW2+9Va699lp53/veJ2eccYbcdtttsnbtWvn85z8/7fbr16+Xz33uc/Lud79bmpubp93mtttuk1e/+tVy4403yubNm+XGG2+UV77ylXLbbbeV3S/mqJ3U6LyUqORWRKSSeWmeuu0ih7wFnZMmIuIrjbvOS1ted14cjxa7TZu6FHIvJpQNf8avj+NsIq/ttAhW6k/7nXE8lIcddbLNkI8clYKy8dc24APugGnjKzt2L8BvRLqkQENmpWlj8r0SuWgvUi8t5v+B+v1JW2BPRsiJ0rbbed/mqK2KNsbxOmW1ral1tiRA6CPvoENZqadVX3zPSjEOuKE4nvCRV1NQeT55Z/NafLW/9fWYL/d04U3i8fER02ZrI67dylrkdOwcwb4eyneaNpHDOazF1JGJUeSLPR/gV0adlyMiMqLKCpzqbcV2PkoUZBJ5T30qf61G5cLsn0A/O3vbTZv6Tly713zsnjg+8Lu743jNN643bcLncf/WvOUdcez+9Y/juPYae333/+PaOG6898E49pbiGoS//GvTpvAvuEcOPPOdOF6/bgjH2WVzkHw1RTY2YB7UppCPdFmEvh2esnOqRt0iFy3FnPrWfrR5Kjykm8jKCJbpwz76Fqh1aklk7flH1f2v8z11vlq72A8u/+cA7rleH/lrDYI1KxRrtV/0MF/7QtwLaR/zQ5ecELFlQV7QH3HUz9Lb6m1e20OjWCv7A7QZUmNVUGvweAHrioiIn8V1rAlw3s3Kkn+X7NFNpCVAruJENH2u0sOevZff2nRRHD810prcXETse4WISO/kU3HcVntGHOt8wG7P9q3WbY7j+ggLQG+A95sWlc8sIpLP4F6cVLlXOscsNHlc9jmBr65pGNl5gH1ZnDteOWrlvOfbbWzOGsZgseelOVcdNczcry/HyIi9h7LZrGSz2aO2z+fzsn37dvnoRz9qXt+2bZs88MADs+7Hgw8+KB/60IfMa695zWuO6Ysan6gRQgghhBBCFhVr166V5ubm+N8tt9wy7XZ9fX0ShqG0t9sfA9vb26W7u3vaNuXQ3d09531W/Iva+vXrxfO8o/594AMfEBGR9773vUf97SUveUmlu0EIIYQQQgg5Sdm/f78MDw/H/2688cYZt/cSyhfn3FGvHStz3WfFpY8PP/ywhCEeRz/55JPy6le/Wt761rfGr732ta+Vr3zlK/H/M5mMkOOFnhwLZcN/IjLX0gFKk+Sp30eU7M/z7eN4LSlKBy3Tvp60RW9zsEXe72BlrmU7ad9KzgYFkhUtPUrKHTWjEezoQx9txiNI25r8FaaNXm209HCqOBTHQUL+WaNKDIypfevtJsRKG/YGkJwMFDrjWJcBOC11aRwPelY6NSGQjO0qos3mNMoNbEqcWyGCDGiPj7G5tBbXYyBn5cWNAulSYxrys92TOP65jQ2mTX8O83DbKsjPnhyC3Kq9xso1H+zHeIwXMceGC7j/V0T2F7+9U5gvr2rC+vzwCGRlrSEka7nAlpYwffYwHilRcl7PypvG1bgPKYnk2gLG4IeH2kybdUshoYt2w+77Gw+j5MSHv/sRe5y9uHZNyqp/4uXvjuN0z9OmTSYLuVI0hnPwt2Bfo1+1krNv/3RbHG87/1dx/MATZ8dxmFhWXrkS5zMVTv/2/NQwGg0XrSX4eS01ajtI1nQZgJVFO4Z1Po7TpMoqNAr2lfWt7LjNwzk85sHmvVXNo26xEq+RAP9fHkLiPKXk0usTtvk5tdaNq7XpQnX8pKT4MXkhjidkFOfjIN98ctReqzp1rgMlJNZhwn5dM1rAr+NNadzzg1oiXrTHHBLIhVNq7dcS73yidMiPxyDF1NJJvb5ribmIXcenQiX/jjDuuURpmCFVOkNLHwOXnvZ1EZFaJflc7q3H8ZWMeWfx53Hs1HosIlKj1sCpAv4WRbivteX9r/+K/UlR5kbl0huO3ode+yt9nCpjDo6Lle6HiEhTU5M0NZX+LPMibW1tEgTBUU+6enp6jnoidiysWLFizvus+BO1ZcuWyYoVK+J///7v/y4bN26UK6+8Mt4mm82abVpbp9daE0IIIYQQQsh8kclkZOvWrXL33Xeb1++++2657LLLZr3fSy+99Kh9/vCHPzymfc6rmUg+n5evf/3rcsMNN5jHfPfee68sX75cWlpa5Morr5S/+qu/kuXLl5fcTy6Xk1wOv2YlkwMJIYQQQgghZDbccMMN8q53vUsuvPBCufTSS+WLX/yi7Nu3T97//veLiMiNN94oBw8elDvuuCNus2PHDhERGRsbk97eXtmxY4dkMhk588wzRUTkv/7X/yove9nL5NOf/rS8/vWvl3/7t3+Te+65R372s5+V3a95/aL2rW99S4aGhuS9731v/NrVV18tb33rW6Wjo0P27NkjH/vYx+QVr3iFbN++fVonFhGRW265RT7+8Y/PZ1dPIhbho/Z54Sh/qYrtWTtVpZQsRbsfiohkUpCSeEoumfHg4JZ0zpv0IJWJlHOWbt8WWMezoupPzpWWsGmySpK4JIIk0PdxnMP5Z0yb5ZlNcTxYhKNkTaoljrUkUsS6HpYag9Gwx7RZ5Z8exykllfF8tNnn4IS2IZq+/omIiK/cq4aVHCfrWzHCAxEkPafKeXF8YALnEybmUHMKy2/3FLY7vQ5je3bLlGkzkIf06AeHoES4tA3yoEcHrSTp/BZIF1fX4TgrazFXftFnHfq+PQbXxMcHMV+uXoa+7RvHGOQmrSxsX/R4HG/0L4xjPT9blSOeiEhWvR3llIxpXwj52kuXWTfGtjZIBV0B7a9cC0fKw/9snURrmzDHvbfcHsd61KInf2DaLPlLOIF23YRrsPbP/iSOW640TaTjUhQ1fe4FuALe3wMJ3uXLh02bn/dA+vfkEO7LLS2Qwz0RwaGv1rPj8fwo7sXRENe6OYU5sL6uxrR5ZgLjm1dy1HU1mBN7J+081PtbEuKY2vV1VAZMm4ygr/WC9hmH6zYc2vu/VR2nWUk0+/L5OH7NCitVXD52ahw/PK6cN73n4ngiGDVtptS6N1aAFLopBWmrlmjrNUtEpBgph04P4xapNT1KrG2ROu96D8fRa+NEoc+0OZzFubYKHDZ9tTb6XmkJfUOAH8SnlLyxkJBYdjnIWc/xXhrHK2RdHP/M3WvaLBE4o/a4zjhu9HHMJWk4DA95OM8kWgY5kcd7gEu4goqWeZbtALkQn4H0+8Xidth2zhfnFt6n0Lljv85vf/vbpb+/Xz7xiU9IV1eXbNmyRb73ve9JR8eRedvV1XVUTbXzzz8/jrdv3y533nmndHR0SGdnp4iIXHbZZfKNb3xD/vzP/1w+9rGPycaNG+Wuu+6SSy65pOx+zesXtS9/+cty9dVXy6pV0Gy//e1vj+MtW7bIhRdeKB0dHfLd735X3vSmN027nxtvvFFuuOGG+P8jIyOydu3aabclhBBCCCGEkGPhuuuuk+uuu27av331q1896rVyvhC+5S1vkbe85S2z7tO8fVHbu3ev3HPPPfKv//qvM263cuVK6ejokF27dpXcplTdA0IIIYQQQkgVEHmxkceC92ORMG9f1L7yla/I8uXL5XWve92M2/X398v+/ftl5cqVM25HTjROdGejmfpc7rlNv1D4SoIXRZDwtNSearYrKleu2gByqcNTkO0lJTjLAuzD8yCTWZqCfG3S2RzPZQ7SpUlVeLUlhafWQ0UrU9Guix0e+vaQ2xvHmcA6FnZNPRnH6QBCswZ1boVEgeeCYAy0NFTLg4KEy9mAKracVmNdp4pSa3fKs7LWzKgnB3mNdsRcVYtzHspb+coZgqLOXaoobDaEmiCd8G4aK0Kq05LGOVx/ARwH9/UvM22Ko5DKntGM9v9+EBLYi5da9zPtLHhOG2Rd33he9S2hVNmkiqB3hRiDzAiuW5My6Cx69pha8tXn43pcGpwZx4fzVi6pR7Q9hevWrDrXXmvn7j8+CPfO3+pWjoOjkJ898rB1Rn3laZB11fwFCpFmP/FZbPSym0yb4tCOOJ6ceDSO+9/3qTjev2edbiI7B/H//3cA53C6MuW8c4+9R1bXYc34/Q2Qs35zP677RSnIKIeLVu7VHaKNr9afrggSuvoJK41drV0BI8gihwq4IhnPygtzkXKrVfN6XBUtn4rstfLVPvS13uNDZrvUWTfVNg8SOD1FtdPjVOID2aZG3L97xzHYXYIJ25Qo4K2LzOv1JFLOyB0Z3OP7CpgDIiI1ypW31lk56oto2Z+ILXI9UMS6qWWUSUZykF2lavDj9Sp1XxUkb9oMO6xHgwUcZ0MW0qvk+WRSmJc9gjVjv4f1eUnKqpr6CpDkNqSwbo1EOL6WotelrMOnPm8t19ROjy7hvKllntaVc6b3ZT2XS8klK536UEruOH8pFmTxMC9C0iiK5Ctf+Yq85z3vkZTKwxgbG5OPfOQj8uCDD0pnZ6fce++9cs0110hbW5u88Y1vnI+uEEIIIYQQQsgJx7w8Ubvnnntk37598od/+Ifm9SAI5IknnpA77rhDhoaGZOXKlfLyl79c7rrrLmlsbCyxN0IIIYQQQkg145wnzi287LAa+lAp5uWL2rZt26ZNsKutrZUf/OAH07QghBBCCCGEEPIi8+r6SE5m5ktrHST+X64lbyUp99ygLPZUTpdTNs2Bj3yRtGet9utSyKMYLh6M4/o0cnFSvjXZGRFY1a/wT4vjQ0XkPRUimwfWlkKu0hp/Sxz3OuRD6Bw5EZvjtcOH7XUugs112rfnM6Gulf5boHJHdO6biM3j0DkuTu1rPG8trBtqYQedUTlqkw75M/U+8iMezlu73bWCPJkhH8cfKeCp/ytXWJvon/eq65hTttlqm4tb7bW6cgWu1ave8e04/sGdb0D/Azu//+D1343jgX3o56uGkWe05rRO0+bRh2Ef/KWduNabmpA38Ui/zaHQpQQO++jnSB7jubaA/KGUs28lK1Ob43hC5UQ+pnILs561iV+nrkl9SpV5yCH/7XsHrfLiFSuQP1dfh3i4BznPz43acd/1K5RjuEblAF44/LE4DvN2Hn7zvpfF8aFJ3CPLdmMe/Kg7cS8W0e9lGYxPUQ31VGTHvWsSvwL/1Qu4T1cpa/tegbX8K5rtfdk9hfEZyKu5ow6TFXtuaR/H7A5xzGIR57Ou1p7b85PYrkkVNggjXMPk2rQhRE5TWwa2+08WMD+G/ETfPJuj+SLLMtju+VH7y/lP88h5uzyLUh2BuqZ5z+ZxNQvmcoPKNxuQQ+ibHI7jrMrrO9IG7deqciW7lQX9WKKMSHMKuZO6xMlzqtSHczb3M6Vye6dCrGdDgbLnT7xH6rImOvfrQBE5w41pmxtYVPleur3OQ2tPbZJS6Fxjbf2vy78UE+9DDep9TZd/mfRRYqEY2vsl0v0U/f6g36OT+WGlPjPoNpV+GlNq38nso4X4PEOqHX5RI4QQQgghhMwJF3niqsBxsRr6UCkWviodIYQQQgghhBADn6hVCb4HSUPkxmfY8mSkHDvd+aYcS/7Sv+AECRngi9RnIPdISlZGlVSmIYCcT8sBk1bOrT7kRU0R5Dn7tdzSs5KkPg/ynlCw3cborDje7T1h2kwW0YeCD2mLr6SLSYmllqY0qvNpVxb23cEB00bLHUN1DsUQtv2+nzFt9DmkBed6enROHO/0H592+yNABvTbTetxHHXd7z1sj9mQwrU/txmSvvefj+PU1E6ZNmsu3xHHv/rWq+L48st+GceNr7MSrYmX/kEct3/ub+P4wf/z+jjefdiWOmnMYo6851TItx7qhdxqdZ19K1iSwblmh2AzP6GkWIGSzG0OMI9FrOzvrOb1cXzXyA5s5NmyCBMh2gyF6LOWXp6aX2PaHJzAWP/LU5Ak6ju0MWXv17Ei+r1rEH24/99QSqaY+DW2L4f/jxWxvycjzC89B0REVtXhXqgJ0GbHIObbAa/XtLlAyZDHlUwsF7bE8TIP8sbenD3m1lbs+zuHsFa+fCmkZL/ot2vG4QLmZb8PGfGEspnvsVNXxgLI7paFuF/SgvuiPrKlBzrqMFYZ9RPxFdFlcRwlctt35Yfi+G0rcN4vjGG+honlWK8zB6fQ8TYPY+sScrhRH/LLCYe1TZcEySk5n16/RERWKlnnIx7u31bBfE2WK+nJoUzEZAbjqWWVxdB+FqhP457V8sC8wxqs10kRe65aXjiSg5w++YmjXlnn97rOOF6Xwhp6KNpp2kTquPr9IVJrRkq9DyZLy+SVbL6gyqI0qPfI4anke4qeBwX1ur4v7PuqEysnLY9KlhvS7ZOfZ070skZkPuAXNUIIIYQQQsiccM4X5xZerDedoeGJysKPJiGEEEIIIYQQA5+ozTvlPcqm3DGJHreka1N14h3ltgWpTxjh+i6rOy+OU0qa16ukMCIiGSWBGQrhHtaShsymL/ecadNcAxnS8x5kdy0ptEknpI/jSuqzTCBz6/UhyyqEE6ZNIYTzXBhBnpcKIEVLJY7j+1hutBxn0oOcJZhhSfLU70qNGcj7tEOZiHWeDH3IYR53e+P4Zd4r41jL7ERE+j20nyhCGndwEn1eUWOv9bIa3NuXLYd8bMlSOJYt+51O00ZGsb9zrvpFHGfOw+sD/2Ld2Bp+/oU49hog4bloI+bBD58+27RZ3oBrFWSx701NOM/HBq2b4tZWjMk5SzCGPz2MOfnIGObNG9usC97uEcj+zmnB3E/7cFz82tAjpo3nq+sbTV9XM+1Zqd/hKVyHi5fifFprMKf2jtq+dU+hbyMFzLeaAGPTX7TX98cTnXFc8DA2Z7iNcTxUsOv7nknIml4Ino/jOiVdPDtYa9pot7qNEe7Fc1vQ5/3qVmy0Jony9DBeqFPS1McH0ZcRsfKx1y/H+DzU3zFtX57ynjdttNyxUXDP1yqpcm9k14x6dWu/ZjXWll/0wDFx54i9vn6IOXFoEjtYr+b+gQm7ZqwJ4aZYo9ac54uYbw0p6yZ5WnhmHO/yIUOs8+GqqSXnkxG2ERHpV5K+ZbI+jnMepJdLnZXt5gLILZsEUsrDkV7T7W/prR720RdhPdP99H07dwcLeO+YKg7FcW0aa5tzVoKn19RciPvqkA+5Y1L+2aWklJ6HcV9WAwdYLdFcoqSoIiIjgjmhj6/dLWvSbVKKiTzmtT4fL+EkLOZcS30mm8+nMTN9Jlw8T4FI5eAXNUIIIYQQQsicoOtj5aH0kRBCCCGEEEKqDD5Rm3eO16NsugVVlnJ/jcF2XkLqJ6pQaNqHzGS00B3H2uErlXCG1EWdtXPWSBHtdfFrEZG0Qx98JT/RBV3rw3rbRhWmPexeUMfU8pGEc5ZyQ9OSNS13HM93mza6WKuWOA77KJ6dcXYMtNTnUPhUHNcpV7IgUcBXSyT1uKVV8esnBUVxT1FSJRGRQLnd6Tvpn9//b3H87e+/SjTFCMdctxQSHj+NMRz9qZXt+KqYdcNn/yqO8//tg3Hc12XlRbWtkEtlP/HZOF79BCSRv/Pph23flIxvYgzXoKcLErE1dfY3u7v24f9vX4fxfcuGrjh2eyA/3TFg15xQzY9v7IUT4Moa3C8XyPmmTU8EieZBH4V1CwL5WF9ox/AD6yDL+v4ByPGWZSHHG03IGMeV6+MP+9D+fR2Yk/05Ow9bIkjLOtK4Zw8VIOs8FBw0bTpCyAhXhJjHI0pat7nZjtvD/ZgTa2owblNK/b0vj3HaWUjIfpXUrj7CtT6nDv1f6myR7KeH0IfhMGHv+GvSieLVK5WDYVN6+kLDr2y1Y6hdAdsbMQbFw7imGxOK15Zccxz35bDvzU24r+8dtWPY7cPZtOhhO+1kqAsyi4g8ryV9gu0alHNug4e+jHlW+jgcYa3Ta+BwHi626cT6viaAS+n5Ssq9XTlnHvKeNm1GBWvlqXJeHHd7OM5w0c5DX70PhcqJN+tjTtZ5dk4c7YR7BO3mOJCQtrbUnII+5PbFsS5yXeNhPLXUUURkhdsQx7tDOGfq8Uy6dWoCXxVeV9J8P/G+HCak8sefmQprn/if3ZzzxLmFf5pVDX2oFHyiRgghhBBCCCFVBr+oEUIIIYQQQkiVQekjIYQQQgghZE5Q+lh5+EVt0XDia5st+mFvWHKryqJv7OTD5un7kLTk12RT0P1rC3utsw+UdXAxsnkTNakWtPHQZomy5x8L+3QTGXSH4rjNg713k7I77w4OmTbNEXIyamVTHB/0YBNdjGzOgrZJrlX91IQJK2WdK7EihDVzzsO+s87mmx0KkHuxIdiKvkXIKWkOrIV9VuW5FUXlqKncj6YQuRKXt9ljHpxEPz/99n+P46/82+vi+OKVNg/EU/ffWdciv0Iy2Pfj/+si02bTRY/LdEweRj5j8xKbCzPRjzyZOvV6+uz3x/GKr0+7WxERKfzVH2PfnbCWHy/aPI5TG/D/7agwIIcm8XpG3SIva8f8FhH5u0PIE9K31fgk5kSznxFNtw8bcZ2XVq/yZ3KJ3Jlv7cW1V270EqmD/rLf9k3jq+2+uR/9uajVrqeXNmPcD07gXmxQ+S/vaNlk2jw3gn30KOv+okN+13f6B0ybUM3XDjWvawO0f2kL2p/ebNeff9yL/nT6uH/Pcrh3osRbxb488ux8te7p65OLWk2bFzzkF50ZIU+2JYPxvKrjBdMmUnmco1O4R1/XgeveP2HzZ09tR07kf+w6PY4PTqJvzWn7gSwXYh3V+VGT4aCUYlmwftrXC4K5s9bB0v9Xss9sp/OoJkLkkekcZJ2jJyLSq/ZxYArje8g9rdrYnKwWwVgf8mHP3xYpq/vEpzptz6/zhHVOmC5dICLSnsJc3iqXxPGzGeT29hfs9Z0KkT+bSeH9ZryAudKSQT+H1bUREXk+RB+aU8ifHQt74niyYO+XFbUoRZIPMY91bnIU2dJH2q7fudJrw/wx0xeIUn9bbJ/vyLFA6SMhhBBCCCGEVBl8okYIIYQQQgiZE85VSR01Sh8JmQ/0jXW85I4ayAu8hATBCg+mXwCCoM78X8svAiUjasucGsddk4/FcTYhIdSyF23trG3zCwm5ZOjBeniZB0mjtqzOJizwCx7kH6Me5EFhCKlOMWFpXFAyEy199JUUNCn1aUtDTvO8g9X+xuisOJ707HG0THTAgwV2GGE7LaMUEWn2YM2+tg4ylwcmIfl8aQskSS9YBY68bzOkQt+792VxvHcM1/DUcSvRevW7v4U+r4SkqLAcMtVz73mXlEPz//p4HOf/4L+bvzWtxzm4L/1hHBf7cM7ea88wbXr/Wtmi/xHmxBv6fhTH9T95mWmzsgmSyx/txzkcnMD1zalbNPmmeEUtZLd63Pt8SJeiqMW0aVQlLMZVOQg9X3OJ+ZFWmpBfDcMu/OGRopTitW2QDv5rP+Z7v7I+f0vDMtOmuw/Xe3cR53BhHaScz41YmdpgAeN+aSuuz7PDmEctGStdfCgHqe94EavOy9shK/vJYcgw/36vHY/IQ5urUhfEcX9Ol6mwQppTaxum3a42QN8ubWwybfLKtn4oj2M+PYZr8FjXGtPm5Wc9EcfnvasTfd6jzu2ffse0yWYwhn/8+/8Sx7t/cW4cf3+3lZzu6cJ60K2k0y0BZIMT3qhp0xq2xHFHFtf6sQKklz0ObZaKPTe9vykP5+N0iZOEgCmjxMtPepD9BQIZ5VTxsGkzmEJ/sh6u21olDz7s9po2pwSYB4dUWZK9DtdDy+lFRPpD7CPl42PiRFRaPqrRpVD0+2BB3b+nRmebNo+7e+O4XlpwTE8f095joXqPWZ7dHMeHJrbHsfMSwjEjJ51rWaPZtJ9pu1LpFwvxeYhUC5Q+EkIIIYQQQkiVwSdqhBBCCCGEkDnhnC/OLfwzIOcWjwELv6iRBSQpIZyvGyt5nFKSAkh9nJSWTmnXKE06sHI47fSoKSUfySvXLBGRpgzkNVrmUhTIRwLP3sK5EBKcJVnlcuiwr56EC9Zu2RHHdT4kNFq6qKUsR46LMdByx3wE6ZNLyFRGI7h/afnmfn9PHJ8nZ5o23Q5/i9S10m5qu5WER0Rkg4OUcvsEJJZ6DP/vKK7B1bXYXkRkSQPGcDQHydrGRozn6Wut69vUfkjlahvR5+wVfy6lyO2CPePUZ5+P49TNV6Ivm62Maaob8sCx/ZBy1f5/GLf0oHWk7O9Hm5bT4JyXH380jt/wwbtMm33/AbnU7qfXx/HqOtyjZzRDM/roAFzeRER+71RIzrqfXBnHh0O02entMG1aBJK15UrO2qNcSk+LTjVtHh2G9LejBhLJXiXhKzgrG3p6GOvBMteCNjIUxz/ptvfyMkwDWepwrj+agvtoQ9Ssm0iHD1nkLwdwz454uEeivG2zUeD0uLEBYz1SwNx7eBzSyxEffRYROdVBwnZmC+6//9uLNnVFK30uOiVTU68/GmIeF8fXmzaBWlJfvxbrScbHHi7Z9Kxps+rDGINH/uziON76MdyjV33BzvfgsR1x/PQ3Lo/jDV/Feb7mPbtMm5/1YI6nw444bg1w3qtqreT0vgncz/uL6MNy5aZYqySJUWJtGxG4767ycfycci/VrrNJGj3l+hjB9XFD9iVmuyGBFDIQrMEDyuky9K3kPFAf87RUUK/1q8N1ps0+tY8xdV/oNb0utVQ3kaKSo6d8jNV4Hn3WTpEubcfwSv/qOH4wul+mI5V4jx0s4Fp1pOFsuqQW68TAhJ2HTrkMK6Vw4j2/3M8m8ylPjH7zJuSkYOG/9hJCCCGEEEIIMfCJGiGEEEIIIWROuKhKXB+roA+Vgl/UyAJyvDTEMxWv1hKYmaQGejvsT8sgawIrY5oSOOctT0MOczj/TBzXZyBfc660dKJZIKPScpogsDLMtuCUONZnMxihTdGzxyko2cyYksZoeeFkcci0yQaQEWq5Y0ZJJMOEU6SW2gwXIc/TUs4Dzh5njYOEZchXDn2RciXzbLHm3kC5QyrnyimBtPRS79I4vno13P5ERLoGIUPKFbFEHlJFdnfut1Kh/kGc2wUX3Cfl0HMT5Gg9vafF8djrcZ6X/pZdorN/8/8h/u9/FsdeP66Hd99Tps1Z/wWSr84Pwhlt3Ucwjx+5aZtpc3C4JY5X1OI+rQkwq05thdzroT4rffz7Z1CwNqX0RSM+7okmzxYq18tBp4dzeLn/UvRTnpNSNORRwDujnA0nQisF6y9gvr1kKebOz1Qx8SdytpD8b9VD5qWLgU+N4TwPBPtNm0MR5kvoQVZ1Qc3yOH5+0rq2vmU11pkL2nGP/PcdOI5SRJqCzCIiT3pYW/b2YR53O8gDl/odpk23KiKu5XQjgkLDKW+DaVOXwocgPQ+WNOIeu/9ZK2P+7a/9LI7TAcbjwBcwHmv/U5dpo5fus77/B3H8wBVwgEwHNbqFLK/BGB4cx7k9KRjPnrGVpk23w7zKqLWtSxWVXhNhbb2qCeuxiMgX+tQ9r5ajJrVuD4o9N128Oq+cd7U8MelOOVnE2rDCxzV5PMLYaom3iEiPBxmyXitrRRXjTrwX632MRN0yHcn3hGVprNV5p94TVPFrLaHXhbhFRJ5Ub2V6jvaGcKpsSluHX82+AqTc+hpm01aimStgvXei36PK/SygKeUgeWTvx45uo/tD18eTGX5RI4QQQgghhMwJ57yqqGFWDX2oFMxRI4QQQgghhJAqg0/UyCKi1C8opWUDniqsa6WHyX1F08YNGUgxcqGtnLwihcLDoZIX1aYgk9NSlKkQsjARkWYlDdMSp6xA6nNesN60+VUEV62DEfY3FEBm1xpaKcjG4MI43lmA29byAFKWCbHywLQHOZ2WLuqirkFCkjip+pPxIU3JeJDDjIl1vmxxGKsGB6lOVjmrJeVfulB4YwBZ1ZIIzoyFCNv8wy4rWX3VSvztynVwvnt0oCWOa1LWFfSC/+/JOP7pX7w2ji+5GBKtmlPeatqseQtkasNfviSOz3opit+m2qxDp3vk9jguvuWiOM7fDnlQ7buti2VuCWRzk1OQUj3zCczdX3VbSVFfDjokfSeMFnB971WFsA9MWKnQoSLuhREf17QhggzqgL/btNmsCuBu8GxB4RcZd9YxVUv1fiWQPq2IIAs7I2Pn+9MFuI9+ZwD93qJkyIW8vb6/GsD/+xzO7aCP+61ezVURkSFV3HtliHv5oRxcLM/JWAnejkGM9sP9kH+dswSSqB/1Q1Y27Nv7siOEPK9LSYDXeFiLBiQhZVNqq5SnxiM8L45fu9ZKNP/ffsg6R6ewFmjp4xWbnzZtujpxTZsaMQ+370LB6tXPPGbaBH/yZZmOi69BsfbCsJX6XXQYY/rwhHKKVYXT9/nWKbJeSRS17K8+QrwqhfibY7h3RUQ2ZiGl1uuRdknUc1XEyh17CnAP1Y66o2GPaaPXTe34Weu1xHFarBR0qAiJoW4/5WMeDyaKoLdEkM2OqPmi3+O0K7CIlUiuFlzTpQHmfp26Bk97D5r2BQd5/oS6z3NFzJVVgZXTjnt4T9Hvq/oaBgmX5kKINTWMVEFyVZjbzZguodFSxXKf4JRbJFuvqZRBnszwixohhBBCCCFkTlD6WHkofSSEEEIIIYSQKoNf1AghhBBCCCGkyqD0kSwi9O8OM9nr4pG4S+jsy8FTuVdr/S1xvD960mync8l6lH7f93DbjRbweksaOT8iIqGHvk065Iho/f3Pwu2mTbtDXsuYh3wRnSM36dt8k0kPOS+np6+IY51roW2VkxSUPb/ucy60+WbtGeTJaPvm5SHyo+oS+RX9ypJ/jUOO2V5ldd0b7TFt0j7yINZEyJXYL8/Gca1DPtQZtdZa/tylsPFetRbxu2oxbqvveo1p49W9MY4vvgJtampWSymmLn51HJ8ld8dx/nzY0ecDm+en89y8n/wl9hVi7rtUxrQJxpHHtOnlO+L43//5DXH8qwE77h+68Ik4/uB9GMNBD/kdDSrfJElW5eO8JIvcpIkQORkDoc3p2hfARlznqOiUjDOj80ybfm8ojusc5mi9YAx68okcRpWHddAhN8hX+Xd537bxVU2eWuW/vl7NrxHfWqmnlT1/W4CxOqRs4g/nW02bQh596/KxNhyawjwqKKv/M9XxRUSeCVSuoquPY702JcuINAnuq5xgjver9eNv99nfdCc85E49PYj7t2M5+pyUHtU3YO7U1OP+f1UHrOWDP/kHKYfcf3p/HNd983+av3U0Im9pqcob1Nl8q5zN49zpY21wasIV1Vg/GyG3sCmRjzjg4bzrpSWOh+RwHC8Rm494qIgcPp2rrPPa9FomIjJRxFnkI+SLbfAviOMDap0TsXlpet9TDtd3q2/H4ylBWYIaZeOfSqGfw/kDpo0+h7MzmFP35rGW9Kl7r9WzZSJGI+SO6hIFjSqP80DRvse2pZGLqsu/BOqjbaPYe2xE9sVxOmiJ42KE+enUe9oRys0rK4dy2+vtyi0XsPC4qDpqmLkTZ8h+I3yiRgghhBBCCCFVBr+oEUIIIYQQQkiVQekjOcHxVKQkjbOSJ8xkgYu/tdZCbrQvfDyON/oXmhZDHuy5J4uQcjWmYFec8iEXyTlr718QZVesJC9L07Dg1tb2IiJLI8hUckoKNqQs0msjK6dJKSmmlsZoSWRSgjNWhExFn0OtD1lVUvrYW1CyrFQL9q2WoQPBQd3EWP8/JX1xrKWcxShn2qxS1v39PqRHDQKb9rNqIHdsSKyCOwex3YV/C0njsobTpRTh/3xfHNcq+Vak5Im5DeeaNpl1r8N/nnoArz/80zievOrNJY/pDWJO1Nz68Tj+/qUPme2u2X419rfku3F8z62QBC2rsfdL73BLHG9pxvX97iiuT87D/GxR805EpCML2d2zk5AEaknkm5dsNG2eGcY996jgXpiIcO8c8q21fFpJHH0ltRtXst1hZWMuInKKQKrXLbDXH1JW92FCEt3vQ+a1IYJF+IS6R5oiK6GtVed6Vgt+E310CHK6pDqnRt2L7RFKS0yp+W4kzc6WERiPcA4DIeRr+n5LrhlFwT60hb22Uh/ybemQV9Stj+PWDK7V956FhK4/Z2+s81uH4ri5BnPnslfdJ6X49gX/Ecc9k+j377/53+L4pz+6xrS58HxY/J+xHxLlF8awhk8lxk3LyU+LIMl70nsqjlerkg8DibIIeq0el6E41vNoVL0fiCSs9pWMMBPgXtJzTUTkQArzdUxZ92ur/pSzcmm9hk4W1fuAsrN/yO0wbYxEUpWN0eVs1mbON20KHo7zSB4lAc5ykLzv8ZTst/icaa/l9VpOn1Ly72RJAF2uYzQPOfzqDNbaYemVUpyegdT/qcnvxbGXsNov79PEbD5zJCWCpfYxV7nl8YOuj5WHT9QIIYQQQgghpMrgEzVCCCGEEELInHDOF+cW/hlQNfShUvCLGjnBcSo6dnmApySNzsgdA7udZ///Ilra4icetQ+FkHkUQjhK1aYhD5xQXmRafiNipTY7vV+qfkKWkkk47w0pKVaktss6uPpp+ZmIyAsO8k0tXcwI9r3SnWLa7PXQRrttDRUgeUnKJfUYZgQyl2flkTg+M7zItDmkpJDaCTDtYd8NqWWmzdII/ZkIILt7vZIuvnT5UBz/3S7reLiiFstivWpTeOz2OO76pJXGrvwLyF71TPFfDkli+tP/xbQpvBX7iO5T8tO/+PC0x0/ivel/xXHmBx+N49/+4x6zXRi9An3ohXTqL7ZB1vXVn19u2vzLC3AgvbQNY/ifz8M8/qP7IM077NtjrozWx/E5DZAEPjMGV8EnhhLyMx9vrCnlrKjd5KaU66SIyIYIboir6zCvfzbVGccjCenTMx76sCk6J47TIa6BdpMUse6QWu64OdUex0+GVra7OoDE8rkRrE2XpyBnc4ll5eEiHExbHSS4fQHOYU2Ic67z7Ft4s9sax49598fxWAES4PqMdSysVRLpc1Jw2HsghHtgNrHOvGcz+rmkEXK60XFIXg+PWnfJCzZjf9ufgRwu3WrdMjWXnIU5euAAxjN466lxfHH4gGmjHeeubB+K4wdG1XqYWAMHQ6xb25WD4ykR3GHbfJzb7miHad8cQM4+puSneu4OFfebNg0p3D91abuGxf3yrVyy1Pqq37uS0lb9/1HlXDk8BUljY9Y6Dus1XRN4GLcoIdytc7jP+5WzaZ3gfa1Frc1TKeuIO6jOrTbAdrr/U56V0+uUgNYM3i+1s2tSGp9NQfI97kG2mwoaVRv7Id+6QOrznqskMfllIplyQQilj4QQQgghhBBSdfCJGiGEEEIIIWRORM6TqAqMPKqhD5WCX9TINJTrRDTXfVdiv3p/UYnX7XGs3BHyK89ThYIT1RJ9JbWr9yDLKPqQVRz0XzBtwhB/a83C4U67H2q01FFEZLmS2uxxkI9MOSUVSlyqQ0pKGSTkPS9SUG59yX5GSnoROLRvc1bGlA82o2+5X8p0FCNbWFuPga9kkEt9uKwNKMe0JDUe3NDqVBHWpdHS6TY/0k9VKPzwJObBF3bhei5J2XFKexiDvmtvieOGlZCfrf09K9srfFP9B2opyT/1JWzzgetNGy1r3PUMZJ2nfvt/YKN3ftG0iX70sTieOgNyxdpeOGJ2ftu6j654B/6W/hEKxi57B67p2yd+Zdr848PYxz91YqyeHYGrX41yIhwRK338UQGOg5dHL4vjQW9YtbFvP8Nq7jYpiVSvcofLpK2sK+dwrXYod8mXKVfCn0/a4zSGkDhpyeaqCLK/FmddLH0PUr1NSmo7FWGdOCch5Tqcx321uQHy2v4c5mFr1t7ABXUvbsigD60FnPfPoh/G8YoU+iUiZj3wIyVTizA2Q+Eh3UKaPFzTb0/+u0yHLlYvInLrY7iXt63CPXZWG8bzFa/9kWmT3QzZWmonnHODG3CP5P/bB02bmmbI1M6/GPvzeiA5zU0lCrzXwPHz7DWYh2fuh8z1wJSVwy0JIP3rKUDmqjVHz3jPx3FjANmiiMjyEHPnvNRpcbwnhHSxGNhjajdF7d65JrUljkeU062ISFMa8k/tvKvXuaR7sJYxpoN61QbHHFOOiSIi2Rq83zSreW3ljbbgdVowxzdEeH/Y52PcWjyMW+SszG+1kgTvL8C5U9/zy9Knmjb6WmXUe3RT1BLHh4vPmDZ6Lg8oyasurD2aGI+CSnFwzl7HuVHaXbqyEktyIkPpIyGEEEIIIYRUGXyiRgghhBBCCJkbkWcMfRayH4sFPlEjhBBCCCGEkCqDT9TINFRaD13JvLSZ8ue0vru0za0r0cYpzbzvWcv2tlro2nWORy5E3kUhkZOlLZNDlc+jqU21xPGAytEREelVNtGrHLT5fYLjm3w1EWkV5DD0uX1xPJaHPXdT1ubSNKh8i+EibJXrU8hteNp/0rSpUaUE9Hk6lfdQl7Z5HAWVRzEVYdwipf9vTXWYNjUOORX60m9ya+L4UNKyWXCcdrcujg/k8fraLPIZVtu0J6kJkBswOYrjt335RvT5/k/aRm9Gzkx46x/Fcfps5DNlzvojKcUpr34ojr13/kMcj33oJrNd6o+Rv1K36jVxPPzAL+K4vtnOiZof/jX2/ZG/j+OiKhfQ09dWsm+bm/A28XA/rtVBX1m+e9bOu+BjUH8e/iyOsz7mTb1MbwEuIjLoIddpQxolGw47mwd62EcOT6vKSzmnBXlKL4zbc5tU9+IZHubbkCD35KIWOyn2jWM9eDB8Io4v9nE9ni3YMgCeh99BO8exzixJYzwnbKqjrFDW+9ohvE/lHWXUGCZzA0dyuH/1fZVJaetxm2OjS23oHCh9j+bdhGnznMqPqjmM+zzrY6xXPmtLenzrrvPjeHkN8mSjv/vDOA7qbb2Czmex7v3qxy+P4/NW4Dx/2Glze197CnKifB9r/XgRcS6xHrdEyIUrptejbyHWAp0HNhkhv0xEpF2tu/uL+NuUj3HTJSdERKYcxrc1jXmo87O0Tb2ISEHZxOuyJNq2f0twpWnTq+aIU7nXOk4FtvxCqyBfK1LbNUXImxxXdvYidkwKKvdb514f9FHWIVmOxlN1rzIB/qbfO4cSJTD0vaDfK9aqvLy9gT1OUd3nLQHut9EI46TvHRGRQOWLF8Nyc9TK+dyT/Dyj89L0cxTa9p/M8IsaIYQQQgghZE4454mrAsfFauhDpaD0kRBCCCGEEEKqDD5RmxfKk+BZKm1bf7z2XQ6zOWapPif3Vcqev9Q25ZFKyDqaRclMipAUhkpG5Kfs7aTLAGhpWKDs4HMRJE35wEon25Rd+KAPqdGksnVuCKysK3Dog5Y7ahnWZHHItNnsQyrzmJKc9YYoI+B71sJej0HgQ9JTVFKh1tR600ZLWA5PPR3HqQCysr7CHtNGS4JGQ/TtKXWLLYtWmDYpNe5DPmzvVyh7/9MaMY/+aaDTtD9nFP3uzV0cxzfd9r449ldYiVbmij+P40IR5xmce52UxVbIxJ58zVfjeGzyXLPZshtwPktXfSKOszfBTr/pnn81bbzf+XIc5z/xJ3H8xa//Xhyva7ByyQPjmC/DBVzTHd6OOF6i5FHaTl9EpM+DPFeXYtDzvTawJR9CJZfSc2XSg9yrTdaZNluUdCmrXNp/2IV1Nyd53UQmPNxnEyEafWgT5Hi/7LNSsOEi+nZpCvUX7incG8cpz0rbAnXP7MzDyvzN2TfE8dp6u579vIA5viKC3MpXv6m2qXIWE2Jlv9piPK/GWsubJ6JB02aVjzIReqzXCWzmn4u2mzanqL+l1c+9BaXXvOFuWyZidR3+trIWx/nZP/12HA9MWslp3xSuQ6h+Id/dj/PJ+HYM7+nEvfRIP9bDpaoUwkRope1PeVh3QiV7m/QxVzx1DVK+vdb7BCUktMSxPw8ZZkZZ44uIBB76VlSW75v9y+K41+82bYaV9LHWw/3TH8Kmfl96l2mTlOTH/UmhvZa8ioj0uE7VHsccT2F+jYW2dIAuA7AzRMmW+hTKp9SqNThZRmBDhBIJXe7ZadtMOjt300pirUsZjId4X0yWUtDXNyNKAi8oGTEsnVIa/XyDFvpk/uEXNUIIIYQQQsicoPSx8lD6SAghhBBCCCFVBp+ozQuzceiZz8fmc933bKScpShXhlnK8Sj5K0m525XqjdpOyQPr0lZS2BMpaYySO2aVa2M24S6lJSOnKuerZzzIOpySTiRdwbTcUTuOtfqQiOTFylr2FeHgpuWOzZk1Uooxve8AsqreAqSPzSnrFKmd47Troz5m0qFLy4W086SWYmqZjIiVO2aUzGVKyWb2+7ulFFqy+pI2XOsdA9hmlZKYioi01OAceqCGk7/5n3Cn+9OP/YNuIsN//JdxvP2RC+J484bPxnEYWrlk6+chq6zrhcRp1+GtcfzPnVYeeOeNP4njwhDmW+2a12Gj975ON5Ho79Hv73/rrXE8EeI8uyesLKutBvfmQF655Sk53aDfhQaJ203P5SYf0lQ9p2p9K3OrjXDtu3242J0lyjXOWbe9USVJPFDAxaqTjJRCS9j6PUg+/+45yJ1fCJ4zbZoFfTutRsmqIsiqeqaeNW1q03AS1PfFYzlIkvdN2ev7uia4HP58FJN0qXLIyyvpVruzsq5IrScvBJDDrY+w351Kvioi0hThvA84uLu2ebh3lvnWWTHrMJdX1GJ+PD6Ea3rNmnHT5vyVkH/WKtfHv9sOeW/yHWFUme9dvQrX3qkNnxu1suwLl06oGK//czeudUfQYg+kFGwtAgfXYSWn03LcpJyw3d8Yx/0O55nyIa3Lh3Y86tMY36jE++p4ZJ2AtQvkhJIBZlOYa5OhlQemfMg8X5H5rTj+pXs4jn2xa5NmeYC5s3cK7rSZoMlsN6TWBi0D1mtGg48LMlK0Mvdn1afR1XJmHPcq9+KkY6mWPmpn0j3B3jiud/Yey3mYe75ymmx02Fc6kfpQCDF3PE+PlXaNnt7Z+detVFzu57FSqRzVDZ+oVR4+USOEEEIIIYSQKoNf1AghhBBCCCGkyqD0kUxD8pHx8ZI7lvOoOvnbQjnygBmOqSRJKeVCl0nIsoZykF/oos5taUiCBov7TRvtlJhVx8kLJBqTBcibdDFgEZHRAuRwSzNwMtMSnGQh2holRykoVzEth3lt9tWmTVceUpAhJeVYkUKR73GXlNNA2qKlZGEEhz3tAiZiC42ucpAKDaYh8RxLSH3We3DY21WE7EYXCk8WW94UKQdF76k4vrcHMjFd9HiJbx3+MmqKNaUxd0aLGJu/u+UPdRP5rTNRBHnLJkjOensgb/qPXaebNkuuwLifu/zSOH71K+6L46HvbzNtuh/FPlacv1Omo/jo39oXLkah4dXfwHXcP475Nl600ictLcv4GJClDtLYKYGkKZ1wPFwTQp6bMS6ckMMeimz/9XzZGOE8dSHqw/4+02a/mv+rPbi29XuYR6sSrqCaDQEkY3vDoTjWUmMR60j52CjO+4bVcD/8+y4rsTpQhIywPbM5jmtD5WSYWFsfGYHEqkE50uV0UXlPFWQXKwXTLqdpD5K3MeXm2OgvM20mlIwv7WHdu7QJ59MzaWVuE8rddY8yDN2o3FR/2WfltK1ZSEYDD9s9NALnyhtPt/Kxe7shlSsomdpjA5i7Azm7vo8VsO4uzWI90nLHNXX2feTSOkjtdgxivt6dx3xb4sEZ8VTB2igiclgVld7gzorjfSlIaAOxEs3NEfbxy/CeOD6Qwtg2evZa9eSxP/3+klPy8SDhSKmLRx9URan1/AgTBcCXe+vRnxDzWDsZFxPyTy3zDNV7ZI16Lx1ycINNJ9ddD/+fEEyqzSGksYfSXabNwTyKg2spqS5+PaHkzSK2qPwueTSODzuM7fLMJtNm/8Qv1f+md330EvJRZ+5tPUdn+jxUzmegpEy1uophR86XyC38M6Bq6EOlWDxnQgghhBBCCCGLBH5RI4QQQgghhJAqg9JHQgghhBBCyJxwzhMXLbzj4mJyfeQXNTINlS4VUO7+Sj3g1TdcMiet1L5LH9NT2n5RWnrnsO+MZ3PUImW9m00jl0bnshSdzRdpCJAT9biHfBzfTW+FnGyvLYF7c9DP16j8rDWezZUY9pGbo8sDaGvo5/NDpo2vxl1bPmtb5SXBWtOm6Nm+vkgqkXeg0fvr8mHNfKGcF8e/8mzeQ5+HnIQaQZ6MzksLnM39SHuYL4G61mMqn0fn8kw4e63XCa5bTYB5dPEyWHU/M2jz4iankO/R8WfIA8ncgbzFqZ2bTZurz0V+xOO7kev0k/uuiOOzl9ucjIefxfU+awx5GBui6+I4fePtps2+tyJnLfAxx/XdNpi3bwU59Ub7fBF5lJFqf0qIPvf6Nrdwn7LH1iUWThPkyz0Z3mfa5ELkKnVmcN2WRMg9mYhsrqS+vi0OuTh6Tnf7PaZNg7KjX6ISEp+bQs5gi1jbe31fjavcvAd7kWvZEtkctUFVaiLtkDeU97CWtIqdew9GKL+w0b8wjk9R97zM4AJedLhHzkghf3YgwjrXp/KERET2O+TC6jzBJ4YxHiOJMiBFD3kxZwQ4z73jmDfdubxp8z92Ym1oT+N+afLQt64JW1Zh9yj+NphX5RMmsbZds8K26c9hLn/f3D7o8wGb2itDav735zHAejzO8tbF8dJa+17VESJ3cyiP4wyp8iAbnC1xMqnyHnU+8OEi1vqGRLmSxjTyLUcKuI46X02XghARidR73GEPOXdtDjl3ndEO0yanrunSFHJ+D0fPxHEyRy1XxPqaSeFarRbkez1X/Hkc1yRKJJyl8pZ3yNNx/KQgN/mMaKtpIxnkr/WGKP3hAqxTydzA7gB5sn6E9+JciP7rnNQjO1T787HuhqEtF1Ka2djzz2fJJnIiQekjIYQQQgghhFQZfKJGCCGEEEIImRMseF15+EXthGY2j9Nn02a+mF4CeAQtcSzX0r/UdokbVklBRFnYt9ZAetE9+YRuYeQkzSlIWIaLkFFoiYmISKSkNmMhZHOhkjgGPmQ74wXY1CfR22nGfCu90DKxQgDpUj6C9HEgsDK1nIOUS8svtXSyGFipo7aqHpch9Cc6jDi0krOCksrkQxzzfiVD7PDPMW3SEWQruxzGekxt0+xZ+/VHlOVyk8N4BEpAkBY17p7em8hgHm3umeiM40cHIG/a0GDn7leegCX3X7UpOd7nfz+Ob7ztfaZNcP0/xPHjF/07jq9klFe/7ae2zQ8uj+PvPAtL8Xe1QZ7Y/BcfMm1WXYLreODfXhXHW9pwfX729BrTxlP26f0+rmmtsr3uDF6I45GilWhqKdakkk4+4UHatyJzlmkzFOL6DhQ60Zc0rtsyt0E3kUitE0NqVvR6B+JYS7xERApKetifwz3aoeSOuchaXi8VSODq1JpxWMml+hPyT10SI5uCLLNJSSS7PCvlPN27JI4bHeZBi5JoToQY27V19i384XHcYz8PIR/T2pkRVfZDxJba0CU0xgXSxeV+o2nzmMCyfawIyep/aYdE+qc99h6JQsypngKOc91GHKc/V2PabG7CPjJKhrx/Eic0VLDH+b+DkN3WJqSlL9JWtDLV51RZEL026PX9OVW+5ZzCStN+eS3eY3Ih+hOESlLp7Dqj5deRKrmgbd37whdMm7O9y+L4YAZzcjCExFqXfBERmVLyPD+l+uNhHuj3NBGRlMN2gYqb0riXBnLPiwXn0JLCPBjwsH7oUi5TqhyGiEhOjUGHg9zy4fy34/i5rJUxnhFBSj0eYDyXRii70ev3mTYtDn+r9bCe9QTTv18f6Tj6rde2UK0FzllNsrbrt1b9sylXpLcrpyQRWUzwixohhBBCCCFkTvCJWuVhjhohhBBCCCGEVBkn8RM1LZeorsruM7PQvxKUOv6xyyg9z0pWrHRA/4Yw0/Up57ilf4/QDpBjRUjBImcdy7IBZCZaDpP261RsHQ+blJSqK3wqjrVz17iD5CbpoqXJFyFfaa6BTKWQcIrU0pKVSiaWzkBSpOVNIiKDBUiFGtLt6GcK/Sy4KdOm1WG7Uz3I5p7LwHVuTBJSMCWB086VWkoSJJakcR+SzVUCqd/hCLKbqYR0UUtOc8pF0ldzd8zDeG6KIHkVEakJsN2qPCROWpozkpBbHZrE3PVPeaNMR/5Nv2OP89Vr4/i1D385jn9w0Xfi+NH/uNK0OeVUSKE2D2NO/suDkESds8tKTn0lY3y0B9e0NgWp7sVtVrb7tS6Mj5YHTXhwIk3KHTXNAY4zUYCMSF/3mdqEAfqjpblDSuIlInJN7avj+NmpoTjO+pAaDnpWUqzvkZ1qXi9XsuENtfZePm8Jru/2AczRh/JqLRArT9aur07JlbT0OOOmlzSLiIyoOXqqchxsSWPuRYnlr0M56TUVsTY1BrjHUhnrFPtE1IljCuZOg0ASmVxBJyP0reBjDP/hMM4n6YK5Jo1r8lwR1+SOPZCiveeUcdOmX7kx7hnFedf4SsKXs+9JI4J9+x7WqTEl0fYSZzSqJKhtDvd8WwAJXkFJQbvyCYdedR21TDWcxDxeGTSZNkPKYXfM4R5pTa+PY/1eI2KlvpMO10DP9/qsdYrUDBTgtrs5BXfZnNj1vcd1xrGW/acF7yN16WW6iXFgHQ0hq9RjvSTdMe02IiJ7PbhYTql1Px1Adqvl+CIie1PoZ6u6bln1PnLUfelwb/coibR2dk75VoLrK4ljZFIXsK8wTDhFavdNpz/DlPvZprztPA99dYn3abI4OIm/qBFCCCGEEEIqQeQ8iapAdlgNfagUlD4SQgghhBBCSJVxEj9RWwzOObNxbSz3sbvmeDlFzqZvv5mkxFIXr/Q9yCLyxdFpX09SUMWjl6YhjRkqWllWt5I1tmVOnXY77QaVLBatj5OUYr7IKdFp5v9PyC/iWBeprlFufXWqMLCIyFgA2c1EUcmylJwmSjha9SkpVX0E6cUmHxKtXyWkjxkl/ZkqDsXxWRk4EZ6uiomLiDxehJSjNsL4NARt2K+z47bUQULXGe6I4yCFPmsp2gHPSgVzk5AOher6vKDcy7on7Riu8Vri2Pubj8Tx1PU3x/Hh6+38+MXud8Txqi/+axw31uCY33nBuhxe24ZrtWUDZJBdT50dx/ccsA5uV3egyO3SLGQ7z45gTtzfZ+dXq+D8DnmQG9U7yNkOFyHnTcqgxpSLXlsWc1Q7MDaF9abNhJJfjflKYhlCYqnd5EREHsor2a6H+aVlYdp9UUSkVsmYc9o/VC0/7UV7HO1geFC5HK4RzLV9vi0k3arm4QFVKHiLwNlxb7DHtOlzuFbb0i+N4xfGcX3GlPTqDCULO9I3jNvlLbhWV67A9fgfz1onRN9XjnYqJaAtgzXwUN7KsjNK8q2lbSOC+XlpnXUSHcrjntMSvroA7ZfXWRnzT7pxDrtVkWvt4No7ZX9vrlXz4GABzpc1av0Z9K0cdsph3FpU4eVJNfdXRlhzOmqtNG5COVruGMd8WyuQ4zVmbT/X5XAv7BCsDXU+Xl/uXWTadPq7ZTp08evWtF0z8qLu3xTu0z4f91Xk7PttqNb7KEJcUFLyZb49TlEVLj+QeySOtXRyibp/9XuAiEider/pUcWrdfujJIlqHmSVS2q/h3u0KbL3yKl1eL94fgrzsF69p2hpr4hIbRp/G89PL+sUL/ncwy8Rz/TZc6GduEk1chJ/USOEEEIIIYRUAro+Vh5KHwkhhBBCCCGkyuAXNUIIIYQQQgipMk5i6eNstMDVYOk/Vw1zObl5x+eRse/Z3KLQDZfYcibKyJ9ziXNWWnJtDW/seQPbN53TlA6QW5PMS9PonDdJq1Dld0zlkVuQSdg3Bz7sscMi8tXGQ+SB9AStpk2+gByPnK9itc2oZ3PH6jzk7BRUiYCpcCiOtW2/iLX413kCPRHOeSyyuV865y2nrPr3y7NxvLRwoWlTq/LPih7uuVNC5JH0e0O6iRz2kLeUV3l+gx6uVUuAPJCcZy2NB5Ut+oiPfJOWCLlr9c7mSizJYil98ofILTrvzzBun33Q5pu847TOOP5eJ2yrD05gTu+btDbgTY9eEMdvOvuxOH7JOuQ6pQ50mDbP9iMv5bN7cX1WK6vtlZmsafN8HjkeSyPMsQMBxvCULEoC7Cs8atpPRri+WZWjttc9IaXQ5S1qPOSVWIt0Ox46lyVS250enRXHj8pPTZsWwTXR137IIQdxb8Fay++WHXFc5+N+0fk/7W69afOfVmO7z3YhNyevbLzrnM2fGYmQN3Qgh77tD5C7Nq5s3Tun1MIiIkUP4/PWWsy3r+5GXzbU2t9n+3PIRVsTIZf2sLKgf8F/zrTRY6hLavxuG17fY9PNpEutYefVIH/PqXX79mdWmTahWrtbA8zRnhDjvq9o8+fyPv7fnML+9BruEu+DDZ7KTxKVk6Us+Q/7mNP9U/aj00rB+PYEWNOLkSoPkLN5z4Nqf/r4NRHeHzq9p0ybtOh7BOvphLp3krb3Oq8zrUouDISl37u03b++1rosyrgqdyAiMlxAKQGdU71azcODk9vjOJOy99ghD/eyfh+qV/mvxcje/3mH7XTeo76vz87a/Nn9k+hb4OP+WR0iv/oZ90vTRn9OqM9g7o7l9uqtTBvPfF7EPV/+Jzg9R2f4nOMSZQEWGEofKw+fqBFCCCGEEEJIlXHMX9R++tOfyjXXXCOrVq0Sz/PkW9/6lvm7c05uvvlmWbVqldTW1spVV10lTz1lfxXK5XLywQ9+UNra2qS+vl5+53d+Rw4cOCCEEEIIIYQQQmYhfRwfH5dzzz1X/uAP/kDe/OY3H/X3z3zmM3LrrbfKV7/6Vdm0aZN88pOflFe/+tWyc+dOaWw8IvO4/vrr5Tvf+Y584xvfkKVLl8qHP/xh+e3f/m3Zvn27BEFw1D6rh4WSO86Vcuz1Z3pMPD+2+VE0/ps3mjU4H5foc0bZ8Po+boEl6fVx3D+1y7SpU/a8WgaRUvLE0XyXaaNthbVEMpuQOL5I2k9KQSHzSCkb7qJ6vcOtNG3G0kPos+A4WqaStCvXMpO6FOR9Wh6UC0dMmyuCV8TxhJJ1PKkkYlb6YaWUek6N5PEjTXfmFNEsV5KiCSWnGVG22Um0PfeAkspMFiA1agogX1kTWjv7rFoWcw4SmryH4+/1rLwoO7Upjm/ZDqnfNVt+HMcbG6306fanIFHctlKVYhBIa5+atLLMkQLO7c7HzovjlbU4z8aULaXwN8/jOjYp2/2VtZjH2cSy21ZEHx4XWJwvjTBuo76SRyauW/ckJI59OdxLLVnIiwamnjdttKS4Ja2s7QuQeK7InGXaaKv90MN5B+r+Py1hcd6rrt1EhHuh0V8ex4f8vaZNFBambaOpE2t7/w8HIaFtFG0Nj3mYLJXxl6uvjON/OgTtYHdO2cynWuJ4Mhoy7ZelIV38jy6se4eVHf1Y3krMs0pO56s1a9zDnMw5q2OMlAxZS/D2jlvpoqZbSQIPFzDh9P3X79uxXeWw7m6sx/0zMY5196HoQdMmq8ZalxtY4WAnryWNIiLnpLCOdoY412URZHNjajzqEiVBejxIileGkBo+Vrgbr9dsMW36CpAra4nmBiVnH4vseI4I5OSBw/2rre71/BAR2RDivA/7kM37qmyNl/jNXr9H1CqJopb9hmLXGS31b689J46tzBTHaVXvtyIiY0rSb1INlEQ75+z7UFbNvQFVPmV5iHHrzVlpYEHJaXVpl151jyzxbHmOrqknZTp0+kbkrATX8zBHndOSzXI/T+nPatWQdlMeLHhdeY75i9rVV18tV1999bR/c87JbbfdJjfddJO86U1vEhGRr33ta9Le3i533nmn/Of//J9leHhYvvzlL8v//t//W171qiP1k77+9a/L2rVr5Z577pHXvOY1czgdQgghhBBCCDnxqWiO2p49e6S7u1u2bdsWv5bNZuXKK6+UBx54QEREtm/fLoVCwWyzatUq2bJlS7xNklwuJyMjI+YfIYQQQgghpDpwDoYiC/tvoUeiclTU9bG7+4ikpL3dOsS1t7fL3r17420ymYwsWbLkqG1ebJ/klltukY9//OOV7OpJxmzkjvNFaUni7Dj2uzEVQEqh5XlawpNJWTc2LTdcnlofx0MhnK4KRSspyqTtHH8RLcepTUHmkpQXRpFyilJyjZoAUpTnPevc1RFBgqYd+iZD9C1MuERlApy3lrZo+UnoWYlWv5JLbqnHWD0+ATlOPiGX0vIa7arZmoY0J3B2SRpTLn8FD/2eVNLHfrH5ra1OOb2pc/XVMfX1bPSs4+GAw75bIozHiK/GMCH7edqH1G9NAfKz7xxoieOOejFMhZi7BycwJ1fXQpb1qbOtxPPHhyDrqg1wfX7SjXMLE7KsBjWG+wKMVWESsq46sWPQlobMbFMBss4uJZ16XT3O838P32Paa6nwRAFtQuWsurTmNNOmUSC7PVjAeGo5bt7Z8VjuIFF6vvhwHK/wMQf0dROx83q8CLlTYwbSx6TUT98j5nUld5xyVqaqXejqHLZbLi1x/LT3tG4iPz6M+TakZIDakTavpHltGVwDEZGVISSjG+sxp56exDqVXDJb3FKZDi0PXCn2OGPKGXWgCJnog5NYC+ojO+FXCSSO+p4bUM6ZtZGduzsDyGaDcczD5324YKYTktNaD+vjiHJA3CuYU8u8DabNwTyu3ZWtuNb/PAxHWj33Ghz6IiLS50P2rqWx67OQ3U7IqGmjr6mWqfcUcZzxhBS0STBHe5XjaUrJ5usCez373VAca9fGjHIfTiXu/wZ1z7Uo19cxD+tzb7THtNEpAZoph/PW76ta6igi0hJgfoyplILJSL932XV3tZI47vafieNxHzLVQqJNoM4hq2SV/aJdK+1nk9o0xqAQTajtlKQxcV+Zv82KUp/P7Otuzk7gpNqZF9dHz0tMJOeOei3JTNvceOONMjw8HP/bv7+0rSwhhBBCCCGEnOhU9InaihVHfs3r7u6WlSuRnNvT0xM/ZVuxYoXk83kZHBw0T9V6enrksssuk+nIZrOSzWan/RshhBBCCCFkYWEdtcpT0S9qGzZskBUrVsjdd98t559/voiI5PN5ue++++TTn/60iIhs3bpV0um03H333fK2t71NRES6urrkySeflM985jOV7A75jZRyH0pO8FISxXLcJJPo7Sp9I5Xqj7W0yyuJYn0GPygUlFRBu6eJWIeuSVWYOx8lqrrqHii5opb9aUctLRcJI+tEpqUxuvh1uwd5o5YgiYg85X4Rx6dEKI485Eo/hXZK5hGoytwZp1zWPCvbOaQkdBMTqhC0j7jgW5laoOROWnZzhtscx495vzJtWjxIubb4cAyciiAV6o6sQ+f+EC6BKeUk6CvJiy4a7gd2Hkbquuki20XlblkvVtY6JigiflYt/tY9VVBxokiuKjz81DD6MKCmwRND1tXz4CT60xBgf9pXbbhgpa1LUriODdH6ON7hQ3Z3vmfdFIeL2EexxL29ZwzbLA/s/VKrpH79NZCfaYlXWqwLZijTF24tRpCl/dla6+D4g0O4tw8qSfB+TznqSZtpM6Gc43Qhdy1t0w6Qyb8td2vi+LAHCd7e6HHT5izvJXG8oQbz8P4C5HRDeXtfPq4Kj+ui8nWq6K9eFxqcLRq8JoPjjBVw3U5TBcC7fJtiMOJP72LZEXZM+7qIyLhg3TMuuE7PSVtU+sx69LVrEtc6cLgPGpISPFXY/pRGHGf7GNwPc6Fdgxt9jJVe27S7ba1n5ZK6yP0BJUPeVnNGHH9j9PtxvCuwDn8Tedz/S9IYN+0U2+gSUnjllJpWa22vkhevjex9pWW8GVWUWse62LuIyN4A0tT10dlxrNe5Cc+OoV7rUg732IgHqXAqIRlfkl0fx1o63ORjDY8C7DfpNKnl5DoNQL9vJI+p5f1TOnXAx32ddlaSmZbp5+gSD2ttsiB6l8M9q9MldNHuqbx9/9ZOj1aeaPdtKfWZSH2WSIyBm7PEklQ7x/xFbWxsTHbvhjZ6z549smPHDmltbZV169bJ9ddfL5/61KfktNNOk9NOO00+9alPSV1dnbzzne8UEZHm5ma59tpr5cMf/rAsXbpUWltb5SMf+YicffbZsQskIYQQQgghhJzMHHOO2iOPPCLnn39+/MTshhtukPPPP1/+4i/+QkRE/vRP/1Suv/56ue666+TCCy+UgwcPyg9/+MO4hpqIyGc/+1l5wxveIG9729vkpS99qdTV1cl3vvOdKq+hRgghhBBCCJkO9+s6agv9b7bSx9tvv102bNggNTU1snXrVrn//vtn3P6+++6TrVu3Sk1NjZxyyinyhS984ahtbrvtNjn99NOltrZW1q5dKx/60Idkampqmr1NzzE/UbvqqqvEzeB76Xme3HzzzXLzzTeX3Kampkb+9m//Vv72b//2WA9PCCGEEEIIIRXjrrvukuuvv15uv/12eelLXyp///d/L1dffbU8/fTTsm7duqO237Nnj/zWb/2W/NEf/ZF8/etfl5///Ody3XXXybJly+TNb36ziIj80z/9k3z0ox+Vf/zHf5TLLrtMnnvuOXnve98rIkceWpVDRXPUyIlGqdyz5IPW6bfzlc4/cuPTbjMzM+W1zSb/bfqcO88r/aQ2q7T94xHyDJb51r65IYW8h5zKS9PW4ZN5m/vheb6K0YdiBE25thsOI5v3oPOrlmeRx3U4eiGOt0QXmja/DKGlD33kA+gchmJC027y51T+3dYAOW57C7Z0wAuesrp2yEGodejzZNBk2ui8g0jlomir7Ra1LxGRAYdcuOdDzLcahzySIGELXa/yefQx9RhoW/afy49N+/YA1ts616o9Qt5Sjdhj1gXIS/l5Dtenw8FyOkpM465JlSMSIt4rKv9mzFptF1Suwv4I95zO71rmWkybblWa4YJa5Gu1TcLaui+y+YS9PsZnmcN4DgpsyJ9V9u3jYvOc1jrke5yVQfvdOVyPnGfn4ZCH8z4nuCqOUyon5OsHbJsWr1bFOJ/WCOO2S2zeY1pZmW+IzoxjX605/X6/aSNqrevzMAatEebrOm+jadIVYD14Zkpbf+Oe130REcmq0goNgvyXgo9fX9MqPzKZO7qzgFynPu8Q2gS435aGNv+uP8C4nxph3Xs+wH3ZGtp5OOaQR6VLeujyGmtTNn/uZe3o6w8PQWEzOIVxP5DIn5vyMMfTYyjnoPORalMtpk3eYR3t8M9Be7VO5MTOo6Iq/bF3Cu0n1XZZVaJhJGdLgugcYp1rpfN8U4nSIzWi8mdVnl7aQ5vk3D0zQo6mzptqCHBNx5x9H1kb4gPmsz7yd5cJXl8R2ZJKoXr/PBRg7k4WcZ8nywDosgj6PVLPFZ0nXO/ZnL2uqSfjOPBVXm0a5zZcPGjaDKvyC0GpXEnPLry+etIy5mEehR6uWzI/86BDPq++f3Uum+8ncm5DzB3PlCXSzPTUp0Q+v0vm8pbyGiDHyq233irXXnutvO997xORI0/CfvCDH8jnP/95ueWWW47a/gtf+IKsW7dObrvtNhEROeOMM+SRRx6Rv/mbv4m/qD344IPy0pe+NE7/Wr9+vbzjHe+Qhx56qOx+zYs9PyGEEEIIIeTkYeELXeOfiMjIyIj5l8tNb76Sz+dl+/btsm3bNvP6tm3b5IEHHpi2zYMPPnjU9q95zWvkkUcekULhyBf6yy+/XLZv3x5/MXvhhRfke9/7nrzuda8re0z5RY0QQgghhBCyqFi7dq00NzfH/6Z7MiYi0tfXJ2EYxqXEXqS9vV26u7unbdPd3T3t9sViUfr6jjxJ/t3f/V35b//tv8nll18u6XRaNm7cKC9/+cvlox/9aNnnQOkjmYby7GMjNzHDdrNBywDKfZyv20QlXrf4yt5WywBrfEj1esLdpk19AMlYrQ+Jx0gRN7CXkOBpW2Ejl1C2yIUQciAtlRQRSSlZlK/Go8ZDPw953SXbTHq4PpsiSIAKifHc4z2FNqp0wD3RvXF8sXe5aaNLBAwomZi2Za7xGk0bX5kFjRfRpj1YH8f7EhbnqwJI03IC+Zc+t5XOWlj3CiybtbS0QZUOmPRwnrmilY/1CK79ktTaOO5zkJI1JSzfxwXywrXR9Lbme3LWAntdBlKqfiU9XONBKpi8Vpe2QvJ59yAkTmNqPJ6QF0yb12QvjePHJ3DeTUp69YJvSxyk1dzVMsgGwRjqOZlJ2J2Pqmvl53EvdvrPxHGQkI/qfaRkernyoD9g/r9PlUXQ93Kr6mdSXqjvvxc8yK1WCOa0lryKiDz3/7P351F2ndWdN77PcIeaS1WloTRLHmXLo4yNIQ42IaZNAhnoQGg6pNPEvdzwdgKG1YmT0AzrTXh/nXSaTEAngdDp0AndyfoRaMyLDdhgsMG2PGBLtuZ5rLnqVt3pDO8fQuf73Y/uLZeqStKVvD9eXutR3fOc85xnOnf47u+ufT8rLy1cKY2oO+kFWM4Wpyyhw/qdibTEclrG0QZKZZCw3GkWtVSF5sFIbU9W3pi/LSufDI6qOitipBuo0D1w+39mQMsY/3aM5Y4YxxH/RFbeW9eyver+O7Py8RTjOBZgfpVTLbHOC8ZhMsWcSmd5JrCF+yrpy8rDJM+/uagl1i9U0B62xx8X3E8U4/phoOfU8jyk6SxfZft3145+SYK2HSd54STJ+Vw7+irtZ5wWoUN6s3LJ1/tZIcFxUzXIdjeHN2blEU/3eyfN/9EI9v58D32iU4eMpLgHlpxXSNad97Hn1D0t0cyR1L87xPiUE+yt9ViHWHDoQU6wN054WFf5VI9VJ8myy4J2ro6x/l/2X1B1Ch7LXiEJZnv+XKCfdxH1gbeIqYjcuc/vOzgdhXGKQ4cOSXc39tJXysnseXqs0jQ942+vdDz//dFHH5Xf//3fl09/+tNy2223ye7du+U3f/M3ZXBwUD7ykY/M6R7sg5phGIZhGIZhGAui1RJed3d3qw9qzRgYGJAgCM749ezkyZNn/Gp2mhUrVjQ8PgxD6e8/9SXCRz7yEfmVX/mVLO7tuuuuk+npafl3/+7fye/+7u+K77+ysNGkj4ZhGIZhGIZhvCrJ5/OyZcsWefjhh9XfH374YXnd617XsM7tt99+xvEPPfSQ3HLLLZLLnfqlc2Zm5owPY0EQSJqmszroM/aL2iWJ+23GXF0T53L8uXMY8kjuNJu0RdPEGYna6coBWIbIkoaErjlTH1Z12FWri+Q0IzHkRSHJOkS0TMP3sdTY+WqurIzhHngogBSlKlo+8vrgp7LyGLlI7vIh8Vqerld1WHI2GcHNjMfjQOGYqnM83pmVcz7qrxTIEE/IAVVneQpJYMGHfGx3+lxWdp3E2NWuM4XMpOxBDsPOkCIiXSQdTEKMKbuKFULIVMJQSyHq1G/TKaSCfQJXwWPkriki0h1CTpPQnDxKssE6uSSKiAyR8+Qv98Nt75kxtPn2Ae0kNlJt/E0lyxB7PC3rerQGGQ+7/w2RLKsn1VLOA/Vns3JbAJkby0eX05xMnD2D/10i2d9qwbiPUd+IaNnbFEn42NGSnTdFRI4mkO325yBd2pvgnkvVE6rO5twbs/K4j/GN6Drdif4Gll3oJiOshbf1XJuVvzK9TdXpIye9OMTc53nYlutTdWYStGc9raUO2qeOkbTVS/UbgBrtB7zP9CcYw3KgJesnSArJrnrXJXhz8viIlnWuSLEWYmEpKfr9Wu+1qk4HSZ9nYsiA2bkvdhxpQ5qvLFNlB1ffkcmujiFXPuDD0dInaflIVe/VBZJvljzcD8tzY5KfxoluJzsrjtHeNOyhP3tT7XLIjqX8nXyN+mZJfo0whRjtWeth7pUFYxo4b+vYfTRIMI9Z7nhru15X3ytjT40jPC9Xh9dl5XFypxURCcnJl90Qi0Ev2hlp6TLD87VGYRU8J5JE76E89gM0J3fXf5iV1+e2qDrsaFknifZBkn9flmxSdV6SrQ3bzHJYF+U2nc4WTjIXzvY93IXjdB6zC8182nD//ffLr/zKr8gtt9wit99+u/zlX/6lHDx4UO677z4REXnggQfkyJEj8rd/+7ciInLffffJn//5n8v9998v9957rzzxxBPyuc99Tv7+7/8+O+db3/pW+eM//mO56aabMunjRz7yEXnb294259zR9kHNMAzDMAzDMIxXLe985ztlZGREPvGJT8ixY8dk8+bN8uCDD8q6dae+aDt27JgcPIgYxQ0bNsiDDz4oH/zgB+Uv/uIvZOXKlfKnf/qnmTW/iMjv/d7vied58nu/93ty5MgRWbp0qbz1rW+V3//9359zu+yDmmEYhmEYhmEYr2re9773yfve976Gr33hC184429veMMb5Jlnnjnz4B8ThqF89KMflY9+9KPzbpN9UDsr5pOE+WJktp+MF1PuONvPvnPt38ZtnS3JtUpETZKxiOQWqZNUcrS+LytvCuHwtZ/O1ZnTAacT1f1ZOY4gSeoprs/K1TqkTl0FLXPJk6TwKEloLo+RWHdPsE/VGaNkpyHdW6kO+Vd/brWq00dJpsf9Q9KI9rRT/ZtdMLn+CkrGy3IcEZEjArnka33IotYFP5mVdzkueAdJ2hb7kOCwNMZ1RitS0u2eFFK9WghJUY2SRQ/ktWtkndzlpsjVs0yOfH057ezIjoNHA8iGOIE4J4QV0fKgr45CBvjaDsiQ1nZol7MiScEmS2jPaIJx43kjItItkIIujTFuOz04bE6lWsbEMsLxCOeeYBdNup8VoiV8CWnvh0kKxm6dpUSPNScx7vAhPWLZUdnXayTHroAkoWO588riDapOlWRrBXKKOxIjqe0Jx8G1L7cebSMJ7vZJmiuOFKwkkE8H5LzHMspKNK7qrMnflJV3kCT4ihT3UPQh22UZpoiW7bK75CFKXn1VslHV2e5jXa6gZO9dgnYecO6N+63bccg8TZ/jjFiOMSYHSVrL7riuQyfDibVZIsrzW0RkWYj2LKP5UYqxpx9KtQQvRxLHGXICXJpir5whmayIlsayayqv6zUJ9pYjvt6rj9L+zPsM98FqkheLiAzm0e8Ha1hjUz7aPOM4Z45UIc/vzUOieQXt4WM1Lc3jROM9IdrAUnROai2i9+Eeesbw3siOq2GAexHRUnveCzgMwn0u18gt98oc5sHOOo6b8sZUnW7B+un00Acn6zuy8jJahyIiz1bHszK7O/JYp668kf6dNn0/4/6d37fM7b1Wqzk9tpqZyKWAmYkYhmEYhmEYhmG0GPZBzTAMwzAMwzAMo8Uw6aNhGIZhGIZhGAviYnZ9bFXsg9pZcS7j0hYz/m2x23mu7tu1rGV99nz6g49r/mNxB8WScexZqjTlum1JAs37dg+xLMWwNyuzzb2LR9bD03XEIxVyiLso+DoOrJJAp5/40KHvDtAWjpcR0RbDHRQv5sXoj76kl6tIieKGunLa2v00x0THVxTJLryQIDZhXNmD6zHo8xC3sN3bn5X/RRFxHDtLut+5TyoUe8FpFWKpqzpsg1/1EUPkkwU3W0bHqa7PltxdIfpjjGIOJyhmUESkL1yflfMpYnvaBPFyE6m2o+fxKaTow+0ljMdIVcfsnKwj3qPTozgZit3qTHX8TJhiXY34iM25OrkxK+/zd6s67SniMCJKTcExnT5Zw+/xEQMlIjKT6riQ0ywRpDFw10tZUIdTULTRHK95Oh1FB6ULuDxBfNXW9NGmbanRfJ+mOLlVwTVZeUJ0eg6OBeNYpdTHfC2IXr/lGMeVapgvPsXyeM4aORljHNb4m7Pyy/J0Vm4nm3d3n1pCsZMBxdkldNwBT6crWJIgtmeS7u1FQczOVOzEqNG6rHqIYeqm1BATsbZSP+qjD68Ib8/Kh9KXpBkci9Yb4DpdPuZkf6xTeuxNMXb3LMG9/f0EYrU6nX2zPcU64/QrVQ/7R5HWm+/rGOicEyd7mv0+7q3sxCN2hGg3xxby3vTGpfq8W0cxjicCjCPPcY7bEtG29zkPcWFL8ph736zsUHVytB9xX41SIoFuXz8rphLMkQGP0xVg3DnejK3+RXTKk64A5x6q4u++r9OVhD7aebBOqVzoGc8pJ0REBnzsQctjHHeS5vtj8eOqDsdRFin2k2PpEuc55FGsYeqMSXPmYuPvfgBZqPW/0eqY9NEwDMMwDMMwDKPFsF/UDMMwDMMwDMNYEKl4ks7qHH7+2nGpYB/UWgaW7c1H9nfxpw5I52X9z/cKOUpKcrZiflCYSjyelVnKFZONcOBr62BuG0vtWF40HWu5VBhA9laPpqgMOc3G9ruzsitJfDZ5JCuz1IileieSPapOD0lGuGvYqvumbi3Ren4SfXAgITv5ABKrLtHyooRkoqMB5GMdCUkiU92HB1NY7UdkkX5wer00YybGuTtJgtctsFVemWh77kMksaqRFLOqLJ/RfpYdiYgMUvqFyIPM1C8gLULg2LdPJpAENbURd6RCrwk2ZOVv1p/IyjfKLVl5tK7lYz0BpD9+jDV/VQ7js6uupX6HSda4IcG97fBhz9/hLVF1ZgTzdSBZmZVzJB89Tqkc8qJljO10vrEYx9V93M816TWqzhMCiVKZ5iHLXK9Pr1J1tsrzWfll/4WsvCSAFLTkrMvYw/pZ6eN8nDqgJx1QdYYiyK/ayQZ8WCD5TByb7HId12Xps++jnPc7VJ3uEHtVldJEsBx3kqzcWYYlItIpvVn5SB0S7W6S8E5KVRT06Oim+z6eQEY9U9ey3SCP9pR8jFV3gnGvi7ZSH0zQhlF/PCuvF0jgdkTfV3XW5CgtQYI5tlwgxztB6R9ERMZ97BmHZzBWvG+6lu0zwZQ0YoJSPvBzw00jsNl7XVbe65NktIa9qEC27qfOR3OcxnHAh3y1N6/78AhZ4isJL6U1me05GtBbvqdmMD/Lnrb0X5dgTPZRCpjVMVI7nAx0agiW8Q4kkI8eF5LjkySx2CStg4jIWB3SZ7bkL4Q6DcjaBOuXZf/8fPEc4ViJ7rVEc7+dZNSu1f6SHPYT3tP1PNBzohbpeQlme382l/du+hjPwzMhTWvuwcYlgH1QMwzDMAzDMAxjQVgetcXHYtQMwzAMwzAMwzBaDPtFzWjA+ZJOzuc6zb8l8fg1r/l3ECxr6MxDijFD8pFa5EphUGesCinIquLNWXko1s55fJ2AJBIxSe1OpvuzcinQ8rM2ko+tTCG7O+kdxrlSLWOKSW40QXI8dsf63pSWgvULJDnsNHcsxf0Ent4qKiQ36iIXOnZJc2HXNHbLm0gg14h8LfVh96+aQOrj03dMu4O9qk5bCjkZy50Gc9dm5SM1SOaKoZaPDSUY326+forrb0w2qzq9HhwHXySJJ8sgWR4pIvIiyURZSrlPML7v7l+v6vzzCFwbCwLJy+Ea+m0s0DK1OEEf7Pd3ZmWWK5ZTLX1iiWRIkuKD5MbYTu6SVdHyUXaNu0ng8NdDrm1PJj9SdW7w35CVn42+lZVvy92alY8nel0WA/ThVIL7ZllZT7hK1XFdPk9zsw9Z1zOJnlPs7spSKr5O3nFtbctBRsiy3dEa5lc5GlV1igEkfZMxpGVcfybFPsWyUBGRsjedlRO6T5ZrrfY2OXUwr9kxledkV36lqqOcBGmsRz3M8XWeXiM7aV63p+zairnLUkcRkRkP470qwV6dDzAGvbHug0KMOTZEbr0sFUwTLW1bJVi/Yz7mEe+bnT6uP+1IQX1qzwg5KLL8PXL2aob3uc0+HBPLkeOCS9Jjvh9+DsSJvk5Izx52+PTpF4dOT0vbt3nPZOWNMcYxViEAeq8ueniOtNPc4TnKa2fUcR+NIpIr0vObXVLd59ABD66a7LrKMvcNudeoOix7ZVk0r8Xe/FpVp04yZL6HNlrzLEk2jMXEPqgZhmEYhmEYhrEgLI/a4mPSR8MwDMMwDMMwjBbDflG7oDRzarw4XRvPD80djxjfg9yDk1WfcTaSJ4YksYh97Z4UxZAU5UPIWWZz2Fqfh+RiX/WH1GYsO5ZbVhznrVUhXPFubYfb1XdmIHmp+iVVhyVOt5IT2UseZIwsbxIR2eZBgvYTwZasXCLnvclUyyX7yMFtmJI/+ySTC50ksOyuyAlRq+SiOSraSWwghWyN3eWORHC0ywda+sQSQ5YuVlL0FTuwue1kR8jx6BDVgdSvI9Xzrj3Afbcl3VSGvLDoaYc/Hodegayq5uHv3xvWMr3XdkJO99jM0ayco/a4kqQ2H3K6dTGcJocp+fVwqhNW/yh+NCt35yB7G0gwHnd2oW//sbRV1S+QA1o7uRzui3HN5aLlRQd8khvSsjpAc2/M14mXWY46WYW0jqVTy4LLVZ0CSXWPpJCpHYywDq7yb1N1Jn1yWiQJL89p39NJkHsDSCnZATUoUCJqxynyZAXzOiDZHSdU78thDNnlUURkPIWcrJ0SKrOMkZMWi2hpWj5tvJ+6a4RZTa6gI5TE/EnvaXXchoQSipPr45oU84hlvy4lcqv0Ezw7E+eZsIT2/s4QY1KvY6zOcG2l9vCcqsXYM0JyAnYlmkvpNb/OyZF7qb7uQ5Yec8Ls7Qn6YMeQfou2Qhonye4IIWl0k6CXIzwTDgrm1yYh2b7nyCUF7ZnwxrMyy/7cuXsryeZf9LCf8N5WEpxrWazltKUA65xdjidS9Ie71/PzeypuLD1ckWhZ51SA/pisQsrdVVgjzZioow38HOhkp0jnvQCPA4dlpAt26Na/FKVNpNzGpYN9UDMMwzAMwzAMY0GY6+PiY9JHwzAMwzAMwzCMFsN+Ubug8Ofk+SR7Zi5GuaT7jcdc7sGpw4kpSVLIMoZaouWBVUoIrOQJJF1iqeOp1xp/p8FOc24S1EmBlIOT3Abk1heRfKU9p2Ud3Qkka9tLOO4X+iE/+9Oh51Uddrjb6UHWsTSGvOiKfK+qszUiCV6e7pMMHF1Hq+UBZGssT9wbPZWVO3I6EXUHyUTYJTAh10mWyYiIHBNy0qShZhnSZPWIMKsLN+EWSO44nUBmuiKAy9u4aPcxdnTry0NmxpKow77uj2vb12fl56YpIbnsz8ptXo80gyWrywTnOukk5u2ron9YTsdJXLmdIiJLU6yFqSYOf65ciucyJx3vJcfAmJbr9en1qn5E63IP9VXq4e8sgxIRuVEgjduaQx8eil/EMd5PqDq7ycWyLQd5cMBOcc5jbtJHnxbIfZATGvvOd5gs85qIITntIHkhJx0WERlPMS85Ef3GGA6uz6XfE00ijVgaw/WRE/uyBFhEpC+HZMltoqW2Wf36s+rfLJHs8rFmy032SZfxEGuEHSTdJOg+7d1XeNgzVrRh3z1c1tLLq1PsM0Pk+nqS5s6gk6x9p499b6QGOS3PCb5PEZGIZJXrE+wNx0OMdZ2cFXOORHQqhtyY56Erh2XWJOi3y4vYAx+pQYLrSlt/mHwzK/eGWNdXUpv3UIJqEZGOPMZ3lBJJD4eQId+Z106gP6xCung8xhqLKfn0Nf7rVJ09JFFm994TNTgz8nO0k5xURUSSGGu+nuL5sCIPt97uRNfZHSOkoC+3PivzHnjIkdMr19cmoQ+854no5NUrc0gGXiIHVldOG1Iye547ks71vd5CJZLGpYJ9UDMMwzAMwzAMY0Ek0iKuj7OkcrrYMOmjYRiGYRiGYRhGi2Ef1AzDMAzDMAzDMFqMV5n08UJrft2fYpvr/s/ddc/Vfc813myubWl2XPPvFjyyhue4tM5wmTqOLX2Zch2a/cCJN+MYszrFr0UxArk68zq+ajnFV0z70O9zLBxb/eZ9HdMxKdDFHxKKhRuBDfKy3FWqTkxW91WKzzpI12+vaWtp30efjlbRN1clsBcPQq2/P5S+nJVXCeIjOLZpbaLbNhLAWn06RfzLWAoL/CWetkju8BBfsTZG/M2LgtgEt9+XJog/6fRWZ+WX/JelEaVIW75zHAXH5nWSBfaU6BiGpUW0+1/nr8jK/3sUts4nYx070hnAan+2GCCmkuA4jgdibkxvVP9+0UOMyHAV8U2XFW7Pyu2+jvOZEYwPx2ft8rfhoCnEjuzwEVcjInINtSFMsXZGPfTndKxTPgx567NykWy4OW3FLmcM2Vq+M8A6H0wwVwqJnrt1Sr3BMXM9OcwVXnsiOn6G5wHHsriW/mUfcTZliq/a2I7YwpmZ16g6ewsvZGW2Qh/zsDcNpoht2hbvUfX9HOpwjOtBiuWLE8eKnWJzJsjivF3F3w2pOp05rDmOdYw99NN4/ZCqUwxprBL09Y5p1B/xtT3/TTnEsu2rYz9rS7DPTIu2J+cUAznaUy+jOMqxdFTV6UzRV53UH+1pFx2Fsrv2egPqjypeS+lcS0K9tw356NMTdcTJcrzqluBaVWeK4sp6BPvHCK0RvheXacfe/jSHyhX173XeYFbeF/0gK68qwtJ/JtF9kKPY694EcXoHKT0Ax45PiR4Dfi5yHFlHgjbvS57R16TxLdF+stZDvw17R1Ud7l9OlVOn+8n7Tj/lEWM6nuJ8vDe2BXoPrTlx7nPjQr9HXTjm+rj42C9qhmEYhmEYhmEYLcar7Bc1wzAMwzAMwzAWm0S8ljDyaIU2LBavsg9qF/qnZPf6bN27UHv+C818ZIzzPV+zGujDYgD5R+L0beiTtIUkX4UC5A4jVS0pYrlkkpB0iuyKSzVVRa7rhpX40SraE5FV72q5OitPeuOqfkCSMbYrHvYgy3Kt2LsEkpMq2QX3JZBuHAoOqjpBiuN2xZABLk17s3Lia2leJ0kS4wR9wLb3y6RL1dkbQx4XUx+wZM0T184a1w1IAMASy15ZoWosIzkMt5rtwjeRJPK4t1OYHElYWJLIMrf2oF/V+c5Jsuf2cQ8sX1vlaSlod4z5dizAnKynmEjdjozpF9ZAovTDYdwDr7BdJS1t4xfbc5BLlWgeFVNt5c5rpES226Hg788mj2Tl1T4sq0W0bT5LtEZrkH8uK1yt6rAcjSV4V8stWblOc01EZImHdldoLR4OILvLpQVVhyVa/THadtiHlXvZ07IllljxWmTLd5Y6ioiMC9ZSWwqJc0pb26SvJZbcv8wSkpK1Uft9xxL8RA3S0I3B+qxciXGdnsJariJ5D/fWSSk0JkVLgpmxMtJmbCggrcJJbz/O68jHEpKZHhKM7005yOFGIt22Oi3g5dQHHk3q0EmdEgnmQa+3Eueiv7elWmZ+glKZTFJKjO6Eng80j8Z93Tcn6liXPFd4/S9JdEqAMZI+lih1SEKyv4lYyzpvz0G++VSyA9ekeTOR6tQhbBvPaQnyCebRk8m3VB22/u/OY59hSWOv04dHqU9GUkhYe4uQ0JdqkHiGeWdd0p4eCNqc0B7szim+t8k6JIn5AH+vik7Pw8/8aQ/W/bzXX5verOps8yG5ZBlwMejNyvxcFxGJE70fAJ6vruT9Qr9HNVoRkz4ahmEYhmEYhmG0GK+yX9QMwzAMwzAMw1h0WsRMRFqhDYuEfVC7oJwv18dmP7VffD+ze7PojgO/g44jmZwU9XEki6ikU/g7yS3Y5VFEO6BNkJsTu0aFgb7OQ9WtWZldrFiGVA0hmWGJmYgowUYfSfUOJXDxSxItjdnkQ072gjyflQdSSF7GUtflkFwoE8hRdgeQf3L7RbTk8kqBtKWaQGb6ePqoqtMdwklsqAppXBKgTiHVfThEMp6jJI2pxdQ7jlpyZwo5CzvAzZCk6ckUMszX+D+p6sckc31WnpBGXJ5sUv9OaS0dTeHAVnDmHjOYI8eyCNK4tSQ/S329Rn2BvOb2AczD/3UQ47axQ0uK4mnIUZ+n+/FpjRypv6DqdOUgJ23zIL8cqmHc2PnveKzlo2t8OJOOeZhvm3JvwPVjvZZd6eBpWLJ2MtAObt3xZVl52iP5GcnUNvtaTsf8SPZn5aUp1lhbovvwZZLqvSl3Z1Z+JPp+Vj4cv6jqsAvcz3ZhjTw3QQ57jqZlaQrJWZXup0JldoAMfMxvES0dft57KiuHHuZhORpXdfKhlrCdpkROhK5TbpEktCcDrLc2ae44uDSGxHl9HrLoiQjr/w0dK1WdmKb/vjrmxyC55V7RpTeAkXH0ez+5glbJoe+or+WB7R7qlFPsz6Me1htL6HKiXYH3+nBTrZE7ZUcO++4aT/dNNcWYlsm1kSW8gafXyGgdsuilJPne78GNNefptlXJAXktOfQOBeiD1Z6WLo8LSRRJ3jvi4e8nnWeCT8+RiJxFp2vH+Kis9Mbc7cL8n/L/ycoD+cuz8hQ50PI4iejnEO9Hu8gdMoq1JDHy8W9+frOM2Z0f/FbJpzos4S9Hjlw66KI6OHctOkFHuaK2xiEwHr1VTyWa82vGpYFJHw3DMAzDMAzDMFoM+0XNMAzDMAzDMIwFkaSeJC0gO2yFNiwW9kHtgnK+pIeQrbA05qL8mdxx+BKS5LADI7uXTSU6WWvRg2yGE0Sza9SS3DpVh5NHs1yCXfRm6lq6OEoSyYECJCfTKdrDUj92kxPRkpOKj3OxxKSkZCUizxch+WDJ5z6SxlyZXK/qbBdIpLqob9iBboYSVItoaekkSXgKJB+dqWuJJf97RRuSbrN8JXbm5IAH2RrL62oJ+uNIomV77B7GSWbLlHiVnSZzzpwayOEe+iPMA3ZT2+ftVnXuaUOf3rgED4g/OAqZal10UtnJBHNnVQrJV42SWvfm9Ba9dRTy3oPTkMm8ngzl9kyJYoxkVTz3x2PM91U5LX3SssjtWXl5HtLaMkk83YTdnBCYnUjbSIraF2iJ1mMRpMI3e3BMLZHc86rkClWnTtdd4jhXnmZ/PK7+/cYeyKd6qpAkPlMhl0bRborMSB3tWeVhXZ8IDqjjWEr9lRLmyxUe5lRnop1Rx33MUZ5vvPp4XZ7pktqYtQJnxmPhvqbHccJqlpK50serKaH5AcH5yglkg13+Mq4i/eSGuLSINdIVY47XnGiAW/uxJ75YQn/euQwHPj2i12+V5IrjKfpnKMD4siRaRGQkguPnZu91WXmPj/Xb7UNqOBrtV/V5P+rLbZBG/Ej0nsEq/lqM9bI+uDErlxwnQb4HP8V9FwQST88RSrX5kFwGCYUEkDw4cN4K9sryhq/5VL/TWW8vJN/NyjxfWPa3pLA+K38vgjTfZWncWNbJCaZP/RvzNVXvc9DOqiP17aNnT5o2lhpOin7PwI6OCb3P4JCIsvP8H2y7NSsfr+EePHKqTMnhd1b4GeW8bUwvwhAW4+ww6aNhGIZhGIZhGEaLYb+oGYZhGIZhGIaxINIWcX1shTYsFvaLmmEYhmEYhmEYRothv6i9KiAN8yxa54sCJ1bCI/27T1bVHH/javY53ir0UZ+15xwfJiIyQDFEk3I4K2/0b87KL/nfUXVisigOSJeepzQCh+XlhseIiExUD2bldtLVM/lQx7h0kH3xiRrOzTF3xxzr4YhibqZyHHcE/T5bEouI5AXxJiHFgTxR/0pWLoR9qk4H6fk5LQLbgHs5PVZFstf2qX+4bzk2UUSP6bEKLNML1FejNcTVTISwghYR8SPE9m0gy/Z99AXdiUjb0Q9XYUf/Z0dxP9Mx4haKgbbnZrtyHpMK2YBfVbtK1bmyG32wfRL3/aMxzP0k1Qt7Y4BYuOtDXPPpGuZxd9Kt6hz2EbPTE2LuH60grqQY9mblwFkv4ynWH8dHVSkmdJvoebgiQLzXQUH9OsUcDTuxY90J2rDOx9w/mSD2o+7pOJBqgnlZitBXr+9E3zw0vVfVKQr6Z7eHtBW8t3CckIiOs0k8XGeG4moCJ8asLFh/7XQ/hRTxfMMJYuECZ11yLA23bU/yNM4b9Ks6HH+7KaX0HhTbuDrV87Dda5zihK8/EC9VdW7sx70WKSXH40PY0+9Yptc/GwLc0oP+PULhvMdqOvbztR0r6DiskeM094ZTPfcKZPd/1DuSlfvTVVm5LIgj6wnxdxGRmQTPFN7HJ2Ncp8PX/d4pvVmZ4445ncV6/1pV5yClDqgkk9IItsYXEVmaw/5WpRjEhGK6pjwdg7wmxvPiJUHs6FWC590ef5uqE6S4b4635rg0ThVQjXX7OSXIetorD0SYE77zI0mF4k+LQW9WnqZnymXFnxBmRhrP18v9G7PycdFxnJwOhucK34MbxxmmWJtRzNb9c/19hG7WObc+CsddjG/pjFfGPqgZhmEYhmEYhrEgEjl/GYJnoxXasFiY9NEwDMMwDMMwDKPFsF/UXmU0s6M9x1elstfk73PEsVJPSbpQJIkWyz/YwlfkTOv907CcbirW1vI3siwrD+vigwLrcrazFtHyyckINvo5sqmukRSknmh7/v4irMhZohElkPq4crqhOiygWa7I1vDTkbYRXpKDhT3LQleksJlmKdupe4A8kCU0HdQHFccWvVsghRqj87EUdLS6R9VZWoAUq89HOydJ/pULtPyzRjITHvuE5CMezaMDvpa5TZPMtSvFWOU8yAtv8t+g6uym+cJyNJZrLpFBVef1vZDQTNZRfmoG53Ktlx8dxjhOkQV+W9Sblbd7+1Wd5THGJBehbd0k54tF7wsT0RFpBMsdVwaQNB6Nt6vjugKM1bEUMiKWeHmpXsvrE8hMJwVr4bCPOT0djag6vQEssPcneI0txW/I63W5fRJraV9wKCtfVkIqiLKnZVmcuuPy8LasPJBi/W3zf6TqDAWQvU1T29YL5GxrQ71+95JNO0sSp2jfvlZek5Vf9H6o6kcRpcoISYpJXc3yMxFt3z5Je4uS8PkTqs6Qh3tbnqzPymM+7ZvOV9r//zHMqfcshcytPcCc2NCp21aJ8drxMtbCaB3r+s6l2mq/v0D2/DWSw9cw1ksDLXfmVAg5Sn/QmaAPpwLsjZxSRESnEakI9h+WzHUHK1SdYoK9pc/D3Oe5W090J/KYFHy0Le/hXEVf2+ZPUjqYkPamlQn2o3VFnSrjpRj32kPt3pVA+hwn+rnKzzUucwocfiawtb2ISL9ATlqKMN/Zdj/n6XYypRrm17IipOjT3kSjw0VEPz+voPYcjl5Wx/E+znLHjhDPtBnR7xmmBGs+5md7OltapHkYYLRYOIuZiSw+9ouaYRiGYRiGYRhGi2Ef1AzDMAzDMAzDMFoMkz6+6rhYQiznKJEkKUc1gptTGECa5ztuiiwfGalD9sbuga4M8XGSGLGkkWUZ9UTLYerkErbG3yyNOCRwJdTOUCKDIaSHIz5crCoRpBztOX1vbQGc4mpNHLbYtUpEJFYudDjfsAe5Vyja1a9AbozHSOK1KoE73H7vOVVnhhztlnnrs/KB9NmsnHfaNh6RXIncy1a03ZiVx+oHuIoM5iAtO1SF2x27WLJkpV30Ncd8SIUm6LusOslPfV9/x9WWQJIz6kPywrKyDaKlT2va0e9T5Gw2E6FtdWe5lmPcwx1LcM3/dxRSpV/qvUzVeWQU/X7Q35GVXWdTpo3cQ1l2y06EwylcSVnqJCLSneC4gwnGsDOAs+IqksyJiLzoP5eVfXJD7BRIki7zN6k6BXJW2+6/kJWvSa5DO6taarTdx5rLCfaJp9PvZ+Uo1s55+UA7Op5mB/XnaEXLdvuKGAd2/DuWYr6Wk2WqDu9NvBa7vD6qQ3JvX8/dJMSc4nnNkuaaI33sDSA52yVYi7zmjzlSsE3+7VmZJZ63etjnRhPHbZPm0WgN47uRujZK9Lpa1YE9vUZr7KeX47iunL7OoRm0u0LSwTxJBdldU0RkhWzMymsELqk7fczxEjm4sgxbROQyWtuP1r+RlWPqg9R59v5EF67z2BReq5FL6W7vkKpTSdHuySpcW9nZ0L1OO63lumAMQnrGvlDVcviN5Ng7RLLQSoxnj+t8mdD+uj5BqMCO9JmszM6MLOEXESmQnL5CUl+WCu+ItdSXzzdFz/8SSdGv9V6r6jyfwJ15Q7AlKz9Uezgr94Z6fEs1PH+78pCM8v4+4Tiwlkk+6tF+lgrvR1qe1+y4VC5EyMr8SFLt1noh23GpYL+oGYZhGIZhGIZhtBj2Qc0wDMMwDMMwDKPFMOnjRc0CHRQvCPzdwGw/5/NxkHK4rpWBDzlMQtKaNIXbV1u4RNVhR8cohvzCI+lC0ZHgVUg66JPLEieVrSVausgukEcSSKTWepBysFTRlazEJH3IpZDzBJTYO061RIulU+x8yUmg3USj+QCytf4UEh6W4FQcqRA70nFS5zy5Y/I1T90PZFksFbwygIxq2D+m6pysQHI1JHD/YxkkJ0oVERkhR8ieAtzY2IFtqobrxDntXsayJna7ZNnflZ6+5u4Uc2o02p+V39r2pqwcOVqMdZ2QxnzjKKRGf/SWx7Lyk9uvUXUeOgoJ3TOj1J80358a1XNiFSX6LkQYnxfSx7OyK+3blN6UlbfG36R7wLk5gflakjqJiBRItjdGrnE1kgOfDPRY51JIn7pJfjZACardZO3daW9WZlfNHT7mTZsjbR2gJMajlHSbpaAdjiMdS3Ancxi3EXIpbc8NqDrsYtcdYwxGSBpbFy3bY/e+ngRtOC6QaB+m5MqdvpZOsmTLJ1fNcjQqzRiJcG7ej1h6ebXjcsqyuSrJXFPK3315R5GryI5p7G8vT6L8gWshK7v5pudVnZdehNSVE7nnfJQfPqZdH3vzaNsJWvM9Picg13vthEduovQSu3+qfdP5insPzSOWO7K7bFeqn0MjFdxDmRxcVydo5wlfjxtL8ArkwPraAlwjxx299AvJ/qxc81jGjOfdfm9c1Xk6xXV4D/apDjsJi4h0C+biQZ9kwNQcduF1HYv5Lcy4h3HbnzyXldvonkVEyhHanaN9rhpDBlkI9dtcfkbujZ7Kysvy2MNKiXaX5XFcI3Ai3lGDXDpwnnfqea7cqtmlcT7v21y5JO4ndfaTC0EqnqTzca88B+24VLBf1AzDMAzDMAzDMFoM+6BmGIZhGIZhGIbRYpj00TAMwzAMwzCMBZGkXou4Pl74NiwW9kGt5XEnW9qkfLEwH5vZxvFqsx1XrUNj7trRs6XutECLz/b8kRP7xbFghQCxIxzX4qYByAviTapkq/xyHfbAvRRDxfbRIiJTPuqEZEPO8URnxJvROZKUbYDRTo5DERG5XhAH9YwHe+7VCeLAlsoWVef5BHFU7dQfU4KYCrdtOYonPO4j5sf3ENgSOFuSjmlAzN802Y3PRDqeIE0xR7j+0gD3cyLdmZU7Ax1bNEnxZlWKceGUBAeScVXnhLef2on59bUKjXWg7axHd63Lyl0h2tzeBwvsy5frOC7myDTa89UjGN/pVMfcdecoVinGHL1eXp+VK46V+h6yne8PYF3O8Z3LU7S/7Ol0Fsd9WIez1T5vWWORth7nlBhXBIgDqVOsZkF03BOnrailiPPh+CqXqofYms0p4kWfopi9qUTHwrVTzNqSBOkTRoOOrLzev1HV2UR1XqyjnSsSzOMxb0LVGUr2ZeUuiolki3VOp+GmBOgk6/AlFAvbl6dUH1VdJ6H1wtfhGLfQeQ7laM2uotQBaztQZ39J7/VXtGM/DOh03UWM23d+cKuqc3wG/dtfwDVLtLWtaNPCoB+UsAdxLFpbStdP9T4zSvOI4wE5rpVjYYdixMuK6D21jaztOR4ql+pYumVt6IR1kyuz8mEfa+xovF3V4VipvhzW3wTFpR0hm3oRkVHBOntj7o6svC1G/G051fOwQ3A/SwrrszLHGevni8hoeohew3H8LOV+ujLRKWuOUnxynWLpyjWMp/vs4pi1iSpSKXBs8mHRa7lc0akITlNI8Xwad57/vsexedgrOR6RY8dFdMoST72H4Ziyub4fav4eyKfrJk6KH+PSwD6oGYZhGIZhGIaxIE7lUbvQrWiNNiwWFqNmGIZhGIZhGIbRYtgvag1pJdv7c3n9VrpPjcdtI7kHy9pO/Rvyi3wIyVmFrPLPsKamWe+RLIvPVa7rOixRnCap3Ub/uqx81D+g6syQjXaSNpZsVhNIa/r9deo1luBdk9yI6yTbsnLgaUtgTiNQCBrbFa8MtOX7Nm8X/kHToFMgBdkbaLmUTxK6kQpkcn3FK6QZJZJ/sRz1BoE9/75gn6rTW1yfldmKma3/Xckov8Z1KoK+ZtnQZKylMWxBH5EcjyVj06GWz7Bsj+UwbNkeiZbTXN2NPvzYz389K/+Xf35LVr5tqZZ1HixhTPeUWGoDqdHGtnZhnq5C4sTSwbIPyZlrEz+QQoq1u/7DrMz3Nl5E23znO7/YkV+ehvvWI/ncqX/jHDkqD4S4n9F4XNXpJmv4MQ/XzNG6GIn1ulzuX5aVhwTrgseQx11E296fEEisWPY76p1QdR6JMJfbfMz3/fXn0JZQpzWIYvTPMcG6ZHkup4+oBlpeXKC1cITkvSFJn/sLl6k6PNbtMdb8fh/1d/olVWcDyaKvIknj16f2Z+X/a3AlV5G2EPf2S2/6dlbe9QJkrv94oE/VuWs5xuHKbuzPx8vYxCuOeoylrZsoNcQT8Y+ycq/otAYJpX3hPbQnxD1USL7u7rssbeP9hy3rr3JSPvzTFNozQ1LuzSnkn9OhlkufjGCVf12KvXZ7CqlxwdPy4CTBuvhO9IOs3EMpRtbQeIqIjFIKiZmY1jlJOT1nzbPckeX5Yarbc5qBUPfhhhwk1v80/bWszM/8Hlmq6hysQ6rPckfe95eGa7mKxLS2fRpHlt0HThgDj+nh9CUcx7JDRwrK6VymfOzBcczHOe9nmv520jzkI0kuvCW/cW6xD2qGYRiGYRiGYSwIy6O2+Jj00TAMwzAMwzAMo8WwX9Qa0loywMXl4ri3lNrJEgvPkSSkjjvTXKiQfKqLXNLGypBB+b5eGixR7A4hGdmdPJeV41i3hV2fCgG7MUIikpLkZlogfxHRrpHPpd/LyrM5TbLTIrsssgzyUPS8qsPn6yGpTSf1wYp4taozTK5nvUVIVlgWGie6PwKSj1RImhKT42Eu1XKYUTqO+71E7oNVx+WMxy5JyMmTpFer4vW4vq9letOCe6iTixaft5Zod61i0JuV8zmM29IUMrUg0XPqxQm0h93uPvbpf8zKn77/51SdR07gHM+lkJy+NgcJ3XdrO1SdqXQoK1+WXp+VD3uQS9UdqV+ZZDssU23P4e8T0ZGsHPpa3sQuaSx3TJpIIkVEqnXM/+eCp7NyWwJJc1E6VJ03d2Nebp1AO0f98azsBWu4ipIh39hGUrsyxmAm1FK/zhjrp0CubTl6hO4mqaCIyFgV0sdp6kNelzXHLXNpDhK0oTrWmBeQc6dgjXfntLywnuJ8vG9WEi2RZBKSwB0PINFix9OKIzkt5rCfXSVY/z9BUuWbl2vJ6YtDcLvseBfWyM5H8Pd/c4WWIT8/DMnn1T1wJnzkBPpzxplTHTRH6l7j58jJdL+qo9wZaXymSBbN84b3cxfet9m98MlYz4/ROuYHj+NRgfthMdXzfbAIp8SdJHdkR8tDJM0T0bJ3lhsrl8ZAS+v4fPyM4X5iuah7HDvxsjS9Ts/RmqevOV7DWLFzLu8LJRlXdQbyWC+lGHJ0lipOefq5yu8hiiRNj8ld1nUS5v2Mn5EnKUQiDPQeWEnR7zlyh43jGVlMPGrbRfL2zjhL7IOaYRiGYRiGYRgLwvKoLT4mfTQMwzAMwzAMw2gxXmW/qLHL2HwSL1+szMXdca7fPlyA39bJTclz3LZSD+OYNnFGih1ZVw8l8GSCAHKPM90lcR1OfDxJiXFjR4bJkjFO+ntt8JNZ+cX40azsulP+YscvZeWvx99q2GZXktSTgxSM5ZozdUgF2R1TRDt0cTLfoySxWkeJRUVEXkowDiybG8ghse6J9GVVh6WQ7LB5MIBEarimE8myk9ZkhL4OSO7hJhrl+0n9xut8jwfHtTuD16nXvhE91LAOj+d0TSeiLpFEclUbkoNz0uBh76iqc5xkUf9lB5ITHyG548FpfW///mo4C/7fL8LN7MUEf098PXeXe5Cm7Uy3ZuVKbRzt9PSjoJ5AnrMyRNtygvakJJdiKaqIljvGTVzJXHkxr19OXlsowqW0P9HOeV8pYb5c4VEC7gTytdjXbmwsn3qw8lRWvm8A4/bokHbOfNGDFLPPwxqreBj3mVhLrNYUbsnKowlkZiWaO1fkb1J1lpFE6tkQY1BNsZaXCOTartvmsRROkT4b59JxboL30RTrqkbjvlEgk33Ze1zVYUnf7mm4LA7kMD/a83o/XFKgOv832rB5EBLab+/TjpT9BcydQoBxXN9BrrNV7R76LXIpHRbIXjlZs+tKynt6np4DkxHGKqX65UiPdTGHvWEiwjq/LMAcOJC+oOqwcyQnGudHbHei9+rDPu2PHq45Tkmd3WeXuz+epkbPhzHRyeer/hL38DNgeaGIdvXl/SRPIQBrKQn7iPNcXkb9HiWYUwFJUd195jb/DVn5ScFr/LxmSeSpdmONsdT4cB3j4zpachgDuzkX6VnqysdZAjse7Ufb5vzes/F7sjPDP6KGxxmXDq+yD2qGYRiGYRiGYSw2aXrq/wtNK7RhsTDpo2EYhmEYhmEYRothH9QMwzAMwzAMwzBaDJM+viqYy2/AfMxs8WpziXdbOB5dR2u6XUtgrZNvhBuTFVEs2VIfMVUTZNkcBNoWmfXn5RQ20RyX1h7q+BmOS5usI25hdzDTsI4b9/B4jBivTd5tWXk/2YC7uni+DsdUhXQ/odNnHE902MM1u3zEq62TXlWnL4d4oFqK+5lOcQ+udfjwzLas3JYnS/AKYgPy1GYRka4cjuOYO7aJjh2NPt8f25IvT9HmaQ/n+lGMeCgRkZ4Q7WZL/6k64kAKYZ+qwzFz3Accy5Nz+r0z7c3Kl7chnuGhY5jjNy7Ra+xbR2Flfn031siXSxSbJDpmZ0IQo8HW40mAmBt3HnVRKoRRsgHn2JEbvZ/IykcpPYGIqHDg4QQxiBwfxfb+IiJ10WkWTlNJMYZj/ljDY0RERiiOa4Bijk46sYFjNbRnTe6GrOyTlbv7DWa3j/6oCOLSRmp7s3JbqON6Qnq8cixpL1nYHxCdSmEmQUxVzcO6Wp6izqiHeejG0hTICj2gNAKBj7Ib17YxQVxYQnv64QDjczntPyIiyyl2ap+P49YEaOeyZUNcRf5mO1JIPD92Ha5JU/yyLj0PawnaunuyNysH9BgarusYSN4bOIa4VEMMVc7Z3ydo/i/JYQz4WRHFmPtunBHHV/IaK3mUSoHmkIjIFMVUjVIM05vyb8zK304eU3U6PayfsQhxZYPB1Vn5UKLTr3CcL/dNIVyWlUPRe1NN6BlF8WocIxbM8uzlmC5mpdeblUdSbVP//eSJhvXLgthtTi8gIvKih2cK9+9QDc9IjtsWESmliDvkfudULEsLV3MVGa5if11CMe5TFI8Y0riLiIzVdXqKs4fXadzk7yJJWpFWIhVPkhZINm0Jrw3DMAzDMAzDMIxzxll/UPvud78rb33rW2XlypXieZ58+ctfzl6r1+vyW7/1W3LddddJR0eHrFy5Ut7znvfI0aP6G80777xTPM9T///yL//ygm/GMAzDMAzDMIzzT5p6LfP/pcJZSx+np6flhhtukF/7tV+Tt7/97eq1mZkZeeaZZ+QjH/mI3HDDDTI2NiYf+MAH5G1ve5s8/fTT6th7771XPvGJT2T/bmvTPxufG86dJb9HXZlKM7tUd+JcfLY0Hmmamt/nwmFpCV9THJlb6si8sr+T/bIrw2C545SM4LigKys3sxQXEVmTwNJ3QiALm4lG1HFFkoOxXXEzO/s40JbRLLthueNgijoszRMRGS1DCsJynI4QMkbP09/PTJFdeIH6oER9s0+0rLPNg3SI5TQjEaRgvmMj7FEfVOqQ4xVykNa4ls+ddN0KSU59kpmckRaBZG9sIb87gm03p0gInO+rZnzIlW5Ib8zKTwbfy8qJY++9LMCcGEr2ZeUqyfZcqVCbD/nY7jIkTaP+eFYuDet+nxHMS5/2kxmBJPByuZGryH7/paw8XYccjWW3PeEqVYflrDkPfe356Ktt8kxW7vIgoxIRuYakehs8nPtlgb24K9vrIDlsZ4DzXZVclZV3+Tp9A7fTp7ZtoLU3EA1yFRkWfY7T9Oaw55RFjy/b4y9PkRahFGAeuykODkeQ9K7Lwfr/UARpWuCsEd+HPLeDLNsTWsvdgrlSSIuq/jolU8Neuc1HOoo2T8uLVxcxL6v0iByKce6rcnoe7qhjb0iapEX5q8dvV/9e24E+vXMNZGHfO4x7vvMKLQX9/z2B9AW9OTwvi7TtHwi0xGx5inQUh+MXszI/UzppPxQR6aOUB8diyNx4jRRz2BtrjmwvoXPzHtabYDx2pU+pOjWS2vGevCOCvNB3pH49nJ6CphunAXGfd7xXVWLsob3hGmkGPxOWFiBZbQ9w/Yn6YVUnT7b3bMM/5mHPedtKzMnfO4w5KaJTguRJwttTwHqrxpOqDu8h3dTX0zRuU5TWxaU7pFQXtBa7REvbRymVCEvL2Rrffd6VKSVO4PM6bbxeZn+NQkGc5x2nLOK0BMalw1l/ULvnnnvknnvuafhaT0+PPPzww+pvf/Znfya33nqrHDx4UNauxYJrb2+XFStWuKcwDMMwDMMwDMN41XPOY9QmJibE8zzp7e1Vf//iF78oAwMDcu2118qHP/xhmZpqHEguIlKtVmVyclL9bxiGYRiGYRhGa5CkXsv8f6lwTl0fK5WK/PZv/7b8q3/1r6S7G3KLd7/73bJhwwZZsWKFvPjii/LAAw/I888/f8avcaf55Cc/KR//+MfPZVMXTHrWzoqLDUskFvrzt24nyzqFZXPnVLnZ5OSObC8liVJM7oXsGjlNMg4RkSVtkHzEJAsZyEO+xk6Ep85HDo4+5CNBAtkBu0aJiIQ5vFYjx0J2FZxKIAth90URkSo5E7IDI7sc9nj6V+lxD9LDeoQvP8oky3LdKdMUcgt21eI2Dwc6znQ6gfSJ5ShF1/2P6CxAAsdjwv12e/DTqs5WcgLrIMfAmMZ9CTlQimi3LX5taW59Vp4UjOHKRMv2WDI6Q/ODJbMHq1tVnZmA+sDHXseym2qkv4zKFyBReiF9HG32MD+nRLvTLQ8gCXopxX3WI8hpp0J9HXb/Y4lVl4/7Hoi1FGzUx/hOkjsdyzWLKdp2g6/HYA85mL4cwbmO50ct0euFX9tA8mLeW2cS7frITm8sAzxcx9w96G1XdVgulUvzWXn7BMptjgRpksaxLcT4sgzKddus1tHWvTHGtzsPF7qKI+Uqk9PjeIw1V/G1XPE0G9Or1L9HY+whQz5kmb0Ct9CaaFn3C1XsQT0p5H1v78d6HarqNz1+HX1YEfT1SA170xOj2k11MMFYPXQc6pqfX4W+fvmwluNt6MSz7J4Ne7Ly7/wQa9H9uvlyD/caB2jPVAD3QJaviohMeuNZmR06B0jS3E5905PqPbSQYq9nieNISDLGWEvj+HnVmYcE74S3H3Wct2jHU+zvXYL1e5Ici3OO+2CpjjnG8txVyfqsvFP0fsbHlRPslekssj3enyc9zP1f6IQM8vOHcK7pSLuCMpf5t2TlkxRe0OE4q66MMUdP+OjrSoTruFLQ9iLGjp//7Eg7mQ7rOvTMnFRSSkw+9/nPsMtoPRptelwzZgs5SVvM9dFYfM7ZB7V6vS6//Mu/LEmSyKc//Wn12r333puVN2/eLFdccYXccsst8swzz8jNN998xrkeeOABuf/++7N/T05Oypo1zfXVhmEYhmEYhmEYFzPn5INavV6Xd7zjHbJv3z759re/rX5Na8TNN98suVxOdu3a1fCDWqFQkELhlfNlGYZhGIZhGIZx/kmlNWzyWqENi8Wif1A7/SFt165d8sgjj0h/f/8r1tm2bZvU63UZHBx8xWONxugE0fM7A9Bn0A6M5z/1HkufvLS59IITTkYey790m8diJApl17W1CeRbM3ktsWIXrBFKAFwgKZrrPsgukCtDyD+O1CGr5GSkHTktP+P6XXm8NuZDMpI4Lk/soFgjqZ1KIBqNqzptOThcsSSxvwhZ1YpE/4L9coI+ZKkNS2PKdS3x6C8gsW5KDnss5dzt71N1ZirkqpeH/IPvuzfQjoWqfsJuiHAvq5J0supISdoEXyyNU8LaqqeT8TIst1ye34Q2h2jzWKrd6ViSOEMOYUvIjW0tOc2JiBwiSd+gQEqW5NDvh+svqjqDIZK35nKQB3Iy4AHRc48dP3OCOuw6x4mXn3QSZrMDI0sayyT7Cfw8V1HSozJJ+EZ9nNuVgrEElp3vCtS3V5Fzp4jI3hycBUcF97BnWju9MVHSeOx5HrrucgGtizBAH7Kk2HUP5TnWHWB8eV2xBK8oWk43WESf9tWxLramcIMtpp2qTpEkoweC/Vn5WyOQaE76Wk57JIGctC3AnvOih76tO5KsFeRwO0pJqnM+7u3ItG7boWmsn51DkDRO0Lk58bOIyHcpwXlIjngrBG6QYaplqiO0Ntmhs56inSfJzZXnqohIJUX/tJNTbZlcX11HvjDA/ODzTVFS6VpcUnX4ebEyB1lmyRtueIwLj9VBD+6WQarnEe/pLM/tIAmg+16AnS9j2lOfmIAMca+HZ1/sSP078hhfThTeQy6nU6Kfy5ygfTxtPO5FRzZcYsll2JsVPdo/Lku0pPj5FPJt3gt4DN3+iOm4VL1v4bKuo9/HxVS+lD52GGfLWX9QK5VKsns37I337dsnzz33nPT19cnKlSvlX/7LfynPPPOM/J//838kjmM5fvzUw6uvr0/y+bzs2bNHvvjFL8pb3vIWGRgYkO3bt8uHPvQhuemmm+T1r3/94t2ZYRiGYRiGYRjGRcpZf1B7+umn5a677sr+fTp27Fd/9VflYx/7mHzlK18REZEbb7xR1XvkkUfkzjvvlHw+L9/61rfkT/7kT6RUKsmaNWvkZ37mZ+SjH/2oBEHjnFiGYRiGYRiGYbQureK42AptWCzO+oPanXfeKWna/GfY2V4TEVmzZo185zvfOdvLGoZhGIZhGIZhvGo4p/b8Fy/N47Wac2EzwruWrfM5w1xec3X2Z89C+1ZPWdZu18iS16PYs/acjidgm/Vj0ctZeW+4Myu3eT2qTjmANp5thVnL72rUOS6Mr7M2dxOuWYVtd7uvrYenkqNUxjU3p7Aufjb9rqrDWnjWz3MsTOhrYx7W83NcTT2Fxv7GDt220Qo0/OUU/c76/4HCFapO3kN/JEHcsA7HdIiIdFLcQj2BdXmNrJDXeteqOuUc0h9EFDd4wEccyrEK4riWFNar+gMpYnuOCWTe7YI+KIQ6doxjP0aj/Vm5J8S5OP2DiI5F6SB77hxZfU9Eel1P+ONZuTvBHB2Pj6C+Y899Isa85jnKdtq70mdUnW5K+8CpKgpFxBAVBOVairEREZmi2MCZOuJnuug+O30dv8yxV1UP43Y02SHNqKUUw0NbwyqKpVvtGFGN1BCPF9G+ub4d8V1fL/+o6TVHKT6zTnEontc8RiWhebisuDkrT6Q67QXHoq2PEVN11EfsaELHhM41h6q4nxJdc8DDmuhP9dydIbv+Nkq5sD6P8R2tF1WdEs3r+wawzj87jLinZamOa/1ejDl2Zx6mYaM17AXfH3LSANDe//f70Z5dHtJ21Bxb9EKAmCTuz0kfc3Io1XFtHDa0NsWes8/DuuJzDdewL7isyGM/4nVRd+Ic2fI9n2LN8nPAjVHjuK4THvYzjiOdTrS1PK95TsnB8Z0z8Yiqk/fR1x7NoyrFV7rznff3Kq3LnZSugFPQJKlOE8Hx4jnBWuxNKGaYLPhFRA5RTHOZ0mH057F2Ruv7VR3ekzmG+TLBuL3kPavq5D2ORUe/sSW/56Tn4DWvrfubx/k3j0VrHptvXPrYBzXDMAzDMAzDMBZEIq3xsbIV2rBYnH8LP8MwDMMwDMMwDGNW7Be1ixr+qf18SS/nep1mEsf52Mw2tqw99QpbtpMMiWyr2RJcRKTgQybSRva8jGstXQwgMytHkEuwnCVyJDjL8rCDHyZr52kPUsGVxRuysmsz7Xt8D7jmiRykLa+XN6o6j6XfRHuU9Cqhv2s5TXceMre2Au6TJR7fLx9WdWKP5B/U790hzjXu3M8N/huysi+QYu0Ica5O0XK4Mtk0T8eQSLLshtMViIj0knTpWALJacGD3Xh3AfKXcqwtnw+RBXRnAKkQy2RcLktgyT8ajGdlTuUQOFbqXXTuUkz22vRd4D5P93sHWasXSR7EsqElJHMTcaSPHtbLJNnJ87iJiPj0Hd7SAuz9Z1L0AUuqrkiuUfUPBQezMq8RlnW5MtcbfUjoDpGMmaW5nLJCRKe0YMlojSTaOytalnlb29qsfLgMedI/l3/Q9DqcSoD7OiVr+amKTr8QBpAY5gJICllCtySn5YEjtb14LcS93Risz8oshy05KUGmPexb/YLrR7T+S6LrvLYH0rKTZZY74jonZELV4b5muWMvSU7Lnu73VQnkaIdrmBOb6VwDeS0fC+ir5K+Xn8vKPPc4/YOItrrndBJqD3T6gC3cX/Yga+Q9jOv7nn7rpNKfkBSc9xZXksz7a8nDfBur4lmROlb77TnsGSxDXEFrJw50ygd+jpRS7DPT9aGGx4hoeX9nDvsprwu+ZxEt8yxFkCiyLDyOcT9uH/I6z6VYb2UPEslSrKWPPA9YSnqDYM/aG2rZ/v761qzM+8eu9PmszDJ7EX2vHF6QJGib76Qb8VSfXkq/78xOmnqStoCRRyu0YbGwX9QMwzAMwzAMwzBaDPugZhiGYRiGYRiG0WKY9LEhkOf5HiQrSTrd6OCLgLN1WnR/Mp6PXHE+dRZ6Xnzv4JGswpWP7Il+mJUvC2/LysdlrzSjSu5bLJeYrB5pdLiIiJQSyET6cuuyMjsRJiTlZHmliHblG69DgrO/Bhet8fxaVee1AaSQj9b/V1aux1NZuY3kMyIiE1FjZzOW/bmwzKXbh2yOpansHCYisteHe981CZzvbvNek5W/XXtQ1eG+ZrljkmBM2WFMRMuaBgJy/xI47A2m+PtkqCWNMTkBTkZw22O3sMDXUsEdyXNZebng3KtTyF9POjLGJQnubZ3AiXQfOU2uStarOiUf9zop2I9WChwlq6JluysDyBKnBDLgTr83K0eOa2wpxdxlNzeWlfYnfVl5xrkm39uYh7k7GUNuudy/TNUZbMP4Tk7hmjzuPB9EtAxpaYrXluYho5qsabe9mFLInPRImkbOeV2OFHSKZKIMS6+6ixvUa7yW2HWVJadrw+tVnQlyZF2SQo5XDLAnlyKUq6JlbgWSjI14WPMzHs8bLRW+J78lKz89gXV9OMC4ubLd5THmwUF/T1beS86OvOeJiEz72JMLCc73lROYxyzDFBEZqmCs8p6WDp7m6nST+ndbCvlkbwHlr1UezcrVWMtuu8kplt1Y1fiG2A8HE31vB2lv43EPSWbvugKzvG64/FJW7iApermuHRxrCfqK29yVQOZa8LRD52hwIiufrEAKzq6krmyPpZAsd+RnFEsVRUQqCfqU90o+znWKZFgmGnrYzw772A9ndc6kfWpvinueoXUgIhKTXJFdKH2ShbuyTg494PpMW9in/l2qYr/XDpeYH54jOU1pn+CwjoW7ep8/LI/a4mO/qBmGYRiGYRiGYbQY9kHNMAzDMAzDMAyjxTDp4yug5Y7zSdZ8LpmPk9Bc7uFc3tts11+YUyTLCFhi4TsSDZZL7awhYfTGwuuyMkvERERmSAqWkJSSEzJP1XTyWm5DgRKadqdwoeKEyutTnbh5RwKJZhs5V/F1OFm0iEjJh5SjtwgJ3lileYLWZhLLfIg2u3I6dizjBM8smZmun+AqylFyu4+E0/cUIL3qJ9mgex12TSuTS2Il1o5063zIyQ4kSFzMjoe7Y/QtJyAX0a6cVZKMTvuYA+5YRQH6/WAd12RXvzWxlsYdDSCN6YkhXRpIIWnqFD13V7AUm5bLrhTy1ZqnpTltqZbxnIYTZl9e0JKzh2uQ56kE3gHGqkhyuFFKxC0iEqZ4tLAMarQOZ8RD8fOqzv5p3PeSHM69vg5p2zK/Q9XZ7WEtlEny+mSMv18f6ETj916Nfn/PC5AEdqUk5XTkUrzmC5T8tipadstohzzM3U6SaxVSLVPrDTFfBkiONlHHnnWcHBiPeHD0FNGumiyxZnnwTXKrqvPXI1iL/ZTo/Fd64Zz3+Ih2Sdzp47pjNKbXBXdl5Xqi5Vos/e2T3qwc0vfFX5/ar+qwTHN1gnGMPEiseS8R0QnryxXqD5K59eRWqzosV2RXz1XeVSinGDdXVTXqYQ+9LIEcfTclZB6u71N1ynVyMFSuvGhnGOj5zgmv2fWRnWKPenqvL9fHs3IxZPdi9KHr+lgkN+TeAOtyRYxyt+i5+5Q8npVZ5snJwXkd1Bz5aTvJmlnuyLJb1zmT5aN1QXmpj/GdSBrLll34WcNS5VP/xlxmB1dOaj1T146UHAagJI7qrU3z93DNk1+3Nqm0xrvjVmjDYmG/qBmGYRiGYRiGYbQY9kHNMAzDMAzDMAyjxbAPaoZhGIZhGIZhLIjTro+t8P98+PSnPy0bNmyQYrEoW7Zskccee2zW47/zne/Ili1bpFgsysaNG+Wzn/3sGceMj4/L+9//fhkcHJRisSibNm2SBx98sMHZGmMxamfFbKrXgMpx06MWl7mqcPm4ZpO3FeLv+HuDufUh67jZCpk197Fj6evRtI8oBmlEEEOxPtGWz+NkMe6T9X85Gqfr6DgujlHhlXZ1ekNWng4QE3IsRayHiEgb2aeznTRr5AdyOu5pXwr7ZY4TmM3yWciKnC2fT9YQhzKQ13E+m5Mbs/Kz3hNZOSbN/pKCbhvbNF+ZwJp9/wz6rd3vUnUO1RHHxPEJq9sQZ8MxVCIiYz7iWnLS2Oad40COxeizU8dhLXOsBqdocL/iKieIG+L4hpkEts57fB33NFWF9X97Hvd9I8V0Pe60jeMo2Lp/vTeYlZeEelt/kWIFtRXaJwAAhLxJREFUf6qI+L3v1mApPl7XKQpulFuy8lMe4jj3RkgNUcoj9QCnohDRY90sVmuqqufhj3Lbs3JPjJifm4uYk1f36H2hOIpYlCdixAa2kbX9+q5A1fnIczj39RR/M0G223udmLtCgPMtSWHTfpxi1GInroXheLEeQSzOIdHj25NiLe6lvWUjzcM0QVzLazwdb3aS9rP93rasfE2K2MKBvBOPFCHm7mqKE4roMbCyqGMl99RxDo759ek5MumNcxW1FoZ8jH3Vw/7MsbwiIp3ST2W8dtDHXu1atjNPJo+gfoh7G68dVMetzyNFyLDgtWEPsZ8THuYxpzQREWnzEAu3g+KEm+0LItqKvT1PqT/o+RI7qWVyFDe81Mf+Ouhhfh5IdNxTN+3vsTSeo+51VvqIzdtA870th7XUHur3EskMzj1FaTjYzp73YN5bRfQzju9tStDvbcESVWe0sisr9xTW41wenikl2mdFRPIh9lq25K/TMyFxYsfy9MzlZ0fCVv1O6gEdl0aW/LPa7ntU8ug443zwpS99ST7wgQ/Ipz/9aXn9618v/+2//Te55557ZPv27bJ27dozjt+3b5+85S1vkXvvvVf+7u/+Tr7//e/L+973Plm6dKm8/e1vFxGRWq0mP/3TPy3Lli2Tf/zHf5TVq1fLoUOHpKur64zzNcM+qBmGYRiGYRiGsSASmZ/N3WIznzb88R//sbz3ve+VX//1XxcRkU996lPyjW98Qz7zmc/IJz/5yTOO/+xnPytr166VT33qUyIismnTJnn66aflj/7oj7IPap///OdldHRUHn/8ccn92CRr3bp1Z5xrNkz6aBiGYRiGYRjGJcXk5KT6v1qtNjyuVqvJ1q1b5e6771Z/v/vuu+Xxxx9vWOeJJ5444/g3v/nN8vTTT0u9fuoX5q985Sty++23y/vf/35Zvny5bN68Wf7gD/5A4njuyjv7Re2smE0eeL7kjgvlXP2I7koqm11nNnnjfL4DQR2WHuZyJFWIp1UNljuwDIFljO5XGGzPy1IflrPkyfpYRKRSh2SDr7MzhJ10J1k+9wokJiIih2Mcx9Kr8cr+rDxGkkwRke4QEjiW5+R9yJvYSl5EZJqs7rk+y1SGatoGfEMAacplcmNWLgUkJU0PcxUpk634PrLqLnuQvLD1uYhOS8DW42w5v8W7Q9WpxxifOklLeshO+oUQsjC2FxfR49uTh7Su38e3YJN0LyIiGxLY9e/0IQ9MUszxK0jyKiKyO4frDKX7s/L2OmzZ2zxtz83UPdxbja5zpKblNCyl+n51L+oIJGMVx2b+eQ/SpWVkb+8HmBOHapClbgwhHRMRmfZKVAdzn23ifbKfFxGZiGCpXwwxD0bofv7nkLbA7k8wJ/IBZGE3+uuz8qjzXA5prxqP8eJrl6D+ngm9F63wr0A7SQJ3fQxJ4bCn58QBH1JMtn8/EkHiGfpaUljwMEcPk/X+He2vzcoHJ1Bnp6clfJsC+qY2xpxclkOd7XWd0mM5SdsO1sjyfQpjUNDqUVkb4zq5PM49KVNU1mPVFeA6hQT3eZWHlATPyjZVZ5oktZ0k75tJIaOMHMn5IcG+uTrcnJUrHp4DKwrXqDph0vitUIdgfo3G2GvXUgoQEZESjf2JmpazniZ15XQh0kGsDXE+3vdZSi4iEtB+sCJBapjdPuR9kVNnBaU8OZToVAaNri8iEtO+yZLgJXnsu18pP6Lr0DNyeQhZ9BCloFkdYDyOJpBei4i8MffGrPyD9AdZebKKZ0XBkUty+gJ+dhyNscY8R5LIsmyd/gX3Vo60FJxT/NRjLWE/TVdhjfr3DK2ziFLInCl3VFei40zwuBisWaPH5aMf/ah87GMfO+O44eFhieNYli9frv6+fPlyOX68cYqH48ePNzw+iiIZHh6WwcFB2bt3r3z729+Wd7/73fLggw/Krl275P3vf79EUST/6T/9pzndg31QMwzDMAzDMAxjQaSpJ+k8jTwWux0iIocOHZLubnzJUygUmlURERHP021P0/SMv73S8fz3JElk2bJl8pd/+ZcSBIFs2bJFjh49Kn/4h39oH9QMwzAMwzAMw3h10t3drT6oNWNgYECCIDjj17OTJ0+e8avZaVasWNHw+DAMpb//lFpqcHBQcrmcBKQs2bRpkxw/flxqtZrk81pZ0gj7oHZWzOaeuNCfqS+06+JCrznX+rNJRM/e9ZFJEnJgS+Cow46HIiIzdUhyWH4VkXvYbv85VWdl7rqsPJpAAsMudq77GEshWcLC0pQTMeRNLBcR0XLHQLRT22nK0aj6dy2BvKc9hKyS5R+9OS0FGK3ty8pjTSSePbnVqs4ucqtrE7TzZ7ogs/n7qaOqTo6khzlBv0/TWDdzJRMR6UlwP+zqtbFDf0N2iNzHjgv6Y8iDFIUd6IpBr6pficezMo9VJ92n72hjJ31IW8IU98nSmjFfy2nu8CFnezzZmpVfrj6albvzut8vTzEPSx5LeiHbYZmbiEhcR/8uF8zJZz1cc2WqXT1ZqneUpEsMz8998Vb1WpeHNbc2gWxwn0/OjgXtotVsjr/s7c/KP9+l2/nlKbRtKsH4Hooh4V0r2l3rp5fjsffkCMbxu2OQNN3qSMGeTyEZDQX9W6O5y3NSREupmjmO9garVJ3LBW8I2mLsLX89+tWsnA8g8er14FopIhLSt7traf85WMe9JZ6W4C0ht9xv17+Wlff7mHsb61epOnW677JAuhx7mO+rE72fDXuQ50372KtHY9zPjOg1wuyowyY7pH3XdVNkl8HxAI6nyxLse7lUz7XtMZxNO3MYA97rr5Kbs/JgoCXJj0aQ8a3N3ZSVJwRzsk8GVZ0jJM+bEMjP+0LISofr+1QddqQd8iELHRfc501yu6oznaI/eO50k9S+LjVVZyzF3l0OsM/8qIz+cF1OV4aQ2vJzrZnc0R23UoJnzyS5cvJztBBoaXyV3iaMR2gbP/tcl+NUhUvgmuyouSSnzR6Gq3CXzAXYT9IA52LXShHtCJmmzd7PeM6/2OkxbnKcSSLPBfl8XrZs2SIPP/yw/MIv/EL294cfflh+7ud+rmGd22+/Xb761a+qvz300ENyyy23ZMYhr3/96+V//s//KUmSiO+feg7s3LlTBgcH5/QhTcTMRAzDMAzDMAzDWCCpwPnxQv4/n4+z999/v/z1X/+1fP7zn5eXXnpJPvjBD8rBgwflvvvuExGRBx54QN7znvdkx993331y4MABuf/+++Wll16Sz3/+8/K5z31OPvzhD2fH/Pt//+9lZGREfvM3f1N27twpX/va1+QP/uAP5P3vf/+c22W/qBmGYRiGYRiG8arlne98p4yMjMgnPvEJOXbsmGzevFkefPDBzE7/2LFjcvAgfu3dsGGDPPjgg/LBD35Q/uIv/kJWrlwpf/qnf5pZ84ucMjN56KGH5IMf/KBcf/31smrVKvnN3/xN+a3f+q05t8tLT0e+XURMTk5KT0+PnPpB8EIFLTo2WBeN6+N8OF8/u3OfsjxnrtekZJGUbHJJ26ZGB4uITsZbjyAPCh1pS1cespVegazraASXMpY6iYhM1yD16aSEpiX6e1sOzl/tAeQaIiJTEbTPAd0PJ/2crGt5YUJSDj43U4u1w19XDvfD52PpY19eJ6+uC2RebR6kKbmUHLU8V9qCvl4jV2dllowdiJ5Vdfi+b/J+MiufoIS5g8mAqjNCLpKTJDfsjyH1eTmB3a7nrOUquX/2FtdnZe6Pfk9LEhOarydjyPFYquTSS8mWl5FUb1sCiVd/bqOqc3mMf5cEEroxHxLYXnJCFBE5EWBM21LM65pHkqhUSzCWUp9uE7hY5mmOV2LtcsiwvIjXBTuz5T2d3JjnzsoEc3KXD5mt64zKro8v+3ChZFnXz3bpPhwjldf6DrRzoIj52l/QznmVGOP49SO4n8djXHNpqucEc5ikwvVkJiuvDLT7IDsTTlDSYCXHJRfby4pYEyJ6LRz1IfGeEsyPLtH7AiecHqpj7rI7Xkeg11hCz7scOVWuiiFnHfK1uyTvBytizP09PvZQ1xmx08eeeNJxnj1N5EjO28hNsRhgb1qXQL75MrkKiogsDyDTrHsYe+6Pq/3XoS2B3nfH6pDdDeSwV/KcZjmhiEiFpHIsc+sMMXddOfBGkpPu89E2HtMbQy2n/Wrlway8JoTzbLO5JqJliT10vuEartmf1+uKXYa5P8cF5+bn7eoQMu5Tx0G+yYms+dnZ5mtn5ZHqHrSncFlWLsWY+yw1FtHS2CLJKnmulCLtWMrPId9rLNGerOxV/2anyIRCErTrY/Png+Zs3w+d+l1rYmJiTvFZi8Hp9+X/z8Z/K8VgbpK+c0klrslv7/38ee2Dc4X9omYYhmEYhmEYxoJIpUVcHy/YjziLj8WoGYZhGIZhGIZhtBj2Qc0wDMMwDMMwDKPFMOnjvEle+RDjrNDWtAuLhWM73Om6jpW4PAf74rEctMsn4xezcuzEPUxWob+PctC8s67dvU6BYiXYuj8hu2TWu1cTHTtWp1iUNrJpn6pD889W0qfODf17OUJ81vrclqw85B9UddiCfnUOMQyHaogXKyc6HoljkNqoD4Zj6PQHgo1N65z0DmflnyrACn1IdNu4T+sB7o3tpMe9GV3HQz+Ox4gLqZAleD+1jWMrRETac4jH6Rf0+0GKnyulJ1SdFQXEGnUGiDGppIhDiRJt385xbXs9zL28jzgutpwWEdkb4ru1NRQPxOda5uv4ypsoRvOlEubhUR+xkhzDJCJSDXBcXwpbcx5fnvvLU21nvaOGOLu6j3P5OTxy2OZeRMeyXE7W8LUU41v29VgP+bjvogfb7DL1+yOTOt5khSCu7dZ+1L+iF+vl+LS2Af9fBxBzEXrYWzjOri3R93Oc4pg6BLFWqY/rj6SHVZ3x8n7UyWNtq1Qb4dKsPCYYw1Nta/xI55idtkDHa4w5c+w0nPojTiP1GqclKVFahCRE36xM9JzYJc9k5W4PfTCYYi0eTLepOjyvl+cxjw+Xn8zKHAvk4tF30Rz76calclxa0iS+8oD3UlZuEx0rxf3B/cl7Qei0s0r9y5bv5Rjz8CfDn1J1Dnl4rVN6szKv338u61QZ3AcnEsR0FWif4fQxIvq5xKlMLg9vy8oHoh+pOvyMq4c431QVc7Qjh7l7LEbcpohIjZ93tAdzfBjHRouI9FKKD35GVSjOuMN5RrKlPseLcr8vy+l0FOV0ouFxpRrFHTprJKU5ls7Zw4DfV/LvKBePlUSSnvr/QtMKbVgs7Bc1wzAMwzAMwzCMFsN+UTMMwzAMwzAMY0Gk0hq//7VCGxYL+6B2UXO+bPPPz5TXcse53luz4yAhYDtrEZHhPKRubH/McosqWfWLiHgefnyeqkLakid7X7aFFhGpkZSR5WwRyVzYKr8t1LbqfWQ3PF6DJJCtk9nuWERbO7Pt/rhA+rQyvVzVGSIZ4okYFtgb85C5HE12qDpVspYeovKG3Guysmu1f5N/V1Yu0tbz/SrkdHfTNUVEvkVyqZ0ppDadHqRg+5MXVJ3lHvqNLfBZ0rQ0Rt+s9iDtExHZ6+Ne2cK6QJIxngMi2jq8O4drxqlOUcCwnIbt/ss+rjlb/Z0+5JL9AgvrJ+VpddzrK7dm5XaSxl1OksYn08dVnTYf95p4lKYhXJ+VT9bRT1GgpVO8Xhif5ECu5JTPvTPFfGfp00C8lKvIcADZHVvDM+2iraI92jKKASRJd/7i17Py5//mXarOEcE6G6O1NEMyqJqv5dIDCebBep/nK861s64t5/Mh9gZeYyx9ZOmVa2ff68i8TsNzd2mi+zAMMCcO1ZFuICEb82o6rupUBf9mmVwaoj3jlBpDRKRcJXktDUkxhb2/a6Xe7qM/jie7pBEsVXYZKkNKubwNEuurkqv1ccl4VuaUHkVaByxNd6XgPFZs/86pVHjcREQ8WossWV8Z3IRzOdmTVnq9WfkQ1amR/Lsj1OM7WcP+zvPoigRy7afi/1fVCUnK2UF1pkXL8xlODcOpWPhcLMdPXKlg2lhyynugm64g9ChdCO2ngQ+Z6XL/MlWH5xGPVT7EM7ot1al2JlNKlRHhOinvz47sOJW6+tfZY+E1xilM+mgYhmEYhmEYhtFi2C9qhmEYhmEYhmEsiCT1JGmBPGqt0IbFwj6oXdTMVSp4viSSCwUyJI+mZipRo4NnhV29klRLkibqkIL4JFdgFzs/pyUWOSXfGEeLyS2rVNMObKo9IdrDEsmQJBqua+R0qv99mpQkIyypFBEZq+7Lyt3kFMkOX0dlt6rjSlCyv7NU0N+gXjscQyKlHOA8yEJcZ7VJcmO8rhMSzb4qzv1Q7YeqzhsCSCEP1iFH3VaHgxvLeUS0XHFlDEngiyTvqwZoy4pU3xszVEdfsay0kNMyVXboHKvuz8qBD42XKweMI/T7RIj5xq6evaGWZbLT40m/8fxo87Qj3ffiH2TlHg+Sz+UJ7qfN13V6E9xfRC6HMzSGfM+1SEvBOvPod5aJjkSQS/q+liT65MQZe5ANdaYkvfK1jLmaoj0lD3N8M0kAj9S0U9zlHVhzHSEkY+FvfSYrd/3dt1SddyyFnGy4ij785hRc306m+1WdQorrbEsPZOVJD9LJ/ryWZcUklyrS/ZyowSGPJWbLilrCdyzCcX0hXBfZpbDqaTntMpJCTuUw32q0riaq2o2V5YbsGtsl2NuORNtVHd9v/HZjn4/jVvnXqNdi2vtZXrisuDkrj9UPqDrVOmR33UWs7YEUUtSXfO0u2UWunL0JynvI5ZTleFHaXOq7vIh7YKfbKacOSwL5OcBuiNOhXlcdKcbxWILjBgPMg+OploguLeC1qRh7y7Ppd7KyK9vn5xo7106n6FvuDxGRiqCt0xH2Jnad5D2ju4Dnk4h2xU3ItZndR5cWrlR16inqeB6eN8vzuOehZL+qM12DY28ugEPuMnrGHXNktuxoyXUS6ifXKTptKluf7QNEK78/My4UJn00DMMwDMMwDMNoMewXNcMwDMMwDMMwFkQirWGD0gptWCzsg9q8abWfqPnHUTe54vloa+D8e64JHhuj5Y6zSTf5vhM6KqUjtIyR3aVYblEn97KCkxSW3aY4eeVAHg6KrhPYeAWymXIdcqfBtp/MyizTqwdaOlGiJNssE+MErywHcmH5Ca90TvIpop3Jlgbrs/KBOhKn9uS0TIXlhuzKtYRkVLVQX+dgArnRkin07+v6cT9PjWsHt+0x5KQbfEj1bpY3ZuVnom+rOgHJCA/4GIOlgrE6EcFtrx5CpiciUknQpyx3rFG/sUzWhWWAPnV8e6AlmnlyLOOksixFbRc9D/cHuJ8VMcbkeHC44d9FRHICOVuQYp2WPMw3lhCKiBwk50uWUvq03tjtLyL3NBGRSjyelYvKTXVcmsHJtPMBZH+rU8idqp6WMbLU7pYiJIn7yjhubbGo6mzoRP9eM4g19tUtcH2sJ7pOTw5rfjpCH7A0r4vmp4jIXnIj/anw9XTu9Vn58UQnJ15KTpzsLsnysUGS/bE016WQQlrHcjqW/YqITEaUmNvD+mVHWXbRc+G1wAmVE0f6tTp3A/5B2zjPd5bziYh0BRjTq8M7svK4BzmcK93uJEnd9QLp9C5Pn5uZIlfPo/G2hsd0UfJq17GUZYCcoJ3lq247A9rHuX4lxv4xXNPjO0FySZa9D5Hsll1SRbScdnmAtTQjJGlMtHuwp9Y59rAcJXifio6rOjzevO+x3JEls3wuEe3aGMeQufN53X5nemgfH48xp8v1UXUcSy75PqNZQiwC6gNX9nqaM6WOzUJTDOPsMOmjYRiGYRiGYRhGi2G/qBmGYRiGYRiGsSDS1JO0BRwXW6ENi4V9ULtkWJjUUDMfGeO5VATPJt1s5hTZvA67M7GMkKVcpfoJVWdl7rqsPJ7AAe1EBTKZdYVbVZ0Jj5zSSPZyMoachd26ar6WCk6T3IIdwuokC/HS5j+Ks8ST5YmpM1aciLXiQQ5zRXh7Vh7ztMNgiWSV3SHkSTtqcGPc6CSvPkbJUvcFcKeMR+BOd0O4UdV5hGSNIbnG9QgS4a4Lb1J1Zjz0T3uK4/qS3qzsh+g31+GrGeyM6EpwWHYzEpN7GTn0FUgGJaLHgROfc52hZJ+qw8lbPZLTXBFD1tkZ6G19fSfW82OTWgaUndfT/c7uncyyeDArD/v7Gh4jop1AeV0VHKc3dU1yY+P+XEPSy3qqpaDtAcaxgxRfhQru+WBFyyWvTCAj7u7GXPnG83Dr68rp/ePu1ZDg1ocgD1xC7phHAu2MyOyqY42xXPLa9Hp13LMCh86pCtwyWT7KDpCeI4phSfIwJQ2vkfwscZJkr8hfS+d+KSuHSu6opY+c9LczD5koz2NO/C4i8s4+OJb+xTD2CZa2VaMpVYdl2Z0k5dxB7XSdANkxsER7/Xgd/Rk7Ul12z1wZoj9WJHAPDWOst+2B3qtZrsiSZpbg8boWEcmHcA/k/blKc2WwXe9tpXg4K/d7WEsjKaTPSvIuOgF2m6Btk7Snc2JvES3ZrJFrcimGHNdNts7rnOWSVxQh9T8QPZuVx2t6vfhe47ejxbC34TVERLpJGssyUT6uu6Cl7ezgyDLRGknB2WlSRM9RdjPm9xKeI29s9g6E66eL+r7NuFQx6aNhGIZhGIZhGEaLYb+oGYZhGIZhGIaxIMz1cfGxX9QMwzAMwzAMwzBaDPtFbd64gYqtZte/ENzvImazx3+lv8+XuVzTbQHHAEAHztb2LglZ7Xb4iO+YqWud/7QgboDjxaoRNOqH68+rOv3FK7IyWxmznfW4IC4ndux92cqY4diRimN33kw/nyf75yjVMYicooCtjIcLiK/4l503qjqfH0O8x3AVVvd8/X31p5y24Xsh1vy/7KNvu1Jtcc621fuT57Iy20z3UpyQiEjZiR85TUDX57QIP5X7SXXcCzHu7XAEi3VuC8fOiOiYtdUFxJUcqT1PxxxVdQpkQc8xXRGN21J/g6pTpTiKPRQDeU26JSsPxzrNw5EJ9PXe9JmsvNG/OSuvSHTqgAM+5gTP/TEf82Ojh/ojobbq5lgWnqM8J/uLV6k6V+ffQO3BGjmSIm4yOCN+FmPyg0nECRUoncYtPTo28PEh9MemXWjDZZ34+yMn9P6+uh398+QIHpuHKE6P0zqIiEzTHnIoh7iyy1PEu77sv6TqzFQRg8TxSRxrua+KOLbuvI75axaLyv3eFvapOqPR/qzMVuo65kh/pxsGiEvj/YOveXmySdX5x1HMf97DInrc9Bcu4yoqbcQLFL93FaU72FV/UtXhuJ8oxP4e1xGXNlC4QtW5PsU8GKI0HO9ag3nwJWwLMl7V8VV8Te6Dch3j2V1Yq+r0eojhG0/RNxyPOEXrSERknYe5c1QQk8Vxxm7sWI+HOK5xDzb8nale88zRGvY9jmEsUcoIN9a5EGKO8l4/Ikfo71i//BwVEYnpWcxzVKX6CHSsJO+7nNKDr89xk6eui7nLsYW8dtzUErmA4gk5vpFTLrgxdiodA9qTzpIG4FIgTU/9f6FphTYsFvaLmmEYhmEYhmEYRothH9QMwzAMwzAMwzBaDJM+NuRCSP3O9vqLUWeu8PnO5XWaXZPlTnO1s8VxcTLtvIbvJwokMxmrH8jKrjyIrYTZDvq4Iz1kRqt7sjJbDLd7kM2xZGbckU6VapDDdBXWZOUlAcolX8u6pmqwEWcJzFQd0jS28BYRmSF5TlsO9z1C7f9H0QyGsLMeC9BOluB0hlrGmLAkKYHMhW3rR6K9qo6WX6HMKQ4K/mZVJxKc+2QKqU7BI8lLChvwrQnuU0TkBp+s6mmHPBZDvlah9ovoPj1chQU1y4ECT8t2Qvo3yyA7A/TbjOg50U729CzvmSQp53LpUXUO+ZjXKenMRnzIblemWgp2eYo59pKPex1PMY+GSap0Z3CHql8hWdQhH/NrbwQ5bMmxEZ8SnHsPrfligHse8LR8bGeyNSuv8HEP+9P9WfnAlLYeXyaQC35wD2zN2Vb9jW2Xqzr/4zD6d5mPtvFcc+E1fz1JU0cofcRoTac48EhiyLKu9R769xidd6Xodh71sC54L+jII60CS8lc8jRfq2RR3ubIsPtzWCPcztuDf5GVd/g7VJ3pBLI7lsPmSVbmpr3gPeS13muz8mMx0nawZE5E27yXIqx/liR3pHrfHEohd5z0sea+cAhzp+RTCo3UHffG33kHJO/LeVrqVxL0R9Gj68RYl2001iIiJwRrebyyPyuHAc7dn9fy0ctoLR9PsT+XPdzziXinqtOZQ1qCawXy64ciSKfdZyRb2gckbWWJZE8IuedoXc99NW41zIPOPOz1p520Oe05pB7o95Hm5USE+6k6z+hmMkZ+XrqSYk7XU4uwn3m0hyepK7nn90pztbY4X++vzh2JeJKcERp0YdpxqWC/qBmGYRiGYRiGYbQY9kHNMAzDMAzDMAyjxTDpY0MW+pPzfKR687l+s5/Jz6UjZbNznbtrenTudB7XSR0HJ48kdLUIrk++B3fIZfkrVZ2jEdz72IlrVRs5/JWfVXWSFLIK19HxNBMx5F6e870Jt2eaZExenh2ktKSiGEL2NlOHPIddBWeiEVWHJYXs+shymrpUVB2WHnaHkFXVyTGNHbVERAYCyKXKJC+aSSDHcd0UWbLJ98DOXaOedhz0UvTPa7xbs/KLHqRYPjlfTiXaWe37HqQtv9pzW1Z+cALb5YlUSzQDchnsJXc3/rvbh8tTSHVyKY474uPcfTKo6pwkSV9E8qthH/LTUU/Lg1bEkPFMCubRSB3XORRoOewUjc+GGNKngwGkgrzNPVx7SNVfkoPcan2Ccd8YviYrn/D2cxUlh2XXNZbw1UMtL2KZqE/rh9db5GmZ2glyy+wSyLd64t6s7O4y4+RMOkqStV6BROxgpNf/uhzkjhvaIJHaXn4R7SeJmYjINMlBE5JiPZ081LDOSSErQhEpR2PSiIDWuEuSwIWuRtLlXNjT6HAR0fvOVbTGjvpov3vNog95X5DDa7xPRLFeI/kc5KiP1r+BtpEDa0eoZYw89izzXJ5grlzZpuvsKcMVs+qhDccCtK2HnFHbc1rWzbI/HjeWv7K0VkRkSQLZ3oSPOeX72GfGyrtVHc91FvwxfTms0YF0pXrtIO0HI0JSX3JMrUZTqs4WD06435PvZmWWGrpuilGMc/AzhceK5a/FoFfV9z12LK5JI/j6IlrueLAC909+dnmOYynL1PlZ2Et71lBlu6rDskiP9nQtd3R/9+Bn88UpY5wPSXrq/wtNK7RhsbBf1AzDMAzDMAzDMFoM+6BmGIZhGIZhGIbRYpj08ZzQTO7oJmudjyySOVeOlPOpf+5+Z26WyPoUc+lD3TaWQgZ+B/0d1xmPdXLiJQVIS0YrcAnMFSGx6HESmk7WIDNh6cQMOW9xImp2TBQR6S2uR3vI4atEUjB2sBLRkhF2epuuQf7itpNhd6uIkt9GQXN3u+Ea5Dks3+SktiIiowlkWiyLqlMyXjfRKMtRJilpeJ+PJK6FtKjqsDvj05T8ulwfz8oso2TJjYiWK/712KNZebkPN7Uk1fOug5w8Ew9jfaKGhMZuf3Bi7kTIkZLcP1dSglsRkdjDHD2ewNmMJUXsCioicsjH+ITcV6TM2RPr5ORhgraeSHAPeYFkrBqjnW6S3eNlJMw94W3LygPkmMp9JiIy5UE21+ZDdtcXrse5ajpBdJWc+IbIxa6LJJGleFjVWUZJxFeSHG6nj/68Itb9Xif5JCefrpKcdUlunaoz7UE2960K1hJL4IqeluClIfqRZcQJyXk5kTYnRxfRUrsgxDyukkyNpY4iWmrXQa587SSHdWV7hRTrZ4RcPTk5el+qZbszJEHzaR+fqO+XZhydxrzM5zBfWHaX+HrPUHJYWttHfTgJTle01Dek9vjU1+2CsZ6muVata6kgz3/ew9ZSUvgo1f3OcscSrd+YJMCutF1LcvEau4+O+dpNdZLk9St9JPbmudvrPBOejL6VlTkJ+s25e7Lys4mWO/vkgMhyQ3b17RPs2/vj51T9gGSd3Ic9AeoMO06RRygkga/J8saCs8amnf3gNCx3TBzpJUtOU+H5xr91zNXZkc7rvAW/JJJht0jC60tJbWq/qBmGYRiGYRiGYbQY9ouaYRiGYRiGYRgLwvKoLT72i5phGIZhGIZhGEaLYb+onRXzyRo/n+z0lxrz6bdmLEYfog0R2Tf7PrTslWhcmEIer+VDxC2wdXhb2Kfq5APYUVfpfNMexRNRDFZZdIwaxwBxGoBjlRelGWyRPE327Rw/wHFoIiKX527PyrtSup/cQFaeqWtdP8cDLKW4o4C2FI67EBFZ5q3PyqNkE+97zdMNcNxAgfp3PEa8yVVys6pTpZimoTris6pkoS10Ljd2jON5OJZtJEXMYWcwoOocqyEOi+PqCjQH3Fi47gRxWCt8zKnIuyIrL81pi/NCHTFESYC+OljdmpU5HlFEpC2He2ULfI5v8pzYz9RvvM44Nmh17oasfKT+gjouShHX4nvowxrZWXNaBhGRewp3ZuVn6xjfAzXc20D+8obtEhEZjNHvO1JYdXMaAxGRaoD7LlFsD8dN/lPpy6oOW+LzcW0pYrcqnrYrXxMjZi2ieT3hj2fl9lTHz2zyEAf5bEApQVLEGfH13bm7wcda4Fil0fqBrOzGgS7PX4O2Rej3nId4Rk5JIiIyTn3KMWEdgjiyKU+Pbz1FTBTH4xYo9qxS0/FVQYD+DWgP43XJ8YwuHOfn+ZjjFU+neaj5iEkqp4gt5PQLYzFibF3Ld/43W9MPe4h1rqX6mrwWec3yudyULZzypaugY1FPU031PORzjxQpxjTBcaGn5xH/u6ewKisfEsSIRcm0qsNt7Qhho39FcnVW3po8mpU59u1UuzEvO/Lo96MVrIPAme8+xY6FNCdWC665O/qhqlOjVARJgjnJ6SjcNAgqBle9hZnt/chsKZNOH7FQnwLj1YB9UDMMwzAMwzAMY0GkLWIm0gptWCxM+mgYhmEYhmEYhtFi2C9qZ8V8PqLP9ln4XP3s7f7MfqG/WpjP9ZvJJd1zLVSOijoJ22H72vKdLdtZesTDW2ZpnYj05mF5XCHpYI0kjccjSMZYoiaiJTScLiDw8w2PEdFSIX6tmX20iMiwB7kTy27K1Oa1xdeqOgcrP0B9sudfnofkpMdboepMCM43XjuYldflt2RlttYX0XJHlsqwZGR3oGV3bQIJC1s+s5SzN4RsaEkCmY6IyK70iaxcjiCTW1bAvfF8EBHJB5AUsaQvcMaH2U+29Z3JLVn5arJIf9Kxo/Zpws0I5lH7LDJVlozxfG0LITljy3cRLalrC3BcKPj7pKBOf36jqj/q7c/KLDViyRufV0RkvI4x7U4gGWUZlSsfW5fAbvywvzcrRxFJPOOKqlMP8RqnLihRH7DNvYjIdITX1gWbsvJxH3K4WPS6OhZArnizj/65sYB7O1rWz4DpmGzJfdw3pyGISXaY97V0ki3fO1Osg3G2S3fubTzCPawMIIMcSvZn5QpJxEX0nFJpM8hKvTvV19mXQsLGY6/mRF7vGXyvLHdkiXRd9Ph2C6SY+bCx7DYveVVnKoG0s8tH/cP1xjJzNxXDGElLuc1tgrGeILm2iEiljrFiCR+nRXH7I0fpXFhqWIrQfne+897QLZhThyJIuVcUrlF1RkkWOVrDHsTPHnFScixpZwk89r3d3k6qgvmeOJJk3uuna40l+CyzFREZruLcAcm1Sx72RldiyXJFfl6ydLIe63uLSbabqufnbO85Lh0zC+PCYh/UDMMwDMMwDMNYEIm0hhtDK7RhsTDpo2EYhmEYhmEYRothv6idV87lZ/zFdFZcbBbattnqz+d8XCdoeAS7J4qIlBM4gSn5CblGhYF2pKokkF/kw8bOZHW6DruAiYjEyRSVyaGPZEwsCxER6c6vbngddqd0nbPYFU+7maF8rL5NmDDowPlIBnWytlOawfJApuxBmuJKW1hW1ZUfzMosRWNnNxGRCklL+0iiNNSkbet8LcEbJRkfu1geKcN90O33ch2yV5YajVchK/MdJ7HVbbdm5R0p+rcaQXbUE2jp02QKmdhSgbS2y4dsaLKg5xrP3YTkSjFJeFypH7ue8r2xbI7dOkupdgVk17jIwxpJ0kiacTzFuB32MVZtHu7n+vQqVeekkEyMZGYzPvrJdbRkmRpLNlnu6c6pYtCblVmympCUa9C/gqtIIYF8+hv1h7Lym9K70X5HlnXA30HtRv+ynO4q77asXBW9Z5RJ3jckkBfzuVzJ2ZIc+uBg7dmszOuV3UtFtJNgb3F9Vl6a9Gblp8jhT0T37xSt6ziBk6G7RlzXw9OwDLLD0+t3IuFzY46zXNKdr7wH8t7SjC7RMvVaiH5nd9sZD3u462iZJ7fLKMb+XqD9w5UH87ys01iz3NF1pOwjF1xe/yxjdB16Z2okBSV3yTo9hzoLjZ81p9qG42IPY8Ay6M78KlXHlWxn7aS9xJUXu2v7NCPJgabHBPSc5vnGEkk3PCCl+27+nsNtS7P3e632/sxodeyDmmEYhmEYhmEYCyJJT/1/oWmFNiwWJn00DMMwDMMwDMNoMewXtXPO+UpoeKG/PpjN4aiZ1HC2vnnlZJGLA9rg8XJwJFol5UIF2UszFy4RLf9SSWrp72WSA1UjLbfMkbyQXQ5ZulhzpFN1JdEAlxWQ1Ppg9CP12mQN7l8dlNh3JkEfuO6SnMA78XAcy/5q5BwmovuAZTcswXOTtXJCcD6uPQ+HsZH6XlWH+5frsHsgJ/b9Vqrr85gyvUVIxFyXxBVt12XlyQhzheeEm0T1RO2lhtfZGL4G/3DUMyUhpzg697gHqdJgoh3pxkkGOCKQBLF8jBNZi4j0kIS2EkM66TqbZs0k+ZqISFnJaWnu0P2wnFBEZCSAnO7qGMm0Z8jVb6d/WNU5kUIimafk0XeGb8jKz6W7VJ0KzTGeByw9vjy8TdXZnzyXlWPampYHmId7qk8Iw2thbXh9Vj4eYc0OBVqC104Jo0/WIYPsy62ndmIvqHra4a+QklstbZshudgOBlcLM0ZJ7hktl9RSsDDA3On0cJ/7Aswvd+7yHOP9JKZ+Tz1difc9TiSf0N/LJJkV0ftZew5rnvefqiMz7wkhw2PX1imSLi9vu16awXvOyXR/Vq5EaBs7DIpod0f9d+zhdd9Jku3IVk9TJGm9u1eHKfadkzFcTtkx1JVLslSfx355iPl+uPqsqsMSy8hDO0dq2F9ZJutK/XmsWSLNCc1dh88wwLxm6WKVHHF7C2tVHd7PmsktYzrGbZuG35u4UkfuU0tsbcwf+6BmGIZhGIZhGMaCSOXC/2wg0hptWCxM+mgYhmEYhmEYhtFi2C9qhmEYhmEYhmEsiFNmIhc+2felZCZiH9RekVa2vb/QzNY3XpPyfDg//c46dM/TFvZJihgcti5vKyCmJHYtfUmzzvEek/WjWZnjpgoFbYFdJZv5lG3VOaYj1bp4jjVgy/WjCeJdio7VNmv7WbPPMTZujArH6bF9Mltwx048xVKyrd6fPJWVxyPEgVzn/6Sqc4QsxhmOLeoKHQt76t+ReE9W5rirGo0Nx2qI6HjEfNiVlXk8XEbr+7NyP9mdc0xJzYlBjCiekMdqf/xcVn5D+CZVh+3Pd/gvZ2W24N+VPsVVpEC29TyOAf2d40tERA7N/CArt+eRMmFJYQOuGSOWx42NTFPEV/J85flZqh1RdYICYmtSQZzdMR9xT5yuQUSkQvM1yWFMnyGbe3dd8vzozq3EcQGO60m6VJ21PuKTJnzECfbH/Vl5vKDtxnm+sFX+CYrp7JKlqk5/jL4epXXVk+A6Iz5i+Y7OIGWEiMjK9i1ZuU0Q21MVxIexZbyIjhViq/xyinjEZQUd13aisj0rHy4/mZUDins8w+Kc4o44XrObbN5de36eV2zNzvupG7fFMVrchrDJPiWi49LSFM8BtqbnPWdS9DzkVBUcaxwl2FtTpz8CH2uE45F5P/Y8bfme97BXcewWMx3ruKsDVYwP900nxSOX6idUneV5jPeKGGtkjyA1RX/hMt22FHHHHD/L1+TxnHHifDnONRdg/XEqhOOxTrHCeyrvLetyWAfjou9tuna8YZ04aRwzeIpmMfOzpfppHJfGsfCpNE9XYhinMemjYRiGYRiGYRhGi3HWH9S++93vylvf+lZZuXKleJ4nX/7yl9Xr/+bf/BvxPE/9/9rXvlYdU61W5T/8h/8gAwMD0tHRIW9729vk8GHt5mUYhmEYhmEYxsVBmrbO/5cKZy19nJ6elhtuuEF+7dd+Td7+9rc3POZf/It/IX/zN3+T/Tufz6vXP/CBD8hXv/pV+Yd/+Afp7++XD33oQ/KzP/uzsnXrVgmCxpnmLxzzsZafK+dKVulKDc/VjJ3NQr/xaz5ZnyeOffvc2nku7w3ncmUqObISj2LILcaq+7Ly8uK1qs5YHZI+lhuy/XIphSyjLw9Z2alrFqURCckdXdvgSg1ykirN1678II5xJHy+j22gSlKyaTo32/a7LPchgdlfg+zOlTF1e+iD28J7svLW5NGs/FL6Q1VnRQo76LIHacoaf3NWPhjrdANMgSQ0LHkr0Hi4aQR6yM7ZlQSdhtMLiIjUIkgPxz2MexTDTprlTSLaHp8lQSyJ/GHwpKrzb/uQZuHweG9WLguuX3CkrWVOpUDzupRirkyk+ouykNrKKSC4nKdj+F5E9P2wTLZch5zOle1OR2jPtgDzaGMC2WGY05K1IHc52pbCyjyX4rg20f2+LITU7lAK+Wg9Qf39oU7Z0JVC4lwiadmLCcY6SJs/Tose5mE5xVhdnug1f9xD/3T6kEEOC8nuapjHbKMuIjJah0w0oPXH8sCpVMv26rSf8Zgsa8MaG6ppyRnP/86QUnpEkIW66RdYgspyY7ZLd2XIzPIUcthxkp/OxCPqOJYR85hy21LHSp3l2zyXOR0Fnzd0pPFs/c/3ydLHnNMfiToO64Ut7LnN7nWXp9inttW+Kc3wzpDknWKKJN7djmx3TYxzP58+hjZH6LecIzkfFcxLltOylJPL3J8iImV69rSFjeWO1VjLdjlNRE8O67oukFFOOXLphKWyqWup/+M/O5LE5nLF2ez5G2NyR+NsOesPavfcc4/cc889sx5TKBRkxYoVDV+bmJiQz33uc/I//sf/kDe96VT8xd/93d/JmjVr5Jvf/Ka8+c1vPtsmGYZhGIZhGIZhXFKckxi1Rx99VJYtWyZXXnml3HvvvXLyJJJ6bt26Ver1utx9993Z31auXCmbN2+Wxx9/vOH5qtWqTE5Oqv8NwzAMwzAMw2gNkhb6/1Jh0V0f77nnHvmlX/olWbdunezbt08+8pGPyBvf+EbZunWrFAoFOX78uOTzeVmyZImqt3z5cjl+/HjDc37yk5+Uj3/844vd1Hmw2NnlLyER7ayuj4Dljq6zYqrcu+bisrQYDkrNzq3Huh6PZ2WWsLB8pSPVMqSZAE5iLIdhKdh0FXKR6UC7dYU+pI85kozyudihTESkkIM7HMtMWO7Y5khOJquQVQWOhO00ebq+iJYRDnn7G9ap1rVsZ08IieIdweuy8qrkmqx8Mtmn6hyOXsjKLCOcISnnZf4tqs7O9ImsXCPpUT1qLPHKO5JEdjPsz0PWye6USarnWn/xKhxXO0jHYU4nsZbTshvaqtx1WfkESX0KnpaC/dM4+mco3p2VeU647pTsbMjjxq6cLMcVEYkT9FUhBwlerY6+ceWfDPcvyyBZquTKJWtqvo5n5ZE8vuhrT7Ub46HoeZyb9hN2cOyTQVWnkKLfCyS1iz3UYRdNEZGpFG3oCtAfqwQSsaNB8zhrdgxcEsJJ8On4+03r5Dz0D/cny2zZ5VFEz4MxkkGyux3vC+65ef2fKGO9hr4j26U1U44wJ1ju6LuOhfS9MO9HLBt05y7LeE+SpDgn2Bt5HYnoedXhYz+ciDD3e8KVqg639XgZe06hiYyyHEMSKaLXQluI9zY9ISSFQ+SUKaL7PSSJNssGXdlid4i5vDd6JiuvKGL/cGWqvO8NtG3KyusTyMqHRDswPpN8OytXac2zA+w4SftFtGNogdxyWVo/kIdUebiG/UtE9wevf4YlkS6BYB4crWMM647bLr+F1yEO/LuF7nc3xKBxnUvpo4HRSiz6B7V3vvOdWXnz5s1yyy23yLp16+RrX/ua/OIv/mLTemmaiuc1fnP/wAMPyP3335/9e3JyUtasWdPwWMMwDMMwDMMwjIudc55HbXBwUNatWye7du0SEZEVK1ZIrVaTsbEx9avayZMn5XWve13DcxQKBSkUCg1fMwzDMAzDMAzjwtIqjout0IbF4px/UBsZGZFDhw7J4OCpn+y3bNkiuVxOHn74YXnHO94hIiLHjh2TF198Uf7zf/7P57o5FyHny8FxsWnWTtxPmlb0K16xyWvNk0o2lyTMlWbSBd1+bg87ebFr1N6qjrG8NfezWXmXj0Sh41VIHDsKkOC4SYM52Sm75bGUxJWPuZK807hJrhmWYnISUna3rJHsR0QnnGW5FUuAtNBPZIrc6h4JIa3pJCnZT+d1wuuXqT07E8jE2I1xb6DbxnKj4SpkQOxk2JFDomF2nRPRSVRHU0gNZ0sQy5JCTqzNMkoew1P/hpzuCPUhj2kpPqnqdAUYK07CfCTlBM86ATC3gWVZLK0r+2OqTi1pLIHlRMWpch9tnng9IqldZx5j40rjXLfKrC0p1kVBdLt6SUZYSSGbG0zhprg3eUbV2cXucjT32U11xkkazPsMyyVflqfx91TLVN9SfE1WfpRkWTMp+tpNCs3ugyzl4r5a3oZx3xBr18iDJL9kJ0GVBDrR+24QQNbMa15oDEPHgZbnGLvtscx0yElWz/sbO1Iqh9BQh0RMc1JkercyRgnmi47zJTNSQ8J7ljgHjlzSnb+n4fvsCLFnzKRa1s193edBhniEJHi+I/VPpEqv4eb4muuDG1WdfXUkOGc5PLt6coJ5EZEcyRBXJRuzMjvsVqp6D9RulajPez2vcRGdAJsT0/flMEenaD9zXV95b3Edg0/jrhe+b3bv5T0nSfVz1XV0zq7P77Wce3NDDBozW/jHxfK+zWhFzvqDWqlUkt27oS3et2+fPPfcc9LX1yd9fX3ysY99TN7+9rfL4OCg7N+/X37nd35HBgYG5Bd+4RdERKSnp0fe+973yoc+9CHp7++Xvr4++fCHPyzXXXdd5gJpGIZhGIZhGIbxauasP6g9/fTTctddd2X/Ph079qu/+qvymc98Rl544QX527/9WxkfH5fBwUG566675Etf+pJ0deFbmf/6X/+rhGEo73jHO6RcLstP/dRPyRe+8IUWzKFmGIZhGIZhGMYr0SqOi63QhsXirD+o3XnnnZLOIv78xje+8YrnKBaL8md/9mfyZ3/2Z2d7ecMwDMMwDMMwjEuecx6jZiyU+WibW1kP3cx237Xn519XoQ/3nNgCoZis+dnzs/Z8tl90cVxC8Vq+3yS+Q0R+mH4lK9+R/4Ws/N0E8URRgpgujpsS0RbUNR/6e7bnzuXdGDXo713b6uw6no4DGUoQb8F1ArLkZv2/iI5P4Lg2tk924wfjGP1WpzissQQ24g8nOlbqjuAnsvLawtuy8oPTX2jYFhEd8+LaW58mojgdjnMS0XFpfpOYLM9JQcmW51OC+Ay2rM45aQDaQsT2cJxcTHN6VXiNqnOw/qx7KyKi47s2+Der12Y8jF3dwxobjdDv7lxhm/VB/4qsvE+eyspduRVZebyq45HYnrtKMWGlGmzq23IDqk57ACt1jhmqpmh/4uk59Vr/pqw8EaGvt6bfzcruvbHlOo9jW4g+DJwYGZ5TPFYqjjTWc/eRKtb5scqLVAfXdGNxPJ9eo7nbIWjzOM2vGdHxSLUUa6xI98mW78W83md4jnLvcmxSzknP0R1g7HmseO52yzJV5wilUkhUihGqT20R0fG4vAfx36/0XqPq7KKYxKUFWNCXKO5wlFIXiOi40GZxi2zPX3f2eo695Li0CsWhcloXER2TxfSHiCPbW3tKvcapNnh+jFQRi8f7rIjeA3d4iEurRuM4l7NGOB0DP5duSNHXz3u6bbxOeT8seegDXi9nxqhR3DNb/dM8LEc6zpf3VE4jwGlRzoxJw3W4PZwuKElcS3+Gnyl8D41dy19tpKlI0gJvQS8lM5FzkvDaMAzDMAzDMAzDmD/2Qc0wDMMwDMMwDKPFMOnjOaexhM8Qmd3OtkkNx3rc91iS49NxWkLTHL5m3OTv7r/Jlly1x/3eA8c9nX4nK99UeGtW3lr5x6w8m5xmMHdtVi7lIFUcLr+k6uTJqprlaxMkTavntDSGYXt9lpxETr8vy12VlacCSFv4OmfYUdM52M56RRF21sO13arOdwUStjfl7sT122/E9ckKWkTb67M0hiWjcRPrchFtN16KKF0Btd9Ni8DyL06RwNePnPQL5QhSnSW5dVl5PDqUlY/FL6s6m4M3ZOW9HuR0nC7gQPiCqnN1ektWHvExdzgtgpsGgGWIftr4+7ypOvq9u7BKvTZe2Z+VizlcR8nsHEnSTIy2VWkM2Rp+MLhc1XkqQR/MCPqTJY2RY1feHUK2V/BgqX+kAslcM9mwiEhbAOnwSGVXVu7IL1fHseSMrctHa5DWDuT1/cyQ9DdP6RNyKUmkSbp8xMe5RERCWnMs6eV15coLed8Jac2zNG26ptNRpDnslTWycm8PMW86/H5Vh2XR1RipFPj6LGl0YUv9vtz6rLy9/j11HPf7jKflqKdx05WwrJHHtxRhXVRjSiPgyHZnSN6rpa0kp3P2UN7f23zs24dmfpCV807qgSLNV5bT8r4dJ7oPef2EPtrjk8TTlXJzihPe27alP8rK5bruWz6uK480DSxZ5XXtSuNT2jcDljTy/HDWZaWG/TlHfVWts1Rf3xuHK6g0M4lOUaB55fcJZ8jsvfm8H7n4SaU1gm9aoQ2Lhf2iZhiGYRiGYRiG0WLYBzXDMAzDMAzDMIwWw6SP5xyTO84d/rF6bv2WkMuZp6R2LFWY7UfwZq/NJsvk11jeoKVcaYr2sOTjpeCJrJxnl0THBatUO5aV4xxkM+zw15FfoerUyG2Lneo6SYrCsiP3fJV4PCt3k7xoqLpT1RmLIc9b6m9Am31IpIqhloJNVVEnIfkVS/3yQaeqUyFnssf8p7NyKOhblluJaOkjyw0Dkiuy9JH7WUSkq+2GrNwTwmVtjJziXPlYkWQ3LJFsI+e9wVS7MY54kA765D6mpFd1LTnb5j+WlW8Pfjor7ylAcjqZaCnoboEUss1DO5MUa2x1sFnVmfHQh4diSKyW56/OykN1yOlGy3p+sGSL5VY819x56PuQNfH4sHTrEEkdRfQc57nDf2enPBGRiQjOkywP7CmsxTGOiyXLmuopzt1bXC/NOF7blpVZhhzSPJxyJKfLaC1NpJB1HavivllmeqtA1ioi8rMrIR/774ewH51MIaENHdkuy+aKAcZtguSrLhWSEbeTDHAmgny1Pa/dZbtIastzok7j5spUWR7He9uEYAwDRw63lOSx0ySHzfmYR26/s/ufK8k9DUs3XRfc2JE147x4i9XuyCUvlxuz8gu1b2fl/jbIylmaKyJypNzY9TWJG7dZRDt2LvchwT0SbadjtEx9qIb1HNBzld1QWa4tIpKnMATeg1hemGdJY6Sl/iydZJl6yPJ1R27JUt1Yuf3ieZ0Ldb/XSM4+92xb/Mxnp0h2sXTes7yK5I5M0iKuj63QhsXCflEzDMMwDMMwDMNoMeyDmmEYhmEYhmEYRoth0kfjIkN/t8ASB9cRcnFp/Ds6X9N1fUrIDY1ld5xo1E3WzCjHQpL9sDSHpUoiOkEry/44Aal7zQEfEpYogKzqRO2lpnU4yfXJEJIPlra0+1r6xG6TLG1hh0HXwZGT9nJSZXYV6/dWcxVJCpB/TVYPZ2VOiM6SJNdJjJPhKodAku3VPC19YtlOFCOZ9lQCWWV/XrczFoxjf4LrcNLjsu84q9H4PpXAEXOZB7lXn9MfY+lRnI+czdgh8HCsJYXcJywjLKYYX5ZU1X3ML7edLH1id7wzEqKTnLQ9D5mcSmDuJF5WibFJSpmnhL3unGJpKdfn67jJyfM+JGicpFr1ja+dBLkPVNtI6lfwtbSNJad87uVFJD5n2d4PvSdV/aePYNzG61gvfD+uY+l6D66rBwVyOJavumuEz8Gy3cvC27LyWKrlhV1CrnyC9cPnYqmziE6MHZA8jyWS7v2w3LFHkKx5JMFe4Mpueb600/zgNcIOn4EjFWTHwkIO+xm79fYlWqK9Lcb65X2OnSYnae2KiCQkpyuEaCc7Z7pOkdw/7CLLf2fJrYjIwRgSyy3+nVl5hw85b85x9eX1zGuEn1FD03BWDUi26BLTs5Nl8ty3IiLVOqS2fH2P7q0Wafk4P6fTpqEPc0tezXJHz6lzCSnvzoo0bY1k063QhsXCflEzDMMwDMMwDMNoMewXNcMwDMMwDMMwFkQic7doOZe0QhsWC/tFzTAMwzAMwzAMo8WwX9SMFoJjvJrZ8+u/p6qO3/S4uTFXS3/dApTca6I99Xg0K+fJLrgWIWYndOLNOJaFre0LAezGp2pODIPS8zeOtZip69iRoxHiDm7y78rKpdywNINt49mOnmPPXKttjtcYD9BujhPqCnW6gRJZKXOcHF+z7MRHdXmIS5mUw9IIPlfixDZWI8TF6EgWqu/EI3LcE8dk1SjWYkpGVR2+7ykfV+pOcK5hJ2UDxxpyeZLmTiA6noj7imMqSrGO3WDYsp3bOUL9uSSAtb3nfOfHsVc8hrwOPCfGJUcxKxyrxPFR5bruQ4690jEy1AfO+JZjxDBNRIjjyoe4vju+nLZitY/0DZUAY3Ciso2rqDgmjr/L5RA/w5bmIiLTCWJuih5i3jpTjG+vhzidSSeGcSLW8Xin4VivTfIT6rURD306QzE/HMNUd+3naVqy1f6QT6k2nHs7UNva8Nwcc8uxViJ6Xl2Z/8msfCTdQfX1+FYSWrU0LZd42DdrfvMY00nqQ47F5bnGa09EJAhwr1057GETKc51LNbzg/d3ntc8Volj8d6Zxz1wvCfHpblpXroF8Z7HEtxPf35jVj5S367qsPX+thRxZRzzu7J4g6rD6Tr6KLXLsRnEu3HsWIHSHYiIzNQwdwKKGeT47orz7OKJyPtJotIn6L3pzOf0j+vT22GOZ/5xK+g4iounczWPdzOMhWEf1AzDMAzDMAzDWBCWR23xMemjYRiGYRiGYRhGi2G/qF10zEeed7EwH7ki2+OydGE+oJbnLI0zpRA4slH9U0CWwXIUlvewxCOKtIypTlKbTcW7s/KO6rezcujYiLNNdLkG2U2g7LS15IxlWS/6P8zKvSQVGq7vU3VYksRyxXE6V+hYWI8mkLZ0BpB/smW8a7W/yoc852V5PCuzPKiWzqg6VyUkscxDYqnlo5C58f2LaNlfjWy82ULbtRFnKVTsysR+zHQwov7NFuG1APeQBuhPtw+jJueeqmOsO3JL1WssQa1GkFi15TAG7v3EEVvVo69Y8tqRh0SzHGlJYtXDvWmZGOaN7+WFYTmqT/JN3Z/6u0WWvSUJ5n61jrXkrhG2Dm/LQX41U4OsitM3iGgZ46HaszIXeI20U1+PV/aj7IS8d1DaiXaSPvYm2vr/NLtrP2z4dxEty2Kp4V5/hzpuog45G/dhLoSc7wrvNarOMR8pLEZr2BuCHMaN56SISF8OFvAlSjFQi7AfuilWwgDjs6v2fRzHkjNH6reiDekGeG9ha/qaY8+vLdtx7jaS54V+kY7R1+zJYd+qkuyuRuXe3BpVZ4zSgBSbpEJw0wiwBLW3uD4rT1Dqkp7CWlXneIQ0K1eEt2flgyTFdOWAk5TSgvfakOaRK7NlG/6xOvZaldqFHpFVZ89h6SKPaY3ljs66ZCl3mrJslp/Lrq0EP6d53KOGf3fPoZ/yCw23MIxXxj6oGYZhGIZhGIaxIFJpjZ8QWqENi4VJHw3DMAzDMAzDMFoM+0XNuGRoLl04e0nCbK5P+nyzfW/Dr0GKkSQkcyOZSxguEaZSg0PXRAdkcyva4LblOs0pWaPf+O+uy2FI8stS9UhWLrZBbuW6nEXkZlgh97K+PORNLO0REWkjF8rJ6FhW9jz07bAcVHWK3tU4TjlvNXaAFBGZ9NC/XT4cz9YWIYncHUEyFgaQNLmw0xvLA125Fd+Dls3hOO5bEZEcuQyWauiPegh5U2eoZYwJXTfwGm/fU3SuU+1BX7EMkM/VndeS03YfYzURod3sYnmiBimZ77SF3T9dGeFpWKYrIhLQHI0FY8oSzWqkXQE7qH8ma5Dw8TXbHHe53mBVVj5ZhwywIw/JqSttY1c+dofk+3Qlxeycx1I/vu/+tqtUHZbNDSdYP2MeJLx8n4EjjeX+4HXBrq/VRDse8tj5Aco3pJA7Pu89peqwOyTLiOu0t7GroYjIRIR78GlOuvfARCQT90mSzFLujrxeIxWSwM1EaCfLhme7Jr8tYjfXmRjn6s6tVDWmSCrYHsKVkyXew7Xdqk4hwP7K8mSWEbvt5DnF+2tHbnnDc4mILM1dnpVPpLQn0+PJ3c9y5GJZrmPNLy9ek5V5XxARKdX0v0/Da9GnfZIllafaQDJmkjT6PtqSOHO3WbiCdmB0n//NnuVzlUvycSZ3NM499kHNMAzDMAzDMIwFYa6Pi49JHw3DMAzDMAzDMFoM+0XtouNi/5rgfLlWsnTBc167EH3I12Q3SMg/4li7F7Jk5Og0pEddRchflhQ2qDqjlV1ZmROKsjte0deJtaskL+oqwJlMucE5MhV27GM3xUowTu3X3wNx2/qKV2RlTkB8g9yu6jybfjcrF0hKNUkuZ5zsVURkj/d0Vs4JZDOej/Y0kxC5sDwpRxKcaUdeyHJSdu5j1zZXHtgboq+HE/SNGitPy8cqlBib5WzTKqm0lgd2F3CvPI4sjZuo7ld1CkVctyeEVNCVb53GlQp2FlBnqoL+ZcmaK7dil9I2kiF2kQtm3tf9wdLWaZ+So8/yHWSYYhx4TLsCnCuftqk6xxJIjBOSLrKUtBj0qjo1wXpmaWwPufXVEr3mOVH4dSkkzrt9OCtOpPtxXtHtZFkkO/QVcjhvxXES5HnEroI/8pCgmtebiN6byiS1Y8dCd/0HTa7D6yLx9D5TyEFGyA6oLEPmJMwu3B6WEbpzL6Z7YNdEljSyDHK0skfV53P3Cuarn5JEO9aOrRHJyXld8LnYTVJEZLi6Myuz3JETsvOeNRvsSOm6yXJi6WIO62Kkvhf1SfYrotcCj2kUV7Iy75Oxs0+xXNH3IEdPEn1cM9KmIQnu879JwmuaK6mTaFwd19Qp0jDODfZBzTAMwzAMwzCMBZGmp/6/0LRCGxYLkz4ahmEYhmEYhmG0GPaLmmEYhmEYhmEYCyKRMz0zLwSt0IbFwj6oGeeZVvg9ej5xcs1sfOdav1kdnDdJK8L4Ap0+x4RM105k5X6KVxMRmfARr6FinSh+hi2jRUSGKFaAYx3yfuOYAxEdn8D2/hx3caYtO37A5xgPtjv/kfdDaQZbxtdziO1x7agT2qI5fmWKLM7Zsj1xbOI5jotfYxvybopjEREp0ZiwDT9birv6hemELM5DtjgnG/E0p+os9y/Lykei7VmZY7ICX6cbqDoxSafJUVyMOHF+IzUaH4o9aaMUEtN1xIS5MT9VwTXzlJaB29mVW6HqTJOVeqU+nJV5HvfldEzmUB0xc65l+mkC0X1Y8TBHazHidIYo7qmL4gxFRDpysIDvFsTsDMW4PluPi+h+7+T4Nw/9Ph4fVXUmKMbsyQCxmzWySOc5yTFYIiIhzTHujxGKD3XTIhRofJbnN2XlY9UXcM3EjdnBv9Ucp/ZETkoPdkXnvYVx74fXIqdICIPmsY48X/W5cFw5Oqle6y1uzMoFigtNA9SZoDg9N/6O05IcjRDPyPFZbh2P5iXHE3LqAk4JICJydf7OrDzu47WJCuahWtei90OOB65Rqgu33wuUEoPjTzn9A6chENGpEDidC8d0RU32IhEdx5mk002PW0x8j9OVVJoeF1Bcd5xMND3OuPj59Kc/LX/4h38ox44dk2uvvVY+9alPyR133NH0+O985zty//33y7Zt22TlypXyH//jf5T77ruv4bH/8A//IO9617vk537u5+TLX/7ynNtk0kfDMAzDMAzDMF61fOlLX5IPfOAD8ru/+7vy7LPPyh133CH33HOPHDx4sOHx+/btk7e85S1yxx13yLPPPiu/8zu/I7/xG78h//RP/3TGsQcOHJAPf/jDs37oa4Z9UDMMwzAMwzAMY0EkglxqF/T/ebT9j//4j+W9732v/Pqv/7ps2rRJPvWpT8maNWvkM5/5TMPjP/vZz8ratWvlU5/6lGzatEl+/dd/Xf7tv/238kd/9EfquDiO5d3vfrd8/OMfl40bNzY812yY9NG4RGluz7twe935yDdnsws+jd5akpSsu6l64MN+eVK0hOfK3Ouz8q7oiaw8Q1Ky3mCVqrMuvyUr7y4/mpX9HLaHwJHGsKwxSljmgu9+ehx5oJbdQD7C8qBKXUt9WMZXJalOjuRN+UBbtjMRWV3X6Zp1kge5Mrcpst5n+RbLsEJHXsTSxSpNqZhkjDzvRESmY8glWY7GVt0nop2qTsBW5tQelie5MiZt1+83/Lub4oClfizrDHJkQ57H+PLYiojUksbSJT7vEtH9PhpBbsn3w2MwkmpbdCWNI3v/IIDtvjsP82Rpz9cphr1ZeZLkq6deQ/+UAowjpwvIe+2qTjUlWWUFMtV2sjuvRM1lVDW6b+63Os392EmbwWknKilkZsuK12TlmUSPFUs0WUrKc9d35LQ8X1mK6TWRDYto+TTLe3kvKOa0LJtt41ki3RmiDznNxKk62E94HsYqjUBe1alTmoSYUgR0U2qIOI+/s2RWRI81r3PfZ5t6PVbFXG9Wbmb9309pTERExjzIjU9WXs7KgZJO6vV/rPysNAZ7QeL0YRI3TjfCMnM3JQdLKXl+xInuK7qK+leaNrbNX3iogSs5xWvqGcvHeHq+m9zx4mVyUsttC4WCFAqFM46r1WqydetW+e3f/m3197vvvlsef/zxhud+4okn5O6771Z/e/Ob3yyf+9znpF6vSy53ai1+4hOfkKVLl8p73/teeeyxx876HuwXNcMwDMMwDMMwLinWrFkjPT092f+f/OQnGx43PDwscRzL8uXL1d+XL18ux48fb1jn+PHjDY+PokiGh099Of79739fPve5z8lf/dVfzfse7Bc1wzAMwzAMwzAWRCqtYRl3ug2HDh2S7m6okBr9msZ4nlY8pWl6xt9e6fjTf5+ampJ//a//tfzVX/2VDAwMNKo+J+yD2kXHfGQAFzsLvefmdTxaAqlydjyXfdvs3M03AyZO8FP+6MzL6rVSDjK1ntzqrDxcfikrz6Ra+rQ+uS4rryi8Iys/XvsyWuY4lrFMjOUw1QjnZpc0EZHBthuy8skE7WaJlTgObhGdzyenOCUpdNqWI3fGzhy+7RojqZ8ry2L43moezw+0zXU8Y/lVQC543E51nw4JSbRCJW3TkiR2U2veB7o/+HyBV6Ay7i12+oPdMlmiNFGBFNOjcxVzuj/4OtUIbn1TKWSl48l+XYdkqmncWArquo/y+GrJKsZ6vKKvUwqwRlgOx06VYaClTzy+7MzIDoOR13ysfOqPEvWtKymMk8Z1ZrzG4he3P9hJlOV8Myn+7rok8nytkQyyjWSIdWfu1qMpaQTL7or53obHiGhJIssdXcdClj4WA8hPqySnYzdIES3j02uOZK6O42gXSRwjQf3R+oGGbXFheTCvRR6fjrz+5p3de2dqkLDzenVdH3kceI6z8+ZU5YCqI6o9LPlEfwROv3O7Q5qHvMbq0bCqk6rnWrMIocV9fisrUbqmkpk7ayd15MKN6qSzOEAaFxfd3d3qg1ozBgYGJAiCM349O3ny5Bm/mp1mxYoVDY8Pw1D6+/tl27Ztsn//fnnrW9+avZ4kp+ZpGIayY8cOueyyy+SVMOmjYRiGYRiGYRivSvL5vGzZskUefvhh9feHH35YXve61zWsc/vtt59x/EMPPSS33HKL5HI5ufrqq+WFF16Q5557Lvv/bW97m9x1113y3HPPyZo1a+bUNvtFzTAMwzAMwzCMBZHO03FxsUnn8ePt/fffL7/yK78it9xyi9x+++3yl3/5l3Lw4MEsL9oDDzwgR44ckb/9278VEZH77rtP/vzP/1zuv/9+uffee+WJJ56Qz33uc/L3f//3IiJSLBZl8+bN6hq9vb0iImf8fTbsg9pFx0IleRejdHI2x8Szvwft9OhRid0gXQeq+fTV2fb12Ttaua5VNVJ1DJM8iV0aWQYpIvJsATKiK+TmrNxbXJ+VWfIiouVGfFxtFhe74Roc5ZYVrs7Kt/ooP1z7lqpTqiEhMEua2vKQKrkyxPHKXtQnSV/YRDrpSjRZGsaJddnR0nU5ZPc/TgqtkxPr7TZVUh3Iulgyl3OS93YX4NjJ7e4gCWDJGSuW97HTXI3kY64UlOVbsUraS/JEGg933FlKNdh2U1aejCETcSVrsZO4HNehfvK1CITHmiVjLHeKEy3TY4llVx5JodlBkWVpIro/8gFkNL0hvhFl2aGISH8BkpaJCC6S7JKapDqRdEBzlK/JUlLem9y5z0nIe3No22htX1Z2Jbg1kqaGJBtmGaMnemxy5MDIyatZnjjurCuey+ya2kdOlUM17XLKJOQKyEnlQ2eNpAlL+vAau39uSK9VdX5U/WaTa7JTZOMxOHUdvKbdJbHmJykptYheSyxJ5DqeI3ri11juyGvEldOqtUyOmHwud07UaT+okhNvKuw06z6v+O253+Tv82G2kAAeh6DhEWdKHRs/Z+fnAG1cSrzzne+UkZER+cQnPiHHjh2TzZs3y4MPPijr1p3ao44dO6Zyqm3YsEEefPBB+eAHPyh/8Rd/IStXrpQ//dM/lbe//e2L2i77oGYYhmEYhmEYxoJI09b4CWA+v6iJiLzvfe+T973vfQ1f+8IXvnDG397whjfIM888M+fzNzrHK2ExaoZhGIZhGIZhGC2GfVAzDMMwDMMwDMNoMUz6+KoDvwdra/qLRZ997n5U5z7wxI0nahzXNnt7msXWLfQemsfsccyaJ5QvhOJiXLtijp14zkdsDtvplzwds8OwZfQNhZ/Jyi8nj6vjukLElR0rP5+Vv5lH3NKK4EpV50gO/V6pww6aY8IG042qDtuv1+qIJeP4G45raWY1LqJjP2ox4rDc2JEkRDuTBGWOKavFJVWnTLFBHOOizuvEjpXquLe2sC8rz9S1VTYTx5gTpRSxPR35wazMFtzuv8dr0OSHjo33aVzrcj6OYxM57sm1wA88jM90DXOCbcjrsY5r8wTnSygWheMRU3Et8BFDNBM1tq13Uz4wfJ3jlReyMseuiYhMJ4gXa2bZ7lrlcxzXFeHtWXmU1uVUDCt3N3aU58RwFfFeOu5Sx3SxDX+N4iPZ5t1z0yLQvOY0AKUIbfN9XYfTNDAn6JouHAvG68VvkgJDRN8f33eXvywrb6t9t+l1VLwXrYNIpU5gm3s9pgk9K3j98lx14VhYfV5dp0rrgseEUzklibaW57gy38N1mqUucNuq+4bjvdw1wv92Y7zPlvk8L3EPusZs9S/GmP3WJpHWMBNphTYsFvaLmmEYhmEYhmEYRothH9QMwzAMwzAMwzBaDJM+voqZn5yPuRRkA3O16m12r/ORQS4mzc+bpiyBIeviVMtSPLqHiKRlh0uQB4VkOS+ipVwsndyRh6zMle1VyQ5+Sx4Syd0e5GMnkj2qTk8I+3S2rWcL+r2hlj5151BnImWrbsiV2E6+SNIvES3j4zpRjHtOUn3NKMZWuqLtuqw8RPIzVzbI/+Z7Y7mTK41j2R7fQ0CW3K6MspMkjhMVtIelmImvLazDAOfoz8Nmfjw6JI3oza9V/+YUEDxXtI24lo+l1B8sXWTJmTvdWdbFEk+2KHdTHITUPyzbjdW467FKzrD4PkUx7G34dxF93zxWLJtrz+u51xNCUlghGXPAMnVav+71OeUCkyc7fTeVAkt/03RuEnhOX8CyPZ6fPB4uSkpJW6gaa9HzmudOkui0BkxNSYrRtkMzP0D9VKcbYIkj1+HjuC2eYwXPfcr7Htcp5HQqBYZTdfBe4EqKec1wG3Q6jeZS7iRlCTy//XOk3OrZMVfb/cV8xp39uXR6nfmEclwK72cuPEkqkrRA/yUXvgmLhv2iZhiGYRiGYRiG0WLYBzXDMAzDMAzDMIwWw6SPxgI4XzKIVqC50yIInH8v1PlqPnhUmpsUJFX3QzI1uucoGpNm8HEzVXKKc+RjFZIrbg1QbsvBqa5c185wYQGSJHZQZPdD102OpUMsZ2N5UHcBUr1STTtasstZVG/sSBf4Wk4Xk2TryDQkVh7JGFkWdgqsmXzYg7+SdGpJbp2qMVKFNJSvmSQ0bp5eiywTLeTgfFepHc3KATliiojM1E5KI4rKIXAyK4/F+9VxypWviSQxdtzp2N2xSO1Usq5EyyVZ5sn9m6SQxkVJ8+8jo5ilZXwdLTmLlUQS7Q7zcDINHOfMXNielQvkCFmlfqs6jqP1AOeu0fnGSHJaonETRxrLkkK/idTXhetoqR+vX92HLKXULomY7z7NaRHdhyw1dPuaYSlmlHBfkcOfK+X2eB/m/Qzn6iysUXXaA8gS2eWU3X/53uqOvDBV/dZFZdxn1dlD2Tm2Wb+70udmbrVxMklHuc9elkiyiyT3oSvtbfb8vrDPtFml/nOWO5rE8VySSmv0aiu0YbGwX9QMwzAMwzAMwzBaDPugZhiGYRiGYRiG0WKY9NFYACyDcOWAF4u8YD7tbHacK/88H33g9ntKJUq2Sk5zZ8pcZpOwnj6Xbj9LglhqxOdOz3Cgw3WieDwrlyiRtDiJdccre7Myy35YLuXKgxJyAmRJYaUOOR/LhmZLbqwd4HBelmuKiJQp4TS3h6Vbvq+T13JCYJZrskvhWP2AqsNtZfllTLIwL9XXYSknJ8P1VX3Xba+D6kBGWI3G8XeSF4ZnSEG1rLERZyQNpnNwf7DMbvaxgswsjTkBueMQqCR95CRIY+WukWYyQB73nsJ6VWelXJ6VD8q2rMxyS9dlcay6PysPJY1lt+lsUkFObizoX14HbnLzGVoXuaA3Kxeo311JcpUSybsOqKfxnOuwTDPxOBG03/CYU+emseO+on3CTeDNY8XzpRjA/XS6ruXOLPVVjpBNXDDd/ZDhtRjT3uY7ayRtstfONg+jmCWOc5Mhsqsv38/8nBFnv1Jj5uOS3Kz+bNdsdlzzZ6Sx+JxyfbzwmOujYRiGYRiGYRiGcc6wX9QMwzAMwzAMw1gQ6Y//u9C0QhsWC/ugZvyY2VwNm014dte6EG5Qi8Fc3Bzd41qJubUrJQmR5yx73tDcRK44Jnb+TbKZlJwmVbJmV2LJggiWaFJ953ZiOgfLmNxk2uoqJBljORzLulg66Z6LHdxiaSw/K1X13/ncLL3Ubdauj3GENrA0LefDLZCTUouIxHQOTjScKkmT4xRH52uWKJid6kS0w12Ya+w0V6QEvq78tJ3cISskc00SloLqeciuiWWS48XUZk6+LSJSTdE/PFdSSgQ9Ta6XItqxT7uCNnbEO3UcxtsTnuMYj9GZF1SdiWA/zsYSWK+xJFFEpFofwblpHvFaUmv0DCkoJz6eaVhm5023bTyO0zVOwh46dZrJLzm5uV7/7PQ417Uckhspu3dyv7v1E04uTs6Xk7M4X6q2qrXEG9Jsgq7G983yT3f9q/OxLFQdN5/njt7DF1fi2Ngh+BRzEbzN9X7mKpGcy/la9dltGHPDpI+GYRiGYRiGYRgthv2iZhiGYRiGYRjGgjAzkcXHflEzDMMwDMMwDMNoMewXNaMBc/0qgr83cWObFhqzdiHs/fk67v00jq+6GDkzZsGj1+ZK4/HRcSnu2V7ZvtmNhePXohiW4CrOzomf4TZU64hP4hgkjh1pyy1zrog2sA05x36lTrxJLRqic/PcwXdhbvwfx89wbBKnEdC28Doeh+OOzuw3EMWN45s8ZXGurxMnuL8odmNrTrcZfeO2Mw3QV3yukI5zY+mKQXfDMsczxeLY5tOYTtMYMN4Z8wPX5XbHyva++XeY3Ndsue6mDtDno7lD5+ZxP3USOkfC/dOsPfrvHNPF8Yjc124qBl4XHB/Fc0XZ5M/SHt2f+jra9r5xfJa7liOKJ2x2fXctcgyh24ZG9X/cuoZHeU33xtm+4+Z0Axzv1nxvWzi8ty5GvHjjWGXdT+51FvOZfXE/Yw1jMbEPaoZhGIZhGIZhLIhEWkT6eKEbsIiY9NEwDMMwDMMwDKPFsF/UjAUAeULgd6pX4mSy4XHzOfeFQcs6PLLUbi7v022eW525ci6loIt5vvNjpazTA8zNfppTFHB5uurKq2azoD59hCvjZFkk/x3zKHVkeylJCvMkv2SpoEuO7cpjyLpSqsOyTve6ibIhp1bWdBoAlm8qO3peF9Tvrl17PR5tWJ/leK5ccsqx0W90zTip6Nea2dY3qX/qupArtnEagWg8K7uSu2aSUZYUJnEzmZ22eU+kmbW9qDHxmtjZa6mf/t44isakEbPZzJ+ZRuN0ncZ/F2k0/398/Xiy+THqn36Tv7ttaDzf9Hn1GlXtTllyyn3Q/N7cFtCFqOx+X99430pn3bcXuqcvtD6vcT0Ies3M9dyL9xxpJm13Za7Nx+dCv38wjMXDPqgZhmEYhmEYhrEg0rRFEl6nF74Ni4VJHw3DMAzDMAzDMFoM+0XNWBTiZGKWVy9+SUKqXM9m0eo0rbPgFjT5+2xtmWudi3NMzg+NHdTSWft9Lm59rrvkUXql+bmjmFwkvcZSvyStuH9pej7gyMdIDqdlUE3OlTZ3tNNSNDqT68jHEjYlWZurix31h5LD6XtjB8NSZR9dZ7Z1QO59JL+arQ7LyZR74Bl91Yxm84hlkK6E7+zHuvl1mp8rnc93vGpM5yo9nMt5F9tNkdcfr7HFdDIWOXfOiM33D5bwpkqWPddzLyZuOxvPqfSM/azZOew5Zlya2Ac1wzAMwzAMwzAWhLk+Lj4mfTQMwzAMwzAMw2gx7Bc14zxwqUkSWul+ZmtLM1nIuWz/XF3OmFbqT5HFdKfUcil9/81kSLOfm+RKafNza/j7uGbyrdm+f2xWZ7ZrvrI8+IzE6wucBtoJtHlbZpdSNTt38/MB131wLmPavJ9UDeV4OJ+xns2xcD7f1zabL2mDUiNaWbLG7VmM5NGNzrvYzFGO7665885s4z6bFLMZrTZ3DDMTWXzsFzXDMAzDMAzDMIwWwz6oGYZhGIZhGIZhtBgmfTQMwzAMwzAMY0Gk0hpGHpeO8NE+qBnGBeB8xWqdr62q2f249vHNYmb4OHeLn8s9zGbzPJ8Yk9nac5r59G3q/KtZ3NHc4k3mHnfYrN/nKqjgPmh2zfmkiThfzOf6s1mpNzvffObaQueR285klteaXXMx47DmyoWeEwtltvlxoePv5nPN2fbqxWS2ti1mKgTDuHQw6aNhGIZhGIZhGEaLcdYf1L773e/KW9/6Vlm5cqV4nidf/vKX1eue5zX8/w//8A+zY+68884zXv/lX/7lBd+MYRiGYRiGYRjnnyRNW+b/S4Wzlj5OT0/LDTfcIL/2a78mb3/72894/dixY+rfX//61+W9733vGcfee++98olPfCL7d1tb29k2xTAcLhbpxKWzgZyi2f24ssFmkqCFjtViS7nmYnvvSoXOnUSyOfORWC203+cjy2zWztnkYxeaxZZLnitaqc9eTczW7wsdk9nkyc3W7ELn6/l/XnrO2890wfuRrQXj0uSsP6jdc889cs899zR9fcWKFerf//zP/yx33XWXbNy4Uf29vb39jGMNwzAMwzAMwzCMcxyjduLECfna174m733ve8947Ytf/KIMDAzItddeKx/+8Idlamqq6Xmq1apMTk6q/w3DMAzDMAzDaA3SFvrvUuGcuj7+9//+36Wrq0t+8Rd/Uf393e9+t2zYsEFWrFghL774ojzwwAPy/PPPy8MPP9zwPJ/85Cfl4x//+LlsqnFJ0Mpyx/lwIWQdi3lNXd/3OuiVOsppXeZGK/XBYsy1ZhKnZi6LLq3sKDeXPrx0HqSnuNTu52KhlSW082ExZeFzvc5cWejzAZLxM6WOzc432zUv9rE2jFfmnH5Q+/znPy/vfve7pVgsqr/fe++9WXnz5s1yxRVXyC233CLPPPOM3HzzzWec54EHHpD7778/+/fk5KSsWbPm3DXcMAzDMAzDMIw5k0hr5FFrhTYsFufsg9pjjz0mO3bskC996UuveOzNN98suVxOdu3a1fCDWqFQkEKhcC6aaRiGYRiGYRiG0XKcsw9qn/vc52TLli1yww03vOKx27Ztk3q9LoODg+eqOYZxEbKY7mHzcQVc3CTGSTrd5NyzJaieq8vgYjKfJNtnW989ju8b8iBvluvM3SXtQkskzZnt4uRiGbdWbtulxtn3Nbs76j1rtnNdiH3fMFqTs/6gViqVZPfu3dm/9+3bJ88995z09fXJ2rVrReSUNPF//+//Lf/lv/yXM+rv2bNHvvjFL8pb3vIWGRgYkO3bt8uHPvQhuemmm+T1r3/9Am7FMAzDMAzDMIwLQSKpJC3w5UkrtGGxOOsPak8//bTcdddd2b9Px4796q/+qnzhC18QEZF/+Id/kDRN5V3vetcZ9fP5vHzrW9+SP/mTP5FSqSRr1qyRn/mZn5GPfvSjEgRubiLDMAzDMAzDMIxXH16aXnzpuycnJ6Wnp0dOSabsJ3LDaMxCpUuLK31sfu65Sh9baas6l31zKUgfmVYdQ2N2bNyMhbO40kebh3MjFZFEJiYmpLu7+7xc8fT78p9o+zUJvfx5ueZsRGlNvlf+m/PaB+eKc+r6aBiLg71hmB+N+8pzln3zh+ds8Wr86/d8LKT53OzPNNsHIL7mXC3szxXn8k0G+nP2Gs3WRat9ebXQLwlm+yBvaBbzDW4r77X2TDi3LGx/n9+Hs2bY+F5MJGmLSB8vvt+gmnJOE14bhmEYhmEYhmEYZ499UDMMwzAMwzAMw2gxTPpoXARcOj9hLw4Lk/2kEs3jmu51FlOCNlfZHl/Ta1J2z3chOF/Xb3ad83X9cyk/a5a6wJidCz33zxevlvucD/PZD10jt/msOVx3fnLHhcrpjVYg/fF/F5pWaMNiYb+oGYZhGIZhGIZhtBj2Qc0wDMMwDMMwDKPFMOmjYVx0zFUqeC5/+veoBMnK/GSVzFzbvJjpAWbjUnAcnI8LZLP+bXauVpOfGsarifnIkLnOYuxtC13zF+v+ajCW8HrxsV/UDMMwDMMwDMMwWgz7Rc0wDMMwDMMwjAVhv6gtPvZBzTAuahZ7M5qrhCalEssdm8vsFlciqc+smUufnH3y6bm3gYUKiXtgE85Wajhbnfked77PZby6uBiTVF8sbbZE0oZxqWLSR8MwDMMwDMMwjBbDflEzDMMwDMMwDGNBWB61xcd+UTMMwzAMwzAMw2gx7Bc1wzCIZtb/C4+Hah7LtlAL/Nnadr5iTPjcze5hMW3yDeNi42KZyxdLXFozLlTKFsMwzgX2Qc0wDMMwDMMwjAWRtojro0kfDcMwDMMwDMMwjHOG/aJmGHOimZzk0vnW5kyaySDd1xZ67tnkjguVIbXS+LRSWwzDABe73JG52NtvGAZjH9QMwzAMwzAMw1gQiZeI5801f+g5bMecc5i2PiZ9NAzDMAzDMAzDaDHsFzXDmBPN5CSXkmRmNi7UvV3KfWoYRmtg+4xhGK2JfVAzDMMwDMMwDGNBJJKK1wJffLSC8+RiYdJHwzAMwzAMwzCMFsN+UTOMs2Y+iYsNwzAWm8D5NwfQXzrfKBuGcXFwKovahTfyaIU2LBb2i5phGIZhGIZhGEaLYR/UDMMwDMMwDMMwWgyTPhqGYRiGYRiGsSASkRYxE7l0sA9qxquc+djrX/hNqLVoFrNn/WQY55b4QjfAMAzDOIeY9NEwDMMwDMMwDKPFsF/UDMMwDMMwDMNYEImXiOddeOFhcgmJH+2DmvEqh+V585FBGtZXhmEYp7kYpeBum1u5rYbx6sKkj4ZhGIZhGIZhGC2G/aJmGIZhGIZhGMaCSCQRrwVkhyZ9NIxLEpZ7BM5r5q5mGIZhvBIXi2yQn3H2fDOMVsU+qBmGYRiGYRiGsSDsF7XFx2LUDMMwDMMwDMMwWgz7Rc0wGuJKQcwR0jAMw7h48egtXyrRBWyJYRhzxT6oGYZhGIZhGIaxIFJJJG0B2WErtGGxMOmjYRiGYRiGYRhGi2Ef1AzDMAzDMAzDMFoMkz4axpywuLSzxXO2l1TF/c21P70mf7fxMIz54a4pW0uvFiwuzTjXJF4innfhZYfm+mgYhmEYhmEYhnGJ8OlPf1o2bNggxWJRtmzZIo899tisx3/nO9+RLVu2SLFYlI0bN8pnP/tZ9fpf/dVfyR133CFLliyRJUuWyJve9CZ58sknz6pN9kHNMAzDMAzDMIxXLV/60pfkAx/4gPzu7/6uPPvss3LHHXfIPffcIwcPHmx4/L59++Qtb3mL3HHHHfLss8/K7/zO78hv/MZvyD/90z9lxzz66KPyrne9Sx555BF54oknZO3atXL33XfLkSNH5twuL03Ti073MDk5KT09PXLqc2YzaZTx6uZc2umbVf/8mMtanU9/uudt9v2Tm3LBMFqNs32e2f5jGIZLKiKJTExMSHd393m54un35Rs73iK+lzsv15yNJK3L3ukHz6oPbrvtNrn55pvlM5/5TPa3TZs2yc///M/LJz/5yTOO/63f+i35yle+Ii+99FL2t/vuu0+ef/55eeKJJxpeI45jWbJkifz5n/+5vOc975lTu+wXNcMwDMMwDMMwLikmJyfV/9VqteFxtVpNtm7dKnfffbf6+9133y2PP/54wzpPPPHEGce/+c1vlqefflr+v/buPjiq6v7j+GcNeTJNIiGSzUqMKYNjNZSRxFIy8jBUo7QUGK2E6lCYWqZpAQmBKVBloLYDih3acXjQTgPVPgB/CMoMqSUZIYUBWgZSBMpQOqYENWsKP0jCg+Tp/P5IWXM3m80mm+ze3bxfzJ0JZ8/unj353pt79nzvuS0tLT6fc+PGDbW0tCgtLS3gz8BADQAAAEBUycrKUmpqqmfzNTMmSZcuXVJbW5syMjIs5RkZGXK73T6f43a7fdZvbW3VpUuXfD5nxYoVuueee/TYY48F/BlY9RFRaiBTgkg36puB6jfv1430FMeYTj97r1zVn31ICm/oBNrX0fx7IN6AaGfUJmODOaDbq0xfvHjRkvoYHx/v93kOhzX93BjTpayn+r7KJWn9+vXavn27Dhw4oISEBP8foBMGagAAAACiSkpKSkDXqKWnpysmJqbL7Fl9fX2XWbPbnE6nz/pDhgzRsGHDLOW//OUvtXbtWlVWVuqrX/1qrz5D+Ie9AAAAACJau43+9UZcXJzy8vJUUVFhKa+oqFBBQYHP54wfP75L/X379ik/P1+xsV8sqPLaa6/p5z//ud5//33l5+f3ql0SAzUAsJm2Tpvx2vrTQL1utHMEuHU2GPvauz/60geB9nV3/R5Inb4I9P1D9dr9+f7A4FRaWqrf/va32rp1q86ePaslS5aotrZWxcXFkqSVK1daVmosLi7WhQsXVFpaqrNnz2rr1q0qKyvTsmXLPHXWr1+vl156SVu3btV9990nt9stt9uta9euBdwuUh8BAAAADFpFRUW6fPmyXn75ZdXV1Sk3N1fl5eXKzs6WJNXV1VnuqZaTk6Py8nItWbJEmzZtksvl0uuvv66nn37aU2fz5s1qbm7Wd77zHct7rV69WmvWrAmoXdxHDQCAgAX6Nyfi/rT2M1+zisG+RiA6v093zw/2d+OvXeF4bRZqQWfhu49aVtJjusMR/jmgdtOqi9crQ9oHAyX8vQmEXH/+UeMPZPcG8mQGGEj+bqIe6LUPdj02hGq/7I/XCvY1QrXSbF/E9Fwl4BVs7RRfAPoT16gBAAAAgM0wowYAAAAgKB33UQv/JUkm4u+n+gVm1AAAAADAZphRwyAUjuswOl+P0Pkal2i+tiBSPpu/RQ/sep0RBpb37zp6vp0lju0i2Jji2AQMBgzUAAAAAASl40bTvbvZ9MC1IzqQ+ggAAAAANsOMGqKU3dJCvkhzcXTa7Yxaw9GYKNCfv1/v53f32p3TV6MpFQ5A5LHD3zUAA42BGgAAAICgGLXL2CDt0A5t6C+kPgIAAACAzTCjhihl37QQ0h37Q3crM3o/Fuxrd0a6I/rKbqnYAND/2tWmrn+Tw9WO6MCMGgAAAADYDAM1AAAAALAZUh8BRLhoSyUjTS768Hvsm+5SqDp/xxw9KU5ApGMxkf7HjBoAAAAA2AwDNQAAAACwGVIfAQAAAASl3dhk1UcTPSnRDNSAiNbfS9Mj/Dr/DmO8Hmvvpp4/XPOGSNWft8rwd/LIfgHAnkh9BAAAAACb6dVAbd26dXrkkUeUnJys4cOHa+bMmTp37pyljjFGa9askcvlUmJioiZPnqwzZ85Y6ty6dUuLFi1Senq6kpKSNH36dH388cfBfxoAAAAAIXd71Uc7bNGiVwO1qqoqLViwQEePHlVFRYVaW1tVWFio69eve+qsX79eGzZs0MaNG3Xs2DE5nU49/vjjampq8tQpKSnR7t27tWPHDh06dEjXrl3TtGnT1NYWPTmliDaOTlukiMQ2w6rNazOdtkB19xziA4OJ8bMBgD05jDF9Pkr997//1fDhw1VVVaWJEyfKGCOXy6WSkhItX75cUsfsWUZGhl599VX98Ic/VENDg+6++279/ve/V1FRkSTp008/VVZWlsrLy/XEE0/0+L6NjY1KTU1VxziTkwyEgl2v8/F3jZpd2wx7ID4AIPoYSe1qaGhQSkpKSN7x9nl52p0P6w6H97XVoddu2vR/N6pD2gcDJahr1BoaGiRJaWlpkqSamhq53W4VFhZ66sTHx2vSpEk6fPiwJOn48eNqaWmx1HG5XMrNzfXU8Xbr1i01NjZaNgAAAACIVn0eqBljVFpaqkcffVS5ubmSJLfbLUnKyMiw1M3IyPA85na7FRcXp6FDh3Zbx9u6deuUmprq2bKysvrabKCP7Jom4y+Fx65thv3EeG2BIHUSvUG8AEBv9XmgtnDhQn344Yfavn17l8ccDuuB2BjTpcybvzorV65UQ0ODZ7t48WJfmw0AAACgnxnTrnYbbMYM0sVEblu0aJH27Nmj/fv3a8SIEZ5yp9MpSV1mxurr6z2zbE6nU83Nzbpy5Uq3dbzFx8crJSXFsgEAAABAtOrVQM0Yo4ULF2rXrl364IMPlJOTY3k8JydHTqdTFRUVnrLm5mZVVVWpoKBAkpSXl6fY2FhLnbq6Op0+fdpTBwD6H6lXVp1TY71Xl+zt84GeEC8A0FtDelN5wYIF+tOf/qT33ntPycnJnpmz1NRUJSYmyuFwqKSkRGvXrtWoUaM0atQorV27VnfeeaeeffZZT93nn39eS5cu1bBhw5SWlqZly5Zp9OjReuyxx/r/EwIAAAAYUB33Lwv/l6HRdB+1Xg3UtmzZIkmaPHmypXzbtm2aN2+eJOknP/mJbt68qR//+Me6cuWKxo0bp3379ik5OdlT/1e/+pWGDBmiWbNm6ebNm/rGN76h3/3ud4qJCf+SngAAAAAQbkHdRy1cuI8agN7jvmEAgGgXvvuo3ZU4Wg4b3EfNmDZdvXkqKu6j1qsZNQCIXN3dDNxfPSDaeMd+d/sF+wGA3jEm0GucB5Zd2tEfgrrhNQAAAACg/zFQAwAAAACbIfURwCAUbFqXv/QxwM78xepgjePuUqEHa38AfdOudjlssHZENK36yIwaAAAAANgMM2oAAAAAgmKMTe6jZqJnRo2BGgD0GilRgD11PknsnDTU+cTNe/9lfwZgT6Q+AgAAAIDNMKMGAAAAIChG9rh/mV3a0R8YqAEAgAji78bcnf8fPSdrAAYnUh8BAAAAwGaYUQMAAAAQFGOMZIN7mHW0IzowowYAAAAANsOMGgAgRLpbOl3ieiIELnq+LQcAfxioAQAAAAiKsUHao2SfdvQHUh8BAAAAwGaYUQMAhAhLpw8sf8vW21UkthkAQoOBGgAAAICgGNMmO3zhYgypjwAAAACAAcKMGgAAUbEiZXffZNs5vdBu7QHQV3aZybJLO/oDM2oAAAAAYDMM1AAAAADAZkh9BICwsHM62mAUbStSEl8AQssu9y+zSzv6AzNqAAAAAGAzDNQAAAAAwGZIfQQAAAAQFLustmiXdvQHBmoAEBadrxtyBFAH6A1iBwAiHamPAAAAAGAzzKgBAAAACIpdVlu0Szv6AwM1AAg70tQAAIAVAzUAAAAAQTGmTXb44jGaFhPhGjUAAAAAsBkGagAAAABgM6Q+AgAAAAiSkWyxkEf40y/7CzNqAAAAAGAzzKgBQEA635Q6VN/Wed8IO3q+JQQAAP4xUAMAAAAQlI7VFr2/YAxHO6LnS01SHwEAAADAZhioAQAAAIDNkPoIAAEJRypFuNI3wnE9Hqz4HQCILEY2SX2MomMmM2oAAAAAYDMM1AAAAADAZkh9BAB4iZ60kchCuiOASGaP1MdoOn4yowYAAAAANsOMGgAAAIDg2OQ+aoqi+6gxUAMAwBai5+QCABA8Uh8BAAAAwGaYUQMAAAAQFO6j1v8YqAEAvAyW1QcHy+cEAEQiUh8BAAAAwGaYUQMAAAAQJHukPkZThgQzagAAAABgM8yoAQC8RM+3kf4Nls8JAIhEDNQAAAAABMnY5PsvWzSiX5D6CAAAAGBQ27x5s3JycpSQkKC8vDwdPHjQb/2qqirl5eUpISFBX/7yl/XGG290qfPOO+/owQcfVHx8vB588EHt3r27V21ioAYAAAAgSMYW//oyo7Zz506VlJToxRdfVHV1tSZMmKCpU6eqtrbWZ/2amhp985vf1IQJE1RdXa2f/vSneuGFF/TOO+946hw5ckRFRUWaM2eOTp48qTlz5mjWrFn629/+FnC7HMaYiJsfbGxsVGpqqjrGmXZYXQYAAAAINyOpXQ0NDUpJSQnJO35xXh4je5yXG0ltveqDcePGaezYsdqyZYun7Ctf+YpmzpypdevWdam/fPly7dmzR2fPnvWUFRcX6+TJkzpy5IgkqaioSI2Njfrzn//sqfPkk09q6NCh2r59e0Dtishr1L4YW0bcGBMAAAAYIB3nxuGbh7HPuXljY6Pl//Hx8YqPj+9Sr7m5WcePH9eKFSss5YWFhTp8+LDP1z5y5IgKCwstZU888YTKysrU0tKi2NhYHTlyREuWLOlS59e//nXAnyEiB2qXL1/+3099m94EAAAAolVTU9P/ZrkGXlxcnJxOp9xud0jeLxBf+tKXlJWVZSlbvXq11qxZ06XupUuX1NbWpoyMDEt5RkZGt5/J7Xb7rN/a2qpLly4pMzOz2zq96aeIHKilpaVJkmpra0MWhNGmsbFRWVlZunjxYsimxqMNfRg8+jB49GHw6MPg0YfBow+DRx92zKQ1NTXJ5XKF7D0TEhJUU1Oj5ubmkL1nT4wxcjisaZi+ZtM6867v6zV6qu9d3tvX9BaRA7U77uhYAyU1NXXQ7oj9JSUlhT4MEn0YPPowePRh8OjD4NGHwaMPgzfY+zAckxgJCQlKSEgI+fv2h/T0dMXExHSZ6aqvr+8yI3abrxnE+vp6DRkyRMOGDfNbp7vX9IVVHwEAAAAMSnFxccrLy1NFRYWlvKKiQgUFBT6fM378+C719+3bp/z8fMXGxvqt091r+hKRM2oAAAAA0B9KS0s1Z84c5efna/z48frNb36j2tpaFRcXS5JWrlypTz75RG+//bakjhUeN27cqNLSUs2fP19HjhxRWVmZZTXHxYsXa+LEiXr11Vc1Y8YMvffee6qsrNShQ4cCbldEDtTi4+O1evXqHnNN0T36MHj0YfDow+DRh8GjD4NHHwaPPgwefYi+Kioq0uXLl/Xyyy+rrq5Oubm5Ki8vV3Z2tiSprq7Ock+1nJwclZeXa8mSJdq0aZNcLpdef/11Pf300546BQUF2rFjh1566SWtWrVKI0eO1M6dOzVu3LiA2xWR91EDAAAAgGjGNWoAAAAAYDMM1AAAAADAZhioAQAAAIDNMFADAAAAAJuJyIHa5s2blZOTo4SEBOXl5engwYPhbpItrVu3To888oiSk5M1fPhwzZw5U+fOnbPUmTdvnhwOh2X7+te/HqYW29OaNWu69JHT6fQ8bozRmjVr5HK5lJiYqMmTJ+vMmTNhbLH93HfffV360OFwaMGCBZKIQ1/++te/6tvf/rZcLpccDofeffddy+OBxN2tW7e0aNEipaenKykpSdOnT9fHH38cwk8RXv76sKWlRcuXL9fo0aOVlJQkl8ul733ve/r0008trzF58uQusTl79uwQf5Lw6SkOA9l3iUP/fejr2OhwOPTaa6956gzmOAzkXIbjIaJVxA3Udu7cqZKSEr344ouqrq7WhAkTNHXqVMuSmehQVVWlBQsW6OjRo6qoqFBra6sKCwt1/fp1S70nn3xSdXV1nq28vDxMLbavhx56yNJHp06d8jy2fv16bdiwQRs3btSxY8fkdDr1+OOPq6mpKYwttpdjx45Z+u/2DSCfeeYZTx3i0Or69esaM2aMNm7c6PPxQOKupKREu3fv1o4dO3To0CFdu3ZN06ZNU1tbW6g+Rlj568MbN27oxIkTWrVqlU6cOKFdu3bpX//6l6ZPn96l7vz58y2x+eabb4ai+bbQUxxKPe+7xKH/Puzcd3V1ddq6dascDodlmW9p8MZhIOcyHA8RtUyE+drXvmaKi4stZQ888IBZsWJFmFoUOerr640kU1VV5SmbO3eumTFjRvgaFQFWr15txowZ4/Ox9vZ243Q6zSuvvOIp+/zzz01qaqp54403QtTCyLN48WIzcuRI097ebowhDnsiyezevdvz/0Di7urVqyY2Ntbs2LHDU+eTTz4xd9xxh3n//fdD1na78O5DX/7+978bSebChQueskmTJpnFixcPbOMihK8+7GnfJQ6tAonDGTNmmClTpljKiMMveJ/LcDxENIuoGbXm5mYdP35chYWFlvLCwkIdPnw4TK2KHA0NDZKktLQ0S/mBAwc0fPhw3X///Zo/f77q6+vD0TxbO3/+vFwul3JycjR79mx99NFHkqSamhq53W5LTMbHx2vSpEnEZDeam5v1hz/8Qd///vflcDg85cRh4AKJu+PHj6ulpcVSx+VyKTc3l9jsRkNDgxwOh+666y5L+R//+Eelp6froYce0rJly5gt9+Jv3yUOe+ezzz7T3r179fzzz3d5jDjs4H0uw/EQ0WxIuBvQG5cuXVJbW5syMjIs5RkZGXK73WFqVWQwxqi0tFSPPvqocnNzPeVTp07VM888o+zsbNXU1GjVqlWaMmWKjh8/rvj4+DC22D7GjRunt99+W/fff78+++wz/eIXv1BBQYHOnDnjiTtfMXnhwoVwNNf23n33XV29elXz5s3zlBGHvRNI3LndbsXFxWno0KFd6nC87Orzzz/XihUr9OyzzyolJcVT/txzzyknJ0dOp1OnT5/WypUrdfLkSU/67mDX075LHPbOW2+9peTkZD311FOWcuKwg69zGY6HiGYRNVC7rfO38FLHjutdBquFCxfqww8/1KFDhyzlRUVFnp9zc3OVn5+v7Oxs7d27t8sfisFq6tSpnp9Hjx6t8ePHa+TIkXrrrbc8F80Tk4ErKyvT1KlT5XK5PGXEYd/0Je6Iza5aWlo0e/Zstbe3a/PmzZbH5s+f7/k5NzdXo0aNUn5+vk6cOKGxY8eGuqm209d9lzj0bevWrXruueeUkJBgKScOO3R3LiNxPER0iqjUx/T0dMXExHT59qO+vr7LNyn4wqJFi7Rnzx7t379fI0aM8Fs3MzNT2dnZOn/+fIhaF3mSkpI0evRonT9/3rP6IzEZmAsXLqiyslI/+MEP/NYjDv0LJO6cTqeam5t15cqVbuugY5A2a9Ys1dTUqKKiwjKb5svYsWMVGxtLbHbDe98lDgN38OBBnTt3rsfjozQ447C7cxmOh4hmETVQi4uLU15eXpep/oqKChUUFISpVfZljNHChQu1a9cuffDBB8rJyenxOZcvX9bFixeVmZkZghZGplu3buns2bPKzMz0pKJ0jsnm5mZVVVURkz5s27ZNw4cP17e+9S2/9YhD/wKJu7y8PMXGxlrq1NXV6fTp08Tm/9wepJ0/f16VlZUaNmxYj885c+aMWlpaiM1ueO+7xGHgysrKlJeXpzFjxvRYdzDFYU/nMhwPEdXCtIhJn+3YscPExsaasrIy889//tOUlJSYpKQk85///CfcTbOdH/3oRyY1NdUcOHDA1NXVebYbN24YY4xpamoyS5cuNYcPHzY1NTVm//79Zvz48eaee+4xjY2NYW69fSxdutQcOHDAfPTRR+bo0aNm2rRpJjk52RNzr7zyiklNTTW7du0yp06dMt/97ndNZmYmfeilra3N3HvvvWb58uWWcuLQt6amJlNdXW2qq6uNJLNhwwZTXV3tWZEwkLgrLi42I0aMMJWVlebEiRNmypQpZsyYMaa1tTVcHyuk/PVhS0uLmT59uhkxYoT5xz/+YTlG3rp1yxhjzL///W/zs5/9zBw7dszU1NSYvXv3mgceeMA8/PDD9OGFCwHvu8Sh/33ZGGMaGhrMnXfeabZs2dLl+YM9Dns6lzGG4yGiV8QN1IwxZtOmTSY7O9vExcWZsWPHWpabxxck+dy2bdtmjDHmxo0bprCw0Nx9990mNjbW3HvvvWbu3LmmtrY2vA23maKiIpOZmWliY2ONy+UyTz31lDlz5ozn8fb2drN69WrjdDpNfHy8mThxojl16lQYW2xPf/nLX4wkc+7cOUs5cejb/v37fe6/c+fONcYEFnc3b940CxcuNGlpaSYxMdFMmzZtUPWrvz6sqanp9hi5f/9+Y4wxtbW1ZuLEiSYtLc3ExcWZkSNHmhdeeMFcvnw5vB8shPz1YaD7LnHof182xpg333zTJCYmmqtXr3Z5/mCPw57OZYzheIjo5TDGmAGarAMAAAAA9EFEXaMGAAAAAIMBAzUAAAAAsBkGagAAAABgMwzUAAAAAMBmGKgBAAAAgM0wUAMAAAAAm2GgBgAAAAA2w0ANAAAAAGyGgRoAAAAA2AwDNQAAAACwGQZqAAAAAGAzDNQAAAAAwGb+Hw/7iAjPrNvdAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# show OSEM recon\n", + "show2D(osem_recon.as_array()[72,:,:], cmap=\"inferno\", fix_range=(0,0.15), origin=\"upper\")" + ] + }, + { + "cell_type": "markdown", + "id": "under-caribbean", + "metadata": {}, + "source": [ + "## Reconstruction with TV regularisation using PDHG and preconditioning" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "static-noise", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Get linear acquisition model\n", + "K = am.get_linear_acquisition_model()" + ] + }, + { + "cell_type": "markdown", + "id": "funky-withdrawal", + "metadata": {}, + "source": [ + "To accelerate the reconstruction, we use diagonal preconditioning to compute $\\sigma$ and $\\tau$ based on the operator K. See [here](https://ieeexplore.ieee.org/document/6126441) for more information." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "statewide-airport", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tmp_sigma = K.direct(K.domain_geometry().allocate(1.)).power(-1)\n", + "tmp_tau = K.adjoint(K.range_geometry().allocate(1.)).power(-1)\n", + "\n", + "tmp_tau_np = tmp_tau.as_array()\n", + "tmp_tau_np[tmp_tau_np==np.inf] = 1e-5\n", + "tau = tmp_tau*0.\n", + "tau.fill(tmp_tau_np)\n", + "\n", + "tmp_sigma_np = tmp_sigma.as_array()\n", + "tmp_sigma_np[tmp_sigma_np==np.inf] = 1e-5\n", + "sigma = tmp_sigma*0.\n", + "sigma.fill(tmp_sigma_np)" + ] + }, + { + "cell_type": "markdown", + "id": "aerial-cable", + "metadata": {}, + "source": [ + "The implementation of `FGP_TV` does not accept $\\tau$ as a `numpy` array. Hence, we change its `proximal` method to a `precond_proximal` method. " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "smoking-mistake", + "metadata": {}, + "outputs": [], + "source": [ + "def precond_proximal(self,x,tau, out=None):\n", + " in_arr = np.asarray(x.as_array()/tau.as_array(), dtype=np.float32, order='C') \n", + " res , info = regularisers.FGP_TV(\\\n", + " in_arr,\\\n", + " self.alpha,\\\n", + " self.max_iteration,\\\n", + " self.tolerance,\\\n", + " self.methodTV,\\\n", + " self.nonnegativity,\\\n", + " self.device)\n", + " if out is not None:\n", + " out.fill(res)\n", + " else:\n", + " out = x.copy()\n", + " out.fill(res)\n", + " out *= tau \n", + " return out \n", + " \n", + "FGP_TV.proximal = precond_proximal" + ] + }, + { + "cell_type": "markdown", + "id": "informational-discount", + "metadata": {}, + "source": [ + "Next, we define the fidelity term **KullbackLeibler** based on the acqusition data and random events. For the regularisation term we use the **FGP_TV** function class from the [CCPi-RegTk](https://github.com/vais-ral/CCPi-Regularisation-Toolkit)." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "exact-snowboard", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/SIRF-SuperBuild/INSTALL/python/cil/optimisation/algorithms/PDHG.py:397: UserWarning: Convergence criterion can only be checked for scalar values of tau and sigma.\n", + " warnings.warn(\"Convergence criterion can only be checked for scalar values of tau and sigma.\")\n" + ] + } + ], + "source": [ + "alpha = 13.0\n", + "F = KullbackLeibler(b = acq_data, eta = rand)\n", + "G = alpha * FGP_TV(max_iteration=100, device='gpu' )\n", + "max_iterations = 500 # Use 500 to match the results in the paper. \n", + "\n", + "# Setup and run PDHG\n", + "pdhg = PDHG(f = F, g = G, operator=K, sigma = sigma, tau = tau,\n", + " max_iteration = max_iterations, update_objective_interval = 100)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5c72f42c-6d1c-475a-9913-5a740cc0bc8c", + "metadata": {}, + "outputs": [], + "source": [ + "# Image metrics callback\n", + "import img_quality_cil_stir as imgq\n", + "import tensorboardX\n", + "from datetime import datetime\n", + "import numpy as np\n", + "# create a tensorboardX summary writer\n", + "dt_string = datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n", + "tb_summary_writer = tensorboardX.SummaryWriter(f'recons/exp-{dt_string}')\n", + "def MSE(x,y):\n", + " \"\"\" mean squared error between two numpy arrays\n", + " \"\"\"\n", + " return ((x-y)**2).mean()\n", + "\n", + "def MAE(x,y):\n", + " \"\"\" mean absolute error between two numpy arrays\n", + " \"\"\"\n", + " return np.abs(x-y).mean()\n", + "\n", + "def PSNR(x, y, scale = None):\n", + " \"\"\" peak signal to noise ratio between two numpy arrays x and y\n", + " y is considered to be the reference array and the default scale\n", + " needed for the PSNR is assumed to be the max of this array\n", + " \"\"\"\n", + " \n", + " mse = ((x-y)**2).mean()\n", + " \n", + " if scale == None:\n", + " scale = y.max()\n", + " \n", + " return 10*np.log10((scale**2) / mse)\n", + "\n", + "ground_truth = osem_recon\n", + "roi_image_dict = {}\n", + "# instantiate ImageQualityCallback\n", + "img_qual_callback = imgq.ImageQualityCallback(ground_truth, tb_summary_writer,\n", + " roi_mask_dict = roi_image_dict,\n", + " metrics_dict = {'MSE':MSE, \n", + " 'MAE':MAE, \n", + " 'PSNR':PSNR},\n", + " statistics_dict = {'MEAN': (lambda x: x.mean()),\n", + " 'STDDEV': (lambda x: x.std()),\n", + " 'MAX': (lambda x: x.max()),\n", + " 'COM': (lambda x: np.array([3,2,1]))},\n", + " )\n", + "sigmas_mm = [5.0, 8.0]\n", + "filters = {}\n", + "for sigma in sigmas_mm:\n", + " filters[f\"Gaussian_{sigma}\"] = imgq.image_quality_callback.GaussianFilter(post_smoothing_fwhm_mm=sigma, voxel_size_mm=img_qual_callback.voxel_size_mm)\n", + "\n", + "img_qual_callback.set_filters(filters)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "1442a99f-887f-418c-aa6c-a65588a637ec", + "metadata": {}, + "outputs": [], + "source": [ + "from cil.optimisation.utilities import callbacks" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "dimensional-wings", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_295590/4217939724.py:1: DeprecationWarning: `run()` missing `iterations`\n", + " pdhg.run(callbacks=[callbacks.ProgressCallback(), img_qual_callback])\n", + "/opt/conda/lib/python3.10/site-packages/numba/core/typed_passes.py:334: NumbaPerformanceWarning: \u001b[1m\n", + "The keyword argument 'parallel=True' was specified but no transformation for parallel execution was possible.\n", + "\n", + "To find out why, try turning on parallel diagnostics, see https://numba.readthedocs.io/en/stable/user/parallel.html#diagnostics for help.\n", + "\u001b[1m\n", + "File \"../../../../../../../../opt/SIRF-SuperBuild/INSTALL/python/cil/optimisation/functions/KullbackLeibler.py\", line 344:\u001b[0m\n", + "\u001b[1m @njit(parallel=True)\n", + "\u001b[1m def kl_div(x, y, eta):\n", + "\u001b[0m \u001b[1m^\u001b[0m\u001b[0m\n", + "\u001b[0m\n", + " warnings.warn(errors.NumbaPerformanceWarning(msg,\n", + "OMP: Info #276: omp_set_nested routine deprecated, please use omp_set_max_active_levels instead.\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "fe85ee9ec8464d068a16f85b2f5bb575", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/500 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "show2D([osem_recon, pdhg.solution], slice_list=(0,71), title=['OSEM', 'KL+TV'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "40f11afe-8c66-445b-8209-abab1d4309db", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/metrics/README.md b/metrics/README.md new file mode 100644 index 0000000..acd22b6 --- /dev/null +++ b/metrics/README.md @@ -0,0 +1,34 @@ +# Reconstruction with calculation of metrics + +## Requirements + +- CIL with callbacks https://github.com/TomographicImaging/CIL/pull/1659 +- metrics from Stochastic Hackathon Quality Metrics, branch [`cil_callback`](https://github.com/TomographicImaging/Hackathon-000-Stochastic-QualityMetrics/tree/cil_callback) +- SIRF master + +### Installation + +Currently building from this SuperBuild branch https://github.com/SyneRBI/SIRF-SuperBuild/pull/718 + +Notice that a fairly recent version of docker is required. Install it following the instructions [here](https://docs.docker.com/engine/install/ubuntu/). + +```bash + +docker/compose.sh -dgb -- --build-arg EXTRA_BUILD_FLAGS='-DGadgetron_TAG=6202fb7352a14fb82817b57a97d928c988eb0f4b -DISMRMRD_TAG=v1.13.7 -Dsiemens_to_ismrmrd_TAG=v1.2.11 -DDEVEL_BUILD=ON -DBUILD_CIL=ON -DCCPi-Regularisation-Toolkit_TAG=origin/master' --build-arg RUN_CTEST=0 + +``` +where `-dgb` tells to `b`uild the `g`pu and `d`evelopment branches. The whole lot of flags can be checked [here](https://github.com/SyneRBI/SIRF-SuperBuild/blob/c21a2a45591550a6e257fc6f3dc343294b2c3127/docker/compose.sh#L24-L31) + +``` + h) print_help; exit 0 ;; # print this help + b) build=1 ;; # build + r) run=1 ;; # run + d) devel=1 ;; # use development (main/master) repo branches + c) cpu=1 ;; # enable CPU + g) gpu=1 ;; # enable GPU + U) update_ccache=0 ;; # disable updating docker/devel/.ccache + R) regen_ccache=1 ;; # regenerate (rather than append to) docker/devel/.ccache (always true if both -c and -g are specified) +``` + + +## Metrics \ No newline at end of file diff --git a/metrics/recon_example.py b/metrics/recon_example.py new file mode 100644 index 0000000..887138c --- /dev/null +++ b/metrics/recon_example.py @@ -0,0 +1,126 @@ +#%% +from cil.utilities import dataexample +from cil.utilities.display import show2D +from cil.recon import FDK +from cil.processors import TransmissionAbsorptionConverter, Slicer + +ground_truth = dataexample.SIMULATED_SPHERE_VOLUME.get() + +data = dataexample.SIMULATED_CONE_BEAM_DATA.get() +twoD = True +if twoD: + data = data.get_slice(vertical='centre') + ground_truth = ground_truth.get_slice(vertical='centre') + +absorption = TransmissionAbsorptionConverter()(data) +absorption = Slicer(roi={'angle':(0, -1, 5)})(absorption) + +ig = ground_truth.geometry + +#%% +recon = FDK(absorption, image_geometry=ig).run() +#%% +show2D([ground_truth, recon], title = ['Ground Truth', 'FDK Reconstruction'], origin = 'upper', num_cols = 2) + +# %% +from cil.plugins.tigre import ProjectionOperator +from cil.optimisation.algorithms import FISTA +from cil.optimisation.functions import LeastSquares, IndicatorBox, ZeroFunction, TotalVariation +from cil.optimisation.operators import GradientOperator +from cil.optimisation.utilities import callbacks + +#%% +A = ProjectionOperator(image_geometry=ig, + acquisition_geometry=absorption.geometry) + +F = LeastSquares(A = A, b = absorption) +G = IndicatorBox(lower=0) + +grad = GradientOperator(domain_geometry=ig) +#%% +alpha = 0.1 * A.norm()/grad.norm() +G = alpha * TotalVariation(max_iteration=2) + +algo = FISTA(initial = ig.allocate(), f = F, g = G) + +#%% +# Image metrics callback +import img_quality_cil_stir as imgq +import tensorboardX +from datetime import datetime +import numpy as np +# create a tensorboardX summary writer +dt_string = datetime.now().strftime("%Y%m%d-%H%M%S") +tb_summary_writer = tensorboardX.SummaryWriter(f'recons/exp-{dt_string}') + +#%% create masks +top = ig.allocate(0) +bottom = ig.allocate(0) + +top.fill( + np.asarray(ground_truth.array > 0.8 * ground_truth.max(), + dtype=np.float32) + ) +bottom.fill( + np.asarray(np.invert(ground_truth.array < 0.4 * ground_truth.max()), + dtype=np.float32) +) +#%% +show2D([ground_truth, top, bottom], num_cols=3) +#%% +# setup a 2 binary ROI images +roi_image_dict = { + 'top' : top, + 'bottom' : bottom +} + + +def MSE(x,y): + """ mean squared error between two numpy arrays + """ + return ((x-y)**2).mean() + +def MAE(x,y): + """ mean absolute error between two numpy arrays + """ + return np.abs(x-y).mean() + +def PSNR(x, y, scale = None): + """ peak signal to noise ratio between two numpy arrays x and y + y is considered to be the reference array and the default scale + needed for the PSNR is assumed to be the max of this array + """ + + mse = ((x-y)**2).mean() + + if scale == None: + scale = y.max() + + return 10*np.log10((scale**2) / mse) + + +# instantiate ImageQualityCallback +img_qual_callback = imgq.ImageQualityCallback(ground_truth, tb_summary_writer, + roi_mask_dict = roi_image_dict, + metrics_dict = {'MSE':MSE, + 'MAE':MAE, + 'PSNR':PSNR}, + statistics_dict = {'MEAN': (lambda x: x.mean()), + 'STDDEV': (lambda x: x.std()), + 'MAX': (lambda x: x.max()), + 'COM': (lambda x: np.array([3,2,1]))}, + ) +sigmas_mm = [5.0, 8.0] +filters = {} +for sigma in sigmas_mm: + filters[f"Gaussian_{sigma}"] = imgq.image_quality_callback.GaussianFilter(post_smoothing_fwhm_mm=sigma, voxel_size_mm=img_qual_callback.voxel_size_mm) + +img_qual_callback.set_filters(filters) + +#%% +algo.run(100, callbacks=[callbacks.ProgressCallback(), + img_qual_callback]) +# %% + +show2D([ground_truth, algo.solution], title = ['Ground Truth', 'FISTA Reconstruction'], origin = 'upper', num_cols = 2) +# %%