diff --git a/ClearMap/ImageProcessing/Experts/Cells.py b/ClearMap/ImageProcessing/Experts/Cells.py index f36358f7..f9a93886 100644 --- a/ClearMap/ImageProcessing/Experts/Cells.py +++ b/ClearMap/ImageProcessing/Experts/Cells.py @@ -6,7 +6,7 @@ Expert cell image processing pipeline. This module provides the basic routines for processing immediate early -gene data. +gene data. The routines are used in the :mod:`ClearMap.Scripts.CellMap` pipeline. """ @@ -82,7 +82,7 @@ shape=3, measure=['source', 'background_correction']), ) -"""Parameter for the cell detection pipeline. +"""Parameter for the cell detection pipeline. See :func:`detect_cells` for details.""" @@ -96,15 +96,15 @@ verbose=None, processes=None ) -"""Parallel processing parameter for the cell detection pipeline. -See :func:`ClearMap.ParallelProcessing.BlockProcessing.process` for details.""" +"""Parallel processing parameter for the cell detection pipeline. +See :func:`ClearMap.ParallelProcessing.BlockProcessing.process` for details.""" ############################################################################### # ## Cell detection ############################################################################### - -def detect_cells(source, sink=None, cell_detection_parameter=default_cell_detection_parameter, + +def detect_cells(source, sink=None, block_detection_function=None, cell_detection_parameter=default_cell_detection_parameter, processing_parameter=default_cell_detection_processing_parameter, workspace=None): """Cell detection pipeline. @@ -114,6 +114,10 @@ def detect_cells(source, sink=None, cell_detection_parameter=default_cell_detect The source of the stitched raw data. sink : sink specification or None The sink to write the result to. If None, an array is returned. + block_detection_function : function or None + The function apply to each block. If function, it should return a tuple of arrays + with the following specs: ndims should be 2, dimension 1 of first array should be 3, + and dimension 0 of all arrays should be the equal. cell_detection_parameter : dict Parameter for the binarization. See below for details. processing_parameter : dict @@ -305,7 +309,11 @@ def detect_cells(source, sink=None, cell_detection_parameter=default_cell_detect n_processes = multiprocessing.cpu_count() if processing_parameter.get('processes') is None else processing_parameter.get('processes') n_threads = int(multiprocessing.cpu_count() / n_processes) # Number of threads so that * n_processes, fills CPUs - results, blocks = bp.process(detect_cells_block, source, sink=None, function_type='block', return_result=True, + if block_detection_function is None: + # use default cell detection function + block_detection_function = detect_cells_block + + results, blocks = bp.process(block_detection_function, source, sink=None, function_type='block', return_result=True, return_blocks=True, parameter=cell_detection_parameter, workspace=workspace, **{**processing_parameter, **{'n_threads': n_threads}}) @@ -407,7 +415,7 @@ def detect_cells_block(source, parameter=default_cell_detection_parameter, n_thr maxima_labels, _ = ndi.label(maxima, structure=np.ones((3,)*3,dtype='bool')) centers = np.vstack(md.label_representatives(maxima_labels)).transpose() # we could come back to the ancient version - # centers = ap.where(maxima, processes=n_threads).array + # centers = ap.where(maxima, processes=n_threads).array del maxima # correct for valid region @@ -436,9 +444,9 @@ def detect_cells_block(source, parameter=default_cell_detection_parameter, n_thr shape = None else: raise err - - + + valid = sizes > 0 results += (sizes,) else: @@ -479,7 +487,7 @@ def detect_cells_block(source, parameter=default_cell_detection_parameter, n_thr if parameter.get('verbose'): total_time.print_elapsed_time('Cell detection') - + gc.collect() return results diff --git a/ClearMap/Scripts/custom_cells.py b/ClearMap/Scripts/custom_cells.py new file mode 100644 index 00000000..3fb30a6b --- /dev/null +++ b/ClearMap/Scripts/custom_cells.py @@ -0,0 +1,138 @@ +# TODO module-level documentation: This module is an example of a custom pipeline +""" +Example usage: +``` +from ClearMap.Scripts.custom_cells import detect_cells, custom_detect_cells_block, default_cell_detection_parameter +from skimage.data import cells3d + +test_data = cells3d()[:,1] +sink = detect_cells(test_data, block_detection_function=custom_detect_cells_block, cell_detection_parameter=cell_detection_parameter) +``` +""" + +import gc + +import numpy as np + +from skimage.filters import threshold_otsu +from skimage.morphology import ( + remove_small_objects, + remove_small_holes, + binary_closing, + ball, +) +from skimage.measure import label, regionprops + +from ClearMap.ImageProcessing.Experts.Cells import ( + default_cell_detection_parameter, + detect_cells, +) # We need `detect_cells` imported from the same module as `custom_detect_cells_block` +import ClearMap.Utils.Timer as tmr +from ClearMap.ImageProcessing.Experts.utils import run_step + + +default_cell_detection_parameter["custom_step"] = { + "save": False +} # The `cell_detection_parameter` dictionnary needs a key with the name of the new custom step + + +def custom_detection(array, **kwargs): + """Detect cells in a 3D array. + Outputs a tuple of arrays representing the coordinates (x, y, z) of the cells **in the array**, + and properties of each detected cell.""" + + ## detect intensities above otsu threshold + mask = array > threshold_otsu(array) + + ## postprocess mask + mask = remove_small_objects(mask, min_size=1000) + mask = binary_closing(mask, ball(1)) + mask = remove_small_holes(mask, area_threshold=10_000) + + ## extract individual connected components + labeled_mask = label(mask.astype(int), connectivity=1) + + ## compute properties of the connected components + region_properties = regionprops(labeled_mask, array) + coordinates = np.array([region.centroid for region in region_properties]) + intensities = np.array([region.mean_intensity for region in region_properties]) + maxima = np.array([region.max_intensity for region in region_properties]) + shapes = np.array([region.area for region in region_properties]) + + return coordinates, intensities, maxima, shapes + + +def custom_detect_cells_block(source, parameter=default_cell_detection_parameter, n_threads=None): + """Detect cells in a block of a 3D image. + Outputs a tuple of arrays, representing the coordinates (x, y, z) of the cells **in the image**, + and properties of each detected cell. + That function can be passed to CellMap's `detect_cells` function.""" + + # initialize parameter and slicing + if parameter.get("verbose"): + prefix = "Block %s: " % (source.info(),) + total_time = tmr.Timer(prefix) + else: + prefix = "" + + base_slicing = source.valid.base_slicing + valid_slicing = source.valid.slicing + valid_lower = source.valid.lower + valid_upper = source.valid.upper + lower = source.lower + + # Measurements that will be performed per cell + steps_to_measure = {} # FIXME: rename + + ## intensity + parameter_intensity = parameter.get("intensity_detection") + if parameter_intensity: + parameter_intensity = parameter_intensity.copy() + measure = parameter_intensity.pop("measure", []) + measure = measure if measure else [] + ## validation + valid_measurement_keys = list(default_cell_detection_parameter.keys()) + [ + "source" + ] + for m in measure: + if m not in valid_measurement_keys: + raise KeyError(f"Unknown measurement: {m}") + steps_to_measure[m] = None + ## in case source is measured, the image used is source + if "source" in steps_to_measure: + steps_to_measure["source"] = np.array(source.array) + ## other cases seem to not be supported + + step_params = { + "parameter": parameter, + "steps_to_measure": steps_to_measure, + "prefix": prefix, + "base_slicing": base_slicing, + "valid_slicing": valid_slicing, + } + + # WARNING: if param_illumination: previous_step = source, not np.array(source.array) + + results = run_step( + "custom_step", np.array(source.array), custom_detection, **step_params + ) + + # correct coordinate offsets of blocks + results = (results[0] + lower,) + results[1:] + + # remove cells outside the valid region of the block + valid_mask = np.all( + (results[0] >= valid_lower) & (results[0] < valid_upper), axis=1 + ) + results = tuple(result[valid_mask] for result in results) + + # ensure all results array have 2 dimensions, so that they are ready to be vstacked + results = tuple( + result[:, None] if result.ndim == 1 else result for result in results + ) + + if parameter.get("verbose"): + total_time.print_elapsed_time("Cell detection") + + gc.collect() + return results diff --git a/ClearMap/Scripts/developer_cellmap.ipynb b/ClearMap/Scripts/developer_cellmap.ipynb new file mode 100644 index 00000000..8bef4df7 --- /dev/null +++ b/ClearMap/Scripts/developer_cellmap.ipynb @@ -0,0 +1,763 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9b55225b", + "metadata": {}, + "source": [ + "# Developer guide to test alternative cell detection within the CellMap pipeline" + ] + }, + { + "cell_type": "markdown", + "id": "2fe5fc36", + "metadata": {}, + "source": [ + "Here is a notebook to help you modify the block processing function" + ] + }, + { + "cell_type": "markdown", + "id": "8242f850", + "metadata": {}, + "source": [ + "## Default cell detection" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "d142d5e4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "masking maxima centers by (dog > 700) for shape detection\n", + "Filtering centers for correct block processing.\n", + "Received uint source array with 0 values. To avoid inconsistent results in watershedding, we need to shift the source intensity by 1 prior to taking its opposite.\n", + "masking maxima centers by (dog > 700) for shape detection\n", + "Filtering centers for correct block processing.\n", + "Received uint source array with 0 values. To avoid inconsistent results in watershedding, we need to shift the source intensity by 1 prior to taking its opposite.\n", + "masking maxima centers by (dog > 700) for shape detection\n", + "Filtering centers for correct block processing.\n", + "Received uint source array with 0 values. To avoid inconsistent results in watershedding, we need to shift the source intensity by 1 prior to taking its opposite.\n", + "masking maxima centers by (dog > 700) for shape detection\n", + "Filtering centers for correct block processing.\n", + "Received uint source array with 0 values. To avoid inconsistent results in watershedding, we need to shift the source intensity by 1 prior to taking its opposite.\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xyzsizesourcebackground_correction
00022107777.03984.0
10038467872.03985.0
20067648583.04411.0
303141057160.03605.0
40321497066.03462.0
.....................
28280592542321436307.03605.0
2828159255193336734.03083.0
282825925520147398.04506.0
2828359255245347018.04032.0
2828459255254266781.04126.0
\n", + "

28285 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " x y z size source background_correction\n", + "0 0 0 22 10 7777.0 3984.0\n", + "1 0 0 38 46 7872.0 3985.0\n", + "2 0 0 67 64 8583.0 4411.0\n", + "3 0 3 14 105 7160.0 3605.0\n", + "4 0 3 21 49 7066.0 3462.0\n", + "... .. ... ... ... ... ...\n", + "28280 59 254 232 143 6307.0 3605.0\n", + "28281 59 255 193 33 6734.0 3083.0\n", + "28282 59 255 201 4 7398.0 4506.0\n", + "28283 59 255 245 34 7018.0 4032.0\n", + "28284 59 255 254 26 6781.0 4126.0\n", + "\n", + "[28285 rows x 6 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import napari\n", + "\n", + "v = napari.Viewer()\n", + "\n", + "from ClearMap.ImageProcessing.Experts.Cells import detect_cells\n", + "from skimage.data import cells3d\n", + "import pandas as pd\n", + "\n", + "test_data = cells3d()[:, 1]\n", + "sink = detect_cells(test_data)\n", + "cells_df = pd.DataFrame(sink)\n", + "cells_df" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "10cc1983", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize in napari\n", + "v.add_image(test_data, name=\"test data\")\n", + "v.add_points(\n", + " cells_df[[\"x\", \"y\", \"z\"]],\n", + " properties=cells_df[cells_df.columns.difference([\"x\", \"y\", \"z\"])],\n", + " out_of_slice_display=False,\n", + " face_color=\"size\",\n", + " size=3,\n", + " name=\"detected cells\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a8084a64", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/ceWJEu2JYhtUU6MOIuIy/Lmy3qsugrd1T3qKQY9wwfgWzEHZlggC1hVXey9l+SSiHA3N6ZqyhUDiy22VdwiO/OGv64qpJ61fLm7mRKRIyKH7HPkiBnHccRMM80000wzzfQXS95/6QbMNNNMM80000z/ZWk2BmaaaaaZZprpL5xmY2CmmWaaaaaZ/sJpNgZmmmmmmWaa6S+cZmNgpplmmmmmmf7CaTYGZppppplmmukvnGZjYKaZZpppppn+wmk2BmaaaaaZZprpL5yCP/VCY8w/ZztmmmmmmWaaaaZ/BvpTagvOyMBMM80000wz/YXTbAzMNNNMM8000184zcbATDPNNNNMM/2F02wMzDTTTDPNNNNfOM3GwEwzzTTTTDP9hdNsDMw000wzzTTTXzj9yVsLZ/rfh4IgwHK5hO/7KIoCVVX9SdtCZvr/D8qyDFmWoes6lGWJpml+8bPiOMZisQAAnE4nlGX5Ws2c6Z+BfN/HYrFAFEVomgaHwwHDMNjvjTHI8xxpkqLrOxwOB3Rd91+wxVPyfR9ZliFJEtR1jcPhMMuu/4ZoNgb+KyLP8/Dm4Q2+in+FqEuwXXzET5sfsN/v/0s37b8Z8jwPcRxjGAY0TfPflDBK0xTfPHyH2/4N+qzDY/4TfvrwE9q2/bOfFUURvnrzNd6Yr2FGg03+AT98+AOqqvpnaPlMX0rGGNze3uLrxXfImhWKfIefgj/g6enJXrNcLPHN/XdYtfdogwo/x3/Ah48f0Pf9f8GWX2i9WuOb9a+QNSuU+f7c/s3T//aNM/1XQbMx8EqU5zmMMRiGAX3fwxhj//d9H0EQwPM8BEGAMAzheZ71+owxGMcRSZLg+/vfIPnPDzAnH9k3Cyz+JsPz9hnDMNifcRxf/B9FkX133/dWCY7jCM/z4Hme/X8YBltEip4H/+e1QRBMrvU8D8YYdF2Huq7RdZ19H8nzvMl7h2FAEAT22byWfNFCVsYYBEFg//Y8D77v2/Z0XWfbwOeP4zh5fhAEuL25Q4wcAzrsqy2Ox4N9po4P+z6Oo/2ubVuEYWj5yvexPewD79H+dl0HYwx834cx5qqA5jhzjPh+0t3tHd6O3yB9fwf4I/DtgGJV4Hg8vhhP3/ftM9hOfdZiscBD+A7rH74CRgP/6wDFzRHPz8+TsXL7os/wPM/OK44P5y6v41xn/8IwRN/31mMNgsD2l+1355OOPfvE9/u+b+/TNp1Opwn/tN2+78P3fdvWoihQ17UdOx1zknrgygs+V+cd5wL5ot/pWPM6fsfrOUd07QVBgG/efov7n38FbxcjvV0h+Nqb8Prtw1s8HL5H+D7HGA/wf2NgPIOmadB1nV0Pbh/d9una1L65KISOSdu2dkx1HXH+hWGI+9sHPGy+g39IkK1XaG9qNG0zkXNuW9xidmEYIggCu/b7vp/IApfPALDZbGYj9xVoNgZeiRaLBTzPwzAMaNvWCru2bZEkCZIkQRAEZ5gvTW0YYBxH+L5vF/LD7QPqH3wMncHifoU3f71A3dR2MdLbbZoGbduibVsMw4D1eo22bVFVlb2Gi0YX1zAMqOvaCll6nVS6NASSJAFwUXJckIQvy7JEVVVo29a+h4qUwqbveyRJYhUVhQmVuwoHY4y91hiDKIoQhqH9XVWVFe7k6zAMiOPYCtflcoll/w7N7xZA2OHu659R9js0TWP7xvGhUlaBfjqdkGUZ2rZF3/fWgKMxx3v7vrcKhzziO8IwhO/7L4STGiNN06CqKmtQkeI4hoEBfADBiCA6jwMFPQA7T8IwRNM0k7bwWeM4Io5jeKF3XuHDCD/ykJgEaZpahUSjR/vnKqjFYoGu6xAEgQ1h6Lvc34vFAk3T4HQ62XaQPwBe8K5pGhhjkKap/Z/9jeMYcRzb+4Az4pHnOTabjR1HGhUkzpssyxCGIR4fH7HdbnE6nSbXqRFFQ4HzROewKlW2n+/kunINB/KYxGfRSPF936498n+xXCDcBhiPgJ8GuL29xehfxmS9XCMZIoyBgYk93NysMUQduq7D6XRC3/fIsmwyr7medYxorJHnbK/OsyAIEEWRHZPj8WjnNK/l/AuCwF5vQgD+CBMAYRQiSRLLL+Utf5RHAKx8jOPYGpI0AN372e66rmdj4BVoNgZeicqytApNvVUuRioSKtS6ricLgoKpGPaI/mWGsAuRfOOjGy9ekiICrjFAQcf/uQBV4bJdbAcV9DiOSNMUURRZBU/BpZ4sjQTGtA+Hi9cNXDwOtpefUemp16xGAADrlQOwXktdn42gPM8tn7RNVVWh7/uJcG0LDzgFQOfBNAFGb7TGEYUJjY66ridoSpIkZ4H2qY0q5JqmmSgB5U/bthNl0bYtTqeT5YMiM1SKHCsqdwAoygLbm4/Iv2sweD127ZMdYz5DDSvlI40wKs3T6YTD4hnmOwMMBkfvGXVT2/tdr5o84vjRaGA/KaQpoHnvcrlE13U4Ho84nU7wPM/2fRgGHI9Hu0Y499hfDX80TWPHv+97NE2DJElsX5ummSgnNVB937fGB99L9IoGzel0QlVV1pPluOlcpbGmqBXnlSIwdV3b9aTechiGk7WgypP3cu2qsVDX53E5ng4Iv4vh34UY8haH8mzIckwOxwO8+wBBHAPJiFN/tPONY8Jncb1wDtP4piHANak8IOICwBrgXdehqioURTEx4K8ZYodyj+j+PZJVhjapUJRH21d1EpQof9ShIM9oOA3DYNGd29vbiaORJMkEgZnpl9NsDLwSUdFSINMb930fdV0jz3OEYYg4jq2w4+JQRV+WJbqwQ7SIYNrEwn6n0wm+75+//7RAFZpmchhhNgoHLngq1HEcJ1AvEYAoiqzwoJLhIlNFRE+NHlpRFAAuSt/1kKgo6U2qRa9WPmFv4AJLArDtT5IEp9PJClsNG1DRj+MIc1tgbAwQduiTE9CceVLXNcqynDyHkDY9+rquX3iP2v/j8ThRouQxFSYVifKPY63hhWEYJmNHQ6jrOjwfNth524lCc+FsjiuNE1XuFLZd1+HD4wfsk3O+SV3XqOt6gqyoAcM+cs5yPvd9jzRNrXFAVIk8KssSvu9bhAY4GyIU6hxH8pv3sP38joosDEM7h2lg09On0UIlwXnX9/0ZCREDlNeTL1x7nG8attA2csw47jRM+bl6tWoguAaGGrvuNWq0GGOscf38/Iw6q88y4thb5CGKIrRti6IsMGJEEAbomx714TyevL/rOuuMhGGIxMsQnjKYaMApOWB/2NtwCcM/XHc0TokWUOZwDuo4cR7r+qA849yv97V1eFwEhnzVtcVr1NDs+x6n0+nc96JAGIb4+PGj5UmaphNjaaYvo9kYeCVy0QAumjiOJ54dLWoKXHpTFIxBEGDEiLZrgeoCqdMzUoWu747jGMtkBc/30Ay1FbgUOFEUWY+MzwQw8WZVweR5jkW+hD8E6E2HqjlNBB09Zt3t4OYBAJeYssb5VCnyHipmvY/XEslwhbbGEYmOjOMjwvsdhnFA9ckb5HWKKpAPNG4o9DVsQK8qCIIXHg55SAVF3ioSwv81v0MFIfmi/KGRx881b4H38LluXNiNpY7jaOeBClx3jFxSFCUMz1CvGhtEJYBpaAiAVWAkVcqcX1REVLCuscjvOEZU5BqyUaO36zoURYHlcmn5y2dz7aRpahWhu0ODfeD7lJTfyhs1yDTspfA855uif5x/anDqvHPXpfKQ48k2qnOha7DveyyyBeIPa+APKbzlgOTvBpRBOXFa1JBm24lmcF5zrNkHDaEpX/juoihe5FK4hhDfqfON7VHEj/NI0VAdWwBIkuS/mgTK/9ZpNgZekbigSJz09Cy42Lk46I2qdUwI2/M8a1lrTJqLTxdwFEZY4Rbhf1jBAAj/voLJjRV+6jGplwKcBU1Zli9io2mSIXq/RP+Dh+jdiPD7EKemtIpZ4/lsowp04GVCkgpRtke/1//ZbkU3tO/qrbnecX1FoGtCmcZOCe2qoiaq4ypjesQaJ3e9TP7vCihe6wpDVS6KqPA7FayuIUAY3P1e5wf/5m/93PXwlFdUukmSIAxDayyq98f5TKVM5aE8i6LIKj++71qSm4ZSOL5uOEkNQI4b3+n2QRM0h2FAnufWw+YYcrzZZ7ZHjUaXp64xQD7qtcpjjr0mz14zxnUNsE06TwG8aCPnKNeketd93wMDgBEYBwDDOHmGGu6KFpVl+WIe6/vZX5ff7KdrtLpz0/3tPo9jo8iZi8SRfzRUZmPgdWg2Bl6JNAsauCxsevTqnZI0SYeCk8ZAGIYoisIKTsKzXBiMJfd9jziKEQwxhq0BRiAoAkR30SSufDqdrJc7DINFFsIwnMDvhGH7tkf30WDYA8Yz8L+7CGsqVjfsoTsQ3Ex3FfYqjNWjVAGh3juf7ypEhktoGDCmTX5qYhw9DSoZvoMxVj5T20yBqJC2CwfzPl6nCkiFpCIKLnTKvnA8eD3bqF6YtpVQvyofjreLtLA9apgqQsG+6bjSGFBvlvdwnlZVZdEvhow0YVW9UO0D30+FpmuA9xOxIrJGYzOO48kzxnHEcrm040wlTz5z3NUY0DbpmJNPCmlzLikv2V7lsasA9bu6rm3ftE18Huel9pW8qarKjh1RGv1OwyR0IopTgeA+RpKN6KMG5XCcQOpsq6JrdV1buJ+Gr4ZGSFyT5BXH3w2B8Pm6rq8Zn/zteZ5NFKasY36GjrU6FnRkZvpymo2BfyaiANFsWI19queiC4s1BfhdURR2odE4UA+p73vAAE1WIv7q7CV2eW1jbaqUSUmSYLfbWWGpnh6FfD92MF/VCIIY/psRvdehOJyFPa1xXZTMjdBdC67ABi5e7bWYd5Zl9vmqENWI0DZrAh+91+PxiCzLLM/pQQCXfArmSez3e/tMvl+TPWkY+b6P4/Fon0M41fXQdXcB54B6kMAlW15j3q4yV1hdEQTlH8eR/KGi1OsVLRnH0faN71GEiMpJYXiOraskmHdBwbzf7+3z6WFy3pMnOj84hwFM8jc4V6gcx3G0hjSfQb4dDocJasEdGmpsKALHhETmDWio45rnDky3RfKH7VRjgePHRD1Fjvg87YcawhxL3X6n7VDlyuRLGhpM7Nzv9/Z+tr1pGuywQRkdzoZc001QMc4Xrg/uRFJDWfNcFM3ge8gHGtTKF65NOiE6HmpY6Bobx9EaO5xDOr/JF7a7bVtkWTbnDLwSzcbAK5HCd6rINKanniAXkQoi4JIYR4FLK3kYholQBi4GR9d12HnPWP3qrGDrrsKpumSzU1DzHs/z7CI6HA4WnaBipaKO72JEbwa0OGeLq/XPWDJ3FDCJjMqVi1shYbZb4U6F/tXbVg+N7aFic3dCsN2ah+H7vk2GAmB3CrgJSgpHcjwo0ChgifC4CZI6BhS0bLeGZ3R+cIsU+cD7lLfqjeqc4T1qKOR5jkW6hGd8VO0Ju/12gswo1KptdBUSFXAcx8jz3CacUmlyHMljfr/ZbKzwV5SCxq9+pu8jL5fLpeURjRBjLuEH3X6nc5O7XkiKBrjIC59Hhaw/bk6LKkzOQ22/Kns14qiklMdurQ6de7yHc0MNfEX0xnG03rLuauFzqRDJG+1DVVXogsucVeOQ9UIocyiDGJokr1Q+KargGqyfCxFwdw77SfnG8WeYUWWgGliK4NDQVISQO0Rm+nKajYF/JlKh5AoBfq8xR/X8gKmgca1iVQy8hpnunysW5MJzvFcXsQqLYRhQlAXaqH0BEbN9NDD0M5K+U4Wt+51+5rbF5aVe6/KQwpMCUkMhCvG7KIV60xR8LnJDoafjeK2vCmOyzeox8VoqRf6tSkyv+2NEgX23uMfd4Rt4dYDiboNh0WO3371om8tXl78kjqsbN9dnUFi7yIO+UwU655oqF97jesuKbCjfXN5oXNnlVxiGSOIEMJgYWdoPd35+jsfaJ7cd167X6/S51/iu32n7yA9+TmPMNQw1FOL2x51zGqpSg4zPUaV+bQ7+sT67/Xfb4fZTf9hOOihxFKMfertr6lo73Pn8ubbN9OfRbAy8ErkKWCe61h6oqupFghEAG3NlpjVj5K5SorBs2xZxHNuwAxEI/nBhM/FwtVrZrPjn52cLib99+9Yqey0kwvt837deMf+mUG/b1kLx3AampN68Ln5+p5+rJ+Dey/i3KwRUgahS4bMJJTPurDAyAJu8SaLHospGY7sArgp7NWIATBL7NBbNmLAKazd/4pqhpPwhT/j8eMwQbDKYxiCJFwiSy44R13Dk2PF/dyxI7LuODdum+QAALKxLIyKOY/sZ5xQLYXEcFe7XHSKugNecgaZp7LOD4Hx+Bwvt8F4iC8tojfiQA9GI9uaEsirsnCYiQP5wzK8ZP2qccIy5BZTzkp4ta2KoR82x5njonFcvm9dzzXOHCz/nnOLOGE2ujKIIx+PxRWiDuREMXRB2V6New27GGLvmgWllST5XixLxe64NzWv5YwYnn8P5y/m4Wq7wkL3Dor5BnZzwFL7H09PjxBjXOg4zvT7NxsA/A6mCAS5JYRR8XJCqICh4CKOph69CXaFsQvWE/FW5UqlT4bFIEeFSXbA0HlRAa2EYvTbP8wmET8FJyNW11DWu6sZS3bwDJTfDWvl6zct2PQ29V40dVaQu5OjGfNlGFYzaFu2rwpyKulDYchyv7QBgLJrP0fdrP/SHc6cxFfp1Ba8KUKWFHXc1VBTqvcYjhcF5H4vPcL5yHNWbB87FidzYLiF9zh3OLTUsdA7rXGIb+R7d9qdhGCbVMdGRBmkQhIifFxj+IYKJgOjfjKj9ahL+UUhelaGS64HrmAPnNX1/d49VdIth7PFUfMRms7nqVZOHvF+z4mkQkge+7+P25hYLf4XRG7Gvt9jv95PcHy2ipU4I57DG+2lIaQye7WMYRueLyi5+Tl7pPNZ3E5FUw4l/X0P6lN9s0zJfYf38BsFjhmCZofn2hGdvM1lTmkzLMdG5ONOX0WwMvCK5MJ4KXS4azZK+JqC46OnFEipzF596GVQomuBDBcAFrZ67ZtSrd+D7vs0fcD0ETVBTL56LkwqA/VZlyO8/B+mpUlS+aRuAaX0CfYfrxaRpiuVihcAPUDUn7Ha7SQyd71Clq89SQeMiMte8HVVkvI/jxO8/p1zUSHJRB7bJNTx4TV3XeDp+RLtu4N/4OFYHe9LdNUPJfY4biuIPgMkOk2vGFseEyJD7nesduqgL76eRQL4o0kOjVMeFuSHcxUBP2bZ1GIAAMAHOpXHNiKEfJjxRY0DnFtvpGq1K7Gee5bjHV8h++4AxGIC3Bu2ytSXG1cjUtaj8JFHJeZ6H5XKFm/YB6e/uMYY9zHcGVVTZLX+6dt38BmOMNWaV/5pIrMa72xbKH37uzqNrfNKEVzd0pvzSd7lr73zfiDEYMAYAggHDeOkjSY0mNRhneh2ajYFXIhXeWnWPHqmbLc1F6nplFKz0zHhvnufo+94mxVGYtW2L7XaLIAgmIQhdtHEc43Q62bACk4SA6Ra+cTyXJfY8zyIQFJxsG4u7MJyRpqkNcbhKhotX20NyPQ1N7nNRByqAa963m7BojMH9+h7r4zv4TYjT3RZd3k0SHdXA0ji/GgLkPceWbQCmQo2CUItAqbDj9fxcS8Oqh+x6Z4vFwlbh4zxx322MsWWAAUySyDShj8/Ua7jNjf0mGqXeKtvHJDBVpIp6sD1anInznVu/6Bkrj1XQc93orozj8ThJuKSRrAWgdPy55bC9LRD+6x4IgMor0ZwuaImuN64fRRxc5aI81HEMwxBBG8PUPkznIRgihMFljRP1UEPM3WGhz2R7ojCCf4phKg9oDYIhmsw7XTOugncNLc/zXhyBfs2g0zWuyBPnBnfruDxUPrp9cQ3pxWIBjOeS22qwcJ7sjjtE6wRpXqHxS+xPuxeGsBpvwKUKqud52O12k4TSmf58mo2BVyIuCnoynufZyUolTCVL2JRb6VT5MTP48fERaZpawRnHsd0ipXDzOJ6zjVlulp46t/TQc+M2LODlyXCka17dOI42mScIAqv82T+2XYvN8H+trMZ3qcdEGNgVTipIKORd4aUKgnwAgCzLkA4LRB+WQGMQ+z3iPMG2304UGPngtkmRDxK/59Y4hXTZBiX1cPkeVeCq4Mhj8rJtW9ze3OI+eAe/D3B6c8CPjz9Yz5DeuypxHU8iO2yDemWaiKYICZ+nfdYtXlS+5PN2u7XjRqiZc5/xd2Z5az4ChT/bxnKy5EGe55PwWJZl9m/OCxqFPMSI1xdFcX4XRpy6EkP+KazRX97JjHzgsqWN46FIhatUFNa3UH3boFg+w3vnY/B7VOER5a604+6iKcxn4NrV8WGbuq7D/rDD4mYJ/ysfvd/hiK1FaYIgwPF4tDkFSm7tBM5R5jjoZ8Nw3pnEo755v+4K4bPoHHBNa7iLSOI1dIXzKQgCvLl7g1V/hxEjtukTnvcbe+ok11BZlvip+8GOJw1cDWHqToooivD2/i0WzS0aU+Nj8hN+/PnHFwWoZvrTaTYG/hlIBWxd11iv15NkKH5Pz4T7xXkgyDieEwL1QBYKfC4ircXOBUlhQ6MiDEOkaWoTj7hYNQmKC5KeIpUGBQAFIwsiaRIR76U3p0iAu9PAVTauwdH3/SRE4cYVKTSpBPlMQsWaGd2HHcZFC1P56LMGw3gRclqMh/0BLtC+ls9VT86FNTU8oYWjgGl8mEKVQo9CVNESNyntJr7D8g/vYBof4VcxiuX0xDiSu51PSQU776MxofCyGqbcxko+8h3uc5nAR75QORlzLmNNNMOFhGnY0ZAg0jWO4+TsBK4FAJO6Gjof+r635yKoccS205vlvGU/kyhF6uWI/XMZW76H60MRIM3lYf+oxNu2xVP5EWVWYBwHFIdiguDonNIkYLZDx0sLajVNg8fyA6plibbvcNweJol9DLdoXgpJx1rXmxqi6s3rGnRDVr7vY71aY5WtYUYP9XjCbr+zSINrjCuyxrkHAHEUY9XfI//h4dy27zyUcTEZa643hjK1bZqIq3kJi3yBZXOH7Pd3SM2I/m2Pbba1dVpm+vNpNgZeiShkFWpT4aSeggvladxNFyMVO42AcRwtMkCFS49DlZoqd/U41cNReJdE61+FjCobrQamEKV6rJpEqMJJ+0l4XyFY4JKRrNAn71chpu9WPgFnAf50/Ijhqx6BCXFod9g/7194wOSD67m6kL6+m0LcRQ1oRF323wNNU6MoignaoXPBfYYaXcZ4MKMBRgMzXgwj9SZV0LswMHnpGggalnDjuyzIxGu0PgTbzTHWKoZU8O680H5yvvMd1/aWq9esnin5ToOPioZhLKJuAOxhXW74gWszjmIETxm63/qIFhFW9xUO0WEyr9VIU6WkvNT8hePxOLlHr2f7OfY0HrVvfI/mlxyPR1vISd+t6BWv/Rz6pG11YXydN9cMBjojd4s3uP34NUzroXy3QZ/3NnHTRbb0h3wfxxEjxvNc7j+1aXiZTKhrxF37ytfJ+BjAwMM4mE9/T2XJTH8+zcbAK5Fa3hSAFERq2QOXZMKu6yzsrsKRQlY9dT2ngEYBq8SpsKABoMU+GCpwFZHGTSloiVRovI/9KcvSenIUPlSmVBRuNr6SqyA+58mwbfToiIa4BpWSeir7/R5FUVw1HFwBS0Gsz6UApxDntYTO3XdTOd6sb7BqHmD2EerVHs/JR2y32xeelAvbqsDr+x7Hbofouxh+F+IYPaM8lFfnnCp3/YzKXZ9PxebGfXkPecHrmRPi5mnQs9eYr/6vXrBrDLDP+r2bIKswr6JMithw3iZxiuy4hv8xgnnXwlt4V6vh8Z4gCIBtgGEHmDZAeB/bIlVqHCpq4nr7NGTJD3dLnTvneZ2OlYsWuXNBcxi0H3y2ImHuunM9fiI57jOuGZHaft/3kYwpvH0E9AbhKoWJLgiJrl13DgKXXKS6rnFYPsN8bzACKKM9gv4SvuQzXDmm80F5yncVRYHD/Qb49YimbfDYvbflsGf6ZTQbA69ECilqbW0AV/fvqhfG366SYPKgenkUFEmS2P3/RAg0x0Cv1XwGV/lQYfLdKrQV9lMlwlAHPTz2h3E+VbxUtm71Pk0YpDGhcdv1ao2b8B5m9LBPNtjsNi92FaiXpQKW7WJYhnu/XYGl/VWkRL06VUR5ntuEUO2v552TNO+WD/D+v2sMe4NsCIBve7v/nGPsIihsO/M5hmHAdr9FnZ691ePHo+UP26hzhvzmGDAGrzkbija5fGOIh0qDc4RKr6oqO6+SJEGe5xNPmIqI29f4bibmqefHZ+p8Z594vDTHRE/pbJrmRTVIz/OQ+TnMbzP0BRB0HtJ/eUmKZZ94BC9zd8K/CoCuR593GMN+km+hypNrWhWfGka83j2yWA1ofqdojs5/t5aDIghKvI/P1tg9642ot+4aHVy/Ov94reYaqCEfhiEqv0Ty5gTUBmWyQ/WprgOf7W4nVMOF7W7bFk+7RxTJ8Ry29DJ8lXyHNmuwKT9if9jb+xja4fM4v3Q+6zzY7J6wD3Y4HA/Y7/dzAuEX0mwMvBK5QoMCwIXNr1USc0kFvethcSFrHJPPcRc28HJL4rUMZFc58b3X+qdGgUKF2o5r96tHrj9BEODu9g5ZmKNDh+3+Gb7v4ya4x+oPX8P0BsHXEeqsxrE4vrhfn+tC6LrtUSFZF4FRxc9nqAFFgeR60AqPA8BgeviLAab1gWyAH3qT3I5hGKzSpJHEcVU+6R59TRR1lT/bovNAPTvlizsWrnGp0L6Ol6s8qCwpeKmcdfuaa5ipcnJj6hq6uoZ0uDFxNapGb4C/GDAOHkw+YhynlSI1nGaMQdu1iO47eEmF4rjH/nk38ZaVP66R6fL42tp11w+voRJXvn5uffEZ1yBvfq/fuaiFGrQu+qbX8DnaXkUV6rrG0/4jqvyEMR1wqk42JOLyye27fg/AJjjf391jubtH8mGNIe2Ab0aUp3JiNOlz3Weqk8HnAudzKmZD4MtpNgZeiTRfgF5NGIb2fHrCtkmSnIWrOW8jAoC6qV8YB1oVjQJRk7U0oYrfadVAKhxa2hTY/NEsYSpNvlOtfBXsxpzzBtI0tYgF8HKRsj2u4FLjg22/vbnFO/MrJB9X6BYn+Dc+DuUePgKY1ocZDCJEL4wgFXr0BN1r9MwF9YLJT3qmvJe81bFUxUv+Uhmu12t73fF4RFkXWPw6gPnaQx+dr729vbUeZt/3OB6POBwOE0GnSZnAFK1wK79x7Dl2moxIxca+aqKZKm8AE+iYc0B3hJBHPLiKY8rEL+5uIF+uGaRRFJ23lH16b1mW9uRA4HJiJv9Wxazeohp3XF95nqMZawR/e0LQhxiSFlVT2VCXGjOKZtRNjX2xw3a3ndQE0HcqBO8qV53TrvJXmN5VlEp8h65fVcyck3o4lK4pba8iOWpIXDNg3CRMziPOAa35MI4j9vs9jsfji+fofNM+U25oDgTnhO1nFwCdB9N68HE5SVJliM5L1zh3w208lGymL6fZGHglUitcF7sqbyqcOIrh7SOsqgh1XmAbPtm4uN6nOQFcEFpSN8syGGOsYGYilCpFQqXqcaln5yYk+r4/gftdg4MLl1nXi8XCfq7Cim11D6vhQqdgiqMY8dMC3nOIsPUQZQk874jS3yP8VQKv93BMNyg3Fw+CtRbY7izLrCLRmgx6YJGewqdCUQUJj40GYBV3mqZYLpcoisIaQzTuttutfQbrPDC3wzRT1IKZ7YvFwipT8lI9Rw3JqBJUIc45Rn4r/M/vuINEQwqu0CQawARUnlqnRiT7p8bk4XDA3d2dnSvkCZ+p7eW2OJ0rVBZaf55jw3lLJcEQjyoZzt8gCHAyBQYMqHe1ba+iNiRF5JgjQ+OG35O/OhbsE5WU8tFVwKq4+TdlgZt/QnTDNUCASwEv1+jgmLDtn0MoXKRJES01yNXR0Nwfkj6fBgrfrW2/hijRsGDF067rUJQFDutHLIIBbVhh225svsY1JEWREL5bDYY0TSdzaKYvo9kYeCXSJDWNezHGp95aHiyA3+YYdh7CdwbJ1yV24w7AxROjglFlzKRBVQxBECDLMhyPR+R5bgU2388Yt7tNjkIhjmObIQzAJmARaSBMrQVUgIsCpMCiYnMFDhewKiZte9u3aJYF4sZDt6zOW5h2u/MJjcsGJjA47o5WOKqhpf3hDoo0TW3JZCIDjIUrEqJtpTfJqnZ8Bz1KbnnSgjqq9Fxv6VobKfSAs+BdrVZo29YqS3qzehQt+a28U+HP8yhIrvd2Dd1Rg02fpcV+dJyMMdY7ZG4Af3ueZ40kzh1C/4owcFzID/aRe8fZNq05QLhfQyYcR+ablGU5MYg0jEJPV+sucGzKsrRGtbsPX4njwrlD5ITf6fWuUlb+K6/Vy1Uldg0ZUpnC9ajznc/VcAsRFipRfa/KDXVeFCHQ9nB+K+9UYatzoaQogW6bLcsSH733OMQ7tF2L426KOvCH9Q/Ib/7QAXGNL3fcZvplNBsDr0QUgK73pdC7zQMwI7zQYPQABCOGcRrDVwGgsXxNdnKzvV1lwUWs0K8qav5QGLOtXLjXoMamaSYLn0reTRZUj8P1WJVfvu9jv9/DW/+A7PscTd/YI3ibpsFms7HvZhlWFUA0UOg9chcFBaJC41ooSY9p1Xi8hmM07sz3k2gIaSY5+a2KV/uq/GAWuiI4KkCVlGfu39dgY/dazgnNmXDHhX+rl+heo94ocDH+1JunQtFiVPyeClznh7bL9b7Zdg0B6XVu2IPrg33kfKfBxDmhc1yNbh1bfb+bu6OeqbafbdM15hpvLmnb3c/dcSIv+L+iBm4SpCsD1CDU+3W+u9458PKwIndNaxt0HBW10PDhOJ4PDzscDi9ki44Hr9X/FbHRa7j255yBL6fZGHhFUuHhJgxROUVRhGaskf7dCcHJw8k/oi6rF5Oe2ep62Itmi2tiFkk9KPUKrlnPXKQ8DU4VIIWAWuHAWSEQftVnqzLQRDQKA2Aa71SvqG1bPG2esAt29t3advJSYV7PO287pKBnkp6bca/Z6hwXxqlV+Om1HCd6wAqp6m/lgxoOOn78Tg0yYOq5su28VksK6zxy/2ab+bkKeo6VK7zVyFPjUNEdheV5r4aV2C9N+uK4MlRyrY4An6VbXDW2r5n16n3Su+R8548epqXjy//ZHl5DD1WLIbFNisKoUaE8d40rV8Hqd6oYP0fXDD8lHkLmez6qunqxtdDlKdvhevfaBiIKulaBaY6K9tWtBeL7vj3tlOvDHQvXCLq2nZHvdx2cazttaNC44Se+S6t5zvRlNBsDr0RahUtjuCpouBC6rkMdlRiz0ca1eX6Aer56PgAwPQxILe4gOB8d60KaURTZSoZUdAwZELZ1y9e6yty1wrUwUF3XWCwWVmDrFkpdzK5i1xKmijq4nq1CqprVT9g5yzJEUYTD4TCBphn7ZoiD46Fb1oDL9sa6rm1SWl3Xk61YVERskyoYXkPYWyFrhcxVWNMIoLJKksT+8H62X40V9k2TPV3Br/zTnRRsm4YJKETJY85bjhGJ7VcB73ne5HwLjiN5ql4heaDnDKhCJ2/SNJ3Md4YT6NErD4gC0cvX3AflMQALLWvOA8dckxNV8ShaxLAR38+5AWCSV8H/FR10oXLXAGNb3XwO3/dxe3OHFW7hdyGK9Q5P5uMkbMfxVxnAOa7KXOcAx1CNXE1S1LVKPvDvYRjwzdff4MZ/QNCGKLI9Pmx/RlEUE6ObfFDUQVEOtoP919wIF1nh/OOcU8eIMlMNo5m+jGZj4JWIC1/jbJy49F6579sYg8iL4Q8h/CxAcbrExLlneBgGG/t2wwPABUGgpa97yvleClyNcff9pQQrSRecKmEKKhU4GpuMoghN06Cua1sxTT1p9ZTZHipkknoSbuxR970Pw/lQJIXXGYKhYlBh5sLxFHgsT2uMwWazsTUhhmFAURQTxa+8V2+ISpyCVD16evvMieD7VJlyrBh7z7IMebjE2ANd22Pz/GQNAh4RzHGggNd+6hxUvioa4xqqbvhIi0mpwUS+scYClavWTiCPGboBYJUE54kxxpYPJl/4Peeg8pvIjypJVaLKX95PxUC0a7FY2NoFVP48M0H55nqvirK4ORmu4iZdM/p1LqlhqwaIEp/v+z5yLLH88Q1Q+Qi/jlGmR5tkrDk+bI+Lprgokr6DqIwb6lJjzw0VpWmKZXCD5Y9vYUofwbsE5eI42ffPe12+XctFcQ1ZN8Squ1zUOFCZRyRrRgZeh2Zj4JXI9cz4GX8rrJjGGbzf5xg2AaJvfAx3l7rc6kG60O+1d5Bc+OyaoHGvU89O7/tj8KXrDbrQ7rW+u5+717tt/1ybXWGqz3fbrf9f+9xFLIDPx07/GC/cMXbbrR6n2y8q2njI0P/HBEMDrB7ucUrLq2cRuBDsHxsnbePnruN3+lu/0/de4+c1vqpB6T7Lbbs7t1363Dhfu4YGcRRFSKLEbuHV57s/n3uvPvtz3/8xnv6593z2u9HAnCvvApiWPL52/bX1/L81j/Wazz3fjhUADABGnNvljI/Oi8+NlzvnPtt3ebfbjs99P9OX0WwMvBLpRNUMaQoH1huIoghe72N49DDuAS8JYG4u1rfeS+tXqwPSCqb3xmuNuRzkQy+cSoieIK1tog/GGFsLwUUUgEs8XL0kWuIMR6jnTE9Rk7R4vyrxa0lNWvBHr2f/eJCOChDy6HQ6TU5+I4/cWvj8jtvJCM2TL/Qc2S4iITxEh/cwJMK+caujGw5QxIUownK5tKiCDQWUHvqNwdAC2c0SeZZjv9/bd+scc6FhnlSpc41jx884Ru4pmGwnQz7KL61twPbrtjLylKgK8ziIZACw6AYrCC6XywmKpQiSVtJUBERrO2hyqyICnH+361sE+xTtBwD3LYaHy1x8fn7Gfr9HXdcWtXANNc45fndtKx+RJF5HUo/3jxkEnPtu/JvPYNjpOO4RfBvCb0Oc0j2q3emFx0++EJVim5j3oTkjGrIBYNcx5yXbwu/d9h2PR2zzDbyvAwRdhFNywHF7tPJKZZNr9Cl6oVtX1ZDjMxTN4vpW/mibuG14DhW8Ds3GwCuSwm/8n7AWJ3rbtmjGCsk3MYbYx/C2RjtcTi1TaJECkgqaygu4LGbdy6yJN/SiCVED00xpW5XtkyDRuCxhbq2URwGpwkYXa5Zl9qAYLmT1htWoILkJVhrzZR8IK1MBUFmo0uv7HkVRTOBntiFJkkl4hmOgbSCfGOtXqJXC2VVUunecELUaUTqObls1kQsA+rRG8E2IsTHwvgLC4hxqoPLTkrcKp/I9n0MPVCDzfW64gd8Retb4L78jasUwi8LsTHTjnAAuxwNzqyvbwgRD5S+VEQ0vVUoaxtC/wzC0OQuch8YYRCZB848+2o9AdPKRfQe0/TmMdTwebW0HzisNlVAR67zU/AWOr5YRVkOc40ojhetNFaDC5G5in4bIxnHE0+ZcwjcIAjTPzaSGiJtsqWECDcfpLia3b5qHpMb+NSOF82S72+IUn3Oc6qf6ReIgf7tGC8eT48x28J3qMLj3KZ8U6fE8zx55PaMDr0OzMfDPTBQyFDp1XeNx84jlskbykKLrW1vkR70l7vcHLhndagHrXnnGz10v3vXI9X8VDm7yEYWHKkQKXl3MfKZ+zj6rcNLP1dt3BRPvoUBl8p4KOO2fKiVVfH8sBKEKG7jEM92dA+6PGhNsG5W0JkOyL26xKQAWDaiqaqKEmrBC+FcDPGMweACKMw/oWev8IWnSn+uJKk/YJh1XVSLKSxp9NAj5LBqh9ERpPAAXpIS/t9utbRdzETQhk8aVOy7u2CkyREPMPfOD42WTBfsGY2rgxT6CtcGIM69Zt0I9TzckwndpGzTHwoXQ3fvdXAIaATqHdFzUMHDnP8fLrf6nz1bFqQrTnSf6PhL75M4r8lrbQp7QANbdGNofFwlhm+nQcOxd9IBtU6NEjRc1/vkc9t09qG2mL6PZGHglUotYJyyFAr1bZq6fTifc3NzYya+QOhWfZpjrtjkXLuOC0iQqLiYuRlWe7q4EPSKW2+pcCI/eETPwFTngQnU9YFdgqMAlz3SrE69huIN1A+gda/Ek9lfbqMqaz1cjSceJvHGNL0VxXGWqPFcPkaRjxOQ3F8LXBDDylN43AKxWK6v41FtWo++aJ8mx1X7qbxoPxhjkeY5FvsA4jijKwu5o0W2QTLwDgMViYQ0Zz/OQZZnlT5qm1pBi1UBFyHR3gZ63AEwLHXGNUIHqvOM8YAltTfRkguIwDDic9oi/T5H9VQ6Tjtjtz0cBbzabyVZLd+ua8kgz76mk1IjSQjj6OcdEQwfujhnXi1XIXhUg26JGgxoxfJeGWXTOa5Id56W73lTuqOK3aJUkKAOYtI99UIPGNR6Uh0q6jq7NUT6XfHQRtr7vrbxywwgzfRnNxsArERe6xtBUsVF50igAznE4ej1ciKfTCZ7nYblcom1b5HkOADY2rNcyHsuYL4WVMZftTKfTyW6PAqZH9gKYCDvgsh9bF7wqrXEcrUGgnguVhxt/db1mVeTkBa+ld9A0DW5vb21cu21b3Nzc2L7y+fRQFSGgMROGIbIsQ1VVVikpvDyO522dRVFMoHuGVeh5qBdN3lBp6tioUivL0o4VPWFC+gxpqJJnG425lK+mQVDX9WR7G4DJOCuc7hqD5DWfS76+Sb5CeEzRZzWQwYaKeHYAjaMwDLFarazxQgWiIRLf922WOwU1SxRznutcco0svYb1LrhDhdtfsyxDnueT0tYswU2laBWj1+EwblE9V9hut9jv9/aZfJ96p+SPa1BxfWhxpWsGF+cGDQE12NUI5LWc5xq/18z6ayiYGi5u2zkG/IzzQWWFuya5s4m5HHw/q5Hqc9nXJEmsvNHtlZQ1nJOuYcG5q+tcSdcY5xV5RN7o/yozaBzOyMDr0GwMvBLRCKA3qt4ucKk57yZ16aI2xmC1Wk2gUS5OKj4KRBVQ3EpFD48KhgKJi4xtUA+F3j2VnBb3ITEerLFKTTQj6TZCogzqxXCLowoS8oDPo3CJ49h6TE3T4HA42JwBVcgUIoTtFa04HA7wPA+LxWKyNZAeKr1xbTtLEJMX2k6NnfOdHEv19o0xOBwOk9LOrudH70aNAQDY7XZ2bDSEQVIPnsoTmFZB1D6p4eh5HpIwRfbxDv4mxrhsUXx9sONNw7Cua2sUcfuW1lYoy9IaOFT63CbJMaYRTCXsKhXX43UT1/T69XqN9XqNcRwtqpYkycQgNsZMFD/DAsDZCNHdBZoX4s5JRSVIbJO7RrRoEv9Xb9UNSanXrTkbGjIi/zX3QD1tLUnM79RwIKKksme1Wtn5lqYpkiEDBoMh6VCcjjYcFQQB7u7u7Hu4HVMTj935yLZpSIRt0bmqPNQDkbQWgiauquGjpCGFruvsWR8zfTnNxsArExU5cFm8/F+t+q7rJpnrtOZVeGqmrzHG7gUnqYJxoctrMX+FqSm08jyfWPvaRhYtcqFEKolhGKz3DlyKjaigcusC8Dr1Lik4aOmzkBGRAD5D97mrItHywxQ26sEy94C8ZNsV/ief1KhTIaPtJSrBPdYaV1bBrwKeQlUVAhWwxuBZw0CrE6q3yWs0lqrKk0QDS+eKzYQPR8AbMQbTuaSxZCpHGjTkMQ8l0piuIjNN09hxJJ84bgBscSzOBXre6vUHQTCZV+wPv+NujqqqbDEhKi81vlWx6Pi4CljHWaF+RVbYF9fTvsY//VHjQtEAzptrpG3Tual5G4pOaIiO/GFoRUNVURRhEaww/tsMqIDwbxo0WY2yLK0Xr7JK1xXRrmtyhe1QVCqKIqxXa/hegFNV4lgc7fynccD7OC4u+sI+qmzUMAeNQZWJM/1ymo2BVyJNxtEJ7ipHnbiqeFx4VyE/jau7HhVwMQTcxaGLTD+nJ6GCUH+rEncX5bU+sf1csK7AZVt0W5ELJ3reZWvaarVCWZYoyxJ9f9nOqNv51MAhX0gKOzIRTz1f/lA4s/0KVV6L7zJ+yTarMaBjxms0IVPbRt7z+yiKbPVJTYpSpe+GWzRU4Pb7Gu/J70OxR3j3HskqQxNUOBYHi2q4hiZwqeBHhIoetz5bjR5FI9h+8odzg8+O43hyAqWOhRpN3A2gfa2qyp5Y13Xd5EhlNZTcXAS2l20nqQFIheQqa4Xjdc3wPW4MW8dZn6Vz3+U736Of6fi5uUPsL/uUpunZ+/9kUBIFseu18TAUBmMDmNID0peJpmybxuXVkOV2RiIlahxxPr+5e4u74muEVYzi/hnvvR+w3W4na9c1KhQtUWNH/3eRFzcnYaZfTrMx8ErERaGldoHrC1utWi3h63neJEbpeksah73mnahSc6Fp17Bgm+hNKTxLWHUYzlX5VGjTOlfBaMylRrgKe/bxGuSnmcFs+3KxRDYsET2l8JYBhmR4EV9n31WgUNgSmma7iCqol8pT9mgIqPDTHQKuMOJ7P2fwuciAes8aL1UjSo0S/q17xMlXNQDJU00AVeVA5ZckyYuSwQCw2+9QlIWFfBk35rx15xARI+aH6PiS92qc9P356GjWFODc4jHTp9PJojfLdInouACCEc2iwHa3nYQN+PfpdMLpdLLjnKaprRnAfhOBI3ysSYJuOWXdEcO+6twncc6wHZwzRC3UMOWz1KhXHlKBugaItkPXtSIKOt/5GflDHrM073q9xnK5tNuDD4fDBKavFyfEfxXAND66hxp91794D0lLKDMniIbW8XicKHFdB3EcIzdLRI85UPtIwiWSZWLXiMpEfbfmv7hol7uWxnG0+TQzvQ7NxsArkQshqncOvIytAVNl6WawX/MmVGipR0EY+prXDuCFZ6TtosBj21w4nPFihSldJTgMg00ic4WdLm4lCgV64UmSIDE5xv+Y4PRsEHwXI/5NYj1mwv5q3KiRoO3heDDEwXdoQhTboIYC/1cFyz6Rh/xO69qzTSq0dV5cM+Dc/AoKWe2noh/Kcz5DjRCOc5ZluF8/IA1yFN0Bz7vN5OwEvrsoiomn546TCwfre11hrjFsKg5+RsNYjT7fP9cgCJ5yNP+rDxMB4b9J4fuHSYza9VTVOGEISdeF63HrGOu6VIOcSppzkYiM651yPrl952/dseOSKkEXWndJ+8z2Km/Zbl07DKuwn5QFRLMUyanaE/BuxDiMOBaXMuhu4h7nAPmlBtQ4jrbYD41S1kGg7GpQoV828IMIXVaj67sXc0vnNdeKyicXDdGj4clrzQ2Z6ctoNgZeibiY3Li7K6DUY2F8UuFE9W64+Pm3K6T4DlUctNIpeBgLJESr96lA5AJr29bmJtDKpyAm7M62AhdDg56bK+g0L8AVyIznR1GEPM/heQajAUZzrnfKbvLdqiSVjxpj1bFgW5n7oF6vXqs5CerFU/F0XWcT3/i97gBgW3i9GhBuHJnKSb1wnh8BXBAFPk8NEvKCfGd7+VkURXhYv8X97hsERYLkzQL9qsNms7HP1gxzPpd8UoWtHr/mk7jKXw0njgVzBqIwAkYD3/cmitLzPHjGAzBiNPhUb3e0IQFVZGqw6Txwz9fIsgxZksEYg1N9ssmh2i6dm+wH+chYu6t0uIY4R5mrQMNQESjmLvCduu453zn2Sq7RoeN9rc36w3M21BhgoivnINug37OqJo19DQnoGtXcFlXgmuCszgJRmk3xhP62h38XoEGFYle8MH4875yzlEQpYEaUp9Iid8oDrkcaNjo3dffDTF9GszHwSqReuyqbYRgmSXhc8FQ+6q3qQqSHRNhYPWG+Q/drR1FkDwtSoU5jgJn2NEJUaDE2z4XPXAbXg9Vjk/lOKkkANhHJFWQk1zNQxRaGIcr+iORfjAhPEdrFCYfjYVI2Vr1yVWpa2ISKlQLk+++/t+9j3+k56R5meofABSHhbyYcatlhTdpi31RgM79hGAabZU/DR99ZVZU1vjim6vW5SA+VE3nBcWBbUi9DeEyB0keYJogeoony5/061/hbx9o1iPRAoXG8lLR2M+o5vlEUIakXMI8R+rzBIdmgqivrydV1jX45IP6bBUw4oo46VPtqUpGQJbzVAOH76YmyLbeLO+S7O5jBoLzd2vckSWKfwXnhGtdpmto6Bu4R3X3f2++5NtRY5pzjGNO4U8jb9Xx1jena1zXhGiIaJhiGAVmWYbFY2JoPzA3gOuT8Jg+voTur1Woil1j1UmUa+1QUxWQe6qmXDElwrldV9em9jxPjlvcSicqyDPfpWywOdxjDHvv1o+UneaVIkIva+P65TPnnEjFn+vNoNgZeieghaGxcvRIt2qLWtgpmd1sNFR0XWpIkdqFTGBMiVLiPP65HrbAiFaR6RSQKKG7jYmY7FyAhWioLzRZXL4zPdhUPBTPj/PROqrpCH/bwFh7qprZIhDHG1pOnIFW4moqZ3gMpDEMcDgfbX9alZ9a0eoEcG+ZEANMaC+QHvSiOF9/Je9Vj1qqGGseO49hm5ZM35K+253Q6TUonK+84P9arNdbBHbzexyk4ovdb1PcHBEmC+u6A4lRMYHCdaxwr8ko/U+VDUsOA/Ob59pz/bdsiSRIs8yXM7zPUfwC8pY/Fv1qiG1p75sL5Xc/wzA5DO6D9oZ2cZkkDjOOgULeus2E475JI6hzhjzkwGKTRgEW+x1P99OJYbf6osl0ulzbHoaoqZFlmn00DsG1bi35xTqpxV1UVDoeDPV+E21i5zjl2XAN6zC+vJe+15DONCV2TbC/bplC5ols0fHUbq67vLMssQsB5RqSB41zXNQ6HAwAgz3PLP7YzDEOkaYrtdvsi/4nyh+QajUmcYFndIni/BIIR2V/ViOPtCxSJfKCMc1Gea+GWmf58mo2BVyZdwCrM9Ds1ALIsQ54u4Hs+Tk1pE3PU++dCZiEYTn6bFPSpQIvC/bqYuHipmKjcgbMSYnIQwwQUDJrASK9FLXN+RsudCk958bm+q2GgCETf92g+1ZMPggBpnMI3AYZ+xLE4TIrHkHR3AjDNcKcxo3kNugtA20ChRkHGug0MhfCwJI6poiuK9qiHrXFutpV8JB+4l588Ihyq3iPfs1gssMrXZ16hQzrmWP7wDqb2EX2d4mP8BxyjI8I0RNPVFnbl+3XstI1EjThmekAQDUB+ryEaGk+cq0SaqrxCmqXwYg8mH9AOl+1pvL4sS2t0UDFzbqthzDHVsIyLpg1hjzEZYHqDMe5hYCyKpDFxANYAZS2LPM9tAiUNRq4vGjpsj+bfMDeC7WQFRjWOOM+Y+6KGiG6vU4XGcc6THJ7xUXUn7HY7a4gsl8tJfQQicjr3OXaKSnDtu6Er1iagoQ3A/lbkR5EORUKZyOeGGdQYUATKjnHfoQsbBHEPhCNa01heqzHqyhuVVW4e0Ey/nGZj4JVIvSyFBjVGqAKY8Npd9oDV41t4rY/T11sM2Y9WgPN+tYy54KikqEz4GRWRCnfNtGeynp54uFwurZA7Ho/Y7XbWICE8qj+uUKan51YgUyGnwkP5o/+rV+H7PvIsR/JxjfFDiNVDDCwvZYPVM1QFo4oqSZJz3Nqcqz3qwUt8D4WOGnAKgZJ3rDKoqIHmQ2hf3MRG8ocKj/FmNUY0fq+FpdR4iuMYD4u3WH/8Cqb30P7qgNEMQOcBnYHpz+jE5nkzUTZ8J9+rz2bbqWjYN9d75nxws97JUz7D885VNDfPG9w+AOFtgsbU2B2fUZal9TxZpEjXj4tKcN6Q1LjWcWzbFrt+g+7XLQw8VChQn+pJ3ozmb3B3DA1orYLn+/7kpEhWBCUfaXDzWo6vzikiXWejOwHGEZvnjY1vU0lq0p6GFsMwxF1+j9XTW5hTgOrdDv3inPSZZZlFLqgQ+X7loRqnXPcMVVFO6FZdOht63oYaEuoQcK1yXtJJobGRJMmk4Ji7LjmuZVlis/6A5W8q9OixLTc2ZKnygtfrfOV7tZ0zfRnNxsArkTtR1UJXCF2vCcMQcZ/C38ZAaxAuUwRJMBFMVAzurgN6LXwuF58qGSUtC5pl2UTwJ0liC/14nofj8TjxzCjAKMRZnY5bHbnnWBN5FLanB6M8ojDR3QRUmux7EqYwjxGGnYEfJEhuUus1s9/sM+OWFA5ZmmHl3SLYJOgXDZro4pmSKBQpnFnAhvxZrVa2fRprpiJSREWz5undaN/JQ/WkNe+C4Z88z60Qd6vUxXGMtM/hbWOYEcDOR3tfYvj6CX4Xoki3aI7NRKmqQaFenoukqNenOQKaWKeKQLeT6cFL5MXhcLCfE3nQd/Ne9ap1fVCBKXyuyWMce/692++ww86OAdvtogFBEFhDgJ68QvpUmFwbNMA1NyPLsonxTYVMSJ4GXehHMB8jdKce4W2MzfERh8NhYkjwb84f8ijoIvjbBKgN4kWO/O5cGZMxcs0B0Z0M6ixwHtH4Jz9YRIhjqWEwyirKA7ZLy1Sz8p86I2rsci1zDFV+aB+bpsHzdoNDsLeoBA1Ezlk1+mk8KVpF42GmL6fZGHglIoxKZaUTWYug6IJt2xZFfEB0t4DX+qiyI9qmtfA2k4MoJPWseI1XM/bHha6CKU1TGwelgqGwBF4ecqRCmMKCypJeoEL1Hz58mEDwJL1XPT3g4tmlaYosy3CzuEUy5OjCBtVY4nA4nJ/ZlEgfInhehP6+xqkrbRY528l+qHfkeR7SKEPwuxzdjwbeOsD6v+/QNPWkPS6SQeG/3+/PWx0/GT3DMCDPcxRFYfMGtHSqK8iTJEHTNDbpShEG5njQM6uqCs/PzzZnQIv7lOW5v0R5PM9DlZeI72uMncEpPmC336BuGnieQbNrLGSsYRSOC0NDGrpQ40yN2HE8bx+7Xz0g7BL0YYN9tbPFoJRcj5HICg0sVXo8j4P8UoNK26HGE5+pxgTnsIY1uE6iKLL/U9Ey8153lmheAhWRQs5UbDxcjAYFDRfdzlsUhV1zXJfxKcPp33sY2xHpb1ZI89KWFGdOCNEgNY6GYcAQ9xgfauDko14UGIfRzkkNM7HPVO784fzRSpZuOK+qqslOI86bIAiwXtwgaCKMyYBiOGK7fbbjoGW4eb3mCwCXw5cUZVFkSXmsYQHN/+HYqnGr1zPhUeXOTL+cZmPglUghMP7vwlfGmHPyT7YEYFC1J+xOzxhvB3jGw7E62EXtwuuuJ8fnaQyPn7nfufe4z6cAAvBCobv9uPa/q+zdtnwOxiNka35IUf3ow7tLEP11D2POeRPlqcR4B/g3Pqq+wvFwnOQbXOOvhY8NgHiECQ1MMmLEy8pz7pgB14+A1ZDB53ji3uPy4Bo/r4WCgIuydse5aRpsjo/o7s7e2748FxCiN7VYLPDVw1cwnkFRFZOqfMqja+PgzjFjDNaLG6y2bxE+pejXDYa3/aSEtvbJ7buLArh85zuUJ+5cvsbjP3aN+7+uBU2gdNuuKN6fMteplFx0Q9s2DAPgjzDxpy2y0QhgWvPARUL4u21b7E7P6G9bmBsfZVugLit7boa7xtW7d/v3uX64fWSbxnFEEicInzMM/xAB6YD07wYcg8NkTrrojvaBhgUNQEUFXLo2P6/JC8/zsMgXSOMMMMCpLiftmenLaTYGXpFoLatQJ1wMnD3Gh8VbrJ/fAgbYrz/iff0Tfnj/hxfK3608RziO5Hme9ULoTdKqZniBEC69I/WU6J2dTqdJDQIiDITsVbhQIak3rkl0zF5mW/RIW1cRkjdDP2I4GIwlgBBACxvLHMcRh2JvPSh6RoRaXSVCtOHMoBHDdyeMK4MhG1D3ld2upoJvsVgAgOUTBS6FKyFiYwxub2+x2+3sSZDu2FM4K5xNIlrDnATNNyACBMBuB+NOAhogvHa33+FwPEwQGj7j7fIrrJ/fYvRG7G8+4qf2B5xOJ6swOBddj4v94/yyHqIJ4FchUHswZQCDS0Ikw0yaw6G7WDh+amS6+SxBEOB0OgHAxMsnL3X7IHemBEFgPXXP85ClZ8h+SAbsdjuM46VyJ8cxjmPc3d3Zd9BL5tw05pxfovODa1mrF9Z1bb1p3e7LMSVcbw8XW/iI/ocYQztibwqMxWiPvuaWRa5BDUX1fY/Hx0dsvA3iOLYIX5qmNjZP3hLp0N0JACbQPbc9uqEeHSvywvd9jMMIrwrRnQDTewgRTXYRaXhEjQMiLqxfwDl2OBwmMkUNA0UkdR1pwu04jkiTFHfRGyw29xijAYfbj3g+biY7eGb6MpqNgVciFbKq9LgACVNm7RLexxQGQBIvEAQhxrG8ajnTAKCQ5SLmgiNUxhgdvwcu0C0TlVSY+r6PzWaDcTyHI9brtYU+u66bCCfdztN152N7CQtymxiFNbfsUQho5TuNtxMyH4YBTVsj+/YEL0nQ5zVO7c4KCOACH2dZZnc6MK5ORc3nqxJu2xalKZEuPm0Nqy8nGqoitmGFTxXVKDSpJFURKJTtbqWkIuD7KfQ5HyjEgUuGNuPTul1Ri05R0eoJdpqoqQWgoihCVq/hP6YYDRAlGZIksZ48eep6whrKoVHFMT02RyQPO8RRjmZR4nA6vDhRTxUsx5xzj31VBETbUZblpHaDKjk1MNhm8pM5Dbc3t7j1HxC0MarkCN/3bQiD4Ried6FzT42G0+mENE1tGIzzmOtPd/Mo7wBMCm1xnNQ4PVUnhFEHExv0x8tzadyqMtVwEueMzT34ZAzkeY66rm1IjmEMhg/ZPk2WZMKmhlJoSJIH7JutJtjWqNY7RH+1gJcDbdQgaIJPhcGmR5NzbXCt6uFmXJer1cqGJ8hn8lArF1LGAJfCYeRlGITITmt4jwngj4gW5xDedrt9sf12pl9GszHwSqRQLyewZhjbBRlWiBYdRozokwb98aIwXINAPXMKUl2MmgzHOKSrKPijZV65Z5oCjN6MJtNx2xSAiZChEFChxD7y2mvtZ1tV6bC//aJGm57Qdu0ka58CnAfp8DPGQI05x2a57UqV+TiOk2xpXksjhG1lG9g3jXmTH0RAaOxwbPkeHvlLAaZ5DS58qwiN7oKgEKSC4njwOZqxruNKRV7XNdp1hSjvAG9EF9XoimlOxDVIXZOv9Lm+72O/36HPO6Q3Keqmth4en8fxdFER3/cn3j95yDkBTE96JKkhrYaVQvLkZRAEWEQrpL+9Bwof/lcxmrtqcjyxohUcJz5f15UiLIqQXOsfDXt3Kyn5x6OV+TwqXOYeqCfuhtd0jMk34JL8SxSF84TGjuuAqBxyd4+wzUxkpczQkySPx7NhdfOr8xZNHlmtqAZ5owmM7C/rg3Atqdev60bnkbafvCAfAGDAgCY+IchTjFGP2lQvcjxm+jKajYFXIkUCqEj4ORdJWZZ48j+g/uYEjEDZXZKxXKWqCXEUIIo8qKJWhUcFnyU5uqEDcJycFkfvWhMeKZj4W1EGzVzWLHdmFeuiZpt5L9tPQaT91O+IRvB96sWpIcE+u1vgKFyU92yXFiiih6WhC02CUh4CsEqB/dcxonE0juPEWFHFQb6oAaFjx+/V0+JRvBTMfKdmi+uc035W4RHR3/sYxhHl8fAi0Y+C2BXAOl7uHNzv95OMbb1Xx52f8R3kq3ustWtwXPtc/3chYOXrOJ7LVsMAMCOoS/hsetXkOxWZojQahgGm53hwDNgXzkdVnMpbRWB4PZNNaXCrUaphCg0J6vgacykJrshUkiR2m2FdNcBoUNWXkJ/2iXOQv3WXC9ENfScAW2tBjVnggkxpMqquU1cOkBc0wukgqIzRsednfDblxPF4hLf8CcvvCwxjj+1xa8N1Go6b6ZfTbAy8El3LzNa4sW5BKqJiAnvq9e6iUCG2XC6td8OMdELfjAfHcYykXcD8Q4x4NSJ8CPD+8f2kDC7DCzRQKIx0z7LGqxWZoIdCCJvPdAXZ57w6EvuutRM01qs80GNuAUyEWdM0WK/X1pAZhsF6sMz4J0pCIcZnq6dHhEQrNhIipgDVsAeLywCwGfGqIDVmqhnQFJy6/1tLOu/3+0nlQg1HuLFVfX4YhgjHCN5PGTwzIlwcJ9swlX+coyp0Xa9S20ChTv5oPovGnflbq06qYqABpciQGofu3FdPE7jsd6cRemz2CL6JELQR6qRAWRV2jsZxjDzPEcexNWbUO1YDkl4715CiZeQV+a7Xcg7ouNDjZhwfwCQ8Rf5qQSPOJ0UfyGe2h/eWZWk/j+MYYZug+YcAaZIg+zrF8+HZngxJvurOA743SRLs93sbEiSfdE6wmBDfp/lBuqNCQ5Bc2y78r+Wc1Tikg6EIDMdHd7yM44jn7TPKuLTPmVGB16XZGHgloiJT6FXjqcDFuqYQUe9AhTMw9fg1fs3fZVlivV7bpKILJBoA/xSj/8HHmAPBKsJ6vbaKk1vD9IhZLnIaHVzYFGYWzu97fPjwwVaOU09ahQg/o7evECz7ogqXSpYGiyYQqqfNd+jWNB5vqwVstHIgjaYgCGwJVyYlbTYbu2+bQorH7yZJYoUqDSYNy6RpagUeBbVmq/PdjJVy/JMkwfF4tMfMktd8//F4tMVfKMi15oPuu6fyosGUFEuEPy8BM2LxfY1d8mwPktG92ep9MezCLW8cZ/JXjRZV+oqasD1qOPI5rEWhYStFAzjHFWpWCF7zCHg9f07VCWPyETBAc2ys15kkCW5ubhDHsW0fDSP2gfUd+GwXamf7df5qwiANIe2D3u96q2MLrPp7BLGPfl1Ptl0S/tdwItcdecH3LhaLS55HP6D63YD6PxuY2IOfAt14OUtD1y3nKQ0cGprMp+B1ajwy34AJkVEUYbFY2OdwHrHuAp/B/ASOseYR0bBgiFHDghwXTUrVfgzDMAnBMYSobZ7pl9NsDLwSUQi4kL2iA6Q4jnGzvEXoRzi1JXb77aTYBoWjwvAUGoTFqAwI81FwJEkCf9EDqQcsRrRo7BYzLhqeZcD30HOhwtDENLaD5xRobgFwNmziOMbbh3fwEaDuKuwPO9RNPRFG6hWqh8zFnmXZRMBwrzi9DsK7nufZZD4aUkRLaFxoTgEzqanI6XkrusL/qXwUcaHwogJk3JfPdHnIsaYQZfv1bIe7u7tJIlVd13h8fLSGhyonenUaEgEukL9+1oUNxqTD6I3owgZddc79uF3fIfIiVN0Jm+3Ghk7cUAnHQuP5VBDkr0LVOvddI0A9YLZXhTrv0Z0pNKYATGLTfIfC5hwPGo40eGjc2DwKyY9heIDrZhzPuTXcncI209BZLpeTXBsqNUUoFO5m/6jobm9vP90Xwt+GaP/XAF0IRP9jiOVyadcun6toiD5T0SAa9WEYous7hFkHkxmYFEA0oD22dn4mSYLn52dr+OguFj5DUbMoiibbUcl/zW9Qj1ydHU2YpSzhOui6DmmaYpWv0SU9muG8zokqKB+BSzEwndsqSxVZmtGB16PZGHgFMsbYil1FUUwUuApyXnuzusXD8TtExxSnux3MGnh8epzEyDTZR+FTemp8Nj1g4GLZmweDcJ2gDzqUbTFRdgpXA5h4/1y4CifTW2YBHI1JcuHf3dzhrvoK4SZHuy5h1gZPm8eJB6h5D+TJ5+LQ/IwQNAUV28PYq0KqimywXKvGLCl8CKlr/67FKil4VGFSubCdGiPVhED2i+/hM+gBKcxOxaRlWBVGVU9UeeVSURT4mP+E9rsGwIhtcy5/++bhDd6U3yHcp6hvjxjXwPuPP0+eqQaBPp9jxfkGXGLIOl6uwuLfOkZu/oiGOXS8yX/tv4tAuUgb28ikNW4TVF7qXAQuULZr1PCdHD9FQ8gz3TmkBjufwXtopGIE/CbC2AAYAG/w4PmePf2QRgwNG4XdySsSjUjOlWw1YvzXBghHFGM5MfTUuFYjnGtACyBpjpK+S+eHImMK+dP45nrQOUIeBSZA+MMS/rOH8OsK4w2wP+wmh54xNKD36tjzR9eTO2dn+uU0GwOvRITdNWOYglHhw3EcEZsEwTYFygBhkCF5l07yBgBYT4b3KEwMXDwpF9YchgH74x6+X6CvLzFeetkKP6sFz3czhk8hQUSCHjUwrVYXBAEiL0awTWD2AcIxRbyMJ0Jb+89YJz1gkkLCvIcCva5re5Y8hQs9cwpQ9fB1W6IaEeQFM74J/1NQ0sPX9vI+ogIcB37Otq/X60ndd0KwDJdQkfDdvK7vz6V7db4oKWTPecHfqoDbtsXj0yO2wdZ+5nkeYv8818wxQBTkiO8v597r88hT3svnKy/1ffrjCn/XoND2ax6JznUKdtfwIfTP+aqhIlUGmsGuW1zVmFEPX1EPReHUSNGfa2gN4Wxdg9pnzpe+75E/+Ej/+xx+7AHrDt22s7kw2h6WBNYtpzpWnOdc6zRq/PayJZFzi0gilTX7RoP0eDxOqgmq4cU5oWtY8y3Yzr7vsV6vAVxqcrBd5Fnf9xgaoPvZAKWBiUOkNynadFqlMwgCFEUxSY5WUmNR59NMr0OzMfBKxEXERBtCrW6ZznEcUQ0ndLclwiBFuy5xai5b9LggdUHxPlWeFJwaewQuW5J0exS9TxoqVHou3MZ3sKgLlZpb2EMzqYdhQDM0aNYl4tFDsypQtScrtBTKvr25xX32BoEJcMz2KE6XhC9NVqRhQKHEpD/1Doly8D72lwaCGiuKnChsTL6qIaFbrthnxkDV26QxxrGnIFdBRj7p/nM+j54jy+CqcuV76SnxtyI6VHSu0akJh+M4ouo+zTUvQ708oOovRXV03FVpcl65Xp7OS42ja784P/h8NfDIMyoJ9QTZFg1LcDz12byWqBlzb4IgsPUn1HNnX9UAdhEKDbupIaDjp0a9GgEu2nPt8KW+73Ec91i8+bQjp+5suIO8Y/4QeUclreEg5akaUJy/nDPKO72PY6Dt0+23aZpivz+fE8A5q8YW57fnedZpYL/dMBnnD7c+9qaFedvCO0QYH1p0Q2uNda5Bzm++lwnAbCtJjUkXyZzpl9NsDLwScUIyIYfKyvX2hmHA0/MjxpsBQR6i6Wtsd9urUKPrBaqlTmFH4UMPRxUr38eaALxW28MTx7jAuOjVI2ab9Efbtd0/Y1gOiN5FqLsau+ftxNOi4LtLHrD8/dcwnYH/XYwu7ibKjIKfMcjPKRtjjM0bYNyfQpNJcgopp2mKJEow9kDT1zYhirkTfC49OfJYBfswDC8EF9vF6+kpaRiEQk2T13RMeJ68vkcVtTsHXKTJ9WJ1Do3jeJ5bK8B/G6Dpa+x224kRoYaHvovC3e2jPl+VKskNC7hGxzVjh6QGmL6X9/B+jiv5y8qUy+VyYtBQWWimPu+l5811w7mj/VEDk3ORxgz7RR7xcz5H1yDlwfF4tO1QI5VbIPnDNaxGk/7WPrpGoZ7AqIaCIm56vSbrXUN0SGqQKmqkjoUiHNpOz/NQVAXwBoi+iTGgt8nFWidB38t55LZF5aTeN9OX02wMvBLRc8zzHEmSoCgKFEUx8WqBS8z7cfNos83dhaOkUCg9Xf7NRU5vKkmSSUZ113WoqmpS1pXeIxeRli1VL0qtbVU+TNBzhePT5tF6DCpgKcDCMEQwRjC1B9N78JoASMzkPVqoRLPLPeOhaRt7miIFE71xvo9tIh9ZwnWZr+D9mGHYGXgPBbroGaf6ZL3zIAiQZRmOxyOyLLN7qFWIagla9ZjVkNHwQBRGVjgSVtUwTVmWdouaa/CocGZFt8APUDcXxIbjrkpMoXfOnXP44OML48UdZzf+7kLGOgc0nMIxU+VIokFJpaGFdNTDBV7WUVDlpx4qFTm9fxoBq9XK8psVBllTo65rm4VPRcs5xuPCOe/Iz2E4b1F11xir6dHYUCSDa5DPKctyEqMntG6Mwc3NzcSb5+4d3WnjhhtdjxjApGKm/k/EqW1bm8dEA5j9I4rGsMrhcJiEhRSRUPSk6zq7C8fdYkkUks84HA5Yr9coyxLbdoskSSZt1rlGecVkREWgOH+JOPBHt3rO9GU0GwOvRFz0WvueCxuYbu/hIqMgUvhPyYUAudj4t+7rBTB53vPz8yQnQD0r3Xo0DNMTB914net1MqlK0Qo+VwWXKm3CkYW3R/htCtN5KPJntHVjY5tRFE3Oae+6c+njqE7RPA1YP+Twlh4Ox4NNjKIBwPMF2E99NwB4XYD2nwyGExD6GdZ/MyKMQmw2G6vgeXIgQwVU2ORh0zS2fa7H3nWd5X2WZVjFN2h+HjFGPYZVjbqtrcd2PB6x3U6RIK19oHHuKIpwu7rDqr0HABzyDd4//jwxwjTnwzVS1JhRRIm8cxPHKJjV41KIn4qSyoFzSQWx5iOoMqei1L37Orf5fuYtcIx1HmqSZtu2WK1Wtoz0OI4TI46GIwDkeW4hZ0LaNNo0SU/zE9SDp6eveQ1q6HAOpWk62a7Iv9l3ji0AlGVpt+7REGH8n31gnzWuT0OM/WZbaBwRFaMRRIeDa5N8SpLE8oX8ZclvrgEAlj/cRaShFBoCbBtDonw38zcYeuCc43ecbzQQDoeDPYlQ0RHOF10zavzO6MDr0GwMvBK5sU96A7Tu3fKjVMQqvDU+yGfyWQq9Ahelx79dBcWFxwN4+A59Hkm9RI3Xc8HxGr1eFQLbQKGsHiQXa9d1eN5v0C1aeImH/X5vPQp6UTwkyHqQvcHh/9Oh+XlE/K1B95tLIRgWhmGVPQretm1t0iCfm0UnBA8hsPNgbnoUVYFjcUEZuCWTpHA/gBdKlT9aI4J8j6MYw48Bhv/owSQj8K87lHVpS7qyyIuiMC4kz7GJogiL5hbZD3cYR2D89YB9urPzgnNOYWsdIxdl0nmq4++iBlRw7JPmfvBvheo1BKCQuc4R7acaProebtY3WKc3AAz21Rb7w34CPVMZB0GA9XoN3/dtgtw4jnYuqAfOCpuuIqERw7nCxFImt9LIZMY/PVVNnNOsf3r2muCn8XQqN/KThx4ZY7BarSblv7ntkfOZSXWKNKmSZNVKKly2U6F9dx1TwZMfyisAk7YCmBx1zDZeex7nj26l5RrSOUCDi/OP8kOdEnWmxnG0NTN4n+62munLaTYGXolUGAKYFHrRcq687pqw1vs/N8H1+2sKXZWKXqOfuUpeIVsKDw1H6DOuGQXuu1Up6b1lWdrkPS5+CqyqqlAUhfUmPM8DDGAMgHHE4HiIfCc9J3pPbrv6vkdRH7H8Fx68wUc1Vtg9714U39FERjcWq5n2un3Q3b5mhds4AOOloNPhcLAFjNxYPXmhRpSOq+cZnOvtnsvuKv91P7Y7P8gH7Z8b2z8//wLxa5s+F6d1x1Wfp31xv1Me67WkNE1xH77F4vdvATMi+DpEm7aTPBfXGHB31mjuhxqzGkdXPrNvbFMURUjTdHJuh7772hrTUwRpILIdWuabRq4qQL5XcyUUJSByoycl6lpVI0y9acoaOiO8nu+gd65VMhUZ0rXlyiN1VNhe5Q2/52dqcHMtUdGTJ3yOGpz80TFyQ6buWM70ZTQbA69EigxQADEGyCpbACaLRj0opc8pXNd7dKF99dquIRC6eFRJKATqkms0qMGibVDrnte58XBVMFS0FBJVVWG328HzPCwWi3POw9Ai/lc+8LbHuGjRmUsJYAotPSWNvKAXwnyAtm2xPTxbwUzPS4WklkVW3rHvWkSF/dNjfCnwj8UR/XqA93cxer/Ftn6ykLUaTlQq18aLfxdFgeObZ+DXADBiZ55sGEpjqapgXeNG54AKVCUVsIpGuWOm/NCwlz6DClD7xed9Li8AOBtZYZvAFD5GAwTtJReByoSGAIvn0HNu23aC7DDuTOWm5yOQD7o1ETgjAywwpcYKM+g1KZCGoXq4Wg6bz9SzPnRsXcWmuS80xDUngV6+vldRKzVgdR2oZ833E1UgQqUJhCoffN+3YTF3x5LrtLhGoGug6nHfum45Djr/gDOyczweXzhQbgGuOU/gdWk2Bl6BxvGctOT7vj3mk0JiGAZ7RCqVFCe9u+NAhbRazLSoFR7kZ66XTwGiMK+rvHUx83pep/Cgepbsi4YsrnmkqvD0fAM1VPheF6VgSIMC+fn5+SwAVufEpbY+w61MzKKwU++dAqyua5s4pd4Teca26Cl3jOuq4UTlQ4FPRIAJaOQ5qw2yPRw/GgmafOXmZXCcOSfIk9PphJ8+/IQwfLQwLAWgwqNsP5/Bvqry0TlB0rFnX9Ug4N+q2F3jg/NRjVU1shQxUdjYHfumaVCu9wjexRgxogj26E+9VVaa6R8EAZ6enl4YMXwuD9khHQ6HyTY7Xs81mqYp1us1kiQ557Z8mjd939vzDTQ3QA0NnU80+tkurl1dl23bWrhbjQH19jk27jZRhfOZ1+J5HvI8R1EUE29dw4i61tRxOBwOk/U7juM5TyeKkAQp4jqHFwNVcq6SqmERrjGuHx1Tyg/yNggClGU52X5IA48IDMdN57UxxuYQ6LZoRXPUQZrpy2g2Bl6JVGC6HiAXoWZh630uMvA5T9r10hSWV8F6bXG4i8e91oWG/5QF5nqi+vk171JRg8/BexSc5B2FHpWNG2/U/qtw/dz7VGkpLM626j36vXqR9Eh5DZU0BT63Darxo/zWbWf6fvWwOF7qGfLaa56Zjin7oe90w0fu9e64XrtP3+POFb1G23/tHtdwNOac+Pbx+B6nvMCI0Ra5UsVBpE2VrY4px4tev6Jg7nxWT58okpvXoEl3fA+VEZ/Luery15UBWp2PYTBNBtb3sL/q8etz9DoazuSL+zwNZ7ljonOBNI4jojBCslkB/5QAyYj4X1+24SppYSeda+5c0GRIfS9lo4ti6Xq7FubU/2d6PZqNgVci3WLFRciCPXEcn7ebfar6Ret3GIbJEavAVGlTKCyXq08Z1JeKXfxer9V7JzFsR6mponM9En6nUK4KEl7Dexl3dNuunqN6NPQaXM9Vk4F40BDpdDrZ44cp9Iiy8H8VhoQ06empoB2GwXp2zGrWbW+Tg2Ck70yIapoGVVVhv9/bpC16/1QMqkT4N3lCVMFVJBqf1noHVGwkd658bpxVePO9Ok46hnmeIwpjwIw20ZH3aVKZepY6Z3RbJ+PmwAVG/9x8U155noeiKOwuAsa0Cd1z+2eWZZZ/Ok6+71sUIU1Tm/DGtal88jzPnsbHLXhPT0+2je4plGynMcZ64dxiW1XVpMy1hgWAC/rCuamlkj98+HBWvp9yBPg+PfSMCYvkKxNlOWfyPMfpdLLl0PXgn3EccTgcbLKtjj8AawCpoWvn5BCg7wF0BmY8b9PVYmrjONpqojTaSaqoFbXjHNTwos53GlscM/ZfHSoX/fhjjsVMfx7NxsArkevN0TPk5Kay4sJ0LXIqfjfb+/bmFg/ma0R1ilO+x0f/Z2y3W3sfIWoNMajw1/fQQHENCc04vpb4c83jITEjWr1yVfRqrDDeTe9IE6xUUNFg4latxWJhhS49ZSpRCuCyLC2vyT8qbiZ5+b6Pm5sbAJeYqm6XcrcWUukYY2wYiOcIMFbNZ2kZYzVwyHeOC/AyPMRdFeQfBaxC3+TPNVTDvYY8VzSFApnPpHK7ubnBQ/oOi+IGbVzj6eY9Pj5+sGNM3qihq4aFzlV6obqL5Np85PxQg4UKgt4yFaaGVWhIaQ6AVsjks7Isw+l0st+VZTk53ZNjp9C/JudxLPI8tzzvug77/X4S/w6CwO42OB6PVlGTuJaMMfZcD+5+8H3fhqVYo4RG0nK5xPPzs52b4zjaJOQ8z7FYLOz84ju4JZHznfUyuq6zW2R1PtLwtecn4LIjqB964OsKYZLAS4E6abH5uME4jtbQUodH80S0P5yX5JkbptS5y22KDIFomEHDBBrS5NyaUYLXodkYeGVyPbVxHLFYLJF6GbzOxy55xsfNh8npYAoxKsQXRREW8QrZ7+9hygDemxDH1R57bz/Z46xQrFr4qhT4ozE7EhcnhQUFpJv8xN+aNOaiEdoX8oKCQxGDPwbhqqDm9VmWWS+OyoXKk4KV/c7z/EW2M/sZBOcTBBM/gx+F6MMGp660sVyNY9Jw4zYwKhf1fPlckhpZHH8qIfaTxgmVKIUyDRLlEQ0FNcLoberOBvJXUQQ9kIkKVNtsjEGW5Mi3twg/LuCnGRa/LvHkPU4qT14LUWkip84lNwFRvTcdT0UV9D18PttLXpEfajAAl+Q2fSeRJM4Lvo98Yrv4fG0DlZImDTJBFAB2u5299vn52baNxYZUmbENNLg5p5hfoAakW89ADRNdv3o4EA1JDT3SEMj8BYI2whBdjE/OSdcI4tjQWKzrGmVcILxv0A89ykNpUTgqezX0FIl0kUpFAihTeKS67oDgs3SeqFOiZd5JzBmakYHXodkYeCXSxCEKeiqCZbBC8J9XGA8GN98EqJfVJBmMpALfWs0YgGgAmhF90GEYp9UBFS7V+1yhy2tdchU42+HC/PpsXeh6j9uHa+9zn+sqJ/5NT4+GBIWXQol8BqFR9ZivjQvbtUxWGP9Thu69QfBNgsW/8FBWpRW0VKL0LsuytNCweuj6t3rLanBxPmjYhR6utlFjwcp/rc8OTLdAurkT17yma16YfjaOn+ZXMALRgB4vi7i4yl2T79x3uO9z54Q+W+cW+abz1lUuei2Vs6JsaoRyLKj8tA06Tu67ea+Om84hVT5931vYn/NTDTK2Xbc28t00OABMxpEKUOeFhlj4PUMJXCN6f+KlGP9dhmpvEPw6R3xXo+uOk/Fgn9UR8DzPwv2n0wknnKwCZ190h5DmKGjJbW0LkUjlM9EZDROpM7NYLCwawM/U6eCzObYzMvA6NBsDr0CuwOIEtV5TbzBWBmNj4LcR/Ozl1ioXgvf9c439bfEM/12A8E2M47DD/rB7ofBUCV5TssBUget2PyonXuuGFkgqxPVeEp+pMW2FSekd8X/tO5/vCnQWhnGroekRwGEY4ng82qIvWllPY7ds9ziOCLwQbeVhbEcMJc5b+M0FyqbAY7jidDpNwiGqGNlPNTjYb601oWEUeqw0AOq6ticc6u4GvotFcOhR8jn0jK4hLu746DzR8d0f94hvPyLNTmhMjf1pOxHOriGoHrY7D9w5o8ajjrMqRnfOX7uWzyIP6K2r8tE1wPwTzUdgO5RHuk5dpa/okx40tVwubfiJ93D9NE1jtz263jIhdSpyhqGMOYdL2B/dW8++8t1sT9d1dj66DkVd1xiSEeYEjC0wnAAzvpwLXddZNE3bqLuIyCudD2qo6DzlXOS61iJDbDf7w7FxZRHXTJ7ntuIhgAlfXDmmhtRMX0azMfAK5HrJXCiMbz/XT7j5zkNQRWjvSjSHy55iCnM+RxfdOJ63LGq8jLFBCgLNOiYpWqAwrnpGmuGrQpnX87cqV9fjV8WnQlaFi25NI6kgcHMXeL9uyfN9H9vtdiKsubXP885bq8qyRBRFWC6XViAxnksolVBt0R4Qfz8iXAUYbmoUpwKnU2mV8el0srkB6t3pLgclzR3QHBHXU6WgM8bYEqzkB/mv9SkAYL/f28OvXMHL9xGWZkIbx0if644N593pdMJP3Y/21DxNFuSY6jiq4lXvjP1UiPcaGsB7XOPFRQlU2GuYgc/P8xyHw8HOD6I4ALBer+1WO1c5j+N5+xzDAe5pgTQ2dUcC4+SnXY1kG2AIWjR3BQ7FYWKEsC2KGpF/x+PRXhOGoX2HMQbH43EyTp53PluEfFeFz++JLNIwYvubpkESJVj9yodXhTgt9uiHSwVJ9otrn3kOrtHHA8wUoWEelCISinRwDRhjbHlu12Adx9G2ne3RnAPmkdCYIH9pBAOwY0ckw12PM/0ymo2BVyBjjI0LB0EwWQjDMKCsCqR3CfAmRlEebeyLgk69QFWILESi+QUkChyNy7vxevW2dT+0FiPRGBzf4RoobJsWOKHgcxWZ68XrQnW3UhEq1/it9l2NDFU0m83Glo+lwmcMlUqAQr2ua3uqHWPLx+KIJmpg3hg0XYtid7TeHpOt2E41rDTpjx6dtk8zptk+tlkT4/gs95AlEs+K0IRIjh0VEwAssgW644DRjCi6Aw7Hy356jce6469jDVwOlFEvkN4w7+MYuYYd28Zn0xtU5XINrdBnArDGFu8jXzRhVOtQBEFgD6lx8y2appnkCjBxL8syu+ediojHSHN/vfZHd334ng/vQ4bq3wNeGmLxP4Vok9bucuG4RVGEqqpsuV7KAQ33kEfcMspzBljTnwYK81u4o8MYg2W2RGaW6JMORXuYKEnKhd1hhzZtEawCNG2DuI8nYSnOQz1DgEikrjuuRzV23FAZ+ctEP363Wq0wDOfiRjxZVHdRcU5wjQKwh04dDmcji0mfTDxmEibnJOfHjAy8Ds3GwCuRCjyFsugZAJf9zxpDVshZFad6XMBFqLrxN16rAnmRL5AkKfq+w+F4sBa90rVMdzUmqMy1H6oktY1UGq4RQeNBlYwqJF7nephueEFDC25/eT89QHqU6sVr7gE9aXonTORy76HnpGOjikyTEik49TS9PM9fCD4KNHqHVNz07tRDY7s1ls32h2GIRb5AfFyg/30EhAOS3yToh+tIgDsvlYeKBl2D3BnfdRW6okTu/xozV/4pkqS849861zXJkv2hMqFy5PxiiIWkSlfHTVEJGjVJklgDmX3nvSzKw3eOiACcy2QP42WHhRpMnFc6x2kc8jOiZny3zjfWIKBByHkwDAPWqxvEuxXwU44gH5D/9RTlY1tdpb4YL9tl6YQowkIeLxYLm9+gnjl/NFdHZZuG43zftwYRDS5u4aQxqWudRpPykiE0PjcMQyRJYg0i7etsCLwezcbAK5EqNdc75wKlMFTvyr1WSQUKBbdOfl0UvDbPcrxNv8Hy+IA2rhDd/Igfqj+8uE8VAXCB9/heNyFPFzAXLmOtJPUcyQvNR9CFzGv0R3mnxoDLY76LXuM1JQNcqvmpkqeQ0bCLCk63Hyr4rhl8vEfHlcKLHqv2jwKS17l9c5Wu5hro/1EUwStD9EcfCDxEQzJBJpQfLox6DcJXQ1C9ef2bMC6Fux6NrQajPkvfwee5dG1uX0sMY7vp0aty0xwBnbPunNJ+cQx0/SjSQ4+U6yD6FggjwItHNP4JfXOJaasyU5ROjVB9d9d11kBg/J/eu/aD8xQAAj+A2QcYjwbofARD8GIe6riyXbozhMYq26ewPNGUcRwt4kIjgNe7OztcmUVjQEt+c21oO8lvlgwnj9kODQG4xpo6ATO9Hs3GwCsRPRkAE4Wj8Cmz3jWx6ZqAAqYCXD1nXs+/eR2hxTiOsTjeIfiYwUtiRO+ebSz52ntcb1FhXr1GDQNVbm48E7hsfaNnp4pCkQfNflcDidClep1MPOJ7CFly+x/3UytRcKkAORwOVjjqHnWSIhsaaqEScq8h76mUeM3hcJjApuQZ+0SPSMMcwzDgeDxOjvHVQ2tcFGV168P7JgbiEW3SwO/8SeEbfaerLMgbNTZ0HK/NlTRN8ebmHRb9Gt2yxqZ+xGazmeQScB6pAeG2W9/B6/SgKc4h8op8pbLl2qKC0LEBMClUowV8qPS0TzzmVxEEhroYNyeUva/3QAgEXoD+1Nt4O384bjQIdH99VVU2nEBEg2GrMAyRpTm8Y4ihG9Ek5aRglt1NM3To7ktEYwAsejTeBeLXsdb5y/fRUFTDyzU8i6KwKAvDMa4h7BroNBAZwiGfiYxxjZEnzOPQ+UlkLgxDfPjwAavVyvKSeSw0PBW5cLe1zvRlNBsDr0RUXlT2FI4K4QGYxLwYJ/wcVPo5z+ja/xa2G3r0aYMg6TFkDUa/f3Gf+y41LFRhaVvYx/V6jVW6BgDsyx22u60Vxi6M53oBn/PQqIzUMOF115SMGiZ6nCzvUZja9chcRak7HJQv6n0oj6n4FD1hbgDzRrQyocLtapwQ7tcEMBpi2n4V3mx/27bnGH8+Ivr+7E2eqpOFozkeuh2S85LPdaF8PlvfyT7zs9Vyhbv9Vwg/LjEuW4xfj9h624lQ1tCGjruGXJTX10I/7vzkmHE96f9qXGjyJsfKrXo5DIMt+gNcTjhUREvnBr8bx9EmZxLK5zV8pypl4Gw8DcOlCI8aTdo/z/NgDj5O/3eDoTcI/mWMaBlNDOlhGLDb79Avetz86gTP99BUjTUUONcUynfXmeb7aPEk16BgH/kcGv1qMLqIHT9z1zqN9mvIhc4x/m6aBrvdbpJEq/NW59WMDLwuzcbAK1EYhsjzHGmSYbff2oQsjXMS+qLCVaGp3hNJoUYVPMBLhUplWJYlnm5+QvzNFr3pcKh3E4ND7+dvRTIUOlVFZsw5oechfYvV4ztgMIjffEDd1Lb6nwpoY6Y7AlzlSqWhuQtsk8YLr8HKKlRpCFwLQTB2656kxxi4epN8lxpy7tZEPoMoABPWqFw0OZDKl+Ov59X7/rkEMA9V4hHHVHJa1EiRIJ0/fd9jf9hb75T8o0dFwc8se8/zbN84/64pCn2vS8Z4wPhJCUjkQY0pt9iOjhcVioYAFE1ShanjQCXBMXUz2anIOJ6E37VwFHeHqJfM9xZFgSzLJtvl2DaF6WnEsW/qnaqxx78Z5+aWQ/adOQ8KuffdgGHwgNHAjBfjxd1ep6W2yW9NfNRdCMClnoEqacLumsmvzgt5qqiaGiUcUzoNrByooTI+hzzjM1x+usaD7/s2iTcMQyyXS+TZWa5u8WwPoXLvm+nLaTYGXoGMMbi7vceivYH5GCJeZ/D999hsNuejeD95JBrjHMfRxstUEaoQplIBXh4Lymu52KhEDoeDLUmqShd4ucNA3wNc4t5UPhpzZSww6XL4uxjjYJCsFxYi7LpuosQV2nWh6Gs7GNRzpefieiQqbLT9hBjVuGJf1SNUw0v77Xrf/F8RHM+7ZH1TIei+bwpKvlc9TneLmG4fVAFJz479ZiKYW1yIykYhcx2ncRxtFT4Ak1P2qEw4F9kPhi04JuQThb8xBuWpwPHmEVncoEsaFP3lmFkaSsvlcqK0ddx4DduqqI07r8kDlr7V/I/n52csFouJYtZs/SiKcHd3h9vbW6Rpis1mg7qu8fj4aMMwXBNxHKMsS/u+0+lk5wCz2bkWuDWUa5HFcVi9kkYZ5yjHnBUsGQtXI9MaYosW0b82QAcMdw2q7aX8thq5nufZ0sRsW9u2uL29te3kvNHzAjScaMy5vDbP4SDvuOtiHM8HRdFw5vpO03RidPJdWgNAjR1jjH2ftseYy04FrSI4juOkVkMcx7hd3SH4mGJoRwzpJaRAQ+Ya6jnTL6PZGHgFCsMQQR9i/G2CYevDe+Mh/VWGMLzEpxXephBWNECNAVXwCvddS5KjZQ5ME/tcUmXHuJ0+B7goGi44ehAA7BbH4+0O/m0KbzQ4xQe0+8uCVJiQXrkaIIo+sH/khcaT9XAcCk8qSXqAfDYVi+YuEBpWBaEwuAtpkw/kmxvCUM+ZP5qRrWgDx4PbxijUyMMgCOyBS4wl01hxQyT8TQVEQUwlQ6SAfWQ9AgAWiWDNhL7vkWWZ5QMNCUUvXPiV40rj6Lwf/icE/kd0hw5FWUzGmManC/GrgaYwtp7GSP4oNM/v+X7y3vXEgekpjZ7n4eHhwdYTWK/XeP/+vUVyWNufSAEVLBWZJr0yts/5eDgcbJjAncsM9xCZIN/dkADnJ9FDrsUgOz/n8HSwCp/3UFl7nme32Gk9BEWsqPj5HiVtc13XNrav4wcAy+XSxukVodL1zWepbKuqyoZTuC5Zppl8UMOd+UEcf7aNDkFQxOj/U4ixB/LfrLELnq3hxT7rHJrpl9NsDLwC9X2P0Rth4hFjAIxRj7ZrJsfvAlNIS+F5N0b7xya3LlzXQ+Y7dIG68UlgGu9TL831WlzDoqoqPBYf0N6eLfxjebACit6txobZHjUIqPw1nOCGSFSw8xkUzKoYFM7VcIS+mwYI++3GxfV//d6No1JQUWEQVmZfWUGO99JzYvt0bKiUqPwotPV6VWwuaT+JHBAp0NAM/yZ0rAaAhqNctEjHQvk/DOcER/KCbXDDMm6b1eDV515DBhSWdkMZ9LIBTKBxN5yVZRkOh4NNKNXCTDTWiJL4vo8syyb8poJ0d5oQfaMxQAOx73ubQKeJwzpvdY64yaZ8rv7oAUKaiMpns0aFu55oEGoekG5p5n1sW1VVE8OWhiWfzTnDQ5t06ySfz78pC2j8sk1EntS4UaOQpMgk19wYj0AEoB3ReS2Gfuo0uUb0TL+cZmPgFajve+xPW+BbwNz7qP0Sz9vnyfG5VDSauKUZ8iQKZPW2OPGBl0mEquyvhQCuGReu0FdPSBU379frj8ejPUaZcKH7LlUeKjTc2KX7W70O7Zd6lark+C7+rR6GkhsLv8ZT/X2Nh7yfnj6PdFVvmB42oVEdK463wqt8pwpjhT41/nptjBU5YjvVIOHfVJxUBOp1A5fqcdf4oc+6hgApjH2NtzqP9BrywzU+XSPDHUe2ldv+eI1ryOnOEiJENIS4q4D5A5ojo+tOi0xp293QDg0tTWYkCqQ8oBHCdc+201DREwB1Dbi7exShUsXJOaGoCdcdQwpsv1vkiQ4BjZC+763RyvF2v3eNbHeMFQVx17POWR13NRDbtsUx3iL+7zK0dYdd94Rif7w6p2b6cpqNgVeix8dH7KO9FSK6qNVTp0Lj5FdBrDAc7yW5SvSax6jCUfdeK5wKTJUen6WL2fVW2Tb2RROANGashoR6i7zW9eL0WuCCCGi8+5q3rJ8pZOwKKb7HRQEUOeB3ClHrNSQKKVZJcyujcVzV+6NXSKXAanXM8te5QCPBhexdhal5DE3TTMokaw198oQ8IKTMualj7u6NV76R1AvjO13UhHHca/PVnXOusr12nWv48n/f962HqkcCM++BRxZzLquXregEIXd+Rj5r8q8eS8w+ag6QrltuHSaqoMo6CAI7XzRcBmCCKpCXfDaNF86jMAztHn4dH84jTVLUcWKbmfjK8xDiOJ7kpvA6Gih8r6J+RBQ4r/QUQwCTMxg4J9gm8ptjr/KRBpQm326eN/A+7VjRXTdqAM30OjQbA69AtN5VSSrspglzmlQFvDyGU5UoFxAhOOCyh1n3APM+9QZYyIQege6vViGre6w11ghcFDwVAz1MNS7cTGu2iQKE7VQPgPe7So6Jclqzn3xgUpG+X71pFbxULvwhTOsqFxKvo7es79Ln3N7c4u3NV1gkC/gLD7vdbnIQC2PFuoWN5WQJ09LjiuPY8qtpGhsjXq1W9hmEZzlnOF/Y3yRJJpC05oKosiJETaODSo0HMBHJ4BxWw4BtoZCmd853XkuAdQ0pEucD26eGqnqt1xAenTvKG64HJtIB52OGiQzwGazDQUWsRhqVJBP8NMNelboxZrIlT41jHnFNhU0lroYOC/wwB4G8oHJVdED5qOvBhcUZ7iDf1uv1ZAcFABsO4TzkuOq65Ls5T6MowmKxAHBR7vv93hr3y+XSPoP9VHmhh4ZRfrmoDp/N9eP7Po7Ho+VZGIa4vb1F0zQoiuKFA/G5eTbTL6PZGHhl+lMtVReK5iR3oWV+55L7mcJw7nXXlKC+708l12O+1lcXEnT7ou/W/mnfXY/0GkT+p/Tj2nPc57vP/dyz4jjGKrpF9A9r9F0A/+9Hu1PkGizuGiT03CgoCcFSoaiQvla18Rpc/cf6qwpawzUqSDXMcm2cXB7p72vfaX8/d83n2uwiAO5a0N+u4eHyXg1b9d6v9eXaunBDdGrI6meqAPU6RcvUoOJn7jOuteVau9x1cG1OuArS5ZUiaDQC+Le2R+91nQh3TDRU87k15j7v2nWfW5v8fS0xeqbXo9kYeCVyoX+NgSn8TMGviIBa++52LEKHwPR0O1rjvI6eocZz+WzdZ+/C7q53xu+0X0ruIta9+rrnWb2Fa21yvUrCn3ynep4KDboKj7wCLqEV9ZaBqeGlSI0qDeCCkvA6KgB6xamXAfsAfQc0mx7BTWDHW8u88ln0sliemIln7969w3q9RlmWeHx8tNAt279er9F1HXa7HYBLzJtjqcWM+A7ymONDGFe9y3Ec7fZIJnTRg2WtCHqPurOCwluhZp0PiiYoMsHP1GNUga6IGRWVIhoALFrDe/l+Y86n6OkWzpubGxhzPqxKlSN3p+ic57zgQToaliOU7VYATNPU8lXnFMdFt8Hyc/V4tdywIgf05N2dBzpPVQnrmtV1PY7nHRJZltmwENcUkxKXyyX6vsdut7PbLimTmJwJnHejMFxHNGSz2UzmhSKGRENYz4EIl64zRVdOp5MN8yhPuHOG7+BRxn1/3lLK62lEa3LlTF9GszHwCqRKWeOMwzDYKmQapwYuk1+hT0L51zwcjf9yIbqxNoVXCe1SkejWHkKhfK5mh7tJRdoeVxC41f20dC5w2UKkQkzfybawr3wPTz+kEgYuhobGU/lDmJS8otBlP932qvBQvlEhkRTy9H0fXVIj/nULNAbV8oBjcbSQp+6hpnBnf3zft7kG3LuuhYZ03zuFNmO2jEOzrzQuqEwA2JAQkxrZL1UYVKocC24zJHTPecrxJZ9oPKlBp2Ol4SfOIVXgOk40IjSPw/X2NFzAMXcRKSpNIivk4ePjI4w57yagElFjRWPYNNgZxz6dTpa3+/1+0k6uJ/Kb4QTynTxxDVr9TWWrKBDvo9GneQsaNiM/rqFyLqpFI5InNyripJA9C/uooiZvOc/IO4awyAvXueHOCJ4OmmWZNdoWi4VNXOV6orGmxiH5wpCGi7RwTml+wrViajP9cpqNgVciCnTdD8z/NYteF55uoaOHpwtevWn1GFwI2vXqjTETBaPPIbnGBZ+rsXK29xoEDlz2zWt7+X5V5NpGCliFUPkeTTpTQaiKyOXbOF4qz6mg4v9um/U5CufqNfoe3e7Umw79rwpgBMrDwSpSHR8+n4aLjiuTC7fbrX0uk/54/2KxmJydcO0IWBXECvdrf1lAxk0i1NMdWTWTz2L7lB80oPhe14t0lRvHS+ebC2crdO/ynn1zoWj3O71e8xqMMS/6wXlKRE0hf/WGaWCpYnSVbRzHL5Lf1BG4FkZwjR4aOopUcPunIiP6ozkcmtMAYOJE6HM9z0OWZRPEiM9Zr9dWmeqWVPadCpxjHAQBlsulNfbctrJYEw0Dzomqqux4sK/a9iiK7BxW5IQ81e2WOpfU0J3pdWg2Bl6JKHi7rrNFN9Rzd+F2fq8LkBP8mpB0lY0KiSzLsMgX58NUDvsXGbok15vQ57gogJugc00QuwJbBaeGOVSQ6XM0gct9rrZF79W2qYJySRWYKls1eBTpUFTgGk8oeFitTjOfr8VamfTF+yjA6aUziZDCkBB1kiQWyh/H0QrZa/wFLmEPvseN7bKPKqD5PDXk2CdVZPzR8JTOO46hCwdfiy+7fXA/13nkzrlrhoL2lwqNCl+39Oo4k8eugabrzs1Q19Ab+UKjU+e2eu9u39yQCQ07d65qv10DWPnu8kqVshowDEdSNqkx5/s+drvdpN+65o/Ho+Wv759rMSRJcvXwIo63ziFWMlSERtei8oTPUAdKDVSGYNy5oU7BTF9OszHwSpTn+SSGxQWgZTNVsHFBXINe+b967ep9ARcBt1wucR++w+J4gzav4N/8iMenx4lwImSnSuOaMGbmux6mpMLHhfV04VKxcS8yheo1QaOCSj0FFSp8n8ZN9RoS26dZ5e52RjWugOuV2ThebJdrDNGLpPfpKkT35DuNgeueeJ5Uxwx0d2eEMQYPDw82v6AsSws9M/atSACJ/WTf2QfyJcsyG3agp0f+8bhlPRGOfeY16mkTVdD36rgpuQbbNSP0mvHijr8aizpmum501wWRMRpa5LXOZ96nlQ4154SGGvvsIk86HxTNIf91/nPnCJWbGlHGnPMcXASA79W1qOE9XVvK976/bKes6xqLxcKGp7IsQxiGNtdCfxR1YG4E1wO/1zXB73jSoRpKWnvDPZpZkRuF+nUecQwYPtW6C4pwzMbA69FsDLwSUTkej0cLeXFx8G81BlxFrTE1Y4wVzPR2VNlRoQPAMlvh5uktvKcEYZ5i+W2BRzwCuJwtTnjUVfDapuVyiYflW0RdgnpR4uPuw6fys9OMYt0ORYWX5zkeVm8Rdxlqv8TT4SOK8lyYiAk/emAKBYIqaRohfJcqSX6nhpEmganyd0m9XN6rHiIFi+Z2aCIXlQLzQLjXmTkNfIcaP1TYSZLYaxi/1Vg/54feT4VP7zHPcxtLVYFojEGe55O5Q6KSUFiWbWZyHMMDQRDYLXq6tVCVMnmlSsc1enQs2U+dx+pNUoFpUR4+w0XA1JtWD14VLd+pCI4eg63PowKiMtb3uj9U9hzPLMsmio6VDTk367p+kUDLdaO1AbiThPOdnrrOU2BaeRC4KNNrBg3vVxSyrmubl0Ie0zDR2gGsyRAEga2xsFwuJ9UX6eXrFmquCxoF5CsNWa5rRSq7rrNVEmlU8nse28xDmNw5reOoMnCm16HZGHgFWq1WiP1zUtHt7S0Oh4MVfm3bYrFYYJEt4ZsA7VCjKAurZNz63673rIL0WgJR2zXowgZRGGOIO/ToJhY8FZ96NC4iEQQBbpa3uH36Gv4+QXtfoFu2FqLWNmmyIo2Tm8Ut1s9vEWxSpKsK7X2Dpm2QJinWizXG8XzccVmWE+WriUiuYUAirE6jSiFoVUhuXJTtpcDWpMZrsWDez/9pSCm8SsVGT9AtjEThHUURlsul/YzKn7sKbtY3QH/uc9OfQzvkKQ+PqevaFidiPQAKTV5bluVEYGtCJzPJgyBAlmU2YVBr3pO39L51N4UKbxcC1/mlfFfP7RqiA1zOg9D5x/mpoSAXTWKfFVlQ1CFNU9wsb2FgcGpLHA4Hm8zK8boYvius8hUMDMqmmMTgiaYAU6NmHEebZKjhFM2D4Xp157SrDAmjaxjAXfvkDXmpyvAaAuOGN0js+/F4tImD3NnC/AdFOrRvCt3zffyORvjpdLJGrxpWWjWRpzeyT7p2iBwkSWLXNx2Xpmnw/Pxs57zuHKGh6RpQM/1ymo2BL6Qsy/DN7XdIfncLAw+3XwFN3FhPwPM8rNI11ru38MsIzdsDhnSYlEsFPr9n31346g2M44jdYYdw/ROWqxNOKLAtnu01Clu79/L5VpF4Ibw6gGk9+E2IwA+xWCxshTHdrqXt9TwPnvHhNQHQGJg6gO+ds+fvszdYP73FOBhEDzE+ju9tPoUK2mtwn7ZThaSGKj4nBFRh/Clwoova8DPCo5+7zs1VUKWoRod6tmmaIjNLdP/kYxhG+N+XKIPSPl+9Xyoz/dH28LNrbVEjThMhr7XXDf24kLAL437uPS6Mq/dca5/bDvcZ/E7H0b0XOKMub5bvcLv9Cqb3cHz7ZBWga6QkSYKHxQNWT++AAYjvn9AlHcpTeVWxaLviOEaWZvbYbkWQrrXLfYaLPHyOB9fe/ae843P3c4z18CzuNNLnam4Ix+za2uD1ikBp2xQFUoNCr3HDj4oEak0Gog2a36JtmI2B16PZGPhCiuMYWb/E+CEAYBAszxYuY5RJkmARrOA/ZUBpEEYZgodL7QEXjtVF4u6v17wBLoK6rvF+8zOeo42NTavyU4hQFy09fHuCWrVH8vYJ0TJHvTgCwYiv8m+RNktUeYGPwc/Y7bYvBERVVdiXWyT3GdJshSYrUXcV4jhG0uYwjzHMYJAsF4jjra3oRoiQ/dMYK3DZ7cC+E0lg5rXGXI/Ho/UmKFzUC2PYRhP1gKn3qYpTY9X0SlyPkPAmeatxdOACE+tRxYT++6NB95PBOBj4dyGCOLDv7vseT09PKIrCGpT03gnF8r0a43fnCvvM8WUiF2Fs1hlQRbler5GmKfb7vUUidPucjomSxq+1rLLOZ4YrdHcCicpCk/LYboW9+UyFlvl/0uXwnhKYwSBe5IjjGEVR2PnOcFmWZYibHOZjDAMgWeSTsJOiXiwzbcx5u+J9/oBlc48ubLC7e8Rmu7H8IHyuFTfdbaqcg9fCOjpHXAOIkL7uGtB1osaWhho5H9x8Goacbm5uJorbNZq1BgDngPKH7+f85zzU9dz3vc2H4LPatrUoANcy5/k4jthut5NzHDj2fC95pDVDZvpymo2BL6SmaXDyC9ze9DDwMOYdmmNjlXBVVWiyGuFNDROE6Nc1hnGwcJjCg8D1jGr+vua9ctEzy129SgoShXJJ69Uad6t7JH6Gcjhiu3/Gz+EfEGURhm5A6mVYbt7Cf44RrXLU706oqtPkoBIKmGNxhPF+Qpyfz40nFNnkFeJ1BwxAE58wNBdloB6o6ylRCLheMq+P4xj39/dYLpcYxxFPT0/YbDYoimJiXFFIKZSrSXfXoE+Ft9VDAS6lo8lXJgNSydCTYQKWm6VucyyyFv6Dh3EAhqzF0F5qDWw2m0lslkKQP3oSJr0mHVdNMCQUnEU5vC5AlzY4lger6MkjGhYUzIoE6dkHJN0Cq8pJQy3ufFOFpXzR71WwqyJwPVAXyRjHEW1UYVy3GHsPfVajP13GWVGapmnQpCck6xbjaNDEJ9SH2o6/ok4amljkCywO9wh+WiKIe/S/afFsnidJi9rvz80pNchdI+dzKJlb5dJdz2pg8b00Yl1kkUYjUSc1dodhQJZlEx5raIhbU3U81RjhmnUTULn+aCSxjDbXA40gvtcazWIIaihQ58SMCrwezcbAF9LpdMLP+x+Q//qcFFN3lfWmKLCfiye0Dw38Nz7asUFVVvY7kgsbAlNDQBUoME2uca93BY4KDwr4+9Ub3G++hX+MkX11RLdo8fT0BOAsbOK7BAhGwAdGfwAwTpQqn0VBVxTFJB5dVRW24ROGbzsM44jDaT8pfEPhQAGoIQMKCTcjnEIrjmPc3Nzg3bt3FjXQ8VBFpTF1fb7ySfmnPNQkT+AidNV7I6lHqB4Zn8Wf4/EIb+lh8fdnQ+Z4OqAoCrsbhQmK+nxtu3rhWvlQFYkK2jxdIPjHJcaPHpJve3T3F/ic7yB6QWG+WCzs1jJVMDpe7lwjuYl+10I8Oo+V9+rRco7r8z+nLNu2RTkekf31Dp7xcKoLnDanF8bzMAw4nU54ij6i/boBYHA4Xc4xcA1z3Wo6jiMQDDDeiMEfMYyXrHmuMRf10HWonvq1ta7Xun+T78oHfY+GzvRZLj95j2bos8IgUSatpOmOPwCb66Brioqb80dDWhqiUuND5zjbxF0Qbo6U8kPnyrXciZl+Oc3GwBfSMAx4fn7G+8XPdsJrERzf91GWpc1uBi5JZdcS6Pg/J7sqcrcADN+vyT5cHAqLq4dFBe73Abwygqk9eGWE4C6wbRvHEUV1xP7uPaI8RR2csC939j2qkNzFqNDmqTrZZElXCdAboBLSCon0QGgMULgwoc96vFmGNE0nW8A+fvw4ESQKLVI4uVnZvI4KXYWYKj32i+NHKJSfUaiWZWlzLeiJ8dqqqvDTzz8hTbcWHdIMbWZSc6z4HH7GKo8MHWiIgKEEAPZAHB8+zMHHUBngCAzry84OzgUmeHXduXrmer0GcDboPnz4MEkGIy9JLh9dxEGRCo4LDTvNS9DxJ++pGDSm7IYd2O/IJAh+XsAMHoL1yY4JDSzyn+uVyYD8fS03Rz3XY3FEdvuM9DcdGlTY1k8TlIZKTj1q9o9Gm85lKlFgauTwvbrTggp7HKflefUdboiIPFK43i2ApjtNVH4wLKJzn3M0CAI7J9UoLopiMvc4jlyb7Af5QZnE3TPclcEkY46FrmMSd9gURTEpEjXTl9FsDLwCjeNolb3WzqYxoBm7JNdCdq14XgNcEst4LZ+v2w650EgqpIALtNv3PQ6HA+7WJeq3OwSnBNXNflJ8pWka7Pd7q/Da4rKzgCev8dkWppVEH+UHBaTGPKm0VqvVi+NOgUu8nbULeOIZi6fc3d3h22+/xbt377Db7WwlPSpSLQmrgkvhdvW2qNAZk7/mwd3d3U2yxdUYYkY1BZ7v+/j6669tjQA92lafzTYpTxnL5xatsixfwNfkoSpDtkl3OBhj0Hsd4r8Z4T8CzU2JMRhsYSOenMjn0jOjwQXAbrmkF8yx0W2VvB+AzUNRT5JrBLiUitbP+Lcxxm7DbZrmxbXKM4X+4zjGolvD/zkDeoMkWCFJNlaxMF9A15PGt9XLVa9aFVBVVfjx4w/n2vldj1N1muTcEHVwE93c8BQVPUtHUxErz9RoDsMQD7cPyNtbAAOOyx1+ev+jvU7nJMmdKxo2oHImeql5Glx7ALDf7+3WVTVI2E/t1263s2uPY8jn80cNO8/zJkYjd8twfHVuaxKv53m4vbnFjXmA1/k43u/wfvPTbAy8Es3GwCsRFyYVCgWmChv10IfhUs9ekwYVGqMidWFuFcZ6Py1/N1atW37Yju1hi37Rw1+dz4bfH/YTqI/9YI4APQ6F99SzU2FN5cHrSVSUwNk4oeDRErnGnPfPc2seE6/GcbS7G37961/bwjxhGOLDhw94fHzE4XCw7yFfXOGikKOLqLg5HBR4ChczJ8L1mvQ44dvbW+vJBcG5PjsVnHpUfJciLPo5Qxx6tKyGTa7F7jURDgDKsoS/8uGvfVSnI7qqtUaWjgfzFGiYUUHd3NzgeDxa9EGNqWtwNvvAz9UbdpO9XIPs9uYWi2QFYMSxOuB5+2yv5fPVwOT/AFB7J8RpCzN4GNIWbXk5zMltlyp5GgaqgNUr1cTbtj2H0hTdUtRCeeGGCvjOOI5xs7pF4qeo2hPKpkAURMijBbqxw/b4jMPhYHmVJAmW3T3S398B3gh8B6Tp8yRermiNIoucH+TZerVG4qfoxx5lVOBYHF+MB9f2MAz2jAzOJxoFXNd8x2q1smuOJbTZNnUAyBuVizywiLsduE4UJWX/4jhGblZY/PAGaD0EX4Uo8gM2mw1m+nKajYFXIC4+hd804Yvegy40LgDez8WhYQEKUjdmpt4pcIFV3WtdgaSCoq5rG59WiFaffU3hA9MtaHqP2w8Vuop+6GdaL5/FWOgt0xvldTc3N8jzHL/5zW/w5s0bAOdchQ8fPtgMfDepiAYH+6FekKuAXeXP+wh3E9rWpDpjDBaLxYvdDwDswS0MD7BQEcdeK6upgjlXisvh+2ehezweJyEA4Gzw0MvTPIlrhaXarsWpO02u49yjsouiaFIYJ8syizQ8Pj7a/l6Db9VzU37qHNT5p3zi/VmW4SF+h8XPD4AB4rcfcUpOE8WiPNLEtaqq8Ij3GL7t4Bkfp6GY3Md73LlHo9qtgqe/9XpV8td4oEa3uz5433K5xEPzNaLHFbrVCc03B5hNiOQPKwxZB+/Ws+iQbccAoDfACGAwMOay/jSspW3SPgzDGQ26x1fIfrpDH3fYP/yMqq5snRN3LXCekmjMab0Gojj8TV64+/91Fw53qLCd/FtDXbqGeK+VbeMnXvQGZvReyJSZfjnNxsArkasMSay4pcKEnpIreAibuZa+vsM1DBQpcEt2fs4Y0JCDeleuwQLghUJX2O6akUFlzEV6rf0qOKIoQpqmCIIA9/f31jPQ7OKmaZBlGd69e4fVaoWHhwfc3d3Z/n78+BH7/d560mq8aOVDYHoyocZbtc2usQDAwtb0gHjqm+d5WC6XVqj2/fkY1zRNbS13jX9r9TcaJ67wvFndYnG8hakDDG8qyxN6eot8gfS0QvAxwXjfwF9ssN1uJwaKGoo6hqrQibiwXarUCPsyBKNbF91Q1jWP2jUCNOavaIaGsaI2hdmHgAHC2+n2UZ3zXCf8exgGHA4HmwhIo0kVpI6vzlsa0dcMBVfJqJJnIp0a9do3ly/W+DI+/EMCFD4CP4XndTBVDHMM4LU+ott4sj6LosD29gPwPTCaEYfgGaftJeFRecG+Kl+4lgM/QHRKYY4BgsZDcPPyNEgXaVJDte97WyOEPOacYCiIpFtsx3G0c58GME9p1PYq/5RvmoTbti2KcY/ou0f4Q4Bj+IxyP63XMtMvp9kYeCVSRUvPkbAXFRA9chWWbgKQClT1ainEVAi656Gr96vP0vMG1NNluxmPj6LoRWIjr6FQ1tLAeo0mH9GL1a1x5AsAm6jGBCPGMmloxHGMqqqsNz2O5xDB999/j9hL8OO//YDyqwrxOsRut7PoAQX009PTRFCqYmQlM0Uv+L16P7xeY6ocV431A5gkklFoNk1zrjz5qS48AJv8R6OJ/FRjLIoi5GYB77cZ0BiEnodgHeJQH+xcu8luEb9fAc8+vDbG4q9b7MxuMm7cJkg+up4uE7eY4Mdxp4HAuDDj20xcI59cY/FzxufntiaqsuIcOkVHhA8JRgOcggNMO60yx3lNZa9euJ4eSSVGj5UnP5LUOHBPw9OxcT/n3FgsFnhYvUHS56i8Eh/3H3A8HuxYcq1yXWvNhaZtUN8ckY4+6vyIU7VDmKXI7tbokgblUNg2Amdka7PfoEzOoanyUL4wYCcogpCu237oUS8L+E2EIWrRhCe7/ZXjo4a+5ieRmMtCNIZOCMeDMoTfsw2UPZQHii4oAsE5qfNC0Rbf97Hdb1Gn50qE5XNp80Jm+nKajYFXIoUw+b/rHauAuAafUrC53j/JhV9deFm9br1fDQ/XqOB1NCJ4vetBKWz3ub67CIO+91q/yCPucddkLAoCQuFRFKEqa/zD/+09fv5/b3D76yX+zf/5b66eW69tdZEN5aMbAnHbr56Vy3/lj4YfNKbOnAsKRM1JuOZhWyjVdPCzAfA8DHGHYZgq337sMSYdTOQB6YABF29KkQAdf+UreaOeuvZRjTgaPRq+cufdtfng8tqdU/oZcIaLn7wPqO9PwDjiUBwmCsV9tttP7Z+iXe5cV7rGF50n+k5SFEVY5WvcbL6Ct0kQr2vUtxWq6jS5z0XnyL/dfodhMSJ9eETTNdj9uEWe5UjvN+iHDvv9/gXCp7F7F/nRz7RPbhvOeQg/Ibnboh96nI7lZLfBNd5cI83D0DlLY43Gle6U0N0PrgwguuDKm8+Nlx5n7I7bTF9GszHwSkSBRDSAngSVGX+0Up7eq3Apv9OMbRc5UGEOXBafbtlim3R7G70beqtsCy12QoUKsRLiNcbYbHMXvtVYoSpm9omogwrnIAjOCVLLJW5vb+1hQLvdDr5/PgApz3OUZWmTlOp9i/bUo3yuUR5LPD8/W6/22nYrVzCqQNLdA8p718AiHKxb7DRHQ7caRlGEOI7RNA2Ox6M9DZDoAU+M00OB6CFx/hzDPfBXgOl8NNEJx91lz78xBofTHnhrENxG8BYjyqqwips5CjSmtG+qJOkV6nuZ0c6iRPzu7u4O+/1+cqwt5yZrR1yby5ynHAvdeucqeGOMTVRUiFpJUTHmmQDn3Iw4is+5EZ92bxCR4JZPjX+7hojOdzXSXAVLtMGDB9P4MJ2B1/jwzPWTR3X+c12cDw96b0/66/seu/0OB+9g1ylRMv5PnruGqRpBynN9v+5i2G63MOYM0WtOjxqFauBynXNXAZMDtTqgPmMYzsXP9OwBYHrgkusksUDZcrlE4Aeo6srmEahzpFsjFSlw59JMv5xmY+CVSAW7xgupPDVrdhwvW8A40RXycxW++x7XE3eLFwEXAcste3w3P9ekKd1F4KIDFGJU5BSWVIg0fowxNmmLSkZrHGgfFSXQ8AH7c39/byF2VaTvvnqL5P+U4Xff/ozsqxinrsTvfvc7KzwYmqFQ1m2e2h8KFPdzQuOaHc77t9vtpAaA75/Pg+ffTLgjqXHIsef7eCCMhh6orBaLBbq+w254Pt9z6qxyY7u67vz9MAwYN5fx4AE0HPcsy+w4sCQs26DHzqoi5DjkeY5xvJxUl2XZuW1OQSTtL4AXdRHUiO26bmIcqzdIXnB+hGE4yVxvmgZxHCNNU6RpasNtSZJg6a8xPgboohrH+x3K0yWBUA0QUpIkdq5w/LgO9Vqd/7p2i+iI5OERSbZAk5Yo68LOPzWiFZ3geHOdKaKilSRpjGlSr8tjF4HQ8dN3qTPB92qOwzXjTBEoz/OwWq1wH75DUuWo0wLb+AnP2+dJaEyTMJkIzBMeeWibtl2RmizLcH97j9vhLYI+QrHa4gN+xvF43unANrOEsaJYbk7JTF9GszHwSpQk51MLqVC46NQroWDJ8xy3izvEJkXRH/C0fbSQqMYCgWl8VhOL9Dx53TqnlGUZ1tkNUj9H2R/xfNjY/f+KJOiWNQomfkbvhZ4dBRYFoy5GFeY0CCgU+Szunyf8zES7JEnw9ddf2+e5GfpBEMDzPSy/yfDGX2Dz/Iyf/+knq5CpoPS8A/aFfNJ2AnhxzK3ykWPF74bhvNWKe/NdhalGFGFd8k4LA/EzhUnVwyI8Tx67iJLyxDXcwjBEVX06FyJMkfQZvMDD6F+MHF7PuvscU7aB7TgcDtYTZr+zLLMFtDTnQYnPUiPSRVM471hfgeND5a75JHq6n3rHRC1WyxXwn1JU/3lEtEpw99+FiJPIJu0CsFs6GbtWI0Dj+Zzbmljphkf6/lxrH/l7+PEjurazZyCw/yQ1BvjbDQ3x97XQoY6tesPutkI1aPVHETr3b85pl1xkYJEusfj5Hv42RniToHlXYeftJutC5yHnK3emKNqm7SAFQYBlcIP8t/dA48P72kORHixPVd5pWE/Xz+dCGjP9eTQbA69EqjxdT0MhbN/3cbu8w/3Td/APMbKHI4Z1j5+qnybKRxcPJ74aCarcKMQ11ggA68UNHrbfIdzmyO8L4AZ4fPo4iaXzerW21ZLn99qva4uSPCASoeiIVhkkn7il8ebmBt9++y2WyyW++eYbi1poQSV6pofDAU3T4HA84OPHD/j48aPlqYtk6I8rWEnaNxc2VeJzeNY6EzaVVxoKchPd1DvmvFD0wYVUXcja3cHhKhUdn67rsMgXSJ5X6H8XA2sg+lcj0rS3BonOyXEcbb6GkiJX9DI5thrqcr1SncP8WxWUZvrTGNEwCQsi6RHX2j/yyL7HACYEjM8fg9ALJ+9lUichbm6p5Vi7xbB0HrneOOfkfr//LIqgKJ/2nWvVJV1r7vvc+115QE88zxfwPR/lqZgcoa5z2X2mtsedU5fP+nM5cg8Y/REjXhpJKgu4Fvi/ygH32fZvMwIeAG/EGAAjXobqVPaRNPQz05fTbAy8Eqnlrp6wHjjDmHHkx/BO4bkUcBUiyEM7+TUm5lr8wCWPQBc273O9jtBE8OsIaA38KkJ8H1lFrvE29fLDMLQV/D4X5+PzXaOBQl0z5LMsQ56fT5FbLBYWPdlutwjDELe3t/jVr36Ft2/f2kNS6MHpzotxPNf1L8sSx+MRp9NpciSregi61euaAJwk4znhHeWtej8AJjkP+lzX+OM4q8enikkhZLZfY8EqZOkt836Fq3VclA+e8eFVAfoKGDwgHDy7k0E9Q3rleZ5PdpL4vo/1eo2u62yBJUUfuI2SvNH2qsJXHvJahic41/g/YWzP8+z59qfTaXK6IjPVdU/68XhE+tWIaBmiMRWqscTQ9hNjg89mSIY1NohwuNthdX7ovFEPWI0DNXp0TdDIUBRP55Sr4F2v3l37+j5+HoYh7tcPuD2+g1eHKO42AH7Efr+3hqSuY3euaxvUeOHaeN4/I7iLkN0uUfsl9qfdZOeStkvRTK49PstFPnRO7JtneN958IcQp/CIw9Nh8lx9vraX222vGRsz/fk0GwOvRHrMLL1Z3UqjAvjY7BG/yRHlKcrVDqf6vFfWXaCuktFtOFxkKog16avve5z6AvXDHkm2RJXvUVTFJGEQuHiAmgmsCYN8F5+p3m7f98jzfPI/t+0Rar2/v8f333+Pu7s7fPXVVwiCAI+Pj/gP/+E/2H3hvu/j17/+9acEJ4OvvvrqXEjm8dFuQ/z48SOMOVcnrKoKq9UKVVVht9vZE/aAaUySAk2TKckn5SGFJJMrKcTcLWyM/6sSY4zXhWOpXOu6niREKT/5bNbHZ/9oDHF8dFyZpMn+aXIZ81MG9Bjf1Qi9FGYxYgg7tE07CakodMvkQc7ZYRgmUDoTHsfxnGtwOBwm2ypVOXJOuoKb4wzgRXiI19C46/sem83GKm+OBT16GgTk8ck/2XBGe7oUqeLWQoYcsiyD758rbhZFgaI4e9EaStJ1RWXH3+wz57gqefKAylcTIK9B2Yx/u4YfgMkaphGkOQmcG1T2ab9A9LgCGoM07JFkGxy9o52LGnpUw4dt0tAYx4nXFkWBpvm97T8NQTcXSNeNGoZqLGs/NZS03W1xis85HtVzNeGdyiJ3d5Bbgn2mL6PZGHglIgQ+juMkpkqvT4v8PG2e0C5bxKsYx9PRKkX1GLmIGHOl4NEYryYb6oLhonzePqNf9ggXEar6hFN1OZRF92W7kDUTmIBLDFuT7oCLN6OJQ3oYS1VVWC6XyLIMf/d3f4e///u/t3kCPJfgp59+sn08HA7467/+a6vUKBCapsFut8ObN29sO29vb7FYLND3vT2Y6FqWuibmkT91XVsl4SZTAZfa+Rwr5S/fo/F/TTjkGOuedk2QZOxfDRAKeAo1bkVU+Jx9ofBXL1RzJIy5nB3xvvsR66/XSLMM43jOd9B6ARpaoVHBpD3gXJve98/Fh4gO8N3cLUEeqIHS9/3kBEc1uMiX5XKJu7s7u3uk73tst1scj0eLCqTp+RRQ3SnCMAXjyVoEB5iW5aYxqsWg9PhtYwyWyyWSJMHxeLSJkvo9URDNqVElRuVE3pRlOTFEXVhblb/uwiCP3HMNXGOUz+B6s/0NGvSLGl4dnI9vHvrJ2tZx4OcM06kSB85nUdyvHxCZGK3XYLt/RlmWdh1x7rvzXsNKkxCAGFW8h5U4Pe9yJLfmbrgIifKIOy2Yc3J/f49/+2//rT1xdaZfTrMx8MqkXsI1WIyC4GnzZL0dza7Vhek+NwxDLBfnmv11U9utXsC0hgA9s7ZtbX13evUsIpMm5wNoirKwyW5q2V+ja23Ta3UB6yLmwgUuZXQ9z4OBwdBftk2qF6A85HdUkBQIyrdr7XHb7bbrWp9cb9Z9jgp0F869dr/7bBf2vdZGvc4NVSh9TmiO47lyned55xi6s1vj2r3KB/XC3O+uKTntp9s3/VwTNXX3Cq+J4xhZmiGOEwShPzHktG/KM5eH7m/94dhpUquGJ9z3uGPnjs3n1vg13rjrxOXrH7v22t/8v2kaPBUfMTz08MYAFQoUh+LFdW7fXF4B53G5Xz/gofgW4T5Fc1+gX3S2wNDnSPnijo87N9018Mfk3WKxQBTGGMfzqZEqBxiOpCyZ6ctpNgZeiRQW09iZW1ELmHrxbvwZuCgd3Y4URRHe3L7DzektvN7HcfmEYfjRni7IeLwrnBQ94J7rt6t3WBzuMZoR25sPeNx9sB6UJrAB07Kq/J/kKld6ZNwD3nUdNpsNnp+fsd/vsV6v4Xkedrsdoj7B8/+zAvwRb/+PZ4HxD//wDwDO3vnvf/97ewrc27dv7aFExpyh9KIoLHzqxoOJZmhSnG7ppFGhHqT2gf10K7Ixh4FeNI/6BTDxOlXQ0qNXz73ve5uI6HmevZd0DW1h3gDDEgwd6A6Icbxk79/d3dlEPPUO9W/2iUfB2pyWT/B7VVU2t4PC91qGPdulEL56r4qO3N3dYbVawfM8FEVhqyNGUYRv7r9F/4cAXuUh/Y2PD9ufJ1UfefYET8XTHA+FogHYrZTGGFuFkQYVt2AS5eA6ZEEbIg5ubQL14InyuJnxun7dHAoa6eSRQu3qQXOeukYy26Aoo+d52G63NtSkdTPUQVB0QNeweuJhGCIyMYLDp7LFYQL/3WUNENXilkTXaOdYAxfjlW3SHBo9qEgRJ/IySZLzWRXJ11jVD0Deo/vuCBOYiROgIY+ZvpxmY+CViPCZChL1rtwkHvV4SZ+D2DzvXP8+bReIf14CnYfM7xCFjxjHada6CgL+VoURRzGS0xLBjzlggPzXFY7J3goYtlmT8FyvzxU2+pmWUGYf/vCHP6DrOvzt3/4tvvnmG1SnCr//f73Hb/+v7+H5Bn/zP/0VHh4erPH0j//4jzZuTjiXZ54D521vP/74I56fnyeFWYBLGIVCQj0WXsfnqEBWIaW8175rLHW73eLm5gbjOFoYVQ0J7jhgtreGFtwtooROOZYM4QzDcE6Q+1QgSvuYpqmFeGm0aL/p8fKdVPBU2grlA7D7upmj4Cp0Eo0sKkTd/sg2KsKjCpTnHFBx67PjOEb/aHD69wOMN8LLRpjEWAWtSa7udkUA1nvlHNb5qdUfAdi6D7p1Mc9za3BwHXI+qLLW/fW6rkhufJ4GGtuufNH79DN3zbm5QVrieRzHCYJyDYFwPXJFSfTdbdui7AtkN3vEQY7m7oi6rSbPVzmmcwK4Xp1U+aQoAN/NucD15/s+bm9v8fbNW8R/uEf/hxD+Erj5KsG2fbQ87vt+Uihrpi+n2Rh4BRrH0ULtWirTXYjXSBUOnwVM0QPgk7GRdhjiHsYDuqBF3/STxfQ5GFMXYNd36KMWiAaM3ojWa9A1l0IyrtXvCid9jwtNK9w6DAOyLEOSJGiaBs/Pz9hsNlitVgj8AKs3C6TrGEHs4+6rW5vc1bYt8jy3XjiF+fv37+373r9/j48fP+J4PFrFpF649t+FWTU+qfzWvl1LftN+0phg7FqVtMbfea968BxTfkflqcKZ/eHeeIZYtG308DhmFJBUbkQ8mNiaZZlNftT8FjdDXr1dRSbUuNN8E51z5JFC7zQEmCeitSr0WcMwoA86eEkI4wND8HIvPZ/vQvxstxtS0ZCOzgXN4en7HovFwhaNUvSEuRK8j/NT54POM10balDrPNJx1nmnCp+fBUHw6VjnJeq+xnZ3Od7YVfxK+rkaIMpLXSeq4J93G/TLDuFDiLa/JJ26To2760nJ9dTd9/Mz/Y7VO7Msw83NDVbrNYIqQfE0IlwCYWowNqPNZyJaqojPTF9GszHwSuRW9AOmlrorqDTZyY33u97DOJ4zznfpBv1XHczooxj3tmiOegkuDEglwWuKosBz8hHt92dPdN8+26Nt6fWpcHLjrBRSrrGgcDC/43ZCFpEpyxK73Q5v377F3/zPv0Z8EyCMQ3zzN+/g+z4WiwWGYcD3339vawoMw4Cnpyf89re/nRgD9MazLENRnCvA0YAAplulSK7w0zoBmpCphpgKdhp7vH673VqomUSPhfvxGeNUJaAKhW112+h65ZwjVAR6OBMFM093JOSraAUVHEvL0qNlzQA1KOg1k9xQkSZEukiAGxqgIZQkid2uqDsv6NnXdQ0v9RH/jwk830eXnKsvqvfPdRXH8VWkzR17nb8Ms2h/yDNFO6hkGELR9UsER40A93lKbo6Gtuda7QhXSd/e3OLt8B3iH5foVxW8tbEH87jIgSsz9D26ll0jXseRc2a7204MVvX8FTnjva7MUsORxDF0kUPynqGB9XqNPM8RhgGyvw6QfWUwBD2qTwc4lWWJNE3P5YuDwKKDM305zcbAK5Fm1upCBaaxxwlkL0KNC4qQsCpaCq2Pjx+xi3bWW+a7XGFNwaIZylpkZnfYYW/29loSFaoKK/WuKPgVAdC91CrgqEBvbm6Q57n9//n5GXVdn3cavD1vMTOeweFwsNsUPc/Dw8MDjDF4//49fve732G/39sTCunpGmOw3W7ttrIgOJ91oPF7vpeeYJZlE7j8Wk6EG3fNssyW2aUHOgwD9vs9wjDE27dv7X0890GNEb2XYQM9kZEQOt9HngZBgLu7uxflpundV1WFPM+t4eIWLwqCwCIudV3j5ubGGmtFUVjjTHdYkGjg0Ihk26hcWNLXPa+AvAHOxtZ6vZ4kkPq+b88PCILAKtc4jlGeCpQoYDqDcAg/bWtr7LO4xshP8pinbpI/yi/OV64r9oPP6vvextvTNEUcxzaPgIYf28Gwkq5n18i/FnbSugiKALANNEQVJfQ8D3EYI3lcwttG8LsA4bexHUvdfsj38n+2iSiPGn/ABb3RdtPAZFu4NjieGv7g9a7sUMRCt1OSn5QTACaJf3me4/b2Fvf39zYceDgcMI4jVrcrVFWL4+Zo1zLPSNA8kpm+nGZj4JVIi7OQKNBdD8G1nCng7m7ukSHHYAYcuz22u+3E4jbG2IJAwPTsci74awk8KqgBTGKwKrSMOVeA09P1VBFwAdODZP/G8QLfMXmQivn29ha3t7cW2gPOMf/NZoP1eg1jjN2LTyX45s0bK0y2H3aImwxfP2R48+aNVXpN02C/36MoCgRBYBUMlQv5qtXqPM+bHCTlemcKQbPvq+UKb27ewu9CNH6Nx+0HlGU5CaU8Pj7i9vZ2otTpwdH7VrSIfKYnxnoNNPJcNIb5BxwLVS4qgNXr4rbOrjuXy91ut8jz3G7Z4/0sCsX8hvNBOie7y4UGGseGBmJRFLYdnANUnkz21PMUVICzfxT85LsqFBoB9NRXixXCNgECoBoLa3hxfLWoEu8jv6nkNYRFIgJAHmrCJQ0Djt81VEDXmRqiiixx/DSXgfOCa4ikxmk/9uhuTwgGg3ZxQtWVFg1SJFBJ5zu3bmrJZ6579lHDNlwvbIeGotx3KWrANam81+8VBWCtFMoJHkDm+749qCrLMnieZ0MATdPYXCzysigKiya6WzJn+mU0c/GVSOE9heU0iRB4uQ2Hf6dpitvxDRY/P2AMewTvfsYpPk329eu+ZmBapEgTlhROppXO63gvF6wbVlClo8pRwxEu3M72UchRgb158wbfffcdvv/+eyyXSxyPR+x2O2y3Wzw/P+Pm5gZRdK4jz9MJ6YlnWYahG/Hv/y+/xe/+Hz/jzf9hjb/9X77D+n6Nuq7x/Pxs94Zz7zwVuELq6qW4Ak376Xo9/Pt2dYf10zv42wTtmwLt6lK5jrx+fn4+t3e4lCOmolIvSxUU3+/ubady0OfofS7UTIVCZUNlr+PFZ5VlOdlG6hqR7I8eEgSc6wLwHeox6j3unMyyDKvVyiok8oLGDucM14UWVlLjlTtg/OcU3X+KYNIR0d/1CMPa7ijQazm3tZAQDVO2kV6+Gs/AJdTHQkhEP/jDeaTKTteAwvCca/q/5vco6nctt8DuyLk7ob+r8XzY4PHx0b5DjQHX49e26Xp157jySBW2KnKdm244gO1le6wR44Tn3LAI54XnnQ9C4j2KFtHQJe/pCNHY4hy8VtBppl9GszHwSqQLREmNAE5iFz0AAN/z4dchcDofjRr04URx8RlqDHARU6FS2LtKz81hIHTIe5MkQdd11ju/1i9XyLnxTVV2wFmQ3N3d4e7uDm/evMHNzY3dDkhLvyxLLBYL26b9fj/xurq2w+7HAvW+xemxgYezUN/v9zgcDtjtdtjv9zY73E0Y0z4oCqPfXYuf8v8wDBEghClDoDIwRQB/MT1vADhnp+/3e+vRqNKjItREPFUIVAquwcZnuwYYx5/81ji/W2yHfKUw5bHF7phRwashx+ew7RrqoNJUo5N/KyqkXraLarBt7hkIamhogRmUHvpihGkBvzbAp4gIE88459yQhfKUY8Aw0DAMFu1ie7qus6gEjXTykAaezhtd26qYXIWp12qcHTjD6FyDPOjsYf0G98U3CJ9jFLfPOBSXHCF33iqSpPPHfY+2hzkCeo3bdn2GG07TtcX14G6h1GtofHieZ08j5Tir0aTJtLoWuc4U5XDX7ExfRrMx8ErkLiB+RkFDARTH8UQQcjGfqhOK1RbBuwhD0KPw9zYk4HoYarkv8gXu8gdkzQr1TYmn6sO58mA/PSRFFwyNgTRNcZc/IG9XaNMam+AjNs+biaeg/dF4pwofz/MmMW++L8syC4WXZWm9581mg7Zt8eHDB5topgYLBVWcRfiX/8tvkN5HuPnbBTo0+PDhA/7dv/t3+Pnnn7HZnL0lLaOrfNJnUmnR81CB9TmY1Pd9VEOJ+s0OUZbjtNjieDq8qMI4jiM2mw3GccTNzc05/v0J5VDPjXC2JoFR6WpyluZhMLRBJau/2SfW2fc8D4fDwd6zXC6tYUKDQ5EgVQ4cW80JIZrAmDy9u/1+P/GSda7TENB4uc4dNYKYf0Fe6zgxGdJ6rO86RJ2HMerRJBWKfWHfR4haERU1EhiO4FZCKlzOh67rJiEW1j7o+97WRQBgjVjdpkjSsVPD+JrSVk86yzI8rN4gb2/QJw2e4g8oygLJmCF6XMDUHhJ/iTiNraJ0d5/wvXyf8lLnE3BJKKbydg0IEkNxnBsaflR54N7nGh56HcNSURRZeVFVFbIss6Ecto2GGZ/FeU5jjmP8/2PvP5skybLsQPAoZ8adBMnIyqouVE+jCXqA6RFZyOL/7i+ByApkZXZmdtBAV7PqyswgzoypqaqZsv1gcZ4dfW6R1ZXh2C9rL8Ql3M2UPHrvuefedx+P7L6Ury8XMPBChRPe9g3bwEB/1++rqsK99wm7dIuu77Fb5QPqzRY+fP4oG2PydAv/IUU4HqF9W2Oz3QwUkL4bOPlT0zjFdHMD72OGKGlRvztgF52CthR42NaBKgIKed1u1HUdVqsVPn36ZGjXtm2xXq8NGKC1yiNySeWu12vj657/aQb/zVs8Pj7i/vHegIntdvssHa3dVyp02QfngJr+qOXddR2eVk84ZAeEsxB5nptMaPo+to2xD8do6GBQF1Xe3KKm/auUuwI3xkOwqEXLelJY21a/Bo2eo7V17GzaXOlq3/PhHDz4jocojAZzScGX1tmOXeF8seehzXTpXFNmo/Vb+H9So2lbFJ93j9jgm8+jr1ljEMiWaJ/Q2tf5oHPY8z63t/HgpQHqaYPD4W7gImJ9ufYV2GifKDjX92XpCLP8FYKPYyBpUb89YO/v0bg12tEBru9jHxeDoFZdk+pi0LGw68Z+Pid79Drep/W12Qidi/Y6smWNGi5kIW2DSQN9u64bMJS6bZjMA9cm561dr0v5eeUCBl6onFvojuMMLA4tthB0nKNPjFYJkfs5wTN4Xt8D6AEH5sdWcmolqDXb958FsAPA6eE4p90OtjBhUeuESo3XqbBqmgbv37/Hf/tv/w1t2+LVq+P2weVyid/97nfYbDYG2TP4a7FYoO97fPr0CQ8PD9hut8jzHJvNBp8+fTKCj2xA4AdYzBbYlTsT0AYMqX7tLwoe7Xeb6VBfOYOXlvXSWNsqePS6vj8dOETr2E40pHEaSsGyXxWEsA2cA7YLhIqPtLgmAmLbNGbgnPJUS/1LIDbLMmDlo/gnwPUd+L85WXXsAxu8MFiPwlq/s6l727rU/lI/Pb/TZF5qQbJP9FrOXSoRggTeSwuT/nnNWQEc4x68MkD1tx76xsXk7RybaI08zwdR+trfdnpcto0BmjYzc5yKDuAMs2DmzQajX2TwEaI8rJG/PxkHOhf43HOAypYvnHfsXxsYKkPAPrZdWzo/+Cyyf7rWFLCQAcuyDJPJZHDWAVkgrhXgGGDMdnEdcceLsltkvS67CV6mXMDACxXN2GZvE9JiK3dgGHyoEcYafKhBPMBpC9pqu0J8lSJO99iHBVbFcrC/nAtXqWUK1bzYIp8/Igr3qIMK6/3K+JqVHlRgowftUCAqmKGvt21bvH//Huv1Gr///e8xm81MEh0eTOT7Pp6envDDDz8gyzLDIOz3e9zd3eHh4QGr1QpFUaAsS0ynUwRBgKIoMB6NMa2u4e4CBKM12vgYc8D+BIaBZF+yqlSoad+ooFThwz5VoQ6clPZmc/TtvnnzZtCPXdeZlM99f8pKx35lP3KcOO673Q5xHBulTZpVlSgD/lTRk9pXC30ymQzo4qIoBgFZ9nw81s+FWwQ4LB20LuC9fX4KH/sjDENMJhMDEnnaIceBfci+Ni6Az33JqH77QCLeS+uY84THWLdta+IhWB/uBNAgUvabnibJMeD843u5k6L50UF936HvHcSvMkNxc0y1H/h+2yVIkGkzKGVZYrlaIV58QvZuitrbY1U9HevqRXBXMbw6hJ9GZvusxoCoglcZwjmmc4/zQoGhjjfH4RzrpQyEXqtzUBk12/2WJAkWiwWm06nZrcSdJYxJ6fve5OfgmFMWaP0V+FHOXZiBlykXMPCChUIeOAkGLbZFWte1oXvVQgQwsH70XgUTfd9ju92i6344ZvrLj0fsUqnQctItXrSIHOe4f/rH7gfEUYymaMy9CkBUOPC5SgdSSNjX8x7XdfHx40c8PDwYAKE5Eh4fH43vlwubUeIEDgCwmC8w9mbwuwDZfITQjeD9YwZn5yG5AeLFBut+PaBDWS+lM23BaPtCKWgobFhYPyoytSABPFPu9/f3GI1GxteuaXWDIBj4R22lbf9oYYIoHidLi5bKVY/t1W1jrL8mZmK/6Jxim0ej0ed2e8CiRvgLD73bYRfsBucCAKctY7SwqZzZZs4FVYicS5rlTy1rBg4qQOO85DZWPs8O/NNjkblONFMd60SQ5TiOaVOWZciyDH3f4/HxEfP5FeI/cYEO8F77SB4TE+vDWA4Fx9pe3TapIIzjcXRdVPjh/vfH+I5Di22+RRzHGLtTRD9OgL2L7HWHJHkwh0/ZTCHzH9hyRpkDBYrKTChzec6lqWuadebf+t2XslJmWWbWQNseczrwxFHdbaM5KQ6HgwmGZv/yft7DZ9ttv5SfXy5g4AWLWpdcDEq92YvNVlrAacFRMdoWgPqieS8t53O0OItSwlR4AEzyG7WQ1UJQHyrrrhaR1p+Kif5/Kge2h4tZI9JpVTB3Pi0EbZ/v+xh5U2TfXwOFi/AXJdrbCn3cAgcHbVSjaetB4B3fyfraQpn9oSCJ350bG91nb/eRDYKAI9VJhaeBlMyhTyFGi08D2mwgoPkIKBjJ2vDdjLxP0xTAKYEUf6cgZv1pUes4s04aDOp5Hmpvj/B/AqqywP2nT4PMfOqyAI5H4DJAz+5vbh1jnXivPTZsM3NIBEFgjl8GjkCFQJHPIRsFwCRaouuGTIBS3HwnFdPhcECe5wOWJAgC5M0G8W9ihEGErnOQFKk51lndRDZrpMBK5xXXks43MihqaTdOgz5q4XRAF56YqnPrTv8/t+7t3+1+YNG1raDDll82s6nbABWARFGExXyB+WSOZJSi7RrD4CijqNQ/05dzLSRJYuQqZYe2Q10kl/J15QIGXrDowrEXqW0xq6Wg1+hEtxcyJz+AgQVyDlTY71I/owoMpfXO+V7td2hdSX/ybyqj8XiM2WyGxWIxQPn066tgUeCk+QBoLRgrpnPQ1w6cxkG775Hvt8CbHbxbH3l73Gqo9bXrqZ+dEx62L9u+TpWE1l/HRgVyXdcoisJs06OlyyQ29F0Dw2AtDTJUpUQWxhbQrAvpVo0g15P7GAnP/d0KDHXe2IqCv682S6xWK5OrXoGQUsQ2qGQ9+RydW1TiOm6cE2SPCATSNMVmszHR5wAGW/1o5bP/qZQOh4NhQzSPAQvro1bnaDQyyqyqKniOh+YfArQPDrI3c0wnhXk328vxVBCkbI/OKXtt61hyrJ6Ke/SvOgROgKLPUTwVg7mq9+u8/NJz9fl6rV0vFh1HW77Ycsp+P68djyaY168R/d0I/q2H4Fd7EzB8bi6re1VdSFw3Ol85l+ykbpfy88sFDLxQoQBQIes4p90FtoDg5OfvXECKirk4eI1S0/aiB/BMQel3qqiI4rVevFaVEoUprTNbSTiOY4Q5fbmLxQKvXr3C27dv8etf/xqr1QqPj4/I8xwfP340bgo9Rc+2hClU1NLIow3ctz78Q4hdtsLT05Ox1ulbJjDR7Wx2ABqFtgohba/tB1UAdc7FQLqaFDEBkucds/mtVsc4DCZWYhCU4zhmy5sd40FGBThli7Qj5T3veNYDt1ZRgdIPXpal2WbIfqC/WcedlH7XnXYo8H1kE9I0RVVVJp+DCmsyMWSC1uu1mU9Km/Odmk2Rbe373ljavu+bLIjT6RTT6QzxPkX3zy7GizmS+dH9MB6PB0qc/dD3vaHTOddZR43ypzWf57lh8/hDV4XrHhNgeY2P6gPQboAgjpC+PbIDZVma+cM9+6qAyfKQcdFth/YuAI4h43BW6xXKqjTzTtNga/yE7iBRGWDLGjUGWFgPjqcyhvYuC9ZbAbuuISp4sl2e5yHyI/gPMdonF3UNxN8dFTczDeo4cD7leW7cQ8y7EMexcbmx6HbXi5vgZcoFDLxQUf/g+cj950yBggAucgpHjT2goFcqkVaO0nIaTKS0Jb+nYKJQAo4uBvUFUllp/YETFa5b2qjQwjDE27dv8fbtW3zzzTe4vb3F9fU1FosFXr9+ber+X/7Lf0FRFMatwXeolcy+sGn5x9UDdlEO13Nx2B4G8Q2shwos4GQxaR/qeyiAea3SvnoNgGeMhu/7uLq6wjSaw6ld7LDF/dOdUe6kuOu6Rp7nyLLMKDFur2L6ZH0uhbgKXj6TPnXgeGLifr9H0zRmn7bnHQ9PYpvt2I/RaGTawyhtKlOl2dXSD4IA6/XanGHAPmK9kyQxW8ZIz69Wq7P78cmWkCVRVoltU8A2Go3gdz62/0eDw32H5JsA0/+Y4S7/ZKxyKnltr7qmdHx5jTIzqsBoZXItHw6H424KD/DeunBjH+kvPGz64TkEWn+uL3srnM7tc0BdwRmP5lWwofJCkz6xvxQU2KyjHW3P+abgiIBFT13V7JEcP+7+UZBHeaNrJUkSwAO6qz2CPkBw7aBzT8e8qxuUfalBtAy+VFBCWTMajQbr/RzTdyl/fLmAgf8fFXvC2u4A13UxnU4xyaZouxab7Rr5LjfX2D9/6F02crfvtT//0nP0O/s6KlBahozI1tz059gKfZYqdF5z7r1t22Kz3Txrl92n+pn9/U8VFUzn+sEW4GEYYhLNML17DbcIEF2vUI1LLJfLs32lQEypULXO7PrYfWXX1f78HM2r39lAiD8KhOznUhnozgtlVuzxs4GUXQcdZ9tKtevVdR06dHATF27owk9dOK4zUFpKUdv1tvvsHFWuFrO2ge3qug5VWyF41yH6ZQx/5GL/T/tBH/De8XiMwAvRNi22xcYo83P9+oeKfZ89/3Q8z4HXc32v5UvXaV9q2+x7JuMJ0jgF4KCqz8/7fLdFMAsw+zMAaYhD8zwVtQId21DSom1Ug+sCBl6uXMDACxVbOLCopQcMo8VpqXje8cCN16O3GK9u0fkN4vkHwIEJAmNQnD6H79EgrHNFLT51Z/BeFeYancvrNZCNbSR6XywWyLIMf/qnf4o/+7M/Q5ZlJm5gOp3iw4cPKIoCeZ4P9unTx6uuD91aRqtN68F2K53PflQKnBYZrT4qDlqi5/Ylq2Cyg9tswdv3x0BOp3HhlAFQeQgOEcLxaY95mqYDdoYswG63w6tXr5AkCSaTCfq+x3K5xHg8huu6xuJXBkKjwVVw6sE4DL7i36RtOb88zxuc2Kj91/e9YS5I1ZM9chxncA4E38vdBgAM+Gvb1tRdsyeyvjz0SN1oHN/b21usVivjemmaBuv1GpgAs79aYPFvU3hTB33YYjqdmhMjGT9QlqUZd7pouPY4Z1TJc0zYBxpvsdls4LrHnQUMru2CDnEWoW4OJqkUU2p33XH73Dy+wnh1jb4DVrOP+Ij3JmBOGQvOd50f9npWn7jOb64Xk6YZQ2ZB5Y8yPLzOBhW8zo4hsRlAlRFhGOL1/C1GT9dA3yNfPJmtmjb7ss03gNPDP5x8+2TMOBc4PowRIfiny4Zj0nXH7bEMKiQrpnkvLuXnlwsYeOGilDsFHoWrAgClW33fRxRGSMsZ/IcEvd8hScZwnLtBcJkuYJsq1G1kjuM8o1zV/60oGxhaY3RTqHWgLgnd4x4EAf7Nv/k3SJIEb968QZIk2O/32G63+PHHH43AXa1W5uQ8bv/iwqfSt5OW6L507lWncNdANeAIIijMlW5X2leB1DlgptvabMGqSpX9t9vtUE5yxLcr+GWIcrbGvjwCN80JwedoYN+HDx/Mue1RFGEymQyOM+YzgBOASZLEZGhknfb7vflMD3Hpug5lWQ72w6u/2nEccwgPBT0DNjV//+FwMMdGq2K15x/HTN/F/uV1wNElxeOsgeEuDZ5boVsEm6bBerNGGIXIbhJ4vgvAN8F9aZoa4OM4jjn2Vq1PjbvhGGjfquuFc4T1owJiEiV7qy2VNddfVGXw7hP0nYMsnSIMH8x+eo0BIkhVS9v23avbgPfZjAX71l7PCmLpGrMZBY6xgl3mu2Df2/Xgc8MwRFSm8D4lgAOESYU4TgY5StTtyTnFOkRRZFxfthtA/+Y8ozzg53QzcEvuhRl4mXIBAy9Uzm1RA4Z+aQpy2zrvug7VvsI+LRCmGfqwRRc2A8WkAuDcu9WCp5ClMKT/WWlQCjXNT66oXq1kWiF6D/2s9CF6nmcSBfGMeyrXPM+x2+1M5jbP83B1dWUAy36/N98Dp2h8FeLKtqhlqcBKQYxaOl9iTVS4cnzs7xTYqWB2HAdP6yccRgd4Yw+H6mDarYIdOMVb8O+6rrHbHY/hDYIAo9HIPFNP16PSshkGAM9OFmQdi6IwY2TT+eeCyyhoqbD4PJ4EybMJ+A4FOQoO+VzOQ77TPgyHfdj3vZk7tPJ0/VD5muOqtxuzxmitM+cClYgmEbJjaoBh/n72AZkw1pGAve97E/nOOUa2QMG11rVO94izBn0H7P0SbXUKENa+13mmz+AYakCcWvM6npzf556jc1jZCF3TbL+9JVKpevt6fl7XNaqoQDiawAHQhBXa/JSDQ9cr66x9QJcoABPjon3MsePYUp6R8aFbUufWpXx9uYCBFy52MNw5ak6FJRdLURS4C37E/l2BHh3yamssJFVMVPK6T1cL32ULN13Qto/R9sfpc3iNCnmm251MJhiNRojj2LgE7u7uzAKfzWa4vr42J96ROj8cDnj37h0Wi4WxCn//+98b9kTBiCp3u/6qhKhgbOVNJex5HsbjMZI4RdM22O1y5Hlu2qbBYHbbVRCqC+FwOGC5XJ71cdpjwb8pcJnfgf1KRUeFrOCOyrLrusFuEwZ4qQDn7wzAUsvJtkYpeHXOkokh/c18BMoAqJvBBiQKzoAT2GQbtZ50t2gf6Xh0XWfAEZMTsY6Gvu9OJ0NScdDVYANkta7tGAVt13g8Nq4D3kPGQt0jOuZFUeApukP1ugD6HptqPTg7w17zZGNUNth9bM/DL5VzQJf9azMaWh9levRaHQcFA1yHRVHgwfuEw+s9XNfB7pAPcljYoNp+N+eu67omroInY/KdGmBoA7okScz2T3u+XcrPLxcw8EJFLW9dEKq4dGLTqlIU/Pj0iF2xM+hbaU5S5bqwuHDUhw4MlY5aQUqLK5jQe4ETjQc8p1YZIDidTvHu3Tt89913SNMUv/rVr9C2LR4fH43Ftlgs8Nd//deoqgqbzQar1Qr39/dYrVZ49+4d/uqv/gqTyQTL5RL/+T//Z2MtPz4+mq1i6j9XYaOWhu0PZh9p3bMsw6v0GyTrCZrkgPXszuxoUFbHdssoXWmzCFqHLwl72wJTdoDf0UfNscuybKDQgiAYJM7hPGAMAAMT67o2OwY49gQXXXdMZcxxp9sgCAJzUFRZltjtjuc8MDmSFgpfOyGW9h8ZIY6J9pemxFaL2nEcQycz6xzjBqh87VTOZAH4fN3zr33PMeW9wPCMBIIRvjMIAnz33XembT/88MMg7oGMic0ctW2Lx6dHrP3j1kp7J4UNsm0LXllAVd62IrW3I2vfK1i117yOl85XBWscJ10TCsB4X9d12Gw3qPbVYNxZd7pWyOIQoLGNCiD5P88u6Pve5IYgK8M+3u/3Zoshf5IkucQMvFC5gIEXKqrs7YVvW7jAyZoFhnQ1rVU7Cxyfo74zDYSz/ZCK8JVm073kCkxUuVEwahuI5tM0xc3NDd69e4c/+ZM/wbfffmty0r9+/RpRFBl24G/+5m/wi1/8YhD8eHd3h7//+7832+Emkwnm8znCMERZlijL0hzxq0qV/mQCGVprFKSampYKhq4Nz/OQxinixzGChxH8pMHhu8JY9+xnWoOMYVAhzb60C/uNyYTo42Sf8Xv9n+BNf3RLWp7nSNPUMCmz2cwo2DiOB1vClManQlXLl8KZfnbORbISQRBgPp/j6enJBAoqy6IKSoEOBTrb7vv+4LQ5Wu8KHKicRqORCQLjWHNdTCYTRE0Krw7gzYHd4ZjJMUkSuK5r4hiYzIkpltXvT7cVQYMelcyfNE0RRRGWy6WhnmezGd69e4fJZIIwDPEnf/InSJIE//RP/4TNZjM4blr9+Ox7Kt1zbKAC9XOBrjag/Sl6X9e6giC+x2Y77DTCeo22Q4EH36eMEbc8co3QqrcPEFJwUhQFFovFIFiaWSF13Ml4jcdj5Hluts3qIVLsEzWQbm9vL2DghcoFDLxQsa0jXUz2YtQ90WrpUtnbFjCvU5QMDK0M+3cFHayHInhlA/QeCijey/ozzfA333yDb775Bt999x2+++47jMdjY/HNZjPzjjRNTRIcLmYK5clkgh9++MHsVw7DELe3t/j222+R5zn+9m//1ggD9okKKxXCqqjZX/ybfd00DQ71AW1Uo4869EmL1jlt8bOtRz5DD/+x+4pCiZ9rwBWfo8pBhbNGl8+mc4RuiN7pkZdbo9x5YqPrugOAoWNP14uOJ68jG2EfqqPMAJP7MOhT8xnwnRowSrcBn03wpGCViWE0YFJpf9ZFD+TieI1GI4SIsP//+DisHcS/duB+46Hr20HiKwIPdaP1/THnAQDj6ydrQhDEwnawnmTo+P9oNDK/j8djpGlqFN9utzNBgerOcZxjrvwkzODCQV5tzVZYAIMgWL1PwTbnIeeLzm8ddwUYelYI28Z7dK7p9wpKdb4zdkTXk7I/HE/WS5+pTILKrbqusVwuEcexCYLVuBE7K+RmszHBxWmamh03tiuT9z89PZmxvJSvKxcw8ELlS4tV2QAt9jXAcCGrRaDP/NJ7gGFaW9uK/ZJVq3WwrQEVXEw1/Pr1a7x79w6vXr3CZDIZWIKkXzV9qFLxbduaXQXff/+9UVRKp/M6CnLbWuH/Cqx0W6F+p2zNNt/i6eojxr8s0bgHPO0eB1TvubG0v9Px0Gu131RQ2dSsDSzSNMW1+wbp/QxtWiOYfjBuEd19wox6AEzQIZ9BC5lt1WA/ZUmoyFgfKlOlZO2265zROazt4P/KzBBIEECy2DtBqBgGz+8d9Hugq4G6aIEe8AN/8BwqQFtxUSnooVG6NVPrQUWl50ZwBwXbwOyRCqC5hVEtd7blKr7F5PEWTu8gublD0zYD5kPX2zmZoH1tuyHOzbdzc0zHUOfsuTHlZ/q/xlLoPQqCVfbwfTYQ0EyVTMBFdkHZTs5RTdREEMozTjRmg0DS932zVfVSXqZcwMALFV0oqoQotHTLkr2gdMHaIMAWCueUHZ+hVpiyBfzetjL0O75DrV19B/epz+dzLBYLc1RtURTPArrU0qayoYWW5znu7u5wd3dn/H2kGrkXn/er79Ruj35+Dgyo1QkcFcT94x1WwdKk+LXbzucBGAhb7ScdYxYVfOpTpzJXZkNZgjiKEW1TOJsA/t5FkEXm1DYV3JqsiDQt28a28PhdPZzI9qNvNhtj0fM79rWCGQI6Bam0hEkRs1/YVk3BrPEQVPjsC46j67pmKyoV8+FwAEIH4Z/HQO5hPy7QdTUyPzOnNNruMO1PHjQEYOCXtpWVHvyUZZkBEmQUlFUgYwKc9v9zq6GygK7jIjqkcNcRnM5BPB2ZvA+61ZJ10DgfVe787hxQVQZP7zu320aZqHMGit1/nJs67va77bgCez7boJdziXPScRyzHZYuF4Iwyp3ZbGbAAK/RNczrGDPAQMRL+fpyAQP/A4ouEKXeVeFzEVO4UVCqIrZT8gInZWUrM77LfoZNESoo0DrpsyisGeFLoT6fzw1yZ8pdBvk0TYM8z43CSdMUs9kMTdPg0w932HzKMbpN0TpHa6mqKnz8+BGu65qo6x9//HFwqhmFLRW+bcUoraqWGpWFBu5R8OgZAFrsPjq3vUsBif2/Po9JVezgLmC4TbLa71GNcmT7CG2yx8ErDRjSeWILd1r0fM/hcBgk3eF9VCo6n/huWs8KALV/1Xq2XRCu6xqFyDaqdWfPJ/UXq/LhePR9P2Am+nGHYBGgK48KuaoqPD09GavQjnjn8zX6n+3mXNJ6AacEWgoCm6bBw8ODmXOj0QiPj4+mbgAMgFFABQBN26DOKkSzPZzOQRVusd/unyljm9Wyx0VBpSp8nWsaM2I/U/9W2aBjovJHwQdwPpuhyjN7Z4KyeXp+CUEF51ZVVYZd1BNKGWjIcSVIYt9q2nK2g8/mjheu6Uv5unIBAy9YFGHrQqIwOrdgOflVSdiWAoBnil6Fge4Zt79Xy0EFzpdoSgUd9PUnSYKrqyu8ffvWZMpjsBgFI/3cAEzUehRFuH//gP/X/+Nv8fAPK9z+uxle/8cp8jw3vuqmabBarVDXtdleaNflnIVEQcd+Yhu77pS1DBju8mDf/hRDokLUtrZs65732OBKBfq5/uVzd7scn5wfkN2u0bQ1tpvNM1ZAx16tUf2hwtXAT9Ldtl+az1UFYLdV26KBgzqfNBslr1PXjgKhc2NJJa9ggO0jw8Xx67pjLgodY4250XG128f1p30HDHPhEyi0bWsSDZHlWK1Wz1xgPH1T+7AsSzyF98hnm+PY5vmAqbBpdp0PNjBV5kOL7ZvX52lf2GNoK3WdU/xd4zm0biw2QNFrGKyp46JGi+YHSJJksJbUxUWQS3nGucB36HbCvu/NrpcLGHiZcgEDL1xstK7IHjhRjXq9Wi28h0E0BBFJkiBLM7TdMRGMUtMq0GwfrgpPfR+vPydcNCCs644pQL/77jv86le/wnw+x36/x2azwX6/N6cHMvDnzZs3Biy0bYtiW2LzMcd+c8D6Q45xPow6v7+/x8PDw5HGv783wEKTDvFa+3ATrbPNlLD+tiKzLURV8LQu1V+v1q2CNF7LeqnS1T4EhuleVdHVdY2Hxwdsws2gbhwvsiNaT51HdiIpFtuKU/++XsP/oygyfl1eR1CieQDYn+fezbbxnQzaU6tac01wfnAMeZ1ay+xzpYyplKIoMutA57WCOfqZHee0hY4Mhm510/VEEMv68h6CLeY70DXCeq3WK9Mmsh4cR+139rEyf7oNUDOW2gyXrkvOLXVNKRvA8UySBOiBoixMnZIkQRInKKtycMiaGgw2GNa5pSCQ9/E5fd8bsEgZxnWd5zmKohh8rzEgZAL4TIJAupt4LQ8/4zq6lK8vFzDwQkURLDBUSlzcVPL8ngqfhQFKXCR8VpZleD1/g7gYo41rrNIHfPz0EcBRMFRVhSRJjFDSlK6MkrbpUy5o3UKolJvjOGbL4K9+9Sv8+3//7/HLX/4ST09PxkoqiuKYP/5zofACYJT7ARXe/acbbH6/g/e6xyY/Wr9XV1cmJwGT3Ch7QiqRgliBjVoWtPDsjHMq1ChMqaTsWATWnePIz/UaZUx0/LQoU0MBpXvaeQ2fxbrbEfc2iFQlqMBGBT7brfS+bbnr9jsdM24Z0znMPd8KKJQtYt0opFk3+z1pmhqFyvt4ngBTHQMYvD+KIoxGI/Pe/X6P9Xpt2svgVJ0HXCccl6qqTKY6z/OQJAl2u51pj8ZJOI5jfM/cztb3/WDrHCPhR6MR/uEf/sEcm62MntLcmoKXyl/ZAWWUbEaQ/WGvV73GZhTYLnXdOI6Dm8Utpt0VnN7FJnvEw+r+6MILr5DWE1SzHA/JJwPmtc7KvNlpitlHrAuDKjnftA5sN7cOMy6AMkS3AOvuAp1/zH/BgM8gCJBlGb799lv84z/+Ix4eHnApX1cuYOB/UFGLwT4bnL8Dx8WldCUtKlXKaZohWy8QfZqiTxq07xo8hU+DvO+z6Qypf0zQst2vsd6sjaWmVobt97ZpdKV/bdqx73ssFgtDBwPAeDzGfr83/n9m5EvTFNvt9mhxvuowXgTY5hvk29z4uIETFWizEfZealWIwJB2BYbJWFSJqoWuFpqOgVr+vI99RYGszADfrxS6KvxzTIwt/Ck0OS6svzIOqug4Hmoh2kAJwCBZkFrynGt8lrIcWl+ts46Dzh+dM03TmK12fC4P+NFc87Tmrq+vzZpgUCDbrcFgTXPMNMc8AJybpJW3260B0wSOWkcF4tzWqpZoGIaI/BiJM0ITtWj705ZKppVmXyrrVJYl1uv1s3wM7CsqUHvOKHWuc47jqACNSlkVvN5jt5MABBi6GNI0xaRfYPThFmgduO8cFOkOo2SM6eMt/KcU0SRD8/p4gJaCef7O9ukuFmXidK5o22w3DuVcGIbY7XZmjiv7yR0C3IGhcoiGEoNlmduCLptL+fpyAQMvVGx/vQpcVWw6yYHnh+ZQYanSRt8DEMVsPj7+Mp1McRW8QvrhGgAQvv6IJmvMwS3niloXaq3owSv8jpQnfX58LpU6/+eiPhwOSJLE7JknKGECGAAm3kDzCVBoqsJTX7la3qyz/mi7VEirUNLfWVTR2t/pPbYrQP/n7/b46jU2tWrfz2vs56uC0WdqzIC2Vd9lW2f6TLtfv6QIFMiQ7rV3M+hYab4CTUZDa5d/e55nKHmuHzIpfd+bqH4dl74/ZQHkM1zXNewXgAF1TWXKGAr+PU7GcP8lQ3nvIXo3QfeuwCbfmHmp84R1YwwBn3Vu3NmnNvtkB1YqMLBZKJ3Peo8tX7RPeMZFHB2Zms12g77rAfRADzg9AOczqOC/flgffbe6yew5PJBNVh+wr2wG0n4GYwPI3PB6JqNSuamAWn8oa3RdXMrPLxcw8EJFA6Z0QahPkxOYhWhY6U6l3ShQ8l2OzfwOWXxA4+2xrp8GEchhGCKoYziFD/RA0MYDoXpO6fP9SqED5zMb0srj9rWmaYyL4O7uzliHVP5FUcB1T9kUbfBDoMGtXErdAifL6JzyV6DCvlYLDRhuwVKWgO2zBSmLjh3/tsHDObCgypp9eg6A2FaUjgnfS8tb62ozEqwbx0eDtc6CyTP1tpkAbYcyKnyOKgr1dRMoOo5j6HuOP380YVBZlkjT1LSX7i17/Nq2NRa6guq6rlGW5bMAQKbQZv20vvpsA3qdEN3GR7vr4W48OP0pgp33Z1k2AOg8ptdmh7RPdf6wTwkQvvSZ1s++17aOdUuijt1sOsNt8Bbxdow6q+BOfsBqs8IqfgC+ATx42PhLlNvyKCOu7hCPR6j8HTbFegA6Ob/UIDg3j84BFo1hYLEDVzlWjuOY46A5l+gCoIFB+aSsBecBmZ4LGHiZcgEDL1Ts7VnA+VPGFHFTwOm1FAz6vKIo8L79EUFwBwCDvOy0eorJGt7N0Y+XuysU25NVbvsBKaCBUxazc0KX9CwtNNc9JhC5u7vD7373O/z2t781W77KsjT0L5F+nudIksScd89T6phTAMAgEEgVvipNChf2VVVVA+uS/U+BpvEZeg2Fl16rQVr87lwkvM2k2MKJ4wGcz9KmbVMBq/MDOMUYaPvZp0oX089qW2A6n7TOHBvNcKnCXK1pnZdsj7o6VEESGDK1dNM0JisiALOnnPSwMgncGgmcmDEqW10H6rJgWmy2lYCaQY18DpkIWvRMZ2zGyDnA/8ZHEPvobiuU+50BNV133JEyiadol4AXOKi8wrACdv4G9gPrwv7nuCuTYs9t7XuVHWyPjiXngW5bBY5UexqNkD0t4D5F8Hcx4rePAFa4f7rHNt6atbbf71EUBXbFzrApZPUY18H3n2OZNNaCReeVvTbYXp2fZVmaMVT5xF0HmmCK7+ea4PzgGJB9upSvLxcw8MJFFTn/5kRXAUdBogvetjQ08I+HyFAIqD97m2/RdR122RY9gO12g91ud5YSVyUJnLag0Xpj/ZgMxPM8PDw84B//8R9xfX2Ntm3x/fff4+PHj9hsNoPo37IsTc4Ato8+vvF4bH7oK9bcCrYCUqueykv30VPI0les1oUqRBtY0SIBMFCwqoBsIUzloL5y25LVurLYdKcqc1XEGjdiAwnOHQphWu2q7LWNvN+m7tXiYz/wex5WpGNPAc4+J0ixmSMCv7IssdlsEMexeb9avr7vI0kSc4iVAt+u64wSYHprjQlQGplzVSP1Pc/Der02v3ddN6Cfub9d2Zu6reG92sN5VSPP18jXWwNMrq6ukCUZ6n/yUP+LA2/qwP1LzyhTrt9zSogZ9nQs2O927goWtpF9f263hl5vszpN0+DQ7FFHe0SxjzY7oO1bo+C55VfvLYpikF1RjQKOq85fgknNrUCQp/NA7+f/jAvQGCfKMLp8mERI60sDgudRsI4aS3TOZXEpP69cwMALF1sBx3GM8WiMHsd95TxvHjhPOWv5KUpOS9edThGjcLAtT7uONo197nv+3rbtgCK1rSO+x6Zk1Sqlha6L+V/Tbvs6FZBfuudry5dA1Dkq90vlj62PPRY6bvY8ODdeX3rGuaJj+1PFpof1xy42eDtXOBf4bBsUEehwjpzzE597pj7P/vxc3Tmnyz3PG8if+fQdOOgboG8c9AcA3XC7sD0O9vz/Q+P/r7nmS/fZf/d9j9VmiWAeIkkzNN4em88BxD/1jn+tEv1D1517x0+1T5+njKR+pmzBufE/tw4u5evKBQy8UOFk1ajqJEnw9uodptUNOqfB0+ITPrTvzWSnxcSF4ziOQdq2lUgryKab1XpUEKA+U6Uo7diEJElMIhC6H4BT/veyLHF/f4+mabBcLjGZTHA4HJDnOYDTYT6sq+aFb9sWNzc3xgK4urqC53mGLlba9pww14xmSk3qFjh+3jSNsS4AmNTGPKVR4zfU18x+oIVs++vPKSG+m2wPLVilSdXnrmNoU/PsQzsGwL5Wk62wD5QaZ534Pp0r+sP5qdv/2J/6LEbtx3E8cP0oQFHFyr5ktL7GEgBHSzSKIsxmM2OR+r5vEvOwzePxGFdXV7i9vcVvf/tbU7+u64y7qa5rZFmG7XZrPuc7WTe10Dne3K3A2Bb7WGjOk9VqhUN6wOJbD8k4RhPtsSyezJzXWBLte2W6dMxYZxZbibH/+BwW24XFuaVzluvkcDjg48P7gRygRW6Plw3Ezs1JbQfrwC2oURQZsMaDxtg+9iN3YjD2SfMJsM6u65p1ykyEXEdxHJt0zpw3PBmU/cU2XsrLlAsYeKGiAoBKIkszZOUM4fsJ4PUYf7vHY/gwSFxiCwalVnXB63fnim2lK8WntCwXaN8fD1e5nt0gcTI0zgFPuydsNmsjcHgvlf/Hjx9NJrG+701KWr7fcRyzO8B1Xcznc7x+/Rrj8dicQgbABIGVZWkEOJU1BQKVDJ+vyUtsa6Hvj1sZF+NrJE6Kg7vH0+YBq2ZlrlfKWxWjPkuVnRYKdLVG9FrbiiUtb0djq/vIFvI2iLNjEnQuKCDkPawT5xQz+tnvOlcXe16wpGmKxeQKcZdg71R4yh9NbIi6mexjnx3nGEyYZRmSKEGz7VE3NeC1WC6XAwWlNHPTNFiv12Y8Cdhc1zVR5lpvzWYXx/Egt4b2TZIkAxqbY826q4uMIKHvezThAe2rGpvNBo8PjwPXis5P7UcFt+xzRs6rIlZlrODPjvmwGRcNDGbRmBsFYPZ8U2DN+aT10bnE+cT3UKEnSYLr2TUSZ4RDf5wT+S4fPIt5HXSdaKwB68E684wSdRcAGAC1JEkGfQPAgKCfkouX8q8vFzDwQuUc8oYDdG4D+B16v0frnnyIKpDP0bwULAoEvkSJ8jPgKFRnsxnSKMOhOWC1XhphYSuHyXiKefEawacR+qxB96rHfl8NIqYpIIn09XAQxzmeP85nuq5r8iQEQYDb21ssFgssFguMRiNzGEwYhgPloUJR22dbMaooVQAEQYDpaIar1bfwVjHa6xKHbI9tvh30swpAvk9BhbIPX6Ig+QyOidZbr7HjHc49U99rAzkFb3a/8IexBgom7Ofo/LDrYtPc+r/rupiOZlis38B/yNDOKrRXjfH72oCKu07KshxaeXmI3f/zgB4B4n/nGauddSDQGo/GQOfA9U9WvQa5kv3RPfiaApfHDmvbtE++FO9Bfz3dE0mSmLgXzldm21Tg+lNr1gZ2Og4K6KjcztXXnmfnFLYCwj801ufebwMSravWh58dx2mCef4W/l0GjGv0Nz32h/1gTDkn+Fx7jes6tgExgbtuZ9Y5qkm8yFZ8aa1eyh9XLmDghYq9QElHrqb3aH/RoO1brOtHI+iAE9XL0vcnt4Fa81xMmslQE+jooh2Px7jx3iC9m6FJDwgXIe6ePg2Cd7jofM+HVwdwageoPHj9cAHzmYwZ8H3fJAShX5cWm0Z0k+a7ubkxtO9sNsNyuTQCgIKc7yEtiB7YFbtn9DYVH99BmtAIHceFu/eBxoGz9+Fkw1P/1DpW6v6cgrb7VQGI0vUKmM79f+6ZAAxL4jjOIOhSr1VhrgGEFKYKXmzaGsCAkgVOuyRsy+9LVpXnefBdH+4hgNM4cPc+fDcwSooWmYICZgokQKzrGv22Rlt9ti6rHn4cnL77DBoDP0SwTtG/D+BdAe4vDoOIeWVjuGYcxzGglVteOb7KijA4UYMN2QYNRCN4SdPUsAjb7dbk0dCASLbbDuTT/5MkOQYtth3Kqhyc3Mfx5P3qJjg3/vq/HeDHsVY3E7/PsgxRGGF/2JtDfezdNzZYUetemQXg83klrgv34B9lxt6Di+FJlAq8lG1in9suMAV2uiVX5R7HneNDVod5KmazmdmmfCk/v1zAwAsV9VcCx0VVliXumjvkaW6oW03CoterYNaFYEdwq/AFhkgfAMIgRLKZwn2KEZYhws/R3XoPt/DsyhzFbIXEH6MO99i1WwM2+G4qX6ZpZTri8XiM6XSKx8dHhGGI6+trfPPNN9hsNia7XBRFmE6nhqbNsgxPT0/4p3/6J/zwww8mMjsMQ9wsbhHlIwA9ksUadw+fBjsTWH/1o/L/vu+xbyoU148I0wz7UY4Wx/oSfNmWiFrXKhQ1ja9awBRwWg8KS98/HTvMd+lpf2oZxXGMm/ktZt0xQdQyvMNde/fsvSwaF6DjrcJf6WS2T6+3gZX2H5+h1hxL1ZQoFkvE0RiHtMC22Jh02QpAdU4zNXaapoiiCGkGRL8JjyzZpELkhPB930SRp2mKyI+AfwnQfHSAnYPoFxHKujTpgFXREvwwIx4pfp6WCcDkOwjD0KRLBjC4PooibLdbVFWFw+GA2Wz27PyCqqqw2+1MjAHbbSstW4ElSYKb6Stk1QxdWGMTP+Hu/s48V89L4BidW8/ndsWciy1h3+i8Ho1GuJ0c63BIKzzGn/D4+DgANDrmnN+MsdE2EvyVZYkiLrCbPSH2xqjjEvlhY/IBqAyzgz9tMEUWp6oqwyQxuJoMox413fc9Xl+9RfOxR+d36Gc1PNcDHnw0gQPcOnj/8cfLOQVfUS5g4IWK+nXVMlQAcI6CU6VLpQOc9vnqnmz9XBXkQAk1NQ7ZDvE4QJvucXD2A9SuluDm8yl5k/EUbdtgtVwN3sdFzHtXq5U5B2C/3yPPc9ze3mK/3+Px8dEcT8q84b/5zW9MwGFRFPj06RN+97vf4fvvvzfCnCxDkCeIf78AnB7duw5xfMpbb/u3tX+pyB6fHrEfHeCHPkbRCEmTIZpkqPocj8tHE7Smfl59jh2LYBcV2LQieT/9qQrs6C7hmLHucRxj2l8he38D9ADeAXl6PPqZ79Ex4hZM1lfpbm49pWLhePFvTeOsQaT8X/tBFQu/X66WOKQHhEmIqqqQ7/KBQlS6mf3AADzOzQIl/OnnbXObk1XPYLC6rnFoDwjmDbwygLvoUBwKo2A0XbEyZNvt1pxTwORACoA04JDb6OjqIhiga4G5EVh3gsLHx0ezc0apd2VitIThsZ/SJMVsd4vgwxhIWnTvWjx6j4bVsGNXlBHk/FRgxney7pqxk/NLQZ/rupiMJhhvbhDejRAlDZp3B6y81bO0zFoPBbBkbvh+AoT1eo2mbhBHxxiN1XoF13UHrkjdCsqia4CAAzhtxeR9+/0ecRwbA4RxHYv5FZofHOz+aw83dDH7TyPUTx3y/71B0i2weFVglS4HZ6Vcyh9XLmDghYqiYNsXp/5+OwjMDhhTy862ThXJ6yJS9L3dbvF49QnpNznq/oCnzVGg0ddmL1bNFaD1U4pOfaq2RXl/f2/ez8NhGDy0Xq+NwmqaBnd3d/j48aPJgWAHBDkO0MOB4zpA+zwznl1H9hNwvHa9PoKVaTLD7P4buHsfxe0TDuPDs+Avto3PsqlOvtemknVMtA763Zf8r6fPhJZ1hi4FBSgq8JVeVdpc4xw4JloPfqa/d11norwBDBQ732tbsbbrQ+erugtI4dKdFEURqqY2z2PQH4DTXHF6dK9KBDcdEPY4HPZGeWv/UYHRskzT9BikKAGCwCnVNRUKlRyVps5h3kdFHYYhHh4eTNv1HA72mYIBdUeY+eSS1j/iva4/uXf4o1sZdY6zD20/u77LDjzW+ar99bkWgLAWfJ49nnyubVzonGBfrdarARi2++JLdWP96HK0+w+AAQrqHjhe06P/nIe9B9Ch+9zPn9fSy+0s/v/bcgEDL1RsHx+tnyiKTIYvAF9cMLaFoM8Fnh9Rq4yClrZt8fB4D+De0Gss6ivnexWs2ItTqT2CARv05PkxkljRPABzStx4PDaCLv98xjsVK+tXliVW4wd4v/IAB8cMipvirMBi/W2qmnUPggBBF8HdhcDBRVDF8OMTHcvgpHNCSoWbfqfK377WHkObWVDF3ffHvPqb9AH4tgN6ByvcG4uVp+MxYFMD1lh3Vbz6Y7sDuq4bHALDYt8PwARpqR/Z9k3bsQm8TpkqtpeAgD5eu9/VwiddvCt38LwKbnfK7U9wyXvCMDRuEzujJbdnsn5kHUgz8xr+sL0sVDphGJr1ynrYwM5ei5zf/LwoCqxmnzD+VX1MH35YDtxA9vyxGQbtIwX7er09/ip7+r7HdrdFPL1DGldowgOW5eNACduWuw0k7MA+u74KBAmkzrGP5xgUe8u0vseOvTLzqT4gettilHjogw51UCG8DTH/v0f44cc73K0/mJMkL+XnlQsYeOFCZD2fz3E7eY2sn6Cc5njY3ZksWqo0bCWiC8AWwHq9vajVQlQBZrsneC2LHQSlAkgFEYUd66DR3BT+FDakDD98+GB8w3Vd48OHD8Y1QeuI3z21jziMjpQwtxzayo6+c22Txl70/ZHqLLBFdL2BfwhRjtY4lAdj3Z+zitgGWn42CKDS0H5Ttod9p9acjpkKuP1+jw93H7BOj3Qm91lPp1Ncj24RNxmKJMeD+8kwKLYyZ7uVFWF/KThUqpfFZq6UVVKrVPtUMyTagEddEQQ0+hwqQfqBNb8Ex5738Xe+fz6fm3aS9ud7eJww/c1U+ACQ57npO7oSCCQiJ4a7DuCkgBfVqLrK5FLY7XYmoNO2/tkP2i86N1joQvvw8B6r5Bgwyy1yOk8434ATKNE1pyyEjqOyTva6VkBwzOXxI5LkCU3VmHNCuFY5Zrp+XNcdnBBpK2plRbh2dS5qPdQFYYMn3RGgLkCmKacc4Y/jHANtgyBAcpugPhywL/Zo4xbhtMWn3/2IT3cfL2mJv7JcwMALFRWyYRhiNp5hvnwLb5kgmk/QLI4LUq0vYEjhAs9zCXyJ3rMXqo3gVTBQgaogOmeNuK6LyWSKeTZH0zVY71bmDHillFVZ6L52MgNU2r7vY7k8WkVMKVqWpVEIqswOhwOWy+WzumsbtT3s58l4gjQYoUWD1XaJ7XaLT48fUU4K+LGPfLtDVZ0C0bTutkBVipRjw3uUujw39vbzdazUGgeOSpoxAuzTSTLF7PE1vGWMaDrGflEadoD9rLElHC9VJDquqvD5t0bi23Pw3NzRvrcBpLZNQZOCCyaxiqLIBBTyXAlalARonFeca77vYzKZmGd4nmeOKw79EAEihFmAHh2a9nQWBQDjEiKb1fenXQv9P4Qo/tmBPwOifx+g6wozf/M8N2CV7bH7Ra1X7Ud12bEOdLFo0OpP9bMCDy06rhrDw+s1uFWNC84fgglbfuic4fN1t8E5luvcOrKNFl3buh74XNvNwXdxTigrooZJEITw2gC+A9TuKVfJer2+AIEXKBcw8EJFrcAjog2AzkXfO8f9087psBh7UXHB2cJcFR/wHDjYQloVg15DWtVWVnYZj8e4cl5h8sMNurCBd+ObBEE23cyFTx8utwZxvzkXNhODsN0U+Goxuq472C9MxWdb6OrCcBwHaZph0b1C+n6BNqnRT3vsdjsTIU6lpCwC631u/JqmMTkUWEfepzQ8Bbzd3zaToWOkbVP2gIrKwXGeoHfgdEdnsx0vQEVO/7tuUeNcYXv1PbxX4x5UmTMuhG2x3RH6LH5vW8ScZ7TgSdFzLjDTJZW+biXTvmGGOeazYDwLFfs4G8P5FGP3jw3w2kX8Zw72h70BlOxvnk3gOI4Bn77noe5doO/RtwC603HIu93OzB3OdVUwfL9N9yvlrT533fqr60X7UOeBfq67R2xgrGCAn+t42kBC55m+Q7er2nOx74fBhF8C5+qus6/RREjqQtAdQew3zkP2pcoJXhPHMbxNhN3fO3CiANFvEmya1eDgq0v5unIBAy9UNHXu4XDAcvOE8CpBnI1wSAqsy9XgMBh1AwCnRaRRxfYC0xgBpSy5sFVRUdDSQqeQYV1ZVDClcYq0nMDZBPB8H9HVMTMYt5NRWPN+++ARfkdlYfvw1HIAhvu17ShpXmsDG+AEFpIwQbQawd2GcPY+klk2iLmgkrN9lArEVHgre2ILT+1bFtuKUoHHazUISseRApFjVzYFdtePCLIE+2iHvNgOgvc0qp5FFYPtpz1nKdkpiu32sM8Yb8C0swzIs+tuW5l8h70jpixLPD4+Yjqdmu2efD6VhipZfuf7PqbTKbbbLdbrNWazGVx4qD70ONx36GvA+bbFttgiz3OMx2O4rovFYmHcBAMA6ALpb1x4ow7IOhzcCkVRYLlcmt0mWthW0tWcP+fcL2y3rjtdZ2opqwsFGMoOtZJ1zitI47xWJlJTPHOcNSW07ZpQxatAh9fbxoK2h9a9AgEbOCiA5Byn0ibzY4N8xnfQRUI3pOM48FwPzQNQ3/dwfAej32RIXkW4u7s7a9hcyh9fLmDghYouYt/3zX77wA/QrBqT+ET3B9vBWbqFiQrdpuNU6XNxqeI8R+vpAlXB4LrHVK203PMix3S0hTsL0AU1SicfBAfZFg1ZENvSs6lj2xJh3RngRlpXAY5u1eOWIwURbdtiu9sgSVaYzAK0yQFFfwpOtPtAhaiCDWVddHtn3/cD5cn6aXIbPp99oS6Yc0qD79M+5XPvH+6xS3eIohh1fsBut3tGR3fdaX+27UfmNQrUdMzZx1oXtlutf/b9fDbHJJjD6z3k/RqPq0cDZnUngvYB28I+UzbpcDjgd7/7nYkD4FHE6hdnYS4AUu1BEGCxWBz7tKuRfhej2Tfwrjsc+r1hAthHy+VyMLZRFBlruw1a1Dc18l2Ox98/YrPZGCqd80PdQ7olk6CMwIBzhm0h6OO1TKvLPiuKwtxjR+NrXyrbw7HinLfdCLxe4w8UWKlCtueSjrsCey0KjO05pHLElkUKcPj9l9hObSfPcSBAZ2Doar3C9TxG8DqEE3YonQoou8Ecu5SvKxcw8EJFrU8ujO12O0DP/F0VkU3haaEA4KLVRQRgoJTsBcfn6YJUhZgkCcajCaIwQrk/ntW+2+3wGH9CcbtF27fYft52qPVVq4VsAH+3A6G0fXw3iwowtlV/Z53ZtyrYWLb5Fs7kPfa3O9TtAavVagAG+Aytjx2foVs5VTgrqOFnqpxHoxGyJEPX9djka2OJ2m3g2GhRUMNS1zVWq5VR5loX7Sc9glnrqvNJ36Gf2aDRBkW8LggCzOMrTN+/gbP3ELyOUaXVs61+5+7VetnzUXee8BAaBcYKXLk1UQ++OgYB7uAuHIz/bwH2zQGHujGHKrHNpPoJNAgESCkz74CCAPWd65xQ0G4DY76XwH08Hpt5zWBHVdZpmg584hqbwL7lOuV6p1K0g1ht5cpiyxh9ll5nuxt/iomzv7ffqcACwGAN2nEtWi+b+dT2U/axX7quw+F1geDf1nBcF43TojtcziR4yXIBAy9Uzvn+1WKzBaZNSVIIqUC06XKNGbDBhX527nOlJ5nxb5G/hr+MUS5WwAxYrVZYrVa4r+8HysRWiKrklFY8Z+nwcztxiw0qVNmq5aICw1ZqwFHw5NXWZIw7J2TsOpMRIQVeluUz14DdDq1DHMe4SV5j+vQKndcinn3AD4ffm9P0PM9HXR8GAMH3fYxGI7iuOzhL3mYOVGBqP9jzzPYb23PQnme83vO8QTAfla49Dl7nw9l7QO3Cq304wTBo0HZLnJt/WifHcUyQHhU1s1q6rossywaUtrqMFBAz6p/n3PNzu09oIRMAcH7wf1VKWsdzYJpKjkCG39OVwfk1Ho/NSZlJkgxAJQGCghSNkyGTyO90Vw7bZoNTjhXfoeNsz2MFt1wDtgxSAG4raN7/JUreBhLKDtrr2JZPtozR8QdO7NZ6vR7kO+HYXZiBlykXMPBChYqfp/optad0v+3zpaXBhCrMeAYMLRN1MfA5fL6+HzgfMKRbwDzPQ+JkCJcjoPAQ+WNEi+hZ8BItHn2mLZD0f9aBi9lxHCO0mUucC9s+XvVLvmtaRjZ4AIAsy3A7fYWkmKJND7jz3+Pu/s7UxWZTKISmkymuoltEVYr9ZIePznssl8tnp93pGDJTXdd18D0fSTWGu4zheR3iLMMoG8FxHVyHrxFUCYrpGg/+J2w2GziOg/lsgRv/Nfw6Qn61xN3q45HZOAOElDmw546tbFUI63gofapzYzwa43b0BulhjP20wF34AcvVcgBcD4cDNt0KwesYXhMgT5fYLfPBvLXHgvXQ+WmDNl5DAEalSaDE/nddF2maGmpdKXyule12Owh2UwDF+cZtm0xgZAfMsV4/tXb4TroCZrPZQMFpjIweRa3+bj6fhyKxZFlm5jfzcugZAgQO6ho8xzKdc9nY7IDez3WoQN6+ThU7/2YwqBounK/ah7qLQ9k3G+xrnVkPuiJUNjA3xGazMewLx5JbWS/l68sFDLxQ4SJhEhQAAwGl1/AzgoEsy3A1vUbYxSj7HR5W98Y3SX++LUi4INVXSGFkW4i0nnQBHlChmZbwvBj1qMShPpjFrQBABSgVuE1zqyBVnzrjAfb7Peq6RpIkRnjR+mHf6KLWVMVUxhrgx2ekcYrR6hrhxxH6uMX8lweso/XgEB3bPdC2LUbhGNP7V3A2IaL5CPl8a/ZhK4VJ5WQrubZrcUhLRJM9Wq9D5e3QHTpcZTeY/vga7i5AuEhQT48n3gVBgHm0wOiHGziVD/fWQzUuUO1PORjsOATbYmVRxaDKBxiCN20Lx9X3fYzTCWbLV/CeYkTjMcrbHXbFbrAXvus6LDdP2CcV3NBFmVcmupxFXRc6p3U7HdksZUeA02mABAaOc8xLf319bepLH3zf98YCZ18VRYEoilAUBarqdMomGZ7D4WD89ZpB0PYvs566NmzXVRRFmEwmJtV2lmUmzoD3cKyqqjLgoa5rrNdrA164PrlLgtsk+7438SFkbJiojGuRfnSuIeAUbHfOMrZZDlW+XNO8zlbkyiCqwmc99Fr7fbyf60RBqQIRnWu8lj+6lVbBeFEUZj1q8igGuV7K15cLGPgfUOzFadN2WjzPwySbYLF5C38VI5sWaCctHpb3z2j0c8/+UrGpOF3ETdPgafuIftojmIXYNTl2690zq8AWnOfe8YfazutspXbumnPUs/5+7v/e7QCvB7weff88R4P93r4/pjXtvR6O+/l+nN+O9aVSFAUeo08or3fo0WG5ezpSvuMOvdcBLtB7PTqtp9MDLgC3R+d26Prnfna7P77UXz/Vnxx327Iz7UKP3pUfnOqo1zH5C7+zKWV9F6/5qf9ZbOVF37fuhyeosONOSPfTd8/fNTZAGSz9355PymjYVLa2T9kYra8dyKfF7i8b1J2jt/WZar2rwv4piv4lit0n2p4/VPQaO/jRZivO1fvcOrWvscfzwgi8bLmAgRcqpLLtrT3A0BfHv5U+8zwf3i6CU/rwgxhuckLFaqWrwrQjjmmNaDCWWgGa191xjglJ7ps7Y2Hpdfai4zM12p9WHwUYrVsVyBRgzADHdtgUPq/TU8tsd4QGJVEI5EWOzewekV+iDxssy0cT8c+2q3+Uz9wdcqyvPyGcxKjCHfJtPvBxspDqVeHDtj4tn7ByV0ZxBUGAZf4Ed+EjHMeoswqbp7UZq1X1BP9NALf2sfGWWK2WA4pa26vbtjQfA+cZ68TtmKpklLXhmKjiysstdrePGN/MsPd22D5tBtvSWBc7IFaBKevHsVAmg/foOKnbyWYOuP3U933keT7wwbuuO5g3ekYA5w3rSvYJOLJM2+12wAh9KWWu7lQhNa+urNlsZo41bpoGHz58wHw+N2mLORYadEj3BNmMoiiwWCzMmuE8Z6pusjZsZ9d1ZqcFXR6MrCejwtL3PZIkGWyNPMcUsCgToCmcKV8oO2zXA5+tY8C5Yrv0yMqwf+3AU52PdMEQ/Ng5HvQ9ygrqtRdQ8DLlAgZeqHBRXk9vMO7naN0GT/U9npaPJvmOAgIugqZpsK8rVNdrBGGCKtuiaouBMOZCjON44NdT4av0sOd5xsd9OBwMtch66mInfamUvVpktlKmYrKFCIWX7Qax8ybwhzSr0qqaylYtA7ZF/27b9nhEND4hDJZAdbTYbUtPt0yxLav1CtW+QhCEqIvDIIhO+0m3RbJfKEh1nzafvVqtUMUV4ihG/iE3wqtpGjw8PqAaHWnkclMOIun1DAHb8qRisq0/Kh0Fb+xHFlUwvOf49/GgFz6fPwp42E47R4VarAAGipQAT1PpasyLHUcAnLZAKgDUfmDGQlUgpP65pqiMbNcFARHboX2gc5rriuCDbZ5Op7i9uoVXRHBbD/7VKd0w3Xc63wk47H7i+OhOBMdxTEIlugG4bmezmTkymO4Dgp6yLM3R35pe+xxboSzRubmghobew/uUjVDgz2fynQpQCXi00M3D9+r7OH/ZR0EQmDmlIFm3QGo96SK6lK8vFzDwgiVNMiwObxB/nAFRi/5tiyotcTgcBsJRF5zneVhv1ujHPcJ5iLIqsd6sjbADngdp8Xf6yxzHwWQyMX9TqNCyoP8VOC7q7XZr0Dv9sFTOuqiBYYS6Ci3geeIjVSi2lW37GlWxUvgTDOg7+AwV9AqqGJNgWxtsmw0OeB1TmSoVzDaxn/lOtcy1TvaYMACKVpoKahX+FOJ8Fq00fmdvbdN3qhBW4azgknWx3Uye52GcjjF6uIL3mCCZxBjfbk0+/nP9q+mCtc0sXzpYS+e4TYHbCl8tPz2fQBWpjq9tYarlaveR9p1dT37PsaZfnNsCx+MxgjLF4f8KgR7w/7pHGJ8S/HB3AxWlHVehuyY4nloPBhA6jmNkBF0lBOk2i3HcreKZ5+phTKrodQ3rHFRwwPqrgaD5Pez1qp9r33EceK/9bu4YYWEcgF1XAgnKK2VpdHuxglP28aV8fbmAgRcqRkC37tEF3TlwHHcgtDUYjQKPCuTx6fGZ4uJzuSBocXGBMajJdV1MJhOzdY33kBngliYuIt7P95Fi1f3YNr2sAvhLbQJOSWdsYazCW60kZSls5kTpR2UjVADZgl6/O2dR8xr9nX+zb22gou/UgCj7fo4TAyDZn/o+m31hGylIlRY9d58qOp1Dk8kEaZKiKAtznoQKcF7nuh6czoHTA33nwsXzgDB9H38PwxCjbGTm667YGYChdC37RgPA+P5zc8IGnfw/TVMkSYqua81Jlyz6TAUDNhg8N0++NA8IprhrgH87jQN0PdA76D+Hl+jzqNiUhdAfBdu6Q4BtpKLTucD1wMOVlO1RS1oDdPV+9i/7U2MWGBAZhRGqfYX1ev1sjHR+2uuIfXuuj1nfMAyRJim6vsNut3u2I0n7T3ddcL3RfWG7wJTdULBwAQMvUy5g4IWK53k41Htsxg8Yf9ui9Rrk7cbQnOcEEhWxKlhNOkOlQho/iiLznMlkgslkgizLTDrSJEmM8KFwYhAYF6rrupjP51itVnAcxwAI3eq32+3Mka+0eLgnmtd5njfINa97p7m46b/nwlWlqwqXC5+LP0mSQbQ2gYC9hQw4CWNSu2QneJ9GTrNfVbjp3wQpSu+y2HEfdvT/OeCghZYcFagKXmUjoihCGIRou3aQJ1/rzL3unFuz6Qw30RtE2xHqrMRj8BEPjw9GKVNx1HWNvNwiWdwjScfYRwW21WbgSuG16iboug6T0QQ3eAu/ClGON/jYvzdJhBQksX3a5wowWfgd300wxDl5nb5Ctp2hiQ6I5ne4f7wf9Df/Z31tBa2siE2f8xrOZ70uiiIkSWLmbzs+IP5LF67jwb3qUG9OljjnhEb7c31wLrFeRVEYup99sd1uTV1UYeqacl3XnKrINahxSepG6rpukEOBQELH8tXNa8wPr+CVAfLRozl7RJWx9uU5NoDzn/dwpxP7bhLNkKyn6P0eo+sVmv50nDRBEcebuR90hxFlBQ0aArMkSYxbgOMXxzEu5WXKBQy8UOm67nMw1B3WwRJ925uFySAo4ERrKa1mB+YR5UdRZGjLJEkwn8/N9rw0TQfCb71eY7PZDJRsGIa4urpCkiS4v783z+q6DqPRCI5zPGqZgIF14dYnBv7xSFjXdVFVldkeNUrG8IoICI/ni282GyPESJ9qHIDmYucin8/niOMY2+0Wk8kEwNEPHcexuXez2SDPc2Mhkm4HMEgqA5wSIQEwQkf7l0WFHeuneQZYCA7OnUdPRUIwo750ZVco7NWS5zPop2Zdr+c3SLoReqfDJl3i/vF+IJyvFldYRDdw4aFwN1htVhhlI4zvruEuI0TjFOVtjjDcDA6HojBfr49bL5M4QVM0JpiN9aFw5/vatj3OveQK2T9fAwcXPkIUo/zZqYq03JQ+t8dBGRfbbcY6jtIRstUcwacMftwh+2WFB+dhEMOhyp7WobJdbA8BNwG17WOnhc4APaY1dhwHWZZhfyjh3TiA56H4fAAWFRcPQ1LFNB6PUVUVttvtYE4WRTFgHHRMbbap7/tBXg51FwRBcKzX57gFz/Mwn8/x6dMnA8R1ndGKZjvHmCL6cQqncTH+1sE2WZs5YG85tNk2BQN6xLDrHpNGmYDLxwXqf/HhhQ5e/S8Z2mk1ACncKcLfCeg0F0RVVc/OPuH3uiZt0H0pP79cwMALlq7rTGQ+F5AKQLU++ZlaYUq9EW1nWYbpdIrxeGyUVdu2hhqk0gZgEtxQiXOxqTBk4B39leqP5WIlCqew4+f7/R6ed8xgl6Yp+h8DFH/vwB/7yP7DGFV4EpYELKqox+OxcWscDofPVPDJCmOkeZZlpi88z8PV1RVubm4+n9F+tJB2ux3yPEdRFOasc7UIOR62YuAz+U7tcwoiVU6qtOzzACh07eA0+3+lWJlzX+vEcYjjBLPmBsmHOXq/g/PGwS7dGUEaxzEW4Q0mP76G07nw3vioogp1U6MNazhBgDZs0Dmn3QBaBwrPoihMsCW/U9Bgg566rrFv9+iiBm4foAsb1G09AFm2cuPn9vPs+a/plQ2D0TTowgZ90KEPWrRO82wsbNDGPmRRBcu1YM8Dfpckidn3z8OT+r7Hw8MDsiwzOx7IfFHpUjEBR3ZHT2uk0udapfIi48Z1yXlhM2dJkph1TdDF/s7z/NlcZ7wQ28YdFs4GohgAAQAASURBVBo3U1UVmlGNPmoBB6idCo3FqthAVd2OOo5pmiKOY5MXgfcFQQBEPdwIcKMejXNAsdsZAEDwxOexjeyzJElQlqXJtaDbWwn61D10CSB8uXIBAy9UbGRPRU6lQYHOYiNvVT5qtfi+b4QUcFJw6ifjtWqlqXKs63pwNK8G5ti0O+tD9K2+VD0n3vM8HAqgK4HWBdzWe4bSbUubbWHb4zg219jbztiPAAaJnChQaUkoJW23Q5/xpTGzx81mDHRs1W3BsTj3LrtPlZE4R1mzeK4Lr/Hh7F2gdeD1J1BGJeh1AZzKB3rArX10boddsUM4/YBklOHglVhuHgdgCziyLZvNZtC2c2PPz7Weh8MBq+IJwZsAaTBCl9To7p8rZW2/3W67T+3vWLquQ77bIp4/IP6uROvVWBVPZ/3CX+pvbYdNb9uFCk93VdBFtd/vkWXZs9gEpal1bnB9fSnO5Uvzx+4L212l5xmo5a99SiCgFrw9NofDAU/VA5xvXXitj03/NMgseW68bDDH3yljwjA0VL3x8892iP5DBng99n6BfXFKvX1O7rFP6Gog8KFsIJhjbJOOswZOXsrXlQsYeKHCwC8KrfF4jNvkDZLDGFWS4zG+w9PyyShXpbNVkXHiu+4xmvnNmzfmgJO6rs17CC7KssTDwwOapsFkMnlmHZVlabb98XAW4LQToCgKk+KTFoz68ggIPM8zz6JQyv5NDD/o4aQdCmdj7mF/UFjo0ahqNe33+wGTQoVflqVpM/dYl2VpfO5xHB+3cV5fY7vd4sOHDyYbnR14p+wA62ULYbIXSiOrENcYB30un6FpXZWWNQr8M4XOfgXOR7Yf6gPW2QOmbx10fot9UGASTpGVM/Ruj230hMrJEX4Tw+1d7NIlylWJoijwof7RBIru9/uji2h2jXl3A3QuNpMHE3Cm9WdRhoR/U5kdDgcsl8eUxeEsQnSf4TZ4C//ax8dPHwf32Va+7hjQ/qNCUQXJ/t7tjhkRqRgYA6P3cq2ociQwtLexEkByLmv/d11nmCWuB74rSRLkeW7er/EzfAcZPGUtGA3POTWZTJDn+YAeZ/+ynxSMMLCQFLqC/L7vB6cmco3SpUj3DNdxURQDF9V6vTYguizLZ6cV2uPPuvKgJb57PB4P0q6T7ajrGq3fYu/sgRbom34AXtjv6urj2gBgcnYEQXB0G3YOvGWMZt9iN16a2AyO86W8XLmAgRcuXLSjdIzxwy28VQx/muDwao9tvh0k5SFSZtFAwjiOjb+fNDS3gFEgqIVCwWQrLf5OgcJ873mem88p2LgomctdLQAqa15T1zUaZwN8exSoVVENfOZqNVIZUkgx4JHCg5aQ1qOqKhM0ycNpKMwJGhjE2LYtHh8fB5Y9hagdRGhTorbwo1Dn8/ks+3790S2IFJ62X1tBis3+8LqiKNA0H7BJVkAPhHWIq/YN4u8Xx/u+6/DkfkIZ/h6O42C73pq0teqjJ2CaYIHk+yugc4B3PTbJ+hlQIdix2ajpdIppMofTudgclliulkiiBNGnMfz7DF6WoP5mj8fgcfBetYa16LykArQtV+2/vu8HeSO0f3kt55vuArHHS9elKmwqXvuEQQADBozuAFU8trXPvxnHQyC83W7N/epC0Rgd4BQjw34iqNO5pO423QbK+9kfs9lswBTac5MMgc57+3u2nc8ko3d9fT1g9pQlUeBHAKnP1GyRatQ0TWPWup2rJAxDBLsU5d85cBpg8j+5OMz2eHx8NAD9wgy8XLmAgRcqzyl/fE5N2x//x/OTubRQyXH/bxzHAyRO+pLW73g8NgKJCpMLlwJZaThGOvM7+8hUWjiu6w6OgKXiJ1rn82ixcTEqnUeFospdFU0QBAPLgMqBAoRRw6PRyCQhoWAjOFEGhvQh60JFowFc+i6brqXQ06KWmCpyFZhKT6viObcjQQGITefqdVVVmb6ZTWdA3MPxPicNdo+CnD5j2zKyqXK4PeD3QPf593aYYletf527QRBgkd5g8ukbOAcP8W2GftoDDtC7vZnTHYbUuPaxDbi0/1h3BWNaBxuk8BqlzXW92W4Ae9eCKqW+748Bl6MJfM9D3dWDNaP9Z+feYHs0k6eOLd/HeaquBdaTz+N15wqVJgADVjRIlVS5gmwqabISGs+i/ci2aOAj20UZo+3ges2yzBwm5TiOYeoIuLVdHDvtG/YFdzgpS6OgQncMOY6D2HfhBkDvAGESIvaPgcVkTWwm8FJ+frmAgRcquuD7vkde5Iiv7hCNU1T+DqvdchAwpPdxwTPtKYEBDybRwBlF+kpLUvgwuImKWyNv27Y1Sp3Wjyoz5i7gYiVDoMKbypbCQwUeo5J1PzAtHgosFTh8F/uFlCUD3egiYBtIhVJZKBiaTCZGOKlFqSCFfUDQwOeqxWiDKH7HyGyOsW0pahY2nQ/KANnBWexLO/sj67Erdlinj+jeHRXl1lmaIEqyKVSituujKAqsRo/AO8DtXeTeGrvVzrxT26YAxSiZNoRbBkDjwjvEcHwHm+0G0eQOSTJC7e+x2a8GgW/qQ1eBzvpxHvP9NhigxahZK1kvVersZ1VcpMj5tw0Q2LYgCHA1uUb2dAUHLpx3exy8yrBUTNIFnM5n0HWk46h5JAhA9FAlAGbe7na7Z/OKLE2WZQOmYblcmudGUQTHOfnLuU7VfUe/vcoErjN754IyFMbH7wzdFhwPBh2HYYjpdGqCEikPWCetI/tYY5vatkWWZWabMde0LbvY/5wrfd8jXWRI/ucA6Bz0kxZBHuDm+gb7w95sj76AgZcpFzDwQkUtlaZp8PT0hKqqEMexST/L73m97cPsus5EBVNhbzYbjEYjE71LRcAUuq7rYrvdwnVdc1Y8gxe56ChYGIjXtu1ASWtKWMdxcHt7a7bzqZ9Ut25xsfPdpP4pDACYNvDaqqqQJAmm0ynCMMRutxssfN5X1zUmk4kR8MwBX5alYQ8oyFarFcbjsdnuGIYhNpvNQHGTNeH2Ns32Z1ut/F+VJgU9A/mUZgUwELg2Ra39RcGo/nEqSPV3q4B+/+lHjEbrIzisTuyHTfOSWdE8Fcv1E6rk6Eag71sZGs4l+t45n9q2ReluEdys4dY+inSJclMav3ccx+ir43iqH1zbbIPXvj9t8VOGiSBGQYS9FVQZH2UvlOWxLUTWi+/jWhuNRkgOY/Q/HANyw6kH7/XwdEd1D5CdcpzTzhyOVZZlhkWjgmagLY9oZttGo5FpB9vIsSMI4txhvAz/3m635l72J7cbM0hZT25ksDC3kbru8Ghyfb/md6CBwHnF+IU4jo2L0gZmvn88fpoAnKwmwQ/lDNkK3s93kdVk/+vphMf5+GTWtu/7ePP6LdolUG4qxFcpNuUKj4+PuJSvLxcw8EJF/b8U9lRe6jdURE/BS2GlloBa29xKp5YnFyiVKZWcHUTFIEIWCk21og6HgxEWtDKm0+ngmFgqmiRJzBG0KhxsYazWjNLyrNd8Pjf1Y110PzRjJShYlRFh0GHfH4PIqqpCEAQYjUaoqlNWNdZJLTgNINS+okJWfzC/d10X08kUaZChd3psivUgs5pml1NfvPpf1WoGnmdMZNHtYXpdHCQYhWOM0hHW2/Ug5THvJ5PCcW6axhzYY7MTeq++r22PB+l8fPiA3WgHN3ZRbHdmex1dNkpjq3WsbdYx5Y9N4SsLcM5VYzMeNuWvc1jvV1DENUJL109cYAI4AJC2cD13kCNBmTKCZ2Wz7EydXHdd15ngR/WL264PDajVNhJMqB9e5yIBkOZMaJrGMIoAjEuBMkZdbAq2VDGz8B6Crfl8bnYx2c/R+CCuUY6HHiFNmcJ36rpgUfmgbB37hGzfYrFA2MZ4+N9KNIWP6a+vcYj2uJSXKRcw8EJFF7Yufv5+zic6oGU/03Fc1BQ0jJ5VKwjAIPJdKVlVNqTyaLnQjaB7llknLkJa96PRyGxLUyGhQpnWJYCB4lXrinWxf2c9qED1+QQrWk/tP4IbsiF932M8Hg8sGe5E0Pv6/niYFC02ukHs4vs+siwzmRCDIMS8vUH6cYE+bOHfvDeU6bl5wHbqvGB9dT7YjASv0RKGIRbjKyzWb+FuI9S3W7RZO7Ac7XnFYvuE9V02Va+7YQggKeBtkKd/28BF36cuJZ2rjEwPgxB1U2O73T57Jt0n2jZ9h+1vP8fI6A+BbBAE6NIa0b/fo+86HNwDDvnBgCU9NIprhgxVURSDQ72o3HQdcz5p3Qn8Off1M/aVXsO5r9S+Xm8zJkmSDNyABFb09ROAqFtIlfm5OcQcAgRDGlOhc5j19TxvkD9DE3+xcG5pUiu7DzVBm6bmNn3i9OibHn3rIPBCjMcjA/wu5evKBQy8cFHFbNPBFGJqJXFhMnkQJz9/1OpUAUlkz8Vo06YU7LToibAVnRMc0K/ZdafMX6Tc0zQ9a9W4rmu2fnHx6/t5DSloCkEK093nRCR2JDvbRiqe71GhoUFL6/XaCHLWOY7jwbYsVXjX02tkmwWczkU+ecKn7sMzxTwejfEqe4tkM0GT7tFPawQfMrhbH33gIbqJDfDhPayD9q22yVZOLGqp69+8J4oiBE4EbxPDKVz42wT+4rQVS/tchaxtOXNe2codGKaWVTDLerFNdhtUualbRUEPf+gvdt3jaYDX7huEeYoq28IZf8BytXzGnJx735cYFu1rVZpcX9yOSit1366M9U73Bd1gegQv2RbXdc2ZD8oo2e4kBVa6jdY2COjCY325o4Fr1g6wVIaDa5FzjImQmPhI59Z4PEbTNMbFw8/VfaMKnv8zBkH7WueJzvW2bRFFkQHfruuaExc1foJyQd0nGvzI3ynnNLVz3/fY7XZIFikmfxOgLlp41x3GzngAIC7l55cLGHihYgeUUbDaGQhtBcG/qZBJHyZJgqenp0EmwclkYu7dbDYDa06VMMGBHWjFutze3prtOfysaRrj1siyDHVdYzweYzweGx88LUX6zuu6xnw+N+6M9XptzkpQAEOWgX/TatcEInoePQADUtI0xXg8RlEUJjiL7gDukyZgIeNAloPBhhScURQhOUwQfZgArYPEaxCGj0YZkAaN4xjp0xz+fQI/TVCmj2inJdzSQx93OHjVwL2hApjjSkGm7iEqAMZiMFiO7SVYVNdK3/eox3s01zt42wj7aY59fRhYXraw5n1qhWoQKXCi0TkvlYFRJaDxFbye4I7FVgw2k8Dnso5xkCD5MIe7CeHPQhTXOZZYDvqQc5IgWneG0H1EZUrr/Zy7hYpKAwAVQA0Awmem6ObmBm3bYrVaAYCZ92maGrDMoq4hurOonFXZs48IplkfrnUmN2IQLtcLcHLFqCIlWPZ9H8vl0swvsmlkQkajEcqy/Lxt9flpmawf7ycIILOnO3WYY0TdOmThOAYaa8H+odHR970JluS6150XdL/oLgYaAb7vI8/zo9E0jtCPeuzr2sRGXcrXl0svvlA5R5+eswT1c0XkXJAUNOobVKpNfXpqoWigoFJ4FCgapEOBxr/VcqfApGItimLgJ+Z3dowAKVber3X0fR9hEKID0Lkt9s0p8Y5asuqPZDuVFqaw4P/af6oYOB4EAvy8bVt0SYM+6YDGQeMf0B6GJ+51XYe2a9FGNbwoQhvX2O23qPoKzvwOcIBivXt2VoFtRdnuCaVobYtPwSLvYem6DqvtEm3WwEt97JsKu11u+lyLvp/9xc9t3zuvta17mzXgd/Yctq1vdRdoUeVjntm36OIa7t5HG9focD55zDlQYX+v7eDvVCacI4y41+t5jcZzsN9UwbOtvIYKSttzjqXQnQc222fPcU1cBJyodfu5NhDTNvMaDYQ857K0x1DboUyOnrtBUKsAUN9vj7XN4vAzm7nh8/m9MhM2o6YuCX5H4POluXcpf1y5gIEXKqoENbHQl7b2UFFx4dFHpwfHTCaTgZKjVc7P1NrjVkT1h9N6598UgPf39+Y9tOApPBi7UNc1np6ejBJl7EKWZWbXAn2qwNG3PR6PB32iJyI6qxDVP/Rw0hb+tx1c95QJj0JrOp2az9iPujVptVoNMugRBNG3qW4QCmQyEX1/jGbfZit07zo4vYPl4cHs2VeQs9vtsJp+QvRui8Y9YF2tDO1JCpfMA8dGAR6tWiobCjPWzd56RXcKiyoQ13WNVUers+u6Z1tEWQ/2XZZlhjnRXQwsCuZoPfN+GxwBw/MXeL0qFyoLVUycX2pJtm2L7W6LYP4R4SRG7VXYbNfPLHab9leFYMeYqLXquq452pvXBkGAxWJh2KggCJCmqXGNeZ5nTu5j3grOaXVJHQ4HTKdTrNfrQbIu1k/PAGH9+F1ZloP4GEbIO45jdiywDtw1RLcPffJ09SlY4Hyz2RrWl+5HDXK0gQzBSRzHZicC2TduryR1rwqf7+RzVdbZbj1V6kmSmOs0iRqZUX0PwRnnOXcpMDGTfbz1pfz8cgEDL1R0IdIa4SLRo4dt6pgLBoARQp7nYTQaGR8l/Zm6PYjCjoJFF7AmS6HyUStRAYcmFKKye3p6MvdpOmHf9/Hw8GAoP1pcKqApYMkoXF9fw/d9VB9d1B87uImP6XcjeGPH+AfZntlsBuB4EAvZCD6TCp90Its4m83Qtq0REiqQXNc1ypCK5f7xHqvguD+Z26E0kpwxDnfLT6bf2F6l49WSozCl8KafWa0eZXcMQHKeu5JYbzIqCoo0mpt1Ubqfdec4M2COu06UKdFxA05uLp03ChCpzO1tlMp28L28VmNmCICapjEpceM4HmxPZN/ofDr3HlXCuv7Yh+rnj6IIt7e3AGDiBhj9TvqfeSpYf47der0285nPb5rG0OVUZKwfTxTleLHfdKso+4DbbNme9Xo9YLHSNDXzjkcfEzhobAbnLrc4+r5vnuu6x4N/NpvNwE1CGcRn8J22O5PjTRClu4c06Q/BLOWFslKO4xiXJNeBykCCD84TgkyCJ85TZSXz/HRiJoHFpXx9uYCBFyo2rcUJTGFORK5UHBcGFxgXc9/35gRCYHj2Oq0LCtAoijCdThEEAfI8H+TwB04HlCjVqZH+/JwCC4ARgrYA4JY+CgAKC+AUKUzWgMK8qiqEQYjwVYDDE+BPHbgp4LSOsVgAGOFs06aMG1gul6YPeA37mv1Mi4QgiuwI+4GKjcpRBbTjOLhaXGMcTtD1HfLDBpvtZtCXag0pzeo4DibjKSbRFI7jYLNf4/HpwdSJoIbvorLR/tOIaApVjjeVOgEHAQEA4x9mEJah9TsHXeWgOOzwsL4zcR8cG847zkHOBa0DfcbafxToFPa6FU4teb2e9+v60D37juMY61epcipWBdoKApQVoPK3GRo9iZBFA3UZe8MxiuPYtFmD39huzXRpu0qUQeN1VNisF8dRQQbZKQW5AAbPUNCvc5pBkNz5w7lAgEH2gc/QWBMFWPz7+vr6WVsUSNrg0XXdwbHPDODlHOPhWOxzBgdznDWmgzJIx5tbeLndmXNSE7KdcyFdyh9fLmDghYqNTtU6pfBQ9M0FqLSqJu5RGhw4ndbH72n5MUjIdV3jClDFDwx9kPpDRWVnz9OFSiuWVjZwAidc1PxRQMTvN5vN0b2QZvD+2oPjO6g6x+QG0P7a7/eG5iUdTuDDsxJsq5mHrvB9BBW8DxgqJ/X36pilaYor9xbZ76/ROz38bz6iCk/BYqrMtM0ct7l/jckPr4AeCN5GqNIS+Wffvt5j+4PZXh5Ow++SJMF4PDZKSAEIFZznedhutwYkkJnwXR/73znY/bbHOJsg/lWMu/Cjyb+gwa4cN2UJCLBYXzsGRUGD3Rd2v6qg5rtsP7COB39XoPWlmApVimTQ+N0xa94MSZyYSHfOKQaisp26JU794/ye9eH/ts+edbEZC/tefsc1yrmoLhQqa/a/9iMNC75P5wTXKMGlBunacUc6J/XZGnRLUK/9rvNDx8YeW9aD7dNx0Tgnuy72dmeudY2voKxSlujCDLxMuYCBFyrGIhNFCwyFrf1DS4ELmhSm45z8hlmWwXEcY+1qZDyToih1yihcVTak+rVuXNiaQEbdCtyqpIcCaZsoREm1U4FpfXgqYZ7nWAUrI2zoG6TFRsFIpUdriUCFFhMFsVp2zIxIIMAkTWr9KvvB97G9/N3zfHiHAKg8wOnhNcd2q9BSYagWjOu6CNoQTnkUdH4Tmv6ioNa+pfBnf0wmE8znc1NPHj98dXVlDr9Zr9cm6yR3VHALJd04rJsLD33hoStbeAgwG83RukfBrMc/24JUrWCN4rbbr8X217IN9rrgvGFRa5rzS6/RdaJuCFXE6l7R34MgwCSbIX24hlcH8H7jwnM9w2zZPnYFlJw3yqLoOtakYMz6x3qR1uZ4k/1R0K8uQbb93A4MKmf2CwEEdyloPZnlj/XknGDbdA3YY/UlOcHDg6h8ybLp9QrK+ZnOI37GPAhdd8p2qa5GO4hTd2GQ8QBgdhQR+JK9ODcvL+WPLxcw8MKFNLCiZOCE9HXicmEr+gZOluGr69fonhw0TQsncXH3+Mko+v1+P8gKFwQBNpuNsa6TJDHv58LWbYcUFrqlTkGECnku4jRNsV6vn6F7VY5UWMBpexivowICYAKAmGZ0v9/j7du3AICPHz8a4U4hxi2EtHKYppgWH9kDBs0Bp4h6ZWPUYgFO+RoOhz2K6QbubQC4PUp/MwhWZMwGBbdSz03ToIxyhG9i9L2DMt6iWTfGyrItW27h4mFUi8UCt7e38DwPj4+PJsaEW6k2m43xs5NNCcPQpGxmP1CgxnGM9HaCtAuBtMEeJTzPw1/8xV9guz2enPnjjz8a4KSCXi1VZVd0PttMgM4TZYi06L3KQimA1mBDHiusgE5ZMrV2uV74zDRNEbUpuu9DdI2LKunhvHONIuf8r6pqkBabcSrKbHFNUDFq3MZ2uzXzXIEeQRcVuO/7ZgcP+45pnamEeYw4lbcdDMz+4TW65Vi3IaqCDILAvJf9qP3Pfufa53td18X19bVhB6IoMsGEum2YbaYRQ8bFHGX8uS7z+dysYX6naYp1XWigorIhnPtcewQiClAu5evKBQy8UKFSV4VBAahWGwuFgu7RpcIBjkChLV1U/wfQw0f4F8cUvQz+U+Gt2QWJmimYeDwq4wZc1zX5zIFhVjAqaAo8FtabVL0WtZw06Q3fpTsOaNWS1VCamIFOvE4tgqZpzL5l+nnZtxpRT2uMQoKfU5gqxQucMpz1/TGHwoN/hzw5pu/Nl1vTXioPvV5ZhbIscbf6iCLNATio8pOrQrevue4x4c50OkWWZUjTFEFwPOqWWfj0xEgKQI4Ng9QI4Ghdsh+AUx77cB4i/jMHdXNAlZfY7Xa4vb01Qv+7777DcrnE09OT6RPdu24zXBoAqHS0Knadl+fmutLu5wS47sJRV4XOH84pKhqtC4vrughHHrAA+qqHPwca56SgabFzXNkHugYADJLjMA+HWth8L9vL3UB81mg0GjAYmntCgQ/XCMGhzi/uXqmqCnmeG2XLNRvHsam39iN3ASi4i+PY1I/sIutDQM22qKHStq05sZA7NfhsAom+PyYFUpeF45yChKnQmcWRGUOZsZEAJssyA/KapjHGRd/3Jpsi68ZdNhoPcik/v1zAwP/gohbQl77n4reD3dD36DsHfQ+gAxzvvLvhnKWlQYJqfVEpqk/W/k7rawv1L7Xv3PeqFGyfoq1sVFHb9/EzVQpfqptdH95n97/9Ny3xbb81far9ovfZljHvZZpkrav+zXFRwEbBp+BOn0/FZddFfcb2OzXAVAPetB9o6dqBZdo3+j67H+y2nSvnrrfH4kvr4qesvT/0Xdu2qN09sj8P4fYe3JGDenMCc1rYjxqfwzraLIiuNYJffa/9c24N6vW6JvgZ77HXCpW6xm+ce6/9TNb7S3Ww57POL72OsSO6K0HHUkHyuc9tOUUZdO45CrjOzfFzMvNSvr5cwMALFY1ot4W3bWHZi5KUH0/s6vvjaYCT11OEfxWha1tUyRaH/ETppmkKACbiN01TzGYz4z8ej8fGMt5ut8aK4GKmNVLX9SBDG1E+aTjWDTgidbVcPM8zrgrP8wwLQcuAsQH0vZJidJyjm4OpUmlB0/J69eoVHh4eBtYUdxWw7kVRGJcALQhaCPzf3gIInNw4/J7CVX3XFMbqR9b7bT84LVYNClVhzrozNoBtoKWkriXuqKCy1uyPPLCKQIIZ8zhGZVkaBoXXjkYjzGYzZFmG+/v7wVhGUYRf/OIXaJoGv/vd78w7NEiQljjBAuevvb1NwcaX9n1rJDv7/UvKiX2gcQ0cE85NjbQnm8Q5Q8vVdV1Ud9UguI8sGt1KtG7Zb5y/bLcNKBmTwvVhf8a5T3qda4T9xT7Q/Bd0czAOQQ8f4jsI8tj3XNPqQuG7yBbQDcR6cN1yXnPsPM8z1jrbo+PL53HsuIOAayCKIsM4an+Nx2OsVivTj4ypoFxgDIAyTuqS07JarQbyk/JMQdml/PxyAQMvVDhBKaRUmZyjUYFT4iEKLS44Ls5dlcNJdkYI6Gl955LP8Dpuu/F93+zD555o+vVVYbIuXdcZ69b2z1KBs36MS9BIfgb36TYh3WvNe7JghK5zEWYeDqjMvnBS69yXzPs0klitAvp9+T8FpQopm33QrXQKAlS5U2GoRa1sAftDI6l1qxhwopC51YpAgOlY6YNVcEJKmTER6q9nXWjpc+w1C5um7yWwpNuh647nTnB7GoU2t6X98pe/xPfff4/NZjMILNMgSZuN4Pf6t1LgLPxd1wOfy/4n5ax9r+tE41R0THiN53kDMMD5mPoZJu0CXVRj1+YmEJf9RvBCgMH/bTDLd2kAId+htDbBBP/m3KBLh32hv3ueZ9ad9g/96vb2uXMAZLFYmPFmPRSUUQbY65pzOgxDjLMx0n58nEtRi0O9NwqaAc0KejUoVseadac84dZJvUaTEhHUEOTze+0zMjEa96DJuy7l68sFDLxQOUd5qdBSxAwMKS9at0S7oR/ChYeqKbHdbgeBRxpQp9HOXdcZfzEAI/TTNDU+8y/ReBqZTMFoLzJVIPybFi7vV8tO30Nfs+/7CNwQ9d/5OPwI9N+4iP5dhM4/toHWhrIJAIxvVy0Zgh76RjUxj03vKlXLPgTOb2/i7/oMpV5t+tOmNfk3BWiWZciyzAg7Cj8KvTAMzVkQqhB1TFhsIKMuAPYxfcdsIxUS68i6qcULANfX12b3yHa7Nb5cjt+5+c56KOiy57/2vd5n09Lnii3kbXBHwK2BejpH4zCG808J9h98eLcewj+pkff5YG5RmdHC5DM4v6kwObe4rjh/dK7rmiH4UpaNLJj2hYJcBSh8FuvGewjGtY851xhsyu/O7YpgUYaIgDCqMpT/p4u+A9K/mMBJN4NcHQoQ9Xe2Uf/meiTAV6DMsWLf2wCDc1nfq0wV25QkydlTRy/l55ULGHihogGE5ywjG02rAmEQTNd1CN0Y3T+E6HIP8Z/46LLOAAIVdKSTu64z+QVIszNAj6wBlREVJzD0CWrGQhV0FLYUULQAFBgoI6KWI//n84DP7EnvoKt69I1zPHmsPiVaUatZhUHTNOaUQwoR0p+kQPU9uvVK2RcVRkp128CIv+sz+VwFCBxb1kd3ZERRhKurK8xmM6RpagSyuksohEejETabDbrulKqVwlQZHB1/vlPHTJUNt3Ox3RTAtuuE1tt0OsW7d+8QxzF+/PFHk51PrXRVwloPW6Gr0ua71S2gc8zuY5uJ4PN0dwnfqfEX7B+O9/HzEH3joW9wnHPd86RFbduag670h99RURN8qbWtgYtq5bPudmpsBZi2QmTb2dcEvrp9j8wa17lu1aVbif3C+aABzXQBUnmzX/lst/PQ10DfA6ETo/YKVP3pUC4N8NQAyL4/uWjYRrq/uLtJ5xLr6nmeAa+cJ2oI2K42sjCcF+eY10v5+eUCBl6oqKAjKFBByIWgKF8pTqLhoA6xe++gKzq4mYvRvz36gFVB0hqglUC/MSPwqYyYh4ALb7fbIc9z4993HAdpmppIaQadlWVpLFlS1lykXNy0cumv5vYiXsd+UKozDEP0Xgf/1y2CqwDNqMK23A0sLi7uyWQy2CqovmxlBqjQFbCo4lU2waaolWZUBcX7+D47KRMVHela/k3rDACm0ynm8znG47HZv83x3+12BqwRbJEV4biQ6t3tdmb82J9UNhTmwAlwclcCo76Zf4F9yhgTVXKu6xoX0Hw+R9seT+zjnKRyUsCoQljBwLk94xTquh2Tn2m/2sBAi1qifD/np+u6Ju+C4zhYr49nHTRdjfBXAZyRhyYrcXD2ZoxJjbPvldnQbXr7/X7gp+eWR46BMgk6zso6UZnSlcS5q7t6CEiowHl2gcZG0C1EVwU/+/Tp01F2fFb2Ci64/giabSaH41WWJbxveqR/6aHvAO+mBSoYORBFkUlFTkCbpqkxMnTbqyZxsncpaHIszi+6Na+ursx6Z8wH+6NpGlxdXQ3WGdmaCxh4mXIBAy9UNEBJfWm2hUkLx0bmfX+MSG9ua/ivA/S5C+e6Qe+ctlnpPmZNNBJFkfHfM7iHyYp0+xXBgQpgCr84jk3ecy5YCi4N6iG44MFKumgpvNg+DQKiUjjUBwRpjzbcwfEc1OXJ4qAQqesaq9VqwE7wqFQKVrUa1WpWvz59x8bycYfBgnovQZVae7avVtkUWubsb44jhfg333yD/X6PPM8NnUl/8q9//WsDqlzXxePjo3HxjEYj3N/fY71eGz8yFRDdBLyPY0Zg1jSN2Z7JNqqC1IRLrBPfEYYh1us1fN/HeDzGn//5n2O32+H7778321k5Fsos6P8EJEojKzCkklR3ku1aOsc6nAMeyuJEUWQOHnIcB/P5HI5zDMjdtlsE1yHKqsBhdRgo+77vDRhWGpvvpGWvDASZB7XclbGhq4FbALkWeFYH+0gDc9kvQRBgNpuZ67ndmOPVNA2Wy6XJKxDHMRaLBfI8N7E6PKBKY0p41ocCYtaD7eu6DsVhh/htDAdAcdibOdb3PR4eHgageTabDc4NGI1GxmjQgFMaCVxLCrQJBtgHZVkiTVMDbpR5JFBmfyjjcSkvUy5g4IWKKiP10doCTj+zldPhcMC6WCL5ZYrIj9C6DQ7VcVFQUdOHR1+ZUpBMPFPXtTlfgCeiTSYTE32rfkpaqxpRrf5lHuDCetLXTRaAbSZo0BPSNEqYbERZls8ikpV+ZP0Z7KSgQoMk1VLMsgxxlMB1HBRVgeVyOQBj2ufqb+X9/NzOraDKQX9YVBHyTPrJZILJZGKeyQyMBHGe5xnQQQaA2QVJLe92u2cBnhSiGgCowZ12jAOFJ4X3ZDIZWIVkCBSM6g6B+XyOKIqw3W4HGe34bPYVM1By/tuKW5kBBQn8XlkzVaq6bvS5fLa9TVDdB3Ecw4EDz/NRFDtU+3KgONTNwHmmYJGKk1H+GrimSlTXNJkGZSyUYdD+0Ah+PoftIZBQYMW1p+mL+V4CaH7GMSUQpVxQRoX9y37j+jyOhwfHOQKs3W43iMchIFFACsDkBtB6qUtCD2oDMADCOnd45oD2K8eGa5kyQZmNCyB4mXIBAy9UFAwAz/dT25YNF6c9kdfrNXIvN5YOFyp/KBgoMGyhRKVDYT0ej431qNvCKPCKohgET+niJQNAFE8LpixLE3vATIe0dFhPO1bA8zxDt1IAqH+QzyY4YP8QBJASVL8qLfF5doXR0xXc1kW+eESVnLbsKaWu48AxUFqbwvKc0lfFxfHm+DEZS5ZlGI1GGI/HBjTRJ886hGGIzWZjziKoqsqwBhp0xnFXS8hWkLZCtOutbdQYAgAGOBIAKjjV7aaLxcLEM9huFrs/OV62kuZ1uib0d1uwnxsDjSHgfNLCtREEAbwiQvcvPoK4x/TbEBtnZcCTun4YZ8P3qItPXQZq1doWNevJZwInoKIBfLyPDAMBGeeE7iihO4HAmAaAuh1ZZ57ux3pwyyp/NOCQ46PjyH6I4xipP0L93z2gA5I/i1C6pQGCqoTJiHAsuIVRd16oQaEHF6nL0Z5PdFdpGzW+xgaM9ly8lK8rFzDwQkWtfU5aFW5UeszIRYVOxUnLnFYjlbOmHWXKUqJn+ttIzZEWr+sak8nELBZSib7vI8uyAdoHhtuZ6LMe+EU9H23uoF01GE0nRkETMFDZqBAn0mc+BAoz1l0D/xzndGQpi4IFjWy3LccoipDUI/j3KdAASTw2FLgdcKRjRdBBt4bmO2DRjHEU4BqzQYVOOpd7yx3neJYE/a38u22P2ebyPDfsBn29BA+O45g95kVRmGdozAZTSo/HYyM4Xdc17eZ4ak4Ix3EwnU5NOzebzYCGpnKjVcmgVAZAarwKcLJEqbh03LXPNYqe46pzzgZpCrZItZ8DPsoykHbf7/fwXB/9R6D5wYEbuohfhYYBYD3Ybt32yuepgifFTaDCdrEuDNxT5aUsiJ7OxzbwWlrefX+M5VAglSSJ2VbH4FkCdh5OxjGgEiY4n0wmKIrCyBG68rjuVIFy/tO9EBYptr+rgA7w5h2Cq5OBwLnKftPcBwQ2BL2UcVxj6uIi+KI8ZDyQ9i9BE2NBCCQ01oDAWc94uJSvKxcw8EJFF72iV9vSsP2StqXKhUL/slLx9r5bFZC0OFgIDhhUpr52PgM4BczxWuBENVJoOgcP5f/eoV57CH8VInoTofKrQaQzwY3tk2d7le5Uq8neRshCJazUNZ+hSqFpGhzCCsHoAKfxUMd7tNWQEraD2tSyZj1VUCo1zfuVFbABSd/3Jk6DhzVRsVJQa6ATd0Yo4FNLi+/UJC/aHgpL7oPnd3b0O7/TrWfsZ46duov0R/uB21MVEHzJImN/hGGIq/kVEjfDAXs8rh6MItA5r/dxLNjvWgddN6w/cMqkaBg5dHBGLfxZADcBEPXoq2HCL/apBovqlk6+UwEgi1rFGhPEOthJm9gmBf1UjJx/nBt89263M/khuDuJIEX3+qtitBkXKmCN1ld3hT0Gfd/DGzsI5g76DgjnHg54vuuBbeQYuK5r4iFsV6kyEpyPNguolj9wyn/Auc9nEBjSFXNuC/GlfF25gIEXKjZ9DDw/3Q4Y+uq4mNVvymvUt06BTUuCC4z0G+k0Wqa01Kngn56eBoeN0CLSAB5GqdNqJ8J3HAc+ws9tAXqc3s3tRPRdatS9MgFcsFSOpD95H+tAIcvv7b3GKrjZX0VR4Mm9R3VbwoOHsi9MFjZVHFonjo++T8dKBTnHSpWT/Xff9xiPx8aKJlBjlkRlUZqmMX720WiE6XRqrC0FLrSKAi8EnB55lxsBSIZnPB5ju90O/PVkaMiokGXKsgwATL/TqqU1pgfpADBKyHVdLBaLwe4Nzhul9tVKB4DpZIrrwzcIH0dox3s4Uwd33afBDpDxeIwsydD1HTbbzWCuaB1sup79Q0aAzAkVfDspMPoPPlzfQdXvzZwkICJAt+l3KlsFA1RCVPCaRZOsCOdS27ZA7wAd0PbDHBZkCgk66IoBMIjJoDuNVrZayQQKOjYAnvUNAZIGAqsCthk29nWXHpD8h+54DPfMB1YwoIJjzXlSlqWJD6LLkcGq3IGhLgVuBbbzD5CxInjmAU08t4NxD2TvyDSynZfycuXSmy9U1EpXJKzWM/A80Q1wOqRDA+5c1zWpUrlbYLPZYDqdDuIIqGiU8tN38jSx3W5nlBNwospVIdAVwbSlwDHYx0t9JH8VIS481KM9es/HLJkhiiKTXayua2y32wHtTnrSBghkODzvlGlPD4ih75Bt54EkduAW/1+tVyijo9VJOpjCnGMAnJgKMijq36YC0kh5CngqCLUa1YUTRZERaDwJUOMA1JJ7enoavLPrOhOXYSus9tGB8xAA0xZhdkCeH2NJxuMxptMpJpOJAWBRFGE8HpvxKIoCq9XKbO2iW4ZtI32sAFO3O9JP3Pc9FosFVquVmVscI46BjolhU1wPwTqBswvg9y780Sk2ATjGmtxOXmOS36DzG4SzD7hf3g22oalVaVuAPA2PCrlpGkynUzMH1oclmqIZ0NSak0B/Z7Q93TAsdE+Rmue8oRuHwIxUfogY4ccU6IH+TWXcTFyLZVkOKH9luNRtSOZIWQdlEjnHARggqS5HBv1yfJV5U9ZH3WV5nuPjx48Yj8fHezelGWNu91MGheuWbZjP54M1pYeHaZ82TWPijFgnOwaJ8ocBxnwX281tsxp/cSlfXy5g4IWL7T/l9iJVMFzYGm1s78/neQNckEoHA0M6kKeRqaVAvzL3Pj89PZlT+HiaGuug+6NHoxEWi4U5Mvd0FkKLPu6xP+zR1ac952wPLQ9NjkQrgQKIFhDBA/ur73sjDJSyVovwSycPUtmynrQa+R0/U2HKfifg0PHh/bQeARiFa0ed0/L+9ttvDVXadZ2x3ggUVPCORqNnZyqwrsAxgLTve8wnczg/jLD/AfDnPtK/HqGZNMbfzAhuzhH2NYtSwfv9Hh8/fjSWG3ACrMxPwd0nrC8VTJqmWC6XmEwm2O/3BpjZRal913VxaA4op2tEfYcmq1C0u8Gpl0mcIM2nCD6M0PsdRu8KbKL14LhebYMCOg2q1HwYZITiOB5sr6P1qYqMa4eAjW1Wti5NU6PwOIdV6XEM6UuPdinKf3bQt0CYxujSfEDrMxqfjBfBpLIlOt8I0HTLLpUt7+F65vZS7hJh/ehyVAaDY6DsENcAj2VmfwAw/cQ+Zx25lnT90hDhdRpDoEyaMnEcC44t5RMZGcoLAh/2IQATG3QpX18uYOCFCq3s6XSKNMrQo8Mm35gkMLZfS60pe/sVcEpnqtfzWqXUSNnTf6wWAO+jgKOlt91uTR4CIm9eSwqb2xBpDdB1QXcALQq2nbTxuTpQaNon6DFwyHXdwXNVaJxzq/CdVLC2v13HhH2p1jmvVV+83q/WPwUer+c9VMoEY0y+QgZGKXQWdS8oxUlBRwDS9z16B3DTHm7owM0AJwDc1h0AHU0KpemZlXHQd+ucYH+T+u373gAaVer0XTNGgWwLC0GPuioAHOndyXtE1xEOzQHrzdrU3bQhbNEH3fEn7NAVQ6Gu1rE9rp7nmXmvgWesA9cDcNr7r99TIXHuK4Wu/nm1zpkWm/dr3EIYhvB6F14CdG0PJzmtWdLmXHPsf75PXTCUI6wHx01dgKwb14nGAIVhCM/x0X5ehwzMVWDMws/0b7vwGg2mtZU5GUB1d7KeBCm8lnWmnNBD0tjHzIXCvmdbubuGcobJiuydJZfy88oFDLxgybIMr/xvkH6ao49bBLP3AzrtXKALJ/y5zymo+LcKKy4WKiLf902goMYvaOCaRvTShwyclGXXHaPMaUHqXmFeQ/aCbAaL+pKVltS4ADuwiNQ/71eq2e4rO1jI/p/F/luZGvs6vlv7y7ZGeb9dFwI/5hcATmmlqTBUYPJv1kkt38PhYGI2+O66OcD7hYv4dQhEHYqmNP1Fyt9WUEEQYLvdGoGswXUcX83VoPvh+Vy+n+PheZ7JVUFBrdedGyvgCHAeHx8HypexKgCwK3Z4nH5A86sKHTps6pVhDhQIqrvAHnMqeX0HAMPG6Xy1/ezsI85LzmW2mW3QoFylv3Ue8Pp2tEf8v/rouh4Hr0K9PgXs0uVnbxVlX6t7ULd7cr5wvjLBFQvnEe8Lqhj7/+6gcwMkvwQKtzBKWNeYrjVlglTmKEvHuAy2VXeMUDlrXATXhK5bBbIKqDjGtPwVsOvapdsQOGVUPLe2L+XnlQsYeMES+CGiYgR3HaIveoSTk3WtFr8uChVm9PtTEVOxkCajFcgFxiAbAIaipkLic9QSpeCiQAJOAo0+fsYUACdBzzrw7AAqsDzPDVKnhaBChnEPClCAU054BUEmAOtz0fgBFTwqrNleBSx8rn7G9qrrgXXkM1Wo2KCF71eGIAgCXF9dI9gk6H4XoshWaLzTVkVbYfI9Sunzb3WvsM1t26LsSzhuhf7QG9cCcAoCfPv2rRl3ZuHjiY96SiUA41N/fHw0SZ2UHaDVr7tOeB9TW1OZch5SmNuAUVkjTfxkuzF25Q5FVQzepy4m1udcIf1Ny1KDV5mRT9cbt9bqDgGyGvp+LQpUy7IcbPVUxoDWqwb9dftukLlRd9ooUNH+0PeqJU0QxTiJ9XptWLUkSQY+9PrORf2pBVwH4auTi4pKne8GTnFO3G2SpilWq5UZVwVOjK/g53SH1XVtApkJcrMsM8zMer02z+A1KudsoKzsImUSZQnZKY4rAHNuy6V8fbmAgRcsTVPjMNrBmwVowwYVCkOx0lpWYaeIWpUZgGdCUIMSAQyEmCpMKn0KLF6XJCm8OoDburh6c4UfP/6IruvM3nMAJpUuADw9PcHzPMxmM3TdUbCt12vjv2d7KAAJQFg34Oj/phDh52xjHMeDICMAz+5n2e/3RuAAGPh5WR/1fbJvbcChQW98LxUZGQ0+U5XcOaUXxzEyZ4Ld3wHVZo/0T0cY/2WGXXE6T16pXxXI0+l08E7uKwdgvmPdNJcEgAHzcH9/DwBYLBYmRz2Fp+M4uL+/Nz5Y7tem5aU0NY+nHY/HA9pag9f2+z08z8N8PjdBh0o9MyjOnucs+vt4PMb19BZhG+PglXhY3w8sbl5PJcB7VTlx1wb72oEDbx+i7wA3OcYsRFGELBzBO4TI5iNUbYn9YXiCJ335BE86X3W+abZGzg8CCx4vbreBzBrnAN0Otp+ec0O32DGoFDiBkaZpcHNzY4J8Ob95hkUQBEhHYwRvPPQu0CZ7FE/FQGaou4vvZFsVwJJlUncU8y6ozOH/eiKn67oGCGVZhjzPDbjruuPBaxr4p2CcZ6dojAgZEV6vwcm2oXEpP79cwMALlm2+RRB8Qny7RdvVWOUrg+CBnz6ulcW2oO3PldKmEFHfvdJxuvC9g4/9/+miK3vgz4EwiVBVpVEI+l77d/5QWarVYtPE56j8L7VTLYJzbT13vd03anXzb32mvoeKb5Qeld6uyJHv8sE9cRxjOp7C9wLs6wqb7WYQw6DvdzzAjYAuBNzIheMOcxSo1aPMg/apXq/3aTnXzxwDbaPtatEYB63/l/7W/lQlrNfq82zXzb+meJ6HyWiC+eoN/FWMZlGgHbc4HD4OgmTP1c2eC/zxfR/OzkfzXwP0NRD+aQaMgDAI0f0+wuFHD+FrIPzTCLU7tCJtgOi6x+2DcRjD6R20aLHZbp4F8Go97P7Suv+h/lG2SPsVGB69zfVGJX5uzR0OB6TTFsm/89B1PfJDPQAoX5I/Wkd7jmo/2XOVYJFF3RF6jc162O45Bdn22NrP1p+fatOl/PHlAgZeqNBi+7H80aB6Wss66YnGNfhIFYNeq6jdZgzIBHBb0Hw+N4wAA3BI/202G8RehmbVodsDh1WLeBbDcWCCcFhfbo+jJbzZbEzbNJMZ/wZggumAY656+qttUKCLnFHpmg2O9CBP9aOyofVDAaC0v318sQZJ2Uo5jmPM0wXm+Ru4nYfN/B5d35mDgLquw2J6havqDfwyQrXYAhMYqpNtZR87SY/x/xKgK4DgykGH075sBlsywJDsSd/3hqJ3nFOAFceafUz/KLet8d3A6WAqMiK0XJlVsG2Ppw7O53PTtyrMAZijcGldjkajQbpo1lm3fTJgb7lcDsCo5szXGAsqC3WxeJ4H3wvgFQGwd+GVEbzxKfmTDXjOKVkAJg+HYcdKB932GMkf1yGqbou+7dFvXXQ7oNs4CN0IyHoTJMt+pO/Z948ZF30nQPQwhpMHcL45wJk62G63hslh0dMnR6ORma/KrNDiVtcCdz6MRqOBcvX945HWunOAcoDBnVmW4fvvvzdMDfuERke3A6p/ATqnR/cKRhawPxWg8B30vzMGpu9PLh2OGXeZ6NjM53PMZjM8PBwTSrEfkyTBeDw28oeBtQDMKZ6bzWYQMMktsOo+AE5ZQPM8H+xu4lylm+hSvr5cwMALFd1iRx+WBnBpKlQKjXOoVqOz1bKkP07foxnuGORDHyJTyHJf867fIvh1Bn/voVkUOFTlQIkAMIvMRucMAKRy4kIk9Um0rxHOVMJ6WhowtJpU6FHQkqq1LWTNM6BR3noKo1ojLDw2l2Aga6fH1MWtgzjMTGIT7n9OvRHC+xFQuYjdHsHsFOXPiO7JZIKr6TXwEMAJPGTvfATRCcy0bYvJZGIYG9d1zS4DCjACKO7aIA1KRWwzHbqv3XEcQ8OSLifAUobj22+/NWcSfPr0CWVZmlTInIcEDowH4Zyl+4dtSuIU/i5GXzq4Gt2g6z4N9sOzfnoIE91IOiZt26LcFyhvVgiTFGW2wbbaDAJdOT9sFkqVKf3oVVUd829MZgh/7aFvHPive7R5i8ZvEP2ygZv48K5b7NGglgRCBIDq3tjv9xjHM3TvI7Q7IAgjpL/MzNgpqFLXAncKaKyFzmeCcypW5ioAYI6pVrdDmqZmLpERcF0Xd3d3cBwHk8lkcN4Igym9TxHKf+kA10EfndYk+5TrivXRIFKCYrZvOp0aQ2C5XGI2m5n1z5wX3OLKOchx5Dxiu+bzOZqmMaCB/ajGAAuP3FZmk3kxKGtpbHDnzqV8fbmAgRcuSjtSadtbzKi8NEKaRaOXNXCO97GocuTfasGrX5fvH43HCBcBDvUBCRJzqAnRNoWrtkUDnSiY1ALUBD78TOnOL7k6qDA04EwpV5sGVcpbM9PxPlU2GoxGYGZAR7xHnzVwWhd1tEddnrZVAkCDA7pxDdcJ0GQHdN3p4BUK9ziO4S1jrP9rAzdoMf2PHdxvHJPcR9+vPlUN4NI94OpzpQClxQbAKAYqFo43AJOMhUGBtMjGozHc2ocTusa/Tcah6zqTYphxDAwctWlrMh1hH6P+ryG6AsjeXqFI88EhP2QGOE/VhcBnUeksV0u04xb+6Bi9vtvtvugeUEpcAaoyEE3TYFttkHxTw4GD6nAEMFVVwU03SP8sRb7L0a5PuyYUkFMpmrUS9fBmPeA48BcOEAWDWA6uAU16w1wDSmNr8JvdJ4zO55hSIbKPNIBWQUjbthiPx+Ydyuw5jgNn1MOfHt0be7dEU592LdhxMMoSsL7sd92FQrCkGQTVRcn6a0wFn0kQzfMuND5J5y8VvAZUK6NEoKVy75KB8GXLpTdfqJzzu1JAKm0KDKlsm8I758NUy5fXq7Dg3wxyop/QVswMMtItOlQitAA1Y6Du6+W16hNUGliTDbFd6nNWq4mF/WP3kw0glEWxGQbdGXBO0GnkclmWePDuUL85wIGDVbEcRHzXdY2n/BHdVYfgJsShr5CvcgNeBr7MHoADwGGQn2uYFtZVAxrVgqMS0K1tdlyCjgUty67rDF1LJoPAj5Z8mqaIwhj4GOLHv1sjvg5w9R9P1DPbwcx9zCNgW+BkLExQp3tMR33sK6DrTgF4dvyIAgMN6ORcresaj0+PAIbgV4s+W9cWx9qeS2Sr7DlDi54BsVS2bBfrp3vdy7ZA+G9auL2HNjrOMe7cadsWbdOi63rAGW7h5ZqiG0vXLAEgmTxlrAgslPVgEjGdE+wDutQ4f6iI67pGlPbAX7Woih2e1vfYFbuz606Vra281SJnP2lGTY4bmR9bkeu8V8BPY4VtcZxT6nOyfHS3sG46j9jPKhttQ+tSfn65gIEXLhReaimXZfnsMBoWtTgpMBRdUxgoQgaGFpQqDtaBylz3oVOIhGFoItFJ2/H56uNVIaICRN+j76dfVJW8CgW1mNWHropChZ/+TQXIdgEYWExq5Wmdtb593+Px8RFlerRoN5uNESisx3a7NdY6BSyVJ63k/X6P/rbG5G9iuD6AeWOElFpJjNIn4NCT8nR7pwZ50YJiH1J4Mk0xlbTjHDPPPT09mRTEjnPMXe+7AcJH4LBs0R16THYhWpwy0dH1w37hbg3OA/XBmnqEFaK/8NAVDh67JfKn7dlMhPbcoLV8LnMdlYC9dvS9HG+15DnejGfgPNHANFLvvu+b43w598jC6I4KPsNxjvEBnneMm3EPwzMQkjBDu07QHVx4NwVavxpQ2nSTZFlm2ljXx1NEHx4eDItD5db3PZbLpckqycOuNDumzcRxSy+Zw91udzpnIe3w8PSA1WplYgHYJ/aWPoISPlsTNfV9j5ubG5N9UBMLcR0URYHNZmMAqoIIBTb67KIoBsmxNMNj05zOHiBrpu4MrgWCbk06dSlfXy5g4IWKKmqblrMz6/F6Wn38nSCARWMGGCyl6JsLXBehWmhkCRSE0M+meQgodFlHBvIApz3tfIf6wTXhCc9N53cUtirMKMD4LgoXCnt7v7cqBhWeJv3r53PU1eerwIn9rgwJrWHWk+1U6le3kVEgq5V6OBxQHHZIX8UAHNRNjTAOB+POfqHQBWCU+Xg8Rt8fAwl54AsBAw+AIojJsuyskqT/1R4Lz/MAp0f0nYO+9eHPXLT+AU7rYLlcmjFivgGyDb7vD44qBmACt5IkQRAGiCYe6qZG9S87s7WNddLx0nnMcVHgoVanBsSqMlegQAuR1yhVzHiW2Wxm/MdUxhw7uk90K5qCa7Z7v98jz3Mzx4BjoCUTQu12O1yFc5Q/JOhqB5HXYz9dm5gbBt9xzlEB1nU92KanjIWyHFx7BL6aaleBPQELFWqSJCiKY3Kh9Xptcv3rGSCcH+wTjWnQwnZnWYaHh4fB5wRYyrAAR9YgSZJBDgCuRZ7HwJMYNQ8Kn8t6EWDovOYP1w8BjhoGGtR5KT+/XMDACxUKF7U0gJNiUNeAbQ3bn7NQmbCowrWtYkX0NqhQ94QdqMXCOusOCK2nAhbbZcF2ahtsC9EOfCQoUEWr/aF9pvEFrCvbTKGmVKe6K9QStV0MNpWpPl3tN+0vCmXgBGb0oCGlMGm9azY2ZpCjwKafmkqCik8FJKlYxh0wqyWDt6bTKdI0NQyU4zpI3gQYvfZRHUrkZW6UCJUQf2jpmaQ1n602bTtZiR69UZgKINlmjYngvRTUnANsr1r6Ok90jM9lwKSi1DlH8KbZ/XgdLUtlAXSniud5xsVAlxkP0mGqW4KPMAzReTXcJAJcF25yAjk6Npwvet4Gx57ghcG+wClgTvf5aypmzh29hkGnmqrXdU/HCSudrlQ6FTV9/awzgQrnKhkBrj/guBNAg2S5FrquM+cuKEBg3blzSGMNuO50B0Xf9yaOSdtMmaHxE2TqCG4u5evLBQy8UFGFaQs5VU5abEpcCyc9i1oz+pm+XxGyXqf3UbiqL04VPv2pqhRtZagCnt+rcOFzVcAriNAAIAVLqkTU2mTb7DaoJcr/NeiSQlProQGdBD487Ic0prbX7gMFDuwP3WVBwarZHvXYW/b9OZpc6wucBLceT61Bf13X4fr6Gr7vY7/fY7lcGqut73t0bou2b41VpwBU54n6/am07OAsZaAILHT+6v/6uQ2w7LnJYvfDl354P+vLvqjr2kT0F0UxsFI1nkAVDPtD5zNjZFzXNcqa2976vkeWVsj+rQN0LhqvRLceugUJpLhOOD+iKBpkkeT37C/WgQBXmRIAZoeJ7b4DYNwg9OGru0dB/LkxU2DYNA0mk4kBiOp+UoZH2TZ1B+jWYw101TgaggnWQd0WZOa4jvk7lT/XqMYZpGl6CSR8oXLpxRcqVHC2cFG/JwW9CkYubFVoKqxUmZLy10VNwWU/WwWnHcyl37MOaoWcq6NSjFTMqrzp41TfJtE8BRsFKi0+Bk2pIjpXJwoLFgVKus2MQoTvYZtZB1rZKoAW0wUW3Wu4tYddtkLbfhxs0WP7tH6sl+/66O8DFN/3iL4ZZvZj23zfh9cG2P8L4MUO/FfdM38o2wRgkN6ZSm4+n5s0uEqRd12HxWKBOI5Nali2mQCN7SeNTOtZj58FYCh0pnylH9h1XazX6wEI4nPtOW4rGlqVtqvAZn6AU7Y+Xsf2KxBQhknjWtTSJcijL7ltW+OCIUCjQrIZDYI30tQcCz1bo25qOKEDx3PQicJlJD7dVqwL99pnWWa2InL89EArZUDoujGWfR8gehjB8QDc1Dj0e1MnskzMg8B5qiBf26fzQ/u3bdsBkKG1rrtW9GAxPkvnFAExATbBCdepzWDycwUjXA8EUcf+SxAWMbp7D85VgzxdI9/lAHA5qOgFywUM/A8oalnbflBV0oqwbSV+Du1qAhEuaD5Lfa+kSM9R6zYToUFgaqUocFClQQGnhRYVv1MlToSvn9P3p+0ldQsMUzHblL1astouAM9AhfaRTVmzrhN/juSfF0DtwHnrYJdsjZBWi4p9q8/2DhG2f9uj2dbICg/+n3oGMKl7pPpdj+X/u4EXObj9TzGS0Sn9cNu2JiiQ72AsAYFF13Um1kDnjed52Gw2RgloOmla8IxLmU6nJi0sC+l1ui4oWNWysy18m33iHLfnOz+zY0CUJdL5yXfZ77PZIJ2/VCBsP7c6UonbPnl9n7IrnJucQwq2aKXTMldgwu/V/851R+oewACcErTr7gP166uSJTDzHhI0vw0ADwhjF970tI2YwX18xmJ+hcwZo+tb5O0G683agERdC2y3rnkyDJzDVPK6i4h9o+mqlTlR1o3voWuSIFn7mGtFQZIaRJ7nIehC9P8co3904eYBot/sUbhHwM7EWZfy9eUCBl64KFXNxWNbS6pg9HcVWkoXKx2nguVL9+rnKlBZlOq3hbkKeFW0fPa5RWssYO90kIlaWow+prXDz5R2BE7AhEpKqVz7nVp3O5ZBgYgd5KbXA0DntEDYAnDR+S16nKe9bav0cDjATR24CeDue/jJaYxoIbINbujBiwA/cRDEHtzPZ9Szr8bj8UBx6DZPBWdM4KKKif5Y9jXBgApnfmZTzKSWOa9UWbN/SNHSsuNz7Tlzbn7bilhdJRoYp/2t68JmY+z5SIXBOAellKmE2Ic2EOf93AWj9VAGgZn+NAeAnYWTfaI+cVq5fd+bXB7at2pR930/AMNkacwBUWmALnYAD3ACoD6cQIDuPonjGPP+BukPC/RuD+/NJ9RpbYIi7R+VTW3bmqRUyj5yXWpQrSpqjiHnD+9RAKLrmOyh5hOw5wdZNeAzwEcLL+rhBIATAXAwqJvtNrmUn1cuYOCFim3x20rEVra0TM+hWrWANPhHI+ZV6auCU5qe/0dhhGpfmTTDpGSBYZCigg4+S5kILnql/g2lDAeO6xiKVP18toXgusf0t7qN0nGOW/1o4ZFypNBRpsMOMFJLn4pY+9jeGUCK3vM8LKtHOG9cuJ2HMsixfdoO+tYGGKRT1+s1FosrJH8ZwDl4GL8JUX1W2vQN0zqavprh6j+G8GMPbXIwcRlJkmAymQxOg1ytVnh8fDSKkH22Xq9N8J/neWbrmu/7Jh5gMpkYdwADuLhvm1ntaEk5jmPey/mgmR0ZOT4ajbBYLEzAox5UA+CZILaVjIIGzzuddsjC+3W3wDmXgr1lVOeoJs1yXRdZlg1ybhAcADApt+0U3FRsVML8nQo/CAKkaTpI0gVg4J8n6wWclBRBHeNpCDboRnOcY6Y/BqHy+YMgu5se6d84aLsW+7DE5nHzbDwAwHM9+E0A7D04bn+0qGV9aL9qYKSuz9VqZcad85igiHO/73uzcwI4uVM0sJP9QCCl8o+Ggeu6n7dxnq6nW0UZ1UO/h/+uR/AqRj9qsT9U5nmXrYUvVy5g4IULkbBNSdpCk0pdlRwXDgWcKnsWAgv9ndakKtamaXC1uMJ18gphlaAa57j3P5ktYUqZ28yFnRiEhYKcln0QBPjFu1/A28Zwahf1uIATnSj9IAgM3U3lSICixy+zvHr1yrRrs9mYbUa6xQqA6SMFYFQG2ibtQypyAjDeu1wtUSVHcEELSKPdOZ7b7dbksme/r1ZLBEGAZJSiqE/WDwP20jQ9Cvi6BBKgbDs0y+PJc6zf/f39wFUzmUwwHo9NVDij1OnPZ73Yl5pnoCgKE/RGRfb4+GiEb5qmJse7MgdUDOwbjU0hXTwajXB/f4/379/D8zwDOtRXb7MCNnhVZoDjqHEOunVW1wkL66M+cX1HnudGIadpaiLOCYg0eI39w/857whKHeeUFpr98/j4aJIBsf78noBrNBohSZJB0CgBjgIxgmXOOx49zXoQrGy3W7M2q6rCfr3HarUyc/VwOBj3YVmV2IyfMHntAl6PItigLk4sG9kI9dNr/VV+PT4+mhgVTSlN4MD30k2gIE7jOci8cIcD30W2gvM4iiJzbsFutzPgm2uYrsZm3RgXBRM3XZiBlykXMPBC5acid20FpN9zcagApVIBhtsQVZBosJDmE1df3CybY/TpGu4qQjBPsb+pTDAVFZpaNQCMJcpnqF/R933MZ3OM4wl8P4SfOEi6Mcq/c9GXgPvrCO53J8HDPcFcsNxSxWQhFKx8hwY4MUqYCVjW6/XAAlTLU2lfZTI0AEppRZuapsDRsQGGgZOakpX36WFEVXUCDkrLM2iMhWOnMQGfPn0yNDEZi8lkYt6p0f30JY9GI1xfX+O3v/2tEchUHGynAqa6rs2ZFb7vY7vdDqhevofXTCYT8ywGclGhqQLXMeP8ty1EmynT8dL7bYZK6X1lZ+zYECpR3YPftq3ZyaFMFseNCgaAodxZp0Hw52d3HSPlR6ORAacEl+xvggBdRyzcEaLxHWR0NIsnx5cAn31EkKZbUtlfrEtZlrjvP6HKCvToka/zQT5/Bbkce3UTUEHT5TSbzQwQYl9RqbPejnP027Nv+R7Nrsh1yefq+SfKfNIlQ3eigvGqqgx7ojFIKgsu5evKBQy8UOGkVtrfDoxhsX//kjLj/SrUeR2fr6BDrS5lE5xjmnWgHwZg2T5YghP+rsFgR9/2BDfJa3j/PIbTO4j+ooMfenD6Hn0PuN5w6w+Vpwp0FioMCkEueu0ftQjCMMR2u0Vd14PtU+oGUCr/XH9RELKNGlWuYMu2Rjm2mrNA/cnMIKg+YVVuOs68nhQvcNrTrZYvAYWCMg0yI7NAapxKV5Wa1guAObSKSWoUKJCVIuOjkeZUgDyYSOejUrQKam1ApeCW7dIgO6Wy9W/9XX9s0E3lSGuy6zpj2dt78VUBcUw1b36apoPx4hpmMiPgFIDI8fJ93zARbKdtLWvbSb/3fW/YOn7GfA+644QsInMS6HrivAVggk+/VHQ8bKPFxMJ8dnXxOawPgY4qe7ZB22fv/ScDowaIjjPXuLqClPHhM/k/r1ewcSlfXy5g4IWKBt0Qyas/VIsqfF3YKuBUsKqfTxWM3kOal/fv93usihW8mwDxLEUV7pAX+cAatOvAhanCm0L0uF0oQYwM9fZ4Xnq76dG/rRD8pQun8dBOWkNvq6DiglUrlIKUgkL7hYKUQjYMQ0wmE2MB8zk8MtW2HDVo0HaD2OCL79U+VKsFgPmOtC7bwKAwKlntMyoWVT58L/uIdCcpYX5HJUb/t24RpFBU5QzACMj1em36QqPrfd/HcrnEaDQyz+DYHw6HQZrjruvw+Pho7p1Op1iv1waMse+0j3SeKhAgE6PC+0vBhxw7VYDKUik4UAbMcU5xIsDpOHHOO65JMhwKqOxkT3aMju57Z5Y9jiVBBseQz+V7NRGR1ocMC0HC4+OjYYyUStekVOwjZba0n1VeaH9ybutnnJP2swmI6XJ6enpCkiRmnZLRI9Opac7ZX3yWMoqcM8p+sBBkc47SdaBggIyCsgKs68VN8HLlAgZeqOiiU5888DyzIDDc3nbuei5UVWC6D1f9zLTmuAi5eNfrFQ6Hz1vY8nYQ8avshFovSndy8dLyHI1GCFMP7q+Argb6aY2n1fFs+8n1BGVRGIudSpJ+PWbMC8PQpH9lqlLuTbYj6gEYa4xCkIFLFGg8X0CDE9UPyfaxT20wpUFrVFJKpSpIIhOgkeYKBiho4zg2Qo0K1Y565xYu+vGVEuUY0gpSsGjHQSRJgs1mg6qqnh3Fq/EPGvnOflbFRleEsg5sa1EUg3SywNDNpP1Jel6pfPaFZsVjXymdzr7n/Ob6oMVKq7uqKnN0s1LrtjKilbzZbJCmqQE80+nUKDXHcUxMAef609OTmT8MdGNa4qqqMJvNEHQRqocawcyFPzqC4W4JeGMXGJ92E5DiZjri/X4/6E8dd42vYH1U0XPOqyWuwETBlbpw2Cc2SNNU6BwDBbEEF3RvcJ4QfDEWoSxLzGazwfZh3Z7LLZL2uLKP+74fBGKSJeB7CIQ1zgOAOaSLYONSvq5cwMALFMdxMJvN4DgO7u/vB6wAF+85MMAFx0VPCwQ4HdShiXnsIDK1fBXVsxDh2/EHAAbK1k74woXJw1OYL7+qKqycR/TXR7dA157ShNJK53Wag16DqRj4xHMFKKQp2NVaA2AEiVr84/HYRBHTh60KXA8BUoXFupxjWqjg1cLVsaKSVoWtQVIEJbRwRqPRoN1tezz5LgxDPDw8HPP9fx5LJkICgPV6bYLQSM9yZwDHWA8s4nfKCnFOaDAq/6cCAE7pcil8KfTzPDd9Ryv24eHBBK7ZrjD2BXMW6PxWxqbvT/vMtY/t+ACOBxW8RpsrSLZdDjrmTIJFZV4UhQFCBE786brOjFvXdcZNwPnBuhPQoAHK/w4c3vvobh3E/6uP8h967P6+RrBwkP4NUDYnqp5r6unpyeyUsZU/+4HX20qZn6sc0bloPwOAWQuaAVD7XLflETxwbNlXu90OTdNgsVgM3HFkQjj+VVUNrHvKsa7rBjs3FNywcAslAzDV6OE4a6wC26Zpsy/l68sFDLxQsSf4T5Wfuo6CRyk/+3u17O3//9iiAlU/U6GsgVRMTELBrrSq1u+ckFNQou2wg8f+ULtoqY9GIxz2h6OlVZwOzvlDffFTz9Z6231kP0PHSV0dFHjqOlAmiN9p39muC323sk7n6mu35dwzbUBqP0/nlA2GCES/FLtyrl/O1cVmpP619577/Vw//dSz2QbgZJ3y55xbQu9T8H38DOj2Pfoa6Koe/ee/u7pHWwFdM1TcHENNUGTH0Xxpzmmf2S4A/Uyfwf6xx+rcO36q35SB0BgmZS+AU9yILZfsdX6unvb/BL36PJ2/ypJxbC7lZcoFDLxQ4cLT7Gdc9GolUan2/WlfrioJ4BSwR+tE6TpVIPq7CgrWg3+Thtdr1dJiNDCfx1z90+kU19fXg61T9EOrH8+mH0nPpmkKz/MwGo2QpqnxPzZNg/V6bfbKk/pjrAGDlfhcpgdWv3aWjpBWM2T9DarrNT7mP2K1Wg0EN/tXrVEFDDo+yq5wvGg5sf+UxlQLJc/z4xbDz9YSWQJVAqRLwzA0R8NybDiWAHB9fW3qWde1SQurY7fb7UzeAd0DTzcM38VcAWRkyMA0TYO3b9+a3R50v9Afy7lBwPX+/ftBjgOyKJy37DvunWd/K+2v8TOcy2Q+lObVuIWyLA2ToQGNZArs4DzND8CjcM8FsJIt4Dhz14r60W2QyjkzGo3wsL9D/HoEL43Qzjvcr/boZoDzyxBVVuPh09KcHkiFRleZygIbdHE+EmTbsoNtVwud3ylA4neOM4ylUOXMv3V8bGBBxk1jezS+hqCc15Al43M51zi3ldFhHfTgJo4Z5wNzDnAN8nlkF/n3OVB6KX98uYCBFyqai1yD5qhUbIvZtsS4gHXbFpUC77P9hDbtbwdZEZSo4LGtPxV++jObzcz2NuC0TU6tGgYVURH0fW+YA9LGWZZhPB5jOp6h2zlonQZtd1SATCrEZ9rKWwtdAsBRWIRdjOa3Pto1EH0zw2i2MVvrVLlof52jo9USUUqb36lFz75kfSnk7C1opP4VyPFaHndLV8BkMsH19TWenp5M+zVegwqESk9zNux2OwDH/OxJkpiDegj2SHvTGmUgJvM/8DoqHz3Qh0DOdY+JYTS5zTnfNeeWRprbhWBrPB7jenqLGCkq7PC4eTCuCbUgdaeIznnO9y+xK6yDzh1er4pMY1RIt/NaBm9yLnNe0uXgeU8IwgDtpsX+/uiSCJMQdVVj97QbrBPbtWFb7Zx7OlfZBrt/+b/KDNtFYvejzmOdSzpvbcXNZzVNY7YjE8ARQOl6Ak7HU9NI4HpQ8MI28h6uDY1rYf00e6Tu4FFgqDsQLuXryqUnX6hwsjNRh/qpdWGqMLAte5uyUyVl32/Tr5PJBONsAjhAUe4GWdLU4vW84x72ND4GYOVFjt1uN7A0oijCZDIxR6QCJ8tBlYAuaAUAXKRqxdU/+Nj+bQs3cxH821MgGJG+Wsm6hUkFCC1sz/PQooUT9nACF35yEk4aYKSWjwpZvk+Blo6jCutzlOhkMkHkx6i7gwn+0z5i32ifUmjleW7iJbgHnnWnkmUynsPhYKx71kkBFIOrWE/dUsbncIzIKrFPGc2usQL8YVsYc7Jer58xQNpX9jrQYn/v+z5mkxmu19/CW8bIFgW6cTfY6mhT5D9l+dkg9tx8VyDI53NcqQybpjExOgQD9IWrq4CMhY4xC9/7pfWqoF7rq0aC3X67vxVgfqnv+azJZIIkTNF2Dba7rcncaYOKc+9if1GWqVHBeXSu/wkgtM8ZUEwmgf2r99v1V1aNa1WzevLaCzPwcuUCBl6wOM6RytajPDUwR6llVVQ2QDhXeD3v0cjsNE3xZvoNsqdroAfW84+4az4O2AK+czwa42b0GundAnA6pDeP+Ni9NwFXpPWZyU5zvislyEXIhaoWLBURS9d2OGwatBUA14HTe0b48oeLnW0liKDw0H5yHAeHvkLyZz6iNkQTHdA9tSbyXZWKghcV/hRaKgzVcrKFOHBUZNPJFIv6NYL7FIdpAXd0h9VmNdh5YP9w6xSFGyPh1aXC/qRFz34hhaqAQdvHfuRe9dFoZOaY+lV53jwDDjlmnuchTVMzXzme3Hnw+PiI7XY7EMC2EtQ+Yp+fU4rsC98N4Ox9oHHhHQIE3jHDYRiEqJsj48FxIaCxlZbtxz/3rnMKV8dVAaHNThEwqRuHoPfc/DgHkLVvqBDVrWErUZ1/59pkz8dzBgR/H41GuPHeIn2co0n28Mbv8aF8/0Vgou4AFgVKnEcEoLpNU4EmLXq6S1lPupiSJDFuNR2DrusMOOb7NFaFrIANmrTPL+XrygUMvEAhCKAQ1MWjip+TX1GxBubY9J898SlMVbkDQBzFiKsxgqcM6IHRZIZtsh5Y9Vy4aZoi2mXwHxPAAdLpwfjlRqMRRqMRZrPZwEq32Q0FAnQPOM5pVwS/H4/HaNsW23yL0bWLBAncDGj8aoD0qdC00N/a96dEOnRJcFuikzrw46Pfm+lMNfcA+0gtFVKewMl3bCuIc+NLkBN4IfwfMzibAFHjIv2uwC7YmfdwfOmPZ6wEy3g8NrsNHMdBnucm1bHjOAY0UHCSuo3jGEEQmDiL1WplAjmZICYMw0FSHDIMOl60ajmHuGWS8QTsp/1+j7IssVqtBkBBWRLtK40JOGep830AUNYlypsnRGmG/WgHNwRux68RlyM02R6P4T1Wq+UAzNB1pDsZbKVGRa7bM21GSWl10tg8Hpp1JLvEucR6aPpsXaO0nG0Xk+4M0v6jC8AG/gRSdI/Y7CLrdw4QaCCd53kYZ2Mkj1N4ywRuGSL9vLuFBgL7UsfSZkDUoOH6Zh/TeOB81SyVdDtxjWnqa7qqWLh2+/546BbbzsylCuYpT8+5RS7l68sFDLxAoSIATlv1ABilRaGrVqnep7Sb/Z1aNipQlWo81AeUaY5glMGBg8rfYb/dD3zbfG7TNqijEsE4A9we+6BEXR0D1a6nNxjHU4SRj90+HwgLKicGG/J8AgqYoiiw3W6Nj5ACgDkCDvEB3vQ43erVMXUuXQtc7Jq8hO2nUKXgpsLk/mbey/fxACQKOxUe7AP1HduKTQEBlQff37YtDs0ezbRE0DloJxWqtjRBeDof6HqhleS6x/wDr169GlhfGswGwAQr8jm0qDj23OpFxoCKoO9PJwo6znGLJ9Pd9v0xvkPzGYzHYxM0aM/Poijw/v17I5TVEmbfsM4EHH9ofbAcgcwS7biBH/lwOxdxk2C2fAX/IUWf1SjfFFg7q0HbbcuY2884LrbvWAG2zR7oFtEgCDCbzjCOp3B7F2W3w9PqycxpKmeCUGVmbIbAbqcCF77fVuQATKBelmVYTK4QdCEOzh6r7RJldXJJUKFqXg6+X+d413UoygKjJIeXhej+v+39WZMkSZalBx4R0U10VzNz99gyK7OWbgDd0wBNzyOI5q/P09DQvAwwNA2gN6qszAwPd7dF911FZB40PtYj7OpRWeHWL0hlIiMz00WEhZd7zz134d5Bh2R31eLmmv5czKvPufvpve8AtX6/X0tbZd4wXlhfjIsbMzAwztQRG0N/HPhx7fg7t/Z17QYGXqn5Rrl2ipdTrGzCWBFdYw2+JEDcol2v15q1nlS8O6pSpfl2+tnJftx7sVhIQ2n83V5SpdlmqsPhoHdvvlH/6UGatlT+plTr27Z25TYAFTazWylY7b4Z41RDBKJTvy5cYuuRfmIp+5G5KNW4TCv9wbqLhYMril9iAmKBSF+Zs7IsNV/MlY0ydcd97aut5svZVcrcKVVoeuo1AGacQaEoDdZPXJnRwSD/93q9UBwIAY9igfrHuiPLwYNFsabxjwNe5/N5mK+Yhub/WNHFn/G/nRWTziB5Op0Gwf7u4Z2k6vyT1McxZsd8fq5ZyHFfmNdroLCqzhkIo86dxp++UXLI1Hk31bF/1Gw+C8De7+NKjDGMLfMvuSbisYxZhPFwrMniWzVnXR3v1qqGZ6XuGS7OMsSywJ9tuVoqHbzX4Lu1jjpotph+ERRdG0PWps+DN9Yg3yFw2INL2ZPci8+7nx8Q6wCe1/36zma5PItZy1v79e0GBl6xxZZnbEXxmdhnKH1+jgEC3FPhvMXCdzqbapbMJF0ira+xCUVR6OXlRcvmMny20+mo3egoWbRULKXkWUq/uZwOxwaPhVyM8OmzC38XMN6HXxI00sVXjFL0bA0/6IT74mv3sfH58P99TGMw4IFyPl8oku12q4/Hj8rzRfBhukXk4+DCLfaturJvt9vh+GYsUGhiB4Tui3cFznjzXeaADAjpku3iEfisOWJBoMY3m00tIwAWqCzLWkaJP+81wMD3AD4+B3zvdDppvpqrNf6ofn+kQ3On9W5Zm4drgMT3SawcY6AQgwEHV1mWqVm0lK6a0jFRc99RIz+nGhLb4ecxXFOKgBp/Pt8DDpzife99bKYtZauWtEmVtdpqDFph/fmceXNg533b7/f6uPuol+ZLGEtcTbA/MahzBe17JAbQ8f0ZX+7DnPv+imNSfG6JGeJZYYTi2BNnKWg3MPB67QYGXrlBCzvFX1WX6noxKLhGL8bCVapH+caNgC+sdzaRC0xv/n/IsW6n6vytdPyYKPuu0jEtJDP+3JqH+VitVrUjRvEPuu/cn9M3LvQe73taE4xDENbNpjabTaDUEYz40vGD0wesEJSuK4w44MgVh7MNrsBcwDH++DeTJKkFWeKPxUJHwfo6wEdKoCn/SwquDw/SwnfqFhev498HXACIqAtALMvhcNBkMgnjD/VNn7bbrZbLpWazmebzS7xJlmWaDO/Ur0aqklLzzlRPL481BRH7cFE8b8fv1C9HOjR2et4+ajabhfWKAi2KIqRbThvP2i12tUyHGMBxD28Ar7h9ySr31/b7vXbjjTpv1koODW27CzUbTb3rf6tWmWuVzfU0+xTmwO8Tp+b5mvf9H9+T/cDrrJP1fq3u3VKtZk+H0UrL7eKzbB4HedesZd9DuNYAonejew2riU7JQdP2s6azOltAP7gfa98BTuzmdAveYw54fo+NcGDhLE0cyOvvOZtwjQm6nU3weu0GBl6peRSyK7HYf+0b4xpt6HRkvPjdovFrXPub77DJeR2FxXVII1RSqXy3U3VfaF+ctNvuasLBN6X7HL3UKTS9swPej2tsh7tN/PlcaBB4xPVQjByH7PQkAOF4PNYUnjMyNB8bFyjeJz53DbSheBGCPk4e/ASwoFgKoIY1wdGsxD54JoX7Xn3teKledzc508TZB1zj7u6utmaxzJfLpebzuabTqZbLZYhzqapK3byr4eFenT9PpLRS9Vtp0ZoH4ezgyuNLBv2BJovv1HzqKR8cdHxz1Ka1qQWK+viSBRKzDq4k4v3hQYG+t9yCj9mp2CI/HA56mn/SJl8pzVMVp0Kj9E6Dn75Rum4qe9fStruujYmPd7ye4h9fE77XY/ddWZZ6fnnSaXRSc9LUqTjq+eW5FvNTVVUNIMUAQ9Jnvn7u3+v1NNm+U/unkdQuVHxbat1af5ap4/NyzZC4NnfOCsT7zGMTHCx5UKkDG79GfC+PK4rH/ta+vt3AwCs1NhWCHUVLBK5HMV+z7l1ZIhz4nxZb+24NuLUg1cGBI/ssy9Tr9ZS3cylJ1Go3NZlMlGWZlqvPi8sgjFBmKCw2JiyB03vUGsdyZQx4Fo+0prnVRTU/ipCcTicNh8OaYOJ8eK6Fm4BAR9IMrxWBcpDCb/pHDAQK1wVRLKR8nJx+l1SLF2D8iuKSzkdfOb44HnfGVlKo3Bgrfb7Pd6hdQN8J8GRsh8NheA6v71BVlZ6fnzWdToPro0YTV6lU/jz2ZVJTZKwzZ0UkKVGitEjOoQBFKpWXde7fdzDmVLgrEe7D72v0dlx0yxVF7ErwsYQyJ3ul3W7rrvNGaZkqqRIlZaokOX+23W6rm/fOtTw261AAx8fBldo1Bsr3r7tiqupMl7+8PNdkwLVYBH929tw1o6DX66nfG6gsfz6/4PjzPJaJVH4OHmP3YsxseIvvx/xJCsGdfM5jbvihyqkDQAfU9AlZyh6K+3BzE7xeu4GBV2ooIzaRR+iixBHcMWXuQXiO8H0zYB1K1y1V6eIb9U3DBkNR9Ho93Q8eNNw+KMkSNe5L7YtdoIbzPA8WP89FX6GTAQLtdjukzfFMk8mkduBNt9sNwUXQ9lCXfvZ7kiShaA7CEMvfLWHu7f5raHaAiLMXbpXFIOxLCsLHldfd4mE8sHI9Fz6+npd99qDBTqejbrcbvrtarYLCxprnWr1eLwAGwBWWKn5gABAWe7vdDlX9CFq8v7/X8/NzODlvNpvp5eVFs9k5CJLMAemicFbrlZZ3L+r/UKlMSi2Sl7AG4nFEIRdFoe1+q+Xds/L8oENrp/Vp+ZnyvBZYy/jzv4NGVzxxhUW3mJ1ZYl24xezXi2n19Xqt1WihxrdNpbuW1vlM6+V5HX8z+k7d5UhF66T5+FFPL0814HItI4g1xEE8sS89/hz7zK/nMsAD7Ngr3nh9MBjobe9bDbZ3OrZ32rQXWjVe1E1PKpuF9o1NLfuE8XDQwr3Ziz5+zmx5P+Lrsed9XngOdx/697j2NebOnz/LLgcp3drXtxsYeKWGcCqKc110Fi3xA27luADz4C8CwL60KR0Bc30XIE7PxyibSPx2u6PefqLsj30pS5Q/VNqmmwBYNptN2PwIR7e+W61WLYiMwDQHIliIHtDnQitNz8f+osAATOS6k/vtAsbLAXtxIj7L+8ROVNU5Sj/O1+ZezgYwDx4ARb/dQvJYBfzwzKd08cMzh/TVrRsEvR/1vFwuw/rx19P0fD7EYrEIzIG7oaqq0mg0CgVZWFd89/7+Plio2+1Wf/jDH/TTTz+FI3W93nxM3zuI/Dj9oGV+DnBcvayugiwHS1VV/Zwd8Wc1G02dNoU2m3UYQxrj5usWwU6gm4Nm3xMei+EAPO6Pg2zuw1j6tVgfjUZDL9Nn7bpbZc1M29W5hsPD3YO687FaH4ZSu9ThN1s1m/NQbMv3Nv3x2ggef8KcuGJ01sldP/TRwWbMFrDXfN+PhmMN52/U/NRTM+/q9DcHvewetchmOh1PWr4sA0t1zR3gzJ6DEvrscx+zIyhq1j+f9XGKgwi5D+N1zVXhLpOiKEJ8loOSW/v17QYGXqlh8eETZ+O6xcLGcQHlAu7apnFB6O/H/0vXqVHugwLLslTNvKGkmSjJpCI56Xg4BrrRLVn6T//YrL1eLyhRd0u4YqGYCAqKwEKUM/S4U8OezgS4oQIhViVj5jQqYAvw4Ur7mhDy8YmjtK8JdsYh9hXHSsqtGX//mmJCKa1WqyDsk+R8EA4CUZKm02ltPmJwEj8j80Wlt+12G6ocbrdbrVarWv0LXy/xXPI332cN+zP79xxQleU5jdWVhgfb0fI816A/UCNran/cabFYfKY4XVE58+L7hxiOa2yPK/v4GbzP3Od4PGo+n4frS1JZlaoahZKsUtUslTT0mWXtzxePYexecuXvbhN/Rv+8j4cDGW9+zaIoVDUKKatUNUqdymMAlT7nfAf2grH3wDyAs4+t94f3PYbG55BrxP9z31ju+f7yz3sAL+Pt439rX9duYOCVmgsUj8TGIqf5JnE/mQsw/ud3jMC5dqzY/LOxoMDqKctS5Win/N+3pKTSSkttFpdcZvoLle90NcqGz7DpHXSA0qlQhssBf7nHU7iQcwXIswFQABGxX96FN2NbVVW4Nvf3sYyVOC0GUv55F4CxoPYWK+xrws0pzdPppPV6rU6nE17P87x2r91udy7h+3OMQbw+mFfmzMfk+flZi8VC2+225uKJrXjG3MfGFeE1Zeyvxe97/Mc1ZU5rNpt6M36ryepbNXYtre9fVA0qzWazmvK8phwAF77mvTnI9uDeOL6D/sbuIK4RMh6WC7UmHzX8u4OK5KjZ/qUGBhx8xHMex1PQly+tR7+mr1/vj38uXoOSNJtP1Zg01f/dWodkp5f1c61mR2y0sCepDkjdC/roAbPxvMfrOgY68VpxGengOwZ6/jw05EcM9G7t69sNDLxSQ1h7Kg9UN5TstYXutNg1iz+2umhfEpYoBw+co2+dTuec/nc66JS+qCzOvmo2pivgOK8fy340GoXN7IWNYBQ8uwCXA0IsjqlwYebR4FB/HkBIyViPJ4CGhFpHKHnFvxgwubshptUZS6ebY5rXxz8WcvTfLVbu4cFV7hPlnlxjNpt9pvxXq1U4OIpiTCj3JLkc/jKbzWpR+R8/fgxzQE2Ca4DF15OvJQeGDtiq6nIENiwP1qGzObHFHbu6Wq2W8qqn1ktP2qfKW0M1eo+1/eDKMFbibun7/oipb+oFAJoA4exXj4thTQF6WV+Hw0FP00ctWvNwiJTvPwf3McBCPnjKLS6ja4CTPexltGNA6uMYuw2q6uw++/T8QS+Nc1wDgaE+hljajPewP9KDvpGqRLOHR316+RjiSDz4l+/GLhEHau7r99ggX+vx38y1uyWQJxSA8nv+EjC/tX95u4GBV2osZkqFIpCJ6kapuXJn0ceKMaYCXbDFVit/u6Kl8Tf+6F6vp36/r6qqQmlaBBRKy5Wjxx/wHDGTgaDF+ucYU78myo2GUqHP9JVrcy360G63Qw0DF0wIid1uF+IZhv2h8qqvMil0SpZqtVrh0B3uyXU5kyGmX2Prw+/lde69xcINoOeWONdyHznfcUDmYAABuF6fo9c50wDqHp/14XDQfD4PY4Rlx1y54qEPtJjer6pKDw8PGud3SspU0+2TpvNpGAOPg3Bwi7UJIPaiR/6s9OlwOOiY7VUMd0p3TR16WxXFKewHWCEUGGPGPAEOAbpYvlR67Ha7gXXx9dvtdgOAWSwWARBI5zoPzWZTrXygQg0dNzO9PD+Gmhrcg/lhXTGG9Ie59Gd1QIicYE2g+FHUcZld1pA/q9Pm7qZknAAyjBPrnBRX+tpsNs/HjJf3av1pIpWJ+j+cNG/PAsN3zQKnfzBxDjS9zzHY8b3uzKJnV7gBwb1iV8utvW67gYFXbrHFhSXgSu+XqNZYaH7pHjH9HdOFvqlcscUo3O8VA40YoMQU9bV7up899g/752PhEF8rHsNrQkVSDTTlea7OZqjyD7nUKZX/rghg4NpYe1/+knGPn+WXPh9/9kvzE4M6fuLYCGcoACxuOaGgnfr9S9bRtc+1223d5fca/PROySFT+tDQsX/UcnmuWhlTv/E6+dJ94zE4Ho+abl5UTAqlVaZdtdV6sf5s3OIf7o9Cxmrkvih+lK2DCf9x1goA22q11OmNte78nQ5JT53mHzU47oMPPVZCMf3/pb39l66xL43bl4D+tfG99l78+vXPVFJSSalUJdfLO1+TNbz+z/3/pTH4l8i+W/tv125g4JUagsXpdaxW6sRLCj5Mp519c3m0rOf9Or2IJeifxypDgWDhU7iGVLZOp6PVahUOsaFPfh9oRtIHsR6om8B9OFWP/nJSnwcXekoXForT+pSsbTQaoRId9+Q5vO45wheFKZ3pZuoOZNOmTgsp2aVqFO2aRej0v6Qa1ekNxsKVKsrYsw/ig1RiReCBWVyDa+JigS52mpXT8lg/jGOWZbWAQw6NimM1pHrQIuvSgy1ZT9LloBw+n2WZ0mNTyaqp5JioM+qpk3e0XC6VJEko6hQ/r68nH0vu5+uH9yhy5Pd3xohaCyhtfjj9jrRJZwYkBQbscDio2WwGFoh95XNPv8qyVKfTUac/1rwa6qSWGr13+ra315uHB81mM61Wq7COnp6ewvyR9kmMB3POeovTgv0Z4zHjf2dcnM6PgyXZRy6HfP3FbgbWpDNH6/Vay/5U1Q9SUiVaNJ61nl6AGff2glnch7F05sbnPwb+rDn64nPr1Tr5vPc73mc38PB67QYGXqmhBF1xIAAABuTKxwvZN68f4hFbbp7a49RdmqYBHCD43fUQFOXPgOFwOKjX66mqqlCjnM3Z7XZrdF+gc38WeNDSCBmUggtXz0rgei6EUcwIKYoSIUARqP4dr0DIMcQIUGoLbLdbtR+6auxTJZ1Kx+5BxfPllLSYUfEIafpVVZcDptxNAuDiWa5RuK5MeZ3PeuBj7BN3we/UsvuYXUj6egGgxIFr0MBOs8ZFblyJO5gsikIrzdV66Co7NbXpz7VZbQKQiM+8vyaQrzFDHJzkz87nfHz4/uFwCMqHfTQcDvXmzRsNh8NwXPNms9Hz83MYu06nE04chBZfLpeh/xS8gVlxYLTZbNTJl+o3PulQddU+fdRid44T6Ha7IV0zSc6ZH4fDIdwfV8A1hsaf79o6o12j2v1sBECjj6+PmzNlsX/fXVU+NwDFj48fNWvPwjjEgYp+GquzJFyHecSVxLMhExhvl0/8eFGzmIHkWT0eg9f/Egbs1v6ydgMDr9R8Ibsgx6KLKToHA+5/pWEhSXWUzAZkg/F9XuO7Uj2QB6HojAOfcVoaJB8jcM4wIJAQawdFhjKXLhUEi6IIKWlObXuWANcGIKDI3HrFkvEDTWJlkiTJzxbmVPnv9irLQuvVOuTfX/M3xvS2N7/uNfDmAWuSAkjyOfL+u+By4QkI4TuxIMVqp/l8MfcOZPyzgBHu5dbbtTXIc55OJz3NHnUYnH3/HE/tY3iNBo8Ftb/vtLxbeHEMin+eokwETna7XfV6PfV6PXW73bDGAMIOjv15VqtVKA3uAbUoJ1/zSZJou1mp3fqjRu2O1tu15vNZYBjcHQED0Ol0QoDrfD7XYrHQer3WbrerzZWPk6+9OH4kHj+Pa3Fl7mvCQZY/ezwuPicOKthzMEtxH+K16yA53kPX3CYOXq4pcb+Wj5PLNl+/8f67ta9vNzDwSs3z4mP/fGztX/fXfd5ipezI2DejK3/f4H4vt2qlumXAfbAw3VrFGsnzPJQZdoEB20Gf3FpJkkSbzSYABzY3YMJdJZ7GCCvgiuJa8J5fj+febDbBktrtdrUiTrF14Yo+Vm7X5sKFugstv3Ys1GKh6+85m+B9covRgZs3Byp+bS+YdA18xHQ0r/tzM6Yo2Xj9xYAjpqVjpRGPlY93zAbwXqPRUL/fV6vVUr/fV6/Xq1UdjMfTc+Rhuljvm81Gg8Eg7BkvxeyKBQueYN9E0m53qdOQZVkoZOXuF4DKmzdv9Pj4qNVqrfVmrdl0qtVqFZgsV9Tx2MRj4W6TXwKssRzwfRbHdjjb4Pf39Xdtbn1+r/WFa1xbc/H/Llf436+JnHKgQPBzIzuf2UCGjD/DrX19u4GBV2iu8BFYpGVRWAZrOF74nlLnkbW8x0aPo+9jEICQ9kApPhf7TLE+uS7C133lviGJNyD+AYWFMCQ2AUUM3Y8/FQGAoPK0M6dU+/2+JH3GTmy3W/X7/fAMsBMoH1eeuGM8LsPpYheePn98360NPusuGZ9nt7Jj36jPgftXr1GhbhXGPn+u5axOPL++npzCd2vcAVTcp9jfy5p0RR+nTTrA8DXNnPq69bH2PjCuKHPWCut1MBhoNBqp1+up3W4HpXw6nUL1ShoR7dzzeDwHPK7X65DxwneWy2UIKiVVlkwBgC81IGKL1BUebo92u63xeKzRaKSykhrDH9Q4tTS4/1HzT/+kf/qnP9T2t1PkzEWI1fh5rv0kS1d2Tt3HazdW9nwWNiMG2OzR2ABotVpqNVs6HA+1mineZ89e8L3l8Q3sH173PcBYxkZKnILZbDZ1f3evSfJGjVVH+95an5L3ms/nnz33rX1du4GBV2hJkmg4HCpNL8fJspABBVipKHm3xhE4kj5D9pIC4+CC9Zr1GadxQbEiJKkMSLnkqqpCKV9XvJ7WhlCaz+fabrdW1rhds0gQYFhuXAfhRoCVp5whCGIFgwCC1oWNiH3WrtihcB3M4F6g2p5bvj53bl0ghBiDWCkzPw5CPF0Rq9TdRCg6V+TuunBwwrx7XjUWugtyxszHzoFlVVUh5dJz2l04u0KQLgyB+3QZK58/qX4wF8KcZ/BUM75DH2LL0t1AuMXyPNebN2/U6/XC2FEPI01TDYdDDQaDAAwajYa+//57PT6eaxSs12ut1+vgopKk2WwWUgr9kKvBYBCuSW2QP//5zzqdzmdr+N5M03PpaJ6VeeIzHz9+VJG09al4p53aGgxz/U031Xg80n/8j/9R6/W6tj+ZT0AIc4O7zdfJNWDgIJTmc+nrFHkRA2JnbNI01Wg40rh7p+axrVN7r+flUxiHuNYG32H+fA/xDP5Z33v870GfzL+zE0VRqJN21f14p3TRUmuca/t2FcDADQi8XruBgVdqvjFcWeV5HmhCt9qxiGls+tgP5lSo+5Zja4wWWwhlWardbgdlKikodUm1Ou0u/BE0bi0Tte99w6ohUwB6FuHh/kqnJF1RoODdwvdqebANNM98kC6WFcoWAY8CueZ35H8PfHTLRqpbMNcCEGkx9euMAM/GZwAIfk+PE3AqGWHuvnZe92e6Bgau0cQOImI6P3YfuH83njt36fizucD3de7rgPXr16A/vV5Po9FI/X4/AAqKK202m7DGsOIJRuOES/q7XC4DGIdp8TkcDAbqdDrh9fV6HdwQKLYsO5/uyXVZX9QkACyTy0957SptKem8VZpkSsutjsfz2v27v/s7ffr0KVSEdCXoDEpsLbs8iOl9B4cxcxPPhSt9/1wcBzLqjnU3/U7Zoq3j/Vq73jaALpc/XDN2K9BYz7EMieWWyzOu74BFkkoVKlsnpY2GytZJRXWqPeOtvU67gYFXbjHN7kLomnDmtyvJeJG7UPb7XLs3v2NL1xVMURRBGMb98D44+yBdwAyfc2WCcI83/bX++tg41euCLI6q96Ip8fPRV7eG4tdii8p/+/vX6NaYWnWh7P/H4xX3IQYR1+bKhXUcze2fixXDtev7WJGCR6qmf9bH8Nrc+efia2PRE3x27Rr0zYV/7DKTFIJUe71eYFgAiRQOki5Bk8x1lmVBuQJQYmXhYwc7BWD1WAOuyed837B3YMfcFYJroiy36lX/WYNWX8lxof1hG+IfFotFyN6Jx/Ta/F1bu9fWw7U5u7Y/vjSnPg9Z0lC6byo5pEp3TWWDz4Of/f7+vyv2WI75XorvGfc/dqNNVy9KJqk6o672jY0W80Vtnm7tddoNDLxSQ1G65SApWM00aNXYdxwDBU8J8yA5v5+DDvyCWFsoUOjudrsd4gWgXt0iwV3AJsvzPPhsEcgIaFwe3mePD/BaCO7/ly5KBMWBf5hsAfruVQv5PtHlftpeWZbh+7FidmHK/2QxeHwFMQjkXsf+Yd5HGUmXMrw8l7MIfM8BDH3ytCz66vQr/XLhyWmObiky/4xpzJb4+mk2m3o3+Vb93URF66Dn7ie9TC+peF66Ov6+K/J4jXa7Xb0ZvtPgMNExO+i5+1HT+UsNzLHu4jF3YJllmUajkb777js1Gg3t93ut1+vgIqmqKlShBNTM5/Maq+NxJJ1OJ1j4fN7jbXAllOX5yOgsy7TdblVVVWC/YtAEUGGMPC7ieDxqOp0G0N09ndTprEJdhjzP1Wg09O2332o0Gunl5UXv37//rOKe94+xj99jTq8BXn5YlzAnkmoutGvVDZmz5X6u9puu2r2edoOltvvLKZq+Tt044Xp+cquzX7EB4c947fnczSRJ8/lcy+WyJjuvjdOtfV27gYFXai7saAgKF+6+Idgw0nXf9TUqmP9dQMcWRJJcKH5XTAgOSSEWAGoZAEOwFUKE1Dy/rveN50aZu7VEMBBWlLsBiIGguJFbG3yHz1IT4UsWf2xdQCHHOeQo436/r7vRvZplW7tqo8eXT8Gfe40FqKrPyz37WPrc8vtL/URYxla2rxuPRRiNRhq2RpKk+W6mp+enmiXr9/UgTWdZBv2BBqs7td6PpGap4m9OWrWWIR2S576WgsZ13QrjO928q/HmrZo/DdRplzp+v9e6tapRyvHz8zdMEnEm4/FY4/FY6/Vam81G2+1WeZ4HRZq3c3WSrpqdpqrmJdsB2j3P83Cv8Xhci1NBkbsrjjECBDjgY53gy/d5ch8968zXprsJ+S6fm0wmGo1GAZA+Pj7WAvd8D/ve9zXpLFCs0FkzPs5VdS4Z/jB5o07a1a5c6/HlMRQdc4BXlqWm86lOg5MaeUO71a5Wb4D+ACocKCZJonarrYe78322xVrPs6dwBHoMZuhzvN9iRoHPnk6nkJlE8zV7a1/fbmDglRqL2BU8YAABE6NjhOFwMFKapNps19psN0FoYd27MnUF4EFrUl05eO5+7EeUzmCAflNp0C0KBAmH4QAm4mAzru11CxC49O9aMB4+Vj+HwIVSDGywAmMF64FXCAqAQKzc+M7d8F530++UTlvq3W91HB1qQCambP35roEBSer3Bxr0BkrTRMv1MgSvMZf0D2EdK1dnGPh8t9vVJH2j3h/fnNfL900t28taffwYlDgY49mTJFGVlkoyqcqqUGrW14ODr5iZcDDATxjTtJSySmpUStKk1p/Yx+zZMwR8Pjw8hGJCWPhUqMRvn+e59NTS5n9LdOwl6v+PWQgMJc3MYz263a7W6/VnTEcMBiQFMMD6orhTvGeYO38+4mPSNA2Fr9jzRVEEJoG4BQ6b6vf7+uabbwIbQ3ZDHA/k69rX/DV6nGeP5y7LMk0Gd7qf/aDGIlf/fqPj6BQqW14DlIvFomaZo/yvuXa4xrki5Ej3ix/UmnfVn2xUjaowvvGe8mvQYuDo8TK+/1x+3sDA67UbGHilhmXtlgEbCsUr1Q+paTQaejt+p9HmrdJTpuXwWZ+qn7RarWqbAAUtfR4XgJByK497uwBmY5Ozi/CgdgBWS1meTzLc7Xa1M81jocFzcIoeffU0vKIoguUHMEBR43f1jY6QppIbpz4iKB0wcE0qKxL0VVVVKOfrjEin01Eja6isSqVlpnTVVLLNlK1aavTq/eN5Y+aB52fcGcNOp6O343cazh/OVPPgSR8O77U/7MPzQZX72LE+YI8khWDJJEmUpZkah5aS7c9R1vumut3ueU0o0fF0DMI2FpieLbDZbrQcTVX89qQiOWlZzoL17gAiyzLleR4C43DzxAWViIHZ7raaDj6p98NOVaPQulzWqHvWpu8RAFyr1VK329Xvf//7QFF//PgxzB2ZFJ1OR71eT9s/JTotj6oOlcptolPzQnVX1bm+xGQyCc/i7ArKmDkDaLC2ePayPB8IhVsvz/PwzJ1OR3d3d8EdwLVZJ6wdXGiSgsKlsBFsQ1VVuru7C1k9/+k//afQZ8CGywl/Tt//Dsw8y8PjGdrttlqNthrbjpJdpmzTViO/HJDkStrZLFx17jLjNFH65zE6aZqqlbXU2HSkXaZs01Gj1wxrKQYo3Nuf0WODPLaA/z0jiBazWLf269sNDLxSi6199235CWVOJWdZprzsq/1xKJ2kQavSdrAK9Gee57XP+n2uWeC+gbEwEQjr9boWRMa1OGUQRZznuabTaaighi+90+nUqq+hyBDasV+RMfB+YwkVRRFq7MdWjisnSjwjhGiu6Ajo4rtlWWo+n+t0upzMNhwMNWk+qHFqadtcqWoU2jzM1O50tR+utdlvQ788I8IVmfvovZ/SzwDrMFTjw0BKKnVbB3XyF2132xpQki4gztO9vDkLslqvtBi/KHvbUiVpl680SAd60/hWKhOtspk+Fh9qyg5l41bfYrHQ8Xg8H+l8KrTZbmpVDhGy4/FY9523ap1yHfobfVp+qCk/5h3lvVwutdlsQsAfANKpbge1uI6kc2bK3d1dUP4oYv7vdrsajUbBT5y9q9T9u0RZN1HrLlW6vgAZ4k7oH2sCKz3Pc6XpOUNlv9/r3bt3AfSSTliWpTabjfb7failgduMtccY0thv7Nf1eq3BYCBJoUgRgYWAncFgoF6vp8PhEE6g/Id/+Af94Q9/0Gw2q7ENAATWJTEtrhQBmR4T4Ep9v99re1xrez9Vs9PVYbDUZr8O8T0O8n0tekwSoA5w4+CT+TydTtodt9o+TNVsd3UcrLU9rT9T4LFLzd0N/O8us5gx89gY5Gq8h27t17UbGHil5iwAaNh93352AKi/KAodk4PK7kE6Zjo0t6FwjxcKkerR106V8/+1+INY2fI9V6xsVnyDeZ4HqlRSqB/gzIfTpRwyk+d5uA8CEOuLe7u1iD/VafRrrAfUsUeA8xkUgV8DEOA0+aA91OD9WyWbhprvcr0M3us5/Unt+452h62Wy/MBSV4Eh3lzvzf34lkY76IodMj2avd+DmxqnXRYXs67p78+3p4+5u/TZ557un3WPt8pTRNVp0rj5F69P72RSin9LtWmf6HD3cJzwIS7h7nydeTuln5noPHzN0qXLZ3utlr3llo2lrWSyDFD4/UzeD53i/k65Hu9Xk93d3caj8cBPFDhks+TLkga3vF41Oi/G6vf7yltpDrOzmCG4FFPaeX4YkAwVD2VAj14NUmSAEwlhSBFgAR7izXJtdibnvEAg+dplMS8MN5kL2RZFooavXv3LoAzaiW4QvSx57vOCjgT4tQ5fZzOpyqHpVqjtnbHreaLebg2n4kpfPrOnLmbjj65QSJJ09lU1ahSZ5xrf9xpNr8wUA5QnG1gjfDbY5KugW93lbrL4Na+vt3AwCs3BIxbtGwCwAKodrfb6aXzpPLbQmmVanmcBx+9+wndd1oURbD0YuXpQt5pxngzQnvyXQ90cuGA4kbgoODjezk4id0JHvfA98hoQJjGNLfTzPQrdinwvwcwunCuuzcSqUilIlFaZjodj3p6fqr11WnJa/782GfuYGC322k7Xir/79vnErabpbafLgVv4mt1Oh3leVdSpdVqFah+bzz7ZrPRfD5Xmp4L44y7D1KRSKVUFYmSrO4aclBxzb3h9/F5TNNUqVIlP49TUqZK03o1S78m1/GzN5zOdreUU8Ptdluj0UiTyUStViuk2pE9ArPW7XZDnYjD4XA+hKrdVrZPdVpfTh2kMJavCTICUB6cqwCg9WBfp705YwArFMYFIEply81mE5Qv4BMr1d0TXnxMuljxsFDs9eFwGJgQ6mu44vW5iteS72n2vStXnuPx6fGzteBMgs+pj2W8Jt01wJpj/I4/76t4r1x7Bq6d57m6eVenoj6ufk//fhyDcwMDr9duYOAVG4KIUqdOofM+UfQoyNVqqdVqWaO8oeTYdMPhUO8G36m3HOvUPih/+Kj3H9+Ha8a0sG/EWECwmaDWEcKu8H3D+5GlKGWEGTSpdDmoB+WB5cvJc15elcqIfhqbK4wY+cdZFS4I8LFjUXCyIs9+Op20OizV/OZRzWNb+95Ky9nys1Q37uO1733OeG63VhjzZrOphppKH8/PmHUboXwu80HL81xvRm/VX98pUaLZ+FGP+lgrjuOgxMsL73Y7LfIXpb/JpCLRvPGkzWpTA2QOqNzNwbW9/w4ST6eT1oeVFm8/qTPuadtZarNZ1yhrZxxc2bsLJQ4yw6rmM71eT5PJRP1+PyhR6VIch9LXlL/muq7YF4tF2FvsOQclcQVEwK0Xs+Hz3NeDaN+/f6+yPAcT4kZrNpuBVdhsNp+5Q4gL8L3NyYmsb5gDrsk1ptOpkuRcDIm+cpy3rx83ElxZM4fOFviajteg7yMHhHEAn3/PXZFO6TurFwMAN0S4HmCsqs4uybeDbzTcPqhsnDS7e9TH5w9hnpBLXMuzVPwet/Y67QYGXqmhVFH+nk+OVdNonM9v94AaFjZCD+FIq6pKnXZH+XSsxseBsk6h/IdzkBP+Va7jglu6+Gyxmvlsq9XScrmUdPENIrQ9J5yN50FQm83mM+sEfytpYAhAPutjgsBvNpvBr+rjliSJJpNJLYit0+lotVqFMUEwVFUVGA4isrEuuC/Bh4feXmmWaj/dBwBBaeYsywLdDZPhisIFkVsqKN5Go6F8P1T6Tz1Jldq/2avT6dTy1Hm2Vqul7n6kzk9jqUo0+l2pTW9Vm3enfd3Fczwe9TR90jo/p4VtlpsaUPK+kd8v1Wnm2Lpkjg+Hg2bzmfb5+aTCw/QQLNdYIXj/PMW0KIownp6SR//b7XY4cVCSnp6ewry22209PDyESoCwaMQhxEp0v98HBgCr3sHP8/NziHcZDoch5z9JklAyHEBcFIWm02nYGx74x9kDZVlqNpsFYAALwBrBtVAURegzipGAye12G9gOUg2T5Oyio5Ii14Ex8Tgbxok17e5G5iVW6J7K6rLC1y/z664JZwGRK6x1vw9AykGC38uvyXvIh7yTa7R/o9ZPQ6lR6vTbgxb5PFSQdOaC+3vwra/tW/v6dgMDr9Rc6cUoXLp+oAvfi+k0PhMUSVmobB2lVqmqfdQpudDg1/oRX+sako4D+9jA1/yH/n+z0VQzaylRokO5r1lvgI+Y2nOrlfdcWEqqWQA+Tlgj1+IFEEZu/Vyj94ui0HK1/GxOXKg4i0Jzq8bvHbeyLFWkR6nzcxZFdlSxr6c8XdZBpbJxUtUupUo6JvvPqNF4/cSAwIMEvTjQtd/0L3YfxIFbKPjlcnmVivZ5dGHPd+M1Ha/1eD5iVw4AjL5hHXqqpYNmB9O/5DIDhPE5xtDH1Y/G9mf0/93y5Tncdx+Pua9P31fORHHdmE1hLOI9fm1fxvPqv735mPDd+HrXXr/2bL+mXft+URYqmkepXapqFiqzCwD2+Y3dDq/Vp1urtxsYeKUGMvbCGDGdDaWMRUJwEw0r/mwdtbTZnA9bWa/Xmo0/qfubrQ7aa7p9rvnRYx9jLMypnY4VJSkU8pnNZrUjiU+nU4i+dmUg/UwB71OlH3pKy0St3yTaaReobJ7Rc+k9ZQ52pKrOBx9hPVZVFfrG9z3OAAueMSZALaaBYR8c8MSV9PD7Sgp/uwJwS8qrGnoBJbfYpDN9P+0+qfyhkCppWc1CURfaxSrdadF7UflDoaqs9HJ40nQ6rYGQ2BKPwY6vK+Y/DiLk+Vkbfj3WWuyXdqXOtQB4zt6QMhr3ydNKff1jPbqF7CAUy5pTBY/Ho9brtZrNZtgjTv37+obKh1FgjzE+sBuceEhfW612CPybzWa1ksowF4AS7sX893q9mnuMoEH/jIMbrH8YE9YVe7jf79eAQa/XO2d+WLCpywinytvttgb9gY6nU3DrXANqzuowjjGw8+d12eKGQgyM+Ux8L6f6nTWQFAI+F4uFpm8/6fDDTmVSaFXMa3uZezo4i0tNf8kourV/ebuBgVdqXoLYlUuWZSHdiIaFgoJzq+Hh7kGj8pwGtxy/6GPyk7bbrZ5mj2o0pkFg+WbF1+3lhGMlSHAUlQIp1tLpdIK16YfOIFixypvNplRJnUNfxU8NFZXUuu+qNdjUFBHxEqRN+UZGQLRarUC1eg0C7tntdtXv97XdbjWdTkNKGDUF/FmhU+m/Nxd+/H/NmvN00NjSRrg5yHGlSVrbZrvWRutwP6hb7wvC7enlSfPGXGV1Od3RrWT/cYXgFiZz5KyO06muoH09xrSrsyT+v7MVHk3v1+A+cVVKV9ieSvjdd9+FLAHW1Wh0rq643++1Wq00mUyU57nW67UWi0VgETw9l354wCupuGma6v7+PpQ0pvjTcrkMaYSj/lj5aqA0bWiTz7XMlrVzFXgG0nFRZjwr+6Tdbuvu7k5FUeinn35So9HQYDAIbgiPGSJmxkF2v9//OW5oFdIW+/2+xuOxfv/73+vPf/5zcF/4nHKNPM/P5aD3dzq1Dpr1n/Th0081JsMBoSvzWKHztxcjkz6n5fm8187gHj433mcvTUzMAOviw+NP6nbP2Q0AtzjmA3nmaZesVweft/Z17QYGXqkhrPz4VyKNfQO7EqTSGgK20Wiolw7U+/Fe2mVKvkm1HZxzrzn5MKZu3RLifZSygwJOKuy1e2pnucpGoe1xEwKVHJTQ2HQo9f1hr6TTUHrXUHWSNtkqWGaxVRErcOkiYAiy8nTETqdTU0TEG3Q6HU0mkxBsiGXq15zP55+dnoeScGFGHxkr/41AAxgQTEZzcMDc9ro9dbJc5aHS8jDXy/ylxgC5Feb3I8iR99yijilk3kchuavFC03FrJBb3vzvY+NKwO/nY8e6jal5d9k4AIxjE3w/AERZ+6fTKawbxvPl5SUA2/l8rs1mE84Q8LG4sCz7QPG7wgEobLdb7Xa7YKkC0NJlU4f/PZMqqfXfd9VqtkLZ3HD6oClSr3KJn19SqDp4OBw0HA5DXxzYuvLks5LU7/eDoncmLU3PmTFv374NmSak/bq1nCSJ8k6uweZe7fcjtVulTj8c1elMw965Rq3HYDAuF468cIvbv8PzeJ0MZ5J8zcTg1Nci1y/LMsRz+Bp0GcTnkKvOPtxiBl6v3cDAKzUWuOdcS59XsvP0ppjiKstSpSpVaaUkqaS0UqUv++9jge4KK6aWy7JUq9lS+mNP1fumsjeFOn9TaZWuahaDU+G+EYuiONeMb23V/dueVEmbw1q7zQXQcB0/BAmrMX4GXkfpeuCjCxQCDuNxxboEdDgVGfsYPRjSrTMqzEHf0qc8z8NhN9C9TpnzvOPORIf/ranTVHr7+6EGfzPQdDrVbrfTer0OCsiVQkypcm2aj7n31S0lp0g9aI7PS/oMCMRrzcfb1xKfdSEbW33XXBpxcyBJpH6/3//MlYByhAJeLM4n0lEF0/cJY+DnB7iSZ6x3u104ayCmt6uqUpWUSlIpqaQkk8rDBaw5S+PK2VkrBySr1eUsBtxbtHhf0GcOM2McAEgYCMfjUaPRSN1uV51OJ7AbPr+SVFalyqRQklYq00qV6scROzPnz+/rzxWvvx9/ntd8zl1GxOs4/uyXGoCLdeVz5WudzzpjBei6AYLXaTcw8MrN0TVCwysDonDiaGu+uzhMlXyTqFE0tW4sNZ/OAyp2ge4bOfbTspGcHpakRImqZapqJ1WrVFl1Lk0MQyGpZhWBvrlHOESmvQ3C1993y57ruUsD5efXHg6H6vV6gfmQFATwfr+vWfuwDAhULEe3gl3xOrhxC4UcdE6sAwzgtsGC5e9utxuAHhRwlmVqnFraryTtpG7Z1+hdJ2SM8OwOCLBYXXG5FYXiRIE5W3AtiI7xZPxdUcfKPxbstJi6vpaB0Gw2z66uSlr/7Jf2FkeMx4wSgG44HKosy2C5ehEn7rfb7cKPPzPjwWdh3HCf4D7yMWI8vVJdWZbaNtfq/w+ZsqyhXXutzXwTrhG72NI0DSW7Wd9kzZBhkyRJqCh4/j/VyUpFAwLoF8AagLFerwM9D/jp9/vBrcF4OoNVVZXW67Vehh9U/a7QSQfNi2kt/ueackcuXMuOcYDoijhmldw6Z43EWQt+3Xhf+vryz7mb0wMtr4EDDCv28q19fbuBgVdqbBJoRk8/gi5lsSdJEoSLC9aiKPTp8ZMWnUX4HyXpaWzSJWDRkbM3Po+yPhwO2u636n63UzPvKn0oVeSJ0nVaUyBOafJcbEIP6kNA48criiKUdXUaD4GMAvQNPplMghW43+9rRV6w/AEqk8mkRvXTUNA+Dw6O+v1+ELBpeg7+4uS4fr//GbjwMfNgyv1+/9nx043WXq2/bamYS43fVDocD+EevV4vlOvFSvUzCOirdMnHlxRS5hgvPzkP4e3PGCtMP0eAa8DEeAlat8BcycbUbrPZ1DcP36hfTKS00qz9pA+fPtQUrwNB+sSzoay98A7P8Pz8HJ6foDpnQLCKnU3BNQAwxP1QFIUGg4GSJAnsAq4j9h3zfDicU9iSJNH+ZR9caIA1p+29BgexCSjoXq+nsizDfe7G9zp8LFSWlbJRVjtWOUmSkGI8GAw+Ow1QUnAHwhpQfImAY/YZ43E4HDRfz7RMF+dn2e9r+7Ysy89iHrw/yCaezeedvsVskbupXAYwty57+H68NgCYsIh8zuMBMDTYFzwfdU8wDn5JBt7av6zdwMArNZQ9UcBOJweLot1VVjZUJoUOh1kN5TpKJ2AKC1VSzbKRLkLV05I8WM+VgnSOGZjNZmq9aan/+5MqVTpsLgcAxSf9FUURkDfWLTXoeT6sMQS/U7YeJOgKwYXsYDAIlhsBjSgGCrt4sBaCebPZhJ/lchkUjStBLDqC1ChP64VMyLLwIDUOR4KCLIoiBJ85bQ2D0nw4aNfbq1BLu+kuKJ/xeBwqyq1Wq/CMBMUh8Bh/p4wdlDHeZFu4Jc1vvhuPg/9Nv2jxoTM0p4eT5HxewaR4q/zHOymV0r9JtRtfYlig7J2W9kA/ouPv7+9VlqVeXl7CWoWR4XN814EyGQb7/b5mLcLoEHSXZZnevHkTru2MjNe0oH4FsTK+PmMQ40dn87kffvghjOPz83Ow4oeDoYqnRLv/NVFVJOr8Ty1V2aWIF33kWo1GQ7PZTFVVBZlBvEqr1dLLy4smk4kmk4k+fvwY5gYXA/ucmAj+97kEVLuy9IBSt7R5Jgd2vo4cdAIukW+425xRcebLg3a9j/ztrAFgzD/DmHG2Ctfs9Xpqt9taLBY1ZvHWfl27gYFXak61xhR9mqbKO121p31V71tqjE7KH/ZqNBo1q1b6/FTCaxvzn/PD0RyIYBUsV0spuZ6TfO261/oQ/x/f59p3+R9FHF8r/h4WhPs4nark/Ziy9mu7z/pLlGLsV+c+/n4cf+FW1uFw0Hq9Vj/p1yh8vzcK3oMZ43G81qdr4/elufml61xr177n9w10cZIqqVKp/Jne1cUF4PP+pedxhSDVz7KP10Dcv2tuH8Yvvj7j7PN+rV/X1ty1cfO1RgPk0nx/n8GMVBU//5SJlF2u5cA9Zl+ujVecRRL7z7/UvrQf/Vniebq2j6+NXXwf7388rtfu8aX+XlsH18bEU46Z75ub4PXaDQy8UsOKxxKBft5sNhoOh2o3W0qmTRXTRMmxoeSufvgJlgzWXZZl4YAet1r4DgrG/ZZuUUr1QDzpzA5AV4/H40DFerQyQsepRVfKWPSwCc/Pz7XAKyw57uvAyH2vVHorinPFtsViEd7z892xABqNRgjK43S5sjyXt3XKWzqfZ8+z3d/fh/tT7c7Hh0p95Kq7D96zJFarVSihjL8V67Lb7QYKnnH49OlTmAuEVq/X03A41IcPH8JceIS8dPGhYrUTsQ4ocZoXt8U1IIoFGbsFnDny+/Ee9+B7291W88GTyt+UqtJS8/IpjAH99ABLp5FjJf7w8KCnp6eaO8hBgj+bH33LOALAYJM6nU446fD+/j7cE6XB86OIPRURKxxFDfPCuFdVFXz+znJ9+vSpFtdBDMigP1Dzm1TF/1ioLEqdhjsdF5fCWhyNzPdgnoimR36wbukL47ZYLEJ/fM4ZtxhM8zkHHsy3A14H3jFoC9kXBv64FusH9xMxD8gRD7Lk2ry23W7DHiUThfXPXue+gHhii9w1VFWVBoOB/st/+S//ElF9a19oNzDwSs03GEKMTbDZbJSlmbI3udJjUxoXKtJjyG12Bc4GllQT3sFSu4KCfWO7MnEB71YGhZGy7HIsKql+HPlKABeC04P+UJLu94SW9yItaZoGnzcFfgACCFJPv/TKen5PXAWUGvaAR8YMYdpsNsO59p1OJygQBCYuCMYFehEqnjiPuEodgID5ii01BGdZluFMAheiuCgajUZIT+NaTsF6c8vzmsWGK8jBGu9DBzugo39u9aKA/bAfX4f7/V4vetayuVB5LIP7Jo51ccXvoNWB4cePH4Prx10dXANaG/qZefNoc3c5sYZR9MwLAX5JkqjfHqh1zNWfLLXYzbVarwJgYz0yhjSsTQJHOSTseDzWyolTCrsoCi2WC2VZpl33vDYPq0PNpddut2t9BLCx1p1RWi6XNWWa53nIwed6fJZxYlyuKXrpUoDL3ZfOUHkkP+vd168/iwNY7uWsmrMefJb9BihwFxljwlqhtDRBp71eT+/evVOapgFEZ1mm8Xh8NrR+Xru39nXtBgZeqbERvFyspJq1U/UqpX+XqawKLZeLmsJ26+dLNB4byK2LWCH5deL+0VDoABUE7TUL0+/P5kZZ8pz0AYEi6TPFE1uJbp379+mfv07QF8LTq5BhhTSbTfV6PQ0GA43H43Cf+XxeY0ziuAo/WhoL6Zov3V0FsdJjTLBm3Npx4ADLcTweQ1EmUiNjV4SPYSyQXYH5/Mdrxin5eB7534X3l9Y0wZXX3CgxMGLc/H9iLPzoX5R/HETn9+AaPDuMG8DN+4Alz9pvNBrq9wZq/GNfxY+pOvdN6beJDsdDUMrcg6OTuRb34ZTQJLkcMLTdbmtgxhVfs9msAUGu52sd5c0acTcAP7AzKL04ZTGeH+/HtT3nDEEMBn2MfW3ELoN4frz90vqJY1Vc1kiXWCiYGo6f5rn7/b4Gg4Emk4kkhTXE/t1ut5+toVv7de0GBl6puZL0amYeUMVGwipGOcV+Zhf8Ut2PKF2EYyyEPd/ZLcM4LVG6IPz5fF7LncYy5r7+HFDhscChT65Y+O0WCwfL0D+nsCUFhE8fUMzb7Tak6/F5p/Ox3CaTie7v7wPbQREY2IhGoxFOvJNUS12UFOoWxGDF2Qqns3kfa9atYMbE50I606DT6TQIPJpbwDEYYM24onWhjTJgrTEusUCPrXf3gccMFK95fYdY4fOas1oxk8Fa51At1oW7oZifGBTxrLAJHlCJG4FxyrJMi8UiMCaS1G62VZ0aOp1Kpcc0xDt49gSWqFvV9BMXklujzUYzUOO+T2AonO4HcMOEsQ7InAEQEhzJ+gGE+Jj6+MfxBq5seTY3MOKCYvEaQAbFDIXHuTjD6OuPPf6l5uyirwsCRwE6rVbrfIrh27e1VF7GhfVAsa40TTWdTjWbzUIdhlv7unYDA6/UUCJeVQ1l4FY9goGUKRY5gjdOz2ETe/CRpOB/dGHPBnO/p29a35hY3wjUPM9DuhaCC0uITYtAdsVF416kXSFgqPVOLAFCYbPZBLcC+fx+yiHPvtvtAj3PmLjybTab6vf7+u1vfxtSvUjnm81mOp1ONcXrc+SnCjJ+DrRcMWDFuxJDiTQajUAD8ywIYmcFJIXsBxQJytgFWgyw3LKLBTMNpev/kw3B83i5Zu8f77NGfE5j4HPNknRK2fuPImSdEdXPc5PFwRhCh3s5X6x0z6ZwfzaWIy4flC1AsPfNSGm7rVNvq9WhHnXOXtvv9xoMBkHZsC6Gw6Fms1k4H2HUnqiz7CvpSsV4p+VqWQObzqy50huPxyGjBGsXy5Y59vRX99MzRrEryX9zAiPjCPOC+4e//fr+/DEoZw4d7Pg9abH8ipkcZ1n4rB897eBnNBrp4eFBDw8PNTkIuGK/eoZHmqb68ccfa6nGt/br2w0MvFKLfdhuOTuNBkUY10KP6Vq3RtmYnqLjAjhWCu7nR8BJl03tQYdZltWUIrXi/fv0CzqVfGZXmB7li2Dk3IBer6fJ6E7poaGkIe2qrbbbbQjKcusIYY4bwv2hLjBRENRybzQaNQYBlgaFuF6vgzWHQndQQ7ASddE9kI5YCcYNQAGg4ru853UCGB/mnFxyCsp0u91aFUWPN/E54+84WIy1wvvOSrg1GF8v9tkC8qR6QRj398YUs685GBBXPFyf5+aAGrekGcOqOp8zsd1ug/UXvw91TJrncDhUp9MJFSN//PHHwI4QZHrKC7XftLTarLTf7gMgccaMdYFiJb6DIltFUaibd9V6Guj0jw2luaR/ewzfi8/x4DoEvBFvwrpibZEzzzWKon7GAmt/MBiEFEKCWB2Mx1a7xxJgpMRz5uxXrMhpvv8d4LOOYvB3rbEXAADsd8DXcDjUw8ODJpNJKD52OBwCeKIKI3OVJOeqj15/5Utuilv7l7UbGHilFgttt8yxFrHOvBqZVHcP+HWcDuS3U7Lx+75B3dKL3QQuBNyK4BqdTidYZWmahkOAsB6o3Q8l68qi1WrVDv1ptVrq9/pKn9o6/KdU2UDq/A/nswiIKmcsUM7H47FmhSO4Yvozz3ONx+PgEiC4EKDlFDfvoZivUeJYYPgumUcEt1tdcQVJ+kf/oT8ZG7f4oEF5ljzPQ1aE1yFwZe39jWlehL8LxmsWf7wOYreBu5bcJeDA1tcr1/D6Eu4rd3ACsCDojvGmEVOA8vcS1c4UMQYeQNhqtXR3d6fn5+cAInnW3W6rw+GSvRArNc+KoF/M/Xq9DgGD7VZbVVJISUNVUul0OtRy/HGhcY0kSQLztVwua4xSvA8ZLwdQvV4vAEsC6q65DFgDXJu//fo+Vz6vsTL39eIKHGAbGza+dmIA6+vdi60R2/Pdd98F14Cvy8FgEOaWvQxDSAYJrA/GwLVqrrf2L283MPDfoLmyjX+8Znos5F0I+3ux0vLNJn0e3OYbNlYoKFKu6UBAughHLD1XgER7x0LV++cKBgqw0WyqnCcq1pVUJmqdsmC9cW9oQLfUEEYupBhfFCi+ZsADpWzpC4xDbLG6gqP/KDVSyTjhEcuXe7nrwKlQd/W4EIQexSWQZVl4dsABc3ENCF2bWyzHWDFfo/Lj97hubA06ePH146DDx86vy3N6xTifr06nU0s/Q2lzfwAn9/LKf75mXakAuJgbqHLAG3+jVD0Lwt0fTvH7fTkfQZI2240a45k6/6avU3bSspwHFoE1ymf9mWG6YAV8vP2zvtd9DzoojxkA9sc1WRHPt+/Pa+vJ55j15SxT/H2f32tg0YNInQlqt9uaTCb64YcfAgMCWDqdTuH45m63q81mo+l0Glx+XhSNNcA1bu3r2w0MvFLzdB2UCZsXPxk+dKeX+W5Mv8WUL5afCwr/DJ9z/198Hb82QgJhiXVdlqUWi0Xw9aNwOVDITw/0Exmx+Mi7dsutLAs1vj2qXbaUDaUqL3Sa1Wv2czpbbEl7nAOfx8fIuQqNRiOAAHzSPCMCGmHkNeHjCH5YDwAJggalgpCiT15XwgP3yrIMcQEISgS7gyeU1N3kTs1VrlNRqnyo9OHxJy2XywBMPD7Aha4rEa7rFl+cwuVrxZXANX/0NRaC/2MwGweQuZWKhTwajWoBc6zjGCx7n5inPM/DscZkDPiYYkWyFr2+gKfv+pHCvJ/neaibQR8AajBXgLrZeqY8v7hzPBOg2WxqtVoFKxfrHoCE+4P5IAYnTS8puT5muBxQpIw1DI8r85jJiRkpxpTmayhW2PHn3OL3NeSggv75OnCwCTPKYVWTyUTv3r0LIDjLsnDGyOFwCHEDzO9yuQxHfbP2kAcAyFv7+nYDA6/UPCgmtualC1vgGy6m9r5E/Tvl+0sC+5coYG/OEriFGwMEFDv9jkviSpegRahE+uiFaY7Ho8p2qea/OqlKU53KOlCJ88ljf2hszfpJh5KCtU7ju846xMrGx9Y/S1Cil9n1jAD+d2AmXYQfFqgHu/kzeR8AA6cXaff/barcV+r+fqJ+f6n1el2bJ7eKHQD4mnAB7GPnVmT8nq+VeGzi8eR1Lzvra4d16mMFyFyv1+FgKAczKGhPF/XI/AugLGv3dvZAVaLjolAzaavKLtkJAFRJqnaJqqrUrtrWQCBlqqVLnEmcieHujHjf+dpx/3hZliHw0AMFfa682JRXT3S2g5ifWopy9WW2MO6brxtv8f7ibw8q5LWYmfPmc+/NA3azLFO32w3Bnu12OwRmpmkaGBjml5RfP32SvrEXYQU4HOrWvr7dRvEVmltX1PJ3xYEVwv8IC6fVHH2jkB1tO10qqUaXXbPMYt/tNSEhfX70KBYRz0RONv49Urrob7fbDZ8FREiXtD0aPmHGACHF657mF9OpjAnAYzAYhKwFSeHUN1dA/ryMtwc9VlUVhC3jCd1PTARCsNPpqNPpaLVaBQszyzLN5/MwV/jDfZ4BCw4IHKAw/qf9z+OUSM1GU830csiVW3c+R+5fpl1TBghqgN01Je9j4mvKrUJfN856+D2waJknPr/ZbPTy8qJvv/22BpIAQ4ABFCSKkCwQPh+n6MLIrP/xqOf/vJcGUutft9RoHNXtds9nUuRdzf600vP/spVUqv/ftZSMzkFoRVFoOByG5+E+HnBbVVVgCFgTDmZ8nIk1IEiYswdgI9zFEoMBd3vwHgGGXnEzBqGsBwcTLlccDPxzgKDVailv51KSaLff1mpL0K7JkhgMOJtBlsjd3Z0mk4lGo5Gazabev3+v4/EY9szpdAqgCfccQZeAMbImYOj6/b4eHh5qNSdu7de3Gxh4hebWogt8TyNaLpfBL+oo33Pq2RRSvSxtnDvMZnMmIGYFoIipAOgbn2hmSUEYe8M3TjR+kiTBPfDw8BCuzftYcVC7BOBR/pfaC+63x0/oitoViOfmewoSvljSM+kXtLqDBqdxPUWTxil39A8LA+oRC428b444jueo0+no7u4uBDpVVRXGhjkEZBRFoY8fPwalcTwe9c27b9X9d21VR6m6S1X++QIYXNB7mirKnXXAOqF5oCljwvwwHoA6t6xiwc53nOXwMtlYazwn4MjXIdH0z8/PWq/XYW05K4b1KJ3TXIfDoZIkqRVwQhESSHY8HlUWpQ4fCu0+Fcp2ifr/uqPFcRaCy/K8q9X2pNPLVkpSTbKJ+vdnUEuJ36enpzDXsTuFjBiqGvpBOu12OxyWA4gmFoJ4Ap59s9mEawAQsIapbsja32w2wYIuikLT6TREzzsDyPzH8TU+XsyPZ9cADinpy/p4GL3RaPNGSZVoNZnqffHn0EdcVvTR5Rz3Abw4u9DtdvXw8KDf/va3QXEvFgutVittt1u9fftWg8FA2+1WHz58CIwBsRhuCOB66ff74TTH29kEr9duYOCV2ng8DgF2+L7T9JI94EDALfe4RKmjfqyzmMqW6tZ/TO+hjBDeWZbVAt+4Np93Fwd9QsBTOIXPvH//PnwPv6ekoCw935sgwe12G5QkY8G1aW6BuJ+cPg0GAw2Hw5B3DBBAUdFfhDrPul6vJSkI+vV6HdKams1myGrgORHs9AWLf7lcfkZTD4dDpWmq8XgcxqAsy1rsA5QnwY3dblfD4TDkwm+3Wy2Wc7U6LSXdRGmV1voR8uV7PT2M36h97OqY7DU/TPUyfQmsE0ASy9CFMn0BgLhly/N4Cqd0YZQAfrFbieauDKfIeY/7Aj5w8aA0mavJZHKmfxtNNY4tJetM7buGGllDaXYGgsvlMtSckM6nTrbbbeW/HSotMzXuErVGmbJjpu12q59++ukMTu+6Gv5dR4VOSselDj8rT+YENkJS7ZjpsizDMcLD1ljNU1u7zkan9FCLGWCc2AsOzrwOQQzCUcSbzSbMhQM/wCVluB3UujyImR3mnP+9D3yP/cuazfNc/dNYnQ9jqZKKxinsDWeKnE3y5rES3W5Xd3d3yvNc//AP/xBAkzNKPD/Wf5qmmkwmOh6Pms1mYT15pgCgnT3WarU0Ho9rz31rv77dwMArNQRvLDjdYvD3QPFxjIDTs07HuUXgn+dvlH78ORcg1zayMwZxKt41AQ8oQJj4gTeeXuX9BwjFVKkHOV7zazabTU3GE3VaufrDnpqts8W/WCzCvbAaeAanX2ER3HJyyw8rH4uDviG4EPiAOHf7eGBeHCPgcRhckz6h3PmdZVlQaowdMQt+oE8372q4eqPmT31V3ZOqb6RNZxPS2xzo+fphHNyFwJryNeFZAE4F+xry7zpo8Ou4UuAzPO9isdCbN2+Cq8xdCgSBttK2tv+/VKeXSvrvEjX+tqFjcc6wIMgUUIF1PXgz0Ju/n6jRyqREWm4Wgd7f7XYqe6Xy/6mh/f6gxf58KBYHHLFveD4PbGR++p2B8n+6UzXL1P+uo8P3C82P889cel4/hKA4X8uuvB3oOg3ubioYOuSHz6m7iny/xcGGsVuIe/N8vu/KxklVq5CqRGWzULmtyxvcFH6NmN3p9Xp68+aN/u2//bdqNM7Hh8MEoMw3m02o+5GmaahBgZsFAwlGo9lshoONyDii/fnPf74dX/xK7QYGXqmx8fDxslmcIo+teSxaf883cixUvbkSj32/3ujTl1rsZ0fQX0t/jHOl3Q+NsHMfPODCaxnESstdA26RpWmq8Wisu/W3ar7vqvM3mRq/KbQ/XrIxnJ504Y1ixfrwao/uc3aF1Ov1wqmI/jxu6dM37kXQ2263C6ADgOPZFNQoADhgFbu15vRt3ELMySGVTomSYxoYhFjox+siVsqsCV+30oWNYU4ciHL92MdM39xavUbZ4lpYLpchpYz+eNbN4XBQVUjFrlR5TFRsCmXlJTUPBU4dh/C940HtbivMd57ntaJex+NR09U0ALDFYhEOu4JR8WfzfZRlmbK0IR1TqUiUnhpKk6w29g4k3BBwd4nHUTijwPvsL9IifR95AGE8rr5/49d9Lv3/a+thu93qpfWo4w9HJZKWxSJE+Mdska8F1mZZlup0Onp4eNDvfvc7/fDDD4H1WK/XwSXDsxBcibsnrtPAuvUS6DCCxOgURaEPHz7UUjpv7de3Gxh4peaR9kSUI7jc7+n+O5rTqtcs55ghoLkF6FS+W6X+mn8v3uD0I6aDr1kAXh6V9/f7fQie9Pt6pgBWBUrb7x8LqjRN1W331Pyxp2qe6dSS9KbU/rQP+dsoc8/Tbzaburu7U6PRUK/X0z/+4z/Wcs55Dqh4p2a5xmKxCCc7AmqGw+FngWCAlvg13Be4Irg+gIfxosECAAZYN9KFKdpsN1oOntRrFDq1DtqUy7Cu3OL0OY7pY1dy8Zqj/zGISNM01GpgfGKA6UIcAOiWJH+zRoijgaIvy1Lb7fa8bw5HNf4+UXPdVPLNSbvTvram6D++8KI4HzXdbrcDaCOmhEDERqOhx8fHEKfggJl+xWvBWZUqK1T9bistGiruDjpVlwJcnllB+hzuB/Yk4MXnxt0KHrcDyMTduFgsAojhuz6f3lfAEfPK+/G4SQoK1cdhvphrrrmkS8lv34+wZV5FkvVdFIVGo5F+85vf6G//9m/1+Pio0+mk+Xyu3W6n2WwW4g8YEwI4Ufrz+Twcrc5ceAwGac7S5Tj2W/Dg67UbGHilRjqUBwRiEaH8sCIRtp4vjCCF8nYfbuzDZoNeyzhwAfAlACBdlHAcaMbfTvf7D4LM7+n9dYAi1Y+3RVg5wEBhuDVEXxvtTO3fJCo7qZrfV9pXh1CuFECFRcKxwMfjMfjym82m3r17p3a7HaxKygCjGL1/WZbVUpXcGgMEIUzb7bbu7+8DwAP8AQSen59rypj4hG63G9ZAp9MJitED1RCwfqTzarVSVVZ6Sj7ptCm03V7KsTpgdCWPQvDnjGNFHEi6S8iBHwobC7fT6YRnYK0x3qxJ7gdYQrn98Y9/1HfffadOp6PFYhEU93Q6vbhGcqkxaGp1PGi32gXGBXaFuJPtdqter6ckObuOptOpyrIM88/9l8tlAI5lWYbxPZ1OwfdMbRCoaOaNbJdWc6V0kKqhhk6bS9VC1j1FlUgFBHwyFwBJ5oC5lhTAH4Wp8jxXVVWazWaaTqefpRU6+MMA8TUbs4PxvmIPs8dZK56z76CDvwEvSZLUAHmaprq7u9Pvfvc7vXv3TkmShHTN1WpVY0n6/X4IpgSIwRLkeR6YBGQdjWd1F9PpdFK/37/KRt3av7zdwMArNS+BiuKJfdUIAqf0YuqP5ilEjs5jy4ZrOF3n33FXg1PCsa8xZh+uKZHYCo6FhbsWoMRp/rr72V0oOTDpdDpK0kSN35VKfjgpbUnr1TH4lv18BFwFKBP6AcUPzexFahDGjA+Bgu6/xT+JUnD2gjgDPku/UR5YrDGrst1ua+Wci6IIgEBSiDhH+LmCXq1XNUXwpfmW6qCR73tshbsEqIvPc8Vrzq+HknMWB6XgljfP4zElkvThw4eQfZEkiebzsyXa6XSCm6YoChWbdS0oFqCBRcs+Op1OWiwW+vHHH/X09KSyLEP8x2g0CrXtsfwlhVgCr4DoYAEXRJZlochRWZU67A9Kj5eYFAeSSZIEYIJh4DU49vt9zXUENc/akhTWTK/XC+vIj9mmeXqys4ixjPD16mAxNgx8f7rMiX/Yo9yPNL9ms6nf/va3Gg6HOp1Oenx81J/+9KcAIDyDB/8+QIi+YDQxJh6PwXMBWJinVqulyWRyK0f8Su0GBl6pOW0KleYbBgrYz1KPlbr0uQXvzTf1L33PN5O/F383Vuh+H1c0vOa/r33XgUfshvCf2CJxFwevI7gPp58Dsk5Z7bnc0kJwY6G7CyMO3HTBBL3p94sZEqdv42eKA8BQsp5hEY8RfmqUGX2nuT/5S/Pg4PLanF77/9oacGURs0Z+r/hvHwtvDhLdinVwiRLmmaCcPWYhngfGhbn1MQKEYFG6sqPiIcrZQar3jbFgTbl/38c6DsTlO3zP136I87D1Tj+usW6+ruNrx0A9HnO3jOP3Y3ni4NTbl2RO/J6zPewbXHLE2ez3e83n8zCv3hgnd68ARgF7MdDkOfmfefD4oFv7+nYDA6/UoMNA9FV1rm72ZvJW/eNYZVJo2n7Sy/S5ZoF41L6j+hjRS/WNDT0ZK/1rCii+DxvJrXnpYtl67q5fy6OunSKMN6+nUHnfEZpx5oVHcGOxY3Xvdjvlea7ZbFYDXFhn0P7+7IwvFHdcJZGjhyUFahbLFBrfxw2fuadGpWmqDx8+KE1TjUajwAT5WBDYWFVVoKF9TpmDl5eXINQ8GBIr6EuR/FwjthL9dQ/cdFCBdck143UXMwW+rohylz4vbOP35j58j3l5eXkJytrrcMDqML5OJWNReryH09YoWtYMB/0wNt1uV8/Pz6GQjitvVyYEqaHIvPy0j6l0qS8BVU3MDM9KDANWLzESABKehewR7t/r9UJNfgdeDhZ83qR6tU1327B2YxAfAwzWnO/XOKDPwTExMY1GI9QKyPM8FAt6eHhQWZa1czZwgaRpGoJ6WZ9ZloV6C8gaxpv5JRWVUwzb7XZg/W7t69sNDLxCq6oqBHN5YFink2u4v1fnzxMprVT+ttSiMQ/KxoWvX0u6Xg7WN3EcLOYWE++jIFxRoCw9X96DjjxOwQWLpNrGvdavOGbArVe3xBx8uCXFJn94eAi+ZNwv2+22Zpkh7KhC1mg0tN/vtVqtammAjUZD496dGo1MZXYu+MN9FotFzVVBLntMzxKljoDi/mRTHI9HDQYDdbvdECTH8wF+3G/qY+7522VZhsI87r+NqV9vsdXmgX5cH3o6Bmi+fhxU+nV8vmkOCGNLOLa2nUrnHuv1OqyzN2/e1AQ+a4xx87x83oPtYe6yLAv7zlmb0+kU6to7Y+QsUAy6mQ+e00sic1wy7qNer6d3797p/v4+9IGoeZQ9z8Be4L5U03MGgkqXBNOhMAFnMUvA/vR97/vR9yDN3X++r3nPGZ24MXYAH4qL3d/fq91u6+7uTofDIdRFSJJztdCnpydJCvEmAKQYdDqj4+dIuBxATlCYylmcW/u6dgMDr9Q8SvdyIE2pEuGdSKrqyj6m62JLzf+Orf0vIX3fVE49xp93ZUFDoPM88b2u0dVxi5VVDHic+vY4Cvx/WXY+4xyriH66IEQoYE30er1w2t98Pg+MwHg8lmYN7f9LQ0Ur0/D/mqvVmtZiKFAqWGbUScfVA7Pg0enMsz/b/f29quocE+D19t1NARvUy3s6lacAJrzozfPzcy1WwefUgZbP8Zfmwy1mZ3XiufF5idedX4vfcSyL38v/d6XjtD5R5VmWaTQaSapnVLi16wocQMMYEPgHUPB1gQuI6n8xkPU17WmKrIWqqkL+ux/pDWAkev7+/l5v3rwJBxUVRaHZbBasWObKsxR8n/u80W+yCLB6va8O8uNrMacOABzc+P9uAHgcihsNvOb9ZHyxzPv9vkajUWBSGo2Gut1uAEPdbjcU7PK143IrXnvUWMBowdjyLCRqD3jM0a19XbuBgVdqsSBO03NU8mL0JP1QqdBJs/K5lpv/zyl89416lHCSJLWyqO5ioMUbHGUQW4FuIdAcQLhvL/ZNOgWMJeYKKg52i/3hbOxGo6HBYKC3b98qSc4ZFy8vL0HgnE6nYDVxHwQvFHNVVUGIBsu8KJVumzpMpSItdJyn6uTnaoKSQm0BAj79YBmUPwoeQUdhlNVqFWJBBoOB7u7uakF6KCAHE81mU41tR9kfc/XeZEq/KbTfX/LmaQR4evDdtbm9xhJhaWGB8eNuJSwynw8Un1uhSZKEkyq5T7zOXXG7myRWdB5gKCkwPQT2PTw8hHnBdcO6JT0X4Me4sj64hjNkHkDpykS6HEgEsMAa57n7/X4toLDf72s4HIYURcaf43ZRSFSXZO1itXoVTxS5B2T6iZ88q7uHUOCAUYLs2If+2wMs473scob3ne3yOXWQ6fuUZwAkDYfDUKnw6ekpgFuyCfiepJBiSB0IZx59bS2XyxBI6wG/rGGA/3q9rgXf3trXtRsYeKXmVbPYxNvtVk961KI5V6UqCEAUIwg9Rvf8zWd9c/pvF7ZuhXlwmnSpHY7y9JK7KAWPEgblu0BHoXAvV/o0p3IROG7FeBQ214HyQ6CXZamnp6cgCBDsHmU/n8+DNV1VVUi/Iq0Pn29Zlvpm2FLn9wOljVRl/6jj7pLhAKWPsthut+H8g9gy5zfjhLBvNBqBJuWZDodD+B8rv9PpqNfu6/CPDR3+JBVPlZrdg1bHVegzY8Q64fmJaHcBjd/c/a5lWdaE8DX2iGfy+AUyGnwtSnXL3F0/uGi+RF/z210q17JjDoeDptOp2u22vvnmG41Go89cASgX9hbrAQuadQ0lzdjErIxb1Kw/1pMzD7Qsy3R3dxeAwnQ6DemevuelcxDkx48fA+jDYvb6IpJCyqCnqNIPLzr19PRUc+m4fABYOOB21sdBAOOOu4K5dBnh14Z5icGjA1Wuz75N01SPj4/63e9+F555uVzq+fk5jPXDw4Om02kAdJ5J9Pd///d6eXnRYrEIa4ZzC2AInB3xoN35fB7Ouri1r283MPBKLabC2Wjb7TYc2CPpMxAQW3yxMGVzgojZmChOorEdWTv9e41udguNe2FBQJvSYsDiACVWHK6sHACgsBxYOO3K0abz+TxYHQgaFA+uABSrC3VSxRCyThlXeaHkH36O56hOtfFwfyXKjWAzLBGuRzlUnpNDZMryXAOAoDoUFCVYa+VtWyepmyppp6ryk/anXaC7yZFnrK65GGIK2IsBuYJwwYnQpcYBc4+Q9QA1P0HSFXd8oiTK1vsTMwG+PtwidqWcJEnwr//xj38MpxqSbYB1Ll1O9fMDazgx0y3KqqrCc3ImRpIk2mw2AUR4ai2Kj//d/07MgQNlalUQI4BbijVYFIXW63UAdJKC9cppfChDAHev1wv3ms1mtfgYxs/3tStx1rG702L3YOzecwblS/EoziBi6PipnMzJcDjU3d2d3r17F1i05XKpxWIRrkVdCq/uyTwSOwEYpSYE92YPUoeBFF/WK2N/a1/fbmDgFVtMofLaNWr1mj82dhv4969Z4vF1Y7+h9Pmxtnzmmv8Y0BEL9X+uuXCJ2Qi/nlsmBAIh1FEMkoIF6Ip6vV6H61AJjesjJPkOQV9EnDsQcZ8zwgirEAHl92cuXDAylowxLgZ382DpO6Oy3q6VvdurMWnrkOx0KHY1C8+Dzfx1HzMP0nS3BGPO584n9l2oVgSu+6EZN2IcTqdToF8Rwm79upXtyorrXFvHMevlQDFN01B3/+XlRd1uV5PJpFZBkDEBxCZJElwDgBP6AlOEmwdF4WvRPxe7NpyVYI8Ajlk7nsGwXq/1/Pys7XYbGJ3dbhdO5EThDwaDkDbHd319dbtdPT09BSXK8zhz42sxHuNYidPcBXgtOJD3rn3f15KvQ15nPT08POj7778PFSABRRTRajabAZARB8B8VlWl+XwerkmcASDWgSag1tkd9lksy27t17UbGPhv0FwwerAazTecb3q+y2ccvXugE++xcWhugSFsXJgggP0QHO5JPzwOwN8nzc4DsBxo0BeEJZvbo759DCSF08w6nU6InJYuh7o4pfnp0ycNh8Na8RgEO9fi+SlPLF0EIn11K4o+Qq9Dscdz5zS5BzKRUlZVlbbLnY7vE6mS0nfn77uPFSF4OByU53kopUq/XSHhgnCLFaXOPDPHPl9YXI1GQ998802ItkagOzhCSVKQh3HabDaaz+ehr/ydJEkYK8YmXs/xmDtYjV0W/I2CT5JEj4+P6na7Go/HYY5gfBg/Z32cNZEU0lHn83m4jwMF3wPc3wEV4CeOk3HLmVoWVVXVUgcHg0FQ5l47YTAYaFBNtPjzRunoqLSXBr++n0+BAvVCXex7f+bYyo/3YswQch0UrMceuVsgnq+48JVnwrBuBoOB7u/v9c033+jl5SUUAwOIudwg5maz2dTOEthsNur3+4ERAuQ5GAGgs0+Z0ziL4ta+rt3AwCu1WMi55RjT6dLnbgAEvLsK+By/na4HSHga3TWLzO+LMIwrAzrVCjqPBXxskcQuDqcvY5YhpjmlS54yCgblw7UI2vNULihlUv9c2Lt/u9PpqCzL8D0yPLyOeswmlGUZKr8xru52YJ7cDbHdboOVlDyVmv6/9lIiDf99Q61Rq9ZfF+YIx35rqNapraJ1rAlmF3Zuufo4Mkdcl+jqXq+nLMtCnn1cUpmfTqejw+EQCvUQmIZPmroIeZ6HCHoOmmHOXIlwXVdM8RqK3WD+mbI81xN4eXkJQh/3kKRgXQICsP79+fhslmXh8wAvB+goNubRYy5iIO+uFMbTWSZANXUFOGKZjAQdEs3+w1abP53UeJOo9e8bKtMyZChUVaXn5+eQ0up9iPcRfYot+Xj8YznAc/je9DVB85ojfJ+58TnFMOl2uyGdNs/zEKvjgcTscQchHr+AWwWw6UaEpFCpkzEFSDAvzlDd2te1Gxh4pebWOr9jgRdvNDavK1anUKW6L96v5Yr0SxvYm1/H8579uwAF96l+SdDEG9CzFXgeL3/risKD7xwEeAwAfURJ8BtrCgpSOgsML9BCICPV7ugX4MItzCC0peAT5XsAA6w/KGT64JZdmrSUdH4e68Z57LykLFY8bEC32VP1nzrazlJlP1RqvW2He1wrY+1AkR+PBeh0OsESdReJu0mYE5Q97o3dbqfBYBCUPeCg2WxqMBgE1oQ0PWrH+1oFxLBmUD6xxRlboQ50NpuNnp+fdTwedX9/rzzPQ1Ag3/OANsbE428cjBDVvlqtagxazA75GnHGwy3xmFWQFJTcbrcLwA2FyD4rqkJJu1LaSpR2KpXVJZuAMfv06VM4kMjHKAb+Pv9Zlmk8mqidtbUvdprOpp+VLXbZEssg7h3HGHgAInJDUo2il85gntiJ2WwW0oL5jseLcB/P8nAlzlkQsDT+eQ90JGaAa9/cA6/bbmDglZsj7msKlYbiRbDFPkH/DALQ6U4XsAiiaxkKCBUXhv6399uVJK+5v9KzFXjflbP7GOl/3E+U4bX0J+qV7/d7jUajWsR7DEi4X6vV0mg00nw+D75avx95/yh+LBmek3gFLF7AgtdIz7Is0Jv4RYn2T5JEs9lMyShV539qK1GiYnjUenFOWfTDhpLk7B/O81xtdbRbZSo3ldJVqsa3jQCOmAuoVl87xEOk6bnyIVRtlmV6eXkJ8wGT4krxdDqFsrHOgDw+Pur5+VndbjcUjcnzvHb4zv39vXq9npbLpRqNRmAUvMgTVK8DVtYkFq6vddanpNqaZX6JH3B2B2AyHA613W6Dn36/35/n4ed1ypx7n6CqATO+7um/u7PYNwQqzudzjUajAE4JGPS1TVorFvL2uNHoH9pK3yUq85M2x10Ah09PTyqKIrhivDqhgxvvJ8806A/0cPpOnUVf+9FKySTR49NjzThwNtCDBWlURPT5cYUfpwofj8ewHgigJNaBtcDYA0xgwTjVlXgWKkG6K40fxpD7FEVRCwB14OBr6Na+rt3AwCs1R7xOy7FQY+uI19gQ7q9ESMdAwTemdDnswy0jrD8/J95p0BqFqYt/vizLYBm7PzamIX3zQjfTXwQ/lh+vIeR4PU3POdlEEOODJYCQADIUEpYddKkHhS0WC43H4xCkNZ/P9fHjxwCgKBmLYuFo4qq6HLuMgl2tVnp+fg6KgYAn2BJSHJ22ZRyn85dLbvtcIQYCCxtBSLqZ2omyv6ukaaL0XaHtaR9cCswf68czRqqqUp7nmkwmmkwm6na7QfjiXmFN7Pf7kCM/Go2C0q+qKjABgCVAGr5gct+hgGEdJpOJ+v2+Pnz4EMCFgzD6y7qJmSXp4mJykOpuM4LPfvzxR719+1Z5nuvdu3dBuRHbQcYA1jjg7HQ6BZBXFIV6vV6YDw8gZX/wrPTB2SBP+2y1WtpsNhoMBmo0GloulyGmwa36+/t73d/fB3fcThttG1uVhwvg/sMf/qDn5+ew/j1I0QGMM47s2yRJ1Gv31X0/VrJuqFOkatxdgEDsinGW0eeCcXSjxZkH5pPvOyNzOp30/Pys1Wqll5cXPT8/azQaqarOqcuTyaQ2ppwymWWZ3rx5EzIsnp+fa/EM/X6/xqTR/16vF4qRrVarsI/u7u5q6bS39uvbDQy8UkMpOHKNqXTfpPF3oX19Q7oARcBiIY1HY/XbQ1UqtdjMtd6sA5i4n9yr2+zrVB01X820WC7CfQEgTmVKZwU8HkzUSlo66qDn2XM4k9374xYL15Lqvkzf3E4hO7X98PCgNL3UKI+BhTMV/X5fkmoABUYAXyU+11j53N3daTgchnoCKEt3QbiLgQAmGkLYrRIULZYJOdFuiXqxFM+yIHDseDyq1W8pGaQ6JpU2y02wMt26li7xFUlyLtUKEKChEKFQGUNAHcqV+yJgiWngHl9SCmRv0Ij6517j8Tj4y5lPXxescQfHvMeYQrmj0GEcGo2Gvv/+e43HYx0ORxW7QskpVbPdDPuCs0DwLwOm/Dk8A8XBLqwJ36HePX3yw8VQYB6rgC8cdw3P6JVIT6eTivIS/U7JYr4LCHDWLd5bjCEK+VSdVAz2yspEx+5WZfK5i9IB6zWZ4/MQ72cHHtKFJcFVFruEWHOMC/uJtEI3SDx4GRaAAFm/TlVVYcz5+8OHD2G8ncW8ta9vNzDwSo3NhbCIN9I1hkBSqKpGJDcRynzPr41i7Xa7epN9p/6PD6pahRoP73U8nYXpYDDQm/J75X8aq+gdlE4y7fa7WgEUZyYQMHfjez3Mf1BznuvwsFI1rvTTx5/C57BMY2uPFlsS19wGXlfAD5rB3UAWAGyJpJqbhPu2Wi31ej2NRqPgImC8XYhxf4QQAOXavPl3/ZlRYrA319w5HszEPd3f6cFT1CMoy1Kb7Sb01X2hDiS5DuzKZDLReDxWu90OKYC+xgA9Hi9Ajrf7lFerVS2Snzngnn6QDmAJYJCml0OEnDFiPN0Cj5uPXUzvugVLf6bTacg40SHV8//7qNOy1Jt/nygbXtLPADrxnHtmg9PLrCcyWvgeB1ZB3/sadveDr5+iKGrHUgMMUViAx+PxqMViUcvB5xr+42Plv/0zs8VU6ShRe5xre1prvpiFuYtZK9+vjIX75WM2wb/rfZQuab/+u9frBbbEY23ifjsj5MGy7G9YAdJ0nYGsqiqACn+WW3u9dgMDr9TYLFizrhSvbXDprBgeRm803r5VempoPXrRp/RD2KRYrR5IVBQ/H4t87CrZNJQcMzXv2uE77VZbzUVHyTZTVrXUHLfCJkVZtFttHU/HEJmbpqnaWVuNVVvJNlNj3VGr1671HeV6LZ7AnwshS388WKzdbocIZDY6goi0Iu6D7x7F6YFjpPUNh0Pd398Hhcf4Y8k585AkSfD9evCSW/woTy9u45UN8ZPHzalxLEyAjytFWAaP2nYLk+dEAHrAXLfbVavV0ng8DiV5sfp7vV6gSnEdHQ4Hvby8fFa4iEI3uEsYUxQ+a4Qx9GyVXq9XO5mPdQAYGA6H4TUACGvDwdmXlJRXxqRvi8VC79+/P1PImmj/2FCxl/ZPhbJRWrPmfV75HzcA4AiLnRMJG4e2in9sKu1Kvb/P1Opc/N273a6WgcJYj8fjENmOgmJvECQKeMMNMJvNtNvtQsYGrJJT+TFrdy3+hjWy3W710/6noMyRE8RYeJAk3/OsCGcefR48jsdlFd/xuA32znA41GAwCIDH44jYYw5kPN4CFwkxBaxH5h+DoaoqPT091RhDZ7Nu7evbDQy8UkMIuWDwqGY2hgOFVqulbjlQ++NIOiUatCW9rZTtmkr2qdbdhR6nnwLNi2A+HA7ajpZK3zRVNQsdmtug5La7rTaDufpVplNnr32yCRZgv9/Xm9E7tfe5Ds2dntafNJ1OVVWVVvul8vuF2u2etqOltsdN2Lg8H1anC904yIjP+ib18YB6TpLLWecIQIQwBVzcMnBfPbnow+FQk8lEq9UqRNFDv0oKggnhge8Xy494AbeOEXRQ+8fjUZvN5rOjhf35EKJVVYWiKx7UGbMU+E8dPDiN7vERjPvDw0Nwi6BkhsNhSCN0a55+ulLAheQxBb5GB4NBrQATc8shM35s7OFw0GKxCEApy7IQT0DK3HQ6DccO05whQdnEConfxIMAiheLhX749jfqf/9OrVNbre+kk8qaAsbCJ6aE6wDkGG+AW6eda/8nafefS2XtRIPvmyqalyp4VDJknfI3ihBA4YAJoPX09BTcMKvVKjAxrBV3u0ifFydDkceGBGuIfcP6oPnpjQBP/67vTY9Lwb3lrko+z7jBdLlbDXfMTz/9FEoDuzEwGo0CAGLPz+fzcCQ54+YAkHGGKWSdfvr0KbgumecbIHi9dgMDr9TcN+mUZGwBx0E4x+SgKj8pOZ1L5+ZVV60/j5VsG2q8bWvTXYcAKYTbcrnUc/uT1uOlqqoMATVlWWqxWCgdvdd6vFBRnTSdToNAHPSHGj6/VfOlq9Nop+PdIVDN88Vc1aBS666l3XGv7W5TK0vsYMRfc1pSUs0KRWl5NDF04Js3b2pnDHASXJIkofSwU5n7/T4cbTwej4OFSjTzfH45GtoVAdHfpMShrPAVAzI8Ch/hApsyHo9D2VkEoR+Ow+eYV6ke/Y2yd+vOx9LLz7oFB0MxHA6VJJfgwLIsw5ooivMpedIlDqIsS83n81AzACXuirfb7dZ8wB5vQVQ4z4MCw5oDCFRVpdFoFP5GEZGO6DXq2QOewtdoNIJ/3sfNYxfYJ5vNRj99eq/RYKNWr6XltK1skYYxohwu1yCwcr1e69OnT4G2J3Xt7Pc/qnc30KlfqtFLpOZZuRLY6imZACIvNNVut8Pfm81G0+k0pGv6Mb4wTO42cleYPzPPAOiS6sWr3AXm4+OuF9+P7jaLswX2+31NHjlD4CwS95AuTNZisai5RWBJqqoKwBEXE82BcGxAsD8BuJw94MWPANrMuQOwW/v6dgMDr9jiRRn7AGM/3G630zx/UfWuVENNnRp7tXa5WsdUOiVKTpnSVj0nWzpvqvlirkWy+MzXWFWVprOpVs1VUIgB6SeJ0lOmqkiUHjMlumzG/X6vp8NTUCieyfCl/sfPfs3vGY8NQoBNHMcYSJ8LNBd07rdGSHnGRNzi3GdXiH4fHz8XiE5tu9/zSzEg/9xYXRsf94teG7c4BTNWVJ7e5p/z6zGvMWXvffBIei+u40rWsz+4Z2zFMkfMkyv3+Nm+NC7x32VZBgXbbDY1OA2CYkYpuFL0+YUF8dfKstTxdFT7+0TZIFWzkyntSkVxqZsQMxbuJrvWPy+I5W4XB9VfavHcx/eO21+6L+PrXbtn/Ky/1Md4LXgcgI+9s23X9lbcL6f/fR3GDNy1fXIDA6/TbmDgFZuja6m+KXgNK5IFP5vPtMyWQWiOR2Ml32Zq7Fta92barXc1xcPCd8TNZnKF6wFUxAysNit1H57U7vZ1zDfanFZBuGKJY0nQT/ylHn3tPnD3H2P9OCXudDtnEQyHw2BNISyyLNN4PA7X4jAX+jIajfTmzZtAlc9mMz0/P4codoTJfr8PqYj4uD16GUZAUqCf3fIYDAbhvTiQyX2uTrMT2U+xJKhO9xl7cNzpdAppnDSPtua6jUZDo9EoMANO0TIHZDJQv8BPSfRnJi0OpehWKnNPn5zFgD2pqot7Zb/fB6vYGQ1JoQpikpyPRYZV+fTpUwAN9N/ryqO03UqOFa8f8rNer3V/fx9YItgeBzNugRPwRmwCgG65XihrZWrmPZ1O52dk/d7d3Wk+n4c9NBicAQjMyY8//qjZbBZAyuFwCOwJY8z69fLS19aT728H8Z5d4J9l3FhTDnJcuXsmSyyLfI2wB33sXfFyLcaQ+g7EYbCPeA+XA7EVsAHUrvBaHdKZCYHFc9ny9PRUA+wOSNM0rdV6uLWvazcw8EqN1KA4MAh6neaAgffcf/h0etK+v1ez1dR6vq6dXe4R9VzLfyMUpIuwgHJzKr7VbOmwPoQT9lzo+kEsXDMWEE6J+9/475xadpcJnzscDprNZgEwOM3s7hasTp6PUq+bzUaz2UyPj49arVZKkqRmrcb0JkFPWGxEO6MkfLzch0qgI5SlX9tpfldonlXhQj+2nLguSsvzyqUzvUsaYbfbDYAMoDMcDkMsCfPm808fcGccj0d1u92guCSFyoX4/T3KnrGgaAwUMC4Hd8l4jrwDSgAZ11osFp9ly3hAIWPjsSWMG/tLugDqxWIRig0Nh0N98803yrIsBG76WJK26gWn8P+zTukP+fL7/T6M8+Fw0PPzs96/fx+C9XAHxCfpudJ2CzdW1K7kXPkDKN0SdnaMGCCXJzQH68yJuyM8HoT3fL6932V5ybxgzcTsFDLAAxcJJGScAWSABgeggF7Amp+sGY8V/WPvAAJ9zd/ar283MPBKzQNvYt+epJrAiS1438yn00nT2TQIhRgV+0aPKVxvrnhopEvF78c+2i/RtdznWm4vwp8WU/2uOMm1xkJAuPu4EGPQarXOFqsyqVQAAsvlMpTHjcc85GKfTrWIcMaz3/25bkFVBAUWMzdYqj7W/lxuQWOtNhoN5Z1cqTIdTnvt9rvPqsm5L9UtZWdeeH5OdCQN0+fcgY+kEC1P0BXWrytqXuPHYxPol68Jp79ZpwA03md8sQpRRg4MOGDKwZ2zS04zx+s6BgqMl6RgnaZpGkCOB1ReUzowFvzPmiXQlLiQsixDUSGOJKYCpQMUnpO94eslZj3i5nvb9xevfWkMYlrcXTHXWAC/Trwv+Szrweff++GgxgHobrcL2SzsA7JRJAUWzFkfn3t/HuIU6IvPGZ/3vcL+vjEDr9NuYOCVGhajR5q78EfwsClin5/TfNLnyj3esB717VT7Nb+gKy5e4/pxcFtM/ceCyrMhYuDgCoPr8Fn6SnS+pNq579CHUj37oN1uq33savt/lNq0K3X+tTSdT2tFWzhC1vsgnZUGgl86A7I87Sn7Y1fVSUp+f9AqnQdqknFhbJfLZeg75x24heZz1Ww21e/2lX3oqnxJ1f2uo1PrUk2PNYDQJLgPWtXZFCzZTqdTE4QADndv+LGwCNokSYKLBPDl1qS7cSgxK12sRalu4a7X689YFCxXP3uBlLr9fh8scKxviscgvOOYhDjGgbXu4+3v0XcHcS8vL0qSJJRp9iJRpGXmeW4BhKcQ6e5jSDYBpxACFLIsU6fd0ak4BZfLcDBUWZXh6GJAbEyxs2/chcd77GdnAOO953vsGoDi88xfHN9wzWhwq9tlAu/xHM4K+DMdDgctl8twLgbMaJ7nYcxeXl4CK+dpvP6bNeVA3jOOmMM4K4u6DXFmxq39unYDA6/UOCUtRvtuRSAQeB1hHjMJ/MbCkq6j6FgQuO/QlSP391QyD8Bjw7nPOhbMMZBwK95/+z0Ph0OgZxHe1IX/7W9/q0+fPgUwsl6vQ2T/aDSSpJ+FeFvFj6nWfzgobUrtb5u108voG5HRCCb65H7FVrOl/NDX+s+VqpPUnbTVfXeh4H0uy7IMc4pgIigOIUvdAejkRtXU4Z8SlUuplTTU/ruOms3tVQqeUwLX63VIoQNMep467/N9rNWqqkL6VafTUaPR0Gw2C+WF02ND+XqkU+ugU+NyBLFT59wHwYoAR6gD/qqqCj7v0+lUqy3PekHJ5XkeUswAIkTy393dBcU8m81C8R3Wsd/PFTnzyByxhzxbgjoVkrRYLAKQY/6en5+V57mazcvx3VmWBaAUp7nRLyzcbrer+8EbdXdDnRpHbd8slZap8t1QVVpoPngJljJrz5Wxx1fwXNdYAPa4uzl4ZncRfEnBezBn/Dz+usezxCCRPhAjICnUpeC7ZGUsFgu1Wi398MMPIb3Xa6NQTpw96mnS9CUG2NPpNMQX9Xq9ANpgDgDTyK1be512AwOv1GJLnc3uwYKuSFHGsc+ezyA4HCCQP+2bnM+QauP+PO6NtUvfaI7+XbB8iUr012N2g/773+4/R7B0Op2Qe4wgongQwOjl5UWdTuccELjbq9HqqHXfUNpJlPUTtat2OJyG+zAeFLtBYHkBoTRLlXUTNR+k8iCdentVqkJUOifmxc8J1Qn1TBwC98TyOzYPSu8bSrJU5eikU3msjQsCETaEecPfyjwAEpvNpubzeRgLYgz4njMofK/ZbCpvd5X9qavlfyzUGDT09n/+VuPJOLhVoO/3+32wglkjBAZSvAjAyPX7/b7G43FgM1hzLshZ007Dwwi9fftW/X4/xBJ49Ui3ErkGMTi+dmGdHFyhYNiLXAc6G0WKEnRWB2seAOj+e/7OO7n6yzu1fxqq6hRq/+umsmVL6Z96UqNS+X2hZXtRA5C+p+k392bfuVXuDJqzPDxbkiQhnc+LVNUyhtLrpx0yRk75M+bOOrrxwbWq6pJGSb9I8Ws0Lgc/IYNIs6S/9/f32m63Id4FBof7sEcBGKSmYkhU1bnOyKdPn2punzhG5ta+rt3AwCs1Vx7XUL/TwHzON7vThzFdjzCJQYVvavfz+t+x9RD7EmOqP2YYpLpf11ssaBwwOIvh4AcBRP8Q/EVxKfZCAFJQvI2m+v9moLTd1Oq0UVEWtfGOaVV3TTSbTbWaZxdOWZU6tfdq/F8SVWWl1XGpw+pQ84G6cOWkP69VzxxyoE9VXc472B12Sn84Kvu2oVN20HK9rAW+YcEybgQz+hryiG0HOu4rdbYCPy1W3vl9qdFoSiqkSqqqC6Xu13V2yIGrC1gCBj1LhHkBJMDu4FMnzoO55pkAOIzdw8NDTbnE68vXbbyGHWD5/gOY+RoHxPnadNbt2hqPleZl0duP/V+WpRLVAwJdSbvyR5HF+9bdbL6HYhdJLF9iOXItPine5/F3fQz42900vj5Yd/R7v9/rw4cPwd1XFEUIwoSRpNYIWRmsx7j+BW4mlyWwHbgbfN5u7fXaDQy8Uotp9JgCixVuLGz8s1J9Y7oQQQDHQTNsmmtWvaSawLjWj2uv0w+aC7dfen6+58LbrxO7FKBXsTaJSEbBzQ9zrTqrUCjHBQjC3kEU92+32+omfemPLSVZouy3ZwW22Z8pbr+fW5Vcy2lIBBufabVatUNU/AQ9Gp934eyKiiyCeB7dqgQMfInRoe8OQk/lSd/8u646902VraP22Uab1aY21zGrwFwwfj7X7XY7xMQURVGr6sjzwVyQucIccA8UAtdk/EjTiw+/4fmdDYiBre8XX5fuV+e7+JWvsVsAKgcU8ZperpbKx4/q/+6kU+Og5XamRtZQ729GOumoWfmi/eESe8LcOOPhe8FdBjT/P1buvB+DjGtj4bEJntETA6f4/s5MMNcASAcGMBP+3nQ6FaWJCRp1gA8DkKbnEwhxdaHgkZlefdTHqijOhb54dh+zW3uddgMDr9RcOcfK7xql7p+J2YEY1fMZ/6z0uQL2aH7/jPv+XKldu64r2Zg5iLMI6D+fYcOz6R24JEkS/NCkYyHoiuJcRc9P0HOmBPoaf/1utwvR+H6iXqxwm82WtGro9I+ZlErJMNU6X4Tn59nxJaPMHJDwXAgllNpwOKyBgcViUbOwOK3N6WieDdbD/bsuaBnDJDkHAq7X6+D+wC/f7/dDTQVe595FUWhzWms3OleF28632mw2tbgFwBIVIaF6mcNutxvcFVl2PguCFEtXnqvVSpKC+2e1WgULELbAsxU2m00I/szzPBz1G5846WuNdRCzVb7+4loOvv6h2FkbXv6We7p17uV9AbWbzUbvTz+q253qtD2FGJdFex6YDdxH8TOwnhyIufsjVtZ+pLEzaaxrj/GpqqpGp7NG/XnpQxzf4QaIx1dI9dLRMXiPjQiCdLfbbQh8ZY6Xy6U6rVyap2qeupqMUm1257HjuzwjrimAHGMKWPQAV2TMl4yTW/uXtxsYeMUWWxZuucYINrZkpHoEcLxZY0ovvlbsO3NBGVtDzgRcs4bcqorvcc3dwP8uUON+QMtSzOdwONSEGhHoSVIvlSspKBfuR7wAws0zHLD0ztbLUcfGXmmvIWVS0TjWfMJE0lOHwOl4gt8Q3CgkgFWWZaFAEbEOsBmS1Ov1asWc3BJ0Qc4YeXAcwX0+PghClDUujCRJArBCwJblORLeDyliXQGoqqqq5Wi3Wm01k5ayNJWal7iF0WikzWYTCtS4IvV5Zw56vV4YRwQ5/5NJQfBhnueaTCYhsJTIfd8bvm7jgDx/3/cRn/F94+v4moX8JTbCv0PRI8bUS/BeY/euWbAOZty3z/riPTcQrjEG/jm+7zIiNi78u/zPeMbX5Doxy3htHBmXND1n38CaAWBarZbK50w//T9mqqpK3/7fh2pNmrX9CzDlAC7AXVEUYa148DWy6JqcurVf325g4JVaHIjjGxml4IqU33zerxMrazano3634LG6oZxjwODAIhak1+7jwZBSnVqNFW+s0LBSfcPScAdwLVA+yi4uZMPfRLIzrsQUcN9YSaMkT6eTZs1njf+HSlmWaqO1duvLaXpkICDQPCWSZ+GaKHSAARZvmp6D6rBiUM6dTiekWFGpzZkHVz4eQwEwIdVyPp/XXAX+nFhUrAvAiXTOiEAoAy6wOAEDnrXQPHZ0/M8NqUg0+HcNqXeuS/DNN9/o8fExAIputxui+KuqCtUJqRv/5s2bMM9eCIn/2+127SyGb7/9NviYPWKd77mSjMFw7IaKmTJv9N/3gQNYX89xfY+YhfD7O8Bzlip2U8TgxVMr/ZmSJAmFoLhH/JzuTgEIOI0fU//en5hZiRlMV/gxi8B+YN15/EAsCzhjYDK5U2fZl8q5Ekn93lDJ6KD379/Xioz5TxycilzyoF1kgT/3rX1du4GBV2rXlCQ/rgAdKLjCxOJD4XjxFqcLaQ4GXKnSXHjF8QKxMootB9+InpLoPmKsCn4TZFaWZe3gHhiA2Ceb57nyPA9+dliRqqrCUbGUx3ULTFI4MKaqzofqYE3Sb6dG1+u1dvn5+vgm6Qe0N+lvVVWF1DxoSyjKPM+DIufUvh9//FGNRkNv3rwJypjDccjx9xgHFNzj42Ot2JHn9Lt1TcYFwtaBAlQ+1CxC8je/+Y2K4lwqd7FYBNqWZ4KB6fV6Iao/SRLNnrZa/7RVVZTq/SbV8Jt+DYAsl8tQZna/3wdqmqqWrPvlchlqDzAPBA5SOpqsmGazGcrNdrtdTSaTMKeASgev3nALoORgIGhxgB6xKZICRe/WdpzC6/vJ89jdmo33GdfiN6/F1LZfx69Pf6HdWRO+51jfPFNRFOFobvZbzN7R/LmuZSs5A4EsosWfxV3msqAoijB3ZAT9q3/V03f/5q3yVlf7/UHp26OeZvOwnnlWwOR2uw3fHQ6HevPmTeg3qaj0fTQa6enp6QYGXqndwMArNacXY5+0b8jYr+8BZcfjUXeTO406EzXV0vI00+P0MfiuHSl7xDH3d8sHYYjgij9LQ6hcoyWxhvkOVqyzGVl2rvg2zMfqqKtDstPL6ikUForZEgAGJWOzLAs19Uk3c0ucZ6Goib/POEP1+/MQ8e8+XFKXGEOEGUFxKG+vnoeCAcC4EIZmxx8PMPMjXuOxxlUSszc0qHRnE7gez9BsNjUYDIK1D5iZTCYBwHS7XT0+PoYx42wI98F6tb3GWOr/rqmqSNT/vq39fheUOmmIULuNRiNY/VSRZO17Xxk3f1bmPPaZd7vdULQH94j3HWXv9LqvZd9XbunzHqDB9yn7w+svANj4njM5zhzFezC22KU6je+smQOJGHgA+lnTuHUcwHrtjjQ9p4G2io7SMtMu3Wi2vBTlkurlsv1ZYqPFQZeDagwVnrXZbGo8HKufjpQk0rpaaTp/CWPDXi6KQp8+fTrXDPimp06SaLc7x+JwFHe/3w9ghpM2YdU4xwTQx74FKLMPHATe2q9vt1F85eaCiM0Ro3NnCRAq0hmNj/M73X36Xum2pfa7ro6jox6fHmub1lkB/mbzxv5G6ZIeNhwMlSSpVutlKAQS+93c2sJ/7RZDzDSkaap+PtD96js1nnsqRlsVd6cQXS59ntZIwFh8PX7neV6jEHkmFDlKOsuyQCk6lRyzLR6w52ODUnQBif+fyGiEuI9DrIzW63Vw06CIAXDuOwd0OJhyRQLdniRJoPApCgUIATRSeng+n9fGg0JI5OEj9F2YSmc3wmq1CsBjMBho8O/PrEOr09TT8zKsUQRzWZbh+oAIj8Hguq7snIp25YgAJw4CtgBACGPC93y8WdO+r1zJ+uccjNIXB+tu8fKau9ViFo/96nuHz2FNxzEHKDAYHuIxfDykeiEoyko7cIrvw/Xu8zcq/49cWidq/26j9O7M0Dgw8/XPOvxS/A+vedwO9wd8DHWn7h/upURKfsi0yy+ZNM5qPT09BaUPe+gxEl50DSBIsSFYK8brm2++CbEwAH5YtFv7+nYbxVdu7i/339daLGyyLFNWNZTsG9IhUXZoKut+XmKY77og4t5S3RLCersb3Oth/YPSQ0OL4aOkH0NJW67nv6V6ipLT625JVFWlpEqV7ptKjonSfVNZcrE6YncFVjXlSXndn8XT2K7dV7oIML6Lco1ZBFcGWP4+VwhIp2Gh4zkgCEraT1RL00s1OIQuKXdY0ihlByNeetjH2Pvkc5gkSXCXJEmi+Xwe6hM0Go0ALpgLLyKEBelnC/h9CMT0NK+slaqdXorwYJEPBoNzWubPRYuwcj0ugDHngCfuSVAZpZN5NsYH0ElBHUmBtfgSHe8gNo7F8b8dJPp1fBwcOLOm/D2/nq9pt54BqddS3zwOB3cYc5wkSQhexXVWVedCWG4s0CcYNZR5mqZqqKnjNlW5l9J9Q+27tk75KZwRQB/YTzAtMYBysBjLLpcPSZIoLRrS/mcG5NhQ1ricO+GxHsiY5XKpbrcbYgkcLLsBk6bng6KorInSZz/CHDCX/X6/xjLd2q9vNzDwyi22chEQrmRdoEmqCcB1uVDnbU+NQ1ur3lSL+SIImmvX4G82tithNltVVcrVU/O5Jx0TDdp3mrWergotV8px4BNK01PZiqLQ7rTR9m6qTmegfb7WZr8OQX5eX5/7IODcQijLMlCHaZqq2+0GH6JbDkmSBKodReICWVKtet5ms6kpLD7jrgP6ggJHKaGMUKqcgYCFw7GskoJVxOew8hHa9Bll6lXyEHjQ5WV5Od53vV4rSS5nDTgj9NNPP+n5+bmWFUA/oJg51ClJEt3d3YW5dKAjnSsBDodD7Xa7cJzs8XjUcnlmCIhViCPQPfulqioNBgN99913AWQwnght3EfxuoV5YL47nU6o/8/64DsObmKXDfvIFZLvixgUAd74rheJAjw68HblxR72133vOACJ95SzA24Jt1qtEHNCH5y9AmjWgGdjo8bvpXSbqnh70OF4COCOPnjcBjE6yAnu4QHIuEgAbjBWZXlOs1xPZsq+OyvhQ3+j9cs6xL6cTqfA8MBA4fZCgSOXHh8fNRwOQ0zObrfTt99+e45vWZ60/0nK7jK1x5cy4+12O5yc+fbt29pRzLf269sNDLxiu6b84yAcNqBTjJ4y9jJ/0b53UNZOtd/uwwZzmpOGC+JaXrHTnJJ0TA8qhjslh4b2+VrF8UIZenwB3/Xf/M1GJ6Ie4fH0/KRdf6dBb6DD8aDVehW+65Xf3O+73W5DlTKUHcoY4Uq/2u12SDFynz6CHkup2WzqbnKvcftOpQotDrMQ4MZ8eCEhjwngWtdoXsZ0MBiEw2skaTQaBbeHz2+j0VCv1wvKx/30aZrWhC5zyvhiybnSJ3NBuhw7TBohYIDnmkwmKopC79+/D6/hs0bJpmmqh4cHHQ6HAJZ8XfZ6Pf3mN7/RdrvVTz/9FEAVAAWqGMUM4EuSRIPBILgS8jzXcDjUcDjU3d2d1ut1OFsBBgjQ+Pz8HGrbwyTkeR7AQ5ZltbMTfBy9pkFVVQEMOv3tlq7PL2xFbPnyvqczMrfuqnC3Ucz0AeBhqwCX7XZbd3d3AXR6kCkBsfP5XP1+P4wfrjXSclm/aZrqafqk/rCvbNLQdrcJ6wwASt8cVFNIypkq5jeWV7Excjwe9Tj/pE13fZ6X1aHmAknT85karJPNZhOChTnciL01Ho81HA7D/QNwT1It/sNes/+wVedup86wrcPxLA/X63VwX7Geb+3r2w0M/DduTpu5Nf+lzx6PR02nL7Xv/SXNhVDcDoeDputnncZHpVWmfbUNxWLiPsXfj4WkU9y8fjqdAn3tUcrxNfz7Tu3GFLBUpyxdUV2jgvm72+2qtxup+s9dJZ1S+W9PajaXNerW++8siFTP9782Ft7fa+85y+FuEbcsfRy+5D7iHu12W4PuQGnj89Q27/u1OfP7xuPs10HheSEq/y5gBjao2WiqmTZ1apx0OF5qArjFG1vBNTdYFIn/S/P5pTn40thdU+jO0vG/r8NrNPi1/ly77z+3n73x/Ix3TMHH68Vdar5Xrs376XTSar2qWfN+3Wug3ufNjZR4rV4baxQ3cR6wN1+aE98X9NcNBJdxvFaUxTkeIT3/nOVMUcuk+CWZd2v/8nYDA6/cYmUpXQQSFgJWA5YFxUz2+304ec0pPBrWb0xRuqXigVUuRJ5fnrVoLgLNeK2P/j367Irbi/LEfnNqAbgS5zM8uwsp+gCVSfqg091+veFwGKyA2WwWrCMs6WazqXarrfSlpXIhJbtU6buL8IWR2Gw2NQWZJEl470tlfz3Ns9vtBqvWhSjV1sgs2G7PVf88KwClCsXpFhdjT/XBPM+laVPJ+56SSaHGd6WOxTF8D6uOSOzj8aherxfGDSaCuer1ehoMBsE64xQ/shL+63/9rxqNRiqKczVI2JsPHz7o6ekpWOvNda7kU1vZ4KjOmywcYNNutwNbQWooQXCsoV6vpzdv3mg6nYa1zFqDxiamYDAY1KouOlXusR6AUT+0KE7VZA05IIB9urZ3fT95No3/RmlxzThewFk6+jGZTMKpmrhEeN/LWNM30jBhCahGyVgy1o1Go5Z6S9YLlTop4uXrFtA+GAzCmDoDt9vtAvuDfIr3DevOsyt4DUqfLBRe59rcn2yUfr8f+vf4+HhmwP6+o3TYVmfc1Km516cfP2mxWIT6IARX3sDA67QbGHilhpL3CGgPwvLgoeFwqHHzTr10oIVmmm1eNJ/Pa3QjLoDYIowFGK/FqVUIJoQhG5UqeXye+8SR+g4G6APXQBgQGMU9HVC4QPXPImDpI4qLQj1JkoTSvg4iJuOJmodcOiRqjlta7hbabDYh2j5JEhVlofTdScmxKbUL7Tp7nWanUFqXoDuEE6mF0iVgzX3gFOyhfvp6vQ7f83KotH6/HxQilCcC2Z8FAMPcuTIDXLUbHS3+8aTNPxZq3qdqvUlVJZfCSAhhagx0Oh11u90gmN2/yhyiWA6Hg7799ttAFVdVFdIOWcvUf1iv11qvz3Tw3eROxZ8b2v/TSc1JpuE3A80bM0mXXH3WDHPjwV5Q49D4ZVnWfNFVVanb7alT9LRfHaVRGoCAl+Tls07DoxgcMLAOPR7AQSkN0Md88HkH0yg/Zzo8HsHXfGx9czjTmzdvgi99s9losVgEJepKFWDhayIwMz8DJgo/8b7H9rDWWGe+x33fM/fO3HS73XNcTNpRc5froL1mx6eQ0eRj6LIJZQ+4dncloIX+khaIfJpOp+E1XF6n00knrdT+pq1TWmq1PgNbYiva7ba+//77WrDwrX1du4GBV2pxFS5a/FqSJBrmY00+fq/Gqq3GQ65icAxRt3zWI+353rV0KrfaY8o77ge/XYC50Go0GhqPxxrkI5XVSYv1Quv1ulZV0FssDFxI8j6Kn2dxahPfMVY5iis+3KTRaEibTNv/kKpYJWr/Q1e9b+tBZSiWWfas9m87KsqzpY417+mbHljmBZtiOhaLnqA2rFbmm+C+mLr3WgNO9/pYeGCazwFFfY7FQY1RpixP1RpnKtKDtpttuB594TmkS7AW4Arwybo5nU6hSmGe50FowyZgzbdarWCV89kQKT4oleWpsoFUpqcQ54FyopAM9yO4jyJMnEvB2KI0GJ9us6/t/5ro8Jyp/duBOv2ZXoqX2nq7thZd6cf0/y+5H5hzrhkDPFfw8TX8fb8/DVap1+ud99XPMREoaZ//2E3gSpxgVcACDBp7w0EKv3ktBv2+3mNjA4Ml7+TKX+5U/aGjZrtQ+vtEh9EhnF/hrEw8Ht7ou4M4r9UAMKB/jBegnD1CFgtHYDsDsVgsakWhbu3XtxsYeKXmATQ0p8sRpgTHJGWqqpKSMlWSXPKNnS52ai4OHuT614Qiiv2agpPqBVocRAyHQ71rfK/e+3uV7ULNh5+C0HYB7H2KLTHuxW9nMtzPR416KHGsVA/k415FUeh4OKk6SVUpqUzUaGS1YkOk281ms8/cHQgL6gh4kZxYKKLQvL6+u1Vwa/jxw7AIsDBkDXhZ4zieILY2EeIIvvVmrcm/nmjwdx0V6Umz9fKz444Hg0FYV7iZCJhcr9chA8DBHnnZDlAoA01gGTUTcA2gjPaHvZJ3qfrf9XTUXsufg//c70spXVggr/pHwCL+Zi/RHUDTqVB5SlWVUlI1znvF1q4rONYHa8TdUB5v4+McM1h8nnX3JSvzS9a/v+avo8w8b96D+nh2d0t4X2KQyJqC2YJSh3nwfrOWvD6BA3T25fF4DK4a3FdhLstEqqSkStVpd9Tr9YL7hc87c+iAJO67uw7dMJAuctMzgrrdbmDkpDPIfXl50Waz0WAwCO6LxWIRanHc2te3Gxh4pRajZLeAsYrYCJvjSp13z2ruO1p3Ftrs1leFUByAFWcKgKQRhl7j3jdmLKycxvM4gEbWVHPTVbJsKts21L7LA1WJoHVr2ptbHQhst3z8WegvKVTU4Ufpokig5suy1N34Tv1/21N2aKiYHLX9OVBqOByq0WgEi9jZBsAF0cvdbjf4WqVLLr9bK1D9XsgEJebzDF2LT9UPZ1mv15rP58HSp0KgdHELMKbu6w7rY7M5B2c9ZCqbJxU/K9R2u63VaqXtdqt2u613794pyzKtVqsQhY4/lvSxPM+DdTYcDsO9VqtVSNHK8zysUXzFCGSnqBeLxc+nEs5rtDNriHGCCaAUMtHl7AFSRl2xs26L9Kj+v+uoWGQ69jdKVpda/azTeL+x9hhLqH5nTlzJOrDw/eJgwa/tdD+gzxUj680rYuIeYXyZF9wefqKlywa+s91uA0gGOHghL/fTD4fD8D9AASASgzXmlfHEEq+dI7HfqTleqJX1lORS1TmpdWrV4pzIQnB55AyHyyXcGMw1lj+f9wJIBCV6Gi7Am/LhaXpO951Op3p4ePhMFt3ar2s3MPBKDZQufR445/7/siz19Pykdb5WmmY6zY9B0bhwciGDFRfXNo+ZAbc8EeBFUQQfHM1T7XwTrzcr7YZLNe/aKppHbbSsBdxxDxeQNFf8PDM0piu72CeLPxrlKqlWlIRiNf1hX3knU5JUenxcaLffKcuyIDAQ1vjQARsoprIsQ3AUFsfLy0u4Pv0k6K/T6Wg8Hof+EmjF+CGcmDfiCRgDFNe1Kox+4iDXhDrudrufpeBRJ4A8dGoszOdzdTqdcOKfp53BrqCEqV8wmUyCJVmW51TDQWeo5z/PdUz2KvIzIHCh6yCt2WyGNDHmDZ9+u90OR/sC6KjJgPvDi+BQQMbHt1Kl5O6k5n2qzWynRiMLB0FBlTstzNpkjnl2b/v9/rM6HQBTFBdKGgXrDcU6Hkw0TMcqs1Lz44tWq0sKLesPsN3tdvXu3buwXjx2xBmZqqoCMANYZVmm0WgUQAffYw6SJAmMD2uReSa+BfcW/WfOATxUCfz48WMYD0DIer3Wqr1Sr9tTM23qOD/WYgxchjhA8zmBbcKdwWdJTfZ0VuQVsTDL5TLED8B0FUURAmCrqgqBq8/Pz6EWxq19XbuBgVduVVUpz7sa9odSJW12ay1Xy4DcsWLIVb/WnOa/Ru3zmdjveI26jGk63uNz7rfdbrea9Z+0u1vrVJ40m00/YwHcR+0BVH4ft8rdF8rGZzMjgIk49vMFEJStVktvHt5oPJjocNjrcDqE8YSGRjBBaSNoEIAIIyhaP+sBCwlBTrYAfcPPiaVLrENVVeGwJE4IJFbA86WdBvf54DXPm2c+ACWPj4+h/gLgjlx7jwOgkiDPIynQp+5Hpk5CmqahjHGn1dHsP+40/V9Oakwyjf7nVgAlLsChkHe7XQAdzDWKCdrZyyD7/BNlTpCaW9bEGgDYut2uirKorV3WWQy23aqOASp7x8cZ5eKMF3/zTHHr9/t6KL5T/tNEVeek5FuFkr/0C2A5GAzU7/drDBDWtLsLPS7I2QuUt8eZ+F5ytwjXdjAECHWXmz8v8+IACReSGxPL1TKAaR/7JEk0Go1CxoxnGLlx4eCZeWZd8lweU0BfWOfuouTH5V6apsEdd2tf325g4JVbq9XSw/BBd6vvlR4bWk4eVenPms1mkr6cN81v33TX/PDe3JfK/9de8+tcu7dvstl8psPhU9hwUL2SQoR53O+4P/Tf/YPuJ/SNHXzFPyvkuHXaHeVFXy//z72qZqnOv75EhsdgCGEfZ2LE/ktnIOL0LwdUDm4ABHwWBQY161aXCzCf22tzFscsuDDGHYAiLYoiZIPQF8bOFUHcf/fxYlVfovgrHeaFim2ltJlK5bkfKCOno92KcwHMe541EwNTfrB+JQX/t69Tru/jFq/n+Pr/XPMxp58xkL32HW9ZmqlxaCnZ/xyIWl0qBKKQGQusWr+HpKAEaXEMgys5/5/mezW+tscCxODfgSifBYz4a4A4Pn9tfzP+DrDok9/jS6xhbJzEgNFBUfw+4+sgyeNObu3r2g0MvFJjcTebTXU1UPOpL5WJ8vZQ7Va75oP2hX1tc8RC9Jq17wIOC9EVot8LweRWFMLc6UMPBJLOwOZ+9EaT4o3KtNS8+6RPzx8DBejRzFg03NMFritlp9GTJAnKIMuyQIsTQwD1XDym2v7TUWlT6v8uV7/fD/fwkr8oGq6DWwWhcTweQ6CipJCv7D5eFDtUN4q0qs6nqvEc+LFdwXpQoQsxF+ooROaLdcH36B9Cbz6f19IYUT58hswLfL/9fl+SaoqO56d+AO+3Wi2lWaLmbwsN1VQ2qrQtV1q9FKFcMSWXue7hcAgBXKwfmAvWBLEJDkRgXUajkR4fH/X8/KzVahWYGJ4NPzlAlL4Si9BsNrVarWo+egcb1xiCmM1y5e0K1hUjjefY7rZaD6ZKlOjUPGhRTGuMEmPBSZlFUYTCXoyL73WvGQBF74wBsgHGxRWx73mOo6YfXI+xooS2Fwdi73Fflz/0wy18p/QZQ56p1+sFRsfBfxzM6TVVPH7A46AAFnExI/oMIwYz4meA3NrXtxsYeKWGQCmKQrtko+5wp+SYad9eqzyVnykH6fNqctea06EoMRro2C3B2Mrg9WuuAum8CR/uHzTMx0qqRKvjQi8/V0Ds9Xoan94o//FBSVap+r7UMl/USpy6QHaB6pvc6XIXaIwHfk+ugUBqtVrq5B11v23r9PGopF3p2NjpuL1UWYNWBnwQW+FCyX3BzgZAfztV7ONDf4hBIJbAFSCCCVoTtwPjHs8xlilzy5qh4TbB2u73+7W6BG5d4TJwP7QHceKPBzQBfFAWVK5LW6na//1ZgW1352vGigylIF2sX/rOM+PzjX3p3I8iRDwDygyF5+CtqqrQX6eVfU3FAMCbKyb/n7GhOaj2vcQapj9n0PVn9bpn19n8cR4UL+PR6/U0mUxCjISXqXY3Be4kV3jUp4jdVoBN75cXDiIYkT3p4BVw7DQ8/XXlyjjQL0nBgIjji/hN1om7t9xi9/H3OaWPtJgB9fddXnrgKGNCIOQNDLxOu4GBV2673U7Py0cdxwepSrQ9rbVar2oKkYawueYOiCnDojgX3Bj0zoFWy/UyFCqK2QRvMfNAc+v/rv1Gw/ffSKXUfPekXb7TZvvzgTJppSStVGWVlNRrBcR0nlOX/ky+qd1idWCAUnNlif+5OZQ6/7eTTsVRi8PlvAYEacxIeKCTW36xn5lxyLJM3byrZtbSsTjoeDrWzpFHmDvtTmVBBJNXy4v9vD4XLiAduDEOKFesf4K6UIhuYcLQ+DN5ACFuF65J8B+KBraEMXDlQ2wBFibpcPQVPzKBa8xDWZYh4NFBgwtxZ20cTFI0iWehoAzzyTOzH2IwELtaYvDwJbdC/LqvHQe1ZHI4pS2dwVGn0zkXExuPgxvF8+TdvYH1CyvCmnXF6vuaHyx8Yle8oh/P7GcncE8P8vP7xJH+zE9VXQofsY9jAOWMH2uEMfP9fw2wOfiN3/N96i4Yfyb67cGot/b17QYGXqm5MF1v1tofLkd08hvKnsWOUpPq9QEcVbM5+v2+Jv07jddvlRaZ2sMnVVUVLGPvg1/vGmsQb+RW2VGybkqV1Dp2wnWOx6PWo5n0m0qFCq3SaRCGrsili0AF4CAcsIjY1DElGWjYn+loKHoKBR2PR316/BQsyHicOFHQ86URcN1uN6QcMgYc+pMkSTglsZt3NTjdq3rfUGt0UPZtoUbzcmwvfUuSJARMEd3uc4u15Wlb3me3lpmjmNYmswHFTblgL8HsqZdOG3vONdR6TJdTO2C329XmudfrBSFLfXvmhTllHKHvsT5hILwmAVS0R8mTLkdQGooJEIPCpT/39/fBCqUYkqRQ/AbAwTrD5YIyjgGj71Fnk7y0NN9nDH3uHFR4qi0sznA4DAcskbFCVP/d3V1w6bBe6Q/WO9d1C92Zsiw7Vwj0EuAeq8H+8eDSOH7G2Z3YHRGzdi4nfPx4bkCGVxNk3XCfuBgaY+/z5tdm77r8Y1zieAgHHLf29e0GBl6peeBWXEzFg6pitH3Nkmcju3+31+upc+yr/WkknRL1GidNG8+1NCsXKJ77zcZCeHieb1EUWiZTZW/bSspE685Mu9nZyl0ul9put+q0n1RWZThSFjDjFhSUO2OAUvazFmI6Fn8mggWqdLFYBKFBGpILTwSmn86GQAJAoPSuKV6ED8ojb3WV/NeWqk+Zmru2hn+f6pjsQynel5eXGoDb7/fBWudZ8aPT59hlE4MBgAvCFIsMwb/f77VarZTnebC+WWfMq18fqw7h63MMwCqKImQCkIPuPur5fF4DVr42PbNiv9+HVMDD4aDRaBSUflWdTw0kO4TTEVHwHJE8mUwC8EiSJBTlIUODmAxS2prNpiaTSUid+/TpU1i/npbGXHtwXVzYxhUa6yWOmUFJu/vK133MxAGIKAzEmFMmmrllXVCemPv6eRbv3r0L6ywuWFUURTAAyrIMbhRfi85auKKXVKuMmed5YIzYP76evNyzP3u8lygvvV6va8aCGwgeI+BsIv12MOHGjcu2GCAAkL7E+Nzav6zdwMArtXjTuXUBOqe5kL3mOvANyGcOh4PK4UllflRyzHRs7lUeL5sUod5sNjUZT5Q3ezqVR81XM02n0yDgYr/o4XDQ8/JJ++5OSZJqMZ/XCopAx/EsDmScwvNn5xk9iCimaR0I8R738QIqWJD87QrDhQHjheKAZndgxfdHo5G6na4aSUuN9s9BVHeZjutE2ajS7rDVYnMeh91uFyw6n6PYj+v+e/qDYondGB6ZH/tVPZL+dDppNpsFi9Aj1JlrgtC4N0wJqYCMh6Tg2kBhcy0KMQEUXegTROj074cPH2puAR/vyWQSakekaVqrbpjnuRaLRShOtFgsagLfYxzOxY1atR+Ayt3dXahi6GsIheYsU5IktaJfgAK3oLmnu6n4HPMTB8QCPHHlJEkSqH+v/hkrVtYg8RPSJauC5ymKIjBjPKczKB6ngRXua4wf5FLMXgGgkBkuuxhPB1nc2zOJ2Pt8j/Xo40x/Xfaw95ELXoPAP8P7/kyst1jO3piB12k3MPBK7Zr1gDKgxYvd6TCuEfuzuc56vdZT46PK705K1dB0+xRoYBd8/X5fb6rv1X0/VtE7qDFshDPrnd73DbpcLmuFO2KrJ6ay/W+/JkLWX3clGl/HwYKPA0oEi8eBBAoLIeAnq8XjhmvBlVWaphoPJmr8NFD5MVXrt1LyN0clv9ur8VbaVVstHufBGvd4AH9m2AiaB7lhabvQ4/lc8V/zbSMYJYWDhbC8YTL4HofeUPcgTv+LLUIX+nGKlpdWdrcAr3uwGxYs7IrHFvh1GScar+FiobqhrwmvCQFLwvoCDIxGIz09PYVI8hhsxoDXFfw1xReveZ8PB63x92NQ4OOJ1Q6QxyhAqXmhK2cbnP3ix6181prXEYhdIM4OOBvp8oi95QWXYoDuga6sS89scaDE+nNg5H3x8fRx9v5dK+lOX9y14KDMAxxv7evaDQy8UmNjILBdqLB5fOPzuiuKWHn6daqq0sv0RevN+XAcP7dAugjRRtZQa91VsmooOyVq9Fs1ShjleG3DcR0XrLFF5c+HIMAycAXpCP6a8I2f3wU41ryPDcFlSXKuyIfS9eAyFLJbJUmShJK89KOVtlU8Zyrn0uGnQuX9RqvNUqvVKtTO51nj68bR1d5HVxoxGxArHn/Nx9vXiB9fi6JN0zQwFpJCCiBuAa6LC4a+c5Qtfn23Xjn4xq1HxjAW0MwAN7IjAAAPVUlEQVSTg7RMDe3+a6Xd6aj+3zWVd3Ltfw70ZJ2SZQDAQhFhxRMZ7gqLdQ6VjeIj7oCxY7zizJb4b193rG0+wx51xRwrYaewfX9KCkF9pNil6fnIYqfFGQ9/Fklhrvy0wtr4RrFAXigM0EFzX7z30cGLjxnvX2MvfV9xH9xBHpQIQGc/OlvJXLsM9PgTZ5zcnXANrMWsgV/n1r6+3cDAKzffIAg+PwvALWcvZ8trsXXoVJxTdbFCQmBst1utuzMNJw2d8r122tRQP9d2+tYFJorA/Xa8hxByBU8fvO/x+y4EEC6MiQslFBnvozSp646gwY/cbrf1/v37IKC4D2wBVe2ozoZS2Z02ar7LlKaZTndbPT990vPLc7CCoUidhuY5XKAicD2ynXFCQCLMeU4UMdSuHzzj48V8zedzjcdj3d3dqdPphPPcWT+AMxSqC0d8ziiawWAQqHTqGRD/0Gq1gsuBfHnmlHtShZG0RNwVp1ml1f9nr+okpVmi6oe9DsdzJUbcHMyFsz7up07TcwAegZHb7VYvLy9B0cXukeFwGDIcSJv08rux5epBdrGVHLuwPBDRrxf7uwGkzCflrcmCccrez38AFFDCmuO7YQtwGTA2gANfj8RIwKA4SMnzPKSHOlhnTbIuiP9wVwD+f/ZNkiQBpBFf4SwTc8u+ZJzpA0cX+1gwljwHwIi/r7k5mC/fjzH7dWtf125g4JWaCxq3KGJlfo2adNTrr/lv6cu0PfeoqkrL1VKfGj+q+v6oTjtXZ9vRYDDQfD6vCURvv2RJXVPqsdUUK/9rzx4//7VniV0KLqTdwka4O1Xq98IadUWAgDkcDppXc+XDo6reOT5gOV/WFHrct3ge4vfi92OL8to85nmu0WCsdtbWer/SbDG7Ktz8uRl3p2n9BDze434+14AHKGWns52iBYR54JrPj78e5q5ZKe2lqo6V1KlH6sduEfdXx1HwMUWPAoifObZi3fd/ba6uvcb/HgfjY8U8+HP63MZrm7FDoXfzrjqNXKVKbQ+bz0C077Nr4MX75GMRs2/XWLUY7FyTIfE4OPvn7zGuzrq4azD+rIMV3EexX/9L++KazLvWV3+WmOG8tV/fbmDglRppT6vVqpZqgxBwvxsbxwuL+OdoLqj8u7znn/PrL1dL3Q8e1HwcaHQaKL07V+Ujrc4ByzWB4r57fvtGd2HkQYSufBAgLsy9IA8Cnfs6e4Il7UKZOAEEFtY3lqxbFhS9wfLBuvSULSxU6cIEeL94Pq7DfR0oxOwJY4AV7MFxnlqZJIlG/ZHe7H9Qc91RPpqpHFR6mT7XxhGlsF6vNRwOg3WJv/dwOGg6nYY++6FMHgnOdQjYS5LL4UcwL5vNRt1uN1h0T09PnykOrEIPOsvzXEX7qN6/b6s8SsfBWtvNOdOCYjhOk3twH2xPkiSh3+4frqoqsBFY1TABWMNpmobMAy/K5ZanF9eJm9PSzDs+fg5ewiouyzLci7HBMs6yLJxJ0Gw2lS7aKv9LQ1m/VOfbSvPNrHaypcfX8CzutnEAyJ4j42A0GtUObjqdTiH4sqqqUK/fs2k8nsHdU16dNE3TcGgaYwlLcilffQGnMAIOPF22xfUsYjnDuPMbkBrHJMSNe/gY3trXtxsYeKWGQCYH25Usi9o3g28iNqJvEqhHF8iuMGlsDNLtsux8ylvn2Ff21JGqRJ28p0H/fOIXvmUUOj5MFxourPm8V4dzJe8KEyrZBSwbHOXtEf48D+PjG9tZAVL3UGoIGN5DUEHZ8j8CHRASp11hsbgicEqf5+WAHRQs713zHxPc5e4OT9XjXu2sq/ZzX9pm6iYjdSYvYaxQRozPdDoN9C1piJTkhYKmfPJ0OlVVVSE+AGuemAHvN/0cDAZBycdsgtcj8HgR5n+32+nT46fwXja/0PxkJjiV7kVt3AfPMzG/Hizp6bOs78PhoF6vp+PxGPz0rOM4mJTjsWOGgTny/edgjzHhf/aYMwFU4uP+BHx2ngYqPyVKl5na73L1+/V1yn5OkrPLBiUMCOLUSJQee9bjDXCbkYYqnZW4l+fGAHBXiccQAch4Bq8h4YGBw+Gwdjy4ywn2uVeijDMPXGa43IvlTXxvvhPHMsWg4ta+vt3AwCs1FrULODa+W7iOyvntFrErexfcDhqketATm4fX9/u9DoOtOoODVKQ65nsdNsfQJ/yN/A99HNO5vE8/4z44u9FqtTQcDmv+P/rosQFcH8ESxyFwXf/x/vKM/ixYLAg4r9GA9c/nY4o5ZkMAVDF97AyNu2V4P6bysYgR5E79lmWpY7XXabhVlnR06G90LI81EOJ0LxUBy7LU3d1dUAR+JG4cf4ISdGWLrx72otvthqAw3t9sNiFLhc8BCJ36ZSzi8cWCZ82jVHmOWMHCyLAOfGwHg0FQZACrdrt9rsQ5GIRgTwLwGC8HefzvmSu+xnjPLWY/R4R14O9zLRQrFRphrxqNppr9rtJhR8mwUtE4xwf4uqMGh69J3Fjcx2scMHb9fj8EuPLjz0eeP/fwfcg9+CG2gddR6L7PnNWsgVnLbmH86TdrvizLUCbZx95BgTMAMRMa7zWfO5/DW3uddgMDr9iu0VqOePlfqiuhayiXzXmtxZvB74uAftk+6fBup6qSVtulFov5ZxvtS9d2q9iROH2CKSB3HIHhwYg8t1OgKE0C+VDcHgvAb+9rLAxi/7ILDp+L2C1z7dldSTiNGs+H9wtryefK58N99/TVP3s8HjVdvKgaVmqOmtoeN1osF58JO+5VFOe8e6jwPM/D0caeekYkepIktSOIsdYcjHEtDwDzHHZPVWO+uRcKjHv6M3uRK57H2RJ/PV63bglyb49EdyBJRkGc3RIre//f7+uf+Ute8756sGqc/leWpVarpdJhqvzf5CqTUvufQRbnQrAP2BOwAr6+uZa7TJgbBwHuBnIAyefJcgCkc11n4dyY4DfHUvva8rXJdeiDAxqn75EL14yfeI5ovt99Lzgo57vuuru1r2s3MPBKLbagpXrRjNjS9c/EVjG/Y+XGb1dG/hnPBJjP51oul0FoOCBx69itBvrmlrHTolVV1YrA5Hmu0WgUlAubk+sej8dQ8he6mL4Qre4WDmNFuVkX7v7s/tzOPMSuFgdaCFZvPi8+dzGo83mMhQ/P6TUHYEyuKRh+73Y7PR4/SbpUyPN59z4VRRGKz3jhJd6H3sfaS9NzISEq1TmVS1/8ZLjYUmNc+e0nKWLpuwsrrnfvyg4L0aPafd3F6YCAjqq6lEL2Q3GIkh8MBpIuYA52i2s4QHTrnjFjrGEUfG78/3guHBTzepZlwQWDYp3PZ1o3VuHzgEB3t3Ef4jeI+WA+4n0JCONaPnaAMHcNleWlCJWDdPrggafSJXsCMMkzO5jjGl5Ujf9dJiE3AEA01o4DvHh/+Ofjv+O6FNcMsFv7de0GBl6pxYua5sjeaUlJIcgnzqmXLv52t3hcCXnakx8qgoD3U8RilI/yiRUh30d4IijcesQXzTHDbp0QbOUUrAsfzyPnN2NXlqUmk4kkhcN53OccV6vzcXba1j/jlrx/3oOifMy4lisvrsvvWJC7FePKH8FFnxyMMK5xxD3j5q4h5pLrLhaLWqll1g408mg0UlEU+vDhQ2BfvKwtfby7uwuKYzab6e3bt2o0GgGk4YMm+JI1htL1I3dZL57q6Mqr0WgEBsk/NxgMQjoj1rGvTeItUHxleT5HAEXlDBX0tu8R5i8ufOOgiBgTz6KIG5YugI/1QNwDMRHMA8/AOQKAcr8WSlpSAG7UUGBNDgaDoOjZR1mWabU6gwz+92DcGGAfDodaSXDf317CO0mSmsLvdDq1ol3OGHENX7/cu91uhzLHPB8ZBaxjj71xY4Q+0zfmnr7DfMV7LZa5t/br2g0MvFJz6zmmGVHq0qU4EAve/WtxapkvehSRKxQ+4xYH30dQOX3nlnDMTHAvLHenYBGa9/f3tapwMTXrDAF57S7ElstlzceMtYkPnKCjNE01Ho9Dv8m7djcCz4qV4YrfXQMx5ZimaQAtWC0oKHymDmgYd5+ja8DPo92pvx9nGaDAr9HV7rvlNcaGMUMxvLy8aLfbaTKZBL9/kpxrTAyHw2BVLxaLoJwAVm558tzH4zGADNYRfXUlx7Pj+qmqKpwjwRi5S4L1jvJoNBoh9x32ysEbcSSMAwdFsYdQkqPRSNL5+GqCJz1TRarXwI/PWvA96oGo9JHP8SxO28dZDwRYEgS42WxCPAYgnDGFsQEkOLsCa7ZerzUYDJRlWajp4Osa0OQZNOxXngOAglxA0cbZPe5+SJIkBKlK0svLS03x0z8vD+7WvJ8TslgsauWWY2ue9XJNnsXzFyv6WHa5e+vWvq7dwMArt9h/9SV/VqwQ4veuoV1XbvwfX8MV3zXUfK1/167D9f21OLDOrYJrP9dYklhgewyFC2ynSZ1SjK3wa7+vjY/35Uvuh2vXvjaOX5qf+FrxuMbzd23Mf2m98B4ZFLHvNaZb3dKK58qZClcUMQPl9/drcA8X2PEcxWPm93bmyMGkgwG/Zwxo4354+0stRWd44nUTMwzxuvBn8cwYrNf4Pn4tBxd+XXdDeV/c/eBM17X1xe9rRkW8vuPn9mfFiIhjXq49k//Pd6+t8S/JvGv/f2lub+2/XUuqL0mf+IO3SfnFdk3xfElpfGmhX1PGX2q/pJB+bfulDehC7Je+Hys+/36shF14XWsulOPvfk37NYImVhD/3PVfa26u3Zdrx35+LCX+dkUXN4+vcOXyJTDg17nGbvxzz8BvtwCvgQW/vgNF/078jNfWxmutlV9qMQjzZ/C94s8cA9svXfeXZMc1sHvtc/6ZL70W3zf+rPfnn7vnP3etX3rmv7SPv/SdW/ty+4v26Q0M3Nqt3dqt3dqt/Z+3/SVq/la+6dZu7dZu7dZu7a+83cDArd3ard3ard3aX3m7gYFbu7Vbu7Vbu7W/8nYDA7d2a7d2a7d2a3/l7QYGbu3Wbu3Wbu3W/srbDQzc2q3d2q3d2q39lbcbGLi1W7u1W7u1W/srb39xBcJbYYdbu7Vbu7Vbu7X/c7YbM3Brt3Zrt3Zrt/ZX3m5g4NZu7dZu7dZu7a+83cDArd3ard3ard3aX3m7gYFbu7Vbu7Vbu7W/8nYDA7d2a7d2a7d2a3/l7QYGbu3Wbu3Wbu3W/srbDQzc2q3d2q3d2q39lbcbGLi1W7u1W7u1W/srbzcwcGu3dmu3dmu39lfe/v/izpKnywTu5QAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(v.screenshot())\n", + "plt.axis(\"off\");" + ] + }, + { + "cell_type": "markdown", + "id": "873153a5", + "metadata": {}, + "source": [ + "## Modify detection parameters" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3dbfd58f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'illumination_correction': {'flatfield': None, 'scaling': 'mean'}, 'background_correction': {'shape': (10, 10), 'form': 'Disk', 'save': False}, 'equalization': None, 'dog_filter': {'shape': [5, 5, 5], 'sigma': [5, 5, 5], 'sigma2': [2, 2, 2]}, 'maxima_detection': {'h_max': None, 'shape': 5, 'threshold': 0, 'valid': True, 'save': False}, 'shape_detection': {'threshold': 700, 'save': False}, 'intensity_detection': {'method': 'max', 'shape': 3, 'measure': ['source', 'background_correction']}}\n", + "masking maxima centers by (dog > 700) for shape detection\n", + "Filtering centers for correct block processing.\n", + "Received uint source array with 0 values. To avoid inconsistent results in watershedding, we need to shift the source intensity by 1 prior to taking its opposite.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/etienne.doumazane/code/ClearAnatomics/ClearMap/ClearMap/Analysis/Measurements/shape_detection.py:159: UserWarning: Received an uint source using the full range of available values. We had to clip upper values to 65534 before shifting intensity by 1.\n", + " warnings.warn(f'Received an uint source using the full range of available values. We had to clip upper values to {max_val-1} before shifting intensity by 1.')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "masking maxima centers by (dog > 700) for shape detection\n", + "Filtering centers for correct block processing.\n", + "Received uint source array with 0 values. To avoid inconsistent results in watershedding, we need to shift the source intensity by 1 prior to taking its opposite.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/etienne.doumazane/code/ClearAnatomics/ClearMap/ClearMap/Analysis/Measurements/shape_detection.py:159: UserWarning: Received an uint source using the full range of available values. We had to clip upper values to 65534 before shifting intensity by 1.\n", + " warnings.warn(f'Received an uint source using the full range of available values. We had to clip upper values to {max_val-1} before shifting intensity by 1.')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "masking maxima centers by (dog > 700) for shape detection\n", + "Filtering centers for correct block processing.\n", + "Received uint source array with 0 values. To avoid inconsistent results in watershedding, we need to shift the source intensity by 1 prior to taking its opposite.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/etienne.doumazane/code/ClearAnatomics/ClearMap/ClearMap/Analysis/Measurements/shape_detection.py:159: UserWarning: Received an uint source using the full range of available values. We had to clip upper values to 65534 before shifting intensity by 1.\n", + " warnings.warn(f'Received an uint source using the full range of available values. We had to clip upper values to {max_val-1} before shifting intensity by 1.')\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "masking maxima centers by (dog > 700) for shape detection\n", + "Filtering centers for correct block processing.\n", + "Received uint source array with 0 values. To avoid inconsistent results in watershedding, we need to shift the source intensity by 1 prior to taking its opposite.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/etienne.doumazane/code/ClearAnatomics/ClearMap/ClearMap/Analysis/Measurements/shape_detection.py:159: UserWarning: Received an uint source using the full range of available values. We had to clip upper values to 65534 before shifting intensity by 1.\n", + " warnings.warn(f'Received an uint source using the full range of available values. We had to clip upper values to {max_val-1} before shifting intensity by 1.')\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xyzsizesourcebackground_correction
00030106544.02561.0
1004355880.02181.0
2015556544.02418.0
30213376402.03604.0
4056676829.02656.0
.....................
5134759251192246402.03083.0
5134859252242395643.02987.0
513495925225164647.02181.0
513505925422045264.01992.0
513515925518616402.03272.0
\n", + "

51352 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " x y z size source background_correction\n", + "0 0 0 30 10 6544.0 2561.0\n", + "1 0 0 43 5 5880.0 2181.0\n", + "2 0 1 55 5 6544.0 2418.0\n", + "3 0 2 13 37 6402.0 3604.0\n", + "4 0 5 66 7 6829.0 2656.0\n", + "... .. ... ... ... ... ...\n", + "51347 59 251 192 24 6402.0 3083.0\n", + "51348 59 252 242 39 5643.0 2987.0\n", + "51349 59 252 251 6 4647.0 2181.0\n", + "51350 59 254 220 4 5264.0 1992.0\n", + "51351 59 255 186 1 6402.0 3272.0\n", + "\n", + "[51352 rows x 6 columns]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import napari\n", + "\n", + "v = napari.Viewer()\n", + "\n", + "from ClearMap.ImageProcessing.Experts.Cells import (\n", + " detect_cells,\n", + " default_cell_detection_parameter,\n", + ")\n", + "from skimage.data import cells3d\n", + "import pandas as pd\n", + "\n", + "\n", + "test_data = cells3d()[:, 1]\n", + "\n", + "cell_detection_parameter = default_cell_detection_parameter.copy()\n", + "cell_detection_parameter[\"dog_filter\"].update(\n", + " {\"shape\": [5, 5, 5], \"sigma\": [5, 5, 5], \"sigma2\": [2, 2, 2]}\n", + ")\n", + "print(cell_detection_parameter)\n", + "\n", + "sink = detect_cells(test_data, cell_detection_parameter=cell_detection_parameter)\n", + "pd.DataFrame(sink)" + ] + }, + { + "cell_type": "markdown", + "id": "bddb0720", + "metadata": {}, + "source": [ + "## Modify block the processing function\n", + "Create and modify [this script](custom_cells.py)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "216714cd", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import napari\n", + "\n", + "v = napari.Viewer()\n", + "\n", + "from ClearMap.Scripts.custom_cells import (\n", + " detect_cells,\n", + " custom_detect_cells_block,\n", + " default_cell_detection_parameter,\n", + ")\n", + "from skimage.data import cells3d\n", + "import pandas as pd\n", + "\n", + "test_data = cells3d()[:, 1]" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "a977b53e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
xyzsizesourcebackground_correction
03987532467465535.028599.0
136137411595341113.042836.0
233182501375642394.033177.0
33518241273945903.026870.0
43118621226123378.01919.0
53979612660265535.011244.0
638136631624231724.010102.0
734180621366632720.011384.0
\n", + "
" + ], + "text/plain": [ + " x y z size source background_correction\n", + "0 39 87 53 24674 65535.0 28599.0\n", + "1 36 137 41 15953 41113.0 42836.0\n", + "2 33 182 50 13756 42394.0 33177.0\n", + "3 35 18 24 12739 45903.0 26870.0\n", + "4 31 186 2 12261 23378.0 1919.0\n", + "5 39 79 61 26602 65535.0 11244.0\n", + "6 38 136 63 16242 31724.0 10102.0\n", + "7 34 180 62 13666 32720.0 11384.0" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "sink = detect_cells(\n", + " test_data,\n", + " block_detection_function=custom_detect_cells_block,\n", + " cell_detection_parameter=default_cell_detection_parameter,\n", + ")\n", + "cells_df = pd.DataFrame(sink)\n", + "cells_df" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "fbf7a6a4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Visualize in napari\n", + "v.add_image(test_data, name=\"test data\")\n", + "v.add_points(\n", + " cells_df[[\"x\", \"y\", \"z\"]],\n", + " properties=cells_df[cells_df.columns.difference([\"x\", \"y\", \"z\"])],\n", + " out_of_slice_display=True,\n", + " face_color=\"size\",\n", + " # size=10,\n", + " name=\"detected cells\"\n", + ")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ClearMap3b", + "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.11.12" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}