From 6a3775307478cbd4399c77f38227e15bfb6f05d4 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Wed, 15 May 2024 18:43:58 -0400 Subject: [PATCH 01/14] small changes to center_diffractogram --- pyTEMlib/image_tools.py | 30 +++++++++++++++++------------- 1 file changed, 17 insertions(+), 13 deletions(-) diff --git a/pyTEMlib/image_tools.py b/pyTEMlib/image_tools.py index 8abf9b12..f25ce33d 100644 --- a/pyTEMlib/image_tools.py +++ b/pyTEMlib/image_tools.py @@ -280,20 +280,21 @@ def diffractogram_spots(dset, spot_threshold, return_center=True, eps=0.1): return spots, center -def center_diffractogram(dset, return_plot = True, histogram_factor = None, smoothing = 1, min_samples = 100): +def center_diffractogram(dset, return_plot = True, smoothing = 1, min_samples = 10, beamstop_size = 0.1): try: diff = np.array(dset).T.astype(np.float16) diff[diff < 0] = 0 - - if histogram_factor is not None: - hist, bins = np.histogram(np.ravel(diff), bins=256, range=(0, 1), density=True) - threshold = threshold_otsu(diff, hist = hist * histogram_factor) - else: - threshold = threshold_otsu(diff) + threshold = threshold_otsu(diff) binary = (diff > threshold).astype(float) smoothed_image = ndimage.gaussian_filter(binary, sigma=smoothing) # Smooth before edge detection smooth_threshold = threshold_otsu(smoothed_image) smooth_binary = (smoothed_image > smooth_threshold).astype(float) + + # add a circle to mask the beamstop + x, y = np.meshgrid(np.arange(dset.shape[0]), np.arange(dset.shape[1])) + circle = (x - dset.shape[0] / 2) ** 2 + (y - dset.shape[1] / 2) ** 2 < (beamstop_size * dset.shape[0] / 2) ** 2 + smooth_binary[circle] = 1 + # Find the edges using the Sobel operator edges = sobel(smooth_binary) edge_points = np.argwhere(edges) @@ -322,18 +323,21 @@ def calc_distance(c, x, y): finally: if return_plot: - fig, ax = plt.subplots(1, 4, figsize=(10, 4)) + fig, ax = plt.subplots(1, 5, figsize=(14, 4), sharex=True, sharey=True) ax[0].set_title('Diffractogram') ax[0].imshow(dset.T, cmap='viridis') ax[1].set_title('Otsu Binary Image') ax[1].imshow(binary, cmap='gray') ax[2].set_title('Smoothed Binary Image') - ax[2].imshow(smooth_binary, cmap='gray') - ax[3].set_title('Edge Detection and Fitting') - ax[3].imshow(edges, cmap='gray') - ax[3].scatter(center[0], center[1], c='r', s=10) + ax[2].imshow(smoothed_image, cmap='gray') + + ax[3].set_title('Smoothed Binary Image') + ax[3].imshow(smooth_binary, cmap='gray') + ax[4].set_title('Edge Detection and Fitting') + ax[4].imshow(edges, cmap='gray') + ax[4].scatter(center[0], center[1], c='r', s=10) circle = plt.Circle(center, mean_radius, color='red', fill=False) - ax[3].add_artist(circle) + ax[4].add_artist(circle) for axis in ax: axis.axis('off') fig.tight_layout() From 81f30e142f228859cd8031937f9c807dbf1f92c4 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Tue, 3 Sep 2024 19:18:26 -0400 Subject: [PATCH 02/14] added 4D STEM file reader --- notebooks/4Dstem_File_Reader.ipynb | 816 +++++++++++++++++++++++++++++ 1 file changed, 816 insertions(+) create mode 100644 notebooks/4Dstem_File_Reader.ipynb diff --git a/notebooks/4Dstem_File_Reader.ipynb b/notebooks/4Dstem_File_Reader.ipynb new file mode 100644 index 00000000..720e675e --- /dev/null +++ b/notebooks/4Dstem_File_Reader.ipynb @@ -0,0 +1,816 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Basics of reading an MRC file with 4D STEM data from the Spectra300 at UTK\n", + "## By Austin Houston\n", + "### Last updated 2024-09-03" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import time\n", + "from datetime import datetime\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import h5py\n", + "import mrcfile\n", + "\n", + "import sidpy" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib ipympl" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "mrc_filepath = '/Users/austin/Dropbox/GaTech_colabs/ScFeO3_Al2O3/2024_07_03/4D_stem/'\n", + "\n", + "save_path = '/Users/austin/Dropbox/GaTech_colabs/ScFeO3_Al2O3/2024_07_03/4D_h5_files/'" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "mrc_files = os.listdir(mrc_filepath)\n", + "mrc_files = [f for f in mrc_files if f.endswith('.mrc')]\n", + "mrc_files = sorted(mrc_files)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/1h/36qxtl8567zdjv8nzdn4fzrr0000gn/T/ipykernel_442/3194067291.py:21: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " x_shape = int(np.abs(sizes[0] - sizes[1]))\n", + "/var/folders/1h/36qxtl8567zdjv8nzdn4fzrr0000gn/T/ipykernel_442/3194067291.py:22: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", + " y_shape = int(np.abs(sizes[2] - sizes[3]))\n" + ] + } + ], + "source": [ + "mrc_raw = mrcfile.open(mrc_filepath+mrc_files[1], permissive=True)\n", + "\n", + "# Read the file\n", + "extended_header = mrc_raw.indexed_extended_header\n", + "metadata_labels = extended_header.dtype.names\n", + "metadata_labels = [label for label in metadata_labels]\n", + "\n", + "mrc_data = mrc_raw.data\n", + "\n", + "# Reshape the data\n", + "shape_cantidates = ['Scan size right', 'Scan size left', 'Scan size top', 'Scan size bottom']\n", + "\n", + "sizes = []\n", + "for label in shape_cantidates:\n", + " size = np.unique(extended_header[label])\n", + " sizes.append(size)\n", + "\n", + "# this part is a little confusing\n", + "# do we reshape L-R or T-B?\n", + "# the following is a guess\n", + "x_shape = int(np.abs(sizes[0] - sizes[1]))\n", + "y_shape = int(np.abs(sizes[2] - sizes[3]))\n", + "reshape_target = (x_shape, y_shape, mrc_data.shape[-2], mrc_data.shape[-1])\n", + "reshaped_data = np.reshape(mrc_data, reshape_target)\n", + "\n", + "# Get these 'pixel sizes' are usually in the order of 10^8\n", + "# is this the ceta pixel size?...\n", + "# what are the units?\n", + "pixel_sizes = []\n", + "for label in ['Pixel size X', 'Pixel size Y']:\n", + " size = np.unique(extended_header[label])\n", + " pixel_sizes.append(size)\n", + "\n", + "# get real space pixel sizes a different way\n", + "# but this results in different pixel sizes by ~0.01 Angstroms\n", + "# incorrect?\n", + "step_x = np.unique(extended_header['Full scan FOV X']) / x_shape * 1e10 # Angstroms\n", + "step_y = np.unique(extended_header['Full scan FOV Y']) / y_shape * 1e10 # Angstroms\n", + " \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Metadata size [888]\n", + "Metadata version [2]\n", + "Bitmask 1 [49185]\n", + "Timestamp [45476.95348159 45476.9534819 45476.9534822 ... 45476.95412522\n", + " 45476.95412553 45476.95412583]\n", + "Microscope type [b'']\n", + "D-Number [b'']\n", + "Application [b'']\n", + "Application version [b'']\n", + "HT [300000.]\n", + "Dose [0.]\n", + "Alpha tilt [0.]\n", + "Beta tilt [0.]\n", + "X-Stage [0.]\n", + "Y-Stage [0.]\n", + "Z-Stage [0.]\n", + "Tilt axis angle [0.]\n", + "Dual axis rotation [0.]\n", + "Pixel size X [4.3988768e+08]\n", + "Pixel size Y [4.3988768e+08]\n", + "Unused range [b'']\n", + "Defocus [0.]\n", + "STEM Defocus [0.]\n", + "Applied defocus [0.]\n", + "Instrument mode [0]\n", + "Projection mode [0]\n", + "Objective lens mode [b'']\n", + "High magnification mode [b'']\n", + "Probe mode [0]\n", + "EFTEM On [False]\n", + "Magnification [0.]\n", + "Bitmask 2 [15728641]\n", + "Camera length [0.07066868]\n", + "Spot index [0]\n", + "Illuminated area [0.]\n", + "Intensity [0.]\n", + "Convergence angle [0.]\n", + "Illumination mode [b'']\n", + "Wide convergence angle range [False]\n", + "Slit inserted [False]\n", + "Slit width [0.]\n", + "Acceleration voltage offset [0.]\n", + "Drift tube voltage [0.]\n", + "Energy shift [0.]\n", + "Shift offset X [0.]\n", + "Shift offset Y [0.]\n", + "Shift X [0.]\n", + "Shift Y [0.]\n", + "Integration time [0.]\n", + "Binning Width [0]\n", + "Binning Height [0]\n", + "Camera name [b'']\n", + "Readout area left [1024]\n", + "Readout area top [1024]\n", + "Readout area right [3072]\n", + "Readout area bottom [3072]\n", + "Ceta noise reduction [False]\n", + "Ceta frames summed [0]\n", + "Direct detector electron counting [False]\n", + "Direct detector align frames [False]\n", + "Camera param reserved 0 [0]\n", + "Camera param reserved 1 [0]\n", + "Camera param reserved 2 [0]\n", + "Camera param reserved 3 [0]\n", + "Bitmask 3 [8290304]\n", + "Camera param reserved 4 [0]\n", + "Camera param reserved 5 [0]\n", + "Camera param reserved 6 [0]\n", + "Camera param reserved 7 [0]\n", + "Camera param reserved 8 [0]\n", + "Camera param reserved 9 [0]\n", + "Phase Plate [False]\n", + "STEM Detector name [b'']\n", + "Gain [0.]\n", + "Offset [0.]\n", + "STEM param reserved 0 [0]\n", + "STEM param reserved 1 [0]\n", + "STEM param reserved 2 [0]\n", + "STEM param reserved 3 [0]\n", + "STEM param reserved 4 [0]\n", + "Dwell time [0.0263296]\n", + "Frame time [0.]\n", + "Scan size left [0]\n", + "Scan size top [0]\n", + "Scan size right [22]\n", + "Scan size bottom [92]\n", + "Full scan FOV X [1.96305274e-08]\n", + "Full scan FOV Y [1.96305274e-08]\n", + "Element [b'']\n", + "Energy interval lower [0.]\n", + "Energy interval higher [0.]\n", + "Method [0]\n", + "Is dose fraction [False]\n", + "Fraction number [0]\n", + "Start frame [0]\n", + "End frame [0]\n", + "Input stack filename [b'']\n", + "Bitmask 4 [204]\n", + "Alpha tilt min [0.]\n", + "Alpha tilt max [0.]\n", + "Scan rotation [-2.0367534]\n", + "Diffraction pattern rotation [3.01700489]\n", + "Image rotation [0.]\n", + "Scan mode enumeration [0]\n", + "Acquisition time stamp [1720039980809786 1720039980836119 1720039980862443 ... 1720040036419159\n", + " 1720040036445482 1720040036471816]\n", + "Detector commercial name [b'Ceta-S speed']\n", + "Start tilt angle [0.]\n", + "End tilt angle [0.]\n", + "Tilt per image [0.]\n", + "Tilt speed [0.]\n", + "Beam center X pixel [0]\n", + "Beam center Y pixel [0]\n", + "CFEG flash timestamp [0]\n", + "Phase plate position index [0]\n", + "Objective aperture name [b'']\n" + ] + } + ], + "source": [ + "for label in metadata_labels:\n", + " print(label, np.unique(extended_header[label]))" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[array([4.3988768e+08]), array([4.3988768e+08])]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pixel_sizes" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pixel size X Pixel size Y\n", + "[array([4.3988768e+08]), array([4.3988768e+08])]\n", + "Full scan FOV X Full scan FOV Y\n", + "[1.96305274e-08] [1.96305274e-08]\n", + "22 92\n", + "[8.92296701] [2.13375298]\n" + ] + } + ], + "source": [ + "print('Pixel size X', 'Pixel size Y')\n", + "print(pixel_sizes)\n", + "\n", + "print('Full scan FOV X', 'Full scan FOV Y')\n", + "print(np.unique(extended_header['Full scan FOV X']), np.unique(extended_header['Full scan FOV Y']))\n", + "\n", + "print(x_shape, y_shape)\n", + "print(step_x, step_y)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0., 0., 0., ..., 0., 0., 0.])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "extended_header['Frame time']" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.unique(extended_header['Frame time']) " + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.0263296])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.unique(extended_header['Dwell time'])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "### This is all for saving to file later, not important right now:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# how can I get the pixel sizes? Should be easy for the real space, but how for reciprocal space?\n", + "mrc_dset = sidpy.Dataset.from_array(reshaped_data, name='MRC_000', chunks=(1, 1, reshape_target[-2], reshape_target[-1]))\n", + "\n", + "mrc_dset.set_dimension(0, sidpy.Dimension(np.arange(mrc_dset.shape[0])*step_y, \n", + " name='x', units='Angstom', quantity='Length',\n", + " dimension_type='spatial'))\n", + "\n", + "mrc_dset.set_dimension(1, sidpy.Dimension(np.arange(mrc_dset.shape[1])*step_x,\n", + " name='y', units='Angstrom', quantity='Length',\n", + " dimension_type='spatial'))\n", + "\n", + "mrc_dset.set_dimension(2, sidpy.Dimension(np.arange(mrc_dset.shape[2]),\n", + " name='u', units='unknown', quantity='angles',\n", + " dimension_type='reciprocal'))\n", + "\n", + "mrc_dset.set_dimension(3, sidpy.Dimension(np.arange(mrc_dset.shape[3]),\n", + " name='v', units='unknown', quantity='angles',\n", + " dimension_type='reciprocal'))\n", + "\n", + "# reading metadata\n", + "metadata = {}\n", + "for label in metadata_labels:\n", + " # later, we may want to remove 'np.unique()', but I see no problems now\n", + " metadata[label] = np.unique(extended_header[label])\n", + "\n", + "mrc_dset.metadata = metadata" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# now this is for a different notebook:\n", + "# clustering" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.cluster import KMeans\n", + "\n", + "from sklearn.decomposition import PCA\n", + "from sklearn.cluster import KMeans\n", + "from mpl_toolkits.mplot3d import Axes3D\n", + "\n", + "from scipy.ndimage import center_of_mass" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "mrc_dset = mrc_dset[:,:,20:180,40:200]" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bffb9a8e394b4a2b82dbee6c8ede535f", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# perform nmf on the data\n", + "fig, axs = plt.subplots(5,5)\n", + "for i in range(5):\n", + " for j in range(5):\n", + " axs[i,j].imshow(mrc_dset[i,j,:,:], cmap='plasma')\n", + " axs[i,j].axis('off')\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# get COM for all images\n", + "coms = np.zeros((mrc_dset.shape[0], mrc_dset.shape[1], 2))\n", + "\n", + "# Compute the center of mass for each image\n", + "for i in range(mrc_dset.shape[0]):\n", + " for j in range(mrc_dset.shape[1]):\n", + " coms[i, j] = center_of_mass(mrc_dset[i, j, :, :])" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "714d1e99b56145468995504a0c07e790", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAhsUlEQVR4nO3de3CV9Z348U8IEi8lYSMkIeUi2gpeqYuK2VqHrRkuulpXdkZb1tsyMHXAXaVFxbUa6m7Zuh11aqlMZ1tpZ0TdzlQ70i4u4ATWNWBhx6VoZYVhBxQCFpZEsIZLnt8fHc/PaICAOTmcfF+vmTPDOefJN9/nPDzkzfdcUpJlWRYAACSjT6EnAABAzxKAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJEYAAAIkRgAAAiRGAAACJ6VvoCRSz9vb22LZtW/Tv3z9KSkoKPR0AoAuyLIv33nsvamtro0+fNNfCBOCnsG3bthg6dGihpwEAHIetW7fGkCFDCj2NghCAn0L//v0j4o9/gcrLyws8GwCgK1pbW2Po0KG5n+MpEoCfwodP+5aXlwtAACgyKb98K80nvgEAEiYAAQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQAS07fQEwCgGzU0FPbrgaJgBRAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxRRmA8+bNi0suuST69+8fVVVVcd1118WGDRs6bDNu3LgoKSnpcPn617/eYZstW7bE1VdfHaeeempUVVXF7Nmz4+DBgz25KwAAPa5voSdwPFasWBEzZsyISy65JA4ePBj33XdfjB8/Pt5444047bTTcttNmzYtvv3tb+eun3rqqbk/Hzp0KK6++uqoqamJV155JbZv3x4333xznHTSSfGd73ynR/cHAKAnFWUALlmypMP1hQsXRlVVVaxduzauuOKK3O2nnnpq1NTUdDrGv//7v8cbb7wRy5Yti+rq6vjCF74QDz30UNxzzz3R0NAQ/fr1y+s+AAAUSlE+BfxxLS0tERFRWVnZ4fannnoqBg4cGOeff37MmTMn3n///dx9TU1NccEFF0R1dXXutgkTJkRra2u8/vrrPTNxAIACKMoVwI9qb2+PO++8M774xS/G+eefn7v9a1/7WgwfPjxqa2tj3bp1cc8998SGDRviF7/4RURENDc3d4i/iMhdb25u7vR7tbW1RVtbW+56a2trd+8OAEDeFX0AzpgxI9avXx8vv/xyh9unT5+e+/MFF1wQgwcPjiuvvDI2bdoUZ5111nF9r3nz5sXcuXM/1XwBAAqtqANw5syZsXjx4li5cmUMGTLkiNuOHTs2IiI2btwYZ511VtTU1MSrr77aYZsdO3ZERBz2dYNz5syJWbNm5a63trbG0KFDP80uAPx/DQ2FngGQiKJ8DWCWZTFz5sx47rnn4qWXXooRI0Yc9Wtee+21iIgYPHhwRETU1dXFb3/729i5c2dum6VLl0Z5eXmce+65nY5RVlYW5eXlHS4AAMWmKFcAZ8yYEYsWLYpf/vKX0b9//9xr9ioqKuKUU06JTZs2xaJFi+Kqq66K008/PdatWxd33XVXXHHFFXHhhRdGRMT48ePj3HPPjZtuuikefvjhaG5ujvvvvz9mzJgRZWVlhdw9AIC8KsoVwCeeeCJaWlpi3LhxMXjw4Nzl2WefjYiIfv36xbJly2L8+PExatSo+MY3vhGTJ0+OF154ITdGaWlpLF68OEpLS6Ouri7++q//Om6++eYOnxsIANAbFeUKYJZlR7x/6NChsWLFiqOOM3z48Pj1r3/dXdMCACgKRbkCCADA8ROAAACJEYAAAIkRgAAAiRGAAACJKcp3AQOQJ5/2t5H4bSZQFKwAAgAkRgACACRGAAIAJMZrAAG6i9e/AUXCCiAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGL8Kjgged32G9wax/1xvHGN3TQgQH5YAQQASIwABABIjAAEAEiMAAQASIwABABIjHcBA0Wn2961C5AoK4AAAIkRgAAAifEUMJB3nrIFOLFYAQQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEhM30JPAKC3aWgc173jjWvs1vEArAACACRGAAIAJMZTwAB0n4aGE2MM4IisAAIAJEYAAgAkpigDcN68eXHJJZdE//79o6qqKq677rrYsGFDh20++OCDmDFjRpx++unxmc98JiZPnhw7duzosM2WLVvi6quvjlNPPTWqqqpi9uzZcfDgwZ7cFQCAHleUAbhixYqYMWNGrFq1KpYuXRoHDhyI8ePHx759+3Lb3HXXXfHCCy/Ez3/+81ixYkVs27Ytrr/++tz9hw4diquvvjr2798fr7zySvz0pz+NhQsXxgMPPFCIXQIA6DElWZZlhZ7Ep/Xuu+9GVVVVrFixIq644opoaWmJQYMGxaJFi+Kv/uqvIiLizTffjHPOOSeamprisssui3/7t3+Lv/iLv4ht27ZFdXV1REQsWLAg7rnnnnj33XejX79+R/2+ra2tUVFRES0tLVFeXp7XfYRilsxr+hsb8zJscp8DmMxfGArFz+8iXQH8uJaWloiIqKysjIiItWvXxoEDB6K+vj63zahRo2LYsGHR1NQUERFNTU1xwQUX5OIvImLChAnR2toar7/+eqffp62tLVpbWztcAACKTdEHYHt7e9x5553xxS9+Mc4///yIiGhubo5+/frFgAEDOmxbXV0dzc3NuW0+Gn8f3v/hfZ2ZN29eVFRU5C5Dhw7t5r0BAMi/og/AGTNmxPr16+OZZ57J+/eaM2dOtLS05C5bt27N+/cEAOhuRf1B0DNnzozFixfHypUrY8iQIbnba2pqYv/+/bFnz54Oq4A7duyImpqa3Davvvpqh/E+fJfwh9t8XFlZWZSVlXXzXgAA9KyiXAHMsixmzpwZzz33XLz00ksxYsSIDvePGTMmTjrppFi+fHnutg0bNsSWLVuirq4uIiLq6urit7/9bezcuTO3zdKlS6O8vDzOPffcntkRAIACKMoVwBkzZsSiRYvil7/8ZfTv3z/3mr2Kioo45ZRToqKiIqZOnRqzZs2KysrKKC8vjzvuuCPq6urisssui4iI8ePHx7nnnhs33XRTPPzww9Hc3Bz3339/zJgxwyofANCrFWUAPvHEExERMW7cuA63P/nkk3HrrbdGRMSjjz4affr0icmTJ0dbW1tMmDAhfvjDH+a2LS0tjcWLF8ftt98edXV1cdppp8Utt9wS3/72t3tqNwAACqIoA7ArH1148sknx/z582P+/PmH3Wb48OHx61//ujunBgBwwivK1wACAHD8BCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYvoWegLAiaehodAzACCfrAACACRGAAIAJEYAAgAkxmsAASIiGhsLPQOAHmMFEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDF9Cz0BAI6soXFc9443rrFbxwOKjxVAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxPgYGABOLA0Nhf16SIAVQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxBRlAK5cuTKuueaaqK2tjZKSknj++ec73H/rrbdGSUlJh8vEiRM7bLN79+6YMmVKlJeXx4ABA2Lq1Kmxd+/eHtwLAIDCKMoA3LdvX4wePTrmz59/2G0mTpwY27dvz12efvrpDvdPmTIlXn/99Vi6dGksXrw4Vq5cGdOnT8/31AEACq5voSdwPCZNmhSTJk064jZlZWVRU1PT6X2/+93vYsmSJfGb3/wmLr744oiIePzxx+Oqq66K733ve1FbW9vtcwYAOFEU5QpgVzQ2NkZVVVWMHDkybr/99ti1a1fuvqamphgwYEAu/iIi6uvro0+fPrF69epCTBcAoMcU5Qrg0UycODGuv/76GDFiRGzatCnuu+++mDRpUjQ1NUVpaWk0NzdHVVVVh6/p27dvVFZWRnNz82HHbWtri7a2ttz11tbWvO0DAEC+9MoAvPHGG3N/vuCCC+LCCy+Ms846KxobG+PKK6887nHnzZsXc+fO7Y4pAgAUTK99CvijzjzzzBg4cGBs3LgxIiJqampi586dHbY5ePBg7N69+7CvG4yImDNnTrS0tOQuW7duzeu8AQDyIYkAfPvtt2PXrl0xePDgiIioq6uLPXv2xNq1a3PbvPTSS9He3h5jx4497DhlZWVRXl7e4QIAUGyK8ingvXv35lbzIiI2b94cr732WlRWVkZlZWXMnTs3Jk+eHDU1NbFp06a4++6743Of+1xMmDAhIiLOOeecmDhxYkybNi0WLFgQBw4ciJkzZ8aNN97oHcAAQK9XlCuAa9asiYsuuiguuuiiiIiYNWtWXHTRRfHAAw9EaWlprFu3Lq699to4++yzY+rUqTFmzJj4j//4jygrK8uN8dRTT8WoUaPiyiuvjKuuuiouv/zy+NGPflSoXQIA6DFFuQI4bty4yLLssPe/+OKLRx2jsrIyFi1a1J3TAgAoCkW5AggAwPETgAAAiRGAAACJEYAAAIkpyjeBAHD8GhrHde944xq7dTwg/6wAAgAkRgACACRGAAIAJEYAAgAkRgACACRGAAIAJEYAAgAkRgACACRGAAIAJMZvAoFeoKGh0DMAoJhYAQQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQASIxfBQf0Do2NhZ4BQNGwAggAkBgBCACQGAEIAJAYAQgAkBgBCACQGAEIAJAYAQgAkBgBCACQGAEIAJAYAQgAkBgBCACQGAEIAJAYAQgAkJi+hZ4AAMWtoXFc9443rrFbxwM+yQogAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGKKMgBXrlwZ11xzTdTW1kZJSUk8//zzHe7PsiweeOCBGDx4cJxyyilRX18fb731Vodtdu/eHVOmTIny8vIYMGBATJ06Nfbu3duDewEAUBhFGYD79u2L0aNHx/z58zu9/+GHH47vf//7sWDBgli9enWcdtppMWHChPjggw9y20yZMiVef/31WLp0aSxevDhWrlwZ06dP76ldAAAomL6FnsDxmDRpUkyaNKnT+7Isi8ceeyzuv//++MpXvhIRET/72c+iuro6nn/++bjxxhvjd7/7XSxZsiR+85vfxMUXXxwREY8//nhcddVV8b3vfS9qa2t7bF8AAHpaUa4AHsnmzZujubk56uvrc7dVVFTE2LFjo6mpKSIimpqaYsCAAbn4i4ior6+PPn36xOrVqw87dltbW7S2tna4AAAUm14XgM3NzRERUV1d3eH26urq3H3Nzc1RVVXV4f6+fftGZWVlbpvOzJs3LyoqKnKXoUOHdvPsAQDyr9cFYD7NmTMnWlpacpetW7cWekoAAMes1wVgTU1NRETs2LGjw+07duzI3VdTUxM7d+7scP/Bgwdj9+7duW06U1ZWFuXl5R0uAADFptcF4IgRI6KmpiaWL1+eu621tTVWr14ddXV1ERFRV1cXe/bsibVr1+a2eemll6K9vT3Gjh3b43MGAOhJRfku4L1798bGjRtz1zdv3hyvvfZaVFZWxrBhw+LOO++Mf/iHf4jPf/7zMWLEiPjWt74VtbW1cd1110VExDnnnBMTJ06MadOmxYIFC+LAgQMxc+bMuPHGG70DGADo9YoyANesWRN//ud/nrs+a9asiIi45ZZbYuHChXH33XfHvn37Yvr06bFnz564/PLLY8mSJXHyySfnvuapp56KmTNnxpVXXhl9+vSJyZMnx/e///0e3xcAgJ5WkmVZVuhJFKvW1taoqKiIlpYWrwekoBoaCj2DE0BjY6FnQDdpGNf4KQdo6I5p0Iv5+d0LXwMIAMCRFeVTwFDsLFAAUEhWAAEAEiMAAQASIwABABLjNYAAnFAaGsd9ygE+drWhs40gbVYAAQASIwABABIjAAEAEuM1gEDh+S0eAD3KCiAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBiBCAAQGL6FnoCANCtGhs7Xm9o7GyrI2to6IaJwInLCiAAQGIEIABAYgQgAEBiBCAAQGIEIABAYgQgAEBifAwMAHzcp/0YGB8jwwnOCiAAQGKsAEIX+M88AL2JFUAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxPTaAGxoaIiSkpIOl1GjRuXu/+CDD2LGjBlx+umnx2c+85mYPHly7Nixo4AzBgDoGb02ACMizjvvvNi+fXvu8vLLL+fuu+uuu+KFF16In//857FixYrYtm1bXH/99QWcLQBAz+hb6AnkU9++faOmpuYTt7e0tMSPf/zjWLRoUXz5y1+OiIgnn3wyzjnnnFi1alVcdtllPT1VAIAe06tXAN96662ora2NM888M6ZMmRJbtmyJiIi1a9fGgQMHor6+PrftqFGjYtiwYdHU1FSo6QIA9IheuwI4duzYWLhwYYwcOTK2b98ec+fOjS996Uuxfv36aG5ujn79+sWAAQM6fE11dXU0Nzcfdsy2trZoa2vLXW9tbc3X9AEA8qbXBuCkSZNyf77wwgtj7NixMXz48PjXf/3XOOWUU45rzHnz5sXcuXO7a4oA9ICGxnHdO964xm4dDwqhVz8F/FEDBgyIs88+OzZu3Bg1NTWxf//+2LNnT4dtduzY0elrBj80Z86caGlpyV22bt2a51kDAHS/ZAJw7969sWnTphg8eHCMGTMmTjrppFi+fHnu/g0bNsSWLVuirq7usGOUlZVFeXl5hwsAQLHptU8Bf/Ob34xrrrkmhg8fHtu2bYsHH3wwSktL46tf/WpUVFTE1KlTY9asWVFZWRnl5eVxxx13RF1dnXcAAwC9Xq8NwLfffju++tWvxq5du2LQoEFx+eWXx6pVq2LQoEEREfHoo49Gnz59YvLkydHW1hYTJkyIH/7whwWeNQBA/vXaAHzmmWeOeP/JJ58c8+fPj/nz5/fQjAAATgzJvAYQAIA/EoAAAIkRgAAAiem1rwEEelBjY6FnAMAxsAIIAJAYAQgAkBgBCACQGAEIAJAYAQgAkBgBCACQGAEIAJAYAQgAkBgBCACQGAEIAJAYAQgAkBgBCACQGAEIAJAYAQgAkBgBCACQGAEIAJAYAQgAkBgBCACQGAEIAJCYvoWeAORDQ0OhZwAAJy4rgAAAibECCADdrTuehvBUBnkkAAHgGDQ0juve8cY1dut40BWeAgYASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiMAAQASIwABABIjAAEAEiM3wQCRDQ2FnoGAPQgK4AAAImxAsgJwe88B/iYT/sPo39YOQIrgAAAibECyHHxH0sAKF5WAAEAEiMAAQAS4ylgACighsZx3TveuMZuHY/eyQogAEBiBCAAQGIEIABAYgQgAEBivAkEip3f4wt0pjs+sNWHvvZaVgABABIjAAEAEiMAAQASIwABABIjAAEAEpP8u4Dnz58f//zP/xzNzc0xevToePzxx+PSSy8t9LTywpu5ADgmn/YHhx88J6ykVwCfffbZmDVrVjz44IPxX//1XzF69OiYMGFC7Ny5s9BTAwDIm6RXAB955JGYNm1a3HbbbRERsWDBgvjVr34VP/nJT+Lee+8t8OxIhs/xA6CHJRuA+/fvj7Vr18acOXNyt/Xp0yfq6+ujqamp069pa2uLtra23PWWlpaIiGhtbc3LHOfNy8uwnGgO7iv0DIBepPUjP6cK7iM/Ywvy9Yfx4c/tLMvyMn4xSDYAf//738ehQ4eiurq6w+3V1dXx5ptvdvo18+bNi7lz537i9qFDh+ZljgBwrP7pPws9g270T/+U1+Hfe++9qKioyOv3OFElG4DHY86cOTFr1qzc9fb29ti9e3ecfvrpUVJSkrfv29raGkOHDo2tW7dGeXl53r4Ph+cYFJ5jUHiOQeE5Bt0jy7J47733ora2ttBTKZhkA3DgwIFRWloaO3bs6HD7jh07oqamptOvKSsri7Kysg63DRgwIF9T/ITy8nInfIE5BoXnGBSeY1B4jsGnl+rK34eSfRdwv379YsyYMbF8+fLcbe3t7bF8+fKoq6sr4MwAAPIr2RXAiIhZs2bFLbfcEhdffHFceuml8dhjj8W+ffty7woGAOiNkg7AG264Id5999144IEHorm5Ob7whS/EkiVLPvHGkEIrKyuLBx988BNPP9NzHIPCcwwKzzEoPMeA7lKSpfweaACABCX7GkAAgFQJQACAxAhAAIDECEAAgMQIwB526NCh+Na3vhUjRoyIU045Jc4666x46KGHOvw+woaGhhg1alScdtpp8Sd/8idRX18fq1evPuK4DQ0NUVJS0uEyatSofO9O0enK4/9RX//616OkpCQee+yxo449f/78OOOMM+Lkk0+OsWPHxquvvtrNs+8d8nUMnANd15VjcOutt37i8Zw4ceJRx3YedE2+joHzgK5K+mNgCuG73/1uPPHEE/HTn/40zjvvvFizZk3cdtttUVFREX/7t38bERFnn312/OAHP4gzzzwz/vCHP8Sjjz4a48ePj40bN8agQYMOO/Z5550Xy5Yty13v29fh/biuPP4feu6552LVqlVd+lVBzz77bMyaNSsWLFgQY8eOjcceeywmTJgQGzZsiKqqqnztTlHK1zGIcA50VVePwcSJE+PJJ5/MXT/aR484D7ouX8cgwnlA1/hb0cNeeeWV+MpXvhJXX311REScccYZ8fTTT3f4X/LXvva1Dl/zyCOPxI9//ONYt25dXHnllYcdu2/fvof9NXb8UVce/4iId955J+6444548cUXc9seySOPPBLTpk3LfYj4ggUL4le/+lX85Cc/iXvvvbf7d6SI5esYRDgHuqqrx6CsrOyYHk/nQdfl6xhEOA/oGk8B97A/+7M/i+XLl8f//M//RETEf//3f8fLL78ckyZN6nT7/fv3x49+9KOoqKiI0aNHH3Hst956K2pra+PMM8+MKVOmxJYtW7p9/sWuK49/e3t73HTTTTF79uw477zzjjrm/v37Y+3atVFfX5+7rU+fPlFfXx9NTU3dvxNFLh/H4EPOga7p6r9DjY2NUVVVFSNHjozbb789du3addgxnQfHJh/H4EPOA7rCCmAPu/fee6O1tTVGjRoVpaWlcejQofjHf/zHmDJlSoftFi9eHDfeeGO8//77MXjw4Fi6dGkMHDjwsOOOHTs2Fi5cGCNHjozt27fH3Llz40tf+lKsX78++vfvn+/dKhpdefy/+93vRt++fT/xdOTh/P73v49Dhw594jfIVFdXx5tvvtmt8+8N8nEMIpwDx6Irx2DixIlx/fXXx4gRI2LTpk1x3333xaRJk6KpqSlKS0s/Mabz4Njk4xhEOA84Bhk96umnn86GDBmSPf3009m6deuyn/3sZ1llZWW2cOHCDtvt3bs3e+utt7Kmpqbsb/7mb7Izzjgj27FjR5e/z//93/9l5eXl2b/8y7909y4UtaM9/mvWrMmqq6uzd955J/c1w4cPzx599NHDjvnOO+9kEZG98sorHW6fPXt2dumll+ZlP4pZPo5BZ5wDh9fVf4c+atOmTVlEZMuWLev0fufBscnHMeiM84DDEYA9bMiQIdkPfvCDDrc99NBD2ciRI4/4dZ/73Oey73znO8f0vS6++OLs3nvvPeY59mZHe/wfffTRrKSkJCstLc1dIiLr06dPNnz48E7HbGtry0pLS7Pnnnuuw+0333xzdu211+ZjN4paPo7B4TgHOne8/w4NHDgwW7BgQaf3OQ+OTT6OweE4D+iM1wD2sPfffz/69On4sJeWlkZ7e/sRv669vT3a2tq6/H327t0bmzZtisGDBx/XPHuroz3+N910U6xbty5ee+213KW2tjZmz54dL774Yqdj9uvXL8aMGRPLly/P3dbe3h7Lly+Purq6/O1MkcrHMeiMc+Dwjuffobfffjt27dp12MfTeXBs8nEMOuM84LAKXaCpueWWW7LPfvaz2eLFi7PNmzdnv/jFL7KBAwdmd999d5Zlf3zqd86cOVlTU1P2v//7v9maNWuy2267LSsrK8vWr1+fG+fLX/5y9vjjj+euf+Mb38gaGxuzzZs3Z//5n/+Z1dfXZwMHDsx27tzZ4/t4Ijva49+Zzp5+/Pjj/8wzz2RlZWXZwoULszfeeCObPn16NmDAgKy5uTlfu1K08nUMnANdd7Rj8N5772Xf/OY3s6ampmzz5s3ZsmXLsj/90z/NPv/5z2cffPBBbhznwfHL1zFwHtBVArCHtba2Zn/3d3+XDRs2LDv55JOzM888M/v7v//7rK2tLcuyLPvDH/6Q/eVf/mVWW1ub9evXLxs8eHB27bXXZq+++mqHcYYPH549+OCDues33HBDNnjw4Kxfv37ZZz/72eyGG27INm7c2JO7VhSO9vh3prP4+Pjjn2VZ9vjjj2fDhg3L+vXrl1166aXZqlWr8rAHxS9fx8A50HVHOwbvv/9+Nn78+GzQoEHZSSedlA0fPjybNm3aJ0LOeXD88nUMnAd0VUmWHebj9wEA6JW8BhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDECEAAgMQIQACAxAhAAIDH/D9wAwF9A+7F1AAAAAElFTkSuQmCC", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure()\n", + "plt.hist(coms[:,:,0].flatten(), bins=20, color='r', alpha=0.5);\n", + "plt.hist(coms[:,:,1].flatten(), bins=20, color='b', alpha=0.5);\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "mrc_array = np.array(mrc_dset)\n", + "N, M, height, width = mrc_dset.shape\n", + "datacube_flat = mrc_array.reshape(N * M, -1)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1f15ec784a34425290031c821e51218a", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "8c9b61bb476748d0a518159e2b6f067c", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1e48ae0ecad94b92aecbbd4c28ac6629", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Perform KMeans clustering\n", + "clusters = 3 \n", + "kmeans = KMeans(n_clusters=clusters, random_state=0).fit(datacube_flat)\n", + "labels = kmeans.labels_\n", + "cluster_centers = kmeans.cluster_centers_\n", + "\n", + "# Reduce the data to 3D using PCA\n", + "pca = PCA(n_components=3)\n", + "datacube_reduced = pca.fit_transform(datacube_flat)\n", + "cluster_centers_reduced = pca.transform(cluster_centers)\n", + "\n", + "# Create a 3D plot\n", + "fig = plt.figure()\n", + "ax = fig.add_subplot(111, projection='3d')\n", + "scatter = ax.scatter(datacube_reduced[:, 0], datacube_reduced[:, 1], datacube_reduced[:, 2], c=labels, cmap='viridis', marker='o')\n", + "ax.set_xlabel('PCA Component 1')\n", + "ax.set_ylabel('PCA Component 2')\n", + "ax.set_zlabel('PCA Component 3')\n", + "ax.set_xticks([])\n", + "ax.set_yticks([])\n", + "ax.set_zticks([])\n", + "plt.show()\n", + "\n", + "\n", + "label_image = labels.reshape((M, N))\n", + "\n", + "plt.figure()\n", + "plt.imshow(label_image, cmap='viridis')\n", + "plt.colorbar()\n", + "plt.show()\n", + "\n", + "# Reshape cluster centers back to original image dimensions\n", + "cluster_center_images = cluster_centers.reshape((kmeans.n_clusters, height, width))\n", + "\n", + "# Plot the average images\n", + "fig, axes = plt.subplots(1, kmeans.n_clusters, figsize=(15, 5))\n", + "\n", + "for i, ax in enumerate(axes):\n", + " ax.imshow(cluster_center_images[i], cmap='viridis')\n", + " ax.set_title(f'Cluster Center {i+1}')\n", + " ax.axis('off')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3a11c48809bc48c7bf0791b9dadf948c", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9Z5Rc133n/X5PqHMq5+qcA3IGARDMSQQpilbOVrJljzyjmbF0PR7bY43kx+PRmsfP1dKMrmwvzzy2ZMvKyZJIMYsRBEkQOaNzru7Kueqk+6IpkBByIEEQ+8PVS0LjhH0K1d2/3uG/JcdxHARBEARBEIRrhnylGyAIgiAIgiC8sUQAFARBEARBuMaIACgIgiAIgnCNEQFQEARBEAThGiMCoCAIgiAIwjVGBEBBEARBEIRrjAiAgiAIgiAI1xgRAAVBEARBEK4xIgAKgiAIgiBcY0QAFARBEARBuMaIACgIgiAIgnCNEQFQEARBEAThGiMCoCAIgiAIwjVGBEBBEARBEIRrjAiAgiAIgiAI1xgRAAVBEARBEK4xIgAKgiAIgiBcY0QAFARBEARBuMaIACgIgiAIgnCNEQFQEARBEAThGiMCoCAIgiAIwjVGBEBBEARBEIRrjAiAgiAIgiAI1xgRAAVBEARBEK4xIgAKgiAIgiBcY0QAFARBEARBuMaIACgIgiAIgnCNEQFQEARBEAThGiMCoCAIgiAIwjVGBEBBEARBEIRrjAiAgiAIgiAI1xgRAAVBEARBEK4xIgAKgiAIgiBcY0QAFARBEARBuMaIACgIgiAIgnCNEQFQEARBEAThGiMCoCAIgiAIwjVGBEBBEARBEIRrjAiAgiAIgiAI1xgRAAVBEARBEK4xIgAKgiAIgiBcY0QAFARBEARBuMaIACgIgiAIgnCNEQFQEARBEAThGiMCoCAIgiAIwjVGBEBBEARBEIRrjAiAgiAIgiAI1xgRAAVBEARBEK4xIgAKgiAIgiBcY0QAFARBEARBuMaIACgIgiAIgnCNEQFQEARBEAThGiMCoCAIgiAIl+Tpp5/m/vvvp62tDUmS+OlPf3rOc5588kk2bNiArusMDAzwjW9843Vvp/AqEQAFQRAEQbgk5XKZtWvX8vWvf/28jh8dHeW+++7j9ttvZ8+ePfzhH/4hn/70p3n44Ydf55YKvyY5juNc6UYIgiAIgvDWIEkSP/nJT3jXu951xmP+83/+zzzwwAMcOHDgxOc+9KEPkcvleOihh96AVgqiB1AQBEEQhDfU888/z1133XXS57Zt28bzzz9/hVp07VGvdAOuZrZtMzMzQyAQQJKkK90cQRAE4U3McRyKxSJtbW3I8uvX/1Kr1Wg0Gpd8HcdxTvnZpus6uq5f8rXn5uZobm4+6XPNzc0UCgWq1Soej+eS7yGcnQiAl2BmZobOzs4r3QxBEAThKjI5OUlHR8frcu1arUZvTzNzycIlX8vv91MqlU763Be/+EW+9KUvXfK1hStPBMBLEAgEgMUv5mAweIVbIwiCILyZFQoFOjs7T/zseD00Gg3mkgXGDn+JYMB90dcpFGv0LP/SKT/fLkfvH0BLSwvJZPKkzyWTSYLBoOj9e4OIAHgJft01HgwGRQAUBEEQzssbMWUoENAJBC8+rDksrg99vX6+bd26lQcffPCkzz366KNs3br1st9LOD2xCEQQBEEQhEtSKpXYs2cPe/bsARbLvOzZs4eJiQkA/vRP/5SPf/zjJ47/zGc+w8jICH/8x3/MkSNH+Ju/+Ru+//3v87nPfe5KNP+aJHoABUEQBOEtxnnl41LOvxA7d+7k9ttvP/Hnz3/+8wB84hOf4Bvf+Aazs7MnwiBAb28vDzzwAJ/73Of4n//zf9LR0cH/+T//h23btl1Cq4ULIQKgIAiCILzFOK/8dynnX4jbbruNs5UVPt0uH7fddhu7d+++0KYJl4kYAhYEQRAEQbjGiB5AQRAEQXiLsR0H+xI2+rqUc4WrgwiAgiAIgvAW80bPARSuPmIIWBAEQRAE4RojegAFQRAE4S3mjV4EIlx9RAAUBEEQhLcYMQQsnIsYAhYEQRAEQbjGiB5A4argOA5jpSzpWpmg5mYgGEd+A7ZTEq6cRt3EpSlvyLZZgvBWY+NgX0I/3qWcK1wdRAAUrgpPzQ7zwOQhykYDXVG5rXWA+7tXihD4FpRLFXn8JzuZGU/h87u5+b51DK7uvNLNEoSrihgCFs5FDAELb3oL1RIPTx1BkWSWhpsIaW6emhtmtJi+Ym1K1crsS89wNDePYVtXrB1vNZZp8dD3XuDgzlFwYH4mx4Pffp7kVOZKN00QrirOZfgQ3tpED6Dwplc06lQtgzZvCICw5mG+VqJo1K9Ie47lF/jO0C6S1RKqLLEh3sGH+zegK9fWl1O1XCefKeH26oRj/styzUK2wszYAk3tEfxBD+G4n/Fjc8yMp2juiF6WewiCIAgiAApXgZjbS0TzMl3O0+YNkqqXCbrcJNyXJ3RcCNtx+Nfx/aTqZQZDcaqmwUsLkywJNXFDc88b3p4rZWpknl9+9wWyC0U0t8rWt61i8+3LL3m+nktXUVSFetXAH/RgGhZIEi5NfKsShAthO4sfl3K+8NYmhoCFN72Q5uF9fWuJub3MVYvossq7elbT7gu94W2pWQa5eo2o7kWWJHwuDYCiUXvD23KlNOoGD3//ReanM8SaAuDA07/Yw8Tx5CVf2x/0sOGWpVTKNcaOzDI1vEDvsjb6V7RfhpYLwrVDDAEL53JVBEDLsvjCF75Ab28vHo+H/v5+/vIv/xLnNXsVfvKTn0SSpJM+7rnnnrNe90tf+tIp5yxbtuz1fhzhIqyMtPC51bfxudW38kdrbuf6pu4r0g634qLJ42e+WqJumWTrFWRJIqb7rkh7roRirkIuVSTRGkb3aMRbQjRqJpmF4mW5/o3bVvPOT9zMLe9Yz7YPbeFdn7oFj0+/LNcWBEEQFl0V4yr/43/8D/72b/+Wb37zm6xcuZKdO3fyqU99ilAoxH/4D//hxHH33HMP//iP/3jiz7p+7h8aK1eu5LHHHjvxZ1W9Kl6Sa1LApRNwXdkgIEsS7+lZw7eHdzFTyeOSFW5t7Wdd7I3roUoWS+yfSWLZNn2xCINN8Tfs3gBevxu3TyefKePx6VRKdWRFwuu/PP82siyzYmPvZbmWIFzLRC+ecDZXRdrZvn0773znO7nvvvsA6Onp4Tvf+Q4vvvjiScfpuk5LS8sFXVtV1Qs+R7i2dfrDfHbFTczXFoejW7zBN6wczVyhyD/ueJmpbAGAoFvngxvXsK6j9Q25P4DHp3PrO9bz6I9eYvx4ElVVWLt1gIGVYphWEN4sRBkY4VyuigB4ww038Pd///ccO3aMJUuWsHfvXp599lm+8pWvnHTck08+SVNTE5FIhDvuuIP/9t/+G7FY7KzXPn78OG1tbbjdbrZu3cqXv/xlurq6TntsvV6nXn915WmhULj0hxOuSj6XRq/r7O+t18OuiRkmM3mWNieQgLFMjl8dG3lDAyDAqk29JFpDLMzm8fp1ugebUVTlDW2DIAiCcPGuigD4J3/yJxQKBZYtW4aiKFiWxV/91V/x0Y9+9MQx99xzD+95z3vo7e1leHiYP/uzP+Pee+/l+eefR1FO/4Npy5YtfOMb32Dp0qXMzs7yF3/xF9x8880cOHCAQCBwyvFf/vKX+Yu/+IvX7TkF4Vxqpokiyyd6HN0ulaph4DjOG75jRnNHVJRmEYQ3KRsJm4v/nnAp5wpXh6siAH7/+9/nX/7lX/j2t7/NypUr2bNnD3/4h39IW1sbn/jEJwD40Ic+dOL41atXs2bNGvr7+3nyySe58847T3vde++998T/X7NmDVu2bKG7u5vvf//7/O7v/u4px//pn/4pn//850/8uVAo0Nkpdii4EHXLpGTWCbrcuGTRY3ShemIRXIrCdK6AS1HIV2ts7u4Q26UJgnASMQQsnMtVEQD/03/6T/zJn/zJiZC3evVqxsfH+fKXv3wiAP6mvr4+4vE4Q0NDZwyAvykcDrNkyRKGhoZO+/e6rp/XwhLh9Pakp/nFxAFKZoOE28f7etfR7Rc9SBdiXUcrxVqNZ4bGMW2b25f0sW3F4JVuliAIgnCVuSoCYKVSQZZPrlijKAq2bZ/xnKmpKdLpNK2t5z83qlQqMTw8zMc+9rGLbqtwerOVPD8c3UPFbBDVvYwWM3x3ZBf/fsUteFXtrOc6jsOu5CxDmTSarLCxtY2uUPi87+04DnumZzk2n8KlKGzoaKMnFrmk5xnJZjiaTiFLEisTTXQE35iahLIkcetgHzf292A7DtoZpjdcC0zDQlFl0fspCKfhOBKOc/FfG5dyrnB1uCoC4P33389f/dVf0dXVxcqVK9m9ezdf+cpX+J3f+R1gMbj9xV/8Be9973tpaWlheHiYP/7jP2ZgYIBt27aduM6dd97Ju9/9bj772c8C8Ed/9Efcf//9dHd3MzMzwxe/+EUUReHDH/7wFXnOt7LZSoFco8pgMI4kSbhkhflqiVStTJf/7AHwuakJfnD4AHXLwnZsdidn+b3119H5mtA1emSGw7vGME2bwVUdLFvffSIY7Bib5Id7DmCYFqbjsH96jk9dv5GuaPiinuVQap5/3reHTLWKg8Nzk+N8at1GesOXFiovhCpfFSU8XxepuRxP/ORl5meyhKJ+bvut9XT2N1/pZgnCm4r9yselnC+8tV0VAfBrX/saX/jCF/i3//bfMj8/T1tbG//m3/wb/ut//a/AYm/gvn37+OY3v0kul6OtrY27776bv/zLvzxpyHZ4eJhUKnXiz1NTU3z4wx8mnU6TSCS46aab2LFjB4lE4g1/xrc6t+pClWXKZgO/S6dk1NFlFa/qOut5juPw1MQYsiyzNBzBcRwOpxfYNz93IgCOHZ3lX7/xDMV8BUWWOLJrDKNhsub6ARzH4bnhcWRJYrApjuM4HEmm2Dczd9EB8OnxMeYqBUJuN7IkMVUqsGN68g0NgNeqeq3BA/+ynYnjScIxPxNDSR741nY+9O/uIhw/deGWIFyrHCScS1jIcSnnCleHqyIABgIBvvrVr/LVr371tH/v8Xh4+OGHz3mdsbGxk/783e9+9zK0TjgfS4JNXBfv5MWFCZzK4gKGbe3LzrmDhgMYtoXrlR4vSZKQkDBeM/x/ZPc4xVyFnqUtSJLE9OgCe3cMseb6AXjlfPU158sSGNbF/347UcoyWsmi1KTFb5GORLpauejrCecvnSwwN5mhrTuG7tEIxfxMHE8yN5kRAVAQBOECXBUBULj6qbLMB/s2sCLcQtGoE3f7WRFuPuf8LVmS2NDcyoPDx7Adh7plEdA0BiOv1uCzbRtJ4sS1ZEXGNhcDniRJrO9s58EDR5nOFWhYFj5dY+kl7J6RM2vULIOo4sF2IGtWMSXzoq8nnD+XS0FVZeo1A92jYTRMZEVC1a7duZCCcDqiB1A4FxEAhTeMS1bYEL/wsjnb+geRJYm980ncqsqtXT2siL86TN+/soNDL48xNTKPosiYhs3yjT0n/v6OJX3IEuybnkNXVW7o62J5y8UN8zuOQ8zroTcUoVw3kCRodwdoCwQv6nrChYm1hFi5qY+XnzpCer4ADixb303XgNjNRxBeS8wBFM5FBEDhTU9XVN4xuIx3DC477d8vWdPJvR/eyt7tx7Esm2Xru9lw89ITf68pCncvG+TuZZdeLkWSJJZFEiQrJQYiMRqWRcms0xUMX/K1hXOrlOp0DTRjmTaaphBOBFm9uQ9NF9/KBEEQLoT4rilc9SRJYuV1vay8rvcNud87epdTtUyOZRdQZJl7u5exqanjDbn3a9m2w1AyTaFaI+r30puIvKVLoizMZPn5Pz3LzHgaSYKepa1c/7ZVuL2iNqcg/CZRBkY4FxEABeEChXQ3v7PiOgqNGookE9De+ADiOA4P7DnCM0dHqZsWXs3F21YNcvuKvrdsCHzu4f1Mj6XoGmjGtm2GD02z65mj3Hr/hivdNEF40xFzAIVzuXaLiQnCJZAlibDuuSLhD2A8leO5Y2MEPW6WtMTRVIVfHRpmvlC+Iu35tVqlTmYuS6NuXPZrZxcK+AJuFFXGpaloukoufWWfVxAE4WolegCFt7SaafCrsVGGsxmCus5t3b0XtIvIm1WpXqdqmHREF2shRrwepjJ5SrU6zSE/qbk8k8PzyLJE3/I2AmHv696mIy8e54lvP0M5XyWUCLLtU7fTvfzyDY03d0SZHJonEPZiWzaNukm89Y3ZgUUQrjaLi0AuvhdPLAJ56xMBULiq1C2T+WoRl6zQ7AmcdbjTcRx+evQwT46P4lFdVE2D0VyWP9i4mSaf/7K1qWGaPDcywWQuT9Ctc2NfNwn/2esb/mY7tz+8nxd/dRjbstlw81JuvGc1mn7mItlxv4+Qx81UpkA84CWZLxHxeYgFfEyNzPOzf3qOdLIAOLT3JHjX79xMNPH6rVROTad56B+eoFqsEW4KkRxb4MH//Rgf/+L78YXO/7U4m5vuXUshW2Hi+BySLLHm+gE23nL6hUGCcK0TQ8DCuYgAKFw15ioFvjuym4lSFpcssynRxbu615xxW7Rio86e5BwJr4+Yx4vtOBzNpDiaTl22AOg4Dv+6/whPD43iUmRqpsXwQoZP33AdIY/7vK7x6I928r2vP0a9ZiArMscPTFGvNrjnQ9ef8ZyWcIB3blzBg3uOsFAsE/F5eNd1Kwh73Tz66PNk5gv0LGnGthzGj8+x57nj3PGujZflmU8nNZ0hnyrSs7Jzcas/t4v58QWyyfxlC4DBiI/3fPo20sk8siwRbwmhqKL+nyAIwsUQAVC4avzr+AGO5efp8oWpWiZPzQ7T6Yuwpan7rOc5zqv//3L/TputVNk9NUPc7yPq9WDZNsOpDMfmU2zqPvfwZ7lY4+lf7MEwTFq7Y1iGRXahyIu/OsQd79541l7Ajb3tDLbEKFbrhH0efPrinsrFXAWvT0eSJBRVwqWplArVy/bMp+P2uXHpLsr5Cv6wj1K2jObRcPsu7xxJTVdp7Yqd+8DLyLRtnpkYY8/8LKosc0N7Fxta2t6yi22EtwbnlY9LOV94axMBULgqNCyL6UqOmO7Do2p4VI1UrUyqVjrjOQFNZ31zK0+Oj1Iy6tRMkzZ/kGWx8ysCnawW2ZWaom4aDIQSrIy0nPJD33YcHMdBeeXzkiThvPL581GvNTANC0WVwQHVpeDgYFvOeQWMoMdN8Dd6Gjv6m5gaXcCdK2NbDpZl09Z98TufnI/OZW2svX0lux/bz8J0Gk13ceO7NxNri76u9z0fxWyZ1GwO3aPR0h1DPkOP8Zk8PTHKj44exCUrWI7NaD6LS1FY0ySKTwtvXg7SJc0BFEPAb30iAApXBZcsE9Y8jBYzRHUvDdsEHPyu0w+zHsrMs29hFkO22djeSqNhEXK7ubW7l4Tv3EOSyWqRL+99lIO5aRxswpqPP1h2C3e2LTnpuKjPy9LmBC+NT1GqNyg3GrQEA/TFzy/4BMM+epe1kpzKkJrLYduLwXHdTYO4tIv78rzpntVUSjVGD88gyRLX37mCtVsHLupa50tRFO755O0MrO2hmC0TbgrSv7bniveSjR+Z4Zf//AyZuTwu3cW6W5Zxx/u3oCjnHwJ3zs2gKSpdwcUFJ0fTKQ6l5kUAFN7URB1A4VxEABSuCpIkcX/XKr49/DJDxQVkZNZE29mUOHVruQOpOf7p8G7yjRoSiz2BH1u+njXx1vO+30NTh9ibHSfg0nHJOul6kW8O7eDW5n52jE2xc2IKSZLY3N3Be9auwLJt9k/PEfTorOpsYsfcBIossybRQkfgzCtVVZfCu3/nFmzLZujg4jWvv2sl9//2jRfzMgHg9bv5rY/fSDFXRZYl/CHPGxLEFFVh6abXN2j+mtEw2fvUQVJTafwRP+tuW4k/7DvlmMe++zyZZJ72/ibKxRo7Hz9A52ALyzaef9FwRZKwncU1kY7jYOMgi+FfQRCuciIACldcrl5lpJhCkiQGAnEC2ul79QZDCf7t8puYLOfQZIXBUAJdOfUt/EJykpLRYFl0cah3KJdmx9zkBQXAuWoey7EJaYvlU2qWQaZe5KmRER7YfxxFlnAcGM/kmCt0M5nNY9g2Y4UsL+2epiUUQFcVXpiZ4nfXbDzrVnFN7RF+/89/i1Khhu5x4fZo593OM5FlmVD08iy+eLOxbZtH//lpdj6yB0mSsAyLsQOTvPdz9+HxvfreqZZqFLJlok2Li0WCER+ZuTyF9JmnDZzO1o4uJg7lOZ5JYzk2UbeH9c3n/14ShCtBrAIWzkUEQOGKmqnk+afjLzFZzoIj0ReM8YnBTcTdp1+lm/D4SXjOvoLXtG0U+dVvXrIkYdoXVtWq3RdGkWWy9Sq2Y7NQKxLSvDw8dgwc6IpEABhJZXjo8DF01cXSpjjbUxMUC3V6CLMsluBIJsXOuelz7hWsqMpbNrBdbtm5HIeeP0q0JUwwFsCoG4zun2D84BTLNr/aA+nxuwlEfCxMZfAE3FQKVRRVJnCBr/PWtk50WeFAKokqKWxqa2cw+vrOqRSES2Vf4hzASzlXuDqIAChcUY9PH2O8lGUwGMdxHIbyKZ6aHea9vWsv+ppr4q28kJxgd2oal6zgkTXWXUDvH8A7OlaxNzPJztQ46VoFGwenVudJ8zgddgRPVSNbrzJfKaE7CmHP4jCr5di4JIWGZS+uwpUkapZ50c9i2TazmQIN06IlEsCrX3rv4NXOMm0s00Z9ZY6k4lJwbAfLtE46zqWp3PmB63noW88ydTyJ5lbZcNsKlqzvuaD7SZLExtZ2Nra2X65HEARBuOJEABSuqHS9gl/VUCQZJHArKtl65ZKuaWBgKSYzlTwKMne0DbC55dS5gmcT1r38l7X38h+f+zGl+izN7hBeWWe8mGXcTjM7VcVxQFVkWv0B0pUqbpcLzVap2yY2DpPFPC5ZYUnk4nqLDNPip88fYM/oDKZl0x4N8b6b19AWff0KOl8NIi1hOpe2cuzlEYKxAKVcmXhHlLaBUxdl9K5o5yP/n/tIz+bQPS5aexMXvApYEK5GYghYOBcRAIUrqssf5mhunqJRx3YcapZJhz980ddL18o8NHWEFp+fDYl2svUKyVqBsVKGgeCFBbGw5sUtefBIHvyKG0mS8KoaRbtOIuCjye0n4fcxXy3T7gmSXCiSzVaJaG4KtRod4SDbBgbZ0Nx2Uc+ya3iaF45N0hTyobtUxhayPPjSYX737s1XfHXtleTSVN7+6bvwhbYzfXyOlp4mbn3f9USaTr/YJhTzE4pdvp1fBOFq4HCJq4BFAHzLEwFQuKLe1raUTK3C0fw8ADc093Bry8WvJC0YdSpmgzbvYhgIax7mayUKjdpJx9mOw3AhxUK5TIc/RFcwctrrrYg2cyg3Q6pWRpFkarZBRPOyItBEsz8AQKZepSsSppJvsKwpQcTrYTZfoNUJcGN790WvGM2WqjiOQ8C7uLAh6veQzJUwLRvXNbwDRilXpl6pc/fHb8P9SsFrQRAE4cKIAChcUQHNzSeXbGG+VkRGIuH2o1zCEF1M9xLRvEyX87T5gqRrFQKqTuI1i0psx+Gfj7zED47to9io41E0PjKwgY+t3nBKmPjk0uuYnE+zY2EMG5ulgQTXdwyye2YOB4m6ZeLTNNySSs00WdK02MsoSzCTL5Cv1oj5vGdt82Q2z3gmhyrLrGxtIuBe3D0j+Erwq9Qb6C6VXKnGQFsM9QJq2F2sSqlGpVQjEPaiu9888w73PnWIp37wPNVSnVAiwLaP30rv6q4r3SxBeNMRi0CEcxEBULjiVFk+0WN3qYKam/f1reWHI3uZqxTxqhpv71pO52uGlQ9mZvn+8X1UagYxzUfGrPCtoy+zJt7KuraTh2tLs0W6njZQs35QIKJKbHxvhEiPl4OpeUK6zp29/cgNhxekSdL1Mg3ZJFutknD5cbvO/iV2aHae77y8l1ylhgMMJqJ84vqNhD1uNvS3MzqXZt/YLJZl0xoN8vZNyy9bj9f4fJaFQhmf7mKwLXEiWB54aYSnfr6barlOOOZn2we30NnffFnueSlmR+d57F+ewTJtIs0hFibTPPSNJ/n4F9+HL3j2kC0I1xqxFZxwLiIACm85KyMtdK0Ok2lUCbh0ovrJ4WC2XKRUbxDTfbhVlbjiY75aYjSbOSUAHt41Tm6hxMqlHUiSxPRYisM7Rvj45+7Bsm1kSUKSJKqGQXzkKE+mjlPHRJVkbm3uP6m3rlitk6/UiPo9eHUNx3F4+PAxSvUGg4kYpm1zbD7Nzolp7lraj1tT+cAta9myrAvTXAyAId/payReqBeOTvCLnYep1BsossymwU7eff0q0rM5HvvhSxiGSSjqIzmd4aHv7uC3//AePJd5X9/zYTRMXnhwF8dfHiG3UGBudIFVNy1FkiSauuOkpjPk5gsiAAqCIFwgEQCFt4TZUpEHho+SrJRo9we5r38p3f7Tz+tr8QVwyTIFo4ZL8VKw6rhQiLlPrQ9nWTayLJ3odVNdMkZjsdzIa4eqVUVGClu02QHiqg9VU8hQYm9mms2Jbn5+8ADfOrSTklUjoQb4txtuYmNPJ4VaA7+2OI/NpSjIkkSl3jhxXZeiMNB6/otXLNsmXaugyDJR/fQ7gBQqNR7ZcwwJGGiNU6rWeen4FKu6mrGTFUqFCt1LFvc9bumMkZ7Lk0uXLikA2rZNo26iu10X1IO5/Wcv8dT3n0f36uTm8yTHF4i2hmgfaKWQLuH26XiDnotulyC8VYlVwMK5iAAoXPUK9TrfPLCb0VyWoK4zkc+RrVX5zLrNeFyuU45fHW3lt3pX8tPhg0xV8uio3NY0wKaujlOO7R5sYe+OIabHUqguhVqlwbI7T51zVjUNqpbBYDROWFsMJMcKCxSNOvvnZvn7g89RcRbD3lgjzVd3PcnXEu+nPxHl+ZEJNFWhYZooikxbKHDBr8HIfIah+RTPpscpOHU0RWFDUxvvHlh5ym4plbpBrWEQDSz2mvk9OrO5IqVag7hPR1UVKsUavqCHYq6C5nbh8V78PMCpkQUe/8lO8pky4Zifu95zHW095w61juNw8LljeAMemrritPQkTvQCGnULt0/n5vdsPePqX0G4ltmOhH0Jq4Av5Vzh6iACoPCmlalXGC2mkSWJgWCCgOv0PVCTxTzj+SwDkQiqrBB1exjJZZkpF+kPR085XpIk/v36m9iU6GQsl6PFG+D6rq7ThsWlazu5p76F3c8dw2hYXH/nCjbfvvyU43yqRpPbz/HCAm5FpWQ0cEkKcd3HwdlZinaNTncEWZLRNJWFRpHRbIp3rFpG3TAZTmVQZZl7lg+yvvPCysa8PDrNj186wKHKPLMUafcFWdIa58npERIeH3d2nbyqOuRzEw/6mEoXaIsGyJdr+HSNRMhPZyzEmq2D7H3+OAtzeXTdxc33rSMcv/BQClDMV3jg29tJzeYIR/1MDCV54Nvb+chn34Y3sDicfbYeQUWVsaxXd3FJdERZunmQ5qXtBKN+1l4/eMFtchyHqWMzZGZzeIMe+tZ0o1zDq6qFtybRAyiciwiAwhVhOTZHcvOUjBpxt5++QOykIDBVzvHPQy8xXc4D0B+M8/HBTcT0U4dpFUlClmVM20GVF7eCk1/ZhePM93fQ0WjWA4R1Dy7l9AFAkiTWbOlnzZb+sz6PIsu8p3ct3x3ZxVylgCar3Nk2yOpoG1OZHIokUzUNfC6dqmmgygoBt4ewx82ntm4kX63hUmT8+tmHWWfn8+w7OoNhmvS0x1jS18Qj+49j2jaaTyFieiiVG9RrFi5VYaKUP+UaHs3Fu69fxU92HCBVKOPWXLxt3SA9TYtD5ts+sJmBVR2Ui1WiiSBdgxe/AGRhJkdqNk9HbxOKKuMLepgeS/HYD14gOb4AwLqbl3HdnStPKdAsSRIb7lrNI//0FOOHpzANi1BzmJLHy/i+aRwHjo9nuP/dGwlewDDwrsf28fi/PEO1VENxKay7fRX3/s4dIgQKgnBNEQFQOEmmXqFs1onqPnzq4rBf3TI5mJ07UV+vLxi7pHtYjs2Px/axPTmKYVt4VBf3dazgtrZXe3MemznKVDnHwCtbxB3Lz/Ps3Ajv7F59yvV6QhFWxprYMz+LS5YxHZtNLR20+0+/Y4btOPxk7yGeGx7DdhxkWeam/m7es3blRdfsA+jyR/jsiptZqJXwKC4Sbj+SJHFrdz8PjR3mQGaGlFFCkWXual/KYHzxdZQliYj33AFmdqHAd36xk2S6iCzL7Nw/wZ03LqNmGPjdOh7bRcasIjlQNw0akk1YO/2ikZ7mKJ+5dyu5UhWfWztRcgYW9yVesubCdk75TbZtc3jXGAdeHCEzn8cXdBNvDlGrNihkirz02H7CMT+O4/D493egu12svXkZlmmRms0BEG8Ns/Fta3B7dUb2T6C5XRRllYNHk7R3RJGAY0dmef7ZY2x7+/ltHVjIFHnmRzuQZZneVV2U8xX2/uoAyzYNMLC+95KeWRDeTEQPoHAuIgAKwOKw2FOzQzw2c4yqZZBw+3lf7zo6fWH+eegl9qZnsHHwqRrv7lnD1qaei77XUCHF9uQoUd1LSHMzVynw6MxRVkfbTizESNcq+FX9vLaIc6sqH1u1jt7JCOlamSZvgJs6us7YqzeRyfHi2CQJv4+gx02uWuPFsUk2d3XQFQ1f9HMBeFWNbv/Jw85+zc3/dfPb+fnxA8yVC0iqzIbWDkaKGQZC57/A4/DQLMl0kYHuBJIkMZPMs/vgJJ2dIfZNzNEc8DNrFSnJDbJWjXXxVm5q7znj9TyaC0/01GHvS2XbNj/628d45oG9i7u71C1y6RLtvQl0t4bH7cKtSTR3LgbgyeNzDO2fYGBtNw/90zMMH5gEoH9VJ/d8/GZW37yc1TcvDrt/95+fw+PRcLsX2+3xaBzbP0lH2E20NUxr79l7K6vFGrVKnUhzGABfyMv8ZIpKsXrZXwdBuJJEHUDhXEQAFAAYLqZ5YOoQLkmmye1nqpLjR6N7uKWln73padq9YTyqi6lyjoenjrA22oZXvbiFAWWjjmFbBF+Z0xfWPcxVipTMOjEWA2CXP8JQYYGg4cZ2bOq2RYcvfMZrBjSde/uXnNf9a4ZJ3bLw6Yvt9+saqVKZqmFe1POciW3bJ4Y1I24v71u+jn88+hIHM0lGR7L4XBrv61vDlqbu87qe+ZsrklUZw7RINPvJJGsUcjk6PCHWdzWjZw18+y0OzBzluluWEQi/cWVSXnp4H7/81nOYhoXmUtB9GrLbTe/SVjbespTDO44ztH8Cx1msNGaZFpru4sVH9nHwheM0dy2G4oMvHCfSHOSO919/4trReIDDh2ZoNEzAYfzoDEqxROalI/hCXu767VtYd/uqM7YtGA8QbQ4zN75Ac1eCQrqIN+gh2nr6FeOCIAhvVSIACgAs1IpUTYPOUAKANk+IVL1MslbCdsCjLva4BF1uymaDqmlcdABMePwEXDrTlTxR3ctMpUCzJ0D0NfP7trUvI1evcqwwj4zEjU193NTSd+kPCjQH/TT5fYyls8T9PhZKZZoDfpqD579fbKNucvDlUQrZMsGwl5XX9aHpi19OsxNpnvrFHjLzBZo6otx+/zpizSH2pGY4mJmjOxBBV1QmSzkemjzKulj7KSt1f5Np25S8Jil3ndzsNK2qn1rVwN3p5rGJEeIRH8GAG0mCxtE8mZ3zaLqLofoEM2Mp3vvpW3F7L7yMi2mYTB2bpVFr0NydIBQ//bD6rzmOw67H9yNJEIz6cXtdZOZy+N06S9Z0sub6ATweF9Oj84wdmsZxHPxhH0s29PDyEwdxe3W8gcXhcLfPzdxE+qTrX3/DAMnZPGOjC5TzZYxckcGuCLGmIPPjKZ78/nb61nYTjJ5+0YrH5+ae372Th/7fx8nO53F7dW5+31Y6Blsv+LURhDc1BxxRCVo4CxEABQACLjeqLFM0avhVnWyjgldx0eOP4lFdzFTyBFxuZqsFloSaCJ5hbtn56PRFuK9zJd868jIz+SJNXj/v7Vl70irfoObmU0u2sFArIUuLW8Rdyvy814p4PXxww2p+uu8wuWqVznCId69dQdhzfs9kmRYP/+BF9u4YAsdBkiQmRxa478PXUynV+fm3tjM/nSUQ9nJ41xjlYpUPfuYOqpaBAyfCXsClUzMN6pZ51gBo2TY/OLKfZxfGKTXZZPMVLAneu2YV++U0alGmOxwGYP/UDLunMtzc0Yw34MZomIwdnWNqNMXAyvYLep0adYMH/v5RDj1/DLNhEm+P8o7P3E338lPL5fya4zg4lk0o5KFYNnAch3rDIqardPQ3ATC4tpv3fOYuju4e5fCOIUqZIr/8349jSzKVUg3TWKyzWCvXiSRODnLBkJf3f+R6ZqYyHN81ynNTc8SbF8vAhJqCZGazlPMVXLoL3aOdsrAEoGtZOx//iw8u9v4FPPjDpy4sEoSrnZgDKJyLCIACAMtCzVyf6OGFhXFm7SIBl87bu1ayNtpGsXsVj04dpWDUGAwm+EDvOlzyxa+YbFgWQ+M5pAUNDzJmQWEskmdpqImCUSPXqBLWPIQ0D63es/c4XazBpjh/ePsNVBoGXs11xvmCpzM3leHwrjESLWF8ATeVUo2DL4+yYnMvVt1kfjpLV38TsiLjD3qYHU+TTuZpCwXxKC6my3n8Lp3ZapG10Vb8Zyhv82vjhRwvTE+R8PoYiMTI1WoUGnWWrW7l+LEclrNYJsVxHCzbQXIk5Fd2IJFlabEnwL7wX+cPPneE/U8foqkrgdunM3lkhse/9TSf/MsPnTZYLd5PZsXWJSQnUzgOFPJVgkEP93xoK92DLSeO61nezuSRKfLJLOF4EMdxyEyncQd9TB6fRZIkOgdb2LLt1MUdbreLvoFmNNti74Me5idThOJB5idSuL06D/6fJyhmSgRjAW7/8I1Eu+KoiozvNT2gbq9+UT2igiAIbxUiAArA4n687+9bx9pYO2WzTpM7QNcrO2nc3NLP+lgHVdMgpHnQLiAsnc7x+RR7pmbpCUfwai4WSmWeGR5DD0g8tTBEoVEjqLl5Z/dq1sfO3Nt0qVyKQshz4c9iNCxM00J/ZSFCGpOdVoEjDz2F4lKwPTXCjQZhz2IPnKLKKIrCsnCcd/eu4pGpY1SMBqsjrby/by31Sp3xg1OUGjVa+5poa02cVBKnZpo0LAu/65U5i5pGqlqmahpc397FaDbHsXQKB0iEArQm3MwcTOELeKgUa7T3JmjrvvCV26VsGcfhxJBsOBGkkC5SrzbwnGVLuhvftQlZlTm+axSXrrLp7rUs33Jqvb7xw9O4PRqRV3rwcvN5SgtZvCEvvrCPrW9fS7T5zEWe2wdbuf3DN/Hsj3eQmk6jR3xkqwazx2ZobwoxemyGXV/5BfGVHXh9Otet6ebWzYMoyunDqyC8lYgeQOFcRAAUTlAkmeXh06+i9Lv0c/ZUna+qYWLZNh7X4tvPr2lMFnP8bPIAiiLR4g0wXy3xo9G9dPjCJNznPzfvjZBoDdHUFmFqdB5COi8VUhSDEjmzjFGzcEIW2ewkLTkNBbhp3SCJtjCSJHFzax8bEx3ULJOQy02tWOMHX/sFT+WHmG8y0ffp3LVhA5+47mY8r8yxbPUHaPL5Gc1niXu8LFQqtPj9tPoCBKM6qixzaGEeJNjQ0kbbJi/PPbyf5FSGwVXtXHfbCo7smSCzUCAY9rHm+v7z2tYtlAgiyzKFzOKWa5lkjp5VnefsOXNpKre8Zwu3vGfLWY/zBb3UKw0cx8E0LCaOTKNpKi3di4szHv/np2juip+y08dkOcOR/BwOsPTGTj61oZfxiRQ/+9UBDr80jNuvY0kgJwJMzxeI1k0cn87DTx7EzFe4ftMAwdjFFbYWhKuFWAUsnIsIgMIbrj0UJOxxM5bJEfF6SBZLBEIaeafIoC+OIsm0+0KMFNKkauWLCoCWbZOqlZEkibjbd9nmDwL4Ah7u+8hWnvjpy+ybnUcKaHgSLrweDdmRKDZqzDdVqek2Ya+Hwx0NJso5eoOL5WG8qnZiAc3eJw+yfXaI9EYVv+2mnC3z8LE9dLQneEfnGgAibg8fXbmGHx09SLZWozsc5r1LVhJyL/bCrWtpZV3LyYsY7v3Q4spZy7L55Xd2sPu540gS2LbD+PEk7/rUzScWrZzJyhuWMn18ln1PHyK/kKetv5m7P3HbBe3lezab7l7LzPE5xg5MUivXwXFYcl0//rAPSZaZOj7LzPDcSQFwtJjiWyM7mK+VAIftuo+P9G3h4HSGTKVOQJZQgflKnYZhoUkQDLipZsuMHpjkp3snOPLAbt72sVtYvnngjG07E8dxmDw+R26hgC/opXdl+xmHwwVBEN7MRAAU3nCtoQAf2LCaXxw4SrneYEkixg1LO/nB5G4y9QoJt59MvYJX1XDLKtunJshUq4Tdbja1tqOrZ3/bFo063x/ew+HsPJIEa6Jt3Ne1jNlqAQeHHn/sknszW7tifOTfv43+wxP80zO7mGwUkSUZ07Co6gaWB1Z2ttMeCjGUT/HoxBC/v2rzifNtx2HX5DS/mBhjtH1xB5Mmw4Ui6VQqFscKyZPuNxiN80dbbqbcaODTNNTzDB0LM9nF+YqtIfxBD/WawdCBKaZG5ulbfvYt5xRVYdunbmf9natp1AzK+QrP/fQlauUavau72XzvelzaxX8L6VjSyvv/6H7GDkyQTxfZ8fOd1Ct19h2YoJSrUC1W+cXfPUopW2ZgfS+x1ggvpEZJ1cssDS4uKBkuLbB9fphirkE8HkTvNZgZmqPqgAXEE0FkWWJk/wS27RBvDlLJVXj0n5+mvb/5gnoCHcfhhUf288zPXqZeaaBqKhtvX8GdH9giQqDwpuM4Es4l7Od7KecKVwcRAIUrYnVbC8uaE1QNA5+mIUsSGbvMo1NHOZZfQEaiz9vEN3ftYaKYP7FK9ngmzW+vWnvWRRuPTR3jpYVJ2rxBbMfhV7PH2ZkZBcnBcaDXH+Oj/Zto8lz6MGB7p05/t5up4xlm81Xciorjk/C5XEQ9HmRJwqdqZOsnFxp+fnSCH+05SFppkFMlTKeOywClUkNtCxDSTt0ZRJXlE71+58s0bCzLPhHUVJeCbdtYpn2OMxfJskxLTxPTQ3M8/I0nKWZKaB4XI/snaNQMbv/gDRfUnt/U1BmjqTOGbds0KnW+9//8nFK+jCxLWKbD7icOMD+Ron9dN+/9w3dQtRposnKiF1KTVaqWQWtTiJn5PG1L21C9Osl0keXdTdQ1hdHpDLmGSXs8SEfIh+L3kBxPkU8VLygAZpMFdvxyL5qm0todp5gts/vJwyxZ30330gvbv1kQXm8Ol1bJRVSBeesTAVA4L47jYDr2Ja3+/U0uRTkpyL2tbSn9gTjD+TSPDA3x1Mw4k8U8Ud3D1vZuNFlh99wMN3V2Mxg9eVFDsljicHIBx3HYl53Fp2onStUczE0zX69ze9sSZGC4uMATs8f4UN/Gi2677dg8m3qRA7kj0N1gU0yimmyiVFMYl7LMWyW2z0/QE4hgOjZbgl0nnf/86CSKLNHUEmF0KEOlUWTMWyMe1Njc28GtzedX1Ppc4q0h2rrjjB+bIxj1UcxVaO6I0NIZPeM589UCu9IT1GyTLl+UddEORg9MkFvI07u6C0mSSE1n2PvMIeiKMZsqEPC52bK2h6aLnFsnyzLLty4F52eoqkqjbuLYNopLIdoaZn48xa7H9jH4jm72ZaeZreaRkGhYFsuCzazd2kWhWGV8Josr5OXujX381p2rSWcr7N45zJMTaZok0BWZhZksnoD7gsu/VMo1atU6zR2Lr50/7CU9l6daql/UMwvC62kxAF7KIhDhrU4EQOGcDmXneHDyEAWjTo8/yju7V53Ysu1ykiSJ/mCclyZn2JdKUnMMqorBnGFyIJ3khtYuTNvGsKyTzpvK5fnGi7uZzRcAiQW1gB6QaPMFcRwomw38mob2Snj1qRoLtdJp22DZNrlGFU1RT6pL+JuGSmPsyu4noPoJa0Hm5AUGmiSyhQSVeQN3w8VMucCh7Dz3dS/lnu6TA51t2ximxUh+Hn+zimL6cMs6Tf4Q7+q+joFXhjgvldujcd9Ht/Lkz3eTnMwysKqdW9+x/ow7gyxUi/yvw79ivJTBragENQ9Fo4b6mnl/juMwK5uMOnV2PvYirb4AigVj0xk+9s5NhIMXt+vI5NEZkBW8IS9SsUq1VKdWbqB7NHCgnK/wtkQvVavBi6kxwOGGpn5uah7EJSt89J2bmU8XURSZplgAVZFpaw7R+vb1+KsNXnhwN2MHp/CHvNzy3utPrD4+X+F4gHA8wNxEmkRbhOxCEX/Ye9aVyoIgCG9WIgAKZzVTzvOd4V3kjRpBl85LC+PULYPfW3bDec9Du1D7M0kKVo1mj5+GYZE3akxUsiSyPtoDQdoCJ/cyPT86yUyuwJKmOI7jkJ+rUpZrHM+lkCWJLn8USzIoG3XqlslMpUCXP0rDtk6EQoB0rcz3h/cyWszgkhVube3jro4lp11AUjCKWI5N0LW4QCWihVioZ5koSLT7g4Q1NxXTYDif5rrmDgLayWFyY1c7+/eMkw/MIGs2MhIJvQlfyY3bucz16WyHJSvaWLamk74V7Xj8px9GdhyH74zsZPv8CLrsQpNVTNvmmeRxPrlmA7HWCGMHJkkGZYbdUPe78DgNcKqsb2lmJpljZDLNhpUXFwAt00LzuFiYSFGvNrAtB0WVF+sbGhady9pRZYW3ta3gjtZlOI6D+pp/P11T6TzNlm6SJHHLe7cwsLabYq5MOBGipSdxwe3zh7xs+8iNPPKd7WQXingDbm599yaaOs7cmyoIV4rtSNiXMI/vYs/9+te/zl//9V8zNzfH2rVr+drXvsbmzZvPePxXv/pV/vZv/5aJiQni8Tjve9/7+PKXv4z7Aqe7CBdOBEDhrMZLGdL1MkuCi7Xp3IrKaClDtl4h4bk85Vkcx6FQryNJi3v6BnQXjgO2vbgCtmIayLJEXyTK/QPLCOknf2MoN+roqoppWxycnWc2U0TTZdrDEW4f6KM/HOXBqYO8lBpntJheLJuSm+Nfhl/iw30bcSsuHMfhJ6P72ZueodUbpGoaPDBxmITHz/r4qTto+FQvMhJVq4Zb1skbRUJqCE3WqJkm6BIuRUFT1FN2+TBtm2VtcaILFrMpkAwPMZ+HgpTH6/ET9Z06/+9ijR+d4Rf/8CTpuTyyLBFrCdHZm0B1KfSu6mTJdf0n5tPNVQvsSk8iIRHTvFQsg7lKgZjbhy/q5/7P3M3eZw/zr3PTtPs0ynULRZEp1OssVCpILC5uuVi2aZFfKGDbDrrbRb1mYNQNSrkyt7x3KxvuWn3iWEWSuZDRLUmSaL8M2731ruzgE3/6TgrZMr6gB1/w8v1bCcLldCXqAH7ve9/j85//PH/3d3/Hli1b+OpXv8q2bds4evQoTU2njmp8+9vf5k/+5E/4h3/4B2644QaOHTvGJz/5SSRJ4itf+cpFt104PyIAXkG24/D8/CjPJ8ewHYdNiS5uaelHeROtKHTJCrIkYdgWmqJSs0xUSb5scwGrhsFPjh5i3/wcILGhpZUtbZ1snxun0jBQJYn2UJB10VakksN3XthLPODj3WtW0BlZHHrrjUXZNTnL3qk5pnJ5FEWmPRBiLlmmmGjQ2hbiY/2bmSxnsRyb5aEWDNtid3qSpaEmbmjqo2FbjBWzxN0+QpqbkObmaH6B2UqB9ZwaAAf9fUyGZjhcOI7lWIRcQe5ovoEOtcrPRg9zNLuA7TgsiyRYFXt1B4x0tcJ3ju5jOJdixs7RHolgVxUapomkSKzubKIjfPmGFJ/+6U5yC0W6l7WRTeZ4+icv4XUrxJqCRFvC3Pd7d7H65uUAFIwatmEjVW2mSmmsmklZMXBvz/H1oWnC8SDr715DT0Immy6SOTpHtlrHditMGyobu9vp7bjwgtO/JrsUZFlG012oukogFsAyLZZtGeTOj9580rGFTImXHjtAbqFAoiPKpjtXIUkSh3eOUCvXibdFGFjbdckla1LTaYb3jGHbDj2rOmntbcbt03GfRx1FQbjWfOUrX+H3fu/3+NSnPgXA3/3d3/HAAw/wD//wD/zJn/zJKcdv376dG2+8kY985CMA9PT08OEPf5gXXnjhDW33tUoEwCtoZ2qCH4zuRUFCkiR+Mr4PRZK4pfXC65O9XpaHW1gaauJQNoksSciSxLaOZYQuYS/g13p8bJinJ8Zo8vqwHfjV2AjvXLKcjy5bx7Oz4xiWRas3QDVtMlUtEPV5OT6f4nsv7+MPbtmCT9O4obeLYq3OP+x4GVVR6I9HWZqIM53PM5UtAGDj4DgO7d4wLlnBJSs4OBSMGrAYdH2qvtjjpXsxbBvHcU7U6/tNqqxwZ/NNLA8O0rANYlqEsBak0+sQ83iZLRfxqC42JtoJvmb496dDh9i7MEuHP0S65iVtplkea8etKjTwcXP3hf3bp6sVjmVSSJLEkkiMqOfV4VfbtilkSvhCHmzbZvczx8gXG9QbCjgFjLrJzkf2ngiASsmhMlbGaBhU7BqGy0GrOPBghgmrhLxS5unvP4/npl5ePDaD07BQNBm7ZhJSbd5791piF7iwYnj/BAeeP87E0VlGD05StxxkVSXSHMKsNzDqEv7wyT3NtXKdf/3fTzCyfxLdo3FgxxBzo/OYps3wvglAwuVWue09m7n+nle3krNtmz1PH2Hfc0dxHFh9wxI23Lb8jCVc5sbm+fFXH2B+YnGXlWhLiHf+u3vpWdl5Qc8oCFfCG90D2Gg0ePnll/nTP/3TE5+TZZm77rqL559//rTn3HDDDXzrW9/ixRdfZPPmzYyMjPDggw/ysY997KLbLZw/EQCvoEPZOWzbpjcYBxaHW/dlZt9UAdDn0vjk4GZeSk1SMRs0ewJsiHVctmLAQ5kMXpd2IrgUG3Umi3l+d9113NTWS8M2SeXL/NPkHgYSMSRA1kyGizMczyRZ19KJS1F4x6plpMsVnh+dYGkiBtLijiO/Hk7VZZVmb5BDuTl8qkbVMpAlmZi+GFhkSeLtXcv47tBu9mfmqFsm/YE4y0IJTMvChlO2wFMkhU7vyeU/ZEliQ6IdTjPFzLRtRguLvYxBTWe52s9LuRpFq0rcF2VDdAUrQ904jsOBdJKpUgGPqrI+0XZi2HuykOex8SFytRpBTWcsn2OhUgagKxTi4yvXk06XSRcr+N06ie44h7YfZ2xogUy2AqoCLo2yKWHM5Smkiyfalz6SoeWYitPnJZlt4Gk4BF6q0iL5MUwD3aNRLlSJTZdpLthYzX40SaKtrhAo2wRcF/btZOTgFD/730+QnsszeWwWx1ncbi49m2N2IoPfrzGwtptVNy476bzJoTnGD8/QuaQVl6ZSKVZ57sE9FDIVAmEv8dYwqqrw4iP7aOtvIpcuo6oKpUyRJ374wol9kh/9znYUVWb9LctP277dj+8nOb5A60ArxWyZiWNJnvnRDhEAhauC4yx+XMr5AIVC4aTP67qOrp/aA55KpbAsi+bmk3eTam5u5siRI6e9x0c+8hFSqRQ33XTTYqUJ0+Qzn/kMf/Znf3bxDRfOmwiAV5AqKVjOYk+TJEmYto3rTTT8+2sBzc0dbafu5XqxSkadmUoBl6wQ0DQqhnFi7ljdMvFrOrK0uJgCwKjZqLJMxWhQUNOM2ZPU3Q1+nrTRPTeyPLRYYmXb8kGSxRIj6SwS0BePcstA74n7Lg02szs1xUupCRJuP3e0LmV99NUf5mvjbSRLZb57ZC/VmsEL6VlenvgpiiTT6gtwXUs77166grj34hY5KJJEUNMZL+RIeLzIjosY7WxrGuD2jgFCLi+SJPHU1Cg/HjpAzTIB2DU/zadXbcawLL5xYBdThQI+zcXh1Dy2A3d29yFLEscyaf7m2R2Y8yaWtVjnb2lXjI5MK0M/24OEhKbKKIpNI+xgGSadK18d3rYsm+aCTn86xp6deaQK1KYdGrKJ2WIz25ulVmkQTzTRO+aiXYuguhSypQK2CorrwqYFHH15lGKuQrw1zNTxOarlKpIsE2mNYFsWN927lrs/dgu9q04OXI69WOBClhd/CSnmqyxMZxf3LfbrTA4libeGcAc8/PDvfkWlVEOSJEq5Ml63Qs/yxWeeHk5ybNfYGQNgtVTDduDIrnFKhQq1cp2dTx7hnt/JkBALP4RrRGfnyV9/X/ziF/nSl750Wa795JNP8t//+3/nb/7mb9iyZQtDQ0P8x//4H/nLv/xLvvCFL1yWewhnJgLgFbQp0cWh3BxHC/NISARcOtc39ZzXuWWzyqHCcUpmhZgWZkVw8KQVkW9WM5UCf3PgWYYLGVyyzKpIK00+L0czKSSgIxDklq6ek87pjUVY19HKLyf2seCZRHJkegJxkC0ent1JhzdBwOWhJRjg92/czGg6A0B/PErwlZVkO1OT/HLyMCoqHlnHo+isj3aetJK5ZhrsmJzCK7mpyTZzjTL5eg2P6qJk1Ck16tQskz/YsPmCV0CXjDqTpTyrEk2kaxWO5hafd2WshTs7lp0YJq6ZJo9ODOGSFXqCEQzL4mg2xb6FWVySwnSxwGA0SiVfw65Z5Mw6h0bmsBs2BalB0iiwOdBONOClWjc4vpDl3fetYXIkw+TxaQynhrmljNRq4PXpmHcaVMwqXtVDR18Cf9BDba5GggCz8wt43SoVbxnjdgWzOYs34CHXW8Vn+5h4aRZZlpEViRvevh5/6MKC8eIvPiDJEpVyjUbdxBvwIKsKmtvFnR+9hb413aec197fRFtfMxNHZ/EG3EwOzeH2udHdLizLRpYlZsZSJLoTKG6d7iUtmIbFC4/OUfOo9LxyHcuyUc8SWjuXtfPYd5+nVKzhD3mxTQsHeOnxA7z9E7dc0LMKwhvtcu0FPDk5STAYPPH50/X+AcTjcRRFIZk8eRejZDJJS0vLac/5whe+wMc+9jE+/elPA7B69WrK5TK///u/z3/5L/9F7LDzOhMB8ApaGm7ik0u2sD8zg43DinALK8LN5zyvZtV5YPYJRsuTyMiLhXnrWW5vuv6yDc2+Xv7uwHaemh5Fc1QcHOYrZX536Wbepg8gSRJLY3ES3pPnkbkUhWVdcR7ImMgyaLgpOQ0cO0TJrFIwygRci0O9YY+b9R2n7srw6PQRikadJaEEqiRzJD/P3sw0fcFXFy0UGw3y9Rq24zBdLCBLEo4DUd2DhYPXpTGez5GpVmjynf8K6GSlyD8ff5nRQoZytow5XqQ5pdDX08YHN64+aY5gw7YwbAuP6jrx7CBRt0y0V4ZY5ybTTBybp6BUyWkGR5JzhIM+cmYNf11Djy6GGremLu6w4YXqnR7mluqonjIev4O74KN1VRu7q8fQ5wK8s+MOugaauffD17PjsYOEIl6WruukrS3MXv9x5iN5Wl1x4i1RFqQsiW0xtvSvolqqkWiPsvL6wQt+7w2u6+bwi8OkphcDuyRLyIqMx6fjDXiwfqPe46/5gl5+69O38/yDe8gk83iDHubG04TiASaPzS6WeokHaO1pQtUWdw1xaSrhRACz1mD00BQg4Q95WHPj0jO2b8Odq3nkO9sZ3juOJEt0LW1D93soZk9fQ1IQ3kwu1xzAYDB4UgA8E03T2LhxI48//jjvete7gMV5t48//jif/exnT3tOpVI5JeQpr0y1cS5l/Fo4LyIAXmFLQgmWhC6sJtlEZYaJ8gzt7hZcskrBKHG4MMT6yAoi2skrSB3HIW/UMG2LiO5dLJ/xBqoYDdK1Kn6Xhkd1sTM5hYpCwuvDsh2mKlmO5VLcsXqAw4VZ9ucn6bZi9AcWXxPbcRZX7KZmCbp9aGoAFZViw2CkNMuKSAt+9cylOBzH4VczQzyXHKNi1MnUq6yKtKBIEg375IAR1HXKjQZ75ucom/UTC0EkSQLHwXYcVEk+ZS7guTw0eYShfIqEoTF3aIGMZhAw3Cw8cJQdDTf3/f5dJ8KTVDGJNVQOVtLYkQhlo4HfpdEZCNPs9dOq+3j60DEU1cGjafiKNrZtIkkOy70J8ukKQzNpupsi5CpVQn43L1VHKPVAizdB3lVA1jx4vDGSah2rWuGRmT0M+JazMtLKsnXdLF3bheM4J74xG1MScmGMDu/iLydKVUbRZW54+/oLeh1+08CaLu771K3seHgv2VQRj0+nrbcZy7YxDQu378wLjeJtEe7/9O0AZOby/PDrjzA3niLWGibeFuGuD17P/GyePc8dx+3VMBoWgbCPDTdvQMbGcWBwbTf9q888n09RFW565yYMwybaHEJRZdJzedr6Lk+RbkF4q/n85z/PJz7xCa677jo2b97MV7/6Vcrl8olVwR//+Mdpb2/ny1/+MgD3338/X/nKV1i/fv2JIeAvfOEL3H///SeCoPD6EQHwKmQ5FjYOirT4BeKSVapWDcs5OdCYts0DUwd4aWEcy7HpDyZ4X896wqfZZ/b1MJRN870j+1molPGoLm7u6EZFwZEMnFeCXdk0eHZ6jF3ZMTyaRNTjJehy896eDdiWzMNTR6kYDWbLJRRbo8XVyqwxja0uYEgOJhq7snu5ObEZVT717Xwsv8ADk4eIal4alsl8tcjzjRrLI80sDS3+IG9YFvlqjYrZQJIkApqGJEHBqGPZNgvVMlG3B1WWuamz+5Q6hOcyVykSdOlU58vYZQN/2I3c5CWSlxjaM0atUsfjczN2cJJf/r9PUErnMLtgZlmD3v427ulZwpLI4kKh97YvY+xXoyghDXdDITUjY9dNlgYTJHxBJoN54k0h6pZJczjAhtWtPJjdR28ojjemMVOzGCkPU3BqxCw3dQfqwOOzR1gZWayTJ0nSSb15/f4OjhbHmaulkJCwHJtBf9fpHvWCSJLEsuv6WLqxl8F13Tz7892UC1UUTWHDrcvpHDz9sNFviraEePcf3MXBF4aoVxq09zezYnMfxVyFaqXO1PA8siKz5a6V3P6ujSjq+f9g2XL3GgrpEsf3jGM2LDbcuoJNr6lHKAhvVleiDuAHP/hBFhYW+K//9b8yNzfHunXreOihh04sDJmYmDipx+/P//zPkSSJP//zP2d6eppEIsH999/PX/3VX110u4XzJwLgVajFnSCqhZiuzuFTvRTMEv2+LkKuk7vpX0qN88TsUcIuLx7Fxe70JF5V4yN9173ubayZBt8/eoDpUoGOQJBcrcaj48Ms9TfzcnaC+XqJfL0GpoxXVck0sngND31+HzW7zg/HdtOoyxiOjd+lUTCqVBsmLjmKKst4ZIkmLYFtuXgutYuwFmR9ZNUp7UjVytQsg/XxDsaKaSbKOQzLYlv7MtZG25jJF/jBrv1MFQqUnBopq8pNHV0Yts1sscixTIpmb4BNre3c3tfHxpa2Cx7qbPOFGClkqDk15mIWtmbQ1LAwDAdd11BUhXq1wcPfeJL0TIau3mbCC0VKE1k+/Ec3M9jyai9VU8LPGk+UyniZWFOQnWaFnAWNisWMUWDtkjbef+8GTNtGd6nM1ws8nJMxXuntDCqt2PYUVqPAQimHU3ZhFg1mlqRxljunfbaVoX4M22Rv7jgODqtC/ayPnnno9FxmqnNMV+dQJIU+XxdhLcQNb19Pe18z2YUC/qCXvtWdKMr591Yn2iLc9u5NJ30uFPXzvn9zB7lUCcWlEIr6Lvjfzu3Tue93bqWQXhz2Dcb8Yl6ScFW4XKuAL9RnP/vZMw75Pvnkkyf9WVVVvvjFL/LFL37x4m4mXBIRAK9CES3EPS23sj39MgWjxMrgIDfHN+H6jR6wmUoex3GIv7Jvb9VqMFJMvTqs+TrK1mqkKmVafX40WaHF5+d4Ns07+paRcPs4kl1gqJKmOxglFJCpVUtYhkOhUSfi1ZmpFMDUWRZe3IFEiUhMlvL0haJMmOPkGz7SZYtMOY/iqrHXPXLaABhw6SiSQsU06AvEccmLe/ze3NKPadv8cPcB9i/MUPAWyZplslaNRrbGikA745kcjgER201yvkS5qXFRRbrv6VzK4WySp5VZKmEZpdxgtJZFd2u86461SC6Zwmye/EKBeEcMze0i3hqldGCS4nwR+5Xh51/NHeG5+SGy1zcoH6lijcLSWAh/X5xAU4BELMCNG/rQNZVfzyps8QRZF+1g+8IIC/USlm0TK/cwOjWGV9HRTA+ZepXy7gXsm+3T9o7JksyG6HI2RE9eLes4DscK8ySrBTyqxupIG418jcxsDrdPp7k7cdL7bO+uEX72wnMk2yYIt7gJhbwccMd5R+tdRPUIPcvbT6zQvVwUVSHWcmmFtWVZJpw49xwoQXhzubQewAvaake4KokAeJXq8LbwAe992I6NfIZ5fQGXjvnKUKsqyRTNOi3e0GUJfzXT4ImZ4+xJzeCWXdzTuZQVr9nxwq9p2Ng8Pz+OIsmoskzE5aMrFOLu3gHSlQr/v107KBsN3IqEhEzdqVO1G1h1gw5vlJliGcuxUSWFqmXS4Q/x79Zs5etHpthVzxDTAsgSpMwiR9JZnL5Tg+2KSAvXN3XxwsIEM5ZFUHPzjq6V+FwamXKF6XyBordIRaoR1/2Lw8EUOZSdo2FabG3tpMsfZiZf4NmRcW7q7yZdrVC3LBJeH16X65yvVcLjZzAYZ6qcozXWTXW6wHiwwESPyo99Sb7zyE9YHWpiPqaQzmRojYWxCw3QJPYoGX6+61HS9SIZM09vIEZLLMzUGofIdU18on8rwciZiy/Lksy7u9bT5g0zXysS1jw4yRzfPbhAeYUHW3LoqwVoH1sse+K/gELOz82P8LOJfdQsEwlob3hx/3SOwkweza1x3d1rue1DNyLLMk88sJv/+bcPY9+YQVEN5kY8bNocIhlLcbgwxI2JTee8nyAIgnD5iAB4lTtT+APYnOjhcG6OoWIKB4eE7mdb++lrnl0I23H47shuvn98D/lanYZt8dDYUb60aRs3tL9atsNSbPKNGjIShmPjDWm0+YO4FIWWQID7Bpbyg8MHSBfquG0vmttF1ONhRbiVO1qW8b3hvRzLLyAhoSsK93Yuw626CMsdVOrHqJlzSJKEjh+kCLbjoPxGAFRlmQ/0rWddrJ2KaZBw+2nzLfbmeDQXqiqRM6qEdQ+SLRGQPISDGku0FqaMCp2+0InrGJbFT48d5oWZKQzLoj0Q5MMr19AZPHcPk0tR8Lt0WkNhGsEAhycr1A2LoVyGQqPOntlZfAMWYTXFkD5NsFkmsamdncoCfkMn2ygzWcnR5gnT4nHT7AuQpYY7eO4tyTRF5ebmV+s4HowfpWdOxy/7cAfcLBydJ9EXx+M//7mNJaPOYzNHUCSZwWCCcqPOM/v201t3WNffTilX4flfvEznsnYG1vfy7f/zOCXDJOoBx5RpVA0OHZhm7a0t1O3Ged9XEITz4zgSjnMJcwAv4Vzh6iAC4FtYWPPwO0u2cjSfxLBtev0xWryXPpSVqpV4anqYYtXANsCxYLqR5/9+/im+/VsfwqtpzJYL2I7DbR191C0LRZLIGzWS1RKxV3b9uL6tk7DuYbyQQ1cUViQS+F0aXlVDkiR+d9lmXl6YpmYZtPtCrIkuLlJIlR2S2QgB3cJ2HNJlGT1msDs5y/rm1lOGaVVZZnm4me2zE/zTyG4ytQrNXj93dw/ytqUD7D04ykK1hAeNuN9LyKuxLt5KPTPHaDqL26VSrDXob43w1MQYYbebmMfDSC7LD48c4D9uugH5HL2qq2Ot7ElPM1xIUTFNKqZBWPVSq9tEVTdT5QLu1iySr06triKrLtRwHsX20eYbxJQMJqtp5qpFuvxhCkaNVk/oRD3C2UqBw9l5HByWhhJ0+MMn3T9bqJDKlPC4NZZu6mfj29aw7+lDlGaKxNuivO23bz3t8O+ZpgvULIO6ZRJwLQZQxXAwDANvUxjVUQknguTm8+QWChgNk2K+iuJRkRd0GCwj1U0aWg1JkmnxXPqqWsuyOfLCEKmZLN6Am5U3LMEbeGMWOwnCm5H9yselnC+8tYkA+BYXcLm5Ln5qMd1LYTsODcui3Ggg2zJul4ppW8yVirwwPsntg/24FAWXLKOpKnGvj7LRoGoZaK8JZ5IksTyeYHn89GVwQpqHO9pP3hbPdhzKZoMuXxP5eo10pULdNJgtFPnHvS9zuKODbX2DxD3+k0LZgXSSHxzfT7ZeZbKYo2QYPDc7zgcH1/L7K2/kF9P7aGAS9iwWiL6nZwW9niaeHhqj0jC4qb8HR4NjQ5kTAbbJ62O+XKZiGPi10+8Z/Gsrws3c2T7I7tQMjm1Tq1lkyjUkoG5aoFjIniqWI+N26dSwKJo1dMo4jkOzHsIr6xTNKkPFBUIuD9vaViJLMpOlHP9w5EVmK4tbNvlUjVXBNmKaj95wBFcJHvjVQdK5Mm5dZfOaHt728VtZc8sK6pU68Y4YwejJdQ3Hx1I886vD5HMVOrpi3H7XCoKvKfQc0jy0e0McySdp9TjkrAoe2YU9XcFuiVLOlVFUmWDUj6a7aIn4yObLlI/6UCQLmmsEdTc3xTexLNB/7jfdWTiOwzM/fpHnfrYTy1hc7HJ89xjv+ffbzlpKRhAE4VomAqBwweJuPwPBOHvnZ1FlmapjITsyPken2ljcvqzLH2ZDUxvPz04wW16cTry5uZPuYOSS7i0BbsVFs9dPsydApT6DT3XREQwya+T4h+Mz7MxNsCbWyu1tg7R4/XhdGmOFLCWjTq5exSUrxN0uDMviudlxfn/VJv689V7mqnnciotlwRY0RWV1Wwur216d17h9agIkKBsNvKqLTK1CeyCIRz37l1HNNPju8B72ZWawHAcFibplMV8vUzUNNEdFkSRMW8bnAqfh4HapKFIDt6RzJLcAwOpQJ1tbu2j2+On0RenwLb6Wz86OMlspsCSUoNxo8MTUMAeS8/R6EmiSjHm0RvF4EV2W0T0aT1WP09sRY+nA6cuspBaK/PxHO8lkSvj9bna9OEKt0uB9H76eUr7M7NgCiqJwT8dyyqZBql4i6PbysbU3MnXgAOOHJtE9GhvvXsvAhl4cx+G3/+he/uYvf0IyVcfeodPd3sSX/voTNMcu7f0AkE8V2PnYfnxBD7HWCI26wci+cYb3TbBy6xIARoeSvPziKLWaQf9gM5u29qNeQDkYQbjaXIkyMMLVRQRA4YKpsszn1t7Cnsk5xssZXIqLKAHaPEGivsVeIkWW+eDgWvqCMTL1CmHNw+aWTlyXuF2dJEnc0dnH947tZ6qUp2IZtPmC1GiQMcqoKOQbNb55bCePTgyxKtLKBwZX41IUDNumbpp4VBdV08CrujBMk3yjxvqmNrp8r+7vOlsukq/XiHm8JDyLCyM2tLRxJL3Ay3MzWLZDwuvlnUuWn3Nl8PPz42xPjuG2VcqNBgeLSRKan1WeGMPlHIoqE5L85Mp1bF8ZXTfweFx4lSgf676DTN0AYEWk+aSdS36tbDbQZRVZkkhWStRNkyZ/gKXROAemZjmcnaO7rqG7dfKZMoVKjUy+fMb2Tk9lSKeLdPckkGUJj8fF+NgCR/aN8+yPX2R+OkPV7ZBcr+FbGkPTVDa19LBt7TJy/ctJz2Rx+3TaBloomQY/PLyfY2aa2OfWcF1RY2uknZVbB9HdZ+81PR+jR2b45be2c3j/NMGID0/Ai8enYdsO5iu9gVMTaX76w5coFWq4NIXRoTlKhQrrNvTgD3rw+M49j1IQrjZiDqBwLiIACic4jsPxhTT5ao2I10N/PHrK/C/LsTman6Ng1PjDTTfy+P5RZgpFynYDPBJ7MrOE/G6WxxPoispNbT2XvZ1bWjrxuTReTk7z+NgImqSQrOcwLJuIx8t8pYzjgCQtzo373vH9/PbSdfSHoowXsmTqFXxuE0OukGk4fPN4AWST5dE4YVeA56Yn+OX4McpGg5Du5j0DK9nU3IFbVfnYqnVc395JzTTpCARPbAk3lcszksqiyhLLWpqIel+dfzZVzDGdzuNUoew0KDoN7HwOdbZCWAZCEn925808Ux7lYGEcl2aiKNAfiFJ0knSFEiwL9LFvfp6jC8cI6DrXtbThfmW7uP5gjN2pKearJbL1KjYOce2V1byGg+3YKLqK7nFh4lCuNpDPUuNLUeTFgs+WjSwrGIaFosi8+Mg+5qcydCxp4anAPGOlDCsWvHg6gjw8cYwuf5QVzc1EmsMnrvWz4cM8PztJi9ePpavst8t0qBUix+doX9KKpp97FfXpNBomM+MpfvFPz1HIlPCFPCSnMhh1g+ZmP6FEgNaexakFI0NJ8tkKvQNNSJLE8JEZfvTNZ9n9yH4CIS93vncTS9ZeemFrQRCEq4kIgAKwGP5+eegYTxwboWGa6KrKXcsGuHvZwIkQaDk2P53Yw/MLI5i2hVtxcdOqQWYWIjw7M47P42Lv/Bxj+Sy/t24T/ZHoOe56cSRJYnW8hdXxFjY1d/Lz44fJpcv4dYv2YJBDmXk0RSWouenwhZirlFBkmd9evoqYD56ZG2LOSGE5Dn5NZ54x/tfxSVZHOohpYYaS4JE99AYjzJQL/GToIP2hKFG3F5eisCJ+8qKFY/Mpvv3SXlLlCuDQHYnwievX43YrzFRyTGTTZKsVWvUQkgNJI0tRd8h2gd5w4aTqjGyf5LMfu5VdmQkWajmOlA5SJ8veXIE9uSM8On6YkaRMJl8hky/Tpvj55KoN3Lihn5taeykadV6cnyCo67S7I8iWwly5RAWTDseLrqrkKjUs06It5Gew+8wLL/r6m+juTTAynDzRu3n9jYMMP3sIf9iLoUJJt/CVZZS6Tas3yLF8itlKgRWRV/eytmybo5kFYm4vUbeXUr7M3kOT/Gh0mP3zKoMbern/D+6+4MUaRw/N8MSjB5geTzE7PM/GDd00tUc49vIo6fk8oXiIt3/qVpq64ifeL79WqzSYGp7HsWzCMT/Z+QKPfG8HibYwEVHrT3gLcV75uJTzhbc2EQAFYLEH66mhUfy6RiwaJlUq8+TxEVa1NtMeXvzBOFpMsWNhhJjmJah5mK8V2ZEexijrNPv9tPkDOI7DkUyKI+mF1y0AvtbKeBMrYgmGC2m+fXwXRwszNCgTVYJ0+SJk6zU8qkrKmOfl3C7qrjIt0RyVgoWfJlyqTdYqUbctcFRGy7MkLZPNvvXIskyLN8BUKU+2XiXq9p62DY8dGSJbqbIkEcN2HI7Np3ho6DALepqZSpb5ShnVZVKiSkGqoUgOtiVRdDWoKiYrCdFI1/CoGjc2DbAnd4TDpQbd3jYUSWa6kmJP7ii+Wj+50gKGv8yQlOTv9+aRJLjlukF+q2cld3cswXYc9iRn+dXEKA3T4h3LllMtZnjx8CRFxQQVWpfGkb0yj0wdYbKcJax7uKVlgIR7sTfT69N59wc3s3fXOOVSjabmIGvWd1OdTrH32aO4Q25w29RVB7dPp2YagINfPXlIV5Yk/C6dqdJiQfLRQ5NUy3VaWmI0e3UOvXCczqVt3PDO868BOJ/M8+DPd1OtNPB4NKoNk8PHk2xY00H3yg6aexN89D+/g1hL+MQ5A0ta2P3SKGPD8xSzZbKpIlGfRnIiRVtvE3MTaTLzBREAhbcUMQdQOBcRAAUASvUG1YZBW2jxh2DY62EsnaVUf7VGW9lcrPkXcC2urAy5PMxW89iOC8l5dR7cr4dfL0XeKLI9tZuFeoaoFuL62Dri+ukXDEiSRH8wxqa2AA1XHc1tUGtkGC15CKohtnX1sSu3m5JRpkmPMVPNoipVbKuOBdg4yKh4FB1dkZlVZpmvFmnyBklWSvg1/Yz7J0+l8+wZm6XUaOB3aTSH/bgUhZ35EVS/TacngmIqzOTzRGwdZAu57sEpWiR0DzXdQK5YRAdDPPPkYTLpEvl4GitqgwOVhoFhLu4EkmmkqQbyaKqK6TjkIhkeHd/LLdct1vj79ZDwDR3dbG3vWqyLKMu84BpnR26BuKXh8+rMSTX+7+efIO+uossKNdtktJjm95beQOiV5wwGPdx827KTnvXWd2+imK8wPZyku67iWhmhGIZKOc/aWBtrY22veQ8slo/Z1jPIt4/s5Wg2xWS9RMJy0et40T0KqqqQSxUu6H2xMF+gkK/S0xvHth2yyTyz01mGDs/g9+hsuWsF0ebFuoy2bVMt14nF/bzrA5vZ8dQRnnlgN0qtgW3ZTByZJZ8u0dwVxyNWCwuCcI0RAVAAIO73EfF6mMzmafL7SBZLRLweEv5Xe70S7gAhl5upSpaY7me2mqfZHWR5qIuHR4YYyWUwbJuE18vKeDMzxQKPjAyTrpbpCoXZ1jdAUD/3D9qGbfDQ7DOMlqfwqR5mqvNkG3ne07ENn3r6IDZSnuJg4Sit3hB9gWaOF6YJqg7vad9MyC1xeLJCTI9gODaGpWBjk7YWkC0XsmzT7AoQd3tJNtIMBJupFOB4Lk1Id/POvuUnSr+81nQ6zz8/8TLpbJmFeplMoUJ3UxhdV3FUk5pVYV9hHgcIBm30ooLLVIiH/TS5NIqpEjXJpqu7iWzN4JlHdzPenKGcK+FvrjPizWLXJSzFQLFDzFPCwsYwZdySimo7ZPXiKe2qVhpYto3vlcUNc8USwYiXwbbFIdHRbJp9mWk293cR1ryYts1oKcXxwgLXxc88Fy6cCPKBf38P6bnFhSulAMxWC3gUFyujLeiKysTRGZ750QvkUgU6Blq47QM38Jm1mxnNZ3nhSJ3swQmKTRUyDZNawyTWcmqoN2yT3dkDTFSm8Shu1oRX0OldrAGp6y5s0+LQrnFs08KWJdp7E9x061I6e5tYvrEHSZLIpYo8+p3tzIwu4NJVbrxvPQPdUQ6pEolV7cyMp6nXDNKzeW5/93W0dp+6uEYQrmZiEYhwLiIACgAk/D7evXYlP9t/mIVSmbDXwzvXLD+xqhegzRvmXV3reXB6P5l6mRZPiPd0rafXHyfi9nI4tYDHpbK1rYuQrvM3L7/IRD6H36VxLJMmU63wO2s34lLOvhI4Vc8yXU3S6k6gKxpRzWK6mmSutkC//+SAslAqkyqVGW/M0rBN2jyLPZh9gRYqZo0WnwdZkvEoOrlGgalyiUy9RNgVRHd8GBa0+3wENZXp2jwRLciHOreiESDfqBF3e2nxBU7bzgPjc4zNZVkRiDCpa8xWSszlSvzerdex097P7tw8YZcPG4eGUqOtReN6rZ9jjRlMx4I2lRXuMO8IruKn33uJsY3DmOE0uuRQMaFQ8tOpxXFX4xiZEJF4iqRRwanZ+BwXktukuynKoQNTFPJVfH6dZLLA/n2T2LbN4JIW3nb3ajRVwXZsbMdBliSqlkFVMhgvZsjrNVo8gfPeOF5zu04srmgCun1hcgsF6rkqxbrBz//uEbLJPL6Ql92/Oki1VON9n7uPvlCUwXt9/K8XfsyeI/MgQXtnlLaVnafcY0f6ZV5I70WTXTTsBjPVJL/VfjfN7jhNTQEa+QoT42lkRcaxbVav7uCWt6/F98pcQtu2eeTb2zny8gjx1jCVQpUffO1hbMtmejhJW1+CwVWLu5WAw9Z71rzue2MLwhtNzAEUzkUEQAHHcTBsm7XtLfTHo+RrNcIeN3791PIYG2JdLA02UzLrBF1uPK/M+7q5s4ebO3tOHLd7bobJfJ7BSAxFlik26hxNp5ivlGkPnH2ulfTKf5azWIvecmwkpFO2vdszNcuP9xwkV63ieEsQK+KS0ngVN2WrREQL4FHdWI5NxJVgZ3Ev07UsHsVNm7uX5lAn+zLTKDkvuUaDqlLHjnh4zp5nWdhhbaIVXTnzl8jRo7NMTaTJOQqqKtOZ8NGdiPH2lcuYH5viWEmnYpnUDAPDgKPFOcpVH/F4iDV9zQR1N2ujHeQnSySb57AiKRRbwTEVJLWG7K6g5ztZ7mvnmJXivqa1HGaI2UIOCUj4ooQXfHznoe3IDYlioUatbtC/pAXVpfDyzlE8Ho21m7rZOzbLsZkUkuSw4C2ADkcL8yjI+DWdG5p66Q/Gz/Mdsyi3kOdn33yU6aEkGiqx1iipmSw9KzoXy8f43UwenSGbzJPoiDE6kcHdEuW6Ze24XDLpbI0d24fo7Hm1ELhhGxwpDBNQfUS0EI7jMFGdZqIyTbM7TnIig8dxWL+mA8t2yBeqHB9K8j//v79kxZou7nrbKiTHYWZ0nnhrmGDUj207TGw/Rrw1jDfoZuzwDIVMmab2KNfdtUrM/RPeksQcQOFcRAC8xk2V8vxk+CDJSpG4x8e7+lbSEz57cV6fS8fnOlftNAmkxZ07FF6ZE4Z0zi3TAJrcUfr9nRwqDOMyVBq2wYC/izb3qytXi7U6P9t/mIph0BePMlWBY7kKSeM4LkUm4Q7z9tabAYmfTm3nUH4a2QnQMMsoipeEq52y2WAqlydQgYbqMF7M8WI2hV8fpdsXZVvnUn572Xq00/RYLswXSB5Po8kyjiZTbdjk5/Lcvrqf+WQed9VF0OUhU6tTbBjYjklQk+jQg0zO54l2BrmlpxcAvUVBa3JwcLAaCnXHwkFGUU1eygxDTUF1FHr9zdza3cfR4jS245DL1PnxoZdhQCKieFF2Q36ujK4pBIIeGnWD0ZEF3rZtNZ+4fSMHJ5IkawWerlUZDMRI1yukamXqlslNzX0EJI0DLwxTKlSJNAUZXN2B/Bs1DrP5CqlsCZcu8f0nfsTxwCiem934kh5mH5uHBlimhaypmA0TWVVQXYvfZgq5Cm63i/grCzTqJmQzv1mPUAIknNduRPUbXRGyLNEU81OsNBiaSNOwFo/dtXMUx3Z4+31r0XQX1XKNYNRPbqGAZVi09iQIRv2M7J+gVm1w8zs3ctP9G0XvnyAI1yQRAK9hJaPOt47sZrSQIeb2cTSb4ltHd/PZNVsJ6yfPtbMcG9M20WTXef3AHIhGGYhEOZpO4VFd1C2TrR2dNHl95zxXkRSuj27kWLbATDlNXIuxMbQRXXl1lWmuWqNYq9MU8KHIMlktR6ms06Qn8CoKhiFRMGCqssCxwhRtnhhuRUORPBwtzHC4OIVlKrgaGlGPn2ONJIoko1gKHkWlbNd4aW6K65rbWRNvPfW1K9XQDbiupYWJchHDZWMXG4wdmeXrL45jqXUmV+QxdQNMC9lRyGJyVJkm4xg8NTWK6bIxsHhhbopqdHH/Y0MxsG3QVBvbkqmWYUdxkt9etp71fe0EPDo9/mbmqnn+n6FfUlEMYoqPtFrG6XVQRmwaDQvHcahWDNo7FoN6azRIazTIWDHNy4fGCbjcJNwB7KDDUHGBoOLmwX/ZzoEXh3EcB1VV2Hr3am65f/2Jf+/Dw3M88MQBcoUK1cQCC+ooQc2Fproo9VZQV8mEx0NMHJ1GURTAYcu96wk3LfawxZuCNEyLYrGKqiqUilW6emI88+gBSsUasUSQVRu6WREaZEd6F/VqHcMxiehhenyLQ8XtfQm6BpoZOzJLoWFSKtXo6YnT2hEln68yNrqAI0lsvXctj31vB6OHpsktFPAGPYRiATx+naauGG6fzk2/tfGi6xAKwpvd+U7rONv5wlubCIDXsLlykalSnr5gFE1RieoehgtppkqFkwLg0eIo21O7qFl1Wt0Jbmu6nrB2+nlxvxbQdD6xZgNPTYySrVZpDwa5rav3tLtmOI6D4di4JBlJkmhYFj8aOcTxjEXA1cR4tcEPRw7y/n6bvfnDpOo5AkoA3eMwXyzRFgowXy3QqDnMVhpoioLlNRkPp0i0ebAdG5e02IvX5gmSM7L0eAM0qS3sX8iRMSvYDovbtEkymqwgAYZtUTGM0z5fOOwlGPBQLxlsTrQwkk2zM1BgtDJBMOihXfFQnJBRXSq27qKoWFh6jbw8Sc22mZ3K89zsOJbLZlksQczVRdGaR9IzyLaFYqtIC600E8CQbO5dv4SA59Ve19lqjrpqkpD91HIGXq9KylWhpdVHOl0in68QifjYesPgSe1u9gTp8IUZLqSI6T6yjQqtniDObJ1DO0dpaovg8elkF4rsevooq7f0E20OUak2eOipQ5QqdbraoxzSxqkXJeo5CKouGrJBI25y88bNuD06pVyZeHuMNbcsQ5IkytUGE7UySbfJ0Pg0LW4vq3qayc4VOPTiCLlCjUy+SnNriNvfvpKbrtvMnDmPW9ZZE15OQl8sKeT1u/mtT97Mi48fYt/+SaqqTN/KxZ7KRt3A69VRVZl1tywjHA+QnExjWTaHXhhmdnweSZLQ3C623L1WhD/hLU0MAQvnIgLgNcwlK7hkmZploikqNctElRW014S0meo8j849R8M28KkeDhdHsLB5V/vbUKSzb4EW93p577KVZz1mspzlX8cPsFAtknD7ub97FRISx/ILdPnD+Fwapm1zLJ/k+xMzGFTxqx7mainCbUHyU2FGc0lQcni9daKKD8dxkaxVGJnM8Y6+tbR6YoxX5vEoLoZKI5SNGulqHp0xYoE+7AwYloVhW6BA3qgRwkPE76HN/+r8MMdxqJgGiiQRifq5a9tqHntkPzOzWY6Gilg+iUBNxe1SGWuUsOqAz0U84CevZHFMh6ppIyNhy3VyeajoDqsSLbT4QtiljUzmRihlsuh2CL0SIG8ViFhuZuYK9DTF0FwqtuMwVSySa9RxN2lUUiaTchHJI7H+/UvY7O5EtmW6umO0tIZPer09qouP9F3HT8f3cSAzh2VDiytCsVDHMi3c3sVeVq9fJ50sUKsuBuBiuUapXCMe8VGXDVRdRZEU5LJCdiFPI96gO97O5m3r8IdP7eV96IXDvHRkgs6eOPlCBZCId4bZ98RR3AEPpYUSLpdCaqHI9iePc6e+mnfedfeJ85NzeQ7sn8QwTLq64rztA5vZcs9qfvi9F5gYTyNJoOsqW28cPLHHb+/KDnpXdgCw5oYlvPDIXvLpEr3L21l/24qzvi8FQRDe6kQAvIZ1+ENsbOrgudlxZsuL5UQ2N3fQG3q1gPN8LU3ZrNLlbUWSJBRJYba6QNmsEHT5L+n+RaPOd4Z3MV7KENN9HMnPUxrexbu6ViMhYeNg2hZDpVnGalMUslVWhrqJ62HCrgBztTTbNixlX3YaJ1UjY5WwpBpGtZkmO4K34iHg8vCujht4PLmHA7kj1K0GjuknrPqoUiQpT3Jr3xaus9v4+cwh5qpFqg0Ljw0rYy10BcIAVIwGPxk6xP5UElmSuKm9m22rB+noinJkLsmu409i1uoslBrEHQejDu4pFfeASlUx0WUZtSBTUSR8bheO4qC6VHJmjXKtAUFo2A4r4yuR5os8k5pkzikgGRJtepAHnz9MulDhnbes5l9HDvGvBw8yUshSddWwXTaaJNMkBzlkp+hrbuEd3acGnMnhJHOTGXS3iyWJZg42slimwfMzUxyVdEJNbqZHFwhF/aSTBdp6YkSbFnt6Az43fp+bo5U5UoE85XoZxeMQXeMi7PgJK0Hev/S+04a/hmFybHKBaNBLLOQjEfEzNJVioVjBcRwKpTrg4PXpGA0D3e1i+HiS2+9a/OVhPlngh9/bQTJZQJYldu0co1JpcN3mPt73gS0cPjRNo2HS0hpmcEnLad9rx14eZv+TB6kUq0wdnETXVVbesPSS3r+C8GYmysAI5yIC4DVMkWU+MLiG3mCEdK1CWPewubkDl/zqogdVXnyLmI6FS1KpWw0UScElnfmt4zgO25NjPJccw7JtNiY6uL1t4KTrAsxW8kyVc/QFYrhkhbDmYbSUwcJhZbSZF+cnyZkF5mpZIroG1DhWSOJRdcKaG1mSSZvTWGqZPk839dl5lGAZj6Jg56J0rVwMsi2eKB/tuYOfTjkkJ4poio6uurAsjSoNVLfCDU09HM6m2Rjpwqu4WKhWGEqnKTbqBDSdB0aO8pO9+zGyDSwchibnCagaN3f28vzwGNP1DJYBsgpzTg5NcdMnBWmb8qBIGnvds5iqjS05VGUDj60hOwq6o5BtVDicWcDv0ri7d5Ce1WGant7DM/vGWd7RTDzqp1CusX94lu7+GE+MDpOfLhKtBhgLGNR9DlYOapky+a4ML/jG2da59KTX+8CLIzzygxeolGo4wNG1EBmIsjzWhO04HMkssPTObqyn56mUanQONHH3B7bg9i4OO3s9Gjfc2Mv2PUcoV+oEHD/+QBDNA7e1r2VjdBkRLYRpm0xVZ2jYDeJ6jKgWQVFkNFUhX64Bi1vEOY5DS2uIeiLI/oNT5AtVKqUaLW1hHAe83lfnex45PMN8skBvXxOyLDE3m+OlF4bZcF0vobCX639jmPs3JccXePIHO5CAtr5mFqYyPPbtZ2kfaCHcFDrlvVt7ZSvE81mwJAhvVqIMjHAuV0UAtCyLL33pS3zrW99ibm6OtrY2PvnJT/Lnf/7nJyaof/KTn+Sb3/zmSedt27aNhx566KzX/vrXv85f//VfMzc3x9q1a/na177G5s2bX7dnebPRFIUb23rO+Pf9vk56fO2MlqeQJAmXpHJTfCMe9cwFnXelp/nh6D4kQJFkfjZ2EBmJuzqWnHxvWcUlK9Qs85X/NVAlGbei8qH+9bR6g3xvbAcRzYtkylScCraSZ6g4RYcvwopQH5rSwCW7aElEKNUNZisNjEaDdd2t3Llu4KT7NbmjuGTI1+s0yjXKZpFKyff/Z+8/g21Ly/te9DdymDmsuXLea+fce/fuHKEbGpogkISEMEYSlqPK5l77IruO6urYKpXLtyjq6PiYYx9jY0tIQoAEEqmhm+6m0+7eOaeV85o5jjzG/bCa3Ww6Q4MAz1/V+rBmjXeOd47xzjn/83mf5/+wWNxgwswSEtFjvBjVFAQqtkXLdUmoGt+7NEN9rU0KFVUQWN+o88Tpq4xoaR6fvYbhK9iEOASImsj28Ty/ctdeLp5eJNqIuCc2SWnM5eL6OjXbQXN1ZEviPQPbuH3PBAEho4kMs+0N/o/nH2fBqdPp9/BDga2NEEOUCcOQpuvQtBywQhqqjxMIhL6MJ0EtL+GX6ySWK5wPZ0jEDca29ROGEU994zQOHsGRiKrcZMNtINVFyOYQBQFBEMgPZ3jok0ewOy5mQkeSRKIo4tzGBpeLRapei8xAjF3KAKaqEjNVpltFerVBMmoKJ3B5bONJrramCaOQpJLg7twdFOjltt1jfP25i1xdLBERMdqb4dYDkwzHE5y7ukpLCHAUgUqzzpakwq8embh+34IgAEFAFDff67Is4fubhS68gTyleqlJu95hbOcQgiDQM5RldWaDerl5gwBcbTX50pXzrLQaJDWN92zZwc7cq/dM/j5LMxssXVtHUiSm9gyTzr92fmyXLl26/CzwcyEA//2///f8p//0n/jc5z7Hrl27OHbsGB/72MdIpVL87u/+7vXj3vGOd/Df/tt/u/6/9go+dj/IX/zFX/CJT3yCz3zmMxw5coRPf/rTPPjgg1y+fJlC4fU/+P9XwJB1Hh64l0vNGZzAJa9l2RJ/9W4RAJeq63hBwFRq01dusVXjdGX1ZQJwKJbmQG6Q5zbmWX3xsZt7RhmNZ5FFkYdGdnC8PMMTK9cwBA0lylLzfBxJ5/6JmzmQ2cbl5iWm29foRC1G+k10K8kucz9vH7oJQRQ4trpM3bXJ6ib7stu5o7DG12eOU3HaCL5CuhOnvVBm2dzAMBVWW03Sus5Kq8lgIkn6xc4lds3BF0JiMXXzl7FlU1trMbdRJXQjknGV/lCn4Tk0hDZ6Fr7tXkTYAVOHe/n1ySPossrV5Q1OnFig0rAYn8xy363biL8YZTtdWeZPrh1nrdVCF2XKcpsTzjKzq3VyrsH92yfY3ttDz1yMldQKrtokFobYwWZldlMJsf0I5al1/mvpUQZiOntvmeKud+/Htl2KUzVq6RZKKKMqDiVtmYVmiiCUiCsqk6kciiqjqC99LBxfWeHPz5yh43o4uGwoLcycSsFMUHZbmJJKda7O//zsGZblJeq7NxjvGyXwBebK61w+/UUKF6dIxE3uPjBOpIkossTeyQGySZNnV6poOZNURsSyPBzHo4zLmtXh+xu0w6M5NENhcaGEpim02w533LkNSXrtHNTvk8jEMeM6lbUa2b40lbUaRkInkXkphcH2ff7s4mkuV8r0mCZLjQafv3Caf3rwllc1Age4cnqBr//J0zSqm6bSp8byfODj915vR9ely98V3SKQLq/Hz4UAfOaZZ3jve9/Lu971LgDGxsb4sz/7M55//vkbjtM0jb6+V84BeiU+9alP8fGPf5yPfexjAHzmM5/ha1/7Gp/97Gf55Cc/+da9gJ9zTNngYOa1izm8MKBqW2jSZlTPj8Lr/WC9MLihsOT7yKLIL48fYDyRo+pYpDWDw/kR5B84dlDPE0XXiGQfB0gIvST8PnYltlF1HEI/y7C2laq/QiRE3NxzkFtztyIJIn9+8SzPLC9ghy6e73JX7wQf2f822icEjjXOovV3UOI1WrEas+sy77zvJh5bmN00q44n+NXtezCUzUrRA2aB2XKZdSwA4q7E9kwWWRIpeClqUZOWaOOKHrIAxUaLHjGJqSmcD1Z4rjjDA4O72DXcz67hl9vKAGxYTeqOTVzScV0fIojUkGbcw3RVtKRKfyLJ/dt6WYmOI3pN4n5EUJWp1JNYqoC6LqAVJaq6yFDS4Mxz15jYNUhqIs66dIl4y8SreCRcCX9rgOu1GEkNc+/wBLteIdr19Pw8XhAyns4AEZ2aRbVjcU3aICar7BMHOfH5M1hNG3uLTXGjTnFhHtlUaFgNRDGioEUU1xu4R+f48MfuIpN9KU+wUe/QEUIiUWCwJ0WraYMkcurqMncf2MK1xSLfPHmVaiyiU3UY03TuPLSdO+/a/rK5vhp94z3c9t5DPPPVY8xdWCKeMrn7l28h+6IfIUDJarPQqDOSTGEqClnd4Eq1zFKzcV0AhmHI2WeucvGFaRBg9y1THH/yMlbHYXxHP1EYMXtplXPPz3DXwwfe8Py6dPlJ0LWB6fJ6/FwIwNtuu43//J//M1euXGHr1q2cPn2ap556ik996lM3HPf4449TKBTIZDLcd999/Lt/9+/I5V65x6fruhw/fpzf+73fu/6YKIq87W1v49lnn/2Jvp6fFn4Ybm7DvoL4eitZ7zT588tnWGjVAAFVEqjbNk/b8+R0g4Sic1vf+A1jphtFrjaLSIjszvTT/yoRk62JPgalXhKahCLJeA6klRjnqqv8zfwFaq6FISnc1r+Xdw5vx5QMBEHgaqXE86uLBJLNQmOJpmtztbpAZbbMoKEiJxpogUGl5tM0aizHTnL1ss2Dk7s40jNBXyxJTHkpD+2hw7tZn6+ysFLHkUIyRpzhXQX60glG9RwUBTzNI4qgotdp1Fx8mkRRhJmRWExUKGlN0mnzepXqDxNTNGRRxPY8qo5FIEZIkUTS0Al0mG3XCKOQhdY1RvQ4umNQidpEOYu24xOtx4iXRCwFXN/BkUAMAqyWw93vOsALRy/RXGtjVR1UXUasehQu23zkl3cy0NfzinPqOB6rxTpLCxUEBCJD5M6BbdyzZYykYrD87AqXKm3Gtg9Qi6vMsYwTNiloWQQ8gppBy4bRkRwLs0WKG40bBGD/QAb/eIAX+TiOh+cHJNI6oihSqrf58uNnqDYt8rk4ZUUk1p/k9ru2oWpv/KNLEARuffdNjO8aoVVrk8onKIzc2PVElWRUSaLje5jKpm+lJAg3mICffeYq3/if39vceo4i5i+tECBiJjbXnCAJyLKIY7lveG5dunTp8nfFz4UA/OQnP0mj0WD79u1IkkQQBPzhH/4hH/7wh68f8453vINf+qVfYnx8nOnpaf71v/7XvPOd7+TZZ5990ZT2RkqlEkEQ0Nvbe8Pjvb29XLp06RXn4TgOjuNc/7/RaLxFr/CtxQsDHlm8zAulRQTgSGGUtw1uvSGy9lYRRhF/efUc5ysb5HWDFzaWqDoWg7EUCCHJuMlHpg6yO/tSZPZcdYU/mzlGzbWIgGc2pvnl8f1MJHrQf8DsGWBfoY8D+WEuV0oEgCHL3DY0wjeXLuGEHttSGUq2zV/PXKJlhxzID7In34cd+NT8NqvWCm3LRhcULNXjifpl3mWMosVENtZcmqpLKEloesh6tcI35s+TN+NMpm8UCKNjeT7+obt55MxFnmgv0DBFPrd8muh8RK8TR/NVDg2NkIub/OX8C1hJmwQqlu+xXK7zwtVpyvUqA0MZHnr4ANncyyuoD2SHuK13nG8vXcbCJYoiNE8jL5uUrDaqIbNRqnPhyiKdtoPmqaQNBXo8PEVAbMewbRvL84lkgXPzGxxMp8gUEoz29/HAoZv566NPoOkKWlolacfwZwIuHJ9jYOzlAjCKHGTLY7XWJKYohFGEWwuIWRo704MArCsbm+sgjEg104SlJPmJddLJMq05jfblPE4qwOo4KKqErt/4kXPLbVPMLJf41vErlNsWyYRBLhfn5h0jrJbqlOsdJgazCIKAoSuslhqU6m2GCmlKTp2nihcoOXUGjCx39OwmqZgvex2wKQL7J149raPHMLltcITvzE1TtjoA7C/0szXz0jq4eGzTJHtocvMzY+HKKoIi0Ki1kRUJz/URZZH+sTfXUq9Ll58E3S3gLq/Hz4UA/MIXvsCf/umf8vnPf55du3Zx6tQp/vk//+cMDAzw0Y9+FIAPfehD14/fs2cPe/fuZXJykscff5z777//LZnHH/3RH/EHf/AHb8lz/SR5cnWabyxdIv5in96/XbiAISncPTD5lp+r47sst+pkNJ1ztVXWnDoR4OGxNz2A70X0Gokbuoc8sXaNtu+yLVmgE1gcr11k4+o8W5N93F3Yy/7MS8UbCVXjt/Ye4tTGKpbvMZRIkdQULlS+zj35C+iixzkvwXOtYb4xH3F8fYUHR6a4uXeYuCbRaNoogYyvQixSEbSIVsdnbFeBtl/BFSSimIsmQZSoEEgdni8neGDw5TYq+f4kC8sWiZhJTjY5em2BNh5DqSRaS6LRcdg72kfvlSwtWtRp0/FchHWBfidJImFw9fIa35bP8CsfvhVBEJhfqXBlblNETY328P/aey8703388ZknKTstFMml7jWJGwa3TAxz9eI6flFEHRLQ8AnVdQTZZ3QgxkYporocIxQ3q1nLjos+kmVs26aFzz2pfXzvygmqYpNeN824M8BGWMFzbjS7jiKH0PoaeKd4e/8qutvHc+VtgIxuiSjWS/dyy54hBsZ7mL+0iqxG3LN7ianCKpmsxmInwReDJM1Km7Ibsf+mcQaHb4zI67rC3//wnRy4aZzzs2somszWkR72bRnk6mIRURRwXB9dU7AcH1kWURWJlm/xpcWnudZcxI86HK86XGpO80+2fOCGjjHfJwxDqmt1oigi05tC+qEorCAIPDy5naFEimKnTVxVOdQ7iC6/9BEpCgJR+NK+WBRFbN01hJmOMX1+GUVTuPWBPew8dGO0u0uXvwu6W8BdXo+fCwH4L//lv+STn/zkdZG3Z88e5ufn+aM/+qPrAvCHmZiYIJ/Pc+3atVcUgPl8HkmSWF9fv+Hx9fX1V80j/L3f+z0+8YlPXP+/0WgwPDz8o76snxgXqhuookS/uWliPNuscKVe/IkIQE2SMWWVY+UFym57s98vAjXfYsNpkZJN/DC8YYwVuOiSTETEvLWAG1kIxOn4Dt9cfYGsmmAk9lJkNqlp3DU8dv3/pnWBI6mjBEEHKzQZ1uZ5qLdNlb0EIXx75QyessZUL1xqRDQ7PjoqsiAQeBEjiSEGe4dYqj5Bx2kSyC5BpIAYEMltyt4M63aRXv2lqJjtenzluXM8OzuHJki04g5RALqhEEnQn0myVmuSNHVGUllWN2RyZpLFlSrZ9ZChrVlkQSCbi7O2WsN1fRbXa/zlN08wU65S9WwMXeVD9xyA3oChdAylKdD2XULDZX92hHvGJji+dI3MSj/ka9SyVxGjAL2ZIRFP0BxeI7YhE9QTqKKIIkHF9zc7cdQ7fO3//A7Bd1s4xTalRIA+JaPHNEa33piTGNmPgfMokZBGVyLuGLzAWHKY5dournXKJMyXiqtS2Ti/9PF7OfvcNIZ6gpGxNuvNPmq1kJG+Er/5/jIR7yabibNt18ArFm6IosCBncMc2Hnje2l8IMuuiT7OXlslAiRR4I79E/Sk41xuLjHbWsanjhNtWtucr1/ksfWjvHPgzhuex+44fOtzT3D1+AxRFDGxb5R3/P17iCVvjBZKosihvsFXXeu7bpli7vIKC5dXiYjQTY29t29j64FRHMtFlKQ3tTXdpctPlh8vAvhGKuy7/Hzzc/Fp1el0XtaUXpIkwh8SFj/I0tIS5XKZ/v5XTrhXVZWbbrqJRx99lPe9733AZpTg0Ucf5Z/+03/6imM0TXvdyuKfBWIv9t6NXvwJ5wYBhvyTaXuliBLvGt/Oc8VZwjBCREASRWRBZLld48DIIHnjRnPgnel+vr50nuVOlZLTQBU0+o00/Uaa2fYq63btBgH4w+jCMhNxmdP1ASq2RRjE2ZNqctEWWHdblINpTtWK6LLCzj6Fc4FNww7oeCIZUmSmctyen8KcyPPnJ55jJjqLj4AsqSQUk6QmsWyt3iAAHz9xjRfOLKDHZKrYtDZcmoGDYAsUvToYIbGYRi4V40N37+c7p64wt17BDDQWvSp/NX2VfsMk7coUcnEWNmo8e2qW2WqNiugSqLDWavE/njhGfHuIrkgczAzgyxGrdp0Dg70kNY2h4RwJKY57VUDbreF3dIbz/YyM9LBc3kCNBai2RlbTKTlNVuw2n/vOMcpX11k/McvOm8ZYW6kze3mV2kadj/x/Hibbm+Tpb54hDCPGt/XTX7hEJJgIUoFCLsHy2il85wrTK30M5pPsGOzh8ukFZFlieLJApifJXQ8fIOgsgJMg1TPB4vQ6kecylq6RHh0gnnnzVbGqIvPB+/YxNdxD23LIJmPs2bIZzRQQsKM2dmCTkpN4UUAjbHK5Nc3bw9uQf8AD8YVvnebU4+fpGcwhiALnnrpEKp/gbb9+52uc/eXsvHkSQRS4fGIOAdhxeJKtB0YRBOG6X2KXLl26/LzwcyEAH374Yf7wD/+QkZERdu3axcmTJ/nUpz7Fb/7mbwLQarX4gz/4Az7wgQ/Q19fH9PQ0/+pf/Su2bNnCgw8+eP157r//ft7//vdfF3if+MQn+OhHP8qhQ4e4+eab+fSnP0273b5eFfzzyu1940w3y1yqFwEoGHFu7R39iZ3vYGGAB0a38tTqLBnVoGJbFO02u7J9/NrWfXQ8l6odkNUNFEni/v5teGHAsdIcmqSQ12MMmCmcwENAeFke4MtRSKg6t/QMUbQdFhtt3ECm5vgs2AtoqsCWxAiKKFG3p+mJR4yLQ8QEjSir8kxlibuDCW4a3Mpwspf/dLVJI7DI6Clyuslae4NTc6u0N5IcGO0nrmtcmt8gaWgcSg7wdHiNdbVG6EaYJYO1lTrLRoOh8Rz/+enn2T88wD17J/mT79ZZtTpUZY+S57LmdkhGMlMJ+NTXnqDWsGi5HooqkTNMBCdivdSkOGejGNAWOmzdPkBK0673Zt4y1csD79zD3175Nq7ZRspEOPEKnUhjuCeD5RsEVkSt06JjgKXBsXNzXLmwBL6Nd3mdqaleEjEFRZcpDGX50n95nPJaHQQ4nonxrt9oYZgbdHydfNJgYkDBTGRI50aR2jLf+u9PUd1oIEoCfTv6GLx9HGQYzbQZ0R1Wrs6wdKlMvq/C0oUMy3/zCB/8Fw9jxF/dO/LV0FWFI7tevnaHzR4KWopLjSJC1CEgJK3G0UWViBB4SQCuzRXRdJVEZvOHSCthsHJt/WXP+XoIgsDOw5PsPPzWR9K7dHmr6RpBd3k9fi4E4B//8R/zv/1v/xv/+B//YzY2NhgYGOB3fud3+P3f/31gMxp45swZPve5z1Gr1RgYGOCBBx7g3/7bf3tDxG56eppSqXT9/1/91V+lWCzy+7//+6ytrbF//36++c1vvqww5OeNbekCv739Fi7XNnPLdmZ6GYlnfqLn/LUtB/DCgNlmhd54nLsGx/mNqZt4bnmJJxdn8cKAkWSaX9uxl0IszntH9vLQ0C5OVK/w6NpJZttriAhsT46wLTH0mueS1H1I7nPgXWNAFzDFFI+t76DiBJiKTCGevN4FI4wENFFlz4tm13XHpuN5dDwPXVYoJFI8OHqEo+XjQMhCbYVSJaRSbnDaP8PZxTU+eudBDE2hWG3SkTso+Kh10GWJ3JBCSo0xU2wjBxBG8Njlaa4ul9ioL7B/8nmSRoeNepJjsxM0XFjNdHD0kErQwRECelwDpSNiWS6RHzIUZnFiNq2gRKl5jV3DvexO7QE2RUhyKiCXCMmEW6n461T9El7b5p7J+9l5S5LjpxZpBx6m4tOjKMydXESwXCxDYmW9iXfWJRNTOHjfLs49P0NlvcH4js1I+dlrK/z3b6u889aAmHYGnTpKXMQUPKTiLF//4igbKxr7bhpHiMn87bVpjGANZbyBsl7nff0efcIc/eMqvtdHuXqI2XNLzJ5dYOetW1/pdv5ImLLGLw3dy/+cq9PyO8TkGAnZYFtyAkVUaHRsplfKRETISR3H2ux1jCBgtWzSPcnXP8lPkPWFEvOXVhAEmNg9TK7/J/v+7PK/Hps5gD9OK7i3cDJdfiYRoqh7m39UGo0GqVSKer1OMvl3+4Xys0DTc1hoVhEEgfFElovlIp89c5yEqmLICkvNBvsL/fyjAzcjCAJRFBFFEfOddTacGoaksS0xjCa9/nZ1GFQIvGOEYQdRGuF4NcuX585RDdZwhDWGYxl6jDhVu8NaMUZK6CWuqiw3GmzP5/lnh24FIjqBgy4qXGlNM9dc4rGzc2h2nqF4L54fMFeq8uHbD6BHIl984jTH9KuERAQVn4ym4WdC5IpBdTFg78QAo+M9LFbr4DWZTH2FmLmA46sYss+lpWG+urgbs0+hV00QtGWW7SayJ1Jom0R+iN/2GAhUOsk1dh05TiZfx9AUJCnDzb3/hJ25OzhWOc6z5ecYMoawA4uKWwYBPjb2MUzZxPV85ter/PvPPULp8jrtuoUgCziqyOCGg9z02Xf7FPf/+h1ceGGGuQvLDE0WEAWBx2YWaBoi731bjrH0c2SM5/GCARpLMolkkWsXknztSwdJZWKYu3McrxUZ3BPiFWq4HYm4HDEsLDFYS5NY38Z0JLG0vM5D77uTd92zD6IOXqSxZG/ghz49Wg85Lfu69/vVmGsvcaJ6HiuwGYsNcTi7l3rT4fPfPcniRo0IyOkasUtFGjObEfG+sR7e+48ffJkVzE+LxSurfOX//g6VtToQURjO8b5/9AB9o68+nyiKuHZ+mYsn5gmCkK17h9l5cPSG4qouP/v8NL4zvn+Oz5z+Ikbi5b253yhWs80/3PfB7vfbLzA/FxHALj8fJBSNXT9g97LebuGHIQVz0/KkYMZYataxfZ8le4GT1dM4ocOoOcLNuUPo0hvPo/IxON+JWLdX8cJ1XliXCaIcU+YE87bIWrvKkNnDe4cOUU1oPDo/S9222ZrL8Ss79rBslfj6ynFqboukYvKO/oPcnhnluVaIqW4KUFkSiQDH8zm8bQxFldi4UsInwEworC1XsC0PqSkhKgrptLnZS9bz2J6vkdLXmC7l8COJmOIwMrRMv9pDQ07RFGw8TyVDksJAkntS46yv1Dj1xFUupapsn1wgla+yaKfQfZWCUeGRxc8ymLgJQzIAASdw0EQdBIm8mkOXNrdYVUVmIJci2mhiawJRXCVSRcyGQ182Sdin0jINvvLVEyy1W2x4LU4ttdEHbWrbWuhGnDVvjLTbhywlaHcy+J02iWSefG8DTQ3otB3cRhvCiIZfIyw7BJaCKwig97C+DE7YYDHWQdmhcMb4HsMrf0oWj0W7xZVwK20hT0JJcl/hHkbMH62Yaiw2xFjsxojxMxcuM7deZUtfDgSYWasweOcW3vbwYYgihrcNkMz93bVre+HbZ6huNBjbNUgUwfz5JU4+fp53fvTuVx0zfWGZv/mTZ7DazqbP5bklwiBkz80Trzqmy//adLeAu7weXQHY5SfG942UHd9HlSTqjk1fPMGGs8Z3N57Aj3xUUeVE7RQhAfcU7nrDz32u/gTTrWOYUoqa2yAUi/SZtyIi0qcOsdCKc0fuTvZk+yELhweGsX2PtG7ghC6fnXmCDbtOXkuwbtf4ytJRPjp+H6P5NGcW1gjCkKbtkNQ1hnObBQzbh3v5gHSAryw/hx+3kLWInlqCPYUR1uSAVafD6kaHnliM/nQC24mQVQHCEKQI0QhIaCqNjkwnDAj1FrYvEatojI6mee/ebXzi5AxeUsTUPEJBhFAiDAUEwcTxG1ysrXEwv4WFzgIz7TnCKCChJLkldwRReKlQSlckdqCiyCFlTcCr2mgrbeweFSVrkMrEaEgBa50yoSYSjtVp5DokFINAtzgTnCde98gZ0JOS2CgKCGIdzSwgayadpkPcgVhcw7EE1IyAEEoYvgBaSHqsh7N1hwExxd5dCXZm/5bFjRqLRRGtUKHHrRBLf4iS3+K58lGGjaG3LJpVb9kYiny94thUFTpBwK63cAv6x6HdsNFNdbOYRQDFUOg0rNccc/HkAlbbYXRqMz1labbI2RdmugKwy6sSRcKPuQXcjS7/otMVgL/AdHwHLwxIKPoN4uCnxU19A5zcWOJ0ZYaQgJya4eHJ7Wy4y3R8i5EXIzciIrPtBW4PPRTx9bd/g9Bj3Z4mJqWIK1kE4sjiGkvNea6s12mGDooqc7lSYnembzNvTtNIvpgPumw1KDsNhs08iigRl3Xm2huU3CYfOLwbWRJZKNXoScR4YM9WRvMZgiig6TWxow0SWoeWZ9Hfo/LAnn080H+E1XqTi2sv+vkVcjw/d55iYDI1tIYdyKj4XGr1MpbbgaI3mK/VEGSISTJa5PN/TX+Hm3yZyTvO0+9GqIZKhEBa7YCooAkuV60RFpYqjAlZ7krfzWAwgqQL9Cf7yKo35pBJssSBW7bR+coxJuM6Rd9DHMix/d5dzG00yWTjzBc3UFUZJSagTqqEvkZSjZFPmkw3V1mxh7kzfgsjuQUSYpulBYOzJ3cwurWfvYfG2X94gr995ix/e8ZCzDSQTBfRDmFN4+Adh2jai2xNFsjI11DcGtMbOv2SiOMlSQR1NqavktixjY5v4Uc+ivDWVKoP5lOcmlmh3rYRBGg7LiOFn50cu9HtA8yeX6S6UScKIwI3YGjrK7sVfJ8fztQRfsiTsEuXLl3eLF0B+AtIGIU8tnqJZ4rT+GHAZKKH940cJKUaP9V5CEJANlMnJzQJwpAeQyZuBvieBEJEGIWIgogf+ejiGxepgiAiCQp22ATAlGVSgsqJUpXFJiihSEYSeGzxGB3xEmlNYzw2zq7ULkRBRJcUFFGm49uk1Bgd30ERZXRJIRsz+ft33oTjByiSiCSK1Nwq3ys9yWxrjunGEvGwwFZtjMhwudae5hZvF6gdOok5rtbWOL1kUncDLjWn2BWaJFWLkq9zrjVGLr2MYbpkgxZeRyba8FjJbNDrt9gdv4awZY2O62MFCjN2mrhqIwgeJ6t5rixNoq7MczZYJO3U6YmtoOoq0q0Pkj34ksDxwxBJELjz/YeRZJFrJ+fpGytw+MF9aLkEK3/6DNVqGwkBy/EwDQVBAs/3kGSB8b4sUsLj/UM3szP9SwT+NQZjFqJmkO2Lk87GGBjJIQgCD7g7WHlihit/1qJtRrghKKHJtLuCdrPEYruKaAokvJCE4BET0vhyjQCJSqND6NWZjE8gC2/uo6jZtllcqyGJAiP9WQz9JfF4284x1ssNLi4VEQSBm6aGuGfvz07l7i3v3I/Vtrn0wgyCIHDbwzdx032v3Wt7655hLp9ZZHFmY/N9IsDOm8Z+OhPu8nNJdwu4y+vRFYC/gJyuLPGtlfPEZBVdUjhRWUAVZX5t4shPdR7n6jPMW6vsSg8jCxJL9gbfK57gPQN3clG7zGJnGVEQUUSZ/em9SMIr98j9YURBYipxM6dr32HDniMiwl+PYW0kGVdT6JGE36nSiJaZa2fpjZIsW8uEUci+zD4ySpxBI8+Z2iyqXUMVZQ7nphgy84RhxEq1geP6FNJxYrrCU6XvsdCZp1SxaLgW7WCJ4qrHQK6HVI/CqrXB06XnuVBdZL1jEeHjBzK2kuBY+QBRGCFrAdlMgCQ5uCFEfoQuBoQ9No1QYFJfQafMNSeHi0Wv3iCFy9dLe1Aik1rdYJAU2b4YiyfOsOO2ZxgbqxMGIfMbL5BZ+t9Re4b4m8WzzDXLJFWddwzu5J5fvpV7fvnW69cuiiJuu30rR5+7htDySGoaQa9L3W/imw6S7nKh4bMtOcx4vB9B0JCVXaDA6JaX34tcbwpVlrGLPgIKpiIR69NozbTYurOP1bjNipUl5mxnKDxLSg+wPInTxR4sI84+c4Q78re/qe3f9XKDL37rFEvrNQQBJofzfPDBA6TiBu2GxWN/eZTi+SXSisCBe3Zy1917kV+hHSRA4AecP7VApdjEjOvsuWkU4yfs6afqCg98+A7uet/hTQ/B2Oufb9u+YcLwFs69MEsQhOw4MMreI93t3y6vTrcVXJfXoysAfwFZsWp4YUBB36zc8sKAmVYRPwxuMMj9SWMHDgICiri5zOKSQcu3SCgJHup/kKvNazihS5/ey5b4m/syG4vtQ5NiVJ1VRGTmLi+hizUkWSQmqDSSHcCnoPfRqycoOkWutK4wldjOF+af52KtiOWDLMvc17+Puwo7CQKHb5/9H6zXz+N4GoF3iLcfvJOSU0LxTOrFJlJCR9RcRN1jvrbOwcwkNa/Oul2mYUuYYhJVDuiETXxgtC9LRjFoCXUE2aLf6CG0JE5fW6BjdmgJLgEKSB4128MKHWRJxBTj7E80GNcvIGNw3N7KKT/FWrvO9l3nKEyssxxkkSSBbN8CM7XPc7pxH0/NT2MEMr4SUrHb/M6OOxk009evmyAI3H3vDrZu76fYbHDCmuWp+mlS5DEMkRZtJEHiof5bSfxQX91qo8PVuQ2CMGJsMEd/T5Lyep0wDOkfzRP4AWZcp1ZrUhteRTYqFBIpClovtxv/mhf+6s9ZXJnHahgI+iQf+eidbBvYgiy+uY+hx5+/yuJ6lfGBHEEYcWW+yPNn5nn7bdv57hePcuKJixgxDbfq8vxfHWeoP8vW/S/3EoyiiO9+/QxHn7xMGG72zZq9ssr7Pnwb2osRxY7r8fjVGeardbKmzt1bJuhLvryP85tFEIQ35YsoCAI7D46x8+DYj33uLl26dIGuAPyFxJTVzahYGCAJIm3fYcBMI/2U8wCzWgpJEKm6DVRRoeY12ZmcRBYlMmqam3OHrh/rhQEy4huKBC2Ua8yXaiiyxo7+w6RMg4s9R7l22Walz2EpbKLrAQOaTl438cIAJ/BBgWPlOc5UFxmO5RgV88w2i8y2KtzbK3J84X/S8r5FMm6iyh7V5gaPnlZJbVep+hUiVyIVpGhFJQQlRGyYHFT3oYkREZsegKokABGaYCBHEmg2oi4yofWhiQIr9hopLUkqoeJ6bbSiSqjCQjrJrgjyagsQGFLb6KKIE/gkpA73j56jviIQtnKYhToOEppvEAURninTFuZ44sIV2mUby9/cYr/YcZgbLN8gAGFTTMhZicdql7loz1ERGvTqWSbTg8iiQMVtvmytFCst/vzrx1ler4EA2VSMDz6wH1OTUTSFRFynWGrSbFjYgy2YcEgkxojJBgvWPHk9xYMf/sfMX1zG9wIGJnrJ9L56d5Dv57z98HpY7CxyxT8L/R6eqqMHCVRZotro4Lk+0+eWaJSarM8ViaKIMIqYPb/4igKwWm5x5tgsqUyMWEJjda7E0ccukknqvO0Dh0EQ+PLp8zw7t4CuKNiex3ylxj+4/WbSxps3te7S5adJtxdwl9ejKwB/ATmYHeFcdYnpVgkBSCkGbx/Y9VP3DNuRHKfs1DhVvULLt9gSH+G+3sM3HFNx2nxl4QwLrQoJReedQ7vYkX7lXswA55bW+MLRs2y4VRrGOuasyN3j27jj3t00vSZn2ldwVJ+R7FayvRZnqtcodjpEUUTL6MFLVoHN6GTd85BFKFoNgrCN5Z3FduPEtV48LyIZn6fRnEWt7Kdmr+AaNXxXJOuMES30kVay7CiMgeESI44VLlNxPVRJRo1yJBWFXj1BshNnaH2Uil5kQyszFywR9UM0LyHNJYmnQuZiozyuBezPz6PKLk6gUfZMyr6JLyTpM0tM6g1WWwpOoYAhrdP0myBtbi+fqUjMlKskVY2eRALLdSnV2zRqz7Cm/hm6GKCqezGMdyIIOt9bv8J8u8ywmcOO6lScJnPtEj26iS6qGD9kyXP8wgJL61Umh/MIgsDscoXvHZ/mI+85zJ6bJ3jhuxcxVIlmyyE1odIzkmC0tx8BcAKHFWsNvaCz7dBr5+L5YcAzpfOcrc1t9ubNbOVgdguiIDLdmubxjcfp5Fapym1CqUKuvAPXj+jNJZBkkVqxwcZSmWxfGoDicoVrpxd48MMvP5fnBvh+iBkTuXJ8juJKBcvxeewvj6IrItvu28G51XX6EglShk4QhsyUK1wrljk08uo9g7t0+dlA4Mfr59vdAv5FpysAfwFJqSYf3XI7F2ureFHAaCzHcOxHN9v9UZEEkbt6DnIgsx0/9Ekq8Ru2oP0w5AuzJ1hrnmJ3fIEgtHh2+QQp5TcZiOVe9nxRFPHtc9doeC3CnjIiDhUr5Jn1i9i0SNxpMdSyEQSBtGETFwY51mgiiRpxIc+1kkDTLWKHi8T8CwxIbdaiGGF4P48+e5WiX6Np27h2m3TSwPd86i2bxWdaBPogYRTHd0BhkGwswTvv2kU2ZbJa85lZcfDFAEEMsPyASK4wluynWS5zeWOOi2tr2Ok6Wo/EjpEt2JHNbLJOZlceZItp0eH8wlYuL2/DjjX551OnmEoG5M0smuiSlWBw9z4upXfwzFIL2S0ylF8HUeCKneJafRK9rlLrcYjCOpoGY8YSkvAdrtYi4kqaIWMeohAz9gFqbgdDUsioKQp+nvlghXW7Ql4zuLN3L0nlRgPZtuWiyNL1ntymrtBsO4iiyNs+cDN9Yz2cLM5T1DvQ16AtrBFEARIiVmjTKxdedj+DKKDu1REQSCkpREHkufJFHl0/hSGpBFHIN1ZfQJUU9qbHOVs/ixu67OvbxkVrjaK/Sigsc/POIxzZO4YoigxP6GQzS2R6ZqiXTaJwmFf73ZPJx+kfznLm+WmKi2VkTSGXMsnk45x47DwDB0ZevgbfzBugS5e/Q7oRwC6vR1cA/oKSVAyO9Px4SeJBFHK6ssiG3SQmaxzMjRCT31yCvCAILxMT36fqdqhZV7g/c5Sk3CaIJGruNEcXJXpTH+BgzyC6/NISDcKIlu0gmQGW0CFJCj+0SBBntj1DSvGQxQxO4NPqlJADl0qpQE4ycRSJnCnTtorclT9GQdnACXVG9TLLre/wnRMqW0anSKaP0XEXcXwBogLtxhD5dIxUPI/t+ixt1Hjorr3smxq8Xnn6wuo0pXCDvNqHhsFGtEpBW+L+2Dy2W6U0YHA0voWKpxBUJTLxkJ1DI5QTl3FEG0n1SBkdQiUgcGUMT+XM4iSHxy7Tm7iCIAZ46JSDRY5eu4LjJznZ3M8ZZwXPE3GFJLG4wKhkMr8iEE+qqJrD+ECVpBLQYIiSZaOKEYPyCYzofQyaGc7Wlml5Djmlh6YccCA7zLuGDjBsFrBsj1bHIRHT0DWF4d40x88vUqq1kUWBZtvhpp2b5s011+ar/izPCZcJ3IBCRSNmuMAMKcUko6Y4nD1ww73v+B2eKD7BkrWEgMBYbIw783dyqb6IJsr06ptVzfPtdaabK+xNj+OGLoqooGsKe6cGmW0ETE2N8a7R/ciSSLNSZnLXM6jSAlGkEkvUGNsW4XLHK64/VZV56IOHqa3VKM4XSaUNxsZyaJJAvdQiIcrs7C9wdG6Jur3ZQnA0k2Yy/9P/MdWlS5cubzVdAdjlFYmiiG8tn+OxtUsEUUgUwcX6Ch+ZuBVDVt+ScyiixIC6jC7WqIXjFDttorCFzHP8ycUxLpQ3+PC2fVS8Bn4U0qunmShk+e7CGr4e0vJtJFFAV2XcyGfNatL2PERBIIxsXLvJYimghkUQBrQFn329q+TyZSx/FEPXkQWPvLyEkStxobGTHlFEDZbJaoNsH3mIS+fX0NTNt4kqb0Yv4zHtBtsRN3KJhACVzeuSlR3uTF3FFAysUKIvucZOyeLq8k58VeTkxipaXGAwnyGzY4hK4yhprUXkR6AEWL7KJTfJad9ja0fFMHuJpAEq9iKqmiCW3oUlKYjWdjZqLUxDhZTH8GSS+lmRgXoMdVuHfCaLJq+jRTJuKNEJ2gjIgMBdvduouG0u1FYAOGBMkD1j8NgTF4m0yxQtG8fzScR1HrpnFwd3jVBrWpy4sIjnR9y8Z5S7b54ijCK+eO4cx8vzhEqIGRo0G2DKvcSEOA/07aFf7yOn3ejDd6J6gqutq+TVPBERFxsXSStpVEnGC4PrazCIQtQXi0TGzDGerzxPxa0QRiFxQ2dHzySyJOJ7AU9/7av09iyzupCn1Qgw4wFjW+v0Tr16b+9cT4Jf/e278atNrLaF6AesLdYY3TFAppDkg727yZkmC5UaGdPgnqlxMuZP106pS5cfhW4VcJfXoysAu7wiVbfD0dIsKcUgp8VxAp9L9TWuNNbZl33ttl0Nr8l8Z5Ewihgw+ujRXr6dC5BSdLalevDtkHW7QdFu06MKKBKkDIVj64vMNGaoeBUkSWRXzxAP7jxMx3N4ptWgLTfIJ2NEqocQxqk4G8QUgZhk0vZ81tsqibhIU65iex5+WyDlmxBB1WqhyCqB6EAkcs1tUfYbXFobxO708CFjN1sH9jDYYzGzXCaTNKi3bQqZBIM9NxYv7CkM88hajA2nghYZDMarpGWfjTBBS3FwHZ0MHaKqRJgER2tytbjOx/e9A62gsLKWotSOc7m6jCB6mFJIb6RS11zOOQoGIU5rHs3pULNzEI5gqRENr0KgqESyS9MKCByf2w9u4UOH93LCucz5aotOuEZcWADBQxMyaPq9CIKIKat8aOxmSk6LVtPmkb84zYXlJURF5PxyiVhSZ9/eEcq1Nn/z6Fl+61du44Hbd3D7wUnCMCRuagiCQNNxWKjVSaoqdcEhqWiUrA6ur5CQe9id2vGK937D2cCUTEx5s9K46TcpOSVuyu5gpVNmprlKSERWTbAnPQ7AgcwBAgKmW9OIiOxJ72FLfNObplpssLZYYnxCo3ekQLzj0qaGMaQQ5cLXXK+F4Rzv/s27efxLz9NpWmzZN8Lbf/12VE1BBd61a9trju/S5WeRiB9zC/gtm0mXn1W6ArDLK+KGPl4YEFc3t3xVUSIiwouC1xxXdWt8Y/VR1uzNrhgpJckDffcybA687FhBEDjY+3ZWSucQWESKOphSxNF6gSvtNZqtDnPtNnHPQECkZl0hpZj81p338O72Di62ZrEji/O1dS7VSlQcHT+yCOQQM+qh0Y4wTJdEKBE6HooR0g778N0t9OtXECObjCIy629jzUpheBFEoGoyZc1FVxU+cM9evvHsRVbLDSYGcjx4ZDuZxI32KNvyA3xk6zv4ysITdIIOBbOXHn2V2Y6LLwfIoY8fiFRbJs2mhqqHJMlz0517OdM6jyLKHCoMU2xVaDkhWiTheC3aoU5O8fCqDr5Qx9NCVlSXOecyajUgbrgYiYBIVtiqb+POkVvZOVggn4hh2DtYtsp8rxnRp8yRVzW2px9A015qtycKIgU9SfFqnfWVGqNjeaptG2FdJHR8BGCwN8XSao1ytU0qYRAzboz+qpKEJstoto4ktan4LezIw+oIBOc6PHbhBbbtH2NwvOeGcUnlJW/GiAg3dEkoCXYmR1BHZGZaq4gI7EiNMGRujlVEhVtzt3Ike+T6/AHsjsvM2SUWphWmtqfoHVrD7fFJy02u+EPMLp/jbf15tiZeXgn8fab2jzGxexjH8tBj6vVcxy5dunT5RaUrALu8Ijktxkgsy8X6KnktTt2zyKoxhszXbql1oXGZVXuNYWMQAYFle43j1VOvKAABFGULfdl/xOnGf6bml3ih1sP59iRVr4yMR0bSKGhJ/DCk1G5wubKKMA79iRT9if1ca67zxNoC4/EClh9RbTeoiwI9ap642qTj2OSFJFYnINICqmrI/Np7kcXvcXhKYzy7h0vNAQZ7l0lHKoIo4qkRmr751ihkEnz0oZvx/QBJenWbmjuHdrOvZ5yvnj/H1eUVjnkXGTJW0AIRi5AX7AEsXcLtKHhNcBwZAYF+vUBMNig6RfrTcZZaHZSWiZ4KWQpG6Q1aRP4GvimwYPUhBQPIYptAVhnSdtEbi7NU6zCY2s5d28evz6dHT/GR8XuZbe0EYCxWIKW+PBcziiLWFspUa03kPgchKSHFPPy2AkRUWx1UVdrcZv6hcQuNOi3P5ZbRYZpXHCzHo06TTCiTPx5SnF7iCZY5/8Is7//texiaeKkQ5ED6AGWnzIq9AhEM6APsTu1GEASmEoNMJV69yvYHO8ZYLZuv/j/f5erpeTaWLL7wX3q55TdCtPEqXmsL4cD9tH2X7xVPMBkffk0rJEmWMBM/PZ/MLl26dPm7pCsAu7wiiijzwdGb+JvF0yx1qgybWd4xuJs+49W92wCswEYW5Otf0rqo0fY7rzlGVHZwynqAy40N5ptlJHmdRMxGiwQUUcH1TCRRwxc9EmLsBhHmBD5+FJLRYuzNDnCpLlKyW+zJDpLMKXxj7iyiA73pBPWoQ9tyudIO2T74fqaGDmBqKlP5FbIrVQRBQBIEfN/nQO+NglWWX18YHJ1d5flrG+iayDeWtzBuJknJAotNkStBEiWIkDqguhKFZBzb9xk0erkrv5tTtYsoYi8JNU2UcohJM2iiT8ubZHY1S73HouOZOJkqscAnkH2QFXAziMHL38btls3FE4vU622qgUdlyCebMUgUREICevUccdngu397gr8++z1Wbl9iOemghQryPpNgpZcn/GkszWN8OEdRatHHprF4GEX8zbVLPLEwi+V75AyTe7aME5O3YcgKp/70OGefvEQpCBAEqBUbnH9h+gYBmNNyPNT/EI9fPs35mXXmrATPT6xxz4E4yhu41t/nwvPTXDk1z+BEgaGpPs6/MMtT5zNofTJ7BqfQVJU4TezAwQt9JOmtyV99PaLIIwo3ABFBLCC8wS43Xbq8VXRzALu8Hl0B2OVVyesJPjZ1B27go4jSG/IR7NV7OFe/SM2tIwoS7aDDjuTUa45RRImRWJYn1q+SMnw0xSUm+ii+QCcIqUsruO0kGTHJQ0M33TC2T48zYZRw3fOk5Ay9ep592e38g6k7KDktNoIaG3YTSRCwHZP96jh7ksPsHevH1DbFwMHefpydHl85f5FSs8OWRIYtsZcinVEUEeEjCgqvxdWNEposk1FVrjVMLgj9yJ6BGzkQOSgtDdNViAsKZkIjwuJq/cu0ncuMKSFIW1jwM4jSn5FWqohCRKht0IhPsdSKaAsiclNATajYisP56hynGg1SmsGvpF/qJdvp2Hz5z5/k2rl15l2LauCRLsSQ97SJ9QeIMiiewVZrC+fOnaeyvYyZCnA7Eo4Q0jcqEWxpE7QVenWRUK3wJ7OP88+0hxiKpblcKfHY/AwJVWUgnmChUefYxjL/4tDtTBcrPDczTxWbYVkj8gOa0grXSic55IyS014S1vMLLZ5/poGAgSyFfOf5KwgIvO3w1tddZ9/HajvAZns1gNGpXqqxBkqvQku08P2AittgW3IMTXzt+/dWEYV1vM7nCb0rgICk7kc2fwVB2DSPjqKIlZUalWqbeFxjdCSPKHa/bLt06fLTpSsAu7wuqvTGl8nO5DYaXosLjcv4kcfu1HZuzt30uuN2ZwbJq3FU2WN3Yp4powpRQNPNcKy8jR55F+/fe5BdhZe2BqMoIvSf5JbMGVY7FbzQJ5/aypG+B4jJGjFZ48MTt3OmuoAXBkwletmdHnqZkBUEAc2WkNciUq7CernB52sn+fC9B8mmFih3vkEQdjCVSXpi70OWXjkKGtc0HN9HlWMIxTR2Zo1srM62eJlOHRY0ieV2PxoyTdfh+MpXsZVnma828MIGgnAUMRTp01usuQMkTIWMVOI9u/tZuxCxHFbw8wHIEVIQkdRE9IyEHpvj8eo6nr6DyfhWnrz6NKfTF4neLuAtm6SXs3haFdfsUF+WUCWFwGyyUKvTjtlkFQEZCV3SaIU2oiFjYZHLCESCgwCse2u8UBlmKHYnVdui4zjkIhU38CiYMcpWhy+dOcfphTXmUyHWpEHQiZgcKpIerdAe83my+JfsTd/NZHw/ANPLJRzXZ8tQHoDVcoPzs6tvSgDm+tLIqkxlvY5ualTW6mwdHGO4t4+TtUu0fYvJxDD39x75qRmh+/Y3CN0TCNIIEBC4T4PYh2I8AMALx2d57PGLWJaLokjcfGiCt923C1EUWLyySnG5gm5qbNk/iqr9dERrl188uj6AXV6PrgDs8pbiBC6SoDOgj5JW4hzO7kZ9A9tuBT3BRLKHvDLPNmOFdhAjjDRGExUGUnXuG34I6Yf6GHthibr9FGm1l7y+EzfsEAQrxMU13KBAzavQ8ktsTcUZNUfQf6i7RcXpcKayxEyryGMXL+NpIVtzfXihwPcaVyhfOM+7x8/RZ2goUoKK/TR1t0bS/BDLVo3Z1ipNfwlTdsmoSSaHx5irBcx736RntEbBC9ijrtCvtVAmwZq4xnT1AK3Kvbi2zHTtKIG6hiw2UBUPWfJICTa+l6bjh5i+hCNIrDsrhOY2xLCCJoiECISRTzrl0qNuYAcWTRemW5c5XTuOHUTYyTaYPqpRI8x0CMoxJCSsTkAyZ6JqMn4mpFESaFsBSR3swEZUIgTRgzDCCltk5BxBFNGmymz7GlF0B17JYuXqBsvtFWKCjDQQY2g4z7mVDbIxg7F4jJWWTzTZQZ1qIVcMssogtWabpzvfJDs6REbLI8sSYRQRRRGCIOD5AZr8+h9Jru/zxLlZzs2vocoiA3dMUDmxRKPaZnLPMA/86m1ke1JsMyY5cXkedz3iUqXMwZ3mdUufnyShPw9iCkHc7BkchSUIlgGo1To8+dQVRFFgfKyHRsPi+WMzTG3ppb5Q4jt//ixWy0YUBbYfmuDh377venSzS5c3Q3cLuMvr0RWAXd4ynMDlb1ee5GpzAUkUCaOIut/mwb7bX7cP8XAsw9sHdnCtfJQoEumECnFFQxBVxg0RUXj5z9EwcgkjD0VMIQgCYqSzWK/zzXNH2fCuovesk4qLhBGEQYykuIWCnuaOvs1iif965SnONS9Q9SpYakAUpGhFbbwIAklAl9bZsFZoBltJKVBxW8ATnF61KbsiCSnCZRlN1Bg288TkVaamHPyFBp5lMNm3ykSsyEo9SwDE5TYTvWd5Xu4lWNqOFYokpCpiJND2NRAiPEnAlJqYkgmRC6HD8Q0Vu5nA1UMiISAmgySCJFVxAN/LkTRiJJUES9YCcTWHoApEdQ1Rc3CUDnJfSDvUCDUNUYpwBZeEkCbpxfDa63RUDznuoMZAVEISkUzZ6VD2OggIZJQEcUXGdl2mv3mFQhXKfSr1wENZbrB7ZAtnoiqmqjKyfQi742CbLRQV4qksC2EJq1xDVlyWy5/jo3t/nX1bBjg3vcrVxRKiKGDoCkd2v3ql7vf57plpHjl1BVNTcf0ARRJ5/z+4m9FMknQ+iaxIeH7AI49f4cyV5euRv6X1Gu9/2z5k6Sdb4SuIeezmJRanbVzboTBYJTsYRwHabQfbdin0bOZTJhI6pUqLWqXF0189DkSM7RzE7jhcOjbD9kMT7LrltVMounTp0uVHoSsAu7xlLFrrzLSXMKQYHd/HC13OVK9xKLOLgv7y7gkd36bk1LGdgKAjM670MDl4BMueY4w+VFFHE1aJa8PAy5PoVSmPpgxhuVdQpALz1QVmqwGrjk5dncWrddgjT1ANWyx0rmDgEgVZrjVKTCaznK2dJpSKGHKAboZYok+zk8ENoE/IkzbjuKHHXG0RUxExpAqmFKfuOnQCj4TsI/sqDQfagoxoNhCiKpqXxpMCQmQiySPSPHQhSdN3QHBZ9hdpSDJb2E0QPo8guGiyjx3KtLwMBiKm5KBJAkVrN8uNPUwmc7h+ASuskFKaQIATWniApqTYms0TRjaiIBFJEYmEgReGCJKNmLEJRRvJ02mpOiu2T8aRqRfXiXSVfLMfQxoiM9wg0iyGjH4qbg07aJOQRZJKEkUKGYsNYzddWvUSR8wcHhqOFFJdLTMRxCkmfRaqNfKpGIld/eTRGRwIKbttLLmOqoZErslio8xXpr/Jx3d/hA8/eBPnZtbwg4DJwTzbR1/eMu77RFFAFDY4O79AXNfoyyQAuLJSYqXZIijbXP6rEyiqTG4sy4XpVQZ70xiaQqvjcP7qKrfsG2O477Ur2X9UoijA9mdotHpYOtdBZBFJkrh0PENwTOOBvxeRSpukUiZr63V6C0mqtQ4xU8PQFBzLI5batBjSTY0o2rS48byAVsvGMFT0bjSwyxsl4scz8+tuAf/C0xWAXd4ywiig4rQpdap4UUgYBRiKQM1tv0wArlkVvrryNDPVNZZKTeRGjF57iFum+rljxxH84AIRTXy/QKNzD5Jkk4nf2IFBFDT64r/GRutLWN4yVxohz9a2UI1aJJUGsquy3mlRpYMuK/QqBgkxx7V6iWML12jqa0QRhIJITNYwdQff9/A9laEejatuhC8qFLR1NEkAFC62emn5EuBTb3cI3QA7lFiolRjpk0nEBDqpNuWWh+iG9EWQ0FpEEcSUCqtWCiV0aXkdnjlps3V8hJ6+RTqhghdKKGLEXGs3B7L3sL9/jO9c+2sGU38NCGSDAhtSSEiEKSeIkUISWxiyhU0ZAhg0Rlmz1vHEDnJWIo5C2/WJ7BSFWBxLd1hyRfzIRjQh1RuSiizUmThCu8Z4dpy4kiajprECC0M2yaoJhowBbs9OErb/O0fuf5JOC9qN21mZHcONZHqyCX51Ypi/On2BYrvN1FAv79lzDy4z/OWFP0VRA6QgAc4Agh1Qdeq0gzZDhTRDhTRhGFIuNlldqpLNx9FftJ2Joog1u4jrzZMOv4MWVbh9rMaJhf0sVSYp1luUmx2On55DvdpEVmR8P+DclWUaMem62FMViSAMCYLXNoX+0de+R6n1BZrOUarVMsutNrp7GK/Vy/Jsgna9xJF3NUnnk7zzgT1885GzlEotDEPhnrt3sGVrH4WhDLMXNiOW7XoHzVQJFZnP/c+nKFfa6LrCfffuYM+uoZ/Ia+jyi0VX/3V5PboCsMtbRo+Wo+742FGbpBLDDX0cX2Kx1WRr8qXjoijikbVjLHVKVMo+nhMhZFrQ6fDMpRKjhYfZOXw35+cXeey0TalRJGU+w7uP7GTveP8N59TkfoZS/4RnN87xzfUncG2RnGHQ8SVkqQlCmiCyUBBRBBNBEFhuNFhvVOnRI0JEAkJavkPWEBnPZRHDNGv+Mo7jsWbtZleygSzVqTsG1+o5TNEhUtqojko63iYmREjYVIsJMuY4onqWviR4nsHZ2k62pYqkpBW8KELVbQ7lZ+hYKrNlhZ2r97GW+A5puYnsiUjaVjLprdw7djP19mNEwgu0wwhF9hlJlMEpEEl96HKEJkYIaIzERpmM7WKxVGLWWgE5hiaBH3oogofkJTCkLDIKqmwTS7qYboYoEkhEKn3ps+w4tAFmE104hxANEESwRRfYlf0NdqR2owoKVvszhNEpBkb7WVmYR1a+zfzs3ey95Tam9g4jKxL/7O5b6bgehiIjiSKel8EoXWHZOUNSyuE4Eq7WQpTSaMJmTmbgBzz6tTNcuXga3SiSzma4823vpacvx9OlY5ypnmG38hgFuUZW38ZwNqRlPc4z023W6mlUReLs/BrbFZPtw5s/NK5eXkU2YG6lQiquU2tajA3kKOQSN6yfKIpYrjfouB6FRJy0of9Ia7/tnqFhP4MiFcCLgXqC0FyhunATvmsD7vVjt0z28rG/l6besIjFNFLJzR82D/7GnXzjfzxJaaWKqqvc/I59nLi8yspKlZ6eJI2GxTe/dYZ8Nk5/f/pHmmeX/4WIhM2/H2d8l19ougKwy1uGKenklEFgDUmIyKopLFcn+KGfkm7oUXbrJESTRdciIZu4dJD1CCsMqXeg0prkb44WCSONwVyMtWqTvzl6geGeNOmYfkNFZxBFrFouuqLhtDzW6m1ELU0qKZBPqPi2QaVjUAsVlr0yjheApaN6adBr2CEoQkhB6+F9Q3fRq+f5v6e/AqQo2xbzdg9tr47vO6hKSAydZi1Jp6HTxwBJESRLRajmSYyN4YY+A3ENAY2aG6cYXcZpP8ZSJBJFEmnJYX/vHBvVNPWGRLW8l5YvYDcDxnYOo0kRoiByrXaMlgeSIhNJoCgdUjQpBXEExSQgwAkd3EBg6ZjBk52ruGqbeJhm2/goTW0DRXQQHJ9G2wPBoeUFeL5MBGyEHWQWGI9fwG0mSUd5suJ5gvAi5bCPLZrGgHQWTbyJKGoQ+LOIYj/ZQoaWmKDcOk2ouiwnFGquTV6JIQoCce2loh9FkXj/TffzP041KGqLtHUHUVZY9w0eWbnCu4f3cO7kAs9feZSdh58lYbbAhovnL9GJ/w4nqufIyz69ikvVT9CwGuxObSVdfZatvS75VB+96TgvnJhhzbfp8WxEBETgyNQgVlyhVG2xe6qfB27bgamrhGGHMKyBkODrF5d4amYex/fpicf5lf272VrIv+m1H4R1IEQWk2TyGusLOaxOmY3lJdplmYP37SKVS2xWrocRsZhGLHZjUVJhOMeH/9XDNKttNEOj0XF49MQcfX0pDF0lZqrMzpfYKDa7ArBLly4/Nl0B2OUtQ5MUdqZGOVqMyMsx7NBHlEMGY+kbjlNFhZQSY8HdQFMlalYbWY1wLUCAdEyn0uzQsBy29OcQBIG+TIKZtTL/47vHsByfbMLggQPbqMltvrF4nueX51i1qsR9HQIR2VQ5nL+V39pyK7Yf8L21ReaaFeqizeWwTEv0KZWy9GU0JKFOQkzyu1t/g4nkMEEYsD87ynx7nUEzw/naMtWOQNTpYZs5QEFKMVe2qK1b5NsFYobKWqnBtvECE5lejjV6qToqqiRTdZvsT6YQwhxep40iB3iCQEqzySUtatMWoqmxEm+Qyhm0FZt9iS30alnsQENXbJxIJYxAEgI6oUjT9dFDAdkQsYI4z28s0FkPyPZGGHIcux4yu1imd1Jn2BzGFNe5Fq5RajhU1jOIIrQSRXxVJG6UIQwouzn25eIEkU6AiCyb6GJIvfMVVv0eENIMRgESdUqWz9X2LCm1A3GfY6vLuFHE7xw6hOsEm72CY/p1b7vt4/38s9Sv8/+78BWisMVkehAvUHli7Srj8RynlpfI7zyKaDaYbvSg4LElfo629Sx+6GPKGUJU4pJPPfDxwhaqopBL5ujJbbaJ01MGi+UGKyvzCBEMJWL8xs2TbNnaTxhG1+fiuOdodr5AGNSo2jIXVicw1Z30JRLM16r81dkL/Iu7b0N9A9XIP4gQprHtENdaJRbLMrrXoDSbwR0bZ+C+AW5+YC+Xjs3w7NdP0WlajO8a5p4P3EwsaRAEIRdPzFNcq2GYKrsOjWMmdLwwRFUVWi0HQ1exLA9JEn9ieYCteofl6Q0EUWB4qhcj9qNFQ7v8bNDdAu7yenQFYJe3lIeH9xFGEdPNInFF456+rexM9ROFNXznKFHYRJQHeHvvfr668jyd3AaNUkh7XeLCapNCQmChWmfXQC8xTaHS7JBNmGzUW6zVW7hRQG86weXlIvOtKvagRcd1sRsBoiLixjzigY5qK9yX20laTYEKvzyR5VRxhf928RgD8RRNy6XoOjQ2DApyD7966DbGE0Mstxq0PIeb03vxw5MUnTo7032MeMMU1yTGjF4iD1Q54KatOaj5tC2HrWM9vPvePeQyJg3P4pniVfww4HBunJvz41yTjpMLyzi+SAyPDS9NIg233jqG3ohRy1bpmYgzkMxzMLMNWZTIGndTds6SlatEQkTDM1h1srjIXF0TISaiqxGqGFLUW0StAFmqg6tiKyDYGqZcYCy2nz435FuX5tkRZri6uEJ1wMPQPDwpiZlO4sZE/ChAEQOEyEOgihf42GGdJetPWIsOkyZgULxCENSJ6x6rXoaLYYmqeY2jGw5931GYv1wkDEMmJ3p5x9t2X49yaTEFzUgzIeUY1VZRhTZXWwFVZzeLQY3heAffjmMKCnUnwJEiEkqELMqUvICUspMsz5KXOiiRhqrdxGKtH6jihyGBDum+BLlQIRAiiMlsiC5b4Lr4C8IqzfbnCcIqktiH58+wPbvEuj2OExgUYnGqlkXTccm9CQHYbtl8+0st2mGWzNBVkukFhke2c/jIbxC7ewsAC5dX+MbnnsSxPYy4xrFHz+F7Pg//9r08/a2zPPXNs4RBSBhFXD23zC/95l2kUia33TLJd5+4xOxcEVEU2bN7iMmJnteZ0ZunuFLlb/7r46zMFRGAka39vOe37yWVi7/l5+ry06HrA9jl9egKwC5vKSnV4COTt9AJXBRRQhVlorCF0/qvBN5FBEEGR6BXfzu/MfoA606N4/IKjy0tEO/XSegq3704jakq3L1nksfPTjO9WkYUIWFqTPblMDWVfCLGc+VZhHbAmJllyW8wqObohA57xWHsZkBSMG+Y20KzhhP4HOwZoGDEuVjZQIjgX+6/i7tGxvnG3GWeXn0ahHViis7dg3fyroHb0CUVuy/i863TTG9UEIDxQpYP376f1VqT9XqTQjpBJmUiCiL39u3g1p4t+GFATNaAkLJzmXjnL1BFl6qbYd4eZyCZ4Z5D2xiPj73itbx76H5mm6tcsb9OREDJSWKhQhQhxmwEWSIMZQKnB78hsOTBYGDipZogBWi2yYZksdy5Rs7Jo7sp3LaH24qwN7K4PkzL/WzRPCYHV5HEGKDgRx0kUcMLO9hRnLzsYoU6L1RlFpRRTKqsWxHzVpopY409hWus1Ascu7BGItzKqtvh5AtnmW3W+N0P3Y0qy8RljZSi0S9+i63qPH7kk09E9EoZsr3b6bTy5PRFWh2RdMzDTBj0Gts4nFU4WT3HKavAqHoft2SG0I1RptL7eI+/zvmldSRBJJQjUqZBPrHZ7/jqeolK68YWhEGwQRCWkaUxBEFBFEcQ/ee4eOEUjfY4aq/JaE/mhi3sN8LRJy5z/tQSfYN3UrJ2c3ZxBcmKE5eepWfoCvf98i0sT2/QqluM7RzYbDkoScxdWKayXufkM1eJp3SyPUl8L2D+6hozF1fYc/MEt96yhd7eFOVKi5ipsXWq7w21JQSo1zuUSi10Q6G/L/2a3Uae/cZplqfXGdnWTxRGzF5c5vh3z3PfB4+8qWvRpUuXnx+6ArDLW44gCC8Kn00C7wKhfwVRnkIQFMKgROA8R0K/l5Q6xNHWBinTYLxnM4HfC0IurxX5J2+7lanBPI2OQxiGfO7J45xYWyUUImKKQiiCLAiomoSpKVTtDoaq4NYjeuNJ8qnYDfPSZJkw2swZHEqk8KOQXjPO3aMTXK2V+d7q4+RjZ1GlANt3eW5jifHkPyNjjIMKv3XPYWY3KjSCDoHm8uVrJ7kwWwFfRBJFbp9I0Zd/jpI1iy/k2dbzy+zO7EIQJIYS7+eFeodmWEGJ59gS80krcVLqS9UxTuAQAZqobnYnkWTeN/kQv3/uIk27SegLuIFAKITYdZNQk0mKGQI/hayXicIILvehD6URk/OMBiIFU6Pmy5S8CpKZYKm9hqPXEVwRC4VlS+Ar5/fx8YF76EkP4fiXcNtfQBTiuIGKFYkYooAduASRQDXIMdtQ2fAC9icW2G6uEUQKmZSNO9XkqRMSS20TgYgnp+cZO3aRDxzZjSrJ/NJQgmJtjlVHJyDLWAz6lLMcHtnHX597G0nhUXr6ykSiQiL5AJp2mFs1kan4GFZgk1ZTJJWXIlK3bx/j9u1jRFHE//XYc1xZK5GJGbh+QASkzB+uGo8jCAZhWEUUe9iYmaPVDplds1mpr5Mu6nz41/e8ohm1FwYU7QYIUNCSyD9gSr62srl1a8Z0XDvP3Ok1hKDBru0ml49No8izbNmrMji2gEAWMHAdD01XNtejH2K+GCmVZBEi8L3g+ntpcqLA5MSr2+O8EtPTG3zt66eoVtqomsxNB8e4//5dSK/igVjdaGAmDaQXxaWqK9TKrTd1zi4/awgv/v0447v8ItMVgF2AzWrIi405rjQXQBDYmRxjKj78FrXP8tnMKNlcboKgEkUORB7ApmjzA6IX9xxs38dQFQRBYLSwaeNRbVs0cFlqNJBFETcMGM9l2JvPMdspo+dFlEpIzo4zkErx7lt2vsw25mDPICc2lrlSLyEACUXjgZGpzcrgVgNBvEyAS8fPIiIRss5C6zQDsU3j6LSpUygYPDp7mrlSiWsbZQxV53B6CtELqDv/iURrATWUMcWAM0vzaNL/l62pMVJqitt7HuDp8rN0/A4JKcktuSNk1Sx+6PN85TgXG1cA2BKf4Nb8zaji5jWYTAwx4xdZ7zQJwhBRlJArfUSZKtmeayQNm3ZGpV0rUMi2GEqv4qevkNIXkaNpNPZiaCkSOzrMmWuIeZu9ap1tUg3sgKo/yqKzh/9yUWJ//iBbE2t4wRJqaCMFS9SDftphhCBEuB0D322S1BzGzDJ2oFJupXC8GENSCVGdxqttRZYlsr0mpxdWuXf3JLm4yVjcJB2kGQhHUCSZpCISBsvsysd4xh/jGyfuJmk2OTI2yQO7H0QQNsVIj557zdUlCALv2redpn2amWKFyA/Z0dvDgeEbK8YlaQBTfxtt6xt0WmvUG2usXJ6itzRGOghpLnRYP1eCXZM3jGt5Nl9ePMaVxioCsDXZzy+NHCYma6wvlCktlli8uo4iCURhRLtlM7mlh2xfisndy/QNPE3fUIbb3lFj7uISp545jCAa3PHwQXK9KYYmerh0cgHX9Wg3bJLZGANjb74Q5fu4rs8jj5ylVuswNJyl3XY4+vwMo6N5tm3rf8UxvSM5Fi6vYLVswjDCdTx6Bn4yfoldfjp0t4C7vB5dAdgFgAuNWb628gxuuCnKrjWXeHjgDrYlR37s5xblcQSxhyiYJhISEFWQlAMI4mbE7/DEMJdWilxeKwGQjRncPjUGQBj5lKxLHF+/jJEtclN8AMeJQABZkXhX3x7OWhe40rzAjoLIiK5zX99u+mI57MBhqVMkImLA6KHHiPEPdh/hdGkVNwgYT2bYlulhqV7nq5cu4JsVPMfBC0NkUSar+lyoL1N2z3FTboQ+M8nTxausWFUGtCxLYRtP8VgMihwyPIaT17ACHUmI03QkUso859aeY2tq87Uk5CzbEweIIp/tiTEyWhqAc/ULPF85QVyOIQgCJ2un0SWNI7lDpNU0W+JjeIGP0xIIBBfX0ojkiMHkCgnTQtOhoHosdCo0jDJObIWWbdAIZDJBEUE5Slx6kAoVJrUCzeYsh8cvo0kurm2Ql4ucKXrMd27mUjnGL2+9j92pq7SsJQJ/ipqYJ6cZCFGWE5UatZZFDBdCEc9T6Ng6ghMhK5vRJd8PCMOITNIkjCIsz+XoxgaebzMqJ8koG4hiD2GwjiQN8PypNmsXy+xK9BNZfUyf8jnXu8LB3W987Y3lM/z27Yf46leeZ+78Eq0zLR5ZdHnwV48Qe9FmRRAEYsa7UOQxVlt/i+cW6e2rIEbzLM5NYPkCtu2+7Lmf2LjE6eo8A0aGiIiT1Xl69CT7/QG+/H8+wvpckU7V4uRTTdI9CWKGQiFrIkku/UOniSIBSdnO4ERAMnORnpEEsczdbD80gSAIvOOXb0bTFJZmi/SP5LnznXvpHcwQBCGXLq9SqbYxTZXdOwfR3kBv4Hbbodm0yWbjSJJIMmlQLrdoNKxXHXP7u/ZTLzeZv7SKIMDeW6Y4fN+uN3z9u3Tp8vNHVwB2AeBcfQY/ChiN9QEw317jYmP2rRGAUj9q7O/hWV8niqqI0u0o5ns38wGB0Xya37z7EBeWN4iImOrNM9aTIYw8LlQ+z+X6IzS9FuMjAoE7RW+4nUYnxkI9iUWdqj9LTlcxZYMNd5Xnqs9wt3I3f7vyDPPtVSJgyOjhPYN3ktNT3Df0UoQniiL++sJF1ux1DC1NQl0looMsBlihwqVaxKOrx/nS3Gnu79/GmltBlxRiqkpMUSm6Nm0s0I7Ta9RwIwVRaNDykjQ9cFx/8/rWZvnm6vM0/Q6yKLFuN3n3wG3IosSKvYYsyGTUNB3Xo2nVeHbtIq6dQ5JEpsx96JKG3bjMetEh3xkmSsxQiAskY4OEkofltkil27RsA0EO6TTjZGQJ24aYF9JebLEQFBFLGkN9GximxbqXxJUl4orP9twcl9Z2U0Hge0txrp3exun5JNXAJhZXuHvnBEHgIdTPkQ/aiKsR69Yg/ekio6qFFLlIYR+2M46WMXBDjwWrwX4jzl8tn+ZKs0gURYwZkzzcO0O/0UKSR+kE7+bzz16i2GmRk2Nsy+WwHI+5pfKbEoAA86cXWXlmjkI+gWSInDs6jZnQeceHbrl+jCAIhGEZ3ZgmmZQQhTKp7c9SKlqY5iQ7dg6+7HlXOlUMSb2e1mCICiudKurJDsXlCtsOjDLph1y9sEKuL8XgkTGunZjFbtpMbmuT6ikQS5mIooCqp+mdGEfWX1qDyUyM9370DgI/QJREBEEgiiK++8Qlnnnu6nXz6unpDd73noOor9PPOBbTSCR0iqUmhqHQbjvIskQyabzqmEQ6xi/9w7dRXq0hiAL5/vT17eAuXbr8YtIVgF0ACH+o9bcgCIRv4R6ApGxDUrYRRSHCK/QFHsgkGcgkb3is6pxjpvkozUDEVEZIc55C/Nt4zkl8LcW2/N1okkgsmiepTeEJcQREik6JZ0qnmGktMWz2IiCw0FnnmdJZHh6844ZzuEHAequFrot0vFE6cgxZWMMJQyreEGl5iJqzSs21KNttcrqGpkJc1hnOJ6iXWiQii77UGraXQJFtInxy2hrrnS1MZA9iBy7f3TiJE3pklTR24HCyeo2pxDC7UmPoko4XudQsi9Nra9T8Eg2rwd9c/A698ThEcCg7xIHcnVz2VimJHXplk7yq4zsitubhBB6qIiOEJkQKKd3HDGPkzYCVZY2Z0xbuTiDp4ZkekRCCJxF5MpIOER6aolBtd5hdKnHqZIOa4tHCJyxHnFpZpycl8OHbp1HFOQTWSagdPE9nrZaitDYMxUPsTI1TdZepRi4xDdaDa+Taz/OOjIsVxSm7WZ6r9PPByQeRpK385aOnKFkWvh+yUm+yWK5jeiLZnjh+EL6pvr2rC2VESST9YuWq1XZYntl42XGOexJRUpiY2s/pM/OI4gpbtla4+57f4OCh8RuOjaIIQXApuusooktKzmAFHjkthmdb1wWbokjkcyaJmMr7/+HbOPv0ZZrVJoWxKr2D6wg0CIMmYCBKLxeZwA2Cq1ptc+LUHIm4TiYTw7Y9Ll5eZd98iW1Tfa95HVRV5oEHdvO1r59mcaGM6weMjORwPR/PC1CUVxZ2iirTN/qjbz13+VlD+KFP9Tc/vssvNl0B2AWAnckx5tqr17dMZUFiW3L0LT/PK4m/V8MLGrihiyymMESPUaODF0BLKjCWTTJofBc/eB5ZqxAKsyxyG+VARRZlmp6FKqoo4uYSH1DbaP5RIlcFeReCuFkgokoSOdNkrioSGAIbnUFabg+uatFv5Llc3aDYbGN5Pl6tSVWz2ZpL4+o+hibzGzuOcCSpEgVn6XQGqTTPIUotXFEjJr2Hm0d3UPNaND2L5VaTmlMmiiIk2WfdqrMrBbuTO1jqLHNifZp6aKFJBh03gWMHLDl1QtEnL59AiOqkEgnWgyEuLNrssEPILOLHfUI5pOz24nujLKyrFLLLGGoTu5Nl5uII5VUZyYiRm1pAMHz8UGYg1sFRRUIx5GS9l5JnE3gRG9M1Oq6Ho0Uk5SaiEtBBJ65XEMN54kaIIjiEkURCd6lrHkV5LwPqOM1GC7mnyc6syv6BOJOJRzG1GSRRZrdeIzBFKl4voVWlEXyQxXKdnSMFLlxbo9ps4UURsqJxamOd/+ObT3FwaogDwwOkfqhDhxVYXGtdxvI7pNQMW+JbiScNfDcg8AMEUaTTshl+xeIJmapTYkVokNobkBEVDt62j4HMvpcdeaZ+haK7jB/VudQqoosx9qX2cEdhO+vb1jn15CXW5orIikynYXPTvbvRTY3Db98LQBhswe/8OWGwhICBbL4DQZ563bXvugGeF5BIbL5uTZMJwxD3xYjy92k3bVpNm3hSJxZ/6RpNTvby0b93B49+9wInTs6zulbny185wZ7dG7znXfvfcCVxly5dfnHpCsAuAOxJTRJFcLExiyAI7E5NsjM59nc6J1XKoksGbbeJKIrIgkVbiDOe7mdIFRC9syjKAUI/heDPkYoeJ4ju4eb0IWqez+XmEh3fpk9aYKf6JP2qRtSeA2UbmH8fQYwjCALv3bmD+kmLC5ZDS2qSiRn0xHootUJW6hu0AwchEAltsPBoFCPeOXGA7QMFkopBGDVZrxeQ4usY+q1Y3jqyGOOmyYcRBAFDUmm5DkudElklTYBPw3W5UC5zXx8U9B7ePfAOppceIXQsIsEkDBqEoUcn9PmtLSe5q+8sshARojLo9/Fnxk6WtBym5BPWfTwtRcntwbT62GjkWCkPM6maKEEW02gg9i5y2+gig73TCJqFIvjUApM1O03JTXN+eZKIKnEtJDTBs1UKYxsUempIYojva9ABz3MxpBotV0GRdQQ5pD8DE0GTe+/YzdHKk6yVSyiyhG9cIW+scMVKMqZbiBE4UUjZ15DDOgZPIou70HUJekWcWIQkCCSMGKudNhuXpplp1Di9uMpv3n6IhL65BeuGDt/deISF9uZaFRCpuCX23baP2UurLE5vEEWQ601y64N7XrauqtE4RfdrmIKPLAq0QpGzbYm+dIj4Az9Q3NDj2dIZdEnhjp49lJ0GJbfKLT1D5LQ42cMx7LbNsUfPEXgB++7azm3vOnDDuUSpFyX+TyBqgqAjCK++DfuDZDImfb0p5hfK5LIx6g2LVGrzse9z6cwij37tFO2mQzypc/+797Nt9w/0CRYEZuZKpNImPfkEnY7L2XNL7No5+LpRxC6/APwdOUH/x//4H/kP/+E/sLa2xr59+/jjP/5jbr755lc9vlar8W/+zb/hy1/+MpVKhdHRUT796U/z0EMP/YgT7/JG6QrALgCIgsj+zBT7M68fnfhpkdF2sjX1Ls5Xv0YnqGKLBhklS0HPEPkXARlJ6mMyHqPmqGQji77cnQzHdmAFDiWnxnRrgX3SMTKKRtY4SCREVFvHOVfRaYmHuTk/zngmw+/eehtL9d10wg6DqSRJxeT/OfkcV7wyoiBiRCqiJoBi0VbKPLJxgkL+dlKqiSQkycZ/nWrrC0CRtFogG/slVGWA5c40Z2rfw5BmGDBbOIGMjElB7qNmB3xvZZa279JrJNiT2sWjxRlUXSQManRClzFjhbsLp1BEHzsSkEWXicwS2wKDOS+NG5r4QcCwbDGVOElCnCG/5W2kw3cRBQKWts5zxWsIzRkm+s/T9hTWKnmyYgvd8DjbGUZojCN5FprRQkQmGvJJD1fpyVXp2BpeRyKTtNGkiJqjMUwHQ4mQZQE/zOL4ENdMfL1KW6uQUfOUWzaivoYpVxg3FNJyQBCGhJGEZ8H0usN4X4ubJgf5s0unmFPqOKaHYSjMBjUStkafYTDRk+VascK5lXVundjMCVy2lljqLFDQ+1FEhabX4ErzEjsH9/DB37mP2UsrhEHI8GQvub7Uy9ZVLRhgxj/EmG7jAKWwQM2NYQU2Mfkl70gv9PFCD0PS0SSZATOLF9l8305PEAQO3ruLA/fsJIoiRPGVo9uCIIPw5ipqNU3h3Q/t55vfPkup2KTQk+T+e3fSk9/sZVwpNXnkKyexOg7ZngTljSaPfOUEvf3p61vgtu3huj6Z9OZrMgyFIAixbe9NzaVLlzfKX/zFX/CJT3yCz3zmMxw5coRPf/rTPPjgg1y+fJlC4eXReNd1efvb306hUOCLX/wig4ODzM/Pk06nf/qT/1+QrgDs8jOLIEhMpT5Ar3mEirOOFq2TCJ+CcAUEHUkeRCBEIiInByBvQYhtRRAETFnnvYN3sWGvkrDOYUgGoqRyrblOx64y11ngZMfkcn2Nj225g6wRI2PcGJ25N7eV+dN1LrJOU7aQTAtJ8REkn5WgyJcWn+bXx+5hwMiCOMJV7ybWrCsIYpxdsko/G7xQeQQ76JBS4tTcOj2qhx5NMd9sM9usstQ8uVnRLEjcOzDJ4cFBLhaLDCopHClgNLmOJgU0Aw0bAROPlGyjKw6BGxF0ZPqSRQ5lZlAEEVWsoElfYFt+iLR5K19cehrf6BDDR5UDKoKGnuvQclJkaOJaBhU7IpuBqKIjIdP0HOKDdQQtwHFEBAU6HRkxEfJ8ewdmx2JLfI0oEAnCCD8aYEv6dtbKJaIwYk9vP5dYIqWsEAo+Q7qHjI8hBHTcDBkxhuOWmS4d4L79k3ytepnxZoZG1SYKQlajNroiM5BPI78oqrwguH5fgsgnJER+sYhIEVUc3yaIfFLpNHtv2fKa60qXDRpRP6thD4qgsOFvkFR0NPFGA+hW0cZZCZlhgYFEHjkuookqBT23WZgRRUiytBmFfEvskm6kt5DkI792G47joarydQ+/RqXFs988w8zlFUa29qLqCn1DGZbnS1QrresCMJ0yyOfiLK9UKfQkqTcs4nHtuojs8ovN34UNzKc+9Sk+/vGP87GPfQyAz3zmM3zta1/js5/9LJ/85CdfdvxnP/tZKpUKzzzzDIqyWeE+Njb2o0+6y5uiKwC7/ESIooDQv0gUNhDEHKK89Uf6khQEgZQ6TEodBiAMbiUKKwiCCe7T4D4PYRmkPgTj/dcriwFkUaLfGCQKtxG6x2kHIQ17DkVQieljbJELzDbXuFp7lv2Zfiyvh+eLa1T9Gv3JFBOFIbYPFKhdsenUPMIJF9mXGCrk2JcbYMHaYKa1Sp+e5pnS97jSvERSSeP5LkfL32N7Yoq236RXGyYhBzQ8n7pbpWKXSChpqrbNaCqDLstsdFq8UFzk/73/Lt4dbEMUBD7/1Ala/iwdXyOueMiRQFzy6YQyRT+O4qoEasBooowq+JT8AYwohSEuc2ztr0gmBmj7HVzBQ9N68ImRlS1KkUhKrlFzYghRD4EQIKsiiizj2iGuGuCEEkIokjIc3FDE1B3avkFdGOQrq8MMqHMcTAjcOrSNLx0VOXX1NLLR+v+z95/Bkl3nfTf6Wzt3zifnOZMzgBnMIBMAkwiJYhBFi6IoWuUkK1kulaRbLkv6YPOqfMuW6/q+vtL7lq/kl0qURIo5AQRI5DCYHM+cnLr7dM47rvvhQAAhDAJJMIDqX9VUzeleO52zdvd/r+d5/g+DO8rsHVc4POwTCbpUlSNEdZ/N+jJRrY3nDhFTDebKu+h1d9JJnUeKPJYIk0zG8QW0O9sdVExLY7lSI26ZjKeSL/5dc+YgCT1JobdBSIvQ8hqMhSaJa0mklKx1t6g5LWJ6mInwAALBll2l4/dIGXF2RGdYbC+x0FpEEhBWI5zIHEdTXpo7+fUqn/7kE9QqPt3JgLn0OjMzw7xz9gSFx7f4ykOP4Hk+e26Z4a73Hcf4PvXnVRRBKPSSMK0U6vzt//gKj19cZdP2uXqqydRohulcEsvaNqP+B0xT5z3vPsyXv3qOzc0aqoB77t7LyHDyBkfq0+fGNBqNl/1smiamab5inOM4nDp1it/93d998TVFUbj//vt58sknb7jvz33uc5w8eZJ/+2//LZ/97GfJ5XL83M/9HL/927+NqvbzVL/f9AVgnzcdKQPczqfxnG++YPZsoYfeg2a9/UWLi7O1RS7WlxEIDqWm2R+feF2BWHfbnK9tYgcuQ5bO3tj7EcatIHugDiKUV4b7hBBc754kXz9HWL1GxbVZcQ/h6JNoOOwPP07Ia7JW1jlTdPhKaYKKFyNumRwf2cHbj59g81oJp2dSEwa6L9CbAeKFp+Oa0+bPFr/O5eajaEKwK5Yia+bY6K7S9BooQqHr2XS6PkNaiAHL4OjkCRq24G+uX8B84UMurOtU7R6eDBiKbq/Q7Boc4LFrMyx1LjMYXSWhuXQlPNrOUZEGw5k4umKhK5cBQWD75N0qGcuhUC9ybf0801lwZA9Vi7LKHsaVK6R1m66TZsm+i1R0mEa7ilPu4VoNHAIUy6PWiGJ5AUPZKpYSYAcq+WqUqKMSjoW5UB5kbsngG08qFJtNMooBToyNlR6mXyK9XzBoRhgNzxLSYrRKGdbqa1QqP02jHWe1V2V832WuXW8QiDo9SyO/OQKKxaBvEC1KFqqbzM4O896b9zOdfSmEmtCT3J27j+cqT9HyWuyI7OLWzO1oisZTpUs8UjxDL3DQhcat6T2Yqsqz1Uv0fIeEHuUdQye4f/A+VmOrOIFD1syQM1/eX/fC88uU8nV27RxjJ6Msnysw0hhE91W+8ldPops6mq7y5BfPoOkq93zwBN9PpJT0Og6nHr7IoxfW2NIUpAm24zO/UcHzA37+/bcyMPzye2B0JMXhiQzl5+bxei7P19tkwzozB1/fYmdrvcJTXzpNtdhgZGaAkz9xlEgi/Lrb9flR4c3pBDI+Pv6yV3/v936P3//933/F6FKphO/7DA4Ovuz1wcFBrly5csMjLCws8I1vfIOPfOQjfOlLX+L69ev88i//Mq7r8nu/93vfw7n3eSP0BeCPKW2vx1K7iJSSiUiOuP6D++AOvHk8+1GEkkaoSQK/gNv7OqpxGKEOcqa2wOfWnyYIJAGShVYeMS7Yn3j1L6Wm2+GvV77FUquAIgS6onH/4BFuz726Wa2Ukm+cm+N/L32TtjLMiDGBHfUpej47onlG9Tl2R1aIGYe4nm+hqOc4nnF4tnwv9abNxfIqI84ARsPn3pkdrJoxrpvrbHYrqBUYS2aYb21Q7NXQhE7Xb3GtuYahTBEgyZij4AU8s36KVtdGSoV0sI+JgWGckE/KtFhsVkkaFsVumz2pAdJmmJVajUuFIgVRoZzx+Hx9kp3SJW20KbpRVuwMGjalVhfX8YjEI0zpecYjq/gI2naU+a1JXMun1MiSitdY7ayz1Qszr57E83022wmcIMx4WOGYOcGZMxsE6QAt5GK7Ek/1qak67XoGPBVfKKBBvVmnFfi0HYeItCh3OyhuC9Py6ZZNavUIdj7C7bfciRGx6Hlz9Lwwo9k2WwszfPWCQ88tM7Jvg56vYG1tcVhr0Y57nG9G2bgiyLY0DibSVNZbTFqSPe96ZSeQkdAYPznyAQIC1Bc6hpTtBo9tnUdXVIZDQ9SdNo9snUZTIGPESVsJ8naZBwvP8LGp97AjOvOqc8dxvBctXgSCsBrCaQesXsvjez5jLxRR+J7P3JmV76sALKxXefAzz1HO15m/XqDqBaiGTszQaEkHFEF2Is0td75ylX1zscijn34GTUoyoymKq2W+9ueP8dH/x/teNMi+Ec1Ki8/+fx9kY6FAKGqxeHGN2laD9/3yO/r+gG8V3qQikNXVVeLxlyy6brT6990SBAEDAwP8yZ/8CaqqcvPNN7O+vs5/+S//pS8AfwD0BeCPIVWnxd+uPM5yZ1sAjoQyfGDiNoasH1BrJ9kGbBDbqxFCSSL9daRsA3CutvSiMAVYahe4WF95TQF4pbHGSrvIVGQQTVEp9mo8Xb7KLeldmOqNw29zGyW+fO4idqpLQiTYavpEA5100kZXFGaiBuPhFDEjQ8OpY+sh4noHUxVoeg83sNn0F2gO1ulaBVrrHnrXwI/AgT2THB/ayec3nmI4lEETTazgHAoNpHuVIfNt7IzuZWMhTGW5zO6hDjFFsrzu8fD563z4zqN8eOdhPn3tPG3b5UBqkMNDCf568Zs8ubSG3TLoWBtg9Gi5A3Q7bXaJIgm1x65QnqobodmdZm09TEWJciEYJWfVUVWf1XaG06U0u0ckbVdjaWGATVFH1R0CIKSlmImN0fUd4qZAq8LxoXES8RBnqwWuOCuExrpohsTz1e3Wc7aObzq4hkvD7RDF4GRsjLr1HNOZZwnh0GpbfPPKPlau5Ti12CaVvZuxVIZEqI2lDrJZjTCYdMjEQzQi6+TsyxwYXcdQJeg+Y3WXzy8c4213V5geWabb07hyqUO5eJTRySwtd5Wms4IiNFLmXgw1jspLYqTtdekFNkPWdoeZuB5msb2BoULK2K6OzRoJqm6TptchrFk3mjYATExnOfvMAoWNGpqm0O3YHLtjJ16the8FBIFECLC7DqHIy78QfS/g8uV1Go0u8XiIvXtHt3v8fhf0ug5f/qunWF3YIp2L0fO8bXFqKrhSogCKqZFIhjFvYBBdLTZoN7pMvWBwPTCRobxepV5qvqYAXJ3Lk18sMrFnFFVV6DS6LF5Yo7xZY2D8tVvz9fnxIh6Pv0wAvhrZbBZVVSkUCi97vVAoMDR046rz4eFhdF1/Wbh379695PN5HMfBMIwbbtfnzaEvAH8Mebp0lYV2nqnwAEIIltpFHtu6xAfHb/+BHF+oAwiRRPoroGSRwSZCHUBRXvri+PYHU8nrByo8uV0EoL5g02EoOp706Hpb1LqP43gFTG2EdPh+NGX7w6rc6OA5ENEtAnyilkHXcZgw4/z8zG1MmiM0WosEQZOEqdKWNptOhhZbaJECqq6yIlu09veor2oEAwrBahhRjbNZKjCXM/EDH8+vsCt0FkW2aPkwbNYZidaJaWFqTZd94TYnMxfQlS57IoJCp0m3s4+lR9cxlupoSgC7fb6pzrFcq1IKOmRSccIioN3T8AOPUaPOpFWm6xt4gWDKKjNXXSNwx4lFWlRkiFLPxJUC3zfw1Q6b7SZpL8zV5haqHkfrqHT0JgoO0V6Lm0cmKXg1bFWS0eOEDZ124KAlbURgIDwHFQ8hfBQhMTs6x4f3sLTWJd4w2D3qYaUuUui6VDthcqkW9+69yBcKJ/nbZ88zMJwkHRnnI8ePENJ0thpPsGski6lrpMw4exLr2LZGqWti+i7T8QrvvP08R/a1MHQF17Px9AgPnR1mrGmhxb9FrbVFEEAqNM2tk/+STqDwfOUyTa9DRDVxek1OVzaJBhmMqErCiCCET91tEdMiVJwGET1EVHvtFfF9RybotB2ef/I6nhdw29v2cvKePVQLda6dWmDp4hpCCKLJMMfe8ZLVTBBIvvKVs5x6bokgCFAUwS3Hyrzr3YdRlO88HFfdalLcqDEykcYMGew7PEnhiTkcT9LTAoShkkpFuf+OPTf09gvHLAxTo1ltEUtFqZeaWBGLcPzVxW+nY3PpWp5810WttBnJRF8UvOK7uIY+Pxx+0C4whmFw880389BDD/HTP/3TwPYK30MPPcSv/Mqv3HCb22+/nb/4i7944V7Z/my/du0aw8PDffH3A6AvAH8MqbktTEVDU17IL1MNqk7zB3Z8RR1BD38Qt/tZpCyjqEPo4Q+9mKN3ODnNcrvIcnu79ZulGK+5+gcwGsoQ1UKsdUuEVZOa0+JwcpRG51O03cuoIkzbuYDjFxiJ/3MUYRKxDAx0Mr0cBWuTiqyh6yoHUwfYGRtFFUO43gJd+xQzmS6Xiju5VJhBRgpEdIPd8UlKdh7DVDCFhhKEcY+2cR2V66113EoPFIEMNvH8VZp+Dl2E2OwElDpPcbZ6lMGESTh8GtfTqLkjuG6ZPQOXOfXcgzxSugKzbSQBc16XXGmcmJ6gJRV6dNEBVJeI8JkNbRHVepiKT8szCTyB6dsoegtFdVB8HcdRiYV79DyBUMLE1RBuN8AXASFFw7F9UCEQkq12m4tLmySGG4RHC2w2ehR6KQJnCKlCRLFo2aAaLVTdR5cm787dxq/e+W5OX1zl8w+dp1C5yo5Em85qjLCm4nd0sukGkZRNTjXZNZhlfqvCY/PLvPfgXkxNo9G1yeka4U4OJaphCx1d13BrYQy1ybH9ZZpVk2ozQh2TibEK+co5ruaXEKU2diOHUKCSPIdnf5nVUIT1ThFNgWJ7nm63hRsEFPxNgs1hPrzrfsJJeLZyiarTJK5HuHfgGJFvW/1bXS2zka8ST9uMjcYIGwOoisXxO3dx822zL1b7AgxOZPngr72ba6cXCXzJ+O5hpva+1NljY6PKubMrpNMRYjGLZrPH2TMrHD48wehY+ju+lwxTQ9NVel0HM2QQ1lWmh5MYAzFsGRCNh3jgnYe55fDUDbef2DPCTfce4NQ3LlDZrBOKWtzx3ptJZm+8omPbLp/5+1NcvLxBS9U4czXPRtQkq8Lhu/aSHkp+x9fQ54fED8EH8Dd/8zf52Mc+xi233MLx48f5oz/6I9rt9otVwb/wC7/A6Ogon/jEJwD4N//m3/A//sf/4Nd//df51V/9Vebm5vjP//k/82u/9mvfw4n3eaP0BeCPIcOhNOdqSzTdLooQtH2b0dAPNmyjmcdQ9T1I2USIJEJ5acXlcHIaIQSXaisIITiYnGJvfPw19gYTkQF+avQE3yyep+vb3JzeyR2ZEJXWHCF9B4ow8IMObecKtrdOSJ9h78QAN8+Ocer6GhF1kEQ44G37d/KeyaMvdAjRSEQ+Sti8G4lLNpllZtDmkfrfEzcsEIItJ4+qKFghjVgiRj7cxOzpWHaEyXCWLWeFCTNFQomiiSSbbRtDsUEJ+NbaAvcODTMjFZYrFn7gEIsmicRKXFx5DHsEkmJbFFSsCi2/xHhiD5utJrbrY8kUQjY5kJknpLn4gYIfCKKKTdcP07ZjSFWn0YoQMR2iloehWAQMYXQS2CKg6fVwhaStOWjCIaQ5KKrA0CVVf4OUm0cIA8PU8EJ5xkKShDHEJnUsV0fKODFh8sDUSX5+760AHNk3RsjSWStAOPYcnUKXWtEnPtCl2VXxfIvMQBwhBKam0XEcMrEwd+2d5uvn57ie72GpYY5k9pBhhVojStjsoqo5QsKh3evR6fbwwyoDKUE6dZqOWKdtS8pmlJaXw5ZlLqxfoz0yykRkiKqzhuu1cD2FATmKa9RxqtBeUXj3ziPsik3Q8XqkjThpc/tBRErJpz97is996RRDO68wtnODsUqc3dMHmEp+iLA2/KL1yreTG0uTexUxZ9sejuMTDm+vXoTDBuVyi57t3XD865EeiHPk5A6e/sZlqqUWAsGdd+zmrp88gudLEskQIevVV0oUReG+D59k55FJ2o0uqVyckR2Drzp+cbHE9bkCU9M5JsbSXL+4Rqdtc+zt+7n3p4/d8PfRp88/8LM/+7NsbW3xH//jfySfz3PkyBG+8pWvvFgYsrKy8jK/zPHxcb761a/y7/7dv+PQoUOMjo7y67/+6/z2b//2D+sS/knRF4A/htya2U3JbnC5voZEcjAxxZ25Az/w8xBKDMErPceEEBxOTnM4OX2DrV6dfYkJ9sbH8WWApqi0nctUXmO8rqq8/46DHJoepuu4DCZjjGZfXiUphIauTVNxyjj0mMwk2C1muNa8QkSLogqQaoBuaZSdMn5PIegIpsc9pvQvkPLWCJphCoEC+nVMoZE1NaruAXR1kAt1h3fsnGEgUaQRRGj618k7LuvhOrZUCdwYilRRezpetItpSXIJjWrHJBsMsyt5iJ5/jq4bQzea6MJDw6flaBQ2pphKWWBXkEEUz4Ku16bcSKBpGreMjiJ9yecWOiiRTYYyVXTFR5MGCSeO3QgwXEjqQ6iGQlspYKdWGY/GmfANApllKDzIHbm97E9OfNvvTLBnxxC7Z95Fpd0kFvoqy/PrtBqwdn0fqaFJPEuh0GjRc12mBkKcrj5NZLjHO2NpjN4g4ZBGOJZB1j7LYKyKIYcp58fpOl9kdk+ZXDtCoaWiyQ6BOki7HSUW2SIRuspc08exNTqdKLBdpOEGXaRUQKhoaCh+BN9w6TkeQghGQjn+MVfn8vz950+THN5g5sAarYbG/JxLInkZTf0sO5P/6g1bF22tVXjiC8+zuV6hVe6w5HrkBhNUKm2yuRi9Wpu/+X9/dTsfb+8IJ951BCv8+iEuIQR3P3CUofEM1a3tvL09Rybo2S6mpWCZr28/oygKU/vGXnccgOf5BFKi6yrC0NhxcJxatcNN9x/Eirx5yf99fhC8OVXA3ym/8iu/8qoh30ceeeQVr508eZKnnnrquzpWn++NvgD8McRSDX567CR35hoESLJG/MVw8FsdIQTaC1WfljZJ2NhJ27mMKiIEskPUPISpvRSS01WVvRPbT59dv8PjpUco9DaJaFGOJG8mZw5xqvoUlxrncQOHhJ7kptStSCT57gaTkUmCkEpXg1bBp94T2ONNpoeepOPkqdkRBlUIGSrny8O0cOlxiLp/E3bQJRBxtPAHiSh/R619CUcG1JQ7sSwFIa9Q9ZZRPJWwrjASHyOmh7hlcIZjqb3sjk9wbmmThwtgqjqVzihC1olYHVZqo1QKaZrlgJsPTDC+28e0FKQ3STHYgZd0COk6QocdiQReaAHVNui0VcYyeSaz14mmIzQJ6DkZOkYNR9tuoVZ1y1hagj0Jk58efRu68mpCRbCyfoILiz6+rDM+Ps1vvfsunlpZ5+nFVQIpuWfvCE7sEs9VCygoqELl0MAx1rstrm0tgNxJWAQM+Gky4rMYekCrlyARa+AqCk3Xo+VAvZGj5wrG0lUUv8PW4mFmR+6gbq2z2VnEpEDCbOC1M3RsG99qo9iDjI8naDW6RGIWQghWrhdYupZHCEG+1cV2PLKDPqomEX58u3tGN0rXK+LLLpp4/er5ZrXNZ//4QTYWioTjIZRyi5bjEYuHGRlNcfPBMR7+qyeplVuEIgar1/J0Wjbv/ugdb0hgqqrCvpumAGi1enzhC6dZXNhCUQQHD01w73373rTevsPDSTLpKCsrZWIxi1q1y47ZAdKpyJuy/z4/QH5IreD6vHXoC8AfU1ShMGAlv6/H8GXASquCHXgMWnFS5g/WI6zq+Dxa2Y3tbJHUe+xJ3sZQ9L0o4pUrFYEMeG7rUxS751CVOAs9hZXW84yGx1ntFojrQyS0JCWnyNnaczww/EECfFShoQkNX/pohzS6vs3fLf8Vqlei7EZwpUpPCHLGKjsTMRbbGuc3l5hvZxhPZ7hndAbFmMJhhKe3/oKmlCStCTKxPBsBhE0HAwtfNZlJZfjZ8Z9CEQpu4PNw/jIPFq9QdxLs9WrEtA4JYRP4JulQimzcwpMK75y9j/EJEAq0qyb/++kLLFXLlIpNZkYy1NwGGU3itcIMhYtMRAsIJcCyFGJalapfYsNNIVBwvBAdr4Rne3TcgLflmmStV6YP+NLn1Nw8n/zGWRbbDi4Ghsjzz+UCP33yAPfu3oFEMte6wEOFDWotnY7vY+ldWu7j2DLCoDmAqRqczS/RcB5lKFzj8nqS6x2D/TmdVGQDXwdLWyeTyKHLWZqNAtXl+9k/cpz7bt9NzVNYq32BICjih7uUw2WuVUZo1KeI5Mc59dwZznzuHPtummRixyBf+dTTNKodAFxTRRHQqAlGJHhBF0XRMEM9dGUU9Qbz6EZsLBTYXNpiYs8wqqYST0eoFOp84KeOMrlrmFMPX6RabDC1bwQhBNWtBnNnlrnn/ccIR1+9GONGfOubVzh3dpWBXAzPD3jyiWuk0xFuOfbqljbfCZlMlJ/8qaM8/PBlGo0u+/eP8va378e4QYVxnz593tr07+o+3xVu4PN3S6c5VV7GCXwGQ3F+dupmdsRfGWr7fmD7Ln+z8izXGhVSxnEutTvM9xIMRTXSN1gMaXQeIur+DWndRQKWb3DBzuC0tuj6Dik9jabESehJWl6LXtAlrr8ULv6HtmNSSppewICWYEzrYBk14kYTTbhsVkw0N8Rt2UUUO81gMMu+dIQvLX+asyunGQtfIW12MYJxBCnuii4wYTpoIkJDZtj0Imz1rhLWxvji+uM8WbpGSE/S6Y5xpd3lnbElho0egTSYyi0Q25eiaR1nKXaGS8UucZFk6QkVt9hjRyjOfLvO3OoWo6MmtvTQI3WSWgvLdNE0D6G2QfFJKg42JptOHE0RqCiookep12Ot1X6FAKw5ZZ4sP8yzWxeYOnCFO/QeTjfF5XyGWvMpWpUcprEXYb2TQrvCevMiUjoEmOTbaZqeRSZsYig6gZRUmw6psE8qUeOgVcKTAsvsYvsGIXMf8VAePyhj6jFGhj7A3kM/g67pSOlg9L7GREhHiL04zilGjBUOJQVby3G+9pUKkVQOKSXPPHyZc0/N49ge03u2LSnmL+cZy8bZWpWsposMTGwxNBglkxxiLPoehHhjq2rbreBABttLJoEfoKoKkaiJqikoirK9GCMlQggCX6IoAuW76IyzslwiFrOIvWDh0mh02dysfcf7eS2mp3JM/WIW3w/etJXFPj94+guAfV6PvgDs811xprLGU1uLDIZihDWDxVaZz66e49f3ve1Fq5bvJ1t2k9V2mfFwhpBmkDEjLLS2WO9USBohPOmjC237CzdoEdhfRRDQkjmkLJNVC+TUBIo+SM9fpuIsE8gIZWeLrJklpN7YI80OXNqBiSd2MG58C893kdJBkRqDpo/LEGmjwuGkz9xWg4c3/55nVp/nePQ6o+EGLc8gLGvssJoI0cLDwpENMmKVQClyueqz5cZ5vtbGw6btbhHzhknpYYZCHh1vArsXJSoDbp5c4LSWo+ioRLUI8/XTRMaucMeshe8lKBSPMVdrkhzJs9TqoRldLKONqTtoBHi+iqoEuGhEFZsxvUaAQtXvUQ/G0IIULfcS+U6BuD6FJlfo9h5joXmeZkNjVKmyN7uAJ1TMoMDt4y00BVotDU/9LJ3m/81qA8atLg46AknLqLDePELGMija5W2DZaVDVGkgRI9cROJLj7DR42orwnozwRE9TUxbQzfux4h86MV2f0HQpGFvstQIsDhFVG8R06NY2gBSXmJyt4X0pgBoNbpUtpqkc7EXw66mqXJw/xhjh06yVTlObqTB7I4UEWMUS3tl4/pXY3zXMJN7Rlm4sIJhGbi2x6E7dpMd3S4UmTkwxtBEhqVLm+imSuAH3P7ATd9VTl08ESJfqCOlJAgkrhcQ+R5y86SUbC5t0ai0iacjDE/lXuxt3Bd/b3H6CrDP69AXgH2+K+pOlwBJTN8OYWWMCDW7Q9dzierfv2Tx89UNntlapuK0KPfaxPUQIQzcwEcg2Oxt8ej8U9SdGgNmmveO3UdK66HiEtbHaDg1PD8gJjzimkHMGqPr1yjYZeZap1EwURim7Tkkb+BDFdPCDJgptpwwXT1DVZqEKRKWAemQpCUDFMXFdk0qbPLkxiWCtk0u3WOrl0LiM6qXGdfbuFLQkjadoEs7MDB8g/VOma5cxGI3xa6PdBt4nofW0BDJGMdHTiAUFd9v0PHWeK7RYsTajcAnFZrHVVbxOuOEQy2yA1UWwwlankPWbIPSI0DQsQ0yZgdU8BF0XYVho4JQwZMaI1qHOXcCK7ZM11/lWl0joUiG1SrIALe3yGC3zVTKxVfAlgJTdclYXTqBgSMDVOmie4vkVAsFkw03ii8FIbWLLhVuTd/CUu8ienCGuwfyDMslrjTiWJgI1WEgWqIrffygxJWax87kOAOh+xBCo+U4fH3pOnOVPEN6hZBSJmc28DyXnhcwakTQNA0p2wSBBClxbI/R6SzVrSalfJ3ADwDB7P5RDh+bAb77EGooavHef30/zz14gXq5QWYkhT6S4suPXCAcMjm6f5z3/ev7OPvoVdqNLmM7hzh8x+7X3W9xq8HyShlFUZjdMUAiHuL2O3ZT2mqxtFRCSpicyHD0hfzA7xQpJc98/TyPfeE03ZaNFTG4/T1HOfHOQ99V3+4+P2r8cIpA+rx16AvAPt8VSSOEKgR1p0tYMyjbLSajGULa61clfrdcquX58/nn6HoOCoKqbdMLNslaUQIpmYomebbyPEVnGfBY7cxRcDb4jdlfQNUGGZALGMoQLbeH7UdQSFKy1wmkhuMPM2hMYKkRNrodvlE4zfvH7wS2exuDA5hoisq7hk/w6Mo8tZ5Gy4uQjt5EQruCkA289iql6jCnNsbohLuo/rb9hyclUvqMh5sMhToIBLpQiKAQiC4eHlsdjVXXJmQ1aPmrJKw2I4kKEQLCgYEi6lRbj5KJ70MXVQJtDJsInvSwRJOQUaFkJ7HtgFZXIxzKE0/YBIaP9CRtW0U3HQpOHNc1SIRtbAEJrYOBz6abot0Lk1JN9sXmwJxmwNquHg/sr9CVHaLm3RRqq4QNl0GrQy8w8AJJSuuiKRIhfUClFyiEFIkiBKrwEQH0fAtDdxiI1lG1dQ5FtlCDCno0jdsJsPQaFwvT1Jwos75Lyc6iCYXrHZ2rz09xYtzmjts9/vrKOZ7eXMMLfB5vzfL2kSZDlk9Ys1lrxpB0GRxIoOsD1KrPEY3XOXxrllvvfRtXz1W4eGoJRRHc9s6dHHiN3DnHdjnzxHWKmzUSqQhHbpsl9iq9cOPpKPd+6ARSSh587Apf/+YlJOB5AXOLRf7Ze49x/4dPvuG5vrxS5tOfO0W52kaw3dP3Z953C5OTWf7Zz51kdXVbGO6YHSAWe/WOHq9FaaPK4186g6apTO4Zplps8OSXzzCzb4zBiX63jz59ftzpC8A+3xVH0uMstso8W1qi1GsxHE7y0xNHvq/h34vVTZpuj92J7are7c4KAXcP7iChhzAUj79afRpdEUTUNLZis9ld52z9GseSH6bX+UvSSoG0vpcL3TBLzRqeLNLzw/gyw4C1XT1sB7DRLQMQOOcIel+k06ux3olwwTmAK+PMnc4i4juYzS0SeDVEOo0ZuR9ZG+bSRojVZhfFhYFsmq5hs+mE2RmtkNVcBBIPFVcKdHxMAXV0OmIcS8vT8iVC2OwJbRLVuliKiyUN8j2LsKyh9OYIW3fhq+9gJDTHSmcVgxaTmstAzMcLucjAI6T46C0HR+3RkwZKSOIEKoFQWeimGVZbKEqHwNZQNI2tThrP1tmTzpKOVmiJKOKFv6ciDNpuicXeJWzVJWr6+Phk9A5DwkdICFAwFR9V+kip0Al0mr6OKjwMxSGu+ghUMlGTtc5VEjxKWh8gFZ5EqqA0H2Qmtk7Vs9hsZvj6s7cSCI09MyV2WQ0unP8WrgmXekVGozHcIODMxiB/0bmd1Vydk0PnUEQL26mRHn4/9z6g02l+DkVxCMeKhCKf5q53/wvueNchhOBlfmT/GN8P+NrfPsvpJ66jaSqu67FyvcgHfumu17RvaXVsnr+wQixqkUlF8PyAlfUK1xeL3HTwtc3Ov53HnpyjVuswM5UlCCSLSyWeP7PM2+/dT24gTm7g9VtzvR6tWoduy2Zsx3bHoGQuxuq1PK1Gh0H6ArBPnx93+gKwz3eFpih8YPIot2an6AUeQ1Z82zz5+8g/DksJFEbCSX5q7CgAZ6pXCaSLJkIIIZAveMQ5gY2mzRCJ/SZBUCHfa3Cp+i2S5iRRNcrl5nVafp6uP4GpGLTcLqOhHNJbwe/8JbVWmStbbRRzE7t7jq8UjuAbChllD1P6BnWvTqcuGB7SyNfHqLXbmJpLoWmzujRBbjDCQxtRtiJbvGdkk0RI0vOq2L6DUAOqrsXj5UmqsonUwqz5YUYtj7Dm0vVNdBHQc3Q00+acN4jnuCxt2XjBWcbCCW5O3oImJI6ziuKfI2aFAYWap9FBQSNA02wkAs9TCHzouCor9iAbtSiRnsv94+eJa116no+m1wgbe6i7Hj2/igA2eypJ6WNwgeGwT0jtEuCz5RnEVR8FqDkqYaFiqR62VFi0IzTcODYugQhhqBaKOsxM9AgCH9/WaboVfOmjKGM0WuM0lpNsykmermXoqF3ef+ApDuR6pIRFfUCl2DSpOQkazR6y7UM3wDYCRqxVLOFjCZ2okiOkH0eE/4RQKIeiDiOlg+dewnPPI5RjPP/EHKvzBaywxZGTs4xMvlzwVIoNrpxdJTecJBQ12ai1ePrCMrnHr/D2+w++aojU97f7BFvmdv6cqgikBD8IvqO53mz1CIUNhBCoqkA3VDod5zvax+uRyMWIJcMU16tkhxKUC3WiyTDJ7Cu9O/u8BennAPZ5HfoCsM93jSIEE9HvvL3Vd8vB1DDPl1aZqxfRFBVP2kzGhin2qgxYKXbHJslaWQq9TbqeCyIgZcQZtLYrk4UIoaqjNP0GTuCSM7cT/aci43S8eda7eRRhMmiluHvgENK/gudVuLgRokoXQ48ybtkoLQdbM0imH8cVLvnSTuJRnVjyLK7bYzR9J4kghL21yWqti9CmyEX2s2d4N6PDFxHOlym3rhHSmuS7Gv/H/H4er4+QMnvkYm2yyR6mAqZi4QQBQoBmuBiahoNBy28xqJ9mVHmGWq/N0/VB1txjDMd0xsxRBs0EcSPFansLnyqOa2AoDqoaoOsemvQZjhSxIjoROcBZe5Snyzs5GF8lohjoxq1Mpn4R0XqCUu88Hc+m1IuRMkJE1RKa6uIBEomLT8VXURF0fJ2FVo5cqMV8a4CV9jie6iN1nV3JQRQFghd6OiM0XDGOJefoukuAh+PMMPfcXgaHd7JfdHCth9hl1lHbe2igIlgmEXmCytpdrHUb2B0HocB9Q8vstDbZqg2Ri8bYN9jCs7+KlC5C/IN/3XZqgpQ2T3ztAo995RyqpuDYHsvXNvngv7iH3HDyxbnmewFBECAUwYVChY1Gi07P5stPX0WPW9x9bIaW8ww9dwlViRAzT2Bog8SjIWYmspy5tIbteLQ7DulEmPGR7+w+mZrI8tiTc1hWF98PkIFk5NvO780gPZDgvg+d4Bt/8zSF1QrhuMW9HzhOpt/urU+ffxL0BWCftwy7E4P8/Owxni2tsNHdpO63udi8xGJ3gTuzhzie2cfHpz7EZ9a/QM2tEVIsjmduYmds9mX7iWgRNEWj5bWIqBG6fps98UmOJG5HUwxGQxkMpcVm/WEs5xyDCQXdj9AVAhmECYSB70sMpU67E8L1JIl4GE+uk0lcpRWMMchOjmRSuOoFjk52mcmOszc3g2k8QLOe4Ez+K1ScgE+VI+SFgmX0GMnUsDQHQ0jqvk1CFUR0n6hqIujgEMH2bFRpMmssUu+a2L7KdOgKba/DXCOHH1PIuyY7Ywk63hqq4iKkhkSl6wvG9BY7Ig0UBFFNZ6fVxm/O0uzdw9mWwmQixrszt9OsC+ZPz9DupdByNrn4/4kQMba8CBG1Q1hxAQWkwAkUYqpHr6fj2iHO99JctHOgSqKGR0LNMBKaoeEVKNrrrHUWiOgxnGCYXeEZElYETYmSGN7PXHyZ1etFELDnQIi4brFV3V75SqYiBGqHw9EcSs0j3/PRNY2TlkaoZ5HxoxwZnyBqlEC2ULUpPOcM4CGDBkLECYIRzj9znmjcIjOYIAgky9fyzF/aeJkATA/ECKcjPHtphS01ICQUhlJR0qkIj164ysDEM+ja4ygIJC5t5wLD8X+JruZ4z70HsSyd5bUKg7k4d9+6k6Hcdxayvev2nXS6NtfniyiK4PaTOzl6+I2HkN8o+4/vYGzHIM1qi1gqSiITBaBRbtFudIino0ReJe8RtsPI8+dX8F2fkR2DDE1m3/Rz7NOnz/eHvgDs85ZiX3KI4XCEP11cRA3CDJhJKk6Db22dZSIyxERkjH+14xepOjV0RSNtpFH+UV7iaGiMA/GDXGpcoO7WiGhRbsvezmx0JwC2X2Wu+mcYzqMYskkmrawOPAABAABJREFUbJOUgoob4TOFQ/Qigpih02gOMRxbZ2okRTxxDU9ukE761OTXKWwVSIXr7BxdYcfAGEKsstH8c0bjH6McFCmqa5StGrtGw9Qr02Q1l4gW0HDD6F6UsZyCI8YZMzLkW+u0gnmqrkXLizMWKoPustnL4igC4cOEVeH5rX0Mhgw0pUnFLmGSxRBVfNXFCyRh1WXWrCMCKLkRbKJMRzq8d0bnXHGCqGlwcFxjofkETz2zSGXeQrNTaKEit9zfZUtGiAkDGxcN8AIVQ3HwAo2VdpKzG6N4uokXMTGkgu+phMI92k6Hc/kCu+NpZKeMpbRJRgNGMzexJ3HfS51GYvAzvzjO9SubSNlldqaGpl5lZKiBE+QwzS7fuj5KIhRhxA2jVx3ciIboDpCML5I2FRIhkH4LRR3DsO6nh0Lgr6CoOYzQA0g5hZTnXwzhvhTJfXm86/TpZco9l54i6NgeoajFjv3DtDIVNvV5rrZOEdUNxqMHiakWXW+OjnORROgeohGT97798Pc0z8Nhk/f95E00Wz0CL2D+8gaPfPEs0XiIQ8dnCL+JbdkSmZeEH8C5x67wyN8+TbfVI5aK8PaP3MHOI1Ov2K5RbvHp/89XWb22ub2fbIwHfultzHwHuY59vo/0Q8B9Xoe+AOzzlqPhtml7PYatDIpQyBgJljp5Gm6b4VAGS7UYDg296vaKUDiROclMdIae3yOhJ0kZqRffbzrzuO4cSRGw6Y3iOFV0HBq2xeVWnJpi03ZVHrJ3MpC2GM8VsP0tFG0fQ+mjuMoK2dgqMS1gID5N2Bii7fboOHNsND/PSuUCdaWL1CU79SKuUCk4KQICBAoh1SRnxbHUCBcrB3gmv44jRxlOrCOEg+srdD0V94XzDSkBDV+n62tUnD1IAnbGdmLpl6hXynj08HAw8VBkgC4kg2YD6BDRcpwYneHunSdZ7VzlmfJXKVRK1MI11J0W5SfH6S0q7NllMrKnQ8tLERVt8AxWS1mE4rPVOMijS5NkMteYHc0TipaI6hbF9iS+s21Zc6mwQWFjhTsHVhmVLmZPIamWUaIzoGxbojQbXYJAcuTYKKr/SQLnAtJXMbUCUmh42t1sdSdYK9cIp0J0tqqobZeLz49iHJ3kwOEOrruOaR5Es96JoqYJRX8ZZBeE+aKx896jkzz54EUc26PXdUhmY0ztGn7x79/p2DzxxBzhiMmJEzt59vo6jVaPvFuipC6QMBXCmkHHd1lsr7Avtv3gIPHf8Bz+Bx8/VX31QhQhBNGIyVf/7hSnnphDSggCydJcgff9wu2Y1ptfcV9cLfPQXz2B5/pkhlNsrVX4+icfY2giSywdfdnY809cZfnyOhN7RlE1hbVrmzz+uVN9Adinz1uEvgDs85YjrkeIaBZlp0HOTFJ1GkRUi7j+6v1KZdDA6X0D6W8g1By6eR+D5hBS/kM18T8mACS9QNCWIUKqCXoMKWLU22FGjRQ14fDHizv458o0M7kEYe0gEkiGE6TDFeKaTyAdrtY32exWiChFtI6PdFyaQkELwnhBQE5vs9TLIQWkDI9YuMO1ZhkYYbV1Bk1NUWpnCbcGaHo16O1lMvsgRyIFXCRVL8xzjXGEKhBCIapnOZQ6QMXeYNobo9IVFJx13KBCz48wGtrCCcBQwBQJULarqq83z+JLl5gcZqno4ocrKDkLvzDG4w/u5RcG88xOSdqORblr4HtpFi5PMmDdxn0D5+mlt+gFJk0PQppNWl/nejuFYUm0SJuMWierVtnaGqLeVul6V7GV/x9EfpGt69e48PQmta0UO3dVuffeU4TiO1D0XQgvD/hY8Q/yU8cFn33mIqVmm/17xhgJdNa6Hb5au4fzl7sMJSK8+8jbGFG3c+6EEPCP+vne9ROHMUM6y9cKhCIGt9y1m6Hxl3L0bNvDdTwiEZNoyGT/eI5T19ZpyzahiMaB0VkCtUFUXKTrFijXbMJ6BjPxxrwEry9t8fATV2m0e4wPp3jHXXtJxm8cZi0Xm1w8vUw6FyOWCOPYLvOXN1mZL7Jz/+gNt/leqBbqtGodJveOIoRgcCJDYbVMrdx8hQDsNHsoqoKmbwvrcDxEs9YmCILXrLDu06fPjwZ9AdjnLUfKiHHv4M08lD/FaqdIWDO5M3eYIevGifZSOtjtP8d3ToEII53nWcmf50vnbsd2TQ7PDPO2Qzsw9O3bIWbswNB30nFWiKslROChiQgb3ghrvRCGNEgYITxpUJYtzheTzA4OstVbYKHRJa1eI6nahI0Ykjo9J05CC+HKAVa6YQaUVQQgUbBEgO1GaLthumqKdMhjq1vFdpO4bpS20sQTDlImaDgqHS9ONLaOYVqE9QxNu43jZcmoJ9k7NsRYJMXh1DTVus8jSypKqE3ckkzFI+Q7bWq+zrodI6716PkqpVbAkFpjhwW+dFGFRjIeRqDguRJ0SQD4vWkef3YX79g5hmWlOTq0j4lEh8q1UyyvVknEl8gkbUJ6iG7g4AcBoVCHZmOQYn4Y6haDSWhPFWlLE12XrNo6nfJpSlvz4FUJ7ddpFGdYLmYpbJaZiOyh59jUGj660sDwK0zmZvk37zpJp+cSMjWeW1zn+jPnGIuniJgOc6UC/tkr/MzJEl1vC00JkzEPgDSYv7JJs94lkY5w69v2IlyXi09d5+vLRY7es4+j9+xFURRiMYuhoSTX5wsEgcTv+BwZH+KWu4c5q51FM6Apj9FqtlDbqzRWVZprU5QPtrn9PvmaJsqFUoO//+oZGq0e0YjJ6Yur2I7HP3vvMbyeS6VYRzd1ssNJhBB4ro/vBegvzE1NVwkCiee98dXG74RwIoQZMmhUWiQyMerlJlbYIHwDr8HBiQyqqlDJ19BNnXqpyc33HeiLvx8VpNj+971s3+fHmr4A7POW5HByllEry5XGBoGE0dDwi1+8UkpW63VajkMuEiFtFvHdSwh1EqGEuVZaotp5jGLUptHYTf50DUUI3n7TLgBMNcVM8uMUmgN4zpN4bo3LjVGeqe0nrFXRZINqz6bq6kgp0MJjDEcPcGb5T1GDLbKmTd0doNCLsyPaY0BrkA8OUQ+O05Y9HLXHZGiDjuxQdUPMdYYwA4tIY4CrpSpdS2E0NLTdO9bTsXRJRxGUuh1Spsah9BJDkREGIjvIBh5D3jw/EdtFMrRtXH1tq8Snzp3C81PEnWOU6mvMZlLsS2t4vb+mHGjknThIjYjS5NnlL3PEmcaWSbreKkJXGJiE9U2NoJFicjhJJ1bj6miZxrqNoSxzNNVlT3g3mVvS9LZAzUIkbGHpERptjTZtiq0U11dH8ZoRom2FYhDDn1QIG23qQmUw3iSqd6l2BdeaSVKqz8jIPNc6JsWaRqJ2heVNH00tU6wOc2XzOh/8iSyjg0kSke1Vp0q7g0Qylb1ALvosO3MdfBFwrTKKL0yQUDEvsvzYHp5/fBnH8yn7znYHk2KdmWgYHfjanz+OYeocvH0Xmqby7vcc4StfPkshXycas7j7nj3s3z9KUOhxsXGNfMdh/doI8euH2Bmaxm52eOKhy8QiJsXFAq1ah9HZQY7esx/deOljdn2zRqXeYWYigxAC09C2fQIvr/PE359ia72CpqscuXM397z/OJmBGCOTGRav5omnwjTrXXJDcYbH35hPn+8HVAu1bZ+/gcRrhpwBxmaHOPb2gzzztXPUCnWsqMVd7z92w8rg/Sd3USnUOfvNy/Q6PQ7ctou7P3DrGzqvPn36/PDpC8A+b0mklJyurPNw/iodzyGmX+VdIwe4bWCWL169yiOLi3Rdj3QoxIf3x5iyACGoOg2WOxtEhYdpKfSULSSSi8uFFwUgQEgbYir1S8AvMeH75Fo1DjgrPJb/C9Y7q8ggoNBKMbe+l9RIGNjN+cr97ItdQ/IYKGOElU3iwiWptQgH86hkueJMkDEf4D2TCT63/Cx5NyAsJO9Nr7IvtsiWXeeSHeF0M0bCTNB2PI4kprl/9x0Uui2yFsTENcJ6mEBKFKEhBATyJY+4pWqNntvg8JALwmazm2GtYvL+XQ/wbOFRHLeIKnUEDr1AIy/X+W+XP09MpBgwDSYjXaQZo11O0tgKg2jSPlBhZDDFZHiIltfl8a3zfL26SbUBquJidg2ioXEsrY4QPardKEsr+6ARwxUeTS3gcnOYkbUa9+SKRBM+xV6CnqLTciyQgq5nYlo9Gg48fuVmYuk1XLeMzy62OneS3+rx7NllRt+RfPFaE+EQmfA6uci3ENKg5WiMZeYISRfVeDeedFivnuby9Tqx5AxzrQaXNxt0eg6aIqgHDveNDVBeLLFwYZWDt2/PgVwuxs995DY6HRvT1DFeEHH3D97GzugUm8USD106z3A4h6appLMx5i6u8cU/+xZuvY1h6Vx84hqNcov7Pnzbiw8nmq6iiO0OIbqu4rgeiiJ47HPPk18oMDw9QK9t88zXLzA0mWP/8R2850PHefhLZ8mvVpjZPcT0TJbT3ziPpmnsvnmagVcRg51ml6/+2be4fm4ZgJ1Hp3jXL9z9mj2IhRDc8zMnmD44QbveIZmNMbJj8IZjVVXhng/cyrH7D+J5PrFUpL/616fPW4i+AOzzlmS1XeGR/FUsVWc0lKRi55mr/C8irs5G1SFt3YIVG2K1XufTV3x+7egOVO8CPccma5RZqQ3QtofR8KnrJRSxAz9oIVBQlJfnYxmqSsawOF38OtJrMi589qQ20DNLbKZ6LDTGKTlJDL1B0VbYHVFRggqj5iZRzaXhJ6m5gozyJLvCGd4xcj9jsRy/fOhupJR89vk/ZCaSp+dncD2HWyJFbOa50J3BIsR9g8e4dWg7sV5KydXKFPONb9DyLUJqwHAoh6VNfNv51jky+DXGEwWEWiEZNVi1d/BctULeNRB+BEtx8KXOmp2k6Rk0ulWKJZi34JorCRo+vUYIO+nTUX2mBy0mcoMIIYjpYS5W12i0VQ5ndyEELDuLXGn4xEI7KXpbLNRbuM0BMo5GXm0jTUlMhpi7cALSLr10h14qz7uzpxkNb4GRwK2FsW2fdjdMbOIkpxcFm8UiucwAoGAaVVodG4BABiy1i0QyPrvGHRy/Q6WdJB6W6EYcVfaAHqoI4fs+vuyCLliqNBBSYgagSijbDpfKDbKej26+/ONQVZVXtFlThcpMdJxBmeO0skplq8nQWJpmrYPd7uE4dfbsn0ZVdKrFBheeuMaJdx8lmtyeU7OTOaYnsswvbSEUgaIIThye5PqXz5MaSGBaOqalUy3WqZWaAKRzMT7wsTsIgoDLz8zz5T/9Jp1mFxlsF2J84FfeyeDEK+1XnvrSac49doWBF/Ibz37zEqnBBHe//7VX6YQQTO194/mFr2UT0+eHSL8KuM/r0BeAfd6SNNwebd9hJJREET5Hok9jcgXHG2A8VmI83mKh8dMMRKOU2h1aygfIGiO47nOs+BbP1WbJtx2aoSq66RMe/FvObv45Q1aaiHUb8fB7EGL79mj0evzp80/SVZcJ0WBvdBkdE03RmYgtIoy/5enqMTKxDqV2k4V2hB2hZXJGDS8w6AZpHJEgGhSx2m2eX1hhZG8S09ARQrAn3abS0un4Fm4gcNwWY8Jj1RnmbeOHuXVolnz3CkutZ6jZdS5Vy5giw5DVpuyobLo7mE6PIKXkfP08Jfm/GEufww9ADXxiqsueuE/JniMQATVvnE6w3WM2IKDUjSERBIHLweQSs7FNFDvAs9MsrR9nuapRr3bJD5QZiWRpuG1UNFT5wkqSBNPdDeo8PhamNojWHcdSotCsYLkQVnWOm1lSiQi253P/cZ2r7nVW7FGGdYfReAVX81haOUguewsPvO0Qi/MrNOpn0MUW9VYWx9UYGUpQ73Z5rHKeU9U5nMBnPFpm2vQYzAQkzWFsb5me7OE4NRBbmFqCWj3G6voaLd+GQGJZBgQejheQz9eYHcly8LZdrzrf/jGRmMW97znC1z97ipX5ImbSY+SBLWrdNarxMpH8FKIcQXoS+UIXEM/zaTV73H/bHnbPDNLpOuQyMfbvGqbw5AKFlRLxdAS744AQRGIv76yjKArPfu0cnuszfWB8uyL44hqXnrl+QwG4uVAkFDWJJreLoxrlFvmF4nd+s/Xp0+fHkr4A7POWJG1GiGsWm906E6E2mlzEloOE9CnqtkEmtIKpblBoZUiFQiRCg5jGh0hrb6feehCR3sQ3yyhSck+qwWR0kdVOFFPR8eWXUNUUUesuAM5u5pnbarJnIsWotYZBQMlWiUgFIQ2GIkVaRoYRQ8c1nyIsHEYNiSZ9kB5JpUpH1tl0TB4rbZDvPsy1cp7fuvtdrNYWCOlFRqObXGu2kKZBLtbCDXIcy3S4bSRBxVnmXPXzlDplViotmqJCrTXGmnEH0wM5VrplNntV5luX+fTa33Ei9Dyj5hbKC83wfBGjp3rUXR0hPCaih7jWvICULXq+ji9MpK8wlqywO71Crxum19YZTdXYNXGOtfpx4oVBYnt18t0KCiqDYpxL5TIL+cuEdJ14yORn9r6d94zOcLawzJbxf5GaucbhUcH5lUmql/ZSKFTRJxXS6RhD2R6+nUaTg0RkE9XvoZs1JmMV0tFnGYhNMLD7caYST9PuNjA0m7afpdAb5P94ZDfXLJf9A8MMhlwqTo1Vz2dcuUzdWcAjxIYbpyOvE9WyNC4do9lRcNw6vhfgqZBOhXE8j2jP48jUMO//2dsYm33JOijw8wTedUBB0feiKKlXzMF9RyYYHE1SLtaZNx5my3fpnQ/R7NTopM/ju+PcdORWoqkI9XqHL3zxDCurZVRV4cD+MU6cmKXVsWm2bN72geN8+X8/yvKVTRRN4cDxHQxO5jjz9DyKojC9a4ho3MLuOejW9se2oggUVcGzvRveI/FsjOtnl7fb0/k+tVITP5B02z1Cke9v28Y+ffr86NMXgH1+JJFyO/7wahWVI+EkPzF2iK+sX6DQazIdV5kM5xgIx2mnOtS7RTYaDeLmCO/bt4+osW02nDWSZLwdnKrVqfkVPC+MlbhOz7NoE6IdRInTwHEX4AUBaPs+AhWcm8BaImz4dPAIq6PEzQ5dQMUgLE8RaA4GEUJKl7prYCoWInDIaB6PVqdwxAQRI+C5+hyffN5EE39N2lxmPNRmd6KKjc5id5CrzjSpWJcrlT9jWHdxemfJt2I4QkVRBYlwhfl8AysUQtUUdKHwbOVJ3KDNiN5GFy6uVFBEgEWNnmzgBTlsL4Lt1YgZYRqujR9ojEfqqF0F1bbRPOi2IviKQ1f4mKkV0rkhpjlBqp5lfnOJ+U6DprNF03W2jZQlxDWL2WSGLy1e5vT6n7Fv4AwdR8cwBffvucCXhcal1QmKfsBhdB58epn40Br702UiRgdVtNGET6AXqPk9/PJlhowYg0N7kPYZfC9PsWWDanPCKnFxc5qNUpzp4XU0JeC6c5iUFaLiXKPmx4kbdwI212oVShtNdu/dzf4jKdZKJU5freH6PpauM5ROMjCeY7HQYGAii2Fo+N4CTutPkUEeAEWbwoj8Eor6yly4TC5OJK1wdbNOToyQPDDK2vU8baPI1DtHue/u7fy/hx+5zJWrmwwPJ3Bdnwe/eZlvnZ7HtAxCls7dt+7kZ//du9haq2JYOmgqn/7kE1S2GgCMTeV438/fxq6j0zz62ecoKVU8x8MwNca+zcPw2znxE0cpLG2xfHGNwkYNL5DMXVjnr/7oKzzwi3eRG/3BtXEMgoCF86svVhdPHxjr5wt+v+mHgPu8Dn0B2OdHCiklTy6u8Nj1Zbwg4MjYMPfvncVQ1VeMPZGbYTY2QN1pYPkuwj+N69lMxDvYkWNM5X6SbDRHJvxSjtKVUonHFvIofo6OU8HGodCRxLQ6HUw0BEgHRYm9uM1EIkHEMFgua7Q678GPuUzGSuQsG7QQV7vDNJ1NZowaTqCTMDQUodJFp+ZnaNsanl/lUmcEgYIpNJqywfXKsxwf3aLkTHG1lWA2WiEW6vB89yAFV+VQYoVMcI7A6TGsNlHMBJeYwBU2zUCjrbTZ7BY5MaRT6j2C4y9i4iACF1tqoEikVAkIqHQ7XKtmKbeHCVvzpCIB45F9lHqStUKRnFensxmBMITooaV6RMItum6Y0Yk2XfMKz8xPsCV9al2ftu2QCVvolsdYOIkhTZ7fWOUrG89xW2oNx9bB19iRrpHWe+Qip/nvvQQrvkrby3NvZYR4XKEX20QoUZKaoCdT2H6FTSfClJGnGCQIaw1CLOPIAKFodIIJBqwVJsIdFjoVxvwOth8QVg180cOTVaJKi7CyBMo+FNnEtVooyasE6XkGJ1zunDLZm3yAs881aTe7FDZrrCyVaDS7/MQ7D+F1v4YMCgh1FxAQuNfw7Mcxwu+/4ZzVhIGmGNh+l2R6gF23TFJxdG7JHCYUtZBSsrZeJZEIEQ6bOK7HRrVBzA9x8+EstUaHhx6/wugHT7Dn5mkA/ur//CYbyyWCQGLbLsWNGmNTWe7+yZuRUnL52Xki8TC33H+APbfc2H8wO5Li0AM3s/63z9JtOszODDAylGDtep6HP/0sH/rVd373N+p3gJSSh//mKZ796jlcx0M3NE78xFHu/sDx17TM6dOnz/eXvgDs8yPF6bVNPn36IoqioCkKX7l0DUUI3rX/xvlZWStK1oriBx+n3R3D89dR1QEGrPvR1FdWR5Y6bZzAx/clajdKKNbkXGuCgUiTrFEiqVvo2jQR8+SL2+zMZvjAwf18+co15ksmpeo+zMmnqTkN2jLOggebfp5QrMWIVSMIUvRoEBU9am4TTZNsOBFKHYuw69Hwu5iBhe046IoCKNjSZKUXZdDw6QUew3qelLhAICy6MoYvNTJmjbRXpSyjqN0Rsk6O45kGaaNAxbEIq21CWo12oBBXVXq+giUUnCBgqTpGtXWAmXgKG4u2s0nT2CRi9hiIt5DCpFUco1VLMjxYxkz6dHpxnGCI6dE2pfZzDE4VaRZ2Eg9MouYmt01dJh7q4bpRlos3M1cQNO0emhomZpQYM5uEDY9ASjKhHj9z+Ar/6/JRIlaZitZisLufbnuFsJpBM3waThvbl/Rsm7rUMCmjiA6WAiouUrVRlSYaOqFOGl1VaXsmIc1jwizhuJsIBIFUkP4lpDTQLJOBbEBTO4PWtXA6CvHBFo71LHZnitmZQRRFUK21uXx5g7vv2I0mayAiCLH9t5HCRAaNV52zmmKwK36cc9WHKdrLIGHQmmYktN0hRAhBMhnm+vUm6XSUVsfBcX1yqSi6rpLLxFhYKVGtd5gY2V6VK25WKW7WQG5XDjdqHZ5/8jr3/9RR7v3QSe7+wK0oinhNAXX27AoPPnyZQqNDW1VZbdrEMz6JTIyt9Sq+H7yuLcybwebiFs8/dJFoKrLtLVhq8NyD59lzywxDU7nv+/H79OlzY/oCsM+PFNeLJRw/YGdmO+dqvSa5sFF4VQH4D6hKjHjkxis0307MMFGFoOV5KI6FaGo07ATnxSRHUj4D00exjP1oag7pbxL4awhhMRwdxNI1Kq08e6cv0JBR6t1pSsE6udAGEf0dtP01ul6biOZS8D2iKMS0CBU/wbw/QsaI0/QCdMck3Elz2Q2YiOtMpDexZYCmdCn1hthhXWQyVCUh6mjqMOUggivSGLgQRGh0U7jVnfzE5E7isccJqUOYapSIlgVOM9cd5UB4mZjmIqSgERiYWp202aPqN1izi0zEa7Q9B8tPoOgeZthB33ONelul2EkiWzF6bgTLqiKJIqWOopeZyAkUXXL75BNEzC4Vz0LzGkwOdri6YhEEgrnOJOPhVQbCHRq+Qs83WGqmGYs3ee+e54hYdRRF0nJSXK2nORp2kdJClVv4QZioHnCpM0uH64y6AYoChqIhCAirS1zb2oPsHORfHN6BFX2CmrOA7S2AVEnqOyi7bZpeGYdLjEUeYPiAyYX8Kk41QSprMTxiUms2EPpL1jkC8WLES9F2EHjzyKCKlD7goaiv3d5sJnKEqJak5hTRFZPR0C5M9aWV57vv2kOt1mF5uYTnB6STEXRLQ0pJo9nD0FVi32bPYhg6rWaP7FACAoluajSrHTotm0jMekPC7fSZZSQwNpKiu9Wk03EolNtYnR47Dk78QMQfQLfVw+46L9rVRJMR6uUW3XbvB3L8f7L0Q8B9Xoe+AOzzI4WhavhBsG2CLASO52Norwz/frccGBzk5Pg4X78+jxME0FMYMlMoTpjdAweIhiYBCNwLeJ2/QvplQOH6epKN2lEShk3UtNlsJolaATUnwmCkjVAbKGqIa+3DZEIOXtCiTg9FEbjqLSQjIX5p+AilzSTfOLPA5ECK9U6KR+Zcjo7PM5ER6Poko6bPoPkMMfNWLDmPEqyRU3WqnourxIlEZ9lj7EZ1DhIKHOqtLqFEHABN6AxZw4TkT7JR+xPSkSU6TgTbG2U46rFmP8sTW0P4ostQyMRVBVJ1UVAIfA+vrdPYskhONGnj0dOraHqThuMRNwxSSpFDuadITbcQwqfomaz0EqzLJOlYm5HcJkEV2rbkya0djIe66IoERWUsVcJSYEKEuVrNYAcKM7EathdnrZsmG9vBc7VBNtwIASk2nQgNv8aqrZGVA0RDRaKRDTwlhpWb5JZ0lnOFbxBrPYGhphmID+LKIq5fRhUGAvDQSAQJLl0r0wn7GBHJ8HAS9ArpWIpsKs3ScgnL0un2HG69ZYZIxAT5bmTQwncvIlBQzfvQrDtec14JIRi0phm0pm/4/vhYmp/7ZydZX6+gKgqNns3DT11jcaWMaWqcuGmGqbGXKnkP3jLFmafn8RwfRREMDCXJDMTgO4iY+l6Aoghy4xnq5RbLKyUqxTpH941yz/tueeM7+h7JDCdJ5mJsLBRJDyWo5GskczHSNzCX7vNmIviOJswNt+/z40xfAPb5keKmiRHOrW9ypVBCEYKoaXDH7NSbtn9NUfjZAwe5aWSES4Ut1up1IobBgcEBjo2NASClh9f9LDJoILRdOF6LhHaGowOjPOOksV2DkN7Edk3iRhdH6vT8GEhJVLOJijwdBB1pESFgSH6JqB5hiHlseRRNSWPqGikrRLU7w2Z5F//q9vvIRaPUGv8dxx1DUUL4fpbArWAqkoHIrbSUm9jv7uCRx+osbawjREBiSqE7ucBwKocbtMjoIfZnBlgq7WW1EWbFCWPqGsNUMNo1au0IalfFMUKoaZOqbxJXPBAOHdUlmYwgIyrS13DQUUQVZBVTutySXCWp2QgkCjCg2QR6gwCddmAxkFkkGjMwNUnJcdn0wuyKNDB9nR4BtmKTjrhMyYCWkyQTVhmKLlJ3Y3h+hDEzy/PVGQI9ivB1rq3u4cTAGjLcpG02KXWjRPQxIvEVrm1+Ck+qSKmxWVeQcoBUvIxHnrCSIxApHH+Exxafpnt1DwOzI7StNa4WSsyMjDIsDxOuN2gvF+mFTe687wBvv2//C72DoxiRjyGD2nYYWCTelFy1dCpCOvVSv+qp8SyVWptIyGBiNP2yY+w7MsmRW3ewtlTCMDWQcPCWacKvYeL8j9m/f4yvf/0Cxa0mkYE4s7EQ99yxi1tv30ks+ep9s99skrk47/yFu3joL5+gWW2THkxw/8/dQSITe/2N+/Tp832jLwD7/EgxkU7y8dtu5tx6Hj+Q7BzIsGfwzc0TUhWFPdkce7Kvsl/ZQwZNAiJIaaOpYXRV4Pg1xjP7WKkeZSz9HAPhElYoypK9h4VWhsnYLLszV0BWUNUYiq/jBTZpZRNDnyGpuUwmv8Fw/DBntlzWOg2ats1gLMqlrS3ujkZR1UG83sP4Tg0pXaADYpJc/DdJKwkevHia+doq0yNjmIpFoXSELTHHTLLLiLpEQvh0O0toShWp1khYI0jZo9yps1kcZEyJEDVNevkpyuo8RrRGKOyiqqAMtZGiC5qO5c+Qb5jg5VF0l7TeJaR4uFICKpIAU0iimkPE75B3Y7hBl7gZghAMBD1KMky7Y2AEJhktgm5cIk6HULKDIopYio8rVXq+yWbLxRJbZJ0EFwoHuWmkSijsEQ18TOER4FMp7SAyFqfheCjaMkl9CkuXpEIQYZkBUaWjBBQ9j7K06LqbeIrOcO4koc7d+N4Gy/Wr2KbOt5YewdEDRlITdAsdts4u4927H9PUARBCQajf3yrZoVycoVz8hu+lslHe/wu38/wT12m3eoxNZbnpttnvSIgePz6DEHDp0jqqpnLT0UkOHBj7oRRe7DwyxfiuYdr1DpFEGCv8xoVsn+8OAYjvIYzbX//78acvAPv8yDGeSjKeSv7Qju+jU3Q6BO4luiJOTLEYjCWQhSzrzQaKOETYOMztM1kGYkPUnBR11yZt3I/Cs7Rb/xcxJYzSzYD7CLZiUOmMkTbHyUQXODBW48tPV1AkjCcSDKWifOXaHPsGBkiZ99NsfxIpWygigqJOgVBo9J7giYbgtHOF3kiNol5hqH0AS7VIaVVSYg4zmKcnU2jqIK6/7XGIrKIpFaquhZNtMFxzuS4DuppAyU8wm+yQHS7jixqK3gICfHTaUuD7gpZj4kpBM/AJIgJFKggkAoVA+PSkxrnaKKgBQ6EiEaOBg4+npDGVOMiASpBkItpEeAaKUBBel0A6KMLD80P02iY9EZCL15gduMxQbp3RkMNQqEHPbtHpxjCUFiMji7QMF9vrIfQW9dYAmtJjJHyKlFFFVxMobpuMWqDjD9IGTKNHyy9SKiepmy3agw7xboJepYY6C5VMHT06yIp/lsU1m/HpSaLmEVTl9VfI8u0mm+0mYU1nNplBfZNtTQZGkrzrg999qFZVFU6cmOXEidk38ay+e6yw2Rd+ffr8CNEXgH3+ybK8VWW92kDVXAwDLq3U6boB2dwmRjTEDi1LmCqev0agTvJT+1Ic7+0npMeZzaQJ6NB081h6hcHIGKrQkfI+wsKjUPsMpcZlMqZCz8+wXgfPz3N40Gd6eIjhTBwn8GgFDsvtOjHbpNGzyYbjaNoeFGUYVUmjKElc7zqXKpd4rgSqG0N1fapKEZcrxIXP8NAKAhdPBniyiXQugzJB1fa50E6SDZmUemFioS5BcAmxtA86OpFUgCq6OKKBEA6eZ6AiEFqAIhZwmaLiWwwaNvNOlH2uyajRxdjuG0LT0zhX2s3Z9T28a9dpVBWaHpiahyXKlO1bUVklrJbw/AYqAV1b0rLTmHoHSQsDj7Tl4GldFEXiy4BcqISDiqopRJRhTMPDlgZRpQTEsXSNlhNjsddgo7KHt808R0tmKLUSeFIhoTUxZIPh8CGK7QqnN9bZXGpgTm8RT7sonoXm6rR6HptWhaHBTfbOXGLFuYTezBK1TzMU/+eoyqu3ODtT3OSvr5yj2utiqConRib40O6DaC+IQM8PePbUIlev5zE0jZuOTLDnVfz6fpx5PT/PPn36/PB4SwhA3/f5/d//fT75yU+Sz+cZGRnhF3/xF/kP/+E/3PCD5V//63/NH//xH/Pf/tt/4zd+4zdedb+///u/zx/8wR+87LXdu3dz5cqVN/sS+vyI8fziOp9+5jyudQ0ltoQbeKhBGuoHWOxdZWJEJZm7i7R8CCmbSL/OgP5ldiaaRCO/SNPNc6n29zTcPIpQGbD2sjf5U+iKRTj0TjbzEZ7afJ49aZex6Gkm40X8wMeTu4lYJ2j6lyh3O4RUjXyrhalqFNstsqEwHWcGTTyNqoDv5+nYgieWmmw6CoojEIqCJkwCvce+6TTplEvTqxClh49HR9qEVAXUCIpqU+glkdLE8ONYkQ32ZZdIpBystIej1FA1G4REFyqaYqKICBKNo5kRntkMELZG2ujy4OY+DqeLDJo+rS5czh/kiysz3LnrHCHDxUdFlx0EJm1X5ekCaAyxP1ImKVoktB6m2iMc6uBLk6YXxlRsfGxQfNZ6WbaaOSLmFkINkNLD0gwC6VKvh8Aw2WrHSScmyMYGQHGRnkAxQth+QLnXI2oGBIGgUYsQz2hEzQQ4IcIeqD2VwPNZ2CwxNBBl3c+jdBT2DM9hqhYbzRyD3RyCS7SdC8St4zecO13P5csLj2OILQ5mhijZYZ5cX2ZfZoAjA9si78ln5nnw4Uvouorn+ayuV9B1jR3Tb33bE9/z6XQcwmED9VUKtIJAcurMMs+dXiIIAg7uG+O2W3egvcGCrmatw+XnFl6sHt51eKIvIvv0eZN5SwjAP/zDP+R//s//yZ/92Z+xf/9+nnvuOT7+8Y+TSCT4tV/7tZeN/cxnPsNTTz3FyMjIG9r3/v37efDBB1/8WdPeEr+SPt8DjufxtXNzBNYmmeE1Gh1BpSkZzpWJxVZotyKU2ptUjEUso0RHJEhbw6jqCI5zliBUZK75IA13k6QxiS8d8t1zJI0JJqInEEKgalNstmuYRpK2P4Lwr6IoKoemfxYhx0mHF6l0O2y1t3vyIiV/8vQzTBAn8Ac5OD7E4Yk2mWiCi5uHWC7ZRAYLGIZOrW0Tjim8c/ImjiZzPFf4JE5gEygGEdFBBpItv01D3UEitEbghdGJ4Wh1UuEGRqqLotlIBA3XBGGiiBaa4oDs0ZMeghAHYjNUeyohO4WhFpGa5AonOTb4PhZWmphei90jDzGerBJRBE1PxfHBEgH56hAHQl2Go0XC+goVF+rODkbMBUJaj66v0upGWPQy1NsRpC4pdZLYdoaRoEnCbIPQ6XlrNFomTtdjo5Hl3EKKuOoxe7DOQGyUS4UCi71pRqxLDOgCXbXp+ClKrolm+0TbR2iuF4hrGmFnlEbdphOvwWgGqxAl0UiSzK5ihBKUO+BJFV861J1VVG0nEe2VLeCKrceYinyGsG6jiDAR/Wby7UkazratiZSS8xdWsSyNoYEEANcXt7i+UHzLC8CVhS0e/PwZ6rU28USY+x44wtTswCvGnb+0xpe/fh5VFaiKwkPfvISqCm4/sfN1j9Gqd/jMHz/E0tUNBALD0nnb+49x/P4D349L+vGlbwPT53V4S6idJ554gve+97285z3vAWBqaoq//Mu/5JlnnnnZuPX1dX71V3+Vr371qy+OfT00TWNoaOj1B/b5kaVkN1loFhBCsCM6SNqMvub4nuvRdVwiSRspfPBjuF4D39UIQlXs1gG67hqryirxRIuGYxInCZYCSALp0XHLWGoCRagoIgQo9PyXzIIPDg2yJ5fjSnGLOT8MHOUn9+whGtqNtG0Go1FWajUGo1GihkG12+VKoYQaEezLDXBq8S7mi4J/9fY72KhdJmIXsDxBRysjTBvDHeRo+iZq9joN38QUPZoyTs036fo6Ljex0RwEpUpUKyMDn1SogaEIqq5CSvWJKV1Mo0tPjOIHdTThgQJ64FNuG3zx+ccppTqMpYuoUhBWNFJqgEOD2/cd5uSeFqdW/xeBt4EgIKF5rAdx2l6cjVKKQ6OraDIJIiCs9QhEhEvtWUZCq+S7GVY2hmk5OaJS0l6IoO8sMToWxTUnCJQ1qj4Ejs5aPsvahUEq4QjhXAs7aLJ1VcfWopSN69hago1gmmSkQySh0KufoLSW49b0EUzVAj+PY4Jf92mWcoRjbYatCdqtRRp+jUo3RC5UIGqmUdQ5ynaFFfcpaC6idQ5jeLMMJWPMDmXwggqO+zVCOuQ7GXIhm4j6FGkzTsZ6KWQsFIEMtv8vpQQpUZS39gpWs9HlS3/3HOVinVQmSmGjypf/7jk+8q/uIZ58ebh8YXEL3w8YH932/tvI17hyLf+GBODc2RWWr24ysXMYTVcprld45sELHL59F2bI+L5cW58+/xR5SwjA2267jT/5kz/h2rVr7Nq1i7Nnz/LYY4/xX//rf31xTBAEfPSjH+W3fuu32L9//xve99zcHCMjI1iWxcmTJ/nEJz7BxMSNTV9t28a27Rd/bjRevTtAnx8Ma50Kf730BPluDSFgOJTin03dzlAo+arbRE2TkVSc602PZNxH4qGrCq7s0OwYrBYkvr+fmdBOvBBEgyrV2hpD0TCWeRJNHSaq5yj2rmCqcfzAASQh7aVjRgyDj99yE58+c4HHriyBB89fXGXYinLL7BgnR8d4enUVR/o0XYe4YWI3PZJRC0vXGE0nWSnXqLQcZofiFOunSHQlFW+ADbeLH9X5fz3zZXalfLTQDhBbKAgaQZNeELBZM2n1PExjkopbx2kMMRArEo9fJ6d12GeVCSkeAZJG0KYlBZ1Ao+qFUYOAuNqiY9aw7AAhoWmb9HoGM+Ewm71rTEYP49hPMh6qs2Fn6DgCNSgzoCucbZ4krNdp2T6K1iMufUzVR1IiF45TcpNcaU1jN5IMZgWxziDjcjfN5VX27c2y6l9irhpDaUVoBh1qLZfq6jjJVAShLKOrHkEhSslqcvK2VczIGoF0aPqCmpsB9SLTI0cYzg6gpmFXLsW1fIVux0Z0fDRcWrNf48BMA0cN6HRVtipRjsya9KjSZSd2a4z56hJtZ4X6+gl0meYnb9nLkRkPaDMd30nHq1LuCdJmnbvH0uzLbK+ECSE4emiSrz50keXVMp4fkEqG2b3zlb2Ev52tjSqnn7yO43jsPjTB7L6RH6mwZ6nQoFxsMDKRQdNUwlGLtaUSpULjFQJQ11V8/yU/T9f10fU3Fv51He+FVfTtfEorZOA4Hp7rY4be9Mvq0+efLG8JAfg7v/M7NBoN9uzZg6qq+L7Pf/pP/4mPfOQjL475wz/8QzRNe0VI+LW49dZb+dM//VN2797N5uYmf/AHf8Cdd97JhQsXiMVe6VH1iU984hU5g31+uDyxdYVCr86O2PaX73yzyJNbc7xv4tirbqMogvcd28/fPtuj2K5ghSvsTRsgM2jtI2SmBljYKKPYOZaLw8TMJzDUOqp2F9HIAwihMht/O07QoelsIoTKUOgI1eYwq6UVMuEQu7JZHNdjZaVKWgkxOBCl1GjzhecuM5ZJ8MDuvZxe3+R8oUAmHEZ6krbmIF1J13GptjuEDZ2ICQfGvkXYfJx6p0XZV9kq7aK0nqMcVCkPFNk5LJjN7SWQZQSSuq2wWfOJaQ6q5RI4szx9PcTNo4KZ1Dn2hcoESLpSI6P0yOoNmoFKD40V1yTv6qiaT8h0MH2PmOPj9eJ4Adieh0BwvrZKsf4sWeFhaBMEWpGOa6ApYYRzkpT1HLp6FVduUe/FyIYDpFBwJDTZx3RilFK1hiyG0YsTlDaaGDvGeWLZpaFUaTUFUd8h4pjIcJNgoIo+fp1wqoPpC8yBJjnrIjm9QcsexAotEdO6RORORDpHW1zmb5c/ieuHCb8tzcBfCKpFl2QqxNSJCrHBIm5tlFQmQTK+TrOSIW3+PJftz7M5r5GvrlHxPXK5LqMZjXJF8ND56+yfOICmxIgYDY4PjdBy8mjKBDvSh18m1o7fPI1paswvFNF0lSMHx5kYe2Vrwn9g8dIaf/L//CKr61WklMTTUT74z+/k3ne/tF/HdtlYrSADyfBYGiv8g10NMy0d3dDoth1iiRDdto1uaBjWK79GDu4f4+pcnvnFLYQiiIRNbjk69YaOMzyZJRy32FjaIhy1qBYb7L91B6Fov4L4O6IfAu7zOrwlBOCnPvUp/vzP/5y/+Iu/YP/+/Zw5c4bf+I3fYGRkhI997GOcOnWK//7f/zvPP//8d/TE/O53v/vF/x86dIhbb72VyclJPvWpT/FLv/RLrxj/u7/7u/zmb/7miz83Gg3Gx8e/t4vr8z1Rd7qEVB1FvLBaoOo03e7rbjeQiPIv33YnW60DNINVdB2SxhApY4gr60X+rNRgs9ogYsY4U7uNg5NDpOLHXgzjxfRBjmZ+nrZbBFQevFbhsaVzeH6Aqam8Y9dOZmMp6p0eY9kEuqoyko5zPV+m0uowlIrxaydv4+8uXmS5WsPSNHYnMjx3eYGLS+towuC+g7NEzCtUO88zld2DFxicKz/Koc5lzmtpjkxexgqtExYuqjNG2nAYVepk7ICeIVltZVGqSWrtBIFXYo91mUm1Rkpt0w10HBFDUwSKIugFHoEMGLIqFP0UnmMyG9sgEW4RjfSoOVtstocwxAS2n+PzK08R91rcFGtiC40dsRkkksvFKc5vtCm2UhydTDMbW0IVGtXuAK7YRSKq8vaB9zIR3c9lf4VTD63itAPGdqc4l+nSqnYxI2Dqkq4SkI4Y4BkkJsCId/GLSaKhEIN7VeLKdapbGQIZQigmlinIhAXLbR1fX2YqWgQs6iGN5tv2kntqhNxQAiW5AYHAdQQKCp4bwrK6hPUBKmseDbuKGYoRkg69jqBTskkmDTq2g+fHyEbex1b70/j+CjEjQjr8Lix98mXzSyKRukCLG1im/poGzlJKvvDJJ1jbqJLMRjFUhVKxwdf//jQHb5pmYChBq9HlC3/9NAtX80gkE9M5HvjZE6Syr53u8L2wvLDFylIJVVXYtXeYodEkh49NceqJ61RKTRQhOHpyB8Njr/RLnBzP8KH3HePKXJ4gCNgxPfCG8x/Hdw7xrp+7nce/eJpe1+HQ7bu47wPHUd5km50+ff6p85YQgL/1W7/F7/zO7/DhD38YgIMHD7K8vMwnPvEJPvaxj/Hoo49SLBZfFrr1fZ9//+//PX/0R3/E0tLSGzpOMplk165dXL9+/Ybvm6aJafafQn+UmIrmmGtuUnPaSMAOXMYjL19paTg9/ECSMC2Ub3tA0FQFwzKwvDHSRpSobiFlwK7hLO+5eS+PXJynYztk42HcwOf/fux5Dk0Mc2RyGCEEhhLGMKe4Xi7z5PJ5MuEQCctiq93mkfkFxg4dIWzqVJpdBpNRKq0uYUMnaplIKSlWW0xoMcYGYhyYSPP5uc8wse8auqrhN8bYKNdYKDbJRZqEglWQkhAKutZl/8QFcrFVym4Yo2FyIDNPSI+zsZ4m0m5zLNJgc30XlxdzOHqXO6fzzGbzrFQmsTKLJIweuuJjKRouCoEM4fsdFDwCV0UtQ9JqIlVQCTiSWOZwvMxQRGOu/dcknAaVhs6pZoaJ1BYbQZd9uVs53x5Esa6i+yqPXLsZX9MZiHdwvSy+4jIUHaBRjvL1K+uETYubHzjE7oEMj56Z58rzz6J6knTaYGrHBp6m4AUZ1FKWo7PTeCmf6MwoVtgk0BsYXoKEUGi1oiiGiU+DtcIq0rpOJtSg4+0gUEcJaXlGd1xh89Eo558uk5juMnVngFQbNFoSK1YnG7+VwfQAzqk4RqwAqk27IdhYGEFpq/Rosns4Rzxkoam3YOmT223nlDim9sqCs8eeX+BrT15BSonnBVxdKvCRn7iFbOqVgs1zfeqVFoqqYhkaQgh0XaHbsem0t1NOnn3sGlcvrDE6lUURgsW5Ak984yLv+dCtb+4N9QJXLq7zxU+fotnsgoSzp5b4wEdOcP8DRxifztGodYgnwuw+MPqqPYXHx9KM30AcvhH2HZthz81TeK6P8YI5d58+fd5c3hICsNPpvOLpT1VVgmA7y/qjH/0o999//8vef+c738lHP/pRPv7xj7/h47RaLebn5/noRz/6vZ90nx8Idw7soeF0uVRfQwjBbbnd3JbbBYAfBHxp+QpP5JfxpWRXMsvPzB4iYVhIKXmydI1HChfo+S5ZQ+GBXJGUtokQEY7teDc3zdzF84vrfOH0Zar5MgLB5fUiUkpumh598Rw6jovte8RfeDhIWBZr9QYhS+e+g7N87ewcc5slQrrGPQd2MJ5NcGphnc88dYG27SAlnC6t4oSvETUjaBookRWqnkGv4xMLbaAGINA4EG6y3kjQ1TbZDFQ6PYOIaxGwStGJsu5qhLtZhlJ5TsRcurZFJ9A5Eg9hKAadbpKlrQluGi0Q00AROi1P4nkJZM+j0M1Ra40wYlRBayC0MBOhLjENfKGjsESOEnEzg57VKPXi/NXaYSwnzEduyuGH5hj9/7P3p0GSnOd9L/rLPStrX3vfp7tnX4EZbAMQBEiAC7hKoqiFsiTLurZ5zr2ho7hhh23Jdhxff3AcBR0Kn6N7HbYsHVumZFEixR0ECBD7MoMZzD7T0/vetW9Zuef90OAAQ8wAGIAyQap+ER0xXZNv5tuVmZX/et7n+T+9LQaRmFnO8crlQ4z2zdOTdAkEnZMrfbx65QwtyyEbNxhIJzgw0Mvi6TUikky2d50jPZdJ6BUEWaK2qdGp3M9EYYAlcZlQbOBLGh2/QTbyYbKxJTy/yFrRxQtcxrOrtAUJRJ+Ou069FcMUZAZiIaV4k2B/hVqPQNnL0RPrUOiBpHGUfaO/wKvV/4GW26Dd9Ak9kcrcMAszafp6fG7vL/DpY3uRXxM7ipRHkW4c0XJcj5fOLRLRFPLpGGEI86slLi9s3VAAKqrM4ESeK1e3qNVNFEnEcgKGc3Ey2e3tK8Ummq5c61RiRDWKG3V8P7hOgIVhiN1xEEWBRr2DKImks7FbziV86ZkZLMthbKKwPf+rW5w7vcQHH9rH7gM3zpH+cSOKIqr2k4/6+Z5Po9xC1RWiyZt7Q77fEML32AmkuwT8M89PhQB85JFH+Df/5t8wPDzMnj17OHXqFH/wB3/Ab/zGbwCQzWbJZq+P+iiKQm9vL9PT09dee+CBB/j0pz/NF7/4RQB+93d/l0ceeYSRkRHW1tb4/d//fSRJ4vOf//z/vD+uy3tCl1Q+M3yUB9x9CEBCiVx72L20tcx3lq6QUDQiksxLm8tEJJlfnj7MslnisY0zSIJIj54kE36drdY80fhOJKFMq/1/k4j9I2a36jiez0TP9vU1v1Xh1MLadQKwEIuS0iMs1epkowabzRaFWJR81GB8d5rRQoZq2yRh6Izmt21FfnB+jiAMmerPEwQhK+EL0JFo1H1EQEu0scMiaTWKKmaxAgsICNBRhTxe2yKpV2j6ImbOxgs9QjpYsQ6RyBKiUaeQF7hzdxvTeYDNDY3RtECv6CKEWUQZQnUCQb2Nrc0v03EarJR7OF0eQNRlBuM+qlEhqmmkNIeACEEoYwc+rg+y5BH4IrvTy1ihxNW1SZbbM0SkPI6tkoi45BLrXJ43WN8aIRuKxPUI4wMW6WSNuJGm1fERBIETV1eImB53juRJD38XQ7NYr/QxFBM5OFTH7wt44oUmplQg1rtEsuCzZad4yepjKjnEgz3LhK054kaAIgXQ0dgUVGJai6a/iuLGkaxB/L0VCn0lgiCkFOqsljIMpB7h7iP3sdQ+Qcm+ymhhiuL6Ms1wnWhigx65n141yj3jQ/Sk3tlyaxCGOI7HymqV+dktRFFA1CU8f/sLq+f6lIsNREEgU0ggSSKf+MK9VMttzp1ZoeP4jOwo8Pnfuu9acUU2H+ec5WK9Ju6KazXqm3X+6Pf+kqEdvdz/qSOEYcjjf/YsV88ts15soadjZPvS7Dk0wgOPHERR3vnHfafjoGkKgiAgCCBJAo7tvePxPyuU12t850+eZH1+C0WVOfrwQe746KH3VXFOly7vlp8KAfiHf/iH/It/8S/4R//oH7G1tUV/fz+//du/ze/93u/d0n5mZ2cplUrXfl9ZWeHzn/885XKZfD7PPffcwwsvvEA+/9Pt1fV3DUEQSKlv/ma+0mrghwEFY/vBbfkeM/UyYRhScVp0PJvxeC8SHQbkMnUviksGTdJxvUt43hyKJDCcPUc2FqNtDQEy4Y98M+6Nx/n5fXv52sULLFvruLEGWj7HxdY8t2nTDOWSoEPdsVg3m/REYjiuh/baA1kUBfBVQrGJ6wkIooAUuNimQEKTUeVB7CBDxWpS7iyhq0kUHiSpP0Ystk5UrWALOrrQZk92lsC3adTy1Bq9jOxr0lm7wKNfzyPafYxOrtCbr7NiitTMLZLaDE9deZAgtkHTa+FIHqXlJEJ5kNs/VEFM1AnwAYUgjFHtVEBwiCsWQ0aVlNyh0GOyZBTxxRHGI6tksxVqtsImGRTZRe8YDKCTHzrN2GiFwcDCd1OcvbIbgQyCLG4XE7TbjGgB9XaGETXOsV3jOMEVnj5xlWJlJ+nkGDNnk1zUisiygB5ucjEhMCafxLI0OkEMXfGIqQ5WKIHs0h+vUWlGmVvtZXjieQb0CrokULUinGSAM6UaHxMU3KADCEQjBlpUI/ASxFWBuu0xf2GFP6tt8hu/ci/jU9OIwo0/Nn0/4Py5FSqVFpurNVY2qkR1FcfzUdoighfSrHf49v94mYWrmwgCTO0Z4KHP3kamJ8k//lefZX2xhO14DI7lMaL6tX3ffnyazbUac1fWsdo27VoLIxvFc31OP30Zx3LAdTn/7GWaHmwVW0TqHWIJg5efvkKukOC2e6be8T21Y7qXp5+4hFRq4rk+siwxOHzzIpafRcIw5Hv/9SmunlqgZyRHp23z5F++QLYvxdTh8Z/09Lp0ec/8VAjAeDzOl770Jb70pS+94zE3yvv70de+/OUvv7eJdXlfE1dUgjDECwIkQaDlOvQacQRBICrrKKJMwzVJyhKWH6CJAaooAz4Q4gd19g++wKpxiTAEVUyQjT3IodEDbzrWwf4+fLXNV1eWkaUIrmjz3Y0TANRMiUeXZmh723Yvnxrbw67BAk+em0MAbM/Hl0ZQMi0G+t1t3zinB9kao9pJENUvMVe/gul5uL7Fk1tRAj9FO/ZR4tFvkJUcWsIODNEkwhxOGCPb+xC7BxzK9SuUw5c5OPyLXGk+wMrqU9yWuERHzLHZgKx6Hs9NMzNzD2a0Qb3tUWrIRNMFduXuoaY/Qcu/Sjxcwe74hKGPI0mk5DZpyaLmRjADhb2pZVRxHomQdEzENQQMJcOppTGG7CrHRs4zsGsBS1LZtGOokRUmRj0WF4Y5NDJINiHw+PdOEUs4ZHNt+nsHkJQKrcYqaqbBntwGduMgM22FkmkyIESRFQFrs0OlWSKpJai2HSKZIrpuEfFUSmaaTjDBluMSJK4ynl2nZkYwTYW8UedID8xtbluTROUcoiBhehUkxUGWTMqXE7iWxfThqwz0bfLywnPYyfuYyv8CipS47vwHQcj3Hj3HSy/O4vk+mwsVooZMIhZBUyQkNyRwfZ597DwXX12idyhD4Ae8+tIc2Z4E93xoL6qmMDLVh+8HOI53zUIFIBrX+fQX7mZzpcq5l2d56btnGN+5bROjagrzF9cIOx0yfSmqK3USKQO3bUHgI0oyWxv1W7p37rl/13bu4oVVVFXmtgcm2L3/x1Pw5tguru1hxPX3dSSt07LYWCyR7U8TTRpEkwbz51corVaZOvyTnt07oFsF3OVt+KkQgF26vBuO9gxxtrzBbKNMCOR0g4eGt6MgE7Ee7shN8kJphqLlIRu7uSs5hxjM4vo+ijKB69dIGRVCDrNRa1FILDPRW2T/yMANj7dsbSJJAiPRbb+31U6J54qXWSkrqJLEQDTHmtng6wsX+Ye77yAIQy6ubBHRVI5O3Msz52MEaplEzKBWidN2AureblbqRTzrebKazsVKH08tyODOkfIUPnubRmiMUHRkJCFFUkoQVWQEqUrTncETShg5sA5/k9nLu7h9cItQNxH8ItmkAE6CWKTDuWoNwzYwBIXetAh5jdCY5nDqCC9fvMRLm6eYay/Qm5Fo6Kc5krlK09eouDF6tTqG6CALPjYyXghOIDOgNvjE1Amm7y7SqzZRJB8PGV0KWHMiFPJV+pQ8H5iY4Dv/7UV6jTjW1gcg9gyWeYW66dNBpuMlULUtSDxBx5+GUCQa1zBkBbPjsljJ8PBYBUtUEGQZJIFaO8pSaQdLVgwtUaJXMVFEDUeRECQBS9aJByF7e7fPZW9kD22vxEr7FXJZiUsXclw9lWVoepPhHatEvRSdmk+xdZKokWE08Znrzn2p1OTVV5dIp6PEEzqblRb1eodde7IkUxHmF0rIssT6coVoXEeNKHhBgKzKzF/eYHAwTSIbo1g1+f4TF+mYNj29SR5+aD/Z1/IAVVVmaDxPdaOGJIn4XoCsSLi2i6JKECpYpo2mybSaNmEQQCjguT6xuM6toOkKDz1ykA8+vA9RFG5a6HErhGHIqScu8Py3TuHaLgM7ennoV46TyP7tVTK/F7SISiSqU92qkcjGcF9bAtffoqK7S5efJroCsMvPLBnd4B/sOcb56iZeEDCWSDMUSwEgCiIP9x9iV3KQtmeTVj9CTprD85YQxAiaepS6+deIgk5fKklfKonr+SiyeNOohYRAQHgtchOEAW4Q0PYcBqI5BEEgr8dYaddw8PnMHfvw/ABR2LZiURD55vMXeHWhQtUrkU85fGPhq5hqwJp9J3uzQ1x+ZZGE1yKqqfTWNPw5jZ6MQCaaww4cDLGXuJKibp8hDD0CQcZWbRL95/lgbANf9LF8mY4rIks+8WgJ0RlDFGUMSaEnEWO0kKZotylbdeZf2OS5k6s0SHHeHqI/qTC1b5Wmv0peaZJWTWKyhSCE+KFAgIqIB6GMqliMpMrktTbtUEIJBVQRhqI10JMIYpIHDxxi5XKbaqnFjqk+RLGf5sYg67NXOdS3TCRaQFNNZrZKJOMlUIvInX7qkk0TBxuf9c27KE69QDR9BTGEJT9JK6Lj600cW0AjYKNpYMYiaIKGFfjEhBBNnmL35D68wGXTWkURB9mbmmQitozUeArh8DypTIeUouHVdIQgQFNStN3FN5171/XwPB9N367iHRnKcrq2zNJKhVhNY6A/ze6d/ZSubvHK1VXO+W28IMDcarK5WmL5zAKCptAyNPR4hHhc59KldXwv4Jd+6c7reuhO7B1keLKX+UtrSJKIKInc/dEDxGMa3/tvzyBaNr7lIEVUHD9gYlc/B49NvKt76J2aN78TZs8s8dh/fxZREolENS68OIMoCnzmiw+9LyOBkixx72eP8p3/8gMWLqwiCAJTh0bZfeztu5l06fLTQFcAdvmZJqnp3NU7csP/EwWRsdgbuzNk0bTXDaRVeYKO/TKevwmIBGEbVZ5+035+yJ7UGJeaK8ybG4gIqKLC4fQOirUVNswm+UiUDbNJXNFJv9bSQH5DZOWuvaOsmk3mzze5K+swXHgeQdwiFEVinRwnV+/eXi7WRFzTR8yuMm/J5OsNdiYaSIJEKOzndKMfPVxHpIEiOgSKgEhIOtqk6SlstFLkjBaK6NPxVFY3dpJVVQq5GLt7c3T8eZLGHGdbV1lpm0T7RhkRx7CqIVbkNIrksNAYJZqaJas2UAgwfRlF8JGwCQS2+/16CrIIUckhDCQ8RLwwRBVcBEHAUHehiAaq7qCoEh3TJhrTaVYULGsEUWzjhxauXqTQWyWuO+wwDTY3okTXRWKyTEpMkDsAXyklGJL7yGg1VCmN52+STRZB9blUHuDy8hgGAbcPlhmKaKibWc48OcTJzv8g9UkPp9DAJyAu+aSlMvkhkV0hmHaRQPBxvSgDE71IWgdVenN/4Gw2Tm9vkqWlMul0FLfjsm/XAIeOjJJKGeze2U8mHWVgfz+l05fo1C1EP6ARuNQSEQ4M55iZ3WRptcY9D+wmEtNRFIm19Rq1mkku97oxfTQR4dO/dT9nX7xKp21TGMiw+/ZxRFEgmY2zsVjEtj1i+SSxlMHoZO9b+hD+z2JruYzdcRjdPQhsRwRXrm5gm877Nqq26+gOkrk4GwtFtIjKxIERdOP9Odc3EQrbP+9lfJefaboCsEuXmxDVjxMEdUz7BSAgqj9ALPLhm24/Huvjs0PHOV9fIAhDJuMD7EoMI4cxvr14mYVmjaSq8dmJPdf1jS3bGyy2r+Dj40cDsgmD3YMv4gQViu1eZDFkb7rClnmVWWUMoeazf3iJgZ41vMCnEvicr9RoW3EuV1dYbbkc60szkNrAD11kUQFUHDGCpnjYYYytVgZDbrFezlLbSPGxHUNUYzUU+VvkUpfQFR9V6mdNTdHJz+C3MhxK9bCquiSVJH3JQxjGLjY6TyD5JqrooIoOCalDGMq0/DxWEJDTm+iiiyE6dAIJK1QpeQaWOMKh1MeRRZXB0Rx7D4/y6ktzlDbqiKLI7cenGM71cr7yn1H1ZTRdwAujJHs7TIxp7JCH2JPOYxVsngleQhBENNmn5clIgQB+jk6rSbPRx8z8Hhp4fGX+IEJEY2rZ4fLjTSQpg9u/xNLKBlPSNO2qTyXyKrWIyc7kvUzuGGW1qBCGW8T6VKIJk4jcS1/0g28697qu8PFHDvHoo+coFRsMDmV44MG9jI7mrtvOEaF3JEtW12lUWsxeWSWIqviSQCafYL7Upt20iMR0LMtFkSVU9c0f0/F0lLsefnMu6sSBESYO3PgLz08aVVcIgxDP8ZBVGbNlkUjHkNUfX5Txb4P+8R76x9+6jV+XLj+NdAVgly43QRAUEtFPE4s8BIQIgvG2S1XjsT7GogUE4fWH2gcGxtmVzlN3LORQQggFyqZJ1jAo2xs8VfwGdbeCiEhNcJGMLIJQxXR0PB90WSMuR9iftPjg/ggvXLhELr1CuxFFi0ax5UVqfoP5lkgY9cnhcX5hCGPXEjm9QiiE1OwUguhRa2dwPYNCUsL1fHJpuHN8hfsnjlPunGCpVaPkJlAFBUWoMpZSuVAS2DQ38DZ9eicLDGeL9MbiOH6Htq+zWktjhJA2asz7AmdWPsgXbt8HtX9HM1BRJJeU5KCLPlVXYs4b5kjuAQwhwzNXv4zttxk63kPv1A6cmkE6E2dq7yA+Fq74PTquQKMjgBTFFbdIF9LcP/0hDg338+jaacJ1mZiUwgkFDNHBDEx6lBxtz2Z22cArmhQyDaKaxtHEA3z9K0/Q6kRQNZP4qI/g+Myf3cRyPBLjIbJscXL2NL3jBnKkQ17fzd70I4ShT0wZRZdzNzz3PT1JfuVX7rrW9/ZG14quKsiKRDIbJaIrzC1s4lsuYgiYNpm4Trlm0rRcZFni3uPTxG8xf+/9ys7bJrj44lXmL6zgewGxZIS7HjmMfAv2NF3eOV0fwC5vR/fO6/J3ipLdpGK3iMoa/ZH0O8o9EsV3Zv5qucuU2l/H9jfQ5H7y0UfQ5O0igx4jznqtxVfPnqFu2URVlUd2T6PEF6i7Ffr0EcptE8tbJhLfotRMk4xu0PFUEnqIH5bYkTYZTDpEkxs0/TZ1R8eTNwjUNj4irgBmoBI1mnTMBOfaeUYRGFab7I+uIiIx7ydZb03QsjdIx4r0ZuogrvNy8Qr9kUkSSpK6H+KHPoqgUch4bPkxlI5B33gvt+/fSVH6Hkv1s3g08cIIiujTdg3Mdh+rzQxGbpELjdMMim2EQKLlq7R8BUP0WPNi6FKMrDTB37z0f1HrrKLGGix0bHLxISZHH2BH8hEkUSQIRCSpQCpuUPXnccIKiDZiao7Hik9RFfcwY75MJ5xH8jWaTCKEl0jJHv16hKXyIM1ahtv3XyQebyCHIs8sb7IV7yXlqEQNhcZGgDbs4/tNnKiO5+vogoCUWafW0YhFdTZsl53k6Im8fRWsIAioqoxju5iNDtGkgfKGCN7u0R52jRS4uLgFQGEwQ3SjzfrMBtGEwa/+vePI6RidjkM+F2d6uu99mR/3boilDI5/6jbW57eobdUhEfnpWU7t0uVnkK4A7PJ3hjPVJb6xcpKG20GXFO7t2cWO6ABzjSqyILIn00Naj7yrfXtBg43Wf8XylpHFFC37NH7QYDD5j3CCJsv1l3h64RyilKE/sYdSu8PXzl/kgwd8REQ2my1mt5bIqGv0KhKN2lH29cfoSyzi+DaGoqOEQ7RavaQNEY2XCF2XdqAgSxYdz8C1NWTdJ1BC5HgV29dp+wX6pDpiKCILIkdTM0zHF1jyY4RSBlXqpeM4lNrLtBsmcS1CNpJl01nD8mtYRDkytJf7j3wMTdJZW6/x/afimIU2guohqn04tLCcXlpmipHeV8hHt9CFEASPjNLB8lRAoOoYmEGG6ewBrly+TKW1RlSXUCI+dluk7JeIGSeJyBn69Q9waaGM7fTSkJ/GMCwkT6ZpyyDqlL0zfGVxnv6kQEKMUbFrNJCQjY9yf36ciKnjX1jint2v4iVNzGYez/WJprdI3aHhfreHZqVFZ0vB6MnBtIkrmQilApVARFNrOKpBT3IPTT9k01qmR39nNiizZxZ57M+epVVtk8jG+NCvHL+W9xbRFD7/wGHOL2xgOR496RgxD9qNDolMjMIttE7zPJ9Tp5dYX6tiGBqHDo1cqxh+P2J3HJ74ixfotCwGJnpoVFp854+fJF1Ikn+XLeO6dOny7ukKwC5/J2i6Hb69dgorcBiN5ag6bf5m+RVwrtBxtrcZTaT5+7uPko9Eb3n/treC5a4QETMIYQtVitJxF2nY51g3n6TYXiAaqZGLR2h3ZFRpD1dKZWS/B1XUWG5e4HjmEr26iRTEWJaex7Y/xwd2TtOylji98H8yv+XjB5voRoOeXpmMngcPGm4VTxAw4m38ALYaKSRfxpDiDAkOKjrtwKdHdfCIkpA7ZIMtNtsWl+oBSD6q4mE1XSJ2irHhMr1Jg1AYIB35KDvit6NJOr4f8O3vnqGiLBKVI/iVfpqOh9CvYoUJkhHIGiVApWEpeKJPQWuhCgHFepoNq5/poT5GYnfxfGsWBJANB5CRRPAckEKVqrXC00+f4sL8BgEaickEiYEOjh/B82MYioIuBVS8FvVaEooCoaPjRFq4ZY9sdCfJfJKoUcWhju9JSGFAxxfQPQkx2iGzs4+46VOtdbh3bA+LtQ2evjKHYeoEd5gQ0QicOGHbYmRkAckRaFs+hnYMQVCvO/dhGDJzaZ1yqUlge5z8+su0qi3ShSRbSyW+9p8f54F/+CCZbJy+ZJyIpnDb9Hvz1AvDkCeevMizz25X0rquz+zcFr/4uTtIJiNv2va9RBG3Nuq8emIB07QZGs1x4PAoknzrtjDVrTpbyyX6xwroUY14JsbihVW2lkpdAfi3QdcHsMvb0BWAXd43BKFDvfN9TOcsoqCT0O8lqr2e6L5QrfLU3AIN22ZHNsP9E+No8ju7hOtuh5ZrkdcTiIJIVotzoriEEQocSo8QhCGXayVe2FjkkbHd72L2Mp63jB08h0SAIEqoQg8tZwbTWyWuTOK4qwhUiOhnWW8kGcrNEZGr7NQH0BqnKCgWVXuE0E2S1ZcI5JNo8oNc2jDZLEsM5ZeIKh0EsYblh5TDcaxQZ91aRBYblJwETV9D8IcYFWVCaRnLd/ADl6jsAgog0bQUTN8nophIWgtCCAOZsplhc/F2zpfLjE1k6YtPMRbdTantktAEBAcqlTbGhIxj+jSLTTquSzYdMJSJkBFFZEnBDgX8AExBY8FS2CjnCesGOwbzTKQ+Qt44RiHSwvRMDL1GWwqxXRWJOPPNOYrVDmfmQg7kRkjqOqvlKRq6jZjwQbAIBQchGCYIylSbdZS2hm1ZhK7PxRPr/MnZr/HL/4+P86EP7+X7S18jmt3EjZeIuSqur9FqR6k12+xMpLj9wAgPPnKYSrvD/J8ENBQTp9qLFF/GiNQZyp8i59UIWk1q4gyut0Qy+nkEYVsAhWHIs09e4unHL+J6Pu1am9riFseOjqIoMh1D4qlKkUuPP086G+fY+BAfP7ATSXxvvnrtts2ZV5dJJCJkMlF8P2Bxsczs7CaHD48CcOncCi8+fZlO22HHzj7ueWA3m0slTjxxgU7LZmx3P7c/sG1AfTPKxSZf+bMX2FyvISsSZ04t0mpY3Pvgrd8jmq6iqDKdloUe1bBNB1ESUfWbH79Lly5/e3QFYJf3DXXzUarmNxCECGFoY3uLiIJORJ1mo9nkT06eYrPVIqLInN/aomHb/Py+ve8oupFUIsQUnaLVoN9IU3PaBAHsjW+wMzKPj0K1k6ftuu9q7k3XRPQ3ELCwBRV8m4hURQ6rCAjEdJ2JXJbFaoOWXyWZ+AEDKR9PqOE7IpPRCK1mjtWWQsdr0GuAHm5iui6Wo1OrjLGr/yLg0vFEQsnFcU6x4Uwgix1qbg+euJteLYqekLknvZtz6ydZtxcYj+QZ1xxkoYMTCCyYOio+Tiij4dNwIhRLec6tTlAOW+gNA7Ge4eTWEl+5NMegkSShaXx0fIqoobE8oyGPWPgJCz/hUpYD1komH50axRD6WO9sIioWuuTSthLUlo7TXO/nF297gMFEgdAvcXDnKQorHTphE0t2uaqnqcgt6pZG0W/BwHku1VWOqCMkpCQiHeJ6hZbrULMGKLZk4mqAp5WRCyYxySES+OQfuYraEfnuhdP0jd3HjimDzVaKZthA09s0m1HGI3dSG3S5487dfOCuKXRdJZmK8ol79vHNZ88zfzVNxpI4dKRGv+pR3Rwl6gxSSGt07JeI6vehyNtLuo16h5efu4puKAzkMhTXFVavbrC+3mBwKM0pq46pCfSl4giKwlNX5hnJpjg43P+urrMfEgQhQRiiveYPKIrb94AfbIdtFue2+OZXTmBbLnpE4dknL1LarLN1eZVGtY2mq8xfXMVqOzzw88duepyrl9fZ3KgxOlFAFAVKWw1On5znjuNTqNqtPT5ShQSHH9jH818/Sb3URBBg17FJRvYMvst3oUuXLu+FrgDs8r4gDANa9suIQgxV7icMQyzvEh33EhF1miulMputFpO5LKIgUG6bvLq+zkemp4hrb59IHlcifLT/EN9YfYXFVomIrPKpXo9R8TlicggE3JuOk4nveVfzb3ir+IKBJCYRXvO7c0OXhJhAFhO03QUKMR1dUXH8PjyhTl9072vtxzbQjAqC6yO3m6Q1mR4DTlXjmHNz7EnniaoC1XqGlWqCUuCRSVdJRSykUGWt00vbm+TunmkkQWSmucrpjdM4ziqy4rBiH2NnTsSyn8QOm2S1KrgCm604oqNw5uoY51dHcTQZV7eZUFP0x+PM1ipstJtIgUjJNPmrKxf4xJ2TXPlPy7S2+lDu3cSXZKobGcpNFUsy+XvTR+hRX6Fob2C20tTX7yMsjrN/LE9vbts/z7OfQ2CW/qF7aDcsgvAitm5ysTiIIvSjhiHJ+AZrtVUWKwnE2FOknDp+sYdsJsSIlTEiz+MjMpCaJyO00HDRZZeSE6VSTxLxr1IxK0CSifRxTlyZQdBsUpJOIpnAabTo7U+h69vLuVcvrXP2ySuk6y7VWoBTMVB6oqiZGL4ZQcwICOiEYY0wfP1Lgm27uI5HMr2dNpDtSZDIJaiXW1jtNvV8yMhQnkw2DgiU2m0q7c67usbeSCymMzFR4NSpRTodl47pkMlEGXmtX+/yQolWo8PYZA+CsN3J4+yJeZSOxcSeQQRBoLxZ58KJOY5/4vBNo4BBGCIg8MPvWJIkEr4mPm8VQRC497NH6R3JUdmsYyQi7D624y0jkF3eA90l4C5vQ1cAdnmfICAIEiH+6y+FIQKvL5WFb/hE2v73reU17UsP02+kqdgtYrJGzPpDlppxFtux7WhEokxfsvSW+2i4W8w2X6DtVUmpfeyI34UuxRCFJE4Yw8DGJY1ABQSVuH6EYfUQRfMpvLDDWOp2AlSWWo9f+9sEJBrCIA2vj6HkDFFVoWQf4GprP45a52PT0zSmxtioPkfDFBFSEqIKK1aS766OkIkbBJJNzW3Tdju4zlVa4QbRxLbQWHDKPFqMsSMxhSHNIslNrq4XKBZzRHNldvWtcnFjmrioYKk+oSKwWqmzWK3iBj5Lbo2oplK1LD63Zz/3Hp3k0ac6XNwyUKWAXqPM7oElAnGNi40cMVWnpWapdZLYTorpsV7G8xke/fYZNFXh8IF14hENSVbRkx4tR0Vu1zHdOAlFJaKBK6qIYsj8yia79teJGwKCuoDtBsiRJhHSZKQ4WdrYIVi+RBQbXXAR1QDZjxEzOqxZEh4+UTFBqb6Ia8L8qRX27RxidOD1vLMzryxgtm3Gp/ow0lFeObPE6Vc8cr0Rcvky2Xwc119AlaeQpdc94VKpKIXeFIvzRbIFg6ZxlbFPtpgY6CNrT+CvNunoAkEIpuMgCgIJ/b1XvoqiwMMP7cOIqCwulRkaynD3XZMUCts9in/Yuu2H+X+e6yNKIsIb7pkwCBGkm3e2ARgZy5NMGywtlNB1BbPtcPTuSbRbjP69Pm+RnUd3vKuxXbp0+fHSFYBd3hcIgkBcO07F/Css9yohLorcg6HuA2BnPsdAIsGVYhldkXA8nw9OTBBT1bfZ8/VktThZLU4YBjhuyESih+FEAUEAOfAQ3yhAf4S50irfWvhjzHATQ4lRSM7S8eoczn6afmMvm+YHqLtPoAobCIJGJPJZFGUvaUEgrR+49jBuOAtsmCdoeotIaLhhm4HofVz2+lgpf5+JlEjNLVC1RQ5GthP6d48/hHn5JSaGLmOpDi1P4lR1nA4ebd/jaHoUQ+wwHXueULuAIFgU3QKb9gCiVEUTL2F5WWJKClFrkO8R8T0FggQFI+Sje8eIKAlO1ldZNRu8srSKFXpogURo+TihhxP4tBybu+7byYWrq1xyNtkxOcdouoiqBkiCixuq1LxeZClLLNUkk5mhtzTB049eJAgCPC+g3WjxwXs7oC6xYS8hBSXKQYqIsUGzYyKJCp6vc2hgN7Wyg6GJSPomnhsh9CGi+xiSQ0RyEX2RQNiOUgWIqGKAKIGm+/hOGrOdp2ouEgg15EBlY2EHoRlQ0CIkY68XS7iOtx3dCkMK2RgjvSn0uE5U+xWGBk4Si3VQ5CkSxmevswVSNZmPfvow3/n6KTa1l9EGlyj0pCGxSqAE/OKeD/K1k4vMbpVRJJHbRwfZP9T3ltdos27SblrEUwbR2M09AA1D4+GH99/w/6Z2D3Dm5ALzM1tIkoAkSxx/cA+zL88yf2EVVVfwvYDjjxy6zqbmR+kfzPDJn7+dF5+dwWw73H5ngTvvnf6Zsab5Wad7lrq8FV0B2OV9QyJyH6IYwXIuI4gaMe0omjIKQCEW49cOH+aZhe0ikIlshuOjo+/6QSQIIqJyCN/6FooYQmiDEEdUbtzns25afOWVH9AxVhG9PE03wHNEIvIsba9CQilwKPf3WTNvx/c3MOQ8fdG7EQSBTWuF8/WXMf0mPdog+1J3sCP5WdbN5/ACk17tDvqNe/ng4NeZ1V7C9trEZYXY0F3cN/oAALLUSzT62zy9+mc01DJbnTwXmkmMiEKvEeMfTN+P4v8FtU6d8xUVgRZD+iq2b6DJm8TlBp4TUGq7xJQ2MQ2OH8jgehInF3K0TAEh4pH1DAxZYqvWoKMryEh4cohnOwwmUgzEE0RknTs/sJulxVkG0hVECZpuhLgSoAo2Eg66VMAhwA1bnJm/hKoM0NObIQxDXj3nMTWpkOh/jiBo4kl76Egx8pEL+FqFjtNLwbiTD/Xfw7/6wTfxlhIk8wIBLiEhXqhBaOOEAaIYIgcBLgoIIooUEFM6OE6C2ZWd9CaPE62VqF6+Sk9qlHxPgaraZmu9juN4aK8tP07tHuDUqQWuvngVLwgxVIlPfPZ27rpvJ2H4UcBDEG68VFnoTfJzv3aEx9dfQZZ2EFezBGFAyVkgI61zNNVDUe0wPpDl6K6R69r/vRHX8XjsKy/z8rMzCLJEvjfJhz51mImdt54vmM3H+cwv38mFV5ewOi4Dw1l2Hxhi78FhTj99GattMzzdy6HjO992X2M7ehjb0e2E0aXLzxpdAdjlfYMgiMT1O4jrd9zw/4dSST5/8M3tr94tcuRhEEQC5wxIOrJ2H6J84+rGpXKNYrNNT0ZF9BR0RaDRaWK5r4sCQ06RVlMsN1+g6Zyn5pwho9/HS9WTNN06uhThgn0SO7C4K/cwGX3XtbGet4wuPMdkdpiaE0WkQkJdIhOpAtt9YPcO7+Ny827m219mOHqJI4Usq+xAlESgg+POE5EHSEZU1tsemlQkqa6gii6+r2O1ZQTfQIxZiLZDI2xCbJx6fA9OpknHhvsmC9ibVb55ukIrK2HpIVFZJhThzv4hvIrDn377FcrlFpk+DR3wQgkQQFAIcBFwCEKfAI8Qg9AXrxc9oUy58SClPoN6sAWBSeg+waBsgSBhawEpfQNVCtFUmXoxR72cJPC3Cx6SySaeYFLxmohiAsN1iQnQcHtZayUpVtPozlF2D9zH/Xt2cP7VZcw1j1DLIYjguj6aKiO+VolbthfZyj5O7L4LOMsqrZlRREnnylqZkc0a2VQU/W3y1EQJZFnAc0JMz6IlbLLWmePKVon21THC9WE2rpTpicXQZInTpxaxHY+x0TwHDg7jOR7//f/4Jk88eg4/CEkmI1gdm0f/+hV+9R+niSVu3Z8y35Pkvg/vu+61/tE8/aP5W95Xly5dfvboCsAuP7OEQQvPeRnCFoLYg6Qeua5FmyBoKJFHIPLI2+5LEgR8KwtOjlArEQgikmiTVQ8Rk7cT7013nYXG1/BDG01KY7qrVO2/oOHE6Y1MbHeJ8DTWOgt0/BZROfH6XMMmYWiiqxP0aRJhaOB7s4Rh89o2flDljv4T9DVtio6JLi4Rda8w60zxJ/NFPpBqMqALTCYmkahDsEUKH0VSaFUL2EITUbOoBQZzF+9Gix2i0u8T4GLkfcYjF5iIrLDsbnLfXQonzu1jxjIINIcH90X47B6Vp/7mJWrVkJGRLM3Qo+VoROMtDFFFFEAMwQ1sXG8dUYjRa+xmsG8vJ66s4fkBjuMRS+iMjOapR3ayYheJeC8hYmMRRQxEFKHEldpTVOsHkTWZ8maW5blh+obXyBSqyKJGb/RObN9HEHy89iFOzZmsVGrI8VVSURfkOcKwQFTbydRUH6dPLzI3V0KSBGRJ4p57plAUiaZb5NXq19lsryBpPmO3mwi76sy8lOJbL17kSrFCf0+Kh+/YiSaKqKpMPp+4VnV77fw5GhszGlv+eQLJQU41EUMNswWxyTWiuTRb5yQeffw8TtOmUmkhyxIXzq3Q6Tjots2Fl2eRNIVc2qBZadEuNqglDerV9rsSgADNmonVcUiko2hdu5W/W3SLQLq8DV0B2OWnkjAMITRBUG+4NBcGJk77j/Hds2xnwkjI/jpK5BPvatl4rJBhqmeAi3MO0XQEpDbjmXHu6v0E4muisuNv4fp14uoOBEFAlBVa1mVEVEICBCT80EcUxOuKWwBEsYAoZfD9RSSxFz/YRJQyiGLh2jaON48frDMY24fdOk3TjZOQbTKhRDtY4eVakmi2RFQ6S0LeIBRGiclHadgvYeolypUUyYjEutnPD4p9DBhNhsQU/ZE0Kmuo3rMs1VTqLY2xEZNE7BL5y3sYHLvKsUMydfsMkSGLHvFuRHLEyDFTGWCHsYAhtYlLHbxQIapESeoHSUXuZDy6Bz0fJy7NMHNlA11XuP3oBKOjeZwgQcctsd74Lk4gAzKmJxCXAoTQ4YmVZYqiTRgKbC3spt1IsvPIRQaTU2S1EQCqzhyxaIYTMwZi4hLJWJOM1osb2FysP8XExii7evfw8KcjzM5Wcc0sAz0T7HnNeqTmrNL2KhhCP4G1Tt12qKtznEyBKEU5kFKZWdjizOlFBvUomipz8NAIDz649zoz5JdemmP+qSzpXVM4vRewmgpCow/R1hBiNm6kSETPs7ZWBdsnHtUoFZu0WhaPfe8c9+3tRxRFFEXCtj3UiEqraTGkyhjRW+8FHIYhLz91mRcev4Bte2QLCR7++dvpf61K+N3s78rZFZZnt1A0mV0HRyj0p97Vvrp06fL+oCsAu/zUEfpF/M5XCL0lBCGCGPkIonrbddv43kV89zyCNIYgaAR+Ed9+Flk7jiDdeteBiKrwS3cf5IWZDNX2bgrJGHdMDqO/wYhaFiKIgoIXtlGEGG7QICqlSEgOJfMxBCIEYp7dyQ8Qka7vNiJJOQzjF+mYf0kQFJHEFLrxc0jSG5frtpdag9BCEkFARBYUZCGOKtps2QUq3EVaXcJ2ZaLabQiCTjS4jVWeQwhVltd7uLIyjS3pSDEJ8bU08XZrHUFos1mO4zYFEFUGh5YR81UMo4LNEHHlAJHYWZzs83hbg/jJlxlJriOGEgnRQcSg4efpi8TIyVXGooNElW3rl/s+sIvj901RcZbxgiZtTycqpzma/TjPOY9RtU5RtV0UXIIQStUCnY6EEws4uKMf23ZRtRR4JbzQwfE7bNkzNOxNSnMdPG+SaNzEq2lU8cjlUrSDNYrmAubyU5juZcKCh9nUeWbpHi5X9/Dg4UkEcVu8Z1I6UkJm1S9D6OO7QF5kXq0T1iyq1Q579xYQvJAXX7jKwECavfte7+axvlFHkyOkzcM0GgKWOguOThgG2K6F3w5omw49uTizF9dZXyoThmDbHq2mxUhcpVlp0Or4WN526CXfn+L4Q/tI5269vdvS1S1+8K0zKIpEKhtlbbHEd79ygl/+xw+gvkXRx804/cIs3/vKCRzbxfcDLryyyM/95r3k+1K3vK8u/5PoRgC7vA1dAdjlp4ow9PHN/0HgnkGQCoRBBd/8CxAziPL4GzZ02P4E264S3jaXrgHOuz52PKLxof3XF4l4gU/dNVFFmYQ6QS5yG8XOy3TYAEKCoIoRLqOKHj4xdCVCr5Zmw1ogKidIKK9HZBT1IJI8QRjUEcQkohi/7li6MoWu7KJtnyJCA1dssub20wkDglAmCDU0eZKoPkZgLeOFPooAvhDQ8Hcw274H0Y6QzYcoqsvubIYNb4sVs0K1UuO2jMhAXKdmCxipBWypgyXqJBUVF5O2v0xvbx++NMu6+y2i+XWMIEOl0ySnrmEHHrowTl9kEtufw/Y2iSqjhGFIzd3gQu1RKvYiCBCVM+xLfZS8Ps7e3Bd5ZvF/Rwrm8QWJxdoYr146hB5fZEfeJtFx0cIJmo5PUD+Irqww13we02nhtJO0wxaF25bYqkgIqo1Vc2i0WqhZkZXiWQTxHM1AwBE6JPU2YrbCM6dl6u0On/vgLjLqMCVrjkR/k3LdYXWzF0fUSUsKRa+N0naJGSpRXSUIApprNvNLJXbvGby2FJxI6FjWtjhS60P4xjKpvjaKKlMvRRArQ9x5+wTTEz38wall2qZDLK4TWiFmucWT3zpDZ6OBpEgYqgqSyLF7prj9nql3da2WtxrYlkvf0PaXnUJ/ispWg1a9QyYff5vR1xOGISd+cAlBFBid6iUIQuYvb3D5zHJXAHbp8lNMVwB2eV8Thh6+9SSB8xIIIqKyl8BbQJD6EMQkoZAm9K6AvwJvEICiPIIgZgn9OUIhAUEJUd2LIL79Epjr+5yaX6PcMklENA6PDRBR37zMXHVa/M3KCZbaRWRB4mhuB/cVPkFK24UbNCmbT7HhnEcWDXRBJcCh4y/xfPH/xiVPox3SqYwRC8Y4Oj7EvsGebdEn3vgBLYoGufivoylTIF+g1JxlsxPSCWzcYIjJ+DQH0qNEJIm8foiidRrT20AWDUZiH+KCKuIrIW4QsiOe49Mju3mp+igr5gxtwcduTtCbrBEbauGrbeqhgWCIeKKN5yt0hAqe1CCalxhI1fFoYJUTJL0ccriJhI3ZCHEzJoIoIYkGYRhwof4UM/W/xHKvoohxEtrtdLw6F+uPk9GGSWk7iTT+N5658n22dI+VZpqh3AIHei/SJ4vUSw5Li4OszN/O5z95J7q7ycmVWZqVDM2ageCHjEzUSTNCxZtHydQJYxqNWoZKpc7O/Q0EVUWnjaKZqPoc8enHuLR0P43WTsZjh2m5V/H9MqEv4Hh9qBGJTbtF1o4wqOpkZY1m2+b83DqVmon/4gxyROHD9+1GkkSO3j7OykqFpaUyAIXROzh8OEkyGSEzNURa7kPTZARBYM+ufl59dQldV7CLDdQgQJIlNEMjYqhMHh4jDCFwvHeVrlCutig1TSzfx2xZRKIajapJJLa9/1slCEJc10dRXu86Iorb3oJdunT56aUrALu8r/HtZ/CtrwI6EOB730IIXbZbEyQB9zVz2+vNdUWpHzX6K7idvyEMGojqERTjsze18vghQRDyNycv8uzlhWvdDq5ulvmluw6iyNJ1235n7RTn68v06inswOX7G+fJaQkOpPcQhA7F9rcRBR0BDUk0cP1NTK+NIA/TaUZZqCwANZY2BeaKFWTxILsH3tpuQxKTpIyPkjI+Sm+ixkR7hbLjkFBy7Ij3okvbD/iJ5GfI6nvxgg4ROY+RHySjrzBfr2IoCkcKfZxY+xvma6/g2zJp2WTd0gnMg0R6nkFRVCTJQ6NO05cQaKCGEm4oIskDEJbxvTZqdIFOaw8dN0ZMCVGkIm1XoD9xBzFligu173C5+v8jLixjCC5eIFNtbFGxj9GfVnCDDqIYw1BShOVJBlIKSa3CjuwcMU/HWowSNRx27VrHNZeYm+ll+WwVO6sgBTpRTaNhmZSqHdSVKHpwlN6dIptlh/ZmDE+8QCh5KIKDqlqIYYgZaMSim7TTp3HCO1lrPo4QCjhmhoRWZqBwiY32FKIpsENK84XPHObUS3O8fG4Ry/UYGczQ35fihVfmGOpPs3fnALlcnM//4p0sLBQJQxgZyZJMGjc8h/fev5NmzaRZbVG2XGLxCAkZak0F3/ORZJFOy8GI33ru37lLq3z7++eoNTqUpYDG7AZ5XSOaiHDvw/uJRG/dhFqSRKb2DfH8Y+cJQ3Acl0hUY3C8W038fkYIt3/ey/guP9t0BWCX9zWhewaQEV/rvRp4s4RCHEKb0L2MIICg7EZQ9r5prKTsRpR3AQ6C8M4efHOVEk/PXyUVN8gbcTqOy5mlDY7tqLCz//UHnht4LLfLZNQYcSVCnAh1Z50tqwGAgIwixVFFg47XIgg9vKBFgEFcGeFyo43gxTDiFj35CPNrDufXtt5WAL4RQ04xnUxtv0+hh+WtYPoumtyHJMbI6Ndb2tzZP8yd/cMAnF2c4ezaaRqVgIy6wVB2nUiPg+inacsOtSBNQvJRhTadUKHo9dETvZtq5yVsdxEvdAlDH0Vt0lCvcrWao1o9wHgkywem7qAvcZCSNcNc45vEmEfCxRW2W4tF5QblzhVmN2I04j7PPnmS2bkt2rU2zbpIT59Pv6GguWmKQZtOQkWIWzQnGzxauYhmxUitZ8jvqGLbJrGoR3MpTnwzxkMP30ZiIM7/+P4pxvsEzs33sFHNM9q/gCa52L6C6Wm4nkwi0UTUqpiNMil1BClcQrElMkGZTNVCasQRWx2K0SKf+tQRNtomuqow0J9CFEVqDZNa4/W2bvG4zr435AXejL0HhhEQeOmZy9SXS6TjCv19Sc5sNmjVTYqrNXqHsxz90L633dcbabYsHv3BBSzbY2woSzKuU9pqcuzYJLlEhNWZdebPLjG2q589xyau2eC8E44/vA9RFJg5t0JKi3H7fdNM7Hpv/Yy7dOnyk6UrALu8vxE0wAN+WPnrIah7kLXDhP4aghBBUA4hiNEbDxfeHB28GVca6/zXhee5oi0RV3S8cJAeOYMfBLj+9ctdsiARU3TWOlUyagwv9AkBQ/5hzqFIb/QhHK9KyCxu0EJXRmgyhBkIIASgtBGCCEKgEYYW4rs0tQ5Cm83mn9O0TxHioctD9MZ/GU0euOmYpa0azYZFQm6yo3cZPwxxXRhO1XBlhRnboBPqBIT4oUgnjLJqLWF6ZUJCZMHADAKCwMd0Yrw6d5C6a3Dk0GEGkkcAKNkzEJaRBB8/VPCCAFkIEHAxPYlnrqZozDyPf6lNNhdnKBajZlrcObmHoeFlSsUZNiIObrSJ5GsEpQSaKmP2WjSf68NrRXHkBk5HIbrSRzSrszy7yW0TMXYMP8/wwAJjoy6rLZemE8FSZJxQQ5UCEhEbUesjIkcQBJEQl6FMiktrFRwzRPMNRvUU00aSl15ZwDMUREnEdj1AoG3aiIJI/AYVumEYcunkPLPnVpAViV23jTMy/Xr3D0EQwHZwiw3ShkptvQYdh8JAivz0AHomRma8QCKfvKXroNmyaLVt8pkYoiiSy8RpNC1kTea5b5yiutVAkkUuvDyLY7kcuf/Gnpc3QtMVPviJQ9z/yMHtYzU6XD63iiSLDI3m0CO3vrTcpUuXnyxdAdjlfY2k3kngzRK4l4AQQcwga0cRlZ1wg6jfu6XpWnxt+RU6gk1WjVG0WpzzFyg3LYaTWQbSieu2FwSBD/bu46+XX2SutYkATMb7OJAavbZNUtvHRDqJ6S4jCipxdRdz7ctcqD9PMmHTLItUN4bYalkkDY19g73vau4N6yXq9vOoUj+ioNFx5ym2/4bB5D+86RjRjVBfTTC8bw1Ft+k4Bm5bASOKrpZIKRod30cWBCxkYkqSqKhi4+GHPggGbhBFJECNRIkV4rRMj5Wwjuk5GLKKEAoIIfihgSyYSIQIhFiuxsXVA5TaEZ4xVziWzmEM1NDUJtaKieDtYCT9iwjhf2erfpZlB67OjrJYNkj1KKRSMkq/yspFEcuK0aNo7N41jChLNOodsqmzTE2epOFaoAjsSLQwybIVZhFpIxCiKyp3Fj5NRhsjr+9is3MWUa/Sky+xvqoznRHos/Ksr9SYL9fxzyzi+gHtjk0QhkR0hUP7htgz/ea2bmeevcJ3/+w5XMcj8EOunFrg4791D35/jY7fpr3h8cyX58GDwlAW3w8ojOTQezOsrtWQIypXZ7fo/PmL/OLfu4f4O/QAjMd0YlGNUqVFbyFJrdFB1xXKy2XKG3XG9wwgCAIbSyVeeeoShz+w61qOoe/5mE2LSExDVm7+WBAEgY21Kn/z5y+xuVZFEEXGJgp84hePveN5dvmfRLcKuMvb0BWAXd7XiOp+FOHXCdwLgICo7EdUfvzN5KtOi6rTZsjI0DOY4tLaFutOjVw2wucOHyATe3M+187EAL82fj+rZhlFlJiK92PI10cbDWUYQxm+9vt04gi9+gjtbJNZ3WROtJALEkdGB5jqzV03tt6xaFk2KSNCVHs9whIEIacX1lgq1YioCjsGViEE+bXiEVlKY3vrhKF/nfH1D/ECH6knYKtTYLW4QY9RwqkZCJUkal5HV3R6xQxVr0wniCKi069KBMECugheYIPQQRZ02q7ASivKstUhEATO1db5i6tnuLtvkL+8uEFc61CISCQkDVXysByRC1tTLJUHmUgnWHZLFLPnSPRUkIUQUbMpJSQU+TeZLPxv2O4F/vKF77PheCRTKk3JQi0q/K8fvpfV4TIvPn2Fgb40sWSEtZUqk9N9NILvoUVtok4W3w+RlQ5JsUNv5BNstTexwy16InvYV9gDwO7UZ7B8h6r7MiljjLZiYeYu0rwqc3Vle2k3GdEIggDCkDuOjHNgzyBD/ZnrOpx4foDjepx+5jIAI9N9hGHI3OUVvr/4N+iahecFLM5vsRGTiK/sYCgVZXCih3qjQ7PUpKcvSTSm4/sBywsllhdK7N7/9svKsC0AH/rAHr79/XMsrVWI6CrHj03irVURRQFBEAjDkGbTYm2tzn/9w8eYPjBEb2+Cx//sWWrFBrG0wQc/dzcT+4dvepxnHr/AxlqVkfE8vhcwc3md0y/NcfzBPe9onl1+tvkP/+E/8O/+3b9jY2ODAwcO8Id/+IccPXr0bcd9+ctf5vOf/zyf/OQn+epXv/q3P9EuXQHY5f2PqOxCVHa9/YbvgaisE5EUam6bgp5kcjBD3tH5eztuYzxxc9/A/kia/kj6HR+naDVYNpsogsTto5Mcn7jx0tnL8yt868xlTMchZUT49OE97OzbzkH8wYU5vvXKZfzAx/NDDlRL3D7to8kmoqDiBTWiyu4bir8wDHls4yw/aF4gsy/Cha1RsiWTUalJesgimS7Qm/oNJpUJvMBj01rmfO1r+P48ohhFlmSgihfYmJ7O5WoPJzd7SUkyB/ogZ5icq77K2fIVzi82SSp7ODgMGaVFMkiybPdxoXiQyUKOWmDSTDcJe5dYcgSMZpI+I4WYqbBpzRENxnjmpEV9NoqbqVPXHXrkGPmVBFupNp/+7FFSMYNzpxcpbTUYHsnx4Ef3s+F/l8B3Mesevh8Qjwv4qkLorxLVBTLiGNPJh669J7KoYYU+MWWEpNpLatzm6sZ5PMcktVTA7jhcvbhGGIY4IohewNhQ7tr7WXOucmH1LKevbNKo9rBSqtP7mi4UBAGyJnW9TK+yk7mZIs2tAHm0TW2pSueqR28qgmaoeKLIa3VHmB2HuWKN//bVl9g3u8ED9+4kn317+5Y90/309SSp1NpEIxq9hQQLF9d49ZkrLM9sYNkeC7NFMn0pNpbLzF9aJ2ybiJ5Lti9FcbnCt//4CX75n3yKdM+Nl6ArpRaxmI4oiojqtnl1rdp+27l1+dnnz//8z/md3/kd/uiP/ohjx47xpS99iYceeojLly9TKBRuOm5hYYHf/d3f5fjx4/8TZ9ulKwC7dAGyWoz7e3fz6PpZZlubKILMXYUpxuI/vkrHq80NvrL0ImW7hYDAVKKXz43cRUy5Po9stVrnb05fwPMDcrEoG40mf/XKef6XB+5EkyWevbRARJXpTaXxg4ALiw7Tgx00ZYUw9NCVIfLRT95wDnXX5ER5jqRsMDYepZnx2OrsZEovUBgq4Gp9NL1d1GsetieS1idIiv1UvXOIoYUsyGjSDhbbFdrmfahhD4KwyHR+galMDT90UGWbYjuJ7qcommkevXAXMaPOZLWXD9x9nNnaMhc2NtmU6sQUD10WEQWdUJcY7eslVLbNnk9cWmZ2rcyAkya2oGKpPkKgUqzaPN6aYbne4L4jOzhydBzX8cjk40QiKuvr+6m2nkaVy0iqiOmobK7t4fj+h6msFrn0/Rpn1k8wtneT+z57jEhMRxJkWqZJs7wdLcv3Jpic3kt1xuLU2WUyqShuEEDbZn22eO393LJe5czmXzK7tQqJgGQkz+LiDi5f9VAWAD9A7ZcwEhqhI1CrtknE4rQ8Fzt0KG81icoiH/75Y6wUm7x6YoGtYoNTixtYvk9jwWd2tczyaoXf/rV7ScTffpk1k4qSSb2eEzu2e4CPfeE4r/zgIpfOrpLuTXHwrkkkSWT2/CrLi2XuvHcHqqYQTRosXlyluFq+qQDsG0zzygsVYokIvu/jeT75m2zb5SfIT2AJ+A/+4A/4rd/6LX79138dgD/6oz/im9/8Jv/5P/9n/sk/+Sc3HOP7Pr/8y7/Mv/pX/4qnn36aWq32Hibd5VboCsAuXV7j7vwUA5EUZadMXE4wmehHFN55peRbEYYh31s/Q81pMxEr4AQe56orTMTn+EDP9cn4pZZJo2Ozo5BFEASm8hZp7VEatUeJ6RMoYoZQSmC7Hh3bxXIkXPsTDCVFQjw0eQBZTNxwHl7g44c+cbmNyivkkjUiUZuiZHNqK07VmWOtehrF1PG2olg1h2FJ4/j9kEmXUUUNy6/i+wUa7TQqMpMpl3RkkaqdRhZF8nqZhLRKfCLBWm2Ac9VhNu0oYVnjnw1OslZzmF8tYigy6SBKs62TjjdxhYAtZ4WhSJ6U0kurU0SWRAb701QutGls2ZSCDrovksoa1JodvvH0eT7/8BHyySivNTVBNY9wZe4QhYF1BCGk0+pj/cxBiuR56SuzWKZLJCrx4ndexXM9jv/iXdSWCszXTuKzvm1UXU1xe3IHOwc2WJktgiSiawpDMQM5eP2crrSewbQtWrUc6biGGNtg7wGXs06GugMRVWb/sSmE3BXK1jqhZhHqFlmnj+TAKFu0ufeRg9x2/y72Wi6ZbIzHnrmEJ0B/b5poVKXa6HDu8hqLy2X27R58V9ff9KFRpg+N8thfn+S5x85fM7AWRQFZlug0LVRNodOyUDQZLXLzwql7H9xDs95heaGEKAocPjrOoaPjN92+y08GgWu3xLseD9BoNK57XdM0NO3N14fjOJw8eZJ/+k//6bXXRFHkwQcf5Pnnn7/pcf71v/7XFAoFfvM3f5Onn376Pcy4y63SFYBduryG5W/ieX+NGmzge1EazkdIabdmxXEz/DCg4XRIKBHswOVyY53ldpmvLL5ATNY4khm/lpAf1VQ0WabRscnHXUZi3ySulRCEIdZb32R8PM4PFvsp1gSq1SiNZj+tto+hTr/tPFJqlJFoni3za7hCiVaQRAgjhP4SUTHBbNNnPHGOSMqhqcc505pmTfCoVz3CQKOQi+O4bWzb4uzKFmFoUMi7xGWJpBYnrc6jSzGKPljI5LKr6L7G1laOVqTFP/uLb9ObSaE0tvPRVmmztZxlst8jF3XYXAs4Fr+blNpLf84mDCGUBUIRBFkkgkha1TFbDvFRjdVinT/7yovoSKiqxL13T9OTS2NdvYdKs0k0KmOWYkiOQnW9SqvWZnT34HavZkng6RNXea7d5uLcBvFcP/v2S0QUjc0LMZZ1gYkdvVw+vUQ0EcG1XdYXy/i5OMW1Ktm+BH5oIYs6gmDjByAi0HE7NIQArTeOK0ucXGtz3/B+9NQMrYLP1lUVe36AwJU4eMcE9z68H0EQiERU7ntwD0vVBpdWS6iqhCAIqLKIZf94TJen9g9x/uQCC1c2kWQRRVc5ev9ONq6sUt1qIIoCB+7bxeDkzQuSkukoP/eFu6kUm4iiQLaQQJJ+PF+Uurz/GBq6Pgf193//9/mX//Jfvmm7UqmE7/v09FxvZdXT08OlS5duuO9nnnmG//Sf/hOnT5/+cU23yy3QFYBdugB+6LDc/EuazgyaVMD2Syw1/hI1lcFQbm6n8k6RRYmBaIbT5QXmvS02OnVEQSAEvr7yCik1yo749kN3PJfhrslhnp1ZRBausidbJBHbw7zdom7LjCYv0x5ZouUoqHac0mbAqUv93LZjkL7sjSN/b5zHJ4du49vL36Lt6qSUGFFZp2jVMd0tdiQ20WjTdBXSyQoHdp1nc3UASdBYmOsDL4kZdohKVWJRj6LpUWuojEz20ReTabkCfhiSUbPMuiqqWEayQ2xTAT3k2fYKiUoRz/FRDIlGxKIjyJwqDbKnlSaykWfLiMEgHJ4apFhv8/TpOQJgaiCL2XYhDHFtn2bLZn2zjqVo7Bop0G7bfPexc3zus0c5tHeKl0/MU/YDJEnk9tuGSQU+bctjo9hC12Wqnsm8YBLMizQbFrWGTrsU5UO3TRG0q9iOyx3HJqnX2rzw/QvMX1xDFmDt0hp/+X8+xj2fOELHyBHIS2TTEnWzitUOWdvUkWWJqcEssiSzWqrzyqst/l8/9wvcl/W4IK2ylahjRDX2Hxkl9iOGz2MjeaKGRq3RQZFFWqbDxEiOkaG372LzdgxPFPjkF+7m/MkFPNdnYnc/0weGmD29uF0EkjLYefsEkvzm/NE3oqoyvQPvPPf1RwnDkHMvznLqqUu4jsfOw6Mc+9A+ZOWtj9vlFvgxLQEvLy+TSLz+uXKj6N+7odls8qu/+qv8x//4H8nlcm8/oMuPna4A7NIFcPwKprtGRB5AFqMoYpKWe5WOt/ZjEYAAH+k/SMPt8L21s2iiwkhsu3vHXGuLVbN6TQCKosAnDuxmV18B21LIKCcpNy1W7Ao9momuWthODyYxsoZMfmyJE6cnKDfMtxWAAGk1xm3ZY6yZzxNXeqg6TSpWiOl59Komq+0YYSjSsgxy0RbrYUjHFlD1BstbAbFcDU1MsjOaZlIvUKqaDGv7QHyZMNy2eumPTZE2FqlbKmYzjirIBGKIE/eoRQL80EdSBOS2hBJKaJKEqYjUlO1+ugCKJPGxY7s4MNrHn375eULPx4sJnF/cxHZcZhY2cVoO6d4E0ahGPKYzt1CiVG7y4Qf3MjKcpd6wSCZ0piZ7+f63zlD2BRbPLtOzq0TfsU32x8HrZJk5O8nmpki1YXJxboN0zKAnlyAQPQ5/aIDS+hpWqc747u3+v2dPLnD5D79HdigCO2Pow2UELYLmHmQ0s4NOq4jnhcgSGJqC43l4XoCh6xw+OvGW5+f2g6OsbtR4+oUZ2qbN7sEsf/+X7yHwAi6fX0VWJIbHcihvYdfyVoxO9TI6dX2Eb+ftbz2nd0IYhlQ26jiWQ7oniW7cXChceXWJ7/zZcwR+gKxIPPnVkwDc/dGD73keXX68JBKJ6wTgzcjlckiSxObm5nWvb25u0tv75ojy7OwsCwsLPPLII9deC4Lte1+WZS5fvszExHu/LrvcnK4A7NIFkAQdUVDwAhNZjBKENgIiknjr7bhuRlaL8/fG76VoNbA8h9FYAS/0gRBduv5WFEWB6d48tnOMU6e+g8854pqN5FlULJ2WF8cXfXwiuLQx9IDYLZjxjsQfxA1a1J15opLAYPQuXq1WyarLaGKAZatosk3gSmytJTlZHWfn9BxaegNZN2m4Fpns12nVp+mPHyevH2KxWiDwp9GNc4ShQ1rXObGWodzJEAoBgeyDAKoDngS25KP5IoIVIqkCHdtF1SQmhl6PBgiCQBCF1JE4p88tozUFRtIJ2m0bLA+/5TN3dRNZEOgbyiCIoGsKkiSye9frwr201eDsmWV27B9G1FeJ7b6AA9Q9hVTPFrtlifoPpjBNDwmBB4/vROnd5L8u/H8x/QatCQ+tOIQoCtTKLdZLLfSoRv/gIM+UJuis9TMyUqDu+sjlZZobHTbLTSYHc3hhyOHJASLaW7ch/CGaKvPzHz/CB++eJghCsukoJ0/M88d/9ATNRoeUobF3/xAf//nb0fW/fQPm0laDl567SqNm0juQ5tg9k0R+5FoLgoCn/uolTj5+Dtd2yQ9m+dhv3E/v6I2LqBYurmF3HEZ3bncT2Vwuc+mVha4A/ClGVVWOHDnC448/zqc+9Slg+7p4/PHH+eIXv/im7Xfu3MnZs2eve+2f//N/TrPZ5N//+3//pqXnLj9+ugKwSxdAEZPkI/ewYX6PljMDCCS1fcSVqR/rcQxZ5yP9B/nG6ivMtTYJCZmI9bInef2H3Wq1wdWtMusbNS68fJDDO3M00vNcVUrE9ArZ5AbNdhohKNKyChzesY+Rnne+JKdJSXalf5mOV0IQRHQxy0hslceWOmTkCwRiExWFhdkxrGaGmY0Ua36B246+itAR2GonMKIh2cw59o4e5RtnLjFbrCAKKrq6n4f39XKsJ813Zk4gKhV8xycgQHUlBCAt6FT9Dq4SIJnghi5RT+FTd+5jcvh10TDfqPCfLr7MltfCm5AQAonDQh9rL16md59CpRLl7OkOV65u4oUhe/cMMv0j+Wt+EHDywjKz5RqpbJTUqI2cE2mvJfBEn82mjxLdQkqPM53N8Zufu4ueMZE/X/q/aHtVVNHATbZwDl3kwl8HrJ+xqNsBBAEzlRJ+AuItDdWRqNYaRFWFA2P9XFzeYmGtwkN37uLjd+y+luP5ThBF4Zrty7mLq/zHP3mKet0kYmi4Irx6eonRHT3cdufrnpiW5TK/VMJ1fQb6U2TTsXd8vJvRbHT46l+8xMpiGT2icOn8KrVKm0/8/O3XCkkArrwyz3NfP0ksZZDMxFi7usF3//QpfuWfffqG+YGSIhH4wXbEWBDwvOAtDai7vAt+AlXAv/M7v8Ov/dqvcdttt3H06FG+9KUv0W63r1UFf+ELX2BgYIB/+2//Lbqus3fv9Wb+qVQK4E2vd/nboXvHdenCdqSpN/oAEaUX2ysiiVHS2gEk8cbLWI7vIQoCsnjrOUu3ZydIqVHWO1U0UWFvaug6K5irW2X+7IXTlFptGk2LStMhVTyIEAlpCGCaMmOZGr35kHiwj5z+aab699+SwAAQBZmo8rpY2pcZZjz+z3lx+XEurMxitw129+wlvbvBy+eXCBUVXXZp2lE8X8X1FHS1iR1uMVcS2JHPIksia7UGz13p8P9++Hb+xV1JvnbpIpfWN5mzy3iCj+pCXjNwWjayJ6CoInklwo4NgwOpAoIg4DgeS8tlvrF6mVW7zr58L4IgMFsvs+yfI3XoFEImJDuicig5yPqZQR5+YC97DgwyUy4jCAKj2TRRVeH7L13hW6cuczFWpxoWGTcrHLU7VFUFOaoSkT1sS8GJKNx+eILd0/2cqj2F6dVJyHk6TQevKeLrJlvmKoqcJ5uI4noBWysVrDEdXVIQZBEvCDF0lZFUinw8SrHa5iO3TZOK3XqXjDAMOXdpjf/y5Wcp103SUY1YVKfWspC9kNYb+hC3TZuvfP0Vrs5vEQYh2WyMT330EKPvMW9wab7I2nKFkfE8kiTSbHSYubRGtdwim3/dl7C6WcdzfdKFbTuYbF+KymaNTrNDLPXmNo27Do9y6eQ88xdWESURLaJy6N63L2Lq8v7mc5/7HMVikd/7vd9jY2ODgwcP8p3vfOdaYcjS0tIt9aDu8rdLVwB26fIagiBuV/2+RY5zx3P4ztqrXGysIYsi9+SnuTM3eUviSxAEphJ9TCXe3EYM4AeX5qi0OkwWcphxhyeLDS41ZhiXNmEzix4fITWQxqbEdP4L5PTRN+0jDENml0tUGybxqM7kSB7pHXzwRhWDD44/wv1jIZ4fIEsif/HKyzzXvEwTi6ankNXqBK6Oh43jeBStbcuIH3bF0BUZx/dxPJ+DvX0c6OnFD0Ou1Ir8+5ee5tLyBnXfIlGW6NuMkIkbHBrMs1Wu0jEdLMvlr756gjNnV7iSrNHM+YxoSZJJA112SSQuovnQXIuhxR2kwgwHj+1gal8/f/rSKebLVQQExnJpPrF3J8+fX2At3aKTAKsTcNWJM2ymKfSUCRQfSdJZr4+Qn4ihZlQEQUAWVAQkWu0mjQ0LNBckCDshYzv7SPakuHR5E3vTRBuKIPVFaCsBISGUPWYaJVzXo7+QInGDfsHvhBdfmefbT5xjea2KHfhs1U1UVcb3fAJFJpV5XVidPrfMlasbDA1mkCWJxeUyTzx9iV//pbvf1bFvxs0u82jCQBQEOi0LPapRL7fI9qXRoze+mQbGC3z6t+7n4sl5PM9nbGc/UwdHfqxz7fKT4Ytf/OINl3wBnnzyybcc+1/+y3/58U+oy03pCsAuXW6B722c5dniFdJaFNOz+cbqKWKyzv70zVtn3SpN2yGiygiCQNTQGO7LoIU+hCGZVJTJsV4UBTquyky9ygubHVRR4nB+gJweJQxDfnDiKk+8PIPjekiiyNF9I3zs3j3vSATCtkhVZIlXKvM8Z12CXpfAdDhT6+fe3ib7B5bRpJCm2UOplSOmqyyWqxiqwtxamZgp8MeLP2Dnzj7uvW8nmqawO9PD79/zYb7+whnOnVultrVONFZBiTk8NdOhLx4nnjF49vkZvvvoOQhDsHwassXJuWV2Tvbhhm3yUQEjkmdLbBO0I6QKPkePDPL07AKzxQoT+SwhIVe3yjw1M0/JN6mqFkl0fBF8X+FUc5peZQ0pCEjrA5RcA1OvEorbdiuj0Z1k1VFmG2dxUz6CJBKu5/AWYqxXi/SPFuhN6YxEU9z5iTtYDNpUmib+ok11pcmF0CSiKdx9cJzYWxRD3AzPD3j+5ByaIjM8kGF5tUKzabFZaaErMgcPj7L30OuCqdWyEUUB9bVl1ERcp1Y38V+rgt5YKrOxXEZRZSb2DqK/w3zRodE8fQNpluaL6LpKp+Nw4LbR68QnwM6jE8yeWeTii1fxPZ9kLs79v3DnWy7rDowXGBi/eXeILu8NIdz+eS/ju/xs0xWAXbq8Q8Iw5HJjnaQaIadtL39dbW6wZJauE4Cu62PZLkZEfVf+aJOFLLNbZcotkyAM0Q2VTx+6lyChUfGXcYUabdfEdrP8xdI8HS8kJORkcYXf2n0MOiHPnppDV2UGe1I02xYnzi2xd0cf44O3Zrfw2NJ5FjeqJLwo6UiMYmDjBDHC0MDxDOzAI5U+z91jv8L3Ly+yvlVHKrr0iDHswOWZp68QAh/+8LafYn8swT944G62Ds1wevZlViuXsV2Bra0BLGmEZ1a+wczlDu22RW9PCsP26Sy6OKJLVFY5lhuhIzxPhQ3kIQNDUihoPeTTvZQurWOoyrVIZERV6Pg+hVyMk5V1EoKK63i4voff9uiESXTPoJ2I4uMjaTDRt932zxCTuAu3MVcsI0TamO0oxeUBCnttEisBawtFhKTO6L1T6JrOJ4eHefHMAovSJvuP9OB5AY2WxXqpcS3P7WaEr/V/e+M2vh/g+wGqIjMxlicIQ5ZWKvTmEnzsg3v58IN7kKTX0w9y2RgIArXXooTVusmBvUNIksjl04t8+789R7PWRhQEJvYN8cnfuI/ITaJzbySRjPCpzx3jxWdnaNRM+gbS3HF86k3XtaopfPy3HmD/PTuxOg6FoSz5gZu3UOzSpctPnq4A7NLlFjAklaqz3fc0CAP8MEQTX6/uvDSzzmNPXsQ0HXLZKB/50H763kGbrDAMado2fhjygZ3jtB2H86ubCILAh3fv4O7JSeywhyuN52l6ZeJSnm/Mu4iCwM50Cj8IuFIvcbq0xpScw3Y8enLbIjVmaGxVmpgd55b/3krTxHMDCjEdBAFZ8ZAlj83KKKIoIksOmWyDnQM6h4aP873HzvHclSuMTfxQaApcvrjOAw/suU40WOJ30JNFgloP+ZzP0PgltjpFVu1ZlFEoTPXjV+JIkkhsU2Q6XeCfH/kgT5W+w3w7jyGJ+GGHlmdidcaprNdpdGyatkPb3v47TcdlIJXg4T07uPREiblqBc/18NQApSMRkSRivkc+ouNoHiPJLAf6tiuHNyoNTs02WetMEZRMfCego4TUh3V++zN3IcUjPDmzzAurm7ywuslALokuSliuRzKqIwgCYRDiuD5BGCLdQAD6fsDLp+Y5dXaZMISDewc5dmQcSRLRVJmpiR5ePDmPHwQk4hH27xnkc5+4jekdb7bUOLBnkK1ig1fPrWB2HKYmenjw3l34fsBTX38Fy7QZne7DdTxmzixz4cQcR+57Z/218z0JPv6ZI2+7naLKTBzoLuN26fLTQlcAdunyDmi6HZzA5678FF9bOclMY4OQkEEjw8H09kNvc6vBN77zKmbHIZmIML9Y4uvfPs2vff4utLewAHF9n29cvszLKysEYciuQoHP7N/Nx/bvRBAEDHV7rEKGw5mPAWD7Hn/lP4YubUePJFFEANzAJ5swyKQMVjfrFLJxqg2TZCxCPnPrVaETWg+vCsvUMbdbpIUKUTTiUQ1JUinEDZTA5cyZNZKGhypLBGFIEISIooDresRj2nUVo0HYwfG3CPwUfuAgqB6CbCF4OkGnl0S8Tv+edRaeHKRpBoiyiDEY4/947BkqxhliRoQ9+dsRBIvZygLlEkj1JertDvVah621OvGoxl27x/jg9DgxXeP/eeQe/j/f+h5Bp0OiqZMoycg9GlaujSJ5TPX08YnBI0Tl7ahYEIR4YYCiySR6M3RaFoLnku9Lsfv4FF95/Ay+ABP9WdbLDR5/ZYaotr1E2r7kMl5IU2/Z7BjIcuLUItlMlInR/HVRvtPnlvnu9y+gvGZ+/OgTFxBFgZ0TvSiKzIPHdyGJIjPzW6SSBvcc3XFD8QcgyxIPP7CXo0fG8NyATDqKokhYpk2nZRNPGttdRTQFAbDat/5loMtPGT+BKuAuP110BWCXLm9BEAY8sXmB54szeGHAcDTLJwYOU3NNZEFkV3KAvL5tkrpZbFBvdBgbyW0/bBWZrVKTSs18yyjg88vLPDY7S0bXUSWJ55eWiKoqP7dnz03HaJLMrnSBH6zPEQIdzyWqqIzE00QNjU9+YD9f/8E5ak2TuKHx0N276HkHJtE/ymd2HuHqcomZxhqSIBFxJhgbiJIuVBAJKVeaXD1boHJlHkFcZHw0T6GQYG5+C1EQ0TWZo8cmrhM+oqDTMlWq7Q0aVgShWaJHD7Eclb5cgkTUwLU3KMYk6rZPmJZ5an2ZVCfCyK4oRZa4uKlRSBjUrJCeSA9uU2F+eYO257InkkFuCwyN60S17Vw31RKZrqXILzgEfrhdqDBvMVRM8bFjxzg0OUlSNa7NsScTZ2dPgdmlGhXJQYiI6GqEQzuGSOk6puUSj2j4fsD8RgXfDxjuSREGIQvrFUzHJabIzM5sMnNlk5iu8KF7d3P3sddtW67MbiIIXLs25haK/NVXTtBjbHcSOXLHBB/54F4+wnbxxdsVGgmC8CbrFy2i0jOU4fLpRWRVwmo7yIpEri91y9dCly5dfrboCsAuXd6C87UVHts4R1TSiMka52sryILEr47d86YHsqbKSJKIZbtEdJV2x0FRJDT1rW+zxVoNURCwHJ/VaoW6Y/FkOMund+16y6KNT47tQRAELlY3yelRHhicZFdqO6l+bDDLP/j5u2i2baIRFeNdGgZnEzH+yYc+wunLq5iWQ18uwa4dCUr2KertMqdPbeAUhxkbTWOaDvOLJR56cC92x8FxfIaGM0xPv17t3OzYPHtxnqfO5xkb1Bjpa2J5PlUzRSqTppATsP0mB6dvZ+t0EilmofTqnK0VsesOSn0EMedSdcqotkvQKtDYSnD54iLlZhvRkIlHVdJJnQsz8xw/PkHMiGJEVPSIRmE0z+bsFqVyE1EUOXrXHo4f3Pum1meaIvMbD9yG8ozIM2tLCJLAkbFBfu3wIWKaxlAhxamZVVzPp9G20DWFmKHRk46DKHBwfIDHnrlEI3QRRAGpKcCzl9izs59UcltoKoqE5/nXcgDXViqEls/I7gS27fGDxy6QycbYvf96j8ggCLhycp7iaoVITGf3sR0Y8RvbzAiCwId+4Q58L2B9sYSiyhx/5CCTB7omu126/F2nKwC7dHkLNqw6XuCTj25Hz9zAZ8Ws4AQemnT9su74aJ49O/s5e3ENwhBZEjl+1xTplHGjXV8joaoUmy2aTRuApu+wWKzy7Mwi906P3XRcTNH4pclDuIGPJIiIPyJIdVVBV99Z94m3Ip0wuP/2yeteG1I+gGo2aK4+RTq9/fdFIgqBHxCJqNxx7M0tnFqWzZ/+4CSvzK2ysCmxWL6TfUOQMRJstCscva2DKECfcYge4T4U9RVGBg3Kgo0kiQRugGPJOJs7WGvF8BNJFtYsWuUNZAH8iIjhipS3VoncU0aKt3mqvM5+7mNseJqDe4c4dXaJxEiOqOuxe6KH2x7cTxDCG+Wf523n7aXjBv/rR+7hfwlDHN9HlaRrov/jd+zC83xm18toikxUV0nHIpQbbTRFotrqsNpukUpEUCWJqmkxU6lgdpxrAvDQ3iHmForMLhQJghDX9pjoyxBPRIgD81e3KG423vQ+vvDNU/zgKy/iOh4gcPnkHJ/94sM3tVzJFBL8wj/+EI1qG1WTiSXf+nrs0qXL3w26ArBLl7fAkFXCEJzAQxEkmp5Fj55EuYEBtKJIfPJjh5ic6KFtOmTSUaZ39L7t0t2dw8P81ZkLLHt1oqpGTjMoyFHOLK9fJwBvVC0KvGkuju9TMTtoskRK3/agWzbLVJw2cVlnLJZHFN55dXIYhlxdKbFZaaKrMjtG8lysFamZHdyMwPp6jZ58knqjQzSqkX+DQfDSepUzM2u4no8l+FxeKxJTVVRRotFWeHVBZW9/D56dZW/sGL0Zg2rbZaveQoxIFEst8j1xYshsYbJutqhYFgklQU7roSRvUvZapKMGWllAbXqIR2awIzZDySEcmpyuPsrd+RQff3AfOyd6WN+q88qrS6yWW/zpX77A5HgPn3r4ILqu8PyJWV46vYDvB+zc0cuD9+5C1xQ0+fqPynTc4AsP3UajbbG4VeXRl6+wVm6gKTIfODBBs2UhSiKhE4AmghsQGKDpr+9nYqzAL3zyNi5f3SQMQs5KCm7bIQxDPG+7J6oeuV7At+smL3/vDHpUZ3AyjWO7zJ1ZYub0AvvuvrmRsqxIZAq3ngLQ5acXgfdoA/Njm0mX9ytdAdily1twIDXC+doqM83too+UYvChvr03FVCqInNw3615AhZiMT4wOIrX8elLxcnqBqV6G/k1mw/f83nh+xc5d2IeQRA4eOcER45P39BiZqvV4s9Pn2OpVkORJO4ZGyGeDnhs4xym76CJMnfnp3i4/8A7Nq9+8fwi33ruIrbj4eHTyHmIaQlRFPH6fBKCQLO2Lf7uv28n/a/lly1tVPnv3zlJqd5GEgWKdofVThNdlrEcF6vtYVouG1qTQxMDKKLM+ZUyXz11kWq7Q6AESJEAsdhiUkly29gg+f4ET19ZYLKQxdBUdvcVKK3XGfYjNCWZLW0LKdMhdJLYdZGFsoWaLTGhrpDO97FzRy8XLq+xtl5FlyR8P+ClE3MM9KZIJQ0efeoiuiojyxLPnZhDUSQe+sCNczElUSQdN0jHDcZ6s5TrbQxdpScd48SVFfp6EpiNbbNsRZfZOd5D4kc6gowO5xgd3q6YHutP862/foXFueL27zsK7D14/bXk2h6u4xFNvLaM/Fp6wXY0sEuXLl3eOV0B2KXLWxBTdH5l7G4uN9ZxAo9BI8OA8eP3N7tncpT5YpWaabFhNjE0hWPj23laJ5+5wpPffJWIoRAG8PjXTqFqCgff0AcWtiN1f3X2Ahe2thhMJum4Lt+4cgGl0CIXNdhh9FBz2jxbvMLO5ABjsfyNpnIdHdvlyVeuIkkCE4NZFjo1LtU2OJwYYDSXYdNsEcQCfmHnUfqScSJvMBg+P7tBqdZmcni7KGb90gKNloUUixARJazQQxEEVFnk8soWs5tlKoFFPKoxlk9TbXdoKBYP7t7FVF+OnnyCUsvkykYJ03ExNBVJFenpSVJaNGnUbXKpGOl4nKbZZmkNUnGZRqnJifUFph45giSJXJ3dorhWhyAABBw/4Pz5FYbHcvh+QE9+O1Lm+T7nLq4ymk8hyyJDoznUm1RzJ6M6yTd0/Ng31sfd+8c5M7eG6wVkEgafuWcfivzmyHEYhpiOy9hUD5/7tbtZW6miqhI7pvswfmRZN56J0j/ew5VX5vF6U7TqJrGUQe/Irfk7/jiwHJdqs0NEVUjG9GtfKKyOg2O5ROP6m3Iru3Tp8v6hKwC7dHkbDFnjUGb0b/UYkz05fvWuQ5xZ3sAPA3b3FdgzsN0/c+bcKqoqUehPA7A8V2Tu8vqbBKDleazUG+RjUWKaSkxTWStVMB2LHeltsZdUDEp2i7ZnvaN52Y6H427nvy3MFlly63QiLoG7vUQZU1QqnokeU64Tf7DtcyeJwjVhoEsykVCi07BxfR81AMu2cTIeI6NZVit15jbL3D45hCSK5OJRqmYHI6mRy8ZxPJ+N2RLCmsX5VpVYQieVivLA4Wk2ImWKlSaDvWkajQCU0yj5JqgKlAucu2BzcmKJoVyKq+dX2So2SMV1EqkoZq1NebPB2ESBrXITy/bQNYlW28KuWfzFfBVBFJja1c8j///27ju6jus+8Ph3Zl7veHjovREgwd5JFapQoorV3GRHkWU561guib1KtJGzseWsj6N4i60c2xunuGVtSy6x5C5ZoqxKUuy9g+i9PLxeZ2b/gAQJYq9g+X3OeTwHD3dm7sVwHn645Xc/sATnKezs4bBZ+NB181nYWEEml6cs6KMidPRK8EgqzTNb93JkeBSrpnF9SwOtTcUkY2lMwziqvGbRuPWBVVisGv3tQxSWFXDte5dQXl9ySvfzXOkdjvD0KzsZDMexWzWunlvPtfPq2bn+MK//fgfZdI7iigLWfGiFrDieLpIGRpyEBIBCXCSaSkI0lRzdk2NzWMll314tms/p2I6xuMNuseCx2+iPxgg6nWR1HYthxWl10Z8ap8ThZywTx2txUGg/tZyAHpedkqCHP647QDSdJuLMkyrMsbuvj6LicRL6MNX+Qnw2FcM0pyxEaagKsWVvF10D4YndOUxwmRrWnInP5yGczhBJpCGtY7NolAd97BwcZGA8TpHfQzgxMY/x0OAoz+4+xPBwlPChMdyjOjYMdFeeZbc08N6lc/hVcjcD4RhjY3FGhgP0pqsIBHXQrfT0u1GVKOkXt0EkSy6ewYJCJJ4mlc1TFPQQcNnpGwgTiaUYGo1hmkBep8TtxFbpxK5o7NvdQ3V9EcuvOf5cuyn3w2phTt3R+z3nsnk69veRTmZ4NTzIvrExQm4XiXSG7z23nrLuLJ6EgT/oYc2HVlA3q2LK8QUlfj7wudvIpLJY7dbT3m3GNE3yOX1y+Ph05fM6v3xtN52DYSpCfuKpDM9vOgDxLFv+cytg4vY5ObK3l+eeWs+H/uJm6QkU4iIkAaAQF7kFKxrpaR+m/cAAAIFCD3OWHr06WFUU3jOzmSe37+TQyCiqorCgrJzlTaU8P7iT4XQUl8XGmrJ5lDkLTnjNSDw1kfollaXA5iCTzxHxGCiKRjCvEfS2o6kj1PrsBO19/GB3P8Oji6gNFHNHazOFLhcttcXcdf1cNu7uJKYOsWRRhn2Hhunv0shGbZS4XShZg1h6YuFDOpOjxu/H6bTTMRLGabVSGwqyqaMHh9VCd/8YPZkIflWlKmknOZrk8LoubGsWs7Slij+u3UPbUIS8bpBMujH7LCTdCilDx2M1MfMGhwdHKXEouMcNsGgTizTCadp3djK4XSdU6CFYV0xWN9i+r5tBI0usfxiHxUIwrxKPps7qXmbTOX75vZfZ+fohskaeg1UaLqedSDJLLqczqOdw2HzUloUY6hnlDz/ZwJ/+9W2435XmRVEUHGewx/Chbe288ouNJKMpyhtLufFDKwkUnd7ikHgqy8h4nJICD067FafdSlvvKB2dw6QSGWpb3g56B3vGiEWSBAq9JzijEGI6SAAoxEWusbWC9370Go7s70NRFBpbK6isO/b8vdmlJXxqxTK6IxHsmoWW4hBOq5VGfwmRXBKvxTEl4fGxxJMZnnxuK0e6R1BVhXQyR8ZiUOh0UORwoWkpCgND+BU/swItbOnrxOAIqqWMV9sS9A+F+fPlSygs9DK/uYKyGnhpaDdJPUG5bqC4RrH3unAOVeJ2ghlw0tY3it1m4T0LZ7J0VjVjiRReh43XD3dxYGgEDBhOJskoJmGvSYFNwZpRGBiMkEhk6DsyQjANtTMq6Q7H2Nc9TEY1yWqgmgoZPU9fvB1b3TDJrEHK4yI+5MSiqwSyJsHiIAOROCPdY6gG2Ivc5DVQ8iZ+q5XxVIaenIHHf+x8e6dqx+sHWfvzjeg5HUVTCKsqw1aFmqCPdDpHKptG0zyYhkEmlWPflnbeeH43q+5ceNa9aAMdw/z2O38kFUvh9rvY/dp+cpkcH/jcbZPnHhuM0LW/F0VRqJlVQSB0dHDodFhxOWyMx1N4nHZS2RyqCj6vE0VVyKRz2B1WErE0dqcNh/PMclCKsyRDwOIkJAAU4hJQ01RCTdOx53mlszle2dLGke4R3E4bK+fXs7x6aqJfr9WB1+o45vHvdrBriPbeUerKg1gsGoOjMfaMD5FP5UjpGRQtQZlNwWH1EMlkSGQMQj4rycEUkUM6L+uDsGmMu+9eysz51XQnjxDPRyl3VFNcCcnsXtqNXgaiNir9flZVlOIPuJnVWkFtaSGqqlDsmxiidtomVgz3DY+jWbSJ1BZ5k8F8mhK7RqDATS6Xp6cvTDanowMjqTS6ppA1DXJ5BUVVCVakcDb3YFpymDYFx6wU4QPFxIYdlGCjsihIRyJNVzZFrHMYxiKoFrAZJoO9YVSHhcKyAPUzy8/mNrJj3SFi4QQllUFQFJztI0Tq3cScKrrVirM9gT48zt62KMN9YTSLxiu/2oKmqay66+T78Z5I35FBomNxamdVoCgKVruF3sMDxMYSBIp99LcP8ctvP89wzxgoCiU1RdzzqZsoqpi66MlutXDz0mZ++epujvSNoqoq8xoruGnpTPI9UQ7t7MI0TBxuG1fdOu+MeirF2VM4u1Qukgbm8icBoBCXMNM0eX79AV7fdgSXw0o6m6dvOMqfvmcxFcWBMzrnWzno3ppb5nJYqSsqZFxPkckZ2J0+7NZiAt4UJnHs9nGyGQftB7LkDA23y0Z2JMMLz2yhrCoIytu/TJK5LH1mgpTHYCiYpC8Vp3dnmBWpAnyGSl1Z4ZS6LKqp4I22bg71j2BxWXBmLThjJoam4Aw4mbeghudf2MPGLe10D0U4GIuhuiwErFbSmMRyWVSngrMyAhaD1LgLw6PgdicJhRJEB5z0u/OM5jNYYjmcORNHwI7N6aAvHCWtKtg1hUzWoCzgIniMJMqmaXJgyxG6jgzQQ5rCpmJqy0LMKSk9Kjl3LpPDYrWQy+pYbRqu0Sy2PMxuqMZiVegfDZPKpuiwmmi1XkqLC7A7nex47QCLb5h11FDwW3TdYLg3jJ7XCZUFsB+j18365j7Ab83/y6RyaBYNi22i92/jczsZ7g1TPbMCTOjY18PmF3Zx6wOrjjrX3IZyQn73m7khrTRWhrBaNO782LUc2tFFOpmlqDxATfPRcyCFEBcHCQCFuIRlsnn2tPUT8Dkp9LsxTZO27lGO9IyecQBYVVpAgddFZ38Yj8tGOJbi6uZa6puL2dndj6qozK1diN29hSMDh8lFHezsrKBn3ILXp1Greaku9dLfNUZkLEFFZS2H43sZzPTSE4mRMFPkkmXYYgq4NUZLc+jDGltfP8TcJfUEgu6Jtul5NJvCn6ycRySWZiyepChUzMhAlEw2z+q5LRQV+lj7x73UNRThtFvZdKQXM6nTUlNMQbGXLXt78LscFHjGiRLDCmQxUU0FVIPyiiCj+SwdhwaJhxOUeZ20zq5lpG+M8VgOR6UPu92CPZ6hIJzGcoxh2M3P7+QPT77OLn+GQY+J/YiDsuoibm5q4t5Fc1HfsZ3fjHnV7N/aQS6bJ5vJ4fa58Hsd2PaPYQJz5lTT5bHQ3T2E3+skbFVI51O0qA6M/NGrggEyqSzPfPcVtq8/hGmYNMwq531/fsNRiZ8b5lZT21rFkV1dqKqCZtW45u4leAJuDMNk18gwh0IKw3qMKs2B3WknHk4c9/9JechP+btWNjucNuYsbzzOEeKCkiFgcRISAApxCVOUiTQruj4RHJhv/vvunqfTURby8b4b57F200FiiTRLZlVz84oW/B4nVzfVTpZ7/gXYt8FBzrRgpmK4x+M0YGdOyM/4UAyn247b5yDkLOHq0M0TQWCkneGwghotBuJYDZW8ZmJxW8iN6QyMRBiIJ4iaKV4aO8JQOo5Ds3DtkhqOHBwjnEjT2FjCDbMbuGZmHb/93XYsmorLZad+RgkJVadrPIanxIuuQFVFAW7VQmYsiLV8BHeZQszIkFcU9Hwhjvogy1xerp4TZP2LB0ilc9icNqKRNL6MSX3IQ9QD6bE8ecvRAVgum+eN53YQ86kkK1wUZgxGu+N0JXT+X884jiGdu25diKpO3I+lq2cz0D3GoV1d6HmDulkVLLt+JuHBCKqqUNhYwndf3EpROAYZHc2AkUwWV2sZ7uPMP3zltzt47uktoCgoCgz9cT92l42PPHzblHIur5P3fmYNu9cfJJ3IEKoIMnPpxJZ9G9q7OODIMUSWsXScHjNBjZHnmoYLm17mnfrahxkbiuLyOqhpLjvt1c5CiBOTAFCIS5jdZmHRzCqeW7ef9r5RUtk85SEfdZWFJz/4BJqqi2isCpHIZXm+5xD/9+B6vFY7N1Y2MbOgmGQyw66dvXicAQoLPdQZRWx9ox37UJ6e8WGcbhvX3DqXUMlED1Glq45KVx1uo5uX2/5A1MyQ1UwyRo4i3UGmJ4FW5uOn63cTSaU46BzBVqCxoKKCSDbNG5EuHrhqMQHVidtuw+9ysLt9gN54gpFUilAyg81qwaVYWD6zmkDpxKrTO1bNpiIUIJPJsLZ7HYdj+9DIE0kGaCivpyFUyD0zZ1Hh8zFzbg2/e2YL4ZE4wRIfWUuWrdo4KR1Mj4FRo9E2NkZD8O05cXpOn1jQ4bCgkycRzZIzTAIWK7oGGzYepqW2lJmtE6lcvAVu3vfJG+lvH8Y0Tcpqi3C+I9nzaDSB02OndlYF491hIuMJrHYNu9NOf+cIFXXFR92rHW+0kc3kKauaWNk91B9h9+aOY95Xt9/FslvmH/X+pvYeiiuCBEwLY4PjjKk6vgUVLLlp7hn9/zlb2149wIu/2EQqnsFi05h/dTM3fXCZBIGnQ3oAxUlIACjEJW7Z3Fpe23mE3tEIVqtKOq/zxp5O7rp2zmTPE4BpGoxn28noUeyan4CtDhMYTSdRFCi0u47aHu5XnXt5pe8IXqudnniEvkSUh1qXE1ScmKY5uV2dqqgUlvhYtriOuuoQ/qAbd6GLPe0D5PI69eWF+NwOFhZX8KezF/LbI/sJOxIYY1kWjQaobSqi057HyOsoXo2+dAz6wWHYmFddRnt8jIieZk5RGYZh8pv1e1i3p5NcLs+olmdrRz9VLjfV1YXcfedCiop89I5E+PUbe3luxyEKPE5uXXINd7lWk83pBL0uVE3BpmkoisLgcJS1Gw4RVk1c1QHuunYWP9+1nY62DqryGqGyAhIFVl7v6pwSANpdNmpbq+h9bTeK08KomcPu0Mi6VErsLmxZCI/Gp/xMHU4b1c1lDPWMMTowTqi8YHKlbIHHxczqEjbu78Ja5CYWjWPLmrRv6uAHh4d570euoWXu1O3hlDfvsaGbKKqCYRho1tP7aDfNif2CaxfWkkllOTIapnVWIzbHsXc+OZ9i4QSv/mYbiqJQ21JGPJJk+2sHmDGvmvp35UQUQpw5CQDFFatjJMyhwRFUVWVWWTFlgUszV1nXwBjpXJ6V8+qwWTUi8RQ7D/dx1bw6igsm2mSaJu2x5+lJrEM3c2iKnRLnStYN+NkbHkJBYX6onPfVz8GuTXwsJPM5do8OEHK4CTkm5hfuHx/mUGSEGyoamdFUyubN7aTTOdLpLMGgh0XLGigp8dMxMMa//PwVdh3uI68blPo9/Nnty1k2u4YPzZjPVeW1jETjHNjZz7gzie60kBgZw+N3cGhsGMWpkCVP93gExQoBnwOPxcbYcJRfPr2ZPxxox+920DyznKICD4MjMW66ajYLZlbhctlJpLP8/NWddA2PU+h10TEY5uev7uLjty2jyD81CXYyleWZ32+nu3eMgM/FwFCU517ei6PZQ5O9igqXB4vNQmdknEQ2N+VYRVG45n3LaBuO0N83QNilovlslDk9zDL8ZJUkbs/UVbDZdI7nnlrP/q0d6LpBWU0Rt99/FaGyAKqqcOfKVgq8Tn7/262E8gqVZSF6Y0kOjYzS+9QrfMZ7Ez7NwvBgFJfbxvyrmji4u5ex4RgAVpuVxde1nNb/ocW1FfxiW4TO0XF0wyDgdTG7YnqGf5PxNOlUdnIOo8fvYmQgQjJ2arvXCCFOjQSA4oq0r3+IJ9/YwXgihQFs8HfxkZULqAoGprtqp03XTUzDnNhtA7BaNIxkFl1/ewwnluulN/kGNs2LQwuQyo+yeeQ5to60UmivwMTklf4jhBxubq6aAYCmKKiKQt545/xC0BQVRVFYfdNsXG47He3DeDwOlq9opKTEj24YPPP6bnYd7gMTPA4bfeEYP35+CxVFfipLApQ7fLz6h4PsPdiPx21jvDfNQDaBmkuSMwwKVTcj9jiGTac3HuGa2jrqHUGe+e5r7DnYS5ocZiLHwXwvLQuqsNosFBX7cb2ZcmRoPE7/WJSaogA2qwW/20H7wBj7Owbp7RxjeCRGSZGPVStmEE+k6R+MUFlegM1qIeB30tkzRnHIz6GDXRxO5rHarfirgzS3zJzyszcMk5c2HWbEotHQUI1/LE4snKQypZK3pWmdW83M2ZVTjtm5/hDbXz9IUXkBNpuFroP9vPTLLbz/oRsBiIeTNHp8tNrc9FrTdEYT5A0Tp2Yhnsry/Z+vwxfVMTI6qqowc04Vt314GdvWHWakN4xFU+je08Orv9nKylvmnVL+wBUN1Wiqys6eASyqytK6SmaWnXyv6PPBF/QQKPQw1DNGcUWQyFgczaKiaurE9oIyDHxKFHPidTbHi8ubBIDiivTqwQ5i6czk1msHB0fY1N5zSQaAlSUBSoJe2vvH8DptROJpZtaVEAq4J8vkjAR5I43HUgqAXfOTyB3BazUJ2CcWF4xn0nTGwpPHaKpKudvHK31H6E9GsakaNb4grcGJniGn08aNN7YCcKR3lA07Ovjda3vI+RQ2DvUSsWYpt3pwWqxk8jqxZIahcIzKkgDDYzHau0coL/XjctooKvSSPJwjapgkM1kKcLCooIq8zcBjtXFf4yJGu8P0doxQX11EeGyE8XSWobEYWucw1RWFFAXe7tmzWTQsmkYqm8dmtZDO5gF4ed1BomNJvG473f1hxiIJbljZjEVTyWQmymayeUzDIP5KJ8XZDOMlNrKxNL6948y5cWpOvLHxBPsPDVAc8uLzOCgvDXCobYjlixqY1VRKdV0RVuvbAZiuGxze20s8nqHUomFzWPEF3Qz1jGEYBtvXt/Hy73eSjKdJRFOMJpKMezX86sQ5KksDHOwYpsXnY0ZDCclEhn27unnffStwWjVe/+12gsVeTNPklV9txe11snDV1KD1WDRVZUVDNSsaqk9a9nxzuu2s+dAKnntqPSMD44wORLA7rfz+R6+zf2sHaz60HLfv7BJyCyEkABRXqGQmi8NimZzzZtU0Urn8NNfqzAR9Lj6wej5rNx1kNJJkRnUxNy1rxvqOnh+npRC75ieW68NpKSSZH8am+olmrYQcJoZpktZzk8Fg3jB46tB29oQHMTCJZNMsKarkYy1LKHJOHUI92DXMv//sdQ63DzHiyBALGKh2lZzDIGMa1OS8GKaB3WLB5ZiY66YqCgoKhjHRzWCYJgVOJ3ddNYOXeroYiMWwKVa8WLhzZgsWRSGn66CY9HaOMD4aYcyqY6pQljO555rZFLwjR15Z0MeChnKeXb+P0aEosWgKp6nQg4WlixoIBNwUBPJ094YxTZg9s4ItOzoZHp0YRq0q8jF8oI9raspRVQuG06Rnfx/j/WGKSgOT1zFNE/Mdq65VBex2CzV1IRpmlE75OeVzOn/4xWa2rG+jrztMPJGlaWbZRI/f3CrGhmO88vudmKZJVV0Rw4MR4j15LIqBYVWpbSoFpxXFNAn4J4J7l9uOoRukUjkGOofxBpwUvlm/VCJD18GBUwoALzY1zWXc/9e388qvt/L673dQUhlE01R2v3EYj9/Jzfcun+4qCnHJkwBQXJFayopoHwkzFI2jmxNBSH1R8CRHXbyqSgr46HuWYZrmUQs5AFyWEE2+22mLPUdaD+PQClhafA3d8XEORoZRUKj1Brm2bGKP4f3jQ2wc7qbM5aXJH6I/GSWenwia323T7g46ukexWVQo1rDkTGwJBY/HTtjI0JOKUW3zct2CBhqrJoYVQ4VemhtL2La7G3vEQjqTwx1w0Dk0TpnVTXWVn4oiH2V+HyP9UZ5Y9zK6rtObz9B5cBBdVXAYJhaXFWfSRMlOHa9SVYUqixNHX5rUQIyMYpDXIaJmeWNLGzdc24quT/ysLBaV21fPoaq8gEMHB4iNJwk6bQygkIyn8du9ZBJprDYLVvvURRHBgJuGmiJ27u3F7baRTGUpK/ZTXXn0/6VDu3vYvqGN2uZSNFWht3OUXVs6WHJVE6vuXEhsPEkinqayrghVUykq8ZOKZ1h8bT2HhsJk8wZWFWaUFJIYiZOyW4lF0zicNgqLvDjdDjKp3ERQakIuk8fhvnR34XC67WRSOZxuO/7gxB8dyVianrbBaa7ZJcI0J15nc7y4rEkAKK5I17c0kMnr7Ojux6Yo3NBSz9K6ypMfeJE7VvD3liLnbPy2OrJGDLvmxaq6KW5NcDgyigI0B4omewATuSx5Q8dtmeix89scDKcSJHI5Ct4VUyTTOUzDxOqyYpLFgopFUWgtK2ZQSbO8oIJbm5poqS2ZnKdo0VTes3oORYVeBoejRLIZ2obDJPpHUVBQVIUlVRVkozn+uPkwXpcdVVXpz2bQC2wUKFYcNgu6bhAbTzIyGqOx/u0UKcOROD9+YSud6Thxq4lXsaDqBllVYSiRZuf+XvxeJ3NayikvCWC1anhtVvoODBKNpOgxTVIWO7m+COHBCIqqMPeaFqpmTN3ZQtNU7rhpLgGfi57+MAG/i6uXNBDwHb1jSCyawjAM/AUePAudFBT5Sacy3PHgKspqQowMRnB7HIwORiks8dHfOUoyliKUMambU4+nyEvA68Sqmzz3zDbGRmLYHFauvnk2VbUh9Btm0d8xTPu+XjAVisoDzLtqxpn8N7poePxOcuk8el5HURWS8QzVsruIEOeEBIDiimS3WrhrwSxundOMokwMAU+neDrDwcER8rpBTWEBJe9aqXqu2DQ3Nu3tuYFvrfB9tzKXF5/VQXciQoHdSX8iSpUnQKHj6MCmtaGUlzccJBZJoTggZdOx26wkrDpNhYV8cPE8avwBxlIpYvEMBU4nXpuN8HiSqtIA82ZW8LtN+1FGFWpLJ3rOOgfCbD/ch8tiQVMVigo8YILDopFxWnDanHidVkaH4+R1g107u+loG6KkxM/8hTX87KUd9MUT5DHJWSCpmLgV8KgKaU2hqryAFQvrWTK/dnKO3pY3jpBMZqlrnAgk2w8PUdVawcwZxXgL3LQsaTjmggq3y84t17ee9GfvD7qxWDTCw1HyeYPwaIzqxhJKKiby94VK/Ky6bS4v/24nR/b1Mdg9itOmsWXtHtx+J7fdfzV1LRN/pPzpn19HNJLE6bLheXPou25mBe//9E107u9DURQaZldR9Oa5T0bP6wz3hjEMg1BZwbSkfzmWhde20HlwgO62IUwTisoDrFwzPbkJhbjcSAAormi2U1gheb6NJ9P8v3VbaRsaxTChyOvmw8vn0Vh8dsmcz0a1t4D3Nczlt517iWTS1HgL+GDDPJyWowODpbNrGb89yTN/2IEtliIQslFY5aOprJjbZzRT4w/wWlcnvz90kEQuR9DppCbtpnffCOl0Dr/PiRKwYb5jyMlkYnjW7bCRzekYhomigKfAhZHMk05miEWTaJqGzaLReWQYl8vGvr19HOwaojOboKm6iCMHBoilcyQx0EwDzVSpLivgvvcto6p0anCUTeewWrXJXlSLVaOwIsjK9yw8Jz/TptYKFl7VxG+feoPwSAyrzUpBkY/uI0PUvdmrtWBlE1UNxbz0yy1kwjECxX6yuTwDfeO8/rsdNC+oRVEU7A4rRQ7/Udcory2ivPb0Vu+mk1me/dHrHNzegWmYVDWVcttHriEQmv60SIGQlw988kY69vdjGAaVDSVHbXEnjk1WAYuTkQBQiGm2ub2HgwMj1BcHsagqR4bH+MPuQzTeMH0BIMDS4ipaC0pI5LP4bQ7smoXeaJTBeBy3zUZjMIimqlg0ldtWzeamlS1EIinsdgs2lxWrqqEqCp3j4/xq/35QTEo9Hg72D/NGdztX2cuoKgzSPxghm85g8Wgc6RtFURSsFpX5jeWUFng51D3Mkd4RQKG+rphZi5sZODxCKq9TUOyl7cgwNdWFWCwa8Xiars5R8oUWior8zLRasHYM0jUWpdDjoLq0gA/cseSo4A+gsaWMro4RhgYiGIaBoiiTvYHngqqqFJcX4CtwU9NYgr/QzVDvOH/8zQ6qG0sm05uESvx4PU4i0TRj0QwAmXQOZU8f+byO9TSTPJ/Mtlf2sWvdQYorg2gWjcO7unnt11t5z4Orzul1zpTH72L2sobproYQlx0JAIWYZtF0BlVVJoehPQ474UTquAs6LiSXxYqmKFgUlc19vfznnj1EMmmsmsbKqmreP6sVTVVJZnOEE0lcThte99QUHSPJJPFclhmFheiGiakbjJEm5TLRNJXCoJuxcIJrF8+gdyyKYZjMqS9jbkMZiqLwkduXcKBzCMOEhopCyove7vnat6+X9vaRKT+nXDyL02dl/5EBAgE3oeog1149kzWLminwOvG4jr0wYtGyevZs6WDrxiMoisKSqxqZNefczgtNxNPYHVacJW4iho4asBGPpsimc1O2hLM6rSQSWVwuG1a7hVw6R1Y3GO6PUF59bv8wGOkfx2LVJlOreP0uBrpHz+k1hBAXHwkAhZhmZQEvCgqj8SQ2i8Z4IsXyhuppD/7GUil+sXcPHeFxLKrKUDKOw2KhKVhILJthXVcXM0NFKGmTX+7YRzSTwWm1cMPMBq5trpusv9duw6ZpjCaTdEUiHIyOEVfyvBHtAy9Yxwz8PidLWqpZ5bIdVY9QwEMocOw5kZWVQcyQld92HkazqDCcwR9XKVUUbHoWh83J9dfNYvmsGtyOo8/9Trs2tTPcM8aMholev/4jw2zbcJil157erhonUlDoYciaY9toD3kN9GSepcVl2J1Th9arZpRSVFFALpXFNE0qakM4vE7yOf2c1eUtgZCHbDZPLpND1VTi0RQ1M8vP+XXEBSZ7AYuTkABQiGm2pLaSoUiczR09ZHJ55lWXcfu85mmtk2Ga/Gz3brb291HsdtMfi3JwbJTFFZUoioLP7qA7EuHJVzazp32QdCpPsceLv9DJLzbuxpZXmN9QgdNpozFYyLXVNTyzfx+HxsbwOe3U2n2MhONsGuvjOmclN18/C9cxgr+TaRsfJxw0seXtpFM5xl06pSEfTeWlVKWyDA1GqXZ5pgR/6XSOTa8foq8njNfnYOlVTYSKfRw5MIDFolJcHpjY9m5/Py88v4esqjJrVjnB4NkvzCmoLSBRZSc3lMGRUzA9diKlGoOxBGX+t+fclVYW0jy/hsHeMbw+J7FomoraEEWlR8/7O1sLrp1Jz+FBjuzpxTRNyuuKuPr2Bef8OjCRC3H/ji7i0RS+AjfNcypPaacSIcS5JwGgENPMoqncuWAm1zbXkdd1CtyuyXQp0yWaSdMeHqPM6yXgcOC12Tg0NkbneJiQ08lAIsb+6AC5ZJaUT8eCQqInja3PQs4K2fYEO8tLec9t86moKODumbNI5/PkDhygORQi4HDQPxYlmk7zgZWLaSgLnVE99/UPkTcMGiqKyGVy7Ez1ErVN9JLZHVYM3SCbeXv/XsMwef4329m28Qh2u5V0Kktf9xgf/MhVOBxWclkd0zTpH47S3hfGnUgT/+12nn92JwvmVVNbW8TsBdVYzjBoiWWyeEu8NNYUgwF2l43O8DjhRGpKAOj1O3nPh5fzx19vJzwao6m1ghvuWDBlmPhYDu3sZusr+8lmcjTOqWTJ9a1YrCeuq8fv4p5PrKanbRBDNyivK8LjP3q199nSdYPn/nMTO95owzAmhv8XXT2D1XcvRFVlezchLjQJAIW4CCiKQoH74tneyqZZJrZSy+UIOBwoikKFz4vP7qA/HqM7OwYYBE0H/bkESXcO1W9BHzMADdM06esf5/fP7eSjH7kai0VjYXk5m/v6SOVyWFWVmJmlsbSI6uJTS1VyLF3DYbb092FgYDVVNAxc0TRRa5JoJIW/wE1xWWCyfCSc4ODePgqLvPj8LnTdoLt9hM72YeavaKCzbZAj+/s5PDBO3qrgK/UyPBZjfGjiVVTgZmhgnOtunk14KIqqqQRL/Ke8P63f5cBjtxE3dEp8HoZicTwOOwGX46iy5dWF/MmnbkDPGycN4gA6D/Tzm/94lXQig8VmoevQAPmcwTW3zz/psQ6XjcY5VafUhjPV1znC7s0dFBb7cXsdRMeT7Nx4hLlL6yk9RuJscXZkFbA4GQkAhRBHcVmt3FBXxy/3H+DAyCgmJovKKrh3zhwyep5/2bcBaxaS0TTWlELcZRK169itFkKmhgcbRSEvo+EE8XiGQMBFc2GIO5qbeaGtjbF0irqCIB+cPfuMczAms1k2dnaRUnJYVI0sOorbZHbeTS6nEyrycf3Nsyl6R9qQic0R3l5coygTKWcwoaaxhPc/eC37d3XT9swmdD1P90iEaCSF06ZRWOQl4HexZUMbvft6Ge4Jo6oKzfNruPneZdidJx/CLvF5uHVOM7/fdYC24VE8Dju3tDZRHjh2ahNFUU4p+ANo399HfDxJ7cxyFEVhqDfM3k1HuOrWuRdFD1smlSOXzeN0T/ycXG47kbE4mXTuJEcKIc6HSyIA1HWdL33pS/zwhz9kYGCA8vJyPvrRj/J3f/d3x5wo/9BDD/Ev//IvfP3rX+dzn/vcCc/9rW99i//1v/4XAwMDzJs3j2984xssXbr0PLVEiEvH9XX1FLpc9MViOC1WFpaX47NPDEHW+QoY8EdJh7MkjRwoYNEVFMUkmc1is2lEoil8PifONxc4KIrC9XX1LCwrJ/lmPkD7MbaWg4kgLZPTyRs6kXgaq0Uj5HOjqm8/7z2Rie3pqmwedFUhZ+hEjQwOzYLVUPF6bLg9U4dMA0E3jS1l7NjcQTyWJpXMUlZRQHX9RO688ppCcho4XtpFdjyFpiigG2QUBdWmYbVpDHSNEldMahtL0HWD7a8fpKg8wPKb55zSz/Wqxhrqi4KEEykCLsdxg7/TpSjKlN27TMMgHk2x4bmdaBaNxjlVk/sET4dQmZ/CEh897cMECr2ER2IUlQUIlZz7eY1CiJO7JALAr371q/zzP/8zP/jBD2htbWXz5s08+OCD+P1+/vIv/3JK2aeffpoNGzZQXn7yVWw/+clPePjhh/n2t7/NsmXLeOKJJ1izZg0HDhyguPjc5f8S4myYpkkqk0PTVOznOAfciSiKwrzSMuaVHr311m01MxlJJ9kQSWDkFDxJC76YjVwuT8ZqMpKIEwyFuPH6mdjftX+u3+HA7zh6yPMtiXSW323cx862PjoGwzjtVsqCXhY0VnL78pmTPYZOmwWXw0YimkZ1akSMLAlybEsM4VKKObh7lD29w/zpfVfTUl8KTOwRvOaOBfj9Lrq7RrHaLSxYWo/X9/bweyabxxlyoPktxIeS2BwWDBPy2Ry7OwcZ0nIUehyU21X8VgfhkRhDfWEGesZoPzAAQF1z6QmHNcv83ilz/s6FpjlV7Fx/iI79/VisGvFICtPUWfuzjZimyfaqQt77iRtPeXeQcy0Q9HDbB5fxwi+3EoskqagJsfruhbi9x/+/IM6CrAIWJ3FJBIDr1q3jrrvu4vbbbwegtraWJ598ko0bN04p19vby1/8xV/w3HPPTZY9ka997Wt8/OMf58EHHwTg29/+Nr/97W/57ne/y6OPPnruGyLEaUqms/zujX0c6BpGVRWWz6rh2nn1aNM8pFfp8fPp2SsoSbj4f4e3UqR5sBdpxBNp4uS58ZpWVs1uoPQMenee27SftZsPMRyJE01l8Dhs+N0OXt/TQXmhj6Ut1QAUulyU1/h4uXuEtJFDNTTcWQ3Na+GNbJiA1ULb4DDp327gz++5ihmVE718TpeN5dc1M/b8Lg62DdLx3HZmHO7ntpvmYLdb2RYd5LAnTjSfJl+qo2VV7EmF7lSKjAJoDjqjKVKjYyz0Bcil8+R1g59/91XGhmNgmgSLfdz1pyuoqr9wf0iW1xVxz3+5jp0b2shlcrTt7iYdT1HVVIZpQse+XnauP8SN75++EY6aphI++rmbSadyOFy2U547KYQ49y6Jp2/lypWsXbuWgwcPArBjxw5ee+01br311skyhmFw//3388gjj9DaevJ9ObPZLFu2bGH16tWT76mqyurVq1m/fv25b4QQZ+CFLYdYv6cTVVHI5XWe23SA7Yf6prtaAPjtTu5dsoDZ/lLGkilGkkmSqsH8hgpuWTnrjII/3TB4ZdsRBgYijIYT5NJ54skMum5OLCwZibBrVzdbt3bw9J6dJIwUnhxoOlg0HVs6j57UiZhZPHYrXkVjYCDMt7/zB1786XrGBscBWLexja07u3C77Lhddrbu7GL9piPsHhrk9b5u6ioLMXwGUTVD3gWVc0IM1uepaAqxdH4d5V43Q5E4+7uHqG+tIK/D+Gicuhkl1DWXMj4aZ9u6w8BED246kSGXzZ/LH/8xVTaUcNt9K7nrY6vwF7hxuCYW8KjqxFzCTDJz3utwMppFw+11SPAnxDS7JHoAH330UaLRKC0tLWiahq7rfOUrX+G+++6bLPPVr34Vi8Vy1JDw8YyMjKDrOiUlJVPeLykpYf/+/cc8JpPJkMm8/QEajUbPoDVCnLrDvcP43Q6Cvom0HG19o3QPj7Oo+dzuUHGmPE47j913Mz96ZSt9kRgVQR8fXDkPv/PMhvWisRRDI1EMTNxOG4lMjlQ6SzyZweWwsmNLFzvChzBN2FMWJmvN4YmY6AEbpsXAcOhEUxlUi0YynELTTWL942QVlZf3DXFkVxcf/Nzt9A2M43TY8Hocb143TW9/GCpt5AydkqAbj2nHbzpJ5fIYBgzqCUrNJHX+IK1L61HaB1g+o5r3rVnEr368AavNMjkn2Wa3kExmSUSSvPDUOjr29mCxWli2Zh6LVs8+aZLv3miU7mgEm6YxM1SE03r0HswnU99ayWu/2cbYUBQ9r4OiUNlYcvIDxWVBVgGLk7kkAsCf/vSn/OhHP+LHP/4xra2tbN++nc997nOUl5fzwAMPsGXLFv7pn/6JrVu3ntfdEx5//HH+/u///rydX4h3czvsDI0nMM2JHrC8buCyn34wcD4V+T187o5rz+ocBwdHeH7vYfpGI2QsBjabRlY3JlboKgr5vE6BzUN2IE5tVQirVWNPbIzRdJKQrmJiYVjJYHdp+HQrflwEy9yEu0ZQHFZq/T7qHC66DvRxZFcXfp+LdHoQXTeAieTQfp8Lv92BRVFJZ3NoisJoKkUur4MCWcVgf3wUv+7AoqtUlhdy9coWnG47tU3FHN7Ty8hgFAXIZXVqm0p48acb2P7SXoKlAdKJDC889TreAjfNi+uP+7PYPTTIj3ftJJxKoSoKrUXFPDB/AW7b6SXKXnHLPLKZHAe3d2KzW1l20xxalzWezW0SQlxGLokA8JFHHuHRRx/lQx/6EABz5syhs7OTxx9/nAceeIBXX32VoaEhqqurJ4/RdZ2/+qu/4oknnqCjo+Ooc4ZCITRNY3BwcMr7g4ODlJaWHrMen//853n44Ycnv45Go1RVnd/cWeLKdu28eobG4xzunUjFUl0SYEFTxQW7/uHIKAfGh1GB2cFSqryBo8oYhklnzyjxRIbCoJvykqPLnEjfeJQnN+4gnEzhtFhI2QysJjQGCoglMjhsFt5/0wKy4Qyv9x7AZpv42GpWChkjSdiZRdMVyrI2ynpUbl4ym2BDKa9vP8Jg5xBB00qDw4WqqYCCbhgsX1xPb3+Yzp6JPW8rygMsX1xPQYGL5VVVvNHdjZa3kDKyOKxWTNUgoDpJGDp7kyNcX17L7Ytn4nXaGY7Emb+ikVQiy+4tHQBcdVMr85bV8e+/3kSgyEegaGKlb8eebgY6h48bABqmyW8OHiCemdg7Oavr7BoaZEt/H9fW1J7Wz9XhsrHmwyu5/p4lKKqC1XZJfNwLIS6QS+ITIZlMHpXHStM0DGPir/f7779/ylw+gDVr1nD//fdPLvB4N5vNxqJFi1i7di133303MDGPcO3atXzmM5855jF2ux27/cSZ+IU4l2bWlPDAmsV0DIyhqSoza0omh4PPtz1jg/zHgS2EMykwYd1AJ382cym1vrdXkRqGyR9e2sPGbR1kc3k8Ljs3X9fKwrnVJzjzVO0jYUYTSZqKCidSmdSZHOwawmWxUFHm48armpnfWsXevb1omsroaBy73YI6pHN3cysZa4rugwMUJawsnFfPDXcuI28Y9O0dYiBtJToUY8dIlpBVpbjUT3VzOUUhL/e9fxkdXRMBYG11IT7vxErge2fPYXF5BdF0iv+7fSMpPUs4lsJIKWDXcVvs5B2w5VAPbb2jZNM5zHCa0pyVUKGbq2+eTW1TKaZp4nTZGekfB0DP6xiGie0E+QKzep54JovfYUdRlMk0OfFs9nRv3ySb4+LqMRYXiKwCFidxSQSAd9xxB1/5yleorq6mtbWVbdu28bWvfY2PfexjABQWFlJYWDjlGKvVSmlpKc3Nb++peuONN3LPPfdMBngPP/wwDzzwAIsXL2bp0qU88cQTJBKJ4waNQkyH6pICqkvOXeqObC7Phs3tdPaM4HbZWbKgjqryo8//Sl87sWyWlsDE6tkD48NsGOyaEgC2d42wcVs7Pq8Tr8fB4HCUF1/bT2Nd0WRAdTKWN/+40w0Ti6Zgd1iZ2VjGny1bREmBF9ebAVNLSzmrVrWwedMREokMM5rLuO22+QSDblKJNIZh4vJMLHr4wx920XF4iHmL6uk5NEBf3zhlJQHu/MSNFFVMpGfxeZ3MbT16LqVFVWkOTWxNd1csxn/u2Us6Hsdhs+JV7bQUhtjdNUB7foT6YJCe7iH6R6MkPV4Sownikc3c++erKAh5WfGehTz7H6/QvqcbTKiaUcbMpQ1TklG/k12zUOn3sX2gH7vFMrFriqZR6jn7fYjFFUYCQHESl0QA+I1vfIMvfOELfOpTn2JoaIjy8nI+8YlP8MUvfvG0ztPW1sbIyMjk1/feey/Dw8N88YtfZGBggPnz5/Pss88etTBEiMuFaZqsfWUf6za1YbNZyGTzdPWO8SfvXUZxaGpeumQ+i13TJgMVq6qRyk/dtSGRzJDLGZPBXsDvYnQsTjyZOeUAsKWsiLrCAg4Pj6KpKgpw48wGasuCU4IkVVW49toWFi6sJZvN4/e7JleSOt1TF50MDUVxOm14fS5mLqrHXxamqrqQ6uaT5wd9p1ubZjCWSPGTcByPxUZzQQi3ZiOT0ym0OrApCplICpuiEs5maQ4FGBmM0N89RkHIS+vyJjwBF31tg1isFmKVDv5l/w6yep65JaXc0tg0JRm2oii8b2YrWV2nKxLBqqqsaWhk/jFyMQpxIsqbr7M5XlzeLokA0Ov18sQTT/DEE0+c8jHHmvd3rPc+85nPHHfIV4jLTTqTY/eBPnw+F4UFbkzT5EjnCG0dw0cFgLODpRyKjDCQjKG/ucVEcyA0pUxBwI3TaWVoJIbf52RoJEow4CHgfXuYejya5HDHMKZhUlNZeNR1/E4HD6xcyMb2HuKZLJUFPhbXVB53QZfHc/IVxoVBDwcP9JPL6QCkUjkKg6fei6brBolYGpvNwgMLF+DULWw40k0sliGhZGgsCpIJ58hm84yPJ4ibBkZOZU9nAl/Qg2Z5e/u2mpYKaloq2Dk4wJPbtmGaJjZN49nDhwC4q2XmlGsXud18cvFSxlIpbJo2uRezEEKcS5dEACiEOHcU3h7dMU8wzHN9RQMZPc/m4R5URWFN1QyWlUyd21dZFuDGa1p4ed0hhkdiBAMebrtxNi7XxLDtyFicn/x6C70D4wCECty877YF1FROnbIRdLu4ZfaMc9RCWLGyicHBCJ2dEz3+9fVFrFjZdErHjo/GefY/N9PXPYbVqrHsuhbeu2IWtaECwsmJ7dvKnG7+/VdvsG1/DwkVHFkoSEM0msLlcVBVHzrqvG1jY6RyucnhZWKwfWCAO5tbjgrwrJpGiQz7irMxsfH12R0vLmsSAApxBXHYrcxuqeT1jYdIpbNkMnmKCj001BYdVdamadxZN4vbalpQ4Ji7jyiKwrKF9cyoLyGRyhLwufC4314otWlnJz39Y9RVhVBVhY7uMV7f3HZUAHiuBQIu7v3Qcnp7wwBUVBTgfNfii7dSwLwzIXEmneM7T/yBtgP9FIQ8eL1O/vibHRSEPKyYNRH8ZjI5fvGfmzD7kjjGdbxJqAsGCBZayWV1gkVeLO/oAXyLhjKR0/DNIDGr6wSPsxeyEEKcb/LpI8QVRFEUbrimGbfLRkf3KB63nSULao8aln0nyylsO1cQcFMQcB/1fjKZwWq1vD1Xz2klGk+feQNOg9Npo/FdiY913aC7Y5g3tnbQ0RfG7rAwd1Yl165oQlEUfvPzTezY2oGqqWQGIuRyBi67heH+CE2zJtLvHDw4wMGDA9RWhAi6newYaScWzdA4s5DwUIyaxhKsNgupVJadO7uJx9N43A5GDvQT7hnjRXUIl8dOXU0xq2pqZXhXCDEtJAAU4gpjs1q4ZnkT1yw/tSHRs1FRWsDW3d2MjSfQVJV4MsOiOaeeIuZc0vMGz/16G2tf2kvnSBSXw0plbYg/hg9gs1qYURvi8IF+3B4HpmHgdNsZHYmhBN043tF7mMnkMU2w2TRCxT5qGoro6RolHsvQPK+KG+9aQC6n86tfbmXv3l4URWFsOEoummbFrCIGLFnG+uK0Bl0sq7w4dnQRlyFZBSxOQgJAIcR5s3huNePRJDv29pDX8yyeU821y85/4Hksh/b3sX1TOzkFPB47im4yPhjFHXSzbsMhAg4rpglV9SG6j4wQHU+SSuUIzi5nLJ/jxXUHqCoroLjYi8tto79/HI/HgWq3cvUNs7j7roUUFHrRNJXDhwc5cKCf8vICHA4rkZEYo6ksAYuDSqefIdWKbTAnvX/ivJFVwOJkJAAUQpw3FovGmlWzuHpJI4ZhoGkqb2zrYHgsRmHAzbIFdVPmDJ5PsUgKXTdwu+yMJ9K47BaGhqKY4ThjfeNoiRwOl43IWILy6kLGRmOUF7ihxMML6/ajKgoup4333DiHW26Zxyuv7CeTztHUVMott8wlVPT2MHo+92bS5zd333C77ei6QTabR7dbScQy1M449o5DQghxIUgAKIQ4rxRFweO2k8vp/Px3W9m1rxerVSOb0+kdGOfeOxdjvwDblAWCbiwWDa9FwW610D8cJZPVKS3wMbupjFQkDTaN+tllJEaTNM+pwFboZsPOThpqQqiqSu/AOK9vbuNTH1lFS0sZ2Wwep9M2ZSEJQGlZgFCRl67uEXxeJ4amUlYWYHwoSnQ4TmllAVetbj3vbRZXMBkCFichAaAQ4oLoH45w8Mgg5aV+nA4bmWyewx3D9PSHaag5ehXyudbQXMbya2ewZUMbJS4H1uDErihzWypwOW0cHo8wOJYgUWJj4eJK3rNyFq9sOISmKpNbUdrfTJ79Vu+e7TiBayDg4q47F7L2xb1ExhPMmVvF1Vc1kRxPYZgmFTUhfIELs6WfEEIciwSAQohTcrzty075eMPEMMzJYEpTFQxz4r0LQVUVrrt5Nq3zqkmnc4yH4/z26a0YGZ39sTE6whGK/G68Lhvr93YS9LqoKivAbrfQNxjBZtOIxFKsXFR/VI/fsVRVF/LAA1ej68bbaWGmZ/2LEEIcRQJAIcQJxeJpXnz9AJ3dI3g9DlatmEH9GfTYlRb5qK4I0tYxjNttJ5HIUFtVSEVp4NxX+jgURaG41A9AVU0h4+Ekm9cfZmA8is/jYNbMCpLhJCN9o7yU2MVf3Hcdt90wm3Wbj5DL51mxqJ4brmo5resdKyfgdBgfjbPx5f1ERhMUlQdYel0Lrgs0/1JMAxkCFichAaAQ4rh03eC3L+xi194efD4nI2MJxsLb+NP3L6ekyHda57Lbrbz3lvm8vOEQAyNRWhpKWbW8CdebKVayuTzj8TROuwWv6+TbvZ0tRVG45vqZzJ5XjfvlHezvG2G0L0zX4QHiiok2GOfpf/0jH/j0TSz8aDWGYVw0wdzpSiYy/OqH6+g4NIjDaWPfzi7GhqLc+acrsVgvzTaJE5NVwOJkJAAUQhxXLJ6mo2uEopAPn9dBKGjS3jVCd+/YaQeAMJEw+u5b5h/1ft9IhKdf3cVgOI7dZmHVvHquml133tOkKIpCsNDDe66dzfhzm9mwdz9YVcq9Lub7/Ay0DdO2u4dF181EVS/dQKmnfZjuI8NUNxRjsWok42na9vUxOhSlpKJguqsnzgfZCk6chASAQojj0jQVVVXJ53Xg2NunvZNpmuQMA6uqnnLwlsvr/PL13bQPhCkv9BFLZnhu4wFKCnw0VR69p+65YJom2/Z0s3NfLwBzZ1bwJ9fNZ3xTFxaLRk0wgF1VGQGMN9t8KTNNExN465YoijIxQii/5IW4YkkAKIQ4Lo/bzoI5Vbz6xmEisYk8erVVIRrrio8q2xkL8/SR3YykExQ7PdxTP5sqT+CY5x1NJtk9NEjeMCmyOxkKxykt8OJ22HA7bLT1jTAciZ+3AHDH3h5+/fxODNNEQaGzZ4w7b5rLVfMb2PrKPqJ5hVQyQ0Gxj+oT5OuLpNO81NHOUCJBqcfDqto6fPaLb15dZW0RFTWFdLYN4XLZSSYytMyvJlTin+6qifNJ4ntxAhIACiGOS1EUrr+6hWCBm4HBCG63nfmzq/B6ps7Ri2RS/PDgVnoSEYI2F/vCgyQPZvn07Kvw2qYGREOJON/ZsoXOSAQAn82OqeTQkyYep410No+iKLjs1vPWrj/sPshWcxiHx0aJxYU7rLL3cD/v/cBSHG47nfv7qKgvZtnNcyipKjzmOdL5HP9v53Z2DQ7itFrY3NdLbyzKg/MXYrdcXB+tbq+Du/50JRv+uI/wSJySigKW3zBT5v8JcQW7uD6lhBAXHYumsmhuzQnL9Caj9CYiNHgLsagqAbuDzliY/mQUr23qiuE3enpoHw/TXBhCVRTawmE8hRbUEYUj/aMoisLc+nJm1ZScl/YcCY+xKT5AhCyqaeFgNowfC3OVcpxuB6s/sOyUztMxPs6BkRHqCwqwWywkczn2DQ/TG4tSXxA8L3U/G8FiH7fde2ptE0Jc/iQAFEKcNZuqYVU00noOj2onlc9hUTWsx1g4kcjlsKoa2pv5AN1WK0bOpLWkiGgyTUNtEVfNq8d6nlbcHgmHsbmsFMTt6Ik8BgZRS54ZTae3NdvEHPu3cyOqb86rM2RenbgYSBoYcRInz2YqhBAnUeMtYEFRBb3JKPvHhxhIxlhUVEH1MeYA1voDqIrCQDzOaDJJz1iEkcPjbN/aSdv+QbZt6mRoOHpW9cnndXr6wnT1jJHJ5KZ8T1MUvF47MxvKKCvyURBw0lgdovU0A8Bqv5/6giBHxsboiUboCI/TGAxS6Tv91dFCnGvKOXidiW9961vU1tbicDhYtmwZGzduPG7Zf/u3f+Oaa66hoKCAgoICVq9efcLy4tySHkAhxFmzqhofbppPg7+QSCZFgd3F4uLKyV6+d1pSUcF4Os1rXZ3opkkwZcObNqmvnRgqPtI5zPbd3VSUnVl6klQ6y6//sJMDhwYwDJOqigLuvnUBwQI3AHNKStnQ0037+DiWoI1ixc5dzS04rKc359Bts3H/vPk833aYgUSc8jIvNzc24bCcv7mLQlzMfvKTn/Dwww/z7W9/m2XLlvHEE0+wZs0aDhw4QHHx0QvHXnrpJT784Q+zcuVKHA4HX/3qV7n55pvZs2cPFRUV09CCK4tiSh6AMxaNRvH7/UQiEXzyV78QpyWdz5E3TH78kw0Mj8Qpe3NFamfPKHNnVfK+9yw85nHtvaN0DYSxaCrNtcXolon0JiGXG1VReO2Nw/z+hV2UlQbQNJWevjEWzq3mfe9ZBEDvSITtnX0cjIwSDLiYVVLCovJy1POcc1CIC/E7461r/N9vP4vT6T7j86RSCT710C2nVddly5axZMkSvvnNbwJgGAZVVVX8xV/8BY8++uhJj9d1nYKCAr75zW/ykY985IzrLk6N9AAKIabFWz1lTXUldPeMMTwam9wXuK762Olfdh/u55k/7iSWzJA1dca9OTwlLhw2C3NKSvjArNmMjMawWDVcThvmm3sNb9vVzcwZ5WgOjZ+/upNwLAkoKMUGtQ0zJPgTl6FzMwkwGp06HcNut2M/RqqjbDbLli1b+PznPz/5nqqqrF69mvXr15/SFZPJJLlcjmDw4ltEdTmSOYBCiGl11bIGrl05A6tVw+mwctOqWcxrrTyqnGmavLzlMJlsnobKQvJBhYPRMTKJHB6bjXVd3bzU0U5BwEU+b5DO5Dh0ZIiDbYP09I3z02c28+/PrCeSSNNQHqKuLEjnYJgtB3qmodVCXBqqqqrw+/2Tr8cff/yY5UZGRtB1nZKSqav3S0pKGBgYOKVr/c3f/A3l5eWsXr36rOstTk56AIUQ08pmtXDTqllcf1UziqKcYJcRSGVyOB1WFEUhomewqio2RcPvcBBOp+iORLhv/ly6e8Ps3NdLe+cwAb+L+bOr0HWTvR1d1FSHJq6jKFg1jWQme4FbfGpi4QQHd3SRy+WpqCumqvH8pMURl6lztAq4u7t7yhDwsXr/zoV//Md/5KmnnuKll17C4Tj/e4ELCQCFEBcJy0nSvqiqQmNViHU72tE0lXxSx1DA7bKSNwxSuTwBpxO3y84H7lpMdWWQZ36/nfqaEC6nHcMwcalWIok04ViKvDGxvV1lUeACtO70RMbi/OJf/0jP4UFQFNw+B7f+yUpmLqqb7qqJS4RiTrzO5ngAn893SnMAQ6EQmqYxODg45f3BwUFKS0+8wv5//+//zT/+4z/ywgsvMHfu3DOuszg9MgQshLhk3LS8haWzazANk0ZXAXMqSoiS40g4TEMwyHW1tQDYbRYWzKmmtqqQ4ZEY8USGnv4ws8pDrJhVQ17XURWF1QubWNh09HDzdNu3uZ3uQwNUN5VQ21xKLpNn3e93yN694qJls9lYtGgRa9eunXzPMAzWrl3LihUrjnvc//yf/5Mvf/nLPPvssyxevPhCVFW8SXoAhRAXPdM02b+zm76uUUrsVlbevIiiUj/xXJbDY2MoCjQFC/G/Y+jI63Fwx5p5/H7tbiLRFIUFbtZc30pTfTHxdBZNUXA5bEddyzAMxocnFqQUFHnRzlNC6hPJpHMoqjJ5bafbTiqZxdAN4rE0Q33jWK0alXVFsp2buGg8/PDDPPDAAyxevJilS5fyxBNPkEgkePDBBwH4yEc+QkVFxeQ8wq9+9at88Ytf5Mc//jG1tbWTcwU9Hg8ej2fa2nGlkABQCHHR2/zaQdb+aju5bB7DMNm/o5sPfOwaCgo9LHkzX1gsnqZvYByvxzG5V3FddYj/8qdXk0hkcLns2G0TH3le57HnMWVSWZ7/6Rsc2N6JaZrUtpRz65+sxO1zvl0mnSOdzuH22E86bH2mSiqD2OxWhnrD2B1WxkfiLLy2md7OUX731BuMDEWwWDRmzq/m1nuXYbPJR7l4l4mtas7u+NN07733Mjw8zBe/+EUGBgaYP38+zz777OTCkK6uLtR35Ab953/+Z7LZLO9///unnOexxx7jS1/60pnXXZwS+dQQQlzU8jmdTa8exGLTqKgNYegGHYcGObC7h2WrWgDYtb+XP7y0l0Qyg8dtZ831rbTOKAcmFpnYAqf2Ubf1lf1se/UAoTI/qqqyd1M7vgI3N9+7HIC9O7t5+fk9JBMZCkNe1ty5gLLKM0tYfSLNC2q4/p5FbHpxL/mcztyVjVx750J+8f3XGB2OUt1QTCaVY9fmdmqaSpm/vOGc10GIM/GZz3yGz3zmM8f83ksvvTTl646OjvNfIXFcEgAKIS5qum6Qz+mTvVyqpqIoCvncxCKOkbE4v39xN5lMnqKgh+E3vy4v9lMQOL1EuIPdY1htFrxvHuf2pehrHwZgoG+c5361jWwmjy/gortjhN8/s4X7/ssq7I5zu/uHoigsvXE2869uJp/TcbrtZFI5ouNJAkE3qqridNsBhXg0dU6vLYS4MsgiECHERc3usNLQUsb4aJzRwSi9HSO4vQ4qaieSRY+NJ4jG0pQV+7HbrZQV+4nG0oyNJ0/7Wr6gm2w6Rz6vY+gGyXgaf+HEXKThwQixaJqyygI8XgelFQGGh6KMhxPntL3vZLNbcXkcKIqC3WklWOwlPBInl80TG0+iqgr+gjPf7UFcxsxz8BKXNekBFEJc9K5/z3xUTePIgX58BS6WXz+T2jfz4nlcdpwOK+PRJMGAm/FoEqfdisd9+vnKFl7bQvehAbrbhgAoqSpk5S0TaSkcDiuaRSWdyuF02UjEM9hsFhzOoxeSnA+KorD6roX87idvMNgbxmLVWHR1E7MWVF+Q64tLy7lKAyMuXxIACiEuei63nVvfvxjDMFAUBeUdW7eVlfhZsaie1ze1caRzGIfDyrXLZ1Ac8p72dQIhL+//5Go6D/ZjGCaVDcUECifOU9tYwqy5lezZ3o1pmlitGtfe1IrP7zzJWc+d0sogH3roBjoODtDVNoTTZefIgQEaZ5VP+ZkIIcTJSAAohDgtmWyebTu7GBmN4/c5WTC3+ox6287EO1cQvkVRFK6/qpn6miKisRR+n5PqiuAZB0Run5NZi+uPet9q1XjP+5YwY2Y5yXiGYMhL/YySCx545bN53nhpP91tQyiqgt1hZfVdC1l4VdMFrYe42J2jrUDEZUsCQCHEKdN1g9+/sJst2ztQVYV83qC9a4QP3rUYxzleCHE6FEWhtqrwvF/HatVonXfiIdf2w4Mc3t8PQNPMcmobis9pHQ7s6qH7yBA1jcVoFo3B3jBvvLSPuUvrJSegeJvEf+IkJAAUQpyykdE4ew/0URTy4vU4yObyHG4forNnlObGE2/3dCU4fKCfX/10E7FoCkyT3du7uPODS2mYcWo/G8Mw6e4bI5XKESr0EAoenQw3m8lP7GX8Zg5Cu8NKLquTz+sSAAohTpkEgEKIU6YbBrpuYLFMDMVaNBXTMNF1Y5prdnHYvqmDZCJNXeNEr1/nkWF2be2cEgAe2tfH5g1tZDN5mlrKWHJVE1arhq4bPPfHPWzZ2Ukmmyfgc3H7TXOY2VQ25RrlNYU4XTb6u0dxOG2ER+LMW1Z/zlPRCCEubxIACiFOWWHQQ1VFkENHBvH7nMTiaUqKfZSXBqa7aufEkXCYrsg4dk1jdnEJXvvpzW3M5fJYLNrkvECLRSWbzU9+v6NtiF//fBOpZBarzUJX+zC5XJ5VN83mcPsQm7Z34Pe5KPfY6ekP84eX9lJXHcJhfzu4q20q4eb3LmbDi3vJZPLMX9HADXcskEUgYqpp2AlEXFokABRCnDK7zcJdt85j7av76esfp6KsgOuvbibgd0131c7alr4+frpnF9FMBoDmUIiPLViE7zSCwBmzymk/NMhAX3jy9++MmeWT3+9oGyIWneghVBSF4cEIe3d0c82NrUTjaXJ5HZ93Yhu7YMBNLJ4mnshMCQAVRWHu0npaF9Wi64ZsAyeOTeYAipOQTw4hxGkpCLh5/x2LME3zsul10g2DZw8fJKPnmVFYSM4w2D8ywrb+PlbV1p3yeeYvriOf09m1tRMUmLeoljkLaya/r6oK5jt6VgzDRHlzZXPA58RmtTA2nsDrdjAyFqeo0Iv3OCusNU1F0ySXvxDizEgAKIQ4I5dD8GeaJruHhmgLj3FobJRilxtFUbBpGgqQzOVO63zpVJZQsY+b75hPeVUQi2XqooymlnJ2bO6g/fAgFosFRYEFN9ahqgqNdcVcvbSRN7a20x8fpzDg5rYbZ2O3y9w+cfqUN19nc7y4vEkAKIS4Yr3W1ckv9u0llc8zEIvTPR5BU1UM08SmaZR7fad8roG+cX79s40M9o+jaRotsyu47Z5FUxZnlFUWcM+Hl7NrWyfZTI7axhLmLJjoIVQUheuvbqa1pZxUOkdhgRuvx3HO2yyuEDIHUJyEBIBCiDNmGCbxVAarRcN5ifVUZXWdte1H0FSVllCICq+X17q66ItFqfIHWNPQyNySklM+3x+f20V/b5jq2iKy2Ty7tnVSWV3IknclaK6sKaSy5tg5CxVFoaTo1INOIYQ4UxIACiHOSDSR5pfr9tDeP4qmqaycVcuqeQ2o6qUxeJTTdbK6jtMy8THotdupLyhgTWMjNzc04bKeekCr6wajQ1F8AReaRcVpsaEoCpFI6nxVXwghzorMIBZCnJHfb9zPtsO92K0WdN3kuc0H2NXeP93VOmUuq5WmYCFDiQQjyQSd4+N4bDZmhopPK/iDiQUZoRI/0fEkuZxOIp7BNE0CBZf+6mhxiTLPwUtc1qQHUAhx2vK6wZH+UYJeF36PE4DDvSP0j0aZ11B+kqMvDoqi8L5Zs1AVhUNjo4RcLm5qaGRG4ZltKXfDLXNIxNP094yhWTTmLqpl7sLac1tpIYQ4RyQAFEKcNk1V8Djt9I5EKPS50A0TwzAvuXmAPruDB+YvIJPPY9U01LNY2Vxc6ufDD17D0EAEq1WjtLwAzSKDLGKayCIQcRLy6SSEOG2KonDDgkZcdhttfaN09I/RUF54yfT+vZvdYjmr4O8tLred2oZiKqoLJfgTQlzUpAdQCHFGWmtL8bocdA+FsWgas2qK8bokbYkQQlwKJAAUQpyx6uIA1cWB6a6GEOLdZAhYnIQEgEKIK1I0kWZwPI7dolFR5EdTZchWCHHlkABQCHHFaR8Y4z9f2clQOI7NqrGwqZI7Vs7CqmknP1iIS8HZpnKRDsDLnvzJK4S4ouiGwW837GUoHKe6pACf28Eb+7rY3T4w3VUTQogLRnoAhRCXpL6BccYjSbweB5XlBSinuIo3lckRjqUI+lxYNBWfy8FQOE4knj7PNRbiwlFME+Us5vGdzbHi0iABoBDikvPG1iO8+OoBEqkMTruVlUsbuW7ljFMKAp12KwVeJ12D43icdlKZLJqq4nPbL0DNhRDi4iBDwEKIaacbBjuP9PPS9ja2HOwhm8sft+zIWJyX1h1EURXqqkPYHVbWbWqjd2D8lK6lqSq3L59FcYGHrsEw4/E0y1qqmFNfdo5aI4QQFz/pARRCTCvTNHl24wFe3XUEXTdAUTjYU8H7V8095qKMeCJDKpWlrDSAoigU+F20d40Qj2dO+Zp1pUE+fvtyBsMxHFaLrAIWlx9JAyNOQgJAIcS0GhqPs3F/F363gwKvi2Q6y462PhY3V9FUETqqfMDvxOtxMjgcpTjkZSycwOO2UxBwndZ1/W4HfrckrhaXMYnhxAnIn7xCiGmVyebJ5XVcDhswMUcvrxtkssceBg74XNxyQysel53BoShWi8bNq1opKfJdyGoLIcQlTXoAhRDTKuR3UxL00jM0TsjvJhxLEfK5KQ16j3tMa3M5lWUFRKIpvB47BQH3BayxEJcCSQQoTkx6AIUQ08rlsPG+a+ZQX1ZINq9TWujlvdfMIeQ/cVDn9zmprgxK8CfEsZjn4CUua9IDKISYdpVFAf78juWkMjkcNisWTf42FUKI80kCQCHERUFTVTxOycUnxDkhq4DFSUgAKIQQQlx2ZA6gODEJAIUQQojLjcR/4iRkoo0QQgghxBVGegCFEEKIy43JWc4BPGc1ERcp6QEUQgghhLjCSAAohBBCCHGFkSFgIYQQ4nIjaWDESUgPoBBCCCHEFUYCQCGEEEKIK8wlEQDqus4XvvAF6urqcDqdNDQ08OUvfxnzHV3UX/rSl2hpacHtdlNQUMDq1at54403TnjeL33pSyiKMuXV0tJyvpsjhBBCnF9vDQGfzUtc1i6JOYBf/epX+ed//md+8IMf0NrayubNm3nwwQfx+/385V/+JQAzZszgm9/8JvX19aRSKb7+9a9z8803c/jwYYqKio577tbWVl544YXJry2WS+JHIoQQQhyfzAEUJ3FJRDvr1q3jrrvu4vbbbwegtraWJ598ko0bN06W+ZM/+ZMpx3zta1/jO9/5Djt37uTGG2887rktFgulpaXnp+JCCCGEEBehS2IIeOXKlaxdu5aDBw8CsGPHDl577TVuvfXWY5bPZrP867/+K36/n3nz5p3w3IcOHaK8vJz6+nruu+8+urq6znn9hRBCCCEuJpdED+Cjjz5KNBqlpaUFTdPQdZ2vfOUr3HfffVPK/eY3v+FDH/oQyWSSsrIynn/+eUKh0HHPu2zZMr7//e/T3NxMf38/f//3f88111zD7t278Xq9R5XPZDJkMpnJr6PR6LlrpBBXqHQ2z5G+EXK6QWWRn0Kfe7qrJMSlT4aAxUlcEgHgT3/6U370ox/x4x//mNbWVrZv387nPvc5ysvLeeCBBybLXX/99Wzfvp2RkRH+7d/+jQ9+8IO88cYbFBcXH/O87+xBnDt3LsuWLaOmpoaf/vSn/Nmf/dlR5R9//HH+/u///tw3UIgrVCKd5ScvbuNA9zC6YVIc8PCB6+ZSV1Y43VUT4pJmmuaUhZJncry4vF0SQ8CPPPIIjz76KB/60IeYM2cO999/P//1v/5XHn/88Snl3G43jY2NLF++nO985ztYLBa+853vnPJ1AoEAM2bM4PDhw8f8/uc//3kikcjkq7u7+6zaJcSVbuvBHvZ2DFIR8tNQXshINMFzmw7ILx8hhDjPLokAMJlMoqpTq6ppGoZhnPA4wzCmDNmeTDwep62tjbKysmN+32634/P5pryEEGcunsqgKAp2qwVVUfC7HIzHU+iGBIBCnBXzHLzEZe2SCADvuOMOvvKVr/Db3/6Wjo4Onn76ab72ta9xzz33AJBIJPjbv/1bNmzYQGdnJ1u2bOFjH/sYvb29fOADH5g8z4033sg3v/nNya//+q//mpdffpmOjg7WrVvHPffcg6ZpfPjDH77gbRTiSlTod6MoCuPxFMlMlnAsSXmhH4t2SXw0CXERkwhQnNglMQfwG9/4Bl/4whf41Kc+xdDQEOXl5XziE5/gi1/8IjDRG7h//35+8IMfMDIyQmFhIUuWLOHVV1+ltbV18jxtbW2MjIxMft3T08OHP/xhRkdHKSoq4uqrr2bDhg0nzBsohDh3FjRWMDAaZeuhXmKpDE2VRdy6TJKxCyHE+aaYMtnmjEWjUfx+P5FIRIaDhThDpmkyEkmQy+uE/G5s1kvi71IhTtuF+J3x1jX+5Ys/wulwnfF5Uukkn/gf98nvt8uYfNIKIaaVoigUBTzTXQ0hLi9nO4orXUOXPZloI4QQQghxhZEeQCGEEOJyI4mgxUlIACiEEEJcdmQMWJyYDAELIYQQQlxhpAdQCCGEuNxIB6A4CQkAhRBCiMuNzAEUJyEBoBBCCHGZMU3zrPbUlhTBlz+ZAyiEEEIIcYWRAFAIIYS47EzPXsDf+ta3qK2txeFwsGzZMjZu3HjC8j/72c9oaWnB4XAwZ84cfve7353RdcXpkwBQCCGEuNxMQ/z3k5/8hIcffpjHHnuMrVu3Mm/ePNasWcPQ0NAxy69bt44Pf/jD/Nmf/Rnbtm3j7rvv5u6772b37t2nf3Fx2iQAFEIIIcRZ+9rXvsbHP/5xHnzwQWbNmsW3v/1tXC4X3/3ud49Z/p/+6Z+45ZZbeOSRR5g5cyZf/vKXWbhwId/85jcvcM2vTLII5Cy8NUk2Go1Oc02EEEJc7N76XXEhFlikMknOJpdLKpMCjv79ZrfbsdvtR5XPZrNs2bKFz3/+85PvqarK6tWrWb9+/TGvsX79eh5++OEp761Zs4ZnnnnmjOstTp0EgGchFosBUFVVNc01EUIIcamIxWL4/f7zcm6bzUZpaSn/9eufOutzeTyeo36/PfbYY3zpS186quzIyAi6rlNSUjLl/ZKSEvbv33/M8w8MDByz/MDAwNlVXJwSCQDPQnl5Od3d3Xi9XhRFme7qnJZoNEpVVRXd3d34fL7prs45cTm2CS7PdkmbLg3SpnPLNE1isRjl5eXn7RoOh4P29nay2exZn8s0zaN+tx2r909cmiQAPAuqqlJZWTnd1TgrPp/vsvlgf8vl2Ca4PNslbbo0SJvOnfPV8/dODocDh8Nx3q/zTqFQCE3TGBwcnPL+4OAgpaWlxzymtLT0tMqLc0sWgQghhBDirNhsNhYtWsTatWsn3zMMg7Vr17JixYpjHrNixYop5QGef/7545YX55b0AAohhBDirD388MM88MADLF68mKVLl/LEE0+QSCR48MEHAfjIRz5CRUUFjz/+OACf/exnWbVqFf/n//wfbr/9dp566ik2b97Mv/7rv05nM64YEgBeoex2O4899thlNZ/jcmwTXJ7tkjZdGqRN4nTce++9DA8P88UvfpGBgQHmz5/Ps88+O7nQo6urC1V9e+Bx5cqV/PjHP+bv/u7v+Nu//Vuampp45plnmD179nQ14YqimLLhnxBCCCHEFUXmAAohhBBCXGEkABRCCCGEuMJIACiEEEIIcYWRAFAIIYQQ4gojAeAlSNd1vvCFL1BXV4fT6aShoYEvf/nLx91f8qGHHkJRFJ544okTnvfxxx9nyZIleL1eiouLufvuuzlw4MCUMtdddx2Kokx5PfTQQxdtm770pS8dVd+WlpYpZdLpNJ/+9KcpLCzE4/Hwvve976jkpBdTm2pra49qk6IofPrTn54sM5336aMf/ehR177llltOeu5vfetb1NbW4nA4WLZsGRs3bpzy/em8T2fSpov9eTqTNk3n83Q+2zWdz5QQ08YUl5yvfOUrZmFhofmb3/zGbG9vN3/2s5+ZHo/H/Kd/+qejyv7iF78w582bZ5aXl5tf//rXT3jeNWvWmN/73vfM3bt3m9u3bzdvu+02s7q62ozH45NlVq1aZX784x83+/v7J1+RSOSibdNjjz1mtra2Tqnv8PDwlDIPPfSQWVVVZa5du9bcvHmzuXz5cnPlypUXbZuGhoamtOf55583AfOPf/zjZJnpvE8PPPCAecstt0y59tjY2AnP+9RTT5k2m8387ne/a+7Zs8f8+Mc/bgYCAXNwcHCyzHTepzNp08X+PJ1Jm6bzeTqf7ZrOZ0qI6SIB4CXo9ttvNz/2sY9Nee+9732ved999015r6enx6yoqDB3795t1tTUnDSweLehoSETMF9++eXJ91atWmV+9rOfPdOqH9f5atNjjz1mzps377jfHx8fN61Wq/mzn/1s8r19+/aZgLl+/frTbsc7Xaj79NnPftZsaGgwDcOYfG8679MDDzxg3nXXXad13qVLl5qf/vSnJ7/Wdd0sLy83H3/8cdM0p/8+nUmb3u1ie57OpE3T+TyZ5oW7VxfymRJiusgQ8CVo5cqVrF27loMHDwKwY8cOXnvtNW699dbJMoZhcP/99/PII4/Q2tp6RteJRCIABIPBKe//6Ec/IhQKMXv2bD7/+c+TTCbPsCVvO59tOnToEOXl5dTX13PffffR1dU1+b0tW7aQy+VYvXr15HstLS1UV1ezfv36i7ZNb8lms/zwhz/kYx/72FGbtk/XfQJ46aWXKC4uprm5mU9+8pOMjo6esA1btmyZcg9UVWX16tWT92C679PptulYLrbnCc6sTdP1PJ3vdr3lQj9TQkyb6Y5AxenTdd38m7/5G1NRFNNisZiKopj/8A//MKXMP/zDP5g33XTT5F+wp9uzpOu6efvtt5tXXXXVlPf/5V/+xXz22WfNnTt3mj/84Q/NiooK85577rlo2/S73/3O/OlPf2ru2LHDfPbZZ80VK1aY1dXVZjQaNU3TNH/0ox+ZNpvtqOOWLFli/rf/9t8uyja9009+8hNT0zSzt7d3yvvTeZ+efPJJ85e//KW5c+dO8+mnnzZnzpxpLlmyxMzn88c8Z29vrwmY69atm/L+I488Yi5dutQ0zem/T6fbpmNd42J7ns6kTdP5PJ3Pdr3ThX6mhJguEgBegp588kmzsrLSfPLJJ82dO3ea//Ef/2EGg0Hz+9//vmmaprl582azpKRkygfY6QYWDz30kFlTU2N2d3efsNzatWtNwDx8+PAZteUtF6JNpmma4XDY9Pl85r//+7+bpnl+f2FdiDbdfPPN5nve856TlrtQ9+lY2traTMB84YUXjvn96Q4Az0eb3u1ie56O5XTbZJoX9nkyzQvTrgv9TAkxXSQAvARVVlaa3/zmN6e89+Uvf9lsbm42TdM0v/71r5uKopiapk2+AFNVVbOmpuak5//0pz9tVlZWmkeOHDlp2Xg8bgLms88+e0Ztecv5btM7LV682Hz00UdN03z7QzwcDk8pU11dbX7ta1874/aY5vlvU0dHh6mqqvnMM8+ctOyFuk/HEwqFzG9/+9vH/F4mkzE1TTOffvrpKe9/5CMfMe+8807TNKf3Ph3Pidr0Thfj83Q8p9qmd7pQz5Npnv92TcczJcR0kTmAl6BkMjllQ20ATdMwDAOA+++/n507d7J9+/bJV3l5OY888gjPPffccc9rmiaf+cxnePrpp3nxxRepq6s7aV22b98OQFlZ2Zk3iPPXpneLx+O0tbVN1nfRokVYrVbWrl07WebAgQN0dXWxYsWKi7pN3/ve9yguLub2228/adkLdZ+Opaenh9HR0eNe22azsWjRoin3wDAM1q5dO3kPpvM+HcvJ2gQX9/N0LKfSpne7kM8TnP92TcczJcS0me4IVJy+Bx54wKyoqJhMhfCLX/zCDIVCJxxiOdbQ4g033GB+4xvfmPz6k5/8pOGXlFsAAALvSURBVOn3+82XXnppSqqDZDJpmqZpHj582Pwf/+N/mJs3bzbb29vNX/7yl2Z9fb157bXXXrRt+qu/+ivzpZdeMtvb283XX3/dXL16tRkKhcyhoaHJMg899JBZXV1tvvjii+bmzZvNFStWmCtWrLho22SaE3Ohqqurzb/5m7856hzTeZ9isZj513/91+b69evN9vZ284UXXjAXLlxoNjU1mel0+rhteuqpp0y73W5+//vfN/fu3Wv++Z//uRkIBMyBgYHJMtN1n860TRfz83SmbZrO5+l8tss0p++ZEmK6SAB4CYpGo+ZnP/tZs7q62nQ4HGZ9fb353//7fzczmcxxjzlWYFFTU2M+9thjk18Dx3x973vfM03TNLu6usxrr73WDAaDpt1uNxsbG81HHnnknOTCOl9tuvfee82ysjLTZrOZFRUV5r333nvUnJ1UKmV+6lOfMgsKCkyXy2Xec889Zn9//0XbJtM0zeeee84EzAMHDhx1jum8T8lk0rz55pvNoqIi02q1mjU1NebHP/7xKYHc8dr0jW98w6yurjZtNpu5dOlSc8OGDVO+P1336UzbdDE/T2fapul8ns5nu0xz+p4pIaaLYprH2ZZACCGEEEJclmQOoBBCCCHEFUYCQCGEEEKIK4wEgEIIIYQQVxgJAIUQQgghrjASAAohhBBCXGEkABRCCCGEuMJIACiEEEIIcYWRAFAIIYQQ4gojAaAQQgghxBVGAkAhhBBCiCuMBIBCCCGEEFcYCQCFEEIIIa4wEgAKIYQQQlxhJAAUQgghhLjCSAAohBBCCHGFkQBQCCGEEOIKIwGgEEIIIcQVRgJAIYQQQogrjASAQgghhBBXGAkAhRBCCCGuMBIACiGEEEJcYSQAFEIIIYS4wkgAKIQQQghxhZEAUAghhBDiCiMBoBBCCCHEFUYCQCGEEEKIK4wEgEIIIYQQVxgJAIUQQgghrjASAAohhBBCXGEkABRCCCGEuMJIACiEEEIIcYX5/1Twma4ZK1xiAAAAAElFTkSuQmCC", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "flattened_coms = coms.reshape(-1, 2)\n", + "P = flattened_coms.shape[0]\n", + "colors = plt.cm.viridis(np.linspace(0, 1, P))\n", + "\n", + "plt.figure()\n", + "plt.scatter(flattened_coms[:, 0], flattened_coms[:, 1], c=colors, s=10, alpha=0.5) # 's' is the size of the points\n", + "plt.colorbar()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "87f83897535c4e2da9abf799ff214c3c", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,4, sharex=True, sharey=True)\n", + "\n", + "ax[0].imshow(np.sum(mrc_array, axis=(2,3)), cmap='plasma')\n", + "ax[0].set_title('Bright Field')\n", + "\n", + "ax[1].set_title('COM X')\n", + "ax[1].imshow(coms[:,:,0], cmap='plasma')\n", + "\n", + "ax[2].set_title('COM Y')\n", + "ax[2].imshow(coms[:,:,1], cmap='plasma')\n", + "\n", + "ax[3].set_title('Clustered')\n", + "ax[3].imshow(label_image, cmap='viridis')\n", + "\n", + "for a in ax:\n", + " a.axis('off')\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pytemlib", + "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.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From b2597c81bbaad0d93d6bdf3846ba17fe108a0703 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Tue, 3 Sep 2024 19:18:39 -0400 Subject: [PATCH 03/14] changed energy scale metadata for EDS --- notebooks/Spectroscopy/EDS.ipynb | 523 ++++++++++++++++++++++--------- pyTEMlib/eds_tools.py | 6 +- 2 files changed, 385 insertions(+), 144 deletions(-) diff --git a/notebooks/Spectroscopy/EDS.ipynb b/notebooks/Spectroscopy/EDS.ipynb index 7b511da8..2497d743 100644 --- a/notebooks/Spectroscopy/EDS.ipynb +++ b/notebooks/Spectroscopy/EDS.ipynb @@ -48,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 1, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -61,7 +61,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "installing pyTEMlib\n", + "installing pyTEMlib\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "done\n" ] } @@ -129,9 +135,8 @@ "You don't have igor2 installed. If you wish to open igor files, you will need to install it (pip install igor2) before attempting.\n", "You don't have gwyfile installed. If you wish to open .gwy files, you will need to install it (pip install gwyfile) before attempting.\n", "Symmetry functions of spglib enabled\n", - "SimpleITK not installed; Registration Functions for Image Stacks not available\n", - "install with: conda install -c simpleitk simpleitk \n", - "pyTEM version: 0.2024.02.0\n" + "Qt dialogs are not available\n", + "pyTEM version: 0.2024.02.2\n" ] } ], @@ -185,7 +190,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -230,12 +235,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8311a0f14aee400abb3491c2531ccf91", + "model_id": "0ca812c4348343c990897ee0c28dec59", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "VBox(children=(Dropdown(description='directory:', layout=Layout(width='90%'), options=('C:\\\\Users\\\\gduscher\\\\D…" + "VBox(children=(Dropdown(description='directory:', layout=Layout(width='90%'), options=('/Users/austin/Desktop'…" ] }, "metadata": {}, @@ -257,18 +262,18 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "17f94d888644492482da183e579363fd", + "model_id": "bdc32be285e3461f8c55728ce86f92c9", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "Dropdown(description='select dataset:', options=('RCOB-3,5Zn_Area5_LiveMap1_SpectrumImage: RCOB-3,5Zn_Area5_Li…" + "Dropdown(description='select dataset:', options=('RCOB-CuZn-Eck_top_Area3_LiveMap1_SpectrumImage: RCOB-CuZn-Ec…" ] }, "metadata": {}, @@ -290,7 +295,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b5066e068c78401fbffe41334b51bf8f", + "model_id": "2deadc7b8e124337b6b0863440e1340e", "version_major": 2, "version_minor": 0 }, @@ -304,18 +309,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "eac19b35095d4daca7b9a4a447771c83", + "model_id": "f963d45d95bf46a3a1975107d1a8bbbf", "version_major": 2, "version_minor": 0 }, - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9ebRseV0dvr/DOaeq7r3vNd0N3bQ02EQGBQVlEHBq46IjJMgQp5DFlKgMDYodFyLiT0SExBgXCoIxKuhSIlEEibDAJgKiwBJoomBciIQx0LY9vXtvDeec7/D7Y38+31OXfg0Cfenhffdab/V799atOnWqbp9d+/PZe5ucc0ZFRUVFRUVFRcUZA3tzH0BFRUVFRUVFRcWXF5UAVlRUVFRUVFScYagEsKKioqKioqLiDEMlgBUVFRUVFRUVZxgqAayoqKioqKioOMNQCWBFRUVFRUVFxRmGSgArKioqKioqKs4wVAJYUVFRUVFRUXGGoRLAioqKioqKioozDJUAVlRUVFRUVFScYagEsKKioqKioqLiDEMlgBUVFRUVFRUVZxgqAayoqKioqKioOMNQCWBFRUVFRUVFxRmGSgArKioqKipuBXjVq16FF7/4xTf3YXxReMlLXoJ73vOe6LoOF110EX7mZ34G4zh+Sff5lre8BQ9+8IOxWCxw7rnn4olPfCKuuuqqm+iIb/uoBLCioqKiouJWgFsrAfy5n/s5/MiP/Age85jH4M1vfjOe9rSn4YUvfCEuvfTSL/o+3/72t+NhD3sYzjvvPPzRH/0RfumXfglvectb8B3f8R3o+/4mPPrbLkzOOd/cB1FRUVFRUVHxufGv/tW/wgc/+EF87GMf+7y3jTEihICu647/wD4HrrnmGtzpTnfC4x//ePzX//pfy9df+MIX4rnPfS4++MEP4mu+5mu+4Pt94AMfiOVyib/6q7+C9x4A8M53vhPf9E3fhJe97GV46lOfepM9h9sqqgJYUVFRUVEh+Md//Ef80A/9EC688EJ0XYfb3/72+KZv+ia85S1vKbe5+OKLce973xvveMc78KAHPQjz+Rxf8RVfgZ/6qZ9CjPHI/Q3DgBe84AVl/Hn7298eT3rSk/CP//iPN3jsV73qVXjwgx+M3d1d7O7u4r73vS9+4zd+ozzmG97wBnz84x+HMab8AYCPfexjMMbg53/+5/GCF7wAF110Ebquw1vf+la88pWvhDHmBqTxbW97G4wxeNvb3naD5/Wud70LD3nIQzCfz/GVX/mVeMUrXgEAeMMb3oBv+IZvwGKxwNd+7dfiTW960+c9n29605uw2WzwpCc96cjXn/SkJyHnjNe97nWf9z4+G//v//0/vOc978HjHve4Qv4A4CEPeQjufve747Wvfe0XfJ9nIvznv0lFRUVFRcWZgcc97nG44oor8HM/93O4+93vjuuvvx5XXHEFrrnmmiO3u/LKK/H93//9ePazn43nP//5eMMb3oAXvOAFuO666/DSl74UAJBSwiMf+Ui84x3vwLOe9Sw85CEPwcc//nH89E//NC6++GK8973vxXw+BwD8f//f/4ef/dmfxWMe8xj8h//wH3Dy5El88IMfxMc//nEAwMte9jL80A/9ED7ykY/cKMH55V/+Zdz97nfHL/zCL+DEiRO4293uhiuvvPILev5XXnklnvSkJ+FZz3oW7nSnO+ElL3kJ/t2/+3f45Cc/iT/4gz/Ac57zHJw8eRLPf/7z8ahHPQr/9//+X1xwwQU3en8f/OAHAQBf+7Vfe+Trd7zjHXHuueeW738h0J/5uq/7uht87+u+7uvwF3/xF1/wfZ6JqASwoqKioqJC8Bd/8Rf4gR/4AfzgD/5g+dojH/nIG9zummuuwR/90R/hu77ruwAAl1xyCdbrNV7+8pfjWc96Fu585zvjf/yP/4E3velNeM1rXoPHPOYx5Wfvc5/74AEPeABe+cpX4qlPfSo++tGP4oUvfCH+7b/9t/id3/mdcruHPvSh5e9f8zVfg7POOgtd1+FBD3rQaY99NpvhzW9+M5qm+aKf/zXXXIM3v/nNuN/97gcAuP/974873OEO+I//8T/i7//+7wvZu+CCC3Df+94Xr3nNa/CMZzzjc95f13XY2dm5wffOPvvsGxDrf+ox6s/fVPd5JqKOgCsqKioqKgQPfOAD8cpXvhIveMEL8O53v/tGnap7e3uF/Cke+9jHIqWEP/uzPwMA/PEf/zHOOussPOIRj0AIofy5733vi/PPP7+MXy+//HLEGL8kUwQAfNd3fdeXRP4AKnNK/gASqjvc4Q64733ve0Tp++qv/moAKArl54KOqr/Q732x9/ul3OeZhEoAKyoqKioqBK9+9avxhCc8Ab/+67+OBz/4wTj77LPx+Mc//gaj1PPOO+8GP3v++ecDmBSqf/iHf8D111+Ptm3RNM2RP1deeSWuvvpqACj7gHe6052+pGO/4x3v+CX9PHB6Va1t2xt8vW1bAMBms/mc93fOOedgs9lgtVrd4HvXXnvtaR/v8+Gcc84BgNMqfV/sfZ6JqCPgioqKiooKwbnnnosXv/jFePGLX4xPfOITeP3rX49nP/vZuOqqq46YHv7hH/7hBj+rJFEJyrnnnotzzjnnRs0Se3t7AIDb3/72AIBPfepTuPDCC7/oYz+d8jWbzQDgBtEoSj6PG7r794EPfADf+I3fWL6uBPje9773F3yf+jMf+MAH8PCHP/zI9z7wgQ98Ufd5JqIqgBUVFRUVFafBne98Zzz96U/HQx/6UFxxxRVHvndwcIDXv/71R772qle9CtZafOu3fisAxrZcc801iDHi/ve//w3+3OMe9wDA/UHnHF7+8pd/zuPpug7r9foLeg5f+ZVfCQD467/+6yNf/+xjPy5853d+J2azGV75ylce+bq6kx/1qEd9wff5FV/xFXjgAx+I3/md3zniun73u9+ND33oQ0f2LStuHFUBrKioqKioAHDq1Cl8+7d/Ox772Mfinve8J/b29vCe97wHb3rTm25AKs455xw89alPxSc+8Qnc/e53xxvf+Eb8t//23/DUpz4Vd77znQEA3//934/f/d3fxcMf/nD8yI/8CB74wAeiaRp86lOfwlvf+lY88pGPxKMf/Wh85Vd+JZ7znOfgZ3/2Z7Fer/Fv/s2/wcmTJ/F//s//wdVXX42f+ZmfAUA17Q//8A/x8pe/HPe73/1grcX973//z/mcHvCAB+Ae97gHfuzHfgwhBNzudrfDa1/7Wvz5n//58ZzEz8LZZ5+N5z73ufipn/opnH322bjkkkvwnve8B8973vPwAz/wA0cyAD/2sY/hoosuwhOe8IQbEMbPxn/6T/8JD33oQ/E93/M9eNrTnoarrroKz372s3Hve9/7BpEzFTeCXFFRUVFRUZE3m01+ylOekr/u674unzhxIs/n83yPe9wj//RP/3ReLpfldt/2bd+W73Wve+W3ve1t+f73v3/uui7f8Y53zM95znPyOI5H7nMcx/wLv/AL+T73uU+ezWZ5d3c33/Oe98xPfvKT84c//OEjt/3t3/7t/IAHPKDc7uu//uvzK17xivL9a6+9Nn/3d393Puuss7IxJusl/KMf/WgGkP/zf/7Pp31ef/d3f5cvueSSfOLEiXz7298+P+MZz8hveMMbMoD81re+9QbP67Nxl7vcJf/Lf/kvb/B1APnSSy/9vOc155x/6Zd+Kd/97nfPbdvmO9/5zvmnf/qn8zAMR27zgQ98IAPIz372s/9J9/knf/In+UEPelCezWb57LPPzo9//OPzP/zDP/yTfrYi59oEUlFRUVFR8QXg4osvxtVXX/1FZdhV3Dhe9rKX4VnPehY+8pGPnNZkU3HTou4AVlRUVFRUVNzseOtb34of/uEfruTvy4S6A1hRUVFRUVFxs+P3f//3b+5DOKNQR8AVFRUVFRUVFWcY6gi4oqKioqKiouIMQyWAFRUVFRUVFRVnGCoBrKioqKioqKg4w1BNIBUVFRUVnxMpJXz605/G3t7eaevGKioqvrzIOePg4AAXXHABrP3itLxKACsqKioqPic+/elPf0kdtRUVFceDT37yk7jTne70Rf1sJYAVFRUVFZ8Te3t7AHixOXHixM18NBUVFfv7+7jwwgvL7+YXg0oAKyoqKio+J3Tse+LEiUoAKypuQfhSVjKqCaSioqKioqKi4gxDJYAVFRUVFRUVFWcYKgGsqKioqKioqDjDUAlgRUVFRUVFRcUZhkoAKyoqKioqKirOMFQCWFFRUVFRUVFxhqESwIqKioqKioqKMwyVAFZUVFRUVFRUnGGoBLCioqKioqKi4gxDJYAVFRUVFRUVFWcYKgGsqKioqKioqDjDUAlgRUVFRUVFRcUZhkoAKyoqKioqKirOMFQCWFFRUVFxi8bBZry5D6Gi4jaHSgArKioqKm6x+MU/+RC+9nl/gjd98Mqb+1AqKm5TqASwoqKiouIWi1/+078HAPz06z94Mx9JRcVtC5UAVlRUVFRUVFScYagEsKKioqLiFg8Dc3MfQkXFbQqVAFZUVFRU3OJhKv+rqLhJUQlgRUVFRcUtHpX/VVTctKgEsKKioqKioqLiDEMlgBUVFRUVt3iYOgOuqLhJUQlgRUVFRUVFRcUZhkoAKyoqKioqKirOMFQCWFFRUXErxote9CI84AEPwN7eHu5whzvgUY96FD70oQ8duc0Tn/hEGGOO/HnQgx50Mx1xRUXFLQGVAFZUVFTcivH2t78dl156Kd797nfj8ssvRwgBl1xyCZbL5ZHbfed3fic+85nPlD9vfOMbb6Yj/uJQVwArKm5a+Jv7ACoqKioqvni86U1vOvLvV7ziFbjDHe6A973vffjWb/3W8vWu63D++ed/uQ/vJkMlgBUVNy2qAlhRUVFxG8KpU6cAAGefffaRr7/tbW/DHe5wB9z97nfHD/7gD+Kqq6660fvo+x77+/tH/tzcqE0gFRU3LSoBrKioqLiNIOeMyy67DN/8zd+Me9/73uXrD3vYw/C7v/u7+NM//VP8l//yX/Ce97wH//yf/3P0fX/a+3nRi16EkydPlj8XXnjhl+sp3Cg+ce3q5j6EiorbFEzOOd/cB1FRUVFR8aXj0ksvxRve8Ab8+Z//Oe50pzvd6O0+85nP4C53uQt+7/d+D495zGNu8P2+74+Qw/39fVx44YU4deoUTpw4cSzHfmP4yme/ofz9Y//xX35ZH7ui4paK/f19nDx58kv6naw7gBUVFRW3ATzjGc/A61//evzZn/3Z5yR/AHDHO94Rd7nLXfDhD3/4tN/vug5d1x3HYVZUVNxCUAlgRUVFxa0YOWc84xnPwGtf+1q87W1vw0UXXfR5f+aaa67BJz/5Sdzxjnf8MhxhRUXFLRF1B7CioqLiVoxLL70Uv/M7v4NXvepV2Nvbw5VXXokrr7wS6/UaAHB4eIgf+7Efw7ve9S587GMfw9ve9jY84hGPwLnnnotHP/rRN/PRV1RU3FyoCmBFRUXFrRgvf/nLAQAXX3zxka+/4hWvwBOf+EQ45/CBD3wAv/3bv43rr78ed7zjHfHt3/7tePWrX429vb2b4YgrKipuCagEsKKiouJWjM/n45vP53jzm9/8ZTqaioqKWwvqCLiioqKioqKi4gxDJYAVFRUVFRUVFWcYKgGsqKioqKioqDjDUAlgRUVFRUVFRcUZhts0AXzZy16Giy66CLPZDPe73/3wjne843Pe/u1vfzvud7/7YTab4a53vSt+9Vd/9ct0pBUVFRUVFRUVXz7cZgngq1/9ajzzmc/ET/7kT+L9738/vuVbvgUPe9jD8IlPfOK0t//oRz+Khz/84fiWb/kWvP/978dznvMc/PAP/zBe85rXfJmPvKKioqKioqLieHGb7QL+xm/8RnzDN3xDycgCgK/+6q/Gox71KLzoRS+6we1//Md/HK9//evxt3/7t+VrT3nKU/BXf/VXeNe73vVlOeaKioqKWyJuit7RLxa1C7ii4oa4KX4nb5MK4DAMeN/73odLLrnkyNcvueQSvPOd7zztz7zrXe+6we3/xb/4F3jve9+LcRyP7VgrKioqKioqKr7cuE0GQV999dWIMeK888478vXzzjsPV1555Wl/5sorrzzt7UMIuPrqq0/bmdn3Pfq+L/9OKeHaa6/FOeecA2PMTfBMKioqvhTknHFwcIALLrgA1t4mP+9WVFRUfFG4TRJAxWeTsJzz5yRmp7v96b6ueNGLXoSf+Zmf+RKPsqKi4rjxyU9+Ene6051u7sOoqKiouMXgNkkAzz33XDjnbqD2XXXVVTdQ+RTnn3/+aW/vvcc555xz2p/5iZ/4CVx22WXl36dOncKd73xnPOq7noQrzV2w2WngxgwkwMimZTaADRnJG5gMJA/E1sBGfi87wCTA9RluyAgz3i4bfj07wI7AsGfg17zT5A3aw4TYGMTO8OcHfi9boD2IGE44GHkMv0n8u+Mxxc7CpAw7TscVGwM3ZpiYkRoDGzKyMTB5+m9YWCACsIBfJ8TWAkKasyNpNgnIHkACkPmYbsgYFxYmA81hQpgbJG9gY4ZJQOj43LIDTATGPQO3AWzKQARSa2BS5nmRx4CRxzDT49gxY9yx8H1GNkCYGdjA72Xh9G4ETMwwAEIrzzkAsePx8JwC7QFvo6+hPraef5N4fMkaHicAM2aehwzA8f6bVUb2QHKGj5vkHBnAxoxsDeyY+R5pDOyQETuDdj8gdk5eB55fkzPskJAdla3UGKSGj2cD3zt+zcdD5nE2y4Rxx0KfjF8lhIWFHbO8bxLCnP/WY0mNkdcU5UlnZ5AtXwu34THpewcA2v2IcdfChgwTgTDne0Pf56nh87cRGHYtXM/nrO/x2BoYAG6TYRLfl8kZvncTH8ttElLHY8zGIM74OiCD56bPGGyP9735hbXztqKiouKzcJskgG3b4n73ux8uv/xyPPrRjy5fv/zyy/HIRz7ytD/z4Ac/GP/zf/7PI1/7kz/5E9z//vdH0zSn/Zmu69B13Q2+/vd3uQg7Vy8wCxlZyME4J4mCM0gW8Bu5yDsDBwBCjJIxJEApI+4Y5Abork+ILS/CsTHADGgM0OaEbA2iBdJZBn7I8Bm8uLdAmBvMro/IuwaNAXIrRG4H8OvMC/SY4RIw7ho0pxJMyOjPcvAJ8CnBhoyxc7COBNHEDBhe0LtAUpUd0K4jRm95YRbyCQM0q4jhpEecAzYA48IAQ0aTSaLGOxo0hxnZAjbzmLshw7QkRnEBtMkgz0Ay3QBoDVxPgtgeJiRHcjDukcAh82fT3KCNGXGPx2SNQZqjkBiTwOcFEmVjDdIuYIcMF4Hc8rF8BLAAmnVG6AzgeHs7gsTZChnyfF1hSFzhgXGHJMwGoBmB3PF2Toix1fVS/WDgDKzN8DFhnDs4l4DGwO4k5Nai3Q8YdxxcnxHnBnnXwK0TYHmfCLyv1BkYb9AgwvQZceaQvAFOAN7y3MfWwI8RuXMwDU+KO0xIM4t2jIC+X41BnFsgA80y8n4SMM4dfMqwTthwAmJrYWKGmyXYaDDuWvhlAhp+HV4IdMPX0BjADSTc7UgyCgA+Zqxub9FdldDvWbghowkZZk6ibI2BNRnWAhYkiNaRfGdHgpgXgNvw/upKRkVFRcVR3GaXYi677DL8+q//On7zN38Tf/u3f4sf/dEfxSc+8Qk85SlPAUD17vGPf3y5/VOe8hR8/OMfx2WXXYa//du/xW/+5m/iN37jN/BjP/ZjX/BjB3iSPWOo1lhetAASBmSqTjbI14S0pYZExW+yqBpAs5KL25jL/bghF8UvdAbNOlOZc1TPIBd3E4FxbhFmVNjCzCDMDSBqid8kkk6PSRmzBt2pWI4tdQbNMsJEPn6cUdWxQgSbVcLsuojUGCpGISO2VCKzkduPfE7JU9lUNcokoFmq6kNFqFklGFGwxoUoa/J1G1DOg9+IsjQj6cz6ThbyB1CVDDOSQjfy39mh/PE9n0Ns5HECiVpyhq+HE8XQ8k9s+TqZRAKdGnndvBJ6Ej4Tef6zBdpDPnbyfG3CjGSVKh1/PluS/2zk384g7Fj4VdpSio2odBmuzwhzi+Sm5x1mFtkbuCEdIbjZG6TGFkXUJFEdY0Z3fUSYC2HrpzAAk6kKx7mDHfl6qKqYGoM4O/q/jSgKIc+9vv4W2ZPQDycsj8vw/aWv/bBrywcbiIJIxZDHsnNVQjZAt5/4vkhC1COPBVlU3oWFXycqhY1BdkL4wxf8q1tRUVFxxuA2qQACwPd93/fhmmuuwfOf/3x85jOfwb3vfW+88Y1vxF3uchcAwGc+85kjmYAXXXQR3vjGN+JHf/RH8Su/8iu44IIL8Mu//Mv41//6X3/Bj+16XhRJlDiuDDNL4rDJsJYXp2x4m9AZjlwHuahFFHIFUS6SV9VrInjNOmHYschGiJUxyIYX+faQpHCc24lQui2yI+PGJO+AZkXWZIOOHGNRY5B4oQWo1Iy7nB3HhkplmFlkx/Fi7Ey5rzCzJE0gwXHWlFHzsGvlXPHvTsalepFPzhRSYqOMNz3Jlf6MDSSDOgL2myykK6E/YZEag+4gIzmUcaiJk3KXZMQcZyjk1fUZw56BSUZUvgzIuXcjkNxElJolyY5JQri3SB3A/8bWFGLnhgwzgiNqOxFVjr4zcmvLGBQgebKB48zYkUgPJ3wZy/pVQvZAnNtC6sLccYzrLZrDSLJmALemWpyEvMXOwsRU1hGyI0E2gS+Ajl3DzCEsLPyGZDR5C9cnIOnY3xTVM3m+N5s1n0A2XE1ABkInr7GQXX4QIDFNhu+d1Bgh3dMqAnIuaiUM368pQj6Q8PzYAAwnqIragSqijph11F9RUVFRcRS3WQIIAE972tPwtKc97bTfe+UrX3mDr33bt30brrjiii/5cXW3iftOuRAJI8pfbAzSQi6cgKhnoLqUgdAA2dmizgEg6eumHafUGKSRu4OjXKBNIuG0gYqTyaaQpP6ERbef4PKkPCqJcuWCm5GyEhoLt05IjcW454qyZAPJl+8z/Ib7ZN11EXFuETtTVB6TMpplwrBnYSMfH9CxK2837Bq0hyRAyRn4kIuali0QreyeiQKXPOBl7GyEFDYrUfkGlH3FMBMFz3Ih0I4Zvs9FFU0N4NccKYdOSETMZXfQRFFqjREiz+eULe+jXU7KnI0ZY8fX0gQZZ7ZGXjuztVdJMmITgMxzqOquyUC2Fu1hKsQmeZRxNgzfP26TuJfYWjTLSJXNAs1BLCPa1BhkL4rY1s+mxop6mWGHDJNN2e2MrYHpZTev5X2akHmsFmWPzxjAhsTH1V3SbAr5UzVSX38bMsbWolklZGcw7Fq+hmv9RUEhx0GOP1tg3JGd1ACYZBBbUfxShrEGrk8Ydp2ogqIgWyP7svKaRcClSgArKioqbgy3aQJ4cyG20/J8NoDvZVevNYi7NBdYMRogYzJwtAbDLslEEiMBydCkFLqBSlm3H7C5nePPL3khHHYsZtdHMQOIwib7ePp42RqYmIrCGOYWCBluTAgzCz+QhIy7DibycZuDyGX7ISPJHmFy3KsyURWoad+RRNUgNpPJwkYd8QnZMpOJxQYAQpDcwOfhN6IiORI5VeeS5/nR28ZWdiY3qYydVeVCBmxPIj7OpzEvIlWqYdeWsaWaMZLsYpJ8ZIS5GE4iiiGkt6pmmWnvT8iW62m+sBHIohY6UU9DRzLjexJFG8V0MTNFcWv6VAiqEmq/SmJwEMIYM8Y9BxMz/DJR5csoI2COdYGxI+GyYxYVMCLsuKIKqpKshBtAGXGHhSu3MXnaF41eSOeS75O04A/p+DZbUZkjYGXXUMl/s0yTujnj48ZdC4DkOXmU18hEIf5iVHKbDDsmElQjhiFZQyjHLeKs31D9NgFohnST/V5XVFRU3JZQCeAxQC9iUQjb+nYOzZqKiF7Qctkx40VdSYIbdWybCpFCJqkIHa92YWaQjaPa1GBSsQKoAsnumom5uGuzAxBIONRF69YJThQvt07IxvB7UYicEjtDxyUM5L8W45wkSFVNYFJ+3KB7eij7ayRYsqCPaQcui8KkO4BhRpJkEs9ddLzP2MgunB7vQBLJfTBg2LFlV81EnuPYbt1+nJyxdqCK5tcZ/QkqlIgktePCoF3Kfl/eOqeNKXt+Sl50302fb7YG/Z4Vl+o0ms6Y3M/lfGXdKxTX9kZczYbHR1OIOr857oUhIVTXdrNMcJuIFG3ZW7RDQtp1cDlzRDszol6CRhDZ1eT9kRSmxiLOxKRhQaPJnkOGkbGzLc50fb/q7d0o6wXWTiTQAH4UIt9n+B5lNzPMDHzPD0cp8P70Q4qqiFYU2NhNSmZqDVIj4+2ZnXZJWyp+7YG4l+V3LMjxRXebXXOuqKio+JJQ/+94DEgtSpRG6Bj9oeNTVZpsJNkzW/t1GgfihlwIR5hxP0qVQjdktMsshCLB91TX1DihC/pGzCLbcSA6no2yT5caqilldOsAfxi3jpUXexiqS2FuZURoyp6eHbkDWEaNnoRtnFuMO1YIjo7BeX7CXMd1k7FASVZsSV5JqnjumlUuo+9mzX9nS0KcGpo5yj5dELVLjSeNESWLZC3J8yBBTej2E/w6ldegWXMMrYptNiSPGskDMeaMCyvKHUncsGMRNIKnzzKyNlN0T0CJ11GlyoYMO07fyxYYdy1iZ8v4WBVKmht4DtyQ0BxEZAeMu56vkUSyDCc9P0TojuU6TSsDokiXsWgG4nxSBFNnkGXn1Ml6QnZUirPsMwYxAU3nUVTlNH0QmF0X5flB9gZNcTnrnuu26QTg8dnI11LPY3uYipHKqrM8UUkMM35YyVaUxBlHw2G2tU8L1BFwRUVFxY2gEsBjgI6zsqNRI1uO82JHxUrVn+S4j1ZUoK0cPhvEZLFOU5adNcVNrDtmOhJUc0cUF6QSEypUclxCktrDyBiRjrtpqio1hxFJ3JtuHWElPy9bElqNXuFYW3Lbci7HpPuKQXMFZVSshFFHiiQx036jGj8AFLIXZlT01DlL1YiPPS5I/IqZALKzh8lJrTmKxT3qOK5tVqmc/9XtPcaFLftjmsFox2lsCkBUyYlJqJEBoAKrpJP7eRJ1k1HMN0p4vOzw6X1ky+ehx25DLqNvVQ9NzMVVrA5XQAwfM+5dDntO9vJMcRObSFKkJiK/JMktx93p883l/qKQxLBwYqqQN0yeHNMm81xmQxMI38OiTuv5Wui+Zy5u99CRMKrhxeRpZJs8SZt+8GgPuTOYHGT/j2Nok6lQqgs8646o44eRIIYnvi587qqsV1RUVFQcRSWAxwBd3k8eRTHpTkVm1nkUUwhjTXh7EjiqeYCQrE2WC7UqdiRXeYtIAeCFVx2nlj+rhpFmleBXiURtpAEACUUBy0bcpG5SBMOMSl+c20I0iwolZElBsse/+3WGG1IhUjpCjQ0KCbWBhgx9jjouny7qEykh0ZueUzHNqLJmJf5ki5Ap8SQxspNDN6EEYTPgenq9UkPiqeNdHUurazureUJcrMWUIcaS9TkcJydnqBaOfB1jowYdkl3NSMyWt4v6uGOGX4ry2ucSDk4yZklsVgn+MPLxMzDueaqRS3Fv6yhWR82J4+TUGNhxyxmbUMKUw5xfc72Qw5GvH1+cjP6kI8mS91aJghFX9biwRVV1g7jZhSgnec8qiVcVNsysKL6Twqjkm2r1FA1jMs9PdjyP2RjE1mLcdeX5KvR3ZNizaJapHGds6//iKioqKk6H+n/HYwBHlxxHDTu8mG3OciSDMubKsiDP0R8vgMOOkplU9vYYW8KLXbPaUjOE9CFjIoRmMhzogrzrdVeNL3X207g4m8m1q20PHD1zTzB5I+NIFBIETMesbmLNGRxOWMZ9DEKAZGeRJGzKiwudKUpS8kIazESQlKQ0yyRqFqasQjlvbM5QlYlfU/NG6KiKdvtJ9iXpONaMPZNQdvx8n9EeJIwLI00hPG9KlmI3RZnEVrMOeazjgqPTdp/qpMm57PdtK4ZKlOJWVqINfD2TtF6U4+qm+7dDRnPITMbsDVI7xb24DYm9vi7Z8fGzNXDrCC9RLOPCIuy4ohzqaNlJBqQ/jIUMllUEyUPsro9lrK+kdNgV0igklyPdLE5s2aOcmzKy5n6rvE8lwoik0oixQz4UrPM0vh3zpLrqXmfW90BGux+pqMsHkXFhy3szW2B9jucI+aAaQCoqKipuDJUAHgOSKD/ZivkgUklK0iChI0mqSKkoWCaztg1AUVPU6Tou+EdvB8iIuE9ChFAuriZTjVMnMgOXY7kga15bWHBRnsaPXFQYJZ2uT3C9ODfN9HPqls1uqp6LkuHm+2nE6noeayN7aOpgtmK4sGOefr41YtowZTyanUF3oAHAVI3U6cs9QFEYlZiNW9VqzpQ9QY4Vc1ENhx2ey+RJVkYZWVpRBk2k+qhqpBJVAEJIdMdPMwW1uo/P0fdUB5XsMy5lUjv1PFJNJBkKc1tyDgES4LCwEuTM78eZ3iYXEg5LomPCZMIp9XNmS10VQkiFlmTYpMyRv9sK6G4MUsfA8LCw5T2h+5RuyKXZJBuJb4E2oMj4fRTFVvYpt13WVA4lG1MItJPdUBv4AWZz0hYzj0YA6ft6FCWT7wf+HG83fXhghA/onI51BHxbwWO+/itu7kOoqLhNobqAjwHai9osJ7Jm8jTSVQKg4bZKClX5CZ1Fu0zlYuf7yb2q968GklHGtNMemRyEmDq0ecENJAnwJH40IORCBKh22aKoKQFTV68+Bw0MzpYkge0a3HXs91wxmGgHsBk4dnbNFJtiRxQyakOeYkNkd5IZimKQEdMAgBIBA6BErSRxVYeZkVw9kjq/yazXG7OEZucSlZMdQ5xt1F1NFPODNpyYOI1XB6kisyOkTcXKTt8Un6L7mWpiMZlKGkOWJQxa9j413kTJbnvAEGQnyitfqwzX8/tukxD3XCGh6ua1gWYbIzuGdkgIOw6psTL6led+KEqhGFOyM3DSSLOdv2eSKbt3wLQzGma2mJOOZDKu9f3Dx0/SmDjsTs5ouqVRXivNY9T8QSXUfpic3u1SGl/kA4a+L5D5PtO1AO0JNsmUfmrXyzF30gDTVwJ4W0Gt86uouGlRFcBjQPYTQUueJEZz7HScyXYQU2rSojg0FclNlWJ6QW4kuqNEZCxjISFKHtk4kYqC4sSEkhqDcYcXe60E03qw5Exp2tBles0ojEIk1BU87Oje10QQsiUR1XxDrUdTN2wUQweMODuBKXha40uiPgbKsQfZ49NRso68yy6eGFj8JhViaMeM2fWphDc7MS+EmZFjnPb9dCTLESwQu+l8l3DhuSVZHKfXRgOjqSKasnsZuknB0+dvI0fM7WEqMTLa+csdNzkf4la2g+4aSvzNzFKpld3G9lSgYrdJsAPv06+o1ELiejRqSM0nYW4BK6NSMSGpg1cVSX39/SoV84weh6q+uoe5vXOpLu4w55/YmvI+1dctdPJBQcijkeDv/sSk9vJ9IPulWVpQxmnvUt9X45xk1AbG08QZI3BiRyVXXe/6XgnzShoqKioqToeqAB4D3EZ6aOcWdmS0h+4y+U0qI6wy3jKTIsJYC6p/qrbpaGtccMHdGWDYdaWSrT1IYiyZLnwmc7SLbMoeYBPTpDZKXpzuV1lREWNjxNkqKpHExMSG5K0RgpCdQZJduamiLpeoEivk0Gmm3cjmkWw5Gm8PkzzfSdX0a85oszNHAopja2DJaUt7hyqQVDHlmCN3LptVLvuQqkbaQGXQRpI5JW3zayNGiXBRclZq4xIVJTV+KMkEgGGPCq9GvBTFquG//ZouXBtyyapTgjuNqvmBYNxl7qO6Wse51K1FlExAHX1n+WAAS8XW9pm9wWu2k/hlhIkG2ZsjBghVD5OS1dkUT6Q1b0YIUzGQdJDXKhbHMQkvCbpRhbUx8DGXOjc10SBPsT6q2Lohl1Du9iBP2Y4JgKGap+RZd0u1Qs6OuZzXYXfKAtQ+ZVU8dQRt0uQ0rqioqKg4iqoAHgNiizKiA6aRme7jJVnIn12fZMRFFadZ062rvbK6Q6cX1TJalV0rGxn2m9W0IM5KdWtukweTAL+KRbVLDUmDqk48Trldv5UBKFD3qkkohMkNk/KmNWyqzujeIPfwSB78hoSnPUhFVVJjCNVSU86XlfsDJmOLuoFtkN06CQkm+eNxzk6lor5u99Lq+LGMrkWd0x22ZpXKcTXL6XwoVOFTdVNje4rK2ZliVFFFsYzf+4TuVCxBymX8LuiuC+W1SmIeyWZq14itgV+momZmL9+XEX1zmABxOYcdV/Y1SQpR4ly6U7HE8qgS6KTH10bufMZWCL8YPlQBVCc1IDE5JWxb1FM1iIgiOuxIDmGfRamV/EkhzMOeLfmCzBSc1FRVIBk0LvuU+h7wPGY36K4nyvvHJDUCTUae5rAaQSoqKipOh0oAjwnc5dsmNCSGJaZDWi8AkpM4Z8zFVHDPWA4NHNYF+yRxMQxXNoWkkHzJxXjOMGFdgNcL5bjnYIcko0UjCqEEMMux6Kg6y34aMomBOkG1v1UJKeNuhKj1uezNqclCTQQaQK1ZiBoQXUwnkaSgP8m3ZJRsuXFhC0ksY944kQojY2clh8lLHZynGac/QYawrQT5rbDn5JTYCQnZ6hJWd3JpGKGoVVRW3rEp4cbqYG1WSSJiMI1bJS/PhFxGyErgxl1XjDh+lYohB4C4e/l3t2HNnx1yidoZTjiYkGDHVHYXw9wWE4S+15xEv5TmDolfUZKdLR3ffsORtd8kzK+JVOx2HVtt+mkVgM9dznNZUZhicpRg6/sPQKnP0w832vmrH1xMlHWI1qA/4SRofDKCMBjdSrzPZCzRVQs1/mgOosYhVVRUVFTcEJUAHgP8hv/VuJXu+oTmMEnsxxS+nBpGjKhxg00L00U5tiRx2/EvRWkTp2dqDaIu8nvmyJlIQ0Bq+XW/iqUfNixoJnDSXzvuWPQnbBmJamSJKmiaFQdMil2zooGCF3PNj+Nz2tzOlTiX7efEPuAsO2kTwYrS5qGEzI4oxFkNKHTQ5rKfqI7P2KBU3bX7ohht1dJlSxVM69wYaYKibqqqpA7tsh+ZJ5XWxC2ynifFyfeytyluZzdmtog4EtRtA4Q6r13P3t4S2iyKpBvYWwvzWbt5jQESFbwszS1lx7AxxTAznvBU/uT94PpEg4l2Nc8sjSFeWzsYtlwMSlEq/kDCpO/BODMlrLs9UILJH0puyhPcfn9qvqWJuYR4RyG3U/0dybmO73VkDkyh2zbw/aJRSTbSVNMexOIm1ogafQ34O8f34fT78gX+8lZUVFScIag7gMcBncTqjp+bHL9Wdqa2A3OHXY7D6BydTA56kXPrBMyl27SzkwoYp8czmLLjtLotO95fWLipkWJD1+64a5EcIzj8ZlLugGl0th3C7Mp+VS4VabAo7RGmnXbt1OGrpgGbp/w5dRfrRZvEiARKXbFKwDSwOYlL2IdEKytQ2lGULJY4mZmGHU8qaXKiBOk+ZJ5MDOpWTYZkC2baSaPiSQdwe0iXq9aMcZeNbm0d1Worhl0lMSSgjMUZL5PRLCNia6XbVojOQANHf9IVUlU6gaWFxa/T1s9Mhgw1BHGsK+Rsq58YoDJmJeDZDrq3meAxuY/DgmHTyXOEnKFqK2BS4ocRIaXcw0Np7yh1eLumhHzrh4ZmnadGmjEj+EnhVvKWLZAlDFpH6tkZQJpVVNnmfiAJvxumcTnAczHsGkCr9qQFpN+pn3ErKioqTof6f8djgLok3YASeKyGBnUlaiyMDZmjNiF9OmLUPSjthzUxFwULmMaw6ujVcaqOJ6Oof6mlChZmMobUSro0KZQ2ZvQn2d2r4zPNaNPwZMacbD1HN9XO0bEsuYHD1EHshdixRUScyg1KOLa2ZNhIgwiNLxz96og0ecnkc0C/5wqpgZBEVfc0RDhtja7pasakEMn+YOhIcDVjUffcGukEbla5qE6qLOl+n+9zieXRWjl10OqxaeC3G5LU5fHrcWYRW1btcdwbORIWo42NuRDFQqBOjeiuDUcyCp2MaVXRUyVTPxg42Xvka8x/J2mUybITmK2h6ijn0m1Xq21F2wA8780y8sODNWWsqu8jG1UBTcXgokHd2+dFcyrtmGVfECUipkTZRJTR8rBry/tUI4/UKa/EETkXw5Q2wOh6gfZhV1RUVFTcEJUAHgPiXCJBttoJSssESKimTlYSAnUFt4esBJuq3PKRYGM3MgpEl9uNkD4deYaZhWYAaq5flGOJHZs6lDi2B6lEcpT9OiEFWUe0rRpXQJev4QjVr6eeXSc1YuOOXNQlmFodvCZOjSQ2AO2Sj9mIgUUfQwmwyShxOWwmmdyeSXLqTJ7UVSVYSkT0eWgfsEa9MBib96NkV8eSYW7Q7zmOL1MuhhXdNXOfFQPDPULuDWYz7R/qCJn7Z7ZUxmWHMkLV3uawcDfYK7RjmsbYzmDcazCc5UkyW1MIvzZ/mJDZ2xxIKJuDyLG17Or5ZeT7MGMawzrWw6nCO9XEZSGaJKVhJj3Mm4TYsYItiMIaOiNZipPTOnmq2RrPo45nZHFkS9SNVvRpzVzoDEaNa8l8b7meI3X9kKTh19obrDu2SvbUoKSvtY6SSyRORUVFRcURVAJ4DPDLqf1Cidm20qTBx25IiDJWZHA0o2NYKcb7SjIutkMW5QhUjITojbu2xH2UijVxnxajgxAON6RyYdb+1Sx5dABK3ZY+JkObabjQvUMbJweoLvnr8fs1zSPjjhgaZCdOSdqwZyfCJ93EOo51Q0a7TJPBQhQkdaDq+dERqY4eTZSswnjUjFKc1/o1qYlzg+z8be0PahWZ1p1xHM3nqBVqoTNbHbpaZSc7b2JEUcd2GcPLc3F9EkJrEHZE1Qo0Pygp6q4bud+WgeGkZ2OHmG5cz85mJX7jLjt6rZh1dNfTiPKbOkvFzxrWwIlSGBYW3bWjZE+y5i2bKYNRYWTvcHZ9ZBxOnpQ8K85cGyeDj5O2k3Y/SpC2KaqsRrQUgib/1ucCTIYnvh4ouYSAGKSaKWtRVb4srm4bph3OIAHg7KSms7vuAFZUVFScHnUH8DhgOL4quXKdXtioHGWb4YaE/qQrO2SqmhSCmKeLq3WTY9cNkeQPU5MGEiNfmrS9M8eLICDjuC3SlJ0pXcA6JjXSC6wByQDjUNQhq2PdbMAOWhn7JpdLnE1UkiQ9wKpiAiitD+qGdmEiFcz1U3c0GziylzG2RTFfmFEIn52aQnQEm4Eybo6tLbl8gCiDQjJTM42KTcrAFsnUnLqoqqNhZp2Tc6nZcy5N+XZKUk3O6K6LGPfIanT3UDMQtfpPR6RJjsHJXt248ELG8xTkvTWizRIoHubc1YPsSiJmRMkNVDIXvZWR7hQ9pK7hcdcje4Ohafh6BD6O1qepy1eVwDizNAJtkbVxbmX8akrl2+ZsJz+nO6NAkB1RVfm8tKdwJWBSdpv1FDk0iDPYy36o7vJZCQbX22lbjRG1vJircgZkH3JcWKRQXcAVFRUVp0NVAI8BunOmESdulHFkn0u37rDrZHRINZB1XUpYUHadylhRdvyiRHyYPKk2NjDWpUSOGDVSiFtzzRiQMi4zAAw7WfXx1HkJTH227PZVM8Wk3sQZTQxZR39F0eRF12gOILYMIRbFtOE1O0/MJNplPFWdsbWD9V8kNZoZp87bsltmdD9vIn9UPifHqo6qdU9QlSRtT1HVrz2YdtjKsQVRGlMurl19bZSoqbqbGhIvgAqajtW1Cq502Mp7xK+Y+6hExsSpJ9hEKr6pYTzLtIepDiOU599dN8L2dH3r2B+Z5hLu7fFH/Ipu4tLyIlmOWXbxtt3nsbMIc4dhzxWjjZqFdH/Vy3s5zqjOavNJeY/p81znrQDvSblVo83mLIvYTMqgnnOe26lhRfcDu32JMmoB7WXmziyJYok/UhWyoqKiouIGqATwGDDuyLhTYlJs4NJ77AyGE45uRzEbKHmJM6lG89PFNnSi9DW638cLty7/A5olhzI2BaYlfjfwwhs7joxLRpqQh9n1sVx0jez3hY67eYwhoSKjrQrlcWW8mWXsFrqplaPEjkisCqD7fzR9WMln07037YhlHMyUEdduBfhqPI0Rl662YuioUiNokjfitJ0iTqCk0QHau6zNKoAqohppksv9qwFGibeSmHK+Il8f3e3UfUQAElZMcqfnTUO71WCzbdhRZVUfU7uWTQD8kqNaO2Q0y4BmP9IoIx8ESOwt4pxObyMh03FmAcvxsAYpF/UsYcv1a4pa6DbcJ/SyvjCZkXIhymkrEFod3bFlXqN+TWN7NMQ6dltGEEzPc1ywtaM94GuoYd26F0kSj0LIdYRclMBMw40qxNth6Xos2+0tFRUVFRUTKgE8JjQr5tSN0jShe2K6R6akS1UK3aOzYhJQMpR1BCojP83/UwKkipCOO3WBnxde5s35TSrOWh3dtvuxLNSXZggzLdJr7ZbJQH/SSoNDLoRKH3e6eJOgujGXBXyFGjCUIOpOWCyh1nyOfpPF9WtLjIqOwQGSamRgdl2kgUQu+G4zjVb1tjQAbI2d1eSgu4JCtJolGzrU0ZwdR9AaMAzDr6vRwG8mh3CSBhISO3myBvCHNGL4wwgvnbpKtopje6RpYwriJqGzPUlccxg4Ku0s2lMjx6gzN6mXMcP2iYowALeOhWSNO47ESQwiWYiiX8WijLqBP5u8KeRb9zyHPVsMImpkUke3knp9fd2QSmRP8jRzbHcLa6SPSeKyllFuqWqTcbB+uAizybmtLS6q7qrRRttq9EOQVvElN92v7l5WVFRUVJwedQfwGKDuRx3pJqcuUZTZrpWeVHbMJqp9SvQi1RA3UAmyISPayayhSk6zZZpwfZpUsJRhg+TCGaA/6UqwsQXVnv7kFKnC7lteLLPlaNivUciG36DEz2izRBY3rpe/+16co52qMQZZxqYwms02qW8axmwij2l2Kok5ZhqHxtbAByBZzQGcSEAxazQGaFDaRfQcZsuxurZNKJkcF6a8PjRsbKlGgSPk5jBi3EExXiBT1fSrVPpw/SYhOZLUOLMleiV1hsqbUwOEEeLFDMLUWlhp17CDhRsSzDKWc1o6ojW0OWe6hWOmQzgDyXBvL3sSOAvefnLwovxs7FwxI6VmcmOHOY+Do2ZT3lcmSQZky+PV3t3ZdRGjVsPJbYPhnqgbpg5oZjDK+9mhuHd1JBwbJdYoxFvVRr+R/mxZRQgzWz4EMSMzw/fy3hG1kMciO4fNFOCNLYJZcduAqdP8ioqbFFUBPAa4niqW7mhpjtl25tm4mKJJYmPg+wS/0j2qqfZM1RArFWK6q+c3vEiPO7YoONoRfGS8aUh2ZtdFtMs09QwPmSHQUt/m1+qSlWq1bXdwnPayVD1T5W7Y5f6WiVoTRkWmWaUyuh52uNPXrNKUYygZfzRAWGxOcn7q1HW8NcpLHvB9IiF20zhYn1vpsx2nuBUNtrZiBmBHry3qXnYkumHBzD7t6HU9j7tZJnhRkLIQ+P4sV0gs/z4FGZP4UcFTV7bGrZRWj5zLyNcOkt8YJkKtylxquH9nx3TEzMLdOWlU2UQgT+qo20guoKiebhP5fljz+ehvugmpOHIBVsllC+4LynPXuJkwtzABNCq1poz13SDvmc3UbWzEFdwuU4nbaeU2Rt/zojiWppUyZgfUxcyAaB5b6YnOKKsPJPFWeop1HD/t+ukY368T8yMraaioqKg4LaoCeAzQUvqyF5e21AgZ+ZoEoGT0AaMYKUpuXxT3ozhBqe4kwDjYIZfuXt3vCnO2e8yuj6XOzTqO0dxhkq5hEiNt5LAxlQvyuKPOYmz15nKkF1sSokJEAqhMzajWBDVs8EeEhGa5aNPlCWAiRnZy2yq5bVbcZUtOn/Ok3PgNR6jjjmNcSwOMc4NmLWNYIyNCv6XOebp3/SoBsIUcBqnNMwlCeuV5JBT1ya1Z2aZxJ5plpwodx+HT7p4S0NjaUqnGc0mFUc+bjnmxEaLnuaPn1wER3Nmz6yhVeqnsbGq1mt4nIHVzCXB9QJi7sv+IlOksbi3MyL3GbXVXz5EJmSHhqhw3tjxmaszUtyv7fNkaNOupXURDtCFrCDZmoNcsQCfqdy4fgLQ6TptidFQ77Bi0y1yMSDrGj50EbWOK5hkXBlYUYqgDXFzszUoUY2lAGRcWbgRGVxngbQW5irkVFTcpqgJ4HBDnqrZPjPNp/yx2Bt2phGaVyghLVRU3SvDtCHT7cQrKldiX4aQveYC6W+b6yWzQrBN3qDyKiWLYYYDvOLdF/Rsl+HecW5IwM2XBmeJq5bjODdNOnAZBx5nBsOeKkqah1nT8TuPdZpWKIgQcDZMOHTuFS8OJ075gTKYKC3HJopge9OuqFGo/8TifTC50AlPJirPJmYvM5+KkUUXVzKIeGgi5nhzIJUQ5y88I+fNrIZma+SdqL8DbAtMIX40ZrqfyF+eOAd4ZZayqYcepJREDALcONLn0sShbbiNBzyPDmVNLNbQ5DNwphBI23jY5AwiBU6XYDakEOMdGmkRkbKzGEhJDnleNiYmtYdafmDvCjOeYoczc21SF0w3TiB+YSF2Yb4/H6ehV1U/3RNUprIpmmJuyI+rXqeQ86nudwd4k/rq/qNV82lpSUVFRUXEUlQAeA8JiCmUGgKlODaXma8qikx2mnsoT95wSkFCUGw0Y1mgQvVCnhiPMIKM13pgEE2Zr6X6uu4Ycl7WHCV6cvtlOrSPZMcy5KGQlAsaUsauSuxJBI8RpO8dv2CHZ1Iu9lZ1GDRSmspnL+Fd3IRmfk4oxQc0izI5DIVzqylU1jupUKvVzyFMFne7E6R+tCtPuZe0sDnOD7voghGYa22sGH/csc6n0c31Cd+1Yzp/rGbXjBvYAN6tQXhPuGibYMaFZBhLdIQKWr3FsqTZmZ2D7CDMmeR9RVg0zIYwAUutghySxNIwOYjSPm5y3nfRGzxxSY5G9hR0SZlf1cOsI19MY0p4KNPro+2BmCim28tq7ka5lVVbHHVfG80UFBN8XVHE1pmdSLcPMlA5hK6+9RiVp9Z8q5by9LRmK/IDAv1upzdMQaG0K0fUF3bPk8fA1dNUFfJtB3QGsqLhpUUfAxwCTJKokYFK1xB3rRioz4SzWjmXDEalJk/K0vSNlxwwr5MOq0iYkcIq70DYNkokw19o4MULsTg0c2QI2iulD/o/aHiQs7+DQHvKC3qxJouyY4bYMBSRRvMianDHsGiAbtEvpiJX7150tDUCOduo9TrL070YufZlkioFDTR36fJIzSOIQaA5jiRSJrZEuXHHjmslpGuZiLNmkouAlzekTtbLZ0MzhVySNVowdGqhsPNs8wsIWI0SYWbQHk9U3dvbI622HhLBwiJ1Fe5AQ5l6y64SQZNn1swZ+HYWciIoohN+K8pe9jF9lZNscBppHAo0nyBnjiRZ+HTAuPNr9EbFziJ2D2wRoZZ7tJ3OJHRPSzAHW8LYSKO02sRCrsKCZxcqHFL7nmC8I8Pj62/mtWj+pYpP3uKrS04cR2Qs8TFROY8bY2tLgoW5xG3LZCdXAbnUHh7lUBlqDYdeUDzGqUNtoJLg7TbV80rhD805lDRUVFRWnQ1UAjwEm0R1pZYdPVQkvQdDa6lEiTjKjO3S/qux5hVzIV5xxkb/EwDiOK7VuTHfQCgGD7FnFySjAg0PZ2zNRR87MegO0NUP2/dRxqwqhNCyYxAw8DX9W8uc3Scigfl2X8g20f3cbR/IMvYYvm2IsaFapRHzElmHITtojNLKkuG+L+1l2Cg9DCVFWMqDIQjSym9RP1rOhOLdJvGIxFOhIc7tZQ48/OXECS9VeNjRbqPvXLwOSI/HKUpMGyIh3SLADs/3caixuadtH2CBB052ofiHDrQPiwstj5CNRJ24dEGeeqqC3SJ2DP+h5vqQuzo68n+aA4+Gw4zCc9DIyTkidQX/SUYXzBmHhJnNIw9dPK95gaM7R59OfdBh3HN9baQpD11Hu9g4oXe7b+7H6mqgaPJG4zUnuZrYHU4SS5miq69hv8lafNU1S6kyuuG2g7gBWVNy0qATwGMAldFPClPsTdmpZkGw+k0G1RTLOVI3SPbbUGInByKUtZCIn0o86k8iUjDJa06DlRirmgriE3cCLIsnU5K7MjuYRJ522280J2rE7tTPk8hxMptM3W4PNSapjPHaqc5Oj02w1dWAKPAYKeQJkv2vLQKFQgqOKnckkAhomnTqDZskOWp5bEo8w34q5mdtSU5ekT7nk1MVpf08dxLpbCcMIFySSI83z8+sEtybB0303jVoBgOZghBsTbEzw64DUTP2/MBzXqiMYAMa9huei84gzkr1C5JzhuBjieh4C3Cpg9o9rZG+o+KWtMTdI8nRvMM4b2JgkjiWXmBkbxCU95BL8rHmQzTKVEb9fJwx7Ds1+KLt1NGzY0tGsDTMazG3iVt2dvP5s88jlQ4UbUcbKR4KwRSn1m1RGzM2alXzZTasKqh5qS8nmLMf4Igkdjx2d326srKGioqLidKgj4GOCDRJXIkSJF0kDra5qDlNRjXSnT2/vBnFViiHDr3NpkABI3JrDhLCYWjr0ZzUIOiymVo3kePFMQBn7chxJUqHNFFQMgdBN/46t3EejGXUkbd0BCYTvE0y2Ze+MYb40bGw7OgEqNaoiah+x1quZhDKi1fDrcWHRHpL8aP6gmg5M5ug6bTmJdSTM0e1EYrIxsgtpSSq6aTcRkD1GiTEpTu2FuqJdedxsDex+4Bh1Zsso1EQSUSuO7Ljwsmdnpj7ikGDGhOwk77Gh+cOtA5A97EhS69YB7rAHdjqMJxo0+6PsB1rkxsIcCLkbAqzXDxOZ4+GWI+BsDdwyIM09UuvkPZOBkGFTkmo6I3uKHC3nuYfdRCqFYgSBURdyxrjnS9NJs4wIc4t2P/FDSJIPJ/LBhWHg9kh13vzaWCrogCneqF3SDa4fFnTnVF3l7XJS9QDGDjEH0KDUwcGWvdKiOMoHhKoA3nZQdwArKm5aVAJ4DLAjL7jRk3hkazC7PtI5K+qT61V5yYDEbqjBoFSEyUgsdkaW3OUBEglHcVrmKS4GwJHA4nJB7gysXgy3TCXcv0K5COuILTYamMwfie10zJO6M6mPrk/FqavBv3bM4og1RU3Ueq8ouXJumHYGARntCnlUVZHROBa5NeXx1Zlrx2mMqxVqbpMAiQLx68xGCSHTJuYyZmZmIc95EjcsHbmJAdGtEYc1n4NbJ2RPNZF1a9Mo344ZsIAZOK42fiLnmveXnQUs0Jza8Ll2HtlZ+CVPcuwcbB+QGwe3ZvuHW/aAtYjzBm7N72UDoPUwITE6pg+wqwFxb1beA6l1cMsRmJEEGtnzA8RYsxr5XAEkZ2FCKgoe42r0fUcy5/sEu0Eheaz8M+W94TcJGTJOlz5ebY4xieN/12c0kkOoyq++RzWSx2Qguuk9B7P1fhGzFEOkkzTrTISvGKvkg4hBNYFUVFRU3BgqATwmZGuE3PAC1J9wVOTGDIx0825O8Ern19MY0a9S6VstGWx6kdxoqLHEiXQcEbt1QhMyNuc0VGuk/cKJQ1eVl2wNhhMG7cHUDZsaiMIIiYABTJoME6kBOB9FiTyJHUdwzQqAqDE2TPtxmnFnxEiCTo0totDNqMTNDiPGXVcIqeuTxKTY0myiMTh2zEXdy9agPRVKbEp2FtlmuA1Jm4WoeWoCkGNv92NpvdAoEcjT0xaNLHtxmuen58X2shtpgGbgTp3uH5b4FhlXNwdjeR+k1tGNq4+7iYjzhkaPMBlxTD/CpVQIqhkjTHAkfI2oeIEE1MQMRCGcEocTd7qyJKUqYJw30MrBKKquyZnfd9LqETPgtnIAZbdQjR8Atsa0QnilX9r2W53InZWsSO4IZivxLZBzK87gbK10L8sqgqiw6pSPHkWJ1g9CVGZRdl3VpQ5MOYAcRQPza+XDj/xMNYFUVFRUnB51B/AYMO7wv6VGrDMSS8LdqTCzZa9vclTmchG0Qy7drEoyNCOtWSbuo8ntw8xi3HMY95zEgvCxbZiaFHQZHwD8aspo4+iUGWrNkhmCJqJcaIOQJ63X0tiUKGR02GFNGPPd7BTxoUYOacVwY4ZfJjTLVFpPdERXdhdFfdMWChpLOC51m1z2ITUse9x1GPe8GGrERdqZadwsrSpsVqFC6QYqgX4ZC1kqOX8xw28i9+fknLfXB7pnG7pxY8dIFQ1TptkgAqI6Jm/EeeowniDJAwC/ZJ5fe30P10dGufRRRvYJdtmTwBlT9jwxhrJzaUaaREzQnJSE3FggySjZObhlD7caxTjBnEATEkxMcMuROY8jx9Cqtur9ZyvmkOJYpuPXRI6CGxnD2zGhOQx8Tfskr4GbnLtCNPU+XZ/KeVYHuN+k8hpmww8fAEoLitXmEc1YBMp51R3StPWx1fVJzEIZs+uTkE+UfEqzpYxXVFRUVEyoBPAYQMfs0dq02BhR16axq97WJCpM2hLCkGVGcGRnytgrzqiqxJkt5Ig1bqmM0nSkydaEaf9Oc/G8Po6oM6OE7I67thAA3adyI2/f7afisISohHTpZrSHSYKip/DmcoG2ov6oSSFTTdL/6nhXR8hOSAcA2blDOab2IAphTiU/rjkIMGFSULMx6K4LYjwwpfXDilM5zB3335wpu27qWDXFBKFEOU7O1TRVpU3EJXJ/D1TMSp+uBjMvA0xIQihHuE1A6jxSY+EPB5owUoZbDkXhY7D1ZIQxY4RdjzBjhD8cSPyMgYmxjJP5HkqA5T/caqB6mDP/3gt5G5I8lpBYMaOEHT/tSlq+Z3SE6jaRH1gWrjh4U2uLu7ndl/sOJG+bs1xxbzv5wMIRLcpep7rQxzl3VjW2R1+r2HB036xT+QDjN7kElWNL0EvN5C43ecvRre50Z8rvWUVFRUXFUVQCeAzQi5DuLGl8RXcqlUBjja9QV2Rq6WZV8mUieOGd8cIYOkvHpuTpRY3iyFzAL52nRjP36LzUC2HobNlHDDM6dd04xWlkgyOKi5OsNnVxAiSVJmV0B5OCqA0TjJKR/TxjioKnTlCAvbNGjqFkxQlZVuXIZNmXM4ykiRJXk90Uep0t0BzErcgalJEtw4BlF3BIMg4HXB/LHiCAojL6ZSxk0UpDho5NAY6zm8NQxqPQcOkMDCdbxM6h2e9hR7qCS2tHzFuVehyxmlHYrTVASPCn1oAxNHSMQuoAwAJpZybn0RYFMHcObjXwPEUZH1tGvphVD9OP/FoCwl7Hr48RdjXC9gFhl8ercS4AyrmC3XIbi8HC9awQVGe4tpXof/V11xF+t5+oropSFzs6hWNrSu0fssTqjJPqWxRw4Ej1oZUxcJjx/V3GxkY7pKlA6/oE92unqsVUyV9FRUXFjaLuAB4DSGh4QRp3LGM45CJZaq4cYJW1yX9iy2w9CxIsv55Guu0BCUzyvOj6peQJgqSpWWVADRwzK7Et0/FwlJpgWoO0YKZe2ZOSEGZ1fKatEaeOkjkm5PNpD5KYRqZ9Le0FttLcoPVvGmNTzByz7X5kabPQ7DcZHSNrh6+oW1JJRgPIVB0XO8e8vXWSncVpb1Ar5nScDjiEhZ3idtyW+jom2BFl783EjOStjF0zxl0PNyS4MZURrdsE2Oi4w2bEzZsyQtPC9YFE59ol4u0WVPZCkg5b/j3uNEgzD7eiAmiGALSehC9wfJtmHraPgLVU8rxF3Glhhwjbb802jUFedFQHU0Lc62BHEjEmeecSr4KU0ez3NLNI04gGRUPcwXZIcBtmCjKAW9TShSvE3w0cyzdLfZOhjF7tkGADf6Y5jLCRaw/NYSoxLmWfz3AvFEAh97oqwf5nC4ssXcBWgqAz+pN2aohxXCvQ359OsijTzCJuS4YVFRUVFQVVATwG+BXVPnUpDrsWsUGJKzGiDlnpg9XF+mkfTVyOQmi0NSJ7UQkHulx1XDrsMrg3O+6qbXe7brsgNYAamFyaahJJzkg7xzQytpGKi+bjwaBc8K0onNlBOoxTIQW6vwhQBWIgs2QRLtMUZi0h16mxkwnDohwDLBAkILs5jPCrOI26ozqgQVIlxBDAFrmYKuuQM6vPNluZen2Sho1JreM5tGiu30iIdhTHKffnNEsvzj2M/JwZI/t2nSU5WweYmBBPzouhQ+/bXbuEvX4Jtxzh1iOytYi7HbJzsrsXAWMQzprT7b1ogcTXGzkzLDqkyTwR5WdC4uh3jLCbALumEcUMAbn1Qogj/CoAmQTXraM4nvkned2zzBjO6vjaiau2jOL3QzHgdNeThMbZFBHEXUxbFNRx1x1xXWsVosbjaOuH7oMCKC7zONM9yyn2RaNl/DrL/ixK7Axd5+oYNkd2XysqKioqjqIqgMcE7bLVEGStqLJjKqpUmGnunZCaQbtc6ZAYzvKFHGbH3StkIUUOZfzW7keO6hZWarlkT61nVqASwiBjVhsgxEmqtyQcurhtIREyzkz9u3HaE4MhIWgGHbfl0nWsY+Sy5yhkzK+TBBw7jl0bK2YOP418R8aasKWEZKE5lDozNY0MNDNkx5BmjW8BsnQOu/J9mkps6dHNjq7TIrwmTORRRrdh4Us1mh6f61OJUTFDgjNipLAGdkOiZYeI3AA5G6pugIySWfNmRjFuOIvcNiR0ISO3jH4xMSJbh7RoON5N3Ac0fSyqYW4ckOS/xpGsjewUNvr1McEerpG7FjYEkumYkWb8VXerkYRSHMJ2ExF25TGzOrIt3CYWZVpNQHHO8bE6tqfxLd8XqhaaCOTuqHPcibEjzsQ9Pbclp89Evlf1PRRmtpimVM2FldH2fPrw4MaEoZvepyWA2qO43O1wbL/iFRUVFbdqVAXwGJAdx5m6mxQbUarypJBxGR7QWBUd18YZHaUlQgWYVCdx/OoOWqnWKi5JuoQZoSFj01U6YrjYNmsA3ENkBdukwMQW6E/KnmKfjxBYQNzFhntdutO3vTenIc5qSkmiIKralhor9Xa2KJLqBkaiUlcy4VoSRYi65Hru6cGwu5d7cjRlZGPQnhqkTo0dun4VxVzCxzOJRNEvQwnC3s6O80s6f8NeCzMmNPsjd+P0uRnIODeTNAEcp+60MP0IuwkwQyjKoOlHmCimjIMNECJMlD25Vj5/WYs0awAA7voVyZ6Qrmwt8rwl+VwPfOwxwg5hiocZI+93PQDeAY3nY+SM3HrYwzXcdSvYDRW73LiiusWFh9/vGQgdSdCNEk5rYEZxnItBJjUk3iaIScmSgLs1SWuzDCVQW7MSTWL1YJirkURInKh6ANhYI802ZR1B3o9K8NTZq27i5A2aZUajJiBryv4sJPw71Y+4FRUVFadF/d/jcUB26TQEdzvoGBD3oqgjJTqkNUAJGLZiItnajRtSqRTTnTk3pJIF2BwEjHseQXblnE1c/3JAhinjZh3NJjeF/Lo+y/hWxnI99/jag1jCnalSiqnlkCql1tAlBzTrjOGkK2SxPYhIrRH1zJSmDBMSbDbwm8iRo+QIaoexNpb4dUCYOdgxs492nWA1UkTGuCZlhJmDG3lubExU8GKmgmVp/ogzVzL6qORlhiNnumPtJsKOEf3JOSNbNoEqGWimaK5eIZw147G2DqaxsH0sodFq1Ig7nYyKwedmPNLcUzU86JG7BnnWTnt5AInVhkqdHQLyrIEZI5rr1hMJdAZp1sEeUl3MrYdZ9kDg3h76iNy1SIsGdogwyw1dwTkhdw3QtYWcmyEgnZjxA0MGMCakzsOGhOh92T+EMbASWUMVVeQ4kJRbdQoLCYwzAxsNkih1dmB7itsIMRtICMcdy9d/nZCHqS5O91s10iUbmkeGXZqXOAYG4KfWEBtll1YU3thxXcFEuok1nqaioqKi4oaoBPCYoLtzdgTCHPDZlHEld5xAEtdPESkAivkCoPJnN7yQhlZIjATi2nGKXHEDVSiNnFHlbVzIKC1ydOaGyXShy/z6mBrijJylg3WLLMoYuFmJeuimERtAgjLukawdadQYc6mIs72oOZ2V4/FyrFz8d5skqmkqphGaUBK0Y9j2EXHukWaOY0khsUiAyalUsNk+YtxteG4zx7sA4FeBdWohww5CbhrLhg0vY0/IqDmQGJmYkWe+xLgwL49qFyxdurmxcIf9FOciO4x2NZYRMRx3AfPMlxBnhEQi2XoSs0VbqttsL+NbUX9NzMidE1fv0egYADDDCJcz0rwBdmYwyw3yzkx2RblXmI1B7hrYwwF53pT71rxCExJcFKVPXqftjMDsMl8ny9dxCsvOJViaSjDKbqvbkIDrbl6zSlPbS8iwYL0bIAYmcQ1rx/LsVCoxSsBkRlJFXT+EaA1ibAx85HvVjhmhqSaQioqKitOhjoCPAXacVAk3ZPg1JnLmzZHb6KhMFUO/SWX3KXkjMSgoozI7JFHK+FiqmGgkh9swRiV2tkTODHtTHp6qj8jTMr528gI0d+jPhplEqAy8sOrtVZlUQwgr28RAIWaR7CWeRqvtIK7fTYJfS0aeRKv4FXPujAQYc0+S5Ch5yTvc7wFjGGGSSebUnFHuexUQGzaDuDHRCSvEAOJ0Tc4Wgmdjgl8GDGd1zOTbhFKvlhs3xbIYg9Q4ZG/glgOsRLG4FTP63HKYxrkxk9iFRLJnOC5P82YibY73DwukWcN8wFmDOPOwmxHu1IbETp6bHbgzCTVRtF5cvbHk/6HxJH8AkBLSiTnjZVYDXcSbAbYfp11BGSVrx3DquFoQdjxyK2aQkMo+qR0imoORFXLelg8i+nowqFyIMZQ4ZmRvS6ZjcxAL0df/88SWTuLuVCxqnZMPEIwS2grHBsrvhv5+hbnFsGORPNcVNEYpSGZmPgM+4r7oRS/CAx7wAOzt7eEOd7gDHvWoR+FDH/rQkdvknPG85z0PF1xwAebzOS6++GL8zd/8zc10xBUVFbcEVAJ4DFBFolmySk1zznTsquNO3W2KHeNGTMwlOy9boLs2TE0gsuOkblU6ay3GHYb0qopHBU6duiSEavQIC457GcxrSlSMmkAA8KLuUFy92tLh+4TkRHWUgGRd4o+dhd8wjqU7Fcv9sEcXZT/R9ZM5w42p7PTBAONZndTeWSpThkHFjBWJiDPP0ej+tNVvR6p9jDkhSfEr7rnZtQbKcUzrVgEICc3BQELlbbmNX0qg8xiRW7a0pM7DDgHNtSuYIcDvb+BP9cXRa8aE1DrkzhWDBXIGvJ1282TnLi5axrq0DqZnuLO6dO0QYTdjIZtmZNwLDQ0JqXGsdAt0AqfWF0UPABAS0skF9/o2oRyf3QRkKzuSziDtzbknuBlhNwyLzlaI3pBghoTcWvh1oLM4ZJJCeS/FmUece4y7jWTyxbJDqS0pNHnQhDM53BnFw31ByCqDKfurzTKW9+0URI0j4eHZSoWimVptNCR6dm1Eu6TjPh7ZLZR/T7nat1m8/e1vx6WXXop3v/vduPzyyxFCwCWXXILlcllu8/M///P4xV/8Rbz0pS/Fe97zHpx//vl46EMfioODg5vxyCsqKm5OnAGfj7/8iI1kmXWm7C65IU/h0AMVu2Y5hUKPuxZ+TXKm8SvYc7zgbSKVlIZZbADEhUp3rdbNlfaRuSM5swZpNsXFADRnUF2UDuAsSp0DmgPJXRMFUfey1K1sEsrF1/UMaaZDmfedGgNjp/1Ht2aQcGoM0twiNRbNMsD2EUEy6HSP0Q4JYe5pwggkPhDXdJx52EgCBTFswEjcyJC495ZJUkyUfcBEk4ZBYl5glomqjDt1BOz6WKJf3HIocSc8xxwhF+UOQNzr4K5bAXML05MsbX8fIcE4gwyL3AkRFLMIrEHabfkYsmeXHRB3WyqH8lgTGUzw+xvkxvG5WwsgITs/EdF+2HIdp0J4cuthVj0DpWXn0DhLpVJIYW4c3P4GSQgq1mBPsTOwqxGYezqEA7MDh7M67lMOdEVnqYTT7mZGC1F1RcqAN8VNHXYcmsOIsONLvp9J0+jXhAw0BhmyBuCsGJamSKGSNSj7qCYZYJ0RtAFE+4IhCmQE8hlAAN/0pjcd+fcrXvEK3OEOd8D73vc+fOu3fityznjxi1+Mn/zJn8RjHvMYAMBv/dZv4bzzzsOrXvUqPPnJT745DruiouJmRlUAjwHZSbjykKWSjf+OnZkiWMC9vNRIILOQONdzX65ZsvIszhhlwp09jVwRshX5d/05JWiAENBmaghhJAvz+rY7WHWnT0mp3k9sjYysIbt4WmFnMLs2oDmMcGu2cFght34lKuB1I3f+NPpmyMWpGzvHnTmJfEliKPCHA7zUp4VFgzgnOTMhozkYSsi1jgNNFGIXuZPHQOokJDBPo2HNsJN9MSsjZhNZ0YZE4uKvWQoRNmU8mjoZtYoxIjtDZU2MGrn1JF1q6pAgZjNG2P31lP+nO3b9lAeoSJ2HW5H0miwj4TnNI3CGsS/GcFSrDmRtFDEGaJuyB0gVcEDqGhJM747UyZl+hNnwOdtNgN0EpJ2Oz0XyCkvDiKfxQ13R/Tkz1u8tAxW8+bTzmY1hCLZ+OBGirfE9zTKg3Q/i5OVrMLsulNgjk1A6oLXlA4D0RosDXVS97CaV0A0Z2ZPoMQJITE8WpRM4NTfxL/etAKdOnQIAnH322QCAj370o7jyyitxySWXlNt0XYdv+7Zvwzvf+c6b5RgrKipuflQF8BiQPEommQ00VAAoatnYamsGyiK+69muMe7YYtawY0LyrgQm+7XUlEWgGSPGPSehuOIGliBpYCKCwBT5ojuBqtDpWJrHzAvruGNKHVeQGjYbINlv3OzPdhq18Y4hhg/mrqVdX9RDo2qgROKQsLoSI0IThEWceWRvkD1HiIhUJg1yMUaEhZd8OoM48/CHrDiLu115rl6CklPnS0CyP9wg7c5IdBonESOx7Odllc1EFTO9xKqIkmWGgDRvYA975M6LwzbTKZz5/dxwhy4tRM1z3Bu0YyzxOblzSBLBgoYKpR2FbPpGMv0MkOQ1aR2QW5LC1sJuSACR5XEgUTKaBwhw1AsZv697wFm6gEcZlXu2p5TjFBez3XCP0R1sAMxojlmNxayMnMUY44DEsb9LUVYEIvcjpY3Djkl6nGXv1U1Ocj4vW34fEGiIiQs7KXiZt22WkXuocgzNKskHE8CaaRTc7xm0S0jwepJmGodmlZDz9HtwJiDnjMsuuwzf/M3fjHvf+94AgCuvvBIAcN555x257XnnnYePf/zjp72fvu/R93359/7+/jEd8efGKVmVqKiouOlRFcBjgOsBN6KMsHQEq2qG7zW3TEfAkwFjO09vOOmpcIxJRrLcEYydKWqL7tD5lex+hXyk8UO/r8vzWr2lF2MApVkjW4P2kCoegDL2JflMhQRmJ3EbWfa1ojhIewmMFrOCElvXp1Lj5leRqtDBAL8cqdQJYfIHAyNeLBidshoZyZJJMppDtmfQQMI6tLhoYftA12zOJG9ZXL5CAnMn5CpRxTMxwfSyI5cS7P66jHvteiR52+2EaHVFwctKKlOiwiUOXrZ1SFxLO42D3Wrg7eS1MGOEP+jhTm24Q9h5Biu3VDLdcoA9HEpeH/cGxRgi5yobg7jbsTpO7tOux9L7S6UzF9WwkNWiItK5bFcD7BD4GuaMNBOSqKaSDKSZJzEX00x2NH/4dZRIHOZS6k6f7qhmL3FFurNqUPqHi4KbssS2cORrtke1EnE07rjSme0Grjr4TWL4eKZCmDxVQkV/kiHp3X6Sarwv4hf4VoynP/3p+Ou//mv89//+32/wPbNlpgFIFj/7a4oXvehFOHnyZPlz4YUXHsvxfj68+W+uvFket6LiTEAlgMeAaQQlztwx0xDiDZw6hA1vx3J7tnAg01nr1rJPNWQYaVnQKjjdtwszw8DkUUjh3MIONHoU56sBhj0Hv+ZFU8fIoZuCn/06TdE0HjABpUbLbVIhhrGdYj/4HLVui2Pg1Nqy4A+pc8vqeO4ja+3AvbbmkD2z416LKAYKu5YsvDHCHQ4c6zruDUJiYVLnkGaNdPSmMuo1QxAiFCaDREpwh2IYEdUsOzeNUK2BXfUwqx5oPPKiI3Fd9TDLDcemIXGkKy0cpmdUiz3c8JgaNxk85h65cbDrgDTzSK2TcOjIiBhxFqeWbR/bv3luOUxtKh2NJSZniYKR0W6UcGhnSuQJwO/xfklETcwc9Y4BaDzCObskqV0DWIs88zDDCIwSCu0tz1+cFkXtRoj2GOmMFndvtoZke6TKllq+B0nwoyjAooomKnvZSBRMx/dDe2qkKpz4wYEGEDs5xbM4ziUbUs0ktue4Vw1SVLI160+Uv0yTSJhZ/v45aQ45Q/CMZzwDr3/96/HWt74Vd7rTncrXzz//fACTEqi46qqrbqAKKn7iJ34Cp06dKn8++clPHt+BV1RU3CyoBPAYQEciMOxM49Vxh6QrdKaQMQDoDhLbCmTBPSyoGCUZpaWGIcqp4TjVyYiLO3tO+mrVCKJ9qJmdwAN3/sYdJyYUOnqbFUd0wy5dtqqm+A13Dv06lQtybCYVT+vdmsMAv4zwSxlvSndr9uK6lH29dn9kRd1uQ8VSlCQAEjEiHbdbO3HQTLnGTU0RiR24bjkyW2+IEkUiruKuQfaMMwFA5U4aMOJeR9IUEolVSCRCziF3QvxyZouGBfK8RZ51JdwZkW0aRnbqYAzi7XY4epXsxdSwzi1bI7l7CXYd4PZ7qolSu6Z5eXaIVC6HCBMS4o6McxsnqiCPM3vL3MOOBC9rnIzcZ/aW+4rrAX5/A7sa6Eg2hu0h1lLlGwJ3FXVU7CzSyQUdxSEBoojCGP58whElExLYrUqrkn2/SqJgWtiQuBfas3klOQPbc4dw3Gvgl7HkQkJd8BIrpJExrk8Y57aMctuDWCKHUssPIclNhqTkUVpsohBDk6iuz68OKGHXt3HknPH0pz8df/iHf4g//dM/xUUXXXTk+xdddBHOP/98XH755eVrwzDg7W9/Ox7ykIec9j67rsOJEyeO/LlZsPX6nTlUvqLiy4O6A3hMcP0U/6KRKwDK0rt267LDFKX6TPerwszAWVvqsLahYbtclrdUX5JDmE8huozx0JaFXC6cyQN+M4XyAmA37wnHcdqaDk0A8Il7VyZSyQlz7i6GuZADC8bXwKA5iOXibkd5fE/V0K0CxpOtmEokOHkdYA8H7rc1ttStZXH/cuzLsWhabO2wGQOzGqeolZhh1qPUm8k+3aJlnMu8hVsyPzCcmMGfWnPsa6k0oScZMhtRCnNGPGvB87sJhYRCyGD2VsKhJbR6PcLmjNR5xHlTiF12hhmBqh5aM3X5gkTP9qGMkdVwwYYXkt4o4dNuwwxAJzuL2Rn+jAXc1QdA1yLtdjSntBJc3TiY9UCzSkjAME5O5JxJ+MZY9gnL7XSEbqkC6q5gnDdUU70FYoZbMrYmtxaxoUprPEkhxKjj16IoOqqCcc4u6+RM2Q8tUTGG8TAwU0xS7GwxRyGZ8kHHRHXMJ6rm0MgYmqn8yPvjKNjATGtst1lceumleNWrXoU/+qM/wt7eXlH6Tp48ifl8DmMMnvnMZ+KFL3wh7na3u+Fud7sbXvjCF2KxWOCxj33szXz0FRUVNxcqATwGxA6wp2io0OwydTaGmUG3n8oF0KQMA8a5ZGs4woUsvHcWgLQvOIOw49CeCohyEZ0cwfwZ1yeEBR3DShzVOex63j/HzcxVU1NIbB2aw1R2B5kPmMXoIOSlpdoVW4t2P1C5yUbGtol1YRnwhwHJUxXi2JWp0LoPCemXTY2DMcz4MzEhSo2ZkiK31XWrMS0wdOjCAnbVT2PdlKbjbFxxvbJTzsKsBzhjgDHAeEeDiXPs6B0DctsgnpzDjKk0TGieX3Z0uMIZwDAqpiCTqMEZjp/HBIvA0XXrkOaeX89b8TObQFWwk9aSISBnjoazp9NXo2nCXsu9t4O+PC9Idh/6xKYPgB8a9jruArbcK3Si9qWu4epnPwAhUhlsPN3AnuNjMwQSt1lDxbNrJmPLJqBZ9lQ8RxpZ7GbEePYCto9w0L1Tizh3AJzsfnLsn1rLOr7OlvepSVRJ2ULC6BdIYLgNmJQ8NTtHlEDn1BjZJ51C02NLk5Qb+EEnOXEGb5hveFvHy1/+cgDAxRdffOTrr3jFK/DEJz4RAPCsZz0L6/UaT3va03DdddfhG7/xG/Enf/In2Nvb+zIf7ReGvCUBngFibkXFlxWVAB4D3EZ3n1BiX1QB9BuqHuwwRYm+GPYcfJ/QLCOz+jC1d4x7jg0fW0HRfin5dY6kUbtXtUe1dAiPbEXIRlpDRoNxwczBae+KRpOw8LDIJcA5W3b2AkBoDPxhRJw7hIUrZg6t/XJ9lL0tqjVeTArAtB/oNmHLfKKBbVPOISCE1Vvk0RSzhTu15tjWW8S9Dv4UTRtpb4YSiBwz99o81UI1SWDTA60QGhn38qCAePYu9/Naqnq2HzHu7sCtR46TQ6La1XrJ4TNHVThjClmzg0SppAyTIpL1MOtQdhnjTit1cg38QQ8/BMS9GbKjg3mKt5HmjfUId9Bz9NtYEmbd+wNfOs3s045iSPah7ROy00q5EXlnBnP9IdD4KRjZWek7plFEa+bMagMs18hzml9y55DTVHFnlz3iHolnmjkGPEv4OCv7JpOItnmkVlTqziJ7U/b3dCfVyf4eUka7H7guII7x7b5qfthh9WHspjpDL78b+m9mWwLjjmU38W0c/xSnszEGz3ve8/C85z3v+A+ooqLiVoG6A3gMSO2komXLfLxS95a5mG6j7C1JGwj38owoHJMTOM4mU4eJQNgRh6XkrMWZhdtkBjj3UwyMOnB1J8qNGeOOOIeFdOpYrTkkydOWhWxkTNdNNVzNAUkad78m8mei7humad/KkPRxfAr4JceJxUgwiotXw5A9XalmjHD7Pez+mupbq725thBEt+zZv9s2bNW4nm0HRiJOCiSbDtYi7XTTzhyAuNMh7nVUIucN1brOI56YFScvg5JtOT7t/2XdHc0YdCsH7uaJmSV7umHdcqAS2JE8Ghmvuj6Whg7m7uVSP4csDR6O3w8nZ0gzqqfNtSvufI4knHHe0Bl97Up280QuS8wWBKhyqkkknn0C8RyqPWa5hln3HH2LY9hefwiz7pEXMxLDwBGx6eNWc4iYeobI8fyazmu3YlSHiXSBx/nW66B8W6KP/CpOtYOBJqQ4s6UXWlttABQV229SaQrxG344KQ03w6R025CFDKK8vzXmqOLWiW1uW1/JioqbFpUAHgPYoyu1bIHGjjA3xUVrkiiEYy5BzWFGdy5wNBTXDYnhzeIAVjIZZ1K7NfDvJkEupBPxTA2NICZrWDNH0W5D04gdJ1Uxzl0ZszVLLvKroURVRzsyjoNmBgO3ClT7lqFkuyEDbh3ExSyqmLh1syORyxKcHBeSYSf7dmYIgLdIiw52w85d0w/T+FdDmVOC6QeOb2cdEBmXojVyyJnEbm/GJgwJctYcQBMT7BCKWxkQU8om8JhFxTQpT8TRWtjVKMHWbACBMXT6xiQmERlxZlFf5XHtEGGGhLjDVOLccKfQjEm6kw3cwYbO28SQanXSGsmJjDstbEishRsj3EHPY4hs/7CDEEcv+X0Ndx3jTgvtDS5ZgScWyI1n20YfYJfr6c0bIomzXHn1e3mux+7KaF7NLzrOtUOUbuupE5hu5nik/k2bP2zP59kso7jSU3n/6XupRDQOqaw8lJo4iJPY0RCilXLai60B0RUVFRUVN0QdAR8DTKK7N3TqTAQVNWk2CDMpuZe6Kq02a1apBN9mY+my7IxUyDEvLcz5dTtkhLmVaBkNmhNXpOOeVPIG2fOCGebiWLWAkQsljC3KYraMgAkzC2d4ETchI8wce18Njzc3lsaPjFLLFuaOvcOrIHtshuNe+S8DjTNz7obpM4fbZxYdI1ZG7uVJNh1SJuloHMxyIz/gOBZedEDj2FmbErP8lhvkRUfDwnpEmrEhw/YkRtm6MrbVmjHEjLSYTB3ZpNIPrM8zd44kNsSpck2NFv0IdJ57jWrqSACsRdzhcRgJmzZDoBopJDF1DcneoK+dmXYOATqHRdWzyw1y23D/TkhsPNHRkash2EKUzBCQOi9EW5zkrYcVxZF3aDkCbjzQD6JyOo7K95f8HgCzksd1DnYlaqFmJ/ZiflmQALtVKCPhOLfICy8h0AboHJpTzCrUruDUSeVgY2l0mTMcHEAZI497TjImRWWW5pFxx6E5iHCigOuHA/7ucf6rYeWqJlbcOpFv5O8VFRVfOqoCeAxIjY53pSGjIUlLjUFsjCywZwbYalSFGCbous0yijTT+DdxFwo0/gIG6K4LaJZSgybVbzZmCdG1JbbFhCnU2Y0SBbOMaA4Z5eJX/G9qDJplEhWH90O3sYWNqbSTmESyFzuH1FoJaA40ilhGvRTVTx29YvBIrW7zgyaF1tOxqrVq4vSFd4Vw5N058u4cabdDPGd3ijMB+P2upYEhJCGPCf76Ncew0ryRrQG85d5cSzeribG4XW1gpVuaeaplkmMHDeaWlhA7inPWgA0kMtrNjUPY60rTiFvSmZwaktZC0HKGWw0wMSLudjJuz8XgYiLJrxpPzBiRFx3PDYC4NxPHLjgab9gRnGae51vOb5x5kmtDw0VpQZk3jLzZIk15xhgao7t/XQsTInLj6ZIeRiqDAMwYSsi33Yx0B+dJ6YPsj2ruo462U8sYoObUgNja8sEBoMmHo2EafMZdJ40iecqVBJVxNTgFcaprFqXf8D1bwqdBVbD+H66ioqLi9Kj/ezwGcKzHMaB2AtuQMc61Egvw6sqFGkH499iRxDUHkaNauS8AxZgx7rB9YdxzMhLjBbjdjyWgmRdYW/ahYjuNoPVCCgCpY5uDjVlCfSOaZYCVsZ7bTLtfsbMIC1dGdf6AxC9JC4Vdh7IzqODIVvfcbGnygPhcqAB62IM1CeKiLf/VPbnstvblxsgdvt1ucuo2Drlr+G9nSztHXLSi3lHZizMvo+A0vfNFoeN5cUf2Est4WM0XXpysOcOMbCqxfeC4NeZyXiBkU4ml7jdqgLXuNZrIAOnyeJrrl3KJNlFwV1GaTazuJHJHz4xR3m+QDEQHfzjwfC8HkniJqsnOkCzLqBzOkUTvzJB35oyEGUZobRxG5gPCWd5u3k7tJgkwMcLvU6HV3UWtHkTe+l2woBpoTSF87cHIBhvD92NqqbrOrh2ZhxnVTJWK/GOSrCiIs96OSvxIJJN0XmdxAlfZ6LaDquVWVNy0qATwGGAS95IU48Ji2LWlD9fqqFX2+0zkbl+2JHjJMR6jP2ua0Jeoi567eW6Ti4FEO1FpUACQUTL+tGquWabSEpINmz40MoYXU1uiaoYTDcLMFWclu3kzlb6yx5hJBEIqpC61jnl+SVs/dM/NIC6Y95e3lvLVqWpSQrzdTum3RQKMdICqeSLNqfAVUpayED/GraTWSYhxnuJU1mPZm8udkxaLSBPDmiPnuNNsxZPwnMZFC6izFiDBHYLUzIFtJI0tDRyAxKOspt5S049U/0DVLs8kyLnzbAJR8ibRNXHmGZ8z8zRxiAoMb9lWYq0cW3PkvRZ3GoRdIcuRZNOtRxK0kJBmvsTosGElF4KcG4fxDnswwwi7v5oIqjE0g4hZBdISonuE9mBT1Na421E1lVzBqQ7OSGMI3/PN/sAe55TRnhqL+YRRRyiGJRiabJoljR9+k6gUGjE2aaOMdkz3W605aTKFlOrB9W0/BqaioqLii0HdATwG2JEjV1VlmlUqF7DQkZD5nuaKZhm3luPZ6ZutQZxxbGwCMO644oikAzIiLBzbO3ru+rE9hP/dVkxgqNz5lXT8JhIu3o6juuwZZzIuPBscNENQYmZMyIgzB2zEWdlYdvSCpA/Ol/YPZpQY7rq1Du7UBk4u9qUiTjLtcsMxL4YRpvUwMYgqZWA2I9J8XkidHTjCVLUsGUiYslTJDbH0/NrVCHiLsNvC9cwZTC1HwUZ3AhsnZgwSBI1eAVBGt6rEmZyk7zdz3y8AsXNyDiA7gEqSshAvErXkbVEVbUgksd4idw2/p52+yXK/zxpm14maGecNTOuoOErodO408kXaXTbcm8zOIHUNxpMzNAccM6em4W1BQp7B15+j4shw7FkDrPMUVj2I4WYzkPxZC6w23BOUlhF3aok872DXBibG0sZCgw34Okr+pFsNxaSTG3Xsyo6q5CxmiRAqr6UFXJIGHKk1bJd83yMluJiRvUPsbOm7tiPfZ27MjFXaVPJ3a8c/IeGmoqLii0QlgMeA1ADaTDAuDNolSq6Z36Qymort1K7hNhnjrsVwwsmFDGXXT92gRviGLsf7PpUKt5ypKjbLaczrhXiqO1IVRta5Sc1c48RtmeE3DO8Nc8lf23FiQAHaU4Pk3DEChOSF47uw08AGiXVJMupdDdNYE0I6vCfR6tmXazeBES0n5xxpWlOq0lTFM+Kk1QgXM0Y4HV/KKNRklOaM1FjkOVU9pztpoBnFbIUw5zS5Wd3BBuHkHLAGcS6KnjUMOpamkbTXwVjQvdw5+IMecactqqcV1TPDIu6y9cQtec5yw1Fsakne3EHPTmENu5aaNROzxMtIaHQfpoBocS+bSOUwd65EwbBzl/EzeebQHAwkVl1TdjhNynwtnClGjrxVOQe0sPsrGEviiRCRTiwmA07ONI2MAWYzcuSekoRdY3q/BogBSHZbxfxisih2y7GcZzeyXlCJIOsBSWoh/dMmMVomy++BG5KMeqfqNwBlXBwXNEC1Q6wzw4qKiorPgUoAjwF+M42AdTkdAHJCWVBnTRzHrxrZwnYP7kvpKItVbih1cYzL4N8BMPsP0tBxQDXRiuPYIhdlBGDlG0Rl2d4PbJaBjt8dT9fvmkpUcxiQxElqIpUw7lexBgwj4zuaa1fcyQOKuSAuWiGtVPoYrZImh+lIZzFSgsmmEBxIDZpe2O3BpiiFSljMJogKRiXLjFKXdphgZAyuJDV7qpXZW6STM6p4hsTXbqTSrGt4G6ktmzL/uO+Xdlu41cD+3jUfO+52sBv2EiNSmVMzjwm8jzhv4K9fITazEuhsV6y2S40thN6MovhZkpjUee7V5QzjGQJdSNWWOcTIfiOh5FHUOzFUQP5jhkDiJ8SZlXB5Oq9jRG6bovCZ5QZmzagdfV1zAxpS1gOdwQdLeL2vgdmH4cSMFYCrAanzVDU7S5K7iSUKKHbTLqnbRKTOIc4sEgBnqDqbJhdTjM3MEtT9Vsa92BIZk2UcHOdiDmkMPzxtboJf6IqbDbkucVZUHBvqDuBxQIieBtMmbxBmYjaQEa26Y7MjuYutuINXCW6cHL862gMkHmMTqco1Eg/Tya5VJgk0OUtTCHcFNTfQxIzhpMew52QvEKUzOBuD8YSHXwbp6512swCOkOPMI+y2YiSwzLWbN+KW5S5gauzk+g0JYdFwnw7slgVIbsooV/5rxshxroxJbR/4tdVI92xi64XpI1LrMJ67YIdwR6erCQnttWuqW8bIfaGQIQ1vVrMEQGes7s0hiVFD+nA1D1CR1ShigDSXfTfN1Gu2Q48za+jE9QwDpEVLI0Yk+U6zBrFz5bFNzBjPnrFSTrL//AH7i7NjdI3f35S9ytKkYmk8QUpl/5FxN6YEQRvZAUythEHvNGWETyOKvFcl1ibtzFgVByCdmJNgz6WpxFkgJthrD1glN4yMiJFzk6QD2W5CObfZ2fLBwIxTnaDbBDQHI5XnLJE7MaM5DMwGlPc9TVB8b6aGH0RcT9XQBjrZNS8TFlI/KKsQEaWZpaKioqLihqgK4DFAs//CnBVWJmU0K3AfrzFs7+gTTJLqNDNdpNTZ2A6x7PHFFkCWQOmFhd8kuEMSLjtwVIvMMGnfozQyqEoCQFo/cmlUKFVbI92rcW4x7vpykXWbSMVq0JYQ1qvl1hcCY8fIXbnSfDGFKqdFi/bqJR27Mw/Ted6X7LGZrX0vjUGxokZZyRCEmC8ySKhzR7LlD3qYkAq5YNOG7PENgUqd7uc5kgs7Bu4EbpiTN40OSYBLV6+YVgAUldOOkePWNYOqYXTnUiJXdluOYqOMVaUeDgDiokWaNTSgrEdRRkmITczI0EYNqqKIGWYMiLdblP1BcxhhwNG6WY8ccatjeescpo7dwxDzCIZUFN84bwoh3H7uAA03ZitAm2P3acyeu7YQUIRQxsHZC5EESvWeyRmQ2Bmj9XmJETuIGWGXu5FuHYUMapwPCbED9yZRPtAAbp0QO4NsXDHqmJDlA4d8gJoZjughindGMUlV3HpRdwArKo4PtzgF8M/+7M/wiEc8AhdccAGMMXjd615XvjeOI378x38cX/u1X4udnR1ccMEFePzjH49Pf/rTR+7jyiuvxOMe9zicf/752NnZwTd8wzfgD/7gDz7vY7/sZS/DRRddhNlshvvd7354xzve8UU9ByexFMzzm8a6pf3Dyu7fqPl+0uFbLmBJ6r7YnaotCMwPlFos6YAtF/FEtbGoi5gcwCZmNMtwwwOV3T+aOhKaw8DO1rkrDtgsu3TMcTOICw/XR/iDHnY9ThEg0pYBaxFOzosy5vc3cNqwoc7c1VhGvmnmj44mQeUmLRqqjidmkxFkPZLYJTBzz4p6uBnFlSpKlZUaN4AjSCWm0nBh+1DUvmwM0txPfb8hsRdXol4AqnzZTXVvPEZwvL4JdN1qLqHuPRrDmJgxlnFrFtOH5h/GRVP2EK3Eu+R5w3BnMb6YPiLPPOJOi2xQxrVmjEgzj7jbUZndaYuxRZVBjYtRhdWOkeQq5bJDmDtXGkPSoqVLWavkducl/w85w6x7QEwl2RiYVc+mkGGc3MOiAmbZEbWbQKKcM9x6RHvNGv5glH/zfWFimvqMS2uMgV/H0j4D2SnUisHUWsSZ4d7sHsfpWXZmU2Mw7DEsuqKioqLi9LjFEcDlcon73Oc+eOlLX3qD761WK1xxxRX4qZ/6KVxxxRX4wz/8Q/zd3/0dvuu7vuvI7R73uMfhQx/6EF7/+tfjAx/4AB7zmMfg+77v+/D+97//Rh/31a9+NZ75zGfiJ3/yJ/H+978f3/It34KHPexh+MQnPvEFPwc7iPt3ndEeiANYHLUaBG3HTAeuNWgOk/SkJrT7oWSpTQX3pozFTITs7gnJa2gisUNGc0AlyQ0JyRk0h5HZfXOLYa9hxqDEZ5icGTRtGTljJZtvONmIE1gCoYfEyjagqGAaVxL2OiF+4syVDl23Gnj7HUaExJmXMetIciEBy6nzdM8KYcoGbJzwrF0zUXbE1iRS2qubG+YJ2j6IQsUMwFTy6abcPrMJcNetSEj6UAhXnDfSiGEKObVjEmLkqZSJQYLnPUtjCIrb1YQE249Hx67jpMaNZ83Ypduzdk7dx9wXzEUVtGuSQni7FaGTprF56+D2exkh+0L2bEjSrhKPVN3FnabcH/MTebtsDQm7pfPWKhHd6cp5KV3SslsJZ5E7D7QNz7MohfZgWfZBTZTu4FVPYrpoC6nPzsAt+fWyDjDGkrPI3wtLYifEna5zW3b+uPfHKBk7UKFGBtccAiOOyq6rHL+XD0Kur07gWzOqAFhRcXy4xRHAhz3sYXjBC16AxzzmMTf43smTJ3H55Zfje7/3e3GPe9wDD3rQg/CSl7wE73vf+44QtXe96114xjOegQc+8IG4613viuc+97k466yzcMUVV9zo4/7iL/4i/v2///f4gR/4AXz1V381XvziF+PCCy/Ey1/+8i/4OYQdVr6pEUSVPjcktAeRO3atQdh1R1SLcU/IyYxjYL+M3AE0wLDrYMJkFsmWWWvZCyEESs0WO3xR2hQATLtv0vKh+1cmZI7jwGgTklNRvhyX9c3IqBgAhfCpQsUqMCFII/t+07zZIpk0R6ja5FZjMQJwlJqPkColBXAGbr9HXPiSjbet8PHEGlGDWFVWxrhB3Kl9oKJ2Yl7MDtmaQlQBiBrHEXISw4U2h+jX7Gqgq7lxQniykBaHeGJWiGrqfDHBmDHCrUZGpDSukB9oyDNQFE8TmXOoZAiJymtuSZZtz9GzxqGk1hbjCyDjcXldTEw0jLTMFYR0MYez5jI+/aydxSEA1sBfv+Zzzxnu1JpRNq1H6qhS5lYq82Zt6WCmqWe6vzxvSwyO7UeY9UA10LGthGrs1AfN3UghlAOP227keSWuHTSHgXmZK65E2JBLMw4spvxLx90/fp/vd/4+1RFwRUVFxelwiyOAXyhOnToFYwzOOuus8rVv/uZvxqtf/Wpce+21SCnh937v99D3PS6++OLT3scwDHjf+96HSy655MjXL7nkErzzne+80cfu+x77+/tH/gDkVqETwmRRwpNDxwufVlZlw8iKOLOILYOhx12HIKpdnDm4DUe/DLWVrDm5YJoIdNeMCPMpYDk7g7CwhSBGvSimzFy0hCMXSxgg7HiYMdEEEhKc1J01pzZS+0aVKnWujE61b9aGVEaT8QRjUcwYC4mycnvNzFNTglXjhzh1VU3SDMHsLdJuC7+UqrY+wPQja9RGxs/o2NHEVEKpmYfDbloklFF2nDewh4MQ5FT25+KinfbKcpbj4vHHmacKu2g5whVSi5A43pT9yDhviiJbjBBCVrNzU/MJZF9vy5iQRcFk9iNJrhFjR5z5aSyuFXP7PZrrNqIeyihbmk509K/nRZ8j9DWyhsHXnZuaRhKoxs58UTWzKJQMz57CrdPeXI7FT+5gMYrkWVPCqo12BntXomKyt7CHQ3mdmv2BvcVK2qWSL8uIt1kF1syJCu1WAXHup6xJcMWhOdQ9SHHNSwWjiUBzWEfAt3rUJcCKimPDrZoAbjYbPPvZz8ZjH/tYnDhxonz91a9+NUIIOOecc9B1HZ785Cfjta99Lf7ZP/tnp72fq6++GjFGnHfeeUe+ft555+HKK6+80cd/0YtehJMnT5Y/F154IQBMNVRKCqRtw0tAsw0ZfsvNaAcJzN0oaeJYy4ZcTBl+kwsxyUZ2oDqDcW9rqT/LYry4jbXlw2nncJicn9kYhJlF7CzHvDOP1EqobqKilGYN/EHPseOioXonUSxuE4qSxrErjQMmZWjv7dQBK3mDiWHL3AMcSPq83TIlyO7XQV/iPzRgGTFvkSx524p5xPTcn9NQ5dzQPAI7KXxK1rIzQohkXy1Irp66kTdBYlwyshdSuB4Zni3KH0R1VPiDXsavQmBnGk4dSkuJP9UXpdCGJLuMCfFEi9KVLIpm9hZuORbSnJ0tO4YmZ4xnzTgG7lxRS0leUwmPRtA8SMcxt0TTuPUItz9w1249kuRpzZ4qsK2H6UfYw4FGG2tLT3E6a4dxMQD/qxfonIsRhNE+8npZC7eSajlZLSgkXxRHO0SkGTMLzUgDUnLMU0wzNynE+j6RD0PtfpAPT9qCY2AHrlJQJTflnFdUVFRUHMWtlgCO44jv//7vR0oJL3vZy45877nPfS6uu+46vOUtb8F73/teXHbZZfie7/kefOADH/ic92k+q8c253yDr23jJ37iJ3Dq1Kny55Of/CR/TgKDXZ8QW4P+pKPRQ9pByoUsTKoFL2K8X79JiDMqebGTOBgNCU5TNIwGPJfjNRwJ26A1b3QOZ5mEqUJEd6T8jDVsFekskjvqGs6etWjaoRsXolQtmhIETSVTVDC56MfdVvbxcgkvBlBCmFPrORZMepFm9EpSFWkrqDh3kiEo2YK5nQivqmKwdAinWSN7ZBy5lt5fPT/dpMZpv7ASE7dk3VqpWgsJ/mBA6jj+zA0DmY04n2HNFN4cuc+HxEDqUlcnVW9JiBoVwel8qWtXFVAnXcpKMrW7F8AU89IwhJrmiYy4s+WEFgJGgjmwTm9LQEkziYGZe6S5R9zryvfCXsfjX0gNXTs1rOg+oVa+wRnkWVvIXzEAAcjOTQ0vOTM4egiw++tiYCmVgMZsEe40nTs1wIwJdhOLQqu/O5qNCXC9olmS8Kn6F+ZThFLstkbeFbc6VP2vouL4cKuMgRnHEd/7vd+Lj370o/jTP/3TI+rfRz7yEbz0pS/FBz/4QdzrXvcCANznPvfBO97xDvzKr/wKfvVXf/UG93fuuefCOXcDte+qq666gSq4ja7r0HXdDb5uEkq7QWwM2iV7fsPCligWZHCHyZGouUHUPxkPJ2eKYgiQsMTOISzY9uHWEcgObkjlgqeRF1Yz7hIQO0jnKtVAkzPCnO0hYUbC6NZSDTcmDHsN3CidrhIFkp2FyWzG0LEiSST7dfmcczFymJgKsQNAxU1cvTak0l4R56L6rEekljExqXVcoxPVqwQ5q4o1BO4YgoYR7qZlxF2pSzvskeYNwl4HO9hpJ0+6g1NDxQvg+FcDliGmB6vEszES7SI7itK6oaPKuNtNe4lCXNx6LIonckaesx7NH0jGoN3KVlx4uBVHxUly9NxqmPYCtQHFGBhw7y11EwlLEpdjDErmXpKoHdOPSLszPi+A5ytl2BCmnESp4wNwJBbHHQ4keM4BlmNg08dJOW64bwljOOIFyZ5ZbpB35zTFKAGMCfDSZDKfiyor7uBTK8Tb7ZQQbKSMsHBoDkMx7ITdlqqmuNmTtdO4vk+Ic42FEdV96wMVMuBXW/uWFbdK1AlwRcXx4VanACr5+/CHP4y3vOUtOOecc458f7VaAQCsPfrUnHNI6fTjoLZtcb/73Q+XX375ka9ffvnleMhDHvIFH6MNMgIG1TwTc3EsAgx7NpHVbWFu0B4kOLndVP1GE0fqJuUjzNn2YUKiEUBCn+kU5uNR9bCy9wf4NW+juYC2T6yB8wY2AG7DMTRSRpjxgpoc1cDS3WuoVm4HUmcNMk4ZcUF3sO2D7Pxh2g00KE7U7C1MHxF2GTfi1nT6pt225NCZMUqItuxN7jYYz5oVVU1NDVlGlVmUKdtzJ2+8/Q5jb65dMZJmty3jX3s48HjnrI2zfYBZj8VFG+cNTSvyOmRv4Q8HHqO2ZTgqglbMLKl1xe0KUNFMjS0KmNvvJwOKE7WzD2hO9Xw6Y4Rb9lM0DVDq33QnMbWO7Rp9lJo0yQdM3I2MZYzLbEhtGgEAd9Az2Holu3z6PhFyneYNlbY+0HiiPc3eMrxa3lMl+Lp1SOoaLmHaGWgbErzAvEiMAWlnVvYM7WEv+6dSxbeQ+7DgBwRn0eyP3I+UDx02CvkLWRy9sZzDsONlD5brDXbIaA4j3IYmKF2fqLh1I1cGWFFxbLjFKYCHh4f4+7//+/Lvj370o/jf//t/4+yzz8YFF1yA7/7u78YVV1yBP/7jP0aMsah2Z599Ntq2xT3veU981Vd9FZ785CfjF37hF3DOOefgda97HS6//HL88R//cbnf7/iO78CjH/1oPP3pTwcAXHbZZXjc4x6H+9///njwgx+MX/u1X8MnPvEJPOUpT/mCn4Pb0PELiBM3JISFkLKcEVtbRrWxNRL+zJ81gfEsSfL/imFEAm+zNaXuyiTASkbauLBwQy6OYLbAZdg+I3Xcj6LT2HPH8ICqWpxZmKRRGxxbbwf0mpjhUyaBkH7eNPcwA40Kdi1jUCujwJThVAWKNBdo7AujZRL8Ke4VqpEjdYw24Q6gRTLMD8yLFs31/TTGdZgctv1YRr52lA5iQ5WyBD7Lnh4JswPmzTTSzHTEpgXbTNSM4lYD1UclY6K46T4evEVUx7I14ir2xRnN12XaV4wnZySLHclvblzpEjbWIOx1ovwZxB22hvjVgLjXUQHUEbkaXLLsWFoqeyZm9uuqmQYk53ZMDI2WPTuIw9mOsTw33Xs0KcGsxhI+nW43h1uPDJ6WHEWTZWQ+YyuHW480fuQMsxn5Wo4BufFl90/Pnz3skRsv2Y/yXorSlpJwpN85W8v3i7VIlupnahkNQzKYYJxDkjF+2HHFZKWqe/I0V1VUVFRU3DhucQTwve99L77927+9/Puyyy4DADzhCU/A8573PLz+9a8HANz3vvc98nNvfetbcfHFF6NpGrzxjW/Es5/9bDziEY/A4eEhvuqrvgq/9Vu/hYc//OHl9h/5yEdw9dVXl39/3/d9H6655ho8//nPx2c+8xnc+973xhvf+Ebc5S53+cKfhEGpd3M9g5up6JlSw6Z7fX4je1QW08VrFRFbjrHCzJZu4DgzyAFbC+6sd8uGiqPfJAx7jkQwcRSW2q3jylkiYnhR1eN0q4C0x3Fsaiy87KWZmJFbwz7g1Sh7f+wNThrp0nEMXHbuwP2x7Axyx1Fe0qiYXvpoQYVPVTcll8iZ+3U503yQAWMn522GhFN7Bv/azciswdaV7EUTEix4fmwfYHuQEC7JsHNjYbZFBSFu2Zqp1k6Iam5c6Q5GIjllsHaSaBxpGdH2kTHBxcRdRhk5A0BaNBwdpwSsI0xjJfbFFpUVANySxpg086KwUgGkCmvK7qc+Bw1c1vzA1PE11DGszXydIKNzHX2XvcLWS2SOAzrPTMKYy0g7tba4uVPn4fZ7uIMe8eQMabflCN45YCb5h/0ANAx9TjuzLVOOlxibCNMHGM89QTMEIYtCWoeA3NkS12M3DP4ebzeHPxzK6+j6CLvwQJJ+a8nNzM7I3i1J4XDSAwfDF/77W3GLQdX/KiqOD7c4AnjxxRd/Ttn/nzISuNvd7obXvOY1n/M2H/vYx27wtac97Wl42tOe9nnv//MhzA1wHRU6bexgQDMX2O2YETsjeXZCPhzKInvYcbABJQDajdOoV0e7sUXp880WW0piRugMmiQ5hN5y5Gyy5MUBydhCTAFguF1LB684b6OES5sgcSmdk70wg3CiE6dmKKYGOKm02yob0To1AGWslxoH43MxkBgwFBiOO3NR1EK3itL9GqdWC1UMlyOypdO1VKFtJneyGQKyb8UwIft/MZcRcy4zUBlhS4YeK+CEHBkLjJhIsAHMmIHGMD6xcaWKTbtw3eFAYu0cj0d6eRnJgqJ+5W4KvdYxbWoYPt3IzmTytrSLJNlNzIuGRHwTSCS9LaN3gMYOO3B8zt3LWGrdUuP4rCWXUWvyVA3MhuHR2VtmL+408n6gMgjZIcxzMf+sxqLSwQLZylg8REbEiAs4N9Ks0rgyTob+V6r+WCcnaumJGcfVp9YlUkZd5joWH8+eyS5oKqqofnAJC1dc9ElilWJlEBUVFRWnxa1uB/DWAL/JZS/Pa2E9ttyJkVEVVnabtMED4PeS4xhRVcAoJfd+zaiYMLewukPY0UGs42ErqqKJKPmBOlK2A4nouDBI8jMaCO03UZy/MkaUdo+szsuWpMdJ16w2QGRvOQZOuUR6qGGDd5SnyBTZB3TrUbp7SZ6imDpcH+EOB44Y93txh8Zym7DTcL9NYlZK5p7GswBsoXCiVEbm42m1GICpexiMHEmesTnJW5KoTWADhzNIHce1qfM8jq0QZ7cJJdImNY6RLy3r7aKYP0xMVMEkqoYHQFXU72+oGK5G2JDgDweaNrI6ounSzZ1DOIth09zzi1O7ihiJTJwyCbMBzCBjeT231kg8DQO604wu4O3vF4V05iU/kWPwLC0upo8SBUN1VFtZUkd3MmJGOjGncqrvIW+pEA8BZi1qYcNxuZHYGCOh3SbGKRpInMTZOeSO6qkdIvxyRLPPRhNooLe3xSXO1yXCDjSGIKPuAVZUVFTcCG5xCuBtAdkyniLMjezvqbsXEvSbS82VFXNFbHm79jCWeJdmlYQEinpnDcZdI2M5KoNTXZy6gLn/FOY6rpQRqvx8mFv4XhzHQ4IdebypsXCrADtw2b7EZ8iOXXaGe3ApF3UoiZkizeloBSR3Thf5dXQobtPsrIxKGR9jDBB3GjTXbbaMEpL3JjlxdknXrx0jclRFL5WWDgNxpgqxy+LABWQcvBmQdjoxHlBVVPdrGUdvAhWrjbSKbCS8+nAoY9zcNSUnTw0UultoS2WcKH2679iPiHszHpszdLGOiREve10x0QBA9q68TmnGmBkjzRk2cKycvYEDChmMQoRNzMjydSQg7XRlX9COsbwedkO3NdQ5bJhVqIqm66PsUQbkYEtrio7rNczZxAhrhdzJ/qWJERi5l2g3ATkluP0V8ryb6u2kFYWE3QDJTEYZz6xBWPkklBIjmNZRIn7kuUpmY7b6ezGFeBuJFVKy7/qIsamfcW/N2B74fI5EroqKii8C9f+OxwCtbHMj1TfN94O4YsPClQxAZGDc5d6ejno1yJmjS3EUZzC7b+t/iFojZyN/VsGctIzYcIQcOnsklsX1GU66UscdjoPtmJAby8f3BjZOMSTDyXZqj5AswdQ4mIF7ce5wQJxxFzHuiOKUM5U+jT9JE3HJzsrzS/DX93JBtzICnvL5xr0W4eS8mEXsOnCE2Qfp7hVnamNlfKvOWT5mah3C2TtUiRorWX1sMYHk4Vnt4BWjhF2NUx6hOH9NzKXhBJnnQPfvckOHbra2jHTtmq0lmmmXWldUztwwroVExZbsOzuEYiKxY+RxzHk+4tyTkOtxSGaeP2B2YZr5KeOx426dkfG5GSPPqZA4E8Wl3QcJ8GY4tz/oeczg93IrfcdxK4w7MTMxt57kb8OMP8bEWMbeOB4PimOc6iMaz/2/VS9mIcCM4nz2WpMCmJ4Kczg55/jfYlJ3xTXcHAwMKG9deV8n+eBgo5LNXJzyFbde1FevouL4UAngMcBIWLMJENJHRc8v1WGbihEhduaIKcFESHcwMJwQNWnIJf/MRn4PAJCBfs9h2LFbpI87iG4kKWQFGAnpcNIVxRCyD+g3jA4JM0cDyJJKXpQdvDRzcGOCk0o2jQNhCHIqxMsf9BKUnOj4PZQRbgYQEomhjn0BukhFXbMDL/p2kDEgOD70q7EQTrMJSAvpy7UTIZgIn5kaQrQebUywKz1u2UUTBZa5flP3sO6rQf6eGsuasgRoU0eaNQxTVldxzDRuSMVanPtyfnLDPEAnY02NabGrkSPNNaNZ/OFAhcyyyzd2JIu5sSVap/2HQ7RXL+Gv35T+XBMZjA1pMinPL9JAky3DpO2G2X9xpy15fyZnlOU42cPTSjqI0uev30ztIJbEnuYMqrhKCtO8mfb9UuL43Mj6QNfADCPjYgZpAzEG9vpDErtZg3Bixh1PYyR/UTIVN+w/jjsd3GEPd91qcmZ72QEdIsOzHQ0rbk3S61eRbvaMI7V7Fbc+bO98Vy5fUXHTohLAY4AVM0T2gBW1jc5bjme1xcMNScZWJH1unUqen+4Nmsj7ASYTiRpJnBDDZpXLPqEbMtr9RPewqIPNmqNG1tFNUSUmSguJZA3q3h/AUOi40xQXqP5JMypZqaX7161Hkp8F+3D94cDx7G7HujJxrdohIrfczbObUfYLDUe00rWrYc0mpNJRy/NoEU90Ry7mSftqPWvfsnTfsgmEKlRqOKbUIGg7RO76tdJRK+7ZMhJuLBswMrP6XB/ZY2snM4IZ4xS4LI5dbeXwy5Ej2AXJkln15VyX495tOYZVhUydwmI48fvs+YXuuTWO58da5JknYYKMe0VxzYUw0jjC18kzNLsVlVP3M/30K5+dQVx4KqISNM6DIbHT/UAzRpLRgWqpE5KOnEu0jYZOGzGWaEg3Go90Ys7dv8bDbPizZsX6PDtGtpl4O834EsfnZoxwqwGpa5B2O/kd8rJn6csuqh0iY4vsdK5J7oE4q00gFRUVFadDJYDHgHEHEuMBBjlbTKYPw5HwsGsRZhxbxYaj2Dhnr6kSMqcF995M+X4KGojhN+IClrDnbA36kxyx2ogSOJ25HojYTRlp2ivMOi2J7NCdxT7SadlHZrA1roxEFXHRUtHRui6pYVOlB3L/kIgVtxxJ3HoqNXaMCGfvMA7ETX3BqvCxV3i6oLuDnsRJqva4jzipktAxZ+J925E1bDA0dACqzPL5+2uXU8BxQ0Kbmsm9m6R/1mTuEyqRVGMLTRBuS+Gb3MZIjEIJUrfGJg+aTNxqmIhq65Bazyo6ANrDXEiUOqS1ok5/YyXmxi1HmF5dx5JluB5lN47u3tSJYSRpi4sQ5M7B7Q8kdoYKbG5ohtFxejYG4cQM2tOMkIp6mDqOgsMus4aSVObp84eoegDYTOIM8mKGvDMHurY0uvhT62lkru5ikKCakMq42e1v4Pc3ADgGZgYl1xD8coSR7E0vgd/tqXFatai41aPuAFZU3LSoBPCYYCR+RKNdYsdeX5NlBGtoCImdLWYRqnmiXLQSFeJZC6eRLayZI4FMrUGYUZkaF6rcTcqg2yRxCOeiHiKTBLKT1qA9FcpuYHY8VvatciSZ5aJs+1CIiDvsJ5evxKkoGUNKJfKFnbSTIzW1VPfyvEFaNKVFg24QjrjDyU4aKWyJocmOBoG417E+TUKEi6NXj8FN43Q1CfjrN/z+kAoBSp1KqrYQLivKniqFmmUIyMhxp5FYHn0dsuzW5eL61f5ircfT84PEHEM7RMRFQ+IM0H17sGGO4B4JUhIlNc45HqVhyE8u8ZHjZ459xVwyk0gcVUP9FMLMnuWxjGm1lcUOgcYdcdFmeT+m1h1RLK24tjXWBlZUzJkv+4+ul/iZnEtvcjoxL2RQ1cHsHM95lFDrBFhR+FR5VZNN3JtN7SkylkZMEsydSuUg73gyguRmWkMIc3c087HiVoc69q2oOD5UF/AxwG+o+AEo4bTDnqNzFxAFjhEu2QLNKpMQavYfUBS+5FFCpDXaolmxyi22ExlpD2W/sE/IM+b4jTu8aLsxSzRGLkSCyhKQ/URyTMjwS1aCGd19GyOSQTExmJwRd1r4UxtRkTxVIy8qzFaUTPJ2anCTSA5VkeyGaqASy9zyYu2v38hoUircUoIZOZ6d6uGoPKrqaCzvL3eMimmuXiHtdTCJ40l7uEE6a3GkX1fz9dKMMSNp1pTGkbRoYIZIVywAkxOyOHYLeYwZJkeYPhaiVQKMh1w6eeFtyT3MoMoWZx65pXM6LVqOQtX04SzcYY+423FXcDUgzVoZf04u6dw5JENHr0kZWSJqzGakQNo4GDuRUmAKfs7OijlDdjk1jmfhRfGVPU45p4z6GZEzn6cZh0JO1f0N6YZGJ+0w0vHLvUR+EMhiILGnlshtA3f9IXLbwC43SCfmfIyG0S7usOeHAnX/DgF5RocxQkSWXcwwa6YO6ZTZBHOyE9d6RLS3zBiYvu/xl3/5l/jYxz6G1WqF29/+9vj6r/96XHTRRTf3od2ikLdsIJUMVlTctKgE8BiQpfoMAPwqYtxzgAG6U1EiW4yMhLnPF+amdPZCVL/u+ojhhMOwY9DtJ9hEc0d2dPVaCW62MCX8Vg0nJqPsrLmNBD5bOpDdOAVHu15lJXHt9glxRtWlXQ8SUNwgzh384VgUt9TJLpoQiBwsSYezhZzZMcIeDtzBAwlJ6hzcciRpG2nesIc9wrm7JCKrsZgBkHMJey6KlDEwQ4CX6BIaOCQQWcaYbjUi7nWMThHykXYYuZJbZtrl1tLksqETNu52Zb/N9CPsBtMuIlD2FWEz3MGGWYSLhuTVy4h7zcBkHUnHRQsrRJhmGk+VNEqItrel1xYAw51FyYw77PJ1hwlp1nLXzdgjkTpKjtxhj7Ro2Yqy28EsuqlLOHDHVMOsNczb9qISxlwIsAkJbp/jVr4+E3FEyiW+h5mOTur/DHP/RC3VLEJYhoOXkXPjkIBSK5cXM3YFn9whwd+MsOuxRL3YDc9X2m0KCVb3trEJRoxABpPpxO9vaNJpGU2TjDi/N7csAvjOd74TL3nJS/C6170OwzDgrLPOwnw+x7XXXou+73HXu94VP/RDP4SnPOUp2Nvbu7kPt6Ki4jaMOgI+BpjIIN3UWMSZlT5gErwoe38Ax7luyOiuT3B9RrOM3N0LueT4dQc0htiQC2Hz0tebGhnpNqbUzMXO0HSSchkhuw3HbQCKyUQVORNkp63R7LSE9tRQIjfsGNHsD2UsaeIUhpw6J20g3BvT+9X2Cea3NVTbAvcJlbSpOSOcs0MnLegGTjNWkqn6BlD90b273FI9A8CdP8kbxJZBg080c7csi3rkGPWSGypUzf7A2JdlT7Vuo0qkL6QMAJU+GU9na2jIECKno1OkzNBmRyUtW1vcv2XMjcmgUMiZmDNKxl7PSJUkXcHZ29KSQlfzNPKezpfuBtqyp6igc5mjVZMBtxpg1+P0OsroXlU3vnczyZ/sTpbwZ3lc1tcJwZcGlrjwxYlsN+Nk1rEWdjXAnVrzvjc0ybA9huqkWaspZEMTS+T70YwR7mBD80vXIDde/o2pgUSbWqxBdlSQU+ekM3hyzt9S8MhHPhLf/d3fja/4iq/Am9/8ZhwcHOCaa67Bpz71KaxWK3z4wx/Gc5/7XPyv//W/cPe73x2XX375zX3ItyjUHcCKipsWVQE8BjhdPLcAMtDuR4y7FuPCwq9JKIYTGkkyOXJjy0y+2Fnu9knVm6qC2RnYkft/rifBsxlIsrvXHiaMcws3kAy6QUa/nsRTHcgmZWbweoMc+f3mkB2/6gRNjYWN6Uilm5NIEUBG29IeATD7TttBkuzU6TK/HSNS42h+EMNDWrQkiWJIUBKke2SmH2Gc7MoJ8XDLgZEmJ1q4/QFpxvuyHYOTs3USVk31Kpyc8+d9RyextHNAnKPsrO2m3b31iLjTAo2bRruWu3tWiITpJ/dvee6iSKrS5oaAcHLG52QN77ehWcIfDoXk0JziYXRMHBJMjhNRluDlPG/4XpI9y7jbwG79vFsNoihKxqC4crO3cAc9fz5rPIzhTp+VtpYWZTQOABCVzwRmDbrlCHvYIy06kjJxUafOM2Ini1EoyXjdmUIgzRhLD7Rdj8jzVlpBegZEa0ZgliaXMcBuBgndFiK4OgR0d1D2A80YYSSnEYColdz9c6sgzuJGsidvOXPDSy65BL//+7+Ptm1P+/273vWuuOtd74onPOEJ+Ju/+Rt8+tOf/jIf4S0PdexbUXF8qATwGBC9KcRu3OH4NzkDv2FcS1gw+FnJmB25m+f6VMbF7WEqhg2TUMwegAQ5jyQAbkiw1hSziBsns4eJKJEzjTSM9CcsmnUu/3a9tGo4C2M4lnWbAJNYg2ZbkOhpXl7LcWueWSTN9DscGH1iDbI4Zc0YywU77LYkj5rfJyYIuwmM7giJDtaWSlLuXNnxMtIlS6IohhYZLduQEHc7uP1h6iNes6c2zWhW0bFx9pY1cWIOgWbhWTFZSHSKklV4C39qXcKeAY64DWJRqDSgOjcOdjVgPGcBfzhK9MrUnlJ6iqOYY0bdTRzg5OddP3Kcai3cSoh1zghnzcreno47CxGUXMTUeriDHk6bSYYoPcIOkIDu7EnIrCilufNScce4H9trldxWdqFnbE+et8jaqKFGGw3Q7mVsLyPlcGLGUOlNLvmGWXp/AQg5ZZRN9haYt0dG7VhugBD5f6aiJMrId5sNDGOJjjEpASOPzUofNGbcd0zdLWfIcemll/6Tb3uve90L97rXvY7xaG4dqPyvouL4cMv5v+NtCDZmGYMa+FUsDsts6dZNjSn1bwCVv9hZ9Gf5Ms7NDqVBRCvkAAmJzox2ia2GRguxnJnSi6ojZ3UjDyec1Mtl9gd3NH2EHdnfktw0VtRxCd9tQnGdjidakoPlUMahZR/NQloj6MRlnIeV2BPehpEqiUYDaQih29chSY4d1MUpe39moMHADIxOKY0UxrCSbKtLtuTcdY71a30ou2lpp+N+nDhxlaAyhoUkSDPpdA/PrUfEEzOGI6uTV9pCSpNFSAgy+jVRYm4kRoWhyKHUtaXOF4UMwERsZRdwm2CRJBmEvY6vQZzicJSMaiyMP9VTUVVnrrPFdZvm7Ayms5kKrfbtlsxFjQJaDdwDXA1sNVGFVp6vvrZaD5cbB9OPVFm11WSvKyPwYj5J0/gYQHGVa7SLfi21HnHRIi86hkePYi6RYGgAJIYAX5NWPiAsNxI4zveLXYmCmHIJzL4l4pOf/CQ+9alPlX//5V/+JZ75zGfi137t127Go6qoqDiTUAngMSA2BnHumN1nTNnha68P8Bvu9P3/7L15lG1nWSb+fMMezjlVdW9CSEhQI4qAGKYGbcQGIkhWggtQbECxZXaKSJOgDD8WMrSKNi0goERQUFtR2kjbIAhGGQQMQjMoCDKGYS1JB5LcW1Vn2Ht/w++P532/XWWIklDx1iXnXeuu5FadOmefvU/d85znfQYNfx4msvbUnmDRAFLPZ0uLRzayLpa1sesyXA+EiS1Zfs12gpMsNI1zYdYgCiPouoTmeBy1gOKkjRO2X5iYkWs75tcFMpFuGUosTDYGbhkKm6XslglsDEHmKtntdoizBtU1C7guips0IG5IV60dQYGRVg6tkTO9ADhvySJJ92zS2jYxAtguSCtJHtfVAvCMrqG1Rq7Z0ycr/beAGFkco160zo1dtVzpRgl7ViBMkBjFcCDh0tO6dABDdJBm2ZMdbeg4tqvAFbXGnQgTWZo8JAqFgDLytho7k0cdp5GavjGMupL1u3bjsinD7fYE6caU7ylIoxua4NrP6fZVVlOvu4LoUmUn8Tv+2BL+mjmZy0XP85/4unHLgc0uYuZJ05rPSTSKdtUXDWdSLacFbDdwnb+7Qq6rfcafXHuYVVeYVzOwDxhdD1S+RBohAXFWw+6u6LZu3MimHrJ55CMfibe97W0AgCuvvBIPeMAD8N73vhf/3//3/+F5z3veCT66wzPrFfB61nPTzRoA3gSTvWT/tTRlVAu+2Q6bHrGxrF/TNXFGyQVUh7ACNjtk+CVXxDZibFtQNkhNHn3CMKXGUHuE6RIGqnlCdoyeUdBHcAhx6ybYPhWQmSXbLksIMk0eYjpYcb1qA6vXYLhOjLO6aM5Sw/UnADJBlmwgAZ/UjhkgbDYEcxhXwcx2y9KmUReAphlvyVs6nZ0tjRg6YaOmDq2L1L1JhpyONnaUCrSYWcNmGGhNIBP35O3Fcp4VvLrFgOp4B7MKNB0MqfQ1Qw0Yml1orWThWWkQ4TmJ2rAhDFmuHFlTPzJ3PCkSSD1E6Y+uqKvrhjGDcIglX1AZQjPEMX9RVqsFMAkrFmd1MVDA2vIYacKVMoGwG4Frz/uMwgKHoxNqJ83YMQwA/uqlMLIVAV/H49LVf9xskDZayf7zxQikWYywFmlrCtSSuegsWb+UgKaGCZHnfSmh2cbAzJdi3BEXdwYzBK200hzSIOiPfOQj+K7v+i4AwP/6X/8L55xzDv72b/8Wr3nNa/C7v/u7J/bg1rOe9dwsZg0Ab6LRdg5AdFVdZtCykh6BjIzrpPd3wzLzL7IZhGAQiK2BjcwV1DzAYWrL/SCTBXR9RjUnA+g6qYyrDIYN9gQPGw5WmkUYAcOu3OQI5KrtQKAp5gg7pNK165YDWzLE0YvMjDhklDWihvKWUOGUS7+v5uMB0ugxH0RnSParVHp1oaxDs4r+Q0JqPIajbXm+to+8bUXwAgGzwymTMXbGGsQNxqnEmWQY9qGETGsLh7ZJIGfY3Z7slUxh2fpQwGhxEncDQ5shoKsPXAsPBCzKVposPyOmCF0zF6OGNYWZVHOFAiq7lMe10pO8ksdYhdK6kluPOK3GXmYJZzYSyG0Cw5PhDNwu69f8l3d53JHr/Titxpo7cRWX66m9vtbAbfeIG/XY8qEdwupUVnZWaJs01VVslEiWANMNSE1FZi4J+NMKOmC8L2up8zOGVXE5I08aPr+NloyotchTAsrC+ErvsxkYp7P3eh6mGYYBTUOW/a/+6q/w4Ac/GABwhzvcAV/84hdP5KGtZz3ruZnMGgDeBGN7wK1yyfYzmWCv2k00gkgrR7Zc3YbGlJ7eVDHTjyYPgshsgH7Llv5f6v4IJl2fy/3EhsBxmFm4FQGnSTSguE67UQkWo4jjuarOXP/mzBzAyjJKQ13A1o46OCP6Ncc3dF0JKxC0QxxbIwAyYykVY0J2YrYQhsqkREAjYMJIq4SV1Z2aGqpjK9hAbR7NBQQg4ShZNtsFgtZWmLIMibgBI1WcGfuGteXEWbJangaUNK0ESCSCDqCEUkNYvFR7dh9vMFvQLnqCqBmNLeGUCSvRjEGuyeoxnsZJVIysmKXKDSDzGRsH1xHY8lwLCOzJ3vmdju0gp0wQj7Rw21yJaqSMVtNla3hdai9VcHXp500z6Wee1Iy9kXMAUKOZGj+ysKC5x3ZDaXKBuLttTyBnQiqaRQK1WlhEvpZsRwBrYoaVjEc1AJWeYV2BywrfiEEmnjoDanYA+2OLAizpIpaKPJUQeAuz6kcJgLfiEO9LPNFhm+/4ju/AJZdcgne+85247LLLcP755wMA/vmf/xm3uMUtTvDRrWc967k5zBoA3gSjGXtuFQWY8TSHqWVkS03Alq3WsoGrTXnzLataTzCYLTV/JmckBzGBGFjVyc9jcUiqPjA2fAx+jetgraYzEbDam7qIgIGsc1PRU5meWjYYEIyIZo0at1xWl3bgY7PNgkYCO7BFQwGeskVk3Kj1yhVBWq4cwtG2tFsw9BgEG6rNa0ULKEYMBWdu3vP5ZJSYmAJ2vC21Z+WxJhVNEfJ929PkYocEKyynCan8Vqj72K6ChEYTcPndnuHJMSNNqmKG0TgbGMAtB7jdHrCGTmWJJ1FgCzF5wBjp7gXMchDwiKLZo7FDdHDCVGZvkCdVea62p17Q73S8ZlJLZyL7kOOkKoYMDWuOmw2QMt3DC+r2dNVrVJ/pLaNjDNf/e1f01OUFCdumo9p2gQafLGYPY8hitn78l0a7neUaxFktrm0BaolMrV0FxsIsqU9Ms6YYZqj7c0VLaHdZ90fgL/FIfeCHj0MaHverv/qr+K3f+i2ce+65+JEf+RHc5S53AQC8/vWvL6vh9axnPeu5Kedwfjw+ySd5ZuwNmw6uy7CBGr3smM0HcQS7XgKfI+Al14/RMCAzlrj+NZGu3tUpDjYA0RPE0RCiodEQfZysnPssodAZLo5O4ebaAWEqrIxWq7UESLaP8BL3AkvGz3ZBojxkHVgZuF4YOmdKHhycGXPfNFMOZGfCRg0vmYFa/2b6UOrOTB5ZJ7scivMUwAi8Kq5CEXPJtgtHWwKMirl+WleXa2EYE/VoGhKt4M/Ne9hOHsMYOnePtAImlVFNo1tWHKtxUtGYERLSRi0ZfxJe3YfCLtolGU1dT+eWgcrwFvAG/tolcutLNqLG5WSJocnWsGpN17DeIsVcDBepYU6i5iwyCsYxI3kVeLzimCZDyTzEsor39fiBIWfE2om+05b2FKOuZwHB2hOcKwu/O5RzoCttWAI3iANYmTeb0ujElQiZJBEt/tiK51Fq+fQ2SMIoGwMMrKrLxsCsBuRpAyDBdgMQE+NsWq56rZxLK6+XuNUgrxYH/Nt9MHPuuefiy1/+Mra3t3HKKaeUr//ET/wEZrPZCTyy9axnPTeXWTOAN8FkQ6NFtUMjQawtqnlCtasOYAI7G0S3N1D3l50aMRjzAnEHB2kTUWNINc/wXaYuMBIMxsrALxNbR4YR/OnaN1uDWFtmEHYJriMDk7RNwQBxRhOAtlSomSCVlSkNJsWaZ2SN6dgSEo5OAYAGAl1JOovqmgV1cc6OFW7C6JVYk9YjNm5PNAojWlLry3rVLgdGhECCqrsorBjGuBJx0aaWsSJ2FWCWQ2HPYA2G06YjwOxCAXJ6THagng6RGYFZWyvkecctsmfFJLIc16TJW4QjDWLLujzVvunrIhuU7EPNAyQLxvMOaeiwshYHxFEcqYUkWEqImy3ipEJqPHMAF+L2FcCV2kocvKygK4Ybifthu4ktTtzUVsLUmXGFLxpM28fCppkhlftifAu1jKpr1Ovs5r2AY7KPufbFgOOWwwh4VwRuRuv9BLyZjsHRaWsCBGG4Ky/gshLNoQZBR2Dg2hshlkxC2wUcTv4PuN/97oednZ194A8ATj31VDziEY84QUe1nvWs5+Y0awB4E0z2BGrZC3ORCcSyH1e5mgkYJgR2vktIjl291TwhtHzrSt7Ad4lgcZlLnqDtM/pNi+zJAlZztk6YmBEmpphAICxh9oaNII0VwMSYGJMy3EDziGanaeQJ1611AQVlfThrqBOUGJHS/atZc1oTJroy1X0x0NdIL66s6YRp0jWqag4VzBkxnGi/bjw6LeYCva1bDgQdsqrleUisSqvJBNlVkIiSCLcQsGEtjJhRiqEjYwyOlvWriYlgTlorGDsjDmBx86Z6XLGaPsHv9qiuWXAFratJJzWAcj8K4GwXRqeuaPpgRf8n7JuusRnVI0adVShr7jitEDYqgiOgVNXBW8SJL7cFUFzatg/FqGMG3t7tdmUdbPbE0BTQWoCrHW9XInzsGN0DstjU/kFcvWZc+2pzSOUQTpmObuSmElDcyDWokBsaj1LtYToaYZLIAJC4zs61PO9AKYLdXcJuLw9tjsjb3/529H1/na+vViu8853vPAFHtJ71rOfmNusV8E0wTlIqspHaNWvZ1SuNHEEYOe3rzZ7hz/WOxLFYoNkmsxU8TRxxYiTOZXT40ggiocxi8nBiMDFDglsmmkymqo0Ss8hEgoxThl8xx87v9AibrO0qLJ04VLMzzIqTOBbNtAtbLde4y8C6LhCgIDnJuBvPCTtmI+vlnHTcxgxjMkwnmi91y0q0iMk0R9iUiykiVzSF5JTh+kAHq6yfAQYkm0TTgel6xFNm4qYlG2bFlGIkc4Xr0lBYtNR62GRFK8mIHGUp7SqM7RPLAXCpsIxoHDAAxmTAEtxZT/2idgnzAXNpBoEFELKEd0v4t2fNX6pH0JYdATEr9hKDkGVdjayygYzkDKwwiWQkeQHqqxd0GmusjBg/bMwlbBzOCBtqJfoHyMK8mpiQ2hqptqiOrZBauo5NL852WV2XSjdhZJHAeB+pCETMMJ5ua11fI5PxZMdyIvNXy0pdmOjcVLDzDiazlYQAmEDS5DFGCDEje+kwrpQtXR3sL/fXOP/wD/9Q/v+jH/0orrzyyvL3GCPe/OY349a3vvWJOLRDOXndBbKe9dxkc6MB4N5/yL7aueMd7wjvbwaYU/7NSjVBmltKy0bl2MAh4Mv1GcOMRo/ojBhCjLiHGdeidXB2yDAD37RtZIC079n+4ToGPvtVKs0gegxh5ggWQkaWhhHTAfX2gNg6xIrHkyYetiOzg5Tp/ZiQqau+vBAGirVqqa2EdRFzS9NQc+ZokCg1aYsO8eiUK0upijPRjuDQqaOYTRB2OSBpP+4QEadcd6prFyDAdPMeuXYlMsZ0sRy/VtbBW6TJTLR4CXGjLjEzJqE0dACgqWNgi4i2guRJhdRW8Lt0uxpnC0toOwLBEg0DMM5GdH+pciV+hGHNQNyoSyadspmat6hdwnYVaHYVvaPq8/yxFevxKle0kyVqRTqEkRL8UgCisIhmiMzg06xCAffZsDItTir+bJRjlvtRVlJdvNka+O0VAZd09NrlgDSpSnsIwZ9Dbh1SLQabnJGNsIEDNZDJWxhZO2eJ/0HKSI2F32XOH3WUAz9cLAbY+Qpp1hZjR9xqaPiJSfp++XO26wDvRgayD0jteI0Ow9z1rneFMQbGGNzvfve7zvcnkwle+tKXnoAjW8961nNzmxuNxvQfsvxVrlistfjEJz6Bb/mWb7mxD3nyjBgmbM/Vb5ha2EDNXr9p4VcEackbVLsJsSEDyIgYhkQ7MYXYQCCoAc2aLThs0OihsTIAHcDDjEAwO0NzSIasgQ3ZLCvB0RseJgNuSSdpmHkYp47hhGwsbMcYmCwBwdkYuCEiTiv4+TBm6MnESSUrZa4z86xFnLI7WNfH+uaeK1caNszAWrhYNaOTd4jFpEE9Wi6xKXFSlXWzW1CjqH3FyaNk7yljBm+LecPkXHLvIEA0bNR0v4YkK2r5fhDmLmHspYVE04geTte3/RkbPAZn4OYdhlOnfExdcS+oRSxALiY6raXBYm9HsRkirIRn25Do2IWsbCNX4qn2BI0Dw63jBsOss7NIjZP1uBh5LErwtBkijLUFOCZvYbSerqPjVt3XJnLFq/pKuwxF45cmFTWArYeLkvk478TFLce26vaFcZshwjpTWD7AFFOLP7ZC3GxKswxihju+ouYzZ9hVjzRrYOcd/HFh9XKm6Wg3wiCW/mgAhcm2w3XXrCdyrrjiCuSc8S3f8i1473vfi1ve8pble3Vd4/TTT4dzhwu0rmc96/n6nK+Jjvu7v/u7ff+AXd/knHHOOed8LQ91Uk2sqffL1oyZf2Lw0DBnkwAbge6IldiYPK6BPWj4CGT/TJSMQFn9JgdUu2QCo2TNOVnHZWcKG+g6/nzJFJwwHzDWbNSwK64hc225QhbAwdVnLH2zRfRfW0TbwB9noHCeVkUjpittN+cbrokRcdbA7/YEVWLucLviel0FmMaXnDsFRVm6hFND4JgqB7/bMXdvFWDFtRs3atilOD8nVVmRZgGDcVpTG+htce/mii5XNX6kiSeAhC21cTQyEOz5nY45dolr3axGDYCmCAuuTGsPNxejibXIDVtDcuVgg6y2Ld2pSTR9xc2bcjGXhK1WomOESWzGbl8btFuXQMo4y+xAAZVuIWtVa+AW7CB2C14LZf1Uh8gLhBKXou7t3FTsV8a4wk0TMVpYC1gyp25FJlV7g8lUepjA14OJzPZT7aeRkOgkmYhsURl7nZEyY20y42Ry44DKsTaurYqzGDEjnDKFP75CmrCtBJa1eXFjwh5giczJAqQPmwbw7LPPBgCklP6NW65nPetZz007NxoA3ve+98Vtb3tbHD169Ku6/X3ucx9MJpMb+3An1wjpYWJGbAmM6h2yfyaLY7cTkLEiILSJIDBMZH1lscetaTDMjIQ+E0S6gYBQ3+BiQ9dxlu5hZQxt4PoXluHURta7fPNnQDHXgQ7VsY6r1MTbazxJql0xZbARxAPTagwtBgBr+MYstVy5IjgZjrbMpwPIVlkAQ+I6VevL8thAEmdN0RkqQ6hu49y4sgJOEwJEzbNLlSPjJiYQK40cqakJWAwk008CjAVMqZlC8wfdfHSkFkNDysUAocHUhRlUYD+Ipk9AjPG2qJeoqbOIm43kBJqitbNdjzitkSuL6suLwuzpetlEPi6M5CM6g+yo53OrALuzQrjFBs+HMHp+1cMBBcyaLgKNI5je6XgtlwFxVsHNE7IbQa86dfPEwS56uEWGWfZI0wZxVqG6eo54ZEKGMWaYLIAupJLTx9geiY6R102cegniluBqzzUzDUBR3OeUHWh7SdKGE2fhjq8AJ6/ZWuJ8BBSnjVaeZ2B9nImle1h1kIdxPvGJT+Dtb387rrrqqusAwl/4hV84QUd1eOeQYfn1rOeknxsNALXI/KudN73pTTf2oU660S7f5BnNkrwp3b+xGQOch4lFqgzaayNbPCpq/ZI3sCBrVO3G8nWtfAuNQWhlZSz35frEiJdVQmxpOvFiMMiex1IfD4iSO+i6KGCG7t96QZCWnIXT9WgaGSN1pKo+DDnTAKGO2KDaNQDJFKOA3xVGcEglK1B1XiYk6rSmNU0V3iLPqmIS0AYJrRgzHZkvrSYLRxquRPsIt+iRWoJCjWdRJk3z/LSPlxrDscM2CziyQ2SYs8aRGNax5YrHqmvVqOBXjAdGWStw9e+XK+RkkSXAOjWOIDxmxJbrTgBwspa1q4AchWWtxDCRuKLNBrIiXY4xK5rNFzNyWzFYu2E0ihNtn5t3QO2LExgpw+324300Dn63l6YOaVZJGelIW1pb4kbD8ybXyq0C4pGJVM1lhKMtnOQNGo3iEcOHiQlhs4FbsLs4zSq4wGtjVwPDvK2VOB++iNOEPdJ6TKbXdW4swdc58u/aL60fUGgkaSgNELYyVw4Iw4H/fh/EvPKVr8RP//RP47TTTsOtbnUrZh7KGGPWAPArzBr/rWc9BzsH4shYLpfXy+598YtfxJlnnnkQD3PyTIY4c/cEPS8j+k2Pejshy1n3XQakI1hMqTR+GAAR4+pQtWiGjuB6l2+MsdHVLVm+NAXCUYfmeByDlQfpHF5JI0lC0QJmZ2C6jFTb8vFanckGpgAQQEKTtYUi0nhRtGKi4dN/oEu0SWHMdG2axzw4cUjHLbI3kJYONxd9W22LcSDLWhFi6DDScctQ4p5AUNi85CUWRqrJFMgiZUD0k0ZiTDRQ2u72wEbNtWXrYSBaPAF2XFFjbOiImQBEqtDUQJGlGUXjbyDOa7dLcMprSfZTo3bsaiADBwIorptFn1eNWYWF/lBgLD/v+pGFNUGyDiu3r3+5rHWlJ9jtDFL7plS1gdvpEGc13M4KJiQaMPpIM4Y0lmTDx3BiBIERU5Cssu1S/j8DSGD4d6JRozre8XisoWFD3dhJmFRP9zDjdPi6pzmEvyxuRce3m+9xEMeM3CpTmouZiCvpCi4O46r5kM0v/uIv4pd+6ZfwtKc97UQfynrWs56b6RxIDuDd7nY3fOADH7jO1y+99FLc+c53PoiHOLnGkJHzywi3ykgeWJ7mYSMQJgahsei2nLCC0u2bAb9KZTVsA3V/w4ZFv+HQb9ry9VQZDFPtlKXeME64fquWie5jyYzLDqh22ZNrBRSGqSv1dLaPY8i0mDW0fm3YZAagm3fU9y0HuPlQgIOJzIRL04oszEAmSZ2j2RnYxYCwURN8tARFcMwkDJs1wlTCjL0liydv+FrRpsAnewszX3E1KCtpf5waPbcI5dismD1sH+CPLQu7ZARUWM22swZpo+a6V9k7WYen2iGJ9ixKOHKq7BgHs+hLXZ2GS0OiV1IjBogusNtXe5MXQ6EwNGMQ1iAcmZSGDGW06I6lFtIfY5ZdaiqEIw3PpRlX/9nyvkxHs0TcaHjeJfzaDNTOqRvYSgBzCY3WYxI9XW4qpIZmHs1DNF0sUTMwhtV8ck40pFvvw2jotLdkdXVN7sf1e660pi+Xyjs6xyGvyQB/fMXX3Crs+3ASp/VYG6dtKyDzikQGVe+DgdCHU2t37bXX4mEPe9iJPoz1rGc9N+M5EAD4gAc8APe6173wK7/yK8g5Y3d3F495zGPw6Ec/+ma5ytDatFiPp7eap315cNWc4cvJ07RhIn8mNAbVgtVxSdo93JBRSetHtrx/3xFYqkM4Ocn4qwyGiUV3xIm2LmOYeaTKFn2h69kE4udBWKu9OXVjrpxbBpguImy1wqSxLYS5cF6aJBzNCFLZBnnTNhkEUJtNaRoxQ+RqWDp43TKg2umLvg6WQInHRD1brlg/lr1FOG2T69I9WXO2CyVoOLWerSRHWgY3C4gCxJDTERTEluyXXY7rQSMVbArCTJRVZEhi2Bh1cqVbWO7fdnzuScKxsxw3hMXL0g5ihwi30xUwmvVnRa8YTplIPV4ooFGDnVPraXrRSjkJyIaV+rzal+dRDCP6emx4Dm031vGZmMRIYUsUjzaWoJh+fHl8gDFGyBl+p4NdDVzvakuJBIenhpmAphsIsHMu51F1grBsjtEKuzitSmZm9owBirOaj5fG3xv9r4L8veYh2wnbJ+eVzHTkuvgQzsMe9jD85V/+5Yk+jPWsZz034zmQFfBLX/pSfP/3fz8e+9jH4o1vfCP++Z//GVtbW3jf+96HO97xjgfxECfVGHnPSY28yQd1yQIQpk9BG92+7OmNjS3mDr8iMwgAqZL71MotA7jdCBPFXWxxnfuxPbMBdX3cXDMgic4sOUOPh7xh+sWA1DCWBSX2hKtWCvEz/LYYPAZpDElcddohwfZdaXWAsGyaxQbR0QEEMW63K6YBEyWLTkwV2fK4/E5HYFXOZ4LpqCljQ4asGldhj3t4DBbm+j2UtbAaLxhMLIYT6dt1S8bHRGH/zBCRZP2JFGHEwWxXUjuXCJbY3DGubsmuCWh1YkAQIG0knzBJjh9DoEdGjSyihekTjyck+GPLArKNhFK7eU/GLSTY3SXyhOxbmtYlNscMYqCYVAIkzRjEbASw9mzL0N7m8nxqL1V1BnYVi9bRCMurespsDIy1jNMJiXIAWcuaSJCX6oaZhGJosUMaQWrMyDVbPgrYFvOHxvoU5/UeTWGc1tQWboixR7SNsBZBQ75BwOuuXQDOIp66AVxxwL/gBzC3ve1t8axnPQvvec97cKc73QlVVe37/pOe9KQTdGSHd9YmkPWs52DnwFKZzzvvPDz0oQ/Fy1/+cnjv8YY3vOFmCf4Axreozi+Lm1ejWkxiTzBA9k4r3MJkBIiu55o3tASPdPvKfeUMN0CCpakPtD3fVDUWxi0T4sTCL7j2VRNKtgZ+HuCg62GL4UgNvwyIlYUPEaHhSjU1YhCRN2g1eKiuj2Ckglswmy6LYxhBGBhZBeuKL+5lkqYVz8cqlxo3uxy4pgSKfs2Iu9dqcLJ089pAMARZNfKkUyM5HGlRbXflftQsQPPEaCDZaxYx3QCXxGkr3bnI1Cu64yvqEAVIlRV1SBK4LSv7bkDOHlbuRzWEpeMWgNvpuLZcBaQjLZKwkmmz5cpY8hHhLcy8k/UpCPgSgZ1dCGvpHeJmy8deDVxZAzx2Q01olGgVMoxgcLOA5zSpikO3mH2sgTu+LMyfuryLY9saJOdLXItbjO0w0VvAMP4GSZo9ckac8bhi62Fqt885rjpRpAQjDS8AyjlkdJCBWwYgi3u4cQwst6ZoNm1IcIvxmsdZjXDqjOt8HK4cQJ1XvOIV2NjYwDve8Q684x3v2Pc9Y8waAH6FWbeCrGc9BzsHAgA//elP45GPfCSuvPJKvOUtb8E73vEOPOQhD8GTnvQk/NIv/dJ1Pt1+vc8wMzA7GJs9Fgx79vOIKM5M1ydWvNWj+69aJAwzC7eMcEvJ9Js5ONUFxgwTR8E7RfkKNg2SAbKjOUT1VNkAYWLhZS2dKssomcRcP74BA37O1gS/M5D5k3w2ZZSyMyNYG9gW4eYDAZo8DjL45l9zDajhyqXGzZl9LmITc1mX5pQZyNzHUs3mj62QZxWio3nC7XRlJakmBXWRmmwKm1kA3hCRwDgRuxhgkEqEDADkTIAJiaxJteospStXwBYbR+jWDao/lMYNro2BcGRSwqlhTQG0RtaRtgvU3uWMuNGSwbKGx6MMngBgrlNpSsmVJdBesZUDhUVLJc9QWb1UWXkejg5myRIk4yjPtXaiRRzzHvUxszXs2JVrD3Dtm2sGbiORxStB3pNqrHEz7BhmDl9FnWTNnMVsRIOpq2WDEiAepxX7h4WJVXc4X4tdOf+Q9hLNdjR9oGRAniMCgWlqfclYTN4i5/H36zDNFVccQlpyPetZz81qDkQDeNe73hW3uc1t8Pd///d4wAMegF/8xV/EW9/6Vrzuda/Dd33Xdx3EQ5xU41cZ2svrelml+j0xD5FavaxZe4m3jS0ZvdRYDJse/ZZDcoDrWPFGAGdKX7CNrJvLhlEvMICTFhBkrqAB6g1tJ8dR0XBAJ22WPlhDMChGj8JuWVPq0Rh0PNaP5crxjdeQQSshzhIMrICCK0ayeCbmsvZU/aCaA7Lk2gGQ+wDikRZIjKwxw6hFTNJokSoec9bYFlm9lkiSyiHOyDam1pcKO3XoIoPPVxs4lAkTBiocbch+mTEAmqYdCc1eDqPJRDt+o2jWBMzFKY00pWWk8fsYsDRhfEuaVEgTP64/IUypxt7oul3OkZFjUJY0SdxMyQ8cUqm7M2Fcn/prF/DHWO2n9xtn9fhzarqQY02Ng9vugZQYug0yiYgSGq6RO8J6hq0G2VkCYgWjzmLYohZUcwaB0S2eJfswGzNqCfX49DUlGYdqAkptJa97ef001BIaaRIpLve0Zo1O5tm39l1fyvWs50DnQBjA3/zN38SP/diP7fvave51L3zwgx/Ek5/85IN4iJNqTCITl7yBW0l+35ARZg42ojSCZAfYLhdTgFslumNbC79MUHzulxHDjJcqVgZVnzHMCJL8IhHUiYkktcwOROaPK6vV7ETELKvoJVe82Rv25wLCXKHozuxKVo0JCEca+J0Osa0LwEkVjRhu0dM56qnVStptKy0fgJgQRKMXJxVXuhMPv9MjOcu2B6Do9ZK4RKkdE0GlZWzLcNoU1bVLsmsSKO3mvQAFM0afCAh0nYY2Z2TrhD3VC4WSXadg0fQC4JBgpWPYhFx6hGFM0eKpq1pZNyOxJW5XmlIqB9iKb2KZFXsEwIlAS7SDqSXQ8vMxtiTOarpmE4HWGAMj4D1GZE9w648vy8pajRZpwjo7PQ6T+Bw0xFkfx/QBqPnYqXb7+oyRwdeHALHU1nQRW3YwD1s13CqOWcsxw65i0TfGzaa8jmxIrIBzrrS/oBnBaXYSbL3kylxbTFJbSbSNHXWmma75LDKGVLnxQ0uS6y7XpASVH7J53OMe969+/1WvetW/05Ec7jmkl2896/m6mANhAP8l+NPZ3NzE7/zO7xzEQ5xUM0xp8HBdRr9l2d/L931pBYmwQ0Z7Lf9rBzKFAHV+riM7pSaQWJP9MZlNIP2Whe8UiJlSI8ceX4hD1iA2VmroUByqkDdvAHyzdBb90bq8ElLlkGpbVnxsEOFKFklYyCLSN8VJmho6YyGNG4XxqslO6bpSTRH+WCchzmNfLle5ukoU8CasUMnEGwQwNI69u7udsEASSJ0ZKJw9gYEaHFLji8NYWSIrwdDZQCriIuyKTSeFrYy5NI2oszSLXi1NfGHozEBQZ5cMtk5tXcCO5uqlxpfzoQyciXxMo6HPrUfYbORa2fEdUE0kIUnESx51idOa2kUzxseYLnKFn3U9nyUAOxJAynmKswb++Gp0NntW21npTbbCCBZTyypQbwl+MHFdhF0N1CFO2dHs5n1xOWucjukGmGUvH0oEbMt5gTUMlJbKOA39Vie0kSYWM3CFb0JiBqOMBlmbIfJ1YUzJJjyszoFrr71235+rrrqqbE2OHTt2g+7rb/7mb/CgBz0IZ511Fowx+LM/+7N933/MYx4DY8y+P/e85z0P7snchLP38h3OK7me9Zy8c2AmkI9//ON46Utfio997GMwxuAOd7gDnvjEJ+IOd7jDQT3ESTMmZ/hFAgxKfIsaOUwYzRsEUwSKNEsAZpURWzpHuL4y8ubPn9ecQF0HE6igsDCxNfBL3p8fuFbOlo9jY4Zdcp06HG1gwTfR+vhAcCfAzu2QtTGWwbqquyoAQ25rV8x5s7JOjc0IIjSoOMubu5on7IrNHpoxNxxp4RdDaelASAQHmatmuwoEFlofB54Su9NLRAzpvLDVEkwCDF4W7VuaeEAYsNxI64asDotjeMnwaXd8ieG0DTpxAUDYNyssZ8mj03YRUxF49HTgZjiphjMw3iJOyR4iZYl0ke7fmIuhhnq3Cm7OSJdsXXHm8kLv0UYOjG7J1pQIlqxrdNHlpbYqJhormYJWWlLMkGBilFgeqXITDZ9RA4ozzBRMANQVvieEGhY8h5WDkVid7Bkr43ZWBHwplfo9s0ql2ze1s8LgKaC1feRqt7LIjq81JLLGRaog+sfU+pFt1ZgbZUhDQtyqaU4JYdRvtgfyGffA53//7/99na+llHDhhRfiW77lW27Qfc3nc9zlLnfBYx/7WPzQD/3QV7zN+eefj1e/+tXl73Vdf8XbrWc967n5zIEAwEsvvRQ/8iM/gnvc4x747u/+bgAo8Qavec1rbnaBp35BBi5MJIbFKstkkDzYfmCE6dPwW10R9wkmMdIFOaPaCbJS5hrOdVz5ajtGtZuQGgK8KrDxww6i9UsZJkqLhjVAkNYPEfW75SDgg2AqShRLbD2z/IR50cw220c6L6cV3M5KYlXkSVtTHL9qTMjOsnu2ksaLytEgIk5UuxoEKBikGQGKunPJALKjt7hFJTA51Y4Zc0Okq7U4YCF5dwHWJuYTzqkvNBnM5atdYbAAlEBi2wekGVfdqXZI04rMmGM4cmxc0ZO5PXl2qotkV3KUdgoDrBJMyGSsBvbX2mUoAcVkWNmpnK2BXw3IcIWBtMswtocI+CvXRWr8TEZx1YYj7eiQNSih2uxulvNjwR5hAaCui6Vazni7bx+QK7cP8MOS+dX6OoiWM8k5RmQINQ0nIKCcVqX+j0HPNCq5RSgsdBaDj5qHYAxyxXV+iaqJeV/IuJFA6zirgGT4WMbA9HQJ09gDuHlXJA4nw1hrcdFFF+Hcc8/FU5/61K/65y644AJccMEF/+ptmqbBrW51q6/1EE/o5EPK5q5nPSfrHAgAfOpTn4pnPOMZeN7znrfv689+9rPxtKc97WYHAFPNiBfXJ8TKwA0ZTkwcCkYy5Day7h02HaqdiOwNqt0gmj+DuEmTiOoGUwUJjs6Mi2kMncANWcZUG8BYGOkBBgC3jEi1hYna4JG5spWAZo0LUUC4781ddW6rQNaupoFiBBUSHWLIBBpZHaaGYIXRJT37fwVQaLZdmtai28owneTlAftBi7iFyRpJALK6fwV02D7CZMa8KMtWRpsmQtrXWqEMpTFciafKlpUwtXOpuHORM4Gk9PSm1hfgSOBC0GHcWKmXG0blFJezrN+jNopkgsO40fA101bFvbo3W684ZhVsy/lFZHA2QRPZRCetI0kyDZllCBjsCSE3BrDMzkMazSGaZRhnHkb0m2aISL4iwyvMmpo17BAJ9HplMdnji0RGE7WXjmhhdrU9JmUJE+d1Afic4C3ixMNeu4KRDyK59ux/jhFx1vD2wtgyyDuMBqDaiQmKHxZi61mxZw9nE8j1zac//WmEEA78ft/+9rfj9NNPx9GjR3Hf+94Xv/RLv4TTTz/9wB9nPetZz8kzBwIAr7zySjzqUY+6ztf/y3/5L3jBC15wEA9xUo0J2JfpFxuL0PDNz4muL0xtYQC1+iu2Gt9iCwMIY4vjFwbojvDnyApqVp5BvROFGUQxgGSgaPVYIWfhl2FsXXAjE5Yqgj232xVXqNulEN9kWZlGt88EoUzdcNqGxL2Iw9eODRzam5sbN4Yfg5pEjS9RPZeJcQRCtQXAHD6GUadRDxcSjLRImJSLg9UtBlbbTVll5roIk+hCzpVjILVF0fJZ0YohSaZdRScp8qgry47fN8YwNmUVkAX4xc0KSDSn8PgT4kbNVWthtYTh2+nIyPUReU9Ysz4vk8X4MVA7afYwq0gG8AQ8ZojI4hxWt65dDaVlxS2HkZk0Bmnqy/lUvaJbSaSLs2PVmjFIE66A0VOPGGX1rB8+oOYROX9xsyndx4BKAFxZy+rrWh3f7AjO8MdWbGwR8J4rav2c5+ukMIZ7qt1gIPmTg6yfh/K6iBvUTDpl+0S/2Z0+gTl2OBnAiy++eN/fc8744he/iDe+8Y149KMffaCPdcEFF+BhD3sYzj77bFxxxRV41rOehfvd7354//vfj6ZpvuLPdF2HruvK37e3tw/0mL7amdVjo03tD+c6fz3rOVnnQADgueeei3e+85247W1vu+/r73rXu3Dve9/7IB7ipJrYAnY7lxDoaiei35J/yMQMYoPk/E3IFJLpUW0UDRzVduBKOEPCoi1cD2H2stS/MR8wNoxfscp4ReoBbU8Xsu0z18deMt3EMVvYMgvEqYd1RgJ3fWED3ZzNHKUpQsBUmlbIXoGe9M6OEYR8rOUgXbURxkbR5UnX7BBgYkbYbCRj0BctoF1JN6ysWrlHz1yDameuGjMiGbNsDOCtMEO2rBDVoewWfTEdwBg2bmwvkRuyRXHK9ajXvEENih6EodqoeX3EXWoXZAXVjMIbi2ml8XBiNCnGDAGrcVoJCCNQ0aBs10XERlevtjCXiLmsReORlut0N3Y5p9rD7XEPu3mPcKShPlNZRQn0LvmQ4vROU5pVzCDB2D17lGHItFnRf6a2KvpFE8n+abyNAu6S+2gMwkYFv831fxJNaIm9kTgXfR7ZWYRTJvDbK2o5gREEestr2UdEYVjDRg0z9UjOojo+yPUdWd9cWbjtjtrX4XACwA9+8IP7/m6txS1veUv82q/92r/pEL6h84hHPKL8/znnnIN73OMeOPvss/HGN74RD33oQ7/izzz/+c/Hc5/73AM9jhszm+2YIdvuqTdcz3rW87XPgQDABz/4wXja056G97///cVd9p73vAd/8id/guc+97l4/etfv++2X+9jA7iCbdgHnFwWJlA6bmth5JzeFvBd4ppWImHsIE5NT+2e5qDZgR3AbsgYKmoJQ8tVYbNNw0mYkjX084Rql1o+AgtIPiCruUzKGDYruFWEE5MCa74gsSdWjASMB0nyRqxsEbtorZg1Blm5ydpSNVstGbQkmXQWocTI5JYBzf74Etk5pIkvTJwea3biaNW6tV4rz1hnprozo00eokHLjvl2Re8nPb9aO4eQuFFWoGvVFJFLxp/q4NJEwquTGDckFkVXsXFaMyx5ty8A0B/vRD+XyOJWBJimF51jJBi0c7Ksbj6Uzl6Aa3uCTIJYfR4KmjSg26yCsG2OLtmdFeJmywibPcHLVo07oqeMWy0dtl2EcXLuQNNFnNbw26viCFa20AzjytUMXGEDZF5TzddDnDVcP6/4HOPE7tMaZkP9KoASlp0bh5wd0qSC3+kYTWMM0rQm4F8ORf8IY+DF5OOGMALTTEY7TCtYdQXHTBPQIZy3ve1tJ+yxzzzzTJx99tn45Cc/eb23ecYznrGPpdze3sY3fuM3/nsc3r5Zq/7Ws56bbg7kX8cLL7wQAPMAf/M3f/Mrfg8AjDGIh7Sc/SAntAZhZiWbD2TFElAfjyV42Q6JK8iaIc4ms7Gj2o2wPd+QY617XIPuFCeAEGiOR7p6q1wq5gA2gJiY4ecRYSbOV28wtJ4O4D4heWoKVZ9Vx1EfZiVwme5Sz2IPdfKuQtHN6TEp2HG7HUEKCC5NT/etunFtF8cV7h7jiLZBqN5PYzvUcezm4woqGQtjIVmDnviwcmP1WFuNncBW17UDI02kZSNNpV2jrpCnwqDtAbpuiIiTCsOpU14f6cHVr0OYOhMTDFIBt+UY1eksjKHpA0GoOpq7WM61AqZsTGmwgAFZsz1awjStS5iyibwu5fbACKyHyOBny9dSbP4FWyKsYrYGxknnsGPQNyRMWxta0rQiqPUEtZrTSNYuFI1ndsx81ODuXHuyeEda6ipFMsB17tgVnSY0e8SttgBuZTrjrEY62sIf70rLC2JGdfUc4ZRpuWYE6RrZI+DSG9RfnjOXsnbSdf01/Srf5POlL30JH//4x2GMwe1udzvc8pa3vMkf8+qrr8YXvvAFnHnmmdd7m6Zprnc9vJ71rOfrYw7kn8eU0lf15+YA/gDALxgDY3JGNU+luQNGQJrk6YWpFQcqjSD18YDYWK5Vc5ZYEOr6bCCjBwDdUT/q9wzvu7R0VIYBz0Pe41BlFItWr5GBYxYbc/+csDEGYbMZtXbCwrmObBSjU/h1d3xV7jtusOXBhFSy9MgAStWc1ns1EitSKuKyhAxTI8awZlvWf7n2xSShjR8a+Bun9dgGIatgWFsyCFPjud7U1pLWy9ckDiVjXKPuMSq4VYCfS66d5PbFKRnC0lQCslem49rULfpR95e5lh222IWrq1G36KVzl+YadQbnaswEJKD2opXjtTcDHcAaGwPpwC179j2OZhhTMgSZmTeUbyVvZZ3fj0BP9I9GNI+jwzaxyk+ctiYz+sXtdASMIAiz6uz1FnbelXNtUpZA7QS/0/GYnCsaSIh72YhjWSNhIAylP94xH7GPEtJt2e27DAT8VjqHVXs4Iyh3u6yfK8ynsMaHcebzOR73uMfhzDPPxH3ucx/c+973xllnnYXHP/7xWCwWN+i+dnd38aEPfQgf+tCHALBm7kMf+hA+//nPY3d3Fz/3cz+Hyy+/HJ/97Gfx9re/HQ960INw2mmn4Qd/8Advgmd2sLN2/q5nPTfdHPLPxyfxaOZfzVw+v0ySlTdWt/llQn08FKAVZq7EqNiQUW0L2yKO4uwNtYOGsTE0mrBWLrQWfpHGuJnKILYOsXESQ2MQpg5uRUcwK99Egxapy3OLAf54V9guCDuFPdVuVgKe41bDvy8ZwIyQCNqcCPlDYjyH44o4W1kfi35Pc9poBhEtW+Ops8PI8pg9Gi67HArL5o8v4a+ZF72a1Wy+yNgaE2jYsLs9HazLQcADWa/kLdec1hZGTrt9tWpMV8Z2SMzxa8i+mcTWDYCgzO4sx/v2FsNmzWYNYUWLvhOA3e3hj60YeSOhyhrUbBfDWKNXSVWe6i416zHxg4HtJFLGgAYJac/QkGcNsTYxEeAajHmOe2rrIJVpqSGzm6SvmFVqYy2dSYnRO3FkaAHJfFQjiK6ZFz38tsQEYTxWvf7++JI/7608pzRWCeYMuxDtYO2KQ1nd13FSoTu1QZxWCDO2ytgV44nitBaXvUgM5Hocxrn44ovxjne8A294wxtw7NgxHDt2DP/n//wfvOMd78BTnvKUG3Rf//f//l/c7W53w93udrdy33e7293wC7/wC3DO4cMf/jAe8pCH4Ha3ux0e/ehH43a3ux0uv/xybG5u3hRP7SabNRZcz3oOdm70CvglL3kJfuInfgJt235Vt7/kkkvwoz/6oyfdPzo3aiwwbFgCNAhZk0E91EqYOmfoQ5i4fWHQCrIAIMyoyat2I4ZNR9NHyLCR6+JsqQX0S+2xRXEZV7sRSd5Qq13qzmLryqo3aXzGHsdunFYlhDjnsZHB7i5hK8+V3RDhgLE7NiZk0AgRpw0ZJTn+XDm4nQ5po+b6UNaFaWpHFi6jsFllhStso7KHqfFjVAmUCbPItSl9tgBBrlaIaVeughaz6Mf7jJlBzbN6BFWqcZNVK0DASUcpV8y2Z+5g2GpLviG6AfHUDUbk6Kq8w6iVS8ywU2OIZuhpp69dDqV5I84qVNcskBoRvteu5PDpOtrKeQXEyCHA2QSu8u2SocmM0uGvdwFpai6R/zcJjF5ZxbL+t6sAM6n4fDLBK7MQJVi7Yj1fWUsLYHVDHJtEbFVAX9wkOxyOTuCPLcl6iq4QCfsYYDXfJGF9szW8Lmo+yWR2q13qGK3RvEkj+tG+sLqqSzys86d/+qe49NJLce6555avPfCBD8RkMsHDH/5wvPzlL/+q7+vcc8/9V5myt7zlLV/Loa5nPev5Op0b/fH4oosuws7Ozld9+6c+9an40pe+dGMf7qSa5IFqnsYQaAtZ5zLgmW5fubEhE6gZdH5JAJY8/5iYEaYOzbUD6p1Ysv0ga2EAxTgyzPiG5xeprJrL4wHwy8D1mwC0VEtzhScLx45XV1adDIi2iKfMkGbNnnWraOxEPwegrBOVBWMsiUeeMPPNrnjbLHEe4WhTVnW62nRS1ZYaWde2nqBKzAbAGEeClArbZBc970vWidp4wQBq5hemSVV0iwDYdqH3Gcle2t2OK9KVGFUmFdJGjXDKpAQhq5u3XOtpzfWn9vDquZFVZzaGjF0fybpG6u+0kk2ZxFS58pjQOBRl3wRYpdoxU1Ec3KrJtOLw1Uo65IxhixEtfnsFf+2SgHMPWDYiMfC7A+LEl2ufWjqhs3OIrS+GlbKmVlbNmtKqoq9dvvYJ6OJGQ7DnbGH44mZTuoaHo21pdrGroVTB2eXAa2QlRNwZhFlVXieFERadJ0Iq2X+p8cKo8jUAcbQfxlksFjjjjDOu8/XTTz/9Bq+Av55nTfqtZz033dxoBjDnjPvf//7w/qu7i+VyeWMf6qSbWFHfp2ydSRlulQgGJLut2k3StMF2jjC1heFTRyMMStBzv1UhNuKeFJYveYMMA5cywkSy3zJ1hln1gw7iErV8s44Jw1bNDlfRWGlrhImS36YVbBNq7OyeN1F15ZpEQ0LRjakjWOJXYG1ZOWZrAMl6i1ts29CfLWHVi57u010CHLezQpo1sPMO4eiU35/V1M+lDKtr42ldgJ0V0Gm6WOrQTKaxAMYgT8gQpmmFbCrGi6wi3DIiVwZ5Ul9HN5adhb92SZOJFYbLG8SpMIKdnIfGEzAbM+rkBLBotqANqdTQqZFDwbkTtrG4rSUPMEvUih3oAk+1L0DZdJESQF3X5oRc8fbVTj+yuU0loc5WArEJDk0XARvh90TDwFmgEtZRo3YM9jG7NFdYaWbJvF/jxyiYSNe5ngcklOBsbYOptnvmBnZD0e0Zx+BtK9FBaVIhtg4m8UODflpNtYUZRJtqFTwLyy0mnTStRId4OCHEd3/3d+PZz342fv/3f79sUZbLJZ773OeWNqX1rGc967kp50YDwGc/+9k36PYPechDcOqpp97YhzupxkZIWLPsODMQW2maEAYqVczoS40Vx6lF3Bi1fKkWt24Askf5KOxWuWj8/CKxbaS2SN7AdwLUMgR8qjvYwc8D9XaZrA+EVXLCzKk+S4Fi2CDYcqs4dtrmjAz23CbHVWZpdDBjCDWz5Syz8eRNn0hlYDVaSMiW2rQ0Gde72RmYZUJuPVJbywq3JYixzPdTV6muadVA4AR0/ss3fLPsubJuPIyAKTfvue5eRa6l0x5gFtKYXadr04ZgDyAQMT2PN85k3bjbUyMoDSGpYU6i6QObNrQ6Lsvq14LsorfwixUNEq2HsVyL2yFh2BSQ3o1BzVZW4ugGQKJ5dAXv+nHlq40qZEgDTGCOo5EwZrMKXGtPqzFHceAf1W/yyZKRS5MKQCpAKzXStpLkNsLGJnESq0ZQdZiUGthxJV358drJ+SE4Bj9ETKqiJ/XLOPYFyzVxy4DUEJha+dCSvC3gN0tlYK4tcEh9Z7/+67+O888/H9/wDd+Au9zlLjDG4EMf+hDatl2vbK9n8poPXM96DnT+3QDgzWnqHTJ7AEpeXGgZ8ZItCMIWzKNLziAZdaNyNeeXETHxa8Omgx1yYYNSJeAuMFdQV7B+xQxA19NdGzYcWUcneWg1gWZsLIzq/pRphLqNtWYrjQ0MOQMR8MeWiLN6n95OY1nsYkBuBRTYXFy8pXotkwFK4qaF6OJMjEDmz8WNGqZPJXMuHvHwu2SJbC85gJnPw4n7NMvaGgA02Dm1HrllBA1ZyopGCkdGUp+THVJxoObKjaHLck5Uo2f8GD6tt7WrAWYpOX6yhs2NnJe2gj/eUf/XB1h1XUNYrGEM/TYmI262BcwqAANQupgBiDM4j9mBco7UZaEGCrvoiz5Q159p1pRonSznHs4Bg4ZIQ5y2AqhUIykMb3erDfgdruDtKiDOGFidvEWu1cU+wKwCsqyPjclwMUidmxuzCyXyJct5iNovHHMJ6y4GFAGZRmJg9MOCmoA0MFy1ltovrc8dfUKsHHBIt6nnnHMOPvnJT+IP/uAP8E//9E/IOeOHf/iH8aM/+qOYTCYn+vAOz6wx33rWc5PN4UxJPcknOQK/2Bj4ZYJfxuLy9XNpbGjGiqthZuH6LOHPGf1RarJiZVDvyu1rI/2/ZPx0YmPhOoI/gOxRmDpxCYvzNCTEysKFjPralWS8Gfhtrl3V7WqgGXXMe/MSmlxaN/YEC2dnYOdhzJLT5+4tnKw+rYmy8t4LJtOecGWMwAuqSyMQsNL6wSo5gyQrXjNIntwQSwSK2QMabBf4PW9ZMedEu2cNjQ17Wi3sIP3A6oSuHexigF30CFstgUQczyNSAiBh15C1ekWmzR9fsZdXn2rlCjjRn1MW0cAUraCRdb52EqvGzeg5ixku0NAQW1+CnDViJ1vGpGi7iIJ9GNAkoeaAlCmR3BvCrWwdIBV6Hui5ms7eorpmAa8fECRfUdf36tzWSkETMLrE8wiOoVWAzsIuBzrM5bicGE8KAE8Ezah9YXZNzrADA6Op/cxF66l5idlYpNYVZtAtAl+fIR/qGJHJZIIf//EfP9GHsZ71rOdmOoczI+EkH5MJSppjATZkhImTN8w8uhZ1xZvUxUtmDwCsOILr7VjYv1SJa7O2cH0qt81yv2bPutcErufUYZyNIUiU7t6SIWipZzMZbAGpxKkqrkplk+JGU9ajWukFZ/gnZ4r9xWCgICfr1yqHsFFxjbs3ny2PxpE4qehC7WLRBRoR99s+lJ9RUDKCBjnfgxwTQMAWEoGE5zpRwVaa1sV0ETYYsJyq8ZjcrsSPaLuEGGjMQCCTai8OWkj4McGPWwyImw3Ckaas0PV446SiUaQLGCQ6B+Ca1vaxMLuQfENY5hki0OAAbyUsGvDXLpG9ZVYjWPuWKznvA0G3WQ5ck+52ZGElOkVDoJO3cPMe/tiSWYZlJe7h5gP1qnIfe4OubR/GqkI/xsOQVQTbPOS5Fxdy48XlK8BQPkRouDO7kp0AZMj6lvmUcerHoHDJb+RrPRQziOoN9YNBqlxh3vuj0jOsmZaHbJ7//OfjVa961XW+/qpXvQq/+qu/egKOaD3rWc/NbdYA8KYaAWtZctbUkJAdYPuEaofsiTp97cCmDt4OpQouTPlm67qEbIFqJ5S1SHYG1TwJ4IQI8tUQkcr9EkDyWBiam4shxfYJqaJ7NMvP7nW5wo5RI9lbxJYxHvqGmxo2bbidrqzx7KIHNIdvOcAtQ3GMqjZMm0iMmA1o3LAMp66lMUKNKYte2jyM5PZZeXOXvDtjSt9tbtwYDSPMoMlsKEHMBQz5OR259VW7EnrMlSccn78TR3DWrDq7J6ZGzmcxNoiztf7SHFp/F6WCzPaxOFTVdIMsuklwLZxqV0KNTR8I/MQ5zsw+aQZxdERrm0iupIFDjiVXDlkZNtHcuVVgPqBG26yC6BfrsU1kUhGQCRubqzGoumgDK4cwE1PQsAdYWcMaPlBzl1ovwdWsBzTdUJzA2TATMFWOK2aJeFHDTmoZjI2Y4RaBr+khlio+Gxgdk8VpjJDIWgqbqO5qAKh2ROfqDicA/K3f+i3c4Q53uM7Xv+M7vgOXXHLJCTiiwzlr3d961nPTzXoFfBNNAVGGcS420LxhBwUMAtAC4ziSMTDJwPZJDCMEiyYASGT5FMiZBIQJAVxsDdARMLqlaPz2NFvom7PtIlLr4Hd6DFsNwae6J2UFaofEtauI++OUq2hkjFEbFVeRfqfbH7Kbc+lqpekDyMYW0Jg8NXip8by/eUfzQ2F2+EZvAgEhRE+YnQG8ZzwIILlyEjpdu2KwyI5rQDMkahz1fSMzxNgMBFIaflyqyXZWpd5OzQxFJycADKI/0xYUaMdsxtiG0fiyljWQr0cBb8YwNkV6jIvT2BmybuIIzpZmDtvReKEMLKvUILpHU1hRI4wewbstPcrZGaSq2gc8bReQ4GVdTid1nEjLRx+Biqt/N+9gegFltQUGU1zRJd/R8vmYIQMSO2OGyOfSB2TNMQQQN8ecUDMkDKe2cMswRtZYSM5hLBEx+66PI6tXtH9uDNfMDbuF40ZdNIFWMxfFSe3mY3vLYZorr7zyK1ax3fKWt8QXv/jFE3BEh3/SGguuZz0HOgfKAPZ9j49//OMI4XD+o/vvObrq09aOajfA9pkRLY7s4LDhENpRCximttS4IQPDzCFVzJELUw3dHWvl6u0oGYJZwKDFsGGRGv6xPc0BsXVkwACCv5zhFoP05bKJRF24sIDb7STChH/sIHo3ryG7jDuBVMplz57dVLnCCipjaCLf3J1Es9ieztuisUtZtGsJbiGOUQWRwJgzOKlKI4RJGWGTbRAASqyK7Vl/xlX1uD6GrL71ZwEQrA0R8eiUsTOLnuySOqIdV5t+V2JjKksGKoNauGPd2G+8Z5KwWXS4VlI5J5VufYRdBgHZ8rMSLRNbX8BzlvDr8jqSaJnUesQtRtpEWSuXUGZpMFHTj9nznPf18NaOgLbxJQoIidmENiRW78mqt9TRJQJ/two8DtX3CStZ1tbGIDvHBhhZk9suFOY0Nw5+PsBts20mHG3G5zvxZV0N0PiiphXbhaLTLI7oLjDEuo9w2/3YTCLrfv3di7MKh3G+8Ru/Ee9+97uv8/V3v/vdOOuss07AER3+OcRyzvWs56ScAwGAi8UCj3/84zGdTvEd3/Ed+PznPw8AeNKTnoRf+ZVfOYiHOKnGJOb32UF6VUNGcgbDhkN9PBCwWcCtEqo5I0iGqYWJKGaO2EoDgvQGs/YNhZGzISPMyIComxUGqHeSPC5DqG2fCL6sgVuGom1TMBdnrM/SUGcziLHAkE3R8OIk62wrLB8sYBfdyNaJttFIHZsJCXaXAc0EV4kZfqLhchL4q2weEsOZndSj6WgMSpae3LJCTXl04JpR26aPD0v9oZoVyDjaAihiQ5NGnFZjOHRkRV2cVlx1N67kypkgrl7RnanxJdWs23O7nThcRVNY9JGMy1FADNHrqdaS2YmOHcoL9gvHWVP0gcWtLVl/2u/rdzoycsaUsGZAImBy5vNUxk7aVZJ0JufKjprJlBA36iJVGMFvKq8/srZ8/tST0ryhj6+j2X9pWtGx67nSNx31em6HusQs5h7bq0wgFFCn59cth2JSSTXNIEiiw4xcBfvtrgDtco6MhGR3fB7KDB62ecITnoAnP/nJePWrX43Pfe5z+NznPodXvepVuOiii9bGkD2zH/StEeB61nOQcyAr4Gc84xn4+7//e7z97W/H+eefX77+fd/3fXj2s5+Npz/96QfxMCfNhAmQBrMvwgXeMd+vIrgyQb4ubJ4yU7E1MJEAL4r5I9cAjEG9nRAbIGtLSEIxk7jVqPdTjZhJkDUm4LpQgoBVN8cqtgwDM77JJ+rT7JxOWDtQF+aPdQQOfSju1lzJz2SaGLx+L3HtCgmULkG/koNYatIGvkmHrVZ0XHYEIcqQiTPYDhLyq2DKGoKyDAEnCWGzGfVpAvyKnm3CCBrTcdXsOmoIlQnNtZf1ugCpDFkFE1SkysJK0LUJCWFWof7yAknWoepSdXMC2yjr9WwAm1E0lyYkXhJhBbUOzYruL23U1CQueiALwymsogJ5k3IJvDbdAFSNGC2oA42VL93Iua64UpaOX20EMatA4CSgMovZRON2yjUK7Im26jyOlAlYPf48fpjQBhkFYn45AMuxNlBfG0CGRRwBW2ULSHaaG7jHdARgH/ucGoLz1PC8+N2B5qc9O0IbEpL89zDOU5/6VFxzzTW48MIL0feM2WnbFk972tPwjGc84wQf3eGcNQO4nvUc7BwIAPyzP/szvPa1r8U973lPmD2MwB3veEd8+tOfPoiHOKnGDgyodSsCPtX+AQyAVi3ZsCHVbcuEapfav1QZVPNYGBmaPwxgMsKEDmDmCGqPLxAbA2sJAFNlkJOszmJCUqG9rANzZeF2GYQcp5LbJlErCrzY1uAE2BAowhtZ1VVl3agGCPbfDmzlyBlpyoiRKIG/NiRqz8zoBNb+Wl3rAhD9mCdAttIokjOQqG3TyjgYA398Ce0MhrH7wAPkmNV4kyRWxAjI0uoyZQoVaKpGzy6DAHMD2zOCxR8P0jdLnRuAoo2zvTRSlAYVrkuNZNOZPnCjKtl2rMXzjNsRQ0yqLGzHDMfsWaXGppEBw2kb422kIcRoiHZy5TyklOGGWBpYUk0Xb2r9WAUnrmFjpF6t5DE6GGMQNmt4bSeRcGvVPRZNYkjFtJMV6AqLbFdc77uVmFlAbWWa1gzfTgT+2RrmRzajY9gOI9grRhdhg5M4zOO0Hj8wJZ77MKv4+oLkK0owdFkZH8IxxuBXf/VX8axnPQsf+9jHMJlM8G3f9m1omuZEH9qhnXRIr+V61nOyzoEAwC996Us4/fTTr/P1+Xy+DxDeXEYZudha+GWCyeMbWWjJ1CTR+iUvlW6NMHYA+g0nDQcC6CyBIAxKt6xuQ7imM8XNy6gP6QOu6FhFEC1b4+GPrcbGC+11BZ3EsfVc12JP0K63sNudNERgP9ujJoecGbFiDXLlxf3JVZ+TqBF4qRmTiBMFfyXXDigNEHbRU1NYe6lrG2BEp8YbJoRTJmTbdOUsWjckSOWYOGRBNjLDFqDktldFtximFfxuX7R6e8OUNTzZxFScqNkZGFldk9ES92wXmbtnUbLxIOaU4ZSJgFOUgGll8uz2EmmjGWNVnGoNuT7OonN0iwFhoy7XKLUV3M6KAKyLwISAem/t3Oj8HUq3Lx/DwEk9YMlVFHazuprJyQagBlBc4YU1HpJ8IBh/lqtpfqjQakG2uDAIXF9ratBQNX880u4LGLcSw4OUpbWGjDMjdyRIO0jwuLWAXCe3GMr3gT2Mo3MIdf01/S7f1LOxsYHv/M7vPNGHcWhnL+Rb47/1rOdg50A0gN/5nd+JN77xjeXvCvpe+cpX3jx7LTMwbNCtm5ysdIeM+tgA12cJvWUbiF+Nf1fDSL0bmQvY59IaQdZnjHpJtUGYaD6ghPtKxIxJDJ12Q6IGcBUQNmtpzmAQspodVCuVtRBWgECpCUsZufXFjKFv5tDVHQDt4i16PmuLzotZg2Tz7GogCNHMQNF+xY1mjIfR9gpL08BePZ9mCcZZQ8OItnhExrYU4JdSiRCxix5pUiFIvEy2fLzsWPdW7fSisxT9nAQMp7ZCUuOEOJdhyTQyf48uYTPwmOOR0e2a5blowLFGwdg+8BjUKJIy8qRG2GyoJZxUZXVbAHIfC9j026ui/fPXLsh2xQzbDYz9ScrcCYiPAtasaPFigu1CAbxuOZTw7ZLtJ4aO3FRkcnvRhoYEIx292ZCR43OlTjNL9FB2whLXvlxPGEPzi1xPPo4we7XnsSwGvg4Sxpo/eW2lasyrzHsif9TRXfSUKZeu6NJrbQ/PB9Cf+qmfwhe+8IWv6ravfe1r8Yd/+Ic38RGdXLPGf+tZz8HOgTCAz3/+83H++efjox/9KEII+PVf/3X84z/+Iy6//HK84x3vOIiHOKkmVYBZEbjF1nIV3Bggs54tzGgGyd4i1qZ09gJcBwMQUGdQLRJCa8dVcMIYESOgMNUGsTVwqyTB07IqToBfDaL9Y6yLiu2BkeFyc645TSCLZgLKSs7k8XZ2GEEJYoaVtS4AGgck7gQKWGOiQaIDNXYN2as4qeCPrWBSQhT9X5KeWmUnwwa7cOOEDRcq7M/SUmKiuGVqz58dmCOnWXCp8Ygb9agBM3sMJZVDONLA73RFgzeaDVBWmmQVZT0uocqukzW5dWy22GgQm5qsXL3n1ykzv7CsqYHCuMHb0qiRK8dVa+3gd/vSQ+yXA2xnCngCMLZ8REbk0J3sYGo3auaWAeFoCySUNWxqvYR2y7HFDP2LPmddGw9HWxpSVgE2RmRHg4vpA9JMI3gIvGwnjKwFPwzIyn3MGqzo0PXUC/qdNK6Ru4g8JVhPzgGBz1OjXezAMO8kuk+724vGk5+UooBm20X4ec/e5Y0GMFwpD0dbVNs9/G5/cL/YX+Pc8pa3xDnnnIN73eteePCDH4x73OMeOOuss9C2La699lp89KMfxbve9S788R//MW5961vjFa94xYk+5EM16xXwetZzsHMgDOC97nUvvPvd78ZiscC3fuu34i//8i9xxhln4PLLL8fd7373g3iIk2psQGnqKKaCIM5eDWd2BG02yJ4yA66TOJeGoEpBXCWMYGwJFrUJhOvlzIYRQPZ2KJEoqbZ0Zjpl16TqrfHU91V2T1DxntgVAT8Mqt7D8onTMk7o8iwCfgVPfYDpIvpTmpJ351aBmi8NVE50sObWk4kTxs3EBDsni4dE1hIplbgRrmErHo8zBTzRhALR9tEVnJqq1JTZ5VDWmMz4I4ukwCBXtpg/1MRgQoLfGYOgdXWpTCHAFW6ajKyaGlUYZ8P7jpttqYRT1rVU02kvrsSWWGm3UGZLfyZVjH/RYGZqNmPR3rl5L89T3NMWML2s2B1BmgmJ4JlS0uJgLm0qwjZqvIu2gGTJQkyNR3/GZlkBa4C0usH19aTOYK17G+UKGXlScW2bM59D5vNPDc0suWE4NMSEFBs31vTJc3eLoQRh28Iu0snen75RVr8A4OcDwqxC2Dg8K+D/9t/+Gz75yU/iPve5Dy655BLc8573xDd90zfh9NNPx+1vf3s86lGPwmc+8xn89m//Ni6//HLc6U53OtGHfMJnH+Zb47/1rOdA58ByAO90pzvh937v9/CRj3wEH/3oR/EHf/AHN+ofsOc///n4zu/8TmxubuL000/HD/zAD+DjH//4vts85jGPoQ5rz5973vOe17mvyy+/HPe73/0wm81w9OhRnHvuuVgul//q4//mb/4mbnOb26BtW9z97nfHO9/5zhv8HNKe6DE/j8znm1nYPiM1Ft2WRZxYmEDQlx3NHK5PxRgyTAlWUmMQW4llCRlhahEmjIxBAkJLgOIXkTrBDLilRGmsIsLMl6gO18XSwpFkBZsaT3F+yCPwk1VqbL20L+TC+uVKgE5I44o25/LGbBLz/BSYlDflBDJnjStGEhpPgkS/WMStETDpWtntduXnWZ8WxrWePK/YuGL00ExAbYDQQGOuDglorIBS07FCTGNUWElHljAKYFEXql0GMqCqedvtCuOnrSR20ZeMwr3mCHd8CbsaCLq9FfBNwIw0mivCET7/pC0ii2GssduohWUDwpEJb6MaPXH0Zsnuc4ueWsOUydrJNfS7PUF2R4AXG2b2wUsUjTxXXUWn1rMWT86Rto/YPpTmEUDMInINNBcytp4gWyQAGhEUN2rAymP0zCFMU7bTqElGATuZXemObl0Bqalis4iJ/PCk2tcRoArYNqMz+bDM6aefXlITrr76anzgAx/Au9/9bnz84x/Htddei0svvRTnnXfeiT7MQzlr/Lee9RzsHAgAfNOb3oS3vOUt1/n6W97yFvzFX/zFDbqvd7zjHfiZn/kZvOc978Fll12GEALOO+88zOfzfbc7//zz8cUvfrH8edOb3rTv+5dffjnOP/98nHfeeXjve9+L973vfXjiE58Ia6//Kb/2ta/Fk5/8ZDzzmc/EBz/4Qdz73vfGBRdcUHINv9oxEXBd4trWWyQ/MoHJG1QLvskNGwxuRpbQ2sbC9QQvXkwkbLJAATQKGqMAQ9dlxIlUzhlxGQMYNj2GzUqOgeAne1Py81wnfbGR7J8ydXwTjXC7BDPK0ih4s12ULDlXNF4mpMLIqXu11LgNwghZMG9O9WSinYO1xZyg7SPaNwugsHYAyDZJFmDJMZzWxWUcW9Hqia7NLYbSOGG7CLcIsLsdAWLlBHjEMa8PKHl7sIZrU/DaUBNp4I7TeJGbauy3dVI3NyXb5KUWrzCPTUVgdnxFML0aYCLz/via0MBssp6m5znLlUV19bzo5bKze0AqSh9zbke3Nev06vKbTdA29ibz2KltNCkjbjbQLt5UuZL9mATcaS6gWwzFocw4mPH/GbUjJh35EOFWgcBUmlWyMQgbNeySph8ra3okaRJZsjJOsxbdvJeVuHxNPryoaSjVXl7TYmjyplwHZmVm+N1h1Kkewjl69Cjucpe74J73vCdue9vb3iwNc//W7K2CW6+A17Oeg50D0QA+/elP/4qBzzlnPP3pT8cFF1zwVd/Xm9/85n1/f/WrX43TTz8d73//+3Gf+9ynfL1pGtzqVre63vu56KKL8KQnPWlfBuG3fdu3/auP/cIXvhCPf/zj8YQnPAEA8OIXvxhvectb8PKXvxzPf/7zv+rnYMMYNYKcUc0TUmXI+iUGNBPoESxmC6nv4o+4LhUgV3Lf6jFYGmDUTKoZAeOXXIVpREq2jKCxA9+I94EbiXCxA1sfTMrMgTPU6RlpWkiyHi7gzFrWseWMOGvK7XItb+Jpjz5Q1nsKDLXD1XZkmFLl4MKADAOzHOD2BB37q5cENNpaUTm45YA4q8t6tKwttdoNKE0RJiaCQo0UkfOnbt1c+bJSzV5Ws5WDXQ2lbi4cnfB+JtUIaqTJIysAk2ubK6nOA58jLI02GvdS6uScQZ5URQOYa1OO1yRbYmDitIZb0TDhlhH9GZvsLZY1es6yWt/uigYwG4JOAICAMZTO5CD/b5CNK+YYNfgo0LaBmrvhlAk/gMwHsqKN25elZwSkm96WnwlbLVe/sxqxcah2eq7KJzSR0FiD0rOsTN9o8LECxlN5Plm7k8U0Uyr/ot2TEQh5vUs4tWZrQsCyNYj1GjR8vcwa/61nPQc7B/Lx+JOf/CTueMc7Xufrd7jDHfCpT33qa7rv48ePAwBOPfXUfV9/+9vfjtNPPx23u93t8OM//uO46qqryveuuuoq/N3f/R1OP/103Ote98IZZ5yB+973vnjXu951vY/T9z3e//73X2f9ct555+Fv//Zvb9Ax2yGj3/KS25Ylt0wyyiIZvDChASQ7AkAbsvT9SiyMMRgmXGfGmgaP2Bh0R31pfQit6Ooy2cMwZf2bX0r1mjdj9IeXnDbRxhVmSLL1dGVpYmauWmLzgz+2QvXl3aLdSm3FVaro4ZJkwaWaVV6pssL4yerPgADRW1jR3RXmzBq6Z6OAAQNxJGvoL+vJwpFmH2jREGmNHwFo8HASI0J9pQcCQbCuvRnIbcuqtARFRzJK4cgEaVqXlbDfYdOE2cN6xtYXkKGZc/t+ixI1mHpcMNQKptoX0KrDvL+aTKyALLcKIgkwiNOKzBu4MtXcQRiDtFEX17WbMxYle557ssmugHQk6XiWdSnA526GWNbv2QBhs4FbBVTbrPozfSjMofZGk6UT921l2V8sINn2EfWX5wynBgoTqw7oUtO3GkptYJxUML2umMVpnjFqJxvJcFSdo8gC+DpA0bCawNdQ9mYPw+hg+8MZBL2eGz5r/Lee9RzsHAgAPHLkCD7zmc9c5+uf+tSnMJvNbvT95pxx8cUX4z/9p/+Ec845p3z9ggsuwB/+4R/irW99K37t134N73vf+3C/+90PXUcWRI/lOc95Dn78x38cb37zm/Ef/sN/wP3vf3988pOf/IqP9eUvfxkxRpxxxhn7vn7GGWfgyiuv/Io/03Udtre39/0BIC0UrFyjDimRAZEGEJMzqp2IakEzByNUpIUjAcNMAqHFEZy8QZhauBUBIk8OUM1Z+8Y2kIz6eCgCegBwEmhculH3dMzG1o8Vbsaw6s1bxKmEHQdqqeKRFuGUKdkxixLZoeyVXYYSgGykQ5b1cARe7vhSL+Z4XY2stCUKRVe7RjpqtTVjXHtnyZgzZb2XW7qUs3T6pklVHKtuRbCRJ+PPFAAnXbPwXC36L+9SCyiRIsC4QszOIE49wpEGqaU71+7RvpXVqhW95sQjzioaKKwtzmgrXceQqJUoDRa5siXOhhd6z3nK2hQjDSISsK0Zekmq7HihR9ZLj6+0cnieH65wuUJNtaf2T8+zsMduThbUzjtG1igLJ/eLJNE6qzCyoFp5J7q81EoEjD4NMz4nu7OSHECUyj7bBzK8k4oh2hIErsfl1KzjrbCrhpmT3koIuiv1e/paMTlj2DicHcDruWGzl/Vbr4DXs56DnQMBgA9+8IPx5Cc/eV/rx6c+9Sk85SlPwYMf/OAbfb9PfOIT8Q//8A/4oz/6o31ff8QjHoHv//7vxznnnIMHPehB+Iu/+At84hOfKFmESTRNP/mTP4nHPvaxuNvd7oYXvehFuP3tb49XvepV/+pj/ksdTs75erU5z3/+83HkyJHy5xu/8RsBAEFcvKkyiLUtWj6ATFyqaPpIUulW7UbYkAuzV+9QPxilf9evCPSyB9prwiiqjwSZdiCzyLUtWS+ycw7J2eI6zU6Cl2OGn4+rTTpZqf9zC2F9FJBGGkuyZzYcAcBQQI/JuQQ02z4Ul6wJXDHnlmxgqh3iZsOcuMYXbZiyVHsBmF2F0T09sCPX73SMeJEGiNgqM5SgfboQVjO2DJAm+/gv3NgCXLNU0OW2ApyBXQ1wOyvJMTRF3+bmQwGU5TUSE+JsD8BIDIrWbEXmH/JbsXEMvk50N8MYauwmnno40V1mcfsmqa5TnaaRUGgFkcr62WUY19ugs1dDlt3Oagz6NqNjOjtLsJvZZZyEYdMauDirEKd1Acpq8NHOZfgx6gXauFE7iQxKpbot1aPznGtcT5ZxUtMkc7QtWlAkvracmFGQCaTdtnQ3W74Wk7fMS5QPCBo/ZDJKTI62f6SGQerauLOer5NZ47/1rOdA50AA4Ate8ALMZjPc4Q53wG1ucxvc5ja3wbd/+7fjFre4Bf7H//gfN+o+f/Znfxavf/3r8ba3vQ3f8A3f8K/e9swzz8TZZ59d2L0zzzwTAK6zlv72b//26zV0nHbaaXDOXYftu+qqq67DCuo84xnPwPHjx8sfDXk1CQhTgrcwU41VllBo/is2zLge1ty+VBlpP+B9uy5LADTIKEpcDJs+TAGMypKpNjDVFsPWKO00oj+ze1aVqXbSzRtL5ZsdUllbZmfIZglbVvp/UxoZnGGsAlMGq+jkDLtxrZgwsjPwx5bCImUaTKRaTM+HivcJNF1h7CBgRYOi46xCnFVFf5Zk5elWQdaJAX57xZXwzoptFc6W1S01cAnZGFRf2hVDigZAuwKUoPo4Y2CXbJrQnuEsblM1T2j+ngmiTxSgly3BXp5Uo2HCCFPXxbEWTzSJNoiRwrAmzYiO0XRjOLRd8VrYLhD4KCuSctFEUkfHlb8CbDeXtpNJhTjxEsBMTantAuwQ4Xd7VuzJpLYaHeTzvqzezYJGGjMk+OMrOqT7KCHjo5NX17hhVpEllGugPcywpkTKhA0Glds+wC0C4pG2aP0AXl+3CkWyYNUQItrIVKnbWLIWM0Q+cThNIM95znPwuc997kQfxkk1eY0A17OeA50DWwH/7d/+Ld74xjfiwgsvxFOe8hT89V//Nd761rfi6NGjN+i+cs544hOfiNe97nV461vfitvc5jb/5s9cffXV+MIXvlCA3zd/8zfjrLPOuk58zCc+8QmcffbZX/E+6rrG3e9+d1x22WX7vn7ZZZfhXve611f8maZpsLW1te+PjhH2od6OsBLibCWHL0rAc70dYPtcwF1sTKmG6zf3dwgjiXZwapHFVaxrNg2ANnI/Jo4rMxMyNVaLvoCOVHN9pm7a2JKRi7NazAJjs4fq5UpmWwbiViNNGNrmQHYoN1Xp9jUxsoJNAFWaNWUdCgu4nY5sWR/2aduQMTJHuv4UFkxjPqx00aZJxegVMYWYmBC2WsRZQ93dtBYwaUqjRtEjhoS00SAcnfB5W1kxCjMJALm2ReNYjg8EgmS6RPM4q6X2jU5sGFO6c8u62IhLVXqZAZRoFbe9IjDtye4i0p0bpxWMdPhqd3J/yxnPr+gJkwRhwxpef/D8pSl1hwSsct/OSDZgLOcwTr3EDY0uboD6xpLBqAYUaxC2GqStCWUDAt7ijCCcTGoYDTnL4V+A5KF8+HCrwKBsAf0aRA3wWupjh60W4WhTgLiVHmY+F3GDZ+wBh/K6ltexOaSY4Q1veAO+9Vu/Ffe///3xmte8BqvV6kQf0qGcvZcvreWc61nPgc6BfTw2xuC8887Dz//8z+OJT3ziPsfuDZmf+ZmfwR/8wR/gNa95DTY3N3HllVfiyiuvLPl9u7u7+Lmf+zlcfvnl+OxnP4u3v/3teNCDHoTTTjsNP/iDP1iO5ed//ufxkpe8BJdeeik+9alP4VnPehb+6Z/+CY9//OPLY93//vfHy172svL3iy++GL/927+NV73qVfjYxz6Giy66CJ///OfxUz/1UzfsXGRpbai47k2NvuFzrWoD18P9lkeU7yk75XoGPcOY4h4moDPIdmwKKT/nWfuWKsuWCgBuxTUfHxSy8hx1Z7aLsgpO5c3TLfqSD2gy14jahmE7slFjqDV7h600TdghFd2hGk1gDPPwZC2aFCA1jllwnqvpLLE8phvYWStAQ+8vS/ixXQWCRZARI9uVi+kDAvKsGA5KpE3MqK5dFqCgYFaB2r4u4lY0dgal8UKfS39Eem1VmydgVg0cWqXGnloGILM7WLqPc0aYjkaObMY1c5o1pabPhMQqu5iK2aMAR0N3LoGUF3ZTuno7GjpM5HrWHV9JULRE/cwaWfdLbV4n/cpz1rspk8gPLiJRqGypXYMls+bmZCjTtEKuCX79Treny1hfM6FUCCrwZF7kwGupVXnyIYO5fYZmGQnLtn3k63IYXeZxUvG45IOFdiebkOB3e2oqQaNRtdPDLeMN+t3995r3v//9+MAHTdIQ/wABAABJREFUPoA73/nOuOiii3DmmWfip3/6p/G+973vRB/aoZ01A7ie9RzsHEgMDAD89V//Nf76r/8aV111VdHg6fxburu98/KXvxwAcO655+77+qtf/Wo85jGPgXMOH/7wh/H7v//7OHbsGM4880x87/d+L1772tdic3Oz3P7JT34yVqsVLrroIlxzzTW4y13ugssuuwzf+q3fWm7z6U9/Gl/+8pfL3x/xiEfg6quvxvOe9zx88YtfxDnnnIM3velN18saXt8kJyvbRKZOw51za+AGavZiw1aPejtg2HDSRKEuRrKCyRP8qe5N32T9bhpr3LQ6LlNvZgeCs2wM3CoWBmsEbwShqjuzfSTYEhG+kbVnljaN7C3CKVO4nRXXj8YAlS15cyaSSXKJ/82TqqzdSiZbSDCOWYT+2KqELpucaYwYIgOHRXOmbBcsdWluEZCsL6tM9vFWsKsIQFggcTTbkPYxQybnYjCxi4GMoGr8JKrFgIYOd5z1dGla8zkNccz2W4SiKUw1TRa5cTCrXHIDbR8JerwlgHbUomVxTVfbHQOcM6QX2MPkVJzapnLFyUwXdhT9oABUXcmHhDxxhTkzketV03FFbay4aD07jQsLZi1MN5TnpLl+BPrC9EleH+OBWL8WN4UV1NfzVoNqp0c0e1b1kh+pzJwZonzgoBNXI4ForrHCeDNixmpryZ7nyyggV16rdEv3pS5PH4eyCcfaQHk9Fv1l65FxOAEgANz5znfGi170IrzgBS/AG97wBrz61a/G93zP9+D2t789nvCEJ+Axj3kMjhw5cqIP89DM2gOynvUc7BwIAHzuc5+L5z3vebjHPe6BM88882sKNM3/xm/5ZDL5iqHTX2me/vSn78sB/Jfz2c9+9jpfu/DCC3HhhRd+Vfd/faN5fqkxMIHnotrlm2OqKaL3q4zYWAybDskb1sABslozohUDqt2EOJE1l1TDqWOY/bw0UphAJ6Y2LtglWUALlPo2XaXq+s6GJHEhZNWi5Lal2hXjB4X+Fpg1BDmrobRaGKkzg8a9NFw1up6RIiZluKX09g4AJLg3iqaPb/aSG2gNkCXmBbm0daRpxQgTyYFzEhlDdk5AlMSTAGzjyJUDujDqEy3EmDACNYTxZ3RNGzebknlnckZq6sL2+WNLhK2WgCvzcdKE2jatcYtTZgTaLiDXHnFac9VuDfMYGw+7GMhwqXGiD3Aa1wKIplFcvdL763d7acAgyA1H2tFsYgzihP3ISZ3RTgBlyqVRwwpbiKYqwM+AIMktZT0s4F+r1jTMm5VujMOBN/DiKHYrPr4+r+yMfFAhiGZ/s6xstbNZHekpF8baDBGQ35PU8noWnSDIUKeKYFZNJqnia5Pn1SE6ygPCtCoRSKm2sLuHf2+YUkLf9+i6DjlnnHrqqXj5y1+OZz3rWXjlK1+JRzziESf6EE/c7Hk/SGsAuJ71HOgcCAC85JJL8Lu/+7v4sR/7sYO4u5N+shUHcGVQ9QmuQzEFKNuSHfMCkzfw8wQrK2MY7DOH6NiBb8Q2MyomtAJejLBtiaYQJ8AvW4PkbDEvJNG9ITFsODuDrP+iCohz804CnwPSRMT8tZX8wgRESAuErFgTCO6MRHM4C7QG2dNNHGZVqU+DtSVHUFk6q9l+XSyGFttHasqChV31sJ0aTBIjR0TjZWIuwc0wBqbviokDOZcuYqQMVGSaimkmJJg9hhjNFsy1RzI8l+FIW1bDAFs+NL8wecvrMNDhmg3IQEr3cJpUbETpQtG1mZCQJ1xVmyHCSI4eqqY0XCBmxFMm5THVzFBCsHU9nUbAaIYI1FrJ1iMcbWlIySor2P+uSXAvWtEuoooS7Bzy2B/c02wSZ3UJko5TT8ANDwM6wHNlRhDdjFpHQIxDkg2prJ3twhg9I/rR2DgYPwZWW2FWkzrDVfspHwCGrRpuOcoMFGCmxgEiN7BdQLRkjvtD3ATy/ve/H69+9avxR3/0R2iaBo961KPwG7/xG7jtbW8LAPi1X/s1POlJT7p5A8B9s0aA61nPQc6B/OvY9/31GiVujuNXgFtl+OX+KIpUG9THAoFeIkjUxg4CQ4jz10ifLxghA37dLyKy5dfsQF1Z9gZ+FQkmK4vutIamjmYENtrl25/SsN1it2dOnOj/tIouteJW1XVcyvDHu+IstathXz5fmnhGvVQOdohwy0HegGM5Zub92RGUyblQk0f2VnpsUT7iu0UYjSNQPV4sLB7DgYG40RQTRGorMk+tH8ODNeRanLtZTQoSwFzq+bT2rItFr+gWjIWxfWSFG3iO9PjTRstQ7NohbNZASEiVQzhlWp4vwEgbZAIv7RlOk6oEeCtLp+fRb6/YtSwrWLfoi4HFLga4eS+5hgSyusJN04pmFAXrWVjiyo3X11vqLEXbCQBxSqOIXQyjK9taaQRh+0s2vCbhSIs0ofElC3Nsh1ieq8awmJio8zRj2Lae52z2nAugNKbQPJKKsUSBa3a2dALbLshzsuV6BFlPa0wPjTFkSlkr+DX9Kt9kc+c73xn3vOc9ccUVV+B3fud38IUvfAG/8iu/UsAfADzqUY/Cl770pRN4lIdr1ivg9aznYOdAAOATnvAEvOY1rzmIu/q6mGz3VMHJ37MwezR1ELhlwzXxsOXH24iTc9h0gAH8IhagoJEwAMX2dsisjdsTBbNP9J6BYave47SMo3ati/DbK64VZQWr4CpbuliLNms5rjWLcaGtxjdi0eqFzYbBvMLyuOVQ4mayNczykzYIXfvmyhYQpABJswlT48cWDTFVlBoxZS9lxWoGVpElrUIrmjQyn27RUyMnAdB2OZpKiptZWEMnWse0IS0lQyjOVJOpwdNGDTfvUR3veMwhcb0q+jRE0Qsuh5EBA8hciq7PLnoeTx8JfuKY+ZdrglntR4a3iNNazCbsyVXzBCBspgC48X5y6cx1ywGplRWpo47ThEzziPQhxxnBLLWFqQD35Pe3rhgJ+9ZmDqRc1uO8lpFg1dkxDFoAIcBVN+vvuLoOR0fmswBPZXExRhGZkIuRpkQHaTOL1BryPqXC7pCChoc97GH47Gc/ize+8Y34gR/4ATjnrnObW97yltfRU9/cZp8LeI0A17OeA50DWQGvViu84hWvwF/91V/hzne+M6pqfwr/C1/4woN4mJNmzF7duYI2AYCxtaiPBwwbHq7jKlhZwlQb5GCQPR3DSZyq1VzYMicrNrm/aA0Boq4FIU7h3Z6NFI2DX4bCKqbaAhCzReOQBaSp9gsmwwQAEqeRKotUV+yF7ST8WarFkDIQuXpziVEz7LXNpebL9kG0XNIB246ZfVotZrvI2wqbVXpj9/bvekv9XUdXqK7TzSABywII7DIgbtVI06qwlUhZKtiEhaod0KgZgSxpzmTKtJHCGAMb2XDiugFJ2LkMjEYYbwvQzN4C2pkrwdTG7cnlU+ZTtX2iTbRBtHLGwM07uCWQNmrR9FHHVtpjAruJYbgaTq30CgMwLsljix60GxBnDWwvncKip7S7XXH0OmkMSQZAMc3wmONGjVRZ+AUNI3ZIo2M7o7TJ2KWydnIspaWG511vp40vWkGoesTCDhrweslt1Q3u5n05VzR4ZMDnIiEA+KEn1a58kMjWj+ynNbCrwwmgcs445ZRTrvP15XKJF7zgBfiFX/iFE3BUh3vW8G896znYORAG8B/+4R9w17veFdZafOQjH8EHP/jB8udDH/rQQTzEyTVGYloMYLtU+oCTvKGn2haGsOQAJpRat+RMiXlJXv9u4Po0BifHjPpYL2/OBmHiEBtq/pTFG8OhCXT8fCi5eoXBybmwbqUKrXHFOevnZPHStC76sbjRMCqmiwQqzo7RKX0Ye30TTSHwdmypWA6lq1VbSYoxwNnSD1vq04CxKULe+M0qiMPV72GDMkxkL6520AbR0+WKWYfImf3CElWTpvyg4uY9Gbxhv2PUb6+4Zm48mTph9EwUhrLl+tkKKNXgaK4sIxnMPWHKADV7SVysSTIYWfNWl6o326cxEy+jrGetBE6razhNPIFo3mMAkgo/7XXWSrjUVgi3mMn5cOIaHkrbS/Z8TbrtHn6ng9/tYXd7au/kA8feGjgTEh3VlS1AVD8cqANZ/6uVg3ZFDWAUxzLADzQ0GkmTymrY1wGcGl96q1XHWjqD49g+UlhrvYYJCFNHEH0I57nPfS52d3ev8/XFYoHnPve5J+CIDv+sCcD1rOdg50AYwLe97W0HcTdfN6OALztm9O1lBLMhuNMVZmwt3Coh1bLSXaXyfZN4H3z3RQF5TliNXFkyictYAJ+JGbHVKi6yILkWTWFIcAL+2OwBmEwWK04rcf7KOllWxWHiCUgSYLOwe40rDFXJodPnI25hf82ccSMxl4YTDYGOk6owfqyvE82ghCSbjNIaYYKGHhNAwhrEI+0YTiwRKxmASbZUlCHnUhFmu8DWidrDLfqimwMkpkbdwimKJpJMWJhO9mQYOrqXJeeOQdxkslJL96+Tlbnb7ajzE6CbGg+/w55q7UpWc8ReJzMjTCwyeB1MMtJzzE7eKK7jXFlAOnqzmH9iyw5nXf0yCFp0ers920gMwZ+6sE1Fd3BhfBsPI+YgkyVKRta06OjuzZ6rWxhTzo0Vx3WScHAFZBq7o88/azdyJzIEOVZ4KzIGed1rNIwxcMdXJbqHeT0YP8TExM8ZbSWRPzTbGMPXvJ9HBHs4AeD1VUz+/d//PU499dQTcESHc9ZdwOtZz003B5YDuJ5xUkXwpf/AZwcJc0YBeyZh1PN5YfyMsIJDZoafdAHbkElqhQxkWbPK96pd1bERMJpMNtFJNVl0FVsXxNWJlGElgiW3Hkn0gbYnUGGVG4q+z0lncC4MF7/G9SsdxWTfcgF2sXJIbU1gudmScVv0iFst16qiiYPZ87gayNxyVW2G8rQI6iBspnYIpww77wtTFqc1QdhyQPJ1uU877xCPTEq9mx5viROp3egmnVSwuyvEzXZcZ8t6MYEBxaYf2S6yf+ywjbOa/bwKrIeILEysiYmAMI76wGJacHYEgYlMrBsisqmpOZR1rgmJjOS0hg1hn5ECUulmojilsy0MoK6+zRDJFkqEkJt3BL2R4Ds2leRN0nwSZzVyS+cvZEWea2HjJLQ8iXNc+5fdiselRplwpIHf7Sk30DaVkJgj6SySB/xy4Lp5pyttLHQdV3zt97acJwXnaVYVphOJod4l+iXzvERXIWx6pO5wuYBPOeUUGGNgjMHtbne7fSAwxojd3d0bHDy/nvWsZz03Zg4MAL7vfe/Dn/zJn+Dzn/88+r7f973Xve51B/UwJ8VkO0ZwxMbCL9jowYiMXCrO/JwgLzY0hiRn2PRhIHo4Ebk7dVmSBfE7AatZQ9DVWLqA+1TAnw3URRnH9WCceNjlgNjSEWp2e9icERsyV+omBaj7U12VianUrOl9QsJ9TcrI3nM1C3a5ui7CLAcJdvalrxWg6N+uAiCZfqmt4FY9wkZd1oJWtGLV1QuyaosBw2lT1P9vB/HIpKxo3U6HeKSFC6msCfdFv2SNrWG0ixkiTRPOlQYSO8QSem27UNyp6ZQpshNAYsgehqaBl8fUbl2kBLsQJ7YGXYv2cK85w2Rm3ml0C/WYcj1b5vfFSUX94bSCNYyHccuhOKFLfM+sKSyYGlKyM4gCdmHluRk2qcSpR3WsQzrSMnRZNJdq6GG3M48BQIkZirO6MJzakQxwnR+3Wp47cT3nZsxCjK1ntp+wc7Yn0+m2aViBNYyQUZbQUPOYrQFWWRzcjmt67VrWnMGBtYEE+nH80FI7hJlH8+UlwmYDJ+0rJmX4VcSqOlwM4Itf/GLknPG4xz0Oz33uc/cFPdd1jW/+5m/Gd3/3d5/AIzxcszcXdk0Armc9BzsHAgD/+I//GI961KNw3nnn4bLLLsN5552HT37yk7jyyitLPdvNaWwQcbqsa7OQEAyAFsaltYiNRb0dkLyDsZI/N7E0cqwyhqmF6zOGmYMNGW6ZyhqtuVbjPDKSaKKSNfDzwPWZRn1EAYSTCtU1K+rGrCl6viyie+bzBZpFxLxglwOypdbOipFD2zOSALk4q2FXA5m32gObjWi9IGyXsGSy+lVdnwZScw04IE285PtpbqApcTTxCLV8cSIOVl37Ouq+1FiS1SWbs3QF8+WdnS0RIqYPMMbvWSmLBjIDpo9FS8ce2YxYV/DbHbKsX+NEgpM1UHoVmSnYAXaQloqawNv0qejWkmb1zXvkpgGESeMKefwejIGRa2yGNDJtgy0h1aVubRUQjk4kasdwDS7vkk4ibWwXkABUusq27ALODcTN7YoeE1rLp4aOyHxIld8rEFM21URZHwuz6KReLk7rEs7tVoFr5JWyvhKBVDtxCbMRR0GmAlvVpZZuYslchAH6rRpO+rXhTKlOtF0sLvEoOZaHbR796EcDAG5zm9vgXve613UMc+u5/llXwa1nPQc7B7If+eVf/mW86EUvwp//+Z+jrmv8+q//Oj72sY/h4Q9/OL7pm77pIB7ipJphKgxeAlwnTs2UUR8LiLVF9gbNsQF+mTBsurIa1rWwhvE2xyNcl+D6BNvnkgk4bHjRcfH+/WIgM2RZtxanvgDFKMAqG0a1ZGtKgHJquAKNm21x72r7h+ruUitZatoi4secNYj5gG/oY35bCZF2VgwMvE+7YkBx3GhKrEn2lreX6BHtd9XgX41WUSOB6YPUm3GdC+ngNdIvW0wAFuV5uEVfXKHZEmRq9l8WMJytrLgz4FS7VtN4ESeVdNmCekjRv8EYVpYJWExTHpddBZochBnjA6Hk8rn5gLBRFxcs8wcDsrUYjrYCwh1BsWHWHgGrOF4NsxXjZgO3s2KX8/El7K4w7znzuUiLCVs8BjqoAa7+hTU1gzB5e1a0JqsWk+DaxCjBz1KjZ2hAMTGNLTAAn78YRdy8L4HkBIx8jZhVkBaZVLqJU+sRjjTF+avxPBqmXQw1cq3r4z2vUSVxNx2ZxrEejmto9m4fHtCwvb1d/v9ud7sblssltre3v+Kf9Vx31gzgetZzsHMgAPDTn/40vv/7vx8A0DQN5vM5jDG46KKL8IpXvOIgHuKkGtdLYLDF2AMsQcSxtYW9IGBhN3D2BtVOQL0dUe9IBIj+i5dR2Azbp8IiAkCcOPRHankMFPetsj9uFVkpZhk7ovVbACSrbRi1ZHsfKxIQMoYkiZPXQ7twU0MWTRkeNTGYIbLPVt7k46wqOj8AMEuGGadKsuUWdDKTvasKG1XCnLPkzklodZb4mBItI8xa3GpGY4djVqGuCfX/udIWA4GAWTcf4BbD2JdrRjOKroZtIJMHoADvVLkCiuOs5nEJc5UrK8wZ2TtlVNW4oueeNxB2rfblXKnhoTSRyGsHdg/zpm0vrerhauTG0aW76HkbAZyFPQPGrEU5dr/Twe10BQizacWMAcwSUg1nShC1DYlaSA343pP1l2YNcuMQN5sS42NFf0hnt+QANo4ROMIeVsdWcAvpeRbWr+QbNh7a66y/S+W1qoHa4gYPU2FTVxGhdYeqP+yUU07BVVddBQA4evQoTjnllOv80a+vh3N4rt561vP1NweyAj711FOxs7MDALj1rW+Nj3zkI7jTne6EY8eOYbFYHMRDnHSTGrp6yTrxa/0RMmNhauFWZFfY+hGRGsvYCnHzDhtc+8IIeLQaJD06WGNjuRruGAVT7QxkiLyRFhHPN0h14tYWfqdHrsXssWcdC2NkjesYs9JyVWy7wFVw5bh6NZYgMkvOW8qwotVCSGSGHJs0srfCEJmx6myTETJ+pyvrQNMNsOCKFZGAQ9fGzAjcr0+0su41IZFJi2S8sqwo7YIMp1XzgkSYFBZL8IMdCGwxjKDEDmT8bEdGLjUefnsFY5mP5xeMsSHAjUhNPQLclOGGMd8uW0PXsYAwdRrDmaJpQyMZeikVxpRMIsr5MDEizRpKCrqIOPUE7r1o8WpX1ubFgZxR+olN0vBxsqtxVom5h3KD3Fj+XFtBvDbwx5cIRyYwQyh6P4uI1FTUU0ooePISMr2Q0OWUqPOTKdV8CkSlz9iI1lE/2GTn4XY6gkJho9W0A0DYYTKaacKMSwWxJiYMRxv4nQHVjjCDoHnqMOUov/Wtby0O33Vywg2fNQO4nvUc7BwIALz3ve+Nyy67DHe6053w8Ic/HP/1v/5XvPWtb8Vll12G+9///gfxECfVKLBLnqxFaQUxVswggPF09SZHFi95MYDIZ956JyJMrPQFQ3IAM78tsiwFfmHmYFUTpQyWODWzuHa1YksZlzityMSJZgpSl2a7ADhTcvtSJavQPko7hDhLYx4jUlRvaDHm4Gmt24rhzG4+IE9UX2fhVBdnDGxnCrjLIto3MdJNIzov0wekjQmBpTGw8w5pox1zBQHk2iNsVPAdTShGVqHafGGU3RKQrWvCKHmAfqdjRVxg3AwsislF/z9bybFTZiyzpcLGzJgUNZ3MO2YITuhURe1LHI4yWaaH6AorCcUOo/6xi6y2m1TISVhDMYP4YyuCqqbaw2xCVtlkapkNWMFtd4xcUT2dMRL3I3EzUhkYZw389opr5hmP2/aBYLGLgKzNbRifo2oEnax1y7pbfgeMtQizCn6nK5KCbFzRL6ZWPkB0AcOpEzFHyemWeBjI7bK3JQYnNhZukGaWIRWtZ5JoGST5nXIGeX+04wmd+973vl/x/9fz1c1aA7ie9RzsHMgK+GUvexl++Id/GADwjGc8Az/3cz+H//f//h8e+tCH4nd+53cO4iFOqjEJJasPoOGDa0Cue21gA0i2YPNGBoXsIKs3bDiEqYVJDJKGIVi0w57mEPC/fhFR7RKAqJYt29GwoVl5RvRoavJwi4HgYs8bK5xBrn3RXtkwrkwhwC876skYN/IvQpyl6YNvzLE4ctl7TO2aFV0eYi6BvnFSlVYJADxu6fh1ux2ZpsajunZVVr6pZWUZEgh6JpXUsWXWxu3RHGbRR2rvLc9NEifzyEKxP5gxKNkYhK2mXMOyEo2yRs9swnDzjmxYs6dpRBs+1CwhzFhUVlXWtMyvIwAi+NWA5ggTY4ntMRLxUlbbNQOmk6cGjuBdV+WZ0S1AadJIjUea1iU0uTq24mvIGD4XQwA/nDplILWwdJrJGFsvJh1TzlOc1YAlaIbE19D9S3OOnne/yzo41VHqeh2W2sY4qwRsyutIDTQSUJ4rRs0kYRJNzKivXRH41Y6tJY2DWwQkb8QAIkDQlGSlQzdvfvOb8a53vav8/Td+4zdw17veFY985CNx7bXXnsAjO1yzZv3Ws56bbg4EAJ566qk466yzeIfW4qlPfSpe//rX44UvfOHNUs+SajVykLGj9o/AzAmgU7MHAGQHxNoiea6trETChFYE/BGINe9D18LIgI1pzGULo0awGB68peNTzCElLy6RdSpBy1rbJatUSBgvUiIYSVkCkHNxikYxEmTHJggjjIzrYmkjSWKEsQN1YFpX5hZ9CVTOwrQBIBBJAmDMnvw8MQGUzL8ZGbvUsiM4N2yJUCNDlJ7ZbIysknmO/NVL2F5MBW1F8CRA2UikDIB9Or2wUbP5JCa47Y4Ax5D1g+WK00jnLgAxNkTRv4VimgFQKtmyM0X/xtcLj79o/iR4uhhxplwTq86Oxgy5bYkcQgHdJuayto9btYQmZzFIWIQjo7NWW0uKU3uDLurUeF7TFTWibrvn8XdDaTxhJd+YOWgimdcsgLQ0dug1TaOJiK8b0aDu9sheOqc1v3JSIWwyzzEcmYjzWX6+rcQxTrDplny9uCGx+q6LiLXdl7V52Obnf/7ni9njwx/+MC6++GI88IEPxGc+8xlcfPHFJ/joDuesweB61nOwcyArYOccvvjFL+L000/f9/Wrr74ap59+OmI8RHuYf4exA8TckQBjgaArWa6v+OaUEScG9W4qa1uuLA1iTW2f7akXtF2GX0ktXEXW0CAjVhbDpodfJpgqwy2E8cogQwdhVPoEt5AQ3UrjNkbQkoWhIvAw+wKE4cA17aKnW3OzgQ+pxK7Y3b40RuTKlXw3MySYirl77vgSuXIIp0zgFgykVtYLon9LLfV7WuOWnWTGJUa6+GFJx+ikkpWjrES1Yqze4/zs4xgjsiVOUmvpfq2EDe0C4kbN/L3Wl0w5BUW2C0VrqPEl5XkK6LU9e4Fz65mlWHt5nlO43Q6w4lCWtbqCbViCn7RRS8NGhj++RGoq5NYgZyMtMNLCYQyZMOlNZg0d2dbU+AIcuf51MN6OK9qYCxNoc4bdWSFtTQg4JasvOzqytTnFDAyUtitq/fT1EFsPB67Cw2bDDwzSUoIUS6+xlUaUUi1ojVxTK1V3/FCRa2pU07QqzO0IbA3sih8cshhI4qwend45k/3zbDTREGpj+XsBqAv4cFKAV1xxBe54xzsCAP70T/8UD3rQg/DLv/zL+MAHPoAHPvCBJ/joDues8d961nOwcyAMYL6ej2Zd16Gu64N4iJNq7ECwFluGOcda4lumlrq+wDVwvZMQG4NYiWDd8//9MsF1CbE2hUHUEGitmYMlU+UXEX4eSjuGgqDC5sU85v5Z6SeW5ok4rYSxEbYmS3esQVknA8JQTWvAWvYJW2GbLMOP4W1hAJO3hY1yux3XdEcmyGp2UNeosyW6wwg7WB5Po2iW7KoNR1tZCfuiGwRoHkHM+1bRxeUqHcRu3jPvrrIl1kVX0MpAGgEy2v7BO7JFe2YEcCRZ4ZqYELdqrtCFWc0NAajb7eB2qXkzPfMCcyWO5NVQuou1DcTEDLfdIRyZIM4q6eYl6C0rV6DEo6hRBwJu1CEdG5p0bBfY4TtEmiGcwXDqlKv+1iNtNEiVRZwSzMdpVZ6r1r/BW4Yub7ajgUWNOxLbUtbNA89h2GqpERzkNRBzkSNkMQKlSnIHBaCrOYddxKaEZ5dg71oiXWT9TuMRu6KHIy3X9R1/NtUOYSIfWkQLG2uLYXI4y47qui4Gub/6q7/CeeedB4DblHUMzDj5ev+ynvWs52udr+lfx5e85CUAAGMMfvu3fxsbGxvlezFG/M3f/A3ucIc7fG1HeDKO4VrXdlILl7OsbMlwEMwZ2JhgooELGaki8+e6RH2gM6h2pf6sMajm0pxQ2aIF1PaPJC0LWdaeyUkorjdwCwUcpnTApppABgI2kBJXrGICsT3Zo9w4RM3Ca9mjy0gSatE0C49BxRGxGEcsLMQtag3MQDbOplRaRDTeJXtLzWEfkT2/p125TlaZSRy1aVJJXqElyG5Fo1Z5rrZl9WyGCJOAuCERKRNfAGpspZdW15igKcNdvUTcbAqLqSvUsFEzbHg+MA6msgK8ooAbJ3o6rozTpOLPim6xRNoAbM1IqWT05ZTZrzxtxvX3IMBxIvE5EsWTN7m2VVbS9kNhExESnGbuVQ5JKtvUEEH9KZ9Xaiu4nVVZz7LmjpEz2YAgVXSGGo0TtlpZ4SZAmkMUkJluAIQlBHJhU003sKnFohg1TOQHjOzE/W2yOMfJJpoMXu/GI9WWmYuO7vS4wV5pK2te1Qjy5EC6k/nhh1FHDtlk5EMUA7N3/tN/+k+4+OKL8T3f8z1473vfi9e+9rUAgE984hP4hm/4hhN8dOtZz3puDvM1AcAXvehFAMgAXnLJJXCS5g+MtUaXXHLJ13aEJ+EMM8DMwfVtn2ECAaFOrEUk7yxcR3NHdGQBTYQYQHJxRdpBQJw1BIejWbiwZnZIbAQxBIYwjKEpKzVji96OOXoEIbFxMImmkLDZ0PW5CICXlo5ETZ9NrCwz4tokM0StlgkJYbPhus7QYatGCCdv6Dmydox9tSB4CLmsIE0kGEKSirSeLtg4q2EHavH8fMCwySiW7ExZP0PZvdUA2+USN6KVYCNYIyMWp7XoKPPYxStOYDtEhM0aPtKA4LdXhUEzkUB+OMIaPttFCbnmY5ohwnZDAbQ0m6C4qDXqxcRE8w9QgHSpURNTh+kG5Gld1qlGQLiVHmN18ZqQWGmnOr/KAl7MNjEDQ4SJBKl2NSBnuqXVUBFmArQFKFHjmEt2YJbaPBhTjCSq84vTunzPDrFU2tntJYYztkoot9HnpO0tjnmF2VgxvvD4UsrAtOaxKZu9R09qkZDEwe1Wga/dmGCSYW6mEqZJXMii1zyM87KXvQwXXnghLr30Urz85S/HrW99awDAX/zFX+D8888/wUd3OGftAl7Peg52viYAeMUVVwAAvvd7vxeve93rbpaGj680urLNjCNDbCT6Rfwf9U5Cd8TCBjKE2QLDhKJ1XeFmYRHZJUt3sN63agpjI1rClkAze5pMWCnn4JeMyciSHWgyqLmTdga3CjRPOCONFKJ5c9reoG/YhsG/xoyZblLJVhgu0Re6RU+gp2/elda22QIIkjqVcwZChukkQqaqAJPLKpbgLxXWLjV+zOHztoA21dYxJDqXjEA9Fo0HyZagTU0GbjmU1oksESfUzNHlTMDCn42th58PjHzRKrycgT4VxtLEhJwkxkUYKpNVk4iRcUwZYbOGW3Jdm4WZ1TUzdW90A0NX0JbXi89LDB5T0d8BzEzU8OwhjrEw3pTmklz7ov3T89l8eSnO7lh0o+rydbsdsOdaGwG8vD/RJnpLxlPAfZxVRWdK1pimEa3r0/xIxgEBRoxKxQATElA7YbDHn7NDYsTP7lDYbLa0+PJBya0iQaF0LduYS6zQYZtv+qZvwp//+Z9f5+v6oXo9nHUX8HrWc9PNgQhk/mWoaYwRH/7wh3H22WffLEGh7bmiNUnYPnUjyp/YMtPPDlmy/lAqq0wG/DxhmNmxnQJ7sv1SLsCP7GFCqi38ihEo2RuEiYONBIGVOm3FmWlCLsxYFidy9hZZ3oDVeQrQZJEjCmulbE92puTDpcqWfDwFYDAEVPqPt7KGcVaX/wekGqzibUpnrqyiq2MrGKkdc12kG1nWlogZxlDjaMW04a5dsA2jYrtI3GzZHjLvANNwdSxByHa3hxOzSdhqybyljDCjwcTEPMbYSP5fnFWFvcoSmq1B19hTDQebWckmVXRZzRWixzQ5cw27DKWpQ8Ff2GrgtzsaRKoGkNW+7RP1cA1NLGTPANOnolHMFUOsx/aYDNsD6FFyGVPj4XaZTxgrMqZIZCPjZkPALLmFubJSuQfkClwLV5QN+OPL4mJO3sKIqcXmDAg7aYYIDCjdzm45iAZV+p3VzJNpdoqTijmExpSOYCOGEm0CsaKLDNOKzzXlch5Vs2ojV8TZGgwzD6yGm/A3/WublBI+9alP4aqrrkL6F4nV97nPfU7QUa1nPeu5ucyBAMAnP/nJuNOd7oTHP/7xiDHiPve5Dy6//HJMp1P8+Z//Oc4999yDeJiTZjTsWfP7sttv8kBp9kgwNWNfokZmxIR+yyEJgPSSJxgmlm7fAOlqhbCMjjmAKzZEGNFS6bYktr68Mbq5dgCLNk3qy0zH1a32CesbcGoryZ9jFI02b7guwhgaLYwTFi4DpgtFR5jaaoxy8RamFjao9WUlquDN9hGQla2bS5uJMnDeIjkL4wzc9grhyKRk6eXGAcEUl6uaUdK0lmBqiziTyBNpnwBA127OhUVCSEAjTtKG7BM0C09iS5zk2akJZK+GkMaXXBy6WpGmXcRhqyXY8Rp90hfWla8XAme3JCtnIUyvoYklF02frHUlfgZ71raptTAhFJOJPpYZIoBaYolEoyhML0Edr79bMhdSx3YSDSMuaDNExLYhe7rVir4w8+daTzaucfC7PTWb4j43hu0kZqBLWNfuRhzKWUBuaZaBMsfy+9ANyO2EHzS6WLIFtW2l36ppgnKMkQkbZI3dgozhauNAfG4HPu95z3vwyEc+Ep/73OeuY6IzxtzskhO+mlkTgOtZz8HOgfzr+Cd/8ie4y13uAgB4wxvegM9+9rP4p3/6Jzz5yU/GM5/5zIN4iJNqTMo0fIh+z6TMcOguF7bHxIx+U8wNsg4DCOrsQIewFTYNgACwjCR5gOz7TQhTi9g4xImXzlqun5nJl0ruH9sRKgJCMaGwD9fsCd4l26f5dKUyTUKBFURAw4aNrA5LswW1dEmaIjRn0HURdncl4n8CVCMrUXUsayAygBKKnCWT0C6GoiOzQ9zHUupKOjcVwYJWhCVI7mEk8BRw5uZdye3z2ysCXydRMgDNCSGVOBhAgq27PX/vAo0aojNzO90YqWPG9a+CRIJt6c2VtWnJyBuidOSmfavswiiKWzaqm1Wib3SFno2hUUV7chtG1aSK4ctxsxl1cPK60+tbdIOTiiyhAFYzJFjJatQw732ssDh6AQnxlmxF/YBBzeKe1Z23I7i0ZLYZ0p2L4cZ1EveyGGh2kqxAWCvRL0leO1lCvSv0R2q4ZSzMdpp4mkwk99L2ie05h3B+6qd+Cve4xz3wkY98BNdccw2uvfba8ueaa6450Yd3KOf60ibWs5713Lg5EAbw6quvxq1udSsAwJve9CY87GEPw+1udzs8/vGPL07hm9PYQBAYa4s0s3B9RmgNbASSI2MEQOrD+IbpV8q0Zca/aGWXHXuAtR/Y9hl+GdkF3Ksz0iJai+r4UPRfAPaE9I7AAUDRrNllKP24bj6U+jFtg1BtltkT35I9QVCUN/UsdWDZca2oTt/SgxuppVNG0a5oDLED2UGrbmQZ07OFJGy1yBMHv1gyQmRSEWS2Feu/NHy5BCYzcihuNKWRxF07R7zFBt2kC9GttXtAIjACNonCSZUDVNcoMTFGwJwJNKa4eU8mrfaIW81+ekLMLLmx5RhtL0YU7U/uAxAVsInOUDSPCtjMEJGbiudUolSyAEE7EDipDk/zEwEQREm7iwkJUVemILPGdg3qHGNFLWMWVzhSJlOayVyn2hXmVoGxTalcSzdPYyB2N9D4I0DQSM0dHdLCTto81vIZiZvZ2HP+vN0jEXDobzHh+Q8JqZVVtrOotjtYXW3XNMTE2sI0GpFDqYRf7V+tHpb55Cc/iUsvvRS3ve1tT/ShnDSzhn/rWc/BzoEwgGeccQY++tGPIsaIN7/5zfi+7/s+AMBisdjnDL65TDZkgkIjgb7WlHq4apHQ7ETU8wTXZen3zeg3rQA/UIQv2sHkAL9IMJGA0S8TkIH+CJk8faMzmSyIEdCYPE0iUdoyhi1hiSyEhaLRI84qpJo/nyaeoEs0gjCjy7gI/vsgb7oeMIBbEAgxsy8VBk0BKBKjPuJWw7w2ddOqJjGPGsMoICNOa4KhkMZwYjGU0JSRYPpENspbMmAA3E4Hu+jh5tJaERPSlgAI6e5NjR+z6SS3TkOebcecPTfvCmB2wgxqFVlqfAHN1CuisHkKmmjaGF8PJqMcozJ+ek6jau4MCiA2KZd+WwV2tmeziJpJksTMZOlJhrW8BiExQmbOzL44ZR8wQGDt5j27hI0Zwekur2HRSC5YhZdqL8He4tIWCYBerxJvIw0jqeUHgrhVs52ldtDWmtRW4+pa42oaBmdDGEHbBTGuWOYTOlOijmAM/HYHuwzwCwJMPx/IDg8Jw8zTABUICJllaZH09XvI5j/+x/+IT33qUyf6MNaznvXcjOdAGMDHPvaxePjDH44zzzwTxhg84AEPAAD83d/93c0zBxDU/tVzgrXiAs4WyEC1EzBsebqEhQFMzggY5M9nQwOJGwjwbMgYJrZ8P3nq8lwfMWw61MdD6fk1mQG5sbHIFojWlq7V0DpU2wPfVFNGAvWAyhL5nQ5xVnMN13pU2z2z9WLaBz407DlO66LXAzSqxrJ6DigMkkkZZhn2dQ/b1QAIi6Zuzzitxi7hysHAlLBlG8a2ErfTsUEiJthEPV+qJzz3AiS0D9kM/Dmym56uUzErxNaTrZz3BZAZ0bzputYOEWbeMRjZoKyZCYjjaAiJGXnii3nChESGz9LUwow+Ahw370fnq2oTDZBrC/SsXst71qzZ09yiq3fs1QIKmIacc2brVWX9DHXcqmZRagDdIMeuLmRjWOdW+331fEAuFWu2F4ex1giKVq3UD0qfcjaGJhY+s+JW1hzDOKvgdsc+5NR6mm2mfGy/02E42sKtqEXkBw6uu20fqZO0pnQw1zsDhqkXIwwf1S8iXe+HcH72Z38WT3nKU3DllVfiTne6E6qq2vf9O9/5zifoyA7X7N36rjfA61nPwc6BAMDnPOc5OOecc/CFL3wBD3vYw9A0FN475/D0pz/9IB7ipJpUG4SJJXvXcc1rJNsseYP+iKe+z3G9axJQzxP8IrE9BIDrhc0TUjDWBtUylZWwapvC1MHJ+hhACdlVdtDkjDDxyABsb+BXfNOPkwq5JrgZREifvcVwSovqmiVz/ULCsFWThRky39D3sGIAkOUVpGyQXZGRKeyhkRWxZPfxZ+y4tm254jRWXLKBTlbtAI6ziv2w4vS0vcS4bDUEMassbKVBxhgmnL0dY0s0KDuJk9QYqX1LdKfK8avZobSK9Iy4McaQeRwirBhTdL2qlXMmSJtGL/rEmJCdG7V5slZV/SCsxXDqlOAy7nlug2QFpusClyxreQK1gOxknawGDgWSAjrp9DawlmA1RzGupMzX1GTMPtQWmCTgVJ27qhd08wG5siWD0PYRdt6VtfveOBgd0wdENeTI4xlprDH9KE3QrmdlSUPrYDtq+GLDKBskgk7XRTZ+DGbMvewiwkSaTBxzAlNlEaYWoT+cG4gf+qEfAgA87nGPK18zxiDnvDaBXM+s8d961nOwc2A9Sf/5P//n63zt0Y9+9EHd/Uk1bslVbayZyxcrdbWiuIFDyxDo7Lj6Cy1r4lIl1WTeECRColsqqdUyXAXHxjAGRt5Io6y9/DJSC5VpUAgTz9uuEuLUw+9KLIbEq2THYwQgvbUCajKAkGHTnno0gIAmZkDYM71tqiy8BDObLhbAN9QtNYrC7GUvmYTWwHRpdPAquycsmRpP3HZfmjyQMzuJ9wIJcddqxqDd7RGOtDzUaVWAkNa+2QXBkhoxrPx8CWjOBFrKcro5O5BzxSgSkyTLUEOtrRVdG40kUYCr6gONMmzOFIBjO74eUqVdwUMh3Gx5nh3SRjPmJw6xuIVzJa0Xq8AmkT3uXc1i1BWrm/eMXJFuYq1N89ur0t1LPWRCrmgsygokZe0NJ851Z5FdKnVwebOlI1s/UGxIW4mGXu8BkSWHUthKO0QCZgH9xiXkhiYOt5LWEdWS7vaIGzXCxMP2CX4Z+QEnMvzcSAagGqZSxd+j5EbN62EbzVBdz78+6/Dn9aznppsbDQBf8pKX4Cd+4ifQtu2/afR40pOedGMf5qSc7MjYZcsAZydNHskB0VkkD/ilZMIZqYDrx9YCG4DYAKEV0Djwe2FixGDCr2lVlomMkjExI7QOYWZR7TIf0ISEZjcibFSMN8lAnFalAixXFv1WhfranuJ9z2w8QNyvQGnVGA0S1BAa0WeZmNn7qzVsstJTB7AZYlkHanC0GSSSZLdHbj1SU0l7RSqZdVbuS1eltgsIR9oCJjRjDn501JpE3SDbRMKYD6cNFhqf4iQvcMJ8P82kg6XZwom7WRtAYutRXbMoWshcW9h5hFkFpI2arlmgsKtpUhG8idM2tbIKz2AEjfPwuz0ZP2XsAg0yAJCmDeJGDX9sVaJkbEhkBiOQNmpqKXuphpNwajvEfWYSXa3qcUeNbNlsi6u2ZB7KGhg+l7YP24fRoLIayC5XI+COtQMk02/YauA6hjG71ciUAnzNmUCJAbuTqX1k/qMta/tSMZdMAfkKyK0wyzTZiJveZmmzybCriLApYDjxgxL6w7kCPvvss0/0IZx8s94Br2c9Bzo3GgC+6EUvwo/+6I+ibdt/Nb3eGHOzA4CppgkDANw8IrYCIiYWbiB4SxU1f7EhqBsmBr7LSB5AZg9wqox035LJ0HWy68lmpVrv15XWEdtnvvlamk409oP9qNSYxcrCrSJBXczw84hhc2TVAEjeHMFlBlfY2teavIXpswAsD4PMWjBh7WCE1ekD0HiCQV3TSih1asRgICYINydTphoxtxxKbIoaDmyfx1Br5NL8RbbJA86WuBLN6ivduuKQZVPG2DSitWNaaafABqJvyxJp43dSqVCDrDBT5RC3GlQ7wmJay2DlSBOMEaY0iH5Og7cBAljNskvaj5wYEq3tLUkieUwfuEo3YMahnBe2pmSeM43YCQnGGsSph1swfiZsNgVgATRtqNMWADWf6r6NY+SLW/SjWaaPYwNKGqvi9PVgIU0fxpAJNgZp4uBXAdnL18R8Q3NJACRXMU3Jmrol4340yy9bCT+X12OWjmsGboMB1s4URrCsqxcBeeZhe2CoD2cOIAD8z//5P3HJJZfgiiuuwOWXX46zzz4bL37xi3Gb29wGD3nIQ0704R26WcO/9aznYOdG/+t4xRVX4Ba3uEX5/+v785nPfObADvZkmQyU9W2YWnb91gR8JmZUu9T7hdaSCUxAvZsQWgPXU9/HthDR9mWU9RYy0G84hNYgtAaxtQSRA4Gf7RPcKhYQGhuLMHVIkuFnQka13Rcmius9oLl6NfYPQwCUaOVKjpyuoMUAEfd21eZcwI+GJ6e2ImiRPD/TB1kP0uyiHa/KgiUxiMTZuKLVtbBbDKJ9Y7yMDcyFS9OqaMty5Qj0LI/VLnrq0GY14kYtphBZNUtQMnPoQtECQmvOLMgGimNVV6ra7UuXMErDSKlyE2Cr91PMKHvOaTaG0S7OFFZDY2JgNZcRqL88Z1vJ0SnXz6pZTLkAZTKaXEWPAc8ClGR977dXvN9EnZ9dDUUnmWpXDCuprZBaL+0gqTzvvAd8atRMnNZ83JQlf1J6l/tRu+Z2CSDNKpS1uBkYAK51dcx4ZD1hnFQl/1ErEUs8kL7uKvnekJC9QbU70O2rTmRnEGZe1uvYL184RPPyl78cF198MR74wAfi2LFjRfN39OhRvPjFL75B9/U3f/M3eNCDHoSzzjoLxhj82Z/92b7v55zxnOc8B2eddRYmkwnOPfdc/OM//uMBPZObdtYmkPWs56abw/vx+CQev8xIAqxCO7KBGg4dJxarU1wxgFjp9q0WGbEChqmRlS+NJK7PpTrO5Fxq49RU4VayZmsMYivuW0+NmY0CtmqL/miNYcNzBSzHlKVqLE4rxImXoGjRpkkIsYb/xglXqFFWjW458I1W8uHIgHEV6xYEGH5XIlky2EWr+YN9gNtZFQ1eqqhLs0NkC8UqjOvALpY1IIBiZAAIqrhKZcNGccYCyA1XsXq8CuYAsB9YQTDADmBhHU0XCfTkWHmuZQUu8SxxSl1dde2SxyFGCmSU1WeU5gvbhWIasX1ArgXc7skh1GsJgHpIoIA77R+moUWfG9fGuv5GYj6hBihrjAuE6TQSoB1nFWAt0rRmjqAMTTGjASZs8PsmJHF8iznHW9idFUxMCJsNQbAEWJuYC+Cm25pdy2mjRths6PbWnuDNFnbRI27VZEDFDFPCqvdcJ+37NaJPzJVmMu6pR2yt/D5JfmFlkJ2Erx/CeelLX4pXvvKVeOYzn7kvKuse97gHPvzhD9+g+5rP57jLXe6Cl73sZV/x+//9v/93vPCFL8TLXvYyvO9978OtbnUrPOABD8DOzs7X9BzWs571nNxzo1fAF1988Vd92xe+8IU39mFOymEPsGSXrbIwRaLlE12gXyXYAGQrlW6O2j8bwHWfG3PaACA0Bn4FWR0nBE+dX5gYGA8kYwtLMmx61sYl9gFTA5fHNbAzyNnA7nEaFi3hEGlY2KzhlqGwO8yhkxo0Y0v/KoCiHcsGMMKcJTkHWdi2JGtd20VGfyQBaOosXg7C4JkCAKwAFrtkpp8NKC0Rtguja3eIQLYF7NVfmhP8iDbOSXSNU9ZMQq91vQiAINQIS1dialgt5pYDbD8yfyZlQJguZUHTpILbYd4eLLV/YVbxei4BeFNuawZZE0+rEfDIetQtB/byLodinKFmzpU1KFtWXHGJo6kAyUw0KZW1dZxKiHTtS7aj6bkST42cnz4ith5+p9unA6yuXRI4ZhSDDjLZ17Q1IUN51S7CkUkxmyCkoilMtUPcagtAcwLorZiMsuHq2fSjQxgAcrbFxBKmIksYEvxyQH9KCxszY3wk4idNPFflbvzwo4572yWsZofzM+4VV1yBu93tbtf5etM0mM/nN+i+LrjgAlxwwQVf8Xs5Z7z4xS/GM5/5TDz0oQ8FAPze7/0ezjjjDLzmNa/BT/7kT97wgz9BszaErGc9Bzs3GgB+8IMf3Pf397///Ygx4va3vz0A4BOf+AScc7j73e/+tR3hSTgmYQREwMgADgmxNfCLhOyEfVNdXSK4swFIwgyaDMTKIFUorJ8NGf2M661hw5bswFQbxAoACHC0RcQIA6hGiiTuU78k0DN72MTsDJxo/TSUONUOVtyxpqfAXw0kasQIGxXcUiJEBAPFWQW/3ZVwYL/TIVvLZoueACE1zHxTXRe7iXOpO4NU2NkFQRFPgKyohTHKhscdZ3VZQbL+TM55YmB0dK60XRQ9orNwx5cIp86kMSVJBt64orVyLGlP9IsRQ0mcNVxdthKIfKTlc9Me25Thr12SGe0G2ESdoD++QtxsJGRZPixopZ2z+1bHCox0RW06PrbZsw/LBkhbtYBa6hCRM7txt1phxWwJx87yHLMVQ4wxsjq3pc9X21yyNbA5I+ta2FtA8w3leuUMYR//f/b+Pdi2vCwPRp/fZYwx57rt7gakvQDiBa9gTqFRiJQEtQ0mxFDG4yVykA+NBtEgUSNaiahgU9EQNRZYxCTqZ33B+jQaKlEiOUprjkGFA4mHGEWCQVQgTffe6zbnGON3OX887/v+5qIbpHEv2b0Zb1VX7732WnOOOebYezzzeZ+LR7wqodPy3vgpM1i6C1w3eG9gXJtVmH/IgO2yjnCBHzBozAHKKiA7cVCL/lUZWRQAUdbFqXINLH/fXMUN2wTy6Ec/Gm9605vuYwb5pV/6JXzqp37qdXuet73tbXjnO9+JO+64w742DAM+7/M+D7/xG7/xPgHgOI4Yx9F+f3x8fN2O6YHMLuRbVsDLLHN954MGgL/6q79qv37pS1+Kw8ND/ORP/iRuvfVWAMC9996LZz3rWXjSk5705z/KB9mUDqgTQVzumN/nEle61PlJH65o4QCuh9PK2cqXfw4JgGaNXJVO4TjWHUMBGUXUijjyxusATIcBcSzwNKcirwOwycjrQE3iisaEMvCGyYo5NilMRx3CWBjJsaHBwICKTnCAZNbtfq10nkxUqqZLg3NwZ1uU2w54fvYE1AgrpOtjXT8WaejwM7VhVZyrqnUrnSf4kvWjn1JjBHd6i8PIoOpwOsEHBY7FhA9hM6McDA38DXQuIzfTgRsJlGvvaS7YXbt6ieYJDvFstugTBdtxLuwonhLq0NnjqcsaAWbS8RvW44XTCVUcxICsV0VXuVvL52Qtr+DRMhQBMWA0c406gZ0wldU7C9r2mdo8NsTwPakSW1SGYM+h7KC9N5oRWOhAr05OaxBw5h0jfpxD2euRV1GMPt6cvKUL9h4yu9KTIRZgac0oEubcnSprK8HXziGvqW91qZpGlK5uBqEXd2PGwHzbt30bvvEbvxHb7Ra1VvzWb/0W/s2/+Te488478eM//uPX7Xne+c53AmBb0+48/OEPx//6X//rff7cnXfeie/5nu+5bsexzDLL3HhzXXIA/+k//af45V/+ZQN/AHDrrbfiRS96Ee644w78g3/wD67H0zxoJq0cKqVhGI4z0sqj9rw59Sdc21YAiB5hKiihfS+NGw5ursZkdBv+WjWDANnCuBVdYK5Ia4/uRHRuAYhjYVtIaiux0nv0x2xM6K9NwlI6xLmwt7j3UrsF646l+5dsStUGkKlYSHP3nnP4XoCTMnDS0KGgMR30CO5AtFoRpQ/orm3hT0eU2/YFjADOewsPzvsd695MWydROp2ESjtHndnEPDl4LyzXhNIDYZMNNGk8ipvofM17KwObGsqsejy2ovSorlhHr5sSwrkTltSjFq7KXZJswe3MdfaqM8AL6cENW65b/Xa2SJ1wNjLWZaSBpnpnwdvplpUxlG7OBqYITKnLhDiVy8A1uUs0h2iYNDR3r1S2ahxvCQh1hbvuzPwBgBE+e70BWpe5xvUQgH0+0X2cCoKYfmofBZDzWnYiL2AuZAXmYixmjR7xeMs+6CFQ2iDMrcbthG0y5rR0nm+JuMbzIEHeU6EZyDsAHnlFVjdumAGY9gIlEtuK6SiQTc83JgB81rOehZQSvv3bvx3n5+f4qq/6Knz0R380fviHfxhf8RVfcd2fz70XENbA6fc1L3jBCy7IfI6Pj/GIRzziuh/XA5mFAVxmmes71wUAHh8f413vehc+7dM+7cLX3/3ud39YCo3Zxwt05wXTgdwEHWi8cJLz13P9myXixScyF7kXR+9cMe/RAaxrXoI7MZhUMXoE0HEqgvi2bq7wkJiZzN+7AkxHHeJZpri+9xYCHbdc7wKs0MqDlzgZYVUcyOKYa5OOy/m2PYKOIUq+XWOu1GWqrFKJ1DV217ZctR75C1281La14GONGil9kDBp1rgpePEj2UkFWi6LI3luDmYnmrsqhpgka1qrehsEDAnoTYeD9SKjAq4Ka+bIAqpmrXRBepFhgcqQeBRmAAaE04kVdJk5fvF4ywukwHIH/VxbUHKpEn5ckFdcmfrtzHMt55cWc+YwquM2rzuEs5G6OVmVh21C2u+YuzfNqPuSGxho5onHo3X4QiJw4LjOdr7AFb4eZh5GPn9fLV9Qu5IBgj+/nVArXbz+XD5cCFNag0e6dU120zl0pyPB41pZ0QJXMupqBT/NiOcz8jrCzwnoArrjiVrQuRly8sCmkNLxgwsA5N5LVzb//vi5oo435goYAL7u674OX/d1X4e7774bpRR8xEd8xHV/jttvvx0AmcCP/MiPtK+/+93vvg8ruDvDMFij04dyLriAP3SHscwyN+VcF4X005/+dDzrWc/Cz/7sz+Id73gH3vGOd+Bnf/Zn8exnP9uExx9OUx2shcCnCp+oRfJZc+xgNyiudMnWzXsO/WmBzwR3cVPRnRekgVo/BYwaMTMeOquGK9Fh3vcWQD0feAOPfiZwmA/kRrnySKuAMJUWrlsAlyiwBxrjV3qu6bgChPxe2JutmEo0miOREbLQYWHo+E3UhHX3nHPdK/+yuzmT/ZKwYoj5RZ20+rjMHmwsY+m8sX5aD8fA5U4iXGCxKgjsxC1rGkoouJQeW3HpWletxrFo/qAESdeeq22aZQpbP6TZw43ZXo/mDfrtbC5qjU6h9s7zNap+rQpwX0dmMh5v6Yg+5e5eAR0r35IYaZjXF07HxriJno5r+9m+XvqI9LBDAvC9TlbUtTl3RR+omknSflxVu7np/qrnhw6uhhmHowAQgUA673W2mtXzUIO30PDaBcRro0UE6Rq47HWYb1vbuZgPKBHQwHDIcxdpuKlSCaevQXMygxhM8trD6WW3666+geYpT3kKrl69CgB46EMfauDv+PgYT3nKU67b8zz60Y/G7bffjte85jX2tWmacNddd+GJT3zidXuev4ipCwW4zDLXda4LA/hjP/Zj+NZv/VZ89Vd/NeaZYvUYI5797GfjB37gB67HUzyopnSw9g/+nuYOP1dsb/HozhnrUuIOY5cq0spjOvDoT6RLN1A32J0VbB4SWhRMgeQKaoQMWUU+j/6ej+8q4GcQDG6rrXgZGk2mqQaHkDKqB9J+h7DNmIeImApQgbyOCNuMcDYj73coJfDxxoy8c4PVwGC6hlMznnR0z/oxo+z1XPGNDJH2NZiL1gwaULYzmAFEHbb5ygq5CyhdY81UD0dgR2DoT7dwY0Y56LmCBQhsSkYZGIXipmTHpvo41ROq+9XlIiHR1er1yFYWxHs3fD1reX2bZBo4jbXRrlsnbujqHHySMOQ5o8YoOXyVDt7oyZQNQXLzJHtxm5iVKI5pL+0g3b0bW8nq42uoczinMYcaPzGHyM/ng6HV9ylT52A/w3o8Z2vuIE0nWg/nqgSEJwHJ645r6CGi6Bp5nFGDR7y6ZQyMY2A0qw69gWwFl1xj81pjniEsdkfzADWTcj7sTHZAmQND0GuUtXEHxA2jkW7Eee1rX4tpmu7z9e12i1//9V9/QI91enqKP/iDP7Dfv+1tb8Ob3vQm3HbbbXjkIx+J5z3vefj+7/9+fOInfiI+8RM/Ed///d+Pvb09fNVXfdWf+3Uss8wyD965LgBwb28PL3vZy/ADP/ADeOtb34paKz7hEz4B+/v71+PhH3TjZ8kC7BziptDFK60fw0kxRs47grXqyVT0EusyHbb6OAVy/WlBCQ7dOfV6agaBE7DkqwVOs+eXj41KoDcfiOA+85jmfQ/c0nHVOxa47BHmYoG6rgJJgJ+xLwIa/Uznb3Zk+Hxqa7bqeCNn93G1kGZ1/mrjBteaO7EdkgGXV+yDzdoeEgg+NBrFYktOVcMo2kRx8Gp7RdlvzFnYjGTfIAHGAIHguiOQ6QLSLYFVeMHZYzlp19D4nNJ5C3mGB2psHbx+ZJ6hm5KAPbqc/ZioDZzphp0fsm9rWD+1WjyUymNMxdhL1ffVVctPROct6w9isLjQAgLRd1XRN8beeotdAeDFWT0mVBdb4PYAc+u66uDGGWV/MEOITxITtJlRD+iyzhJN41JBOB5p1hmTdVaXw5X1P6s2tCAgZGkh8QAKX2fuPM/TdsZ8ZcUPM3OFl/BsVwvP215na+h8wMq5uEmsQDwM8kHKYbg3Yz4MCNduLNbov/23/2a//u///b+bSQMAcs549atfjY/+6I9+QI/5+te/Hn/1r/5V+71q9575zGfiJ37iJ/Dt3/7t2Gw2eM5znoN7770Xn/3Zn41f/uVfxuHh4Z/z1Vz+LNEvyyxzeXNdAKDO/v4+Hve4x13Ph3xQjqtk73TS4BArGTpUyGq2YNoLiNuKsC0Yb+HNqz+t2F4Jlgs4HXAV3J9JQO+abE13ThAXN5Wmj9OCtPbwwlTZ8ztgvDXSXTwD8Sw3hrCjW5KMIt3ATmJp/FRaCwMkuzBVIDPfzqVqLtYycK2Y1gH91ZEgT/LgwulkzR5k90rLFpyLgaDqHcLpCC99tWGbTINWNPxYwIhVw53PcBJLAufg5yzRMrJ+30jI9BDlnEisy876GQVwscpaMkq/cJTIl9bPrKvEGj2ZRflelyvi6QZ1IDNW1h3mo15eW+sT9mcT0pU1GTNd8XovWj6YQUXr8LSqrezRWFIOesSzwqxC72R1LW0fCfL8bF0JZzR1lP1eDl4ihY7oiK4C8P2UhX1MNN3MjKlxc0YdOoTziZpI6ZkufUCVjmcEMon6vVpp51UGAILY+bBHPJ3kPdjJA5wy0hDgasF80CFuGEKdD3rGDhXRF6YqYFu0pZVRL2EsCCP/ThVZM/tUkXuP7ryg9IxbmvobiwH8S3/pL8E5B+fc/a561+s1/vk//+cP6DGf/OQnv9/1qHMOL3zhC/HCF77wgR7uDTXLBniZZa7vXFcAuAzHZca/uHpxBcXVFxm6tOKqN60cYpEQ6IlGkO5cVqfRoT+p5tbcXf8C0hAyU/81CfuhzR8K6qpjc4ifW9afBlOXzqH0gB+rmUHI1ET5dRFNoFSiRWFlhIUDmNHGF8dj0xt1GYK5SMPItTA1aQQqXLtCwCIsloRsj+q8kpkQ4CBBw4xhcQqQRJvoJDJEV5V5rwd8e1yMmaaBIZJBUkevhgdLeLHLEHOGtJvIutlvErzU3dU+Iq8junu3XMteWZEhTXTZ9u/ZmE4SHXWH7AqWbEMHOnu3CeEczTEsWX81OAvTLuto1W6Wn1crnGrsBBxDjEY0wux8+nAOrhS4cUackoREM4Tab2doP7MfM49hzFxPp4J8MLToH2Ei+abCfg6AAXYF8wScZHTDhuv0cDpxPe7V2RtsfezKzuGKe1gZ4xob08gngzGdRb6e9vh/nyvSGsjRy++BcHJjmUDe9ra3odaKj/u4j8Nv/dZv4WEPe5j9Wd/3+IiP+IgLzSDLLLPMMpc1CwC8hFFwFcZqQHDec4ijhD4H5v6VjmaD+YB9wbvdsm7n0y67WB1KL5q3DJS44w52kMo26qHmfa6Qu7OMeT8g9VwXh7GQJVlJPIxkphG8MSYmdQLsJFC304w5YS6LAKIoUSzK7HH1m9rXEs0FeR0vNDeEbRLTgYfbJLiOTKCunTVCJCh7pq7iUhnnIpo0pxq1TKZNGzu4Ui2mvatDZ40fZd01ICG5g7ULEvrsDagCZORqH63jtqy4skXXAYWgFrI+dXOGL9UaLJAr4KvFyJixIouZRTP7SgGqtxgXXY2zAq621zJmlH2CM2uH2bFvXTChRE/Hs+T0KbCsQ9f6dbWtY2h//f0mwclKHYAcJ9lKrQ2k+UX7qZVp9hcY1bruLvQB195jXhPAxzOpnhMmsEaPcM855oftYz6IGO5pwcPVOwZLnyW4KNdn5wnixRWu13yWTEw3FsRNMVnDdBCQb7AmEA1+LuXGAqY36lx0AS8U4DLLXM9ZAOAlTOmAcMybVhzF+ds7a+gwE8eoGkAH5yr87FAjJALGY3VvxnTgzeTBOrdia+DqgDIQOIUt42Hi2HpZ6Y7k87ksgdFOozT4y7DlGjCvgt3U/czVJgFlNdelnwsdnYWOXjJTrEvzuaBC4k2E2QEEuA00TYStmBK2BGr5SKrASmEmXqfatgrUZGHPqrtzlYDESRadAp90OKD03gBgKMyKsy7dDWNg3E7kjNaWhbOpRccMoWkXNSC6iu6tC8ZQcj0uAHMVUUXrZ2aKzhvY8yDT6c+3KPsDws5aHU4cz4EfBPJeT/3m6cgV7DYR3EveX+k8IK5k/TM3N/CXDnqr88v7PcL5zPXrbrC05jQmZupZnZ+AaUAiXrxjF3CmLtNvUzNkSCZhWUWEE8bP5CEglLJTt8cPPuHqFvmArSea8WgxPN7JWrwibjNX5+Lm3u361feEa2g5x5HXnzLspXfY7nV23WoeprKUN+L8/u//Pl772tfi3e9+930A4T/+x//4Q3RUN+4sK+Bllrm+swDAy5gKdpZK1Mt0KNq8DMCxyq0/k/iVClvJanRLd1Ywr7k+DrPo0ITlQ1UHsLAusvqiI5YRL3C8MVbPPw+SA5hWDi7w63FbLVgrD56GlfOCEgE/kVFJnQfWAXGbhYGUVobOmc4uH/bNBOIc5isDuuPJIj2QK+I5Q37zKkrrRZI2CnU7+4sVb6UyRkTZKAlP1jVqiaLR05u7J5DNe73dJbRZA5pjqKxqKnC5uWI1wy+cT0Byxuw5AX0Qh626jrUaTrt76W5OxjaiFADOAFcNHr4mpFv3aIYRDRycA/po3b6olQwjwMDkniyg6gzdlJrOTsClxvLE04ms5NlM5+wQaRBRvR5gmkJWzrF2DakwDFh+Rg0bkOOsfYQbZ4RKsKdMr+ry/JyRjwbpaZb1+ibBuQoHybU8GCTQ2lkmYt7rWrPJLuMozSVZ8gH5+rz9ncq96EZTxXwYpf0D4kgvCBtgOgpiYJK/I/ONiRr+xb/4F/h7f+/v4aEPfShuv/32C6HMzrkFAN7P3Jjv5DLLPHhnAYCXMD4TrE0HjHyJsjZztaJ4gjoFcXFbTNOnjl8AZvrQle+8TxCZJOPMz9VMJU6qy7QTuEQCPD9x3VvlHuoEmNZKdoTP5c2VXAPX0qqpCmNB6T3mfV4m3WlCGQIr0SLdwmGrDlZvLI06eO0mnwq81LhhzMKQVWMQ1S0LUE+mBgU/F+q/KgDPdabLVZ6HLFWRlSvjRIKB0dpHA5bVCUCeBKhJvqErPDHKHDJ7EFwzrwXM5QqXE3wJKH2kgWMj5hM5FnhPd23V1a50IZ+MLZ7FO4Rzgpu0HxHmwqYTWfuqBtFvZ7ZyACYJyPsdgjJEoneEAFBt0kAByn5EOBvhAZopziXTEYyX8ecTq+lmZiDmw8EAmL5n2gKS93uCvai5hjx3ZY85i6o9DOdcNZvJJzITMpxNKH1EXTnRXWbrhQ7nqnWU9Xp0CBvRdEodX+miMIGgDjUw54/r3WSZhHGT7Tocb+3QaxuOo0SilBsTNrzoRS/Ci1/8YvzDf/gPP9SHsswyy3yYzgIAL2Fyx5uPhjRzBVst2oJxLAK4dowZJcqqduUY+XLGFWRaeesVdgUmzJ/X3vIEw1ztueKGv057rJrLvUeNwhgmwNciQdMFpXPIUdzJWXIJK52mfs5NNyaryzx4VEeQFk9E8+aEwXE0T0CDiUU7WFZkuvxEds9v6Gp158lCkd2UkG5dA7nCnzOORUGZk7o3jWPRPDvkQnndjp5Nu3o1IFpjYoIwWmWIdv60bi7v92TxNgnpymBMnJohLLQZaFVxUmNWuoCQZlvjolYGRNcW66LHrs7h/ppk6gXHNXEqxm7mg0EaL1qGYrw2WiafE+DHVbQYN+SchLMRZcV1r0sVZa8juwiCrbJiRV98zwb5yhoAbA0cNi230cDdZiaw3OtYuyfvobKEALWpytiF87lF5RSu3ePxFuloZSYiZILEvKIuUIGf9jcDkOuZuYpZeqOrc4jnMwC+hrBlj/V8yLV86eQDVtdikErnkGtj1m6kuffee/FlX/ZlH+rDeFDNEgS9zDLXd24shfRNMmEEpkPGUUAF6jvNBEHy+1gHB4vZCGPL/mNvrsN4FKzdA5AGkdTWwGGSNgcFmhKmHKaK/ljqzkRnGLdyg9+J6fBTWx/7VNGdcsVWI9fJBHTgSjGShTGnb09DCIFPa9HIq0gTQ7+zNgWQ9zqugVfRasncnAmqDlfMp5vIEJYhmsGDjI7msVTTj2l+XukjwtlEs4No1/yYrNrOb+icVY0jAHEeM4bGZQF5gdo69gd3BoBrFxiz4hr4dqXCjzOBpScIKn2gbrFWA58a7qyrXlcqkMhsqjPaxE2Sl6hAiDq9Sc51tDw9N2bT68XjLTPx1p05fAHAn88t5iUXgmoIEDxa28o9HfQIZ1NbTcvxKLhkRmOx+Jp00AvgkzzCIXAdLMCQZo2AskdQnfd7W1X7TWtcieczwoZ5j3kVmtsYQJAqP6j+T9i+MrDrV98/i1QaC4O0ReeaO0og0urGBH8A8GVf9mX45V/+5Q/1Ydzwswv6Fvi3zDLXdxYG8BImD8DwLpo1zPErvb39KQFVPC/IXWBo7dWM0kud1UznsE5/Wih0r9hhSMTAMdNgUKJD2FZjDgGugNMeDSRxw6y/Eh1qTxeyK7yJxpkMogZS03TB9TFXzKplE21gpAkCAPJeRNiwQzhsErSjNmwTWa1UWG02CJM2aa0XQUYZBAxWQHP3lMnTDDrNkNPsQFcrqu/MvKCgqKw7cxzXPkpv8WRrR1fISvLAKxCd9d+i1GZA0f7b6ODOioFUdEEiYYIcg0e6skY83iIfDpYP6FMB5mpGlbzXC5B0jG5RTV6iu5dvloAph/Y6C1fk8B6uFPiZTud4NiPvRbipwM0Eqx6J3y8NHV5y+pS9ZXC1OGmHiFqrrWHzXsd+5E0SCUG0YG4vrwGArXH9WFpDSG1MIMA1cndtK7pCjzKwhSStVzQADbGZhNYR4WxmjWClvlT1sAr2jR2NfC1pHSXKhx88tPlGHfdurojGnEoLTjMk31DzCZ/wCfhH/+gf4XWvex0e+9jHouu6C3/+zd/8zR+iI1tmmWU+XGYBgJcwu1l9jkkfDYB5AqwiwbVeV1Wy3i2ds3Wrav+0Ak7bPpzmAG6rMSI1UhcI8PHnAw+fCTTT2iNuCuIk+XfrFq2S1h5RmEpdUSdZLXsV2cvKunQOee3RnZDd8hM1Wa4yk630XqrSPJKwb1o55ucCBK5Q09HAjEGJegEg7Rbq9izSVtFaP0ofZMUXrPNWtXWlC4xgkUoxjRlxudo6sgwRZQiIpzN1bKDzubu6hd9y/RyOmVUH76lzFKBTVp0xazU4hJPJmkWUkfQ7oIWMb2VziRg8EDzcKCxcF/gzU0I+HExXiURnsRdNHRzX2cUxGiaeTtTqzZQGIHrU4uHOtqhX9via9jq6rgvX1vF4aytdNa24XI3ds7zDVOAkiqdED5cyP1xIXmAUhtBNifpIJ6ysOKj5oYZVbrtB0DXQ9OMq4FyxbD8/ZtYKSvyO6kiL54cWV4Gyt2P0kHMNiGzCtdxMgHIHOuyrMeFxW5HyjckbveIVr8DBwQHuuusu3HXXXRf+zDm3AMD7mxvzrVxmmQftLADwEiZua8tKA0FJGqhN4orUGatXOq5ya6DuCYCtbOGqaZnCRtiowuBmOLaCKAAs8k7qetln3iCnQ3VFEpgEAYFhKsgdV9C7TsoSqT0EBIwmAYLyez9WqaKrjE4JmvnnrCaOJwFk2rR7WFzBpQvw24zae9TsRPNIE4gDmabqPJzk68V7Nih7g4Q0KzAuAmYqEMW0ET0NCV1orRGzBkXTjNJf3TD3D5JZ5wdxy3bUkYkurYpzuAxi5Aje3MtejzFIjqBn97BqAmtwQCbYovZROoszzR55v29B2gVc+8qKmk7iQN2drEzrEMRF6w0w+SmbuSbv94yW8Z7g0ztZh5Ld1BYU6hilIm6cgTgwX3AdxRnu7L2rwfF5U4HfMp+QJpKZ2s05C/MYLTfRT8l0n/mgb7V0wcFVh1pqA/hJQWaVDmon7m6eR82FVBkBhJHUnMgSgxmUiqTYVAfELT/sVA9zyZcdNv1Gmre97W0f6kN4UMzFHMBlllnmes6iAbyEsRWuc7JurRLEzD5giEMxjsVYC5+q6fV8FgdjgEXJ5DVjP9KeRxmojdLoFs0+i+dFAp2b2USjYKrn6pcmD9bN+QyETTF9oWauKUANGwKa3HuUoN2sIv4PrmnsFFRuk63ryFKBej7pvq3RY7qtF2atWsWbNmAoO6ROVD8mlKM16hDIEjntGfZWTaadt2WIZhhwO+tVlwlKSx/YbStAqfTUrrlUDFgw8y+Zbq67d0MmMknUS61wY27tG97RSQvJKhSdHMAVNko1sGSxLLm0sOXVRbZsfuge0uHA3L9NsvVzlRgcP2bmMWqv8kHPtbV82FAQpiDKzdkaUgwIAmY4cVX0o8FbsLK+Fj3m9w6Mrs4hHUlHsKysw/lsINnOv+gOVfPXsib1w41rRhK5JqvDBfAX5oLuZIafK8K2ucJLdMiDlzxGftAh0+4k+5LXah68aW+XefDPYgJZZpnrOwsDeBnjgPHQodvwplYC171BquBcoc6vGyu6XDDvSRxJqaYB9AnoT6j/c4WxMWnwiNvW9tGdFaQ1b6ZFPRJOgpoDyOrJKrdEh+FaZl9wBvbuTkhrz9WZA9BBQChDp/PgkFcBeeXYQds7hBMBixK/kdYB3VliwHSpmA86GlhkbWwNEhKtgiKAM5LVCedcKzIiZaLGMFeUVUDYVDOCIHA9rFExXgKdXS7wmxnpaGU6O2UanaMe0m+5yg2bwlXvLWuuIE8T4tWthRhr6LAT0BVOR8y37dEYcipGDMnVoxFjFuNKtRVvHQhgw4YdwxAw4kpFhbCKnYcDEE9GA7Dqmg7b5oj1NfHLuQIlWzSMuXqj52q8CzR/TEmaTgiK1NChTKUybHCA39D0kvc6AX7V1talo24PBagddYvqqM5HrIaLp4yzcUnCv+cGisu+ajIjXCe6RG23KdSNto5pL3V9ZLd9rnwvhC0s1aOsPeKG634/ZqRVM+PMR2HHXAWEs4KcCP5Kz79zSDcOaHj+85+P7/u+78P+/j6e//znv9/vfelLX/oXdFTLLLPMh+ssAPASpkSgO+GNp9swY2/ecxiuERzZCjVVzFeCNHyQHfSSUVw9QR5bPop1CMMxJqaTIOluJ1Cart1qLSMAUAcHvy3WIgIIUyLGkdI7FA86liuADsZQwkne4OCExfO2h8k967Y0IDpsCYzKEIxBKn3H75v4fVWYUdX0WQhyoN7Nb2fkg0EML566xklWxFqJJixa3uvQ3buRdayD2xRrwDD2TFaxeb9DOJ4sviQcz9TP9d4q6FQr6HJF2e8xP2SfrJ+wVNQBZuu91UgVRpAEglKAxgapnvPa25sK0i3rlo/osRN2zLgd9kSL6cFRy6eOaNSKcDIiXVnJeUoW31KGAH+SBSzXxjZKXVrpPNJBj+5kgiuNDvObhLInx+DZqgL98NAFAYs0UsTjLcpaO41bBV9jfcU8E5wYR7je9aPoBiXmRlfMXlba6u72pVjfr+YC8rHIeFIHWK1/WlnEEhziTIa3v1okD7BiOuLfAy8flG6UeeMb34h5nu3X72t2Q6E/3Ke+j18vs8wyf/5ZAOAlTJhh67TqAa1/m/c9tPXDFWC8JcLnamCLMStSD+d22DsBTmEUBlFulBS+88/6k4ySK00jI2NcVMuWe9FFbaVHt1akgcDTz4zPSOsGHnPvMBwzoJphuwX9ecZ0FGgACZLpJms2yAp1PuyoLVxHroFFV+jHbFEoQAM/LhVxr5LZygdcp5boEM4zak9nrpfYE5cz4KKtgOdb14hns6140YcWaCyr17wvocoeDBeuNKm4Upk5CNGjzRnufER6yEFzz3oHt52l4YPASDt7HYD5NmbpVef49TkjHa241hWWEs6hroM0hhTGrpzPAqCELZOcRAAIJyPcXs81aK4oe5FdxRJSzWw+DXJewW+ZRZjXfG3auxzOJmTp5VW9IDyQ93qLl1FtYTibyCDuD2RJDwfREIqp5XCw71OdIQKNHFoJpzmPtgbOvNZq5+nLrWQ900GPEpkPON+2J33UHrn3iBIqjuoQz7NoZL1JI/JKQKR8EApSs5iFFVQTU5h4TftUEW6gteGv/uqv3u+vl/nA5gZ6K5dZ5qaYG+fj8U00GgSthoISJbNvpq4vTAVBMvnCVjP8+OeuVGMvcu8w73lqmTS25bywsk1YviD6p3k/WL5fWtFVbA0jM4HkdCVi3vcSLE3NoBpR1EHcnRes7s3So0oAp6HSu1E0gNR0CUtEIT+Q1qKBE2doHrw1gvgxN+ewNnoUnqe83xt4605nqzPTHDo/cQ3KLLkWWlw6b2AjHI+MoNlSC5f3e6BUxPdsRFdYEE7Gi7VzM8Fl6QPyLXtk40pFONkCoF4u7XfW/Zv3erKOXUA8mfh+TdouIhE2Z1wZa0ev3rlq9ATwFYx3qQTDOhpng8JzV9UIMURzHZc+IB2teC4USEaPeD6TKQPDo5Wly+uO61lpAvFjYq2eADUIC1c7royLxOeoG5ta02BsJ5ywfI4OX8tHzBXjQ1cWO7ObNVl6AtR0ZUDe4+tIV9bmlIYH4paNHq5AArIdfC40FmWyez6puYpst34wygO1f6ZxlXOf1t7MUcsss8wyy1ycBQBewoSROrq4FcA3VwFJMLDkp4L+JBsjCNCkkQdvDSI+S97fWOwm62ql0UIE7y5VhC1jQcJY0J0VDMcMAA4TV8vMhqO+b/cY8kCzQNyUCzVz5gqeq8XXuNSclbuu4Dw4W9mhspNXb8Jhk8Ss4VFWgTd/zzo6eEbClC6YTo4hyDRp+DmLocRZ7Rmr3VpDh4JAmg4Yi+JnNm8AgN/O1rJhGrWdflx4IF0Z6GbWHMBaEa9uqKtLhSHT20SwVSpXvRp27RzitdHibMpeBw3+roHMFaJHOhzE/Zww3L3hc4vpgZE34nLNmq/I7MDSB+seBgRAajuKZOlRSlAMcOlKue66hWXq0FELuNcDnq5ev2XrSj5glqHfatOJN4OMOojLip3IRRzY+v4oW7p694bPJzrM2gWyhA4IY0aWOCCGRZMRnm4ZUGQdHDY0enRn0h3deaS9wD+PYk5aeZMmMESb15MC6yAZldMBpQeuvfxlHoRz0QW8UIDLLHM9ZwGAlzDKaqEC3aYwr0x+r67edBAw73sJWOZ6sDstFxoR0kAgmFbeQFZaedH4SZ7bykvgs7OYjRIdutPGMhJQSu6gAMF4Lo0f8mclOmkO0dcgN9lS0Z3m1jssWYVqZrFWE3FlQp6nOmdr37CVBgzJptMg6SqZfgpIq/TIuqprVXYPo1D/VXqP+cqKrOCUbH3IMOjUfl5y7kofqTXsPN2j64giIdGlC9TxpUoglYsxdmWvJ+u1FbZxzICsiXeBkZsSQc6Uyf5Vrl7hBcAOAdqqAUglXheaLm63UUVXp1OixrALVkNHU0ax/MNwPpMdVQAs38P1cDV2FamYDhG1Yr5lxU7fVFjVtu6QDgd2GouJRgFdWzvL8XtqUPW11OioCey9AWd1QNfgUYZg1xYd397AmGn5IO5gyaXMg8d8yLBnNYIA/PN4li3nsfTssg7b2qJrJDoprT3SyqE7Y5i5v4FMIMv8+WZZAS+zzPWdZUFyCaNsmDYV7N6EpkOPPPDmFUBHb14zKiVI+0aQFg+IIzdMjVWDuDVdqnCSu1YjAV2Jzta5VZ240vpRvVTPJQK7GgAUJ+CNTl84HkurT2XuYDpyGI4z0oqAtUoQLwDJ4auI59liYdjHK+HVwSGtA1tLCowd8ptE4OBgIcBs8fDIGkuimra5wEUPfzY3xquP4u6d73P+GcyMC3q0eCJdwJ1HPBm5poyenILTYGFx4IBau3w4kPGLDrUUwHnrKbYMwFIsziWcTWbAgLBTkHy9KqCxRI9wOsrKlSDY2MxClo7NI75FpgBwsqIvwtK5nIGhY59xqmYise+ZCVohTSlVWlSYp1gsN5DZicquOuSjnu+D5DCWA9FQSlxRGcjqVckUzJ2Hd8LGFVBbOrOrN6/ChXzIInFCEFCY9kQusC1k9qSOMO+ARxqB+L3Wpz1CXie1qPPaI44EfIy28fahxJ1/0H+Nl7nBZgGAyyxzfWcBgJcwZOEA7fud95qGTztMtbaty9R7af9v2IqmKRD8VU8gSd0eJBOtiHtVDBQjb4bzPmNiCBwr0uDhksS7BEAbPeKGTJ/Wb7lM/V6V3EKfYcYOABiuqXkEkrtWUAb2COeVN1CnQ+OLQ/W1abqqt4qy3HmUvkdeeYr9IYYVWY17MHdPI0zyUS+xJB5uInMVtklq2FZcY3rJ9isVpYcFN5dVpEO2q2Lk8IxLmdvzolZ4MWUA4Jq07/m6oqcD95a1mUM0jqbsdXQKZ7a01EjjRjibJGdQVrfBtbgYwMKgGWOTmV8oK1NXK6oLkpMnDN9cCOSkms0VAuC030weNOY0PWTu6doFgBrpFlbWsfTBGESt1CPrCp7f4BE2RFl+k9pqet0ZOKRTORLUO4g+kKcvr5gRWAaPsCnWd8y4l+YG7k6YG5lWAdU5ROlBzmte291xwnwQpQtYrt1UhG3mB5+08mZmAoDxKCDM8vcC/Hu2zIN3lrXvMstc3iwr4EsYBUNhqvCZfb7q6PWpIm6L1VVVyRSG480sDxKVMlLTp+vQuC101Aqr5qQ7F4CAAho4CEYkA28nA9BWzyuH7W0RedWaNfS5XeXxhm0RE0C7sStALb1DkRaTtO/NpZz2uNLmWtuZFk4bSFyuKIEAyQmbFLaFUR6nczOXSMNI3he92iBtE57VcNolXAMbPDRDz82ZmjbRxvm5SC6fhhw76frV2jquh/3IlavqDzUSRdeNuq4MZ5N9H13MwuRJvp4fE3+9okYPuv6sqt2U91mBsoDLdDgQ2GZt4eBjsSpOQKqskovEreT93nIDNYTZqa5yLsIoSqexRNQ4XeXKzylgDJvZ9IcqP0j7UeJzJGjae3NsVycB4M4RlIsUgE7tFuECSIRQR4A3H/XsjtbooM7bf5Cw8tIxPgaVrvT5ICKvPaZDygv0g1D1QFq7xopD9Kgrh+68mIZ21xSyzDLLLLPMxVkA4GWM22HRZG0FB2H1KjV9AvxyT5evn6uZMTSzT3uB9aaZpA3EKuXW/FmAN8Aq7svq1YjgxPQh9W2poj/OBkarrNC648T1c5TKOXkNLlUDmtUDThjJqr23wVlUTOnoSnaFrxmi5RuuzmIWofNY40xy7xG22RpFSiRordFLjAzXsqXzCJvU8vbE2AFwteukfaNGacQocq72OzGQ8DH8lMwZCz0+NTkAzSQij+PHRCAlMSelD/w5GWUOXZX3I3i4WTR3uZqWTk0TeU8A5/lMDZ9eKmrSKDC3c+2jgO1gK282edT2M6UI28mVrhvpAm7xQ2JUqdRPhjMaPvyYmiN7zhcMNaq7o5bT2weZPASCziqsn2olteO5wFa8vFbB1bc0xJiRBASXpfd23ZdAIMmKQmA+lLXwKPmT0dFM1UnlXK5NJ+r5wYgfePi65z1vgNuyM5e5KWZpAllmmes7NxwAfPnLX47HPe5xODo6wtHREZ7whCfgl37pl+zPT09P8dznPhcf8zEfg/V6jU/5lE/By1/+8vt9rFornvrUp8I5h1/4hV/4M5/7ZS97GR796EdjtVrh8Y9/PH7913/9g3oNYVtthcpsv8bMNaBHxk5jXXZrrCyXLxFQ5RWDlvuTbLVtzZlbzPih7QeuNF0eKgRcVGNcGNqsIKoi7Qf4uaI7yQhTscgXAMz98wRwYZtNz+gyu1f7kww/VXuN/XGSleeO+UTcw9U7zIcRaS/Yyk61eGFbZP2nK8kqIdiJztFaEU6nVsMmhpLxoSuC6z7QUdozENlAVpaVrcSuqJatBk/zx5wtisVPyVaqTqrUwjbJahaARqKUirBNcJuJ5gx5vHzQU3fnCeaK6O/gHcJ5aoyeBEBXMVaE04k/B8CNZENnrVuT/uTqnYQtaw+z6PQqJI6lMxYRAjy749GAbF5F5AO6kdNBL7mK1dbKeRW5Js7qxnZSzecNJGu+Y+k8yk6Yeem8ROXwG8NIZleZQNXCQsCstoMoY8mmG7mwHSOH5j1vDToAGT9AQ9Rha1/NuCT7LUy1mJXCLFFHyzxoZ8F8yyxzeXPDAcCP+ZiPwUte8hK8/vWvx+tf/3o85SlPwZd8yZfgzW9+MwDgW77lW/DqV78aP/3TP43f/d3fxbd8y7fgm77pm/Dv/t2/u89j/dAP/dAHnKr/Mz/zM3je856H7/qu78Ib3/hGPOlJT8JTn/pUvP3tb/+gX0vuZBUVlckotlJ1VUKU3+vwwlQofJeA5hokBkZcjmGU1a88hmry4nkWV7Az1jGvGJ8RRoI6BYhVzCLsBW4VcPNRIDhLfFwneWt5LVo97+DHlt3n50oGBwSsad9jPgxIK6mvW9EAwpt6MKYzTDScpH0yVC5Tgxe30nUr/6HIOlvYn3RlQNrrBKyQiRru3hKsViCe7bB83tFYIuyZGjO8AMp4bYN4dYt0wMgVWyVXArR81GN6CIOeLUgZsADnGhzq3sA1tHxdQV/pW1g1Ab102O6weFYR550FY9cuIO8PgETiaMafl1Drso6stoue9XdTYmD4uVTVCeB0c2HbyhBRVh2d1M61Xl6JbWEdXLT8RQANtA3UI6a9QMA3BMt0LJEh0Ko9zIOweZEA3lW+xwSTUk0nHz584nlWk1Q6CDRBDcJwi1O+E5d6kTxKlT0QPALz2ovzF2b4KB3fv7RqmYDLCvjmmQULLrPM9Z0bDgA+7WlPwxd/8RfjMY95DB7zmMfgxS9+MQ4ODvC6170OAPBf/st/wTOf+Uw8+clPxsd+7Mfi7/7dv4vP+IzPwOtf//oLj/Nf/+t/xUtf+lL8q3/1rz6g533pS1+KZz/72fjar/1afMqnfAp+6Id+CI94xCPeJ7v4/ib3zm70PsPWYKaXW1PE7ufG3JXoxAHpDSRm0dqFTbnQeaosnq57jVUT/ZSfCsIm2+qWAK6IeUQAmwRHewEpdPby8cKGWWxhzLwZHydjAavoCVElHFpDrLey/k1A3GinbJXVnjMNYQ0Ei6XzBh7zOiCtArIAPejX9yLXsVNGOE+yshV2z4NM1lxES9ft6OsYhmxOY8DApBOwVwNBURDtmtNKM123zlyTKvhE9ARKtVWZ8fuEMRQzT9jMCGcj/7+ZLf5GI11KT/1hjd6CsMPYHsNZf69cP1OWzEGwzq7z8NJNXDsaTfIe9XW1o8GjrPn4uqbOXTPquFqNVSxDRAmebKaEOwMEf/rrMBaaOuRaCWOWXEon6+cqbTbFHM8lqBvZ2f9L5yy/UrWkem1rJVzYVos6Ui2hxg7FTTEjlGZn6t8ZusthgFojYRQ8LnNzzMIGLrPM9Z0b+p/HnDNe+cpX4uzsDE94whMAAJ/7uZ+LV73qVfjjP/5j1Frxq7/6q/j93/99fNEXfZH93Pn5Ob7yK78SP/qjP4rbb7/9z3yeaZrwhje8AXfccceFr99xxx34jd/4jQd83EGYMZ9g60+A66sSYdpAFckzz476JQVq1TGapT9OyCuaK5wwc2FLNOjn5r6NGwr/fWLGYI2y7h0J1qo2JKQd84hH0xAqOyhgMPcSwissjRNmxiW5eTs+p4LVGtShnO3xsPP4NUhXsYRa58EZw1idMmKgSSOIU7WCRoD9zlgoVyrSYY8iq9A6tJVwdeBKsxfAIwHCZQgoK/4sJES5dp7u20TWrorZo3ZieEiFwEzcu6o7UyOGP6eeTlm1fNCbNhGAaObY4gFI3Zz2Cg9B6uAq4rUtj0GzASX42s9Z2MTWkYvgUNYR+WgAgsN0pSdYE/dxEe2i5gQqq9nfuyWQ3OuQ9jrT5FXH66KIWYQXLxlXBX0uFXQnM68hc/l6TFc6mmsErKvxiECRTt0auPK3VXEkKz0fSDzMzJBwAMYYh01BmO+b36dGJgV7PtUWdJ7Zo5076kbjhmanOLYaxWUenFMv/HpBgMsscz3nhoyB+Z3f+R084QlPwHa7xcHBAX7+538en/qpnwoA+JEf+RF83dd9HT7mYz4GMUZ47/HjP/7j+NzP/Vz7+W/5lm/BE5/4RHzJl3zJB/R8d999N3LOePjDH37h6w9/+MPxzne+833+3DiOGMfRfn98fAyAq1/q14qZLEqnDQYMsfWpYvOwiCisXAkOcSRL1HRwO47iUd0KFUXbQgKBZJi0To76QY+K7njCfNQbK7Ib4pw7j+HeGWkVDAy4TADmp2LmkLApkr8GzAfeuojDVEx/paDGZd7E034Q57FH9d6+XgJX4PNhRCehvnpzrsGZ6aX6VgfmU8HUR3QF4l5lfI0vxWroqoO0c7BtgtVu1eJNwulkYdGoEsbsnHTzJiA4rlCdo3mjE+fs+YyykpWrMmLK5BWuYwEydGQWaX6ofQDAnzfgKN+nNWnhfObjVfYL8xhmxsPsRNq00GWywtpwktcR3T1bVD8gDwHdMTt6u9MZ6WglQLJFu8B7qdbjJVR6j3A2S7cx8/q64wnOc4Xr59YsMh82oOeqVP0VwEsjTREDkBc2szogrYJp/vRDhZqXNFA8945/F7zGJvGxxluCdPlWIPJxizLoE0FiM4HwZ+MWyAOv72nfoz/NSCsNof6A/glYZplllvmwmxsSAH7SJ30S3vSmN+Hq1av4uZ/7OTzzmc/EXXfdhU/91E/Fj/zIj+B1r3sdXvWqV+FRj3oUfu3Xfg3Pec5z8JEf+ZH4gi/4ArzqVa/Cr/zKr+CNb3zjA37e99YL1lrfr4bwzjvvxPd8z/fc5+sWvRLFCakVZZ0GEwPTUSSTMXJ9Su1ei9UAuCrt5Ndhm5HXAeG8IHuH4eqE+bCTOrdW2RY3GZiA8SGD6QKro/6vZn5P2BYDf2z0EPG8NIu4zPy0eL4TIyOie2UNq+evp8OAblMYaD2Q4ayeIHH3xk+Q6mwNDmFyutOMtMfcuHiWuOKceK7yEBA3on+EAia6bcNWwF6FGDloUKiriLyWFW6t1MB1LQy5AhZ5kg4HlN4jns6NnesYDVMHCUyOXLnWISDv9XASPG2NINsEFxwKIlm2/d4yGv2YxUnMqjk3ZQJQyTd0qTBqRTR1NYo5RCNxxPihJhOfCtxYgSEQnMp5UoCbI8O0dY1cvEM4mzFdYZgzZQhc0ZZ1hB8z8qrjmne/g5sLuqujfHAQjWnhBw6X6WIPY7EPAdU5xglVMRgN1Ij6XK3vmRVtBHFB9KOq3UsrZ1mXYeT6N+640EsEXOX1WR0/hJA1dBKQXiScXF3pbN6ZxEmMysilZR7Es7P3XVbAyyxzfeeGXAH3fY9P+IRPwGd+5mfizjvvxGd8xmfgh3/4h7HZbPCd3/mdeOlLX4qnPe1peNzjHofnPve5+PIv/3L84A/+IADgV37lV/DWt74Vt9xyC2KMiJEY90u/9Evx5Cc/+X6f76EPfShCCPdh+9797nffhxXcnRe84AW4du2a/fdHf/RHABjgrE0QjOMgs8LC+xZNEUdh25w0g4zFVqYuNzclXa6+mR22GdMVda4SpGmMR4kO82ForIpqqTIAD4LCnQxCNWRUhwuRMmwjCQSmphsTkOoJTvPg2VecuNINE9d3YWzRHH6qxhKllTM9GHt1SxPqe4d00CHtBb62HdxtNWmSEajMX1lLrVsfDGjX4BFPJsvf0zWtmjHC+WRgMJzP6I4ny/Jzc2ZMSmGtmQYel73OauvymtmDFr687lCFYct7nen4wjmpp7TX0ShSKvJe1wKzC6ypxI8ZbszULErProYlO6l289tZsgydNHcQECvr6eciDDNXxxpFk/c6eNXpbbOdy3mPfy/i2Wyu3LyiQ1hzHNOK16wf6RpX5zhAJpCmC3HwejLfWk2o2la9duCak5cxRs1woswgG24YM8RcSl7vuSMIbEy3AMK1FyNTtZDuLAyj/T1cNsA3zSz4b5llru/ckAzge0+tFeM4Yp5nzPMM7y/i1hACirQmfMd3fAe+9mu/9sKfP/axj8U/+2f/DE972tPu9/H7vsfjH/94vOY1r8HTn/50+/prXvOa97tGHoYBwzDc5+uuAP0xDRQ+F5wfDojnheszwJyObH0QV7CyJVl0fhNz3vKaYM5PXJ+qZsrE9IODP+fNu0bAjxLkLC5Lzejzc5UbrZfwaYd4luEz1781ONNpqQGhuuYUDptiNXFxIxovYW6oUaNuMPcOPgibFh2mQ9EWQoKx5yqax2bY0BWxmkn09eXeI26ERZPMOxX5uwJ017bMqwtcWSMDcI7O3pFgxwlYc55aQIxokSpilNColjJEM40QeBVrFAEAJ+AJucJPSb5fQ7YFXDkHNxVrJZELGPNRj3guphQP5KMeQcAXRJtYVZ/oyDDmvYh4NjPypQt8zlUnGjgycE57cyWkOR32YjyRazFXM59k1UFWoDtNkpXY8vxUIlCDA1Ilmww2eqCAhp+d/mh13+p0p8VqDbUPmvIGMnMlEBTmHV2eTxXFkZUuvUPa8xbl4qeKeV+uqVwNBJJllixJcQxvHhIRJs3frAAcSgTmeEN+xl1mmWWW+ZDPDQcAv/M7vxNPfepT8YhHPAInJyd45Stfide+9rV49atfjaOjI3ze530evu3bvg3r9RqPetSjcNddd+Gnfuqn8NKXvhQAcPvtt9+v8eORj3wkHv3oR9vvP//zPx9Pf/rT8dznPhcA8PznPx/PeMYz8Jmf+Zl4whOegFe84hV4+9vfjm/4hm94wK8hraRT11dk76XBgzEnedWTlRB2owzUPvUnvAH6sZorOIwV3Sn1gzV69NeSZQVyRUZGjp2oajIhgOyPE+JUsHlYh7jhzXw+iBKXQsCTVwFFHJxqCFCDissV3baihogSHfP9YnNYVg9jA52HrXwZW6MxNerUhB2v6v5U0+jExakrWM2DUwYvbGQtPCa47Bv4AP889wSAfuQa2E9crfot2zTquqORYs4EXKqvS8Uq3bT3tvbRvubmYq5abdDw5xMbRPa6Zs7IbOYIZxOwivCbGemWFSvVegKrtBcl9Nqbg5g9t/zzvBcRjiega6YPAAibhNIFxG0CHNfIeRUQzpOca2kgiV56kRmDE7YEp5q1Bzjm9qVCEKysnIfRKjQMCWqskrdXIe5ktBDyHpb5qO+R5URudhpkJIQ8dxBNHxByM2VUz3VviQ5pcCgxIIwFYSpmlvIaUyTd1kE7rEGgF0eJiXHOsjVbSHXL1FzmwTsXTCALBbjMMtd1bjgA+K53vQvPeMYz8Kd/+qe4cuUKHve4x+HVr341vvALvxAA8MpXvhIveMEL8Hf+zt/BPffcg0c96lF48Ytf/ICB2lvf+lbcfffd9vsv//Ivx3ve8x587/d+L/70T/8Un/7pn45f/MVfxKMe9agH/Bp44wRbKATI+bliOuzYtOFE33fWbmx6w9IMQK/MjjBhXls5qq51eeMb7p2R9nhX7E4y8poAStmz4d5kqzS6gaWNRGrcAK7znOi2wrZQB1iAklt93bwfaTpJdPiGbUV3ljAd0VQRpoLSAajOmkC8/IMdz6XxY8VoGK27AyDP1RjB0lO472bGipiRRdlIUA9ZhoDkBuswrrlaTy2iQ3ER2GsZfbULKK6ZMao4bWsXUPqAeHWGLwCkjQQe0maRkQ56M2no47lMMFc6Aqp0OCBI9l44T3DjjBTXDJKOEpLsaguHjp56QxCYusLVNgDMV3quWx0QzhPyfk+A6kRT2ns5P4yCMS1kJfOna1w/ikN5L9rd06XStIVzbWvouSDt03nt6k5EkRg64nmmY1v7jaNDFn2fdlKX3u2wf5BgZrK1STp541YYRFn7psGZZCKtvDDSFXHmhwsvsS8AneSjaE6VRQxzxXTkxZTkEGYgDQ7DvZlSiLSghptnlvdymWWu59xwAPBf/st/+X7//Pbbb8e//tf/+gE95v1VCP3hH/7hfb72nOc8B895znMe0GPf7/OJO9EVOnLJejCoNsjN0hnzIjfUDhiuZaQ9LwJ8WAgyNWkO1ZEl8b6iFt7M0z5vct2JdMlqyPPgUCfHmzoaKwfwBh/PyQh2JwnlIPL7HS6sdv1UUAaP7jhhPopwI1+XT6rpo0lje2tEWrOyK54X6/4FqNVKe4HgcSfDTQ0lzgPDeyZMt/RinKjyHBVINKUoKInnGUm0a0Ey/qpUjgFo61ttK1G2TYCVGjJcqcjrDmWvtzVtvrKiA9c5hOMtyrqz6BatYtNAZjVklCEaA+dKRj5iLmEJHi7S6FEdrCKuDoEmlioJLRJB4wFMtwxsWpkywugRj0eLkEnrgFgqo2xktVr7QDdvyYygmSmMsziZEJD244UuYmUBAQhg50rf2OTUrhHNaNQ2m9J7RHFva6SQTxXjkUcc+b6rvlWvXzi2xdC927IBg3x/Xnl05/xA4DMwrRz8pnVFK0uo7PS8R4BomZmdHgcZx+FqxngltOu8VNQlBuammYUBXGaZ6zuLQOYSJoyAZuPN+0G6cB26k2TaLO1MHa5mxG2RvlPWplkW3+DNDFClNgvg42oQdNgU6Zt1VrHmJ4rp1fHLOjlxCydgOuqQVkGy+QIz+XLTV4WpuT9RgfkoXuh7TXu+9RvLzThuqsSvkMWcjoKtgeFUyF/ttWg/cIkO40N606b5zGy4EjXiRR5XMvHgHRCcAUEnkSVlFSQ4uFp+Xd7v5Hw5y7ArvcS3jImPuY4I4sDNez17ew+o69ToGJdZ/aYBynyg0tav3rFhZEPDiZ/pxNWaOzjHmjgAfpPIyMnjh5GgKsh7qyHU6WjYyS+U1hTAAJyfKSvQ+Bu9O5ae54k6QicGlx3TTeftg4U20bD2zZvODhX8l8EBaeWRxbxjgeESsKwOcgDtg4voCEtkT3RatbYbvWbS2vP6kGtBzR39WaEb2EsFoa6RJRhar7MSYe+nGkJKlKiiuWK4ljEdBZRAhnGZB+8soG+ZZS5vbjgG8GYZJ0L2KJVW1UvlWriYi1Z37k+McSkomt8muWs+sae39N6AVBVB/XwQxfAR7HlUJ1WL9BBXGkrSPsGEMm+o7QbspCIubquBqNK3Ht9um5DWgd8v4NMiYrKaHbj2c7kieK4RtYbOyQtVJpAsY3M9q6kl9x7dKZ2401GHsKFe0c1FOn6Z3ZdXAd3pbK5WVAEyzlvVWTibUaNHPBlRBfi5wrUvpIEDtcJNCXHDXDxEmi/CeWKMy0yXbbplZXl/1LgJMzsIKyeuYVdbhh5fb6tySwc9A6bPZiBX5IMe81HPHD/nzOxRJOqmSn1aPGE/MCvdIOYh2HlLh1FcutlWx9V7MQO11W+Jwcw+1O1JWLmww83p3a4HL25in2jwQIVF/cSxIG7RQpt3DD3a9azmI7rNvYH6sC2YD4NUxmFHi8ifzYO3ZpwiAc/M9yPQzBIFA7AHuAYgDR5RPhDEbUFak51c5uaY5Z1cZpnrOwsAvISJ24q8bqJ4da3OcqOGgCh1X5LBg92E/byj09JVYSc351StYcNPop2rvMG6VC3yRdd+2sWrwA1S96asjAKwUKrceJ2BKnVmAmzkcLlaTlvpWqhvd0J9mLaJlN5JhZhDdQQiCgi15ivMoCZPQaTEmGimXO7ZfDJdiZLl5uF8WyXG8yxRLc4c1Bp+7SvDkhUUAkA66KirrBWQSrO84go3H60AALXzCJsEN7H71wUHONeq4WT9W9aRJo8Ifq8Du4K173aTmpYQbA5Jh1wPQ1g552jWcCVIT3AAVgHxZAKExYvnM0rXC8gsIgegTk8NJi4VW9citEgdupwd5j1+v2XwRSAH1VKSXU173s4jwZwToCfNHlNtHwaEMdRV9Lzn4Kq7KDFQL0kAinzSCaOs3geydGXQrzFCqASCzbgRE8gAC3weriaMV0IzCBUaQNKKLKMCz+6sGIDNg0eYKpYc6Jtn7k/Ks8wyy3zws6yAL2GyGhlE0K5ZgPGcblKL6CjVdFg+cXWrqzuNYynRsflDS+3Fhavr0niWETcF8YwMYek0tLnsdM0qa+Uu5BCyTqu0Zg+5oWo+YNxk9rM6skUan7KbVagO3nieDczl3pl5hTUY+lqdmUoArhc1E5D9wHxdtvp2zUFqTKnUxdXY1uRFdXWBa0wFKC4VxLMZtfOIZ4mZdxDnqgPCNjG7T85TPJ3Jgg2BK9tSgSKaP2vyYG6fATA1QOx1fG+dQ7oysJN3CPDb2cCfnzJK8JiPeqSDDvMhzR1hzKL/k9iZqVgbR9hkyeUTILsOLVy590j7sRloxA1cpEM393SOO9GLouzEDmmkn2/Xon4tnmfTqFYHi27Jq5YFyfNN/V13Ju/V2KrZtJeaOYFuxzjEzuSsbnZhySGmEUDkDsI8x03BvB+kU7tdt6VzjBVKzUDlasW8xyiZ6nnsYVpAw4N5lvq3ZZa5vFkA4CVMCbxZaT4dA4mrrVDjNjO+xAHdyYy4zYhnGd2Z8BWSn6ZASeNeADE41MacmWA+qM6LURlpP1h0hzIneWCmWh58M0pIN7Cu7cJU0Z2STUzrYAG7yiqWwRuTQ5DCx58PRNfmnekZ43mRxge6NOd1cx4XWQUrQN7tIZ73CHjDtnAFDNGBSVQJDQzCTsmKERVIhxKOLR2+1MI5IKs+jjVmNTjk/Q55FakVXEU5596ABDwdw/mgR1kFydGL1sqBQnetfj+dwdRIWvgxgLzuEM9mlD5gvmUQ/WOr0IM5YmUV3nmed+0w7rysX+k2ZluLfH1iI4qu/hnO7BG3omkcRBc6Fa7pNT4oOPtwkgePuCk7LR38mbRHhtkVArRW+VcNML+3gz2tCOgU2IeJK/24FdAnADKMBd15QXeW7boMY0V3luUDAUGnajfVVRy2rfHGPhyp61jCyV0FujPqan1usTHLPPhngYLLLHN9ZwGAlzCuyMqtwhguV6qwNrzBMuC4Ig9B/vOYDrsG5JLGsmR0p3knzNlJNytvxigNbFQnjQnbYscBiOFiJYBKwpg18w/g43jJaHMFmPc92aV1WwWrlkzjZLQLWMOlw1hsFafGDZfp9nSVILE7Z01XPKfphVZYAA6Y95rb2acq5gPfDCEWE8Nz4uT8WKaikx5jMV5owHONHrXjGtaq+CpdxEFq3bprWzkRElVydcvH3+/5OCOZWzaR5BbwLIYJt5Pt50qVtbATtq/DdMsg0SrUg0Zp5GD7RrSAawOBYj7Zbd4I58lY1rgha5j2gsW4TFekJ3hoQFY/JNRAx7bGr+iaXs9dA3XqviULl/Y98uDMpassMgDLXywB1vpSOjJ93XkRFliZ5GLMJN3fju+T07w+MoVJNIZaO9idsePZz401zj11sq60XEBtCombgrgRECsSCdUiLvPgn2UDvMwy13cWDeAljE8QZikgnmaaLzKdmyE1cFSiM+CSBzZ0+JlsHCQqZT4KJpLnGlk0eN4hHfAmTIbGmfO4ptaxq/pAdXaWqDdcZysyP1MHBkj/qgY8V7S8wMrQag2eDiMZlgIHxBZnoy5QjXzR0GjV44Wp2ooOAKYDj9W9GX4WLRcqpkOPuCUg0HgRXRPH80xjzFxROmEl+9Y7GzfZtGMA4Ldk37gWprHCb5ip5xxjU2r0ZOmih8+Fhg/nrF5Pa9L8XDA9ZE3ALODM1YoysKElbBKQWqahnzIfb33xr9musaN2BKh+5jVQ4AV8BfjRYT6MZD3HgvkgcDXqgVwEfAtAZtYkjRaq3dMPAK6IHs8rY9w+mNQAPm6qxjKzeUPaX6QbunSwDxpxpnRAnbklAh4tmkW/Dge4JA7hXIk3IwGbT4DLzoxA1Tl052TGtYpwOgqI24Ky4uurkaDPp4rpgOt+BXiuVEwHzVnsSsV0GJDy8hn3wTy7oG/RAC6zzPWd5V/HSxiG46KxZuKCrHpjlDWbq7D4DwLBBrTgmZ9XAhkYGiqcMV+ukLXrj1uwsYKgdBAsP09bGmpwSGsvrmACRGCH/cnVRPmqx3K56cL8XM01rO5espJ053anydbTAAFHWtMYovEgqg+jCcVJztuOblBYpCjB2aodg+MaMkxScTd4AiQFWxIhQ3exszVq6T3yusN81COvAg0YjqvVKgxWdzLBpYL5qEft2emrRpywmblOTsVW1WHM9jWA7uu0xzDsvIrGOnIdHFCkT1izCNVskdcR82GHPHBNnfa4vs0rce9mRvRo64aCOgu+DlqzpsC7WkRLHvyFDxl5tevAJpCurkUDKUuo69LuVAwbEuGSh8YcskWEPbzGAoOObj8153vY7rjd0dhDcwcLo6dMJdCyB4t0CvtUMe95YTXJ6lWRNOgHiO68wGe+5k4c97lvrxeNRF1mmWWWWWZnFgB4CaPNG+rKDVuuall7VhE22VyR835k/MqG6664zQbcAAK1eE6NVpgK5iNh9bYF/dXEVg0HWQtrNgia0aRW03BVx/Wusowa35L2vBhX2ifstHbmHtaWhzAyviNsswRGMz8OFdg8rKcxIwrQUEG/aAjDWMx9rCyOPr/Gjyg7qYaUbsMoDz/L+VOGSkwoaS+IXo6ZdvqfrhFdqgxDTtJzGz3iuUSwdB7TLUMDhxBHb612/ucrK0xXeqTDXl4MHxOBTtvSeXY12+qbwc4uFWEW3U4ECiyTr+p5dczw0w8MXkB42Cag6qq3mOElbAtQ1AHNLmd15Srj50WT53Yc0GHb1qu5a8yvAskwq3ZU3vPohMmDncswXfyAQO2nk/dXPjBUYQZ7h7Sma5hdxLx+rA1kQwdvGZxcSxIBJB8Y+mvpAsDrzilB8AaEpVHESU6hyAY0YqgTp7qXNp5lbo5Z+L9llrm+s6yAL2Fy52w1150lJGGflP1QULK7ukQRNqbz5oAEYAALgEWupHXAeGs0EwU1UgV+ahlqu6AwD9RNqSMyrb0ZO1jfRkCQ9gOr4AaP7oxsSlq3iJC0d7EqTsFBFQcoxfwEbbUjEPZJnaf6fM5y7MzEAf68MlAuVXgNGlZW87bOmEdbg1uvLB8rTKI10wgdMRGE3MB3GQJyp9pGOqfZ1kGwaAAMBELKWsIDbuJ5LsWzJi4XFHBtjAILV9YWlHimnb3i2g00KUDaSxiYHZnxKC7vOniLuvFbuob9zPdBGTYFwKVrgdxq/nGZWjg/0b0M5zAdBWP6urNi75NLjp3VqgUUl7CrErjcqRkJlmMJiLv4tBhDVx0wHfGaUcd2mKoFofcnGZgqwkitZ5j5+AAw3tZZtFAYRduq142GoSd2/nrtE46QDw8SOD04a87xqaLWdl3Es4UCfDBPfZ+/WWaZZf68s3w+voThTTgRQO0pqhF2xTnETaJxYkvAEiXsmI0GzfBgGqcdxog/l02wD8DAlP2cRKiUjuAxnjXGTkFjGKvptLa38Bh1zRi2xdo+tEXCZd6gdT2sx6UZchrhgkLGqTsX1k3dxdtiRhgAxpqV2Fbl1B4SlChDGLf82e4sG0sVzxJBW2rrRK0s4wupxsLGbasv2zVHhG1Gd++GwdKgXi9sM1wuyOt4oULOgJGsdaGPJ8yjxq9oXEuNntE9GgjtQCeyvk/C2rnUQsJtbVvaGr0EefwgGjgB82nfC1hqrl597WqqGG+NO7l5Vdg5CRCPwvquva1L1blcg8S+DOKGrsq0OWxvDUhrgvIanKxiyewp86hB5CWSAexPsmgVeYzdeTMLAbIuHotIG3j9qSaR17J8QBAAa73RsvKnqUaMR0Xf84L+WN3R7s/713mZZZZZ5qachQG8hHGlYry1h5+Y06e5fozcyMjS6FB6L47XICu+LOs+rq+UAXPiwCy9Y4NHJGDTmA6ggb3SCRApAIRNKVK5RibJtYy3QECqRhA/Z3MpU0vlbZ2IUOG34myO1I8ZEKytHQRoukL0ZIK6syTrWo+wVbdxtZWoTzDns7ZFpJXEh2jm30712HwQTRuYpWdZXaxcu4o71TkLxI6bhHkv0ombucadb13zPM6V+XtjJpM6F8yHvVXEoVb4MWO6bYV4lszwUTt93mq5h1U6db2s+KdbOq6U9yNqIBjX9TFjXcDWkm1jqjTORMO+VTfpU0UVLZ3Gt4wHNEqklUccC6sBFfhVYV9VUiCu67ip9v7117KFfau5x2UBiMExmiU69Kd8n+c9bW7hsWp9XH9SkAcBqupKl3OhIdJ55Rn+PfJr3WkWZ3VBudLZGllX2dqlrO+/OePluveyXlapreYJ5t7De1k9LzEwN80sBOAyy1zfWRjAS5gaeMMLWzY1eAlaVtaO60jRf2Vlv3Z6WAFr/1DmcN73otmC3GhbO4j28+7mDiqQzCtnphEFSd1JtkBfn6rVZemNW12naeV2jg8Wa2MOWIltUaF/DbxZpz2P8dYo+rWWQwjAtFpZ1reqB1QAmcU04nOro8sDDSwGAlae2YJT6yAGhPmssHgR1d7RxEBjRzpgo0SJjaHzmSHNeR2RDjp2BOt5XQVMV5gFSHduFOdxaOA7cB2swdxBcvemK52shp3F+QCQlWs17WOWHl5tQNFz218jO+mqvP9KJucd9lVYxU7W4hqCHTfF2FxX+WHB1syBRg89P02fCGtl0TgYlQBo7MtwLRu7mnvpkJ4r5gPNmpQV8nkWLacXUEpdoUb2uEIN53QUMd3as+Kt8oPIcPdkOZllcJapyfdbMgV3HOklkoUsOyHmdt0uG+AH9Swu4GWWubxZAOAljGWqVerK5oMoK9Jq+jNlUKrcgMvgkPYlrqRotp50voq7NWyLNTkwI5BByax5Y0wGAKmYI7vkx4qwKTsVbVxLMwT4YkRLliBfl0XndVLY3ACCmHmfjtXxtu4Cs2QAbKqmx4oSIaJrVAYAV2PxXKXuL57xNWizRHfKda/LXPFq20gUhiyLwUCdy9Z77B2mKzzPNTpGmEhOoTJHrsLcqVUY2Boc3FRYt1aqaOcIsIHWluK3NGTEDdlMdjFTY5dXgREyGucjgDiMZBODhBLngathgMHWNG80x7S6dDUHTxs/5gMvsSngenxWwE5dnJ/FLStgvPQO877kAx7xBM373lzDPIfe2LkSCOqjBi13HmnYyRGUVg0zmOysYXXdqzo+1SM6AeL9cTIZRBAt47yvgeQiiwgwQ1DpHNtNIqxOUZlcdTPzA0rF9tZg79FwLTcJhTSM0LiygIabZZZ3cpllru8sAPCSRjVOec1mBo3zqMIuWTfqmutW7Q22IOWdn6/RoT/NrbZNa+MCa+KYt1bgxxYHU93OKha4EIehazbNg1MGL26Y7ZbWyrrIStk1IATAgFcehN3pZJW910Cr1tO1BglhDIUJcuJmTfse82GUrLj2nBqHU/q2Bg9igug0XHqnWQSQlXiGtYfETbawZtVHxk2Cn1lzp0zmdEsveYXi7N2L0JBkXd2nfaLreY//19DmvHKWk+jn5tjVn2UziLR0aDxJbA5ZXXdqZIpG2XD97jHt6OFq4GscrwQD/RrL4hN1l34k2xy3NE6okzfMbW2qa/z5IBjAG2+JXAFPzUGrlXJ6bOyJ5rHpdahGIG0AyWJaSmsvLGik/nDL74kbAk0FfFkYUGXy1JmsHzA0gDv3GiINA6/9SZEVdDWnsvZZq5FGr+1lHpyzVMEts8zlzQIAL2FKcLaai+eFIv2ezlFAYjYGjyysk4rp5z0vuX3Oun+1zSBsC6Yjgg8/VjOC+J0IjygNGawRo5kirz0DnGUNqLq/vKP70liStPLW0mGxIGDXq5+KZQPG84JOXKBFM9p2zCBhUkDjrBXES3Cw6rTCtmA+bGtU1nxVC72uUdaWWhlXWr6bAkhdoWqgMTMHCS5qdOJW5rrUTwSqudPj9GLkcKYlc6ViPoyWNacaTIiOMq9aR7ECFj+JiWNFkOgKnzvtt1y/PHjTwfm5WsAy6+aKNa64JK/dN9dttHw9AUwrZ6xfWrtmjqh8X9NBEGOKtmPsAGTJ7bMOZwVvUKMLNX76AYCGjSay03aPuOE1DecsQLr0ztb5Sa5jjZ6pjoykT2TkpsP2zw6lEMU+kDAaid8bz7Mx5Ow2lrBpyclseZUwOYQy6Pp9SxXczTPLBniZZa7vLCaQS5iQKo0IkVEgWjGWB09iSfPWHOBH9ryyJswjrRz6k2IgoEZgHjx8cnaj9BNz0dLQGKPa0z2pzRnxLJMhm6rFuWgYr0ar0NlbjRFUPZjGq5QAhAxrNSmSDRc3FO6TbQQclLmUOJMKWycDQF7FC9Egcdu6fNX1qg5S6uXaTV1Xw0mjZ0DDgQHZlUORBghXBIhJg4g6oWsAUAnCwtZLXp86pquxRLqqbJEifIy07+zxSyer07V8bcIFt6mT9746wJcCn+S9F5d2Dg4YYAyjF70eAOtuTprtmJwwagRc6uIu6rKVXEQywOIyFp2oSgJ2u3JLR1OHmm/yQAOOl+YXZQpVD5hWDeSlTnL1IMedK5Ab+DNnszjM7X3theF0DYyFqdr7qedf2T0/UwZQBof5MFzQDPpJOqYlogaVTTLdhhWDygDyvaqMr9FztMyDfhY2cJllru8sDOAljeaZpYPOVohFOmm1SxcQHZqXjtuR7Js2IZTeoTvJBpjS2hPw9N5aQcKY7ebuJa8ubNlFq+BP+3V1xZxWzGKzaBYBW/q9AG+2QYwDZfDSwkGgSO1W01oxELiBJJ3dcGfexEWLl2BMWJBeVxX6x00R9q9YzV0JztgqV2QFquBP2C8vxggnETCqsStiVCgddYG60i0D15WqA+RatqA7TRKZw7Vt7r110XptIuk9/Mg1/CyMmxdAXHpq3Fxhldl4JXBNK2vheM7VczwjMpkPAx9j5Q0Ixq2aW+hstXw7J7pCMREpO6kgSt87du/Cjps6Q2owZ4n3oYmiNa4oE5iEPdTrMEzFrgXNX9x1gGutn77v+sFFWe3cNwaUfdferpvuNLeYl01zy+u4LJEuV5M5rbXasDqH6ZDXcXUOw9VsrPSuO3338ZZ5EM6C+ZZZ5tJmAYCXNE5ZIWXXqorcva0QgZatp3VtfqZLOGwLuhO6hF2qxmhFcZKqqUEjZfRmrq5TumYdpsMgIvqmrdPsONVJqWZQTR3q3gWa+WKSTmKfG2OlLlIyb87WqADX1Aoqwrb9ujveuZl76tDS2osRQY4/OGMv4bQho1pOYNwyciQNogtzba3tZ54rdYs6A4ZoK2Hgotta2LXSe8wHsQEby/aDrbLzIEC3NsCqeYR5JW0Xwjyq5k7DvbliDmSHO4/pMFiLRe7UrQ3L6zPTw0QjiZ4DZdj099q5q9eA6jpt1Vva8WvrR3fGNb6GfheJu9H3W3MDVbt5AdirbvCo7Vdz7yTTEebozSsCSFd4Pas5BGjxMRoUXvrGVmstYhQDSOl8Y4Qz19Q1wCJn+AFKpAjyHpeg6+AFQdwss6yAl1nm+s4CAC9hLLtNgJmCNQYb05ig3bIqfNcV2PbWAPjWh6quRtUThrmYW7R6Ojg1DqM6ZyYEV8X1K2tXZV5K59AfZ7l5guBz1SJW0to1fdtO84OK+MNWAVRjZPQma07hCBPy+8QcQD/qSpCBx1rVFjcEutTtwTRcNJc0M4CaUlQTBidM2bZYbV13VjDvE1Bub2NocemorSyxmV0AmMs3r4NpHZWxBMi8ac+xrqvzmppFc8YK/slrT2ewpw4unjP2RJso9PtK7zAeBjJX28yVZYboHKuxlNXDnNVmHJF1eRKNHs06ZNa0ao3MF3t4Te8ZLpp2+FhkcefDYEzZbs3ernFHHcOosHBwaiQFCOe2dtVwcdWb8slg51ZBaSfsp35QUVexn8tOu4szDWYz8PCDSXfONpj+JFtgeBWziALzvPYG/pe5OWbBf8ssc31nAYCXMKXj2pSGAG8dpursVAfrfOBbZEvRDLlWwUVtnGrXpFEhemF9eMPkf1Wq3oq5jRX05IEAyGvIbhYNoawPAV0VwlZnqmfT4wiygo6bDNRqYnsFKgpQNXIFFVInJhq6FUGtri9NI5fEIJJrAy1Rg5ldc5oKcNC2kyxMECDGlU1tzlPJGQyyttQImRLRnKWg3k+dwBa/Iu+DxrikvSBhxrDYHqu/E4CrK8+0EiYqOIteiZuKtE/Gt0Ye/3CszSTeol4075FRJ75V+cnKe5bWDuv2FSYtbFvenb7X+qFBA5EB0UXqGj+197y/lhDGIu5ecVcLOPejGFYkRiWtHXLH7wkC+OKo1zXBlzKGYSyYDwLCVj78iFFDWcAiFXvqwtb4oLTP86ZaQp/ImOr701+d4aVyUD/MKGut7LeufdUcpeB0mQfn1Pf5m2WWWebPOwsAvITJnbRBzK0PFWAsya57tBN2qAbwhq0MU3AY7k2IGwkVlqYKsj6hgQaArRJR2ZVqzztcy5YFqHVqCvDyKlgmoDJzYSrYPCSYFjCKPk+ZH670/IU6NT9Rc0gWSde9sq4UvV3YFHTniau7gyDrWlhvr4KaKm5fXR1bFEp0jLcJBCHxXB2jBIa79WYuV8xrZ25TDY/m8TbgpqwZo1kEUMvj6Wpa3bjWkavRLvLeAgS5Ck4tWFtaO5ruketZfd9pxCiW8UfQLmAli9NZgHruPea1t4YOC3J2jfVTxnQXgPkkq3QJdk7iAtdmF0A0exK5oj3Ru8HUWfSm05E3zWF3LpmSOx8SwiQfHipZZjPXaAOIML0qc8gricCRDwJ+Ft3qSOZU2cr5UJpjxmLXlGot2e5SzR1ta14BzapxVKPNMssss8wy953FBXwZ42TVWZXxUIcmjB1T3Zzm9rlUgQgMVxPyEMxVmVehsVI76yxdh+beS2dr0xEqmwUUW2vmofXH1kBQwugUaZMI3hgdv9PsEM+0UUIMJHsO8TxLMwSPxacKnxziaebxav5bqajZoQRvwNJ6g8FaPICuWucAOIfuZEZeBYTC79nV7CnQjdIsoSvKEoC45XntNrIuTbUFGffCbkmLCM9PMaOInyvSQTDQpw5gp3pJDReGat281ddpf26U1bhLaK0cHpjXDthz6E8LV72qS4RkPMrqmvpBXY/rWl1q+nLFvB/MBa7HWLrWwdtMRU7Y2gbqYq723qv72+0AVV0NK/BXXaGCcv2zEiFtJQ6lE73o1EwkcSMaRHEFx/MCSEQOH3dnJSs6VL129dyXjoDf5SY6rNGh5soPOxIoDkCqBYvU/5HZno+ixSb5HZZ7mQf/LC7gZZa5vrMAwEuaEh1ccmZgQK0o4oj0qWLeIxOkWrIqK+LqHbqTdAHM0Q2bkVcRDg1opINAICftIKVvuimsuPoM24p0i0eQVa0K+g04AtTPnWTm3FWCpnhWLIgZAFCrGUu4xq5wSR5H1nV6vCb0lyxBn6WYuDDcub+WUAI7h7XSTpmsvBcx7werBdsFN8O1DFTqJIfj0jSDFRJPAyDICr1vzllXGmNGNhUGGrRRBNjpXS4CFFW/qevIPW+uWjKpzowWWm2nRgjVCYYZppf0opebrgT0J5lxLp1D9ZQFdKfFgHLuna1s88Bfa5MHXNPb8b2BaTY1BkjPm09kzuaDYBV/gJpT9AMI7HxndaXLytpVwFfYKh0gE+iKhH5HwG3b+625jBpRo+tZZUQ1lLsIcA/zfV3Mlo+4HyROhivzeJYAhMY+iosdostMB6EZYQaHmhyyW5YcD+bZrX9bTCDLLHN9Z/nX8RImiIMxjHSY5sFZxhwA0exV64it3mE6CNTaRWeGAnWxulKR1sEAC8C1LKA3brIraeUsciRKt271QH+SZeUKcVU2ljBsimTGidB+W8T1Wqw2TXt6/VQx3DOznkzCfulOzWz9qEB3PJuGjgwbMB12puvrryZMVyLyioybrpWnw8BYl65V3u0aYDQ3rnQOw7WC7S3B1r6qK2S1nbiDVY82NYOKy1wjG5tYG5OmrFpe7bh+C6NKtIs5jhfX1lwzO9MxKmMWxmoaxO4sozsTM0nQXD9gOggCqqqBsNJTTzdeaXo/e59ltdudsZ4vTMVW0n6uxvapwUPZ0llAUZBAaX291kEszJ6FREuo9i5gLfIxMQ/MWJzlmDSfUR3Afm6aPieNI2nlrI/aYmrOs6xvYeYi1Viadi9VdMepHW90GB/SWci6tsqoFtPl5gRPe/6C1nEZ4IUvfCGccxf+u/322z/Uh7XMMst8CGdhAC9hiqxZdcXIlRUZNI3F8ImfaHUFqQxJPM87+ioCDsiKVIFGWrfKruocysoZmMidQxzZg5ukNaLIijKMxSq69Kbqs+QC6lpttVPhVWDPs1uNhqqOW4/uvBqoLL0HSmAXsLwOZvI5+POCGng+uhPpbe28BWH3J7kZNPZ5PC5R45Uk9sOOOdH9q6vWJHE21NBxlT0d+QYARVOn0Ta61o1nBXktK+C1R+21s1jeP1lzVy9xL0Vdr3wszQhUVne4munMFfbPWMPdKBUBx92ZuJcLEMdi6+zurDRmFkD10jTSSyh2R1DlClgPOLI5I4zV9HK7sTzxvGkHy6CGFq5wozitqUXla8w7HcAaT6OsJNCihHZrAbX3N6+9MZq6Th7uTchrMXeIaagI0PQqQ+h2pBAClONc4CBubfkgVLMTt7RHEX0lNYZawce/RMpMogJuWgCgzqd92qfhP/2n/2S/D+HBVZOyvJPLLHN9ZwGAlzCtWgwonazw5AatK1U1BOhNWN2zzI9rzs4aGFCsP6egQ00JNEeQVeqPWemg7Q9xBBtBBODllZPYFG9NERrVAijrJazfTrMEJEokr6RWLoPgrPD/egP3c0XaD4x1EdayikliuhIJMHov+jsymsitbg1OHaAQrSTPZ9gWAF4MEjtgSBgv6tDknAaQ4chtjRnEZUoWTTV+1arjNOsvzFxd5r6th62tBC1suzqHNDSHbXVcZbri7DxmL8yUVJ2pEYjvoUPc7rCT0cGLoSSt+Wd5aE7Wec9by4WfC+I5nzdseT7jeZHfq8zAGTCtgTpOSBOH9lCzLg6mB82DM4ez6uy0l1eBtnY169jKFu29MN1lgVXcmT4xap2erN1r6xUOm2xSAD62RxjzzvfuaGbFsBPPM6+xPX7oUuaV0Tc8z9PhgwvkXObEGB90rN/u2rcuO+Bllrmus6yAL2HmPWd9rABvjmnPW+yFavbimTByop3S6JMqwcTaPqGuXWYDOvu1acHmln+mzlR16aa9IGuyls1WQtOXkYmpdlMtvZPVGox5CRMF9Rraq3l0BFGikZN8Qho0dlaY+95WrIzHkdBfia8BYCHN+hG/P07CoHKta6yT6N7CpOvUBpB94tf4gNIbKzo0jZshoG4mDNXubW4LXFUKM6UASJlZ7bKl4URXqDx3w7WM9T2ZJhABUK6SqXWVWj6NrIE4VoeTLO0njOhxRRy0qoPU55Hj9Xq8VdgvOb9sMqFruT9O1L1ZnqOaXVpfc3eSheXz5p5V57Kee2WfNdZGO63T4HfMGu012RpXAHOW9pAwNrdwkbVsi/QRc8pZRneW6TZ3Wtvn7Botgf88aW+zThCGW0PVUSEMrTx+ajmFywq4zVve8hZ81Ed9FB796EfjK77iK/A//+f//FAf0gOa5Z1cZpnrOwsDeAkz7zn4e6oBH62nSgcBfqTD1ifw7qk6rlQRNnnH9UstYHeaUHTN5glMdtd0mnnnCm/sGt1ijEkQ04Voz7TPVxlIZdPS4LC6N0v9WN5Z6XnU1FbUakboTyTSpmdAcokXWxcKWkixRpgos1ZCYz7huJa0OI/MeBY/kXEMU7HGEltLSsB16RzCeblg6AgTn+/s4RFhgrBqLcokbgpz9XqH/qzAJ9hj5a7CFdVP4kJANMRooiCzPy1IK7JocVu4Fg7SvTtXpMGjP81wA98HdfACkOYTPm8ncTndGcHtdOjJuMmKM0tFoAZaAzyu3bXtdBjMyau0qYFOMFrHVTKyrjZQqzmGrjiJaRHX8VQRxLneqUb0wFsLSpikrk8/EChATUAE9aJ54IeRGoBanbGHGiruc0U8T5iPeutVjloH17kWwB0bk+qyaFVVYqCmI9H71UAHsbLlGkq9DPDZn/3Z+Kmf+ik85jGPwbve9S686EUvwhOf+ES8+c1vxkMe8pD7fP84jhjH0X5/fHz8F3m4yyyzzF/ALAzgJcxwrVq2n3a5AjAHZJhb2HN/Il2+USJftGFDNXfG1lETl3tGshjbZaBOum4HjeQgAtC1LNdrGpUi612vlVwV63sSqubGrT3GW2ILd9bA3rlVeiXRe2m2YDzPkqcHM3BoHt9uR62GVivD2V9NPN7T3Nbaccfssm41amYU2On9BagB5GoQmPdd0ybK9q+/lq2lY94Ppk1k2wRBznAtozuvwnw5qzlTk0TcCricKuNyhK1T96qT8GQFeVqJ5oXt6k7b+xw3BXGsjcULDYD5BGMSWxg0XdquCmg8KzT8QEwe0pwSZMWuq18/MVxcH1tNQPpeKshk3t5Ob7BoHjUncjdWJkxk+eZ1O+605+WacJj2vZmA/MSAbxpUYExdHhxQKjYPX5nJRSvf/MzXESb+58cWH6PvGa9nCdhWZ3vlta3/oumHLgWnH+7z1Kc+FV/6pV+Kxz72sfiCL/gC/If/8B8AAD/5kz95v99/55134sqVK/bfIx7xiL/Iw7XZffeWDfAyy1zfWQDgJYy6JjXLL2wbgFJ9EqvGWr6frmE1VFjBTumpm6qR61PL8asNUPmpisbPI4seb7ylYwyM3ED1JqpxJcwFlAYOXdVZoHQDV/pnGi5M127LYqteGC1Zn7KxomnF6JKFuWe1WkwbP4oaLSIfd7w1YJIMQgV9yqwBZCrTyiMNXGsnWaGGjTJicpdwBG3deUFee6C2pg91+aI2HZ6yfd2ZNFXMzZDQnRXJOpQ/21Y7/3qH2t4WpIVDjkmAh57f8VZeFAr8SxBzznkx1s16baPbcdfyaxaiHRRcC3O8G4Ys58qVVkenTTLaouLnYuYJXjfFmGSVFOTBtZxHWadX5zAd0FhUIplCNX8EAb4ayaPX8ngLawFLx+8P24J4nk3r2bSBDt1pgktiXtoLBgjtMcVRb2Hncj0SyDr7QLLbYlMjzHSzzMXZ39/HYx/7WLzlLW+53z9/wQtegGvXrtl/f/RHf/QXfITLLLPMZc8CAC9hsoCe7jTzBiirTwC2ktRRl7ACLdXqqW5N42A0I1BjXlSfpY9VdxgkOlcJ8qajYAYNgEYHbbfgKpps3nTghckjcOh23KPMYmu9tDxuNLAqz9daPeT/ToCU/Hz1NKrEcwInP/Gmvqs/o1mGwFAbQZglWLGrIXNVI1ekbm7fM7IFYhKRdgwFURpJouAHmp248xqVdQoTo1b0/arBiUaQrycPDvNa9HmiPezO+SK6UzJncVvs3IxH3kBd3DAQmmHPBIu5l+YKAanK8oWxRbDo+UlDe15jRKfWl+tnrkT1XJXeWbuKGl7CRFOKM3ayWF2brstLhGUKArCVr7rNu7NizJvqNM1MJNdU3FQDsLrWzcLWVsmr1GaX6Uq0n2eFIsEqnEMYs70X+rrsA1JUQFosfqY7zWJUag7xZS7OOI743d/9XXzkR37k/f75MAw4Ojq68N8yyyxzc83yr+MlTBirxV3omszCjnPrxNUVYh6c3ZDVPABA1l5VuoCL6Al3gM3grG9X16fxPFuGnRongriIi/Ta6nosTNXWd0GcxXTLMhqmv0ZxVdrTDEIC0dw1xiVsK3rpt1XXahiLrY/7a6nVno0NqBD0eLnJN+bKFUakqCtU69FcJngkuKrCbmrINsycQKYOxt4pqxY3xVo4lM1DpX6vOr6O3HuusP2OPrJIm4droNsnrtGT9NwqIAcIRJXlpPvYI255PcRtuQDSSwRyz5+L502PqD3Ofq7oTxoIc5XrarK+pV07BwHTYTCwU4OsZaWlQ9/76njOUdg4U3qH+cCz51fNNoCt6Of90ABc3GFXQdOKVtJxNUwQGTfUBfYn2Zhb7QHO62AfctrflUzGUq5jygYKUKoZbmh2IdOLsvN+i+5Ugax+aNIw611N6of7fOu3fivuuusuvO1tb8Nv/uZv4m//7b+N4+NjPPOZz/xQH9r7nfde+y5O4GWWuX6zmEAuYYpkAPpULUwXVW7a3kmZPW+KaT/IGotuzRS81WtpxEl1TowEbe0aN42VUyauky5V1YUBsDgQl6tk7zlZ9dG44KfCNaEECqsGMYq5wuUKxBbzQpC2I8r31HNpfIhO3BRUB8wHkRoycTwrY9efNHPHe8eLuFwxH8XmUM7arOEZVC2MqEdFDs7AqQYpRzFWwInGMcOq1ABg2vfWQKGauLwiSJ0PA1AJMnPvgUzNX+4dhqtZ1rzO9Hi7x60sr2neHJAG6hHVbGM9uhXUAQqrqx/FiuQ4VoltYQyKmn2K/WwRMwXPebU+3V22tohZhlE4xeKC0r634+hOC8I2o4hr3U/USfan2WKI4qaxh4D0PYMmoXntaLYBWvtHANIQpOmjWuyMGqL6k2xh5NNRFGNPuwZRKvI6IJ5lfphwLVcyDx7wgEsVtbb33k0EjYje1tDzQUDYTNfjr/SDft7xjnfgK7/yK3H33XfjYQ97GD7ncz4Hr3vd6/CoRz3qQ31oD2iqkPfLLLPMn38WAHgJU8Vh219LmA+VRVGhv7cMtLQXWn1Wlto0VANpcVPNmQm0NatWfGmcjMsV6dCjPxEGURozorhJVdjvZA2rYC13DhGynlw7dLUiR+q8ujMaOzSaRnVi2sphTFsBQexEAGsuTMngqwJMAInvWGkncTMieDFnaITNfEgAq45puLbigwPGKwE+A1WCqqtUgWUxK+jKmAYaAUVowK07r9aYYeenEmB3UzYmVFkkZdby4M2BzGPWsOli54T6QMlIzMCAzNWvMJW2knSwVbDPsGaVOLYeYTU9+LlicxRs9apAaT7wxiJr2LTW3SkLnPZafEs8v9gH7GcCs7ziPwOuAPOhNwYQwAUjhUsVdeUMQPqpIrqm8QPIkDoAqBVh5nvP1X6xKBj7AJR3NKazxAeJMSmMDMSuaKtlV8XVq3rMTtzMncoRpGZx34u5ymEhATmvfOUrP9SH8EHNe/f/Lm/nMstcv1kA4CWMkxtWHppT0U8VfmygTZmjae2b3gwwhkc1bGTbWtiymjh2GT4T7/cOOIhmNimdMzBSPXMHbR0oAAPgjXV9d+bxRu16lZtuBm/mWUFllvWjmknE5CHrZQUgggIM8JShhfi63MCXSwAKGyzK0EKKNb/OJ6DEaqvWvHLiwkVbfQPGlmoIMwALgNaIluod4klG1jYUYTjDVgw0q+bCBaSmzTn00jus523a9+g2pUWVaDxP71D32jpYu3OrknTy/dpR3I08DxoUrowhWTMCGaxgusXqqcULE1fJuuZXI1GV8Ol5n2aUTrWWEnrN2j+aYpRNu/BBQQOUNexbdJH22LFpSPmBRjWBrSrQZZEV5KZLVaZSw6WZL8n1rzKwNOe0NXvYZPg5o3Q91D3vcpVQdALxGhtALmJU4Qcngs14nlFr+7u1zDLLLLNMm0UDeBkjrNZ4a5CIElhvKQCLGombwhvlTuxLkC7eEp0BodxLvZhjbRhv+rIKFADSn2QR1NcdcT1vuOxzdcz1k9WorgY1dHi8JbZeXcDCpQnUnGQKcvUKJ2aVWbWMdGZqNptPEj8i58KVynYQWWfPBxLbIvl/eR3MYJJWvoU2yw29P85IK/6c5tuFSbVfTTsIx9W7gkx1iypQ8jOBnpM2D+32BUTbN0v1mZzr3DnMe0ppwaJRNPBY18AK4ryEZgNiVEkw1tFVWOizai6V3a2yxqyystZVfZja+9GfFfSnhS5vcb2mlWuvD82kEzesybOKPjmX01HAdCVeyGyM53Tm0pncdKraa5zW3t5DPzb+RVfN+npLoONbA5uV0QZgmlbNjXSlWvA1IIy5/Kfgm7KEAD+Vpr0UvagdU4Kdq3hOxlBbQ1wiM71QRjfXLBrAZZa5frMwgJcwCqz6E968XBZ92ooAQJk3A3grslT6tbR26E+L6ffUELALMrKwINT98aaobEjeY+6ch2jbSgNLut6lQUBdlzQkpLW3Y9OMPF2pDVeTrQ/nPbKWufcCtNhWkvZ4w017Hn6nvSMPNAy4Ki0eUVkwARs7DNZuxZsCG2Ubneop0QKtXWnn25VqAcl6vkpwrLKrOyyasUktr1FBtzFcwcHNBXUWRi1Qs0cDCAGPgjYFcWEHIIVZV8HOWLq44dc0C9D1ZC6H49JyE+X8WCXftiKtZXVcm7HBz9oL7ZF7NV8QTPlEg4oyoqr/8wkX6ghtDY5g58LJa3CTALwR1lYDwN7HGoQ5BFCFjTRWtcq51PDr0phaPbfdOfWwLhcgK1AWzWxujTMAECo/YMwH1AuqNIEHysdXkFs6fs3Olz7vMg/KuY8J5ENzGMssc1POwgBe0lhMher7RHu3G/Jr3yNuVdXiqX4s9y0PTzMDCXZEb6aB0qbpqhbXkdcMBNafVRZMWRvNVwNaA0SUFSEzCltzhdbMqfM3bovd6AFgPhQNWRWH7UwGTvWJCgqVtWxZdpqLKOdlJytOtXuaBeil7UGZSF1tq+FC2Tht7VAGy0CZ6B936/nU5MLIkmLMLavOdmJ5pFGiRFaibW8hkE8rvl/aQavuX5clLHk/IAlonw75XqbBW5A1ajUWd94T8BtasHcNYvKpMDDeyRqfzTEFcVPQn7CqjzmLLUdSJQCAXk+y9g3O5AmualZjNfZZ8w51xR227THCttCcIY7mvNoBYsJgK3DTzMq89vwZCXjWayD3HuMtnb0n3WmSxhiy5mk/8hqeC8Hf3ACmFzNRJ0Hqel1zDc33sTsr9ndsmWWWWWaZi7P883gJo+5HMjmwrD/t8vVjAzwKvsLIm7mXtdZ45A38KCMUt80MoiDLSeSJrm8ZxVFs5akOYV0n9qfMgFNNnLp5tW5McwV39W3xjPpAbQEB6Mp0qQC1ojtJTesobSGAZBdK7lx3luHnYg0lWvmla8Fdk0zpPMYjb53I80FrSFE9XBL9mpob2uqVx54HCS22CBU1oogBRBzDee0tAkbZzbSWsGrRGObOWZRLEIChuYnKnpad1bFVoRX5/tIAWPWwGB29NqoHhmuqFxQQJ6BImUbTQA5tRZ72g5hVXANAMx9fI1FULqDsomYhEqxRS+kzLtTtkZEmkI9n2T5EaK5gja2ztzvJF669MjRAqMYcXrNNy+oq2dfuNLHDWDIu570IPzGuB2IMgXfIq0g5wsqbY90VOtjzurHqfixmdIpbAuUlB/DmmmUDvMwy12+Wfx0vYWpo5fR+RyOmN0OIbq3IilIF/Wnt0Z1SF9htJPBZWDSNlQGE4VsRrLx3OLOuPRX4oTICZTwi45N7B9QWDaJrUzVvsFGE/b5kw8jgtJu8mDhWnkDAO5TB88adKlCrNDkIEEUzxZTOYz6INGxsCvxUmhM4Mf9OTQdxu8MKSq5gf5qNBdJfaxWZ9sFqOHHYFoslidti2j7tUe5PNbPkYqgyHcdaVwdrUJkOvJlA4pZAGoCFHVuYs1PzhJggxHTTbYqshQm4NOMO4K81t8+nBvTnPeotcy8xMGOBBnzra1LG1cCwMHD6GIAYTeQx4lbq/ISF1saTIEaOeJ7ZXiJmCwNcAiaBFl4NB4y3Rqsh9HORlhZveZe6HreVLVoUUV4FkzIoG+kqEM+SfBgJpvvzUxFwKIagHZf0cHWGSzxeXVezj7mx1MvcHPPeruBlllnmg59FA3gJUzqpR9tZsyqIoaC9rUC9RGxM0j0773PFOq/pNPXVSWCwAImTLOHIHj4KyyPgpTpnYctag6XBzt0svcLzRX1V9VxjAoB3BH9hWxG2GTUSNCogqGIk0Zu7ifgddXYAAMdeXFv/Qtas+6HFnswVad8bE1UiEFARR+2y5TlwSTtsnXXholSUtUeWijbGtARzhCI18BLGYoxmf1KMgSoS06Ogb5Zj0boyRtVUiX3heetPixkd4raBp+mA3+sq2TqgaQm1f9higAALlq7BicsYdg3UKCYY0dP5czGIZKD23thCBfBxLGQv5cNFGhzCrNo+ntvcO3hZiepaeT5gOLWfKzAJYI+w8HI61AP8WKXWT8whAq6LepYcX1d3li3CReNX+Fqr1cbpNd6dXnTlloHvo5o58hBM/+inVrVH0Mtr0qUiK3jpiU4VZRUakI0OqSPoLmpGWuammIUBXGaZ6zcLA3gJ4zIwr31rIpCVl2XO7dxUFUSp3g2ON9ZOBPZh0joscZh67b+tzd3bi+C9tsfwc7X1od6AAZh+sLmBi/Xact0rrs6ObEoQJqz0beVqWjphdlxt62JUfZ0CcgWMdccJ3WnZMWHgglbP72QdUrvlTM/YX0sowqK6SvYQED2gF4AhBokkXcVJNJB+ZvwOoExhtWw6bRQB9DgYYUItpgZ5M05l3uP7FEZpqFDTgayp2eLC1+QzhHFs3csW7ZMlH08NGrpGDtQXqlHHHNoSxtydlwvRPWnV3MAMj64YjkvTCcoxAq2DWnV6mhNJN62za9J0oqC0oAxsoFEWVN3QdN+2NbGxeBDWssIYYf3Q4yfpPJ6L5fwx7qXYte8sw5IRLnnt+cFBOoHTOtr15OeC7oy0b+nZlV31mtyp6FMwuswyyyyzzMVZAOAljJcbvKtA7kTkfxi4shNzhK0YK0GCK9prCnRnWRg0YDwKZpbYNYtollqUajDVy5EVoZ5PnagAMO/tgEgSc5jXngHM0vLgCnVZ1F6R5dObMmoT11OrqI0hWarUSgOEWQCHrPS0rSFuyV4ayCjtsayqrjZNo/bTlt7Dj/z9eIU0mzpQ24pQH5TfP9w7I55LA0X0QKVpguYYnj+uRv0F4wq1cgyqTmJwIFsLY/K0l3jel6o6icoxl7EjU6gAV5nKKh8A9JymtXQKO5h2rTunFjTIelzPR+4UaIqBJbT1r57P6cAb6xZHrpyxEwVjK/OVtswUc5YrK+xyRTzNptXMa9FxbgXQiSM7TDTrmElHQGLcagalN0AGwFpQSucvMIR6ftUh76fSYoD8Tnak/P3QaJf5ILJFZGaTjRqcdLKYbeqy43hQzxL7sswylzfLP4+XMb7luUUNwZ0KtrcE3Z2Zs9NlyFq2adWmQ35f7RswND1dlmowdYm6xjSmlUd3zhvibgyInwvi1pkA39a8YzUwpD+f+95AnUO1tWseuBqMUjeXB+r1SkdA1Z9kTHIjLr2XWBGHrGaPTiNfeAzxvFjunP5ZEPCgWX4We+JYXxY3BcO1LNElnBoYQJxF+xV2woIVYKrLN0tTiatA2mMNmppQSmiasu4s01wj28p4zsdIa75vaeWwupdCNFeBab+t9gEe8/oeaQeZKAeYDsRIUiVGpVYaNvrm/u5PufYOtbld55UDqpg6psqsPQHUqmeEA4pvukl4Xc/qGl7PlXxgSM5c5k37KLrE3gHwAvDEGLSiHs+VBqiK90grb3rJvGJUTicO8xqAeRUYci7rXQWZ1Um/NGgmwlwB5zEfeHEcC6iDVBXKhxMF9BZSXlruoAZN8++IAO0EY9iXuTlmwYPLLHP9ZmEAL2FKaKyROnYBMQwEAj8AGK5lc5UaQPLO2I8SYXEoavCY972tKzUoGYCwL7LOjNQhAsIySbVamIrpD1vVGS7GsngJ0BUGUk0AYSwIm2JsEqoykmS4SvToT2bJfqu2GtZ1tLZEWPRNdAQq0j7hqpplWk+tspe53wkNluMKIx9zPgi2mkZtOjZIOLVmB8773pgzV1Trt+OWRXOqGtgTNo3nvQFlV8jM6vHoul5Xj3lwGA+DnCOywGFkdV7uYM/Byjr+nvV0GrbtWlXftmJ9T0YQsMgPDNQ0BgF8ygznQX6u58/qWtYVaRYRxld7d7VJRWOEyg6gnA+CRNoIWy0ay+4kWye0mWfkvFffjC1qaKmBJiCnv9brTQwseeWR9gJcqhjukZVu55kZOWoOEYzJzJJVSSlAFuMR6ESX1XPYZDO6+LwghmWWWWaZ+5sFAF7C7ObrEXDAGDm9AeaejJtpyySiQ9dpqvHTlW3uvaxftdrN2eqzBodZ2hGmA4957Y15BGARJLoGDFPTvmnUh2rE4ragO0622tNWjeqdaK+4VjSt4VTgUkHaC0jrSDCQ6gVQBkejRekp+PeS15cl/sNVxrq0VTPBna4sFVjtrvgUTOh5UoZ0PmDEDez8kLGMW2YcukrwFcbCDDkBlN1py6hTJkk1jSWKXnCsLdxYDDZFGkGszUPq2EpEa+qQc5A7mmC2twRzdOuHgRJgRggNrdag6fGKt7gWoK2YpyPqHJVlU0Cvj+ky389pvxlhSoC5v/X6iuoKrjsspqzDNYtQ3dJ5kJigBIv90YYZvSa0raU/yaYzzWtlhWGOco3M4QcFZ+xeDS3Yme+1Qxj5oF50hK2rWK6RKCaRwOsU4DW3zIN73hu+Ly7gZZa5frP8C3kJEyYY21U0miUKG5hbxyx1erxBphUZmzC3LD+6I3d0cYXGB31MbXJQo4EfK7pz3synferefGoGE1d4U9SGkbQiEPKpGpvEB3LWXgJzC7dsOoAsDVslPIpk8ul/1Tsxj+yK8ql1HG8JF6Jrgjh/lemMGwFGYlJgo0RFd5obQIiaMdgAMGNnMgFaUj2lgAGvANbBjwSCasKB1PTlNaNkfKazF2pyEBZ3llxAzRnUnl09Z2FHi+czY2LiWO01uHwRwPExVSDXztMsrmXVGoZJ9XkAKsOmXW2GDZ+q6Q3DVO0DhcbRzPsBPgPToXQdZ6mkSw1kacxL6Vq/7rzvMR0G+xChzLQ20/A6Z3zQvG7vuxqT5gNvcURpHexagBhQqqzcW891q7JT2QMgmlLRHtboELYZaRVM+1ejt3rBEpwwip7O7trA6DI3xywr4GWWuX6zaAAvYUpova9hYryJrktLhEVjqHmDRgQg92Sf+LPu4s3ewcKJ9aavGr7qHVZXM8rghPWpiNtssR8+7QRTV7T14lgwHQYaAuaK4d4Z815k1IrWvO3iQl3NpoKyjsjZGyhV5qZ6Z7mB2sdLGqjCJweIocGn1hrRX0vWXMIg6Wp1Y8pEQivIoq5BZe26s2I3I4G4nHWt7ueC2lErWCSjLndiYBG9ooYcZ3HUKuBVcNJtdte8BKBx5GtJK9H3Oe0wln7abZUGD54/slUtioeROGhGDufQnWdeK4KX0ppAkI0d4uAOQJyB4ZhazXTIY6FWtFolmzrDx0OPblMRz4oEPkuvchGjT6Vpwhy7uTSGeOLjtfBwDSYHavCWW6iMJcF8QfUEYt1ptvcsrVkp6Cr/TOOH9H3clUDoKjrLOthVvm81EtC3Rhe+xu6EgNAVIJ4xCkYZ7GVunlnezWWWuX6zMICXMZW9sXAwh2VaN32W9dnGBpxyzxWddtpOB97WtoAwGbXd3JlFR7ASJOZjXjd9oIYWaxacMiGuSIXYWExDqKxjWkekfQ+Iu9cVarQ04NjPxW7+Chx0rczctmouYFcYuzIf8Jiqc+YMLp0z8DsfBsyHgX8u4BZoQIBNJzt9tLJiVjCibl5ADCaiwVN3sEbSxE02BkpjT9JesBWnHpMGIzMUm2vhEoBp/6JhIkwFSYOfc2vs0OiYLCC7BGFsO4fp0EubCNr75mGsnfX8yoo0i7FBW0hW92SC6iKr/v3QVtAaLi6rd7KX1ZjBEqjxY6OKtIXI+6aRPtogMx94cxzntcd4S7wQQm6NNG4HiAW5tsUdruHe6k5XRjOvvL1ven61wpBAb7dOUExMYyX7ObRrSKv86FQXM1Cmix1or1/rFJd5cM7C+C2zzOXN8q/jJUzpYUyNRrvYym5WB6Os6KSKrDtv2Xyqb2JFnEaASIOEsIdppWtlh/44WxZbWvkLkR8K0uZ96X4tbdWm2jrLExwIOOb9gLQfLujB9NdcvfE488qZI3hey9ek1SEPdC7HTatt8xJLwxW0UFyiudOVdukczQiTuj61Uq3YylPdunocmmvnapX4mhZn4qdi0TMMyJaAYUegk3tn1XVqDiGT5UxDpmze7krRWFzV+IGaP13XK8DTnD81+xgwkrgYM13s8bnS4JH7xo75DKTBYTrwGK+0v65RXiNzIyWyRrSICnzVTKKPo5Vxao5Q9izLClgbW8KO/lKbWID2eGnlpOKvmXrCtli00W7Nna7tS6REYToIbD3ZYb+VkeaJbbo+BZ36fut513ihMNIVHDfJfp0HMef4i13Iy9wcs8TCLLPM9ZsFAF7C+ARY4K70xM4SIaJGkNw3I0da8wao/aphJoDYrbGad8KffaoYrhUCnVIxHUn12lilCkzA3VwNkCk40MovVFi2HLtVG2tI1yjXsygaRg0L29UgZzI3zlys2tFaPYGkS3TfRqkw223E2A2j1jgTZb2S1N6pbhFVwp+V+XFtDalRMbur4OqB+Sgir4IFWOeVh4ZYQ/ISUcXB62BdyPNBMI2fMpDr92RruJgP/A7riQvgXHuDIWymMoDsxeV/89pLrRzEeMNz2Z0XCw8v5owGtrdI162A3Cjvi4Ijm9o6n0t02Nwa7Dx7MXSoGUSNQAamxGzbVu5kK1Wr56emiwRgJiBdj9fA6KK8ko7gKszjtki7B/V4WVbYWbSiWYKmw7Y005LTqjmRBOh1gmaMUe0g1M090NnskradOHMwL3NzzQL/llnm+s2iAbyESStgPKITN61F7zaRyanesefXOVTf3Ku62s3iuARgtV6l0zWerCpFR8dVZ1uFXmiJ8A2YkOHj18PYVtC67tT4kU76cVVI70c2YzAqRRybWVa3+y3ChO0XBHv9CXVppac2TXVhWm/GdWx73CDatRJ5rOEsQwOUzYAQHVIIdtOH5MwVOMS5sv4N2HGRkkF0taJix5zQwzqD46bYylpr7dT5yiel7q9GyceLAsDFzFLXNK7M+876gOOmNHZSY3XkOMNc0Z+2HD9IBMx4yA8MCt71Z/uzIsycGn2A4USaTgJQE1fHUQKyGflS4QrB2XBc7HwDvEb08XVt7dHq6hgsXZCj6Og00Dl6pBWsOk5ZX63E64+r6fkUxBcJYSY7VzAdUKPoSoUD4M8J5MZ9jyLva5j52rCSVbSYWGqTCUqQdFuVU6daGyCU3uT+WjLNYNnJjFzmwTeL63eZZS5vFgbwEsZLuLNVp7m2dgOoF1ONoEbFqDPUbtAVwqQwMJh6JmdOVGXAyL4V058BaO0bVUX7sJWdgqq8EpZO2cJE48d8EMjInBdqxnYiZxT8+Zl1YwBsrV2iswo3gIzd6p6M4WqW9W018LXrAp4OfFtvh7YCboaQYoBV17iaC9idZaBKf60EH6PAVplaJxdGef7M1zodBmOHNJakDI39VCYWlWvLIO5qmjoc+pNiq/PunO+rApHc8T3qNkXWrhANJIzBBcSYM1YMJxXdpr7XuraaPlQbNLrzytYQ30xBcatsMsGXZusp2J73CJA0dDv3TReq4MqyFiWoOYgBRkG/VsvlHZ0kmWyYU9zlKl3LaNefgPh5j9IDPZ/6HkIeYzfzMIwV/Um2BpgsDm5XuNqHRBKpE7lK13YevLmYXdZquqY1XObmmWUDvMwy128WBvASJq3o7swDzAgS5oo5ejIYtcXCqEDfwyENDsNxMeDIvDr52XULMc4DWRvte9XVX+65cvSZzKKuWF25qJ1hgwdXhC5VOAl3jtuCeF7tpkoBfmbMi6xDvWS6MXS3WtizdtjGTZWKMY8ia1mXAC8fNTR02cnNWUOUVVNHp6cYBLZ0rSo46aYicS8FYWzH6GRdXIX9yiu6T/2YkfeixdMoEDIt3lxQA9eHfiQbGM8z5kMituodygBrL6nO2fGbWcU1cE1zSLVzjloxHEv8zppguj8tmPc82diJoDetnIE2Xffmng++qxktHRBHmH4QYAOIdj27Ino+YUmxA45oLIE1o2TJpWSfsVYXVqtQm4WhZVgzV8/mIg+wFX1aeWu1KWIAIuBj00rdY+sMI5G4eu82rNoDhGWVc1gr9afdGZ3QQSoN43mxAGuTJgigNmf0IC00GlEzSp/00gTyoJ77AL4FAC6zzHWbBQBewhD8OVkZEtiVoACgGtN3ATxAsuR27ldxK0YSDQGWQGONUYE4YXcjQAB9btF0Saiyfs0VruwUCHiINnAi26bHBMCaQEzPODj4icAv7XlgJ+KEQBfSoEHTAnVx1RopisTEdGcF3lW7QVfX1sNODBu592IIANCRqdKqsjBWuxGUTpy/qxYq7RIDobsKhDEjjMC8H616LkzMHiyDauKKrRPTOgj45jF3pxU+81zVKO8RYBpCBX25d1K11nSI+hi65uY6mOep21Qz3WhWowJprZWLY8G87y2YWhm/KgaPuK2oXWuLSeKwVS2mtr/kvq3G03qHGatkYIcTAq7pMIh5SdfXDkmYSI13MeZZQWIm+PNidiHYlN7ePb8DDGGgbZbrz8ZpRJJU8q1aKLhmD/odfZ8y0XptK+iPG7aj5FWwXEJzbi+zzDLLLHNhln8eL2F0nUkTgNyIxQGbe0bCKPunbuEqRo3xiIyXtjlYDZYwJtWRRdGqMmX91GxCQ4O0Y5wXW0FquwhcC0lWp6gG784HAekgIAtISNIuwuy/JsYHmpNVzQn6ey8ruiAtEwrodMJcMR160+X5iSvGeE5mp/TNsczGBxizk/Y9jQVSI6drxl3NX9i21zndEpHWEfNebPmEtUqriphKIlAGMkuWBTi0MGYFTVmAZ1p5OX6eu9y7Fr4MNJes1/MkjtVZ3NZyrorE9UwH7gLzVwJ1nXGkppI5gtUc38okKugMk5iINES8SE2cXFt0heu1w//HbbXj6c9oPmG8S5G1r7xXYzFTkZqW0o5bm2HY1b6fruIG5MYjfr9G0WhbSndWBEATbI5Hzur9VlezXceld4hnhW0upaI7o6tbz3PpeB1kNQ1lmpe6s2QrfgXPy9wcs2gCl1nm+s0CAC9hXGrOSld4M/fyNWrH2p9rJEoNQHfeokKUDQJYIaaPlQcR/os2j+wfgSFvqDAWsfR0pCroI6BwLWhZ17K12kpO8/wU7OWBYGw+8Ka/mvd90/N1F1251JxlMzOw7aQaywlgh80heKH5hc8TNnQ3Uw/oDZzqv/ta9abOZYAgLm6z/Gy2LDrmBrI6zM8F8SwD9h607EIA2N4WTUfYnWUxZhSLrVHHMSvjCGqH44zVPZnhy/KYlvEomjYvq3ptaNHIFm0FUUZPf+11hVprywCsNAT5VBvbqNo41TbK+Q7Se6wGEldg9YGWL6hZlKpLzI31ZZyKgF0N587UIAK8llXDp8yuAj82kXj7YKDXPhzdzDQwta8naT3pzmgqmQ49WcW52tp/vFUiibyyl2SB1SkNSM1g55DWAeNtHfMdIyyWZpkH79xnA7zgv2WWuW6z/PN4CUOdHwzIlegw7TdjgYKhec/tNEbQWQtojh1EzwW7ac57ZJuqGjKEBTNGJ/FGPu85q3yzGA35PruBCkCxY9IYDtEeVmkuqZ5rwrQTCB0mBvdq64WySfEsw88V82Fofa/qHNaXr8yn3uTFgaxRNXBAPC/oj6XXVdig3dUkG0YEZCSupBm3oj28Cv6Ekepk1SuZezUwksT6jOXc7bKnNegKvPX9kh0UvaScu7R2lmHoM1orSG5sWA3YcXDzdZbQ3jsnTKbm6u0GNPvEnwVUG3jxA4BGsuSB/dK51ygamHFHWcoSHeY931bynWMHs7w/1XFt64oCc7meI1nNtHJmcjGd4876VmUNPFhpwdlUA6LKAtrfkwj7sBI3Tbe6G2rN2kR+T+4lx1E+UOWVAwow3Evwr4YqAGaUWhjAm2uWd3OZZa7fLADwEsbPMKBHBqZYjIve0F2pWN9TzMihN3cL8N0BGaqjKlGr4uQmtwMyNXIkboo953TIyJB4zniStNKWDgZQx/PcYk9cew5XWxRHiU40a8W0d64A2yvCxEWHee2R1nQQFzGU1OBstcjHEE3Z0MBJd16wvns2RkmZrOmIrE+RVhRl1uJYdgKuK/zEdZ86mEvnMB8FWwf6uSBssrSCOJTOoztJ0GYKVACFrGZ3lm1dXjoaGPSY+B6IK1elawKUrRUjNIOI5hLqijh3be2vek5XG+um14XL1T4MEFBqlVxF7hojXEID0rmjHlFBLKsHWw91c5S3doy4bR8edKIYMzREG6BhRVnL7qyIXrFa9ExV6YF8EMg9n0tdyRphE0c6qNV9rM0tcdNyKxXwqcbSS/NNCc01rI51OJhTnQ0mUjenDTXivtYPD8sss8wyy9x3FhPIJUyVkF8/7gQeAy2SxZO5yl0zLdAVehEAaLtGGCvgKzP8MoCpOVC1SUOfI628RMo4Y6HU9FGCl8gSArrpKEp1nLpOISwijA2MWxogULlNVpdpt1H2UACeaM6UUeO6Wx5TIjr4dYdpn920qMD2IR21ghIeXPodPZvU6NXgkCQqxImzWtewxviUakaHLJq+Eh3mw8jHFdDhEv8s7XnRDQJ1x03K8+pQVjx2ZSh3Q6ZVk6fnXZmtec8baHcVmPYcVleL9UIDwpamihK9NaAoMKveWWd0FQ3pcFIMLDoBbxbCHNo1F8cqZiM9RsACqfvGNCoQrLEBNS8mGsiHBJ/ahwHqDKs1lfgsndW60q9Ny5odL0g/N/AbtwyRViDtM5D6poGd93xzMecWrI2J7yVBZ8F05I1NLD0/XATpKZ76yMaSqVCr2nszF+maeZkH57z3yndpAllmmes3y7+OlzDVNcBQImxtmAdYQDCcmCdm/owX8b2t2TQAeqwG0rQlgmteT7H/zJuormeVITE2K+y0c8gxqdFE2R1dNfrcgorNlan6O+egTRq66tPAaV0FprW3WBCN62i5d1VAAR2w2mah37PbEtKd043sp9Y2ofrJ3RaMspNr56Xb2AswdKlay4STFbcyXk5AMMDzU6MGLjNP0BWC8urbOaq2si0SmUKHreoQ00qNIwq+K1ZXm9PVqt9msq8ALNRY8wPZhQtbISvIVjBWQgN9ui5WgDqvG/NKM4nUw4FMnuYAAvxAMB34BiwvsJyNKdT3O8sKXFfKBPJaR+iM7VSzznTQ9IclMADdavtkBa6P7+dqH1gUFGrPtRqLdJVrxqPM7+tOM41OrmUoEvyptrE2M9UyN8Us8G+ZZa7fLP88XsIoCFP3bxr49bLDfEyHBAHURjEzUB2WqufrT3iThQNCacySF+YoS35cFfZOV3Eq+jeXcXTY3hIsMJpZdQSkQVtC1mSi+hOujk1gv0fnrK4NrTbM73TKijklTGJU2Bbr0a1Dqxez2rVNYbvHWlkwyXATwIsIYwPDtrF1Vc0Je15YLRgAy2vtgCWQymtvbJBL0mdb3c66uZp+jsHDBXVqZhTW4enasq2tLaxZQ7czgIgdQNuCtzW6xtWK/pRxLOMRXbm7hp+0UqYuGGPWnReJkVFQXDHtO9QkzNpGrwe2nfgMuFmdsDSCuKmIc9e3nL+OrSLdeTVns15HCup01Uwjjb62HTZw31vMUcstbAx2Gpz9XjWLes1MB8zCjBvYtU79ZoXzztbD/IHmeHY7YJF9z3J8k7qtYDmN7T2EreiXWWaZZZa5ODccA/jCF74QzrkL/91+++325//23/5bfNEXfREe+tCHwjmHN73pTRd+/p577sE3fdM34ZM+6ZOwt7eHRz7ykfjmb/5mXLt27c987pe97GV49KMfjdVqhcc//vH49V//9Q/qNShrUiKwvUKmxYnerAYycMpiuJ0cteqB/kwAjZofcmPInKxoiwCkee0xr2UFKVEyahAA2vpZNYjaukBWj6Asd000z4gab0xkY9xgXcU+VYxXvDFFuWMzht5oWRfmjdEztmyWkOGpYrrCcOZ5zxujpWyV9gJr/lvaU6AsDJCArbhlzE3YVgGV2dhVPzbmTw0FaT/QnSzOZJcJfJThyytpjzCHMUFcXnnELfWAuROAWMUwsfYGdLtzNWbAKvk0G3C4ytgTl6mfC3OV+jVphdnw9WiItE8E+N15tfeOWY3Nwazgzc8QA8eOMQgQNtjZsTCo2wOONXN8z6ut3hUQ+wz7r2lMnehSW8ZkmKq95t0WGjUu8UmpLezOdthXAdb6/dO+N9ZbwSvQGE4AF94vfZ/gaOSZD4KEhvPaMAe8aDYXyujBPhffwGUDvMwy129uOAAIAJ/2aZ+GP/3TP7X/fud3fsf+7OzsDH/lr/wVvOQlL7nfn/2TP/kT/Mmf/Al+8Ad/EL/zO7+Dn/iJn8CrX/1qPPvZz36/z/kzP/MzeN7znofv+q7vwhvf+EY86UlPwlOf+lS8/e1vf8DH7xMBz3zgjIlIg0OYgeGY9V8qns+Dk4ovh9Ix8kWr38gMtbBkXcl5AY8ar2L5fPJcBnoGxmZccH7KTdJVGGNlrtGdUS0i0J5X+4SHa8WARYkO4y1BVsGaSyiHo1o1r3mI1TLb+OcKqpw1QvjE9WuQNaM+R17RaEKWp7FBqqEDYLVmNRIklM4hnmXGyaSKvA7wY4Efi9XHlc7bCjhMZWdNWa3VIq29tbnETTEwpPo5Pa8aiWMh1UF6gnf6nXPH62Pec/dhVPMgJhk0PZytwHUFWzW7sa3+vZgtNLNxvOLNLV7lZyyWJrVzCtfMRCW2jD+VGmiOo/6M5v2VSOCmgNMyD2cC3NK112Mu6J1YmjzwutfeZK0a1DVwiVINpxpNAa9paB8G1OntsoD3FR8/reUDl/RlLyaQm2uWHMBllrl+c0OugGOMF1i/3XnGM54BAPjDP/zD+/3zT//0T8fP/dzP2e8//uM/Hi9+8Yvx1V/91UgpIcb7f8kvfelL8exnPxtf+7VfCwD4oR/6IfzH//gf8fKXvxx33nnnAzp+P7X/mylAV4NOGiI8ALmh6vd053KDH1RXBdOChYmrNXU4qoEgTICbi4G1aZ+MVVpJ7VzmClMZFV3tAk2PqDf4KFVh21u4iiSD5VCFcVMgqqBEGyzUEKHxIKonBIB5TXZMNXR+qpiOPFxugLF6h7glY1UTULsGYMk0Feu11XUyjRlAPMuYbomIm/a6quP62E8V6SDAjxXwQOq9GTdcrgilRd/kNWvg4nmR7EOHuMnyZ6yKAwg2ABjwVsDNnuXm8K7icq4BtrLVZpj+NGOSPEN9v32q9p42JzjX3HFb4Tysk9fAYNHjkBctoL50Dt1ZNSlCkQ8NRYLJfZJzFAGfnGn8FODqtaEudgN4uTWRqLGnP+G6XwPJLfNR2eoOmMXwUuW51WTCNXg1kw3zB9tqmE7tijDyWPVYdC3drkN+aIjnGQDPa8jAeBRQFgR4c82C/5ZZ5rrNDQkA3/KWt+CjPuqjMAwDPvuzPxvf//3fj4/7uI/7oB/v2rVrODo6ep/gb5omvOENb8B3fMd3XPj6HXfcgd/4jd94n487jiPGcbzwPAAQ3rNBLgWlOCSJwyiVmjvUijw7+A0AAUnFAcWLQWKuwCggKwHIwFyAOVL7l4JDBbA+SSglYJSXxFgOoI6A5B/DjdSF8RscV2SZN8ytuCq1biytHLpNRQoV9dxhrhW5eoTjguIcUgcaI8SM0J8WzNGhbvm8SQwTqKAmLsmNeQZmBxRhm7yv8FclEqZ3CNcqytphGwBMQBJWrDvPcJPDPHjUqQAZyNGhZglWPivY7nnUAagpoaZKQD3T8IBEt6nbAnMkmCvRIwVQM7drPgmA2wBlwxaKnMn4ZcdzULdAFlDWnRVG1BS+T2qMKABS5xHOKqbBoWagSP9uScDkHBwq6uRwvgeEs4nvcQTqFijyHvrzitQ7lOoQTyumlUN2lasvz/fPnQCYK2rvMEWHeMrOZD8ScJbRoWTAbyuKGnaCun8dkuP7g5kvobtK5rN2DtsVu3frmcN2xyhUi6zmewfIex5OCjZHHshAPRO2cWzVfxlAcmS+S65InUPZ4yo7nlVsVg5xqsjeod8UFDhk8PjrSaYhScKt/aYCmc9fsziut8LYboUtLxkpB6SVpzzgPUCWT2OLe/TBOcvbtswylzc3HAD87M/+bPzUT/0UHvOYx+Bd73oXXvSiF+GJT3wi3vzmN+MhD3nIA36897znPfi+7/s+fP3Xf/37/J67774bOWc8/OEPv/D1hz/84XjnO9/5Pn/uzjvvxPd8z/fc5+tv/jff94CPc5lllrm8ec973oMrV658qA9jmT/nLHhwmWWu39xwAPCpT32q/fqxj30snvCEJ+DjP/7j8ZM/+ZN4/vOf/4Ae6/j4GH/9r/91fOqnfiq++7u/+8/8fucurotqrff52u684AUvuHBMV69exaMe9Si8/e1vv2lvNsfHx3jEIx6BP/qjP8LR0dGH+nAubT4cXueHw2u8du0aHvnIR+K22277UB/KMu9jSqn42p96PT7+Yfv4B3d8Ep75r34Lj7xtD7/3rhP8t3dcNO+99X+f4uFHqwtfe9lr/wCv/b3/jZ981l/Gug94oPM/3nmMb/2//yv+wR2fhL/6SR+B//LW9+DFv/jf8eK/9Vh8xiNuse+7+3TE1/7k6/EVn/UIfMVffuQDeo5//v9+C37jre/BT/wfn4UhPvBjfKDzff/+v+MP7z7Dv/h/fSa8/7NlED/7hnfg/3zd/8IrnvH4+5zfZW7eueEA4HvP/v4+HvvYx+Itb3nLA/q5k5MT/LW/9tdwcHCAn//5n0fXde/zex/60IcihHAftu/d7373fVjB3RmGAcMw3OfrV65cuWlvqDpHR0c3/WsEPjxe54fDa/T+hvS7LQPgt/7wHvzK/3g3fuV/AI9+6AF+82334Dffds/9fu/LX/tWPPHjH3rha//k1b8HAPiZ3347vuavPPoBP/83/J9vwB++5xzP+te/jT98yV/HV/6L1wEA/s6P/yb+f9/zRfZ9//SXfw9v+qOreNMfXX3AAPCfvub3AQD/7k1/gv/nZz7iAR/jA51/+Z/fBgB4w9vvxWd97J/94edb/+//CgB48X/4XfzIV/4/LvXYlrlx5ob/V3EcR/zu7/4uPvIjP/ID/pnj42Pccccd6Pser3rVq7Bavf9PNH3f4/GPfzxe85rXXPj6a17zGjzxiU/8oI57mWWWWWaZP3vm3ALTx5Tfz3cC95xN7/PPxlTe55+9v7m6me/366djeq/fv/9j+0Dmgz3GD3Z2z+0HMmfv9ZqXubnnhmMAv/VbvxVPe9rT8MhHPhLvfve78aIXvQjHx8d45jOfCYA5f29/+9vxJ3/yJwCA3/s9fvq7/fbbcfvtt+Pk5AR33HEHzs/P8dM//dM4Pj7G8fExAOBhD3sYQiD9/vmf//l4+tOfjuc+97kAgOc///l4xjOegc/8zM/EE57wBLziFa/A29/+dnzDN3zDX/QpWGaZZZb5sBz/fiQ3yyyzzPWdGw4AvuMd78BXfuVX4u6778bDHvYwfM7nfA5e97rX4VGPehQA4FWvehWe9axn2fd/xVd8BQDgu7/7u/HCF74Qb3jDG/Cbv/mbAIBP+IRPuPDYb3vb2/CxH/uxAIC3vvWtuPvuu+3PvvzLvxzvec978L3f+7340z/9U3z6p386fvEXf9Ge9wOZYRjw3d/93fe7Fr5Z5sPhNQIfHq9zeY3L3Aiz6/T9s/DfZeDDv1Cn8WJrXuYGmhsOAL7yla98v3/+NV/zNfiar/ma9/nnT37ykz+gyIf7yxF8znOeg+c85zl/5s++rxmGAS984Qs/6J9/MMyHw2sEPjxe5/Ial7nRZuH/llnmL25ueA3gMssss8wyN+/ssnrvL3UBANwlQMS/0K3zsuJe5gaaBQAus8wyyyzzIZsPqxXwMsvcQLMAwGWWWWaZZW6IuT+GL3wAOXbLLLPMA58FAC6zzDLLLPMhm11W7/6w3u7XLgMK3mxb2aX2cJkPdBYA+ADnZS97GR796EdjtVrh8Y9/PH7913/9/X7/XXfdhcc//vFYrVb4uI/7OPzYj/3YX9CR3nd+7dd+DU972tPwUR/1UXDO4Rd+4Rcu/HmtFS984QvxUR/1UViv13jyk5+MN7/5zRe+ZxxHfNM3fRMe+tCHYn9/H3/zb/5NvOMd7/gzn/uBnrcPdu6880581md9Fg4PD/ERH/ER+Ft/629ZVJDOg/11vvzlL8fjHvc4C3B+whOegF/6pV+6aV7f/c2dd94J5xye97zn2dduxtf54Th/1grYXxQJXurz3wxzs72eZS5vFgD4AOZnfuZn8LznPQ/f9V3fhTe+8Y140pOehKc+9al4+9vffr/f/7a3vQ1f/MVfjCc96Ul44xvfiO/8zu/EN3/zN+Pnfu7n/oKPnHN2dobP+IzPwI/+6I/e75//k3/yT/DSl74UP/qjP4rf/u3fxu23344v/MIvxMnJiX3P8573PPz8z/88XvnKV+I//+f/jNPTU/yNv/E3kPP7Dkl9oOftzzN33XUXvvEbvxGve93r8JrXvAYpJdxxxx04Ozu7aV7nx3zMx+AlL3kJXv/61+P1r389nvKUp+BLvuRLDPw82F/fe89v//Zv4xWveAUe97jHXfj6zfY6l7n/WbIBH9gs+G+ZD3jqMh/w/OW//JfrN3zDN1z42id/8ifX7/iO77jf7//2b//2+smf/MkXvvb1X//19XM+53Mu7Rg/0AFQf/7nf95+X0qpt99+e33JS15iX9tut/XKlSv1x37sx2qttV69erV2XVdf+cpX2vf88R//cfXe11e/+tXv87ke6Hm7nvPud7+7Aqh33XVXrfXmfZ233npr/fEf//Gb7vWdnJzUT/zET6yvec1r6ud93ufVv//3/36t9eZ9H2/UuXbtWgVQr127dt0f+9d+/931Uf/w39dH/cN/X3/mt95uv9b/Pu0fv9p+/SU/+p/v8/P6Zz/22j/4oJ7/M77nP9pj7D6e/l7nuf/X//d+v/6BjP7cT/2XP/ygjvGBzJSyPd//5w/+9wf0M/r9/8e//q1LPrplrtdcj7+TCwP4Ac40TXjDG96AO+74/7d372FRVfv/wN/DZbhDXJRLoIIkXiEERVCQHkrCk3a66MkS8UQUXlMszMyTeszbybTSTE8KmR41M7WLP48YghSUQpCaisgX06MSochFwYGZ9fuD2DrOIDM4gDLv1/PwPO611177s1bb+Lj23muPUCsfMWIEsrOztR6Tk5OjUT86Ohq5ubmor9f++aGOUlJSgtLSUrV4LSwsMHz4cKl/eXl5qK+vV6vj4eGB/v37NzsGrRk3Q6qsbPyYvJNT4/cwO1s/lUoltm3bhmvXriE0NLTT9W/KlCn4y1/+gkcffVStvLP1s7MpKb+Gn89VqJXV1Sux6sBpHL9QKZWVVdXh/QM3v/P+ac5ZjbZufQaw4PxVrDpwGodO/6FR78hZ7d8PLquqw/dF5dKzcSqVwI7c8/g89zzST/2Ouvqbs8G78pt/PKDg/M3+FP9Rg4LzVzXqXLxai5ziy822YQjZZ8pRWlknbVder8fBwjI0/PnZt1tvAV+oqMVP/9cYj1IlcLCwDJXX763fPdRx7rmFoO9V5eXlUCqVcHV1VSt3dXVFaWmp1mNKS0u11m9oaEB5eble3zdua0190Bbvb7/9JtWRy+VwdHTUqNPcGLRm3AxFCIGkpCQMGzYM/fv3B9B5+nns2DGEhoairq4Otra22LVrF/r27SslKfd7/4DGReF//vlnHDlyRGNfZ/nv2Fk98m4GACAr+RF4OVkDACZtzsPBwj+w6kARzi79CwAgcXMefj53VTru14tVGm2Z3PZmyKo/E8aM1yLRw8VGKj9wsgzHL1Si/4MOavVDl6ZDqRLYEBeMqD6u2JF3HrN3HtMa98ztv2gtb1CqcP5KrbQdtSITAPDjnCi4Odz81nzY0nQAwBeJoQju4aTZ0F0+oJdV9AdiNxwGAGkMx6zLxunfazAnpjdeGd4T4pabwK9/cRQA8NXUofjp/67gnb0n8VBXW6QlDb+rOKhz4Aygnm5fqFQIccfFS7XV11Z+r9C3f7rWaU27d2vq1Kk4evQotm7dapB47qV++vn5oaCgAD/++CMmTZqEuLg4nDhx4q7iuJf6d/78ebz66qvYvHkzLC0tm613v/ezszvzR43054OFmrN2tyZ/zTGVyWAjN9Uov3C1VqPsl/9ptqdUNf4/N6uo8dOf+47rn8g3qLQnbueuXNdafuRshdbyu5WtZXbx9O+NY7yn4CIA7Tlmwfmr2PPLBQBAUVmNZgUySkwAdeTi4gJTU1ONWYCysjKN2YImbm5uWuubmZnB2dm5zWJtDTc3NwC4Y//c3NygUChQUVHRbJ3btWbcDGHatGn46quvcPDgQXh6ekrlnaWfcrkcvr6+CA4OxpIlSxAQEID333+/0/QvLy8PZWVlCAoKgpmZGczMzJCZmYkPPvgAZmZm0jnv935Sy0xMZHh6oGfLFduQwd6sbYd/RPAtYNIVE0AdyeVyBAUFIS0tTa08LS0NYWFhWo8JDQ3VqL9//34EBwfD3Ny8zWJtDW9vb7i5uanFq1AokJmZKfUvKCgI5ubmanUuXbqE48ePNzsGrRm3uyGEwNSpU/Hll18iPT0d3t7eavs7Sz9vJ4TAjRs3Ok3/oqKicOzYMRQUFEg/wcHBeOGFF1BQUAAfH59O0U9jJfTIUkxkHb9Wn8pQWVU7ZGeC7wGTjvgMoB6SkpIQGxuL4OBghIaGYv369Th37hwSExMBAHPmzMGFCxewadMmAEBiYiJWr16NpKQkJCQkICcnBxs2bNB6S7I91NTU4MyZM9J2SUkJCgoK4OTkhG7dumHGjBlYvHgxHnroITz00ENYvHgxrK2t8fzzzwMAHBwcEB8fj1mzZsHZ2RlOTk547bXXMGDAALWH9KOiovDUU09h6tSpAFoeN0OaMmUK/vOf/2DPnj2ws7OTZnIcHBxgZWUlrSV3P/fzzTffRExMDLy8vFBdXY1t27YhIyMD+/bt6xT9AwA7Ozvpuc0mNjY2cHZ2lso7Qz+NlVIlYGaqW1ZnKmuLLwDrR3kfTas1c7eaSAMTQD387W9/w+XLl7Fw4UJcunQJ/fv3x969e9G9e3cAjbMLt64V5u3tjb1792LmzJlYs2YNPDw88MEHH+CZZ57pkPhzc3PxyCOPSNtJSUkAgLi4OKSmpiI5ORm1tbWYPHkyKioqEBISgv3798POzk46ZuXKlTAzM8PYsWNRW1uLqKgopKamwtT05jM6xcXFKC8vl7ZbGjdDWrt2LQAgMjJSrTwlJQUTJ04EgPu+n7///jtiY2Nx6dIlODg4wN/fH/v27cNjjz3WKfqnK2PpZ2ekFELnXz4ymcygz1+2Jj9SNZNV6TOTCeCupzJ1OZ22mITgrWHSJBN6X8FERGRMqqqq4ODggMrKStjb29+xrhAC3nP2AgBS/j4Ij/h1BQD0eONbqc6pfz4OS3NTtbLmeDpa4bG+rkj54axa+ZaXQjDU10WtjXee6o8XQtQT9ab9E8N6YP7ofpiYchgZWl5I0abpTdsr1xQY+M80jf3bXx6CEJ+bz3M3nWv2470xKbKnRvk//9ofsUNa/w+Jpf/vFD7OLFaLrantvu722PtqOKrq6uE/f7/acQtG98Pnueelt6ybjr09vkf7dMUncYNaHR+1H33+TjaHzwASEZHBKHW4B6lLnVtpuwnc2ufyWjMH11y87f1muC6n0zYsMh2fo+R0kHFhAkhERAZza67UXM6h7zN1Jloa0jeJbNKqW8DNxNveN9DudLqmBI+3gElXTACJiMhgbk2Wmss5hEq/NrXNXhnszVwdtOe5WqspxLsJtaPftqb2xQSQiMgIfPTRR/D29oalpSWCgoKQlZXVJufRJVnSdwZQ261WlZ5J5N1o7WyjhnZZBuYujr3381wyICaARESd3Pbt2zFjxgzMnTsX+fn5CA8PR0xMjNqqBYZya7LU7C1gfZ8B1HYLuD1nAO8i2Wyv28RNY3Q/zFbSvYEJIBFRJ/fee+8hPj4eL730Evr06YNVq1bBy8tLWjbJkHRJlvRNirS9BNKez981+wygDseqHXqPfwmEt4CNC5eBISLqxBQKBaytrbFjxw489dRTUvmrr76KgoICZGZmahxz48YN3LhxQ9quqqqCl5dXi0tOfJZzFov3nkJtvRIA8IC1OazNG9dcvFhZJ9XramcBMxOZWllzPB2tMCrAA2szitXKHa3NYWVuqtaGTAa426t/O/rW/R4Oljqd89b6AFCvEvij+obGfmcbOSzMbs6j3H4uoDFJvKSlvDW0tX97mVII/F6lGeutbo9BW7vUcXq42OA/CUPuWMcQy8BwIWjqMJGRkXj44YexatUqAECPHj0wY8YMzJgxo0PjMrT58+djwYIFABoXJjZk/yIjI6Vf4Pn5+Xj44YcN1jZ1DuXl5VAqlRrfMnZ1ddX45nGTJUuWSNesPqpvNEjJHwBcvV6Pq6jXqFemJZlqTnB3R/h2sdUor7hej4rb2hYCd0zw9En+dKl/+ZpC72P1jUGf9nVt25BjRIZnbdE+qRkTQLpnHDlyBDY2NjrVvd+SxX79+uHAgQOt/pdac7788ksUFxdj8ODBBm2XOp/bX6QQQjS7jt2cOXOkLwUBN2cAW/JskCfCfbtAKQQalCpYmJmq7b9aq4CthRnMTG7Omt1oUKKyth4OVuZQKFWwNDdFTV0Dam40wMvRGn097GFqIsPA7o4oq6qDAGBpbgrTP2NXCYG6eiVMTGSwvO18QOO3cevqVbAyv7nvuqIBMpkMQghYy81wXdEg7Wvatpar/3qsV6lwuUYBV3sLKFUCKiEgN1U/n0oI3GhQP1dTuUKp0hqfvmrrlbA0N1G7LX57vA0qFZQqAXNTE7XzausX0DhGtQql1n3U/izM2+fpPP7XpntGly5dOjqENmNmZgY3NzeDt+vk5ISqqiqDt0udh4uLC0xNTTVm+8rKyjRmBZtYWFjAwsJC73N1tbNEV7u2uYXo7WIDbxfd/oFIRC3jSyDULq5du4YJEybA1tYW7u7uWLFihUadHj16SLeDgcZbp926dYOFhQU8PDwwffp0AI23PX/77TfMnDlT7Tuhly9fxrhx4+Dp6Qlra2sMGDAAW7duVTtHZGQkpk+fjuTkZDg5OcHNzQ3z589Xq3P16lW8/PLLcHV1haWlJfr3749vvvlG2p+dnY2IiAhYWVnBy8sL06dPx7Vr1/QeE5lMhrVr1yImJgZWVlbw9vbGjh07pP2bNm2Cra0tioqKpLJp06ahV69erTofGSe5XI6goCCkpal/yiwtLQ1hYWEdFBURdTQmgNQuXn/9dRw8eBC7du3C/v37kZGRgby8vGbrf/HFF1i5ciXWrVuHoqIi7N69GwMGDADQeNvT09MTCxcuxKVLl3Dp0iUAQF1dHYKCgvDNN9/g+PHjePnllxEbG4uffvpJre1PP/0UNjY2+Omnn7B8+XIsXLhQ+uWoUqkQExOD7OxsbN68GSdOnMDSpUth+uetnmPHjiE6OhpPP/00jh49iu3bt+P777/H1KlTWzUu8+bNwzPPPINffvkF48ePx7hx43Dy5EkAwIQJEzBy5Ei88MILaGhowL59+7Bu3Tps2bJF51vlRACQlJSETz75BBs3bsTJkycxc+ZMnDt3DomJiR0dGhF1FEHUxqqrq4VcLhfbtm2Tyi5fviysrKzEq6++KpV1795drFy5UgghxIoVK0SvXr2EQqHQ2uatde9k5MiRYtasWdL28OHDxbBhw9TqDBo0SMyePVsIIcR///tfYWJiIgoLC7W2FxsbK15++WW1sqysLGFiYiJqa2u1HvP222+LgIAAjXIAIjExUa0sJCRETJo0Sdq+cuWK8PT0FJMmTRKurq5i0aJFGu2UlJQIACI/P1/r+YmEEGLNmjWie/fuQi6Xi4EDB4rMzEydj62srBQARGVlZRtGSES6MsTfSc4AUpsrLi6GQqFAaGioVObk5AQ/P79mjxkzZgxqa2vh4+ODhIQE7Nq1Cw0NDc3WBwClUol33nkH/v7+cHZ2hq2tLfbv36+x2K2/v7/atru7O8rKygAABQUF8PT0RK9evbSeIy8vD6mpqbC1tZV+oqOjoVKpUFJScsf4tLl1TJq2m2YAAcDR0REbNmzA2rVr0bNnT7zxxht6n4MIACZPnoyzZ8/ixo0byMvLQ0REREeHREQdiAkgtTnRiqUmvby8UFhYiDVr1sDKygqTJ09GREQE6us1l5RosmLFCqxcuRLJyclIT09HQUEBoqOjoVCoL9Vgbm6uti2TyaD6c/VaKyurO8alUqnwyiuvoKCgQPr55ZdfUFRUhJ49e+rdT21ufzPz0KFDMDU1xcWLF/nsHxERGQQTQGpzvr6+MDc3x48//iiVVVRU4PTp03c8zsrKCqNHj8YHH3yAjIwM5OTk4NixYwAaH2xXKpVq9bOysvDkk09i/PjxCAgIgI+Pj9oLFLrw9/fH//73v2ZjGzhwIH799Vf4+vpq/Mjlcr3OBUBtTJq2e/fuLW1nZ2dj+fLl+Prrr2Fvb49p06bpfQ4iIqLbcRkYanO2traIj4/H66+/DmdnZ7i6umLu3LkwMWn+3x+pqalQKpUICQmBtbU1PvvsM1hZWaF79+4AGt8YPnToEJ577jlYWFjAxcUFvr6+2LlzJ7Kzs+Ho6Ij33nsPpaWl6NOnj86xDh8+HBEREXjmmWfw3nvvwdfXF6dOnYJMJsPjjz+O2bNnY8iQIZgyZQoSEhJgY2ODkydPIi0tDR9++KHeY7Njxw4EBwdj2LBh2LJlCw4fPowNGzYAAKqrqxEbG4tp06YhJiYG3bp1Q3BwMJ544gmMGTNG73MRERE14QwgtYt//etfiIiIwOjRo/Hoo49i2LBhCAoKarb+Aw88gH//+98YOnQo/P398d133+Hrr7+Gs7MzAGDhwoU4e/YsevbsKa0fOG/ePAwcOBDR0dGIjIyEm5sb/vrXv+od686dOzFo0CCMGzcOffv2RXJysjTb6O/vj8zMTBQVFSE8PByBgYGYN28e3N3d9R8UAAsWLMC2bdvg7++PTz/9FFu2bEHfvn0BNH6qy8bGBosXLwbQuJj0smXLkJiYiAsXLrTqfERERAC/BUzU5ubPn4/du3ejoKBArVwmk2HXrl2tSlJvdfbsWXh7e/NTcNRmDPHdUSIyHEP8neQMIFE7OHbsGGxtbfHRRx8ZtN2YmBj069fPoG0SEVHnx2cAidrY9OnTMX78eACG/9zdJ598gtraWgBAt27dDNo2ERF1XkwAidqYk5MTnJycNMoN8fTFgw8+eNdtEBGR8eEtYCIiIiIjwwSQiIiIyMjwFjAREd1R0+MKVVVVHRwJEQE3/y7ezaNETACJiOiOqqurATR+opGI7h3V1dVwcHBo1bFcB5CIiO5IpVLh4sWLsLOz0/hW9e2qqqrg5eWF8+fPc83AP3FMNHFMtNN1XIQQqK6uhoeHxx2/qnUnnAEkIqI7MjExgaenp17H2Nvb8xf7bTgmmjgm2ukyLq2d+WvCl0CIiIiIjAwTQCIiIiIjwwSQiIgMxsLCAm+//TYsLCw6OpR7BsdEE8dEu/YcF74EQkRERGRkOANIREREZGSYABIREREZGSaAREREREaGCSAREenso48+gre3NywtLREUFISsrKw71s/MzERQUBAsLS3h4+ODjz/+uJ0ibV/6jEtGRgZkMpnGz6lTp9ox4rZ16NAhjBo1Ch4eHpDJZNi9e3eLx3T2a0XfMWnr64QJIBER6WT79u2YMWMG5s6di/z8fISHhyMmJgbnzp3TWr+kpAQjR45EeHg48vPz8eabb2L69OnYuXNnO0fetvQdlyaFhYW4dOmS9PPQQw+1U8Rt79q1awgICMDq1at1qm8M14q+Y9Kkza4TQUREpIPBgweLxMREtbLevXuLN954Q2v95ORk0bt3b7WyV155RQwZMqTNYuwI+o7LwYMHBQBRUVHRDtF1PABi165dd6xjLNdKE13GpK2vE84AEhFRixQKBfLy8jBixAi18hEjRiA7O1vrMTk5ORr1o6OjkZubi/r6+jaLtT21ZlyaBAYGwt3dHVFRUTh48GBbhnnPM4ZrpbXa6jphAkhERC0qLy+HUqmEq6urWrmrqytKS0u1HlNaWqq1fkNDA8rLy9ss1vbUmnFxd3fH+vXrsXPnTnz55Zfw8/NDVFQUDh061B4h35OM4VrRV1tfJ2YGaYWIiIyCTCZT2xZCaJS1VF9b+f1On3Hx8/ODn5+ftB0aGorz58/j3XffRURERJvGeS8zlmtFV219nXAGkIiIWuTi4gJTU1ONWa2ysjKNmZsmbm5uWuubmZnB2dm5zWJtT60ZF22GDBmCoqIiQ4d33zCGa8UQDHmdMAEkIqIWyeVyBAUFIS0tTa08LS0NYWFhWo8JDQ3VqL9//34EBwfD3Ny8zWJtT60ZF23y8/Ph7u5u6PDuG8ZwrRiCIa8T3gImIiKdJCUlITY2FsHBwQgNDcX69etx7tw5JCYmAgDmzJmDCxcuYNOmTQCAxMRErF69GklJSUhISEBOTg42bNiArVu3dmQ3DE7fcVm1ahV69OiBfv36QaFQYPPmzdi5c2enWvKkpqYGZ86ckbZLSkpQUFAAJycndOvWzSivFX3HpM2vkzZ5t5iIiDqlNWvWiO7duwu5XC4GDhwoMjMzpX1xcXFi+PDhavUzMjJEYGCgkMvlokePHmLt2rXtHHH70Gdcli1bJnr27CksLS2Fo6OjGDZsmPj22287IOq207SEye0/cXFxQgjjvFb0HZO2vk5kQvz5lCURERERGQU+A0hERERkZJgAEhERERkZJoBERERERoYJIBEREZGRYQJIREREZGSYABIREREZGSaAREREREaGCSARERGRkWECSERERC1KT09H7969oVKpDNru6tWrMXr0aIO2eS84dOgQRo0aBQ8PD8hkMuzevbvVbZ05cwZ2dnZ44IEHDBYfE0AiIiJqUXJyMubOnQsTk5ZTB4VCARcXFyxatEjr/iVLlsDFxQUKhQIJCQk4cuQIvv/+e0OH3KGuXbuGgIAArF69+q7aqa+vx7hx4xAeHm6gyBoxASQiIuoE6uvr26zt7OxsFBUVYcyYMTrVl8vlGD9+PFJTU6Hti7MpKSmIjY2FXC6HhYUFnn/+eXz44YeGDrtDxcTEYNGiRXj66ae17lcoFEhOTsaDDz4IGxsbhISEICMjQ6PeW2+9hd69e2Ps2LEGjY8JIBERkQEJIbB8+XL4+PjAysoKAQEB+OKLL6T9GRkZkMlk+O677xAcHAxra2uEhYWhsLBQrZ2vv/4aQUFBsLS0hI+PDxYsWICGhgZpv0wmw8cff4wnn3wSNjY20mzbokWL0LVrV9jZ2eGll17CG2+8gYcffhhA421Jc3NzlJaWqp1r1qxZiIiIaLZP27Ztw4gRI2BpaalzjPHx8SguLsahQ4fUjsnKykJRURHi4+OlstGjR2P37t2ora1taXg7jb///e/44YcfsG3bNhw9ehRjxozB448/jqKiIqlOeno6duzYgTVr1hg+AEFEREQG8+abb4revXuLffv2ieLiYpGSkiIsLCxERkaGEEKIgwcPCgAiJCREZGRkiF9//VWEh4eLsLAwqY19+/YJe3t7kZqaKoqLi8X+/ftFjx49xPz586U6AETXrl3Fhg0bRHFxsTh79qzYvHmzsLS0FBs3bhSFhYViwYIFwt7eXgQEBEjH9erVSyxfvlzarq+vF127dhUbN25stk8BAQFi6dKlamW6xDho0CARFxendtzEiRPF4MGD1cpqamqETCaTxqizASB27dolbZ85c0bIZDJx4cIFtXpRUVFizpw5QgghysvLhZeXl8jMzBRCCJGSkiIcHBwMF5PBWiIiIjJyNTU1wtLSUmRnZ6uVx8fHi3HjxgkhbiaABw4ckPZ/++23AoCora0VQggRHh4uFi9erNbGZ599Jtzd3aVtAGLGjBlqdUJCQsSUKVPUyoYOHaqWAC5btkz06dNH2t69e7ewtbUVNTU1zfbLwcFBbNq0Sa1MlxjXrl0rbGxsRHV1tRBCiOrqamFjYyPWrVuncQ5HR0eRmprabAz3s9sTwM8//1wAEDY2Nmo/ZmZmYuzYsUIIIZ566ikxe/Zs6RhDJ4Bmhp9TJCIiMk4nTpxAXV0dHnvsMbVyhUKBwMBAtTJ/f3/pz+7u7gCAsrIydOvWDXl5eThy5AjeeecdqY5SqURdXR2uX78Oa2trAEBwcLBam4WFhZg8ebJa2eDBg5Geni5tT5w4EW+99RZ+/PFHDBkyBBs3bsTYsWNhY2PTbL9qa2s1bv/qEuO4ceOQlJSE7du3Iz4+Htu3b4cQAs8995zGOaysrHD9+vVmY+hMVCoVTE1NkZeXB1NTU7V9tra2ABpv/3711Vd49913ATQ+WqBSqWBmZob169fjxRdfvKsYmAASEREZSNMSKd9++y0efPBBtX0WFhZq2+bm5tKfZTKZ2vEqlQoLFizQ+gLBrYmYtqStqa0m4raXMLp27YpRo0YhJSUFPj4+2Lt3r9aXD27l4uKCiooKtTJdYnRwcMCzzz6LlJQUxMfHIyUlBc8++yzs7e01jrly5Qq6dOlyxzg6i8DAQCiVSpSVlTX7dm9OTg6USqW0vWfPHixbtgzZ2dka11ZrMAEkIiIykL59+8LCwgLnzp3D8OHDW93OwIEDUVhYCF9fX72O8/Pzw+HDhxEbGyuV5ebmatR76aWX8Nxzz8HT0xM9e/bE0KFD79huYGAgTpw40aoY4+PjERkZiW+++QY//PADFi9erFGnuLgYdXV1GrOk97OamhqcOXNG2i4pKUFBQQGcnJzQq1cvvPDCC5gwYQJWrFiBwMBAlJeXIz09HQMGDMDIkSPRp08ftfZyc3NhYmKC/v37GyQ+JoBEREQGYmdnh9deew0zZ86ESqXCsGHDUFVVhezsbNja2iIuLk6ndv7xj3/giSeegJeXF8aMGQMTExMcPXoUx44da3ZtPQCYNm0aEhISEBwcjLCwMGzfvh1Hjx6Fj4+PWr3o6Gg4ODhg0aJFWLhwYYvxREdH49NPP21VjMOHD4evr7QgNJ8AAAInSURBVC8mTJgAX19frW8bZ2VlwcfHBz179mwxlvtFbm4uHnnkEWk7KSkJABAXF4fU1FSkpKRg0aJFmDVrFi5cuABnZ2eEhoZi5MiR7ROgwZ4mJCIiIqFSqcT7778v/Pz8hLm5uejSpYuIjo6W3uZsegmkoqJCOiY/P18AECUlJVLZvn37RFhYmLCyshL29vZi8ODBYv369dJ+3PZiQZOFCxcKFxcXYWtrK1588UUxffp0MWTIEI168+bNE6ampuLixYst9unKlSvCyspKnDp1Sq28pRibLF68WADQeGmkyYgRI8SSJUtajIMMRyaElhUaiYiIqFN47LHH4Obmhs8++0ytPCEhAb///ju++uorndpJTk5GZWUl1q1bZ9D4jh8/jqioKJw+fRoODg4GbZuax1vAREREncT169fx8ccfIzo6Gqampti6dSsOHDiAtLQ0qU5lZSWOHDmCLVu2YM+ePTq3PXfuXKxZswZKpVLjzdW7cfHiRWzatInJXzvjDCAREVEnUVtbi1GjRuHnn3/GjRs34Ofnh7feekvtTd3IyEgcPnwYr7zyClauXNmB0VJHYgJIREREZGT4LWAiIiIiI8MEkIiIiMjIMAEkIiIiMjJMAImIiIiMDBNAIiIiIiPDBJCIiIjIyDABJCIiIjIyTACJiIiIjAwTQCIiIiIjwwSQiIiIyMgwASQiIiIyMkwAiYiIiIwME0AiIiIiI8MEkIiIiMjI/H9czNaHT8rpsAAAAABJRU5ErkJggg==", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", - " RCOB-3,5Zn_Area5_LiveMap1_SpectrumImage\n", + " RCOB-CuZn-Eck_top_Area3_LiveMap1ROI1_SpectrumImage\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -335,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -417,13 +422,13 @@ }, { "cell_type": "code", - "execution_count": 125, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "27f1d54c9acb404085a2ec9b27b45f73", + "model_id": "90a198c2a4694c64978ebce60617722c", "version_major": 2, "version_minor": 0 }, @@ -437,18 +442,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b8566a09fd67479cb4a3d3c5b8de5b29", + "model_id": "ef4d6bc503984cadb528687943a7329c", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", - " RCOB-3,5Zn_Area5_LiveMap1_SpectrumImage\n", + " RCOB-CuZn-Eck_top_Area3_LiveMap1ROI1_SpectrumImage\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -467,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 111, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -476,65 +481,20 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 11, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "1\n", - "(350, 2, 1500)\n" + "ename": "AttributeError", + "evalue": "'Dataset' object has no attribute 'get_spectral_dims'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[11], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01msidpy\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m prof \u001b[38;5;241m=\u001b[39m pyTEMlib\u001b[38;5;241m.\u001b[39mimage_tools\u001b[38;5;241m.\u001b[39mget_profile(chooser\u001b[38;5;241m.\u001b[39mdataset, selected_area, spline_order\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 4\u001b[0m v \u001b[38;5;241m=\u001b[39m prof\u001b[38;5;241m.\u001b[39mplot(figsize\u001b[38;5;241m=\u001b[39m(\u001b[38;5;241m10\u001b[39m,\u001b[38;5;241m5\u001b[39m))\n\u001b[1;32m 5\u001b[0m v\u001b[38;5;241m.\u001b[39maxes[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m.\u001b[39mset_aspect(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mauto\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "File \u001b[0;32m~/Documents/GitHub/pyTEMlib/notebooks/Spectroscopy/../../pyTEMlib/image_tools.py:837\u001b[0m, in \u001b[0;36mget_profile\u001b[0;34m(dataset, line, spline_order)\u001b[0m\n\u001b[1;32m 834\u001b[0m profile_dataset\n\u001b[1;32m 836\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m dataset\u001b[38;5;241m.\u001b[39mdata_type\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mSPECTRAL_IMAGE\u001b[39m\u001b[38;5;124m'\u001b[39m:\n\u001b[0;32m--> 837\u001b[0m spectral_axis \u001b[38;5;241m=\u001b[39m dataset\u001b[38;5;241m.\u001b[39mget_spectral_dims(return_axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mTrue\u001b[39;00m)[\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 838\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m spline_order \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m:\n\u001b[1;32m 839\u001b[0m xv, yv, zv \u001b[38;5;241m=\u001b[39m get_line_selection_points_interpolated(line, z_length\u001b[38;5;241m=\u001b[39mdataset\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m2\u001b[39m])\n", + "\u001b[0;31mAttributeError\u001b[0m: 'Dataset' object has no attribute 'get_spectral_dims'" ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f1eb306933c94f7989e45c68142526f5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "HBox(children=(Dropdown(description='Image', layout=Layout(height='50px', width='30%'), options=(('Pixel Wise'…" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 130, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7d0c4ac824c94071b9e3f9f0d087088e", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " generic\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -580,7 +540,7 @@ } ], "source": [ - " chooser.dataset.metadata['experiment']['detector']" + "chooser.dataset.metadata['experiment']['detector']" ] }, { @@ -653,70 +613,19 @@ }, { "cell_type": "code", - "execution_count": 127, + "execution_count": 12, "metadata": {}, "outputs": [ { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a931c3467e15430e82817c79e14c5dc5", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/350 [00:00 2\u001b[0m spectrum \u001b[38;5;241m=\u001b[39m prof[\u001b[38;5;241m0\u001b[39m,\u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 3\u001b[0m spectrum\u001b[38;5;241m.\u001b[39mmetadata \u001b[38;5;241m=\u001b[39m chooser\u001b[38;5;241m.\u001b[39mdataset\u001b[38;5;241m.\u001b[39mmetadata\n\u001b[1;32m 4\u001b[0m spectrum\u001b[38;5;241m.\u001b[39mmetadata[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mEDS\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m=\u001b[39m {}\n", + "\u001b[0;31mNameError\u001b[0m: name 'prof' is not defined" ] - }, - { - "data": { - "text/plain": [ - "(array([ 6.35168305e+01, 1.44458014e+02, 1.11568104e+02, 5.66347316e+02,\n", - " 9.32698150e+03, 1.09546433e+02, 4.41444353e+02, 1.90172654e+01,\n", - " 1.17385106e+02, 3.10844808e+01, 1.20409438e+02, 1.12727008e+02,\n", - " -7.75122369e+05, 7.75146732e+05, 4.29660606e+02, 1.29590679e+02,\n", - " 3.07297065e+01, 2.46113423e+01, 2.43226546e+01, -7.20597952e+01,\n", - " -1.78161907e+00, -1.20086368e+01, 9.64913975e+01]),\n", - " 15000.0)" - ] - }, - "execution_count": 127, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "8b6b2112f66b4bbe845fad1d2d6779c5", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" } ], "source": [ @@ -1082,6 +991,338 @@ "# elements = pyTEMlib.eds_tools.find_elements(spectrum, minor_peaks)\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## adapt .fit_model() to fit any n_dim dataset\n", + "### Austin Houston" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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", + "
Array Chunk
Bytes 82.76 MiB 82.76 MiB
Shape (226, 256, 1500) (226, 256, 1500)
Dask graph 1 chunks in 1 graph layer
Data type uint8 numpy.ndarray
\n", + "
\n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + " \n", + " 1500\n", + " 256\n", + " 226\n", + "\n", + "
" + ], + "text/plain": [ + "sidpy.Dataset of type SPECTRAL_IMAGE with:\n", + " dask.array\n", + " data contains: intensity (counts)\n", + " and Dimensions: \n", + "x: distance (nm) of size (226,)\n", + "y: distance (nm) of size (256,)\n", + "energy_scale: energy (eV) of size (1500,)\n", + " with metadata: ['experiment']" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dset = chooser.dataset\n", + "dset\n", + "# [spatial, spatial, spectral]" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3a44b48112e84914ad03ebe44237007a", + "version_major": 2, + "version_minor": 0 + }, + "image/png": "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", + "text/html": [ + "\n", + "
\n", + "
\n", + " Figure\n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# first, fit a single spectrum with a defineable function\n", + "spec = dset[0,0]\n", + "\n", + "spec.data_type = 'spectrum'\n", + "spec.metadata = dset.metadata\n", + "spec.metadata['EDS'] = {}\n", + "spec.metadata['experiment']['acceleration_voltage_V'] = 30e3\n", + "\n", + "view = spec.plot()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "%autoreload" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "import pyTEMlib.eds_tools as eds" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "elements = ['C', 'O', 'Cu', 'Al', 'Ni', 'Zn', 'Mn', 'Ce', 'Mg']\n", + "peaks, p = eds.fit_model(spectrum, elements, use_detector_efficiency= True)\n", + "\n", + "results = {}\n", + "for element in chooser.dataset.metadata['EDS']['lines'].keys():\n", + " for family in chooser.dataset.metadata['EDS']['lines'][element].keys():\n", + " if family !='Z':\n", + " if 'height' in chooser.dataset.metadata['EDS']['lines'][element][family].keys():\n", + " if element+': '+family not in results:\n", + " results[element+': '+family] = []\n", + " results[element+': '+family].append(chooser.dataset.metadata['EDS']['lines'][element][family]['height'])\n", + " else: \n", + " for line in chooser.dataset.metadata['EDS']['lines'][element][family]:\n", + " if element+': '+line not in results:\n", + " results[element+': '+line] = []\n", + " results[element+': '+line].append(chooser.dataset.metadata['EDS']['lines'][element][family][line]['height'])\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'C: K-L2': [47.32667844961177],\n", + " 'O: K-family': [39.88862874257683],\n", + " 'Cu: K-family': [38.18606594167507],\n", + " 'Cu: L-family': [146.97594701646338],\n", + " 'Al: K-family': [3107.7171475565747],\n", + " 'Ni: K-family': [28.65322708917621],\n", + " 'Ni: L-family': [66.21082252190115],\n", + " 'Zn: K-family': [27.73482082767504],\n", + " 'Zn: L-family': [127.88862727456458],\n", + " 'Zn: L1-M3': [27.49174915684291],\n", + " 'Mn: K-family': [35.300915738881066],\n", + " 'Mn: L-family': [37.20133221647442],\n", + " 'Mn: L1-M3': [12.867940425359869],\n", + " 'Mn: L1-M2': [12.85848648842486],\n", + " 'Ce: L-family': [64.21258044197614],\n", + " 'Ce: M-family': [55.40215826986221],\n", + " 'Ce: L1-M3': [10.374802385907048],\n", + " 'Ce: L1-M2': [7.098636929281133],\n", + " 'Ce: L1-N3': [17.2167002208615],\n", + " 'Ce: M2-N1': [-2.171030134650959],\n", + " 'Ce: M2-N4': [52.71344406720891],\n", + " 'Ce: M3-N5': [15.975410977638916],\n", + " 'Mg: K-family': [169.46101590376372]}" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'prof' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[10], line 8\u001b[0m\n\u001b[1;32m 6\u001b[0m results \u001b[38;5;241m=\u001b[39m {}\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mtqdm\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mnotebook\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m trange, tqdm\n\u001b[0;32m----> 8\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m trange(\u001b[38;5;28mlen\u001b[39m(prof[:,\u001b[38;5;241m0\u001b[39m])):\n\u001b[1;32m 9\u001b[0m spectrum \u001b[38;5;241m=\u001b[39m prof[i, \u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 10\u001b[0m spectrum\u001b[38;5;241m.\u001b[39mmetadata \u001b[38;5;241m=\u001b[39m chooser\u001b[38;5;241m.\u001b[39mdataset\u001b[38;5;241m.\u001b[39mmetadata\n", + "\u001b[0;31mNameError\u001b[0m: name 'prof' is not defined" + ] + } + ], + "source": [ + "elements = ['C', 'O', 'Cu', 'Al', 'Ni', 'Zn', 'Mn', 'Ce', 'Mg']\n", + "spectrum = spec.copy()\n", + "spectrum.metadata = chooser.dataset.metadata\n", + "spectrum.metadata['EDS'] = {}\n", + "eds.get_x_ray_lines(spectrum, elements)\n", + "results = {}\n", + "from tqdm.notebook import trange, tqdm\n", + "for i in trange(len(prof[:,0])):\n", + " spectrum = prof[i, 0]\n", + " spectrum.metadata = chooser.dataset.metadata\n", + " spectrum.metadata['EDS'] = {}\n", + " peaks, p = pyTEMlib.eds_tools.fit_model(spectrum, elements, use_detector_efficiency= True)\n", + " for element in chooser.dataset.metadata['EDS']['lines'].keys():\n", + " for family in chooser.dataset.metadata['EDS']['lines'][element].keys():\n", + " if family !='Z':\n", + " if 'height' in chooser.dataset.metadata['EDS']['lines'][element][family].keys():\n", + " if element+': '+family not in results:\n", + " results[element+': '+family] = []\n", + " results[element+': '+family].append(chooser.dataset.metadata['EDS']['lines'][element][family]['height'])\n", + " else: \n", + " for line in chooser.dataset.metadata['EDS']['lines'][element][family]:\n", + " if element+': '+line not in results:\n", + " results[element+': '+line] = []\n", + " results[element+': '+line].append(chooser.dataset.metadata['EDS']['lines'][element][family][line]['height'])\n", + " \n", + "\n", + "model = np.zeros(len(spectrum))\n", + "for i in range(len(p)-4):\n", + " model += peaks[i]*p[i]\n", + " pass\n", + "start = np.searchsorted(spectrum.energy_scale, 150)\n", + "energy_scale = spectrum.energy_scale[start:]\n", + "#p[-3:] = [100, 3, .007]\n", + "print(p[-4:])\n", + "E_0 = spectrum.metadata['experiment']['acceleration_voltage_V'][0]\n", + "\n", + "#model[start:] += (detector_efficiency[start:] * (p[-3] + p[-2] * (E_0 - energy_scale) / energy_scale + p[-1] * (E_0-energy_scale) ** 2 / energy_scale))\n", + "bgd = p[-4] / (energy_scale + p[-3] * energy_scale ** 2 + p[-2] * energy_scale ** .5) - p[-1]\n", + "\n", + "model[start:] += detector_efficiency[start:] * bgd\n", + " \n", + "plt.figure()\n", + "plt.plot(spectrum.energy_scale, spectrum, label='spectrum')\n", + "\n", + "plt.plot(spectrum.energy_scale,model, label='model')\n", + "# plt.plot(spectrum.energy_scale[start:], bgd*detector_efficiency[start:])\n", + "plt.plot(spectrum.energy_scale,spectrum-model, label='difference')\n", + "plt.ylim(0, 400)\n", + "p[:-4], E_0" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# next, aprallelize this func with SidFitter class" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null, @@ -1109,7 +1350,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.11.5" }, "toc": { "base_numbering": "2", diff --git a/pyTEMlib/eds_tools.py b/pyTEMlib/eds_tools.py index ca53056d..c87a8b84 100644 --- a/pyTEMlib/eds_tools.py +++ b/pyTEMlib/eds_tools.py @@ -212,7 +212,7 @@ def get_x_ray_lines(spectrum, elements): # omega_K = Z**4/(alpha_K+Z**4) # omega_L = Z**4/(alpha_L+Z**4) # omega_M = Z**4/(alpha_M+Z**4) - energy_scale = spectrum.get_spectral_dims(return_axis=True)[0] + energy_scale = spectrum.energy_scale for element in elements: atomic_number = elements_list.index(element) out_tags[element] ={'Z': atomic_number} @@ -314,7 +314,7 @@ def get_peak(E, energy_scale): def initial_model_parameter(spectrum): tags = spectrum.metadata['EDS']['lines'] - energy_scale = spectrum.get_spectral_dims(return_axis=True)[0] + energy_scale = spectrum.energy_scale p = [] peaks = [] keys = [] @@ -385,7 +385,7 @@ def get_model(spectrum, start=100): def fit_model(spectrum, elements, use_detector_efficiency=False): out_tags = get_x_ray_lines(spectrum, elements) peaks, pin, keys = initial_model_parameter(spectrum) - energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values + energy_scale = energy_scale = spectrum.energy_scale if 'detector' in spectrum.metadata['experiment'].keys(): if 'start_channel' not in spectrum.metadata['experiment']['detector']: From 0f80b43b33bbdf95a54531031787d23c350f729d Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Sat, 14 Sep 2024 12:35:42 -0400 Subject: [PATCH 04/14] support for 4D STEM --- notebooks/4Dstem_File_Reader.ipynb | 629 ++--------------------------- pyTEMlib/file_tools.py | 10 +- pyTEMlib/version.py | 4 +- 3 files changed, 52 insertions(+), 591 deletions(-) diff --git a/notebooks/4Dstem_File_Reader.ipynb b/notebooks/4Dstem_File_Reader.ipynb index 720e675e..93d93b1b 100644 --- a/notebooks/4Dstem_File_Reader.ipynb +++ b/notebooks/4Dstem_File_Reader.ipynb @@ -9,524 +9,83 @@ "### Last updated 2024-09-03" ] }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "import time\n", - "from datetime import datetime\n", - "\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import h5py\n", - "import mrcfile\n", - "\n", - "import sidpy" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "%matplotlib ipympl" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "mrc_filepath = '/Users/austin/Dropbox/GaTech_colabs/ScFeO3_Al2O3/2024_07_03/4D_stem/'\n", - "\n", - "save_path = '/Users/austin/Dropbox/GaTech_colabs/ScFeO3_Al2O3/2024_07_03/4D_h5_files/'" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "mrc_files = os.listdir(mrc_filepath)\n", - "mrc_files = [f for f in mrc_files if f.endswith('.mrc')]\n", - "mrc_files = sorted(mrc_files)\n" - ] - }, { "cell_type": "code", "execution_count": 5, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/1h/36qxtl8567zdjv8nzdn4fzrr0000gn/T/ipykernel_442/3194067291.py:21: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", - " x_shape = int(np.abs(sizes[0] - sizes[1]))\n", - "/var/folders/1h/36qxtl8567zdjv8nzdn4fzrr0000gn/T/ipykernel_442/3194067291.py:22: DeprecationWarning: Conversion of an array with ndim > 0 to a scalar is deprecated, and will error in future. Ensure you extract a single element from your array before performing this operation. (Deprecated NumPy 1.25.)\n", - " y_shape = int(np.abs(sizes[2] - sizes[3]))\n" - ] - } - ], - "source": [ - "mrc_raw = mrcfile.open(mrc_filepath+mrc_files[1], permissive=True)\n", - "\n", - "# Read the file\n", - "extended_header = mrc_raw.indexed_extended_header\n", - "metadata_labels = extended_header.dtype.names\n", - "metadata_labels = [label for label in metadata_labels]\n", - "\n", - "mrc_data = mrc_raw.data\n", - "\n", - "# Reshape the data\n", - "shape_cantidates = ['Scan size right', 'Scan size left', 'Scan size top', 'Scan size bottom']\n", - "\n", - "sizes = []\n", - "for label in shape_cantidates:\n", - " size = np.unique(extended_header[label])\n", - " sizes.append(size)\n", - "\n", - "# this part is a little confusing\n", - "# do we reshape L-R or T-B?\n", - "# the following is a guess\n", - "x_shape = int(np.abs(sizes[0] - sizes[1]))\n", - "y_shape = int(np.abs(sizes[2] - sizes[3]))\n", - "reshape_target = (x_shape, y_shape, mrc_data.shape[-2], mrc_data.shape[-1])\n", - "reshaped_data = np.reshape(mrc_data, reshape_target)\n", - "\n", - "# Get these 'pixel sizes' are usually in the order of 10^8\n", - "# is this the ceta pixel size?...\n", - "# what are the units?\n", - "pixel_sizes = []\n", - "for label in ['Pixel size X', 'Pixel size Y']:\n", - " size = np.unique(extended_header[label])\n", - " pixel_sizes.append(size)\n", - "\n", - "# get real space pixel sizes a different way\n", - "# but this results in different pixel sizes by ~0.01 Angstroms\n", - "# incorrect?\n", - "step_x = np.unique(extended_header['Full scan FOV X']) / x_shape * 1e10 # Angstroms\n", - "step_y = np.unique(extended_header['Full scan FOV Y']) / y_shape * 1e10 # Angstroms\n", - " \n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Metadata size [888]\n", - "Metadata version [2]\n", - "Bitmask 1 [49185]\n", - "Timestamp [45476.95348159 45476.9534819 45476.9534822 ... 45476.95412522\n", - " 45476.95412553 45476.95412583]\n", - "Microscope type [b'']\n", - "D-Number [b'']\n", - "Application [b'']\n", - "Application version [b'']\n", - "HT [300000.]\n", - "Dose [0.]\n", - "Alpha tilt [0.]\n", - "Beta tilt [0.]\n", - "X-Stage [0.]\n", - "Y-Stage [0.]\n", - "Z-Stage [0.]\n", - "Tilt axis angle [0.]\n", - "Dual axis rotation [0.]\n", - "Pixel size X [4.3988768e+08]\n", - "Pixel size Y [4.3988768e+08]\n", - "Unused range [b'']\n", - "Defocus [0.]\n", - "STEM Defocus [0.]\n", - "Applied defocus [0.]\n", - "Instrument mode [0]\n", - "Projection mode [0]\n", - "Objective lens mode [b'']\n", - "High magnification mode [b'']\n", - "Probe mode [0]\n", - "EFTEM On [False]\n", - "Magnification [0.]\n", - "Bitmask 2 [15728641]\n", - "Camera length [0.07066868]\n", - "Spot index [0]\n", - "Illuminated area [0.]\n", - "Intensity [0.]\n", - "Convergence angle [0.]\n", - "Illumination mode [b'']\n", - "Wide convergence angle range [False]\n", - "Slit inserted [False]\n", - "Slit width [0.]\n", - "Acceleration voltage offset [0.]\n", - "Drift tube voltage [0.]\n", - "Energy shift [0.]\n", - "Shift offset X [0.]\n", - "Shift offset Y [0.]\n", - "Shift X [0.]\n", - "Shift Y [0.]\n", - "Integration time [0.]\n", - "Binning Width [0]\n", - "Binning Height [0]\n", - "Camera name [b'']\n", - "Readout area left [1024]\n", - "Readout area top [1024]\n", - "Readout area right [3072]\n", - "Readout area bottom [3072]\n", - "Ceta noise reduction [False]\n", - "Ceta frames summed [0]\n", - "Direct detector electron counting [False]\n", - "Direct detector align frames [False]\n", - "Camera param reserved 0 [0]\n", - "Camera param reserved 1 [0]\n", - "Camera param reserved 2 [0]\n", - "Camera param reserved 3 [0]\n", - "Bitmask 3 [8290304]\n", - "Camera param reserved 4 [0]\n", - "Camera param reserved 5 [0]\n", - "Camera param reserved 6 [0]\n", - "Camera param reserved 7 [0]\n", - "Camera param reserved 8 [0]\n", - "Camera param reserved 9 [0]\n", - "Phase Plate [False]\n", - "STEM Detector name [b'']\n", - "Gain [0.]\n", - "Offset [0.]\n", - "STEM param reserved 0 [0]\n", - "STEM param reserved 1 [0]\n", - "STEM param reserved 2 [0]\n", - "STEM param reserved 3 [0]\n", - "STEM param reserved 4 [0]\n", - "Dwell time [0.0263296]\n", - "Frame time [0.]\n", - "Scan size left [0]\n", - "Scan size top [0]\n", - "Scan size right [22]\n", - "Scan size bottom [92]\n", - "Full scan FOV X [1.96305274e-08]\n", - "Full scan FOV Y [1.96305274e-08]\n", - "Element [b'']\n", - "Energy interval lower [0.]\n", - "Energy interval higher [0.]\n", - "Method [0]\n", - "Is dose fraction [False]\n", - "Fraction number [0]\n", - "Start frame [0]\n", - "End frame [0]\n", - "Input stack filename [b'']\n", - "Bitmask 4 [204]\n", - "Alpha tilt min [0.]\n", - "Alpha tilt max [0.]\n", - "Scan rotation [-2.0367534]\n", - "Diffraction pattern rotation [3.01700489]\n", - "Image rotation [0.]\n", - "Scan mode enumeration [0]\n", - "Acquisition time stamp [1720039980809786 1720039980836119 1720039980862443 ... 1720040036419159\n", - " 1720040036445482 1720040036471816]\n", - "Detector commercial name [b'Ceta-S speed']\n", - "Start tilt angle [0.]\n", - "End tilt angle [0.]\n", - "Tilt per image [0.]\n", - "Tilt speed [0.]\n", - "Beam center X pixel [0]\n", - "Beam center Y pixel [0]\n", - "CFEG flash timestamp [0]\n", - "Phase plate position index [0]\n", - "Objective aperture name [b'']\n" - ] - } - ], - "source": [ - "for label in metadata_labels:\n", - " print(label, np.unique(extended_header[label]))" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[array([4.3988768e+08]), array([4.3988768e+08])]" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "pixel_sizes" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Pixel size X Pixel size Y\n", - "[array([4.3988768e+08]), array([4.3988768e+08])]\n", - "Full scan FOV X Full scan FOV Y\n", - "[1.96305274e-08] [1.96305274e-08]\n", - "22 92\n", - "[8.92296701] [2.13375298]\n" + "SciFiReaders version: 0.11.6\n", + "pyTEMlib version: 0.2024.09.14\n" ] } ], "source": [ - "print('Pixel size X', 'Pixel size Y')\n", - "print(pixel_sizes)\n", - "\n", - "print('Full scan FOV X', 'Full scan FOV Y')\n", - "print(np.unique(extended_header['Full scan FOV X']), np.unique(extended_header['Full scan FOV Y']))\n", - "\n", - "print(x_shape, y_shape)\n", - "print(step_x, step_y)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0., 0., 0., ..., 0., 0., 0.])" - ] - }, - "execution_count": 27, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "extended_header['Frame time']" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.])" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.unique(extended_header['Frame time']) " - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.0263296])" - ] - }, - "execution_count": 26, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.unique(extended_header['Dwell time'])" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "### This is all for saving to file later, not important right now:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "# how can I get the pixel sizes? Should be easy for the real space, but how for reciprocal space?\n", - "mrc_dset = sidpy.Dataset.from_array(reshaped_data, name='MRC_000', chunks=(1, 1, reshape_target[-2], reshape_target[-1]))\n", + "import os\n", + "import sys\n", "\n", - "mrc_dset.set_dimension(0, sidpy.Dimension(np.arange(mrc_dset.shape[0])*step_y, \n", - " name='x', units='Angstom', quantity='Length',\n", - " dimension_type='spatial'))\n", + "%matplotlib ipympl\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", "\n", - "mrc_dset.set_dimension(1, sidpy.Dimension(np.arange(mrc_dset.shape[1])*step_x,\n", - " name='y', units='Angstrom', quantity='Length',\n", - " dimension_type='spatial'))\n", + "sys.path.insert(0, '/Users/austin/Documents/GitHub/SciFiReaders/')\n", + "import SciFiReaders\n", + "print(\"SciFiReaders version: \", SciFiReaders.__version__)\n", "\n", - "mrc_dset.set_dimension(2, sidpy.Dimension(np.arange(mrc_dset.shape[2]),\n", - " name='u', units='unknown', quantity='angles',\n", - " dimension_type='reciprocal'))\n", + "sys.path.insert(0,'/Users/austin/Documents/GitHub/pyTEMlib/')\n", + "import pyTEMlib\n", + "import pyTEMlib.file_tools as ft\n", "\n", - "mrc_dset.set_dimension(3, sidpy.Dimension(np.arange(mrc_dset.shape[3]),\n", - " name='v', units='unknown', quantity='angles',\n", - " dimension_type='reciprocal'))\n", + "print(\"pyTEMlib version: \", pyTEMlib.__version__)\n", "\n", - "# reading metadata\n", - "metadata = {}\n", - "for label in metadata_labels:\n", - " # later, we may want to remove 'np.unique()', but I see no problems now\n", - " metadata[label] = np.unique(extended_header[label])\n", "\n", - "mrc_dset.metadata = metadata" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# now this is for a different notebook:\n", - "# clustering" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ + "# for beginning analysis\n", "from sklearn.cluster import KMeans\n", - "\n", "from sklearn.decomposition import PCA\n", "from sklearn.cluster import KMeans\n", "from mpl_toolkits.mplot3d import Axes3D\n", - "\n", - "from scipy.ndimage import center_of_mass" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "mrc_dset = mrc_dset[:,:,20:180,40:200]" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "bffb9a8e394b4a2b82dbee6c8ede535f", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# perform nmf on the data\n", - "fig, axs = plt.subplots(5,5)\n", - "for i in range(5):\n", - " for j in range(5):\n", - " axs[i,j].imshow(mrc_dset[i,j,:,:], cmap='plasma')\n", - " axs[i,j].axis('off')\n", - "fig.tight_layout()" + "from scipy.ndimage import center_of_mass\n" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ - "# get COM for all images\n", - "coms = np.zeros((mrc_dset.shape[0], mrc_dset.shape[1], 2))\n", + "mrc_filepath = '/Users/austin/Dropbox/GaTech_colabs/ScFeO3_Al2O3/2024_07_03/4D_stem/'\n", + "\n", + "files = os.listdir(mrc_filepath)\n", + "files = [f for f in files if f.endswith('.mrc')]\n", "\n", - "# Compute the center of mass for each image\n", - "for i in range(mrc_dset.shape[0]):\n", - " for j in range(mrc_dset.shape[1]):\n", - " coms[i, j] = center_of_mass(mrc_dset[i, j, :, :])" + "\n", + "# Load the first file\n", + "dset = ft.open_file(mrc_filepath + files[1])" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "714d1e99b56145468995504a0c07e790", + "model_id": "a4751d8cf9c14e1f8b72efbcceeea284", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", - " Figure\n", + " generic\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -539,42 +98,42 @@ } ], "source": [ - "plt.figure()\n", - "plt.hist(coms[:,:,0].flatten(), bins=20, color='r', alpha=0.5);\n", - "plt.hist(coms[:,:,1].flatten(), bins=20, color='b', alpha=0.5);\n" + "data = dset['Channel_000']\n", + "\n", + "view = data.plot()" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "mrc_array = np.array(mrc_dset)\n", - "N, M, height, width = mrc_dset.shape\n", + "mrc_array = np.array(data)\n", + "N, M, height, width = data.shape\n", "datacube_flat = mrc_array.reshape(N * M, -1)" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1f15ec784a34425290031c821e51218a", + "model_id": "4d27c7ac67a04e9aac72e2dee2a75fb9", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -588,7 +147,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8c9b61bb476748d0a518159e2b6f067c", + "model_id": "dca60fc6df6e47d7983babea1e450180", "version_major": 2, "version_minor": 0 }, @@ -613,18 +172,18 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1e48ae0ecad94b92aecbbd4c28ac6629", + "model_id": "07a816072a7845dd915f5d0db3a9d377", "version_major": 2, "version_minor": 0 }, - "image/png": "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", + "image/png": "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", "text/html": [ "\n", "
\n", "
\n", " Figure\n", "
\n", - " \n", + " \n", "
\n", " " ], @@ -682,108 +241,6 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3a11c48809bc48c7bf0791b9dadf948c", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "flattened_coms = coms.reshape(-1, 2)\n", - "P = flattened_coms.shape[0]\n", - "colors = plt.cm.viridis(np.linspace(0, 1, P))\n", - "\n", - "plt.figure()\n", - "plt.scatter(flattened_coms[:, 0], flattened_coms[:, 1], c=colors, s=10, alpha=0.5) # 's' is the size of the points\n", - "plt.colorbar()" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "87f83897535c4e2da9abf799ff214c3c", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig, ax = plt.subplots(1,4, sharex=True, sharey=True)\n", - "\n", - "ax[0].imshow(np.sum(mrc_array, axis=(2,3)), cmap='plasma')\n", - "ax[0].set_title('Bright Field')\n", - "\n", - "ax[1].set_title('COM X')\n", - "ax[1].imshow(coms[:,:,0], cmap='plasma')\n", - "\n", - "ax[2].set_title('COM Y')\n", - "ax[2].imshow(coms[:,:,1], cmap='plasma')\n", - "\n", - "ax[3].set_title('Clustered')\n", - "ax[3].imshow(label_image, cmap='viridis')\n", - "\n", - "for a in ax:\n", - " a.axis('off')\n", - "fig.tight_layout()" - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/pyTEMlib/file_tools.py b/pyTEMlib/file_tools.py index b0bc425c..d48fb2c0 100644 --- a/pyTEMlib/file_tools.py +++ b/pyTEMlib/file_tools.py @@ -44,7 +44,8 @@ Dimension = sidpy.Dimension -get_slope = sidpy.base.num_utils.get_slope +# Austin commented the line below - it is not used anywhere in the code, and it gives import errors 9-14-2024 +# get_slope = sidpy.base.num_utils.get_slopes __version__ = '2022.3.3' from traitlets import Unicode, Bool, validate, TraitError @@ -595,7 +596,7 @@ def h5_group_to_dict(group, group_dict={}): def open_file(filename=None, h5_group=None, write_hdf_file=False, sum_frames=False): # save_file=False, - """Opens a file if the extension is .hf5, .ndata, .dm3 or .dm4 + """Opens a file if the extension is .emd, .mrc, .hf5, .ndata, .dm3 or .dm4 If no filename is provided the QT open_file windows opens (if QT_available==True) Everything will be stored in a NSID style hf5 file. @@ -654,7 +655,7 @@ def open_file(filename=None, h5_group=None, write_hdf_file=False, sum_frames=Fa if not write_hdf_file: file.close() return dataset_dict - elif extension in ['.dm3', '.dm4', '.ndata', '.ndata1', '.h5', '.emd', '.emi', '.edaxh5']: + elif extension in ['.dm3', '.dm4', '.ndata', '.ndata1', '.h5', '.emd', '.emi', '.edaxh5', '.mrc']: # tags = open_file(filename) if extension in ['.dm3', '.dm4']: reader = SciFiReaders.DMReader(filename) @@ -690,6 +691,9 @@ def open_file(filename=None, h5_group=None, write_hdf_file=False, sum_frames=Fa elif extension in ['.ndata', '.h5']: reader = SciFiReaders.NionReader(filename) + elif extension in ['.mrc']: + reader = SciFiReaders.MRCReader(filename) + else: raise NotImplementedError('extension not supported') diff --git a/pyTEMlib/version.py b/pyTEMlib/version.py index ea5db57a..8f0e45e2 100644 --- a/pyTEMlib/version.py +++ b/pyTEMlib/version.py @@ -1,6 +1,6 @@ """ version """ -_version = '0.2024.02.2' +_version = '0.2024.09.14' __version__ = _version -_time = '2024-02-26 19:58:26' +_time = '2024-09-14 12:06:58' From b7da4ee278c22a3b6e35377c15ce7afd8dbd809d Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Sat, 14 Sep 2024 12:36:27 -0400 Subject: [PATCH 05/14] dependency update --- notebooks/4Dstem_File_Reader.ipynb | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/notebooks/4Dstem_File_Reader.ipynb b/notebooks/4Dstem_File_Reader.ipynb index 93d93b1b..deb76b9e 100644 --- a/notebooks/4Dstem_File_Reader.ipynb +++ b/notebooks/4Dstem_File_Reader.ipynb @@ -6,7 +6,7 @@ "source": [ "# Basics of reading an MRC file with 4D STEM data from the Spectra300 at UTK\n", "## By Austin Houston\n", - "### Last updated 2024-09-03" + "### Last updated 2024-09-14" ] }, { @@ -31,23 +31,15 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", - "sys.path.insert(0, '/Users/austin/Documents/GitHub/SciFiReaders/')\n", - "import SciFiReaders\n", - "print(\"SciFiReaders version: \", SciFiReaders.__version__)\n", - "\n", - "sys.path.insert(0,'/Users/austin/Documents/GitHub/pyTEMlib/')\n", "import pyTEMlib\n", "import pyTEMlib.file_tools as ft\n", "\n", "print(\"pyTEMlib version: \", pyTEMlib.__version__)\n", "\n", - "\n", "# for beginning analysis\n", "from sklearn.cluster import KMeans\n", "from sklearn.decomposition import PCA\n", - "from sklearn.cluster import KMeans\n", - "from mpl_toolkits.mplot3d import Axes3D\n", - "from scipy.ndimage import center_of_mass\n" + "from sklearn.cluster import KMeans\n" ] }, { From d09716dd93c1dc0eee91940e9c8fc27f169597c0 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Sat, 14 Sep 2024 12:58:16 -0400 Subject: [PATCH 06/14] clear all outputs --- notebooks/4Dstem_File_Reader.ipynb | 135 +++-------------------------- 1 file changed, 14 insertions(+), 121 deletions(-) diff --git a/notebooks/4Dstem_File_Reader.ipynb b/notebooks/4Dstem_File_Reader.ipynb index deb76b9e..1d1aec2f 100644 --- a/notebooks/4Dstem_File_Reader.ipynb +++ b/notebooks/4Dstem_File_Reader.ipynb @@ -11,18 +11,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "SciFiReaders version: 0.11.6\n", - "pyTEMlib version: 0.2024.09.14\n" - ] - } - ], + "outputs": [], "source": [ "import os\n", "import sys\n", @@ -31,9 +22,14 @@ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", + "sys.path.insert(0, '/Users/austin/Documents/GitHub/SciFiReaders/')\n", + "import SciFiReaders\n", + "\n", + "sys.path.insert(0, '/Users/austin/Documents/GitHub/pyTEMlib/')\n", "import pyTEMlib\n", "import pyTEMlib.file_tools as ft\n", "\n", + "print(\"SciFiReaders version: \", SciFiReaders.__version__)\n", "print(\"pyTEMlib version: \", pyTEMlib.__version__)\n", "\n", "# for beginning analysis\n", @@ -44,51 +40,24 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "mrc_filepath = '/Users/austin/Dropbox/GaTech_colabs/ScFeO3_Al2O3/2024_07_03/4D_stem/'\n", + "mrc_filepath = '/Users/austin/Dropbox/GaTech_colabs/SnSe_MgO/2024_06_19_data/4D_STEM/'\n", "\n", "files = os.listdir(mrc_filepath)\n", "files = [f for f in files if f.endswith('.mrc')]\n", "\n", - "\n", "# Load the first file\n", "dset = ft.open_file(mrc_filepath + files[1])" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a4751d8cf9c14e1f8b72efbcceeea284", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " generic\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "data = dset['Channel_000']\n", "\n", @@ -97,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -108,85 +77,9 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4d27c7ac67a04e9aac72e2dee2a75fb9", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHgCAYAAAA10dzkAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAADGAklEQVR4nOzdd5ycV3n3/8+5y9Sd7U29S5ZlyV1uYHChmE4ILYQkPEBoD2mEJEAKKdQQSvyYXyABAk6CaXEcG2yDce+WLVu2epe2afvOTr3LOb8/7p3Vqku2tl/v10uWvDvlzOzuzHevc851lDHGIIQQQgghZg1rsgcghBBCCCEmlgRAIYQQQohZRgKgEEIIIcQsIwFQCCGEEGKWkQAohBBCCDHLSAAUQgghhJhlJAAKIYQQQswyEgCFEEIIIWYZCYBCCCGEELOMBEAhhBBCiFlGAqAQQgghxCwjAVAIIYQQYpaRACiEEEIIMctIABRCCCGEmGUkAAohhBBCzDISAIUQQgghZhkJgEIIIYQQs4wEQCGEEEKIWUYCoBBCCCHELCMBUAghhBBilpEAKIQQQggxy0gAFEIIIYSYZSQACiGEEELMMhIAhRBCCCFmGQmAQgghhBCzjARAIYQQQohZRgKgEEIIIcQsIwFQCCGEEGKWkQAohBBCCDHLSAAUQgghhJhlJAAKIYQQQswyEgCFEEIIIWYZCYBCCCGEELOMBEAhhBBCiFlGAqAQQgghxCwjAVAIIYQQYpaRACiEEEIIMctIABRCCCGEmGUkAAohhBBCzDISAIUQQgghZhkJgEIIIYQQs4wEQCGEEEKIWUYCoBBCCCHELCMBUAghhBBilpEAKIQQQggxy0gAFEIIIYSYZSQACiGEEELMMhIAhRBCCCFmGQmAQgghhBCzjARAIYQQQohZRgKgEEIIIcQsIwFQCCGEEGKWkQAohBBCCDHLSAAUQgghhJhlJAAKIYQQQswyEgCFEEIIIWYZCYBCCCGEELOMBEAhhBBCiFlGAqAQQgghxCwjAVAIIYQQYpaRACiEEEIIMctIABRCCCGEmGUkAAohhBBCzDISAIUQQgghZhkJgEIIIYQQs4wEQCGEEEKIWUYCoBBCCCHELCMBUAghhBBilpEAKIQQQggxy0gAFEIIIYSYZSQACiGEEELMMhIAhRBCCCFmGQmAQgghhBCzjARAIYQQQohZRgKgEEIIIcQsIwFQCCGEEGKWkQAohBBCCDHLSAAUQgghhJhlJAAKIYQQQswyEgCFEEIIIWYZCYBCCCGEELOMBEAhhBBCiFlGAqAQQgghxCwjAVAIIYQQYpZxJnsAQghhjCEMQwBs20YpNckjEkKImU0CoBBiUmmt8X2fYrGIMQbLsnBdF9u2cRwHy7IkEAohxFmmjDFmsgchhJh9KlW/IAhGQ2Dl5UhrDYBSajQQOo6DbdsSCIUQ4iyQACiEmHDGGHzfH532VUrhed7ovyuXqfyRQCiEEGeXBEAhxITSWuN5Hlrr0fBmjDkmAB7tRIGwMlUsgVAIIU6fBEAhxISoTPlWpnrHBrVKRdAYc9rhbWwgrPyxLAvLsiQQCiHEKUgAFEKMO601QRAcMeU7NpS9mAB4tKOrg5X7kUAohBDHkl3AQohxUwlkY8PdeIWvym1bljV632M3mlQ+X5kyrvw9nmMSQoipSiqAQohxYYwhCAKCIACOrfodfdmXWgE8nfFUAunYMHr0GkIJhEKI2UACoBDirKtU/cIwPKIqdyITEQCPd58nCoSVPoSVKWMhhJhpJAAKIc6ao3v7ne56u8kIgMcbw9hACByzflACoRBippAAKIQ4K47X2+9MdvROdgA8mgRCIcRMJgFQCPGSHa+335mYigHwaEeHQYhCrgRCIcR0JAFQCPGinay335nezlQPgEc7nUBY2WUshBBTjQRAIcSL8lKmfE90W5UK4nQ0NhBWgqxlWcfdZSyEEJNNAqAQ4oxVqn4vdsr3aDMhAB7tRIHw6CljCYRCiMkgAVAIcdrOpLffmd7uTAuAY1VeZiUQCiGmCgmAQojTUuntVzlq7Ww2TJ7pAfBoEgiFEJNNAqAQ4qTGHud2tqZ8j3cfsykAHm1sINRajz6/EgiFEONFAqAQ4oTO5kaP07mf2RoAj1apClbC99hAWDmlxHGccQnjQojZwZnsAQghpqaxx7lJ0JhYY4O2bdtHBMJSqTR6mUogrFQI5eskhDhdEgCFEEd4sce5ifEjgVAIcbbJFLAQYtRETfkez9hqozgzR08ZQ/S1O7oHoQRCIUSFBEAhBHD2e/udKQmAZ8/YQFj5Y1nWMZtKJBAKMXtJABRilhvb2++lHOf2UkkAHD9HVweB47adkUAoxOwhAVCIWUxrTRAEkzLlezQJgBPnRIGwMmU89hxjCYRCzEyyCUSIWWhsb79KE2J5o589Kl/vStiuBMIgCPB9f/TzxzvHWL5PhJgZJAAKMctM5kaPk5kKY5itziQQVvoQVqaMhRDTkwRAIWaRqdzbT1ajTB0SCIWY+SQACjELSG8/8VKcKhDC8Y+tk0AoxNQlm0CEmOGm6pTv0WQTyPQ1dlPJ2DWlEgiFmLokAAoxg2mt8TxvWlT9JADOHGPDYMXRgbCyy1gIMTkkAAoxA1WmfCu7fKd6+AMJgDPZ2EB4vArh2F3GQoiJIQFQiBlmKvX2OxMSAGeP4wVCy7KO2VQyHb5vhZiuJAAKMUNM995+ldNIJADOLpW3oOMFwqPXEE6n72chpjoJgELMAGOPc4PpU/UbSwKgAAmEQkwUCYBCTHNje/uNbdUx3UgAFMdzdCCskEAoxEsjAVCIaWqm9farbFqRAChOplIVrCx5qHzPSyAU4sxIABRiGpouvf3OhARA8WIcHQiB0Uq467qjgXC6/4IkxNkmJ4EIMc1Mp95+Qoy3sb/82LZ9RCAslUqjl5FAKMSRJAAKMU1Mx95+Z0omJMRLdbqBsNKMWgKhmK1kCliIaWAmTvkerXKurG3bkz0UMYMdb8rYsqxj1hBKIBQznQRAIaa4StVvpk/5SgAUk+HoMFiprksgFDOdBEAhpqiZ0NvvTEgAFFPB0YEQjlxDOPYc45n88yhmPlkDKMQUVOntN3ZXo7zZCDH+Kj9rld3olUBYablU+fzRawjlZ1RMNxIAhZhCxh7nNtOnfIWYDk4UCCsV67GBcOw5xtLOSEx1EgCFmCKO3ugh4U+IqUcCoZgpJAAKMQWMPc5Ngp8Q08epAiEc/5QSCYRiskkAFGISzbTj3F6K2fq4xcxyokDo+z6e541+XgKhmGyyC1iISTIbevudiTAM8TxPdgGLGa2yznfsW+/RgbCyy1iI8SQVQCEmwWzp7SeEOFJlfWDF2I1fx6sQjt1lLMTZJBVAISbQ2N5+M/U4txdLa025XJYKoJjVxlYIjTGj08lHbyqR1w3xUkkAFGKCaK0JgkCmfE9Aa43nebIWSogxThQI77//fizL4o1vfONkD1FMU/JKK8Q4q2z08DyPMAxHX8Al/AkhTuV4TaeNMdx+++3cd999kz08MY1JABRiHI3d/Vf57V2CnxDixRjbY7BQKJBOpyd7SGIak00gQowT6e0nhBgv+XxeAqB4SSQACnGWSW8/IcR4y+fzVFVVTfYwxDQmAVCIs0iOcxNCTAQJgOKlkgAoxFlS2cUqVT8hxHiTNYDipZIAKMRLVJny9X1fevsJIcadMUYqgOIlkwAoxEtwdG8/CX9nhzGG7U/uZsujO8gP5Vl47nzOv2YNtU3Vx728X/bp6xgAA3VzaoknYxM8YiEmVi6XI5PJTPYwxDQmAVCIF2Hs8U3S3uXsMsZw3389zAO3PI7v+TiOzeaHd7Dpvi28+y/fSuO8+iMu376zk033baH/0BAYQ01TNWuvXs2iNfMn6REIMf4KhYJUAMVLIn0AhThDlePcpLff+Oje38ujt24gnoqxYNVc5ixrYf6qObTv7OTRW5864rKDPVme+sWzDPUN07K4idalzRSGi2y4+zl62/sn6REIMb4qU8AzZQ1gEAQMDQ2N/n8YhnR1dZHL5SZxVDOfVACFOANje/tVTvQQZ9f+zW0UskXmr5oz+jHbtsjUVbHtiV28/sPXYzvRecG7N+5jx4Y9lIseT9+9iXg6ztxlLcQSLm07Oo+pFgoxExSLRbTWM2IK+LHHHuPGG2+kUCjwgQ98gCuvvJJvfvOb3HPPPSxevJiPfvSjrF+/frKHOSNJABTiNEhvv4mjrOM/r1prdKjpOdjHtid2se/5g2y4+1n6OgYxoQYVrcE8sKWNmsZqWpY0c8E1ayZ49EKMv3w+DzDtp4C3b9/O3/zN39Db28u8efP4p3/6J26//XZ+9atf8Y53vIO77rqL97///fziF79gwYIFkz3cGUfKF0KcQqW3n+zynRhL1i2kqjZNf+fg6Me6D/Sy8+m97Hx6D5957Rf56T/ezoM/foyOXYco58v4ZZ/AD0EpLEuR7c2y7fGdGGMm74EIMU7y+TyWZZFMJid7KC/JAw88QDab5YEHHuD2229n7dq13HXXXdx111188Ytf5Oc//zmLFy/m5ptvBqJfAsXZIxVAIU5CevtNvMZ59Vxw/Rru/s797HvhIGGgKWSLuHEbjE0xV6SQLVAueaPXMSb6j1fyMFqTqUuT7R2mt62fpgUNk/dghBgHlfV/0/31qLOzk3nz5o1OZdfW1rJ48WJWrlyJ1pp58+axYMECDh48CCC/0J1lUgEU4jgqGz3K5bKEvwl2YGs7zz+4DQA36VLMlTAYGuc3AIpkJolf9kEDI+8H6eqQ5rklbDtAa0N1YzWWbaFDqRiImSeXy82IABgEAZZl4fs+AM3NzVx11VUAo+urs9ksjiO1qvEgz6oQR5Hj3CaPV/b54eduZdcze0lWJXBcF8tS2I4zOiVstEaHUfJLVYW87cPdXHb9MG5cM9TncO+tjWx/vpXmhY00zpdNIGLmmSmngCxfvpyhoSF6e3uZM2cOH/zgB4/4fE9PDwMDA1x00UWTNMKZTQKgEGNUTvSQqt/keOL2p9m9cR/JTILqhiTLV7dT33iAMFA8/0SGrU9nKBeCkUsb3v+XHVzyymHywzbFnEVdU8A7PtLJL35YRWbeVfjlYHTHsBAzRT6fJ5VKTfvXp9e85jWcd955pFIpAOLxOMBoe62NGzfS0NDA5ZdfDiBdF84yCYBCcHjKNwiicCHhb5wYA+F2lOnGWAvAXjL6qXLRY/fG/cxfWubCqzu57NoOahtLhIHGGLjubX3c+9913PyVFoxRLFldYu1leQb7HIq5KOSVCjZN8wKueUs3N9+4mXKxzBs/+mriqfhkPWIhzrpcLjftdwADtLa20traeszHK6+9r371q3n1q199zMfF2SEBUMx6ld5+lR1m0th5nOhu7MLnUcFmwAfiaPcydOrPQFVRzpdZc+FG3v3BjaTSZRJJjdaQHbDpOhAjldFc89YBNj5UxfOPVzFnUZlUJqRYUFiWQWsFCkoFh3SNR3VdwOaHtrP84qXSDkbMKDPpHOBKtU9MPKmnilmr0tvP87wjGjvLi9E4MGYk/D0DKgGqEZSD5T+AVbwJgHTVAS592VMoQrQ2hCGEIVTXhdQ2hOSzNm5cc+HLh1m4osRb3t9LbWPAknPKLDuvSF2TDxhsOyDb6/PcAwdo393Fr3/wIIEfnHx8QkwjM+kUEHm9nTxSARSzkmz0GB8Dh4Z4+leb2LlhN7Ztc+5VK7no+rWkUgeiyp+qAVXpXZYGQiz/AbT+AGHu1yhVZqhP0bJAAQajFcY2VNcHDPQ6KCCZ1vzfL7TRusCjVLSIxTVuDFoXejgxg+MY7ru1lv4uj6o6h/YdXbzw0HYuuFaqgGJmmEkBUEweqQCKWafS2y8IAqn6nUXZvmF++k+38+CPH2W4P0d/1yC/+vcHuPWf7yQodVKZ9j1SAoxH156tbPzV44RBCEZRyluMfkkMWDbE4powVGgNLfM9uttd2nYlKOVtjAEnZqhtCHjslzXc9r0mAi+gnPfINFax5dHtE/tkCDGOZtIUMEC5XJ7sIcxKEgDFrFHZ6FGZ8pXgd3ZtenArB7d1sHD1fBrnN5CuSZGqSbH1sR3s2ayJwl/xyCuZAkEQ4wd/9yBP/LKE1uC4muEhG69s4bgGywaMob4lYNszKbJ9DgaFDhVeSbFve4KDuxL0dbocaovxL38zl1Lh8NfWK3oc3NpBbjA/0U+JEONipmwCqWy6+6u/+iv2798PHG72XPn7jjvuoFQqTc4AZzgJgGJWkOPcxt/+zQeJp2L4XsDWx3aw6cEtbH9qN/s2t3H7t3cQWJeCzoLuBN0FYQeYEls2ruDJO/fw8M/T7Ho+QXV9SDoTks9aBL5Ch6P9nmmZ7zF/RQmFwbJHPmqgMGyhNezfkQATfV0d1yYMQzr3dNN9oJeffuUOOnYfmpwnR4izqFgszogAWGnw/JWvfGU0DFZelyt/v+lNbyKbzU7OAGc4WQMoZjzp7TcxEqk4gRew65m99HcOkKpOooBCtsALD23j4TtX8spXKzBDo9cxqoH/+XYJv+QRasWXP76IN/+fHq563RBuzJDd61BTHzA86FAqWKSqQtZdkUcHiuZ5PgM9DmEA1fUhgW9x33/Xjd621oZYzKFxbh0rL1tOb1s/D/7oMd7+Z2+U3oBiWsvlcqO986azn/3sZ1RVVZFIJHj22WfJ5XIkEgni8TiJRIK2tjZqampmRNidiiQAihlrbG8/qfqNv1Xrl/PUnc9yaF83iXSCUqFMtncYHWosZWiu+y/ywz7KaiGRjmEpGx308abf2crjdy7EtiyyAw43f2UON3+lldaFZT77vf0M9jrkhqKXqnLRorbRxxjobo8zZ7GHbRuy/Q4/v7mBJ38dnSmKAR1qmhc1cs7lK6huzJBMJ+ja10PX3m7mrZgzic+UEC/NTFkD+I//+I8AlEolPv/5zxOLxbAsa/S1es+ePVx77bUzIuxORRIAxYyktSYIAtnlO4Hi6Tj5bIHcQJ7cYB4dGmzHprqxirmLemiZX2TgkI02OeLJGPWttegwzYLlfcxfVqZtdxJlKUxoAEXLAp9EStPd7h5xP4Vhm0xdyHc/NwdlQSyhObAjQTF/VFVPGeKpOG48ur4Ts9FBSOCFZ/S4ykWPQ/t6KOZKJKsStC5pJpZwT31FIcZJoVCY9gHQGMNf/dVfMTw8zN/+7d/ye7/3e2itKZVKlMtljDG8733v453vfOdkD3XGkgAoZhRjzGhj50qDUQl+42+oJ8vP/+VXpGtS1DTXUC6UKRXK2K5FcbiEbftYNuhQEWpNMVeir2OAhnkZbEeRqoq+bqOL/YChPgevrEgk9RHhLp7UeGXFYJ/DYO8JgpgC27YY6snSc6CXhWvmM9A1SHVD5pjzgY0xtO/oZMfTeyhmS7QsaaJlURPZvmEGDg3Rtr2DwAtGf4loXtTIpa+7gOqGzHg8lUKc0kxoA6OU4vWvfz0Ac+fO5eqrr57kEc0+EgDFjHF0bz8JfxNnx4bd9LUPsPT8RWhtOLi1Ddu20KHmnAv6ueq1WdxYSF2zpq8rBsaimCtRzBYZHnA4sDOOApSt0GGUAvdtS7BzU5K1l+UxhpE1gJp0TciD/1t74vAHWJbCibt4RY+OXV1YjoXt2FzxpktJ1xw5nbTxnue59z8epjAc7TTsa++nXPRomF+PCTWBH7JozXxWrV+OZVt07uri+Qe2cuVbL5XvLzHhjDHk83kymen/C0gYhti2zdVXX82jjz5KX18fsViM6urq0bV/NTU11NTUTPZQZyQJgGJGqFT9pL3L5MgPFVEW2LbN0nWLKBdKtO3o5N0fb+PV7+jDjRkcF+KJkGSqyECvgxszeEWL2747F1QKZY/0AlNmpBKo+M7n5vLBv+5g+XlFahsDykWLDfdmuOXGlpOOx7ItGubURVPAMYflFy5h9RUrWX7R4iMuN9iT5cEfPwEo5q+cw/andtPXOYBfDigXyliWReOCenrb+6nd182Cc+bRMK+eQ/t7Ge7PSRVQTIqZsgbQtm1KpRLf+ta3+Od//mc8z2NoaGj0tTwIApYtW8bOnTtHN/GJs0cCoJjWKse5BUEgu3wngO8F+GWfZFXiiOe5fm4tgRewZ9M+hvvyKEtx8TWKV7+jjyBQZPujKdxMXUBtY4AbM2x9Os3dtzSw+ekW5ixrYqBrEDfu4HsBA11DgKG/2+VLH1s4ctRbQHdbjAM748DJv8ZhqPHKPq1Lmnnd71/HBdedd9zLHdzaznD/MPNXzaXnQB+9bX3YtoWTjhMGGlzo7xokWZWg52Af81fNxXZtdKCjzwsxCWbKGkClFNu3b+dzn/scv//7v8+73vUuYrEYnufh+z75fJ5EIgEg4W8cSAAU05Yc5zZxSvkSj93+NJvu34JX9GhZ3MTlb7yYlZcsA6BpQSPD/Xl6DvaSqIqjQ8NVr2rHiRmyA4dfuIcHHCwLuttjfO7DywkDTSwZra9L16bRQcgF153HI//9FEZrfD/EK3jsfuEUuwCjk+MAsGyF4zr45YBYMsY5V6w44dWMNiNXV/R3DQAKvxwQBuHI6SI2pVyZ4f4cNU3VYGCoO0t1UxWZ+um9BktMT1rrGbEGsKKjo4Pq6mr+4R/+YbKHMutIABTTUuU4N6n6jT+tNXd86x6e/fULpGtSxJIxBtpfoOO5u5nTVEtN83IObKomUZWgdWkLHbu6KOVLGBNgNBxdrTMaHNdEu3EtCIOQYq6EZauodY8fsvLiJQz15cj2DtNT7Dtic0gl7ClLRWv7LAttDI5jY9mKmuYaAi9g8ZoF1DRVE3ohnCA/zl81h6raNP1dgxhtCMo+gRe1DXKTMVzXoTBcpPtAH4vXLaRjVxfxVJzVl6/AceXlU0y8QqGAMWbarwGsvGYvX76cG264gSeeeILLLrtskkc1u8grmJhWKlO+cqLHxGnf0cm2x3fStCA63i1TvZerrnuYZCqHP+wSJJ5nxXLNBVeu4t6fRieB2K7D5qequOE9fcQTmnLJGgltBidmePqBkekrDToICcOQbF+eTH0VsYTL6z58PedcvoJdG/dy81//lANb29GBRmuNUmok+CviiRjxVGx0OimRjpNMJ3AbXJoWNmI7Fso68fdH/Zw6rnjzJTzw48co5krks4VoE4oCih5hORgZt4Vf9oklYjQtqGfrYzvZ9MBW5q2Yw7ILFpGpn97TcWL6KBQKADNmClhrzbZt2/jYxz7Gpz/9aZqbm6mqqiKTyZBMJqmrqyOZTE72cGckCYBi2pDefuPIGNC7ULofY80De/7op7oP9lEuerTWpBgezPKKV/2KhpYsuUGH/KBmqB9qG8pcfu3z/PKHK6LQpSw2PZphw30Z1l83TCoTorXCtg2HDsa44weNo7evQ0MxW2Th6vm88t1XcsF151HfWgvAuqvP5ff/6b38+2du4dC+bor5MkE5wFY2yao481fNJZ8t0rO/BwPEkjGUpVhwzlxyg3nWXn0OqeqTv3lc9saLqJ9by7c/cfPoDmQMhIEmVBo37hD6AR07D7Hv+TZsx2Lt1aupba5m0/2b6dxziJf9xnoJgWJC5PN5HMchHo9P9lBekkoAfOGFF9iyZQu1tbW8733vw3Gc0c8NDAzwsY99jBtvvJEgCEaPjhNnhzybYsqT3n7jTPdiF74G4QsoPAxJjHslOvlRUCmS6QSWpQi8Mle+4k5WrB0AIJEMaWz1yA1Db2eSTG2OpavzbH4qAxjCEG78i/lc89ZBrnjNEMm0ZtNjVdx9Sz19XUe2cAn8kD/81gepn1t7zPBWXLyED3/9d3jqrufo2NlFuibFyvXLqG6oYtcze+ltH2BgSRO9bf04rkN1Ywa/HDBvRSsXvWrdKR++V/J54aHtdO/rQ1lRFh4rDDSokMFDQxRzUauYZ+99gdd/+HpqW2po29bJ/s1tnPfyc17U0y/EmagcAzfdN0VUxn/99ddz5513Eo/HsSyLfD7P8PAwQRAwNDTE8uXLgWjHsDi7lDFHv9wJMXWMPc4NpLffWWcMdv7TqOAZjFUPJIA8ygyh3dejE++glPN44mdfJ5HYx7kX76OqOiAMLHSocFywHOhuT6EI+H+fWcymR5Moy8IreUeu3TsJ27F4zfuv4Zr3vIwlaxec0ZtbGGps26K/a5D9L7RRzBWpba5hydoFJDMnr/617ejkp1++nece2MxQz/DoeCvTxpVNIrZrE0/F8MsBSimM1qy75lyueut6eg72UddSw/W/I41sxfh79NFH+T//5//Q1tY2o14Lfd/nwIEDtLS0TPvp7elCKoBiyqpU/bSO2m1M9994p6RwB4RbovCnRnYVmgzG9GKVf4BVvoUq8lz35pFTOhQEAdiOxhgHgwXGp6Yuz8Hd1ezbXkUsYaO1xnasqHp2GiEwDDW/vvkhNtz1HFe//XJ+409eTyJ97BSX1pquvT107j5EUPZpXNDI/JWt2Kk49a21o1PHp+PZe1/g+5/5MYcO9FLKl44YZyX4jY4vCCmNVP+UstBas/3J3Vx4/VoCPySeip32/QrxUhQKhRmzA7jijjvu4LbbbuPBBx/kQx/6EH/yJ3/C008/zd69e7n22mupr68/9Y2IMybvqGLKqVT9PM8jDEOUUhL+xokyfSjKQBJMGcKDqPAZlOkBysAwI1t5R18tHCfaxRtLhFi2j7I0xig2P3slVbWN0TFsTnThSsX2VIWKRDpBujZNKV/miZ9v5N7/eviYyxhj2PLIDh752RPsfGo3B7a288QdT/P47c+MTs2ern2bD3LLF26jY88hyoXSqUOqidYq6jDahGSMoThcYtN9W9BByIJz5p3R/QvxYuXzeVKp1LSv/lUmHx944AH+8i//crSl16FDhwAol8t861vf4oknnjji8uLskXdVMaVUevvJLt+JYaw5GJJg+lHhVpTpAIKRT3JkMBrzb6WiXFgYVnglm2cfX0tf7zouuPY8Vl26jLnLWll2wWJiCRdjzDHr6o5mWQq/7BP4AY5jsfGeFygXykdcpr9zkO1P7aaqLs28VXNoXdrMnGUttO/oYP/mg6f9mL2Szw//4Vb2PX8Qv+yP5tvTUmlBo6IqYfvOTlZesowFqyUAiomRy+VmxBRpZWbnpptu4rLLLuPf//3fueSSS4jFomr6+vXryefz9PX1ARIAx4MEQDFlaK0pl8sEQTBa9ZPwN86sxRj3UpRuI6r4jTiN11rLinowdrXNZfeOaP1bGGhqm6tJ16S46NXrzui0DB1oQj9Ea0O5UKaYPzYAlgtlquoOT385rk08FWfTA1vZcPdzbLj7OQ5uaycMwhPezyO3PsnujfswZ5T8DrOc6PsylozRMK+eRefNx7blpVRMjJkyBVwJdG1tbZx77rkAHDx4kOrqagAcx2FgYGA0EIqzT9YAiikjDENp7DzRlEInPopV/tkZXc1o0Frx1H0NvLDxWmLpBN0HehjsHiI3kEcpRXGoeNq3V8gWUZYilnDJDeZZuHoemboj3+SUOtw02o27OK5NGGjatneQzxYJygHKttj59B6WX7iEi161lrYdnTx372b6OwdpWdzIuleu4dlfv0CqOkW2b/i0N6lUWJY1GvaqalM0L2qU5QliQs2UCmDl5+acc87hySefHP14S0t0zvf999+PUooFCxYAyHvCOJAAKKYMqfpNElVNNBlgAae3acP3oKczxnf+YQ7184aoqgsZ7M1iKYUBFp4zl96OgagSN+aYtpMx2uAVfbJhjjnLW9Ghxnai1g+BH9DXOcDBbR0c2NJOdUMVzYubAMXB7R00zqunt6OfeCJGdVM1u57Zy1DvMA/95HHyA3mcmMNz92/hyZ9vxCsHNM6vp2tv96mfGksdsSFE2QrLtrEdi/q5dSxbt4i61ppTPzghzpKZcgxcJQD+4R/+IR/72Mf4/Oc/z44dO9i5cye33XYbf/7nf84111wzWh2U94WzTwKgmDKkxcsEM0Ws8m0o/9eAHvnDaQU2Nw69XTGGB20WrEmT7R3GL3qka1IsXD2Pc69YSbYvz+P/u4EwOIMym4rWAx7c2sYzv3qei1+zDsd12Pr4LnY/s4/mhY0c2tdN+85DHNjaDio6u1eNvJnkBgtk+3PEEi7PP7AVrTXJmiR97QOUC2X62vuJJ2M0LqgnVZ0k2zt80uFYtoVGY9kKDLgxl0QqRl1rLedfcy7nX7tmNKQKMRHy+fyMqABWnH/++Xz2s5/lb/7mb2hoaOCb3/wm5XKZt771rXzxi1+kpkZ+wRovEgDFlCHhbwIZH7vw9yj/8ZENGiNr5k4zqxkNDc0e85dDLO5ywbXnoSxFTWOGWCKGbdtk+7Ik0gny2cLp3y7RMWx9HQPs3nSA+avmUNdSy97n9pOpT+PEHfra+rFshV/WZPvz1DVnqJ9TB0CyCvJDBTp2HSI3kKe6voq2bR0YE60XBBgezOMmRl76ThF2lYJMfRWBH22MWXrhYuYubuK8q1dz/jVr5PQPMeHy+TyNjY2nvuA0EQQB119/Pddffz39/f309vayZMkSXNc99ZXFSyIBUIjZwPgo704s/wEwBYzVhPIew1g1oLyo+HeG6+HiScOytTHKOkFNc4Ytj+1g8yPDBJ6P7Tpk+7JU1aWjHnqF8qlvfyT/G204tL+P3Rv3ct5VK4kn4xRzJWIJlwOb23BTMRa1zqeQLbL1sZ3ksyUK2QKp6hQAtmMTBgHKUvS0942eEQzRLxnGGJJVSVKZJLnBPPoEG1XcuINl26Srk9Q0V3PulSu5/nevpmFOHW5c3pzE5Mjn8yxZsmSyh3HWOI5DT08PbW1t2LZNKpWivb2deDxOMpmktrZ2soc4Y0kAFGKmMyFW4XNY3gNAgCHAogQYMHVAmTPrhTJyXJqK4we1rFq/jO79Pex+Zh+xZIxkVYK2HR2UcmVaFzfRvLCJ/s5+8tni4VYOxwmDSqnoBA4Fgeezb9MBdj69h6raNEO9w/R1DBCUfFqWNEWbV7QhU1+FDsNoijdfxpioqfT8VXPpbetn73ODpGuTI2M2lEsemfoqYkmX177/Gn753fvZv6WdwnDx8JhUNPVbVZ/GaEjVpMjUp6Mdz3t7yNRVSQAUk6ZQKJBKpSZ7GGfNhg0b+MIXvkBXVxfFYnF0I6DjOIRhyOOPPy7VwHEiAVBMGTIFPD5U8CSW9xCGAEUeNbrez6BMG0bVnvFtGqPYt72JeGYFS89fxHP3b2Hh6vmUi2WK2RKWUrgxG7/sE0tZZBoyFHIlTGCijRXH6elldDT9q6xoXZ9f8vjFv97Lga3thL7m4NZ2HMfGTbikqpN4RY85y5rp6xigdWkz1Q0ZAj/AK3qsvmIFtmPxL390M4VsCduxMcYQT8VoWtgA2rBw9Txe8e6r2PfCAZ695wW6D0b9xpyYQ21TBifm0NvWj7IUrUuaMBie+/Vmeg/28bK3XXbck0qEGG8zZRdwxcc//nEA3vWud1FdXU25XKZcLlMqlSiXyxL+xpEEQCFmOBU8CxRRFInmWe2RvwOgOHL0m41SwWnfZiGfIa8/zHv+8nIObu+glC9FVbeDfQx2D6FDDZY1WvXToRndTauUitb6HTPQaPrWhIz2ghzqzrL54e2ce8VKFq6ey4GtHbTv6mLushbmLm+laUEDmx/aRizh4sYc4imXJect5IJrzyNTX8XzD27n6bufI5GOk65NU91QxcChIVZduoxF5y0gVZ2it62PVE2SWE8MMLgxh1Lew+/PA2BCTcfuLoq5EisuXkrH7kO0be9g+UUzZxpOTB+FQoFMJjPZwzgr8vk8Tz/9NAcPHhxt/yImjgRAIWY8G/CI5jhtouB3uFGyohujTqPZ6pgCbaa+mZf95g0A9Lb34zg2B7e209c5AAbsmEOQL+N5AToIcRPuaEuVygkAo7dpDv8deMGRJ45YUMqV6dpziPmr57H0gkV07emmrrWW+rl19HcOcPEN57Pq0mUEXnQmb+P8ehw3eml751+8CctW7Hv+IGEQMtyXY/Ga+bzp/74Gy7JonF9PXUsNi9bMJzdQoJgroUNDUCrjl32cuEsYhhSyJfKDHRSGS6y8ZAn9nQOABEAx8SpHwc0EWmtuuOEG9u7dKwFwEkgAFGKGM+56KP0rUbLSjA1/EQelXMLARqkix/Q1Ps7MvDJdo/9esnYhdS01bLz3BTINGeKpGH7Zxyv5pNIJQh2ibAvbsbFdm6Dsj6whjG5a2Qon7uIVvGPWBhoNxVwJoxSDXUOcf+0adKCxbAu04dyrVrLqkuWka4//hljbXMP7Pv8u9jy3n/7OQWoaMyy/aMnoGr5ywcMrB2TqqognY6RrUzgxm+79fQRegA6j9Ug6CCmX/OiUET9khVT/xCQwxpDP52dMBdCyLBYuXMinP/1p/vZv/5aamhrS6TSJRGJ0E8hM6Hk4VUkAFFOGrAEcH8Y+H+NcigoeAfwxn7GIIlgdkMd2isduzjjiS1JpFh2AOrz+zY27rH/dhbzw6HZyAzmGukOUpahtzJDIxBnqHqZ5USO5gQLZ/mF8x6Y0csybE3NwXBs35kQB8Hjj14bBQ0MkqxJgwaI181n/houYt7yVWOLU64Mc12HlJcuO+zk3EfX16+8cpLopQ2GoQHG4RLngRRtSIFrHmIiRTMfJ9ufJDxXoPtCHV/JP6/6FOJsKhcKMWQM4MDDAfffdR09PD29/+9tZsmQJlmXhui6+77Nq1Sq++93vYoyR94dxIAFQTCmVNh3iLFKKMPUP2LkPovTOkQ9WynwxoAroGbnsSW+IaPpYoZ0rRz9aypfo7ezHK/rkBnJobYglXGKpGKCYt3IOy85fTF1LDY/etoH2HR3YtkWoNbZtkaxKjAbCExkeyNHoNZDrz7Pi4qUsPGfuWWnA7MYcFq9dyDO/3IRj22gNw/15/LIHKGw72pmswxCvFGLbFovPW4BX8une38P8VXNf8hiEOBMzqRF0VVUVn/jEJ4jFYhSLRQqFAoVCgVKpxODg4OgxcGJ8SAAUYjaw6wkz/x/28B+i9FbABlUFqg70wGneiB65Xh06+ZHoI1rz5C828thtT0fhL9Q4rkPgh2R7hilmS5x7xUrWXLWKFx7aRiIdp6q+iqr6DMP9wziOjWWpkRYwJ+5GYzSsuHAxV77lUuavOjvhr2L5hYtZceky7vz2vZQLZRzXJpVJ4ZU9wiDEtm2cmIsTc6mqS7P8wiWUi2XKJ6hYCjFewjCkUCjMmGnR2tpa3ve+953yclL9Gx8SAIWYLaxmwqrP4eT+GHQ/YEB3AcXTvgljLSVMfwHs6DfzvvYBtj21m76OAdx4tNEj9ENUaAi8kEQ6TjFf4plfv8D2J3dSypcJ/ZCmBfUsXbeQbO8wiao4Hbs6KeaKx98dDMSTLvNXzWXxeQtQSlEulOnYdYjBniyxhEvL4iYa59W/qKdFa0PgB7hxBztmk0jFCbyAsD8cbR+TrkkRr4qzYNVcqmqjcJiqTr6o+xPixcrno53pM2UNIERT2vfeey8bN24km80yb948rrzyStatW0cikZjs4c1oEgDFlCJTwOPMXkqQ/AxO4c/AVCp/p9sEuhFlhlB4ozEtP1RgqHtoNEAl0gkCPyD0Q7TWODGHnRv2AIr61lqaFzbR295H94F+CtkS6Zokve39lAp+dO7acQKgshTp2hQP/fQJmhY0svSCRTx7z/N07u3GcWzCIGTn03s5/5XnsmTdwjN+Srr2HKKvbYCWpc1YSuGXfSzbItNQReiH5IfyJDNJlq5bSMO8Onra+pi/am7UT1CICVQoFABmzBRwLpfjG9/4BjfddBOZTIZUKsWhQ4colUp88pOf5FOf+tRkD3FGkwAoxCxjBQ8BPqhWwAXTxrE7g48nAFPAKvwjJnYD2n0Fiao48WQMJ+YQlAMCP8SNRRsjtA+FbJHAD2ld1ESmLs3wQD5aSej79LT3ka5dSHV9FfmhArVN1QwcGjxmGtgYQyFb4kC2nX//zC00L2qkrrWGNVetGm330t81yJZHd9C8sPGEO4JPpJT3sB2LTE0a3/Opa40Ony8OlygMF1l9+QrmrmylnPdQlsXKS5ex+vIVo/ctxETJ5/PEYjFisdNo2zSFVU77uOuuu/j+97/Ppz71qdGG0AD//M//zNe//nUWLlzIe97zntHLi7NLXsGEmE1MiOXfA7igYmCKnH4FMKoYqnAjqrgdq/wDWlr/mFXrV7Br415KuRJBOaA0XKRULKNDgxOz0aGma18P/V2DlPIlQl/jlT1QisDzcVJxMnVVFHNF3HgMr3jU2joTVRpjyRhGG3Y8vYeG1jqa5jcwd3krAHXNNbTv7KK/a+CMA2B1QxWJdALbsTm0t5vhvjyxpMtA1yDpmhSXv+kizrl8JYWhAo5rk8zI1K+YHLlcjlQqNe3XxFVmeZ5++mnWrFnDxz/+cYwxeJ5HPB7nD/7gD3jqqad45JFHeM973iOzQuNEIrUQs0oAxufwj36Z4x7Me1JWdD0zjFv+Gi97yxKueddV1LfWEoYhpYKHCQ2xRIx0TYogCMkN5BjoGgSivn++F00Td+3r4cC2DsIgRIca3/OPe4860JTzZXra+8gPFDi4vZ1f/8dD7Nt6kGKuNNJQcOSM4jPUtLCBxWsXEAaahnn12K7FQNcgyaoEr3z3VZxz+Ups2yJTXyXhT0yqfD4/YzaAADiOw+DgIPl8HqUU8XjUXioMQ/r7+2fMVPdUJRVAMaVM999spzwVxzirUf6jI2sAT2fq92h2dD1jATmqUs/wlj98Cxdev47v/eUPad/RRXG4iLIVQTkg9KJwB9HXNwhD0GC5FrG4QzFXpre9Hx2GmPDECc5oQ1AOopNEQug52M9jtz3NuZevpH5OHVW1KRrm1J3xo7EsiyvedDFVdVXs3riXqoYqVl++grWvWM3SdYtexPMjxPiotICZ7q+TlencN7zhDdxxxx189KMf5cMf/jCpVIp0Os2//du/ceDAAf7v//2/gLwvjBcJgELMJkaDLhP18zOcefWvco4wROHRRpkCSilsx6KqNg0KfC/Adh3CUGNZCmOi83/9sh+d/GZH5bpCtkSiKk5usHDCRtBjhYGOThCxos1CAx2DdOzswit4vP6jrzrj6d+KeCrOJa9Zx9qrzyEoBySrE7LmSEw5M+UYuEqgu+yyy/jzP/9zPve5z/G7v/u71NfX097eTrlc5otf/CI33BAdNyk/i+NDAqAQs4gKNo40g24ACiN/zjQEVi5vAQ7GWQNEJ4J4JR+/5EehT+uojUrcoEs+tmWjjcZCEU/G8L0Ar+SNVgcTmTiBF+KXDk8DV84PPuIxWAo1cniwX/apn1tLy9ImWhY1nvkTcpR4MkY8Ob0X2IuZK5fLzahpUWMM73rXu3jDG97A448/Tk9PD9XV1Vx77bUkk7LcYrxJABRTipT6zxJjUMHjKO9+FEW0cwEm9hpU8AyYLFH1zgAu0fFwlZB1dCuWytej8rGQaNOIBcpg3Msx9joAmhY2UtOYiZpBxx2KwyVsJ9oEoqyo0bOFhQ40OtS4rkM8HcMv+WgvoLqhmtxg1OYi8IIo+BmD7VhR5Q+i27AslAITWhgD2f4c9a11+F4wbk+nEFPBTGoCDYdf73O5HPPnz2fp0qVkMpnRtYBifEkAFGKmMQar+A0s72dgoqle27sHU7oV6AM8Dm8CGRv+jscC4kRB0B65ro2x5mLib0bH3xmlMsC2La76jcvY/Mh2ykWfctEj8AJs18Z2nZH1e2E0XRyzaZrbQDKTYO+Wg/heQH4gT+CH6DCMKogK3LhDy5Jm2rZ3YsKooqiUQmuNNgZbKYb7h+k52MvWx3Zy2esvxI3L+bxiZppJx8ABlMtlvvOd73DrrbfS0xMdR1lVVcW73/1u3vve91JdXT3JI5zZJAAKMcOocBOW99+ADdbIiQEmQOltRBW8SviziMKfJgp4taAMkMBY8zD2CrDmYOw5GPdlYEJQLpAcadp8rHWvOJer3rqe5x/cStOCega6hsgN5gk8n1R1gnLRw7YtHMch8AP6uwbRfogbi5pI16TjFIYL5AbyGG1IVacIvJCapmpKuSJhoAn8EKPN6Kkdc5a2sOrS5bRt62Dh6nksXD1vPJ9eISZNLpebERVAYwxKKW666Sa+/OUvc8MNN/Dbv/3bWJbFc889xx/90R+xc+dOvvCFL8hU8DiSACimFJkCfumU/zDRJo+aMR90RnqkhKBqwQxxZP8/m6DmNrBqT3LDp75v27Z4w4dfRSIdZ9/mAzS17GfpOe3EEw5te+fzzMO1hIEh9EPStSnygwVS1Uka5tRRyBYpjvQSNNqQrEpy2esuxE26bH54B8VUjGR1ivxAjmI+OrN33opWLrjmPBKpOIWhIn0d/RIAxYw1U9rAVALgV7/6VT71qU/xh3/4h6Ofe+9738trXvMa3vnOd/Lxj3+cZcuWTeJIZzYJgELMFLoXy7sT5T8ExmN0qlc5ROmtUvGLgWok6gGoo76AVguomhPf9hmoba7hN/7oBgqdf09SPYuyAjA2YdjFyzcv5ef/MZ+Y00eh4BNPzcWJOzTMradxgUVuIMehvT2Aoqo2je3aZOqqOOfy5Wx/cjf1c2txXQt3qMjCc+ex9upzSaSi9ULGGGzHPiuPQYipqFAo0NLSMtnDeMkqv+in02nWrFlzzOcvvfRSjDFyFvA4kwAoxAyggk3YuT8Z2eAREK3t64569RkbSBOFwCSYYVCZ6N+UgRAde/MJp3VPmzGg96F0P3bwPLXp/+HwuW4hWsOai7ey5qLtaA1au+QLy7nx00sZ7M3RMLeeqro0h/b1YDkWqZokqZqo5UVtUzXNCxtZ/7oLcGIOWx/fSeviZtLV0fTQcH8OJ2bTsqjppT0GIaawmbIGsBIAP/KRj/Cf//mftLS0sHTpUizLwvM8vv/973PddddRW1s7uQOd4SQAiilFpoBfBBNiFf52ZFo3QRT+KvTInyFQLYSJj2GXvwk6G31aORj3lejEe1/aGHQ3duGLqODZkZNGhjh6c0nUyiuahrZM9O9YYhcf+HSBz31kDW3bO7AcC6/k47g2i1bPw41FL1HFXIl4Ks6yi5Ywd3kL1U3V7HhqNwe3dwBR+5bVV6yk+Sy0ghFiqpopU8AVv/zlL7nrrru4//77ueKKK6iqqmLnzp088MADfPazn+VHP/oR6XSaeDzOm9/8Znl/OMskAAoxzalwCypsA+KggmizBjZR8DNUfsyNsVCqTFD1/6G8X2P5DwIao+pAHwR7+YsbgNHY+b9Ghc9zuNI4Ev6O7iozykJZBgiYu7CH3/nL83jkf3MMD+ZpWdxEtm8Yg8EreZQLHn0dA6y4ZBlzl7dgWRbnvWwVc5Y209cxgFJQP6eOhrl18gYhZrSZUgGsaGlp4QMf+ACHDh1i//795HI5fN9nxYoVfO1rX8PzPDzPQ2tNGL6YU4vEyUgAFGK6M0WilKXGTLmOFfXHU3SgCv+EhQ3kqSQzFW7B8m4jrPpHjHvVGd+9Cp9DhduADKg4MHzyVoJEzZwjIUr5rL+mk0tf3s1QTze7tzRy/+2NtO/spq9ziOaFDZx39Wpe9hvrR08EUErROK+exnn1ZzxeIaarfD5PJpOZ7GGcNd/73vcmewizmgRAMaVIBefMGWc1qBSYAlHlD058zFvxOB8LgRx24QsE1f8zsmnkDOhOomnnSs+uE5ykMfqltcZ8QAMeVvm/CEOLdNJw/iWKpatauPu2t9G2s8zaV6zm5W+77MzGJMQMNFOOghurWCzS3t5OGIbEYjHi8fjo3zMp7E5FEgCFmO5UBp34AFbxRl78Gb8GdAcq3D56tNtps+YQnSjiETWNPtVRapWx6TF/+1hKYdkuvpekuqab8y99jqGei9n/wkEuftU6UtXSD0zMXsaYGVUBNMbw6KOP8u1vf5uenh6MMbiuSywWvX4sWLCAr33ta6MtY8TZJwFQTDlKKYw50wAzu+n4ezBWI1bh+yizjcq075kJOLI3INGUst6F0kMYqwWsBcfsFjb2Ooy9ChW+EF3ewEkW/3HcgGocjAlxHI8wcPA9Q13NRvY830RQ8nlwfgOvfNeVJNJyRJSYvQqFwoxZA9jW1sYf/MEfEIYh119/PZZlUSgUKJVKDA4OonX0WiQBcPxIABRiJtCdWN7PX0L4AzCYyjSuyUGwE6t8K0rvIWoXk8K4l6AT74+mnCuUTZj++8O7gCkTBcBKD68iJw+EROcKm+gytl3EL9sEfoAONPF0gn0vHOTZXz/P5W+65EU+tjNXyBbJDeRJZqITTLyST11zNcmMVCLF5JgJm0AqgW7Pnj20t7dz8OBBXPfExzdW1v2Ks08CoBDTnSni5D4Cuo0XH/4iduEzGPcGVHAfKtgJFDFqDljLQOVR3v1YZNDJ3zvyilYzYdVXIdyLCvuwSjehwq1E4c8aOYVkxNhNIaO/2AeAPZIRNZZtseH+eroP9LL68hW0LG5i/5Z21rzsHDL14/sG6HsBT/9yE9sf38VgzxB97QPYrkVdax21TRnWvmI151+zRt6YxIQKw5BSqTRj2sCkUinWrl3LwYMHWbp06WQPZ1aSACimHJkCPjPKu2ck/J2F2wq3gO4ZaRTtAy7KdGHCQZSyoyle73aIvQns4+zAtZdgrCaMvxwVPje6K9mYMTPHY7+0Y/5tqTAKhKHiwI4YP/2XKoq5PEO9WRLpOMP9OYrDpXEPgBvveZ6nfr6RdE2Swe4sQz1ZlKVIV6fwy0kevfUpEukEqy9fMa7jEGKsXC4HMO3XAFamcy+99FLe97738Y//+I/8zu/8DslkklQqRTKZJBaLkclkZtyGl6lGAqAQ05HRWN5PsEq3gN5PFNbOxjoZH2VyGGsOUTpzgQKKEpg0oFH6AFbpX9GpPztiPaDvBXTsOkhT+q+oSu/EWDEwAUqZo6p9J1YuWvz85mZu+94cSrkYoR+yf2sH81fOobqxmnTt+L4hFIeLbHt8J1V1aZSlyA8WaJhXR+AFDBwaYv45cykXPR67bQOlXBk37jBnWQsNc+vGdVxC5PN5gGk/BVzh+z4dHR18+9vf5rbbbmPp0qUYY4jFYgwODvKOd7yDT33qU2itpdo+TiQACjENWcV/xirfzJEbKs5W1TQPppeoXUulX6Di8Do+GxU8DXoX2FEVrDBc5OGfPo4d3suC12+jXLSw7ADbBscBdYrXb2MgDBU7n6/mJ99aTnG4jDEBoTaUhkvs29zGW//odaRrxjcA5rNFSrkytS3VDPUMR+cLuzaWZTHcn2OoZ5hD+3oY7s9RypWwbIt0bZpLb7iAcy57kY20hTgN+XyeRCKB40zvt+1KoPvZz37GN77xDT74wQ9y6aWXjm4A8TyP7u5uVq1aNdlDnfGm93eSmJFkx9cp6B6s8i2AihovG81LXft3pBClu0b+XR7z8eGRv2Mo3YYq34WJG7AWsvnR7ezYsIdr3tiJZYW4KS+q/J0GrS0GehIYEzB/aY6G5kEODsYJwhATGnwD+aECS9YtOuVteSWfPc/tZ//mg4RByIJz5rHsgsWn3UImXZ0kURVnqDcHSqGUIvACygWfwnCJnRv20NPWR21zNdWN1TTMraOvvZ8Ndz1Ly+Im6lpqTut+hDhTuVyOVCo17V8fK8t7NmzYwLp16/iXf/mXk15eqn/jRwKgENOMCjYR9dyr9Nsbj/WSAVGD6LEqU8JxIIdd/i9M8AiaRoYOttCxx6anbQj70uDoTjGjBntt3LgmnTGEAXjlBKFOEQYeOrCIVYdkaksEoQOoaP+I1nTt7eGbH/8ub/vEGzhn/fErbYEf8NhtT7Fzw15iyRiWrWjf0UXb9k5e+a4rTmv3rjHRXujND2/DiTmUC2WyfcMEXkAsFSc/lMeNOaSr0xzY0oYTs6mfW8eBre107TkkAVCMm5lyDnAl0L3sZS8jCAJ6enpoamqa5FHNThIAhZhu1FHn7Z6VtX+jNz5yu8c7d9MhCoaVSqAGkhB2s3rtFl545BwG+jInDH8AtQ0h+Zw1UgWwyGVdlApQShFPa/yyRfseFx0cntq2XCtqG/Hsfv7rH27lnX/+ZlZcvIRY4sjWEe07u9j97H5aFjcRT0XhOPBD2nd0svf5g5x75cpjxuOXfTp2HyI/WMCNu+x4ahfZ3hxzlrcweGiIcr6MX/axLIu65hpyAzlqmmtoWdpEtidLX3s/NY3V0d6V4HjH8AlxdlRawMyECqBSikQiwX333Ud/fz/vfe97SSaTVFVVkU6nicfjtLS0EI9L38/xJAFQiGnGOBeD1Qy6G4wVLbA7a0XAk93Q2Glmi6gKGVD2mojF27n69dtZtiZ78ptXkExrtFYYIJ7wCAIHJx5gO5r776yjrzN+xDiUUoR+gFdS7N20n598+X+54No1nHvVSlZcNBdHP4YyXaiSh1KMhj8Ax7WJJV06dnUdEwBzA3keu20DHbsPYYwhN5CnbUcn81fOoXVRE3OWtGDHbPY9f5B8tsDaq89hqDdL+/au6NSCRIzCcIn8UIFYMibnEotxNdOOgXvmmWcoFovcd9993HvvvWQyGbTWuK5Le3s73/ve93jLW94im0DGkQRAMeVM999wx51yCdOfw879cdSw2Yzji+Px8qCCKABqlO7C6DTpjMelr8ye1mYPpcAYi01PLGLRii5isYBSATY8sIBf/HAlsdQApVy09tCyonV4YaAJwzKJdByv5FEYLrH14XtYtfQ+YvFuQLF8aUDd76Z5ftP7yOUOTymFgT6mWgjwwkNbObijk3nLW3BiDrue3kvPgV56DvbhlTzKeQ/bsaLTRwxYyiKWcNHG0Nfej18OSFcn6e8a5LyXraJ5ceOLfZaFOKWZ0AQaDk8Bv/3tb+eyyy7DdV1836dUKo1uBOnr62PdunVHXF6cfRIAhZiGjHMRQfV/Y3l3orx7UOGzHH/a9qXcyUk+rgyQAFMgkejFcsugQOso4J0swxsDXQdifP2TS5iz9DySqUH2bS4TBGmq6mIo6/CVNQZrZBxRf0hIpBM0Lajnoov+E0cdAhpAORhVprahn3PX/Jgnn/gooMgPFTDasOCceUeMoZAt0raji7qWmpG1fh5bHttBtj9H6I08jwoCD8oFD8tWZPuy1DRm8EsB6ZoksYTLqkuXc+H1a1l6/kJ5oxLjaqasAaxYsWIFK1Yc7qUplb6JJwFQiOnKakAnfhvb++XE37fRGKWAAJsOzMiO35OFv8oxwUbDrk1x0jVJ0vUt7H/Bo5DThEERozUmBGUrTGhAQxAEKBQYCL0AozXFgedpaO6mXIyhnKgaaTsxdFBFXcMhcr3P0dfTRCzhcu5VK1l47uEAaIxh0wNb2HDXc/hln/rWWg7u6KD3YB86HJN6x/xTh4aeA/0opbBdG0jxjj97MysvXSoVazEhZkoFcKwnn3ySW2+9lQMHDmDbNsuWLePNb34z559/vvxcTQAJgGLKkR/806OCTVjln6DCzUxU9c8Y8D0bxzUolScMHIIwSSzmAgHWSLnuiJM/xtykIlqyeOHLczz9cBc7ngcdaLTRWEpRKnigDJYa84h0tDMXDSqu8P2A/vYD6NDHK9sEYR6MwbJt4imXeMrn4lctYXh4FY3z62le1HhEZeHXN9/Hjkf+h6bmHLu3pHhhVxflgnfKpyQMQxzXIlOfoXlhA3OWNcv3qpgwM60C+Mgjj/CRj3wErTVLliwhDEMeffRRbrrpJn7wgx/w2te+drKHOONJABRiGlL+U9iFz0ZrAM92+IMjNxmP/bACNxZGAQ/I5zNsfHQNL3vVE1j2kZeDY4+AK5dthgct0hnNq962h81PNVI/txa/5DM8kAdl0NoQBtFOQWUpdBjtrrVsRbo2SSzu0tddT2HYIp4so7WLUuCVPGxVwk4pVq78KagMoXMNgXojkAAg33MfF1/0D1z3qiKWBcNDNv/51Ubu/uGpN3CEfkhuqIjWMG95K4l04kU/vUKcqZkSACtTvZ/+9Kc577zz+OY3v0ltbe3o5z/84Q/z6U9/mosuuojm5ubJG+gsIAFQiOnGGKzS98HkiYLN0ITevQJCDQaLRLLI0nOHADNa/RurlHeIJwPCUDHYG+3ONcbglSzmLR3G6CJBOR2FN8fC9wIsy8KO25hQRy0jrOhsaDfuUi74DA/k6N5f4q4fNvGW93fiWEN4nk0ypUmmAkKtMOUDODEL29uKE9xNYL8cMFTb/4FuzFMux9AhpKo83vcXHWRqfQZ7XbrbYrzwRBqtj63sKdsiP1SgNFwiNbIGUIiJks/nmTdv3qkvOMVVqubPPvssX//616mtrcXzvNFj4L785S8zf/58guBsNrcXxyMBUEw5Mq12CmYIpfdgVBplBoh25E7cFLDRUMw7JJIhSnksWPQCnucSFKtIpApgojYvhVycUiFOIj1EWFZkagMcVwNRoBvqc8kPeeSGurBsi9r6Knrb+gjDgLAcPR5lRd8PlhXtwA0CTbZnmKG+HD/+ZiPDQzaveUcPdU0+ga8IQ4vhwSSW45LKxInFBrD0s7h6C6BRsYDBYRevBEYbwsCivsXjd/70EMW8RRgq9m5J8NVPLKSvKwp45fkpsuub8BZU4Xiaxr0FBrN5fC/AjZ34JdQYgxeGuLaNJd/T4iWaKWsAK6/vc+bM4c477+TCCy8kFjvcumnTpk3Ytj0jHutUJwFQiOnIGMAH40d/TxAV7cUgU1P57TxKirbtg63wvGYUQ1iWRzLt48RslLJIpDTGgA7VyOWj6zXOKdO538WNxUZP3Bi7EcNU1v9hKGSLuHGH/FARy1agFYcOxrj31maGh2L85kcOYtuAsqPpY7JEvQoNasyRdtV1Pj0dCpRFdV2AZUGooP+QixvXLF9X5EOfbefzH15MaUGa3rctJkw7WKUQL+nSdVkDd3f2cd3Gfcc9/9cYw4NtB7h1xzbahoepjSe4Yeky3rRiFa7schQv0kwJgBWf/OQn+cxnPkO5XGb9+vVUVVXR09PDX//1X/PWt76VTCYz2UOc8SQACjFdGI1Vvhmr/EMw3SgCxucYuOPc9Wj/Po5Y61fhOAYoY0wXxUIdykriOEUC38az4sRiRZQC2zEYYyjkYmhtc+UNw/zsXxoo5AqEQbS28GiVHcGh1lihxi+HNM7x+OQ39rFoVXFk57HCcTVhaOG4DsZoHKfIMaelqGiqOlUVUMpbOLEomHql6PN+2aKQhdUXF5i7pMxzlywhTDs4vWWskftRVYreFpf7n9nGqvXL2NrXy56hQapcl4tb5/Jo+0FuemYDvg5JOzG68jn+bdNGDhXyfPTCS8bjyyNmgZmyBhCidYDve9/76O7u5uabb+aWW27B932y2SzXXXcdX//612UmaAJIABRTjvzgH59V/h5W8dsj/5cEcox3ABy7iSM3aJGqjjZknOhLpBSk0gOEoUWxGKO/O0FjSwnXPXwdpSCR9NGhTfO8PF4pQ+CHYDiiB2CFZSksxybwQ9yYS+hoPvS3+1h6bpH8sIXvWTiuoa4xxI2HFIshYaBRauxzY474K5EMCX2FZUW9C4cHDqda31PEU5rqxpDyvBRWMcRWCkO0McXkfaiJs7UwwMfu+gW7hgexUDiWRUMyybDnMVQu4do2+cCnNh7HC0Pu2beXt6xYxdwqqWyIM1coFGZMVayyK/9Tn/oU73//+9m5cydhGLJ8+XLmzp07yaObPSQACjEdmAJW6RZAgUqAKXN2zwA+vkrVL/AVtms47gzmmF2+FbatSaVKxOaVcePmmMBoO4aqmiKKDJalDuczffyjRyrnh7YubSKZ7GfNJcOUihaBb6EUaK3wSg6pWEDMzeMkw2OfnrHjcyFZpdEh5IZsSoXDATBZFVLKW7TvjqHWa3TKGTm7eOQcU9siiFs8nizidbVjWxauZdGcSnMgO8RAqYQ9sm4RYxgoFZmTrqIQBOwaGJAAKF6UXC43I46C27ZtG3fccQef+MQn0FrT3Nw8utvX8zy2bdvGqlWrpBAwAWRBipiS5If/KLpjpOULYAaBPOPS/qViTKgLQwsdWtjH2/R6ki+TZUEscWz4G72qgguuHCJVfeLHYdkK27ZAKWIJl1gixrxlMWwHgiC64VjC0DTHJ1Xto5TBdgzKrnQdPL4wUIQ+lEuKWMJQXe8TT2qq6wPcGPzqJ3UM9zukXhjAxCxC1wIFRilK81KUHCjZoAFtounpztwwed/HjHzMGIOtFFobOvM5LKWocmXnsDhzxpgZUQHMZrN89atf5amnnhrd3AXRlDDAzp07edOb3sTjjz8+mcOcNSQACjEdqLqROdQCE7XuDwVYYNk2sYSDG69i9CVD8ZILkMZAVa3Ppa8cOuFtaR21gamuqyJTX0WyKsFgXx1e2SWVBjduUdcUYLsj08cKLLuyNnLMtO/YAz5MFADLZUW5aIEBr2zhxAxD/Q63/HMzP/p/LQDUPN5DclcWXeXg18cpzUsRJI582QyNoax19CeMwqwGfK0phiFlHVIMAlzLYm2T9DUTL85MWAN48OBBNmzYwOc//3ng8C/6lSC4atUq3v/+93PTTTcBh4OhGB8SAIWYDqwGjLVs5H9O0KV5vO7acqJ2LNig7LMy81xpJxP4ikUrCye8SdtWxJMxqlsyxFIuSimaFi1h2wsX4cQUNfU+lqU5JuWN3tHxbzee0NQ2hFTVaEINGx/M8EdvWMEfvn4F//OdptHdypYX0vTTvTT8sp10r4ebckbOuzvzx5z3PJ7tPnTmVxSCKABO9wpgb28vQ0NDLFu27LifdxyHefPmsWvXLoDRpRdifMgaQDElKaXkh/8oxr0GFW4BJrpBakiUeHzAHvn3qY9OOyEFGEUYKop5m3zOGqlummMCW3VLLVU1SWxloWIOiUyMvo4B7vnZcrRJcPkrngQ1zHFD8Qm+fcZOSbsxg1KGqpqQ/u4jp2fDuMXwtfMoLK0irItjUg7BSwi/ng750bbNXNI6R5Y4iDPi+z6e5037NjD5fJ5YLEY+nx9dz3j0z0Jvby/hSCVd3gPGl1QAhZgmjHsxqBaMmgdMZCWgEjjLQC3Q+OJvqvJar2IUC1UM9bs890g62vxx1Gu9ZVsUBvNk+3J07+9leLCACaGmOUO6rpqOzusY8D6OIYPhDI9lGzOF7bhQLBz5UujVubR9ci1918+huDSD1xDHT9ovqe5a8H02dR8i65VPfWEhxsjlovW/0z0A1tXVEYvF+MUvfhG1VDoq/A0ODvLUU0+xdu1aQNaCjzepAAoxHRgNYSdgUOYQ47oB5BjV6PjbUcFGlO4fswP5yNYqJ6UA4kTj1ihlE6+ax4YHXbY+ffwXea01gRfilwIUhnK+TOCHrLp0OWEQ0rGziw33NfGqNy7FMS+8pEe4+JwilmXwky7Zy5sZuHYOJuWMzCwbCAw4L+33ZQMMlMt05HLUxE8cWLUxdOSGsZVFazotb4KCfD4PMO3XAF500UWsX7+eP/3TP6Wuro7zzz+fqqoqwjCkWCzyta99jccff5x//dd/BQ6vDRTjQwKgmJLkTW8MY7AKX8bybieaenWZuNM/bLR7FTr1B2B8VLgZdD92/jNA7gyWIiqMtYhoK20ZRYGieRuP/XoL6ZpOckOFaOfEWAYsxyKedEFBPBnHK3gUs0Wq6tK0LG6ity1PX+HTNCffj2L4iOuerlJB0dga0LrK55nLV1JckI7CXzTsaM7YqtzoS/i+NAbXsnjmUBerG45fRX26q5ObntnAvuwgClhZ38AfXLSe1Y0voeoqpr3KlKltH6cL+zQSj8f50z/9U3bt2sVb3/pWLrvsMubPn08YhmzYsIH9+/fz93//91x77bWjrZ/E+JF4LcRUZgxW8UtY3g+BLFHwm8ApRFWDib125N8uxrkA41zEGQdQY1D6AEq3AXnC0OH5B3fQ3zEIKGJxN9pbYR25wUL7IX45wHFtmhY0YDkW+aECAG7MIfACfL8BVD2jVzzN8GdM1EomN2SjLEXq5dUEC1NY4Uk2k7yUOWCliNsORf/4z93OgX4+8+B97Bjow1EWlrJ4vqebP3vgHjpHpgDF7FQJgDMhEK1atYof/OAHfOITn8CyLDZt2sSmTZtYvnw5t912G5/4xCcAKQJMBKkACjGFWcWvYZX/i8PJYyKnfsGoVoz78iM/qHt5MRtR/LLCibugs4S+RduugPrWWg55fRitCYOQxtaAy18zSDoTsHtziu0bW2iY30R9ay0Ggw40thNVQQZ7smQaqqhuyKDNWuxg/4kDmoFQKywbFAZjFF45QakYp7ouSxAomq63qe0JyJccjolbaswNnaIKaHFsMdMZeTMr+B7Dnscj7Qe5sLmV1EhfQD8M+f7zz5L1yjQkkqNvfnHbZqBU4ue7d/KB8y88jWdZzEQzoQVMhTGGBQsW8NnPfhaIegNWV1cf8XkJfxNDAqCYkuQFAAg2YZVvZsJavhx9NwqMqo9avxxxuW5eTBANg4Aw1DhuiF82dB3wsWNJkuk4fsnjytcO8ZG/O0gypUeH0rYnx23/uYKGeQt5/qFtuHEnWiO3qwtlWVxw7XnEkzHC4Hexg7s4UTDVxsL3ksRSTUA/xhgsR1NVnUcB/T1x3FChFCQTIQVPo1/EBIkCHGXhGX3Exyxl4euQMAy5e88u7j2wlznpDH98yWXsHOjnu88/y4HsENoYtDHUJ5I4loU18nOwa7D/jMciZo5cLkd6hqwHrXR40Fpj2/Zo+AvDENu2Z8RjnC4kAAoxFZkCdu7PmLCWL8fLmIYj19WNsLxfn9lNj9y2sg2hH5IvJSjmbarrbEyoMcZQ3xzwkb89SCIVks87OI6D42gWrujjqlc9w7NPtXDO+uU0zKmNGkMvbmbpuoXMWzknug9nBYH7PmzvO6iR+psxCqUMWtvkc9U89Ovf5up3/w4x5yBW8EtU2IYKnkSbFFpZrEz18qvBBYTGxlIGrccchFxxijcnA0eEv9GP6RAFxCyLuVUZlKXoyA3zVw/dR1chjzYGx7IohyGlIKC7kKc1XTVaa2xOnV71Z+/gIPfs38Ow57GmsYlrFi4mNs3XjYmZVQGEKAQevZ5xuq9vnI4kAAoxVZgQFTyK8h9FhdtRpmuC7vcknwr6jvmYCrcS9QMMT7sn9dBAI/2HHAq5gIY5LuWCoqcjRRiWCP2QG34rJJXR5LIOlmURi2vcmMayYf0r91G3fD2tS+eRyiSPue1y0WOo8ykaqp4hEUsBeZSK+vuFoUs228rDd19OzfwLceMuhqWE9odR4XZsvRlMDdnkMHNbhrmO/dzbtQg31ATmqDekl1iZMEDMdnBHqhwt6Sqe74kaQ9fFE+R8Dy8MMUSniAyWioTGEHccbliy/JS3f+uObXz1qcfxtUah+DFb+K/6F/jGda+hNnGGbXLElJLP56d9C5jTIdO/E0sCoJiSZt2LgPGx83+J8u8f+UCJY1eSTTwd5Bno6mbXxnb6OgbINGS4/EqLuBsbGV/5lCHQGIUxUVuXTK1PPGGzZ/tF9HaEZHuyWK5NMh2glEUiFSOeKOG4YfQ9oAyQZ+XKWwkSnzjmtvdvbuP5Bx7h6uu+gwpyDBdTOG6SeGwAyw4p5mPser4RK7GS1ZevPHJcqhGIk/OGGPJ8bGN4bcsBLmvoYuNgE9/ZdT5aK7DO3veibSkCYzBaYxMFvZhl0VcqEmh9xNM47Psj08eKn+3Yyp/VXXnCal778DBf2/AEgdaknejElEBrtvf38e3nnuHPLrvyrD0GMfFmWgVwrLGhb9a97k8yCYBCTAHKu2Mk/LmgYmB8JjsABr5ieAhu/fc7GewpEU+4eGWfJNVcdFUCxzn1jmQdQhg6xOMlbNslO1BF78A1DOYuoXXpbnra+gjKAft21mAMuG4Jxwmi6dvR1itg+z/FqCrC+IdHK3EDhwZ59H+eYsnyZ6muLVAs1hD6Ian0ALYTAoZEssi6SzdTKB6iWLwAWHF4cFYD2rkSXfwfqhxFKXBJxTzm1WTJ5xNYvkK/hD4JlbeysaEu53k81x1VdmO2jYXC03r0xANLKfTIvxUwN12FpzV3793Dgkw1v7v2/OPe130H9uGF4Wj4A6I1hFrxy717+MSll2NLT7Vpa6ZVAMeuAax8v/b399PX18cdd9zBO9/5TubOnTvJo5z5JAAKMQVY3j1EGyssMDkmO/yVSzZeyWHTYzVsfXwfV7zxkqhFC7D5mRLzl7QzZ2EORf7wIr/j0Br2bE1R02DYt+ciXtiwlkxDDfFknoFD3ay5pJ3WhdDVlmDn81WsXT8AKtqpizFjNtyWcbzvgKoijL8XTIGuXZvIDQwyd0kJpTSWBfEqD8cOCMPoHGHHNVh2SG28k0LbX1Oo/hdS1TUA9LT1sWP/FTxY7iFu9bC8aoC18V6eODCf7zxxCXHL4AYBXm082oF8iufMIqpghCPPx/GelcAYrJGKR8H3sccEPus4xx96WpNyXXwd8r+7dvA75607bpWkMFItPHZMCi8M0UST9pPJGENnPoetFM2pmbGhYaLMlArg2I0etm2Ty+XYuHEj+/bt46GHHuLee+9lz549vO51rwNkSni8SQAUYiowPUTVtAk+JuwE2c1xQg71Zbj/juUEfkgpXyI5sv4ukVnCz295Je/8v51Up+4nDIscb2ZSa+g7lEbZDVjWIBdd00B6zqXc98NHKA1u4UN/8RRNc0uHr6DUsU1WRj8wUtUq/xsqbMMOH2DNqjwr/lgTT/g4jocbK0XTzRgsFW0AGblhUNAyZyf9fTdRUH/Mf3/15/xy5052rElRrmrBJFpwTEjcC7B6wEq4GDvk/N2atb+7jv/euwM/DLFHduZ6YYgXhoQmuq+4ZbO+dQ5PdXWS9U9+TrIhCnvVrosXasIwGDlwxDBmxNFzOBIIXcsm63kEWuMe58m+oKUV9YKKppRHPm+Mwdeai1vn4J5B9e9Adoj24WHmZTIsHAnLL9XTXZ189anH2T04gAJW1Tfyp+sv57ymZgAGSyXuPbCPnkKBBZlqXrFwIWk3dlbueyaYCRVAYwy2baO15oEHHuDRRx9l+/btdHV1cc899/Da176WL3/5y7zxjW/EHWmPJOFvfEkAFFPSrPrBNyFKd0zC/R75v1pDuahGq2e/+I8a9mw2pDIB3Qf7KOVKlIse6eoUqDhF/3JixafZ/UKC+UuHydQEKCuaoTUG+g/F6O6spa45iWUNMNRv0bGzi3jc4rf+4gWa55QpFV18zxBPhGRqo8qdZR2936KSAmPAMHbwvxiVQFkh6aqoKXSUk6Iq4NgHp7WDMRZKacLQoir5BHd874fc/8td7H5TKyZm4R4qUW5wKcVtSo6DVRvilkLmZS3+5PffyLkXL+cNq1dz/4F99BWLLKyupuj7/GLPLnoKeeK2w7WLl/CmpcvZ8utfkgv80eA2lqUUcdsm0BrHsqhJJMmWS/hG4yiFa9uE2lAMDjeKjts2xhjKYcA5DY3HDX8Al7TO4fK583i0vQ1PhxgDvg5xLYuXL1hwWpWUbLnM5x57mMc62kbHeMXc+XzmipdRHY+f9Lons2ugnz++95cUgyAKosawubeHP7jnbn7whjczUCrxlw/dR3+xNPq984PNm/jSK65jUc3ZCaDTXT6fp3GanwajlOKmm27imWeeoVgs0tfXx4oVK/joRz/K448/zt///d9z8cUXT/YwZxUJgEJMMqvwj2CGJvZOj8onxkQfs2zo73FJpUMsFTLUM0y54LHv+QMo28K2Ldp3dFLXWkvngVVYjVBTDwd2VlFd51NdX6amLqBcsti7LUVNU4xEcgivGKPtwCIObu9g3ctCmudm8UoOynJQKhgNJ5YFWlvY9jGtlIlCoMYQA5PCcbJUZorBwmgFVjgaHsMQwsBgOz5gsJSPZbUTN7+gtOJigqRNbNDHCzWJfo8g5RDWxLBcm0WPD/Dht1zHuRdHu2+X1dWxrK4OgB88/xw/3r4FR1m0pKso+D73H9iHAkJjsJXCUQptIBjTEsYYMxrEtIkGro1hQSZDd6GAF0YbXxQKjSFu24TGkCuXcC2b95y79oRfTkspPn/1tXxv07P8YPPzFEM/akht4P97ZgPtw8P8yaWXj/YVPJ7PP/4wD7UdIGbZpF0XP9Q81HaALzz+CF94xbWn+IY6sR9t20IpCEiOWe/lWIac7/HT7Vt5oqOdvmKR2ngCa2TzSttwlq88+Rj/fP1rZtcvgycwEyqAAB//+MdZuXIlf/d3f8c73vGO0Y8HQUChUJjEkc1OsipYiEmkSrdhef85cXc4EvSOOxYL4gnD3EUe1XUh85aUMToKJeVStMYs8ALq5tSSrkny0K0H2frsEqpqFU3zoo0b5YJD3yGXno4YC5ZrmuflKRcNW55bT8Ay5i/ez6Klm7EdTajVSOi0CAI1upTQ9xIYM/KmPzr9mySaHo/+reil0oxaKVBKUywm8bxqtLbQeqQpsxti22ZkM4pBqZDLrjtA69IeAIpxRak1SbE1SRi3SHiGTGCxsMfQv6/nmOdocORUjoTt0JJOk4nFaEmnSdg2T3V2RIvbjSFuO8dsHjZAKQwJwhBHKfIjR8LdsGgpMcse7QFoMFTH4mTcGKHRLKiu4S8uv4pXLlx0wi/r7oEB/u6RB/nB5k0URiqImqj/YM73uXXHNp7sbD/h9Q9mszza3kbMskk4DraySDgOMcvm0faDtA1nT3jdU9na1wscWdWvNAN+qrODjlyOzMh0b8H3KQUBjmXxQm83bcPH9qGcjQqFwowIgF/+8pd57Wtfy5133smXv/xlnnjiCSD65aihoWGSRzf7SAVQTEmz4rd+3Ydd/LuJu7+TtGoZ+3QrBSi46oYBhvqTPHrPApZdsIhirkw8GaN+Th1eqczB7Z08Onw+sfQSWlo3YDtD7Nma5O4f1TI8VMMVNySwLJvh3BIuf+Na5rXcBOv24MYNjhOSqQnJZxNYlsEYCx0qbMcQTxSOMwVcAuKARtHP6FnEYy6XqtIEQZxyUbF3W4bFK/PEEhrfU/gliCVVNOVchlddsJN7Dy7Fr3FAG5SBIOmQtxWpIU3RhCSqju2ddzA7RM7zqInHGSgV0QbSrksmFqevWGRxTS39pSLDJ1kHqIFiGFIKQ2zgm5s2HvNlKvg+r1q+gg9ecDHNqdQJd/D2FYt87akn+PmenceddoaoKpn3fX69bx+Xz50/8jiy3Lx5E090tJNwHM5tbMIPQyxlUS6XsS1FwnFwLYtC4NOZyzE/U33c2y/4Pk93dbKlt4cnOzvYMdBPdTzOm5ev5HfPW0dLKs2O/qifpK91tHZSa5RSI7ueNb7WdBcKhGMqpq5lMVAqsqD6+Pc7m8yUTSB/+qd/ypNPPskvfvELfvWrX/HII4+wbNkyyuUyOTnvesJJABRiklje/wAn3zBw1pzhaXLGRFOo1/5GD/t2x5izpAXLtkZuylAcLpCuSWIpm51bz+XAvgvQOqQwVCJWfYhXvuFc6ltrceMOC8+dS0v130PQxmBvmkJOoRpD4vEimdoiUFk3aI2s1wuPc9yuR2C/Fjt8GkU70QWObECoVBETenS3x/jaJ5bzkb/bxborogqSG4dSXtHXk8ErB5gqRaAMRo30+dMm2oAN9CQ12VfU0NO9i+ZHN3PllWtG76M6HsfTITsH+qPdvibq7Vcdi1EVi/OmFSt5pqvzhM+rMxJ6PB2t+/NPENoCo7l7314WVtdQn0xy1fyFNCSPbIJd8H0+fs9dbO/vO2H4G/16Avuyg0AU/j541x0MlEbW3AF7hgbxwpGK6sh18r5PciQEzstkjrnNUhDw421buHnzJoZKJcpajz7Gchjwb5s2srWvl7esWMXD7QfJ+T6BHjO1bwwHskMoFH2lYnQ838inQiDQmofbDrKuueWkj202yOVyZI7zNZiO1q9fz/r16+nr6+NHP/oRP/7xj1mxYgVf+cpX+I3f+A1e9rKXMX/+/Mke5qwgU8BiyprpVUAVPD/ZQzghBWCiqto5l9gc2t+DNlG/unLJY7B3mIuuX8vKS5bRtaebzj3ddO/vo7e9n5UXL+Pqt1/OpTdcwAXXnkdDUx8q3IGy6qiqiUJhMR+Puryoka+zslCWQlnHC38RJ/xfoHfk/44zl20MYaD51mfnMDxQ5rtfaKa306W73eXAzji7NyfJDxnuHlrMZ/ddi3btKPzZCuNYEBoINSiF7dgcrDV89u572LX5wJjnJZq69UamcWO2hTaG3mKRhmSSoXKJ8CRpOzAGbyQEBWN2/R5Pzvf49qaN/OOTj/Ge22/lzl07CcMQPXL9X+3bw57BgZO24YnGHKmNRxXNbz37DL3FAopod3HacQn1sU1u9Ejl8ILmFjKxw5tA9g4O8n9+8b9c8R/f45+eepzuQmE0/FUel60sHMvikfaDDJZL/NbqNUeGv5Fx5TwPbTR65LkwKjrIz1KKmO1w597dxx3bbGKMIZ/Pk0qlJnsoZ01lyvejH/0o999/PzfeeCNKKT70oQ/x1re+dfQyYnxJBVCISTNFp7ZGgpntRM2g+7sMg91ZhgfyOLFoIf+StQu55DUX4CZc5q+cw95NB9ChZvG6hay8ZCnJMdOnygwSnWns4iYcapsyoHtGAr4CVY8hAQyiOPk0kDpum5xo66gx4DiaP/jSQfJZm31bE3Ttj9Oy0CM/bKM1vFCs4ZaBNeRDdyRDVnoNRq1ilAalDW4pJO66DKY1P77rMT69ZiEAD7cdIGE7KBdKYUBgTBSkbJtMLM5TnSeu/r0Y+ZH+fqUg5GtPP8mqurrRqdhN3YdO6zYqe6ivW7SEhw4eGJ0uDtCUwmD0MmMvP9YDBw/wqlv+g7pktEnjUD6Pf4pQVhizk/nvHn2ItOMed1yBMQz7hy+rRzbRVMfiKAV5z8PTmuQsb2JdKBRmRAXQGENbWxtz5szBcRzCMMSyLF796lfz6le/mi1btnD//fcDM78AMBVIABRikhh7Bco/9eXOitM8s7dyWWPAdgw7n0lxcE8CpQxVtUnOu3o1zQubWHzeAuLJaOH+2qtXs/bq1Se8OW0tBpJRg2sTYNEH1uGpb0NsZA74RfZ9qzReNlHj50RSM9TnsGZ9gdyQTW+nQ9Pc6In+2YE5DPsxTGCi6l+l74gCLAujDJRCSn6AlfNQtS57uw+fhzw0sj5ueX39SDgJiVk2pTCgr1gg7539KX1DtJmju5DnVwf3c82CRdy+awdPdLbjhyHBaVRKmpIpLmxp4Xd+fttoZWV0N/Jp3H8xDCi+yDVaChjyTr+/ZWgMWa9MzLI4p6GJxAla38wmM2ENoO/73HLLLTz//PN8+ctfBsAe87Xdvn07jzzyCB/96Ecna4izjgRAMWVVdgrOVMZeSnQ+QzjZQzlG4CsO7EhzyzdXY8fLrLhkCR07u0hlkqy6dNmZ3ZjVROi+Bsf7D6DAkXO8BsUQhnpe6suRZRnCUOGVLfJZm/ywxZyFPg/9vI7925PUNQY82VpPqcUCd6SipDi8A2akEmiqXUoZh3IhJOYbmqoOv/EuqqmJ2r1oQ1UsHjVbDkMOZIfoKRRGd/aOBwN897lnuXXHdvK+T6hPL/wp4J2r1/BoexvDnkfajZH3vdMKf2fDqaqFxxMaQzkM+c1Vq6USRBQAp3sFcPfu3fzgBz/gbW97GxCdDW6NqexalsV//Md/kEgkeO973yungEwACYBCTBJjL2dCA+DxDqc96mPGQHdbjG//3RIOdS3HiSfo2dtNb1s/+WyB3o4B2nd2cfXbr6C2+fSnsMPYu3G8H3J484bN4ePuimBKKPpOeP1TqawntBTksyPTjUYRBjBvicePbmwFIHutD6+zKi0FD8+Pjn0eDNGpJGmHoBDyxosuGL2fqxcs4rYd29k50IcXhhR8f3RN30RMUpZ0yECpRGs6Td73yQfBKa+Tcl1esWAhj7a3oVCkHIdS4J9WeJxMSil8PfV+OZponucRBMG0bwOze/duhoaG+OAHPwhwRPgDWLFiBW94wxu4/fbbee973zt6VrAYP7N7YYUQk0QFz+LkPshoO5MJvXOODD1j5LJpvv2F19C2fznpmmp62wbo7xxgoHsQr1Cmr62f+374CHf+66/xvSPDRylf5tC+Hga7j+0Zp0wXAIYGjGrCqGai3n6GqLXLEIcD4Rn+1q8OF/FCbZHPHp5Kth3o7z78e26sp3Q45FkneB7GhEEds5h78cLRT1XFYnzowoso+D6D5fJo+IOJO705NJrOfI7e4uk1znWVxX++sIlDw1mKvkdPsTBlw5+l1OFfESxrtIfgbFZpjzLdA2Bvb+8pQ53WmoGBAUA2gUwEqQCKKWvGlv9NDjv/V6D7iFLIFKhyKDBa8eN/uYCOvTBwaIjcQI6h3mEs2yKZjjZ11DRV4xU9tj62gwNb2lh2wWK01jx772Y23vMCuYEcbsJlydqFvPxtl1FVF02fGlUHygYTbQbBFIh6+1XEiVriHNveZdTRB+UC0fOXjtbu6Tw6tLHs6ESTuqaAUsHi8V8ePk7M8jV2IUDFIIw7URsYPbIe0BDtBLbU6H0YW7Gzr59FtdEpIIHWfOOpJykGAYmRY90mOkyd6ZTqoFfm1t07x2k0Z1flPGSLqJ1MdezFH0E3U+RyOZRSM2IXsG3bdHV10draiu/7OI4zGgq11uzevVsaQk8gqQAKMcGU/xCYflDVwNR5US+XEjzyizS5wTxKKYZ6c4S+xnJsUIrqxgxVtSks22KoL0e2L+qxt+WRHdz/w0co5UvUz60jnoyx6YEt3PODBwnDkbBitaDty1B4YHIoBjmyZlbZYGA4ppZ2dMeXI/7fBhKgqlFWBsttonm+z5xFAV7J5sffbKKYs7n+7f1c89YB5tbmaKgpM6euwOrqXs5J99LijNy3Ahx1ZGVQwZMdbaN3van7EHuGBrCUwrasKVtJm84q1b/QGJSKTl+ZzSobQI6eMp1u1qxZQxiGfPvb3wbAdV2UUqMVwfvvv58tW7Zw1VVXATO4ADCFSAVQiAmm9ODIvyxQGTAlJmUqeKyRxs8XvuocSnmNX/LJDRxgsOMAQ4NxmuY34MadykXBaKpq04Sh5rkHtmC7Nk0Lot/c48kYTsxmz6b9dOzsZME58wDwE5/ELfZjhRuOunOLE06gnixfGUAFQC/K2ITO6/ASH+eOH36BvZv2sWNjkle/s4/f/NB+EinNk0NzaYqX6fZ28b8HVlL0XOIqQNsWljFoc+wbjjKKDd1ddOfzNKfTdOSGR9rkKMqnsf7ueI63FFOArRRq5CzgQGvijsOPtm3h3v37+MIrrmVl/eysDFV6AE73QHTJJZfwute9jm984xtks1muu+46amtrsW2bPXv28A//8A/Mnz9/9IxgWf83/iQAiilrur/gnUi0+cMCPFBxoBlMJxO3iuz4YjGPC688SMeBFVyw/te0ztlJ4JfIDjg8eneepx9exWBvjr62Aerm1LHtiZ0opRjuGyZdE1UytTYc2ttN195u+joGuO3/3c2rf+8VrLh4KcpqwE98nXj+5Ufd84t73EEQw3ZriaJUGXAol6vY+kwLm+7vZ/11Q1z3mwMUchZ79lTz/fz5/P3LHiHp+Fi+4b6eRXSVq9BaUW0XGQyOqsYaiFmKIa/M9v5emtNp6hNJUq5L3vfOqPrnKotK5Lu4dS5PH+p8UbtjZypbKT5x6eV8/4XnGCqXqU+miNs2oYmOiPvKk4/zrde8bsa+JpzMTGgBU/Enf/InlMtlfvCDH/Dv//7vVFVVUS6XyWazXHXVVXzlK1+hpaXlmB3CYnxIABRighnnIoxzPip4BoxP9GPownGbHE8crS0WLtnCoqVbaGzaTyFnUSxYZGp8bnj3dno7h9n6eD22a2PCkId+8gR7nj+AbVl4JZ/qhgwHtrSxf0sbGINlKzr3HOKnX7mD13/oes5/5TLc0ic5G2sejQGvnCAZb4ramegsVvg0Q4cOMdQzTCIdZ/31OSwLhgcctvithJZFyvYJjeLChkM81LMAh5DQssgHIxtHDBBqHGWRSMQIjAYDcTt6qbyodQ61iQRdueEzGq9vNGnHxbUsNvf2HHMqxmzXnEqzuqERT2sakiliI9UfW1mkXZfdg/3sHRpk6chazNkkl8uRTqenffgNgoDa2lq+9KUv8YEPfICHH36YnTt34jgOl112GTfccAOWZUVHAkr4mxASAIWYaMomTH0eq/T/YXn3AEWiAOgxeRODNrajiTl9pDN5BnoV5ULUIyXwYtTUe7zmnT3c9z9NzF8xHwwUh4u0b+tg3qq5BKWAjl1dtO/sxLIUoR8t7M4N5Ona283tN36XZYt7aWg4e8ffWbZNPlugnPdw4wUUDvu3dOCVfNK1aeqbFUEQbegoG4dhP0Z/McHc6hxP9s+hx08RGouydrCVxq9sALEtjG/wgwBtKZrTac4fOY821BpbKRKue8Y9//KBT6UOKNO/h9lK8bmrr8HTIWbkJJCxrJGG1aUXOeU+3c2ECqAxBsdx6Ojo4JFHHiEIAtavX8/73ve+Yy473YPudCIxW0xZM/qFwKpGp/6cMPFBMHmiTRCTFQsUKAfbMfR1O4ShTylvRnrrKSxLUS5Y1DUFNM2xMQaSmQSJTIJirkwxX+aCV5/HYE+W3vYBSvkSYajxvQClFOdf6fHHX3qY+rrnwJys8uWO/DmNESvID4f0dw2Sz+ZB59lwf5xbvnRndHbqYJ4dzyWJxTVKGebZQyjgl/sXoY0VTf0aRVlHvwOXtXNEQ+jQVXihJuPE+LPLriTuRJfb1t9L3vc5r6n5RZ1QYSuFNZO/r18E17L420ceJNCGtBsjd1Swzvs+dYnkrKz+wcwIgEop9uzZw+///u/zkY98hE9+8pO84hWv4Gtf+xrFYnGyhzdrSQVQiMmiB7GLXyc6J3cyKcAn8G0evauG3/xQL45rCIPoJJYwCHGqQvJZh4EeTaKYpZQvUS555AcKlAseftEjP1jAssArBXilIrVN1SQzcd7xkRdIZ3xOnXuOU1E7yRF2NTVZLBXtJOw6EONHN9ZzqK0b3w8ISgH3/CTFustjzF3sUTV4iKd7OrmnewmlTQ6BH4U/31gYo44sy42MM9NV5s8uv5gLW+eMGU70SRtFcyrNweHsGcV23xicMesBZ7uU42ARnS/8xccf4TdXrebmzZvoKxaJ2RZ+qHFti/etPZ+EMzvfrvL5/LTvAQhw44030tHRwd/8zd+watUqfvKTn/ClL32JV77ylVx44YVy8sckmJ0/UUJMJt2JVfw3LO9e4MzWko2PaJ1bPhtn3/ZGuts6mbOwwFC/wfcVqbTGcQ33/nctw/0ezfN6OefCLGFo2LohQ6Br2PXMXmpbamhe2ER/5wBhEJIbzLN0TYmm1jyhHnPyR+X0jdN1ghDoxCAMDP/zb808clcTfV0ufrmM0dGFe9pj3PgX83ntb/Wx9vI8v1X1LP4ujzu2LaTQnEYnj6z6jTJgGVj1VJYl19UccZ/nNDTSnErTXcyPPpQzUTl5zlGWrAMECmOmdTtywzSnUnz6ipfx3zu20ZEbZnF1Lb+5ajUvX7DwJLcys82UAHjPPffw0Y9+lI985CMAvPrVr6a1tZX29nYJgJNEAqCYsmbki4EZxs59ChXuIToXdyLv+6j/P+rpraou84df3MiTv67GjXnUNPg4DpSLFvffVst//2sjv/nhbl77W/0kUlF4KRdtHr5bc89PFuKVfBrm1OJ7AflsgVK+RDFrUJbCGGv0uLbTGcsJxzz2UwYyNSF7Nsfp6bDB6GNOD+jYF+e7n5+LZZuR4Fkmc/kQwauqCMMQPzPmJVCBGqkEWoEhvqiWZRcuOeL2Uq7L7627gK8++Rid+aETD+4kD0cbQ10iwbDnUQ6nQBPwKSI0hq88+TifuuIqbnrVDTJVPmImTAED9PT0cMkllxzxserqamKxaAOWbPyYeBIAhZhAyrsPpfcTVcO8ibvj4wWpoypxjqtpmlPg2reWCDzFvh1xfvmjerZuSNO+J8FFVw/z+t/pIwigu93FshQ1jZpr3rSXtt3VbNtYRxhozn/luSgFnbsOsXd7nMEel9rmImEAzomW+B3vlI/TKK9ZFqy+OM+zj9RgOdYJr6PD6IbjaQfv/AZqatPMb6hjU183vhkz/2vAKYW4KF771itJpI89ieKq+QvY0tvD9zY9C76HNuaM9jWHxjBQKlEVi9GQTFIKAobL5ZFxQNp1McYcUR2bLQbKJb74+CPsHxrk9y+4eLKHMyXk83kymcxkD+MlKxaL/PjHP2bv3r1YlsXcuXPp6elh+/btLFiwgFgshuu6LFiwYGb+8j8FSQAUYgIpvWfkOLQC0SkWIeO+HuyUzZQP/69SoENQlmHt+gKrLyzS3+3w85sbaZpbxo0ZBntj2LZCWYpsv6JlfsCaizvZvKEaJ+5iOxa2YxOGmuG+Et/9Ygsf/8IBbCs89R6PynhO4ylRIyd1lIsWOtSnscYw2oMSr0+RqEqSTMaYk8nQlY9OAgm0JqEs3CqX85qaedN1l5zwdprTaRqSSXqMoeD7pzdgDj/VllJc1DKHT6y/nM88eB87+vtgZEo4YTtcvXARz3R1sj975lXG6U4BP92+jdctXc786ppTXn6my+fzzJkz59QXnOLWrVvHfffdxyOPPILWGqUUyWSS7373u/zwhz/EcRwKhQL33nsv1dXVkz3cWUECoBATSdUQVf8MExL+TsdRoStdHQURpcB2DTUNAb/1R130dLhobahrDqhr9HFcg++D0TatC4eJucNgWtn0wBYObO0YWdNj8cidtQwPKj79zf3EEqdRKzuDp8QYePxX0ZuF1ie/orIVa65cQc3l5/PLQwcIjWZeJkNgNP3FIkop0ukE57e08ueXX3nSKcjzGqP+g+UwwJzBgJVS1MTjWCi29vbwyfvuoW04S008jmvZFAMfX2sW19TSnErz3U0bCbWe5BbhE8sPNX6oebark+ZEcmQnujX692wzU6aAb7zxRoaHhymVShSLRYrFImEYksvlKBaLlMtlhoeHZ8SZx9OFBEAxZc3EaQDtXoNVugXMMFMi/FWMGUrlaa90bCnmbeIJTfN8nzCARDKamtQGEglABay+eIC//rfNbH3W447vpXj9b/dR31Km71CcB29P09jiY9kGo0GdpfdwrSE3aNN1IAmY0c0fx2O7Ntf/7st5/xffQ69fYvNDA7Rlh0m5LinHhaRiaW0tH7voUtY0NZ9y/dnimlogetocyzrtUz1cZVEMAgIdrVfsLhZIOQ4Jx0GhyMTiDJXL3LpjG//vVTfw0+1b6JtlbTKyvoerLOKOi23baK0JR9ZKqpHj4izLmjVhsFAozIgAeMEFF0z2EMRRJAD+/+3dd3hTdfvH8fc5GZ2UAqXssqHIXiKykU1pC4IIgvNRUcGJos9PUBEnCIgL8EFQEETaMgQFhBZR9pK992qhjEJH2iTn+/ujNLZQpkDa5n5dFxeQnCR30jTnk+8UeZqmaVcM7M/XTBVw+r6OKWUId3wM4L992TRwZmQGoYx0DT8vhcVXoeuZLW+mS8coBWazwmRy0KTtThq1AKXsKKcCDTr0snD8oBXQSEvR8C1064UZRmYwTTprwnDqnD3ti0LDZNExWUxkpOZ8TXWThtXHSpMu9XlmZH/MFjNlvK2816I18/buYUP8SbzNJlqWK09YlWr4Wm5sHcILGenomkYJPz/S7A7Op9vQ4brbwxkovNBRmoavxcqFjHTSnU7S7A7XY1tNOmfSUhm5dgUa2rV2Si6w7Mpg2s5t1CpZktJ+/pnLETmdGIbh+gO4WgYLcutgQZkFLPIeCYBC3GXK2g7D/hB6xrQ7+CD//i40ILPhRWHxUlgsyjWITbts3KDJDF4+6XhZFbqP4uh+bxwZCnQoVsJOoSKZrYZJZ0z4Frr1yQ22VI2j+73wLWShcBEn6/8IxnAovP2t6LqOXcvIfOqXurU1PXOgYLl7ymK2/PNxV6ZQAM81uPoYv+vxNVvwNptx2hXlAgLIOOfE5nRkpuGr0ACnobBrBmZdzxxvqRSGUiTbM/C1WFAozqbZcCiDbadOkZSenpfaie+q3WfO8NaypUzpGoHJZMJ0aeHtrBZB41IralYYLKhdxRIAxZ1ScH5LhMhHlFdHILNVLHNmxOW/in6glcat39E08PZVBBR14uNnXDWIZGUe/8JOzBYDXVeUq2yjQg0bJcpkkJaqYbEamRMwfMD5Lya3+vorqtexEVw6hb1bfZk9IbN1yJ5uJy3ZhqZnTkDRtMxFm30DfPHysXBs94lbf9BceJnNtKtQCZvDQardTrCvb64fphqZP1mdzK5iq0kn0MsbpSAlI8M19DLVbudiRjpn02zYDScBVi9K+PnjbTZ75Ie0BvhZLRw4f4718Tl/drquY7FY8PLywmq1YrVaXeHQ6XTicDjIyMjA4XC4wmF+pZQqMF3AIu/xxM8WkY8UxHGAAMpUF2VuTOapzrj0twnwAvxx+v4fjoBpKHMrbjoE3mKT0dUar0ymzOVWrvaj0LTMrtnM2cOXxvhpKvMkXsgguJQdpeCvXwNcx/4rWmaxQSVTCAk1Ybaa0U2Zm8hnTjzJLMrb34vA4AB0kwl7+u1fUqV/rTq0DAkh3ekgxW4nwMsbL92ERcvsttXANZbQ22whomp1gv38yXA6MZTCx2LBz2J1HXvOZsNhOPEymSh56YQf4OWd2cV526vP28y6ntnCqhTxyclXPU7XdUwmE1arFW9vb7y8vDCbzeh65vshKwza7XZXq2F+k5ycXCCWgRF5j3QBC+EOmobTdwSmlBfQnAfJ/C5mAs2KstyHsnYCzYLSvNEwZV6HInPbuNt7EjOcmaHMdNmnQda58nq9aUqBPf2yNf6UfmlWrsJsAZMO//uwHIt+SqfvKydp1OpCZli8hWSjDDCURmCQg+5PpzIpoQyJx85mjhVV4LA7MVtMFC4eQHpKZitbrRahN/9A1+FrsfBOs1bsPnuGA+fP4aWbWH70ML8d2IcyDHQ0dA0Ke3kzoH4julapypC43/nr2FF0TSPd6UQpRVFvH4L9fDlrs1G7eDAbE+JdwbGwlxcZTidn0u7youFu5m+1YjcMzJpG2ZtYEiT75JDs4wWzTyTJflx+6CqWLmBxp0gAFMJdTEE4/b9Bz/gFzb4aNG8MS0uUtTNomWlKc+4jM/R5kRn8vMicPHKN5VRucB09ZYDDmTmhwttH4VcoZ7DU9RtrrXPYMydbaFrmgxoG6Cb1z2xiBckXzKSnWjh20A9lnM7sor3VZi0NdE2RngZBxY9iSyuO2cuMw+F0TRjSdZ3k86loQLV7K9M0/M4sKqxpGqHFgqhapCjv/LmMNSeOE+jtjc3pJM1ux99iZUjTZnSoWBmAFxo2YeeZRGwOBxbdRGFvL4J8fDGUIs3hpEHJ0mw5dYoUewZ+FisaEOjlRXJGBnYjs+XwVhp4b/AtkWdoQIrdTq2gYOqXuLU18C4Pg1njBbP+7bi00HZeHjuolJIAKO4YCYBCuJNeFMP7MfB+7MrrlB1UMpnBL2spkNt4Gtcgw6ZjMWv4+TsxnFe2At5I61/8UQs6GkGl7VisiqSzZnz9FWZrZssgKI7u88fibaZ8tSTq3JdEWqqOr/+ttWRqGqQm65jMivNndC6euYjD7kTXNfyL+uHt703y2RSsXiba9mtJt+faExh8ZxcU3pQQz4b4kxT19sbn0mxepRTHk5P56+gRVwCsXrQoDUqWYtupU5QNCEC/NMs9ISWFEn7+PFi9BicuXmTRwf1czMjcb1gDDGVgMZlwGsYNLTlj0jScl/Xp62iom1q18O7TAC+TCQ2N+8uU479Nm9+WLeGygt3lE0myQmFebR202WwYhiEBUNwREgBFnlZQxwDeGJ1/WvpupEnvJu9ewcVzJvwCjEtj+DRM5pu7E4c9c5yfMjROHrFSrIQDXVecPWXC4m3B10+h6U7WLSuFf6AftZomoZsU6bbM8Ji1P/DN/pi1S01af84vjDIyxxtql+6oUp3yFC0ZyPnTSbTsed8dD38Ae8+dxakMV/jjUj3+FgvbE0/jNAxMl1qZnqxTn49XreDYxQtoaBhKEejtzX/q1sfXYmFwk6Y0LVuWlceOku50UrZQAOM3rcei66CbsGekX7MWs65j0jQMpzPHW0Kh0C6FQACzpmHS9TyzH/E9xYrzn7r1KenvTxFvH8rdwd0gcmsdzIvLzKSkZH4JkAAo7gQJgELkWTqaax5p1u4hV3ELzTrp6RqpyTq6CfwKOW86/AE47BpLowPZuqoQW1YF0KX/GXoOSKBQESdWbx2L1Qe7qRuV7mtAOvtBuzSWTTOBMm65K1jTYNncQP76LQhN17BYMpcJMZtNJBw6TdnqpUg8fpaUpLszds7XYkGpzGVdsrdY2Q2Dwl7eOS4LLRbEJ20eYNmRwxy/eIHivr60LFee8pcWlzbpOi3LladlufIAJNlsTNq8CYfhxNtsxtdsIdVhz7UOi667Hsuk6zgMA51/3h5Zc7mDfHxxGAa2q9zP3WbSNH7u3tMtj3211sG8sMxMcnIyuq7j4+NzVx5PeBYJgELkWQqlBaCpc4DtWofdyl2TkmRC0zTiYgLp+dzpK7p/4dJ4vmuc63z8FD2ePkPVOjZ2/R3I3O9KsHZJERq0ukD7x5pTvl4PlKkK7fpDg/b1WP5zES4mbaZwUTvpNg0vn5sr3nBCuk3n40EV+ftPP4qUKIQjw0F6mh2zJXNGcEa6nbSLNrx8rRQufnf2FL2/TFmmbdvCqdQUgn390DWNVLudDMNJu4qVrmjJLuHnT+8aNW/ovgt7e9OhYiXm79tLhtOJl0nHpFtJczgI9PLmh7AI/vPbL5xMTs75OJeCi8Vkwqzp2JWBRdcJq1yV1+9rRoo9g7UnTpDhdJLhdLLn7BkWH9zPuXQbxl1efF2RGXQLe3vf1cfNzbVaB3PrKs76952QtQSMZ/eEiDtFAqDI0zz6g0/TUeYGaBknuWYAvElKwbF9Xvw2vRjb1vjRvOv5qy4BcyMvv6ZDnftSeHjgcf43oiwnj1j545cQarZ/gJCGVVzHFS0ZSM3m9Zn2eWOeeH0DPr42DKcz1+B5Nek2nagJldm1sSi6yZ7ZGmM2oVQ6mlknw5ZBoWL+JBxOpFaLUEpVDr7xO/8Xivv6MajRvXyxfi0nUzKXLbHoOveXKceD1Wv86/t/rUlTztrSWH38OCkOByZNo0qRIoxs056QwoE8WL0GX29cj8PpRNf1zOACeJvMfNi6rWvSyX1lylDEO7M1ydtspnPlKjkep1+t2jy7cAHHLl741zXfDB04nnwxTwTA7K7XOninJ5IkJydLABR3jARAIfKgrDXtnOYeWO3L0dTVT8gZ6T5YvW5sv1ilID1NY+rokiyfFwjA8yOOXTWEado/4/SuxmEHiwVaR5zjh1Fl8Pb3p1TlEvgGXLmpe6W65bEG3Mc7T/nQtd8h6jc7jI9vRuYM5Ouc447uszL+nQqcPlWVkhU0Lp5LwZaagZevlWKli5B6IQ3dZKJ42WI06FCHlj3vu6vjtlqWK889xYqz6vgxUh12qhYpSr0SJW/LJIZCVi/Gte/MrjOJ7D93luK+fjQsWQrTpef3eO167DyTyIpjR8lwOtE1HV+LmafqNnBNQLkR5QsHMufB3jy3aAEbTp5AvzSZ5E63B/pYLJT0y/vj3O72MjMpKSmyCLS4YyQACpHHZF+uAr0ydusArOnvkPv6f1rmIsgGKDR0/TqnagVbVvnz1/x/JkbYM3TXpIrcQti1AqDTiWtigZevokrd0hiaP+XvKUuV+hWuON5k0unz3+7E/liEUiHf4HRYObgnkGLFkygZknbVxzEM8PLROHkshA5PNKP+A7UJLBHAshkr2blqL/YMByE1SlO3TU2qNqiEfxH3nDSDfH3pVrXaHbv/0GJBhBYLuuJyL7OZz9p2YH38Cf5OSMBuZM5wtRtOYg8fpEXZECyXWrGux9tsZswDHXlpyUK2J57OnExynS3uVC7/vlEa0KFiZYrms3Ful4dB4La3DmYFQGkBFHeCBECRp3naB1/WeKPs69kpS2NURslLYwGdZM0MVvgCgZgsKRh2G5pu4HTomMzGZfeJK9wd3OXDyJdCUNmmBqxdWoja96VctaZr/QQ0Mvfb1TTFhXOF8CtanJKVStLh8db4BuR+QvcN8KHbs7UwJftiqCACy/hyYNMhks6nUeWes5gtl0WIS7OFi5dOp8/rpWn5SBfXVZEvdqbbCx0xHE4sXhY8mUnXaVK6LA7DYNify0jOyHCF82pFizHmgY4E+V7ZKpubQG9vJnUJZ/XxY8zbu5tFB/djNZnIcDpzLC/jYzbjYzaT6nDQomwIfx49jO0as4pzC4jFfX0Zcl+zm3/CecjlYwFvV+ugtACKO8n9Cx0JIQByDDbP0VqglcAw34vSAlBaGZReHqVVBa0QylQOZaqLyZK5/61uMnKM53M4MsOTYcCmv/x5q3clLp435wh1sycW5+I5/epJ79LlhgEpF7UcZ3DdBGazAZoZu+UZ+r7dk/7v9qJstWsv3qswo+tmTGYNi9VMqSolMJzeHDuYsxsws3bt0jIv0Cy8whX3ZTLpHh/+slzMSOe9v5aTnJGBv9VKIS8rPhYLu8+eYdz6NTd1X2Zdp3m5ED5o3ZaWIeVxGjmjm0nTsJpMpDkcmHWdOsHBrnB4tbeSn8VCIasVf4sFH7MZq8nE0/Ua4mspWD8/Xdcxm82uvYqz9iu+2S3qssYACnEnSAAUIg/I3vKX1V3komk4vZ5G6VWBDFDpwEWUXhKnJQLUScC4tA+vhqZrKKXhdPyzh68CSpZz0KjNRVAqxyxPh0Pnpy+Dr9p353Rk7hpy7pSJ5CQzF86bcuwQkpZqJcn+KiVC+1KhVjks1hvoWNBKYpiqohlnQDkJKFaIyvVCKF7GF6U0QAPNhKaZ0E06ukkDTcfsW+fmX1wP8tfRoySl2/CzWl1jDy26jkXX+ePoYZIzMm76Pi26idFtOzCseUtalAuhtL8/Vt2E+dIagl4mE280uZ+GJUu7xiRqmobp0p+sd7KuadgNgwynE7thYChF9aLFCK9y57rM84Ls+xV7eXlhtVoxm82uiSVOp9MVCB0OR44wKLuAiDtJuoBFnlbQu4CzJntkdRVdEf6yjtPLYPcdie5YjWacROnFMPTGWGxvoBsnUBRDwwHYUMqGUs7M5Vsu9bmZTBBcJp1HXj1Naqo3W1cVI+ViKupSz9Q9DdPIyMg82GzOvJ1G5t+7NvlSvqoNsxmcDo30NDOG4Y23rwOlDOZMf4zIVx++uSeuaTitj6EZp9HUMTAUVgtYrOUwtMaYHL8CRrbBhzqGuTnKVOVa9+rxUuyZAe/yb/YmTcNpGKTa7fhbrTd9vxaTichqoURWy9xTef+5c6w7eRyryUSLciEU9/VDKUXNYkFsTIjHUJcW5750e7Om0alSFcoGBLD00EFMmk67ihXpc09t/G6hnvzsZhahvnjxorQAijtGAqAQbpJjsgdcNfz9wwxGPLp9Cah0TGoyOvvInIZhI2ugn4YTTc96jGy3NiuKlbTxyMun+fRAILZUE45LY5Mq10rDcGqkp2WbKKCBj6+T0ycKk5wUSL1mCaAbOOwmzBYHGk727ypP3XZdb2m2ozJVwO7zPrpzJZoRD1pRnOamoBVHZZTDnD4NSAEsOC1hOLxfu+nH8DQ1g4q7Wua8zZkf70op0h1OygcG3vAYwOupXKQIlYsUyXGZpml82rY9Lyz6ld1nz5A19NSsadQoFsRrTZpS3NePgQ3vvS01FATXWmbGMAx+++03zGY5TYs7Q95ZQrhBbpM9rn6wDd2+GnP6KDR1MtsVWQPLsyZbXAqB2Ubaa9mbYQCLRVGu8kUGfhTPtNEh7FyXhtNpcCbeQpHgf3aF0E063n5WwIbTKMqCn6rj5bee6nUS8PFTGIbOqVM18S37f5SuWuHWXwi9CIbe9YqLnV7P4rQ+jqYSUVogaNIKciNCiwXROqQCSw4dwG4YmDWNDMPAYtJ5um6D27IkzbWU8PNnVvderDx+lN8PHsCsm7i3dGlalSuPlwSZ68pqHTQMgyFDhpCYmMi0adPcXZYooDR1rfn9QuQB6enX3vs0v8m+Af11W/2MRCy2j9Ac69DIWgswa3u47LMtTfyzTIy66ng+ZUDS+cIYhh9rlgQwfWxpMmwZNOt0gmffOYRhZC4L4+PvhcXqQGFl2/Z3iD/qR0BQIUIbWfH1PYPSSqNM5f/tSyHugAynkx+2bWbOnt1cSE+nSpEiPFa7Hq1C5OeVHxiGwdChQ/n5559ZtmwZVatWdXdJooCSACjyvIIUALOP97l+ly+YbWPQMxajcRZI55+gdwO/trkcohRkGHVwOr04uT+eMa+Hcu6UHafDzkPPHaBz31NYvTRMFh00f+zeb2JYOtzCMxXuppTCqRTmu7gYtvh3lFK8//77TJkyhbi4OGrU+Pe7yAhxNdImL/I8TdOuuRBtfpF9kPeNhD/URXTHWpRWCE2dyXbFDS63m8vda5oFiyUQCw5KVAimXtta7F53guTzqaz9szxFK1WjSQcDs5cfhrkpaHdnL11x+2mahrmAT6IqSJRSfPLJJ0yaNInY2FgJf+KOkwAoxB3m2tbt0oSLGwp/cGm5FydoFpTyQcMOrqH1t8oLzXkMjdP4+leg/38rc/p0F0xmC0VKFHbVlfuqZEKIO0EpxZgxY/jqq69YunQptWvXdndJwgNI34AQd1BW8Lvp8AegFUXp5dBUEkorQeb3tX8TADUgA40TKKxo2LHav6Vk8AqKlgws8EvuCJEXKaX48ssv+eyzz1i4cCH16tVzd0nCQ0gAFHlefg0m2Zd5uZV9QNF0nNbeoPmhqWSUVgy43o4JGoqiKIIuHatf+uODojiKAAw9FGVuiDJVQWne6PZFYJy+lacohPgXlFJ8++23fPTRR/z66680btzY3SUJDyKTQESeZ7fbr7pVUl51s5M9rkVz/I3JPh/d2IOiCIpCmJy/kXMWcBYdw9Qcu/cQTM41YMSjtAAMU0Ms6WNB88o5rk8ZaMZhHN4vYZhlfTYh7halFN9//z1vvvkm8+fPp2XLlu4uSXgYGQMoxG1205M9rkOZ6+Ew1/vnAudhTCmxZK77d3kwNuG0tAVTGZymHtnu5AJgAuW8bHKIE9BR121ZFELcLkopfvzxR4YMGcK8efMk/Am3kC5gkeflly7g7Ov75bqn722iAUoriiIA8Cazq9crs4tXKwp6cC43CsAw1UVTZ0Fd2g9WGWjGCZReEmUKve11CiGupJRi1qxZvPrqq0RFRdGmTRt3lyQ8lLQACnEbXL6zh6Zpdyy4Kr0USi+FZpzE0MujYaCwgjqPho6h575frtPaA02dRHfuQ6HQUCg9GIf1UdB8cr2NEOL2mjNnDi+88AIzZ86kY8eO7i5HeDAZAyjyPIfD4ZpFmxfd1M4et4luX4w5/RtQ6SjNF03ZAHBaH8Tp9cQ1ik1Dd27KbPm7NDYQvdgdr1cIAfPnz+eJJ55g2rRpdO/e3d3lCA8nAVDkeXk5AN7OyR43+cDojhWY7PPQjCMorRhOSxcMSyfQTHenBiHEDVu4cCH9+/dn8uTJPPTQQ+4uRwgJgCLvczqdOBwOd5dxhds92eOWKaeEPiHysNjYWB5++GHGjx/PI488km/GNYuCTcYACnGTbnlnjztFwp8Qedby5cvp06cPX3zxhYQ/kadIABTiJmTv8s2a6CEf6EKI3KxatYqHHnqIkSNH8vjjj8tnhchTJACKPC+vfGheHv5uemcPIYTHWLduHQ8++CAffPABzz77bJ75HBMiiwRAIW6A2yZ7CCHynU2bNhEZGcnQoUMZOHCgfF6IPEmaMIS4Dgl/QogbtXXrVsLDw3njjTd49dVX5fNC5FnSAijyPHd9gOa5yR5CiDxtx44dhIWFMWjQIN588035vBB5miwDI/I8pRQZGRl3/TGzlniBO7uzhxAi/9u9ezedO3fmySef5IMPPpDPC5HnSQAUed7dDoCXb+smkz2EENeyf/9+OnXqxMMPP8zIkSPlM0PkCxIARb6Qnp5+Vx5HxvsJIW7GoUOH6Ny5M+Hh4Xz++ecS/kS+IQFQ5At3IwBK+BNC3Ixjx47RsWNHOnbsyNdffy3hT+QrEgBFvpCRkcGdeqtmTfbIE9u6CSHyhZMnT9KpUydatGjBt99+i8kkO/KI/EUCoMgX7lQAlMkeQoiblZCQQJcuXWjYsCHff/+9hD+RL0kAFPnCnQiAMtlDCHGzEhMT6dKlCzVr1uTHH3/EbJbV1ET+JAFQ5At2u93VSnc7yHg/IcTNOnv2LGFhYVSsWJGff/4Zi8Xi7pKEuGUSAEW+cDsDYPaWP+nyFULciKSkJLp160bJkiWJjo7Gy8vL3SUJ8a9IABT5wu0KgFnj/aTlTwhxoy5evEhERASFCxdm7ty5eHt7u7skIf41CYAiX3A4HK4t2W6FTPYQQtyKlJQUevTogcViYf78+fj6+rq7JCFuCxm9Kgo8mewhhLgVqampPPTQQ2iaxrx58yT8iQJFAqAo0GR9PyHErbDZbPTp0webzcaiRYvw9/d3d0lC3FYSAEW+cCvBTWb6CiFuRXp6Ov379+f8+fMsXryYgIAAd5ckxG0nAVAUSDLZQwhxK+x2O48//jjHjx9n6dKlFClSxN0lCXFHSAAUBUrWtm5ZE0Yk/AkhbpTD4eCpp55i//79xMXFUaxYMXeXJMQdIwFQFBiXT/aQmb5CiBvldDoZMGAAO3bsIDY2luLFi7u7JCHuKAmAIl+4XpCTyR5CiFvldDoZNGgQ69evJy4ujpIlS7q7JCHuOAmAIt+TyR5CiFtlGAavvvoqy5cvZ9myZZQpU8bdJQlxV0gAFPmaTPYQQtwqwzAYMmQIixcvJi4ujpCQEHeXJMRdIwFQ5AuXBzuZ7CGE+DcMw+Dtt99m7ty5xMXFUalSJXeXJMRdJQFQ5Dsy2UMI8W8opXj//ff56aefWLZsGVWrVnV3SULcdRIARb4i4/2EEP+GUoqPP/6Y7777jri4OEJDQ91dkhBuIQFQ5Auapkn4E0L8K0opxowZw9dff83SpUupVauWu0sSwm10dxcgxI1YvXo1//vf/zh16pR0+QohbppSii+//JLRo0ezcOFC6tWr5+6ShHArCYAiXzh37hzff/891apVo2vXrkyYMIGTJ0+6xgEKIcTVKKWYOHEiH330EQsWLKBx48buLkkIt9OUnEFFPqGU4vDhw0RHRxMTE8OaNWto0qQJERERREREULZsWWkZFELkoJRiypQpvPXWW8yfP5+WLVu6uyS3++mnnzh69Chnz57lhRdeoGzZsu4uSbiBBECRLymlOH78ODExMURHR7NixQoaNGhAZGQkERERVKhQQcKgEB5OKcWPP/7Ia6+9xrx582jTpo27S3K7l156iQULFlCxYkW2bdtG0aJFiYuLIzg4GKWUfG56EAmAIt9TShEfH8+cOXOIjo7mjz/+oFatWkRERBAZGUnVqlXlQ00ID6OUYtasWQwcOJDo6Gg6duzo7pLcbtSoUYwdO5ZFixYRGhqKyWQiNDSUDh06MG7cOHeXJ+4yGQMo8j1N0yhVqhTPPfccv//+OydPnmTgwIGuLuL77ruPDz74gB07dsiYQSE8xJw5cxg4cCAzZ86U8AccPHiQRYsW8eGHH1KzZk0MwwCga9euxMfHu7k64Q4SAEWBomkaQUFBPPXUU/z666/Ex8czePBgtm3bRosWLWjQoAHvvvsumzdvdn0ACiEKlvnz5/PMM88wbdo0unbt6u5y8oSyZctSrlw5qlSpAoDFYgGgfPnyHDp0CACHw+Gu8oQbSBew8BgXLlxg/vz5xMTEsHDhQoKDg4mIiKB79+40aNAAXZfvQ0LkdwsXLuTRRx9l8uTJ9OrVy93l5AlZa6dmH+OX9e9Jkybx1VdfsXHjRgBOnjzJ6tWr6dKlC15eXu4sW9xhcsYTHiMgIIC+ffsSFRVFQkICn376KfHx8YSFhVGzZk2GDBnCypUrXfsLCyHyl9jYWB599FEmTJhAz5493V1OnpH15Tb7WOisth+r1eoKeidOnOCee+5hxYoVEv48gARA4ZH8/Pzo2bMnM2bMICEhgXHjxpGUlMRDDz1E9erVefXVV1m+fLl0iQiRTyxfvpw+ffrw5Zdf0rdvX5n4dR3Zezw0TSMhIYHmzZvTvn17Ro0a5cbKxN0iXcBCZJORkcGSJUuIjo5m3rx5aJpGWFgY3bt3p2XLlq5xM0KIvGPlypX06NGDkSNH8swzz0j4uwkxMTEMHDgQs9lM3bp1+eWXXwBwOp2YTCY3VyfuJGkBFCIbq9VKly5dmDRpEidOnGD69OlYrVaefvppKlWqxIABA1i4cCHp6enuLlUIAaxbt46ePXvy4YcfSvgDtm3b5vr3Z599xtatW695vNPpJD4+nvbt20v48zDSAijEDXA6nfz5559ER0cze/ZskpOT6dy5M5GRkbRr1w4fHx93lyiEx9m0aRNhYWEMHTqUV155xePD3+bNm3n88cfp1asXx48fZ8KECezbt48KFSpc83affvopb7zxBiDhz5NIABTiJjmdTlavXu0Kg4mJiXTs2JHIyEg6dOiAv7+/u0sUosDbunUrXbp04fXXX2fIkCEeH/4gc8/0kSNHMnnyZFJSUvjrr7+oU6cODocDs9l8xfGXX36140TBJF3AQtwkk8lEs2bNGD16NPv37yc2NpbKlSszfPhwKlSoQJ8+ffjpp5+4cOGCu0sVokDasWMHYWFhvPjiixL+LjEMgyJFilC3bl3S09MJCQkhKioKm82G2WzOdXWDy8OehD/PIi2AQtwmhmGwZcsWoqKimD17Nvv37+eBBx4gPDycsLAwAgMD5UQlxL+0e/duOnfuzFNPPcWIESM8/nfq8v179+zZQ0ZGBlFRUfz222+0bNmS4cOH5ximkrUuoPBsEgCFuAOUUuzcuZOoqChiYmLYsWMHrVq1IjIykrCwMIKCgjz+xCXEzdq3bx+dO3emT58+fPrppx4fYrKHv61bt+Lj44OXlxflypUjKSmJkSNHsmTJEpo3b87777+Pj48PzzzzDM8++ywNGzZ0c/XC3SQACnGHKaXYt2+fKwz+/fffNGvWjMjISMLDwylRooSEQSGu49ChQ3Tq1InIyEjGjh3r8eEvu7Fjx/LJJ5/g5eVFoUKF+Pjjj+natSspKSmMHDmShQsX4uXlhclkYt++fRw5csTdJYs8QAKgEHeRUopDhw4RHR1NTEwMa9eu5b777iMiIoKIiAjKlCkjYVCIyxw7doyOHTvSsWNHvv76awl/2ezatYvWrVszYcIEMjIyiIuLY8KECUyfPp3evXtjs9mYMWMG69atw+FwMH78eHRdl9m+QgKgEO6ilOLYsWPExMQQExPDihUraNiwIZGRkURERFC+fHkJg8LjnTx5kk6dOtGyZUsmTpwooSWbefPmcfjwYU6fPs3w4cMBOHXqFJ988gljxozhhx9+oF+/fleME5TZvgIkAAqRJyiliI+PZ/bs2URHR7N8+XJq165NREQEkZGRVKlSRcKg8DgJCQl07tyZxo0bM2XKFAl/2Vy4cIHHHnuMuXPn0rt3b2bMmOG6LjExkZEjRzJ69Gg+//xznn/+eTdWKvIqCYBC5DFKKRITE5k7dy7R0dHExsZSvXp1wsPDiYyMpEaNGhIGRYGXmJhIly5dqFmzJj/++KO0WOVi06ZNjB07lp9++omlS5fSvHlz13Vnz57l3XffZdmyZWzcuBGTySSfGyIHCYBC5GFKKc6fP8+8efOIjo7m999/p3z58kRERNC9e3dq1aol46FEgXP27FnCwsKoWLEiP//8s+zBzT8zflNSUkhNTaV48eJA5vjIV155hdjYWKKiomjTpo3rNhcuXMDLywsvL68ruoGFkAAoRD5y4cIF5s+fT3R0NAsXLqRkyZKubuIGDRpIGBT53vnz5+nWrRulSpUiJiYGq9Xq7pLcLmvdvt9++43Ro0ezb98+6tSpQ9u2bXn++ec5fvw47777LvPmzWPmzJm0b98+x+0l/IncyNlCiHwkICCAvn37Eh0dTUJCAh9//DEnTpwgLCyMmjVrMmTIEFatWpXrqv9C5HUXLlygR48eBAUFERUVJeHvEl3XWbZsGT179qRly5ZER0fj5+fH8OHDWb58ORUqVODtt9+mZ8+edOzYkdjY2By3l/AnciMtgEIUAGlpaSxatIiYmBh++eUXfH19CQ8PJyIigvvvv1/GT4k8Lzk5mR49emC1WlmwYEGOnSs8mVIKm83Go48+SrVq1fjggw9ISUmhRo0aREZGMm7cONexBw8eZMKECbz44ouULl3ajVWL/EACoBAFjM1mY+nSpcTExDB37lxMJhNhYWF0796dFi1ayHgqkeekpqbSs2dPlFIsWLAAf39/d5eU53Tp0oVBgwZx77330qBBA9q1a8f//vc/NE1jzpw5lCpViiZNmrjW95N1/sT1SAAUogCz2+388ccfREVFMWfOHOx2O2FhYURGRtK6dWu8vLzcXaLwcDabjd69e5OSksLChQsJCAhwd0l5itPpxOl0EhYWRpUqVfjzzz+pV68ekyZNwmq1cv78eZ599llatmzJ888/L9294oZJABTCQzgcDv766y9XGExOTqZLly5ERkbywAMPSJebuOvS09N55JFHSExMZPHixQQGBrq7JLfLarlLS0vDx8fHtWjzkiVL6NWrFyVKlGDXrl2u4999912mTp3K77//TqVKldxYuchvJAAK4YGcTierV692hcHExEQ6depEREQEHTt2xM/Pz90ligLObrfz6KOPcuTIEZYuXUrRokXdXZLbZc323blzJ2+99Rapqam0atWKXr16Ua1aNcaOHcvgwYOJjIykVKlSpKSkEB0dzZIlS2jcuLHr9kLcCAmAQng4wzBYv349UVFRzJ49mxMnTtC+fXsiIiLo3LmzdMmJ287hcPDkk0+ye/duYmNjXWvaebKs8JaQkEDNmjUJDw8nOTmZEydO4O/vz2effUbNmjVZsmQJn332GWazmUqVKvHEE09Qr149GfMnbpoEQCGEi2EYbN68mejoaGJiYjhw4ADt2rUjPDycrl27EhgYKGOMxL/idDp59tln+fvvv4mLi6NEiRLuLsntstbpO3/+PHPmzGHr1q189tlnAMydO5cJEyaQlpbGp59+SuPGjV1hLys0SsufuBUSAIUQuVJKsWPHDqKiooiJiWHnzp20bt2ayMhIwsLCKFasmIRBcVOcTieDBg1i5cqVLFu2TJYqySY1NZVnnnmGP//8k7CwML766ivXdfPnz2f8+PGkpaUxbNgwWrVqBSDBT/wrEgCFENellGLv3r2uMLh582aaN29OZGQk3bp1o0SJEhIGxTUZhsHLL79MXFwccXFxhISEuLukPGfkyJFMnToVp9PJ4sWLKVOmjOu6RYsW8emnn5Kens6CBQsoXLiwGysVBYEEQCHETVFKcfDgQaKjo5k9ezZr166ladOmREREEB4eTpkyZSQMihwMw+CNN95gwYIFLFu2jIoVK7q7JLe72pi97777jm+++YaqVavy/vvvU7lyZdd1ixcvpnjx4tSvX/9ulioKKAmAQohbppTi6NGjxMTEMHv2bFasWEGjRo2IiIggIiKC8uXLSxj0cIZh8PbbbxMVFUVcXBxVq1Z1d0lul7W0S0pKCj///DMOh4MiRYrQs2dPACZPnszkyZMpWbIkI0aMoFq1am6uWBREEgCFELeFUoqTJ08ye/ZsYmJiWL58OXXq1HGFwSpVqkgY9DBKKYYPH84PP/xAXFwcoaGh7i7J7bImfKSkpNCwYUO8vLzIyMjg8OHDdOzYka+//ppSpUoxefJkfvzxR7y9vfn444+pVauWu0sXBYwEQCHEbaeUIjExkTlz5hAdHU1sbCyhoaFEREQQGRlJaGiohMECTinFxx9/zIQJE4iNjZUAk41Sim7duqFpGrNmzSItLY2DBw8SHh7OPffcw+LFiwGYNGkS//vf/xg1ahTNmjVzc9WioJEAKIS4o5RSnDt3jnnz5hEdHc3vv/9OxYoViYiIoHv37tSsWVNmMhYwSinGjBnDmDFjiI2NpW7duu4uKU9JS0ujXbt2PP300zz++OOu2bz79u2jfv36vPHGGwwdOhSAw4cPU758eTdXLAoi+dQVQtxRmqZRtGhRHn/8cX755RcSEhJ4++232bt3L23btqVevXoMHTqUDRs2YBiGu8sV/5JSii+//JLRo0ezaNEiCX+XUUrhcDg4ePAgR44cAUDXdRwOB1WqVOHBBx9k+/btruOzwp+01YjbTQKgEOKuKly4MI888gjR0dEkJCTw4Ycfcvz4cbp27UqtWrV48803Wb16NU6n092lipuklGLixIl89NFH/PrrrzRq1MjdJbnd5e9jTdMoVKgQzz33HNOmTWPevHkAmM1mAPz8/NB1HaVUjtAnQybE7SZdwEKIPCE1NZXFixcTHR3N/Pnz8fPzo1u3bkRGRtK0aVPXCVLkTUoppkyZwltvvcWCBQto0aKFu0tyu+xLvcydO5fExESaNWtG6dKluXjxIq+99hoHDhzg2WefpW3btuzYsYNHHnmE0aNH8+STT7q5elHQSQAUQuQ5NpuNpUuXEh0dzbx58zCbzYSFhdG9e3eaN2+OxWJxd4kiG6UU06ZNY/Dgwfzyyy+0bt3a3SXlKa1ateLo0aOcP3+eIkWKUL9+fUaPHo1SilGjRjF58mQCAgLw8vLiiSeeYNiwYe4uWXgACYBCiDzNbrezbNkyoqKimDNnDk6nk7CwMCIjI2ndujVWq9XdJXo0pRQ///wzgwYNIiYmhg4dOri7JLfL3vL3xRdfEBUVxdSpUylZsiQzZsxg5syZOBwOvvvuO8qWLUt8fDxHjhyhUKFC1KhRA5Bt3sSdJwFQCJFvOBwO/vrrL2bNmsWcOXNISUmha9euRERE0K5dO7y9vd1doseJiYlhwIABzJw5k65du7q7nDxl2LBhnDp1iqpVq/Laa6+5Lp87dy4jRoygf//+vPjii1fcTsKfuBskAAoh8iWn08mqVatcW9KdPXuWTp06ERERQYcOHfDz83N3iQXe/PnzeeKJJ/jxxx+JjIx0dzl5TpUqVThw4ACPPfYY3333XY6JHH379mXPnj2sWbMm1y3hhLjT5CuGECJfMplMNG/enDFjxnDgwAF+//13KlSowLvvvkuFChV45JFH+Pnnn7l48aK7Sy2QFi5cyJNPPsmUKVMk/EGuSxjt27ePdu3aMWfOHBYuXEh6errrugYNGhAUFJTjMiHuJmkBFEIUKIZhsHnzZqKiooiJieHQoUM88MADRERE0LVrVwoXLixLavxLsbGxPPzww0ycOJE+ffp4/OuZfczf7t27KVKkCIGBga7xqS1btmTfvn288847NGnSBLvdTmRkJA8//DCfffaZO0sXHkwCoBCiwFJKsX37dqKiopg9eza7du2idevWREZGEhYWRtGiRT0+vNys5cuX06tXL7744gsee+wxef2yefrpp/nrr7+Ij4/nxRdfJDw8nIYNGwLQsWNHfv/9d8qUKUOLFi0oUaIEY8aMAf7ZH1iIu0kCoBDCIyil2LNnD9HR0cTExLB582ZatGhBZGQk3bp1Izg4WE7C17Fy5Up69OjBqFGjePrpp+X1yuaHH37gww8/5Ouvv2bFihXMmjWLOnXqMGDAAJo3bw7Aww8/zC+//MLPP//smjDjcDhkjUvhFhIAhRAeRynFwYMHXWFw/fr1NG3alIiICMLDwyldurSEm8usXbuWyMhIRowYwQsvvODxr8/lM3VnzpzJ8ePHefXVVwGYPXs2H3/8MZUqVWLAgAG0atUKgC5durBu3TqmTJlC27Zt8fHxcUv9QkgAFEJ4NKUUR48eJSYmhpiYGFauXEnjxo0JDw8nMjKSkJAQjw87GzdupFu3bgwbNoyXX37Z41+P7F2233zzDbt372b//v20atWKwYMHu46bP38+H374ISEhITz22GN07twZgN69ezNr1izi4uJcwVCIu00CoBBCXKKU4uTJk8yePZvo6Gj+/PNP6tSpQ2RkJBEREVSuXNnjws+WLVvo2rUrb7zxBm+88YbHPf/LZQ9/Q4cO5fPPP6dp06asWbOGoKAgJk6cSNu2bV3HL1y4kIEDB/L888/zyiuvuG771ltv8c4778jalcJtJAAKIUQulFIkJia6wmBcXByhoaGuMBgaGlrgw9COHTvo3LkzgwYNYujQoQX++d6MHTt2MGnSJHr16sV9993H4sWLGTt2LE6nk9dff5127dq5jt2yZQt16tQBMne2ka0MRV4gAVAIIa5DKcW5c+eYO3cuMTEx/P7771SqVImIiAi6d+/OPffcU+B2bti9ezedO3fmqaeeYsSIERL+slm4cCFPP/00hQsXZsGCBZQvXx6A33//nXHjxmGz2Rg8eDAdO3bMcbvsy8UI4W4F6xNLCCHuAE3TKFq0KE888QS//PILCQkJ/Pe//2X37t20adOG+vXr884777Bx48ZcFwTOb/bt20dYWBj9+/fn/fffl/B3GYvFQpMmTThw4AC7du1yXd6+fXteffVV/P39ef3111m7dm2O20n4E3mJtAAKIcS/kJyczK+//kp0dDS//vorQUFBrgkkjRs3znctg4cOHaJTp05ERkYyduzYfFf/7Xa1NfrWrFnDRx99xM6dO/n888/p1KmT67olS5awfPlyhg8ffjdLFeKmSAAUQojbJDU1lUWLFhEdHc2CBQvw9/enW7duREZG0rRp0zzfAnT06FE6depEx44d+frrryX8ZQt/69at4/z585w/f54HH3wQXdf5+++/+fTTT9m8eTOffPIJYWFhV9yHdPuKvEoCoPB477//PocOHXKtASfE7WCz2ViyZAkxMTHMnTsXi8VCt27d6N69O82aNctzEwFOnjxJx44dadWqFRMnTpTQks2ECRN45513CAgI4NSpU5QvX55Ro0bRvn17Nm/ezOjRo9m0aRNvvvkmffv2dXe5QtwQCYDCo8XHx/P444+zefNmdF0nKSmJfv368fbbb1O2bFl3lycKCLvdTlxcHNHR0cyZMwen00lYWBiRkZG0bt3atWesuyQkJNC5c2fuvfdeJk+eLOEvm2XLlhEREcHUqVOpX78+vr6+9O7dm6NHj/Ltt9/SsmVL1q9fz4cffoiu6/z8888e33Iq8gcJgMKjzZs3j08++YSBAwfSp08fFi9ezNtvv02rVq0YOXKk7NEpbjuHw8Gff/5JVFQUc+bMITU1la5duxIeHk67du3u+rpwiYmJdOnShVq1ajFt2jTZluySrN/9r7/+mmnTphEXF4fZbHaF47Zt25KUlMSGDRuAzFnTFStWdHuYF+JGydcU4dHWrFmDpmnUrl0bgA4dOlCrVi2ioqLYuXOnK/ydPn2aefPmMX/+fDIyMtxZssjnzGYzbdq04auvvuLIkSPMmzePoKAgXn/9dSpWrMgTTzzhCoZ32tmzZ+nWrRvVqlVj6tSpHh/+zp07x8aNG1m/fr3rdz8xMZHExES8vLwwmUyun8tXX33FwYMHWb16NQDVq1fHarUWiFngwjNIABQe6/Tp02zfvp3atWtTq1Yt1+WFCxdG0zQKFy4MwCuvvMI999zDe++9x+DBgylatChhYWGsWLHCXaWLAsJkMtGiRQvGjh3LwYMHWbx4MSEhIQwbNowKFSrwyCOPMGvWLC5evHjbH/v8+fNEREQQEhLCTz/9lOfGJN5thw8fpnv37vzf//0f77//Pg6HA8jctu306dO8/fbbAPj6+gKZYzyLFSuGv79/jvuR7l+RX8g7VXisTZs2sXPnThYvXsycOXM4c+YM0dHRTJ8+nXvvvZfSpUszaNAgPv/8c4YNG8akSZNYvnw5a9eupU6dOnzyySfs27fP3U9DFBC6rtOkSRNGjhzJnj17WL58OTVq1ODjjz+mQoUK9O7dm+nTp3P+/Hn+7cidCxcu0KNHD4oXL86sWbM8vtvy+PHj3HfffdSrV49vvvmGmJgYzGYzSikqVKjA0KFDmTlzJq+99ho2m41jx44xZcoUvLy8CAkJcXf5QtwSGQMoPNawYcNYsGAB9evXZ+3atWzbto3ixYvTpEkTPv/8cw4ePEivXr3o378/Y8eOzXHb06dPM2zYMNq3b0+PHj1yXDdv3jxatGhBkSJF7uKzEQWVUort27cTFRVFTEyMa/HpyMhIunbtStGiRW9qnGpycjI9evTAy8uL+fPn4+Pjcwerz/vS0tLo3r07wcHBfP/9967XMvv434SEBKKiolwtg0FBQdjtdpYsWULFihUxDENa/kS+IwFQeKSzZ8/yzDPP4O3tzbRp0wBISkpiz5491KpVCx8fHx555BHWr1/P1KlTuffee3PdwzMpKcnVVZySksKsWbN48sknqVy5Mnv27JEJJOK2UkqxZ88eoqOjiY6OZsuWLbRs2ZKIiAi6detGcHDwNd9zqamp9OzZE6WUa51CT3f48GE6derEqFGj6Ny58xVBLivcGYbB+fPnWbRoESVKlKBWrVoEBwfLOn8i35IAKDzSL7/8wvDhw3n88cd54YUXcDgcOQbAp6Wl0bp1awICAvj111+vCH65feP/+uuvWb58OYGBgezbt4/FixejaZqEQHFHKKU4cOAA0dHRxMTEsGHDBpo2bUpERAQRERGUKlUqx3vPZrPRu3dvUlJSWLhwIQEBAW6sPu9YuHAhXbp04cyZMxQpUiTX3+20tDRiY2Pp2rVrjsul5U/kZ/LOFR6rWLFiNG3aFPhn4HbW96G0tDS8vLzw9vbGYrFgt9tz3PbyD/21a9cyatQowsPD6devH0FBQezatUvCn7hjNE2jcuXKvPHGG6xatYr9+/fTvXt35s6dS40aNWjfvj3jxo3jyJEjpKen069fP5KSkvj1118l/GVTvnx5fHx8mD179lUD3Zw5c/joo4+umJkt4U/kZ9ICKMRlsk4Cffv25fDhwyxbtixHC2DWr0xWuDty5Aj/+c9/KF++PN9++y3x8fHUrFmT7du3U7JkyVwfI/v4orS0NC5evEhwcPAdfmbCEyilOHHiBLNnzyYmJobly5dTqFAhgoODWbVqFUWLFnV3iXnKmTNnaNKkCeXKlWPChAlUq1YNyPk7OmzYME6dOsUXX3zh8bOlRcEhX1+ER3I6nVe9Lutb/RNPPMGuXbsYNWoUaWlpruuzd+ueOXOG//u//yMpKYlvv/0WyFxLLCgo6JqtA5qmkZKSwpAhQwgPD6d9+/ZUrlyZwYMHs3fv3tvxFIWH0jSNMmXKMHDgQJYuXcqJEyeIjIwkOjpawt9lDMOgWLFiTJw4kXXr1vHGG2/w999/A5mvY2pqKh999BETJ05kwIABEv5EgSItgEJcw/jx4xk9ejRVq1blP//5D4GBgaxZs4bIyEhCQ0NdJ9ndu3dTu3ZtHnvsMUJDQxk/fjyDBg2iffv2ud7vyZMn6dmzJxs3bmTAgAG0a9eO06dPM3/+fE6ePMm777571dsKIW4vpRQzZszg2WefpXjx4tx7770EBQVx7NgxVqxYwaxZs2jdurWM+RMFigRAIa5j69atfPPNNyxbtozSpUvTqFEj+vTpw6FDh3j00Uf59ttvqVWrFjExMcyaNYu9e/dis9nYtGkTdevWzXU7uZdffpmpU6cyfvx4evXq5TrGbrfz+eefM2vWLNasWeM63jAMmVAixB22Z88e3n33XQ4ePIjT6eSBBx6gV69eNGjQQMKfKHAkAApxExITEwkKCmLFihX06dOH9u3bM2nSpBzHLFmyhEGDBvH9999z7733XnEfhw4d4v7776dXr1588MEH+Pv75wiJSik2bdqU60kna5spOREJcXOyfseutr931u9absfJnuCiIJKziBDXYRiGa1uooKAgAJo1a8aKFSv47LPPXMdkCQkJoUiRIuzatQvgil0bDh06RHx8PJ06dXKtw3b5iaZBgwYA2O12li5dysSJEzly5Ai6rkv4E+ImvP766yxZsoRz584BuMLd5bKHv8uPk/AnCiI5kwhxHbqu51gjMEu5cuUIDAx0HQOZAa5KlSquDeKzLoN/QuKOHTvw9/enePHiOa6HnCeatLQ0OnfuzDPPPMM333xDaGioaymP3CilZCN6IbIZPXo0n332Gc899xxvvPEGgwcPJj09nYyMDIArfl8uD3oS/ERBJgFQiNso64QxduxYKlasCPwTDrP+LlOmDOnp6bmGtazLLl68yLBhw9i5cyfTpk1j06ZN/PHHH6xevZpffvnFdfyWLVs4fvy467GldVCIf3Tr1o2BAwcyfPhwunTpwsKFC2nTpg2vvPIKmzZtyvH7IqOhhKeRs4UQt5mu67z44ou0aNEi1+vbtGlDcHAwI0eO5OzZszlaGbJOSNu3byc2NpZXX32Vpk2b4nA4aNy4Mc2bN2fKlClA5jZ0Y8aMoU2bNvz222+89957bNu2Dch5MnM4HHJyEx6pePHibN++nW3bttGjRw+2bdvGe++9x8qVK2nevDmDBg1i8uTJ7i5TCLeQACjEbaaUumbgCggI4Mcff2Tv3r2MGDGCnTt3kpqays6dOzlw4ACQuUzM8ePHefDBBwFcYxCTkpIoVKgQAEePHmXv3r2cO3eO2NhY1q9fT6tWrZgxYwaapnHmzBkAzGazdGUJjxQYGMgHH3zAjz/+yOLFiwE4f/48e/fuZcCAAaSmpvLqq69So0YNEhIS3FytEHfXlQObhBD/yvXCllKKFi1aMGLECD755BMmTZpE/fr1sVqtlC5dmilTpmCz2cjIyKBSpUoAeHt7A7Bhwwaee+45IHN5mq1btzJ58mQiIiIwmUz07NmT0aNHk5aWRkxMDOvXr+e1115j0KBBrvvIXseN1CtEfrF69WrOnz9PxYoVqV69OkopQkNDadasGWfPnmX+/Pn07duXUaNG8dJLL5GSksL//d//sXXr1qvu2iNEQSUBUIi7LCtwhYWFERYWRmpqKnFxcQQHB1OjRg0ASpQogbe3Nz/99BMPP/wwhmHw/fffk5SURIcOHbDb7axZs4bq1avTo0cP130HBQWxYMEC4uPj+fDDD1m/fj0jRoygSZMmtGzZEoCEhARKlCiRI/g5nU5MJtNdfBWEuL1eeuklNm/ejMlkYuTIka5lXQIDA2ndujV9+/YF4IsvvuCFF14AwM/Pj0qVKrm+aMlyL8KTyDqAQrhJ1nZ0Vwter7zyCrNnz6Z3794cOnSIpUuX8vzzzzN8+HC2b9/OwIEDqVevHmPGjAHgxIkTPPPMM1gsFmbPng1kdh0HBgYyfvx4HnnkETRNo0qVKkRGRtKuXTt8fX1dwVCI/Oq5557j999/Jzo6mtKlS7tm2GfXs2dPAKZPn47Var3bJQqR50gLoBBukj345dbyMHr0aO677z6mT5+On58f06dPp02bNgBs3ryZxMREwsPDXcdv2LCBM2fO8OSTT7ou2717NxUqVMBut6NpGsnJyRw4cIDp06dz8uRJli9fjslkYtasWTRu3PiKGq8XUoVwtxkzZrB48WKmTp1K3bp1r3pco0aNmDZtGikpKVitVmntEx5PJoEIkQfkdiLSNI3evXszd+5cpk+fTocOHbBYLNhsNv744w9SUlJo3bq16/g1a9ZgNptztOgtXLiQwMBAypUrB8C0adMAGDRoEOPHj2fbtm3Ur1+fDz74INe6TCaThD+RJ2V1Xq1fv566deu6Fk+/2nFDhgwhPT2dQYMGATL2VQgJgELkYU6n09UKl8Xb25vnnnuOESNGuE5i8fHxbNy4kSpVqlC9enXXscuXL6d8+fLUrl0bgMmTJ9O9e3cGDBhAoUKFKFy4MK1bt2b37t2cP38egOPHjzNq1Cjuv/9+OnfuzLx5866oSxadFu6WNdt+w4YNBAYG4u3t7Zotn52macTGxrJ161Z69eqV6/aMQngi6QIWIg+7WutbvXr1qFevnuv/Z86cQSnlCnoAO3fuJD4+nh49elCiRAlSU1NZt24dTz31lGspGcg8Qfr6+nLmzBnsdjv9+vVj//79PP3001y8eJGXX36Z06dP89RTT+W4TVb4NAwDpZS0FIq7KmvNzFKlSrFq1SocDgdms/mK/bPPnj3Lhx9+yNtvv80777yDl5cXIBM+hJAAKEQ+dPlJrmbNmvz222/YbDbXZXPnzuXcuXPUqlULgDlz5gDg4+Pj2touLS2N/fv3ExAQQOXKlfnoo484dOgQf/zxh2snk5SUFL799ls6duxI2bJlWbRoEStXrqRPnz5UqVIl123yhLhT9u7dS0ZGBkopatWqRa9evVi4cCH//e9/GT58uKslMOt9efLkSWw2G2azWcKfENlIF7AQ+dDlW75ldcdmX+uvd+/eDBs2jIYNGwLw3XffAbB27VrXMYsWLWL58uV07twZm83G6tWrad++PRUrVnSNnfrPf/7D33//7fr/unXrGD9+PJ988gndunXj3nvvZdGiRbnWmdU6KMTtMG7cOHr16kXjxo156KGHGDNmDD169KBdu3ZMnTqVoUOHusKezWZj7dq1hIeH06BBA5o3b+66Hwl/QkgLoBAFQm57AFesWNHVipeenk5cXByTJk1i9uzZhIeHU6FCBSZMmMBTTz3FY489xqlTp9i7dy9du3YFICMjAy8vL/bs2YO3tzfBwcEkJSWxYcMGILPVcdCgQXz//fcMHjyY2rVrU7p06Rytk1l/ZwVU2atY3KpPPvmE999/ny+++AKLxcLcuXP59NNPueeee5g0aRL9+vVjypQpzJ49m3bt2nH8+HH27dtHy5YtGTduHHBly7kQnkwCoBAFlFIKh8OBxWIhOjqaokWL0rx5c1q3bs3o0aPZt28fX331Ff3793d1jZ08eRKLxQLguuy7776jVatWeHl5sXr1ao4dO8YLL7zA4MGDgczWlGnTprFu3ToiIiLQdZ309HTmzp3LhQsX6NatGyVKlMi1PmmJETfihx9+4K233mLNmjWu5YoaNWpE69atWbx4MR07duSnn34iJiaGxYsXs2XLFho0aEDv3r3p168fIIudC3E5CYBCFFCaprlOeB9//DH16tWjZMmSFCpUiC+++OKK451OJ4899hjff/89DzzwAD4+Pnz77bfExsa6unhXrFiBxWKhS5curtudO3eO6tWrc+HCBQBiY2P5+OOPOXPmDBaLhVdeeYW+ffsybtw4V6jMqg8yW2WyTyoRIrtz584xc+ZMqlWrxqlTp1yXh4aGEhoait1ux2634+vrS79+/ejXrx92u931RQYk/AmRG2kLF6IAy+ruGjZsGG+++Sb+/v4AuS6XYTKZeOGFF9A0jerVq9OmTRumTZvGO++8Q9u2bUlKSmLz5s2UKVPGNa4QYOPGjdhsNho3bozT6eTll1+mYcOGbNiwgdWrV/PHH3+wceNGZsyYAYDNZuOvv/4iPj7eVaOEP3E1RYoU4b333qNhw4Z89NFHTJ06FYApU6bw119/uXa/yVoWBq4caiDhT4grSQugEB4gaxusLFebuVu1alXi4uI4cuQIa9eupUGDBq59UtesWcPx48fp3r27K7CdPXuWv//+m3LlyhEaGsrMmTPZt28fEyZMID4+nl69etGlSxdq1KjB33//DcDhw4d5/vnnKVeuHM8++ywrV67k6aefpnLlyq4xWqmpqUyePJlmzZrlWO5GeKZGjRrx+uuv8+mnn/Ldd9/xxx9/EBUVxaxZs6hVq9YVLXwS+IS4PmkBFEK4OJ1ODMMgJCSEnj17usIfwKlTp7DZbDRp0sR12fbt2zl69Cj3338/kNlFHBISwuLFizEMg2effZagoCDmzZvHqVOncDqdHD16lISEBPbv38/u3bv5+++/ad68OXFxca6Wm507dzJ58mTXItR2u/0uvgoiL6pXrx5vvfUWZcqUITo6mh49etC9e3dAZvUKcSukBVAI4ZLVcpLVlZb9xNqvXz+6d++On5+f67Jly5Zx7NgxHnjgASBzQerq1avTqFEjvv/+e1JTU1m9ejVLly6latWqmEwmli5disPhYPny5QQHB/Paa6/RvHlzfv75Z9q0acPMmTN56623SElJoWzZsgA5xnMJz1W7dm2GDh2KyWRi9+7dTJw4kWeeeQZd12VSkRA3SVoAhRBXyG1ShlIqR/gDaNu2LX369KFRo0YAdOvWjfXr17NkyRIAfH19adu2LR988AGPP/44x48f548//qBXr14EBwcDma179evXZ+fOnQB07tyZkJAQzGYzL730Et7e3qxcuTLXOi9evMiePXtIT0+/rc9f5F3Vq1fnv//9L6Ghofzwww98+umngLQCCnGzJAAKIW5IbifYZs2aMWLECNf/H374YSIiInjppZd46623WLx4MTNnzmTv3r1AZtfurl27XEtzQOYszxUrVlC/fn0AtmzZgqZpvPTSS1y8eJH58+cTEhKSa00bNmzgzTffpE6dOrRo0YKNGzfezqcs8qisEFiiRAmOHj3q7nKEyJekC1gIccuyD77P6oIbN24cM2bMYPLkycyZM4cWLVpwzz33oJRi1apVFC5cOMeuDHv27GHLli1MnjwZyJxskpaWxr333gtAu3btrvr4ZcuWpW/fviQnJ/Pkk0+ybds2GjRocAefscgrKleuzJdffkmpUqUAWVdSiJslAVAIccuyz7bMOvmazWb69+9P//79MQyD+Ph4SpcuzYkTJ5g5c6ZrIV/IXI4mNjaW4sWLU79+fdLT09myZQvFixd3BcBrqVKlClWqVGHixImUKlWKpk2b3v4nKfKsrPAnO3wIcfMkAAohbjun0wlkBsTSpUsDULp0aT7//HPX/wESExOJiYmhR48eAGzdupXjx4/TokULfH19r9uqk5GRgdVq5YcffqBly5Y57lt4Dgl/Qtw8+a0RQtx2JpMp17XYHnjgAWrUqOH6f3JyMsePH+fRRx91/f/QoUPUrVsX+GcP4auxWq3YbDZWrVpFt27drpikIoQQInfSAiiEuGsub9GrUqUKZ86ccf2/YcOGFClShBkzZlCsWDFatGhx1ftyOByYzWZmzpxJYGBgjt1JhBBCXJu0AAoh7prLu3OzuoqzFCpUiEmTJqGU4tFHH2Xbtm3Xva8pU6bQpk0b6f4VQoiboKmsFV+FECKPuXyLryypqan4+voCmZNOvvvuO1c3shBCiOuTLmAhRJ5iGAaGYWA2m68a/oYMGcKmTZuoWrUqhQoVku5fIYS4SdIFLITIU3Rdx2y++ndTX19fnn/+eapXr86KFStISkri0UcfZerUqaSkpNzFSoUQIv+SLmAhRL62a9cuvvnmGxISEvjss88oU6aMu0sSQog8TwKgECLfyeomNplMsvuDEELcAgmAQoh8zTAMlFK5jhcUQgiROwmAQgghhBAeRiaBCCGEEEJ4GAmAQgghhBAeRgKgEEIIIYSHkQAohBBCCOFhJAAKIYQQQngYCYBCCCGEEB5GAqAQQgghhIeRACiEEEII4WEkAAohhBBCeBgJgEIIIYQQHkYCoBBCCCGEh5EAKIQQQgjhYSQACiGEEEJ4GAmAQgghhBAeRgKgEEIIIYSHkQAohBBCCOFhJAAKIYQQQngYCYBCCCGEEB5GAqAQQgghhIeRACiEEEII4WEkAAohhBBCeBgJgEIIIYQQHkYCoBBCCCGEh5EAKIQQQgjhYSQACiGEEEJ4GAmAQgghhBAeRgKgEEIIIYSHkQAohBBCCOFhJAAKIYQQQngYCYBCCCGEEB5GAqAQQgghhIeRACiEEEII4WEkAAohhBBCeBgJgEIIIYQQHkYCoBBCCCGEh5EAKIQQQgjhYf4f1fCnKZeF134AAAAASUVORK5CYII=", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "dca60fc6df6e47d7983babea1e450180", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "07a816072a7845dd915f5d0db3a9d377", - "version_major": 2, - "version_minor": 0 - }, - "image/png": "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", - "text/html": [ - "\n", - "
\n", - "
\n", - " Figure\n", - "
\n", - " \n", - "
\n", - " " - ], - "text/plain": [ - "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Perform KMeans clustering\n", "clusters = 3 \n", From 50b7b9da9b0fcb4a8e63c4c701787a133a27d647 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Wed, 30 Oct 2024 14:34:03 -0400 Subject: [PATCH 07/14] unify with .get_spectral_dims(return_axis=True)[0] --- pyTEMlib/eds_tools.py | 6 +++--- pyTEMlib/file_tools.py | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/pyTEMlib/eds_tools.py b/pyTEMlib/eds_tools.py index c87a8b84..afffaec0 100644 --- a/pyTEMlib/eds_tools.py +++ b/pyTEMlib/eds_tools.py @@ -212,7 +212,7 @@ def get_x_ray_lines(spectrum, elements): # omega_K = Z**4/(alpha_K+Z**4) # omega_L = Z**4/(alpha_L+Z**4) # omega_M = Z**4/(alpha_M+Z**4) - energy_scale = spectrum.energy_scale + energy_scale = spectrum.get_spectral_dims(return_axis=True)[0] for element in elements: atomic_number = elements_list.index(element) out_tags[element] ={'Z': atomic_number} @@ -314,7 +314,7 @@ def get_peak(E, energy_scale): def initial_model_parameter(spectrum): tags = spectrum.metadata['EDS']['lines'] - energy_scale = spectrum.energy_scale + energy_scale = spectrum.get_spectral_dims(return_axis=True)[0] p = [] peaks = [] keys = [] @@ -385,7 +385,7 @@ def get_model(spectrum, start=100): def fit_model(spectrum, elements, use_detector_efficiency=False): out_tags = get_x_ray_lines(spectrum, elements) peaks, pin, keys = initial_model_parameter(spectrum) - energy_scale = energy_scale = spectrum.energy_scale + energy_scale = energy_scale = spectrum.get_spectral_dims(return_axis=True)[0] if 'detector' in spectrum.metadata['experiment'].keys(): if 'start_channel' not in spectrum.metadata['experiment']['detector']: diff --git a/pyTEMlib/file_tools.py b/pyTEMlib/file_tools.py index d48fb2c0..a474b328 100644 --- a/pyTEMlib/file_tools.py +++ b/pyTEMlib/file_tools.py @@ -46,7 +46,7 @@ # Austin commented the line below - it is not used anywhere in the code, and it gives import errors 9-14-2024 # get_slope = sidpy.base.num_utils.get_slopes -__version__ = '2022.3.3' +__version__ = '2024.9.14' from traitlets import Unicode, Bool, validate, TraitError import ipywidgets From 91dc1c9a0a6e34446b8ad89e7ee446da8cd2791b Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Wed, 30 Oct 2024 14:38:13 -0400 Subject: [PATCH 08/14] fix mistake --- pyTEMlib/eds_tools.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyTEMlib/eds_tools.py b/pyTEMlib/eds_tools.py index afffaec0..1b58149c 100644 --- a/pyTEMlib/eds_tools.py +++ b/pyTEMlib/eds_tools.py @@ -385,7 +385,7 @@ def get_model(spectrum, start=100): def fit_model(spectrum, elements, use_detector_efficiency=False): out_tags = get_x_ray_lines(spectrum, elements) peaks, pin, keys = initial_model_parameter(spectrum) - energy_scale = energy_scale = spectrum.get_spectral_dims(return_axis=True)[0] + energy_scale = spectrum.get_spectral_dims(return_axis=True)[0] if 'detector' in spectrum.metadata['experiment'].keys(): if 'start_channel' not in spectrum.metadata['experiment']['detector']: From 72d8398bc7771f421a160996d3060511210dec22 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Wed, 30 Oct 2024 14:52:25 -0400 Subject: [PATCH 09/14] unity --- pyTEMlib/eds_tools.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyTEMlib/eds_tools.py b/pyTEMlib/eds_tools.py index 1b58149c..ca53056d 100644 --- a/pyTEMlib/eds_tools.py +++ b/pyTEMlib/eds_tools.py @@ -385,7 +385,7 @@ def get_model(spectrum, start=100): def fit_model(spectrum, elements, use_detector_efficiency=False): out_tags = get_x_ray_lines(spectrum, elements) peaks, pin, keys = initial_model_parameter(spectrum) - energy_scale = spectrum.get_spectral_dims(return_axis=True)[0] + energy_scale = spectrum.get_spectral_dims(return_axis=True)[0].values if 'detector' in spectrum.metadata['experiment'].keys(): if 'start_channel' not in spectrum.metadata['experiment']['detector']: From c3f0fe2865fa45ab406779ab5cffdf83fe48fb52 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Mon, 9 Dec 2024 17:38:25 -0500 Subject: [PATCH 10/14] update probe_tools --- pyTEMlib/probe_tools.py | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/pyTEMlib/probe_tools.py b/pyTEMlib/probe_tools.py index c7f3ed34..9cb40426 100644 --- a/pyTEMlib/probe_tools.py +++ b/pyTEMlib/probe_tools.py @@ -167,8 +167,6 @@ def get_ronchigram(size, ab, scale='mrad'): return ronchigram - - def make_probe (chi, aperture): chi2 = np.fft.ifftshift(chi) chiT = np.fft.ifftshift (np.vectorize(complex)(np.cos(chi2), -np.sin(chi2)) ) @@ -181,6 +179,7 @@ def make_probe (chi, aperture): return probe + def get_probe( ab, sizeX, sizeY, scale = 'mrad', verbose= True): chi, A_k = get_chi( ab, sizeX, sizeY, verbose= False) @@ -189,6 +188,17 @@ def get_probe( ab, sizeX, sizeY, scale = 'mrad', verbose= True): return probe, A_k, chi +def get_probe_large(ab): + ab['FOV'] = 20 + sizeX = 512*2 + probe, A_k, chi = pyTEMlib.probe_tools.get_probe( ab, sizeX, sizeX, scale = 'mrad', verbose= True) + + res = np.zeros((512, 512)) + res[256-32:256+32, 256-32:256+32 ] = skimage.transform.resize(probe, (64, 64)) + + return res + + def get_chi_2(ab, u, v): chi1 = ab['C10'] * (u ** 2 + v ** 2) / 2 \ + ab['C12a'] * (u ** 2 - v ** 2) / 2 \ From d67c9ceb80511d0d251bbc866309b19231975480 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Mon, 9 Dec 2024 18:10:26 -0500 Subject: [PATCH 11/14] cleanup imports --- pyTEMlib/probe_tools.py | 1 + 1 file changed, 1 insertion(+) diff --git a/pyTEMlib/probe_tools.py b/pyTEMlib/probe_tools.py index 9cb40426..a6dbcf2b 100644 --- a/pyTEMlib/probe_tools.py +++ b/pyTEMlib/probe_tools.py @@ -2,6 +2,7 @@ import numpy as np import pyTEMlib.image_tools import scipy.ndimage as ndimage +import skimage get_wavelength = pyTEMlib.image_tools.get_wavelength From 37655a4fcc8f2c99624b9c11e848eeab1f580801 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Mon, 9 Dec 2024 18:24:03 -0500 Subject: [PATCH 12/14] fixed atom_tools --- pyTEMlib/atom_tools.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyTEMlib/atom_tools.py b/pyTEMlib/atom_tools.py index 43121f79..d8febc5a 100644 --- a/pyTEMlib/atom_tools.py +++ b/pyTEMlib/atom_tools.py @@ -53,7 +53,7 @@ def find_atoms(image, atom_size=0.1, threshold=0.): if not isinstance(threshold, float): raise TypeError('threshold parameter has to be a float number') - scale_x = ft.get_slope(image.dim_0) + scale_x = np.unique(np.gradient(image.dim_0.values))[0] im = np.array(image-image.min()) im = im/im.max() if threshold <= 0.: From 720929f7398702b9726f96ef9d8f27a485feafd5 Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Tue, 10 Dec 2024 16:34:08 -0500 Subject: [PATCH 13/14] simulate haadf atomic res --- pyTEMlib/image_tools.py | 59 +++++++++++++++++++++++++++++++++++++++++ pyTEMlib/probe_tools.py | 17 +++++++++--- 2 files changed, 73 insertions(+), 3 deletions(-) diff --git a/pyTEMlib/image_tools.py b/pyTEMlib/image_tools.py index 4e2e5bbc..028d6b04 100644 --- a/pyTEMlib/image_tools.py +++ b/pyTEMlib/image_tools.py @@ -55,6 +55,9 @@ from scipy.optimize import leastsq from sklearn.cluster import DBSCAN +from ase.build import fcc110 +import probe_tools # Assuming you have this module available + _SimpleITK_present = True try: @@ -68,6 +71,62 @@ 'install with: conda install -c simpleitk simpleitk ') + +def simulate_atomic_scattering_potential(fov=100, angle=0, atoms=None): + """ + Simulates the atomic scattering potential on a 2D grid. + + Parameters: + - fov (float): Field of view in angstroms. + - angle (float): Rotation angle in degrees. + - atoms (ase.Atoms): Optional input for a custom atomic structure. Defaults to Al FCC(110). + + Returns: + - np.ndarray: 2D grid of the simulated scattering potential. + """ + # Default to Al FCC(110) structure if no atoms are provided + if atoms is None: + atoms = fcc110('Al', size=(2, 2, 1), orthogonal=True) + + # Ensure the structure is periodic and centered + atoms.pbc = True + atoms.center() + + # Determine the grid size based on the field of view + grid_scaling_factor = int(1 / (fov / 1024)) + grid_x = int(atoms.cell[0, 0] * grid_scaling_factor) + grid_y = int(atoms.cell[1, 1] * grid_scaling_factor) + + # Create an empty grid and calculate pixel size + potential_map = np.zeros((grid_x, grid_y)) + pixel_size_x = atoms.cell[0, 0] / grid_x + pixel_size_y = atoms.cell[1, 1] / grid_y + + # Generate the scattering potential by summing Gaussian peaks + for position in atoms.positions: + x_pixel = position[0] / pixel_size_x + y_pixel = position[1] / pixel_size_y + gauss_peak = probe_tools.make_gauss(grid_x, grid_y, x0=x_pixel, y0=y_pixel) + potential_map += gauss_peak + + # Expand the grid to ensure proper rotation without clipping + expansion_factor = np.floor(1450 / np.array(potential_map.shape)).astype(int) + potential_map = np.tile(potential_map, (expansion_factor[0], expansion_factor[1])) + + # Rotate the map by the specified angle + potential_map = scipy.ndimage.rotate(potential_map, angle, axes=(1, 0), reshape=True) + + # Extract a centered square region of size 1024x1024 + center = potential_map.shape[0] // 2 + cropped_map = potential_map[center - 512:center + 512, center - 512:center + 512] + + # Debugging output for pixel size + print(f"Pixel size (angstrom): x={pixel_size_x}, y={pixel_size_y}") + + return cropped_map + + + # Wavelength in 1/nm def get_wavelength(e0): """ diff --git a/pyTEMlib/probe_tools.py b/pyTEMlib/probe_tools.py index a6dbcf2b..caaacfde 100644 --- a/pyTEMlib/probe_tools.py +++ b/pyTEMlib/probe_tools.py @@ -7,15 +7,26 @@ get_wavelength = pyTEMlib.image_tools.get_wavelength -def make_gauss(size_x, size_y, width=1.0, x0=0.0, y0=0.0, intensity=1.0): + +def make_gauss(size_x, size_y, width=1.0, x0=0.0, y0=0.0): + """Make a Gaussian shaped probe """ + + x, y = np.mgrid[0:size_x, 0:size_y] + g = np.exp(-((x - x0) ** 2 + (y - y0) ** 2) / 2.0 / width ** 2) + + return g / g.sum() + +# below is an old version of the make_gauss +# changing to the new one could cause problems in other modules? +# need to check if their are any imports - AH, 2024-12-09 +'''def make_gauss(size_x, size_y, width=1.0, x0=0.0, y0=0.0, intensity=1.0): """Make a Gaussian shaped probe """ size_x = size_x / 2 size_y = size_y / 2 x, y = np.mgrid[-size_x:size_x, -size_y:size_y] g = np.exp(-((x - x0) ** 2 + (y - y0) ** 2) / 2.0 / width ** 2) probe = g / g.sum() * intensity - - return probe + return probe''' def make_lorentz(size_x, size_y, gamma=1.0, x0=0., y0=0., intensity=1.): From ce48099eb3501a9a430adc0c410beec3af4af7ce Mon Sep 17 00:00:00 2001 From: ahoust17 <88668350+ahoust17@users.noreply.github.com> Date: Sat, 14 Dec 2024 14:39:58 -0500 Subject: [PATCH 14/14] necessary functions in image_tools --- pyTEMlib/image_tools.py | 110 ++++++++++++++++++++++------------------ 1 file changed, 62 insertions(+), 48 deletions(-) diff --git a/pyTEMlib/image_tools.py b/pyTEMlib/image_tools.py index 028d6b04..76325e85 100644 --- a/pyTEMlib/image_tools.py +++ b/pyTEMlib/image_tools.py @@ -56,7 +56,11 @@ from sklearn.cluster import DBSCAN from ase.build import fcc110 -import probe_tools # Assuming you have this module available +from pyTEMlib import probe_tools + +from scipy.ndimage import rotate +from scipy.interpolate import RegularGridInterpolator +from scipy.signal import fftconvolve _SimpleITK_present = True @@ -71,60 +75,70 @@ 'install with: conda install -c simpleitk simpleitk ') +def get_atomic_pseudo_potential(fov, atoms, size=512, rotation=0): + # Big assumption: the atoms are not near the edge of the unit cell + # If any atoms are close to the edge (ex. [0,0]) then the potential will be clipped + # before calling the function, shift the atoms to the center of the unit cell + + pixel_size = fov / size + max_size = int(size * np.sqrt(2) + 1) # Maximum size to accommodate rotation + + # Create unit cell potential + positions = atoms.get_positions()[:, :2] + atomic_numbers = atoms.get_atomic_numbers() + unit_cell_size = atoms.cell.cellpar()[:2] + + unit_cell_potential = np.zeros((max_size, max_size)) + for pos, atomic_number in zip(positions, atomic_numbers): + x = pos[0] / pixel_size + y = pos[1] / pixel_size + atom_width = 0.5 # Angstrom + gauss_width = atom_width/pixel_size # important for images at various fov. Room for improvement with theory + gauss = probe_tools.make_gauss(max_size, max_size, width = gauss_width, x0=x, y0=y) + unit_cell_potential += gauss * atomic_number # gauss is already normalized to 1 + + # Create interpolation function for unit cell potential + x_grid = np.linspace(0, fov * max_size / size, max_size) + y_grid = np.linspace(0, fov * max_size / size, max_size) + interpolator = RegularGridInterpolator((x_grid, y_grid), unit_cell_potential, bounds_error=False, fill_value=0) + + # Vectorized computation of the full potential map with max_size + x_coords, y_coords = np.meshgrid(np.linspace(0, fov, max_size), np.linspace(0, fov, max_size), indexing="ij") + xtal_x = x_coords % unit_cell_size[0] + xtal_y = y_coords % unit_cell_size[1] + potential_map = interpolator((xtal_x.ravel(), xtal_y.ravel())).reshape(max_size, max_size) + + # Rotate and crop the potential map + potential_map = rotate(potential_map, rotation, reshape=False) + center = potential_map.shape[0] // 2 + potential_map = potential_map[center - size // 2:center + size // 2, center - size // 2:center + size // 2] -def simulate_atomic_scattering_potential(fov=100, angle=0, atoms=None): - """ - Simulates the atomic scattering potential on a 2D grid. + potential_map = scipy.ndimage.gaussian_filter(potential_map,3) - Parameters: - - fov (float): Field of view in angstroms. - - angle (float): Rotation angle in degrees. - - atoms (ase.Atoms): Optional input for a custom atomic structure. Defaults to Al FCC(110). + return potential_map - Returns: - - np.ndarray: 2D grid of the simulated scattering potential. - """ - # Default to Al FCC(110) structure if no atoms are provided - if atoms is None: - atoms = fcc110('Al', size=(2, 2, 1), orthogonal=True) - - # Ensure the structure is periodic and centered - atoms.pbc = True - atoms.center() +def convolve_probe(ab, potential): + # the pixel sizes should be the exact same as the potential + final_sizes = potential.shape + + # Perform FFT-based convolution + pad_height = pad_width = potential.shape[0] // 2 + potential = np.pad(potential, ((pad_height, pad_height), (pad_width, pad_width)), mode='constant') + + probe, A_k, chi = probe_tools.get_probe(ab, potential.shape[0], potential.shape[1], scale = 'mrad', verbose= False) - # Determine the grid size based on the field of view - grid_scaling_factor = int(1 / (fov / 1024)) - grid_x = int(atoms.cell[0, 0] * grid_scaling_factor) - grid_y = int(atoms.cell[1, 1] * grid_scaling_factor) - - # Create an empty grid and calculate pixel size - potential_map = np.zeros((grid_x, grid_y)) - pixel_size_x = atoms.cell[0, 0] / grid_x - pixel_size_y = atoms.cell[1, 1] / grid_y - - # Generate the scattering potential by summing Gaussian peaks - for position in atoms.positions: - x_pixel = position[0] / pixel_size_x - y_pixel = position[1] / pixel_size_y - gauss_peak = probe_tools.make_gauss(grid_x, grid_y, x0=x_pixel, y0=y_pixel) - potential_map += gauss_peak - - # Expand the grid to ensure proper rotation without clipping - expansion_factor = np.floor(1450 / np.array(potential_map.shape)).astype(int) - potential_map = np.tile(potential_map, (expansion_factor[0], expansion_factor[1])) - - # Rotate the map by the specified angle - potential_map = scipy.ndimage.rotate(potential_map, angle, axes=(1, 0), reshape=True) - - # Extract a centered square region of size 1024x1024 - center = potential_map.shape[0] // 2 - cropped_map = potential_map[center - 512:center + 512, center - 512:center + 512] - # Debugging output for pixel size - print(f"Pixel size (angstrom): x={pixel_size_x}, y={pixel_size_y}") + convolved = fftconvolve(potential, probe, mode='same') + + # Crop to original potential size + start_row = pad_height + start_col = pad_width + end_row = start_row + final_sizes[0] + end_col = start_col + final_sizes[1] - return cropped_map + image = convolved[start_row:end_row, start_col:end_col] + return probe, image # Wavelength in 1/nm