diff --git a/Nasa_Harvest_Model_MLHub.ipynb b/Nasa_Harvest_Model_MLHub.ipynb new file mode 100644 index 0000000..cfd9277 --- /dev/null +++ b/Nasa_Harvest_Model_MLHub.ipynb @@ -0,0 +1,1693 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "27f7fd9c", + "metadata": {}, + "source": [ + "Radiant MLHub Logo\n", + "\n", + "# 2021 NASA Harvest Rwanda Baseline Model\n", + "\n", + "This notebook walks you through the steps to create a baseline field delineation model for detecting boundaries from sentinel-2 time-series satellite imagery using a spatio-temporal U-Net model on the 2021 NASA Harvest dataset." + ] + }, + { + "cell_type": "markdown", + "id": "6337cc89", + "metadata": {}, + "source": [ + "### Dependencies\n", + "\n", + "All the dependencies for this notebook are included in the `requirements.txt` file included in this folder." + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "3752bc39", + "metadata": {}, + "outputs": [], + "source": [ + "# Importing the needed libraries\n", + "import getpass\n", + "import glob\n", + "import keras\n", + "import os\n", + "import pickle\n", + "import random\n", + "from radiant_mlhub import Dataset\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import rasterio as rio\n", + "#import skimage.io as io\n", + "#import skimage.transform as trans\n", + "import tensorflow as tf\n", + "import segmentation_models as sm\n", + "from segmentation_models import Unet\n", + "\n", + "from pathlib import Path\n", + "from random import choice\n", + "from scipy.ndimage import gaussian_filter\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "\n", + "from keras import backend as K\n", + "#from keras.callbacks import ModelCheckpoint, LearningRateScheduler\n", + "from keras.layers import *\n", + "from keras.models import *\n", + "from keras.models import load_model\n", + "from keras.optimizers import *\n", + "from keras.preprocessing import image\n", + "\n", + "from tensorflow.keras.layers import *\n", + "from tensorflow.keras.losses import *\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "from typing import List, Any, Callable, Tuple" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "87d838a5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tf.config.list_physical_devices(\"GPU\") #activate GPU resource for model training" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "9bc382f7", + "metadata": {}, + "outputs": [], + "source": [ + "dataset_id = 'nasa_rwanda_field_boundary_competition'\n", + "assets = ['labels']" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "6aa90238", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MLHub API Key: ········\n" + ] + } + ], + "source": [ + "#Append your MLHUB_API_KEY after this cell is executed to download dataset\n", + "os.environ['MLHUB_API_KEY'] = getpass.getpass(prompt=\"MLHub API Key: \")\n", + "dataset = Dataset.fetch(dataset_id)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "aa7a8a79", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "nasa_rwanda_field_boundary_competition: fetch stac catalog: 144KB [00:00, 324.30KB/s] \n", + "download assets: 100%|████████████████████████████████████████████████████████████████████| 1738/1738 [02:53<00:00, 10.00it/s]\n" + ] + } + ], + "source": [ + "dataset.download(if_exists='overwrite')" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "a6e40e30", + "metadata": {}, + "outputs": [], + "source": [ + "#image snapshot dimensions\n", + "IMG_WIDTH = 256 \n", + "IMG_HEIGHT = 256 \n", + "IMG_CHANNELS = 4 #we have the rgba bands" + ] + }, + { + "cell_type": "markdown", + "id": "764ddebe", + "metadata": {}, + "source": [ + "We have two sets of data: the train and test dataset, each having a list of file ids belonging to them.\n", + "For model development purposes, we will use the training set(`train_tiles`) and use the test set for model prediction/evaluation." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6ee46009", + "metadata": {}, + "outputs": [], + "source": [ + "train_source_items = f\"{dataset_id}/{dataset_id}_source_train\"\n", + "train_label_items = f\"{dataset_id}/{dataset_id}_labels_train\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d3962103", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'nasa_rwanda_field_boundary_competition_source_train_26_2021_12'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "next(os.walk(train_source_items))[1][0]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "62b6f279", + "metadata": {}, + "outputs": [], + "source": [ + "def clean_string(s: str) -> str:\n", + " \"\"\"\n", + " extract the tile id and timestamp from a source image folder\n", + " e.g extract 'ID_YYYY_MM' from 'nasa_rwanda_field_boundary_competition_source_train_ID_YYYY_MM'\n", + " \"\"\"\n", + " s = s.replace(f\"{dataset_id}_source_\", '').split('_')[1:]\n", + " return '_'.join(s)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5dcde75e", + "metadata": {}, + "outputs": [], + "source": [ + "train_tiles = [clean_string(s) for s in next(os.walk(train_source_items))[1]]" + ] + }, + { + "cell_type": "markdown", + "id": "f0f58736", + "metadata": {}, + "source": [ + "57 train tiles for 6 time stamps, gives us 342 train tiles in total" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "9cbdcad7", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "342" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(train_tiles)" + ] + }, + { + "cell_type": "markdown", + "id": "3bcbd418", + "metadata": {}, + "source": [ + "Our source images have pixel values > 255, hence we need to apply normalisation on our images to generate a normalised image. We apply the min-max normalisation for this which is simply: $${\\text{all pixel values - minimum pixel value} \\over \\text{maximum pixel value - minimum pixel value}}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b2e534f4", + "metadata": {}, + "outputs": [], + "source": [ + "def normalize(\n", + " array: np.ndarray\n", + "):\n", + " \"\"\" normalise image to give a meaningful output \"\"\"\n", + " array_min, array_max = array.min(), array.max()\n", + " return (array - array_min) / (array_max - array_min)" + ] + }, + { + "cell_type": "markdown", + "id": "40e56a84", + "metadata": {}, + "source": [ + "### Data Augmentation" + ] + }, + { + "cell_type": "markdown", + "id": "4e2060bd", + "metadata": {}, + "source": [ + "In this notebook, we will perform data augmentation on our normalised images. This will be used to populate the model with data to obtain even more accurate results.\n", + "\n", + "We will employ the following data augmentation techniques on the dataset:\n", + "- rotation, flipping, blurring.\n", + "\n", + "These techniques were thanks to the radix-ai GitHub repository, which can be accessed [here](https://github.com/radix-ai/agoro-field-boundary-detector).\n", + "We will observe the results on a random source image and its associated label below:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "d1aa9927", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "30_2021_08\n" + ] + } + ], + "source": [ + "#loading the 4 bands of the image\n", + "tile = random.choice(train_tiles)\n", + "print(tile)\n", + "bd1 = rio.open(f\"{train_source_items}/{dataset_id}_source_train_{tile}/B01.tif\")\n", + "bd1_array = bd1.read(1)\n", + "bd2 = rio.open(f\"{train_source_items}/{dataset_id}_source_train_{tile}/B02.tif\")\n", + "bd2_array = bd2.read(1)\n", + "bd3 = rio.open(f\"{train_source_items}/{dataset_id}_source_train_{tile}/B03.tif\")\n", + "bd3_array = bd3.read(1)\n", + "bd4 = rio.open(f\"{train_source_items}/{dataset_id}_source_train_{tile}/B04.tif\")\n", + "bd4_array = bd4.read(1)\n", + "b01_norm = normalize(bd1_array)\n", + "b02_norm = normalize(bd2_array)\n", + "b03_norm = normalize(bd3_array)\n", + "b04_norm = normalize(bd4_array)\n", + "\n", + "field = np.dstack((b04_norm, b03_norm, b02_norm, b01_norm))\n", + "mask = rio.open(Path.cwd() / f\"{train_label_items}/{dataset_id}_labels_train_{tile.split('_')[0]}/raster_labels.tif\").read(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "206812fa", + "metadata": {}, + "outputs": [], + "source": [ + "#https://github.com/radix-ai/agoro-field-boundary-detector/tree/master/src/agoro_field_boundary_detector\n", + "def t_linear(\n", + " field: np.ndarray,\n", + " mask: np.ndarray,\n", + " _: int = 0,\n", + ") -> Tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Apply a linear (i.e. no) transformation and save.\"\"\"\n", + " return field, mask\n", + "\n", + "def t_rotation(\n", + " field: np.ndarray,\n", + " mask: np.ndarray,\n", + " rot: int,\n", + ") -> Tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Rotate the data.\"\"\"\n", + " assert rot in range(0, 3 + 1)\n", + " for _ in range(rot):\n", + " field = np.rot90(field)\n", + " mask = np.rot90(mask)\n", + " return field, mask\n", + "\n", + "def t_flip(\n", + " field: np.ndarray,\n", + " mask: np.ndarray,\n", + " idx: int,\n", + ") -> Tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Flip the data.\"\"\"\n", + " assert idx in range(0, 2 + 1)\n", + " if idx == 0: # Diagonal\n", + " field = np.rot90(np.fliplr(field))\n", + " mask = np.rot90(np.fliplr(mask))\n", + " if idx == 1: # Horizontal\n", + " field = np.flip(field, axis=0)\n", + " mask = np.flip(mask, axis=0)\n", + " if idx == 2: # Vertical\n", + " field = np.flip(field, axis=1)\n", + " mask = np.flip(mask, axis=1)\n", + " return field, mask\n", + "\n", + "def t_blur(\n", + " field: np.ndarray,\n", + " mask: np.ndarray,\n", + " sigma: int,\n", + ") -> Tuple[np.ndarray, np.ndarray]:\n", + " \"\"\"Blur the image by applying a Gaussian filter.\"\"\"\n", + " assert 0 <= sigma <= 10\n", + " sigma_f = 1.0 + (sigma / 10)\n", + " field = np.copy(field)\n", + " for i in range(3):\n", + " field[:, :, i] = gaussian_filter(field[:, :, i], sigma=sigma_f)\n", + " return field, mask" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "e399abb8", + "metadata": {}, + "outputs": [], + "source": [ + "def show_image(field:np.ndarray, mask:np.ndarray): \n", + " \"\"\"Show the field and corresponding mask.\"\"\"\n", + " fig = plt.figure(figsize=(8,6))\n", + " ax1 = fig.add_subplot(121) # left side\n", + " ax2 = fig.add_subplot(122) # right side\n", + " ax1.imshow(field[:,:,0:3]) # rgb band\n", + " plt.gray()\n", + " ax2.imshow(mask)\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "658d7fa3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_image(field, mask)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "98f36ccc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f,m = t_rotation(field, mask, rot=1) #rotation\n", + "show_image(f,m)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "9bdefc22", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f,m = t_flip(field, mask, idx=0) #flipping\n", + "show_image(f,m)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "e3f46a71", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f,m = t_blur(field, mask, sigma=5) #blur\n", + "show_image(f,m)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "2dbd77cf", + "metadata": {}, + "outputs": [], + "source": [ + "def generate(\n", + " field: np.ndarray,\n", + " mask: np.ndarray,\n", + " write_folder: Path,\n", + " prefix: str = \"\",\n", + ") -> None:\n", + " \"\"\"\n", + " Generate data augmentations of the provided field and corresponding mask which includes:\n", + " - Linear (no) transformation\n", + " - Rotation\n", + " - Horizontal or vertical flip\n", + " - Gaussian filter (blur)\n", + " :param field: Input array of the field to augment\n", + " :param mask: Input array of the corresponding mask to augment\n", + " :param write_folder: Folder (path) to write the results (augmentations) to\n", + " :param prefix: Field-specific prefix used when writing the augmentation results\n", + " \"\"\"\n", + " # Generate transformations\n", + " f, m = [0,1,2,3], [0,1,2,3] #dummy data. will be replaced\n", + " f[0],m[0] = t_linear(field, mask) #no augmentation\n", + " f[1],m[1] = t_rotation(field, mask, rot=1) #rotation\n", + " f[2],m[2] = t_flip(field, mask, idx=0) #flipping\n", + " f[3],m[3] = t_blur(field, mask, sigma=5) #blur\n", + " for i in range(len(f)): \n", + " with open(write_folder +'/'+ f\"fields/{str(prefix).zfill(2)}_{i}.pkl\", 'wb') as handle:\n", + " pickle.dump(f[i], handle, protocol=pickle.HIGHEST_PROTOCOL)\n", + "\n", + " with open(write_folder +'/'+ f\"masks/{str(prefix).zfill(2)}_{i}.pkl\", 'wb') as handle:\n", + " pickle.dump(m[i], handle, protocol=pickle.HIGHEST_PROTOCOL)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "19c76a1b", + "metadata": {}, + "outputs": [], + "source": [ + "def main(\n", + " field: List[np.ndarray],\n", + " mask: List[np.ndarray],\n", + " prefix: List[str],\n", + " write_folder: Path,\n", + ") -> None:\n", + " \"\"\"\n", + " Generate and save data augmentations for all the fields and corresponding masks with the following:\n", + " - Linear (no) transformation\n", + " - Rotation\n", + " - Horizontal or vertical flip\n", + " - Gaussian filter (blur)\n", + " - Gamma filter (brightness)\n", + " :param fields: Fields to augment\n", + " :param masks: Corresponding masks to augment\n", + " :param prefixes: Field-specific prefixes corresponding each field\n", + " :param write_folder: Path to write the results (augmentations) to\n", + " \"\"\"\n", + " generate(\n", + " field=field,\n", + " mask=mask,\n", + " prefix=prefix,\n", + " write_folder=write_folder,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "e379cf5b", + "metadata": {}, + "outputs": [], + "source": [ + "#apply augmentation effects to training set\n", + "for tile in train_tiles:\n", + " bd1 = rio.open(f\"{train_source_items}/{dataset_id}_source_train_{tile}/B01.tif\")\n", + " bd1_array = bd1.read(1)\n", + " bd2 = rio.open(f\"{train_source_items}/{dataset_id}_source_train_{tile}/B02.tif\")\n", + " bd2_array = bd2.read(1)\n", + " bd3 = rio.open(f\"{train_source_items}/{dataset_id}_source_train_{tile}/B03.tif\")\n", + " bd3_array = bd3.read(1)\n", + " bd4 = rio.open(f\"{train_source_items}/{dataset_id}_source_train_{tile}/B04.tif\")\n", + " bd4_array = bd4.read(1)\n", + " b01_norm = normalize(bd1_array)\n", + " b02_norm = normalize(bd2_array)\n", + " b03_norm = normalize(bd3_array)\n", + " b04_norm = normalize(bd4_array)\n", + "\n", + " ids_list = tile.split('_') # XX_YYYY_MM where XX is the training file id and YYYY_MM is the timestamp\n", + " tile_id = ids_list[0]\n", + " timestamp = f\"{ids_list[1]}_{ids_list[2]}\"\n", + "\n", + " field = np.dstack((b04_norm, b03_norm, b02_norm, b01_norm))\n", + " mask = rio.open(Path.cwd() / f\"{train_label_items}/{dataset_id}_labels_train_{tile_id}/raster_labels.tif\").read(1) \n", + "\n", + " #create a folder for the augmented images\n", + " if not os.path.isdir(f\"./augmented_data/{timestamp}\"):\n", + " os.makedirs(f\"./augmented_data/{timestamp}\")\n", + " if not os.path.isdir(f\"./augmented_data/{timestamp}/fields\"):\n", + " os.makedirs(f\"./augmented_data/{timestamp}/fields\")\n", + " if not os.path.isdir(f\"./augmented_data/{timestamp}/masks\"):\n", + " os.makedirs(f\"./augmented_data/{timestamp}/masks\")\n", + "\n", + " main( #applying augmentation effects\n", + " field = field,\n", + " mask = mask,\n", + " prefix = tile_id,\n", + " write_folder = f\"./augmented_data/{timestamp}\"\n", + " ) #approximately 30 seconds" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "0db7813f", + "metadata": {}, + "outputs": [], + "source": [ + "timestamps = next(os.walk(f\"./augmented_data\"))[1] #Get all timestamps\n", + "augmented_files = next(os.walk(f\"./augmented_data/{timestamps[0]}/fields\"))[2] #Get all augmented tile ids. can just use one timestamp\n", + "X = np.empty((len(augmented_files), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS*len(timestamps)), dtype=np.float32) #time-series image\n", + "y = np.empty((len(augmented_files), IMG_HEIGHT, IMG_WIDTH, 1), dtype=np.uint8) #mask for each scene\n", + "i = 0\n", + "for file in augmented_files:\n", + " idx = 0\n", + " augmented_id = file.split('.pkl')[0] #id without .pkl extension\n", + " temporal_fields = []\n", + " for timestamp in timestamps:\n", + " with open(f\"./augmented_data/{timestamp}/fields/{augmented_id}.pkl\", 'rb') as field:\n", + " field = pickle.load(field) \n", + " X[i][:,:,idx:idx+IMG_CHANNELS] = field\n", + " idx += IMG_CHANNELS\n", + " with open(f\"./augmented_data/{timestamp}/masks/{augmented_id}.pkl\", 'rb') as mask:\n", + " mask = pickle.load(mask)\n", + " y[i] = mask.reshape(IMG_HEIGHT, IMG_WIDTH, 1)\n", + " i+=1" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "c88dd7f2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxQAAAF+CAYAAAAbc1yEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/NK7nSAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9ebxlV1Ev/q1a+9zbGRklkJBfwgMT0ABCngwiAjKDhDB8RATCJKLwFIw8H4gCogIyicJDBQWioKCCgAhC8h4gU1BQ5ikBYhJISCBAhu6+9+xV9fujhrX26c6ThO7c3LCrP7vPveees/faa699zvdb9a0qUlXFbLPNNttss80222yzzTbblTDe6gHMNttss80222yzzTbbbNvXZkIx22yzzTbbbLPNNttss11pmwnFbLPNNttss80222yzzXalbSYUs80222yzzTbbbLPNNtuVtplQzDbbbLPNNttss80222xX2mZCMdtss80222yzzTbbbLNdaZsJxWyzzTbbbLPNNttss812pW0mFLPNNttss80222yzzTbblbaZUMw222yzzTbbbLPNNttsV9pmQjHbbLPNNttss80222yzXWnbUkLxyle+Eje5yU2wY8cOHH/88fjABz6wlcOZbbbZZpvtamLz98Nss8022/axLSMUb3rTm/DUpz4Vz3zmM/Ef//EfuPOd74z73ve+OPvss7dqSLPNNttss10NbP5+mG222WbbXkaqqltx4Nvf/va47W1viz/5kz/J525xi1vgxBNPxPOf//z/53tFBF//+tdxyCGHgIj291Bnm2222ba9qSouueQSHH744WC+eqtdv5/vB2D+jphtttlmu6L2/X5HDPthTP+lbW5u4uMf/zie/vSnT56/173uhQ9/+MN7vH5jYwMbGxv5+9e+9jX8yI/8yH4f52yzzTbbNc3OOecc3PjGN97qYVyuXdHvB2D+jphtttlm21d2Zb8jtoRQfPOb30StFYcddtjk+cMOOwznn3/+Hq9//vOfj9/5nd/Z4/lf/5F7YEdZgEFgBSAKqAIiUFEQFOT/mDj1XQQACigUogpVexxFUOsSWkeojNBxBMsSUAFBQCogVURIR6BQAoT8527/BNOT2c/xFxsfq6CoYqHAmigOFOBAIawrsAagKKAELAnYJGA3AZcVwkYhbDBhkwgj2yZEqEwYC6Eu7HEshHEgVGbbkRK4MspIYCGQ5FBsZOHBI/uP1H6nnFMAqiAFSAUM30hBJABrnjRBUQQoVTEIMFTFogIF6vNBAAFaGFIIUgjjglALQxgQHwtXxaIqSlUsRsViKaAqgCpEgRGKkYBqp4dKBOUC4gHEA5gLBl4H8wCiAqICJgKDwTYKMCgvCwFgVRQRDFUwiP8sAgLZdWaGMGNkQiVCJWBJiiUrNkmwWQQbg2JzIGgZwDRgjdZwoByIg+Qg7JB1rMs6WBaoCmygYgNL7MQGLsPF2MROqO4Cy24cOO7CtZcV115WXGupuO6oOKDaVIsCuxX4DikuJsWlpLgUgstIIVxAZcBQFlhfPwiL9XXQsAZaLCBrBXVRUNd8rSwY4zpDiq9hBWRZgaUAo4KW4j+L/zEWTQtqCgBhuw4Sy82Wi617BUgUrHY/sJLNP5FfBV86CqDa/QWpUKl2X8K2qsCoilErlrViWTcxjkuoVJAqCgg7yhrWhgFDGVDKAOICMMGWu/8TtWMgNl8CZJ8WIIIS2z3ha9E83L7+Y6zxbr//83OAFJXt0eZB/V4T/1nt80QEduvYfBQQCnHOiR1AAJUcuzBBmaDM9gjyz7v4zKuoOkJEIFKhKiBilDKAiVEB/M1X/g2HHHLIHp+lVye7ot8PwOV/R8w222yzzXbF7Mp+R2wJoQhbDUWr6l7D0894xjNw8skn5+8XX3wxjjzySKwPA3aUBUjti5nIvqyVFCABFGAKQkEOJfNgeUzxrVKFEEOoQKtBYKoE0gqIkQqjDgCcQAipAQp/RqkRitz8uZ5QDKoYRLEGxQ4FDmBgTW0rBFR/HxyoLdmIg7CBcGFCYQKYASboQNAFgwdCKQQtbKBNbGMwilKSnCQUBAdSdkCCoaN4DUg7MqEGgNTmk0hBTFBGsidSIxQD2fkNBKxBUbQRLMQ5DIQ6ELBgYCCAbVMAXI1UlFFQSDFoRQEnqK2qBmLhGxGECkB23kxs15wYTAwiBlOxNUCUpIK08SlWRYFdmwLBAMGCNGGvsJG0kdkJBWFBik0WDCwYWFFYMDBBiEFUMBBjwYyBgMKE4F+iRoILyMgl4ESPMAA4VBnXUsG1wLg2FNcGcIDPXwWwIKCSAU124sxQVBQAjIEK1qhgASM2oAFCAyozKhgVhEqMkfxckhQItBihwCBAcYJRO1IhDVE3ID3dkq2qgsgJhRqJ46D5FHTfX0/hEGBAGKpihB+KCmBQxVIYBYwCYKmweXZCsSgFa2XhhKKASnGC0MC9Uk8o4oOo3QNKnMQibkD7pzlO6t6rMDJSCVC2ayLcOxjUOZg5OYwkGJ1laBKKAbFOG6UwEjIlFFKcTAShEJtYFYG6s0Co2n0tNseFGMwF7CPaLhKg7/X7Abj874jZZpttttmumF3Z74gtIRTXv/71UUrZw9t0wQUX7OGVAoD19XWsr6/vZU8BDMi/vlskQB0A2F+nk0Pd/0CQDkO8pArikgTBAA4ShavuuS9WIxWBowKf5w/uwYQDEygMXMRRxAEygNExQvUIxUjAkghLRrcpNplQCyCsqBGdWCOMhVELQSI64RGHDrq1GQoi5KiagCREOZPsQBc63eK8mKDFXmeEwnBYAH1VA0IsLYITJKkyMDJhWQjLwcdNBtBKUchogFEhICEDFLDxkCJJigIQcYCtYoiWBNDqA4srRSs/J80D1EAgwUgiBTiOYyRppNwAAhE86gEjIcKQah51sABUUbGJTTAEipEqGCMqgCUqNnXEErshshskG+C6iUVdYn2s2DEKdlTFugBrAgzd9BfYzbsGYAlgDYQRxgPg4L2IglXBQQKqQuMFAACxJTKQsdhic4/CUBLzhMOB/khAVaBOvfSrsxn3Q94/fg+p2r1jc8z5gaWxlmJHUCcB1K02svsSBHZiJuoROIgvRyejlEG5tka7ldtuAYpD+ZonxK1NTiR0ukIQU7H6Uauw9aK+P1LjxkZiqCNXPh1iURsj6B65AZwYxqeE9h9nfj5BemId+s9Oxvpzl1ze6sSE0hVydbcr+v0A/L++I2abbbbZZrsqbEsIxdraGo4//niceuqpeNCDHpTPn3rqqXjgAx/4ve8ovHP5hE6JBfVkIr6qe0JhHi/zXAIAg8sAcdlDgshqAEeqf7F7dKPDPy6FMm8olBIAaHrwqfuCZ5AIahXUqhhVsIQBg+r7C0KxZGA3A7uZsJuBzQJsFGBjgBGKgYxQrDHGRYEUNmkEGFwJRakbKyFhHgVXmiJDAkHZiVMPktyzro7UErANgJQG4AxMKSKeUwEUJ1yBHXVCJoBlATYHYBwsCqBk3vuhKMYi5v0VxZqq+98t4lF6kEZ2LhVqXnapCIim1KI9QAOM2MMDGvuI5UIAe2TFJTERjWoLicFk41IlqJjAZhTYPNKISsAGKUYssYkNixYAGGESlVE3oHIZyriBoW5ix7jEgcuKg0bFgRU4sMJIhfNbgpGLNQDrIFSfZwUwKjmINY8+i4JEnHGJEQaVjFyRKGhBoIFAC4t0VQK0MMBi90FRYyojgUYAo12PkM7BiR433G3rKomERTfEoxNCdtEYfo8AvnC0A89AF/qzSyEWiVAiFGYUNrGQqthxiRJMk/GLhv5j7fkx20fClEgHkWhOgbh3AuBr3v/5DmpEmjXu8fgU0lA5QVyeZHPnUTuPrhQKeWbnHlGF5JGmn2O23pGfXRZtVP/ssi1OWJzF1G1CKPbZ98Nss80222xXmW2Z5Onkk0/Gox71KPz3//7fccc73hGvetWrcPbZZ+OXfumXvud9kKjprsPb6eAmAUFzOeZ7ggpQoIhAK3B4QIxCAU5cDoWGJewH0zYDIYMIwBmkwt/v0gRxOY+GNFvVSAoTiATsMopRKL2UlcgIBQEbTNhVgN2FsDkAG4WwuSDUBUMGhgyujV8UJ0IGFlEpcVp49aExzpBldEAJEY5onl7RBpZUzFMMMk8xMabRifDpEsxjymgKFscyGVHw44uD9JBzVc+rIBCkmHxEAcufqGRSMQ3pUORl2E5FbU1UCCoIShUq7Vza2GLA1J7rVojE72wkoeV+NMDaQ0oCgZVRAgiKyXxELNoBrhDahNIIOCUSKESqad1lA2XcjcW4ibU64oCx4oAqOKACO4SwLoQ1NRJhKS1GYAY1ydWakkW2QFiCICBoXHfX7QeI5Wo5IRKINNbJQEBl6BoBA4HY1iANDk5LgRaCFgEVBY0Krer3YMLw4AQwIN3yk/q8i0D3tlri1XGNfF6Z4gJYxEMJxAISBrPafLOtJpVuz921yXs6fP7UnolnG8mM8ax+VmiO026TvYFyP4pLqfzTKNelzYPdWjEVrBFhI18Redv4Z5d97lgMxsbPk6hJG1tGG7V99oDYnRsmGwMU0k/U1dz2xffDbLPNNttsV51tGaF42MMehm9961t47nOfi/POOw/HHXcc3vnOd+Koo476nvfBouBOg6Dd/9QjBX+muSg1v/Z7a7oxd0ujgIolipK7GdURJTkimsIPhxLu+VQycFwLOxgDwGQAqRIw2jvY0XZxrbkiIhQmddpkJxEF2CyE5UBYLgiShILt58Joqc9djkBsAYrQuFE8Q0GUiPMcLC9B8/0goKq5Y5UM9FHoNfz8OWRJqzj9ciwkYHFMdWKRnmslULUcEioEFXMDE3veDFpOeDiPLdIgEK1+BPLYRdIPn6OgN51u3f9Xal7/ULzt7Voj/xZjYRQ19mbz4JKTTNaoRjbVoyhSwbJEqUss6oj1WrFeBTsqsCaENQEWCst/6UgZq5pKSQkDKRYwyROCUIByMjTXr/2MqiDfnyIiGuRedTbwGyiXARSGkK8NJigJQGKEcrR9qyfvd3cQQtXH/mjz0a3NyUrQNplxfSh/go2MoSzQjlSoBnEN1tutLV09Bq38SHs8FashpX/5eRFj1Om+emeENpJk7233lvRRTUReV5ek7qsRk/20I2UCe8xlvIB0OiS1vAnNkJx/JsW13ya2L74fZpttttlmu+psS5Oyn/SkJ+FJT3rSlX4/1wpGcY9c+AV7TDJFC9M6TB3a6EGIgwwiT2FUgbI6qRBAqgFqbW8OIhJ6bJM6wZN4LfFYBicVbIcdqv2s7o1UqHn9HRCP7DkUbBEKkzk1MjEuGLJm0QktBToUiHveycvOOO4z2UuHhZqsWxMwxawg5V9IWYV5TCkBiXqEgrMYjss1QvqCBuY6fLgn2HOvbRK2OKZHc4zjGJEoxY4HNlDKbFIqEtt1yX1rPkQcJogFozrQhhMnmXikcw7QSMQ0yV6bFznmLEX46rkqXj1KWyKvkDTPeVYMErAaoaA6YlGXWKsVa1WwLpY3sa6EhRIGtSpA7o83MgAjFQNZpGKAYuEguWorzhUecvH16wEoi96JPbKvl6guBvVk+fh0YADMEFaoszdb59IWSTA5DfDrhEWRMrmYm0zK9re1SxCkgvK4pL6uJK4Ju5xJUagAbGoui3V1u9H+usGvHlauQ7se8TZafaRGKhDJ3XtQoraPzC3pwbvnSmgMALBiAep1CEATqjudjbaO+qOtfGjFSbmE0z4PKT4XNSKR24dQAN//98Nss80222xXnW0pofh+rdSKgmplHpmz5Gj7Il5VJcP/3ojFqqOy+RvJCUIBs+vAlQEq7m02EJN1o8Il70RCClC9JOo4sMmTimnUiYCxMobRKzcpMAKgKiAxqcPImoRik51MLKwc7HKtoK4XyGKwBNri1Y3ABsCVwE4kWBooA7zijUblmy7RGeiq39CkYk8ALHFQ5sWYLEGWvHqPy48M6BrYz8o+qim94rhCrTwTqhcVqkksbGxGZmx8JbARk2n6tXmSQ5MWo1fYHIpKp4238bMCYjWvEBq09P7G/tDvL8qFalaGCnc0dWsp5jCCNaThpVcvIep7UxudracKy2cYsRYyJ1EcKIoDlbBDgDUlDCCX7wVp0ZTKFI9UDLDqUHGtahxbTWdDap59guR6V4KRiUJNl6YAVQJXskpbA4E8T6Z6xC2Tf4M5KvwYLUpBDnCtYtL0jmQvjxrefNVWRCGslZb1M+JIYvZ1i5ZDQwyItDWe5WoVk2uW64PiOsfioLzOWcyhWwfxXvh90z4n/JziIyCeW8HuqnHuzQqclOfaoW48SIJgJ9LG2Vt7n79VbVUqceZUxFmTX6PZZpttttlm2x+2vQnFOKIoA1xMl8yMvp480Lx54TnsVcQBVhqcXJFidAmOxAySAnCFKdhhuDi+7/2NUuAyJ6A6CVguuEUpBgYKoYhiHK0EqRfgMd24mOY5KjqNvm16VKIu2HsJDDC3fSMT5GUjqVrZVarmRLZCOC2R06oXefUk5owQhEcz6+pz6/Pg0wEhioJAGV0JSQs8BySIRFH1Ddabwl9rZVt9jKSQqhhH9ZwJRWXXxcfEiHoVJ784TKAS4wEqW6la4xZWTta2RigSQKpiQPGoUMmuFBmZCs8+Os+09mCX4Ge/p0s5XuvJ0PC5kMjKhT+qp377z6yC9ao4QBQHVOtLsqPLm2iYnTzvJUiFV3tSYIDNc+2Op1oBrVBr8NEWKdBc6UQgNQmRxUEELASpBB4JvFBwtfXMTpKt5wdDB5skdRILUsunkO4QHsExTOz/yGi4aldCIcCuXyfOqF+bZI5Xs+T+SY1MCNUWpVD4mo4KbkkzPGnZ6WCs7Y5s95Z5F3EeUXChUfDJqsjPkgy79HQTzhfi2jUBXlfMOmMlLZ+kr3bVtvyr7zMOqX5fA730zdb9TChmm2222WbbX7a9CUUVFJddZDlPguuH22Nz+gVanH7RkyPJAB49TqTwlBJ7zkBBq8ICT9p1AMDmtRUnE+NAqIODMO8dIVb30pu4sb1/KdBBbD8gVCiWTBiLE4rBm78tCurAkIXJnMDFwRl7wzrLN6AakYneK+uYH10VG2VL1IVmEaqsEsOeQ5HVZ7Xh0S5BQpQg4hgv8wRCAtUBu25LbTsZph6qbXVU6zkR7mWx5F+qGlg9eAsqE5Z+HUStMhFp6wlSs+KNzYCQ1ZwK7znBqusYL+ggXQDYnkzoFEIa0FR0aBMRsUhA6+sDYqQqSv2QkwhnTAbg1SpYrXklp4UTib7NmXSPMTQrHkYJTlsStlgeibA1iGOGiuUf2L2CpqcnT/UlBao4kPfziWslCioWqSABqMQ42no25mMEEdXXoi86YvJ8l0bYc+pgExW5Q7EuJnEjmt6xDG7H4lbIV0Sxx/3rBDZlWGjkWn2tKrXrZx8RK8A7SKmz0z3lTt1FiTXUkQrkufpxguSscFJbqdMC2N6axApExNjRx3O6febYG+lp+5oJxWyzzTbbbPvPtjWhIBGUKp4oanDctPdTSKD9Tzr9W8oV3IuaXQv8+9ec9j2p8FKVDkajk21oXIStlKsMUdLVyrtaFSO0TrfwL/+iKIWBwplLUUHYZDVSEuRkraAOBTpE3kQor9klTSZRsbwJsuo7fg7iCC6lKjAwTAhA6hDEcVKQCXWCFOCLnDQZiDNPq8R+EYB/CnWyytTKzyr2g1ZCqd5Ze7QkcJMqkRGKquDRQa2dRhQmsogORfXg8B43AiVBcMgEVBWUsiuT/UuCP0qG0z9MgWZwqQb9OrDWnXM8E2QqmvFZLoBOyASpEbrB+0wMSkYmfElBW4WsdmQ4IfQSuvCKQdRyZVQkOyZDGMp2MVV4xRNvJIP8esALHRDIIx1+QFHLzRl87TjARUYruoscN5bGWmzyQ5tDcvKqE3d7EgiNiNGeGS4cd3cicquolQk5qzd+kpNYsbFGKMfvLKLH/A7bJ8KsrndGuB6mx2k7iIeOdK4yh35tdX+Ykoq2noNYRITK1njMWBszdSOHrbB2yJlPzDbbbLPNtp9sWxOKIgqOLFNPuFUwrDdF78lrX9Si/TOp6k6fY+97RP5uZIK5mNiJCGBJD7Bnt0JZXfJkJKAOwBgRigDmiI0BMnnPWDiTEhSEEYSl92Wog5WHretDEgllj04ogYQNWFbyPmoK8iEFSIqIA9wzG/IUkqmOO0iRehUnoY5Q+Iuk2PkHACe1UqSRL5BJr36iTfvv8+gAWkGAWGUrIxNqpVQV0OLe52gA1kVcQpokrBi1K2u7itiCGLgb2EYh1lg8emrYCzKxmtCBNIJ78QMEN9nc9Dia72keanTgTZuXXxUkFqWgXAUWobByuE4MgnTZFKDuhSBrLEMABYoCl5PFmJRQZfQ1akyXpGSye16nBM2KFgKyRxby3HVbU5UVqLbWauQKkXUF12iKF2Eob2OuTnAjt4fyiNP5TGis04hC/p1aueO8c0Oux3EdomoXMi+jp3oh6aMuh0L6awa0dZOkArnWu9XQ9mnM0Z0Pkws/WQj+slyLETlBd5wkE3nftpLVeW9QF6XKVR/OkEZ41D5h+mW4MrbZZpttttlm23e2rQkFi0lkoK1lk6o1R7BqNM0ba02iIqkTSFhCoWkm99Y3wGBf3gRmsv1aeRmQMkQUohVSGRqQjwVanFRwt1EDCpYMYD7yKOVY4YDdQdlI3mdizXMm1hiyPkBKMTIRCdg1ZA4OcAJxuLRBHHFqO90EcayMwQ6ZCiahBlU61NMYh5cSVe9oDT8dAUGk031r867nRAbIj7/DKzSR5VKU0TtBu6SmxAtVu5JFkUxuPwtNc2JCxg+18rUcnmMKoiMYo/qpEMSTozVIRedJ1kR+Di61S9j2PB1JcOeJ7ghQSK3yWCcPi9KtUTEsVO7scxFIUdSS1EPSNcBjUZ33HGg6/BKbkzVIyyUZ65jjYC7TkqL9GPPEtUmVyKM/4oSKFVyBOpJ1qy5q+ULspII9/4bV1nLk72S6yIRRo5GZDqD3wN//movG12rMMWVuk5EYAUNEcvcSyyeXcE9UyBvfGfiORnwR5VilBo3brIqq2v23mlreEyAra4uWoxPXsjtQPzUxVZnPBIvo9GQiJoSAzE3qyYmAcr5mm2222WabbX/a9iYUXWWZgJYTCJKAATBPsaTPMurWh7wiqspwAC04mSADDBx6ayVABcQKEiMZliwrLguKr3z/2jc0gUSmagTI3me6b0FItUyTPjJjXMAqQy0K6ppVdNKhOEli9/xHEmiT91g+h4PYqM/vkxHvYJgnvMAqBYXUyvYVgBeZA2En4gDGyUWTT8Ebm2Hiicfk2qxYz1m8GlWpK/kBPbBXB1Tc3h/TGuAsxhL71Ihu9Icki2xUschQFUH1/s3IErIe3fLrHonFgk7oEnkmAe3T/Yx2YoqW0G881POim1eaHcQaITFiOSphCWDTdxM8Y0BrC8HoD5VxuSZdczRdSVEjs54tmsYcFCTIhK2nKalANxN2n3n7D5c+2bXgqKI8eLTCd2Pdzp1YqJFlrdTlpWu72E4iG9x3MhF42QcU8sN+7QiCD1HmaahL2NTHLz4fbX10901HDRgO3Fs2dB6oSYj65dsPsEVC+se87bs3ru4+zqulN3QSQoJFKaitA+32F7e5kTCXIZK/yOcw5Jp7ysdmm2222Wabbd/ZtiYUFIDPUEp2zE3QwD0sMoAbUohApQljyCIPIbdQajAzKs7AvdbknlC4dELF4I2i+hd39e7UCuIOmBNMt48OeKgBP+LwRJqcJLpg26P1mdBSTAvvCFrVde4eBTEdT6CuIDDUsK6m070Dp434KFySQzZ2Ztdgazv9fOzQSRIICXlPEKnp1Wpz3ohG5AqwwDuU+6s7kiBODGMoGueGHnj5WTsZITQy1fzHaJ25oRjJEqYpOxw0kYx2++4Te8kH18vX+usZpiHRIbgUqHs/kF2T2ddlhVVoGqFYgrDpQLWqe6nVIhVTODv1hyfTIs3ol3hSNqRaOCnIIsP+82YiSUJjV+SRivzVFg+TzavlGBHIG4BQQdsvt2vW8dnMRc/bKZJDukN3JzeZVerzLXwaQmGlBEv6DjmTvzXmQH0+VhF1LuPOjR93fTfVjRTYizGJnAS5bVysHZ/az/HXCcH1E9d8bcSefK26kyGicj3RyDlMEhHPGbnwSWtz4uRxttlmm2222faHbWtCEVVtFADEdekJIhsxSPW1y0y8w9TkdZTVbhggdoBPLr0Jb253cGKr2OMacqB6xadqchsRK69aBVXRpFee7R0AxOROCh2cIBCZ99yrOYn3mbDNAKASQ4UcMNkjFZi8JHT/pK5bt1NlB+1RDSjIBLsrVR3tmafTPdNevUm5y0ch5N/De02i3vNCwVVTbhRRjlUjNAKjSnmc4jsluFQMrYRt9vcgzfc1z3Cr7kRKUCc2Gr0JtOFDIc1sm8KKglYlrEw0+D7QBNXu8UWTDGlHLILDxWuDyCqxXV901YgQVY/QoixJkCjPqoKwICMaCTSpkzZ1M9CsgWgrtVutR4MQICOggyWwd+u6NYaMLciEr6V4dQDf4IYZySIve2zEAoBL7SJSYW+OyrXqZMkudKwHyuuQpCBPqYmKLJfF5pNDxuiXicnun4gYmVffI25JKmJf8X8w2Bx2I9Edl46XrPLkKZFo1y6paRB1aEYiYh/Rhd5IRSRaT0myeLWyiK1OIhTdRcmPJ4r150SjIxUUYb/ZZpttttlm28e2vQkFWRcB8XwEL/djnnJHaw12KuB1+YNQ+NcuCAwmAVHSB6vnrkjwGFKMeAGpAUNrqlcBZagyihIGVfPGqliNfDavf41kZ1av+OQHGxxQUIFCDTgPnGTC3L/FEZt5GtVF9VIUEGAszfsbHbKJTE4UEYOIShTSLhlb3XWsIK0gcl0+2VSVQqlFd+7h1Zq838QoKKPmxtU199KSi3t3b5AJDlLg+xaFgUuPBETPCWWFFrYE9+JzB7+2PrBe+gRx+CZ+3f3SkyITku06+HkTo6p4t+maawKglOKAuJ1H5h9MgSUQp6jtbCOqQmySNF+bqAUMsWRzCmBshxtJsYRFKtbIOmWvgVBBWAdZSVmPrABGjkZ//QiLdFgCr/2tqkKqj4WXIBkAZpBmPTNETkgvM0qZTxfliVgfOUFOwhikjeG5IJbMLRzJ/f5uJxdZZaojkHGN2kqJtdnuNyIkQSa1amCRj2IkOSSLvp6cKMd6ELYqXykao/yvXXMIyCvG2bUUrHyK5LWPcfbqrX6bvMrXeVCOKAEbc555ErDPnL6xpMBJReeY2CuVdAKRk8Zsa4t9bkQw22yzzTbbbPvDtjWhyFKuCoRspW2dVxcK1WqbV2WK3gLskYnog5x65JBLdFIJNTcoANfDg0Dmwm+ASBWsghKSE0UCgSATQJeszQQt4btWAOzeSS8J66m31FyW7iGmBMxx5qHRJ/Zzs1mKwTfNdSIRj9YkobCqQ6oGwApTBnPEJzTyJBiKIooyCngU8BjEJdzYDuwdbE6Alo+f3FNflCDuvo6iXZFMa/MD1AVhDK0+fJ5HaeTJI1UpSAlw7NckwKpwADY1sqKKhap3lVYMEqC5SX4A8esRkzD1oAfw7Z9Nj3ScL7OtB/L9WRcMJ2kEJbFn1ZKpFUiyUAlJkCoseb04sq4ul9qEYrlCKoBYwwSVEVUKqI5WIUwKqIR/n6bnkvePX8s4L4JHwLqzF/eOC03IIqIiL8GiA7F8Y89tgdpRxSJ0QS6AqALVCFqW4e1ydDhkU9oKK8T7beGqFUvwp1TsukdXec/MblNAkTfjr0d8PjRrnyvd79Sek/6FeYY5o8lTMZnr2IdtU0LhiePUvSMIE3WFCpzvZgxGjQwzKZTYI3CzzTbbbLPNtu9tWxMKZnYAYa5PZUZIliIhNhIzDdwbqYBGdZ0GpKLhFRGHKxHZQVobUI0k3fAEan6L2/tIGAwGK3tJUJf0kHt1AUT5ISV4+U2klxhwb2mI0dUSxxOlRP6sR0E6B6h7KP2XABo+PVkiyAF7kzZlpqxXHnKwnjQrDtAIjJGmTuJU3fMe1Zg6IKWglHZQeF41aJ//U6/q5O/VlLjYeQjDKmcNXn4XFnlBkIkEn3FE33/bCRKgaktuNY26RzhULVlYreN057/3vfo1y9lOxNle10W+4rlI6tdIMFBAtSTRkt6JnRWKpv5t1Yi4ESqpV+eysVYy4hGJ3KO6jC52q0BUsgpSLVrBWgEdmvqv3Qp+Dj0EjnmyuynOO9eVUDj3M0rBAY799ghwzBTeec2LpOzLUn0KO4LW4HYXyYj51XZdo9gA+32Vf7OSV3Yr+SO5D2DyJOCfF+1oPZeKeemvS84Prb6iA/WTWWw7rPEbtfet/pzypiAJ2j43ck86fV13iIy6EBhK0uWCzTbbbLPNNtu+tW1NKIjZIxThlfaKNU4szBsY8o+agCqQeLSoCxkBgaEqXolH3FsZgMWkEP03dvuy7yAPUzbyClIRciODLv7eAFkMSInqNMhIBAeZ8BIvGiVivYQn4Mg8SnMqMq8gyQ5TG2PvdoV77uFpoB6hiDKkPSjiDqirNJKRZCIiE9IAoc27HYvJK+c4GiQCiie8A62ylgFeOADu5VLq0i6CFLR8Dvdm21gsapIXJd8byCvQb4wtoh9+DTw6ARhRCsaRZKqDhUFAMgKSC8EGHvkJRE2Pz0luAYABboSiJdePxjcin6UD7XnlyHpvDIheHpp9KkYAm6pYUkQo2nUD4PK7aHRnCdokAhRjmAG/VwlU4NggOjk+8nkAJ1EKBhdRhDb1mhxcgoR0hMOmhRq5Ulg1qYgiBtGINev3SNJvQq5bDpJA+WDvEcmbUBnIBiZ+Cn16O/qYBFGbi5iXvRCwvVpcO8/s77hS+3uQiD1IiWJKp2J+p8fSyWMUDUBGWSgkkmrR2Nlmm2222WbbH7btCQXzkKVNlaIePltyM6xKToVA1MDUhFB4smOAfQVZJZ1MmPWkUvXCnCEPSk+mem14j4Ik+LKKUeb1DxmVBx0MBSMb2XFozFsNIAIbKfE30Egu1UBwlswjSIS8AlRijBLVd4QgrChjACyXLWkkqQuqqns/CdX3r9DMx1AHzSQGnEttEQqIefgV5n0Nr6oA1r9ADTBK5BUoUJw4kctMigPRIgbyWb2Ld5IfSq91cXnSUG0cVHVSKQewudVUwrW0aIHJiEa2sQ2wUrKAgdi1BIxd8nS3Zc8CH5eNMZ5rERLlSIb160jIDuS2xsxdrh5RI6kGfJVQxUGxXxNRxVI9/8WPJ05uJNY5wde7dVtPIOzzKlIhMlrrdi5g78JoSdDhpe8XUXjEI8LnUT7xvitkaxU8oCUEtagBFC3PJdYtx9YS7iN5O46vDvZDeggEqaAIHhrZZ3Yi7OsFFrnJCB6iE7mPzEmF7b+TCsFJeEYeO6A/mYvusyeIEqZ/2vOV7RwzubyLKChiLO39E5pAMauRb9GyPZLV7I3jhHQraC2xf57MNttss8022763bU0omAuYi3v+rcILefdeJaBqtZ4DqqjaGsk1HXhLTh4ABDVgal/e4W0P1VEFp269UmjWNasPRTUbUwA5/I0Gex6qoOwoZ/CAxSGCkkukoi8GEpS1hFZXmHBzjEfibE8k+tKdEWXRpb2BAHCN7sxGklSjL4LLMQK4iXiVGQfnaNp1lohQNMlRBANC0oEOBFm+hAE6FcLg+RMl4ZE6qQBEgEEUtQKlwjpp+xxAFcNSsLZUDMsmuZKQVHED7rW0MrKJunwOqyFQOzc2qsFCmbAceQFRUrX30reTbT+HRI415p0sARp+3RFFSa0JnIF1p7TkA2KBSoWQSdDg67V6srYfzAA+DEjbEtAcTnBMcZlaSmJUUKUCQSpKsSRtd/FnTKZP7EXo/j0i4sSkiXjU5ysWa08qGgHtSYUyQZhbPktEitDkaCbX86pjGnkEQPT/sATtdhOwX1+VqFnsr9Ogkeo3hbZu4RAvBqBZfCHK+0b0ID8pknz4p0JMNFrKdjTQa2SEOoKmfnhqayZe2xhCHiEOFk/3UZhGMvbc2t0WJAmZv9Maucw222yzzTbbvrVtTSjgXjcOkBHIMXMnuiopaNg7owuAgUhYiU4hgVAQCjJwRzAPMiQBT4VFNqyyjljVIMAq+fRgDx4xAZqGx2u2coArRyzquRLBOxIk+A/knlthZH+NKQjpvMsRASmU3lENSZAAVI3PNEJh46ixjyAgroghhEc2/qZZLraIZlUnCo03OqDUjSuiFKBWMhVRgao7JcvP8FKyFRicUARoIwDDUrFYWsSleNJAZUALEIgrqvpITH/MQQzNMXwkH3NRLKrYORN7nkk6rZtHOQFlTyyAHtEnrA4ZlEc6LCHXCVp4jBkwIRMB4lWJUI0QqFczckgfgLvCyYSik0+hG5OTz269G6gUQCpURkAGz6VwANuRAYOlmnlI8HNpsi9PrxaANZMS2uQmIHai5XNvEQiAWZ1Y2HlUDhJvr6tB0AOoU+RZkEcGbKyUC8mOxdQWXrw/E+y9ljG1KQLU72wljxI5RcgKXRGhiZOL698RCz9nVvsMoG7N5zljxXTPH6l73cqtnVGZ/ve4L/OMk23Efdg+I4KMzXb1tpvf/OZ42MMeht/93d+1XkezzTbbbNvEtjWhiDC+JgForjsFoEJNL4/2pSrq/R6cABApipcSFfZSnuzSJtb0IisZ+Eg5FRQjGaFIyRMFcKJWVpbauIgUzLBjQCd5A0YmKPtEJFCgqIoTHlcYKO8ASCZqkhEOHQgYqIEZc1lbLzNYNaGQDYUXPHBg7LOodlGJKaEw2ZNFOlicJ2nAGGrXgBqQ8SEY+IJFABhe2hYNRIWXvwhQhFBGxVAC9NkYhlGxGJvcqZ8DAAZW/UQYRsbsMqyky5JHclxStGRBYTsXa+3B7rfvwZi2rQfz0Nx/Aj2NaxzAcyrbARjC1K0RclkYWa6DlXeC+nqr5HItmLwJvv+ovkVxHRLUe5QCvg+tUGFAKkhGQKpVOiOvskTsj6Hhb+9VR62ae/TfY03mjdlNl7Y1Y056Xxs+bvFyrlTUIkZO2mItq7/WY4cesfBaVJGzQcbMW76PmanYpEnmnKB5xlWOI89K2zUIgmW1FijHZS/WXKd5t/gSSaCPjlQQoJMJWZ0sJHmJZxo1n7xqOsXaXt8+K+zAIaWaEgrMdjWzAw88EDe72c3y97vd7W74jd/4DfzjP/4jvvjFL+Kyyy7bwtHNtt3s2GOPxfr6+h7PX3rppfjKV76yBSOa7QfJtjmhIJeUWHSCOuCuUbfSNBYAW6MGlebhXXJFqI2YFSMrBlYwK8hc2i6PcGDllXqsYo3JUEYSjKwN/CQTICiVJBRR9SakVcga+i7HCqWGYoVQOLRwTy4VQjgetce58Vhcoz8QsKCmk6gALT0yAYtMLMRKpkIclJJ6zwnP2SCLEgAdGHG5U+ZRiOU+BBmK14Y+XlzSAoTsyYZaItJB1vMink/NvABcyfIb4Kfi80xOKIbRoyNqYKyiEUvhlufSV/fx2lkocJkMwfol+Oltlpbkbfw0ymLp3kFdu9zu+XY42L04PORJNtB7o72RW6wZFpOZVTsHSPXokSVc2wYsySo6ReiNfbxB7IpvFE5OJyXwXCKRJbQyhjo4OSUwuTQmEa16/lCjJC2K4dQxyHALSfh8USwKBPFiafMVydHq889KUaDNwXVsmqWWKRK1yVZTZh0pfA4ln8tiA+7lJRiBBaysMnfErpdvZSQic30oxzK59ukJsAFQRwa6j6Emm4rPJY9CRtY8xbEQ8qhu/UxCG93607Z/z86Z0t2eDMb9r76eZttyi7UCALe61a3wkY98pMko3T7+8Y/jzne+Mz74wQ9e1cObbRvb2972Nhx77LEAmrOEiHDaaafhXve6117fs7r2Zpvtytq2JhQIzy66co/9lz8zLM3a03mJAC+bWVENlIU7l4BlAYon6pIjM01ACTtClGJlIxUje/6Eg0JidumVJ+SS5Qi4XB8iAGtFUcGoFQzBKARRcU+zJvAlba5mOzeaesQTxPrvEaEp5MyB8jWs6jInwVAVQxUsqv0MSbjooM8iGcHJstEFkLkTxQnFIJZcHVMu1KRTQSYmYMyBbZZu9ZwT1QbqASMnLJr5LQKNFiAgtfyKUtscVQpQ6V7lyKGnvLzw9AsUz+GIcxCX0VRSLNkTn5ktl8Wb35GDxoCNiZt7oT1Fjk6sSyASbsMDnjKUJB9+XT0CFtKbKFbkfA9LVexmwSYRNgnYgCViw6VmLCYNK04uinq/CiCqFHs0Q8BavRdjAeqI4rLBkKIRGUHLaxK41n+3ZGi/HdiiGtTH1FZAdNw6QJArv1YeWqFIOgpCEdI1avlLStq6nGsUenUw7SRTMU2Yz4pUHpUgPzmT3jmpyDWJRpB8PU7YX3fJolM3fE4i3yquJ/Whsj4C0W4BO9fgIz73LTGd8m/kP/jla3t0EkfdWoybXdGiUr5DJ3czodhqO/roo/Fv//Zv+fswDKi14phjjsHFF18MADj44INxxhln4B3veAde/epX43/+z/+5VcOdbZvZHe94Rzz72c/G3e9+d9ztbncDALziFa/Agx/8YFxwwQV7fc/d7nY3fOYzn7kqhznbNdS2NaFQeAI2IqHTwSHQAD2zf18TIARVhoBRlTASMHoUAkSohVDYox1eXkj9SIDJQKLIvnrydySWNq8s+zEjsTp1HIDCm5cxWEevIFQBmHwlZCA9AEMAHDRQmjp9WQEI2j1Q4pSUEGWpV/EKTRL6fhsXAS2Hww+6h/dC433AIHBC4X9y8FUT3LTTIAdrAQZDmR/nJR056h9t3JYnkRjdSUHkd9j1pwSwPYjrPbkcANmlL4MAtVqX6fDeKkxWNJIYL3NmZcn7DXQ76s7jGPgmhATJwKCTXc/xSemdxlu7Qq0BWgmwLu1OVNWKCiyVsEmMDVJskGbPCSCiEiYZKgIw2zURtRvcUwfSBNZ8UVP2VEwGRdxJpZBEKM6xzTaBqPgao5RMxamkVt8nP6+LL0zyeSJ4lIBkUsWpBNBmZAnckNE57LdxaQPU1P0UhQkmd4eX+4rIAmG6NiY8vSMY0O4yU3dtMZUJIk+vZ1Po5g57/93ntZ+zxjWTCTZSkPkie9kpoc2Nj4OSMe35jtn2vx188MF4+ctfnlGJQw89FNe//vVx8skn46KLLgIAiAjOOeccLJdWduE73/kOHve4x+G3fuu3cMIJJ2CxWOCpT33qVp3CbNvIvv3tb2Pnzp044ogj8KIXvQi/+qu/ipe//OV417vetcdrY20+73nPy7XY25lnnonf+73fuyqGPds1xLY1oRD3SEfStbgnM+USXj3HSlua1kkctESp1xoeZCYwM6T08qnpVzCReanVS0Mpd0AAIRspYPLmdn7saKBnYFItETbAZHhRkS3mpv+vkIlIIKboDtdG58C2Pd10/DAJTxUv8yopH7GDtuO1nI4eYU3dqwRPnNYmrclE434szWnbtP0egSHFxKscQRCO94cnO2RK3b4ivyI97/6WVcTUyJHukbxq+RkWaTGPsOb1sQgKeb6CoMmexGr5B1jzRwOh4e3WzN1o18VJr09jJFPv6TFu8ya+VkUZowpGMEYIRiKMICyJMPoaIFhkTdQeg0yoWGGfomRJ9BrXz/3XKmCpIKlATyhivXVkIu4HCqYKI1gtQuHkqb8g5N72Hr33cxOAXOM8TPpkcxoV0uylsuedkReTOrAcxCKqvu0J+R2UayMk/fy3FPT+MBrD9dySIP7aERfq+VYGBNqpN8K4B9vp8mfsnl8ZA7Wfk2f4ee+dJZD/vZsmWFGE2favMTPucpe7YBjsq/XQQw/Fox/9aPzrv/5rRiBOPfVUvP71r8eFF164132M44i/+qu/wm1ucxvc9773xSMf+Uj80z/9Ez70oQ9h586dV9m5zLY97YwzzsAXv/hFPPrRj85186EPfWiP1x166KE44YQTsGPHDhx++OGTv9385jfH7W53O3z0ox/N5y644AJ88pOf3O/jn237Guk2FNBdfPHFuNa1roU//eH7YQcPUCATVoNYVEYmsJoMRzGiYqkjljpiQ0fsxoiRxDzBTN7XokUYem+tSSbsb55VnUAge02AUXwzUhGEAg3HiKJKxagVS61YYsSmjliioqpkk7UeAmW9fo+GKCPzEmJ0IFgS9sAmdVon8MLKtA6iWNsUHHTJEgdcusSOXRU7do9Y311Rqlr1KJguf5OBJVuPhpGBsbR+AYCB1aF6/oUAa+Kee5hGe8mEzcGiP8Ie+XAPevGqUYOXhDUyYs8P6rkN2gBYdFeuPhavK2SvE4d/ZEm9y4Gwe42xOQBLto7aUO9TMQoWo2IYbQ9ChOrv2VwwxmKvFxjZMUkYYVEZ6zpg0AGFCgoKihPG9IfHtU/yttqboCXG94SlAUWClRV2IoGQ9giqCioqqtZcr7tRsYmK3TDJHCKfJWVokUNBGNRlT9oqZ1lFLVuVhQsWwxrKsIYyLFDKAsQF0Xci/hlRtqgEs59/9EhhBhcGhmL5O9GAMPIXpIKXFWX0vBihRgCCxDm5z7wbLytbi1V7svvYxsJqEsKijEXca74/qt5ro46QOmJcbkDqEio1STPKAOXBetVw6UhH4PSOXANeiKEj9QSvCmWvav4E+0ywMrg8kftFzlW7p1c+cskJVEeKM6+jy9XgyCFxohyrMKRcSUjiPLSVdCZVbI4j/uJL/4Lvfve7OPTQQ3FNtviOuCpsfX09IxDr6+s4//zzUUpBrTVfc4c73OFKgbEnPOEJePnLX4719XXc+ta3xmc/+9nJfmebbW923HHH4WMf+xjW19fxmMc8BqeccsoVev+LX/xiPPnJT87f19bW8M53vhMPfehDsbGxsa+HO9vVzK7sd8S2jlAsuaCUkoQi9PjiRMIAiQFbq+OvWGrBUr2bsMKrMpk7kVbIxAQorhIKammhSSfUgZqDnPzCB9Lrb57N0OS7JCF00kSoEE+q7KIuDmQS6kh4Gw2VqrtD1ZOJo3NbyJ2oCmgpwLICo0CqoIp1V85cBgAjdRKTQFSubQ+kE7r6yBmxYVADNEyN/Ph1IqCrBNU85XGOMUHFPdMFAaQCODkodrAVSeuAelNANwt3pISFVK1CVPVoROexJVFbHGRAPMmnJy2IWEPEpYY8xh6j63V4pbOfhLb1ktnyfryUDqmmhzrevypEyTyNBIicVaKiSZtVoAp5n06S4G2MwKiKEZSEoghl8nvMn43Jmt1JhecnFAfP4nI3i8oUYhQ2IE3FATwH0Wg9xeOatdKrnAe1/dpAs7qSalZxiqkLAprefrZKbCETc+bml1t9TTQvP9iTMIqVQFCCl+NtC6XRhnYfZaTB/0bApMKTwnMv+jiGdnuMMJtGNbUWoSHOuFBGNRVtmfSJutqNK+4vQhQk6NZwUqH23pwipa6DvUViyhyh2OdGRDjjjDPwQz/0Q/ncjh078MAHPhDvec978rkrC8Je85rX4NRTT8VXv/pV/Ou//iue85zn4AUveMH3Pe7Zrtn22c9+Fte5znVw9tlnX6n3P/3pT8dv/dZv5e9veMMbcOKJJ+Kcc87B4YcfjnEc99VQZ7sG2TYnFIShGJgJT2aQispqXm0nE5Wt1OZSrTmdqAJakImN7oVlCqlSn2YankBPPtX2LIBWvtFJRMl4RSMT8EeTQRtQLFAoMUTLBJgrrB+G7xRNM97tqwMdBjdi336c6oBD1RI0lgKpmo3+lkA4x1MXHs368jA+XpIgLeG1bZEgcdyo3e/m9Q0AiKxo09y+/mt3ShKExfFdQYAnixqUDjAHyQN1JVgdjbK0xGcSoFTNfIsoKxqOYBUFqpMdslK+FQZwIfDmhNZ3JMgENPIFfHUEqYqV5BPUSBOa1zukUjH3Ezjo11KRZNaSwf21WsCiGGLO/EKbeE7yuqRQiYL8eWdw9iiQ2HkUVSeuAtERNeZgArZbVSVlJwGRvwPN3Iy+MECfOKyZxEPJOVMiqA1gR9M8dSKmgEU31K6JN6CwqBzFnKv3fUEHyn1NEEGZgVKCskKp2nysevLT4plG9Wwe1clXEzjJ5F09sXCHAQuifBwRvMIYtWukca3auJOD+vXvdpl0of/UiZykNuJmTdqG9hm0l9fNduXtsY99LH7u534OAHDDG94Qf/RHf4RTTz01//7xj38cu3fv/r6PU2vFeeedh3vf+974i7/4Czz+8Y/HTW5yEzzxiU/8vvc92zXXVBW7d++GquJpT3sabn7zm+MZz3jG9/z+cRwnpOG5z30uPvWpT+FpT3vaxPkx22y9bWtCMbrExmQGisqWExEEorK2aAV57X5EHgVbci/aF3Uhiy7EF3EryRjylq6aTeftaxi/kYjmgwx0oK1yC8JDzF6MiR3stP1VB01T0zxYqxDTHUYbmLBEETJEPCo0pE1qkQnHxumFbeCuAZnJyVH7UWDkgwkYO2/rRNpD07fvBcEB6I7bHMPmZM7k0+5cM1oQ7+3IBBq4Ja9UlUTCSQPlhLWoB7I/BSzpHi4582iSJft7UjUYSmJrp8swbyA1pDeN2MWYAU8IDrKg7Twy0Vst8T/OsZFYPx8qSSSsiwl7U0ZYU0ZodpQOqBvXtPjP0WOjFTEQj2AEoQBaCVTNakrtIqMr3doiRdCVROhYl8FaSSbJ2a22gEcntM+S6BmCeu6SjVvZXP/k5MkqhBHY85simmaREItUKGD5JNnToy0anY56dXk2YuGvoyAY2khJ3n5x40iecu46cvjjtszl0U3TZJ6735MQeKQiiiaQxhing6b+PX5DUc9UZrvCduyxx+J2t7td/v6gBz0IP/7jP453vOMdeOMb34i3ve1t+63E68bGBt7znvfgDW94A+53v/vhfve7Hx71qEfh7/7u7/YJaZntmmmqije96U243/3uh+OPP/772tcnP/lJHH300RiGIXN6Lq9q1Gw/uLatCcWSFaUYbqjFqjSl5tojE0Khz7YymwJLeIUyiuu5rVIlY4CXeNVGJti/7SPikB2BKUrV9hpr5P/Tn5Ce3eaFJvcGEwq6CAXMm2uEooEs8XGoI5cJ+JogEDsnCLWk62qEQlzmFKdRwuMb+5sgnFYRKWtp+q/RrXoEmaM+MCB1ifHd+eejIj3YbcSUxCmIBbmDN/tb+JunnlaFFLuWDYA3zy1DJ1WtSKbvF/j+q0W1wjsPWJRCNLqdx78KJYaq1zbVLmpTXOoVNIAAqt0xJ55kWsF1q3DQwSI1/EfEWXYYFHNiPvMlDEOPcZhIGs65D4lOkItY7yZxKqgoLqUaBLb+mVvHaQIiGjP554B2QmD9+jbvvg1WPWrQXyhVySpWQWzamvN58vO1PA5bfLbaXbBV7P4hX28ck03wiIrXDw5yJf5TIm7FaneRAOCrtodXLgg8yHOetHtanag6WVTKnhtRElaieAQiOqcr+56OLCKm0a8lmkhGdLR/a3ukxnRi/mf7no2IcN3rXhcAcOKJJ+J5z3sevv3tb+ffP/WpT+Gkk066ysbz9Kc/Hd/5znfwv/7X/8Ipp5yCf/u3f8NXv/rVWdM+2+Xar/zKr+CQQw7B0Ucfjetd73r41re+daX3tbGxgZ07d+I1r3kN7nznO8+EYrY9bFsTig2uQKnQgVEHwjggyURUDsrU0qiso9b5OLX5MG1xAWFQ+zm/uAN7JGgNmUuTL4yE7JTdJ2+216l7dW3MWXUIrQwp4MehKDVLUKpgIqvsA3O7i79XQ7KRqJz8cNQ8ljH+UTNCUR3gCgNc/PghYfHKUdF8LDy5PVEKiGN5D23cjRy4wETbsEKSNCVX3dz6XpKoKECsUGk6e1Lr6t3wogEkq9ClnuZBmR+gsGgMV3Fg3+VduFuXAKioe+7V004MpI9OKlo/DTHZk44WwdKQ8BDAijoQtDCifDCP3hSvWnTEujv76+M8qJuTJBzaYT/KBGqFmoyObL0K+VqFdVkZUbGZF16SOPfELqNKPudMXbK8Kgqsa/oaMQYlgBgDc6taRiVziAguD8zr56fR13eIP3hHR43eFc5ClKLamuWtVBWLUmhbcSkJ87kmlyjCr7EQvJO9HUq4J6BA3OG2Vi2RVaUTLOXC7Vbw6u/dudDK/xFx4HYbNVkYOeAn8uvuUiyXZBK1vBcEuXBpWBKrbirtWlFHJtCtqXxV3ngRwQlil3Kv2b5nO/jgg/H1r38di8UCAPC1r30NRx11FLayjskLXvACvOMd78CnP/1pfO5zn8PjH/94vPa1r92y8cy2Pewud7kLzjnnHFzvetfDrl27rtQ+/vmf/xk3uclN8M1vfnMfj262a4pta0KxyRXEFVIU48IjFNxVVBEHyxLeVGrgUixR1ZJWKavilAD8uRkcNg9hczUHAO6Zx+QLPBB5JwnqIIrjWnKQ29K3uWMElG8X88o6eA7g0leNDLlHABgCsuMzeZRCFBjDG+9yJ3IW5O01EpOEl7mXMYUFaeoKqiITRP3Fvawn+mBMK9QEIGrzGbjIyqUqSniB4z0hedLcsTewI1RRK77ljEZFMjqR1Y1inhJ1+j40QLeCycREo89D9YFajIKwxAhoFAO2DPA6ADp4grZaV/Ti5wxpEib142vOol1HV/Zk+dSc+O5a2NhLAtOBvOIWCEsQ2LMp7JwkwbrCoDSRecL70ydx4ZQCRcX+ruJiKl+X3Co7MRgUxAJtnSGLDawslLi4Ufd3kiggwRTy2gepCGlSEhdiFDbCmL1XyKJjEgSSItJFHpTwuy0iign0Ncdrcx2LsBt2fxp7YPB2vfICKVYetZHqOCYiMtXlVbgDgGP9x+dWEo1GXxqZ6CRN7ebvxt6iUXCSEsUApuWMZ1u1Ugre97734eCDD87f19bW8JjHPAaf/OQnsbm5CekJ6RbZmWeeidvc5jb4P//n/2z1UGbbBvasZz0Lp59+Ol75ylfi9NNPxy//8i/jwx/+8JXaV6z/1772tXjd616H3//939+XQ51tm9u2JhSVrFN15YqRGJWbpxsBIF36wxJkgpJQDELZmC02q0IkiKo6AWxaknYkfdq3fYG28qiAK4gUmADHDnjkV76ZYQuHDZGEC52UmbSytzLxloYj16FK8+Ki816KgiosKVs0KzSJI8rQpocW20B1VKfx4+QOe9AS59KSfqOyEmAkrBeTBIDlbkuAj8DPhPDMJhjqjmeEAhndcQRukQxSJ4UeG1KPUEQp1YxQUDvnPJ04ZqbvBorvyJT63wXVaRSjglwoLwVWKpUj8oHs+EwMGyOmHRGMgml3MeOc4uSDzE4lXbZDACim5w/gSkDVFiUTj2hFNaTo6UD9vtlKkRYEIRAMKqhqkRsDv34SfkLpcZ8AbY3LkY92vI4xhjRO0X4OSVB3QbJssmqXzdTuw6De6mQNsDKzWbwgb8IYmlcdYLZE727e95Y/0a6Rk5PJX3X6wnxZxFK0nZfmrPsF6UkPTJLYh+kaT2rRL2r7trVPeSv2h8/x9Kcd9293NnORp73bPe95Txx//PEgIvz4j/843vnOd+KLX/wiAOCf/umf8N73vvdKV8vZH7Z792588pOfxDiOuP/974/du3fjb/7mb7Z6WLNdTe3ss8/Gaaedhpe85CV46lOfikMOOeRK72tzcxMvetGLcNJJJ+HGN77xPhzlbNcE29aEQkgxknhnY81GdwBlcm7Uvi/+OCUUXvlG3aMsRiZIxFChioNh90iTgsmkLaLmWhQyUBaKjgDHDRT3ZCKs8zI6pinUPNgAG31wAOBVYCGtFlK3p/ih17c7cM8yss1dneU6G/RIr6r6fvJv4T0OoELdmBEExGVUOZYArG10fXQiCEUmw2sH3APld2OJg5E/H6VTAXO5FpeLFFGUajuswB6EosSx7bIlCI+zVW2EIvXuTFnpSaGopM4WaotQeJ6Osmn6SQkoColSpwjP8xTNTeYfNj/9X6NTuSVpR1mAwJgWXmLVdi7quR9oyfVGgPac39y3qp+felK8YPCtSfiora3E/QHENS5XeuUtWZkA4rb2mUAlBuLkgBjRKJKy07bdFerrtN1HkZzuvV1y/LEpqlIjvzEyjhNnTyQPKRBNcnlyzvdGIDIMqHs83W6INiXtpf5EJ+Fq89aRme59FLlEHm2M8QeBiJSntpu2ppIsUNt7HHHiHJgNALBYLHDUUUcBAE466SQ89KEPxbnnnotzzjkHf/qnfzop+Xp1NFXFV7/6VdzrXvfCEUccgX/913/FV77ylS2VY8129bUzzzwTv/3bv40nP/nJOPzww3HYYYfhG9/4xhXez+bmJp75zGfip37qp3Cta10LRx99NM4666x9P+DZtqVtc0JhgL66V1OiVCMYXAnDCJRK3lDN8yO0ae2tN4G2hlFSAR2RTbk6QkFwPTkXKDHI9UHs0gsW13CjAev2pR5ABvkM0OBAlDM1kEjZYTs00qqUlWHME5u+dMQZ96CDg0yNajkUVf18tG3+3lBsdfylAXtqICSAUqtlhHTIVmrnzQ1toVWkaTkMSd40ckjakEJMEOe0wsImJIzcg62kKEQYqmINwAj3uEdCdrUxFDUSE5WM2MdnGDcSsF2Pr/ZChUWHloFL1QisRIQCDMIIxWDgWaNMp7pITRGd27uCP82T7GtrrxGKyLvovdJJGl12Q4NXI7NnW4WumjkhmQfi90tOq6pH7yzypq6lG6RioIpCFYUEUnRa5lQjmTgkUjZ28SUmDIiwUV9nb5yrJsiTDYo1mjUAzApWzepJIkYiLIfDtsLsTfV87kQn65EomjC289RA1EoepWAnhdPCAbbup0Q4nuvXXz7fvTfJxeR1fhx0xRu0JcwbqdEcZ/Zd8UWuzmqDPLboI+X60Vi/3ZjivJLs9Z86M6FIO+qoo3DGGWfk7x/+8IdxpzvdaQtHdMXtDne4A/7iL/4Cj3vc4/C5z30O1772ta+0Pn62Hxx7zWteg7/6q7/6vgsKPPzhD8dd7nIXHHHEEftoZLNtd9vWhIIAl2IrMPrPMP/+UBnDSN7UzBOvlR3UklcBQpIJA9wjREZPDo0ohXt0KWARXLvtHXo1EoHbY3ilEV5TdB7qACjanYP2INr2HYm57PIpkQD6BrtTAoV4nWvMq3nwqSp4FKAKMFpyMqQl4lISKXTddBuebYOLYTcwSJ28RLrTCoJiunxqz2vbVQDjPrHU8W07rE7nJSyAWPwfXmoWxTDaPtghm3poIc4xysQWNOevzaZmlAVwjz/Z+igACpERDY9ACQtEqwF9JXBlYBxdF+/ZB07gNLz28EUDm4ApnVQoUyOVbWlM5jtlcfDxBdDs9mTVqUIiZ8nlo98UgamloVGfY0qSAFUsVVCkgqmi0IgqA4TYZW3kVaLsMeImRgA8sV066RUBVAhKVuc1pTpBZpjtno2OhYok7sIChpVyHogxlNLIRLxYPLcp7iVPypbufDNZGkbMVdqxgtX116NPyp7SWaxctfb6qDTV7uDYRdN55RigGfHKxRH5Wn5cIoBYgVIAVl866vOkaJPQyi5PP3cmJzi5h37Q7d3vfjducYtbZKL1j//4j+Mb3/jGtq2U9LSnPQ3vec978MY3vhFf+tKX8KhHPQrve9/7tnpYs10Nbffu3TjmmGPw+te/Hg95yENw61vfGj/2Yz92paJaD3nIQ/D4xz8e/+N//I/9MNLZtqvxf/2Sq681TzxQRkVZCspSbRs1+w9EAnZu2rbWnEuyT0NVQVVJLXe4OhsIb9r15u3uvP3ovtS1afQjthBlbPt/iHMRSxIfhLEQxkIZa1J8Y6wJYSFk+R8a5+Xypui3UHW6SZCJLi8kQGX3c/Nwume9O+9GFpoFoWhlekOahTwnYAp6fVZSSZKRDfVoUUQvEmD11sB4ALo+AjJUxaIqhtg8AlXU+lHkz+p9F0S7CI224I1q6zLsSe3sc9iXORUVVKnQcYQuR+tEvhxtq9XQtefjAN4BfUU3HxK9KK0aMp925g0UJiHzJyxh2funUDHgTYwFFQxUUCg6WbdjmZSrXbt4tE2tqpgKRqkYpaJKRRXx89XmaVc14u2/i98zVSqqVlRvzlhZIQNsK5F71ORT2YWbGEMZsCgLLMoCa74teMBQBpQuGbxNTVvXcZ9nJ/CYQL9BdZLAYwefevenFbFSOkZ72eIeRtZ9aA6DcA1M1ne7AybHi88XtSICKgJIBcRklyQCFslIDKDtw2Zla/esR0O6M2oSxisOHK5pdsMb3hBHHnkkSin41V/9VXz+85/HOeecs21LYH7729/Ghz70IZx88sk47LDDcPLJJ1+lpWxn21527rnn4qUvfSne8pa3fF+RhQsuuGBSQnm22YDtHqGoXYUUzwwOqMkaPQi8QopX34nWdObR9y/YAJMBFLsv46jhD1XXs6sXivHE0ZBQoclazOvqUQn3/PZf5QrN5mIR1QjAER5Xkza4h5sEoxpgiOZrvcRF0TzZ6dl3DQqJOOoJQtGRCRuM+0XtP/HHHh5lRaYcPxwcU3bGzo7K0uMcDZdvO/fec0wdIYgd+/sCFPZkJHzAUc0nvf3qgJ/ivQ2sNfyu2V+EO/i3Ct21fzZIHtQrJLVrL5DMt6FqJUnTS10BGuMa2AkrdVSMpiATPpdtdVBKpfpKXnE9EqSS5n6shCxjAKOqek8VzopNcX3z3MjOJ/IOAkhXVVQIRq22ScXAgqKUIDuuX3rIyQG2BiGHVWqKPIlQNgky6z8qHsHzKMAFJARhgnj5JoskEaKLfURDAGSBgTihIJURMhOm/CxQgknYYlNKiVcfoYi8hj6hOZPLO3IcE5brMP44Wa+Ub1j1ACrQn8h08/WQ9z/ZfavQTNjO3atOdtbmpDkD7FI38v2Dbp/85CdxnetcBwDwb//2b1gul1s8ou/fzj33XLziFa/ACSecgDvf+c5YX1/H5z73OXzsYx/b6qHNdjW0t7/97bjWta6FBzzgAbjjHe+IT3ziE9i5c+eV2tfa2hrucIc74BOf+MTcZHG2bR6hqBaJGJbAYgkMS2CI6MSoWRK1fXlH0nKDc31UIZJTK4BKDm44mnK1aivsicG9N9R+78rNSttiDOnNhfc5UEENT2UkTgtAHkmJKMWaMHbEVm1br4RFJSwqXNYF63kwKshlTpk7ER7PFVLRuv1S57FuidjwczJPvu4RNYhk8UrAyN6Tg5sXN/yjiJ97Ly/n6QJOAooqBlWvvNVHKtxybL0Xnxop8cRsy5lpEQ+KyEcHrgMGqlKOIyskxb7zWno0I0rwhldZBeoRCmyOwOYStOE/L0dgrBapSPmcoi3Ihj776IQQ2dzENei86EkmgjghnO4tUjFQwSKjFBaxKB0g75liazjXrr9AMapgqRWbMmIpRiwiYpfRifSwN3KtGpGb6vWwqknEijUh1NJFCqgj+EQoRCjMWPCANR6wVgYsyoAFD1hQQSFuydtOFWJLiiWRo+NRu1yqzspMwzYNK8ZHQ6zTIFfdWq2+zvNn9M0Pm7Rtb9YT1P4lSfy1rSf0nxldlALq/c+7cNxE+qXa1lf08ugIVx8U+0G3k046Cf/7f/9vHH744fjIRz6CG9zgBls9pH1iy+USd7vb3fDBD34Q97jHPfCe97wnZV2zzbZqqoqDDz4YH/rQh3DMMcdc6X1c5zrXwUc+8pEscDDbD7Zta0JBo2nnFyOwNhLWxgayrfdAAwntG9W9ft2vQHP2CQzsVgYqEypTA3ewKlCsJkUICQ1D904ywsseQNxJRQIvhFSkeXc1SQVQqlWiWquEHcI4oNp24Mg4YCTsGIE134xECXgU0FJAo3vOaxel8P2iA0BNtmQ9PGpphABdpKBoT75alCKkMkkSnGBoB4p7b7s46RidhFQHcOFhLmJSpYUAg8uT0rPqaDrK9rayrmjgP4lP957O4vWWpOyECED1iE9FBnQyQhHXefAxDSooKmCplsg/jsByCWzaRpsjaFn9GkgjdVqd2PlFju7QBChP57CfrwC/k8R76h7JGzRGvgEVLFCwhoIFGINaF/jsdkLT/XUsBULACMFSBUup2JQllk4sqkpWfuoxdGLiALci001rW9QkHpXQlXOiTrLFWHAxUsSMwiaJ4qwIxZZgzcUe+07efs1S5phJ7WSvLWQ9QwoZwaFcQd0HS9wbHYFdIRNJmYJodQRrstZ0Kj9qPLKVouYoFhGXQuHEwqNgQUi9qliEGAmtKh1Jtfs91qR0zoOYl5lSAABe9rKX4Xa3u91WD2O/2MMe9jA88YlPxLWvfW1885vfxK1vfeutHtJsV0N705vehJvd7GbfV1Ww1772tfjRH/3RfTiq2ba7bWtCETkRC2WsqXnyF8IYhL2zcENgE6CGBuzzZ3/M6AGpeyU1PbcaUFTbF316v8N5CKyABJOjNHIBTCQK/SbeLdgJALlXfFBgIYQ1IazHVm1bq5Y7UIJMOIilWu2xz59I6VPgks4ry3C5CbyufwM3Lc8kZn7P6jK5OYGwikmNSKQHPMka2vyigdEAzAVdAjWQHtn0IMMSjCfXryM79tiV720u3Xx/RfM+hwd6j6iHX9/iZGIhvkWOhlRQHW2+x2pRibEH1L3XWdPrPNHFx+qiWGWa84iYG4q5sfdlxKWLvNi8NWKxQNuiG3wrStDziCAZEalw2RMqli57qk58G5GYgtPe487epdy2WIe1K8fcAeJJjKFFXOw8VoIJOWBqpILYunCzJ35jtRcLvBmc/8Vfm/In3jMS1J9ert9cRy2RP50AEaWI1ahoURz09zjCn9F9VlBGaTgpXzg7IvJgpCwysPKTyv+WVek8/6KRCWqVwaiVHv5Bt42NDVx88cUAgD/7sz/Dfe5zny0e0b6znTt34t3vfjce+9jH4pBDDsFLX/pSPOpRj9rqYc12NbPlcolLLrkEAPDiF78Yj3zkI6/wPjY3N3Mff/zHf4yHPvSh+3SMs20/29Y5FEWAgVuF/gS0QFaZmcgaSCFeman5Jbv8CTTiIA52rI1ZANasw5JIg5RdQhVymuh+vTpa02gzTImUY0KQm6Z8MGDtIEDtUCUQlZ+UCnXe0EZ2IlkWahWeSDuAEeCt9+ADDTR5JSNWTAhD5k8EyFrZYl+TU6bmtVbqOmp34IwcyPesNghMn1g7ISt5QAqH7x7RiCbMcg08ggx1pXyD4KCXO1G/mwR99qgQ8WiABKgUVHWy4kQxJW4Bj8mJkjdViz4j4GyFmOPaM3mWfFThYe7yg3wLaYuVqW0EtsATncEYAQxQjAgipe3igvwC27HiugmiOIFLnqRCqHRjbDMVZ2Aec9tKFWCsICYwjWAqoJEiQDFZQLkX7ea+uw57+NAiJ6AjjK16VnsDwXIwgmwKkVVK0qAuttDjnsPqvvoFTejut/hZ289R+ax70cRh0e3fgD7s88NPpz3XH0ABIetxonDyEH+3F6e8yR8zrSMcAqCONM6EIuyyyy7DW9/6VtznPvfB1772NezcuRP/8i//stXD2id2zjnn4M1vfjMe+MAH4qd/+qdx8cUX4/zzz8epp5661UOb7Wpkm5ubeOtb35pr5Bvf+MYVXiO7du3CW9/6VtzjHvfABz7wgf000tm2i21vQgHG0HsfCV3ZTLRGdxRf6l62MTCU76fX+7cKLgbezAtp+60aidfhqvQGFOpUggKmNKBIkYzQZUSmRh+YAu/wbHaZ0aEZL2hvICF39DYw4XV1bM/hBU5vpSTY49yLg6HwzpLNV4zPEkAbyJwaNSSfCKendch9K2zuJtWJ/HXV3yWkEzwXEQr2yVGYJCm9xMDk+Lp63Dx2x4A6dKodkaiT678noI1j5aModASkCKoSRjX5Vl8NLAErJUOcnD/F6sr8hTbB2oF9e31LeG9kyyRYtKqVJ6/8pIxCioUWLCFYkJGIAR5liPPN40Rvi7jedj0qNCs+VbLqTaLD5Hg29LbiWf1GGcXGjgpWizYUIcvzqUEsqBUI8ItL/bnngaZFDezYU9CvMaD+NRr3eeRrMIQU5Do6IwDxodG/sydYjQFH2vaq2Vy2ee2upEuh2skEcci8hszn8kaJsT+0e1ud9Kj4ZxkpAJ7kr8AjnEm21MiTRWm3dSB6v9h5552HBz3oQfjCF76AxzzmMbjVrW6Fe9zjHrj00ku3emj7xC699FI8+MEPxgc+8AHc9773xY/92I/hlre8JS677LLvS+Yy2zXHLrnkklwj97///XHLW94SP/zDP3yF9vHtb38776P19XUceOCBVzrBe7btb9v6m2YNU1nHZItkVCYQA1pgCaKkLrPRlLwYAaGU0FiagUKkQqSiyohRRyuHqRVjlMh0/XSTFHUSGbUGa7GlLAqtu/HeHIbm4RXXQrfEzF5albkaFS5zqqbZX3bJwKOVLiWpLUk8cgyyP4MmoEtC1XEly6mgJlFiymaC2rBnS1TvpF9hgpA3uYQM0dG5EbcezBMsX2NQz1eAsd4+hzavERpp0f73IEMpj6Gs7rXq+c7XOqyOfJF+DAtVrIlivSoOGBUHjooDl4IDl4IDlhVrY8VQK7iO3hzRE7EjoTauoUuAeKwpCWrX13MsXEqXeToimVdSRPP3IoJSvRN4XoMmsxtgsqc1KlgDY40YCxAWoMynyIpnaNIbSpITCdoWnYgSsqLVImCxXnNTG7P6OS4rht1LLHYtsbhsicXOTQy7lhg2RpRlbecexAjxGBcnBEMCibK10qRFQSAIjZRNrr/tERRzol71igqoFNAwAIsCXXCXT9GtyF6W1Xn7U55EbQ5X6GCuT4kyrn5DBFmOpo79Zonz7PsNrmxyJpEKqSOqLDHKmBW4zIWgWcI2F3WLTeQIWyfy2Xo77rjj8Od//ue43e1uhwsuuACHHHLIVg9pn9rd7nY3PPvZz8bRRx+Niy66CEceeeRWD2m2q5nd7W53w3Oe85zvez+/+Zu/iQ996EPf/4Bm27a2rQlFcXA0IDT38Tub5AOuwyZ4iUyFkNfHJ0mQW9FXD5ogEvtCh2mlRyiWMOlIRCtSppT6+K5XRSZW9qDJB5/u6k7nDLTH0E9Pklt1sqk2oGWgo9u6crHxXurJj8K9xI1ohHs1SsFWBsYCLAthLISxtCpOgVtsrF0Cuni0IEgK9RVzdOKDjWlIkB8e5SRlDdyXeE0YJaxESrki2b6b216DT1nlq9tXerF7/X7L4bBeH/A8FmBNgPWqWB+B9VGxNioWowF/zhyB6TYhhnXlMfoNqDghaz9b/wzfdxWU6iSiSld5KwoQdKDXwWlBwYBI0LaeJkN3fj3sTIldR8RijgW2zrLhIxR9zkCLzNhGIkaalhW8MWLYvcSwe8SwMWLYrEkoWHqi65e1u1eg2o4r1Y9f0yPfa5Ao/+tXV/tbVHeLuaHCoKEAC4YOgGb2vxNCtPstJIITUoHLIxVTohsLsi992whK/NzP+RT4x5xXz2XJDYIROsn9iahX3z2dJoPCbCs2jiNe8pKX4MlPfvI1sirSOI54/etfj4c97GFYLBaz7G22PWwcR9RaceMb3xgf+MAHrlTls0c84hH4q7/6KwzDtha9zPZ92rYmFIMDTe4epzryriMzDO1GfkTv2TOP4gq86nMttE/iJVQAI5HX20d2ZYboBCg2EhBSpKgP385hCua4gevw2PZVXjIJs2/AZ4+jSEZOxBO71V+rvj9ogP0OKHVRCgqJBZDJ2SM7meC2SVS/wZ6EghMc+lFpBWDFnybHDzlWA299nkAf/bicvl57bhTzGNcV+Zsj5Q6EN0Jh64jQ53EUdFELsS2Ts7voAUd0yYHvXolFkDppj5N5QEu67qtWsRMW23TSlK9fuf0azqpPIAxqEYpBbZv0eZtsHRDNObQ7JNfTRN41HTfi/KoVCOClEYuyWb3xpDRCJJLXtlXn0iSXec8EsRBrPqku6ctrGgtrL4A51idlIjq1SlHFqj5F9reyfyJMrpvvdEIq+nK906jX9OCUID+ki33ieN4OK+Sjkbm4VdSabkrXUFH984siX6xJLnvHRFvzs12effnLX8YnP/lJMDN+4Rd+AUcfffRWD2mf2te+9rXsSfGoRz0Kt7rVrbZ4RLNd3ew//uM/8Pd///f4yZ/8STzhCU/Acccdd4Xe//GPfxznnHPOfhrdbNvFtjWdLDAvbiTFptwZgENnxyWeap0yik4SYSjbtNRBR1QSnCHyLkCoxBhh8oqsx6LojqOpKYcC4K5ePnUNswg9gvAIhVfwIWulZyBJGmpv6A6KClFrdrdUya12Uo2oBhRHsWdNz9176LNEJZATGOOsBFChyXsskGG67gB9LXG523fnLY6fczyqE8DeV5Ey8Nx+j7FbidRIoKeUeDSQp5nAvkog9gasemAY46SVuemfZ7RICbtXOJoSLmGSrkzqpxaHiQVJkazi4FIJIM+C7wFxRHfQkx0/fpRCTpCMWMPdHIeGnggMRVEjFUZAyfI9EOtdM1keXgCgXSsn4/F8RgW6SFmsmcl5tteSj44rvNcELIpEaNp+inTymIRutXrUrMmcvKxBkg2bL6V2vffCKdr1DqIIpGxJvNJT0+pJ8yJ47oHNy0pkiyIBm1bGvhIMoH41Not11V7XCgkgaJXfiG3q1WRfRFCV5oBIUtP+xb04WYR6ebMz2+bmJs4//3y85CUvwSWXXIK3vOUtuOiii7Z6WPvMxnHEueeei+c85zkopeC8887DhRdeuNXDmu1qYqeeeirOOOMM3PWud8Xv/M7v4JJLLsFnPvOZK7yfxWKBww8/HOeff76pJGb7gbJtTSjCG26gAoivVfYv8OJfqCOsl4CVWgxQbF49DpRMgFVdYRdLGXwJvGTVnhgVA5RKdvA1/qDti9tRQlQkssZpbCVZEYnP06//Jp+QznOsmVCtMK+5OpJUWCfjpQo2IdgNxUaehidea/NWGh6aMJ8GWMVxnZJLTQxxChvoG9HAawO+4eG3TuRZ4UpXQl4U4Kj3Jqv3mwAG0fT4h7Qo8zFkJW/CQZ0l12r2rwA0Z7M9EyfdeXmBBp79dbw6R93xemQaxKOo53P49Q2pyYIUVaI0sSR5y0o96gIj8hqlzBbRyhR/asAcKwPwa0o9yVInKMF5J7QKiTBZGQMUUAPsqoyq3GZEqas4FuDYyQQs12fQJpFi9NGyOB/saW3xIzz7jAomtRwG9tNlJwg58dyumb+9l0MhztDPPVZWAvPuQvbgPOeROhLr9xxFjpXfV9DqnEIAMIiK88BVUWJfKW1PwhDXZUJ04rNE21D719tnCcMiXJwEgCCZo0XV9qZQKEtGUm06nahTjE3biQOTeZxtah/72Mdw1FFH4aKLLsKrX/1q3Pe+98VDHvKQrR7WPrOzzz4bRx55JM466yw85znPwf3udz/c/va33+phzXY1srPOOgtHHnkk/vM///NK7+PYY4/Fueeeixve8Ia44IIL9uHoZtsOtq0lT4Ectf+1swDMRcy7yxVe1rMJngRR8x8OWL2JlqW1gmkBsG3CC1QuthFbN21MqwSFBColCu5VFGl16HvvcyaMBsgBUhdfXNpiGvqavSVQJXM7UoZF5OPpuxI0iBzxion3NOYpnLOBMxEValqPhkqtd0Tqtsm9u51MYwKu/PpkFESMKAyi3tMBua31EqLIH1DNjteDAgv11yiwUCchuuI1jvOkdl3yGlEAfaRMh30r3axlk8L8fTVR2/qCLJSwpsCakI0JFjUj93RHki8ikVlCDhU9BDSlcvCeJgkWfazTpPMgKfbzZN3FdEciOozwFrKcIhvrdOvnMPpURB7SAt7bRQlraK9lz5GY5PMEpdGpmCfGLCEB8wZsXCvYH4vUTDS3RPQoXjBNXI4yuEzccgT83ukjOf3j9LOgyfuC0EYkDLE2nFSIVmit0DpC6whUK3AA6QmVrux/1fr7jqDEmHRD9+hI35PFmksSKjOUC8AFRLYxCoqy9d6J3jORT9Pl1cRnRvSgyS3W2myXa+M44ra3vS1OPfVU3Ote98LHPvYxlFL+6zduI/vpn/5p/OVf/iVudatb4bOf/SwOPfTQrR7SbFdDe+Yzn4k3vvGNV+g9f/RHf4QTTjhhP41otu1g25pQNPmSNsBI8SwacHeA3uvSKeRPnqwd2oHIZWBicH6hDwAPUC7QUiDMthFlaVrTMk9B+7ShlTYyoV31GUyBq4GpBpJSDhRAIZO8uzhHVogpKFQa+ApS4XKK1tivVbTqbe/CjAxIQLQ7t9gXkXnmGa17dedtjyTrBHLqTeKkVVBaqEUqDLTazwng0VV8yt/VCVjjMqCorIMJyZNYExQ9RhoFbQ3imod3tdFayo205VIMSt24aEJwrCJVRyomR9XgWIik+tTqRwJ9yHxy3kMr3+W2oGnnI+G9wXrEqkBEvyZEQW2LXIo+P6Tk+bRtDUaaJoQic0V0uq7jek/940i5oZOqaHI3yQtRQXaV155UNCIR67r0pKK7Tt2SXVnB7Zf4LLBu2kFIIrrjPWe0S0QX6z7dto5QdIRqunVuDmqLVFc/L4KUd8+13xlKDCSh8CIT7nwwUmFJ+kNW/nK5YNfIcrrtcYPPtmJnnnkm/uzP/gxvf/vbccwxx1zjkpi/8pWv4PWvfz1e97rX4Ra3uAWe9axnXWG9/GzXbHvRi16EL3/5y7jTne6E5z73uVhfX/+e3nfrW98aD3jAA/bz6Ga7Otu2ljw1zTp1Mge4nsAQSa85Z+1APpDALd5EBEBbcrR5Fn2HLskQBzKiAZsaqLFdsnmgoSs4g5JM2LgCMHUyFt+bJZByeqyjnKYEACa1XFL18qAIKVXzthc1yUpCUtdYiD/XTVTmTNgzms8DphOPuTDZTAcYg1QoWUTGpqglecc+HYiGVzgiDi3B2bd4Pjzn3bxSXkvKPJWA/hVGGoJIZKKqvz9wFHfvysiJr5W8lpM1YedqpX8b4A6fpTqLGRmoSl2vkihrGlEGyZwFUiewDXsa0Ev10HQtKyxnQ/PaxXWz10m3BVn0ZWwyOYQEkC2fAmRjRcdh4jon6WvkaF0Ja+TlZtWjZiwg8b4JzKtpFBNLLq1BsHxWRVouBSsgmsRPYeA6OjOwLwChtkJbhlC70C2Hprv48RizFoRFonyzT1wQbyIISZZwi9vFcj/s3gNxV4aVckxtOJpDmM5LDKQbVKMeiGyMRgsLQILo0WGSM5gky9dQyz2yPh+xB6vs6xQ2nCVzDsX3ZG9+85shIjjhhBNw3HHH4Utf+tI1qrb+qaeeivPOOw93utOd8Gu/9ms4//zzcckll3xfUpfZrjn2ile8AgcddBCe8IQn4Dd/8zfxkpe8BBsbG//P9xxzzDH42Z/9WZx00kn49Kc/jXEcr6LRznZ1sm1NKCbSm85NGQ2oIoE4KtFwHy1A1ImfNhaLvAiNTIzwMMbrtOv67F/0QQSCpbRj2Jc+d6RCQ3wf5R21JxVRVpI9MhLvM9gcry0ELIiwTgWAJXIPfs7hHWfXuQvEIimwcrmCvnqRwU/pGVH8GIwroHboufN5j07YaUG8YzkLDKyBJmVNi07zJkK6tCZeitVB7CIfW+QAASwp5EiUEYkA7kKUPUWCaMa4g0j04rggFZEP0aPP3idplZ8sIrHwbfBrHa8WaYBePD2iUjtmdF1n/z3nUmxCow8GiJNYqM9vEiIflAHtdhat/wL56ynH7WeIELAVWLWn8MLbWAgiDZyyBJmwCMU6yPu9kJfRtepMBMkGbcFW++jOKsBut50CKlmilki6c+/WG+B5Sk6SyIlVH21DawWn+Va/oB0p638gn3dmk0AyG3kXKlCuqMwQdkmawCIpTuSJBOrREmW2pPqugtP0nFdWWuQxdJQ2SfseVMzJiko7hkqu2ZjMJEgw8kjSmJVSJLXHBwzQJczM9j3YQQcdhP/4j//AT/7kT17j6ut/5jOfwW1ucxtceOGFeNGLXoSf+qmfwgMf+EDMTe9mA4A/+IM/wPvf/3588IMf/C+jdESEt7/97Tj22GPx6U9/Gre+9a2volHOdnWzbS15Eoo67N6QLQDcqpzE9emRl1C6/ISUbwQ8pfAuk4MFdrBjmxaGsumf28YQl0Ol9pkZxKH5ZosmKGEQky0MQjYObbILCokDD5m3YdsAUk6Z1CCENWUcoAUHYsDBtLCNFziQFziAF1jnBQZegMsAcIEUxlgYy0JYDr4VwhhyJf/MYEUnn9hzC/lEgJoAd5FbMXLXqyL2ifB6ey6E50qsiWJNffOfF6omsUH0FHEw72RjDQ7stWt4F2Cepjkee3jvJ57qLkFX+wT/toVcqM8/WI+8Ce1yKBRYF9+qRVui4RzgjRSp5e1k/oRLndqcqpdF1VYqVH2DopJiZGDJ8OsIjIVQi8nOAodahaZe7mRyIetJYY0f17ociXU/hyB2636eO0DYAcaOeH0fpdijR4okcU/JUmw2DQCSy3ehi+513etTtEUh6fP+EZFInTk7vWkj9f6zrvzLMQo8d4lMTOT3nZaCGvcKEzZYsUGKDVRsasVSRowyosqIqiNEreJatJiLf/3xnH53VGlqGeyIs4hcIJc9qX8GWeSUfdzcpIP+WZIyNqUm8YywWZU5h+IK2Dvf+U7c7GY3wziO+Md//Ec8//nP3+oh7XOrteLYY4/F29/+dtz73vfGl7/85WtkL47ZrryVUvClL33pcqVMhx12GM4//3zc7GY3wx/8wR/grne961U7wNmuVratCUVKbuw3xyi9Ll0ykZI6UhGyjgYk1d8v6fFG/9gfE80bHMRCfQvSYWSidJ1vIxpB6bFv+RJxrECDlpAZ+Rrg0kAFQg5lgGIB64C8TgU7qGCdCta4YOG5FOzkRkvpgJIRiWhWVwvlPJqns08K78iFdpWGgASD8KhPzKD5wuO6TAtq2v67hOvcul4PaDkl08Z2DSyFHKdVH3KvOHXe/f9im46piw6hAdroSxHduldJTp/Q3Eu4Igck1lXCzEjSRiO51CYPE11+EI7sa9FgauUgboQazQaZJgQu+yTkFvkHHamIxGwnCplwDlgiNhhr3hhv4WUKSkTkPJ+nkYpGiIIktXyLLiuoT5yPR23XJG+y3iJKuBJJm754lUxozrPmFl57tIiMywuZ7L6F3yvS3SubDGyyYpOsqtoS0jqHe/fwIBat03ZLmc/eGnucWHcK+SeaPNXeERTXM2PCCeEEY3KtNXrwUOaldCGi2b4H29jYwDnnnIMnPOEJuOiii/DABz4QL37xi7d6WPvcLrzwQrzsZS/Dn/3Zn+HII4/Eq171KhxzzDFbPazZrgb25S9/GU94whNw8MEHX24eRSkFN7jBDfDbv/3beOMb33iNKrU82xW3bU8oJiDDk2qzek40hesqnZh8oQHVbHwXpCKSulclQAFUQk6QXm+XQvWkIryJK1VpJs3EdBUb+X4o5B/unWTfqFVuInDndTZwuCDGQIQhklaT2Ni+hBnVCcRq12tJOYZLipxERJJnJrH2mnJ/7IFwDwwTDPXz2HmgMwkdLtNCIwbtkjZfdZIMYJqciu4a5tYBpy560aRxHn2a/DNSEW+ileMliYhjo4sAOKmwyNNKBSFtyf9BLJBEooHgnqBNSq6uJP9mFI41qwNZQnw7354osZL3gGjrZXAJk1VzopQ4NfLUKj0N3hwvkvxDpteTngTsfUd2x/NZQQwdgQBac8R47NfMf2GXTxTjQLEetSMTgtbPoluP6KIfXIBiUUgpbAScjVBsMGGDgU1SbEKsU3XfSDLIRBAZtGsWPVJibU7X6p4cqZ0PddGKFjfL+0JbP2zWoI3dZ422+Y8I2Gzfuy2XS7zuda/DP/3TP4GZ8ehHPxp3v/vdceCBB2710Papvfe978Vf//Vf44Mf/CAe/ehH4/73vz9ufvObb/WwZttiu/DCC/Ha174Wm5ubuNWtbrVHQ8QjjjgCP/mTPwkAeMtb3oJPfOITWzDK2a5Otq0JhZl//QaQiUpIUrOaDGkFaXTl7cpkJqmYFlWN6jq5/0kUI6IUyGRwy+4MiRQlkCfuSAX1wHUlCEKNTCj3G3sEZCp9ADhlIFb5xoFtkJeQaoVMy6VatTCWA2eEYlmsTGUvd2qRCaskk6RiDwLUzU0HHFdr3adevMf4ir0Qqi6qQVYxq3mmDUAFgG/VnvooRlQGaoAtV4eTpiytSw2gTeISdjHaM9pFH0KyhhYVyWiKYkJSS0cqzHGuqGiyGCv26xEKB5s22Ckgjo7rUREpy7XmOlWoRyeaxMz+Ni19GxGKggU5AUXJ3IgF+qiPJ/oTY6CCgQsKe/UwX8tJ2lS9e7VVQ2o/t3umrQen5X3Z1Kx21KJk6M5D+/sNIWvs7r/ub7HAtCcTOSZ/1OpyyMZ8J/WwOlIh3f2yMTB2F8LuQthV4BIowRIVS62oMlqkQipUaxIXoKsqF6SiJ7/dyfRlm5MXTW6bnn745wC1KwzqYlFESf5aJBZzlacraU95ylPwspe9DIceeihOO+003PjGN97qIe1zO/300/EzP/MzuPTSS/GSl7wEv/7rv461tbWtHtZsVwPb2NjAM5/5TPz+7/9+RioWiwUe/OAH401vehM2Njbm3JvZAGzzpOyINgDhlW7A39OFkxj0fsH4oi7xCgd9AWYoXq9RM8dN4a/pnl2JZISGXQEQFS9BqfHWfH080z+/Cp4a+nCCAbaKSr2XNV5GyATNxlYY6mjCPNqMCoXCuoFjRDaQs6iJgruST+mIpkgMpsk5Uz/3qwCt+4Axj3Qr51oJGIlQyKonjUxegcsBppKTpIjHhNiju/aqGKAm3yfvx+GLofoYK7WVEHkWIOoq+LSqTs2vbHPYH7uXYQV/jMT8ybVXeJ5L6wROqq06EwGI5oVKLluJdev7EHWyqD7H/cptPTasC7tPexYX8IvVIVJbF7aoPZvHmwPCE6IFY0RwAItyoRiZoIJCA0qSCJu3iLKoeuQlzpHa/DWY3yROkuuHMmoUydaUGfhxB0zvYIFVopJ2+VqVN23J75lDFc+op2175I+4FWGIu9vIhNXDyjwpWO7LUhjLICEetVtWy/kZRLHQClX2qmoR6Yj7wBr1ZSGDuPd7ct2uVq6oeI72eFVHfCc7aQusrz0Xn3bkc1Xm7/wrbX/+53+O0047DWecccZWD2W/2WWXXYbDDjsM73nPe/DYxz4Wd7/73fHf/tt/2+phzbaFVmvF0UcfjTe84Q044YQTcPbZZ+OII47AO9/5TtzlLnfBeeedh5vd7GbYtWvXVg91tquBbesIRUpmVFObb+VJWxJxdF+eyJsikuCAcpVqhOd3Ei1Ij2CPDqOfxESIgJbMTRklMBQ39cSGW7L3wyIAkrbGe+KVgPoNCYqAPUXo8HKc8OO2SIV5Xgkj2xayGYUBz9Xk2G6HDl799yAQmeA6lR6tQBoIKBt3jUyWWMyEjV5SUoDdTNhdgN0F2FXItoGxuzA2PFG29hELbdWhFtLKzWaVI2rJ2nHOIxuhiWjFqrfcqmLtvRFgIx6Yesy7bbUngsKPD8VI6qTOX51JzHvZZPr7pNlf5CgkYY5zbQQ2iR9hkthcqEmZBmIsPBKxYCcSPGDgAYUHcOYCcXaH524RqEt+0kMvkavQyJzFZPpNUL2ggm32/KS/RqMEXVxn+nv0ishHsU29f4R6MzqNXKpWJ7ddzy5KAESyd1d4oRDGgbAcGJuLgt2Lgt25HgmbTFjG2Py+jZySzN2CF37QPsKUl79FKYA9txxrG18r4LASqcjmea36VFyvkO3NduVsHEfs3r0bAPDqV78aP/uzP7vFI9o/tmvXLjztaU/DK1/5SuzYsWOrhzPb1cB27dqF5z73ufj93/99XO9618M73vEOHH/88Tj11FPxiEc8Ajt37pwjFLMB2A+E4jnPeU5XEtK2G97whvl3VcVznvMcHH744TjggANw17veFZ/97Gev1LHsC1fTE5yVe4DsQN08xatf0N0+fD8T+BikokvADiBPmcswlcf0nuRokNeSrZu0KLy3vbUmeAGQuiRP98w2ItF5pzMy0EcM/JECIFllnMjziMpU1SVPJpnpem50tCDlWDnyDpRoeNb3rJAUku/wTIfkaCTCkghLNjC26aRig41MxOMuDjLRHjcKYdN17TWGh05uhEYcezCv5F2ICRjJk5m5JxFBOoJkrDaMm/a3iChLPtc9n5ekIxXxt5HaFuC4yWLaWg4y0Z5v1zeq90ReS0plaEWO168yokYqENGfJmlKUkFs8ia2HJzYTLqXwqAuGmNrQB3Ei0pWpIpzFljEaIRiVLFHKEZ1YhFgnJBEoYsvtLkPEqE6+TkiEtIRm5A4ZRWtTrLY1vGekiJzBnDeK+1+4Vb5qTCWpWCzMDaZjVA4WayI6M20ulyLmgaJ9PsdK7YSuehG1ZwVaJ8BjVCsOBu6+7TliPREcOvsqvx+2Ne2c+dO/PVf/zVuc5vb4CEPeQjue9/7bvWQ9ot99KMfxWc/+1kccMABeMQjHjF3054Nn/jEJ/Dv//7vKKXg3ve+Nz72sY/h7//+7/He9753q4c229XI9ovk6Ud/9Edx2mmn5e+llPz5hS98IV760pfida97HY455hj83u/9Hu55z3vii1/8Ig455JArdJwgC/H1Gd7aFvi335psZ9q2Lc3ZtUmHIum6++Lu4g/af8HvxavYvuwp953Vo9CBvPCUEgx8gNtfRafVqlrHBXtrnMDqyVCKrbwRV+R0UJeg7YCGBKIGrPsyq0x9lXzqxo0OrMRMOJFDOy4cuMLnXLt9V5eCbFqGhP1NFaLA2EV6ohRskCEm0/UvFBiqYkFWcYkkrnfkUFB7bzduQWuKRuxA3D3kffZMNshzWRnDPeg+pqrdZUUAZXhGxJRU5LXy/Y/+PgGyMSGhFQro5XUc++nwX0aMyMav3PqqEBq5IT8nIfRXJeeJyK+ce7Wtr4JHNlSTaBR0kQnt5lTb1W9Jzh6V8KhY9I2IKEn0AiF4pAV2/qwAU0iifB7yN/I9W32FvAsIE7mTeLJ1Jkar+GLt6YJ/InS1gzV/j1PS9rpwBrACKrmGahwfETEUoFoJ3b5cruYqoHaPhmSRQhTWg3tq/++FVDRyjxx/TjA18iCxTqjtsZclMvXH3Dq7qr4f9rVddNFFeMQjHoGPfvSjeMADHoAf+ZEfwUc/+lF8+9vfvsZ5aHfv3g1Vxetf/3rc8Y53xCc/+clZ1vIDbpubm/jWt74FAHjWs56F008/fYtHNNvVzfYLoRiGYeJ1ClNVvOxlL8Mzn/lMPPjBDwYAnHLKKTjssMPw13/913jiE594hY7TEwr0X6LApBkL+Vd8fI0bwWja63hNgOOoyqOdhodCEuEgZEommgc4QHAC1Q4E5JeOe/WhDZCbfKTNU6vvr176Ns5Pk0zscXynO11QBMyMwkBhwlDMC68QVK1QtfL0VcxjPHjzrDiWzUPgsD3gTRfM0WnzG2rnLWzjGqk1gItoTRVgqa2ZnU035fvVtUvEJtlYF8JaVaxXxY6lYjHaWPvv8sBbvQc6qzx14zOiZSVrk1CQAUdSIxWkwABFaS2qUdEBeEyjDq0XynQ8ERlJ/se2CMPbvnCg3VMAcqKYlZCALneHjBQFgiy5gifEKWRHGmstT5+M0CgBVMBMmQ9hFcRKVoXao2IQyOmgjYn9PkCcu9+P6iegEULxtZUlj1UtCVyAwj4p5NczyJdSiwKpJq1WTAlFyJ1ULCF6el9ELoMlXUs6CWJfcdN5xJE9z4Q7uVmueuqiVgQhhpA1+EONBHWAkmD4RWSFiuUztYpN0+Bwu7L9b/lEfm5N8iWI2tqP9ZIrAdknMObi6hChAK6674f9ZXe4wx3wvOc9D09/+tNxwQUX4EY3uhEuvPDCrR7WPrVTTjkFp512Gs4991x8+MMfxrOf/Wz87u/+7lYPa7YttHe96124wQ1uAAAQmSs8zLan7ZccijPOOAOHH344bnKTm+Dnfu7n8JWvfAUA8NWvfhXnn38+7nWve+Vr19fXcZe73AUf/vCHL3d/GxsbuPjiiycbgEkFkwCjIVsAlclGkf/Qu68DfPn/fZnFAEPCLsfgkEAhAfEEuffyptx9JxDq5SsaZWy9ik+toDoCUoE6umSjTkpxIvIqVLvIRZCg6fn3YCpKhg5R2YesT8WCBjAPIO9TIcyWtO2gK6vvoM0RuvnpZTgNwHVkg1q+SFQhEs/ZWHJInuCyJ2DDt92s2MXAzkFx6aC4ZAF8dw347rptF68BlyyAyzzPYoOt0dtIraFdRlzQHjV+DoDPaE3iVrbRS+suGVgSYZOAJQGb7I/+e2wmYYrjtOvfR3eCfCwJ2KB2vlaKtJdBIec89PBChFr8+jC3SlW5tFrOxGquTfPTm7+fYvNoUN9fwx6dRPnG+fNKyV5Q9qXoE+aVLBI1kmKTFRsk2EUVO6liJyp2YsROjNitIzZ1xKgVNSsxheyvkf3J73v5W2v8JytRiiDXrdpaVGNLSVjIxDqmaRIhdiJuW0iGInohTE0CNRTsHgo2Bsvx2Sh+PWESL9Gu+lPmmHRlZqfUNz83Vk0RnzdoFeH6zx/EZ9KUSK8S66uD7evvB+DyvyP2h6kqXv7yl+PhD384mLd1GuL/077xjW/g+OOPx1lnnYVf/uVfxt/+7d9u9ZBm22KLPLXZZtub7fNPw9vf/vb4y7/8S7z73e/Gq1/9apx//vn4iZ/4CXzrW9/C+eefD8C6K/YW3RYvz57//OfjWte6Vm5HHnkkgL2QgKkLugP5zUO5Cn+J+t+5SQSCVEBNHkSRHO1eV8IKqfDjogE4A/yC1WTbLCWZXZI9adSTSFtkornPdUIqGpmIKEcenZDAJz3CLmNZQ8FCB6xhwAIFA6yKj3UJLlAqHRDtfKV7REQCeiG19e3sO8FZAJx+Q4sYZGdrmJykefvV6v2zYjeLkYxBsasodg3ArqLYXRQbZH0BlqRJKPpO2X1zvQDqFS1isCQnEIwuST2Sti1xe+RGPuI9k1wIavvM44L2gIk2hsjj8DwSoglBibyMBgAjf8eIxFgYI3Pmf8R8hunqnE/+lgvJSaig9WSxill9GeVYp9FBvK9cFUm+lo8RkQzO6JwQMLJiyYJNMlKxmwS7qWI3VWxQtQZxWjFGp+mUBsY6j7Ufv6Mle+vKyfrJt/Ol/AyYdLpfcSZMPjLy6SjJ3IhEVBzj7t4KAm7lly1Be2MgbHojPFuTli8SvSp6wpM9K7otnA15Bt1wG0F3MrFyqnHzJ7HcY/2txs62xvbH9wNw+d8R+8u+/vWv43Of+xyICE9+8pPxoz/6o/v1eFth4zji3//93/HKV74SZ511Fn7qp34KT3va03DQQQdt9dBmm222q6Htc8lTn6h2y1veEne84x1x05veFKeccgrucIc7AMBUHgMDCqvP9faMZzwDJ598cv5+8cUX48gjj0y9fdP6NyDRe+78IGjFPruvWhUjG4haRB2ZUMl9NwlKlG5dAX5x+JRQtGRMFv9KnwCiDkyITt4KdDvv9hfRidxPR2QapNc8ZXJ9fIHJikIMUpRRlFBBDiwrQiplu3BBjx+fCJPyqjHMDsd0cRG47GJyhf1/TQ18RAxIm4wI+SrLTRghFjFhsXKfcGLFisIAs5pUyo8wAfnUkqsDXEf52BwRNxKUJAcm47FzUCzVytsSuve5ZQlcdEnaQEZ3rOJSO3bm8ZCRFwJBO6alCsst8DlVap3YpURidEz4tBrVnrNuayM8+pFAnUTXD8jovPQaf7OywnHdGSb1m1Qyg0dPVFGIUclyQyrDSZknX5N1lRbPK4ioCGt1YmJefNUCVc8eCblUJIj0pXD9Gqra4Nq67zOngkxQJle3xOU9PfXx2RF7sWaUahWxpBGv7tPEIzEEVcYmYI6G6lfBo4YiisFzRkzS5nlSYqVl82QaPbef81LGjdy/1i5T+7z0G2qP1dnoQ+xOJn/fGtsf3w/A5X9H7E/b3NzEl7/8Zfz2b/82LrvsMlx00UU477zz9usxt8Je/OIXY7lc4td//dfxohe9CB/84Afxuc99br9GgWZrtmPHDhxxxBEAgPPPPx+XXXbZFo9ottn2bvs9XnvQQQfhlre8Jc4444zUza56my644II9vFK9ra+v49BDD51sQKRKezsnDelFwJ4oo9h3nC5eQtU88sQMKvZzPAcq9vWunvTrcgXRCvsnEI9YZMds9CBFs7EeS0UZK4ZaMVTBIGIlP8PbK61qjx1LpxGKcLuGxCPKY6qNyRBMl7CdIIRaRR9lDFqw0IJ1GXCALHCgLHCgrOFAWcMOXWAda1ijBQotUNL37LOpTT/f5GWUnuqs/EOUHtVeFtXkaJ0HNr3P6J5Dq4ijXZlNl3+JVFStWEKw6dsGqW/oohVREraTQAEp4+ojIVFlyqRXLmmKkrbFfy7967xMqMugNl2utOQW7ciffRxjf3w4CWDGyAXLYttGN47wbKdsayKvsdKlmwvzjI/cSbp6juzrsJEHn39EKdNpqdoigqICVgFLBcloWx1BUgGpiOaQkWDN8O7h3gCvcAH7/WWyNsVGEWxwxW4W7GJpj1SxQYKlRylqyJWk3zQjE4i8iCxrnC3cEC3cOKRNcV9zgXLJEqqrREK7e6Zh1VZaNyVPxTrQF0JKwJDXxZpDbg6E3QNj54JxmW87B8LOYtG0DdKViExF7WVQWrvIY1eEQVtUoZcvtZssrjOCP2IictNpRSzpk42uJrYvvh+Ay/+O2J/2hS98AT/8wz+Mb33rW3jhC1+IU045Zb8fc6vsj/7oj5IMfuQjH8HDHvawLR7RD47d9ra3xZlnnokzzzxzIgecbbarm+13QrGxsYHPf/7zuNGNboSb3OQmuOENb4hTTz01/765uYn3v//9+Imf+IkrsXdKUNtBWyMVIdtJz6SRCjh5QClAGQAegJ5URCdqhSW9Sgdq1QpdRtfjvsRlr++GeqfuOqL4NtSKkqQCrfu0b5OIReZJeGQD7uXWHhyETMQswVICp5gJk6QEodhRBxxQBxwogxELXeAAXWAdC6xhgYEWGGiwKj/KIOUVMoFpszdCes4JlASBBK2PQvQF6X9e6RVSvFHYIIq1atv66NtSsLasGJYVZRxB1a7FqIJlyKNIDdzDtqi+VAPEU4seTCRPHRGIvhwje3nbjmhYfkfbNpiwQR3RKFb+djfTHq+L3hkS668MwDBAhgF1GDAOg0llPCdkk50YMdLjXwt52VLK8qUmfXLQmdKgDohqX6p0msOTkqa8LkEmjFBARkCWEFlCZYTICJUxo1fhT48O7dlFOxLuSVAhWJJgybZtsl2vpUuBrNSqVc+yPhMyKQGbkiBf4LGek0TAun8zGZlh75tBPPh9bn0ZIt/EeOsqyYrbZhqhKF5Cd2DGwITCRirYfRVGKpCkYmMg7B4Iu5xQXBrkYmAjFp5PEsSiinfYVs+Z0rEjGGLOgqkAzsZLsApu6MnDdIvzlPjM6IjF1c327/fD/jdVxW1ve1u8+c1vxp3vfGd88YtfvMb2b/jSl76Eo48+GhdeeCFe8IIX4G/+5m+2ekjXeHvuc5+LN7/5zVs9jNlm+55snxOKpz3taXj/+9+Pr371q/joRz+Khz70obj44ovx6Ec/GkSEpz71qXje856Hf/iHf8BnPvMZPOYxj8GBBx6In//5n7/Cx6J+65ImgRR1ZPQgOuVqNpqLaEWUU3WtdQALheU3VLVyRF2kQlqsIptZTRJGs5GWALWCqoCqgL25liVkd05GUMqLVnXVveu5/UOSJaAJHXTlZ4RURT1SIYQ1ZawJY10K1rVgTQfLrcCAhROJ4um2tpF3dY6IQ6+rb2KryXXJaIPPoTYy0fqFOJFQ0/AvxLY1AdZEsaMCO0bNbX0pWIyCYRRwtf4CrWHaXvIaqJM7kc9eRJX85z6Po+8loeiJB2UkYo9thXBsxM+FJr8vmVA9QqalNFJRCmQoqINHINga920SZV5IRFssstES2yWiE9RWxxRYrlyP7l6ZRpx0QjAowGysdR1RY/N/UdK4AfAA+o1QBrnRPdatrctJ3CSiN0DXmC8qRPk5UETBgrhE3kY03TNiQXlf75mY3hOvnKPVuYn4nOdPRC+OwgRmCvXUHqRi9FyKzWLRil0DY+fgkYqBsLsY0bRohWKJapI+9Ypr3edLFmWIJO7oqdERw34mp58PyNUweYxozxbbVfn9cFXZueeei1e96lV43eteh//v//v//kt51na15XKJ//zP/8Qzn/lMfOlLX8JP/uRP4sUvfjHW1ta2emjXSHv2s5+NE044Abt378bJJ5+MjY0NPO5xj8NjH/vYrR7abLPt1fZ5DsW5556Lhz/84fjmN7+JH/qhH8Id7nAHnH766TjqqKMAAL/xG7+BXbt24UlPehK+/e1v4/a3vz3e8573XKka4713McAJ9X5HasQCSSrid4XJogQI7XaYBMx38A91rbpOyo9mzRxtvIwn0QpxgOZj1E4WhOQQ7lFG27GJpCfn2vkoDSaEvKnPF6F4bf7gcvROX67Ic2FtADqhCYmDcAfffm6EiJh0cDVOInbd/dw3vGOP9jSZTTSjM1IxiGIRz/voRRWDEkQVo5inHrE/sQiIp58A1CVHY9oTIrtGd/PYT/60aV/7k+VbEEYyr7A64Shol0bRdeBOAqJONqhL+m5E1iprDQCZgAZqIBogKFVvsqzZU4ISiGvnT2/z3P8Y829LqoHJ9Mh3JHYqP7OJpC7hv5FxhsI89qqWvG0HZJ9Ljw5S9JqA9wfxurbar7A4dos0RESwVaZqJ+VLFy3PoM/isKiT5ZvYWMiJY17elhQ0vf45Wd39Qf2nR0Qp1KIg7JWtSM3v4OPLKmYAVCNnh3PuoppYZUUdFQN5J3dRz2kSy5uJ+EjmCrRS0vmzcCtNDSdX2p1V97NOntL+Ft1yuyq/H65Ke8973gNVxeMe9zgcf/zx+PSnP43vfve7Wz2s/WKvfvWrcf3rXx8nnXQSfvVXfxVvf/vb8alPfQrf+c53tnpo1whbX1/HrW99azzpSU/Crl27cOqpp+KP//iP8YAHPAB3utOdcPDBB+NTn/oUPv7xj2/1UGebbWKk27Ajz8UXX4xrXetaePV/uw8O5AWAVg1HiL0TNKWHuq+Q0lfHqdQaYkVugtQxvYRVqyWVsqYURti9oSgYtGBN7TEzD1TBUsEiltBZJXrJIdK+p0IGbVEO90AaOHIw5GOVvtyko2iK6jVe+SckMpLJvAbYohZ/D6+ipo5A276rQLNs7ehSlyWgFdp8yHYRfGdZSclRViymzJmAonhUJsjEUBULj0QsBFgXxbqi5ZZAPUnaJUgO2u3INpnZJRohaQppUcuXSO9997hqGsgVLdrS54AE6Ymxl7hwcV0856KXUW2SZinbkQjCBVSGlOUUHqy6VhxRFKgVqDWjWAVAietX2CV6jTiSRoUzz/fp/kWOw0JgScGetzP4miSJ49g6h8v51L3l4inU6oSLPEehoHjTuwHs1ZOEGCMDmyTYJMFuGnEpbWInjdigEZueK2EtMyxStq4DDtI1HEALrNOAdRqwcLkhexTCyEY2ImmPHYG2yEZEqiQ7VWf8oSP/cbXbum0d4oUpyxvXAoxFsCxWpWqDRuyWJTZEsCGC3aLYCWDT82NGMnmdxrpUBVeb50EEpQoWtWKtCobayfqcVAwKDEpYKFAmuSGUc0ye05GNBuOa5L3WPlD61KsWjbG1vCkj/uicD+C73/3uNb77cXxHXJV2j3vcA//8z/+MUgrud7/74d3vfvc1usTmXe96V5x22mkopeCBD3wg3vGOd1yjz/eqspvd7GY444wzUGvFr/zKr+BP/uRP8m9/93d/hwc/+MG47LLLcN3rXhfjOG7hSGe7ptqV/Y7YL43trirr65hQB2abkf81fm7uz15Okd/I0r6VQ7qkMNmBuMxkHCyqwagQFEAHJyTcldM07KdEKMwtHQJIXfNEBhJ68RgrUfOcU+f5D5REDn57UJ/gHq2+Pnp0IQ0wx4yQxTuYzMNqHuIy2Sf5PGVybFTciYR0imZq8DmlVpSHkNWhMlVerTzpQg1QratihxqpGBywx7UUMn39koBNmVZSgnaVk6jJnOw15qfOOdDwRHdrh7q50PZzlsn1l0d35PReU7sUSn3ORRAfNbAJTPImCg+es9Np/OGNyaitZCECSFBVPU/FOjEX6TzTmbPiHSCcfMY5iTebE187SnFOjTAF2CRpfRuCsIqD8+iLAWKwmsdeACyIMncm1kqWKXaQvOZnFF3BFbaPAQXrWOBArDmRGDBw8eIIHWGILB2NWm5BsCl/brEKOAkRROmuPj7T1jxNn9PWw0X9uqsAzGQND5VRqWBgyejXAMEA9UR7WBd68qifz2tlU0mOYpd5UxQbFUkmhipYq06oKzCIYE3sw7gogbV6r4+OQEjL8bJNm9MhPii633KdZ9Rltv1t73vf+3DEEUfgrLPOwt/+7d/iDW94A37pl35pq4e13+yDH/wgbnSjG+Gss87CG97wBrzpTW/CL/zCL2z1sK4xdqtb3Qpnnnnm5LlHP/rReNvb3oZXvvKVWzSq2Wa7fNvvSdn70wx0aoJfAEBPFNJWyUbnyuuBPRrgj+RQS560BMpRRox1iaUssdQlNnWJTW/QtfQk4VEDjFkibiWrVy9d/wAJ0Bv5Fl0CdsKdiKyA9u5hj4TtlSZZmSAej5NNJltWW8pZ6nXq7k0n3/yf5WMALOSe+wbMctzoql/1V0GtQlSBEYdBrZztmijWBVgXYE1tC+9tEXKQFUDYLnZUTIoeFn0Du9y64JuuDKaHYQSvXKSeU4DWMDAIUyUvh0pISVPfmG+z+JaRIosQmYfZq4rtReOfZU0LQ4utE/HmdQnqxdYJVQXHFnMf55IkkKDc8kcyIhfXY+K9nq6HiFpVKEYIRgiWvqZHiEcBohhBtyaTnBnFGZSwJtbZfEclHDAyDqqMg2TAQbrAQVjgAF5gnRdY8AAugxGKwTYMAzBE4YSeZMRV05UtCDblPYMVGB1ywQmyjvnTdu2LRwqKtMpxLUk7elJEgrZTdGolapWjb4jnVQyEjYGxe8HYtSDsXBB2rjF2rkVFKGoVoUixiwS7IdiAYFMrRhlR6wipS4se1hGoVpgA1RtjRpNM1VwPSbY658NMKvavjeOICy+8EI985CPx5S9/Gfe5z33w53/+59fYnIpxHPGtb30Lj3zkI/GlL30J97znPfGa17zmGnu+V4WdeOKJ+OM//mMAFmXb3Nyc/H3nzp247LLLcMABB+Bv/uZvcMwxx2zFMGebba+2rQlFyFoSoCeZmMDY7ufw2LcEx/Dgh0dc3CsrUFS1plSjCkYRjFqdOIxYyohNaWQikyz9/dYHoetu7F2om5fdKUBImPowRnr8A7B1zyUJWgGD2p1Xd26dsGny2vhLEI/mAO7KZno50EK+RWfkDuCvVq/cK2oHJkAnvNixLYJAoCMSiLK0zfeapC+vO3WPXaO3/gut40xTGNrGaaAyiEQD6m2dNVJhze5or122owFeJQeWXgiAvFM7ReI/WynjzPDtngdzvtciDH59HDxydQmTtBK+0VCuL48akZvQ+Et/3rpCPNHJhrJsbXus8ffVRGtqcxuREyMUjIU4qaiMA4RxgBQcqAUH6oADsMCaRyes3GxXvrmU/Jk6yd70CvqdsIfvoCcd8apW7a0nG/mO7nqzR3Yo5xYZKYhKVoVatScOUtHnMUXfkKzMRRgHKy27OTA2Fk4uBuo2YFdBVoPa7RWhlqhZarZKdTJRodUkiRBvhKlGKiya5VEXn44Z2l31tnPnTtRacdRRR+HEE0/c6uHsVxMR/MM//APe+ta34pvf/CZOPPHEmVBcSbvLXe6CBz/4wbjzne+Mf/zHf8SuXbv2+rrzzjsPp556Kh7ykIfgxBNPxHHHHXcVj3S22fZu21ryVNkAT36BZqzBfu50Qu2pFXjZ/wsykSUvu828tYqlAioGAEscTZv8pokwgCxZ693csiEdxPQTPgbSqe7Ukq67yISHJnLkQR7Ugat4AjU5iuRgHyYBibRMWQH9rSkamrc2vZrR+Vib99vgvI9aUqLdk4UEmDbQyXkFmShqiaiDmsxpgG8dkNduDqfN4rqE6/DAIwDzavdoT2lWTJ7Xtus8byAIUqwbuHQmPPGUIDqObc3NjExU7iVXtiIj6ZijP4KTCiVyztMB5ahH6gtKVaHVcgQ45En+MlYGOwpOuVm3uz56EMndQWJZLc8g9qnqkQcSjLCSrksoqnqCu7ZE+Vzvqxe1y+soYAxgQIvLhuy6WO6I9ToZaIGBF626Wpe0HrInUgYJdQsr7rXuHo97i3LaujnoixfY75Q/txcm9PGngkioRr8VT8hG9N3wR9j8hCBLiPyIvkf26KLa/UdMqAqQEFjUE7YtT2MgxiYECygWZPfCuvpa888MVs0KWEQM1eJKMM2oIil3J4SUG+bKn3HefrVSCq597WvjLW95S5aOJSIcfPDBuOyyy67R+QW/+7u/izPPPBOvfOUrcfDBB+PSSy+9Rp/vvraDDjoIr3jFK3Dsscfic5/7HE444YTLfe3pp5+Ohz3sYTj77LPx/Oc/H0ceeSR+5Vd+5Soc7Wyz7d22NaHYLIoFt4RZ0/s7iFbtv1EdVHZRCQpw6F5Yl3UsyQrCjiTY5IpNFYyoGKN+vhMCUgaRaasVhAUck3hCqbo0QsENyGcgIvIMWt2mpvFmtDhEA4rae2kziRtQCU+4vZ+8AzMzQzyZIfMJem6lgHKjAvE/U4sMMGtgOQNvjCRFlqIdkQ8Dr9ZVObCZzb0lqaNr4hdAzROPXUJVVBH1pBTm5Y/8hKWXXl1CW4SHgsRFvoWTCc1Z6ohAV0LWSQGArEykTnJsyTjQJGrvp4goUQLzSdSiT4YnAGrdP6y06YDiEQowpze7ry4VJA7EQAlwrF1zN2Oslu+iXn3II3KkEOOfXZWtds7R691KHNtGLukjWDWpEUgp14b/Xv3WIYmkb18faFGRSPP33tpJ2gYI2NeFJ2FYvwgUFBq80lVJIiFdXkQ7ygrgDwdAn2uERthbYQBM3jep+JZz3t1LnVzLPxaMUIhVdbKIRGyMgSRJcIXNVT9y8s8VqN37RgH8M0DtBiHPsyieX1LIKkAtyCueRR+SqliHQgSACtjxmZJgUI9Ypawuktbt7t1b1sRe6OBs+9Duete74l3vehcWi0U+d93rXhff+ta3cLvb3Q6f+MQntm5wV5Fd+9rXxje/+U3c8Y53nKsQfY92/etfH1/72tewWCzwwhe+EL/1W7/1X77nkksuwQ1ucAP8y7/8y1Uwwtlm+95sW0uelgVYFrWOwdziEy0ZuZM2qfWGQFQ0EoFI61o7asUIky5tUGyCDRZssFqzMbi2XNWiFlqx1BGbGLEke+/Svb0VXbdjmvY76BOILdlTvfSkn4Oik5Z0+RbovfDUXue5GNZQrm8Y1xqXtd4AnexJG8SI/ImoJBMAqhBj8MpEQ3TTpsFlUNFejFqzuyAH3qwuO4E7WJsQvA6EZj4EISVFm8U7UxcjFWMJuRFZPor3ZLCfnVRwVO1pVXyqv35keIdpqwhl3awbMOxzMPqIR3SsljgON2lRf30jQtXmsKB4VTDqyESrHUzTjckAYUigqAHD7E8i00fqt1zr3V1A0/sicG1W0fL5WVJr5Lfhcx7lbomjyhOjaBZ87f717eY8xyA8+8pZyWjInARaSShGgnkIQNXKAlNeEG2J5BGf6tbxpMFk9/nQEraDMgdBjI0tSkdddTJFHpsmBLhFKiyPokUnMmW85yv5R3IZlOfIFFtHI1uTwk3vXbHh/Sti2zUQdhXf2PuaeA+LURWjtPwuqSOkWlU2jUcdga4Dd+vEPdv+sGc84xn4wz/8Q6gq7nWve+Eud7kLnve85wEAFosF/uIv/uIanaANAKeddhp+5md+BqUUvPrVr8aTn/zkrR7StrHFYoHHP/7x+NM//dPvuXLTcrmEiODBD34w/v7v/34/j3C22f5r29YRimUxT555Uu255ul3+YF2CDZAhyqErCldJXGduGCJ0beKkSqWbOTBKva0JmpBUsT7WFiKcAURoVBFoa4qDbwykJOFlKk4AM18U1dnBHBKYoGGwXuftmlMViZEQ2rkx4v3axCTNhMesnEgROnZbFjIogjm+fSBcQHp4BEa87QmiFOdlHVFRyKyxGsXPRDyaqmwvIQCdaWWkYpNB7mR6LzkKM/ZektE9KBFIjp/tk6rQAmp57U0Ty1pkzEVv0Yxu5rvpWl0o19NBK+otRJtCFKBVuoT5HkTtFJiNy5jJvgiyQUxA9JFq1z2whG1iChGDFi6ZRf3gK6QCZ8rKHuUrnjExdc4a5KpKMvL0pGFLG0anRK6akuqYLWIAeX70UnJWuSqtwwsqlqU0eVDpL5ItCNUbfXmtczzyonws89bhCbJ403+1q5c36cFBCdpZKSCp83uinoePbwKV0x5HCLmP5cFpV8DsKmHWjUuOy2CloiIBZllnzP137xfRRIrABArYxznLXHjUyOjSZZoJhT7yU466SSccMIJuM51roNXvepVeN/73oflconNzU0cccQRePSjH43b3va2eNCDHoTvfOc7eOMb37jVQ94vduGFF+K9730vXvWqV6W+/6KLLpo7av8/7JhjjsEDHvAAEBE+/vGP46yzzrpC73/b296GBzzgAbj73e+OJz7xiXjjG994je1/MtvV37Y1odgswJoj6EyobNAAwBSMtVwJk36kdjwSIDtCYREHwbIjEqKRQRC4QzCCANRkBkzVKsR3CaB9km8P7gLoMFFXkci8zZYX0YEfbUCpsZCecFConhp4F+Q+Akpkm7FwkiPKkHp1JwShMIAfz0csi1UgOvh7g/i05mWIsQaZCDlaTyZgkqnRJSVLVpPW+LgqkXecblWUlkwuL2sAflLFKEBj5JtoO+8gE9WJRbyfVMHSog1xkWIcLToRAJZaFClXV7uwMZfRYzw6OBNzB+4orzv5SSg6UknkovyC0N+oBAF2udUkGiE2QGhWGrL9rFwSxByRJ4QjuV8jaJ6L04FyjkhVljFt0YkkpNqc8hpJwR2ZRTyfXvJo+EgTEmS5ANmKsht4IyMx/+ErEIoiCnnp0/p7rieJmq9t7oeMoCWxJKuexLgcUhEg33undPdYrJ09RhK6NFFYA0kCsRMKdXkUUWYpQSXXuFOM5A0a86ImajOy54Qs1hrZQELqNROKfWeHHHIIDj74YBARXvrSl2IYBvzzP//zRMt++umn44wzzsBJJ50EIsK97nUvHHPMMXj/+9+Pb3zjG9fIHIOdO3fil3/5l3H00UfjTne6E4499li8733vwwUXXIBa61YP72pl173udXHf+94XL3zhC3HeeeddqZ4SL3zhC3HhhRfiBS94Af70T/8U733ve2dCMduW2fYmFIP1KAC56lpCfe2grQOxCktwrLDmXSMEmxixmcShWiMuly2NnkcxOoCLKlINUEYKpqBSTQlTyCkqYHkVCgxtRIjk0r56kwSY8vMyzbwkKEhC4SJ5Ipj+PM8OyMTY+CcGbjMHwMcET2KPxGFQeNRdioJQYBOIBSwMYgOtBn4iaZVsiIjqSAzrX9A5kleIhM2WdZPeYPPQCimqEjbZgBk8IrDB1JVktQhFeM7DpmVRmyc2gHJ4sS3K0HoH9EErbkPN56LMpjqZ2KNBnuYLobkfJ48gDNQIRWjbhd2PTbkSEMPNH6whiPUcKGgD9ZyHES79cRJHEjBezJvuOS5BOHtqDZeDqRaPcrCvRc7O1ZYo35KwGYQ1sm1BjAWsghP310B9DUQ+kEx7W0yibUKgSmBPULdxRRUny0mKfhJEHFOcCyqvG9r1yKps1F1DBN9uUYLukrfr6c+yv96aBLbLQmrlkdlzKASelE2RmC3WOwJdlKK7r/sLTE4mFNSxLQP5ykEm2MlvSCIZ1ZskVlKo97dYFycVguxXUmA5Plk6Nj5gOh2W6gzo9pU94xnPwDOe8Yz8/TGPeQxOOeWU//J9Rx99NL7+9a/jqKOOwtlnn70/h7ildt/73he/9mu/hpe+9KX4+te/jpvc5CZX2Pt+Tbc3vvGNuOc974lvfvObOOKIIzqn4hWz1772tTj11FNxzjnn7OMRzjbbFbNtnUMhDIzFu1hHiUavAV9TQx+gw8jE6GUYo3/EhiyxobZZCdjRugWrdLkLDboHeA3d/JIVSxJseJfgnTxiFy2xm0ZseLSj9h2uU/MeZ0EJYNtBtG0inUuygV9N7X3T25PLlqx+viU8m3bdKu8U73bMK/kPUfIzdfzs4wmSEmSDGIU5S8kOPGBB1j15oGjq151PzpVdjyi1usmEDSbsLsDOQrisAJcWwqUD4dICXMaE3Qxs+Guj43TkQkSN/35bennOsQDjAHv0LfIssg9I5FlkHkZX4pN9H5GfgS63os9NQIDUlkVg+QLROd3jFNmpfJo3EP/3JU3zGrrcyUqnFmgZoFxQmbOBXlXv8i5iJWWrdWUvVW3rOpPboULHb/uTMkAGa7Bn/UYK1lBwgA44SEtuB2rBDhSsefUmjm7VidQjSiKAVFBuEYVoneijn0sNzb/3UkC1XB/y/AkLxbS8HyCiIN08UiRid7K3iB0luehpRJdn4c372ueCX2fSdq3jbeIRtsyn8FySJBWKAYqi4kSsOxa1z4u4V2nlvtUoE7xSZtb6VxB2eYnZnQvCZQvCpf6403MsNopH8Mi2ER5RVYFohXjH+8ivmO37t3e+8534xV/8RXzxi1/ELW5xC9ziFrfAW9/61r2+9jvf+Q5+5Ed+BJ///Oev2kFeDeyUU07BPe95TwCWX/HYxz52i0d09bD19XV84hOfwB3veEe89a1vxR3veMcrTSZW7V3vehd+8Rd/cZ/sayvs6U9/Oj7/+c/j05/+NA455JCtHs5sV9C2NaGIL+zKQC1GKmpBJuxOEqI9MlG9l8QyGtKF1CnqvTv40QBJWAHymCZZV4ovc0/gpooNtqTuTbJE7wrL1+jJhEmBNL3BvUKCugPu0aePMH3HypszD0K7XIgAvNR6SjCVJBITQrPHINrvlOSCPdk4ko97b3yLGCRY9ypI0cNhyZYbYaRimny628nEpidNZylWms67ELp9t2P0ZDIIRDxOwB3QAGkSDXTrp0+0bnORQYNOvuSpukbUnETEFrGpAOHmxY7nbGK1f82EWLRNi1UOqx5pqh45i/4lJOrJzAoW8a016IMfN5PLS1eq1RPIFyhYV8YOLbmtw54fnIRSt+AiHylIRZAIiuNqB7CTVIsDXCcTUUzAQXuu+SDRkQiUBNfBOFr0rh0l7o/uM2KFSEQDv9aLpYtyxL0d19nHYmTCE7PzalveTUQHLJfCSEW7f7oxd0Qo75PWzAJSfB2WjlgUwrKY9M/uE2B3sZ4Vu0pIApFV0Ma4X6Au7YummQJo3aM89WxXzA499FD8zu/8TlZs+sM//EN84QtfwBe+8IXLlZnUWvGFL3wBL3vZy3Dqqafm8yeffDLucIc7XFVD3xK76KKL8LGPfQzPfvazcb3rXQ8Pf/jD8cQnPnGrh7WldtOb3hTPetazcNxxx+Etb3kLXve61+3RDfvK2He/+108+9nPxrWudS1c73rX2wcjvert137t13DiiSfi5je/OW5xi1uglLLVQ5rtCtq2ljwZuHcgCJcCCaUsB9I8ywIr/7rU0aozeb6Egf7WCVgQjd/sCCkbcUCj1IMP0+Urqzv3DX0wVUTxy8FlJEU5i9SQNMlD6M+pHSKlHs0D3kBTjgWRC9AnlsY2/af5yJYQ2r04lREdo5h44KnPWvDxWeF9MBNUItKhjtNNRlND2tXhwjxX7Wv4q0dSWq4FIUq1RplWL4MKNI80tWpLEkShmx9dOY8+y8OUY9PzlU77NJnHcFWvym0Q5MR7TThJYwRZY5ecrXj0V6kjtYuR8vd8ips8hgXii5rESsWyzzGpS4XU6EmeG2mHZ1tp1S6n18cekQCv0aQh4WkAOi57L9lKqi0uAIxSphmZaCSMYJXIFBVaGUqxAuxOoVgYndll6u+E+N3HMblx2nXvpzmjighy4VyFQvYXbMUlQ3FX9fvydRmkouWVeNlXaFY4a/fzJBPExtvf111EUMGe8yO5WCnG6huce6A2osv+fKjLkpQBmdCda0IBklnydGXtute9Lm5961vjWc96Fs4880y86U1vwqtf/erv+f2vetWrcO1rXzs99k95ylOwa9cunH/++ddoKdB3vvMdPPe5z8Wd7nQnHH/88bjRjW6ED3zgA/jCF75wjcwh+a/spje9KZ7xjGfgC1/4Av7kT/4Ep59++j7Z7yWXXILnPve5eMQjHoHDDjsMN73pTfHlL395n+z7qrKnPOUpWF9fx1e+8hUcffTRuPnNb47Pfe5zuPjii7d6aLN9j7atIxSARyhS7uJylULetVgtD4KMQGzqEpu6iQ3dNJkTLbGJankT3swuyqlaCVZ0Xla0qj8Tz7t5BpcMbJJigwW7qfo2YpOWGDGi6mgaZu8DUKRt2UcDwMRT3Xm2Vz3YOkFMDVOF9Tgr5ErsJUzZuxNHJSLqkNjEo4tO7hP/505h0pzCwMDAUICBoUNBHRh1YCwHtg7BXhozymNuFliZTN92DYTLCmGnRyp2M7BJ4XGN6jc0kZpFkvXeolF72zIJV6eTFJKsKAc7kUYRoD3IncjOQmpWwLwA8wKFF6CyAPHCpEpUgCQUfvz+GvdXaeUCGlehjFCAB5fHsEcpotO6kwER7/nhW7VIRUQKAjfrymZDMdKwgMme1rttkVGXArCdT0YGtHn94TInVtuseSGyZ0P2GhEBau02SXlTVgVbIW9tQmyjlOXR5FwiMXuPkr5o3b6lK87Q8pl0sk5ajgUmUYokFVHxirpoBTS3VkY27ugurkOUBC/LyQ4EHQgyMGQgyECoQ4tQbA4WjdhVgJ0DcNmgue3050P2VLl3EnhxBfVx7SNZxQ+i/fzP/zz+7//9vwCA+9///leITFyePf3pT/+BqYB073vfG6973etw3HHH4dOf/jSufe1rb/WQtsSICBsbG7jtbW+7z8hEb6qKpzzlKXjLW96yz/e9v42I8Ad/8Ad4+MMfDmbGRz7yEdznPvfZ6mHNdgVsWxMKJTJdOZP3pLDKT0sWLL1y0yZGbOgSu3UTu3UDu3QTu7GJDWxm/4jRS8caeE5knZ49OxZcEkO5hSyhli4/gBSb5NInWB7FpkdDRrW+FxDz5PakomiTJ/V5EVOCYaVHe9kOEOPUJBYxN713tvdWp9Rp1ckbSbQaUZ2Vjaw6jbDaVgBZEGStoK4X1B0D6o4B4/qA5fqA5YKxOTA2FmSPg5OK4f9n77vj7aiqtp+1Z865JYGQkEBI6EVaEBUBKdJ7TQAREF5BjSiC0gTx4xVQRJqAVCm+Ik0h9CIdQUApERFCaKETCCQhpN57z8ze6/tjr7X3nnNDz83Nxaz8ds65p8zsmdlz73rWWs+z4gh6+3kCKKQuvDSUdJ+OpOzQMZtQyTykxx/OAalMK6DZnPTMqZPtKJZHWdJGddV9hKyJ1L6DcpCACZMJmMhqQJaBTeabtmnHZJlLCi5SJzmBkyGL4zM4wqXI/NCae0sUHWS5ZmENOAiwgM+GOSDE5wNJWtWWxGFOe2dQDiODyPMsIADJmSz091BnnSUjQZKhyJlRY0adgRYmtDqDVkdocYS6A3LrYGwJWAtyJeAsYmlOktIK1zFmkSqAKOZI5iIRPJehIEzhMel5SdZMMsIq0cyEkyGKVxkZZEZJ2gKcEEntfpAiiXjtBUwgIyAnIDPgPA6XG7jMwKbAIge6cqAzBzpyYHYOzMqAORmjI2N0GkZJHBSiiD2IywFPpgehlt4cC+1j2y233IKTTjoJb7/9NoYOHfqpI7/nnnsuNthgg8pr66yzDiZOnPhfUS9+/PHHY9ttt4UxBs899xxGjRrV21Oar3bOOef0uGTwRhtthLPPPhtrrLEG3n777T5R/rTccsth0qRJWHrppQEATzzxBIYPH75QraoPWt8GFJC6cgNx6H1GoiAnmYcyEK4D8To4+AoknCdjktYdp+UcJPsRx1NLcaTW2YnDGKPk0pgNHMqoCvIStIFLkWgVhWA/JyUlECdE9586AdTtCcQnikAC0dlyFIGAS5ypZpeJEmdUQs8BVOjL6liH7SnfICeUdYOyJUPZ4sGErWewNQOr2YrMxJrw3DeXUwCofIpqBiNpZkcI/SOiExujyWnpDYkjpdK3PhDMsYSo2/qpjqjmlAKW2BFbQYcHE5kQmjOQyWXE7s9hKKgJ68pf9WqhWtOsEu4AkQBNMuLYRyJvKL1DgAuVbFWlmaAMrmxfZhR4NP64PBiSQQZOh3S1DtkbKBfBBVDhS9i8E1tnEk4GoZUNWhxQd0CNGZlzMM4GIjfYViaqvneabfDXqLmRXSrim6535d9od3WurJm4Aua6NJLLQeEc6vmMWQpR80KaqYAEB3T9pfczQlZFm96xkR4UmfGP4efIqXBZ+jtOmw8CnQIkGsSSYVVwp1kJhGZ8OTwIWmgf31pbW3HhhRdivfXWw9ixY3HEEUfgnXfe+dTyp3PmzMH48eMxevRovPfee/jLX/6C008/HUsuuaTveP45t1mzZuGJJ57A97//ffTr1w+HHHIIfvzjH/f2tHrciAhnnnkmtttuO7z11lv44Q9/iKIoemRfU6dOxeWXX45f//rXfWJdbbvttjj11FOx5JJL4phjjsHdd9+NsizxzjvvgJlx4IEH4uCDD+7taS60j2kL9mr7CPOa7VoCE8FEAd+krot9mVOzilMEEwok0tIedU2jc5n2OQhObQAVEUyEfgVQzobnbZRhfzZx6iFOCgXydFSwAUL6oMk+yPnh5DECAInKsnJDXHD+uMmp1G+HDtrNqlJII8AJET4nlDUDWzceSNQz2FoGl2cx0voBKkql8SpMhXauDkAidsQOakupk98EJDQiq/XisY49AU2JC9983jSDEUCFOq96Him9xuJ4GwOiDEQeSFDIKsUsUgQSVfBQhZPNk0ECCuKaICIpfTLeEa2AnggTY/VaclDQzFMEiqgojUFrrAREZHCURRCRAAkFMimhmYUcpOVVGTNqDNTZg4pWKKggtDBQc0AmWTpynjAcMhTJVa1U9SkokH2mpUvN//T+S5WcHCWfSLIbcX2kz6npiilwJy8tC1X2ipKyWv6kYDYACj2CCsqT65SAigrAmMtw4R7ygLwhwEJHQT6IEco1pYzSZ05kbjS3O2Chzc0GDx6MLbfcEt/97nfx5ptv4sYbb5wn5UkzZszAJZdcglmzZmHKlCmYOHEiiAhf//rXMWTIkHkw8wXbpkyZgj/84Q+49957seaaa2Lbbbft7Sn1qPXv3x+bbbYZvvOd76AoCtx222249NJLe7Qnx9ixY0PJ08Ybb4yhQ4f22L4+i331q1/FqFGjsMsuu+D+++/Hn/70JzzzzDMA/N+oBx98EGuttRa22WabXp7pQvu41sdJ2ZQAASd/xOVVtrCugHOFl6p0BUouvdoTtASCYEHiZAh5WUP+4gpUCMECKsIfenWyoN+BODr+0bGFZd9pOw5CTYsiJHpJHN0W/QcgdBf2PxC8G0SgxB1ifSuch2rU1WsCUcw6uFQdB+GMhW2rAwoImVYdYNl2qFv3SkG2xijrItFq4MuBSgIX1p8vyXB46VzZKBCah4FVN19lOQWY6c96LE0R6+SUhQyL56HEY/GN7jSSHs9VJRkjm2bdTjhOyPVPJyChZfJSq0S5L0UyypXQcjQ5ryHjEc9h6rqyXHH/IVFrqiiBJYVQZOC7SIvTbxyck7IneE6FkdWh/HLM5TEFWeH6SybGX44kns7Jt8n/HI9H35dO8aKeRBIZrzGQs+8qTQAck2TuZLUxA2zBWkvImmsx4cCr2Ykk0xCAclXmtRIMICVfV8GWrujqY7wy1PRzWGccMb7PUFBQOAsEbcBLyMIT5qXHYLhj04xa6J1Ceq/JvUIGcM6fFyOwmOM20qyUYSA3jNwBNfLnVhWqSM69ZlCIgJz7dPxovli9XgcAbLHFFrj66qvRaDTwox/9aJ7XuxdFgYMOOihEkG+55Rbss88+GDNmzKdqcNaXzDmHXXbZBVdddRUGDhyIer2ORqPR29PqEVt55ZVx3333oSgK/PrXv8aVV145X/brnENRFLj++uvxve99D3/6058WqHVVr9dx0UUXYe2118aLL76IzTffvPK+rpGrr74a7e3tn+s18nmyvg0oHHwXYYlIWudlKFWaMgIKC8ui45RkJWxwVjwwARCdDvJ/yPVzVYclyo16gjRLUywhZDoOtetsObSSsIhNq3wfiOjeRUlJJXCmTg/EefNeb3PZUijJCtF1iUiDg3KQ94wclJtR6X/AFACLOjDRBVbgA4SEFsE7tIZhM8DlgMsAlmZshglsCTDOS2JyKc6qCwCNArAIe5FyJdI2BL50hNWJS68PhymnoItku+GsOai4jjifVV6JVzxSpaSm0x2uSdiy/6fcApMLwT3JUPgLmWQ8qAJ8uoGK8EGPcEiQayABU+LgSoaC/UkWfoaD1d4m8MRgCmCI5NIqGNRdUWX16Pon4xu3KQpTkEbsEhe7+bx519Yo3BZZ0oyBGpMMIIMHPiWAQtaWEyK5Jeub/rnSZ1/gEEAOaZmSlJ2BpcO93O/JccVcQFRystqIUgEQVTMPQQONkwRCenn0f11rQMgoZmzk/GWoIc7JQXtBVMFD5E/IHE0VbIbMkUNQD4v+v0OUFo7nxbAnvWeOkRuHLmIUgARJ/M4l8eGBZnohF1o3y/Mcr7/+OhZZZBFkWYaZM2di6aWXxqxZs+b5vtZaay2cfvrpOOigg8Jrl156KUaOHIlvfvOb83x/C6ptvfXWmDhxIoYPH/65dRiZGSuttBLeeuut+bbPZ555BoMGDcKrr76K888/HyNHjsTOO+883/b/YTZw4EC8/vrraG9vx9lnn11pEDk323777fHmm29i+PDhPVYqttDmjfXpkBU75x320sGVFrYsUdoChW2gYRtouCLpNeF8WUDSibZSj6+OCJpIv+qQAs3VQRqmjWUO4gTXHCO3jJpl5NYhtxbGxlpxl/yLkUoh7Yr3EpVh4iMUKIRyD3VW4jZUalWbW5VspaGYhbMlnLO+B0BCgg36/KHUSQ4y+kDQ5m1e4lPLfaSVHUunC/ZV5RlnyJN/GeX+u0kUP0i+GgSFpaDBn8fmXkWuJPgqKddfAwUlCITyWOfu1Y4yVT2S1+IBzQVcIG4/DC1JyQwg2QhjclHKyoNEbFDfogRwJrhBQV9cvHHOqYefZibCCCR6UThKzyOUVxBlj1MeQVJgF+aiksfOGFgZpQ4tS9O+HoTQ+C08byI6W9mnOuAGovAEX25TY6AOQh2EGhFyUuKyv7O46Z5IQX/sI5NkJuBlc/39APX5I6RIeB0ujHjfxJNRVZZSIB/YLpI9qIIQCClb+QkGOflRI0INkZydIenCLSk4FpKPX1vclHGLxP14XwugMvFeUT5FaYCGYXRlLI0gGV2BU8FS0hkL4ioZz4VWsdVWWw0333wzBg8ejDPOOAOjRo3CHnvsgZkzZ/aIvGlHRwfOO+88HHnkkXDOYc8998Rjjz2GTTfdFNdee+1/hQb/qaeeil/96lcYOHAgbrrpJowYMaK3pzRPbf/998c555wDwPNnerLMqdmYGbNnz8bee++NBx98EC0tLfNt3x9lRIT29nYcdthhuPDCC9HZ2fmBn/3Nb36DX//612hra5uPM1xon9b6dobCMthIfoItHPvuu0478nIZ+AOBzKl/qNE0ksi0PrIq6SSfqyYHOETYDXMAEzUhn9Yto26B3EonXSYQLBCixAYO0kNA3aHU6SQSJ4DCnGMUPToH6vbE6DGCAyXFLABrF2sHNpobkeIp3aYAqwBfZIfB2SIPK9RxZI1gs09GMLyjRaKE4+RgMnBQ0UozLyEHolFa2Ue4FimSc7LnZmdbHPNIQFaQ4SOyjiNq5tSnV2cN1RKy5OTHzytpGUm/Ce01YdKMT7LtZJ/NYCJc027HkUxOQ+XNde8CLLTkjom6KXJRhJtxe6huW1dGNxUiTg/Dl+2EqAMDTE3Sq+KwGoiznGC2CCzijNTRTp1/5fcQa2+KlAshpT6E0D8iZh00bdAceo/gwYVXkjMRgLJfh5VrkKBo5nBKwjnRwEHoRg/fkyKHg4OBBYeyJyvnj3SOFZDQlGeUY1KMFMApkQciIF8GJWptIISu6Q3jS586M6DTAnXjOSwt5AnwGohwc1nlC80rLe20007YbrvtcN111+Gmm27C2LFje3y/48ePx6KLLgrAN8177LHHwMxBCWl+OqC9YU8++SQAYM0118Tuu++OsWPHor29HY899ljvTmwe2E477YRRo0ZhxIgR+POf/4yurq5emcc999yDfffdF+ussw723HNPXHfddb26rpZbbjlss802ICI89NBDeO655z70808++SSWWWYZ1Go17LXXXrjjjjswefLk+TTbhfZJrU9nKJxzcKUDlxZclnBF6bMUZYnSWZSsxOiYmUhLnQJQ0NpwjhHd4Mui+kdfP6h9Kgz7KHjugNx5ANFSMlpKRmsJtBWM1tKhpXSoWYtMMhU+KmtjCUdCDnepkyQOpD73j03zChFNddN0+JIP55SQK7Kc8cBRVXRSsrao9lTOQnS4iE0Yhg0yK6Mk5KVBzWXIXYacc9Q4R44MOaSfAYzviwGJ6qtjLOo2aabCE1ERshkKZKAgQs6/d/BQjTazLzsLGQpXbTyWWswqoEK89/NSIrT276gOzU5UVIkQn3+Yhbc5fS0waCprIPRgkHMW+kEka7lKRm6GwikA1Swchc7iqVxuJTtBiJmIJCMRRwpmovOtgEJHJWIv83Bhmype4MI9G7ZbUWmSfVQQZczeNF/YCHyrJ5nmtlZ0oPtQ0QQDClnIOBIJWVIJ2SYZWX+55OA98EqPQQMBYZbp8aVSuQZC0PbXvDQspGwPJuaIjKzvTcHoMIxOkbEuiFEu7JTdzQYMGIAf/OAH+N///V9MmTIFBxxwwHwBE2plWWL69Om4+OKL8fTTT+PCCy8E4MtC8rxPx/s+lj355JPYf//9MXnyZPzsZz/DwQcfjAEDBvT2tD61GWMwcOBAnH322dh6663x1FNP4Vvf+laPlM19XJs9ezaWX355XHbZZVhiiSV6bV31798f2267LS688EK8//77HxvYFEWBjo4OXHbZZVh99dV7eJYL7bNYn/6NZUuLzHnys3MlHJeSqbCwXJWETTtNV7IU3Ox4xOxEiIwida1ZPH6WiLknP+aOUbNAa8loLzyYaLH+se4kQwEpo5AieUcZQJlE7jV6GmvxQ9YiHHE17ozUCUEEQ9Ek5CkHS+KZeO6BP0b/BRfOBcnxarTcBFV9nZdXGQoOmBWH0QEw3ulyFjDOwDFLTiTGgdVH1lKM6FxFUKT+H/mp+U7OcjRaupQ+hhInPeqEl8GoOrHByVdFrsShSzMJqq7km/9pF+ykP0Mo4fLHlQKe9BqkaysG0rWPMiUAh2L0miOomCsoUVBhCMzGR/nJl7j5uLkLx5/u0S9XE+Ly8X5IoufsL75yUQw8MCMI0KyAFek9AU7WHlWO319Sjo4yEECQJaAkhwYAK4VVWjpHoSjKhTI+vV5Aeq0UbCXb17kk2RLImdFO18Ff5yRDQbruKZzmVFiAw3lksJPrZQALA0smgJ4aM2oJT8tnKbgKFJLfPyAIdwJh0aZrkrWXCQuJm8iXSzEBmf/d5qD3gAccZSnlUdah1Xk+izULAUWzPfXUU1hmmWXwyCOPYOONN57v3ZvHjh2LoUOHYvLkyfi///s/AAAR4e2338amm26Khx56aL7Opzdszpw5GDZsGO69917su+++2GqrrTBs2LDentansuHDh+PVV1+FMQY///nPccopp/T2lHDwwQfj5ptvxh133IE333wTO+ywA+688875Po8///nP2HHHHfH+++9jiSWW+Ngk8TvuuAPLLbccpkyZ0sMzXGif1fp2hsL6jIQrS3BRAoX12QqrEfkEHBjEESL8iUfugMAGZiF2J3XXQfs+1Or7yHduHWqlQ0vBaC0c2guH9gbQr2D0KxBGW8loLRm10iGzvrMws0XJNvSsKEMdvMpbViOZasE5DqOpazI4iWor58HX3afsDCVux+yELxfTwWH48xFKXVhPlTq0BuAMJEXehjMQZ6LS7zkUGeXIk+EbqImaf8JBqI54sFpWZRyQSRlZbj2QyyVD5N9PuhKHCLSPLBsnUWUno+LMizwnRSlg32/CN5aLHcarpU46z3Atkkh5s2MdX+DqG3o5kmyNk0h0SrSP5GJUZGS1gZ4LJXpc4Q2kDeMoUZOKrndSYqQ9HCR7UOrQNSqA3bH1awZVVSqFFtpgTrcXBkmXc+mp0EVAp2F0kEMnLLpg0cUWBUsGhLVUURsrNkX303NECKBUL40hDyA0wxClXSkQ/gUShnMS4G8Aq5Ef1f15U6M7zVQ0ZSl0PkgeA05vBhoVhBO/HEQgVGHOQJp6+v4tc3KDWTlhRo0wvU6YVgPez/2YnjNmZtVww3+zLbPMMhg7diyWWmopnHbaaTjggAPmO5hQazQa2HTTTXHffffh73//OzbddFM453DJJZfgZz/7Wa/MaX6bcw4HHnggfv3rX2PIkCEYO3YsVlxxxd6e1ic2IoIxBqNGjcIf//jHXltTqTEz/vGPf2CjjTbqFVJzrVbDgw8+iE022QR33nkntthii0+sOKXZjIsuuugjSdwLrfeszwMK5zxvAtYB1oGsRFT1b2eTcxcfkzcYgGOviR9ABUeHWz+i3xePmhwjs4xayaiXzpc5FSzgAZKl8KNuISRthhE1Ks/v8A3vrDSmioAiIUlzLNsIRN5wHOrkV1vX+UMXICElO6SOc3LYgeTt0uH37ZjhnBK2dVbqHFLyaMJg6cOgNR5K4M7CEDAhQMIoyEnKVtLqlapjl3QWd0geq3XtFS5CyPOo84fuJVKIUXPvxFM4Bu0grSR07UERnDxEAnazLGi0yhmvvt7kDFcc5PAtBYyx/Mw7o6YyQm+KsC604RwDTjtZC+/F6fO41pGADHXgdU2WcLBJ9k/XpmYymuVoPYG6mcQdy6gKij0UOg2jkxw64TyYgC9XtKF/ylz6TgTSOWIpVOXcJkR2yRIYfS1C6koWp7tpBsmDhlTamHS9uURGFmlPCiTghRNydtxxBVh8LFABARVIQIUvVyuNbwjZmRPm5IRZMmbkhJk5MDPzY6F56+jowP3334+uri6sssoq+MpXvtKr83nyyScxbdo0LL744lhvvfXwu9/9Dv369cMuu+yCAw88sFfnNr/shRdewC233IJLLrkE66yzDn74wx9iww037O1pfWz70pe+hNGjRwMAxo0bh0mTJvXyjKLNnDkTTzzxBJxz2H333bH99tvPl/0us8wyOPzww7H++uvjnnvuwWWXXRa4M5/EiqLAmWeeiX79+mG55Zab9xNdaPPE+nbJk7PImQFnAWsBoXCSiY4OtIQDqcNBobTAR7HFaXdpdJ/9H2024rCkvRsgDbyA3AH1ktFiPYBoDeVOhBbnwURNghSOfOmDJQdQgl1gg5NjglakFn3EEqAw4VSJqRJjTj1x8VhS3dKKR+O/r8TtdJv6v8ctJmZLNFtDkK7gWndvhOfgHWzSKLKBz1iAJVsBZAS44P4RQA5MWgqmM20myiYZCs0waLkT4oiZAt1Q4ubq7uAdxBRMqGasKuogcTm9kpUoWlEsc0rdaNbzm0C57uCheSIcvq9z13elG0O8uqmjr1ebyAMJjtfMJyNc3EbihPtz6ItjKITK/fX1mrx6rjjsM9Kifc4iQEl2MOwq2Y54NpJmk/ASqsT+3BbEKMhnJgpDvvbfAB0GKI2DIYsMhBobgC0yNgEcVnunJGtUn1M8Q3r648qXRnQkgFNBJqEKzpPbR38N6PJg+Z4DBzDhmCNIhc9SWLBXfYLvC5FzlUviktuQddsJsqnyQ3Qysl4ScOHvL/8BrUQuAHTKgoqlYUDh5HfQh6On/yqbMmUKjjzySGy44YbYaqutsOSSS86TxnWfxSZNmoRNNtkExx13HL785S9jlVVWwUYbbYRf/vKXuPPOOzFx4sTPvWzmY489hpdffhnbbrstfvKTn6Ber+O1117DxIkTe3tqH2pLLbUURo4ciWOOOQavvPLKAnmdnHN49dVXse+++2Lw4MF45pln8Prrr/foPldeeWWcfPLJeO2113D22WfjgQce+FTbaTQaOProo/G1r30Niy66KJZZZhm88cYb83i2C+2zWp8GFGxLODISbbXegTIAO1Gn0WAuI5ZLQOqQWVRTlKTsAHLilGikmKniUsWmUYwMPjpet5KVsEBbCbSXQFtJaAlqT4ScNcoMKBeZycFJpNaxb26XQXgZ6oT52VecHE5cKUeoSMh690FJwkInTbzV4Piqs6FE7QpISbwOThI4GjlFrH+3xsu6ltIROzjjSabIO6AGhnzpByCMDfLPCBZM/uwGFSh5O+1BEUYCKlJAETMv0lOBBF5S07Gk0V9UMwqqqhOLYnzZVgQTmXfiBZxV9JSSc5Wc7PiEErhByZlOgEVqei5iaZJmoPQ78CVP/on/tCxlcl55SxWffNM4kmkkzRON5rT8+TJyXXV/PivgS/OQjNB3ApG0nKpUOQIK5nDMnlTt13qnYXQYTyCenQOzDTDbeKCRwaIGQgsTyGWoEcEg94fH8XxDb1vyyMH31tCSMA4YIcBCospxa6+X9DIpKFHTYIT/fPo6wbCXrTWOYAx7YjYbOPKN7SyM700hv3dqDigMC0NEr20KKli4EXGtpCiZAK/MxgCMA0sHm3DPSwZIrwk7iGSsJ9i3WN+vAsVCRNFsG264Ic4555xez1AAwCGHHIJ77rkHN954I1588UV8/etfx+23344LLrgAr7zyClZbbTU8//zzvT3NHrcpU6ZgxRVXxNNPP40f//jH2GabbRZ4Mu7111+Pr33ta3j99dcX2FKtRqOBNdZYA3fccQdGjRqFTTbZBEOGDJGgYs/ud/XVV0dHR8c82d7ee++NzTbbrM/ybD7P1qdLnth5xSRyVnoNCK+B/R9QLTHKLSMv/aOWySipN+FIVxIA0pcuxmVJI5h+P5mFcCecz0o0PLBoLbzCky9x8jX+qjJEDEBKihz7EpKSLQouUXCBgkvfzdsV0pSvhLMFnC09eHJl0NZnaKfg5kInxBBoWg5joipQcKL1f/GGiTVy7wFOUGISR1tLgoIaUAbfK6KeoSGjqBFsTr7RnYEQm/3IyCAzGXKTJ6VPuS9/YuOvi4vgQTMTCM+pOpBkHOQxLUNyGfk+C5lBmRvf3yITRSPV9adU1Smeu1jqZLplJjRa7s+1ApIU3aDqFFLisMpBkT76lVwNHgenPlFQEk6EUqI96E2ucZYBWQYmA0cmUILSsjkPvB2M3jPWIrNlGEYGuRJwJdj5NWdDLxffz6WZ6xPyBQIcSmI0COgiDx5mE2OW8TX8WnozMwdmyZidA3MyhznGoYNKdKFEwSWs7J+dBaRMUDOJely+I31Tv4nkfqDmfwmYgET5A2eF/EhL2PTD6WUFKJTXGUcwjpA5Qu4MamxQhx8tINSZUGffOTzNqiW/xZo2zopX46OJPUjIGFBmgMyAsgzI5N7ODFzm+RSNjNCVEzpywmzlVNQI02t9+td9j9o666yDF198Ef369evVedx9991Ya621UJYlrrnmGpx44onhvXvuuQcvv/wy7rjjjl6c4fyz7bbbDmeddRZWWmklvPzyyxgyZEhvT6mbLbLIInjxxRfx5S9/GX/605+w8cYb9/aUPtK+/e1v4/DDD+/x/Zxyyim46qqr5uk299prL/z85z+fp9tcaPPO+vRfmOZacMMiT8m+FKnmPHfB94PwKky5RVPdfeRbeL86lr6ok6mN7/w+5fvSuK5WNg3rScKZ8yVRaX8E5tQR8p29nXOwzorMbRmGrThU0pBOwYRESKvunJ4UJIBCCJwSVE8b6HHIXKS15iTOs/IZ/PuhaR4l5SwynDjnNosjZoM4OM+eKSEkbJGQVSHZnDPkTBLp9SMtSUp7A4TMAjW9IK9ptkFLspw0arOZBxN+eDJrkA+mmKFQMCFFMuF8VIji0PPZBBTiwpzLYm167PYSV0a6Bb3OTkrJKgRkARVKuocQyWOJULLuFC0zw7CDcQ6ZcwIs/DC2BNnSlxDKuivZevALh5L8sEq4DlKucY4WPhjeRUAnMeYYP2brEGlTlTftzLQhm0NBDgX7eyE0YRRAoVLAUe5Ymtep7pQCbE0XhfMbeRPpOmo+l3HwXJ83rUYBtRTkY3Mm5F4LDDVkqMH4Zn4gCXJQVbq4kh6pzg0E38RQhcQS8EhhyGuZkXvdhPvRl5R5snZnRujICB19Oh/dc3b99dfjoosuwkorrYSTTz65VxuszZkzB88//zyOPPJInHbaafjb3/4W3rviiiswYcIEfPWrX8Vvf/tb9O/fv9fmOT9s4sSJuPrqq3HGGWdghRVWwIknnoivfe1rvT2tihljsMIKK+DCCy/En/70pz5RhvPOO+9gypQp6NevH377299i+PDh83wfJ5xwAnbYYQfMmjULP/3pT+dZCdjbb7+N9957D4sssgjOOOMMLLnkkvNkuwtt3lif/hNjnDirGtEmhNIWX74kJTqabTCAMQzL/jlAEvSMDkiVbKyOhFqSBdFu2CWjViKCFUuiAMOR8KuDE9WbkAnxpREKOkBOovUUJSyZvJMoBSax74BOW+KmqdNbAQ0hhuw/p9slANJILBqlgdK4ncThcs3DROcLqIIJjb6rTwSBFaAs7oMZgIFhhLi3ztNLwLIW70RHj5Njku2GzATFfhaageDAg+FQymbRBCbCufSgIs19NAOXqmmpSuLIJh5jms0guU7xHMdzr9Kuus3U39RjRrqt9DoqsHDCiRCJ0bQUi8N/ugkGWV/S40vaGIYYJOk6Ji8ZYBOnHaFIyu/SA0yGYw/QiH2zNV+6R+F8FQR0GaAz82VOc0J3Z0/MtgKQjXPIiTwBHNaXM7kEDsi5q5wbOVtO35Br2QQjKngwBaYRlDdfWDlSTt6icKXgfx94PkUmdUzMBjlloZGmA1Bjh5xj74oUVKTHopeS0/2FnAjiraoBECl98nK+xj+y/70FANoZW8s/ufvCXWgA/va3v2Hq1KnYYIMNcNBBB+H1119HZ2cnJkyY0CvzKYoCv/vd7wAAr776KlZZZRWsvfba+Ne//oVGo4GllloKhx9+OO6880488cQTn2s5zUceeQSTJk3ClltuiQMOOABTp07F+++//5EN0eaHDRw4EF/60pcAeEnURx55pHcn9AlsypQpeO6553DYYYfhsssumyccleHDh2OppZYC4Mv3pk+fjttvvx1nn332Z952au+++y5eeuklHHbYYbjkkkvwzjvvzNPtL7RPb306QxF7EcTSJeOA3BHqltBSEloLoL0k4TaI8pIAgMzFPgaAOp4ayY9OJpHnNmSiMlSzjLx0qJVSSlU6ZKVDZj3YCCpTos7kmFGyJ2mWzF4KMynVYGdhnQ1ZCeuKJEuhMp0uKXFC4ihTiKzPbaRR+5CdSEtlTAYyGSiTxyCVqtkN8iU04qhrPXwoLGEHsJfBBWs02XrCrkSVveNMMaILg4wzyUxkqHEmzfAMcikf8SVi6kQKkDEIzdhcKFuqNmlT1RunWYmcUOYQrgdQZIQik+ZtCShSh1LzKCoyCo38p+daJ1WxalahKW/UXbkqHSmghHIT0g/Ha5wqQIVINiFml5JsBZPxwJikdE/J8uAQ7TfOwjgbSp7IFpKhKOBsAet8xiyUPGmTNMP+kTh0bC6VdK3gwfjmarNDuZOMnDHH+OxEV+YBRRG2J03u2N8PTjMUHDORUeksljc5JCVPqorG8ZoGYJicv4qylgwXSuG0qR7DGc1SVK+xlt4ZR4FHkbNmJzLUKUedMtTJhCxFBVAwN62FtLSJfKmTPCL8LFmKLI5Y1hglj31Joi9/aoisbCNbCCg+yJ566ilssMEGmDFjBk499VSceuqpMKb3/zzecMMN2H777WGtxZgxY2Ctxbe+9S0453DnnXdi5MiRC8Q8e9JeffVVrLvuunjnnXfws5/9LDT/600jImy11Va47777EBrP9iG7/fbbsdVWW4GZkWXZZzoGYwyMMfjBD36Axx9/HI8++igGDBiAX/7ylzjooIPm4ay96T2h++6L5//zan06Q5GxaLwnJTIq656FEoPofWln2SIDupj9H2nyLpw6ldohGUCUIHUcfq5Zh5qUUOUCKIz1XZvhJPrNBhZ+e8rBUD3/ghilvKaiUl5oyUkNOnnNJ/adrjIftwXBJGUlCE40ACF3euc/1PqTulsa9kSIriJxriq3ojg5qeKTk/InJx6xz4z4kis4BpXwUW05l8SMrHQwpfBGRG6GWZ1qkkyFCQFXxx7c6TkJmYM0JG/0vbAhZKLyKz63d5yTTts2I5TqIEIyFM6Fw0srY9Th1KIsQyL6Gbgn4vKlAWudX5hnFUSEoHplHwj8DwQlMgVd8cNMQgZmvU5GvhtVm/zuGAEIGQJx1AZ1AED+eDPJ9uj9QZIdCbKyChPJwklJU0kOhWE0RD7W93JTUEKSOCO5jowckp2TaTt40NYwCjAkQyElTz474e8LCPC2LIRiWDjWrJwsCCMIQIEBkvWISHb2S6Qp5yBfC2WClI5U4SoqQFE434nDL9/V62XC/euvF4nyElMu55JQA/xgB+t8YMGG7VC48CoaAfK/R0iyNgiAk2StUPjlEdYCnPSDScj4cqxOvs9m4R/eD7OyLLHCCivg8ssvx0477YRXXnkFK6200ifWzJ/XNmnSJAwZMgSPPvoojjnmGOywww4YMmQInn/+efzud7/DTjvthJEjR/bqHOeHjRgxAmedddYCQXq+7LLLMHLkSMyYMQMrrbQSpk2b1ttT+tR233334cwzz8Txxx//ib87dOhQjB8/HgDQ1taGZ599FhtttBEA36G7p+3hhx/GiSeeiNNOO63H97XQPtr6dGjD/0FPilLEafIESULdAq0lSYbC+EdLaLUq55qQJMUr1XIUA++w1qQDdotltJROuBiR4E0ukkNtkokowGgAaBCHodFbKxFjDUqnvQA4IZhaeGdLSdBaXlSp+zfiEOmj4ickO6jUVCRZCvKEzmo/A3HckmZzmrmJYEIIstbBlBZ5YVErLGoNP/LCwVgPtFQbN5CrFfgxpLlYaH/nMxbymLHxOv7scwVKQg6cDUNhaLM0JVeH82QAlwmRPEuI2KZa6hRkRSV74ntjJJ2wAxk7+rOqKhRPbppV8N+J4A3hsVKCI16xRqsjulSH329H5+aBjjzXdZ+sXxLeDISky5mBMyb0KSgNQjbBUuwxYYUjYbkMQgEllyFToCRsK46wZiNK4yVgG/KokrABQGR+dGTAnByYk7NwJmJWwqYYIbmRvXOd9EDRTFiialbhODT9YlAAkF6CoIxW+RdzS7o9VxloKjHkdDdJb4pUhSyC0oyMyMj6Rnc+0NHM41KOUcJjMgRkFLgScx2B61QVDkiFFEKW0aTZtYX2Qfb+++/j5JNPxjnnnINhw4bhyiuvxBe+8IVenRMzY9q0afjJT36Cv/71r1httdVw3nnn4YgjjsBjjz2GDTbYAJdffjnq9XqvzrOnbfr06ejq6sLqq6+Oyy+/HC0tLfN9DlmW4Y9//CM222wzjB8/Hvvvvz+mTp0aGq/1JZs5cyb23ntvvPfee/jmN7+Js8466xN9f6uttsKFF16IgQMH4le/+hX2339/HH744Zg2bRqmTZuGRqPRMxMHMG3aNOy1116YMWMG2traemw/C+2TWd8GFAFMRHUi/QOdO6BmCXVHaHWENutHqwVapdFcLt2SQ9RW/hYb6DYimKgno2Y5KBKFKCC8c1SS6u374dVugIaAiVIAhTpEQHRMEHxKDp2KLTGskfILI9HbwFlISzcSh1cdVagvlThM+naljEadEHlTnqcEbu9USURbFHfI+lKvvHDIBUjkpW/2l1ktqYlgKQKnxBkDCXjw/yKoML6MJESMSUpSUlCBCCYQOSXhfBgFIRFAuOQ8heAwYilWzFBEHgUnjimjeu3CWvzARarbTz9FoZwrhRuBiJ5cO78uo1KWkY4eBkm2Aemlo0DW9SRd45WuhISuYNYDVQ8UfJmRHwVbDyTgULJ/zbdf1EwAB1K+gpMUSDQk69AwQCMDumR0SnlTV+ZfL7N4TVK/30AzgxFgK5hQPTMEGKB5hXg9/bbS9Yy49hMgGHNw1XujmaCtXAhWkNMMXpquWwQIsQu8ke7ZWQIq0hEa45FcVwUV3cqfUBVQqICKqqiCBgYqQgwLMxQfyx5++GGMGTMG99xzD77xjW9g11137VWittrtt9+OG264Af/5z3+w1157wVqLsWPH4uWXX8Zee+2FHXfccYFUQpqX9vTTT2PChAnYe++9sfPOO893Uq4xBnvssQcmTZqEG2+8ETfccEOPy672lDUaDVx99dW4+eabAQA77rjjR34nyzJsv/322GmnnTBq1Chsu+22uPXWW3HNNdfg6quvnm8KZJ2dnbj66qsxY8YMrLLKKth0003ny34X2ocbcR+8G2bMmIEBAwbgR8PWQgtlovwSJUdzBlod0GaBFqfNpXwZR5eoyszOgBk1YHZO6DJAlyE0xOHUUhTDjJxZGrP5Eh7jtMRJHOdSCNrO14/VxAk2mg0ABQfMiYNSVn5OVZfEiMWB9FHHzGQwJgcoR6iNFyUfjWqqs2m0NAdayqHzQMg6RAfERGeUUWlUJi9VHS3WqLF3xwjczbFJicWqmuVJ0k2gh/0eItfEgdn3PHCwsFxID/HEkQzypx6oZFY5NB5MIi13qhEaNa/o5B1pUf9JOqGT8DRUecpQjpxqMJT5kifKYEyWZK4olG0p74ZExlTNn2f6QMARyo7C8XPlnEO+L/UzyZJQBzueBz1/CiwMx/mwcHNYwZ/zhOeaY+TOCR/Iy8dCO7azQ4Msusj5TtbkgUEp3BWGgBuWTtDsZVFbHIksqn+dEAFfQTFLoQTsQMQmJVL7e0i7yrdZoF9JaHOei1CjHJmpgbIcnGVgY2AzQqE8GkIkIgfH3CALnBK/yllQW5qwQ3L/hSxU03Uzwv1JMwnhXfJZQpfFUeaEosYoMkbDOHSQxSw00MEWHbDohEOHgDDfHJI88EtADAuA9/cRh0ADJFED7WpvOXS4h3VenStZ55RkB7m06HzkP5g+fToWXXRRfJ5N/0Z8FltkkUXwxhtvYJFFFsHFF1+Mww47bJ5p6X8WW2ONNfD444+jvb0dBx10EF5++WVcf/31aG9vx2677Ya//vWv6Orq6u1p9phttNFGuOuuu9De3o4999wTN99883w5XmMMFllkEbz55pvYb7/9cOONN/b4PueXHXXUUTjwwAOx1lproaOjY64gKcsyDB48GG+++SbKsoRzDm+//TZWXnnlXpixt7Fjx+KLX/winn/+eay11lq9No/Pm33avxF9O0ORDMOxnEDlYlsdfHbCAf0sod36xnPtJdAumYoW6xtP5czI4R9rLI5NCbQXjH4NRr+Gf95aRAlabZynDaQahND5d04GL5eZcVUaU8pOUq5GJcoM79D4CLCQXw2jkTGKzKHIHErjYMnB6Uh6ArjgbDZFuknLmbQnRVNfCkoLQKqCtN7nFyfVWlBZwhQFskaBWleBeleBlq7Sj0aJupRA5dZ5KVJnYaT5IElmw8v9xtKeDMb3paAc+q8mmQojbpyfZyRel1L6VFKzY5nMP4S99dgJnBBZyWhpimRGyI9MylUiPEPMUFASsQYiABBwh6bvxEg5JZkf/3P3LFF1NYSCLCl1ysgPLX1KJW21LAwZ+f4EWQaXZb4Ph/BJfNbMoQsWnbDoIIs5VGIOWcwxFh3k0AVGAw6lQjmO01e1tDLJSsQshICHnNGRyz1QAzpyoKMGdNaArhrQqAFlDnDmAVpOQAuTDwI4hJLEXGRtyXkJWwWcfkhzPdZO3RxPn9SR+ZIlKdcK90q6vnVxo4IiYikVJw5+kp0IWbbY3E9J7uQgjxTAak4GNcpQI4MW8lKydQB1JtTYy8pmgA9EECRDQfFRshRGSqFMKHmKpU4mZDSS3indyhgXZig+ic2cORNLLLEEHnvsMYwePRrPPPNMb08JAPDss89i0KBBmDx5Ms455xwcccQRGDp0KDo6OnDNNdfgoosu6u0p9qj94x//wBJLLIFZs2bhqquuwv/93//Nl/1usMEGePfddz+3cr0rrrgipk2bhqWXXnqu7++www54/fXXkec5dthhBwwcOLDXGw5usMEGOOWUU3p1Dgst2ucPUEj/iZoAC9+t2v9cd3HUtI9EMnLtbm0ZdcdosYxWy2gtIQ3rpFTKRqUWdQZVZahS+pHF5wWlykIUIr4Vh1Oea3TSSllKSRaWLKzR4eCMlVKUVIM/8Y9k4yEboYRtI3XWCSFdo+mRyC0/I0KK0CDNMchamNLClCWyokCtUaLWKFBvlP55USIvLfKyRG6t9DpwooAl/QQq5T3qMMd/XglKH71zRgKCVBZWuQE2g5SDeUfQARUHEZqlEUcbWQQVmo3IdITCJ4p17XqJUqdTH9NFqBhCQUXqwFWcuaS3gQLLpDRFt0Vx6uEc+ce04V7yXVW8UtCoAMroefNZgQICKsihkxw6DaOT/GgQC5AISaTKMWv5m57vAHgNUEhZU6fxCk+dkpXoyv29UGReZcsahN4oGbx4Qgt78N8qgYC609JCBRTJ4Nigzzjtp8GhuSWFIkThI1XvlAqY6H75uPJGaFgIfS5gPcmYxYEINpxmND1YrlGGmvGgok7an8J31vZgQm/JhBNGFBW8UhARwAQ1DROykAFANI+F9oms0WjgRz/6Ec4991zUarXeng4AH9zp6urCqFGjcNddd2HdddfF9ddfj1133RVPPPEEtt12W9x0003V3z+fI2NmzJkzB9tvvz0ef/xxbL311rjlllt6VO3qJz/5Cc455xxkWYYddtgBDz30UI/tqzfsL3/5C/bbbz/U63VcffXVGDVqFACflbnlllvwt7/9DSeddBKstdh6663xxBNPoNFozLP+Ep/WiqKAc+6jP7jQ5ov1aUAB6N99X0binZMILHzGQuRemYNko3FKiuTKyC17EraMutOO11LSZLnayTn4JQkZWKLlZQIiysQBsxQb5lUUZig6bBoF970SOERYdagKjyNxmprirmF4rySO4GSY4IRWnCUgmUuSr0g26iOx4tBZh9wKcBAAUSttBBOlRWadH86FjuFz64atkrJBsJVNZWiWQj3sFFTEkZCtwfFEAOH4OYtEdB/NzSqgwlDkKGhyIwKfVF0pLsBQ3tQMDvXz1cVaBXD6mun+fveFHq9lhYCdSPxWR+JgyvVWbo4qjjUkY9FIFcgkE6GLoQqFElUlFQyQdV7oyPQ5B1BdGO1SjsAB0vOrWcUWx2hxUTAhY5bMlgOJJDElw4NUv7Z0EDsp3XMAWzQTu0PJmGQWEK6tHJ1eAzRf1/RaJpmJMBC2F0CF/r5hARWImYqcPJ8iB5CBEdk63IQBqtebTBogSDkUCJ9r5laEjNjn07/scXviiSfwwgsvoH///hg9evRnLqWaV/bwww/j6quvxkMPPYTNNtsMX/jCF/D3v/8d48ePx1ZbbYXRo0dj8ODBvT3NHjFmxkMPPYQrr7wSTz31FLbcckuMHj26Rzgke++9N0aOHImllloKF198Me67777PXe+P119/HXfeeScuvvhirLXWWlhmmWWwxBJLYPTo0dhyyy1hrcU///lPXHLJJfjb3/6G6dOn9/aUKzZo0CCMHj16IUG7l61Py8bq30glcqqMbGwipX+oNZuQlEiwOLfWRwhzxHKZjEXhSdScQm06oo9KGj5WJwRJ47VQ2uLnyRTdsvg3PTrz1OxkhjgqQ2OWDBt8yrhbccE5dWr8cWi5BEsZhKo6ESUkYzkn8gAm78ww+2PyWYlEgDKp9zfOAwXjfKmYIefdcHIhUm4NJdwAA8CByHiHMvG8YyAtwkPWKyvOn/beIFJiMAPk/LwZYBeP3882HGCyUOIJJ4KQ+H1PDJMoS4W8BKfXVLM+ScQ6cbYjwVvfSbBMsmZZL19yCZKVFEAqun2XqhuS13SNRIlgjjvRiUnTMzj4ayP7SJuvBeCYzKn7qo3rOjjcLOsX8TQH0raJQKNMe38gAjTDHthXsokC6P3a8cfEwbn2MzScyTqMPWOcMX69Kl/HGNFMjUgtZHk8yymccOZkHSpq1Hu8cj49byhZBs1X1oNjB5DzSy5zhNwYWMp8yRgc6uwqGUELjmpmgNy7Mh2S+QFg41cdM4s+L4dMKQxL87pkzVNcYdznw0e9Z3PmzEFRFLjoooswfvx4PPnkk/NFFvOj7E9/+hNeeuklrLvuujj33HOxzz77YPz48VhzzTVx4YUX4pVXXsEjjzyCmTNn9vZUe8TOO+88vPHGG1hrrbXw+9//Hq+//joeeuiheXK8WZZhyJAhOOOMM9De3o6//e1v+OEPfzgPZr1g2uTJk/H9738f2267LRZddFGsu+66+P3vf493330XZ511Fm699dbenuJcbdasWajX67joootwyy23LBA8p/9W69Ok7B8PWwutlMEwUCtjNkGJnW2OUZPMBIFRwKHLMDrJa+HPzBizsxhFLaXxUyidkkip+miOfclIjOJqDb1MTBybNPOQSjVS6pykPlpwUEWmMsk5gOAjjnlsPgfj8zHExg9kyNjzDzy5WNRlNAofypyMxEITZxDafE7Vm7yHHgOt/oOsNeK2QF6WyEqLmrWoW4e6ADmt6a+UJWUZyjxDmaWKQ57DUeEOhOi/KPo4IWhLyUphLBrGBV5JqZ2b2fe/Ji13SfCLyw1szcDmJMPDS2LAWEJeEupWmuqxKEslhU6RqFttEFjxJAMqqEbyU+PwQTQ9S2BV0pMilIEhiTQryEm+GzJIyfPgYLI/l2xV4tcCpW9Wx66EcyWcNFIMvSg4NiLUNaIZN6fyvJIFAkm+iKIIgc5SOUWl8aR431xNvivzzKTMsG6BtpKxSIPRv/DPW6zPBirCUXBAJoc2YoSU7+n6cSSd0U3zMAFQKNcg8A3CNkxsmigyw3r8BIRO2EZU5DKX3MJyjpyqjqVleJl/XUnaDeNQkEUXSnRwgU626CJGFzE6M0JDv2sQ7p+wBnUhCXiGZXDJvq9KIGZ7KWdWZTUnz7VnRWHR9fcnFpKyP6UtvfTSeOONNwAAP//5z/Gb3/xmnm7/s1hLSwumTZuGtrY2XHHFFfjJT36CyZMnwxiD0047DUcddVRvT7FHbbHFFsOUKVOQZRnOOussHHbYYZ95m6uuumroyH3QQQfhggsu+Mzb7Av22muvYdlllwUAWGux+OKLL3AZiWZbc801MW7cOCy11FKYNGlSb0+nz9t/JSk7teYyEY3yWyR9IQjoAtBFjIa8ZgEE30XrsIM6iujeJ2USkGwFibpQswRkcKwVKSRDHVLfcTop1RFHzTtcGjUWSMHqNDj/6DwhNZBGjY9ahv4KlRFLsaJkLCcBzFiqkRK4Q5w/fI+C86912louRNqzgcVRFxWsUEIWGgEilpEJpyVnzSZpOVrsXG6YIocCmZC0c+SUIyNxKjMDzo0nHeex14I1CDKnnDjIeoyh9wX57XruhJY6IcwlY046sTfxPmTEbWuqpPtnKr1SkhUa/0cIhKcrOETPgXD+03KmKAkaHWuEzwiYVWJuZoA8A7LMKyVlmY/oi2pYc8/mENUX8JBMMx4DBR83lD9pVkLBRNmcnaCEi+PYly1Z32U+EzUqktKlcN6Vg2MtsrJEVnieTr3hRQDSUZf3akWJPB1aimctcud8KSRYuAus1WORalApKULgHIVMV6X8TE8VxXXGCOV9mYWAV0LdGbSwQZ0N6jBCzEaYj0L+WI1IcjnS/ZGUu8kHJUUb5h3SsoqIYqBjoX16mzRpEkaMGIFXX30Vhx56KK677rrenlKwRqOBr3zlK3jooYew8847469//SvWXnttPPvss/jOd74z3+Q8e8tmzJiBL37xi3j66afxP//zP7jrrrvm2ba32GIL/OUvf5ln21vQbeutt8YVV1wBwGdpHnnkEWyzzTa9PKuPZ/fffz/22GOP3p7Gf631bUDBaYw2kVsUZ1vLOWylXtwDi9gXIvZ7UKWjNOobiM4BU6ikbAQRuUud40RUSEtrdL4hel91/H1EMpbypOVFqVSqV0dKwE6qPqMqRyZpxkVceex+dBrR5oozL5NFCiyCkxmI3Vl4ZNKiM49ACKkzDZHVFTUtV+W1xP3qccVmg74wJYKKyj8BMxD1Kk56U6gkb/D3RSLWc2fIy5tKqVOmnAmi0H+ExLHT+X8QmKAEXEYwwWGNpM43cfMryTJGkqsIC0agHoXTWsmSBEWnpH6+SrxNfk7UvZBlcUi2K82CVMEExXklRnq1OayQcK5Dli1Z24HbgsjH8eVKIv/rlCuRgjddC07WiSdhZ054O9aiVsZR1+eqMFb4vii1wqJWOv+eVdlcFgdelzD5YQiUifKXqiklPAXlJoQTkACLSKaO6z8FFL43C5BbQs15QFETlaecKfC79DG5ihUAV3mxMg8kPJxkXYRrigowXGif3MqyxDPPPIMzzzwTL7zwAjbaaCP87//+L9rb23t7amBmPPfcc7jwwgtx33334Ytf/CJ23313XHPNNfj3v/+N9dZbD7/4xS8WGP7HvDbnHMaPH49zzz0XY8eODce72GKLfartbbzxxvjRj34EAHjhhRf6dCfsT2ovvPBCRT1rtdVWw3e/+11885vf7OWZfbC9++67+OUvf4nhw4dj4MCBvT2d/1rr04AiaPNDAERwnmPNfSklSgWQNJnTxnOx2VzsIOzrmV3T4MTtMyGq7h2TOARUIPI6fBAxlqtUm2bFYRMwERz+ACbQJEkZy0FAHDMUGYsTxwkJvHoMrOVNgQ/hEkeeo7PoN94UiSVxQDNxULNEgla7dVAIrgcCvERgFVgoAAuNvTQrVHEmtdJde0QnSkwi6ZqF7sBmriRtp8X9Og/nHbrcEnJnpHleVdHJg4r0fMRrHjI5FTCBcP5SMJF2KA947CMXdOLQUyyvUmAbuzZTyGZE4r1uI/k5XEySLEUmKlcmlA5FZaCoGBUADOJj2HQAWfqcU+QmwF7ABMUsWdyOZiYkk2VjRssIUNaskGaufM8Mn8HIrEXmLDLrZYlr6Sibh4CJwqJeOtRL+RyLRLQhmJxgcgPKDahmYDI/ArDItGwwBWcJObp5QIBwyNgh9Ezxa08e2aDGBrmCCgHbqeBDM/xs5tfM9Ton66YKJD7OAlxoH8fOPvtsXHfddZg9ezZOOOEEfOUrX1lgHPUrrrgCf/jDH/D666/j+OOPx7hx43Dvvfdi6tSpOOGEE7Duuuti0KBBvT3NHrOLLroIV1xxBSZPnowTTjgB6623HhZffPFPtI0VV1wRe+65Jw488ECMHz++15WMesNuv/12XHzxxeHnPffcE3vvvXcvzujDbfLkyTjuuOMwa9YsLLXUUlhuueV6e0r/ldanAYWWIzGSrtKqPGNUzUa0942vVe4yLLKWQJfwJ7R7r3+unApRvaHYtZoRHc2MI4m07oCWRJ7WK7cIsFDHM3pdFTChcw4ZClGiSSP8WretzpeRTAWSLIUzToAEw2aM0vh+FdoF2bJvXOZkaPdhLTGpRIsZ0C7kmieITqdkKEwGNhmcyeDIwEqzPSfgQr0Xw3G7WRoddpxIfWpfChfAkjpm3mkTFabQn8L3qPCZilgPH7toC6CQM04SJa4VhHppULcZ6tagxkmpU9pwTjM1lVInlsZmTRmKpBN4AGrOVUrkNMof/cGqq5iWs2gWKEq9Si29RvkJMSuVgIdQYpc6kTqyVDI3A7I88HHIZIFToDU/WkrlyfMJXgBCFieAZxdLxJRrFNZ34BUkgILVwWbk1gVQkFvfcC93CtRF+pmj4loeQIX/Xu6qoEJBQ71waCkcWhoOLQ2LVvm5tbRocYw6AbWMkNUMTEsN1FaDafOP1FaDac1h6jLyDCbPQJnxwEPABjIDyvy5DapKiCplnm9BIvwAZCWQl4xaSahZQt0a1CVTUQ+ZCoTj1+xduv78StIFqgsRyfVuuu6aUUwfF9o8sbPOOgujRo0CEeHBBx/EyJEje3tKwW677TZsuOGGcM5hzJgxWHzxxbHtttsCAO6++278z//8Ty/PsGft8ssvx1ZbbQUAuPPOO/Gd73znE33/xhtvxCGHHIKXX34Za665Jt59992emGafs74iQ3zCCSfg0ksv7e1p/Fda3wYUTgm8vg+DymGWRrIPRsGEZCeMDumYbXzDuc6c0ZEz5mhDLnnszJF0Co5OVcbRMa4pJyDlBbgoWxtKGNLykCRL4XtOeB6H49iYjpwCCUIehu+BkVmEbt1wDoADi5xsaSxKkgE/CrYouEQpw7KFky7K7GIZlXExOyH0ZSgxOO3c3ezwRi6IOMBISaQsvQIERIRSlxjhTiP86kABCI4tgkKVBxE5Z6hxhrozqDmD3InMq2ZKjDrhfv4ZG+TWoF5maCkztJYZWmzuv8smdEJGGvlPlhmlozlyLMcYO3C70LPDg10BAEDi5KHq/Mm51uyEHoP2kYg8GK6WcqWWTDKQyI0viwr8CkMxM2EymCyHyYTsn2nWSfpZGCSgRTI17K+bSiirMpN39BEyOpqliFwOmWICLj2vxo8WHQLMW5w2pQTaHKFN+lTU5J4zIg1rnEPGTlSiYg+ZFstoKR1aS4e2kuXRodUxWgDUDSGvZ8ja6zCLtoIGtAED24DF2kEDWkGLtsEs0grTvwWmXwtMWw2mtQZqyf2oZ6CaDBFLMMaLIPgSOgUVCZFbQIUHFj5DVuMMdRktjsLvkVwDB1reWAGtyQolNI1mMFHNqFAP6vT/N9r48eMxfPhwTJ06Fb/73e8WqDr7adOmYfjw4Xj66afxgx/8AFdffTWGDRuGN998EyeccAJuu+223p5ij9qbb76JYcOG4fXXX//Y3xk8eDAmTpyI1VdfHWeddRY22WSTHpzhgm//+te/sMwyywTFrG233RYvvvgi8nzBFQdde+21A/9joc1/69N/YbyySZKlgBBDSTTwKdHDbx7ElcZzmqHolIxFV66ZC9+4q5QsQiiBgQIGanqMTkQ61BkNc4fUm3PCbVBnQT7vo+ZeRcdvn2IfhwAoPKhg1uZdflhYyUqUfjiL0vlH62K2grmpIV7i2MYyjibFIXGCQ4YFkbeQlrekoCJt/hWc8m4kZvU80/IMlbmN8zAgZM6Xi+SOkDmCkc7ElWg/CMQGhj3oqDlRdHJZLHfiuF09fgVFjrQzgJ9HnFHzQtSHuBb1+FUJLD0ncwUEut0k0twMOoO8a3NZXDoVdS5DPX06Uj6ANsbLKh2V2VA3wKt7UAAY+ENSvpa5ZI13Py3hWqtEbMhUuaT5JHMl29fKcbQwUGef+QskeT2LoTwtzic0qJQGeZo5rDFQI0KWZ8jqOUxbDVikBRjQCizWLqCiTUBFK8wiLTD96jDtdVB7HdRWB7XWgNYa0JL7Uc9ANQPKM18uJcDCUOx0HdZ1KIOiwOXJYZBrjwpHgWcUS8DScjqEY67eOHO/ximx3Esm940IY1+xsizx1ltv4fDDD8ezzz6LjTbaCOecc84C0QCPmTFp0iQcd9xxuPPOO7HqqqviuOOOw6mnnorHH38c6667Li644ILPrW6/tRZvv/02yrLE7rvvjmOOOeYjv2OMwVJLLYXf/OY3uPLKKzF58uT5MNMF14qiwNtvvx0ax7W0tGC55ZbDBRdcgJVXXrmXZzd3e/fdd9HR0YEvfOELOO+881Cv13t7Sv9V1qcBRcKUDjyB2LQLsWs1JY+U/pyCjAgsupKhGQrblKVQgJByJUKZQwokGCG6G6vIq1Kf/jA4ccCjnxDAipRRKKgIJG3rpSK1izA7C8declWBhHVl0/Cf6dZdOyl3icfZ/V96DNrgLK3xD5Ht8Dk0Ob5zczv1ZYo/pI4SEECFnodMHLPceTAXVZcETGjXbSFg5xzlYSuAIiFMR6nYJsefmh6bl2LT83CNUyCRkOjjcTXlRNKH9Fwmik9hX6mPqa9SzIhU9pOeQykRU0lhSgnuISNEQfJYp6nTyFwyFFwEcn3M86RkdpN8JooZxMxCAAACIFoYaGVCi2YnEPlJlAA3LQOiwLeIGULdbo058CYyQ8hyA1PPPUBYpNUDigGtHkws1gYaEEEFLdIK6t8C6lcH9asD7TWgLfejVYaAChNARUrojudeQTPJPa3rsBZGLHvKNXCgGQqHKqhILGLoFFBreWICLPr2b/sF1i677DLcdNNNeO+99/C9731vgYrg3nDDDRgzZgzGjx+PAw88EO+88w6mTZuGIUOG4Pvf/z623HLLHmkGt6DYo48+imHDhuGAAw7Apptu+oHXZujQodhwww1BRLjmmmswduzY+TzTBdOYGQ8//HAAV7VaDd/73vcwdOjQXp7ZB9sLL7yAyZMnL3D34n+D9ek/MY4TZ1yc4xKeaN0wQKdhdBhGRxY5E2GYKpgoFFRkQFdO6JSSJ81UFEJ25kQrVB0sAgUAUAETLnVyu0elI581fiB15H2GwlQzFIxQl21KhikdqLSgsgRsCbgScAWc034D/rm1MhJQ4XMZmtWJJUucOJVInZXEm2Y5/7FrsoKJ2Ds4/hzcPiSx5eT1+L2KB5ZYBcBJXwAluXoVHclUcFpqkoAJJL0mJGuRZif0mCp9RMJAeC04+RUgJK+DkuONnwtAQl9rAitK9ganr1Y/E9eJPOMKJPWfoTirqA7FAagF0nDSj8GYLBCQQ6ZCnNJ4KRLlIvZZgiyJpIcO9AmIVk5FlUMTOREpkPBgwgOHVslOtDlKMhQUMxRQRkq1tEwzFVX+hQ7PUajBN5jL8gymJfcAYdFWYGA7MKgfaPF+wOB+wOLtoMXbQYP8wMB20GJtAXjwgFbwoi3gRepA/zrQr+75Fy05TD2LwCJLyNwya9K16TTLZlBDhhoM6iDUHaHOFAQMMheli6tZvpgthTwGqoShhN8h11a4HgutZ+zkk0/GkUceCSJCrVZboOrNr776auy1114oigJXXHEFdtttNwA+In/LLbdgq622+tw6Xvvssw+uvPJKrLDCCrjvvvswePBgmKbSvzzPscsuu+CGG274ryRgf5g557Djjjvi3nvvRVmW4fVarYYsy3pxZh9sp59+Og499FAAQL1eX6Duxc+79W1AoZkJBRTsHeSCGJ3GYY5hzMm48thhPHeiK1MggZDRKE0sgerKCB01oKNG6KwBnbkvkSpMWt4To7ipdGSlzMm/WXHwvO8YS1ZC4JEEnJCPrButx07KqUJk2HowYQqHrGGRdVnkjRJZo4ApCpiyAMpGGGwbYOsbmzknZVBwgbheZuRHqpDULJtJCM53CpKiw+1J2VFpyaBMhvIsLJH0iVD1Iu2lkBC75RoHtaXgnMbHKMWpoEL5JdFhyziXUVNohtCGrYJs0ixF0uMhNEgDnDQ98/yApv4eUFCh1zl53vRPszWxmR0QG9Lp+wl4SNZ8Ih6F5i1XLszcothAtRQn8Clyz6cwngtASnSHkowRwWzTqGQrVB7YMmplHHWr/UcESHA6kqyE81kJz5tISp4A1AHkUElhzY5VtdhC521GAio8GKkDyImQZwamJoCi3QMKWqwNGNQODG4HDe4HGtIfGNwfGNLfA4wh7eAh/WS0y5Dng9vAg9qAxVqBAS3AInWY9hzU4rMWgbydAAuS7ETNGdRdhrrL0MoZWl2GVjaeRyJNOnNVwmoqgYIAN3+bCs9JeBJBpSozoJz8EGnchdaz1tLSgokTJ2LLLbfs7alU7LXXXsPAgQMxcOBAnH/++ZX3/vjHP+Kqq67qpZn1vB133HHYbLPNYIzBSy+91K1PwQ033ICzzz4bkydPxqBBgzB+/PhemumCa/vvvz/23Xff8PNf//pX/Pa3v+3FGX201et1vPHGG0GQYKH1vPVpQOGb0nEgM2tDOAuHElHZqVNARAAQQdIy9mxgxJ4TzsTmXI2gAEVJ+ZNvRhejzdHJThWATFrrjDQynYAKTp1BjQyLg4Do1IUsCGu5kxA3S4esZOSFQ96wqBUOeeGQlRbGljBSCkWuBGtZFFvhXLioikVJ/4YQja9yJgIwimkL75inRG1j4LIMNstCV+wy852yA6gwyr+gAMx0pBmC1DeOkq1Nj9LJPHBLNHtjCcYZGOe7iXuR/sgQTrmtup8o+inHFJrIJaDCJKCCkkzA3BZomp6SnYXIcsqXiUsk8myajr0CNLgKIeLm45dIfk7zPf7SyTGGkqfMZynSodmLJDvmz16iXpSCCskKBLJ2yaiXjBZ5rAuo8GCiualhbGyYQ14HkIOQg7pJMJv0WJJ7P2QqJOdlAGQgXyoF8mCCyJc8ZSoTm4FaMqCtBmqvAe0+24B+knnoX/dZiEVagEVbfFZCMxSLtcIt1gq3WBt4sVbwYi3AgDqwSB3cngOtGVD3Dn0gRQuYM/CAN3dewrhuPb+nzqL85EwkaAsnpJuscnoekGQRTTKy+BxmIaDoafv3v/+NPfbYA/V6HSeeeOI86dY8r4yZMXv2bMyePRu///3vceSRR4b3WlpasMkmm+Caa675XGYqGo0Gxo0bh5EjR8Jai6OPPhrHHXcc6vU6rrvuOnzta1/Dgw8+iH333RezZs0KnIGFFq2rqwudnZ3h59bWVrS0tPTijD7cnn76aey2226o1WqfyzW9oFqfBhSMpL8CNEvRxKUwcZQqq0pNUpbpNpPSFXWyS0o7AKvjHTvPBh4tqoBCS0Sqc5b/uTn6HB14VVPSSDFSMJFgFA8q4AGFDgEUeemk87AFiRoWhFsBkY1VMFNpqpdE1pOZITT0CmBC5icOKBlVCTJwMmwFWGh2oonALedEy6MCqJBrkYKJmBaJDnbzOTdC0DaOQDqk45eWVwXeSBrtT0FFE4BSPKJNCWNGJrmGqYeXevHJnlN3Lp130+L44Ed0BxzN67ey/irHhTRNESLmVXJ2FoGGOr8sTr1kyYJsrjyqjGzMTnilpXoKKmy1vGluYCKUTaE6KHmM91gCrioZGgUUIpoADyryZBiJ5BuJ3qNm/KgboJ5FsnWLciRq4DY/0M8P7l8H95fHRergRf1wi8jr7TnQkoVtU0aVskFCLGHMnUHuvJRszUmzO+dHUIvT0jKRdI5S1N3FEkgOXkufkCVgYmHJU4/alClTcPPNN+Oaa67Bcssth5EjR2LXXXft7Wl1s2eeeQY33ngjxowZE0p8llxySeyyyy74xje+gcGDB/fyDOe9TZ8+HTfffDPGjBmDwYMHY+TIkdhzzz2xyy674JlnnsF11103T7trfx5t4sSJuOGGG4J4zEorrYSdd965l2c1d5s6dSpuu+02WGux8cYb42tf+1pvT+m/woiDtFDfsRkzZmDAgAH47qCV0GIyLVTxb8rfTN8AzBOGvQqRV32KkrLsuRGZdvP1ZTosf3QJ/g+3RlfrJaOtBPoVQFtJaLVAiyO0Ok+klCIaz+MwFDIhDeFu6M++mZ6AGoSAeXSApN67rg4FRwlasGZSfLO+EEeRsocQUc8INgPKTLIAQHBpvdOYg7IcWVaHMTkMZT4aTbGNnMqwGgU6TNCO3bAWsBZkrZfubJKbRVDh8c+V6Bv7G8gQ4OCMCZkJwLuIxC5mIeCdsfA+Ozj2qlVeGtehQX7YcF4McsqRU46MMuQyjPAItLws5IbkReUcBHWltI8CCXxQNBIIs4l3H7IWFB5jNsfvoyLOw95ZDybAKsitUtwdEpBAYc46f07eU9ia3NrJ/iJ5x4l0sJcRdloSZwufzdLr7ORaSLlZs/NPeq5kaHbPZv6xzP3rgP9+Xjq0dYmUawn0K4HFSqC/Iyl58mVORq6lJaCLGHOI0QWgAKPQ082SRaEMNQhXhrxyUm4MMiN9I2oZXFuOrkHt6BrSH51D+qNj2GKYvdwgNAa1w7bXYOu5v//lmpJ1QOGAwkY1NZVw1c84ByocTFcJdFlQZwme2QU7qwuuo4DrLOG6LFzDAQ7yfX+hw+8ncujKLDqpRBeV6CSL2WQxx1h0Gt8Tx/+uUkBOcr7Te0Z+C1YwdwTeYAY3Csy6/iFMnz4diy66KD7Ppn8jesuuvfZabL/99ujs7MQqq6yC6dOnw1rba/OZm2kJ0PDhwyvKVDvssAP++c9/wjmHGTNm9OIM570NGDAAl1xySaXsaeTIkbj77rsxZ86cXpxZ37D+/fvj5ZdfxqBBg5BlGSZNmoTVV18dM2bMWOAyO/V6Ha+88gqWWGIJjBkzBvvss09vT6nP2Kf9G9GnMxQlxa7WaeSfITKq5ELk3YlzFqOXFJrPqeRrDvJSpEkEUbbq+y3IH3OrfQ6S0qSgMMNRvSYQK5tJlWGr/rmfEwWnPjZrU6hEkW/AXmoWDt7Bc543kJdAvQRaSqBeMOoFUCtFflJSGp6/oecnlj6FR2d9XwvnsxjkBIqk2QFAItsZKMtBWQ3Ia2AZLs/h8hw2y2OGIjNC+k6yE3o89CEDcc4OTjgyLnA/nImlWZ5vkvmeE2yQOQrOfuhTklTdMyeALEkpUHgez71mS4JqE8WsRHOGIzj9iFhC1x0qW47qUmEVBPCRLPIESFDT9run16qZD5N+VgGRAE4/TGh2R1kGynNpepdL+ZOJJTqg0JsknU/gLDigbv36aysY7QWjvcHoVzD6NRjtJXxPCOk3UWPtmO7vDz99FVdISpmS+yRmHRBVveTud+yvbYTOkgEJ2Yl4z6dASK8PJ+cndMJOS6NqGVCXzENLBm7NwG0epLh+OewiNdhFaygXraEcUIPr71/nNi19MrEUSa6950T5LEW91FInz6locQYtzqDVEVqtD2DUbZTFTQnwsppi9qmp9ClkpBaWPM0323PPPXHQQQdh0KBBePfdd7HWWmv19pS6mXMOK620Em688cbK67feeiumTJmCZ555pncm1kNmjMGLL76I3XffvfL69ddfj9/97ne9NKu+ZdqJ+p///CcAr441ZcoUrLLKKr08s+7WaDSwzDLL4I477ujtqfzXWJ8GFGntf6XsIY3GIjpXvtTCq73UoIRN/3Md/nldsgNewtFTeAlGIuQJWTfhFqijo6UcNdbyjkSpRUYzkPA+gC/FyBLehDq2LBkG7xsr9yIeV8of8KRkjs3vtD8AayZAJF4VaCVgAlIKBSmR8lHppHO1Zh0IsVZbnFHOM3CWwTUPI48Um+AJFgqlQwocKmVXSGSABUB4MCH/SAAFASxdu41kI3LKkcN3wCaNwktGQ7uEa1lccw8H6FWRuq+QvWAErkZzOVF00eJ1DRc3RQZJSiFVjlIgUVGSagI1JHOiZH+paxhARNPr6YcDmDDNj+Johi7aGWDSEZWfQhaJKkcqMqi+NKfm2AML68FDa8lotQiPLSVCCZR22tasiU+cJMphiCBDMyPK18gQQbqCEGYXPq+gInapR3gtWuRepCIJ1UuWcBCE9Kygw4MzT9a3OaGs74cBsgABAABJREFUE8oWQtlqULZnsG0ZbFsO15qB6wacJ869XwhVWV1HQUa2hZWobdDKHlhUmt+FLvPx91zTMotglpreWGg9bs453Hrrrdhmm21gjMHll1+Ogw8+uLen1c2cczjmmGMqnIqDDjoIp512GpZcckk8+uijWH755XtvgvPADjnkEDz66KN45JFHMHDgQBAR/vnPf+LrX/86iqKAMQYjR45c6Hh+TGvOtC2oak8AQtZk2223xd13391N4WuhzVvr02c3kIhRjRQriVVVX7xKTZJBUGCh5UVMqLERQBGBhq/zNgIqNAoYI9dq6tCZyvZjBNYEDfnmLEUCKlBV1SFUeyEEwngaCeek9EQdXclcqOY9FExQ0ogugAonjphyUJw4aL4UBkmH3oqKUIjqqmNlwFnkT3C3QRUg1pyjCccZwIVmA1KivUVs3edLxmI02ROLM8qRU4aMPKAw6vkGzog080M8Js00xKuRmKK3BEiYACxUlalpUaZevZ6j9JiTXVSARQJQUyCTZihC/iR5rfqNuUxfnf/ow/r9GZKFo8RzE8FDFp9zCgYTEJheM91ZJGmnfSASlScbm9elDfGMxgECyVrzDlw5zrSHRSbXwO+aRWSgWU+L5V2Exxh0mPtoZmQ0YbtYYiQXwt9bws0yjDIDyhqhrBvYlgy2JYNryeDqBlwzPjNkkEgJc9iRkt5z9iVbdTaow6CF/ahXAIXwTkLQgKuAswlxLpROnP82depU/OMf/8BZZ52FJZdcEqNGjcKhhx6KQw89FIssskhvTy/YSy+9hDvuuAPnnnsunHMYMWIEZs+ejUsvvRTrrbceDjzwQKy//vq9Pc1PZQcccABGjRqF9dZbD+uuuy7yPMcdd9yBSy+9FI8++ih+97vf4Y033sDgwYOx0UYb4dBDD/1cckjmtV1zzTW47777ws/f/va3sd566/XijD7YbrrpJjz66KNYZ511ensqn3v7xIDi73//O3beeWcMGzYMRNQtXcrMOP744zFs2DC0tbVhs80265Y67erqwiGHHILBgwejX79+2GWXXfDmm29+4slHhaDocDdnKJrBhM8eRL33ugCJFslMxNclSwHpVA0j9feqz6+SsTGKbKSkIoIKdZq4EtVmhMkGMJGSUIM0K2LEliVqq4doEgfE91OoOqAQHrb0xPLcDpL6dvJSuZaklAixazbrlxLitjpg0SXj4JSmKkjqmAZQkSVgwsTyIYF8iRscSfUeNGl2IgEUISuRkMeFTGwogomaggqjrJYIlpyLwCIl8aLbT03ZCQUVzYpSyTqLoWAg7UcRLrU65IiOeXD40591Uej+wxwiSIz5qw/JTDSnMBCzC0j3qbU/hgRExOyEXkst8VN1s3DPNYN5JNkK1oyF9JmwOjxxuybNCAMQDuAAlbWg90qqJqX3sieIJ2VS4AAY03smFZf1GDHNTLimn2OmJOBRKUNLr2f6fQ+CFOgqqDAeVLQKqKhnsDWCyymohCl4dgmwMPL7psYGdWRo4Qwt8tiqwIKpCZBxLG9jjsGLsAzS/3vWFqS/DwuCzZ49G4cffjgef/xxrLTSSvjpT3+KM888E2uuueYCBSqeeeYZHH300Xj55ZcxevRorL766vj973+P1157DUcccQS++c1vYqmllurtaX5sy7IMyy23HI4//nhsvvnm4fU333wTv//973HRRRehKAr89Kc/xQsvvADA8wPOPPPMBbpp24Ji55xzDv7v//4v3JfHHHMM9txzzwVyjVxyySW4/PLLYYzBsssuu7B7dg/aJwYUs2fPxtprr41zzz13ru+feuqpOOOMM3Duuefi8ccfx9ChQ7H11ltj5syZ4TOHHnoobrjhBvzlL3/BQw89hFmzZmGnnXb6xKQ15TVUIqZNDn5Vl96DBN+Jl9DqjNe8l8d2GW3Wk61bnfFlBmln5US8Uvz2BMz4PWuNt6ripBHY1P2K2YkYqY0lDBo1RcWxAhA4GyqxqXXh6ZwsfJO/EoQChAZR7BCeaWdwUb8SZ92XFilfQWvYXahPD1FgcegrDhEpgVkARqbk6wgqNGLfLJ/b7PQpmPAOmgvgRyVunQAX5XFkWY7c5KhlNdRMDXVTQ83kyIUD4B0sKe+SbuK+1Ksaja7Gp8OLICYBEJTI00bp1EotvpYThWONGQoFCxFIcAVQRCAQF3SzYpiW8DSrLTVNOTrCCbqoJGLCXClkelT1CcaXPnGWiwSwqfQpSdXOVFwgvQeAajahbjkpgZIeCw6hrDB1hpNlH5xjQnPDuggs1HlmZlhx6kuwSEdHzk2p64kdrGMPLm0KnquldmFNkoJ6JD1v/OedbMdZi9I6lNaiYIeCGEVOKFoMitYMRXuOoj1D2WJ8WVTOKI1DSS6ICijY8YCMQtlTG+do5wz95LHNGV8GJdmKXBoG+mxFBBZzBZnzwRakvw8Lku24445YfvnlsemmmwIA/vnPf+KAAw7o5VlVbc6cOVhllVXw6KOPYp999sGtt96K5ZdfHi+++CIOO+ywPqWCtPTSS+PVV1/FsssuG15zzuFLX/oSbrrppl6c2efHrrzyykrm6ogjjlig18iAAQPwyiuv4Itf/GJvT+Vza58YUGy//fY48cQTQ7fN1JgZZ511Fv7f//t/2G233TBixAj86U9/wpw5c0LjnOnTp+MPf/gDfvvb32KrrbbCl7/8ZVxxxRV4+umncc8993yiuajSSehhoJFhChXU4V90wlVFSbryCoBot/7RPwfaSt+tt8WZhFNhQmkSg2BBotrkR5lmShJybVofr++HzARTxfkKEUdVEFKnijlkW3KGz6JA+CDC9YA426UBCkNoGEIXAV0EARPxZ98p3KFBNjwW5PwQp6wMzllTxoDZ9/8AB1coLTcJEVgp7VDQEUqZUieeku8FHoULJSSqjhUa7hkDTpqxZcaP3OTITYY8kyEKP5nwUzxyEVUj9qpGkZTuqnNKRjQKikxpH4aQnUCafWjqsF3Zppa6yNpo2ksAMWgCE6EPAaSEDrHEjRNQ0bS5sM2mnysvhWL7KCEbshRZFrIUXg0tjqqUcgL4ZM0DESTnFpKZgNxPiXQskHQt7+776jmP2Yn4XB1oD0wZpQCJAg4NVf+C844+OxSOYZ2DdQ7O+sFW1a5cJdthgQBsY7+LmMmLJVoeWFjZdsnsz1FuYCVLUbYalC0GRR0oMkZBFgWsAAoLK9sjAas16Ufhgx4Z2nVwhnbhVbQ4QksoIVP1La6uh27XuWdtQfr7sCDaq6++ipVWWglvvfUWfvGLX+Daa6/t7Sl1s7322gvHHnssllhiCbz00ks4+OCDcc4552DVVVfFSy+9hCFDhvT2FD/UDjjgAPz973+vvDZu3DistNJKmDZtWrfP77fffvjZz34Wfr799tsXqB4iC+2z280334wvf/nLPaZE9c9//hMvvfQSXnrpJTz33HNob2/vkf0s6DZPORSvvPIKJk2ahG222Sa81tLSgk033RT/+Mc/AAD/+te/UBRF5TPDhg3DiBEjwmearaurCzNmzKgMIEZ104hs6rwn1MwKqMg4lj21WITOtK0yWizQYsmXaDj4BlROSos4btdnSAilDAUVlahtWiICjRrHCGIGT8Y04iimBG4fCY/ky9BAjCGkcj8y8hdSswSlIRQZ0KVN+YzPUJTQciegBKMQxysMkqgpccwKSLTXsgtgIoCH5tKRFCyQHjuCA91c2a6RX81SsIAJp/sWyVabCZjIDDghDRNloeTJaDM2JbgbE17TLt8aa67wKYKjWMlNVPnaGkGHv/5pZkCvY1oWE0fST4Oq2+vm7YWwfCyNC4+c8jZkzIXLER1JmW3T9pC8F6dC4UP+PBlRd0r6oFQkf5WLI6AirBXMJVuIEHVPO2sb1s7bUUFKM3WE+F+EGHq+I5BTIOL7nvvzoKDXr2dGQYwGksGMgtmDCuudfyeDVQ3MJTyOMAQ4p2uFY4ZNL51fxxQ4J84QXG7gagYuNyhzL1sdMhNcohRw65SzJPd95uB7U1iDuo3gotV6INFqhU/BUV46DUikZPTKsutF66m/D8AH/41Y0KwsS7z88sv45S9/iWeffRYbbrghTj75ZLS2tvb21IK9/fbbuPXWW3HSSSdhxRVXxH777YepU6fi7LPPxoorrogTTjhhgeVUHHLIIdhvv/1CZuLkk0/GUUcdhVNPPRWvvvrqXB3Kt99+G7fddht++ctfAvDZjW984xv46U9/Ol/n3hdt+vTp+OlPf4rJkycD8KpPp556Kvr379/LM6va7Nmz8dprrwEAfvKTn8yz/hlLLLEETjvtNIwYMQL//ve/ceedd2KVVVbBSSedhFNPPbXSXfy/weZpC8FJkyYB8E1yUltyySXDxZw0aRLq9ToGDhzY7TP6/Wb7zW9+gxNOOGGu70XnlUQ2Uhy+6CdVPkxA0P3PnDgAHB1Cdfo958A74RbeaQhqKpyUFRFgiEMfAwOGYQqRed8NOpa2+ERC5D9koEqjLwUWYFQyFMYhfNbzNHxpFaBzZrBGjkN3bwETSYkKyzkxFF0gzRQAkJ4Cek4MMsRGYaGZVuJI++fsHU/duHqwzSdNXBoPPbT0iRPFp5ilSJ177+wqX8KAybNaSPtlJA6+lvkwfAMzp5Fv9deZ4yyY4NglgVsTjyGZtT8cdW05/KzOsi4slrmmj80x4bi9ZH1y8yeTnhJhyPljRIItC5dF1zv786hb0vckeRXBA0iuTTon+QSp+IB20hZUZ4zn1xDBGY6auyTVUtI0QteKnM14VE0gLAUFUYhAEnvJ8eg50mH0HkMqAevXpb8ntSTP+TUQQIkHAoVzYZQhQ8Fg6+AcByDJIRShgI0rQ0GFnucQvNDslNEzznCZA+cAZwAbBpMFuEx6e8CXUlKS/5RSOWPibcRs5D73jyWkb4qce8/FkHWZnkc9lb2MKHrq7wPw4X8jFkS78MILscgii+B73/sejjzySPz1r3/FU089hffff7+3pwYA+M9//oOJEydixx13xN57741LL70Ut912GzbffHOMHj0aU6dOxdSpUzFhwoTenioGDhyIFVZYAQDw/e9/HyNGjAjdsc8991xMnDjxI7cxbtw4vPXWW9hxxx2xxhprYIMNNsCwYcNw77334umnnw4NABda1WbPno3TTz8dG2ywATbccEMMHToUP/3pT3HXXXfh3//+N6ZOndrbUwxWliWeeOIJ7Lbbbpg8eTJuueWWz7S9oUOHYqONNsKRRx6Jp59+GldeeSVeeeUVrL/++vj617+OlVZaCY899hiefvpp/Oc//5lHR7FgW4+oPDUrijDzR6qMfNhnjjnmGEyfPj2MN954I9kZEGU3k8ggUbdyKFInnrX0oikzUQKtJaGl8M9bSinTsJKhcIgSrMLfKMhH/7uMDPIOfIMIBVV7L6hjp1r6VYlZoGY5jpKRWx2Jag5DiOMI4MIAYEOwGaHICF050JkMBRaFRpbBKJlRspaGWDRg0YUSXWTRJWVQhZRBaRmJTWRX50pmbfoXmwui8lxhTIUzQS4MRw7OsB8ZBZJ3JA0nikQaVSeqdCImzVgoj8JoBoGjfKwTOVkXsxXqeGoGJsFBslDVzYT699W3P+yxG7rg8IEUrKSZBUpeU+eTHMdSJ4cmZa8kS8FRcrZ7+iRJJai7Lk6snsuY9ZFzSOruJqphKZ8i5VVQBN2ahVJMFNXJkk7cklny106OPClfVPfez1YzGgorFTJo5s1nJDooGWDMAaODGZ3s0GUditKhLB1s6WCtg7Psh0uGEK5ZuBYI6mfJeSS/Finz65OyTCSVTej54QxQkr+nGlyicAUKW8CWBVxZAqUFlQ6mdCL/LGViJVArCfXSoKUgtJSEtoLQWmp/ilj2VHOQnjcRuFWu+QJi8/rvA/ARfyMWUDv99NOx//77g4jwwAMPYJtttlmg1LimTJmCddZZBxMmTMCBBx6IU045Beuttx7effddHHvssbj44ot7XYaTiLDNNtvgX//6F/71r39hxIgRYGZMnDgR66yzzscCE2rvvfcevvrVr+KFF14AM2O55ZbDv/71LwwdOnSBui4Lou2+++645JJLws933303dtlll16cUXebOXMm1l13XTzzzDP+79tnWLvGGBx44IG49tprYa3FNttsgxtuuAFPPvkk1llnHayzzjq4//77sdVWW+GBBx6oNI78PNs8/W2g6gjNkaR33303RKWGDh2KRqPRrZYx/UyztbS0YNFFF60MQCKjAADJAMylG3P6GiiVZiTUtKypRAAR9TAINX2UP+6+WRqCM+bgS55SvkKnIXQSBd5CkWYFEDkcWv+clly1qE6/ducWZRwFP3UXwUSNfSM+7WRtDaErI3TmQEdOmFMjdOSx7Mk7feTrwtmPUiO27J2cBnyn3gaVaJgSDWNRUImS0lpvC8dWwIW2iqvSmeNQ8jYSoJf2D9G6+yYwIWVPwc8NCkQmhsPDL/jqL/oYxZYhRGOS7yoZ2rHzxyJdogNZ2yXyWMzReQwdjgFm6u6nVRz1JHMjb3bPOFSzPGh6XeWAU1ARiNgKGhyBnJRhCahIuRYf+Ccwmbw2qkv9zQgoKDRazJCFhosaha+UPimw0CwZVYnbKbBISeYqkRwaszXdv2mAoJnortc3g0EGz4S38J20uyAgghizZMwkxiwwZjvGHOfQaR2KwqIoLWwpnArnKmCCNWvRNAKAU/AqjQFNLQfVaqBaDsozDyoMeWI4WxSuRMMW6CobKMoulGUDrihARYmssMhLluF/5+SWkJeEWgHUC/KgoiC0FoS2MgmGJHKygbCegK1YPNZ71lN/H4AP/huxoNvYsWMxdOhQzJgxA3/4wx9w2WWX9faUutnGG2+M008/HauuuireffddbLHFFrjsssuw8cYbY+LEib1aL37FFVdUHFnAZ3++8pWvfOptbrLJJjj55JPDz0899RT233//T729hbbg2Q9+8AOMHTv2U3//wQcfxNFHH40XX3wRSyyxBN55551un9l3333x3e9+F4suuijeeeedz7Qm+4rNU0CxwgorYOjQobj77rvDa41GAw888AA23HBDAMA666yDWq1W+czbb7+NcePGhc98XPNEZU4l/KEB2bT8IDimQMhSaKYit+SH0+e+FCqTR61n1nIkfdTIro/C+tIon61QIOEzFOpEaY+KGvtOwZUh4KFmfYftuotAQoeqVGlWI5cyEUg0uDBAkQGNjNCQrESZUYgaR8nM6AxrfXgkk/ra7gJKGC0jkJBOEJZdBBOJOs7cg6DiTlMC9LQO33ACKpp7YiRReo4O59wpu1FyMzj0+r1K9qKZDwBEPoUVSVmLlHQLdc6Fr6CkGD2PDt2BRTNBOnIcEjnPMIBU3jMFGPqojQk9INHyrQ+QjpU1GT5fvQzdLYAKhAh/TFYoKPOAwpCRArNYyJTyZDQT6KVlI78ogImQIGE5F/HckCJuUNieDd/X7UUukt9OAiqSAfgytwJAgxidBHQS0CGPnQR0gtHFwqlwLKpPfiiXQklQSWUYqisx9qWhkKHIQHkcvp8HRQDrSpQ2GWUJW5ZgWwLWwVhGZjn87skswUggIxMel+dVqARv5Hlpz49AdoeCiggQextSzO+/D33ByrLElClT8L3vfQ/jx4/HZptthksuuWSBahY2ffp0XHbZZfj5z3+OQYMG4aSTTsKzzz6Lk08+GUsssQT++Mc/4ktf+tJ8nVOWZfjDH/6ATTbZpFKv/4tf/AIXX3zxZyodmzFjBq666qrAoVhsscXwwx/+EP/7v//7Waf9ubYxY8ZUyO0HHnggjjnmmF6c0dxNxRAWW2yxT/zdAQMG4PLLL8eaa66JO+64A4cffjjee+89qW6o2qxZs3DvvffiwAMPxIABA3DSSSfhyiuv/Fx3Zf/EHIpZs2ZV6iZfeeUVPPnkkxg0aBCWXXZZHHrooTjppJOwyiqrBHJKe3s79tlnHwD+gnz3u9/FEUccgcUXXxyDBg3CkUceibXWWgtbbbXVJ5pLUNrRFz7o7yXFOntfc01BJ98AwRt0mvEQh9M47xNEv49DqQvCI4HBsCBIET8cABKP2MLLlhomwLFvSoxqrwrfr4Kjeo86M+mxgoJEbEaenKpRWyfR4cJ4IFGotCdF3kR1uRPQRCx18PDIIjqYRhxLzzsQJSlFbIlzr2yOAOo4+PXBSU39fQcti9HO2Do/ca7T6L1eO0oc6OT067VhcCK363eq5TPe1WThA8SL5xMQLkruOn/QcwcuVKnrT/dfOVD9fy4ZgggsFCRIIR7F9zU74QFCTB1QegEp7ie+7H9qmmJ34/jp5MfKawmqCOfPwDe5U2DGoIRvkJS0wV9bkABv+ONUH92EPcQiJt2vv//Ss0Z6x4Xjc0xhzeinfZZCuEw6HyCoNGn5nc+SJEIAjoP8KwshmhOQVzknRBK4EDDlYa/ioGR9Mkjnx843oAf7rJ6zAVTAlv73gSU49ppxhjIYY5DJccgN4KuqKN47ufEKczUHlI7grL+XSvLZIV+m5cGXoUjNnh9lGwvS34e+YsyMMWPGYOWVV8Yee+yBffbZBzfeeCMefvjhuaoS9YaNGzcOM2bMwGabbYaddtoJb775JsaNG4e7774bu+++O8aPHw9mni+14gMHDsTGG2+MffbZJ5DZy7LEPffcg6uvvjr0lfgsNm7cOBRFgdNOOw0AsO6666KtrQ2PPfYY7rnnnj4tYdxT9tRTT8E5F7I766+/PlpbW/HEE0/g7rvv7jGFpU9qd9xxB1ZffXVstNFGn+h7Sy+9NL7+9a9j3333xUMPPYTrr78et95664d+5/XXX8dVV12FXXbZBVmW4ctf/jIWX3xx3HHHHbj//vvR0dHxWQ5lgbNPDCjGjh2LzTffPPx8+OGHA/CdEi+99FIcddRR6OjowEEHHYRp06Zh/fXXx1133VVp4nPmmWciz3Psueee6OjowJZbbolLL730E0dlfL1wquPE/g+/fiD1mkhrtr3CTGiOpU4Rq5+mf4gBMhSixBCwkXBjAWgZB4nbQkIqTh0j710b9rKORIQa+0hixoSc2c9HwATkUYPY4VjJZyVy8nNXB4cFNCigKA35R0rIz3oKlPwbnF+NkiuwEN6CqDupK8Lw3cIZBG2yoEU4BCGGgsHCCFYiK4fvp9wJBM5E2nzMO2DxrKWlMDG6mkRZxdmOgf4msAdAY9aGIFFiOSZ2YEeCIKITyUYmSiYhakcytv7fTQqWyQPIdN9OFhRFcKkbIJesWapmGPTc6bqM20zAijxTAra/nFx5N342hWrdTbeqDjJkW8pjgGQnIGR4Rw6egQ0gXEF/D6gTbwySNaVXIqHZc9NAXBsRfPrVl4X16j/oCCHL5jMU/jNOYK2udgeggNwHAlxtALCJ1piSrMO8GFRhuiPca+rg6++JcM78rRAuGGmKyv8igIPzYMJa2DICCrIM6wjOZWA4GOOQsQ86GPbbZLnlHBMM+WACO5+FKYlgFZCTHKuLYD5mdCQjNx/q3Rekvw99zX7zm9/g6aefxjXXXINbbrkFW2+9NR5++GEwMzo7O3t7enj99dexww474OWXX8aPfvQjPPzww9hll13w0ksv4Re/+AXWXHNNfPvb3+4xJ6m1tRVEhK9+9au4+eabw+vWWkyZMmWe9yphZnR0dIT9jhgxArfeeiuGDx+OqVOnLgQVczHnHDo6OtDW1gYAWHvttXHzzTdjscUWW2Cc55aWFtTrdRhjwjyLokBZlh/6nZ133hnnn38+Ojo6MHr0aDz33HMfa3+zZ88OqlIHH3wwTjvtNPz1r3/FmmuuiVdeeQXOOXR1dX32A1sAjHhuuZoF3GbMmIEBAwbg20usiLqJJRhaguB/UOfWg4iaA9osSVMtaQplY+SXEVWbSpJeDuSd9CABCwQvP42ChvfEQTfiuBJJEzJyMMQ+MwF4DoRTdSeSBl0KVkgi59XYbEaEGknXbvJ12R0Z0JEBs3Lg/TowrU6YkwOdGaEzAwpKnHVEd5xYOnNLSY/KTBqIBK30b8iMQWZ87XzoBWANcmc8CEKGjDLklIfoqhJrWcL02qsifbThGaIjTFXwEB1uis3WtHwJVJEQJdbeHQmYoQhcVPq2hI8SO7bSd8D6sibZl4Hx/S0oE1K31MdrmY+WbUGcZdISLRcuVBpZrjyqsa4RJMdsZP8IYCI2e0uzIAmoCGVb/kuKEfW8qyOqSlrhs4lVphVWsJRmOQY5By4t2JawtpToegHrCjhX+rIwdgEsV4A6OEiYZk46ZDuWrtm+rK/ShwIxyq8gQTN5XlrZA+LqfafXg1CC0EnAHGJ0ChG7MwOKPEOZGbhaBlevwfVvAwa0AQP6AUMWAZYeCCzeH+jfAmqvA/VcZHP9mlDnPsixWgasA7sEIEuPjtDokR1sWcI2CtiuLhQzZqPz3ffReG8miulzUL4/B5jZhVqDUbcGbZxhEbSgH7WghXLkpoaMpLmgXGdfuigCCdIvpjMr0ZU5dGUOjZwxp8boqHkuVSMndMqjloyVRYn3rrgH06dP7zMcg09r+jeir5kxBgMHDsSkSZOC2MVbb70VVIwWBKvX67jgggtwwAEHYNasWVhuueVwxRVXYLvttsPkyZMxbNiwHolGv/rqq1hqqaV8UC4huV577bX41re+hUajMU/3R0So1+t4+eWXMWzYsPB6o9HAN77xjQqoWWjeiAgtLS14/fXXQ7+SRqOxQAGKhx9+GOuvvz6yLAtr5uijj8ZZZ531gd+58847scUWW+C9997Dsssui0ajMdcyp4+yLMuwwgor4MUXXwz7fuKJJ7DBBht8qmPpKfu0fyN6V6LhM1qlERwjaPRHiw6YcicybYrlSBpkkThCqcSkN44eWpVMywikTHX4lEthFZCQd3K8LK0nzxrnORp1IVG2JjyKuig45ZWsSxwGCLr9GpWO9eu+5jxwR5rmq1K0obeF7CN1yDU7wg6h0ZdznrhccuRSlKTDCasiwoVq06+k3wOUc2FhuYTjEswWYBt4CplI6Oq1UKJt9Z/wAzg6wyGzgqR8SjElKHxPVYSM8eoOkeitKkISb5c5+xMRy6jip5IR3tNz7PkWxjGytIMx+2tHohLmwQJ1a+bWvMbmigCUMKTPjT7qc2itGirZqKbt6fkLm9OEBNI3VDo2g8nyMMjkMCYHCfAiJcnrLqmyB7lOyaDqcwXszSM5xZU7GQo0w+RNmEciQOuln8Ghe3ZJ0lMlgFoW7j2HbFc3fkuy1tQ4PVGUziz93SFrSTppW+FL2LKEs1buLVVNS9acYxjr/PqxyToKXC75veV8j4qaNWixBnVLaJGASeBUsA9g5ARkhpD16d/2/x3mnMP777+PrbfeGttuuy3OP//8IF+6zDLL9Pb0AHgH8bTTTsMRRxyB/v3744YbbsD6668PYwwWX3xx3HPPPVh11VXn2f6WXXZZ3HvvvVhqqaVQr9dRq9VQliV22GEHbLHFFjj++OPnOZgA/O+Frq4u7LnnnhXwoNHthdbdNJu222674Y477gAA1Go13H777VhvvfV6eXbearUabrjhBuyzzz6o1+uo1+sfmP1sbW3FHXfcgfXWWw933XUXdt99d3R1dX0qMAH4bNqbb76JLbbYAttttx1uvPFGrLnmmrjnnns+F0GeedqHYn6bOnJJbLX6ZlLGUXHOOWrYq1WWR1J37N+U7YaSoSStkThHWv5ExCELoPvzc/BOfO5iU7qc2ZcTsdR8KwcjFogg5hZ0t7EmXKOP0YmWR9Z9x+1EVwuxf0PqvIabhOCcvEjOK2WBwcpFEH/KAjBCqI6lSN2d/ZCTUHARz1Ti9HMAS2nkPtaaxKOj4ChXr1sAE6zZDfWvpS+FALyQFSAW0n61/4CHJwG2Vc59sqTijATMKrgghlQFeW/Znz8/JyX5ple0+xFWd0Zxy/Kh6LzHDIgci56T5jIrIYCE6VN1ReleGAlXhOCzQ7qWoGDUO+MGnntA7CrzpiYvnJL/QrGRAAnPj0mzMPE5h/8oHHZ6jjigIIF7ei8qtwjS1R1R/jUgBxnKU4nFgckkqOler/6SSNGXfL57zwoXOnLb0JXbWQc45zORCoZlfiwEKnJ6Txk4E8+Dn4Lxv2+E/wEiOGtQGocyA2TzQc0tTHE+cCgW2mc3ay3uv/9+AN5BGzp0KPbaay/su+++uP322/Hkk0/26vwA4LnnngMzY8SIEQCAFVdcEYsvvjjyPMfmm2+OfffdF7fccgsee+yxz7SfL33pS9hxxx2xxRZbhNfeeecd3HzzzbjvvvvmS6nIww8/jDFjxsAYg5122gkAsOWWW2L69On429/+1uP774v20EMP4a233gLg//Zsuumm2HvvvdHW1oYHHnigV+ZUr9fxrW99C0OGDMG0adMqAH299dbDLrvsEoDjZptthhVWWAGtra3YaqutcNddd2HMmDF46KGHPvM8Ojs7w7oZPHgwWltbsfPOO2P//ffHrbfeipdffvkz76O3rM8DiuD8BOde4YX/RIAT6sixlv2kjq8+UjV6OpehpfIpiPCyqGlZFPnGcUK8Zd0/q1IUxx4ULH0kOM5Wsx0pSFLugR6Vj7iSRFtpLhr/EWwpoTwAHFBwTVLJUj1P4Xywj+CC/fEZuOjVyccNnH89nEmBHbJPRzE7kWYyIjQwoTZcO1qrw5tcZUSnLb6aOnh63RxDyq7Sbyf/Ej4GxFn2DPeEpM4sZztZXKmTDTTtOKoVpb3Z1VtO11UCiUItfpqlqFjiDKaPkRMvYEg99ipzO0yYwAELU2WD1XuAmg7Sb9YAmoAgKWWKRV/SHwDwUE2Pn6BNEE0KhfQykqwnWVdBnQpyLwBV4JU853TiUu7k771qN3pVNYu9TuSVCpBIB6pDz4rOTUsdE3wRr17TepSFyE4ARGll+OwESy8LFQVwbHy2jy188zoCyAgDCAh5SRPPE0BgZ5Lfdw7WGJRWyq4MUEpZWTiahXiiz9n999+PZ599FltssQV+9atfYcCAAXj99dfx3nvv9fbU8Pzzz+O73/0uAODyyy/HLrvsEqKsxx57LIYMGYKXXnrpUzc3GzRoEPbee28cddRR4bWZM2fikUcewfe///3PfgCfwK644gq8+OKLWG+99TBkyBAcfPDBWH755TFu3LjQJXqhVW3GjBl4//33g5rSoYceiiWWWKJXAEVLSwuWW245XHLJJZg+fTo23HBDbLXVVnj33XcBADvttBNWXXVVPPLII5g8eTK+//3vY++99wYATJ48Gb/+9a/x8MMPz/N5jRkzBs8//zy+9rWv4ayzzkJRFLjuuuvAzH1yXfXtvJ2WexA+EAioQ9Fcb56qDWmZkn9MGnN1G9qortqwrtpbARUHh5PJBUDhvEJLnf1oYaAGQg0e4QXVIXFELYm2PgGdxJhDDh1w6IJDAxyUbJrLmzLm8Ji5OIyL5U7exFuEqvf4R41w+sECXrRvhIXV8idTwppUXtYidK7gEs4VvszJqUSmBawFyTClDFvCWAvjShi24pTK0OeMkA2Qmcf/kvqdlKrf7V8AL7FBHhuTZGIkWhxkZKM8brpfkw4FFE7PP2BclCjWXAxRdSj4aR5hL824Spuv6LKqgA2qbqTJUthC3d7RNUpBlhaIcqjIMlCWw+Q5skyGyQPHJhPifhQ+kOwb+zXtS79CQZ6/N9N7q3LfKnJC4txTt2us0rQlURAksMb/7Mj4exDkr506+KE5nVPdZA8wpFlgnATHSTn2/P0QMWg6yQko92tAAGrpOSi2KGEbJWxh4QoPLrSk0LH0p2CLgksUXKB0BZwtwM7fK8ZaZJa9tLUTDhgb1NmgxWVotRlayiz0p9CmnEGO2sWx0PqevfPOO1hyySUxYcIEHH300SF7sSDZfvvthx/84AeV1w488MDPlKF44IEHKmACAH76059i5MiRn3qbn8UeffRRLLPMMpg9ezYA74S+8MILn3uxgE9rhx12GPbYY4/engYAYLfddsPzzz8PYwy22WYb/OIXv8Brr72GJZdcEksuuSQuuOACrL322njrrbcqcrJz5szBMsss0yNgQu2pp57CsGHDMG3aNJx//vl455138Oqrr6KlpaXH9tlT1rcBRe470aree1BFoVi4ov6BJV9DXRDk0T8vCNI7gtEgJWVHYFDV2k8ByNw/192hUxcqEolzZhm+t0SNCTUQcsTOv9qZmOHBS0PBBBxmw2EOGJ3MKJhhxfnRxmaZ40h4bcpYhGZi6hipA05GhjYS8z87ooqPpVFpB8+hsFRKv4oClmSggPbXZuVLOOVM+HIOYxmmdDClBZUlqCxgygJUFoAtRFZTR/wu2EqJjarpaLBaAEQTKT8t86hADCV4C6CIje9SUMG+8V0CKtTdpWR7zb0QAtcjja6zCRydNFNS/ddkASxQOJ4qmEjDz3KVNIIelItYnN0YmZ9roFrBhMw9RSraSA7hXGUwJvNEfFKmCwU55hyxA3zdsYy04RqgBPfQm4Ripm8uJyA5/up30nvRiygQrDGwuoYFIPtG1xz4QexYaoNYAAAqmaaY8kpObVMCiJPrEi+NXAPr9+UKC9co4YoyggnlKElPl4IturhABzfQ4RrodA10uS6UtvBgXO4Bz61A8nvDJMCCPJciNL+TBp2WUSsZNeFjLLS+azvttBMuvPBCfOELX8BTTz2FQYMG9faUKvbXv/4VG220UYWQvcwyy+Dpp5/G8OHDP9Y2Ro0ahaeffhpPP/00VllllW7v/+IXv8Cll146r6b8ia25dn7RRRfFk08+ibXXXruXZrRg2yOPPIJ11lknqJTtuOOOePDBB+eLhHWzzZgxA2uvvTaOPfbYbkD19NNPx1577RXmddRRR+Gggw5CW1sbxo4di69+9as9OjdrLTbaaCOstdZa+OEPfxj2u/766/fofue19W1AkRkZBM7Iy34mDhfgHWAvg6pOB6Nh2PdsMIyGAgtRdSqh+vVzyXYkoKI5exECl4lVgsvBqaeg9pRr9BaqdqMqTuJeBjBDKAnoIp+l8I8c5spJ9iNtvufBA4XeG5XiGimrQBKlR9KRmqXLeIWxC9lZIC17B18orxFEoAQ4HQICHEc1JiUwWwdjHchaoLQgW4JK0ekPev2lz2awBbl031L3Hn1NOeGUpi6gTdDSApUIKhRYRJChHBpf8sUhksyyTySk+SBvSxEEhm3q1ef4vBlMhPWh738AqoiHwwEwV//paucAfNQT9kT5uJD9Z/T+QHXxcre9xpNL6TnTDIuJhHf4NZyzb7JW51RwoNp0LXDGK/eRB9AhUUBhOiFzUbkfkYJ8lVHVrtpGwGHayJGr2YokUxF6flSyIsnOk+uRAgkO5wYhteRVshwgGQoufWaCA5gQbgezbybJFg226OQSnQIsOrlAl2ugcAWsLeFsCRYwTpJh1IBBnjS9q1ugVvpRLxVMALll5AtVLvu0TZgwAWPGjMGll16KtdZaC0cdddR8byj3YTZ9+nQ88cQTOPHEE/H2228D8ATYESNG4PDDD8fXvva1D/3+fvvth29/+9tYfvnlceONN2LGjBkAgKlTp+LEE0/ErFmzMGzYMGy22WY49thjceyxx2LllVfu8eNKzVqLU045Bc8//zwAr8o1YsQI/OhHP8K22247X+fSF2z27NkYN25cAGIDBgzAOuusg2OPPRZDhw6dL3P45je/iVGjRqFer2PkyJFYZ5118Nprr+Gcc84Jn5k0aRImTJgAIsKRRx6JAQMG4N5778Wpp56K1VdfvdI8safsueeew7hx43DPPffglFNOmW/7nZfWpzkUyEQf32koMYnMItaWO/YZisLEyLynGAPaiM4TnMVBT4ECNZdQJZUQQMyCJM5spTEbouPpHa7oCGTJa74ePL4WmsrBR6JLATtpA7HI2fDHpc36HLz8q1NQIp/Tmn0o2dmkkIfjQSTOHokTS4jSrIY51MZrSNc7uQ4xTYTg8BtxzLV8hDSbwloqxDBE8qLxBwGWuqFMQA4DLIpChsAw8XjCIVD40R9wuliqoCK9LkzGcwGEDu/D2eqee/KsHhqYhBKLwPlAsr0UOvg5UiAPp0564LDouU/eATURwSk5rsTv5yQjAYrRMw7Pk/cVRCgDmvxVrc6JwrbD/6SATF7TUjHKJEPk7x7PrfDldUF0wDFyx8gth3siBQgBuOkhSKLAxOXT7TPdAYaWPqXlU1puaPz1o7D0pOu5g0m6YmtTO5Lyp+5kA+17EX+umlw/BbjMXlrWWnBh4YoSXFhwKQRt50DpPQEKpXyqiqYkEgdGTowafH8KSA4TIGRBoYxRY/JBExsDHmUG1HLASSMdtzBD0SfMGIOVV14ZRIT3338f77zzTnjv3nvvxWuvvYbNNtsMRx55JKZPn46pU6fijTfe6MUZR+vs7MRxxx2HNdZYA5tssgmWWGIJAL4fSVmWePvtt/Haa69VvkNEWGWVVXDwwQdj1VVXxTPPPIMrr7wSe+21F4wxePTRR/G///u/2HTTTbHEEkugra0Nv/rVrwB4sJGWHL322ms92rPDOYcTTzwRSy65JBZZZJEgJzt69Gi0tbVhwoQJeOmll3ps/33RmBkvvPACVlppJfTv3x9tbW345S9/idtuuw2TJk3q8f3vu+++2HTTTfHGG2/ghBNOwGuvvYYbb7wRZ555ZuVznZ2deOGFF/Czn/0M48aNw5///Gf88pe/xGGHHYZll10WQ4cOnS/znTBhQthvX7M+naGgzIByP5D7TAUZqvy91wxFaYAuw+jMGHMyxhzD6DBAR8boNIwu48uK0g7T1bpu3VZTZoKq/kel7h+exNqckQhZCSiAiNHdjPzQaDcygssMbEawGaE0fjjJHhAoiQr7kWvUUt4zZLzMncmig57F+njK5DGXkRk/RF41IwpASB3EvGTkpUMWuA9+UFnA2AKZLZC7Erm1yJwL/I08SGCKLKZ1yKwTHoWDKUtQUQJFASoKUNGQRymJknIo0jIo1bpF7PuhSlRpZF2fxwyC8BdMKikbo+6kEWhR3/G9K7R0ywWJ4gAWm6L3UGnaptImoBs2SDIUEZSk0Cd9X7kcHuhob48oQWr1eXhNCPEq4VuR9lWHNgUeqGYsKs6zZmIkM5GWPiHyKGoMtFig1QJtFmhzQKuUPdVDhkIj/FrClPKPug+9/yoJhOTei2VQ/t5gosCLceQ7S1vAZwScQ+l8TxIW5SVu4lQEyeAEsAUQbkhKLfXnpnNnJTPR8OVO3FX6RwEV7Hx2wrLP7TXYoRMlZqPELBSYyQ3M5C7MdJ2YZTsxx3aiw3ahUXbB2gasLcDWlwAakZXNGT5DUSYcigJoKRgtBaNeOtSLhYCiL1i/fv0wbtw4PPfcczj++OO7vT9hwgSsvvrqmDp1Kk466aReLQH6IPvGN74ROiarHXXUUbjuuuu6fba9vR1PP/001ltvPYwZMwa77rornn32Way88so477zzsOOOOwIANtlkE6y22mrYb7/9wnfPP/98PPfcc2F88Ytf7NkDEzvkkEPw4x//uPLavvvui/vuu2++7L8vWVEU+NKXvoQHH3yw1+Zw6623Yv3114dzDnvssUe3tQkAzzzzDNZYYw1Mnz6923t/+tOfcOKJJ86PqQKIweS+Zn0bUKgDXMtANS1/8o6cAgufbWDJUDA6BUTMyf3oyIDODGhk0mlayyZATYHKmHbgplGZE9JsBPt68qYRuRJNGQzxTzLy/RJInH5kJKTYDCbLkGcZaiZDCxm0wKCFDVqZhORNqDvPy9AmeJk4f2TiOfJgwoAyvx+TGdGql4Z2ZJAbz+2oyTZbLdBaAm0l0Foy2gqgtWC0NhgtDYeWhkVLER/rhfOOTMm+ltvGiHUuZRhZCWQly3DICj/yhkXWKP3oaiBrNGAaDVCjAVM0QGUDZAtfIsW+LIrZQjV9Qks/CY1TBUxQAACZOMfh0RjpU6H9FeTaszbCE06HU1CROP5aOmUSWSSJ7gdqR1gnAi4Yld4avjROKdwp4dtH1qFRbPY9Qiw77yQLc6UQOnz6WEB6ibAnyfteIMILCdphmtmLk03BTFqq5c+Xb2poKENmMv8aKPRJ8DX+vtzJAwm/PrWZo5H9VIBA01DhhEpmkJt8fAU5iNe44vgbAyecigJAwYzCOZTWorRWyokUWNhuwIKbfXDZtkoae1zk81EkzQBhnc9MNApwVwHXVQACKCAlT8yxP0YhAgudXGIOl5jFBWZwgenchemuEzNcJ2bZDsy2HegoO9AoO1GWXXBl4cUNnINJCdsCKlqL6qiXCwHFgm7bbLMNXnjhhUrjtrkZM+OLX/wi/vKXv2DjjTfGxIkTMXHiRGy++ebzaaYfbRdddFG3MqcvfvGLeOONN0LTwS233BIvvvgi6vU6vvGNb+CJJ57Af/7zHwDA5ptvjtNPP73bdh955BEMHz4cw4cPx913311577bbbsPEiRPx6KOP9tBRVfe12mqrVTpmDx8+HBMnTsTyyy/f4/vvaVtnnXXCulK53M9i++67Lw4++ODw85133oljjz32M2/3g6xWq2HChAnYeuutMXLkSIwfP/5j9w8577zzcNlll6GjowPLL788/vGPf/TYPJtt8803x4QJE/okKbvvlzwZg1DTzvBlMzBS7+4/FrILIBjjpVC1vKjSKC117KBlK6leUCy4CFmLEDpOv+fBhO/0y8jhR6riRBS/nIKSACwMwRhIbb+fNxC7ameg0N+CARQsgXopUbHwjfVCaYk6PxIVDo4RIqCJJGI5ZqdZCd9VvCZN+WpWuSASoae4DX/c8Vx5UrmXtnXwfhqEQ6FcCl9CJdeA/PtsADZOPGwjTp6oMTkD7SLLRj5MGUJTA9E55VCcpOeYkBb6BLlejXIDABkwMchICReTnFj5sAMA5wGr0+sTAUKADAFMxJUTPtNE7k45GdDzz3FrrN9R7gT5rFvazM/LpWr5XRrLl20RB/BipJ+IPzsZYj1Xanqump4H7g0DhkEmA1EGQxZexUo7fTQDEimIY5+NSN/Xsir/yKHcScVpnYArQN+PBWM+QaBgUeeXAn6Kss6kamjsAaH1JGljrYCJRE6W4trwlVcUQKJGj4hlHuwkUcaejF36UqdQ7tQowaUHGrAerKRZT395U5lbCu9ZMEqWTi7OP+bsUINDTgxC7CBvyGcmGQS2BtYwytIfi4GndSy0BddGjx6N3XbbDQMHDsTBBx+Mww47DJtssgl+85vf4Jhjjun2+XfeeQcXXnghHnjgAeR5jjPOOANHHnkkll9+efzxj3/shSPw2YbTTjstOG7NNeC1Wg3Dhw/HmWeeia6uLiy77LJYfPHFccghh2D99dfHuuuui/b2dhx00EH4z3/+g5kzZ3bbR6PRCD0OzjjjDFx//fVoa2vD6aefjsGDBwPwZOkLLrgAAHD99dd3Ax7zwjo7O/HKK6/gRz/6EY4++mi89tpruOuuu3DSSSchz/uWa7XNNttg1KhRldeWXHLJUNLV2tr6mffx3nvvVeSOBw8e3GPN3L7whS/gyCOPxHLLLReuBTPjoIMO6lZylxoz44gjjsBBBx2ETTfdFGeeeSaOOOIINBoNbLTRRjjllFNw9NFH98ic1VpbWzF48GD8+Mc/xnPPPdej+5rX1rdWfZORljgljeNgAcCBHIGc/rlW51+03x3BGXGjmAOo0NIVDWz7bfpvq7PX7DfGySCACu1CnTFHxRsAuYAMkn1UehOokxWDq8FJMJo5YHlNnPxMHBsn+1KH3TIFkrc6VX7DCIBD96dAotJxHFEGNU/q4GtSSlGz5CVpNYpOJNuKsqF6fhwxCuNd6hD4FQ4FiQNnHISTQRFUqJdMDBhprucYnHndfqelTlkGZs+xYCGZM/k2drqxNC5LTf83V/oob0TBRey8Fum9xC5RRErnrQAxOsq6D3Xq0zUUunAHQBud7+prkkcQXVoterLEgccTIvkCKpCAClUeMmAY9jKqmWQA2CgAi+AhLm0FQunCV6yk58aIQ5sJmDB+Rsp9UKTPKbhoLuSKF0fBRABH+nMyEw6TQNhaEB0ICFkBigGTi1kOBoyQsU0pQKL0MsY+88QeRVfudQrzI4r3bzVioWpRLpY8KXei8IIDbKNSWCxdQ9P/yTP2170kkTEGwzqHOukV1/IxD7oNfJkjs+eVOetgrVxeMOxCQLFA2zbbbIP11lsPDzzwAH7/+99jtdVWw/bbb4/Ro0fjtttuw7/+9S90dHRUvnP//ffj/vvvR61Ww6677ooNNtgAtVoNzz77LB555JF5Nrdll10Wyy677Ed+bpFFFsEPfvCDD40EExFWX311rLTSSsjzHA899BDGjRuH73znOxg2bBj+9re/BTDwUabdmPv3749dd90VWZZh2LBhWHHFFYOMLTOH8/bII4+gLMuPte2PY41GAxdeeCH2339/TJ06FS+88AIA4Ktf/So6Ozvx5ptvzrN9zStbc801MXDgwMpro0aN6ib7m9rqq6+ONdZYA+PHj/9M+54yZQoeeeSRkLlaeuml8dWvfhVjx479TNtttmHDhuF73/se/vnPf4Ys0uOPP44LL7ywokLWbMyMP/7xj1h22WWxxx57YPTo0TjqqKPw1FNPYfjw4Rg9ejRuueUWPPHEE5gzZ848nXNqZVnioosumi+NG+elEX/aHuK9aDNmzMCAAQNw4Je+jHqWifBQ7ELL0pnWWgcLr+6iJRPBL2PtE2BkEDI2yNiXbaiD7b/i/7BbeJUoT97mUO8dnEL2GYmaqNrUGWhlRrtjtDqghRmtDLQyUEdUdjLiBfk6ckLDEGbnhM7MP+8yvgxLu2/n0scikytnySs/zc6UFwLMyQmdNUIh3AtrPIjyzhiC82VYeBws3AZWJSbfQyCzzpNrLaNeMlpK4UHo95CW6MTItPJNSgIKExWpFFBUZTo5ytkGkGKqEWcDWAMvaZsBNjdweQZnDDgzYJOBswwgKe0i4YwkpGiNgOs1VbAI1qg4hwFVA5KeGd5hdJGTohwCykGyH0JUAIpObwQZwRRYBOAQz0MFUHCcn3csHUqVPzYOhWHhHchjkE2uOqV+7iIpzMqtkbIlk8u5jqK3EfHI/pE8MgeFLu88l0DDl6CZskReFmgpC7SWDnXn107d+jUluAaWCIUhlMYTqK2gLiX9Z8z+/hFydw7PEaJwDf169vKwBgUZFIYw2xDmGKBTxhxidIJRwJcVlcRwNQK11pC115Ev1g8twwahNmQAssXaYRbtB9O/FaaWh8wgEVXK4FTVyiMUfw7YWt8Ju7QoiwJdczrR8f4MdE6fic73Z6FjynR0vTcTZUcXbKOEKy2sU1lrlkvE8T5ghOtUg/ElhzBoQ4YW0pGjNWtBLasjNzmM8WvfGemnYxiN3KGzxmjUGEXG6OASt9x3H6ZPn95jkcEFxfRvRF+xPM/xl7/8BXmeV/osfP/738d5552HPM+x1lprYfz48R/qEN1yyy3YfvvtMWPGDCy11FJoNBrdpE6b9/tx6rV/8Ytf4Nhjj0VRFB9ZjqXmnKuUAwESEDMGSy21FM4880z0798fe++9N6ZNm4Ysy3DJJZd8qGP7cezHP/5xKJVK5+qcw7Bhw0KUnJnnGbh48MEHseGGG1aA1M9//nOcdtpp8xTAfFKb2/W99dZbsc0228z180VRVH4mohDhv+mmm+ZJD5BBgwZh8uTJ4Vy98sorWHXVVbvt+9NalmXYfPPNcdttt2GJJZbAVVddhenTp2Offfb5RNvZfvvtce2112KJJZbAnDlzsP/+++Oiiy5CnucYMWIEnnnmmXky3+a5b7/99rjmmmswcODAXgMUn/ZvRJ/mUHgStq//N0IqNjXPqUCeCZ8CSH0kH8UVuUmjg8VZhYZQpS7bhNIiw6n8KuJNKp8V/jRyeLDQAqAVEUC0wJc8BclMIDjLITMBoUuQz2j47RDaQGiHQT8Y9OcM/dk/9kOGdhi0s0ErDFqYUIcf2t9Ca9dbZLQy0Cok2faS0a9k9C8YixSMAYXDYg2HgV0OA7sYA7scBnUxBnb6MaALGNAABhQ6CAMKgwGlH4vK6F8S2kuDtpLQmspXls4P6wJRm7RmnTko7WTOl1a1loQ25WwUjNaCUS8cag2HvMvCdBUwjQLUKICiAW40wGUXbNGAtQ2UtoHSFbBOG+x5QjXYJVkkCmTiLAAFcR51ZFl47gPuwmdQkrZTOdtYMhOa8em+nINhP4Iz7mQbAlrYWrAtwaUfKAsZJVD6poBsfaNA60qUzjdCK7hEAc+R0H8W0nQQVsR8LUq2cK6MMqSh14cLnBDNaAQeewISiZM+G4GcnQk/JwdMBmcylJQJEDboEkBckoElA6fcA6QN/ygAv0CiprTRZARODlEmVqViS6OPCKIFpREgnRm4TErlyPimjZZ9P4hGAe7oAnd2AZ1+HZHVNaK3KMXfCcm9G0j5Coo1/SYlT67wRGzXKHzZU2lDuRM4Ke1qGqo4VwoQ6oJDJzl0wGI2CszmBma5Bma7hidq2wZKIWkbUdiqM3lelc3QVhq0FQbthUF746Mdx4U2/y3LMrzyyivYddddu733xz/+EauvvjoA31jtyCOP/NBt7bnnnjjwwAMxcOBATJky5UNJysYYvPLKK6EU5cPGUUcdhWeffRaLL754RXXqw+z888/HoEGDKmPLLbeEMQYvvfQS7rjjDuy1117h8zvvvDN+8pOffKxtf5hdcMEFYX+vvvpq5XgnTJgQjmnixInzrE5922237VYKc/zxx/dKV2g1IsILL7zQ7VpuueWWc/38yy+/3O16DRkyJMj39pQtv/zyeO+997DMMsvMk+2deeaZuPnmm1Gv1/Hmm29+Jjnf9vZ2TJo0CRtttBGuuOIKrLbaavNkjh9kF154Ia655poe3UdPWp8ueQIoSHl6P8XEP/wsoXBnvLMHrSVHDLYSpJTEl7Q4xyGSrJUumhUApAIHWoPPQlL1UWVVbPKAgqPzzowWeHCg6k6BrwBUYsIad9LtsGZSJLJrWBuH+ehlKrNZguV1n1mowfsvhhnWaV+FaklN4EdwbEJWS7ppZ45hrCozeSK1qkiFzAZFMKQlM97p81kJkDTeg+dJqE9F8JkjIClrUSdOe3VIBoUgMpjiuJFRh4xCJoGcT5s4NmDjy6I4cwBngURLZOS6UuX8g0JhEBCyTrJzmVRwxdTZDCVQ1k8uQHMTAvupNKxuO5S0pKUvQVUoAhIjhGAtV3IkDQWNCxkzR37NOiPTksxHyOxoSkAzCuIr+zokSQnBAEY4IdBmgSTzS8uKIPeQAAz1gEGANEEEZXBkURoDYpFsReQlafQ9nFGKW+dwP/psFDlGaShmscAeDFD8XEmEQkbDUGhUWZA2u5OGeQw/P1ED87KuDG5YcFcB7myAuxrgRt33QqnlIJOI6ibker8+k+aAkl3Q88yasSji4NKT+LWPSbVrSLxuMY7sfw/p/aHXguS66ecyNjDOlzplIORkQgkoST0lswFZ53+fVLsGLrQFwFZddVWcdtppGDp0KM4444xuKkhFUeDNN9/ErrvuivPOOw8HHHAAll566W4KQ2odHR248847se++++Lyyy/H7373O7z//vtz/SwRYckll8RZZ51V6QR80kknYY011uj2+aWXXhpXXHEFFltsMZx//vm46667PvTYJkyYgFmzZlVe+89//oNRo0bh8ssvx09+8hMsv/zy+O1vfwsAOPbYY7HiiivivPPO+9DtfpQVRRGi3aNHj0a/fv2w4oor4owzzqhwOtra2nDttdfCWot77rkH55577qfe55w5c3Dttddi2rRpuOSSSwAA9XodI0aMwA033ID/+Z//mSsfZF7Z4osvjj/84Q+V14gIw4cPR71e7/b5+++/H2eddVbltVmzZnW7XlmWhQzX+uuvj7/85S/41re+1S3z9Els5syZGDVqFM4880ysuOKKICL079//YxOmP8paW1vR1tYGwJfCnXjiibjxxhs/8XaeeOIJfPOb38SVV16JU045BVdddRWuvfZaAMA555yDiy++GH/+85/nyZzV2tra8Oyzz+K4446bZxmb+Wl9G1CQ/0+JxuTga8KZvBNpjK93J6rUsHP4bnTwAilUfCn1uVKXKv45jg6Flg0ZceZr8NKYLYgZgRZOOlejKhNbyXrIFB17XXl1OwwIzHE/vhwizouhfAZPiM7hO3HXHTwZWp0eQuLcSb+AAChE1lM66masjed8xsBI921f7hQViAKYCM6hjyKTeJyO/Fz0nBG0GR8HbMdyIVg87tT5zGKA2DvN4hda6zkB3rd3vueGXEsvn2pCbwzPp0iasLGWQaXQTrJFFN1nAL58Kl52D1xdBBX+wjiwI5CRGHOFL5BeJ0RPXGvodRsB9Mp7HEvuFHw548GTg/T9cBzWNBHHa5DsOHV2yQFkEWfGnu8gN45eBFSRd8J2YAplOdH7JSiPgkWa2JkSpRNeBhlkxnnej34j+a7OVY9US9FKBUThO4QsAL8kO0EUu2STl3325VAIPCkOm5I1wvBlkaWFbRTIRInJNEpp5OBE9lfXNYXHuBYSsBkuKQfuAksJlG9s58AJGRs6J0QQHQMdTWADkrVgHzQgNvB3NVBzJWrIUKJELlwRQwpMJXTAALGBdcKnWGgLjH3pS1/C9ttvj5122gk333wzbrjhBjz22GPdPtfZ2Ymbb74ZW2yxBbbZZpuPVHJ68803cdNNN2HMmDHdnLQddtgB7e3tldfyPK+UBhERXn75ZTzxxBNz3f4tt9yC66+/Hvfee+/HPdRg06dPx0033YRrr70WW265JUaNGoUXX3wRN9xwA7bYYgvstttueP3113HLLbd84m3Pze655x4APgq+4YYbhteHDh2KjTfeOKgXLbrooqHHwN133z1X6dCPsldffRU33XQTtttuO2y33Xbo378/Fl10Uey6667YY489cN99930oIfjj2vDhw7HBBhtUXlt88cXnmuECgMcff7zbfh944AHcdNNNn2i/Q4cOxY477ghjzGcCFEVR4Oabb8ZGG22E7bbbLmTRdthhB9x9992YMGHCp972TjvthBVXXBGAL3G76aabcMMNN3zgWv4we+edd8J9tNVWW+HLX/4yrrjiCowZMwbbbrttj8ngvvPOO7j11lt7ZNs9bX2bQ/HVddCa59A/9E6yDFq7aUsrkpDyR95xkJ3UR3WuDBNyZ1B3BjXnn+feVwzbLsl31i6VRyHeeS6Aoc6MNsfob/2jlha1sM8aBDnZUMeO8KhOlZPSjUZGKI2R8g0DpsxnSxKOB7Ev/yjB6DCMWcb9f/bOPFCOotr/n6rqnpl7b24CWQibEtlBNkEQEEQk7KAQIKCyiqhsDx6LKM99RRSR7YlPEVkUcGMHA6hsP0QEhLAYECEECHvIcpeZ6a6q3x+1dM0NICQ3CXkvByozd+7c7uru6pnzPed8z5dB3xq3JaEIvAlPwA3gR/j5OEBhvQiZVzX2gEIktfKu2ZLnVAR+SeJkxZas4ToQMhSWNoaWcPrZTq3cZS4KKkVy7bM+0p+XmpV0IalZr8mBi9C7qLPTFGlLS6lciYuWUCrHF3GlLpLSl7tUKuAOUGSiKm/KcO1iQwcfI4IgWpJJiOVJFqGNG16tOLSMJdWeELIDTKSCbiGy7prbGqfcjNeE8CVTISIvqYjZwv+tO3Z3/IV0bZBD5yJ3JWzHviM4xsb+q9IEICvJpCJTOVJlHWVLsaOR31JsjevBRCzrsj4ib3yplg4lWo5PoYwmM4a6tjRMxb2Rlg6Fa+2fpwBLWN8MwBLbzyoCT8VxJ1pK0ZYy8owGFQxKaEv8a2GdecVz6867VSAygWpk5Mt3UxvTS7b8CPLRveRjR6F6u5D1muNSKIVUgT/h2w1bOkqcjNbosqRslxTNFoNz5tL/yms0Z8+jNbuP5mvzKOYNoovSEaWtux8CkT4es7/PAn8mAGsRPjNslZ2soeiRGT2iRpfM6ZI1uj2nQnq9GaMkpbJov04GdJv/vvemZRyKd4D19vZy+umnc8QRRzBnzhze8573vKXSkm9+85vss88+bLXVVsydO7eDHzFy5Mh/y4d46KGHGDdu3L+tzb7wwgsXubDWz372Mz7+8Y8DzuG/+OKL2W677ejr62OttdZi3rx5b8oXWRibOHFijDaPGDGiQxzvgx/8II888gha6/ki9m/V7r//ftZff33yPKevr4/e3l6OPPJILrnkkrdF5m00GvOVZe25555ccsklr/v+vr6++Zz9I488coEj6aEcb8UVV4zHMnr06GGLnp988smcfvrp8ef//M//nC9z8lZMSklvby+PP/54FFNst9ssv/zyw0Ke/vOf/8yMGTM45phjmDdvHg899BA33HAD3/zmNxd4jQy13t5eLrjgAkaMGMFuu+02LNtcUFvQ74j/FRmK6mcfLvfRVyGtL7FwDqshiHrR4TgGjmzQq5ACV/JgKi2KQMCO2hOi2l3gOzQsjLDQa6HLChrWcSjyAACoSMwqeVS4iQSHM5QPhU5Pwkdhg1UlE+GwXQvQDJcdwThHpOZLuCyhJr4ifaYZigAoar7sSabtM33Nt4iOTehq5KPYwvpuRjamKaSfo8KSC+c2KRwQ8xVqvpUsqai2j8T7rkXWxiZPVZTf/b0yfuGK6pyCa7EJwhPoBYUImQvHVlZSYnCgwh2FIhWyC0J+iKFrShJK3QQu6+Wi+jYOKwIHIRZMOQecClAYwqZNopbhgYWpOgAR/64qtwNPajeVAypNUHt3cXtlQienClAEJffQKjmS5wW+fEnTUXQXz011ftPysHBcMYvjuz1ZqdxV96WGoVxHIJxOhrXIcP2TY0JU91RcD/40GIQPEjgyfm5d6RpUPIvIoZCBb1GBQuJxJpfU78AY67ovDbahv4nNFaKWobobyFoesy5IFa6mv5dEvJ5uF8n5NQZtNGWp0e3SEbB9y9igPWFTIIHtPBdJdiL8GPxFY13JX/jMQmjP/yk8SIQct5YRoa1z4Kq4zI62Szdl7n+TPfjgg0yYMIG//vWvbLPNNm8r4rveeuvxyiuvsMoqq/DSSy8BxHrxodmHoaaU4oQTTuDss89+0/ctjjjjZz7zGa6++mquueYann/+eXbccUeuvPJKfvKTn/Dqq6+y0UYbLXRXoTeyP/7xj4wZMwaAm266iY985CPxd7fffjsAjz32GO9973sXaPubb7453/nOd9h5553ZfPPNef755/nv//5vPvaxj70tZ/H000/nqKOO6njtzUDj5ptvzj//+c+O1xYGlGmtec973sMVV1zBPvvss8DbWdS27rrrMnXq1A5gONx20EEHMXHiRFZZZRXAgaHddtuNDTfccKG3Hfg948aNi53LlkZbugHFG33miUDW9iUSwkR30DluPspKxVtw/f2rSLhzrpzAXIjyaio1X5uAiToOTHRbGGEEvQa6jKVuBXWL71CTjkS0jKr8PjqdUAl+SUGpvPqvb29rPXNTxLII51Bm3gERolIXqKLXFaAIkeYQ/Y0cCv/oIqWpv+y3ETITiVtl4yMVKvD7CkCJEDn3IfuSNJrugQmVs2RwwK70f5s6+AFAZNaVuKXnT0sofYTXWou2zl221l1LbaQ7p1biisSMd1C9kJ11IxJDEtK80+zw0enQahXja+N9tL6jBCaAg2qhRvwrKncyKl5H5eoKLLoZ0tlmOGaaQjtYrwXiI/ohAxDWhsFnA/xjWIQOhPoLLYw/x8bxKfxBCys6yNnhulbiDH7dKum3o/wxe7CFcDDP4kqBROpCJ0ix49pXt7Xz/QNAcA69A0OO3K3DPQJRu6ETAFWcjVAy6JuLuSlqS9nWiME2opYh6znZQAvZqCGVwmYOJNrk4pmkGUNAKlo4FW5tressV5YuG1GUvuypyo4aW115N69qzcQAQbiPw76tiPKDqWVoWoRWzYLMFkjjeWTCk+itjAAoS0/4MluippTiRz/6ERdccMHbAhM/+clPePTRR/nVr37FjTfeyNe+9rVYHpRlGSeddBJ/+ctf3nQbTz/99EKVrAyXGWO444472H777bnppps477zzmDJlCrvtths33HADl112Geeeey4//elPh33f1tp4Do4++mhGjRrF6NGjueGGG6JTuvrqq3e03n3ggQfecgcqrTXGGNZaay1uv/129ttvP04++WS23nprbrvtNnbccUfa7XbH31xyySWstdZaHa9NmDDhdZ3kgYEBdtppp/k6SE2fPn3Yr63WOn5OdXd3c+edd/KZz3wmChAujF166aU88cQT/P73vwfg+OOPZ8MNN+Twww9/W9sRQnScp/vvv58jjzySZrO50HMEl+U56KCD4rw++clPcswxx3DQQQfxl7/8hT322INXX311ofahlOJrX/saV1xxxXBMeYnYUg0oIjE0/Z4UoQsTrtQFvAtsknIn66N/lfMGREAhvAOGiJzvxNH1uxTBscW3h4UuCz0eWHRZQc1YV7ZjE+GyxNkJ8wyOZnAWEa4tplQSMonNFFpKR2Y2IL3WhtRVBFNYByKsj0hmOOclObqqRSvOAVXWOeZZAipimZd1QMplC+ImHCghcars0Chr9auQmUjBlMWJ30l8Jsg65zY6lMKVl2mM17fwWQ+RnDsbnOpq4CO4rrSs4mcYa53qso+Qh4J6YQ0yRHRxrYMdX8IPD0pTFzViDBngmq9RpxNUdLSeHRLpC1wH10nJl5bhOz8NASDW7zMIWgjrdElCRig60AEgGpe9kbZqiRuAhPLRexsXn2cjSF/CJQQIPw/pa/DDZe6I8lcMExt+2WEWTAbxHvNgQnotCFNxQ8I66YSTdP4k0lddyZEkVdgOcDUBEjaUFlYBg7ARSQWUjXEdmUS7RDQL5GAbPdhCtRqYPEfkmeOpDJmsCc+lW1cue2nR1jiuQunLLUuTlFom2hPhcygCcX+1PfIJUCz8zvpAgPGrWuA+nwosGQaFQaHJKclsFoGxMC7jFs6LWjTVI8vsbdioUaM45JBD6O3tZfr06W+79eSzzz7Lrbfeytlnn80RRxzBxz/+cbIs4/rrrwdcpPYf//gHU6ZMWRTTH3abPXs2d911F+eccw6TJ09myy23ZMaMGZx99tkceOCB7LPPPjSbzTcs8RkOC+JhI0aM4KyzzkIIwRZbbMGWW27JBz7wgfi+cePGRTL8ddddx5NPPvmm273rrrtYbbXVOOCAA9hyyy257777aLVa7LHHHhx77LHzlQ195CMfiUJyqT3//PP85je/6Xit2Wzyl7/8ZZGVhA21G264gUajwR577MEWW2xBb2/vsGz3+eef7wAmq622GhtssMHb2saWW27ZwR/505/+9IZ8pAW1adOm8eSTT9Ld3c1xxx3HJZdcwu9+9zsajQYHHXTQ6xLfF8T++c9/8thjjw3LtpaELdWAIoYeqZwfwDuDQOL6CADl/8RYH/t12whlISHSHpqhWFmBliraWznIigpMdFvoMdWo+/aNubW+PWbqeyVdc9JD8cdhPaHcZhKbK8pcUSiJtsK1VS0ttB0g8F6/m4+NPn6MxKbefkebS//+DCJhPLeCzHhn0js2OqCp1IFNz396lkWVpBDJsVUxUnfWg4q4TkBFJKniCoI0MukcZeM5ixRqf02UdRxaIaA0UEjfDcrPoSr78VHewNC1AolB+myFEj6aa30fLuGLc4Ty/BC/b+kJ/viIvsU3D0pAhTEY3y7WWNvhQCOoSn8SgnYEI6RvrTqJxTWenKewfkInMBUBhQdZOCAWshRSgpXOofW1Uo4b4rNxDuy4sidhA/05zVKEiYVSQOGdYhnLABFE7k0QL7fSuoZrwvgsSwKchqyXKuvmzGHbsGEfjffIzgEkD7YQMSMh8V3SjFu1IV4XVpEIzRmMxZYG3XYtiPVgGz3YxjTbmFqOqOexQ1wK+IU/sdaXFBqcmnVpLaXRjr8VOVwG47OicYTjgo7zkNxS85kR+KyqiO9yHCWXaZJocg8qhBVI4/hB0gh3Pf11WWZLznp7e9l4440566yzmDlz5gJ3/Xn++ec5/vjj2Xbbbdlzzz1ZbbXVmDp1Ks8++yyHHHII48eP5+GHH+a5554b5iNYNNZutznxxBNZZZVV2HHHHTn11FPZbLPN2Hjjjdlyyy1ZY401uPXWW3nuuecWqQPd19fH8ccfDzgti+Dcr7LKKiilWH311TnrrLMA102rLEuMMW8oXnfttdfyr3/9i2222YZvfetbnHjiifzud79jr732ijoZQ23u3LnzdeW67777hqWd7sLYhRdeyKxZsyKJffz48Sy//PK89tprC73tsiyZMWNGPM/1ep13vetdPPvss2+p9G7XXXflC1/4Qvz58ssvXyRZrf7+fubMmcOPfvQjHnnkEe6++26efvppDjroIFZZZRXmzZu3QHyKPM9ZeeWVF2m51uKypbqoVmgQ2roWkP5zxjkMznsSSjgNAeW0KpR0I5OuxaIjOFatXBHW8yiMFxEzXkDMi4hJG5V/lXAdnRrWMsLACAO9fvQY4bMUuLInqq5P4XkNSy58K1mBi7x6IEGmMPWMspHT7q7RHFFnYGSdgd4aAz01BrozWnVFO5desM652ZkV1IygbgUNI+jS0DCChiaOunZgJzzWAo/CCN9CVkTiZ2ZFZ2cq66LkHcriVMTRSCa1iZNr3XY6dTGq4YTLfFcp73EZjNdOMBRoR4L3rmsgh+e2Os4w6lZQN2G7Il5XF+T32xVumwWattW0bUlhCgpTUuoCrQuMLrCmdPoS1riByyxI4UGFkgil3JAVsduC6zJlDaWvqdem0pgQZYksNVmpyUtNrTR+WOraCQeGUdOWWmnIw++0pVFaGtqPAFyNO97MSp9xcgKNmRHkWlDTgrp266BeCura6Xzk2pKVBqUNqjRIrZHGaYRI4wUOwwgOvz/OSNwWgfSuQCmEyhBZjsxyhKohVI5QGVY5EcLYgUlUIF5YG0UVXcmWjYAoiCMG4nVLSVpK0lauYUEAFS4zIaoyPhM6l/nzqG1Hy+Pg1Rtt0O2SsllQDrQo+wfR/U30YAvTajvNDusAomvVSxS2DI0ZSqzjiXj+RFGUlEXpMxXGNYqwlbhmKEWsMqZDMhbhdzYRv6PKoAY+V4kT2nQ6FYZBWzJoClqmpK0LtHb6F0JrhDZIvQxQLEk78sgjoy7BVlttxYUXXrjA27LWsummm/LrX/+arbfemkceeYSNN96YP//5z+y1115MnTp12NpwLi474IADOOWUUxg7dixPP/00Rx99ND/84Q9Zc801mTFjBuPHj19sczn77LNZbbXVWG211Xj++efn+/3//M//8PTTT/Pwww+/qSP46KOPstpqq/Haa69x5pln/ttMy3nnnRf3G8akSZMW+niG237729/yne98Z1i2NWPGDFZbbbUIzDbeeGOeeuqpd1xThcsvv5z3v//9gOsEdsIJJ8Tf/e1vf+OTn/zkAm13ww03ZPr06Sy33HLDMc0lakvXJ85QK4wLR2sTycMhFSBC21jlnD8nTCZQ0nf4EaHTUhg+8uhJxlY4AKH9o5EWKy1CWjLhuRPW0m2h20CPtvQY99y1iq34CZkV5JAM6wTsqIjXSIFRApMripqi2ZUzOKJOf2+d/uUa9C3XoH+5Bv2jHLAY7M5p1917tZIxeqsCsPCjbl0WpeY5EjUr4vPcCu9kufnF82GJ5yUL3ZD8z50tbkM5hYhZjxDFDuTfOCckOa6DU8NKGggaVPPLsL4UyvgotUZjPHnbeEDhLJaaGQcgGimwsB4wWRLAQiw7swTQaCmEU1AuMBRWU1hNaUuMcQNTIoyunGt8qZUUEQAGEbxA6I6lOFTOprauHMYa1yVKlYZMV2CioS1d2tJVWrrDc/9zOrpLS5d2Qn9dxoHFuvFChjiAHMX5kCgrKyBnKlDR8IKD9Sg6aMhKQ1ZqVBhaO6CR6pLY5DyE/0TyGAQBlUKqHKUypMoRMsf6rkPai9BpD76I4NPGDEtmqgyLRfjOZ4K2krQyEUc7dPXqABVeM8VYcu2H11fJ/HUMWhrgs3kpqOhvUvQPUg4MUjab6HbbcSKMq4k2nnCu43WtMhOl1hS6pCwdmCi1diVQ1qKt57EQkhIdqaZYHpYkK6qGBR3PRcxwaOG6WBVY2sLQxNC0mpYpaJuCQheY0rXCFaVB6mU1T0vKrr76aj7/+c/z9NNPs9ZaazFz5sxh2e4Xv/hFDj744EjUPfzwwznhhBNYbrnlFopUvKTs17/+dWyJGvgMu+yyC+BKiFIhvMVl2267LWuttVbsSJVab28vjz32GJtssskb/r21lve///2stdZarLXWWmywwQbz8SfAdW8KmhzL7K3ZjTfeyLHHHht/3mqrrRYpB+GVV15hrbXWisT3f/3rX6y11lq8/PLLC7Vday2bb775sLVLXlK2VAMKURoojctShDaOCagI5FrhnXYRSiYgOrqhy1LUVcDVucfSjOgpu+fSO76ZtU5vwljfGtY5sgFEhNKLoSOAiOCchvIRowQ6kxS5pFXPGOzK6e/J6R9Ro7+3xkCvBxK9NQZH1Gh257QaGUVNUeZODRjv6KbHFcuaSEjYhIg2HoDg1cAZcm46hxQVNRdEdHzcKyL2vk//6wAV1oMKfDbBCuoEZW/XfjdmKpzr7zs22UiEh4qUHY4nN+7vI2DyDnQtycCkLUtdxsKDRoFvA2zQwhVbOYK0xobsRFTWtskacWvKtRL17WJD+1gv9Ga9o+vKz6qaF2EMSlsyHzmvJxmHhsZllsJrSXYpjggmiNmYCkxU59tplnhQ4cFH3f9dXbtMRa4h05bM+EyFH1l47hXNlQ2gItwKVemf9GtaUAGsoDDuQIVCSIUVVZYidk3D/SOHDr+SXKmR4xSVHkC0/XBtgvEZD6qVaUO2oxqd9zexhMn6a2O0QRceVAy2KAdb6MEWutXGFAWm1JgEVAROhGtH67gTpS9z0qXv9KRNBBRVV68EJCTH32EJqAgn2Ybn4S0iJFl8O2agwLism9E+4xaAkHZgdlnJ02K37u5uTjvtNLbccksefvhhvv3tb/PEE0/MR6ZdUHvppZd49tlnUUrxrW99i5EjRzJlyhS++c1vssYaa3DyySez6667Dsu+FofNnTuXqVOncsopp1Cv15k4cSLbbbcdp5xyCmPGjOGwww57y8To4bLp06fzxBNPcOedd3LKKadwyimn8PDDDwOuO88aa6zBiSeeyEc/+tF/u40nnniCadOm8YUvfGG+bkwzZsxYaGLvorRHHnmEr3zlK4us7Oy0007jzjvvBNx5/frXv/6GSu+9vb1873vfY/PNN2f55ZePr0+fPn2RKntrrXniiSdotVpMnDiR//iP/4j386RJkxZ4bVpreeqpp4atBe2SsqWaQyG0I5UG7oFr6+QRRXAwIpiwET25aE6IWFff0s5htZXYlH8t1pLbSsXaObDWO7HOcc1sp96EoAIPFR8gTCJMDqyUTjshU7RzxWAjY6DbA4ruGv09OYM16QithSbPJFJ78rT3NlTSTlSIqnVoPIgkEkyYj63AVfro/s4dc3R6vFUtOdMDIb5LdIyKgB73SYiyilgTHjgsUoQobtoLqOpkFdr/hnr5jKSFpxXUrEtYlRYK64T6jEjwJS6qGyba4ZTZcMy++xP4Inxf7pSMjisZgIWUvs1tEB9zImcdfY18fYtI1kkEszZwM9x7wnkPWTPhgXHqYGrpZpp2OYLAhXBCh0HPIuiWxOMWTh5N+hKeoL+NcFsUVoDy7XJDqR8eZMtwDTs5R/62chkS6fRLpLQIofy9abDWdWgSwlSkfO9BV2tPRJCi8e1afWlfFSQIXJrO8xZK8Yx15PywdgKAr86h8Mfh9m2MdUJ3rYJysI1otBD1HAbbiEYt6lCAACmrkqRAxE54E0H/xoGPoGru8aSo4h6x3snPMf186ITrr/PZEf5cEEF3aW3MtrWtoCZKakLFFsssAxSL3bq6uvj85z/P448/zu9///tFUtsNVTvYp556ijvvvJNbbrmFPffck8mTJyOE4Omnn15kLViH2wYGBjj99NPZfPPN2WabbVhppZWYNGkSu+66K5ttthljx47l7rvvZurUqYuNlAyOEB80E8aPH09RFCil2GijjTjwwAN57bXXuOaaa/7tdrTWnHnmmay11lrU63Xe/e53A64d8Msvv/y6JVbvBHviiSc488wz+fKXv4yUkrFjx7LBBhtEcLWwdv7557POOuuwzTbbIITgP/7jP5g5cyZ9fX3zEeBHjBjB5z//+fhzs9nkH//4x2JTl542bRrbbLMNRx99NH/84x957LHHFmhtrrzyyqyzzjqLYcaLx5ZqQCG1QQrf/UhYrLLO4Uh9Pu8DdDi5/ps9uKOBeEpaluAdgGozFiVcx6YQDa8bl6GopZkJKn8lLQOK3SZDpD1kJqSgzARFrmjWFQONnHkjcuaMrDGvt+5ARU9Os6awxiILS153jVeFEC4zIZzYnbLax0A9eBDhONNockVqjqUrNgET8Zjdv5Hb7n2RysEPZyWYGHKeq/3J5C2+p5LrTCSc8259R6HSupayWjhlYOfw21hCFK87xNKueH2scKUlxteZG6+mbZ3QWSY8YVs58UAriYReiCX13vmz3hn1gEIYXyYjI8SqCr/wGYlwstwtZfy5RFpP7PV78ZkOJ4boMkkuW+S7Z/kTGp3O1FlPFpf1LXG1X0PaA4vgZQbNDhmzTzZ2x6oAheMnlNio/2HR7lilQFj33KrqGENTgtRBFjJMuwKrSkhHrTDKARKpIbbGNRjjQIUVnUJu4ZhNWJvCZd6MdFkKG0GFB8Q+syaM9aJz7sTFBgXemY/nTdIx4r6MRZeaotVGDDQhc1wmumqIRu67gfnPDBWuUaeIpi5KyqKgbBc+Q5GUPKWgorqdPHAlnoM0xBF/l/ycAgsbz5PjdJQY2pYIVnMENaPcuZAONC2zxWuBx3DAAQfwwAMPDOu2Q5lTypU455xzAJg1axbjx4/n7rvv5qCDDmKbbbZhjTXWGNb9L2rbb7/9+PKXv8zXv/51/v73v7PKKqvwla98hc985jPcc889jBkzZoGJ7QtrJ554IuC6dr366qsopWIVxFvV8DjqqKM4+OCD+cUvfoEQgssvv5zTTjuNU089dbHogCyohbntu+++bL311lGXYbi2ba2Na/u0007jgx/84HzZn6FaHE888QSbbrrpsM3j39nQtbnyyivzla98hc9+9rPcc889LL/88vT39//b7Rx//PGcfPLJlGX5jr7mb9WW6pInVRqkrw2W2iJ1pe4ctBSqxqNAdAOTsqfAp/AqypmQ5B38CpLyIUfErsprHLhIS2lIHYbguYe2qMKLdQnvIClJkUlaNUV/I2Nud86c3pzXRtaYNarG7FE15oyq0TcyZ7A3pzmyRnNUjcHlGgyMbtC/fIPB5RoMjqzT6s4p6q78SaugkE1sUxoi+ulwfImKF5FaFcStOutUDSjdiMBrqKdTbaHjpwAEnBCgdKTqZIQSqByvkO0jyuHcpQ1o01Iq5fkDuZWeN+L4FD0aekroLTpHT+nKiupJVklQlVpV+RAPM6yJj64EylYjzEEolMjIZDWUylAi88ApnLmQobDk1pU5dQdCv4aRBkZqQa8RjDDC83IEXcbNOQ4D3Rq6taBbC3r8Y5dxo2E6z20cye/dI57cbalrQ6N0o15q6qWmpg017TUujCdMG1z5k3F8hVC+lfnSsqDoHBTJXSlWhpBuWKkiSdtIpw1iO74g/IUXQRPEl5FJiQnlUiKAC/flonyThRzpOSVhHclYkmZlle0Iiyvs1/WltxStkvZAi3Zfk/acAco5/ei5g5j+JmawhWkX2LJ0GQjtCPem1GgPJHSrQLcLdCBla422iZCheJ0sn0cZlUq27QD3HVgyed3/sQNN1hHDC2tooR1B2xY0TUHLNx4o7eKJ3i0zZ5MnT2batGnzOT/DYUIIHn30UV5++eXYwz+15ZdfnhdeeIETTjiBr3/968O+/8VlP/jBD9h6660BePjhh3nwwQf52Mc+Rp7nTJ8+nZ133nkJz7CyT3/60/z9739/W39zxRVXsO6660Zn8rjjjuvQvninWX9/PyuvvPIim+OXv/zlf3tNDznkkI6syPe+9z223XbbRTKfN7N0bQKcdNJJHe1r36pNnTqVFVdccVg6Zi1pW7oBhSeMqgRISO0cnggoQsS2ozMNEOrfcTXwSggPLLyDGjgG6cBzEmzoTFRFAyF1fIcM70Q4dV+nB1BKQaEk7UwxWMvo78ro63agYm5PTl9PRn+3YrChaNUVRUNRNDKK7oyiJ6fdW6PVW6PpH1s9uXtPTVLmAq2IoALoyB6knI4kSB/fl+RyOv9GJAAtnM/KTWbIlpKof3VeBL4bD0SSdt07gcERrDpvBcJv2F7aBydMt5OvoQgkZNfJquFJzN0ldBfQVXhSc+l4CnWNJ+x2gsJQkxK1ja1BWO0fA5gI59BzV6R0wEJmbgiFFKpS4iaUgIVOVQ6UOg0T1xksHV0WDwR8hzAPlmq+m1Vde+Cg3Qhgwg1Hfq9b2cFXCZyVOiIS9EPXr5rGd0Uy1LRxXaA8Mbvq+uQdXuMdYNN5H2b+XLquTS6DUKmRK4L6tPXidEZUehIBWDiQmoAJ6UaV2RMx25X5NVO3gi4r6YqP7thrhKYCFbAQ4XqIJHsWSpi0oWyXlM025UAL3dfE9DUx/U3sYBtaBbYMXbs0VhuM9kJ2bQ8m2oUTtdM68i0q/sQb6bb4nF8AEWl2M8lgpHdZyMYkEomuM5o1tDG0rKZpS1p+FHZ46vaX2b+3k046iWOPPZZarcahhx7KjBkzhm3bq666KhdddBETJkzgqquu4r//+7/j78444wwOPvhgjj76aEaPHs3JJ5/MRz/6UVZYYQUuvvjiqA69tNjg4CCPPvoohxxyCFJKDj74YCZOnMinPvUpenp6OOWUUzj66KOX2PwGBgY49NBDeeKJJ2g0GqyxxhpcfPHFb7kjVavV4umnn+aQQw7hmWeeoauri/XWW4+LL764gxvwTjFrLa+++mrkAC2//PJcfPHFrLTSSsOy/f7+fu6//34OPfRQBgYGAHjf+97H//zP/8RuWo1Go+PcDAwMzNdqd3HY4OBg3O/ZZ5/NFltswZw5c1BK8dOf/vRNifqplWXJq6++uixDsaQtEi49YdRlKHDcCmNjbXVwgMMIDkVwigOxVvmORiG66lqnMv/At0OlM3IInUAi9P93jx5MSBIwIWnlisG6y1D0deX0dTtgMdBwr7fr0oMEia5JdF1RNhTt7pzWiGR0Z7QaGW3fTrZUIraUtQlySEuvImBIDsBlVqqFXZHJAzEbD8Qq2NEJJKouNCmgSMmowm8vZEocUVuS+05QOQ7YJdUtYWaJrgSR9BwyJBH42NA2VETycb0UEVx0lTZ2OaqXVSegKgo/BBpZDypCtsIrQVegQsTOSmEduYyFchFy585WoMJWwDT3YKERx/xZm7TFbh7axJqKfB7J1h5g1E1Ceg9/HwBEzK5VIMUR2D3JW6fnIwUTAZyHYb2gnidr+5HpJHNhqwyXEP6ZUCAUVvqMgwhZB7dWw3OXTXDvqUBEtYYD/yTzx9Swgm4r6LYyji6UA6s+86jweiNJhksgKv6KAaMtpjCYVun0KPpb2P4mDLTcaBbYovSgwjjQUGpM6ZWxUzChO1vGDg0ypKVP4XOqA0zYjltxCFxP16dfo9aVYYWWy21ctqKVgIpltmhNSsmOO+7IAQccwOqrr84NN9zAxRdfzKxZs4Zl+2uuuSa77757VOj9xz/+wezZs7HWcvPNN3P55ZdzySWXcOmll/KHP/yBD33oQ2y66aaMGDGCgw46iN13353VVlttWOayuGzu3LlcfPHF3HDDDay66qp85CMf4YUXXuDmm29mgw02YPLkyeywww5LZG5FUXDppZfyyiuvAMTz/HaE31qtFpdcckmMUPf29sZrFfgV7zT761//yqOPPkpXVxcHHXQQI0eOHLZtv/rqq1x66aWxE9aqq67Kxz/+caSUbLHFFqy//vrxvXfeeed85PbFaf39/UyZMoU999yTtddem1mzZnHLLbcwefJk3vWud73p337oQx/iPe95z2Ka6eKxpRpQyODsxMyERWrX9UnoquwpggkpXKQzKaMQaVcaKZPSiUo7IQ/OnCWWPOVUpVBDwUQoazCiqlMvhH+Urt1lM5MM5or+esa8LpeVmDMiZ+6IjHndGf1dimZd0qq5zk86k2gPKsqGoujOaI9wGYrBkX6MyGh2uYxGqyarLjgx6ls5ZqkjHnyWoZ0s0zIlRQUCQgchmWZ9YqYiAAnXfSaMFFSEkiUVo+WujWzs+CTSsqwKUISyEdfVJugAhBIS72wmznrNuKh7yFQ0fGaiq4DutqWnbekqLF2Fb6FqKpG/ClSEsidblTwRRqXNIPz5CGAii4AiyVRUORd3Xi1emyOACkGXz0x0DQEWATxUa9GDigAGtKBhJA0t6TKys+wJ4aP1PksRwEpouxvKnvy5qvmWqw5gmagP0qHM5k9NKC+UGpS2KN81ShnXNMCdR58/khIhVQUqhPRdn4I+hQfByr1ulYzAI9a/JcAx99mbbiMYYSW9RjLSKEZaRa9VjLCKbqtoELJgVcAgVYgP19txMYDSYNsaO1hg+1rYuYMwdxDmNbEDTWi2se0CWzhwYdoFplWgW21f8lRiClcSZT0xO6hkp8Ai3mUJ0Kxyg8w3oAIYFbirroljwLhWxYU1tKxrIztoSwZsyeAyQLFITUrJyJEjueaaa9hwww258cYb2X///Yct8liv1zn88MP58Y9/HCPjG220Ed/5zneYO3cuH/vYx7j33nsBmDdvHrvtthuPPPJIR0epiy66iMmTJ1Ov14dlTovTPvGJT3DVVVex9tprc/XVV3PYYYdx5513suWWW/K73/2OESNGLJLysrdizWazgxDcaDTIsrdHUW02mx3X6pJLLmHPPfcctjkOp5100kmRrwMLdrxvZtZaBgcH0VrH17q6ujjjjDOiWvng4CBHHHEEl1122bDt9+3aM888wy677MKsWbPI85zHH3+cPfbYg8HBQWq12psqaF944YXstddetFqtxTjjRWtLPaBQIapsbAUkPKhA2+jFutpp76QohclcHbeVCqQrg1CRQ+GcD+fodpZRdEUHzUV3U2E8QeUsRCAhcYJcEppKMKgk/TVFn+dMzB6RM2tkjVdH1XhtZM7sETX6ejIGAyjIHCgoFehMUGYOVBRditaIjMGROf2jasxbvsa85WrMG1mjrzdjoCuj6bMVReZabGrfYjO02bTCF2AkRdkBVIQosGtDG0pLiNmDUBqWlkAF0FC1sbR+uH75AVxYXOQ6ZCa6kHQj6RZudCE9uPDZIH9WjdeOaEtDU0FTWprS0pLQlpX4HdioHB1E+2pBf6GAnjb0tC0jWpbelmVEBBcOeASSfeBWeM85Hp0jK1eCd46EHLgckgwHKHKRkcuMTOYomSFFjhSxAMcDtISTg2sDG0qTGkgPJmRsD5tbSWYkmRH+0Y3cVNkKp8nh1msj0f1wPysXvTc+kq8F3VpG/kXdg7DMWJT2rUb9CEreTpSt+tmVPlnXeUxbZJkA/AAopMtOCKEQMgOZYaPgnaLMFKWqHo1SaKUwmcRkEuvUHz0QdecsggkjGKkFy1vph2I5FCNR9ApFD4puoWgId0+7zA2x1XPI2OShxXBpUS2DHCiR85qIWf3wah/Mmgez+rBzB7B9TcxAC+OVtXVoM9t0gnimKDGlwWinP2Ktjb5/tKHOT1IWh62aJ4iQzqDS7gg/Bd4FoY0tjqBdYGlhGETTb0v6bME8M3/v+2U2fLbddtvxwgsv0Gg02HfffTnyyCOHdfv33HMPJ598Mv/4xz8YO3Ysd955J5/85Ce5/fbbGT9+PIODg/P9zYc//GG+8pWvdLz2ne98h1tuuWVY57a47D//8z/ZfffdyfOcZ599losvvphPfepTjBo1ildeeYXNNttsicxr55135pRTTok/33fffVF1+63atttuyze+8Y1hntnisXvuuYeTTjpp2LZnjOE973kPV111FeAyPy+99BIf/OAHAXjhhRcYPXo0jz322LDtc2HtzDPP5Prrr48/X3bZZVxwwQVv+jdf+cpX+PCHP7yIZ7b4bOkGFIQvXBudGnQyTGdEtRNUSGzmHvERUCEqEbYIKKykgaKLykFzDoknfw4FFTE7EcTTBG0BLSkZVJKBXNJXU8xtZMzpzpjd40DF3B5f6tSlaPqsRKmcaFfocmSE40VoJdC5oKh7YNGTMTgip7+3Rn+v064Y6M5pNhStmgcVSlBIQRmj+p0E0VDZXZUxdXInYltZMb/AXVrGEcBEGSKlwkal6zJEaGOU2WUjgvPcReX8OjVx79j7yWhhKTyAGFSWgcwyqByoaEu3L42NAmFRVyNkLUyVtWiETEWZjBihr7QrKhXwKveCrUCFjBoVdGRxMiS5UGSRqF3zwCJ3DvUQ9RNXepOc59DBiECe9yVV/jVXpiN8pyPHS3GcnqBMTlUWFUGJ9GVU/jwbUWVCPBCpGc8d8mBgaGYiOsbhmgcnOTk9HaVRUJUaekVtIQOoUA5YZAqjMnSmOobJnL5KyFJErgpVpqZmqfghCRgLpU558hgI26H8qzND48vFdCX4V2sbsoES1ddCzh2A2f1uzBnAzht02YtBBypss41tFthWyE4Y1zbW2OQU2uj4h3NZWVrYl6L7CnSk7w/tbsPfDLkETl8FS9uTtJvWjWW26CzLMqSU7LHHHtx1113D1sJyzJgx3HTTTay55ppceumlfOtb3+Kaa65h/Pjx/OhHP+Kkk056wyhnu93mV7/6FYcccggABx54INdccw0bbbQRf/jDHxgxYsSwzHFxWVmW3Hvvvey2225Ya/nqV7/Klltuyd57702e55x33nmLXacC3Hn+7W9/y4EHHghArVZ72xH7drvNJZdcwmGHHRZfO/bYY/nRj340nFNdJLYgx/vvrNVqdWQo6vV6zEBZa2k2m+8Y3sEBBxzAH/7wB97//vdz7bXXMnnyZO677z523HFHrrzyyjdUrS/L8nVFDpdWW6oBRVp60Zn+tx2R1aoHJ1XpT9qCUnriKKmqcwAVyg2rfHTTOWauJCrwKYIjWH2tG++4lwLaUtDqKHNSzOtSzOvKmNet6OtW9HcpBuoeTGSSMnazqUjNsVxCOCE8k0nKmqSoK1rdGc2ejOaInMGenGaP41S06k7boshCCVQCKpLtAR1F2p2sCGLt+uuVYbhLELrYeHVxvw+XlbBJ2VOieB2cw3iuE7Kwd4yD641wuguFErQyaGYw6EdTOUChPUhKaa9BgyEFFbmBWsqtKB2puV5W5OTMVKJoqdBexaHwGQqTiN7ZpKUtIeNVgQolM2QAFJGYnABGKrWL6IQn0C3+ZxOCt49giwRUxGMlUWqPPAyZqKg7cFH3wCM3Tjk98khMch8ljjDMfz91cAQi4KiUOyIPIiFaC5mBUi5TkSlMlqEDsAhlT75EMXKdAsDCt0pGJEKRSQle+JtwbwvXOSyIOkZQYZkPWNS1oF5aaoUla2nUQIHsayHmNWFuABOu/MkOtLDNNqZZYNslpl3xK6xJMjkdYKJDnWTonfaGH2vpa6HEyYZH6Pi8iNoUWArrSqDaywDFIrNtttmGnXbaCa01f/rTn4ZNoGydddbh4IMPZscdd2TKlCk89dRTrLHGGkycOJHf//73XHXVVdx3331vuo2nn346CoattNJKPProo9x+++3stNNOHHLIIUyYMGFY5rq4bPbs2dx000384he/YMyYMXzgAx9g7NixXHTRRay++upMmjSJ/fbbb7HP65lnnuGOO+6IP2+22WZvKnb3ejZ9+nRuvPFGfvGLXzAwMMA666zD7rvvziGHHEKe58M95YWyadOmLVJVaoBbb72VP/7xjx2vPf7444t8v2/Xbr/9dn7729/yl7/8hY985CPcfvvtXHbZZfzjH/9g++237yjF6+np4dBDD31bPJulxZZqHYoqlk78phXWVadY40qfQFawKaDbKK7g4uvCeDE4IV33JlyZTSBdB7CggBxDzboR9ANSLoWApKsTlBKXHcgE7dxxIvp8R6f+bkVfT8bcbkV/Q9GqS4rc6VJon+6wqdeOd96kcyB1BkExwRqFKHIvtgVCW1Rh/YxcXaaIzgwukuy3GU9POKch7RAeqyedz0VV/pKWO7myptRlCloYzvkzybVLW/OGq2kQtP2stZ+Ple6cGOWAYFsKCipuSy12arJx/qJjxv5fK6LbJqxzhHUAhoAsiYArDCsrbYCgo+AujHYOvzC+NSzR/Q+CD06QzTuFyr0mPfKw1omfBQAWdCjCfDuZGn5hBb6KBxWIqq5eYpP1SiRFi+TncJ4FFoPTVVEi5Es8sdcEQGw7QIUI6MynmMISMThnPqhtxCUbpyq8pppfadIi/EeP9cdlkQ5s+u1WXZ+IvAkR7jWfiZF+B+Ge0FSOd+imFjQoQglfhsAgPeiyGCsTjoOIy10YgRCu7EvZoir7AqdRUWpsPXPAvtkJKmxpIqCIICK5gzpup3iPzPeSe6vtfI8Tx5kf+btLIuJrxq8jTZAgFB1Ae5kNn40ZM4ZjjjmGSZMm8eKLLw5b1HS55Zbjox/9aBRTO/3009lvv/047rjjeOmllzj22GMjGfjfmdaal19+me9973t89atf5Yc//CEf+MAHOOecc2i1WvzmN79hzpw5wzLvxWFaa4488kguueQSPvrRj3LGGWewzjrrsNpqq7HVVlux9tpr85vf/GaJzOvll19m9OjR7Lvvvqy55ppvSewutRdffJHDDjuMiRMn0t3dzZprrskFF1zAHXfcwbPPPvuOiWjfeuutPP744+y///6Ac5SXX375YW1/+uMf/5hnn302ku5nz57NtddeO6zlVcNlF110EU899RQTJ05k3LhxnH/++bzwwgv89Kc/Zdy4cbzyyiuUZcnYsWO58MILmTVrVuxk9b/FlmpAYYXEIKuIbnDIfOcZ52GYmIUIfehTZmeI/coQ0cVxBTLv8ijhhbOEi0LnGHJ0JAwHABKcuarkyXVzaitBM5cM1lz5UX9XztzejHkjMga6Mwa6FX3dklZdUNYEOqs0JDrQkvfejA/yGhkcbeneD2BtzFxY6dwLnUnKTFKqIsTYMaVxm7OOeIsVQ0BF3GuHoJyLflbgwXjYYIR3RLExMmpSj57g7DhQEbIjwbUNDq1z+Qwljl/RFq4aTUh3HCHTojMFSsX2sDXtujY1Ct+y1KblcCIJmYuqM1MAFtaXkUG83oWAwrqSEYFFK5xCNE60yBjvelr3mpSuu5P0UXQRvWDv8Cr/6FeJyztIDCWl0LTRNK3L4oRyMktwsispvVTyTJA6m+43yl/HUExVFVUJX5Il4lrFO5gGz3exfl3FaLfL+EjjhPmEke4e8GCjugfdvaTjHOfPeNlUtc6hefejFAirQPhVI6rGwGkJXqr2HUCRFICUaCFoe6ClZRVg0EBbQFMKCuHEEYUM6uomgjWsjpmEIbktd46FBW2wusAUXsAOi20VDlBkElO0MX2DTqei5d5njY3cCTxQq1Dp/Ld2uNdEHP5+GQI+hJ9lUAqH6qMv/q0Nz92aCtkMY9O7eZkNhwU9iBVWWIFbbrmFnXbaadgAxTXXXNPRX/+uu+5CCMHDDz/MRhtt9Lb28/TTTzN+/HimT5/ON7/5Tf7617+y8sor8/LLL/PTn/6UPffcc4F66C9pO+igg9h///25/PLLmTlzJltttRVbb701xx133BKZz3PPPcf48eN5/PHHWXPNNYdtu0opnnjiCfbZZx+uvPLKYdvucNoXvvAFdt99dzbaaKNFto+99tqL2267bZFtfzgsz3OefPLJeD+NHDmSmTNnsuWWW3LPPffE922xxRb861//WlLTXCS2VAMKLSVSKoysetgL79DFtrG+CN5KgVWuxCSUXwQgESKeygZBLBLicYiue5dQ6ES7IRE/E1UU0gpXnuMAhWSgJulvKAYaGfN6FHNGZPSNyBhsKJpdkmZNUGRgZKLqS5VRCD5F4o94ZWYfKRbSvWqy6LNZXMmKVsKL3eGipQJMW0Bbu2i+r58QiKENfGKkODnKWMIUeuqHv6icwQpwdH7dWV/CE0jagiwBFu5/7yg5T84riTsyelGTrntVrihyhc2Uy0yU0CgNtIzTRvDHXUXjITjP7lnaTSdxwEzILok4XecIGqzx5WcesBprEDaofePLd4TXYhNID48E7jgQynvAwl8rx4EAidElbSQSjTZVedZ8DYljZqUT8oVjcdH3TjDhwEngkVRgIxJ//fUVIehtLaXFK44LSuG6PCljfdbCi9pJr8ceMn7++hnRuYbidBOn2F1a6cG8A5BS2LiGDWHNG38e3AaltQlI8pkuISmsuy6lErSS7I7FAyXhM11e4DHzYM45Y8ZvzcMo2xnDd4DTrQF3TjRY67KHRYmpK0wu0bpEDzQdlyLJULiMRpKr8+dZhI3Hc+UzMTYmfzpOXbWW0jyhv59SMCE614OhylS4dbssQzGcFqLgY8aM4ctf/jK/+tWvhgVMdHd3c8cdd7D22mt3vL733nvz1FNPLXDtuLWWnXfemf/6r/9in3324W9/+xu77rorX//615dYd6ThsD/84Q9ss8023H777Vx66aV0d3czbtw4HnzwQXbbbTeee+65xTqf9Nqsu+66/P3vf2f77bd/21oJO+64I1/72tdiBkAIwZlnnsm2227LCSecMJxTXmB76aWX2Hjjjbn66quZMGHCIllHt912GxtvvDHAO94Bv++++3j/+9/PHXfcwdlnn83NN98c1+ZQe6fwP4bTlm5AoRRSuQi98V1gwhe2Mj6y6cN+VlrH05aemO3flwIKV28uY212cMiCs1V1/HHOlZE+CikE1lblSVok9f4+O9Ffd2VN87oy5nUpBhrStYXNBW3lS2sA5yS6YQOYCI5ScLCoSjPCcRgloCbBKPdGbZBFHsGHtRZZhhagIIyJrT3deagWt43xUSJAcO5X1Qo2akEAkP5tMkT6m8oyEbpAecfXH4MWwvMgEs0O5UvGcg8oaop2TWFyRWnAFBYK4QjX2sQ2oPhcgIwerkicscRZs1XJl7WgNBEsGYTLUoQLgCvdkVZgPBizQmBVibWe2G+FAxdIYtceDzri3lVYTw6qagSFdXHz2L7UDmkjGhz/JHKfHktV0tSp7p6WPMmwnuPZqMq/sA5cVC1UbfVoLNIYlHTlQdJYUL6MKX5/VFyJjji4z+wEpzdMOuRhAsiUQhBYJO7M+0Idvy7Tcq4Qnbc40O7K1tImAZUWSuDuWBFK7MJatyRMFEggcjS/jowl5ooMGjFQgDHQVthcYIx2nZ18doKkq1PHqUgjA0N+F+4XEZdrp1SkSLeR/Hl1HX1JYbo9f0TW+k+u/33fX0vMtttuO/bZZx822mgjzjrrLG644QaefPLJhd7ummuuyYEHHsgmm2wSiZx9fX2cc845/L//9//econTG9m0adO4/PLL0Vpz8MEHs9tuu7HSSiuR5zknnXQSP/zhDzFm6cpkzZkzh/vuu4/vfOc7HH744VFkbaONNuL444/nt7/9LX/9618X65zOP/989tlnH7baais22WQTTjzxRK644ooOhed/Z9OmTeOXv/wlrVaLgw8+GIDVVlvtHcV5KcuSqVOnxqYA48aN44tf/CJnnXXWsJXzzJ07l6lTpw7Ltha19ff38/e//53TTz+dT37yk4waNYqHH34Yay2HHnooO+ywwztSsHC4bKkGFGUmEUo5x9X5b9HpyI0l8w45nqxbGk9mlqFkyHXNUcY5pJmRKOuF7WwQ5Ao+kf96TsCEsdb10McirPQZAOsdYdeutZVLBjyY6Otyo79LMViXtGuCduadIhGcnEowLHgBonINCKFMV7fup+X6lmIyATVfWmMUlKEkyTvLpXHOICCs8SrIxDKWyuFIwUJS5iQqcnWYUXDKq79kPgJ5jML69xS4yHHl9LoAfpkAjUKG4c5RqyZp1R2oaNczTK7QBmxmEdKQ++48uTbYBCSp4DRbqm5EcaadP4pQHWcq3oyECpSG0i7jXTgbzpty5AslPHBwfIMABKQPI4uQpbB4JCsiobmwDlBFXRUSMGA9OOrwQpMCqJh9EL4Er2qvmuY5OjIz3pG3HhSFYqyUgxHBhDVIK5HGuCEl1gOxACqs6LzG0YIXHcGHB1g4jgL+PIe1HOL5Mj4L4oG2M2fjs4wWlxlJF2A4M9UdFXYvfAti/H3mshMuw+iuW9o9KaB449cGVqOtRYoCoTW0BTYXLotVlNiyImQHMBJuqsjrSR5F3AkxGNGx6+qUxWsXAgnhCCM3CBGDBdImu/fALICKZbbwNmHCBD7+8Y9z6KGH8thjj/GNb3xjoYXr1lxzTaSU7LDDDnz1q1+Nr8+ZM4eHHnqIU089dWGnHe3666/nmWeeYauttuK//uu/InD5xje+wY033siTTz75ui1o38nWbDb58pe/zLrrrst2223HuHHjAKeXYIzhhRde4Omnn15s8znjjDMYO3YsW221FQBf+tKXePzxx98WoAC49tpr47VaY401kFIyYsQI1lxzTZ544olFMfUFsqeeeopx48Yxfvx4vv3tb3PBBRf8r+MHvFUzxvC1r32NTTfdlN7eXt7znvfw+OOPc9hhh9FoNCjLkscff3zYusC9k2ypBhTtXCEy5yJI4ctcjCU3UNcVSTfU+ZeZpTQSraxX4AVppesmpAU1I8lNlaGQwWVzoWisMBghXckDPhPiQYuxBoUrKWorHG8id6VO87qz2BZ2Xo8DFK26osgFWlXbC92ppHAlJlJaR+w03ov1lU2uLiohm+MyMELhIqZIjFUY48BN0KAIkVPtMxZKu7anorSea1u1BA1H6MSyfJtZXLkTJM4OnVFTS+juVNXTC//cu9oR+IX3B3Ckhat7HxSWQQkDCgYyGMyhWRM0G5JWQ9FuuAxFZgW2bUG5zESjdNc+twZ8t6I8RvyrfaX7DZFbV7JFrF4TNlGHTqWzrV8L/tw4f07GAxLKldRIIRDSMyZElTnDO+NWea/SeOK1EAitnYaKMEidEJATeCeSxwokeADhAVRoJhDAVOJuz2dVhqOKcqdZEIEDFMpn4gKBGWMx0l3gKp5pq8WAn1x8nWphibRvVcjCSX96k85FSVekOL/gYePyGUZUoNWttyqmb6n2g/XHaKtz54CMcODEuottq80TFoQJh2It2hiU1chSIzILnl9jjcZ6IbtAxn4jDz4CiTRrE4BZuuv43gC4KghSzdPG0xvWg41AAiryxjI4MVw2ZcoU1l57baZOnRpLMRbGsizj3nvvZdSoUfP97rLLLht2PQuAqVOnsv766/PKK6+w3HLLAU447OGHH2a77bZ73RKNpcH2228/jj/+eM4888z42uc//3kmTpy4xDQqgi1oOdADDzzA+uuvz6xZs+jt7WXHHXfk/vvvZ/To0R1CeEvSdt11V775zW/ypS99aUlP5R1lu+66K1tvvTVjxozhrrvuYosttuC5555jnXXWWdJTWyS2VLeNLWtOPZrcqVxnuFaQDUMk6dYLGx9rhYkjLwy10rr2kKVrIxqUiDOvARDcEWtDW0zhAIWQlFJRqIx2ltHKMlpZTjPLaOYZg/WcgUZOf3fOvB6ngj0v6Ex4bYgilw5MJFFqC1hjMcaJYUVRrDC0Sfrbdz63JmnbKnFidnVJq0vS7MnoH5HTNzJn3sicvt6Mvp6M/oaimbsMQCHx5UYmkqvDv2kBReWAViP4eFaEsqWKQ1IKB2ZK6XQwCunJssIyKCz9wjLPj7nCMFdY5ko3+iT0S8uAcm1i25mgnUNRE7QbinaXotWtaHZnbnRltOuKMpcYJXzXLseLSXUKaghfS/86GZXwjy9AF9o6wNUxjMv2+CHKElGWyPCotSsRMjaWMFWK0a6VqZQKoRRCZZBlmCynzDKKTFEo5c6VF/IrsJTWoHHDWDesNcl1qTgGHZkfKmCQlux1kp/Tn0Phkee32FCCZyKwkEmr3FCeJ5P3RTXx8BrhsdMEPghgEwFCQ1T/zk2lVB9BvhUdmYpU8yIm9XzeIbaIxn2ZV1mcVPE9EOqduKUQ1c/Sc7SUVz3PUGRWkRUC1TKoQY0aKJEDBaJZIgqNKE1Hm+rqqouoqC5E4NwIogJ4aBghHD4NWddUL8YInyH1d6axndcx1Qh5M0CzzBbevve977Hjjjsu9HY23XRTnnrqKUaOHMnnPvc5PvWpT8XfTZo0iS9+8YsLvY83Mq01733ve7nuuus6Xv/tb3/Laaedtsj2u6jtZz/7GVtuuWXHaxtuuCEzZsyI4Glx2He/+1123nnn+POPfvQjfvnLXw7LtkeMGMFTTz21xEHS65kQggceeCByP/6v2mGHHdYRDNhzzz35+te/vgRntOhtqQYUZBKUKyWJisMGcl2NTFtUGCWo0pKVlkyHR//epP9+EA8DOr6UQ6cdIwRGSrSUzgHMM9p5RquW06xlNOs5g42cgS43BruUI2DXXaeiMnNtLo13JmJUMjgIxlY97H23GGOq51bbGAmNrwVQYX2JkoBSuRa0RS5o112Ev9klGWwoBjs4HIJSVQJ0GuMzEknZiY+Czuewen8oAAojPZgQrmWuDqDCO0VauJ/bAlo+GzEgDX3SMk9a5knDPA80BoSlKaCN66evSZwriTu2mnTAqeGyPu0oChj0C5z6uRMrrMBERlXSlkaF03a3HZ2FvNBd5h3doGeRGetKx7RBae2Hd7wDD4HXyRK4uiNXaiOdYruVTjW6AmOu05ROr4u1mCFAz2UR5i8LisH81PsW6XFWZPs4wvmNWyeCiqjxYkMrWWLzA5GAizcadDxWgEP5lr9ZeLRUj1bE7lWhM5ewdO7ThH1USZH0fFehAToAniQQ4KuTJJK/EASgoRzAQKHwZZFakJUCVVhUEYClzzDaeKqryxwaRkhf+jYETFQE65AVrXhS6cEEAFyt1wAm6HzT0Ev/emtwmb0tW2655TjnnHNYYYUVmDNnDi+99NJCbW/ffffl1FNPZeWVV+bzn/88q622Gvvuuy+tVovjjjuOu++++20Ted+uzZw5k3PPPZef/OQntNttjj/+eObMmcPuu+/Ot7/97UW670VlfX19PProoxxzzDFRDyTPc971rnfxgx/8gPe///2LZR5z587tWCPLL788Y8eOXaBtaa058cQTefDBBwH3ebLqqqvyxS9+cYlobvw7W2mlleju7l7S01ii9uqrrzJr1iy6uro4++yz6erq4sorr5xPuf5/ky3dgEK6aG/oaBMcvFxbDyQcyVaGYQK4oANMZAaUEbHTU+WsQPh2TltiWuEyFUZKSpVRZA5QtGsZrXpOs5Ez2Mjc6HKPLivxJmAiDP9PBSb80NZnLHwGQ1dZi473RVDhHXjpOuCUuaDtOyU1G5Jmw4notXNBO3N8hTKoWouq9WtaeqGGDl+6FJzUIOYXCNUxWyFEMhxXIiiINyUMCOgThj6fqejzgGJQWJpY2li0tTEqb60DPFoJykxS1CTtuqJdl7TjeZaeJyN8dx8ikIjdkETl8KXelnNavfp1BBFeEC8Z7jXrHeEAKpIIvgkOdHKBwzUOexLC8S6kdKDCC7ppmZwvDypcZLoCEw5I+OxAkj2qwETnjofmIkIOqhrzA4v47iGAIAILf654HQBRjQoERCJLKO8LSuM+oxOAW8hcVAAgKV8KljrutrqEwnviFcCw1XuHzif52wpMQFWm5lsBC4VMMhW5lWTGlUq6QAUoXV1zl8ULsoQiggrCkMlzkSzEjsc0npHmkJJrWKUkOoFECmg6jm+ZLYituOKKbLfddhxzzDE89dRTC905aLPNNmPy5MnsvPPO3HXXXdx3331sueWWbLXVVtxxxx2cd955PP/888M0+ze3KVOmcP3112OM4e9//zt333033d3dfPazn2Xrrbemq6trscxjOG3evHmcd955/PnPf2bmzJnx9cMPP5w99tiDddddd7HMo6+vj7/85S+xNGm55ZZjyy23fNvlT9ZafvrTn3LDDTfw2GOPxdf32Wcf9t9//3dEpmLGjBk88MADS3oa7yh7+eWXeeCBBzjqqKPYcccdmTNnDhdffPGSntYiM2GXwt5Vc+fOZdSoURy1yZZ0C0WttDQKQ1fLUCsseWnIC4vUJjpQWriOQY6ULQhKvcpHHSXOURBJqVPa/jR1rvEtKJ28hUVIENJifdR8oEsw0JD0NQRzuiWvdUkG6oJWJmnXZCzJcboYxFaZQFUaoRRCSVDSPWbKZWOUK5eQUrr9EhwFW5VaGOvU2rTnRxSGrK2p9RfU+woa/QVd8wpGvdZk1JwWPYMl3U1Nd0tTKy3KJLoFITocHS03ywAgCp9JGBQwKGBAWAaEi66HlrCx1SdVS9PYPQtXg14IQxtDS1iawjAgDW3lsxC5pOjJaPfUKLpzyu6cckQdW8ucGrURdDUtI+cWjOor6R3QLN+nGdtvGNm2dJWWug5CZh44AU3cvlz2gwiiQoQ+KH13RuuT6LZ3GLNQGiMVUuXIvIHIaqBypwKtVAVIsY4PYwMB2Ln1rmytxGiN0SUUbVc+ZQyZ1uTGklsbhRQzi29x7FWfcaruoTtZKK95fesEGOF8tIRlQLrRltDyj6WSaKkcgM5ySpWhlfvZJK2YCWtRJB8pqVPsT6CwRBVyZYN2SKz6j/db1W2LKJ5osZ4zYTuuiwNBnqgtRORShNbQqVJ65MZ4IBQhmrWxa1p6/lwpkUFbTWk0LVPQNAVNWzJgS+ZS0C80TWFoSUtTWooEXFsJNgQQpAcWMnHwbXXfRhG8BHjhgVA4tUM/sFNSvvJq6cqrzLsGE55Abyx3vPA0c+bMYeTIkW+wNv53WPiOGC47+uijOffccynLkvXWW2+hCLFZlvHkk0+yyiqrcNddd7Hjjjvy4osv0tPTw9VXX80+++wzbPN+q7bHHntw5ZVXkmUZH/nIR1h77bU599xzybKMDTfckEcffXSp6/4U7LTTTuOkk05CKRVfmzJlCnvsscdi4SAIIZg5cybjx49HCEGz2WTcuHH09/cvUOvQvfbai9/85jdkWUWBffbZZ3nXu941nNNeINtggw146KGHAPjMZz7Dz3/+c7TWS3hWS9ZGjRrFCy+8QKPR4Ec/+hH/+Z//uaSn9G9tQb8jluoMRa6hpp2wWb10mYkwYv268SVMVrhSBaPIw9DOGVXWOR1V6Ng5e7FUI4n+kkQanYOlKGoZrXqNZleNgZ4aAz11+kfUGOyp0ezOaTcUZa7QmXO+YuLDZxTQaZmT8eJpniOhDVob72gaTOmHNr7fvcte2DI8hpKoQOiunFcrwCrXWdZkoDOLVhYtDaU0zqlPRuFLn/xhewE60RHdd8BCROepkMKpg3syeKGgrVwL3dJnFNqZpJlLBjJJXy6Ykwtey2BWDq9llteUZa6EfgGD1tI2Fl0YbFsjkoF28XqtcCVdXcqJBXYpBnwGppU5lXKtrAeCQV7OooQlw5ITBAv9cws1oG6hywp6rGSEcaPXP/YYSY8RdBtBl4GGX4e5L30SWoNxw5qE92CsL1tKCfDe2RQKpBtGKU/Y9+VP0gsIhmuBy7rkBD4AMUthhANHZQQLacap8z9N1Qq4agksIpAyBL/b1+wHsbYwkpKnwKOQvh2xNEl2UNuouu2E8tyohPNci2cRSPFJ2ZFAgJARKDgytn8eMilC+OwhEXC4+6zKnsTsQeSEBP4HVVYhZl18iRRO7FAJSSYUucyoyZy6rNEQNRoip2EzGlbSMDJmrgLwi7ofoROB8IEEWQUUqjInYuSySlKIjiRG9QmVAIsk/ZBmV9JfLctQLLzNnDmT0aNHL1R72NVXX51Zs2bFcpUvf/nLvPTSS4wcOZJPfepTHHjggcM447duf/jDH3jXu95FURRcd911bLzxxqy33noA/OUvf+Hkk09eIvMaDvvqV7/Khz/84Y7XJk6cyHPPPUe9Xl/k+7fWstZaa3HFFVcA0Gg0mDlz5nxzeqt23XXXsdpqq71jCNlvZGeffTZXXXXVkp7GErc5c+awwgorcN999y3pqSxyW7oBhUm5Em4EIKF8mYTLPrjq54zMESs9uVIhkVb6nv/h67ZyRIITnppInkVn2mtOtL2acyi7KWqu9Mb6ev7Y3WYImMBUo4OUHUqaPLBwz3VnqZO2mAAgtMUaYmeo4MC5chI3MmPIrCG3mswalNcMxhoMxjuixjua3gn13kjs2+9rhGwoY6LiRmiRcCciqPCtX3NJK5M0a0GbQ9JXU8yrSebWJPMywbxM0J8JBhWOPyF8S1VjXd/ftkG2NTIhwBocX6Rdc7yQwBEZqAuaNWgqS1taCmnRwmCF61clcMevrCGzlsyaCmBYqCFoWDe6bAAPki7rRsNKGtYRiGs28HCcg+w4LTohzVdgIgbHqVgQBKdTSF8CpTy3wpVuBefZRkdR0Kk54bUZPOE6lp9B5K/EDEmy0mOEX7i1bIJjTjUcsBhK/k2yaq9T2lTpaRAFFKVN+AVpliCxat/hmOd/NFJEEBt/lmH+iahiCnw6yrJSwri7kzva5TKk3a4ve5JCoqQkkwFYZNRFRkNk1FEuU2TdWshslRmQcUMOFVQcCNvxmH7GVICqKsXyN2HHtbHpX8VWYtWP1YfWMjixsDZ69GguuugiVlxxxQX6+7322osf//jH9Pb28rnPfY7llluOr33ta/T09HDQQQfxxz/+cYm1ay3LkpdffpnJkyczffr0KHg3adIkZs+evVgc70VlrVaLhx9+mH333Ze+vj7AKU+PGTOGK664YpEqOwfr6+vraBPa29vbkWF4O1aWJS+99BL77bdfLH8aO3Ysv//971l55ZWHZb4LajNmzGDSpEnMmTOHRqPxf55HEWzevHlordlzzz05//zzl/R0Fpkt1YAigogIJJKuOt7hksKBitCpxdVAu1InaWXytU0sQ46OlvAvBku+k0Mk1ESnzTnUhe9mVEoHNKxMFLzxFdq+rZDwnYQiwdoOGSbp4hQARQd/IiVnh/L0FEjYhDfioue10lAv/aPW5Fq7+n/vZFlb9XcKTmhqseQpRodFPPbSd3MqpaBUzskPYMIBCkGzJhisKQbqQZ9D0leX9NfcGMgFg0rQkoK2FBTBcTRgNYjSIAqLaLtyLrSNrXCLyBORDDYkgzXBYC5o5h5UCEMpfKckYRBWu85FWBQOTLgyESqSPy5TUbeCupU08N2irHcekS5LYKuaf3c9NNoPY3VstzofgTY9sbHTkEJIV+6GCvyKqguQ9yvnc3yDsxkyFFq48xIzDW/gUw51UFOwQ3o/YH1V3RAwQSDte1L4UGDhsxXx9c4D75hDla2phnmdoTvAxVAyecUU6TioWELU2X0qJWlX2QlbZSsIoMKRtJVQZFJVwEIoavhhpe8Ul5T2pedZpGc0+YX/8BmaUQg8jupQxJATODTikf5edL5tGaZYYHvyySe59dZb2XvvvZk0adJ8Ktb/zrbffnsmTZrE1ltvzZVXXsnAwAAbbrghG264Ib///e/5/e9/v9gVnYea1pqrrrqK3//+98yePZtdd901/m699dZj4sSJS3B2C2ezZ8+O5/mZZ54BHKj42Mc+xt57782mm266yOdw7733cuedd8afP/jBDy4w96EsS6666qpIOm80Ggu8NofT5s6dy1VXXdUhdPexj32so9zs/6rdeuutDAwMMGnSJPbee+//lWBrqeZQ/NfaW9GDJC8N9UJTL3z3pqhBEZwT6UjUSnqVbFGVSJA6WpUCLxBbTlogEKhjdDFERDOBzgRlDmUuaTUEg92KZkMwWBcM1qG/5tSwQxvVUib1+tZ174lzEEDsBCM9UcPzKJRA+OdKBeezIo+mXW+ksajSkBWarDDU2pru/jZd/W26Bgq6+9qMnD1Iz7w29UFN3tKowjh0FErEUDSQ3mmWsTOS9hyJtrAMCJgnLf3SaUf0KRjwJU/agyoXcRfxWKzy+hvC8RnaGNqmpNCuRr00QRzMXQmFQCqBzBXUMmwjQ4+oUY6oYbpybE0hckWuBY22obup6e0rGTunYLm+gt5BzYhmSU9bkydq4Tatn6cq3wqUWhBO0A3fRjiq9FUxYwjA0jm4pZS0MkWRZZgsQ6sMstxlHJC+pEVQuc9JxiAAOmswusDqAnSJ0AVZUVLTmrqx1Ax0WVeOVUPEsic5pCTI+Bk6jQoHklT0sp3zHcUEhaUlYEA6MnxbhuHK2BxJXKJVhgm8EJ9BEVJW2bdwbtJPFWsj2EFUxx0CAI5LUa1/67N+Tv8kKF53NgoILZLtkOsXDi926EoI3o5DUQGI6kpUmiLptCOPwq+JUEpVWkNpDYXRtE1Jv27Rb1oM2pIBCvpFyYCytKTTpHFd1Nz9EEU4/TkQPgXU2aXKVufN/xw5JEnQA1txm5RwAZTM+qyVz5A4YONKOo0x3PH8Mg7FgtrKK6/MP/7xD0aMGMG3vvUtTj/9dPr7+9/0b4QQ9Pb2cscdd7Duuusybdo0tt12Wx555BHGjh3LnXfeOSztZ4fTuru7OeKIIzjzzDOZN28eAPV6naeeeooPfOADzJs3b4Fq/98p9tOf/pRPfOITHQ7dpZdeylFHHRWPd1HZTjvtxJQpU+LPF110EYceeugCb++mm25i2223pdFoxNe+8Y1vvKW1uahMCME///lP3v3ud5PnOe12m+WWW26pE0tcFHbkkUdy+umnM2LECNZYY42FKp9clPZ/kkMhrWvhqLzadShxcpmIDCVzlKyRyZxc1ciVe57JHCUypFDOKU/iiJ3OSZWpqOrPo0SBAwPGUGqNLjVlUaKLEtMqsC3Xm162NFnbkBW+bW1SXx4yFGhbaUzMV+LkypxMqbGlxpQltigxRemeax3fgzYIbZDa6STkhabW1jRamu7Bgt6BglH9bZbra7F8X4vlBgpGNktGtDXdpaGhLbVA/sUJqkUnMXX0fBamLSXNzI9cMpD7rEBdMtBwAn593Yq5PZLZIxSv9SpmjVS8Oipj1qiM15bLmT2qxtxRNfp6a/T31hjsyWl15bTqWVU6ljntD43EGIHVQAmiJAIgIxzZvV2XDHYp+noy5vZI5nRL5nQJ5tRhXmYZUIamMBRotC/1CvX0ymcocj9qYdiUAC3jyAPQChwcnMBhaTWFKWnrgkIXlNqRrQM/Jkb0/eIKObJQVuM0EDI3VIaQwYH33Z+kAwKxpAnb4XCnIxTVhMD265fTJJZEy9PIfsyuhLsg8g+qR3cXDWldm0T5XbckB4iFUqBUZwZGevAvq+xD6A72elkKx/UQvngt8D2SWXbWlc1XXlVxNYJjniqFJ12iEvDhStMqEn6mMmoqpy5zGiKjgS9/soLcO/RVmZfPkJjOkQYBYncx25ndiM/SdFTMWCU5jQT8hN9V2dRlKYqFsZkzZzJmzBj+9a9/8aUvfektib+NHj2al19+mY022oizzz6byZMn8+qrr7Lqqqty6qmnsssuuyyGmb89u+666/jhD3/Iiy++yJgxYxgzZgzf//73WXfddXn11VdZYYUVlvQUF8o++9nPzqeR8MlPfpJp06YtsPjckrJdd92VU045peO1t7o2F5VZa1lnnXWGTXPjf5Odf/75wyKG+U61pRpQINxXrvC6ETL8K5R3xvJkZJWTJpUTFouAIuno4jddlX6kzlToPlORbE0gTJfaOfqtEtsswAteyYESNajJWsYBi9K1rQ2AQnjOQ0qkdmDCdpY6dYCKIQCjLKHUCD9kockKTa2laTQ1XYMFPQMFvf1tRva1GdlfMHKgpLepGdE2dJeGbm1pGOvLeyD3znWo/w58iVIKWsqNwUwwkAv668KVLTUEfQ1JX7ekv9s99vUo5o1QzOtVzE3GvF5FX6+if2TGYG9Os7dG0VOj6KlTduXoRoauZ2hPZi8zp/uhpUQLhUE6ErOQWOEyTyaTlDVFu65odin6uzP6uhXzuiR9DUl/TTCQQVO5DkalLwmKEV+q0pdUpdr97Em2IRJM4DCkAojOqS89qHAlTyXGlFijwZiKT+CzPbF1bfgv1OoL4bpGCb9Wo0aFpJTSATph4yhEBSrCf8659/wA28kTSLMJlfmiGltFz6sSIO/HRh7CEFE7kvcQ31z5vVK4jmWZQuQ55Ll7zDLXwcxnOQLXKJQ9zfccn0EKr8X7NtH37khXVEc2XwqiggidEMtnoqpsQZIJiXVILlsoE7J2Vf4kXVvZkDEYwi95PWCRnstKJPBNKpVE5+w7j5N4nqosrHjDkrdl9tatLEsmT57MpZdeyrrrrssdd9zxumJpP/zhD/l//+//ceONN1Kr1TjssMOYNWsWl112GVmWMWnSJC6//PJ3VAecRqPBbbfdxmabbca1117LoYceym233cZtt90Wo+hZlnHdddfx0Y9+dMlOdiHMGMOdd97JRz7yEYqi4LjjjuO0005bYE7D27F77rmH7bffnna7DcBuu+3G9ddfv8BARmvNr3/9a/baa6/4mpTyTdfm4jCt9VLbFWxRmrU23vO/+c1v+PjHP76EZzS8tujvoEVozqGQMYwohPU3pnRgQwRHxQ2nTuv+1r3LYH2fSOc7hHiuZb6vcQtWOEcgDXgGEmzCUcWBHIMw0ke+XctGU3PvUbnESOfsmVD2kJZcyLBDEshnqVrYuFIppEXKyrESttLayEpD3tLUW5quZkn3YEn3QOFaxA6WdDdLGm1DPQE41lZtUo0FhI3BUOM9mwAomhIGFPRn0J8LBjLLgBIM5DCYS9qZE9Vzwzn7Vgk3Mqe3EJxEa8FoiS0ktpRe4EIgCpd1cQ6XgKAunSlslvntVJFuk0m0sQgEhbE065KsLRFaIkuJagvQEm01NesAQOZPq4xXLpTDBD6A8K5ZFdEXAp9ZcJdIeK/biKTdqTWYQLIxBiGc0rTwis8pY7ZyAt35dpV6vixPSqxVIA1WGlemZDVKWNrBaU8sXS4J5aKjba/bZ7XKX0/DQljfycsOGcm+RIf7WpUGhv13nCAPKAgtkIU7LxiDLXVS3uO3FqPwttqefz1uNsJA90rMJljhu7MlJYsExzq5T1/nO1wkW414IgGdFpFwi/w6DZlSDy4yq8gwZFZQRI6G45/EXcZuUna+85uCsvSUuBeqI+6AhMJ/NqQXQ4TPKBG1RZbZwtsDDzzAb3/7W+r1Ovvvvz+f+9znuOqqq5g2bRpKKT796U+zyy67IKXk5ptv5q9//StjxozhAx/4AKuvvjrnnnsut956K6+99tqSPpRoEyZMYO+99+aDH/wg11xzDY888gibbropW2+9NZdddhl5ntPd3c2vfvUrPvWpT3HAAQcgpVxqu/jMnj2bu+++G2MMa665JssvvzxdXV0cffTRXHbZZZGbsCj3C45jsMUWWyzUNl944QVuu+02zj33XA488ECmTZvG008/zeTJk8nzfDimvcyG0ebNm8e5557LwQcfzKqrrrqkpzOstnQDCimwxkcLk6ghVmBFhvUZiMhFSL5QnRMl/XevJySL6gv79WqzbQomwu+TevzwXCAQRiBKgzLS6R8YFTswKaxr3erbmIbWtH5ibv7WOm2LxN0TwmKt27ZUfp/h+AFhnLhWpi1521BvahqDpQMU/W16+gu6Bwq6B0u6WppGYchL12LXYyXXr15YTHAXhcUGZ1k6cvWAz070K5iXW+bVcJ2ZPLho1tz7XGZBUOYSm/myFuWeh4h0LNfQ1gmFFNqXweBAQmlAG7QVWKmQmYI8c1yKPAyF9TodRnqCNopmoVBl5kjqpUG1FUIbjJWu/Mi4DlYuE9EZvQ9RfeE9s0jixbtxIkTG6VgTJlkTwhqwAmm0yzRgXGcxf+jBNYwZEr/8nO8YQ/u+25PBKoP2e22HmLxNfHHrbmgZ5mlfR9k8jegLG/VAInPEA4lArpZR6DGArarDk0iW7Xz3ZkRG4Q8TMJFn7mejQWt39EYijOnwoCtCsgsUdIjXkcbmU4QwP1rovEad163aQ/Xe6tH/60FnpUuT8KmsL4ESCiWMG1Z6RW0b+SGBtxECEXEvEUxUmaswfWvDOklmWC2c2CAhnocK1SVXQsx3bMts4e3aa6/ln//8Jx/84Af59re/TbPZpK+vj3q9zo9+9CP6+vr45S9/yQknnMBKK63EH/7wByZMmMADDzzAscceu6Sn32GjR49m++2354wzzuC5557j5z//Oe9973v5zne+w7PPPstXvvIVDjroIA444AC+973vse2227LnnnsyYcIE/va3vzFz5sylklNhreW5557jM5/5TOxidc4553DrrbcuMkCR7nfVVVelXq8jpWTVVVflhRde6OgE9XZs9uzZHHvssey0007cdttt/PGPf2Ty5MmsvPLK9Pf3MzAwMMxHscwW1GbNmsWxxx7LbrvtxsiRI1lhhRU6FNWXZluqAUUQqbNGYhWAwFqBtRIrMoxQHeq0nSl/C9Z4R8W7UyEJkIIJO8TFSH+O0Uvv1UVyhUCUOCKxzwCY0kLNYOvKReMzgVUWK0ELg/TR7Vj7DFXWw3shrluU8zKs8Z4f7riFxQGJ0lIvnchfz2BB94DLRvT0F/TMa9M9UNBoa+ptJ/6XaR+R99lJifU16VUdvhY4rQcFAzXBvFzSn0FfDnNqgnk1XClRLmjmglZNON5DJtG5z05kHtQp4UjmCaAQuNa9DlQYaJWIXGHbJRTalX9ZAcoDhzyDrhr05Ni6gprE1tz2jbWOqCIEostlN2IpkDZoa2kLTReO2Ky1V7q2vt4d6/kQPithgzyfhHB9CJFsf53CGhChHt85kcq4C+g6SLlOWhKDFMaDXt96mLCOhgTNQ2QfCSrzTqzjkLi1YtHGUlrHo7Ax6yLIqHQQqs5Vwi+ZqseQ8e8Jjw5IBb2Rqp7fhomKak2GzFpsoBQi+UJ4gO7vSeGuuc0k5ArqGSiJdTLgWGv8I3FDDsA5UCE7z0riGCfgIPyTtH+Ov8NF54W/PVPnW/qsQ3pLR4BH+Cxw6y9G+klUxcPni5RIq1DCooQmQ7uuYT4LpqzvxCar8x9AXwUmgvvfCQICELJDjjxR6YigorMAqlpQoQ3vMhs+mzZtGu9+97t58cUXOfPMMznzzDPj7/baay+mTJnCmDFjmDFjBlJKTj/99Pnq3d8J9uMf/5jJkyfT19fHGmuswc0338yHPvQhnn/++Q6xtLXXXptnnnmGlVZaiW984xscccQRPPnkkyy//PJLpcPabDZZY401uOWWW9hhhx0W235brRZrrrkmN910EzvuuCOjR49mxowZbLzxxkydOnWht3/KKafEdfbAAw9w6KGHctFFFy30dpfZ8NuXvvQldtttt3eE0vlw2FLNobCZwGYCk0lMpjCZQsfuOsqp+MowgpgU1Qhq1dKXlnSyIKPnFDrvWF+i4UYAEX5oENoiNIjS+tamFtkyyEGN6teo/pKsr3BjoCAf0GRNTd42qMKgtEVqEFGfgkqfIuhV6DAMojDIwqDaJVmzoDZQ0Ohv09XXpntei545LXrmtuie06JrXptaf0He1KiW+zuhEw+KKjLvHFGXSUFYjLQUytLKoa8umNvlFMDDmOs5EwNdkmaXpNXIKLoyyi6F7sow3Tm2yw26am40cmjkiEYOXTl059BTQ4yoI3ob0NuA3i4Y2Y0d2YUd1YWJo4HprfvtZth6yFI4p9V4IFPUFc2ujIHunHk9OXNH1JjbkzOvO2NeI6O/JhnMPCdEuk5HJY4jY/11d66YdyOFxQrXkUtL60jDKtT9u6KiDNdStmHc6DKWhrbUtaYW2vRqpwkS6uUlqYgiRHfWZyhcC1lX2mWVW99lltFWyul6+Da7hYBSiOg8S38NHdnci/hZp7ERiOcBbFSaFr7dMkmZlCedd3RL8mtE2sAjqcp1hI+SR26JEFGUzwiLEQYjNVpqjDRuCA9frQP6nVyNlNsiYkvoOGwQpxRV29oEbFSlaJ1K6Cl4sAwltHtxQGEpcNosgRtTWtNJgI/XSSGlbwrhGlOTedJ+1X2pOq9piVP1sZNkVkIQJL5BUJ3ZhMw/5BFbvTMAvMhPWWbDatZattxyS6688koA2u02G264IXfccQd77bUX99xzD1JK9tprL77//e8v4dl2mpSSe++9l912240//elPbLXVVjzwwANsvvnmXHHFFWy99dbxvWeddRa77bYbAHfddRcPPfQQBx100JKa+rDaIYccwqmnnhp/vv766znuuOMW+X4PO+ywDoB57bXXLrSK8k477cRPfvKTjte+973vceGFFy7UdpfZ8NsOO+zABRdcwHvf+16mTZu2xPguw2lLdYZCKFxkWwmnAI1AGomxLnYXK8O9l9OppBswgctqeNIAaSai6hTjY4RJnfcb1mGn/fZtaEDqnEdrJNK4qKXVAjKBzcDkwilXSwHSeqm5agcW60itxkfBrfXOg0F6MbW8NNTahnrb+K5OJV39BY2mptEsqTU1WVtXQCKUrfuRlpLIUGvh46IBVJTK0s6hVfd6ErkTjmtl0M6ciF2ZS0ytykrYXLmodKZcdx/py9JkaMkpY9lTEPxD+TakuXYZC+OjyKErUCahHrYrgoR3vC4WV1pFJl32wiqstajCIEsTj1mGUi9/toW1kYRdOXsGfHbCuaUSK63PLvhH6yLpLpLveDPx6vkouBAemAiDldqtOesi3J0x5Q6FAr8RV9JnpYoZsZhDM24n0gX5yZOqIZdpsFETIaPqwGQ8dyi2GBXWO7q2cnhDloZA63Hrv1LKrpxySZWkSzNsIaPhSgK1b0DgM0jaif9ZU4Kj2RMyQ/HQrc/KxRzRkPuvmop/3V+XeBKrTEXgEYT7siJyV++0BP2VJAtB2pBBxIxIBUj8QfsuVkoEIU3jM0U2ZoHiPsLxdTx6ECQqMBGJ1eEmtem5SWCbL4XqBCdhm1U2bJkNvz355JP8/Oc/529/+xtlWTJt2jQOPPBAJk2axIorrsipp57K3XffzSuvvLKkpxpt1VVX5eijj2aDDTbgyiuv5NFHH+WQQw5hnXXW4YILLuD3v/8906dPj++fNWsWf/vb3zj11FM59dRT2XXXXXnttddQSvH1r3+dn/3sZ1FkbWmz5557jhdeeCH+/O53v5t9990XKWVH1mlR7PfFF1/s2O+4ceMWaptPP/00l112Ge12O5bWjR8/ng9/+MN84xvf4Bvf+MZiU9j+7W9/i7WWQw89NK6Rxx9/fLHse2mw6dOn88tf/pLBwUGOOuqo/xVaHUs1oJCBO6F8tgHpHDQrkQEoANGpEBYjK1BhYjDUfw1HKeLOggMbajqMTTfnLXm/DUFlizCdve6d4JlBGeGdKgG5wOYCbYUDQaFGxW+3coVCfYYvBfGgQtlKd6PW9h2dWn4MlHT1lzRaJbW2Jm8ZVNv4LIrvXDXEKUqdEen3HpxhpON9lDm0a8IPSTuHInP0B61EVd6UKWweauYdkdoBChkfgxMWeRQRUBhX6lOoSkk8lM14PQ4yWYGJ4PEGL1K666iVK7FxQW+L7MqQuuqeo7Rr1VlxHlwJmPLHXXEqkli2z1IE5eZA8hW+778gAWhhPRjrgAQChMYYgZbSg05PkxYJlEgc5Ehylj6ZaC0OJngYJHDdo3ClTyET4H5lO7tWYR0hPFxX61rPeoUMd8y+rC7wF1JuRTi4WOKU3gb+9x0c6vjEYjyQMN5ZDtoLRhukVy0M581xQ6rkaUJ/j7834RgTQGHT534puderOykCTgIw6zyEABwqAOEEAk3cpge3IpwZf4jhfIWWskb6LIWNwMIwFOyE65RmJRIwIRLAknzMiNcZqTDfULPhFnvd3y6z4bDrrruOW2+9ldVXX53111+fI444gvXWW4+//e1vnHbaae8ojsHKK6/Mdtttxxe+8AUefvhh/vSnP9HV1cXXvvY1HnnkEc4//3zuv//++f7ulVde4bvf/S4TJ07kAx/4AKNHjwbgpJNOYsaMGQwODjJjxozFfTjDYq+99hqPPvoo66+/Po8//jhrrbUWn/3sZxcpoAAH1B5++GE22GADAFZYYQXWWWedhQJnt912G88//zzbbbcd733ve5k5cybGGE455RSuu+46/vGPfyxyvQ2AG2+8kWazyeGHH87JJ5/Mn//852WAYoj9+c9/Zs6cORx99NG8973vZerUqcyePXtJT2uBbakuecoAJSTSl4S4siX/KGRHRsKVWbhIu1EWrZyDbBW+BEp0tnOPzp13P7x3InypUyRShy+KxDMXic6E1BZZWmRhXPlTU7s2sgOafEBTG9DUBw31piFvW89r8OrWxpVAOcXrRKTLuLr/vDDkhaHecuTr7v6Cnr6CEfPc6OkrHKgIwnWlQZb+WEwSOaZyAAVD6+4tShik8CTxDEwOuibRdTdMTaFrCpOrSJC2mc9KZL5VaKYQWYasZcha7h7r7mdRyxA15UY9c6PLlUDRW4eRrgTK9taxPTVsd45tOMASy9aGOGJG4kjhuaSoKdpdGc3unIGenP4RNfp6cvq7MwbqisGaopl5Ze5Q+uTbsBobSqCie4kWBi0NWlq0XztSQCYEdQRd1o1uA10G145XG2pGo4x2JG1TIowGoz1521ZjPvPRb+kI2qgMssyVP/mhpYoaIdZn5IaWrylM5HOkHAuZPFagMpCik2E7Hdeq/t9WAMp2PkaxPl2giza61aRsDlAM9tNuDtBuN2mXbVpW08ZQYCjxYo+2UyekGu4eUKYiOzttF1H9HEj0AUx4MrnB0tlcIdy+VdlTBBMiaH14Ho51KuvaumFCcZwIyNFdo9jtSShyEbRK0tInX1YWSrTCjZeAVJN8dkU9xfRaIKg6dyX8iahrIqqlE/52GZ5YpLbVVlvx4IMP8uCDD7L11ltz7bXX8uEPf/gdBSaEEHz+85/n0ksvpSxLPvShD7Hjjjty1llnMTAwwGabbfa6YCK1HXbYIUafwd1bZ599Nt/73veWOh2HYFdddRXbb7891lr2228/zjvvPIBFfjzXXntt3C/A4YcfzrXXXrvQ23388cfZZJNNmDVrFl/5ylf43Oc+R57n/PWvf+0oZVtm7xy77bbb2H333Zf0NBbK3jaguP3229lzzz1ZeeWVEULM1zbu0EMP9erN1dhyyy073tNqtTj22GMZO3YsPT09fPSjH+XZZ59925PPjSAzAmWl06CIytHVt2h0E4TBCO1rt13dtlUG6z2QEJWNHW4QnY4TFciIHzEhFJw4UU6kKgUV1oEKbVGlRRWWrGXJm5Z80FAbMNQHDPVBS6NpaLQs9bYjV2elJwxrDyaM7+CkHfG6URi6miU9gwUj+gtGzGvH0dNX0DVY0mg6PYq8MKjSCWgJk8ydEOBP9RZcmUyOpYalZv3AUMOSC8glKCV81yWFyDNHlvZAgiwIlsmYXXBtQz24yN1w2Qvpy7/8qElsPYMuN2x3ju3xfIku5YjtufSkfJKaeBtV0I0UGOU6TemapKwr2t0ZzZ6cgREeVIyo0dedM9DIPKiQDlQIQQEU3pmcH1R4Z1JojL/Y4Rxm1gnh1YOmh3HPc2PItCbTJUqXCO0AhbDap8k6q/qJVyZFua5O340cVA6qhlF5BSqEU2PXonKSnWNtIl+jGsYXBqb7rCw4s5XHmyz8wC8i7fqUcEHCMVmD1SWmLDDtFmWrSTE4QGtwgGZzkMF2iwFTMCAMA9IwKC0taShxzruJ3CWLNMaD6xRYdHI7ogq25324+zd0MbPV7drBV0kAhqhKo6quTngo6deC16AJZZGE8+TL+aRSKJWRSUUuMnKUUzS3xJHON3BOjAcSQbhv6BWZLyNhU36LiGAvCumlfyM6r+CisnfS98OStP33359jjjlmSU9jPrvvvvv4zGc+w9///ndWXXVV7r33Xj72sY8xZcoUJkyY8Ja7DJ144olMmjSJoiiYMGECN998M3vvvTePP/64C/AtxXbrrbfyhS98gTXXXJMXX3yRFVdccUlPaaHsnHPO4ZhjjuHd7343zWZzSU9nmQ2xqVOnsuKKK/Laa6/x4x//mMsuu2xJT2mB7W3f+f39/Wy88cace+65b/ieXXbZheeffz6OG264oeP3xx9/PFdeeSWXX345d955J319feyxxx5vW+Qn14JMB1ARInVpb3aCl5/EHx3dEoITF6uiE/CQkFERQ/6rTKS7ibtLgYgdEkEFpXGK2YUla0PehlrLUmuZOGKmoiSCicyP3OAARWFotH15U9NzJvxoNJ1Cdl4Y8tLEjEflhFTdjFyEMxE/S15T1nU+ygOg8JH2hjEeYNgKWCiBCDoDQaQsgrokEhyjrqH7j88QpdFYKSDDczAkNk/ARtCyCH9D9Rhd8uBBSfde4zUqylxR1BXtRkarK6PZldFsKJp1RavmFLlLGRxy4VWo6SDg2uha6gRk2FjQIryT7s6f48uEx8xaR8Y22rVI9WJ3xAzF669z52/GGLQDzlIhZOYyFjJzondCUgpJKRyfwgn3eUdYkMy/+q+afTh3FdcIv98q8yOGONyVK17xKhx4Ef4Rn4WxukTrAl22KYq2y0rokqYpGcQwICyDCprK0pSWtnAkaGPTTEUqAEcUCZzPeY7BgDRiz5C7FzqARLpOhwCoyMWyoiORlJYNxtI96cCzlBIllctW+AxFbgWZqYIDqeNf3Sdi/vl0fpTFUryOkXzWDIGhHZmmRW3vpO+HxW0PP/wwRxxxBEVRcMQRR3DOOedwzjnnvCOi9uPGjeMXv/gFa621FldeeSUXXnghp59+Oquuuio/+9nP+N73vve2WqX29fUxe/ZslFJ8+9vf5sYbb+TCCy/k3e9+NxdeeCETJkxYdAeziGzu3Lkceuih9Pf3c8stt/ClL32JcePGLfLa9nnz5nHooYfyzDPPALDiiivyi1/8guWXX36htmut5dhjj41E++9+97vkec5JJ53EEUccMRxTX2bDYGVZ8tJLL3HUUUfxyCOPMGrUqCU9pQW2tw0odt11V771rW8xadKkN3xPvV5nxRVXjCPUWgLMmTOHCy64gDPOOIOJEyfyvve9j0svvZSHHnqIW2655e1NvsSBCSM6InRDBbiio0TVsYmhTgohUh8c7qTTjRC+tpxYQlCBCdH5ZZ88xm0lZRgOXFgPLCxZYcnallrbUmtZcv88Lx1wyLR1YMJCbiy5sdRChqKt6WpruptOa6Krpam3KzCRla5zlNIhGlp1FQqORwQWNlFSTpwW5wxDbgw1bWhoQ6N0nYsaxkVbM+HUnaUUjjwu5wcTIcobyk1cJDYQX6NbWl0nQUc3LqNwQ3qeQEc5iO0AFu65qIYUrtNXLtE1RVlXFA1Fq5HRamS0a4oiD4BComUodcHXz1eRaTtkVIUvUdIOEcGFV6sO591H1oUxCBtKnYZkJ2x1xsIzEVaaiCvU66s4MIFQWJF5FW2XYWkLaAMl1pcQWX++OzsZhbbAKVcglNsY3zEqZnz8eYldk0Tq9HowEY7BmgiWrNUYU2J0idYlpS5p65KWKWmhGcRlJgaloekzFIXw5UWk9+vQTAiJ5kZnpylIneohoMLOvzZfd0R+z1Bz8wjcqrj2YtmTiCraMoAKW3WjykySnQib6/isqvaUfraIIT+nnykua1F1xBoKJsL9vKjtnfT9sLjt+eef56KLLmLKlClYa9lss804+OCD2XHHHent7V1i81pttdXYddddOeSQQ3jggQd46KGHsNZy8MEHc9ddd/HrX/+aP//5z297u6+99hp//vOf+cQnPkFPTw//+Mc/uOuuuzj44IPZfffdWXvttRfB0Sw6azabXHzxxbz22mvMnTs3Eqa33XbbRSpA1mq14n4Bent7OeSQQ+jp6VnobV9xxRVcc801PP/88xx44IEopZg4cSKTJ09mu+22W+jtL7Phs8svv5wnn3ySsWPHsv322y+Vmb5FMuNbb72VFVZYgbXXXpsjjjiiQ7TjvvvuoygKdtppp/jayiuvzAYbbMBdd931uttrtVrMnTu3YwAuO1G6LIUKWYoUTIhAoq3isdHR0S5KHIY0JnFSQp2zE6jyBVWI8OhT9VJUToqk6glfOeYi1qmrUJ7ga72VxmUgCiKYqLcsjaZ7rLcstcJSK6GmHbioaaiXlq7C0N3SjGhqRgyUjBgs6RlwoKLeKqkVugIToTzEDCkLgSi6FbrQKKgcYVtlWDLjyqwaft89hWZEYeguDN2+tCcXoAKg8BFeS4jiWqwxTi3culp0Y0xSPmI7hg3O75ARAceQzEQEI9ARSQ9gwsZMhetCFbIU7a5kNByoKDNBKWUsGypxw9XQp+UuOg5jg+vrRtUfyEfTcc6eihkK05mhSLMUlXve4RU69eckQ4FzVoUHFVYptFS0haQlBE0BTWFpCmgJaOPE8MpkaGF9NsM/CiglLjsj8UMkj65Nbul/V12XFBAlpU5WY40DE9qUFLagsCVtW9KymiaaATQDQtMvqzEoDU1haAvtSp9C2VNHliKs1cpxTj3oFEjIjsfOjECVY0oyW3hgEDdZvQais5lB4GMk4DXorEipUNJxKTJchiL3wQHH/7Adn1fzr+m4kyEgYkiW0abieZ0CjCL9vHqDz+vFbcP9/QBv/B2xuK0oCvbcc0922mknvvOd71Cv15kyZQrrr78+Wbb4e6DUajU+8YlPRB2Cww8/nFVWWYWzzz6bvr4+9t57b2677bYF2vaDDz7IbrvtxuzZs/n617/OBz/4QT7+8Y8zMDDAOeecw9FHH02tVhvOw1ks1mq1OOCAA7jgggtotVpcdtllTJo0aZEfS6vV6ujAVK/XhyU78v3vf5+TTjqJVqsVX5s4cSK/+93v6OrqWmwZtDzPlyl3/xtrt9tssskmXH/99UvluRr275hdd92VX/7yl/zpT3/ijDPO4G9/+xsf+chH4mJ+4YUXqNVq86Xzxo8f39G6LbXvfve7jBo1Ko4gtpOXkkzLquwplj6B8B2djHSaAVpUjixaI0qnxSBL4zr/+JIkGXva+37ynlyphCKTCimVizwKiRQBdAiUEK57qXBgJEM4UrMVTjQNonhaLF/SkJdQK6DegkbT0tW0dA8aepqWniZ0ty1dhaW7hO7C0tM29DY1o/pLRvUVLNdXMKqvoHegcJmKlqZWaHJtyDxxVRnnzAZHJCj4VsRrT8r1josz5zVJ60CJAxSaES3NyKZmVLNk+aZmVMvQW9oILDIc2TRGXi0YbdHGoLWh1LoapUZr44d2IMMY917jia/WYIx/X/K74Nin+QGbgpLo9CVZCiUxuXIk8kZG0Z3T7qnR6s5pdeW0G5kDFd5pLgQU2DiCFkGcg9FoU1LakhJN4Qnbsf4/uKrRCR5aCuQebQQTkQkSvcy0WCcCV+syQiLhVCAVpVK0lGRQCfokzJMwT1j6/BjAutIiYWkmj00JTQVNKWgqQTMTNDNJM5c0a5LBmnRtgmtOuNC1CHbgI3SVivmU5Pgc2CopbEnLFjQpGaRkQJQORIjSj4I+0aZPFvTLgn5RMChLWsKd09KfzZD5SMueOrKRyfdiEHHrzCRWKcYw5wD9XJbGX4GODfpAggdxQShz6N8HUcog4ieUclwKqchk5rgUVrlhRML/cvdkzFIEAB5eeAMwUd3PPusVM60BTNikCkugpEC9AyJei+L7Ad74O2JJ2q9//WvWWGMNrLXcfvvtfPWrX13sc7j11lv5xje+EX+eOnUqRx55JPfddx/jxo1b6I4y7XabVVZZhSlTprDvvvvy97//nRVWWIH777+fo48+mgcffHAhj2Dx2zbbbMN3vvMd/vnPf7Lccssxc+ZMfvCDH8xXmjfctu222/LNb34z/vzII48MW2nSbbfdxoorrtjBoRgzZgyzZs1io402GpZ9/Dv7zW9+w//8z/8sln0trfaZz3yG/fbbb0lPY4Ft2L9h9t9/f3bffXc22GAD9txzT2688UYef/xxrr/++jf9O2vtGyLlL37xi8yZMyeOUGsojfCdXarHyHMQrszJdeKxlLIiVdogDBeE6DyJOu2QIoXLSygPHpRUSA8sQm20ey49mEiBhPCdkjrFtyKgCKDCBk4E1ErrgEXb0mhDV9vS1bZ0ty3dhaW7behpGXqahp6mZsRgSW/ITgyWdLc0jUJTKw017UjAATgEkFWRctOSpoTIGi8GVXjUl+pkxhHFG4Whp6XpbWpGtjQjW8ZnKyxdpeNZdJBNrbu2RhuM1phSows3TKnRpXs0EVgEZ929P7zmnmsPPHT1HmOrxwAk0ghyUjrkDlhU3IyaQtcduCgbvhQqFxSZiKDCRe4DqPDZCmvmG6V13YkKTMVbSMqMYhw/OIy2Kr+ztiqX8kv3dUp3kk4+Q/7DCzNqKSikoCVgUBKBRJ+w9AuSYRmQlkEJg0owmAkGlGAg96Mm6K8JBuru+UBdMlCXDNYdsGj7c6R9CZqdb+H44/VCcAWaljC0hKHpy5qa0tASmiYlTVvQtG2ats2gLWgKByZC16dwLm3KmUjLgIaAipDjGdoWNpzUkAkwrzPSjkpVxmP+EbkkaYaDkCFzfxdbyMqMTGSRoJ1bVZVAhc+v5HrHU5nMPs0YdpDN42lPMltJAZUQAinfOYBiUXw/wBt/RyxJ01rz0ksvsfPOO/PMM89w4IEHMmXKFKZMmbLQegP/znp7e7nxxhvZYIMNOjIjn/70p9ltt9045phjho2g22w2OfXUUzn99NMZO3YsV155JWeffTYXXHAB9Xp9WPaxOK3ValEUBauuuipXX301xxxzDFOmTFnkxxL2G6xer3PccccNS+taYwxz585ljz324N577+WWW25hv/32o16vc/7553P44Ycv9D5ezx588EH22GMPWq0WtVptqcxYLU4rioJ2u029Xue6665jk002WdJTelu2yL9hVlppJVZbbTX++c9/Ao5w1G63Y71gsJdeeonx48e/7jbq9TojR47sGOBjh1Eht+IyAB1lMx0OXohgG8D4jjSm+rtQtJRAC5+NSMFECiqEF7ISFbAQFZCImQkqReLMhvavXnU4ZCu0K3GqF67TU6OwEVi44Uqdupua7kFHxm60NPW2cUCidByLzFhP/qw6+qQ8kViWZel4LbXgz8ToqN9uzXeX6vbAYkRb09N2Pzd8WVYWnR7hq2BsFDQzpfEAwgMJDyaMNlhtsMZpFhgdHs3rjyFgwho7xFkPROFwNN5ZF1TiepmE3IELkyt0Ll1XqFDWI6jKngRJuRBoG0qgAkXbRmVlV05EbD3bsf6ic1wBiQpYzOcCd1yXQCoOTmQoZwnlOMaTydtS0BKCQQEDCYjoly5DMSAt/RIGVDUGcydUOFCTHkT453Xpntd9hsIDijLzuiOv0z6oatHqwECB40S0pe0cwv2uTUnLutGmpO1BSCmcgrYJqS638aRdbcotsEPmEIBlFfFPnf7I3wlAIjynAhvzgYShzQPSvyUBVkkHo5DNDG1kq/KnlFeRdqcaApQCMMdnD8N93PG7jrs2ngm3f6rPqHcAoBhqw/H9AG/8HbGkrSgKbr75Zn71q19xxx13MDAwwE477cQnP/lJ1l133UWyzwkTJnDggQey8847R+5GX18fl1xyCTfeeCM33XQTf/3rX4d1nw888ABXX301v/vd75g4cSKPPvoo06ZNo7e3l4MOOogRI0YM6/4WtT300EPcfPPN7LTTTtxzzz3MmDGDFVZYgQMPPHCRlq49/PDDHZ3R1l13XbbYYoth2bYxhj/+8Y+8+uqrNBoNRo0axSWXXMLaa6+9yPgus2bN4uabb3aVIcvsLdlzzz3H5Zdfzkc+8hEOOOCA+brgvZNtkX/DvPrqqzzzzDOstNJKAGy22Wbkec7NN98c3/P888/z8MMPv+3+yB1lDLZyuKByGrQwvlbcRZBDu8cYxg5gwroMBR1OmisrkSItc1KeaFmBi0xIMindowhZCvc8Zi18D/rcg4vYQjJE/43jSjieBHQVlq6WG90tl5XoGaxG6ObUaGkabU29cGTtmvbbtFWHoZRknToule5AWhgSnlVnOLTndIAicDhcxqS3qelteVDRNtS1AzWdWQrn8IcshS01pqgAhS0DULARWLgMxesPHZ87MGJNGAmwGAIyQhVRDDpL15VK+Ba3NnedoLRyxGYthe/4RNI1ScQsRQmU1roSqJCdEA5sFCJoWVSaFiHTUQ4FF7FJgK3GEOe4siRinUJBIWJpl9uPoCVdlqJfQr+0zEuHohqZoC/3oyboqwv6GpK+hmReQzCvIehrCPobgoGGoFkXtGKGwnMGXgdUhIIvLYzL8Eg/lBNBLKV1IANN25a0TUHblLRNSWE1ha0YKdaXVVWgOOVQVFoTouMUhSxJJwndChuBQ0d2Qs6fqUi1IOLrUfMkBRNp3yw/hVD6FDOZVZaiRshUCNf5yaacirT1bvJZl67fyCHpXBMdK0eEKbjsRCYl+TsQUCzK74d3kn3lK1/h4IMP5j//8z959dVXOeOMM9h7770ZM2YMY8aMGbY69pEjR7Lzzjvz3//933Gbg4ODPPbYYxx88MFvq5PT27W7776bI488Emstyy23HEoplFJcfPHFrL322jQajUW27+G2q6++mlNOOQWA5ZdfHq0148eP5+c///kiPY5rr72WE088kVdffTU64XmeD+samTNnDptssgmnn346J510Es899xxdXV0L3VVqmQ2PTZ06lU9/+tO88MILnHDCCUtVR663DbX7+vp44okn4s9PPfUUDzzwAKNHj2b06NF87WtfY5999mGllVZi+vTpnHrqqYwdO5a9994bgFGjRnH44Ydz4oknMmbMGEaPHs1JJ53EhhtuyMSJE9/WXKovVFF5E6FNrM9OhIhx6euLg3PplKvTaF7nVh0pc4h7LZwTI72jIq1rEWqEJ+sKT4AWzok3/r0lrszIJ0UI9dGJ7+P+sSL2xzfgnGQNtgChLJnR5KWm3i7pGggEbENeunKk3NDBlagyNrbTIQFkp0uKIOxbxHMRI6F+mlL7FwqLqxUTFErSzDQa19uoLd0IqsBGCrSr9XG4zzv6QltPYBUIYX2HnHiS/QWJ6aYKAFZXrGN+rkzNndugQxI7DnlXK4CjAOxyfFmaFyNDKYxSaKUopbuOjoszpF4/YNjk810IB6JMUg5T4m4w6Q8idE1ygMRxehyG0Fgj3TkIIXGPgNJDtvH1Kh4fH4XACum6WVmJsYpSuSh/y1pqFpo4DRHpF4hW0M4FrUzSUoJmLunPBc0M2gra0j2WyXrIDTRKgSgF0mejbHoigiOPz+IQyg4DQV56Z1y7jA6W0vgGtsIikU7x2wpMUMtO1qBIf7bJkulwuDvnEuCGwMZrln43W1G9mJ7XtB1xqkvh1rrLxKQ3kU0erQ1d4SRKEj+apBVICVaHDmBOYyNwMIQ/5FQqJk61I4NhkwVoK85IxJguMOKAhCJXimRLi8zeSd8P70SbPn0648aN4+mnn+bb3/423/72tynLknHjxjFnzpyF3v5ll13Grrvu2vHaeeedx+c///mF3vbbsZtuuokzzzyT97///fzrX//i3nvv5cQTT1zkytOLwqZOncrRRx/NRz/60cXSaezJJ59khRVW4Omnn2bVVVdl8803Z+bMmYwdO3ZYFK4POOAADj74YH7xi1/w4osvIoRgww03ZOedd2adddYZhiNYZgtrg4ODrLrqqh2BlaXB3jaguPfee9l+++3jzyeccAIAhxxyCD/+8Y956KGHuPjii5k9ezYrrbQS22+/PVdccUVH27wzzzyTLMuYPHkyg4OD7LDDDvziF7942x0NorsQfE1RRQidyq1vAYrr2IOx/su2EnGrur4H+OABSjTvrorqyxuc+JtFIIXxnYmEAxAJqNC2iqAqrBeotlgr4ryjS2hE9IRsaLduLLYElEVKp7KsSk1eaLKWRrUNSjtSuQwEbKouTrGMyz+m3IkUTKTgxkWCg0PucxTecREEcT2DLgS50DQySfdgGduUDirBoJJe6UM6p1E6vz5EfInAzr1opXWeVPAOY6coG8GENbZjos61TsnKbvsyHhQEOfDQaUlZS24FNWOpGagX0CigXkhqWpIbR7FHKIzn3gjpARB+WpbEG/UUWOEAWgAM7tK5cpbSut/FNSuIbVpduVOYuEaYRDpRum5C7kDd+vJXI2DPZPUGL1KCVLGdrUahhcN/bQwtLEo4cIoEk0G7Bu1M0M4c4Xowh1bmFMPbEgpPvI4gXLsSPdc+thJgs1QAMMwrYnN8qR8ytqlV1iKEISrOa3CKi347vkGCc547G7/OH5uHCmBWZyr8G+biQIIHFuE3IrQ4Fp3vo/ocqdSzPaDw69kmyDtgwU4wLDxAkO54rfL3pcWKQC4v/f1gwEDh3k6JP+9DwVI4Wpvc39Xu/O5FZ2YiU9RVNuR8LRp7J30/vFPNWssuu+xCrVZjo4024qKLLuKOO+7ghBNOWGCHNc9z7rjjDtZff/2OSPYnPvEJbrvttkTIcdHa3Llz2XTTTbn00ks56KCD2GijjXjf+97H9ddfz0knncT73/9+PvnJTy6WuSysTZ8+nfe9731MmTIFcCVDeZ5z1113cdxxxy1Qq92htueee3aQ5oMJIRg/fjynnXYa06ZN42c/+9lC7yuYtZZrrrmG7bffnj/96U/x9QkTJvD3v/+dXXfd9U0bICyzxWPhnt1rr72YMGECO+ywwxKe0b+3tw0oPvzhD7/ph1O4+d7MGo1GFP1ZGAv10e558poAK6QXQfP10lYDEkPpSm2MIbgvgWNgRXBRK4sRaVIH1jl0zueVLsLeAU4qDYIwjPUtNj2oSL/dHa7wHoFJjibwO7RBoJFGo7QhK7VTvdbeETOJo207+RFVhNNGbY009xKmEhx04rF1xIR9fJcYspXaoEpB1vaCfMrQkIau3FDPDW0pXFmLdDXiLmob/WM3Z0QySePRgNt+POcReIRStaFXR0QnUMgQGfZueewG5DpVZQZqVlAzgrqGrgIabUGtEOSlJNcSZRWSDEK7Wun2L3zUXaYLwjuPAgcknLPvwKfF8Rmkdc50uqrCKglgKbYyxrjzLIQDWqFNabwGidMaHeDEoRcChELIQBfOnLaEtZTWOavSTQiURec4EnoOhRK0PJho+bKkQkAhQ7mRm2baDSnFeDYsnHB9k7UnfRmgQWKsIbdOKyOzLpOlrXPqAzlZQmyvnIpLIiqQZf2aqqjsHSfH39fCr2UbgR8iAT8irPfXBxMVoEgebefv/SWIRGzbcV38J4bAE7R9plB6Do3xXb1s4HaF9UACcgLEjHdgx1qKt09Yi6LSzVFSkimXncgWkzP+Tvp+eCfbo48+Crga89NPP53jjjuOww47jPe///20Wi3OOuust1x3vtpqq3HggQey6aabxlaTzWaTs846i9tuu42ZM2cusuMYalprHnzwQc4//3wmTZrEZpttxi677MIvfvELJk6cyIc+9CE+//nPc/bZZ7/jVZtbrRYPPPAA7XabnXfemdGjR/P9738/XqvllluOK6+88nX/9rOf/exbKiHadNNNWWeddTj77LPnu29uvPFGrr76aqQXyjzhhBO47LLLePzxxxf62F577TXuueceTjvtND71qU8xffp0HnjgAT772c9y/PHH89vf/pZ77713ofcT1uaSaJn8v8Euu+wy2u022267LV/4whe44IILePnll5f0tN7QluqrHJx0GSOOVRQSKSHPnHKzEmANVrQwtFzvGFNiTCAr++wC0U3z1hkXFGHbScQwRBCjQzkUUFiXuzAi4oMO8NPpIPsfjABcKYQQYVva62U4UCFK16XKpz06vBznTHVGNEEkYnbV72zyCJ1gwsa/Fh1Oosv0CNCu9W7W1tSkoC4F9VzSqCnaynUcyqQjhRoSx81W59FFo4WblAkn1p1UGx0sn6GwNvnQrbp5kTyGaK0AhHFAIozAUWloaGjhAEUT8pYgLyS5VmQ2c2vAIzMjAFlplITzNRR22lBEJgSlkJjgHFunuB2zRvFS+5IXDyCt8ArcAp+1cVcq4K6w36CP4LFL5dg6Yogjm6M8yDWx3aq1xgEtCVZZbOYyFGWO62qVuceWCi1hHe9Dx33bMG2XYQuYN6z0ZH2Eyxqc+sxzBaxHfcZCjuObRCfdhjbGvktaaLZgJcJKjxY9yPJoPnIiApQPa8B6B1y4DIcU1e/T6qxYohT/1jnwHjNjsRWAEiSvJ2AiALkEsLish0MFFuv4Otbn0SwIq8iNApG5QEYIOHgH0goHLubrOBVARQciTbQ1/BoLgCKTntulFHmW8SZ+/jJbQjZjxgxOPfVUdtxxR7bYYgu233772KFp+vTp/9bpXmGFFfjQhz7Et771rfhaX18fjz32GF/84hcXW2ZiqJ133nkMDAywxhpr8N3vfpf3vOc9zJs3j6OOOorvfve7/PGPf+Sxxx6jr69viczv39nyyy/PmDFjAJf92XrrrRkcHOSggw5ip512Yu+992aFFVbgoYceet2//+IXv8iIESPmay7wevbQQw+96bXaZJNNeOqpp/jqV7/KSy+9xNy5c4clgzAwMMCpp57KLrvswtSpU/nVr37FDjvswIknnkhRFLzwwgs8++yzC7WP1VdfPa7N559/flnm423aBRdcwJw5c1h33XX57ne/y3XXXfeOBhTCLqlPnIWwuXPnMmrUKM55z450i7yKvAsBSmKVpKzntLu7KOp1ylxRCjCtAeRAP6rZJGs2qbUK32nJ9/cXKgrYpV2eSJyGCF1slZHoiGgSyLbueacYWiAMeyIu3klOUEWIlAqRABNrELZ0j14YTWntou7Wd1+yXmAOyLBRTM9vzg1bcSe829nhGMd9+1eDUngEH8KJnhW+PWlbSQZyxbx6Rl9d0deV8VpPxisjc+b2uNfmNRT9NekzFiKWylTtNavHVFTMhX0DkKhI1/hzjxBDRAZdxy0pRCXaZyxZaci0I5N3l9BTSLq0oFEKugtBve2UylXboFoa2Wwj2iWUJaIoEGXpla071ZnT8xr5NqJaM2mbV2WJnb1S8bFYoy/BSsffsFJhpONxGKH8ufKARQivkO3Ag5VVRNw5pV5kz2i0LdGmTWkKtC0wtkRTYpXFZBKbKUyeoes5OlOUynW3KpQnj0unEh5kloRXd6+Xgp62pKuQNLSkq5TUjURZ4YnEFm01pdVRn6MtStrSUHhydksa+oVhEONaw1pH4M6spIaki4yRtkavrdFFRgNFg4wMGcvvwjF3ZhNEx+tDW7q6kjsPjML5HwLM0r+1VIrpIbtoCSJ7xOsrhEJIGfkh7rr4uzqsGW0Qxqmkow26LCl1m9I4QnoztMv1HbCaylJIJ6howWUFg8K2qXhS7h7w85ACqSRZJskyRT3P6WnUaeQ1anmOtfCzO29nzpw575guSIvKwnfE0mYf/ehHufrqqwGnS3DnnXe+6fsvuOACPvWpT3W89qtf/eodU1Y0YcIEnnrqKd7znvcwffp0Nttssxj5/sQnPsFll122hGf4+valL32pQxPiqKOO4sc//nH8+corr2SvvfZ602188Ytf5LTTThuW+WRZxqxZs+jt7eXKK698UyX6t2v3338/73vf+3jiiSdYa621ePrpp3n3u9/N3XffzVZbbbVQ295++6qsarfdduPGG28cjin/n7MVVliBF154gY022oiHH354ke9vQb8jluoMhbaurWTwSKvSdgEqR9a7yHq6oVFHZBIzWPOdVwRojS204ylA/PJPycBVhD6+wT+1VaQQkv2GenlREUWFxZjg+LmYsfUMbVdEg8cVlfcfynyENR5QaOeMWO+UWOtF+EI0dqgJrzlRtfEaWofdyRjpzMuk2R6TgA5rnXPlZTwcOCgBT2BWwpBLTS0X1CTUsNQUtJXA+G5AwndQqtpy+gKUobjWgwnX1te6nYZ6e39eHRFb+E46xrfvdWAqM5CVhlrhCOv1wjKiLegpLF2loOFLnvJSoEqQpXS6JDarWoQq4aPiiZK1cVdNJOuhSpW46xy6hKWV/2F9OSCXipl58GmNI/uGwwSsxJXuSekdYZGAL18dF3hD1md9kAhpkVZhyWIDAXw2T0vjCdJ40cfQwch2VNsJbT3XyDnS0jhSviyF124RYFzJkvFhfuk9c+sfHQnecSds4DZYsFZSCrfOlHUZCWsdsK+hqFtFjkLhuquBQouO1UzglaQljzELkdwRcfV63pQR1W/Smydwe8I1CcTytNzJhqxZuOQBPnqAl2pUxM8RX+tnbQCYHmxaiyCPgB0Plt29bqJgoBBVViSso1A+GO9WTwAPavcZglxIakpRUxl5lpFJhV76Ykf/5+ymm25ivfXW46GHHuJ3v/sdrVaLF198kc0337zjfUII7r//ftZcc82O1w855BCuu+66xTnlt2R33XUXX/va17jwwguZMGHCO07wbv/99+f73/9+/HnUqFH861//inygoZmGT3/60/zHf/zHm25zYUUDUyvLkvXWW29YuRTBdt11V4477jhOPvlkZsyYwaRJkzjyyCNZf/31F2q73//+9znkkEOGaZbLDOCWW27hBz/4AT/4wQ+W9FRe15ZqQGF99L9ykX07FXxVhJLILCPLc0SuMLqGreWIVoZUykd7q2ij3yqxfCF1GtPfdtT/BBPxIUb4naeMkAJjBViDNN4RlMEpMNHvgMphsdgY8XUAwtdf+8dUNTd0jwnV9kEDIojYRfJmhxuUvjIUVFSAIj1uBzCC85q8qIHSIqRBtkG1BCqDTFqyTJB5fQe3aQ8sEkfJRsfL79rXkYtQ5mQswiREbkI5jTvHUhgUkuz/s/flAZtOdf+f77mu+36emcHYjUGR8aZClpJEKLJUyPbaitIrZS95o2hRKW/SokWiRVE/si8JaQjZxWQLMRTGOmOW53nu6zrf3x/f5ZzrfkYx8zwzhvv7zJl7v865zjnXfX8+35Wi5vYXQtHXYbSHxDrR3wHGDQLjKrFO9NXSylqAsoBknTEqBDyaexDVYPNZI/bxKcQfNrec2SfyCRSAnSwVJhFC0EDRp8CtND7f7nTk+8OJcGO/mtZcayCEgMCFkAroOVEKIE/pTg1ZQ4PYs1SoMYtpMDLB5uoUnHTGbIS6EyG2lYiCg6Z/lcxPLZb3y35NhKKFAm0UKI1MUACD3FLj+1NZFFNC12k+9DazWNhcEpCdrVPl7F46Cjfa8P2XiHkikClbGRpHpJDGTsxS3ZwTMRUrplowwagiobYvJnK+kcbVIBWpy0CpFk4ZpPZEUCLfOEhPXpEyMDCABx98EIcddhhCCNhkk02w3Xbb4Xvf+x6++tWvYtq0aVhxxRVx9NFH441vfCPGjBkDQADnkUceicmTJ+PZZ59dyGeR5Nlnn8UhhxyCL37xi/jwhz+M8ePH48QTT0SMEfvssw+WWGIJnHLKKQt8XG9+85txwAEHNB4vtdRSOProo/2555577kULJD7zzDOjmoJ3bvLPf/4Tc+bMwVvf+laccMIJ+NznPjci9R2efPJJnHPOOaiqCscccwwOPPBArLfeelhhhRXwne98B5/73OfmKd5l6aWXxnLLLed70+KGevLy5YUXXsAhhxyCo4466hVteV2kCUVETECJgoK7ZkABQbTnCPqjrlmESOtKEHJ9pomRCkf60oejaIMJGY5raD4TojBIU9hoAhmHSYCdYiISlMAqgORmwwKqE4GAV8AunDw0AzdFE+p68waIGk4q8llozgjPpcF84lk4GdUMqhhhKKIYrFCUjKJglG1Cqy4Qo51XVrtACVTMiZuRu+RcD9Tq+qRRwKZYNkIhmtmIFoK6gBFatWZwGgL6OiSEYogwtpKA7HZNaEVCoVXSU2UyhdJUiJaYgqJ/ghWfszVJ69skbcT5+pMDR/ucxAekvRNYFpKj9B7NvyWKJcHn2txuCGCD454dIN+C6rNPAVIJxawNMd+acrWwETr2uQ92TRmIjkIiQkSyTnBGKmBB6YBbDhpAO6i1TAPkOXrGJ+uPGSg5aP0WKRpJFCQVLgXUZJYf25SJVPhT+eVqO4ryVcrJXw6us9iE/LMNepG92yww5uKmJIIpuR+xf4d4FxnqF/JaBLjSIJK4RVrxzVaUlLrZVlJ7ZheLyPahOdsZmUiEQt02e3xikZBOp4Mf/OAHAIDHHnsMq6++Og4++GBcd911eOSRR7D66qvjoIMO8vfPmDEDd9xxB374wx9icHBwYQ17rjJjxgx8//vfx+abb453vvOd+NjHPobrrrsOt99+O972trdh8cUXx+23346bb755VOM9xo0bh7XXXtsfv/Od78SBBx7Y6Peaa655xScCuO+++/CWt7wFBx54IC688ELccccdIxKHctttt2HatGnYaqutsOeee+Jf//oXnn76aRx88MG4+OKLcdttt70sorrBBhtg+eWXByDZsX784x9jzpw58z3O16rMmTMHJ598Mvbff3+stNJKWHfddXHHHXcs7GENk0U6huJbr9sMY4NwIqIg7kwhAGUJGtMPWmJxQF2e0C4RB+cAL8wEZs0GvTALYdYAQhVd+y84N4EEstK4hgTYLAcyDlLNJyuYgPm7U3LNEKzMMJcZye5Si2XFYgO4hgcfs5AiSSNZZ3ETNUKMXvxKtL6sWYQYLdX6ltD0qNAaCJwHA+f2CCMVTULBGWjLN4aOSqtHEyoNPh4IAbOLgNklYU5BmNFmPD+GMHNsgVljC8xarIWZ4/sxOK6NTl8LnXaBTlmIqw2QtLJGHkwpq1YJ1JoBqY7pdU6ZrFJF8oB21EJhShjGDAH9Q1IosL9DGNch9NfyvpIJRTS/fyhwlrWRputUdyT+xeJeMi21MT81Lsm4WbX5ILcgtRnoi1LDoc1S0LBgn3FEsMctVAHohIDBMqAqNJ4iFIhFiRgKreFgFarV2gOL3DDCZSlpJZahRkSFCh1U6FCFqmBUgVGXhKoVwGVINSJsTaCVytksFIQQA9qxQH8s0Y4FWlygxQGtKC52KYC+1hihVFJOCkxKkclOYE2NoHUqWOB3wVIErkSBvlCiDCUKLypZpCxgGUEzC55dZ/n+1S8G38lGnMgPovtaLTUSFh+98KDFT1hgttewiZYxTUlbKMCF1BHhQFIkTy+pREAlrXOI6q6ofoOyxySeYrAewiB3MMgdzEaFOaGWauIktUBq22+qJJA00SSEmgitokC7LNFul2i3WxjT34/+/j4URYkQCENVjZ9eO7kXQ7GIyYorroipU6dqOuDQINZW/fh973vfQhzhS5MTTjgBn/70pz0l6ne/+13svvvuGBgYwHLLLYfZs2ePeJ+Wani99dbDzTffjLqu/bXZs2djueWWe8WRsP8kO+64I8455xwURYF3vetduP7660f0+I888ghOOukk3HzzzZg8eTKKosDuu++Os88++yVZRIgITzzxhBOKoaEhLLnkkj1CMQJy++23461vfSvuv/9+vOUtb2ns55GUef2NeOWVTn0Z4i4xrECAa3RQo4oVqs4Q6tmzEGfMAJ5/Dnj2WYTnZ6CYNRvFwBCKKmoWmdzXPYPYjRQrQLJ4iBXBK+5mAK8mjQ8IJAXGAjnJCaFMrWghFCXIWwsUSlAoUYQSBZUoEDQmIGSg2Rqkyi4IbaQCbXnla09fiaZe1gLYTXct2v10WyKB9ALN8OIGeGULfgZKZrTqiFZVoz1Uo2+gg77ZQ+ifpW3OEPoHK/QNVWhXEW3mVCkcErDc8mrhjL5ORH8nYsxQjTFDNcYO1l6ZezFrA4zFBxhLzJE2fpa0JWcCS80iLDWTsNSsgKVmF1hqToElBwosMVRgXCXBxO2aFOCJxSivdxAQPFNOUE05BSGsXBCitSDVoutAWSyC7hLOyEWtAbUx3RZsLVVRL1hfixGFBt9LQL5qsa0qtwc916j1ueQClQUiZ5mfgu2t0ILYAQodMIO1Ojk0cDhoAHZZA2UlcSatitCqCWUMknnJc6KR1nxJblTR7wcwSV0PIqN9JQouUHKBNhdoc4k+LtHHLa8gXer7jZBHQipQCQ2UJquFkW67q11Hyy6GdClTfkVkJDA3IBBMsaAGTaBxzQSzblLhigxkBA9mtcj2lP9RyJIIiDWmFbSCNpXog8xLHwvxbUdCK0qV+oLNEta0piQ3Qqs/UaAMUqVYUhgz6hhRVRV6sujJE088gWWXXRbLLLPMMN/pQw45xIsCvtLl2GOPxXvf+16EEPDggw/i97//PXbffXeMHTsWjz/+ODbZZJMR7/PWW2/FM888g6uvvhoxRkyaNMmrk6+88sqLHJkAgIsvvhivf/3rR/V6Pv7443Hcccdh+eWXx4wZM3D66afjV7/61aj115OXJptuuim+9rWvYY011sAzzzyDFVdccWEPqSGLNqHItHVg1YXGiDrWqKsO6oFBxNmzEV+YBZ7xAjBzNnj2IDDYAaqY1IjI3JS4GaAs4iYJJRPINMVzATEGLM3vO7OeUCi8IZRAUQJBSYW24KSiQDBCwTQM+Av4N5enZH9IWWus8Fgzg33u4R/+Q2sCLf2fxX2lYEaJiFaU1o4RfbWQgf6hGv2DFfoHOugfqNA30EF7qEK7kmrfrRhRxogyChlp14y+KgqZGIoYM1hj7ECNcQM1xg1ELDYQsbiSiMUHgCUGgPEDhCUGCEvMkTZ+Trq/xEDAEoMBiw8FjOsUGGtEIgaUMaUl9YB+u/UzVR00Bc0AlsiFW6VCnq0q1Y1wkBqzWJeY79eu+9qbrLFZX8QSZWmHJdYmZQrLfe6B5HvPnEiFVV/2Um8K1AOEFATWAOuatUmRxKIGippR1kDLWhQXsXzuzLZlgN0qafietxgIslS2ulu5gP2Vecv2vJFi83yL2Tmlpn3T3Fu6erusFix72Aaep2JteiaRr30BQqFEwm5DILmmjXnkMR7du4kzIs5ByUnwVlJ2H0FS7UZCqZatUl3OPG6q+7sQcA12CAFFIeMDCBwZdR1RjZI2qyejK8yM6dOnY/r06fj5z3/uxQIB0bLPmjVrIY7upcvAwAD++te/YrfddkMIAVVV4dprr8Wee+6JsWPH4mtf+xo++clPzlcfxx9/PM455xxvq6++Oi688ELsu+++2GWXXfCvf/3L53LGjBkjdGYLVqqq8rF/7Wtfw8c//vERPf4BBxyAP/7xj3jrW9+KU045BZ/4xCfw17/+FZtvvjnOOOOMf1tgcpVVVsHZZ5/t1sEpU6Zg9913x9DQ0IiO8bUqM2fOxK9//WscfvjhGD9+PEJ4ZUH4RTqGwuIJGID7lwPiblHXYAyB6xqsgYkhMlDXQiYq0fwyowGMgObj3AHIMQglEJXcnCgBTSRs4e5E+qQ4YJD6P7McjILUnHAAScmdg1h05hS9yJfFSyTg75DRz8IAHtl4OT+/uTd16EKznFa3t3mzCakQa0OMjD4w+kgK2sXAqEpCZ6BCbBdAGYBS0voSxINFvMEYVGnF75pRVpLutaiipNusWLT8DBAn8C1afdXwR0I7BrSiuOC0Y0BfTR4rIbUQlEHrCcUMTHqxM9Uus1uuAoLWBZDKzgocGT5LjXlVsCdrxQ0A6Hspn9Bsk8nnNUMXp5gD1tgL2VO5dpqRxsyNMbnbkmYLMsAbENK4okB2yg5FVnzNNlBNoEhp3mFWq3Su0B2TPDG64W7wDlJ0ReaipaQn1+DntgT2c/arx8mwhTXRsH6pcf2yzm1z0jlbD/Y5TBnajFRTRsyS1SFldaLsoshdCNk+rWQijdtc3pI1UdMeZwqEUldHloJtOTwbV+PadQtFQBGUWKjrJXNEjDxq5vGeLDi5++67MXPmTLz73e/Gtttui/XXXx/3338/rrvuuoU9tJckzz//PH73u9/hlFNOwdve9jb84x//wLnnnouddtoJm2++OXbaaSc8/PDDLzm96EYbbYQJEyb445133hkhBK8PceWVV+Lcc8/F+eefPxqns9CkqipccMEF2GKLLTBnzhw8+uijL6lo5EuRyy67DBMnTsRiiy2GnXbaCeeeey5uuukmhBCw4447IoTwot8l48ePx8477+yPp02b9qLF/3oyb3Lvvfd63M8222yDq666Cg8//PDCHZTKIk0oDPhYTTRA88dHiB93rRl6TEvP8LSrpEHCmsHVNZL66yzHR2atMBJBFvadyAOSojvhHhV5X9LmIn+dGZ7uiZAqOyOkwF/OAmqRfLctg1Oz8nUCuEYiYlefQefBIJXqMBsgyGBQgnl+Mg3wG1hTtILR1uy9FRj9NaPuiD97XdSoBiqgXSAUAaStEwt1SWGgZoRORFGxaMY7jFYnoqxYNeZGKIKTqkK1uAVLDYQWE1qxUHIhr7XrgJa5Eqn2384l2nnn4JzzwmlC9AJ5RQEH7DksRXYcA6ykGvDAFkfBSSMO9qxIptjOyVtaYzipkKKL0ddCCKfvLgesUJKaa/FZ95atKRmhAKSeiaU11WCbENiPT+quJefjNhsFvmoV83HorsiV9FkqsIyOw2G0F6XMdppeKx5w7nNt9go7Tzt79jl0cJ0Tti5Jveuc5SFklsVLjxlYyWV2hfi1TOkxZwTIhPyLAZ5EgWxNOSkCbPbsOjZSUSKgxfoOllTTtmdrZGRpmLtTQFEUnt0JrLEwdY26nv+MMD1Z+GKpPR944AEccMABWGeddfD+97//FVskbm4yc+ZMHHLIIVhrrbWw8847Y9ddd8Ull1yC9773vVhnnXUwadIkzJo1a5jPfl9fn1cDB8SNaquttmpkIfrBD36Az33ucwvsXBaGzJkzB7vssguuuOIKvOc978Haa6+NVVZZZcSOf9ppp+Guu+7CVVddhTPPPBO77rorrr76avzqV7/CYosthhkzZgwjFe12G+PGjfPHg4ODoxIX05Mk3/nOd3DUUUfhtNNOe0XEqLyy7CUvUwT4KNiJ5IG8HKMU96orVFUHVSdrVYWqrlHHiJpZgi4hrho1pbz61lKKTfWZt1YgxUuYlQJmIQHYM+DISC1Ym0MAcnenogSKFlBKc7enoo0QWuLzHkoE89f2bDfdtoVmM22mnV9qWewHeNifpW5ifzUvDZZpmZlRQArrtVgL60UhE2MqxtiKMXaIxV1pdoVxMztYLG+zOlhsdgeLz6qwxKwaS86sseTMiKVeiFhqJmPpF4ClZwJLzyQsPZOwzKwCy8wusMycEsvOKbHsQIllBlpYerDE0oMllhxsYfxQgcU7BRarAsZVBfqjuDi1OKDkoM40WrowA8iucU4bC1Ywz7KB5bEswQiD7jePwbCA22hkgrxoovFUW5eKIIHttu+yQOsEPHlYKxip1gasYF5yj4KSCNZiipE5uUbZtcIBBQeUXAj5qgllJfESRSUWolbFaFUS3N5XEfpqKWDXVgtQaUXWGhYYtR6Y+4/GEHHm+mQxFVIPpgBRmbkA2vu63J00aD9mrl5p73aT46bVzoPozcjByUaSrlWWWBJNAkBqKSsiSz0TJawlAlowl6dkTWkQPb81+pa5TnEiYrm1LY2dlFQElJo+t58D+rnAmBjQb8QZ4vLoxyJNFRsCyiLL7gSSuilVjbqqEaueheLVIsyMN77xjfjVr36FTTfdFI8//rinkH2lS4wRb3jDG/C73/0OW221FR577DG0221sv/32OPTQQ7H88svjmWeewZprrjnss9/+9rfx7LPPettmm21w/vnnY+mll/aWp359tcs222yDI488clSOffPNN2O55ZZruIYttthimDZtGjbaaKNh7z/66KMbhRgPPvjg/1j8ryfzJ2uttRbe9KY34dJLL13YQwGwiFsoTKsLr8Ggt6o11RJkqJF0ucRWrSJZGCx5bCA7pv7IU3J3EIUppyJXDVVsGo9rt2UIcJiT+dcLaMzCptU6Icgoc8dQ7Skxi6oY7PXVWN1wQJrVFOb3QV5ETKcG0TWi5nwiWnCTFH+hGlOGz43l6vHRMlKWEda0rSwzbXEdLRa/+z4C6g6jHoygokaJygOQq5amZAWBKqibE1BUhJYGAhc1e/0DAeZKCqjwoPUGUGNZS+L8uaT9NfsLqeY8rwVhiup8bY1UQGsoEIu9wAq4xZxBWtpZA+4Y7urE0MJqzIiUgCSy7WIuLq4pZwZpRjCHqSx71WJZBETn4NrQsx6Hm+cUEHR7yU4ILIXtwJD0sFCwy0AR1eefCGS32aHzPWxdsl03jb1EGQWApIT1c89tPdnDfG103uzaCZSO74Cc0y1ni5q7+yWxHc+JVHCyTtgl61eJWSrI6neQWysb9gkda7J8UeaSmIhDt+Um2SpkD5duhwOC2hktbWzFLIUBqYtMZK3QeYoxItYRsUcoXnVSVRW+9rWv4Y477sBJJ52EK6+8Ep/+9Kdx4403Luyh/Uepqgpf/OIXceutt+Ib3/gGrrrqKhx88ME4//zz8fjjj+OCCy4AEWHffffFfvvt55+bNGkS7r777kba3KeffhqdTmdhnMZCl7quUdc1ll9+eY9HebHaGS9XmBmdTgfMjOOOOw7XXHMNtt56a1x66aX44Q9/iF/+8pc48cQT/f1FUaAsE6SsqqrnZjnK8v/+3//DKqusgnHjxuHqq6/Gdtttt1AtFYs4oQDsp9w1pOZaAHY/cgAenOzkAYksRKjrUwb6zf3JvC4sNWyq8Cy9NlwbYF4eiUDkZEI+Qn4TQO7GILUDkNAPF5LyBwzmAoiFu2RE8uz/EqCLXDvKDmhcc2vnyMnFqzDglJGNBHMS2HL3Lj8aMn9+JStKaohMY00oWYrLtWugGmKgiAhUa+aqGlXLmFBAqKVadVkTippEY16nrEjkmn5NIapBrMEIhZ2/A0rK9oHTON8n6UzgwD8vj5itrs8qQSxW1p+76Ph6ydp5rRKGH81Ig/k91mTrwml0ur+MtDo497+oVq/g62vHkHMUn7OcWDCszgR8xHbWQs7k+RoSt2EpkQPMZUsJhb6foFWhmTyew8mSEs28b7brBqTkxa4BnRsPwtD9lXiFX3iZw5kTe7ucknlV1sHW0vZoVLKQi82CH7NrwKRPEhGsBAlpogb7rgCTEsNEru1zch2nTinv37dLVl8is7borEiMhRI4230MoILU3sljuAIRSm2tENAKiWhbxUSulVT0ftxfdfLAAw/gsssuw5ve9Cbst99++MhHPoLFF18cV1555cIe2n+U++67D5deeinWWGMN7Lfffth3331x/vnnOyHafffdse6662KttdbCmWeeCQC488478cADDzQ04a91mTJlCn7zm9/gIx/5CPbbbz9ceOGFuO2220bk2MyM0047DTvssAM22mgj3HXXXTjllFPwoQ99CDvssAOefvpp/OIXv8Aee+yBDTbYwD/385//HPfcc8+IjKEnTdlggw2w/fbbAwA23HBDXHPNNXj22Wex/fbb44ADDsB555230GIqFuk6FN9bcQuMCSWgwLeiZi555pj0f1lQKlHyww+U3F4CmZsCuXXCEKH/iFMGjNjAa1P/CHNNMuBmbhGUgUegAQwAOKEIMYLqGlRX2oaAziCo7sjjWKOIFYpYi/aTIwIn6G+DS/Uy5H+3UrBkh/JaFUja9KQ17iYX9kKC2Tb+CpIrvwNggIBZBAwEYCgQBgrCQDug01ek1t9GbLXE9YsKiYOoCUUdxBoRU0rX3DVECAUhUJERikQCKJ16RjAIKVA2nYm5d1mcgUB2zZyEVG+CotQBYa1FUXOFKlaotZaI1Kiw98qY25HQNvcUBlrMyQUng4651cpCNywlcRW0LgURqoJQFQWqUKA21zmkeAbSfcwkBLWG1Heo9HyibwRStzlbW0m1HLnpQORkLMLzjAVL/epB07lwcvnLNPiWhSk5zWWpbfVcAbMKWS0JNG91n0WtXI5AoCDXaqnE1dPtajC7sYioZLuZOjZ3b2OpPZLVhDEbkVcaL8xFMbj7owVGW0a32q6FjAjmYntRXOGsDoXsK8QaMdao6g6quiMWBa4llS9HrSESMUQRc6jGIEV0SOqWMDGCWiTaZYGxfW2M7etHq1WiKAowgMGhDjqdDjqdCnOGhnDBQ/f26lC8CqXdbuPuu+/GyiuvjEsvvRQHH3wwAAmKfaVr78eMGYO7774bEydOxBlnnIHPfe5zuP322/31Bx98EJtvvvnCG+AiICuuuCJuuukmTJgwAd/61rdw0kknYdq0aSN2/FNOOQW77LIL2u021lprLZx88snYZJNNMDg4iA022ACTJ0/G8ssvjzlz5mC55ZbDhAkTRrT/niT5whe+gOOOO84ff+pTn8Ktt96K8847DyuuuCL+53/+B+edd97LKkTYLfP6G7FoWygcJYjKNrmwkILF7jgBSu4YpJlnKAU4smk99T1WARddQCEF3yqhUMaRgjMVKFJwQAsjJwbvyQB8BthJ9aeaikj8zbUjVhsBEag2nSXAHGE5dLIQ7OQmkokH+pIsfARQm4WChr3dR5b09Enrb9JtHbECgQULKWgRECuBlyGaj34AtwJI024GkuBqT2VqMTHIrQ3BrROBJX9/7n9uWm7jx8yZLjrhaT2jLKdTQ5usGn5nejyMLLpvPFkmKAXDbPPBGpOTgGwOZw1Me8ZiXdNEXK2ug8ZZBCHKHUTUMotI9pSg6xrVhS00RgoQKt0+0awCDUBNaiWL2dxxyjDGGgtipNuIsQdb2xnpOVKz9kkC2JRtSAXrdj3CAs/TUtm12DhOIESp4AZoET5ikviVKKsf6rS28HGwr8+wone2KTjNHXT/CvmWvQZOiQxsfL7fs9lEV9/5KKDfPdHiXLw8e0SEEAfWLBPEAAUCYtrhTISKhMQQMQJFd3lqhYB2kGKA7UKrjDNQxwhWVyeuanDPQvGqlaGhIUyaNAmXXnopPvShD3ltig022GDEtNWjJXPmzMFqq62Gq6++GoC4MI1kgPFrQR5//HGsssoquO+++/C5z30O2267LdZdd90RO/4nPvEJXHrppTj//PPx8MMPY9NNN8Ull1yCH/3oR3jssccASID8eeedhzvvvHPE+u3JS5ObbroJq666Kp599ln89Kc/xbbbbotddtllgY9jkQ7KTpJSXRr+FvBMbkFgNrAXtdWoSbR/NUVEi48ImpoxWKGsFMQJqB+5uuBYS1lbkAXzKiEJGpAdkhYzEYvuzDnBA4FFK1oARQEuS3DZArfaiGUbsWyhLlqoixK1VlKuQ0BF0jpE6BBhiJAatBHQyZ4fDMAgiWVhgOS+vadDWbE2RUrd401hzskKY3ELkkkIkg62ighDEcVgRDmnRntOjfZgRN8Qo68DtKuAVm1pX7X0GgdNU5osSVYXgLK5I2V8DvqYGw1dTYBjrrPmbM/MJdg431tOFPP0pka9WF2WGDUxou6rTC/vADcGeU8VpHK0VMiWVgVCpyAMFcCQWnqGCuj7pEXLmYx0SxwRwFqbBFLPgPICiSHNof4VWv+hhUKKynGBwltaWz3BZD7wOTTJ3Z1SfFLO8X3+1HLUyHiUX0PZLdmDQJJyuE2JGmkAAO2JSURBVBUQ2wViO6BuB9StgKqUAoOxsOuWfM8my2JGLrSWjF+FZo0IAUUQa0ygUq0xIZEo2wcxu41Z0LxXwo5a1T4VJhSSFpVQsn8HVWolqp3W6UlnQe2kYypICuC1qEAbJdpUoI+ESPQVJdplkcVPQKq71xmZ6BGKV73sv//+WHPNNbHRRhuBmXHuuefis5/97MIe1kuWXXbZBddee+3CHsYiK1tvvTV+8pOfzMWKPP9y1VVXYYMNNkBVVfj1r3+NNddcE5tuuqm/fsghh+Ciiy4a8X57kuSCCy7AoYce6o8322wznHXWWQCATqeD9dZbD1dddRW23npr3Hzzzf+2ZshoyKJNKLIMLimAuVuXnEBfZEhmJ46otOKw/EX9Y4+tde0yAalgGQ0jE3lhOQe4RiaSIliG6yCHMrQE1/w2NMEk2nsuCmllgViWiGUpZKIsEYtyGKmoyZpkD0qZhETj7c9p64AwlJGPDqRVsKxQKVOVg3gnE7krV6YXp9x6A69pQDUDlZALqhihYoQKEkPh5KyZESd3RWv+2cQ2vzgbIQ3OMnQ1DQDbXun+tAHGnFDkiBgC9CyLUWOdMwArJEwIQ60AslHLWklGzMhHRezVn3NiURWETiGWCrk1sgLEkI6VQXlopIUH7DaKsRlANlepYQTDSFyaZe7+YyVtGVhPhRxz4kzZJFNGKky73yRzzh3sPChha6mNR+CSgJIQWwGxFVC3CLEk1KVmX6PhxSa7r7vmklLK1kSp6CRpJWz4jNoUsxOERtMK40Is8lsjpplFRzNv1ZDvohpZql8lO2aV4ZCIhayjFAFsUYE2FWiHEu1QoFVIxe0imKWFJdtdLa5cHK2QZ09ezfLYY4/hvvvuw1//+ld8/vOfR6vVwk477YTDDz98YQ/tP8ppp52Gq6++Guuuuy6+9rWvYfnll1/YQ1rk5OGHH8YzzzyDCRMm4LjjjmukcZ1fmTlzJqZMmYJjjjkGzIy+vj489NBDACR96ZQpUzBmzBh8/vOfX6RSGC9Kstpqq2HKlCn4zne+A0DcAZ9//nl//YEHHsCPf/xjXHTRRVh77bVx3HHHLVBr36JNKFwyoJhrlQ0UUQIFYqXQH3Jt0X7UyQCaaTQtH74dM2UTKrJm2YWGV5ZGA2gm2Jc5R3hQZxOck6Ios1bEogQXJWLZQmyJhaIyK4WRCjJSQWqxICUWyFKTwv2+KwjJEGsEeTOyIS42cOjn+e5zCEqZncA19nZGSDjebiMDXp0ZnmqVGBm4pYZFwohM8/i5JO142g0pNkI6jzk09LHJWzN6kgV0C7ngtL3Su3x9LFbGkK/sHSUTBL3NSAUlLXkiFObixEoYkCwWBZRUEKoC0gJQhyz9LyUgmmYEvkpGJvJUuDkFpGyOG/Od7VcBvOmvmQUsy35EhFToMdvfXeS6+zoxMpHbA0NOKrzwNonbUylEwshELCSVcyyA2qyMOTB3skPpmtSBeXrgEDxWROJ7rMq3LX5m6fK4mYxAqJVCYjpYg9qNdNheMkuVpvVVi2nkRAuFLDZTUoPMUqGkggq0yMhEKWSiSKmlmSXDUyITrDEiPXktyMDAAI4//nhce+21WHXVVfHpT38aa621VqOGwytNfvWrX+GXv/wlHn30URx99NF417vehRVWWGFhD2uRkyeeeALTp0/H5z//ebztbW/DkksuOWLHHhoawje+8Q08+uijWGaZZTBp0iTcdddd+O53v4s///nPeOqpp3D88cf36k+MsJRlibXWWgv9/f24//773T1wbnLOOefg9NNPx4MPPoijjjoKm222GSZOnLhAxrloE4ouC4WlscyDcXPAFyEpZCtmdDiiw7VaKoxYcJbjPmEIAZ+UtNfoslRAXEzyWIQuvXmyfFAzSDSDtw7w8hz3CFK7gssCdavlrWr3oWq10Sn70CnbqIq2WC5CKY0CIoVUI4OoCQJNGz4XQtGhrD6Cw/AEOQWkqlsItK4ASbk0J2GZ9loiKAiRrUGLDybjQQLyXe5TmrEmES2nKg2teT7jySqVAcBsryQrVhL3HrJ18HW3rZbZAUhjcEyLHRJYRyBxmwtQd6YURGsWC87IhRCOiIqixEoQ0CF2MtEpCJ0S6LTsMVCVGlsRGLUSEIsXirajdB+KlULqEhRGUH3+bI8n1mfWjbQjIYTbrHqIqMDSiAW8O4AXEMzi+6fa9fyi6L44utOpZo9Ji8vZeAhqtSOxVgRAkp8JoahKIV4yL8jGlWrINMlO7poYkmXCa2IUct35NZAR4siAButTjAhRalZI3QqWAHFr3CQYQYmFWCmaCo1GjRiC1rsh1EVALIK7PxWhRBlKtIoS7aIlrSxRlgUoqOKEWTM7SZYnIRZum+nJa0R23313nHjiiVhppZVw1113YaWVVlrYQ/q3ct5552GLLbYAAJx77rn41Kc+tZBHtOjJ9773Pfef/9Of/oQddthhxPtgZuy6664466yz8Na3vrWRVWg03K1e67L00kvjzjvvxBprrIH9998fF1xwQXLpnotceeWV2HjjjVFVFc444wwcddRRC2RdFmlCkfvHk2kI3WKQUoa6ZptSwawmsYiJWIBRc14MjIcDzexxcnXS/ty9gf3W/s8DxC2lZYMTZdDKfPUFVWVuT60SVbuNqt1Gp68PVV8fqnY/qlYf6lYbddlGLFrgogSrlhVegCtkmnRyl6YaErzbXWRNNM+mpRXaFKhEoJbeliBqgVEgUoHY5W5Vq5VDjhkQQwCHAqzvjZDA5th1/gb0kntOI1oizSJzg5w1LDy6LpQdGUjrpupppHfrbUZuoOMyklmrm0qulTdSIUA0NAhFJzCGAjAYGIPEGAqMjvrPR0pOdlGzklUkmZk6QYlFICcVVUGoWgKc5TmJvegEblg2UtHCHDBTNo+J7EnhOM1UxTUQY0bMnZJ5xqgOagxxjQ7V6Hi2oQR8Y0GZm45aJWy/hSyOyOOJPLWAX9PussWaEUmvKwHmag3Q2AUychYYtVpvzD1MCgfCrT+RsrH5dRV0zfJmBfZSNi0nks67dI66LRMxucqJwgEpa5mRCm1gzRyWFeqL2XjrQD63lRbTjNk4Q1GgLEqUrRZaLbkNReFWshgZdYySNcqK9vX4xGtSfvjDH2LDDTcEANxyyy3Yf//9F/KIejLacvfdd2PFFVfEM888MyrH32GHHXDkkUdiwoQJeOKJJzBp0iQAwJve9CY8/vjjWHbZZUel39e6bLHFFvjmN7+JBx54wOf+xWTGjBlYaaWVcOutt2K//fbDrbfeOurjW6QJRU4mHOg3fJsTqTA//FwXasSiNo0rpGiU+zNnlgoP8kWyXMxNctJhbzbXG87uy78uv3Q/bE4sQnKvMWJRCLGImcWi1oBtVjKBUIJCKWCXtMazkQpoxpmGv7kW8LO+cz8TFAk4m0sISoBKRBJXKwsIF3cpvQ3ielWHQsgECZkwUsFmQVFiwcNmEki+MtmSI7MkOUsXFGxnaC47iYrAs3Ol80vq8jwqo9mfrI+QiYiKlXBCaYppt0nAKYUADuRa+06wwGq49aEiZHssNm4ToIRXYxctdd6S61PKBGWV0SmlMW3MZtc8AkjVtI1URFDMGC7S/o3MqNhIRUQHUYmMjDWPVciDH3yKteXJCRqxDflYuwi8xyNoBWvSatbwseoaUeY6ZvErTgA9IaxbKHyPh5Ddz6wYgJNGJ7uZiYVAybKWzVd3kxiL9N0kLlPRx91d9buRghfJsulzZcHahaS1DUWBUEjWNABaVVwsEhztGsGLarN68uqW2bNn47777sPHPvYxAMDHPvYxfOELX1jIo5q7bLLJJjjppJMApKxBPXn5UlUVpk2bhhgj9ttvP3zmM58Z0eM/99xzuOiii3DEEUdg+eWXxze+8Q1UVYUvf/nLWGGFFfC9730Pm2yyyYj22RPg0EMPxVZbbYW6rn19X0yYGdOmTcOXvvQlnHfeeVhjjTVw2mmnjWps0qKdNjYTS51KDPclz6vY5tpr8ZeIrqUVMcccKX0nxa26SEQmuQ1CpBuyybucIHD6HMF+3FXjTl3uNdR9NLVWQEvwFea+JM9bxWmQuLhQbWDZQI+6Z/gE2diTs5C/m5CCqUkRoPmYoACh9MfiOsWuXe9AATOiEgupoxBDSISiCOBQCjnKSIWtVbI26PkBci6cZhO6xsSqaLbzNIsEJQLRwLNkZBJuu8jXquEqlY0lmnuKuvv4eukxCUHU0s40g9CDIJ8lBhAYHDXrKdvxWVzAKCIiuPXDNNTmthMDgQtyoGnrWNkZZDlozfUOAAIx0kjZz9lImfSv9RCMlDn98q2SxR0BkcmxuLjmMULQQnCU76W0dw1t+3WUL7S9YG/zaczS/kY9dmSEOirRjYkg6DWaCuU1x+Gr3iAuXUxHu2LffEqwfU2p8ckkaRfleL2RWdfmnyUTl1gnWGmkxr90H5vSibiVJB9yAKggJRSkZIKc/OVkIlv0nrxG5YUXXsDPfvYzbLnllth0002x995744YbbgAA3HXXXQu1ZkAIAZttthlCCNhuu+2w884746qrrsIvf/lLPPLIIwttXK8Gueaaa7Dxxhtjzz33xG233YbJkyf/WxD6cuTee+/FU089hfe///3Ydtttcccdd+BXv/oVNttsM+yyyy644ooregUIR0AmTpyIjTfeGESEHXfcEQ8//DD+9Kc/veTPX3zxxSjLEq973evwsY99DJMnT8bkyZNH5dpatC0UKtlvrGs1G1pOb83UrOLOk8VWQMGwpZZVrXRETD/UnGsT8/w6qrHOxS0U+RPIQEruupO0qQZ681G7y4pqwi2dbCzVUtFuIbbaiK02uNUGF21Q0QZCSywVaq0AJSCfXDqS9tVTtFLQ9JlmlZDP5y5LdQjoUMBgCBikgMFAcj8UGAoFOqFAVRSoQwkOZjlpgUILCK1EKkDqfmPgHdkM59PGKc6FbV082Sa8IBkssDurXZFyUjWDuxva6kTE0oqJRUKsV3ncjVkpUixF8r83K4X49Ev6V8JgYAxZnASSVcwz/mTZntzNpQiI6k6UByFXJXlMhVg/2IPsPRgceR2WfE65uZ/N/SbzHyND/qZQdwtNjQ5Sqyh60Dn7hafB1L67soNSnoGJEUNSADSuZwXBbnVUCwVVDOrE1KooxVSUVMg8yvlXRoSQucYNW+/0BZGyQFE2JvI1dvfB3O5FFkqekTRwituGuhtlsRdWTC+/5huWwmzP55PjZEzjUihvJAwmRvbK2Jx8CXvSEwDAXnvthd/+9rdYddVVcckll+DKK6/EVltttdCCtUMIWHLJJfH73/8el112GQ488EA88cQT2HLLLfH444+jr6/PW09enjAzdtllF1xyySVYe+21cdlll2GJJZZACCMH+5555hlsueWWePTRR1GWJf71r39hq622wnPPPYd2u/2KTgKwqMjWW2+Ns88+2x//6le/wkc/+tGXdYzzzz8fe+21FwB4ZfPRkFcBoejWieYIoak1TL75BUKQRurmIJmPEqHoIKLyPPExSy3bBQSQEYr8h9t//TPrQ+YekbtoJefs/Pc/gXwH+qy1BDj4OVBRAmUpNSrabcR2H2K7D9zuA7f6gFYfUPaBCyEZMZTgIPEVUbPZGFEptJWaRaakFABaKClhKlBRgaEQMECE2QGYHYBZBWFWUWB2UWBOWWKgLDFUtlCV6opVtoGyD2StaAGFkAqzUNTM6lIUNY4l06ZnZC5yTBls8lgX5ESySSpShefhuutmAyzGxC0USio6GnMjLj8C4JkIRAVCKL2R1Q8pAuoioCqUVBRaOTyw1ACBEIEhsAdue1BxgczFSYJyYxlQlwFVi9BpEYZKwmABDBaMwQCP0eiQEYssdW3Wmn9GhPP8TgH5NZUIiFwTHdTplqSeC5MnXXZNPPn9jFjoe2NgrfNi6W/z6zfZiFi1+YgRVEeEOkra4QapYKBWEE8Sw1IFzW6G7iKDTXztqX4BzbyFlOkNmVUATSKSZ/kyy1GzSrlZddRFLkbUsUYd0/eJBbanQPKUKUv2Mg2LCfNhqIWCAul+1SDsqkas6wahyK+HnvTk6KOPxlJLLYVll10W06dPx+mnn44zzzxzoYxlq622wmOPPYZ2u43tt98eSy21FN74xjcCAK6//no899xzeO655/Dss89iwoQJC2WMi7oceOCB2GmnndDX14d//etfeO973zsq/Xz+85/Hdddd54+///3v44ILLhiVvnryypRF2+WJkmNQ01KQBc6iC1Bkrhni3OTqWFeNijOFgBFzpzFwn7tRGRjLCYC9L7kwUPNWi75Rjmr0JJhZFeRNgmQa29BwoyB3l3BQoxrORvwDVQLGqAJiBcTgGmlw7UA8QIu6gVAgoAShREALBQoUnh42IkhsAKQQ3mxtc4gwSITBIHUt6mDB3RKILTEdEgdCjcBXOZuaRcPNnOYQiAge3WukzcwVDRuGaMXz9K++al3TORchKIhjdYvRqucS19G8H7O1tbrUEuysLkUkLk3mNsdMWstDwGqIEucQ1AXFeGcjuw9lgcQ6RxwsU5GBX7Ma6OMsliC3nOUag0aAse8tGz90no1M2JUj5+jz4Br4qPvY5ib11qg/gqS5p2ytonE3G5sDaZ0XysZpa21DMpDM0AxSrLEPRgBI9lK3J5oeKzdC2XZqXFqYy5PaTb4X5X+bkzRjkTk7MbVf6DVnZCKRPVlrBrmLmU5R42sp6Bw5YSZTkGg3Eagjo64j6losFZHT4JNlrievdel0Ouh0OgCkkNyxxx6Ld7/73Tj33HOx2267oaqqUe2fiPDb3/4Wiy22GJZffnmEELD99tvjpptuwrvf/W4v3PXGN74R5513HiZPnoxTTjmlt3/nUYaGhnDDDTdghx12wNlnnz2iFgqTj3/84/jUpz6FD37wg7jkkktwwAEH4IADDsA73vEOXHDBBdh1110xNDQ04v2+2uXrX/86PvCBD/jjT33qU7jiiivm65gf//jH/23a2fmRRdpCQUoGmq5HeRBmMzAzB1Giuc6KtBFlk8H+qaZrQtLw5pYJ16pSPrZh+YNScHDjtcxKkfSyzRNVEGHZY/LCb8Ed2jW9bCEF8GorgtdqoS5biKWklY1FS60U4m4EkuxEpPntJcd9l5VC3Yag8Q4dSpmLBgJjIBCGioChIqBTlKiK0vtibSjEwhHy1JxKeiz41F2ZrDl45eac5NaIZjQ7KJsvZOD/P+6lJgbUWwvOTdmxDFw7gVTrh7mHhWw+Lcg3aqaeKpBkbgopXa/EmWQabdeSowGQ7eSYJKaitsxPBTBUaAYpt1BkrlPI3X5SooEGmcgC7j0FcOYS6FmRMpcwhlkPanCs3ZVHYnWyW23B64CkK8dIls93ds7Nay1zfbPg5sheqVpum2uIkFkTdAqbLpHdKogsuD+/8NJmympZoEHincxnR8y/cyI3g/ClSnYzTWwzQ1fTouLpqjkrWminqMNkt4JYdicNxG7YJ3qArCdNufLKK3H22WfjnnvuwXbbbYc999xzVIM2l156aey1117Ydtttsfjii+O+++7DmWeeicsuuwzrrbcedtllF2yxxRZ47rnncOGFF+Lcc8/FNddcAwDYaaedPJtQT16ePPPMM/jDH/6Auq7xnve8BxtttNGIHv/Pf/4zzj33XPzpT3/CtttuiwkTJuD222/H7bffju222w577bXXAquF8GqSDTfcEOPGjcO5554LALj22mvxwAMPzNcxJ0+e7AUJR1oWaQuF/ZgCcNDh/shI2r8apD7elHCgB2g3aYG4ZxiGiJmOlhARFCCQ6iXnBlhNa50ed1sp5sbi2Pvkxg+/69y1o2BaUUqfEc141IBnQSWk2WpCKBBDRBEqIR91JSA4KqDkmKXnVOsEE0oQWggoxcnKwbQVwhskYA4BcwIkdoIELFdBYiskh7/FFwQH2aRZdVJmHyODCh/ZzktnnhL8zeeYhvmXNfXu3XOb/k9zScPe03U0kv9SVWnWQGc04zMo6JrKawVq1AggigCrZQGSHhfIiGXDH08sNBEGb7vPIGX+MdecWACIYuyJhVRC5gD1oAtgMKwUhOHiRpyPxhKlrFgCwH2+GEI4kfaZaAkl0oeZtVharWSatYfgezxdYakydv5OQK7LSNleBqslqGkHgGUCY+j+RcMMY8TBiD0FUvJBno3JIh7MjjgMYndzCnuYs021pLjFh+0+d308nYERozpvlKxRTGJlsBouZNYIPWEnQjAyYS5MOhaGWieUVLDFY+ngafh10ZOeAOKacv/99+PMM8/EL37xC3zwgx/E1VdfjVmzZo1YH0suuSSKosA666yDM844A8899xy+/e1v4+KLL8YSSyyB8ePH40tf+hLe/va34x//+If7ewPApEmT8Oyzz+L73/8+PvOZz+C0007DjBkzRmxsrxVhZjzzzDM4/PDDseqqq+KAAw7Ac889N2LHP+ecczBlyhRsvPHG+MEPfoD99tsPF198MS644AKcfvrp2G677fCvf/1rxPp7rcj111+Pr371q/jQhz40z8fo7+8f0QKHLyaLtoWCM01n48c6eupI8VOOrqmNijrkhzkB5zYH9DGhra3FLHnvVcMK7o6faFo+ckuFxz0QqQuRuBIFEApKrzVtGHZOGAZo7Miua2RkRbIMPUk2pbog9bMv0OlrZa0PnXYf6nZb6lW02uBS4hgotFCEFsrQQotKlNRCi+x+5u5EAR11axqwVgQMFQWqshRLSKstcRvaqGyDyhaoKL1WA+WF4NwHXSiEBT/nBQelGFz3PFjLrTs5WE1rZBrh6M92k8guWwalV836UAapRtwOLfSFFtqhRCsUaIXCLTsFpUrGFo9i5yiWHSFdg4EwWBCGCpKAakv7mo8vK5yWp3I1rX5FmpK2YAwWZimKGCBpQxSlVgQk9qPSObCMSIBZ5jTgXou5SUE3bUUhlqWiRChaCEULRSFWpgAB6IgRXFdCVOsKFCtQrLXgm4w9T+XsjEBXKikBZI4aGa70sQUrmzWDlU1LjAEhRHi1aiENWbV1tUQWZJVU7LqWVLRi4Ujz7PEe+p5u0tGwSsAIAPleITSrx4MAK2TotUYyC5I32G3mCoXcOpPV54BkCytIrBQSYiKWiSpGjdNgtYyQft/1XJ568uJy+eWXY9VVV0Wn08GFF16Ib33rWyN6/FtuuQXTpk3DVVddhRgj1lhjDZx33nnYcsstMW3aNEybNg2bbLIJfvWrX+HNb35z47MPPPAAlltuOTz55JM48cQTceGFF47o2F4rMjg4iNe//vX44x//iN122w333XffiH8n3HvvvVh++eXx1FNPARDLxcorr4w5c+aMaD+vJdl7771xzz33zNdaffzjH8cdd9wxcoN6EVmkLRSKLvQuu9uBB0dmP9YW7GhJQwVQASXEn92qXpMfWO9RApsStWAuDeo3r9piItMsqnXCQQaQqEDXhjD1rffY1NrPffvkOs903kmrnqWUDYxIhBACOIjPewgEChVCbcG3tQIo8e8XK4UANbOnmEuSgFjCkILZTpCaCFxIVWEUQTNKFbDA1WQJQrogHIylU5IYBkmNa/VBcsuDuXqA5j6b6Z1NW0NyZTENdm4vyjXg+eym9xHEapMIYvTXA4K7hBHSmgSuPYg+cABxzGoKiEZewKuRQknxKhYjVjAeEGMU7bpmCGKOiNFqhwgojQQgSOpWNiuHxVIwUGYuckCU8fheo8Z8QMcIMpeb4BNDCCgQ5TkmRNQA13JuRlLMmmRk0RYrm9+cPruFj7L0zQqQJW5FV4Zz60gionb5mKXC0gin05FrwObY9jlxsk6kPUTI7Tc2J3KtJwtRLmRxNyCPb0qWikRbLdtWTZIdzMiEZ3Uztqx8y1ykmuNT6wQZmVB3RyVoMZp1QiwUMcpxjHjJ8vQIRU9eXGbNmoUNN9wQp59+OnbZZRe84Q1vwNZbbz1fx5w4cSIuuugirLLKKvje976HM844AyEEnHfeeRg3bhzGjx+PoaEhbL755uh0Onj66afnWi8lxoitttoKX/7yl3tF0+ZDYow46KCDsMcee3isymj0AQBf/OIX8Y53vAOHHHIIAKng/Zvf/AbHHHPMqPT7apK+vj786U9/wlve8hYAUvfjfe973zy7OxERnnzySbz//e/Ho48+OpJDbcgiTiiS1jaBav0hd1DUbPpBz2UjFXgJJbOALwMxfpx0bPus/UUHugnNUIYCEvDNoQE5aCLAXUVyeJxG0DhZP7c4bGyp0q4Vp7MAZ+uDEcBcZOCZNGBV3otoFZLzcZC7kNWQ2IkGmQgQF6tC4yKKgGBa7qw2hgNWO26Ga9I5ZnU2OIGxfI6ZKAWz+wRRA3V1z12aNf1Y9vm5Ebx8DgTABe/fLFpsViYkDThs9JzS1AYEJSNa24TY51TccWSgwXyhdD9TNAsFgeqYpiYGd42JgR14+l4k9kw+RlbAAQVkYySKGKRf36iJPNst+y0BFnROQkzyAPCUoUytH5RWLNeoeEpWSsuWaLrT99Q/67gSp0jXUlc8h6845+sri0lpUfVtGbnkrqvOSGS+x7rGNlxyNYD0ZYYYiwsinSuxkLIHZEf/XHZVZgqG/DuLKOXiMsunjUviJyz7WUqtbG5mafg9QtGTF5cYI+644w6ceuqp+NCHPoR3vvOd+OxnPwtAfLf/8pe/vORj7b333lhxxRWx9NJLY/3118epp56K8847D//85z+xzz774G1vexuuuuoqXHXVVeh0OrjllltQ1/W/PeaUKVPw1FNPYb311sPhhx+Ok08+2YPLe/LS5YEHHsDDDz+MMWPG4LOf/Sx+/vOfj2gdEmbGD37wA+y6667Ycsstceihh+Lkk0/GLrvsgve///148skncfLJJ49Yf69GCSFgvfXW83TJVVXhtttum6fipHvttRfe+973YmhoCLfddttID7UhizSh6P7RdSJB2WsOsu2Z9KNqmY1aDLSi3BYeH6HaRdUGG7C2IPCoaDBXxAYfi2ZyooRjoM/7rZOKpP3sJhDpMwkSRyVPkfLUtclaATvnfFBEHtwcodmiNAhd4kKy+IWY3FBsFJEkdmKIpJ7CUEGe5pKLoIRCyUShdRgM+CXk6OQnJ35qApJsQZCCZd6vn71prXUFiTwhUz6vDCveNpxO5Hm3gG5ikQO3ZMXyfEeUr0OKDkjWlwQpJctTgcLc4ziigGR6MhcYWDarmMivEUyKqrevo9YXAKjWRQuJlMicWC0J6VtcYgTgi9VNz9MzZ1leszRPDkvtGsmuH3cP1DkJen7MARQLB63gGk5w7TlKRE6CuxOpMGJh6+x7N/GCdAUYqM993mzdqOuJbtDvgQhpN6TNmL0tvSEdjfLX00cakNzf3wTq6ZtG7uUB8ak+SLafdSwh4z122HzvEiULhcSck9cIEQuFVsi2FMu6/nnSqZ705D/Jj370Izz33HN4wxvegE984hN43etehx/+8If45z//+W+1m4stthhWWGEFAMCRRx6J173udXj66afx4IMP4he/+AWeeOIJbLTRRvjmN7+Jhx9+GD/5yU9w0UUXvayxPfXUU+jr68MJJ5yAK664Ag899BBmz549X+f7WpQXXngB06ZNwze/+U3cc889uO666/Dss8+O2PG/8pWvYMyYMfjIRz6Cr371q1h//fWxyiqr4D3veQ+++tWv4ve//z2mTp3ay/w0Fxk7dixWW201V8i98MILePjhh+f5eAcddBDe9KY34c477xyhEb64EM8L5VnIMmPGDIwfPx7fXepd6A+lu4CYv3VtGW5CloJTg5TJfKohsRL9EWhHoI8ZfTWjZHfEUACQFwuDBBxnRa4KKhGoTEG6VIj2kLwcXdKsahtGgrjptgQFC8je40QG5kOfMgKl2BDHjplGVg8SFaTWEaFmFHVEq6rRV0X01RF9NaO/juivGS33H4f761dEGAqEOer/37GMRUVAXRReDTtmAdlGrlIippwAJd9wa55lx7PZiCtJAUJJpNmmkguP8yWkINXcoceL3rlfvMWuhGxNXC8Oc49ycsVplYYDMke0SLmLpIZGxRWqWKHiCp3YwQCGMIQKHYpaRVyyh5H68YfIKGslAKqB5pIQy0JiYloFOq2AoVaBTqnF8gIwhJTRB5XUZ2jVQFkT2pHQFyU2qOSAEtZS1i6xvmS+9bp/crAb9doxd60ajBgrxFhrhqcKiDUKZkk1TIQWFQiW6SoQOASNi5CYCMtwZRmNjBDByVFaFbtJDmgpHqD7GomaKpazYnlBC+IVUfd81PTI6gpGlHKvpX6aJCInwE7B8nEZoeNEWqLFAKHGIHcwhzsYJNkDQ5qJy1LFijWJPCaqmdVJEjEUAMoCaLUCirJA2SoQSqmuXtURg1WFgU4HQ50aVYzgmsHR4kTkWFVd49xn/o7p06djiSWWGLajX01ivxE9mX/529/+hje/+c2YMmUK1l577Rd93x577NGoZ3HSSSfh05/+NADgoYcewmqrrQZALCHLLrvsPAcEv/vd78bkyZMBANtvv/3LJiU9EVlmmWXw1FNPgYhwwgkn4H//939HvI8tttgCf/zjHwEA2223HZZccknfIxtssMGoa8wXRdl2221x6aWX+uPTTz8d++233zwf74YbbsDNN9/srmcvReb1N2KRDsquDOxDMznB3JxSfQPAtM4GRxLW9toLzCgj0GagL6bW7/cZ7cgoowRpm/dzBKeq2l2ayAwnNwB108dfpBkD0VUgS4lDBUsHilQEzdKNZkGfppn0g1kfAYgWsF0GdFoBnVaJTqvEUFlisCwwUBaYUwbMLgJmlwGzioCZRcDMsvA2p1Vo0TpJDyvVr1OwdQhZOl4NSpb6EwIsOZA0D24FPL2nNwtm1rF3gX1ZVLgvvcerzEVf7ArqJoNDM5A7W5XMT58CIQRCoedVhIAyFChDgSIoMKdCMyUJUQkUUCCl3G1RiTZKtKiQrFkkblNFRjiDBhd7IbPICBUjdIQkhE6N0IkoOhHlUEQ5xCiHGK1BRmsIKDuMohbgGKOSmpiaFQps7kezJOh9Sns3Iibrg10rBE8qUJDOARUoqHRSTVTA8pCxXyV5ULVmvAqkdSOsxkZeh6OraKSSA3PnE4KTMrk1U6xqvQzPP5vONQ/QN0tBVPIRA6Vq5IUUxrMm+5MzKyRrvRZNtOD3U/G5ZDNhr/liCR0s6Don/gRCwUCLSaylepsSOqhlItj8W+YuKWZXayE7KWanwRN5EHy29j3pycuVLbfcEt/97nfxxje+EQ8//DCWW265Ye85/fTT8b3vfQ/Tp0/HaquthlVXXRWPP/44Hn74YTz88MNYZZVV8NWvfhWrrroqVlttNUyfPn2ex3PjjTdi0qRJPcvEfMpzzz2HVVddFVOmTMEBBxyAP/3pTyPexw033IA11lgDAwMD+PnPf473vve9WHfddefJdee1JAMDA1hjjTXw5z//eWEP5WXJIu3yZITCgXgGOkynnLwsyEGBN86JBaemrzVcp6BAP/NPFn9xcRzy/lgAsUEcd5sxYJuh3WGWCpr7LSiBJgNclYM1du0x9DxJ40CG9WdWjEJGVhcRFVvOTXINdeHZbqCWHkJFUkdhSNPC1kSp2JoSBScBGRkwkJePQdyXOJ1kThKYYL7vqVZA8zPuHuNn3HR86Tptl6ZvvGnDjXxmbmOusE9HSXsm9TYsBSsYxAGBxDWq4AJMLARDAaX9kWUqQmZl4abbizlYMRiBxHVKquOR91ezZgRiKQVhcRlODjjtsblNipwvpbXJdiRz0sAToLEjQuQigqZopezck3XPQ5GMYFvaZp2r5P6mTlgvMk6GDw92SAbrFmsSyO6fqPzaMve5aMdTHsqUju9HtNgKNnuibFr3oMq3rN636xRmbcnW2q1e1EVc2SxSaoVzKwXUBZD9rXlWJ6k/IYHXHGNGJsQqAW/Z2JAFvvekJy9DHn/8cfzmN7/BwMAA/vd//xdf+9rXcPrpp+Ppp5/GgQceCADYfPPNMXXqVJx66ql45JFHcNhhh+EDH/gAFl98cRx33HEAgGuuuQaPPPLIfI9ncHAQU6dORYwRH//4x7H00kvjF7/4xXwf97UmMUZMnToVX//617HHHnvgTW9604j3MTAwgH/84x/47Gc/i0996lMYM2YMHn30UTAzPvOZz+C3v/1tL2tXJnvvvTd23nlnlGWJQw45BK9//etx//33z9Ox+vv78bWvfQ2rrroqbr755hEe6dxlEScUoqV38J0Ukw2wDjSB5twAKGBuBpmWUbWPOaEIUUFGiPJjTVpXmxPYCkxIIdtdhdBUUh0GZOAqWVhifi6UXvMgaWqSiW6/+OBgSE/EyISW3BVtaUAHUV24LDaDEGKUgF6Yq5e4qwipCEnTrGCycQsDmIbU0kwbePWK2AyQEyEZlz/OF49zSCRjdXTZWOMEMC24mnNEZXcc/enccZrn5vHyZutrlUAoP2KaZgW6gXVOUaDUyhSlRCFAdoxCVc6IBNtSMTgmKkaIKcNUDKnOHIRMVDIrqFULbS4zw5VA3Ta6bOgZaG/wLiQzZnpNrDHJwmRjzZ2/4LecP+4OTujmlRlYN8mrajf3uT2Xkg/YQBvbx/Y+idWB7GAkWc8aFq5s/oxMEHPWk81L+p/9PNizbDl5dEsPN/YHALecBiaUAEpWV6xop8EWYqSpYgmp/gTE8qFWCWuZOVTfI+diAfw96cm8yF/+8hdMmzYNW2yxBfbdd188/fTTePTRR3HooYfitttuw1NPPYVbb70Vt912G97+9rfjf/7nf7DUUkvhmmuuwXe+850RHw8z49Zbb8W73/1uDAwM9AjFfMhZZ52FVVZZBeuttx423HBD3HHHHSMa21DXNU4++WRst912WGaZZbDOOuvg5ptvxo477ogYIx555BH89a9/HbH+FmXZdtttscUWW+COO+7AQQcdhPvvvx//+Mc/5ulYfX19OPTQQ3HfffeNCJF/KbJIE4oOMQrT+lHm5kQJpMzN+93EksjYhwyWeyYYBQr2gx4gfu6RIZl2FJZDwT1QgNhSngYFPiTwkVI5LVDwIGMgIyyUbt2/3G+7618kC0UO4MihKpTk5KQixWogGMAPEn8SGJXWRJBUp6xWGspqBKT7AtAU7eSuR9QF7gD1dTc0lZ24ZS9ymGpAzuF+ql8g7E3Bm4w7B8h23g2P+AxUs6fOtNmQjkyDnzILKYj08VOGGlPrJqyGhgUgpnSr4rJSokTMVObigmQHMVJh589ABgzNj14K14Ug816EgBJCqksCKpCkkbXzRMoIJFYTdcvKXMvs3PLsTvlJ+XpkDIN1bmToWkgRtl+ixgBYlXlkgeNGAbJj2x3O+28OopkRLCOf+WrYuIatiX1ezjMGIftWm4HV1cmWWNaCUtXt2OXGlM9N/rXCRiTyOjXiamaE1r9DOMVwGJkoWNL7tplQRHkMlpTPtjclGNvq2GifmXXCLBQelMIAItwFUh/2pCfzLA899BDe8Y534NFHH8WRRx4JQDTQ73nPezBr1izsvvvuuPHGGz1b03e+8x0cccQRozKWqqqw+eab48ILLwQRoSiK/5glqicvLjFGTJw4ETfeeCNWW201PPLIIyPullTXNbbeemtsuOGGWGGFFXD99ddjr732wrve9S6sscYavfVTueGGG7DbbrvhqaeewoEHHoirrrpqvo633377vawMbfMjizShGKKIgqyisj2rUFRBRoLTCQFw3ggKllkLaSloaVxLgjYDCFqQ2JFfxVE1tQIqajJNrTuyiEbRtPhILkbM5ACfkcbb8D1H5lduFgl7LXOhMBzW5WCUJbnJLDlB+wuEGFlqUzBQxICiDk2NuYFnBTcGcoy0Jfembr1tk8gJiGVYnQ4ydKMa28Dw1JheJ8AAtZOKREzYfU80yJrgAbah0buBf07acJ21yNl8IuHF4DzJjkXeV3elAjse29gYMAuNVYwuEFGizAiTxTTEFMqB9HG7jWCtnixgPaiBBupHHwkog+zZiiDWIyRqU1JACwEtkoBsKbxXaGC6Eb1cZLPY3rczDvbIxmfXFqmlIOgamSkBBmI1nWkeM4DMwpKRx0THdH01UYHPMblTYTZh6fV89yUOmJ1fAECFZEXS18hSJmWfDjV8foIBenflkn3npE8lksSt1EYq1EpRU1IKBJZ6JmAppldrj04morQyCtkAS3IJqXwu4ymMCCoRjjEi1rXEUER1efIThMdNmM2oGll80JPXqLzlLW/x7452u417770XY8eORavVwvPPP4/VV18ddV1jcHBwgYxnxx13xEMPPYQ3vOENPVA6j/L9738ff/zjH3HrrbfizjvvxGc/+1mccsopI9rH7rvvjj333BOnnHIKnnrqKXzgAx/AFltsgS996Ut45plnsPbaa49qjYRFRbbccks8+uijnjJ2UZJFOig7ejB0FhidpWVMRe5In6O5atzrvOn7Bcwnq4eBwYKBMuaNxUUo1kCswbFGtMYRke3WAqazlhCuSKYRSCRDQK8X6IMFfzdJkYEu1sxPc7VmwENxxW0qAHVB6JTShsqAwZa2MmCoLFBpFqc6BEQtYOdZnEJoWFIadYU5tx9kGlqkINPgt8mVI68P4reWdcqqlscIxBoYVokZjfse9KwtVytbjQCvrs5pXr06MeBE0NZkbuvD+ky3y5191gK1Cyo0nqJAyQUKDinbEBt8l3mMoBRArb7xpFm6JFNXRKHZoVo1NKsToZ8J/RzQj4A+ClLRuyhRliWKskQoS4SiABVFInd2Rl3WCTuFLgruVoHU1BKi5+ruYLbPNUiYY9Q1NKKbOQRSY6rdHSgfjM8z5ibOgIcLESwrm+1bJnHdswrVto/z+5EscDwLIAca7pXRMq1Rll0OKeNcJAI045XFSbTYsnDJurVryTRnAdkli/tTCclGlwrZWW0PympPcIqd6MoEwb6fhYD0oFZPRkJmzJiB6dOnexs/fjx+/OMf46Mf/Sg++tGP4tlnn8X06dMxMDAw6mM54YQT8IMf/AArrrgizjrrLKy++uqj3uerUQYHB3H//ffjv//7vzE0NDQqYHbWrFm4/PLLsd9++2GJJZbAsccei3a7jcMOOwzjx49HCIs0HJ0vISKcdtpp2GSTTVCWJcaMGYO9994bd9111zwd7x3veAd+9rOfLfA5XaRXMM/aIoHSBvDy7DKpGXiwNLJRU1k230cJJCPHWJRlhQIKJRRFlJSUVozMSQXbreWF7yYV8B/9piuHZWcxUKDnlAGEBmh1Yf+fYdaMrNmxFARZ8LqQCqByYhHQKQI6ZUBVBCUUAVykDE3IMjUlywu6gJ/NWhM4hq5m5KJBOnIyAWSBqsjUrjrnDTKRAeHGbdJCmzXC/Nwjd2XnMmIAg84NGN2Y4+Qdz67Jdn/5fAYspbCSihKFWAy8/F06diIV8GPKoNnU0kKitIUobnitCE8Va4Sin0olFC2UZQuh1UZolSAnFcERvBM/lgJ5IL1FRMZs0n1bzwaZ6KaQtiH02tB1a6yZ749kFWq6m2VWBnTv+XzXv4hkcT2JsQS1rlgzxUNSQhiBSPdT67Zq5ckRLJVz1KxqrNHUVKR01a3MItHWdSuZUKq7U77vCyiZCOR1SXwPGploEIn8dThBrpUA9aQnoyFDQ0N44IEHcP755y/Qfv/85z/jhhtuQKvVwq677opllllmgfb/apKZM2fi//2//4dZs2ZhrbXWwiabbDLifUydOhVnn302LrzwQmy44Ybo6+vDJZdcAkA08294wxtGvM9FQYgIO+ywA55++ml3GzznnHPmueDgyiuvjA9+8IO45JJL5jk987zIIu3yZBVhCSzBsmxBu0hgAJaeVIAwZUC4YNFQVqoRrCJQuGuFJcAUMdhVQOsZQNlYFIxidTAk8xPcUiAfE+cXq5hLFn2bu2/oQ/HkSX7S8lJOEIaDKDdwZICB80xPWU/WPCUndG4M3EVLXUqIEc3MM6557u7fAmWtr8xKQYm1EsPzYZkxZm4EICcR0H5ZO27aCpJTm4BR1ixbzTXLJ8AJJzEqzZCUkwdxl7EAczubNLF5zGsKpk9WCiOBPkqCZ/4KYEiKrRJpd0rmMNJAdQvAb/ST+7JGABQlhCQGAZlZ6iIK4qQVKCCEEkXZAhUthLIFKltyJpHFwlPVvie713Su9z0CmyzUpDFDlsbXC/6pGp8tQjxG+Xg04iDXEVNWFJLtXHJbRHadZGshj7jrua7Hw1A0Nd6ZYXDdnxltVHITs9fzAHV4soTMEgDSa9UsGhIvRZFR1FClg8bDcIqnaEdJFWv7ngFA0+Pad5fEPWUKhhfL6mTTreOyPd6LoejJaMjMmTNx9NFHY80118S+++67QNO59vf3o7+/38fRc3maf5k9ezb23XdfvPWtb/X4mJGUmTNnYscdd8Stt96KdruN/v5+zJw5E6eeeio+97nP4fvf/z7mzJkzon2+kiWEgHHjxoGIcPLJJ+P555/Hr3/96/k+7qxZs7Djjjsu0GtikSYUNUdEjgJCGfKjC/0Rh7osBMksEwNEWxgEhJUhiF9zzShIMuXUkVGzZXKCg2wggzRKJhjUyD1fMxBIa0Eo7oqKjk0TSmQA2LLhmKsLGqkoc924A4iMTHD+fkulSoloJIKRa4ETGRCQIqDHc+1rrxSahALq0y1WA0oZhCDZb8S/PCcu5Kk1KQ1P509y+DsE71Is25w7oYBFRHRr/oXC5GDQFyi/RQritvSkkQg1MypocUCf/ASIGxp2Hz95vIOTCbcapfPJi+GlsWlgNExJLvCOANSoPDMQdfnnN/dgNpEEMLSSdpS4lBCAggMCJ2tICC1Quw/U7gP6+oC+toyvqoBOBxgYBEcC11nqVgX/sicizIqWAumDxEp4UHxIlgXItSaxLIXH3JPlF1K3JyYAUeNMguwrC/RPV4ARySaRSG+xWTFyk9FZzt+Z20y6Osge+HWl128gQmAGB0Kh7kWSDjimDFA6LYlMWDVs4Y15zRWqAerUoIoQOlL7Jui1VURxdSosgxzEikrEGuch885GKHQ8XOdkwjYmZ5YJSatt3xv1Im2P7skrUYaGhrDyyivj/PPPxy677ILNNtsMK664ImJcMPT1zDPPxPbbb4/p06djwoQJCyxu49Usa6+9Nk466SQceOCBeOqppzBhwgTMmDFjVPo6+OCDse2222LppZfGAw88gK9//evYYYcd8K53vWtU+nslyjrrrIObbroJrVYLp556KgAsshXEF+mfGHMlGnarblCebpXg7k11Ka0qCFUhMQR1SMA6h61ApjFHcsXJHxes7goMb4X6+0MJT+SYxXnEZkyF/XEO3tL5QAtj2etAHjOQB13DtePDm2n49Zz8JBNhcZcvjauoS6Augaok1AUQC2ghMLX0kIHj7kSkeaJcuS0gc1JwfgsUYI2REGuQzXUKCrZOrOqy+sBTSOsKdLm8NRuQESZK7i2anyu5upC9HmDpbxsuMRlIM1DnVgRdS8/yw3nNCdtIll0puT4FbQWsMB58XgNl8wE4iHWHKO3T6LMVRmszoY2ANgW0igKtskTZ10I5po1ibBvF2BKhPyC0CVQAIQhQzve1BMTXANdArLR1pNUdINYgrhE4IiAigD143QoCksUOhODkw+cq6p7WImz5Xs6my/dAc381d5qtr+24nDRY9elUOHD4MeSyydbZrgFi1AGoglQ2r63pt4vtuZhd457diSKqwKhaQN0mxL4A7gtAOyCUUiCxgFYw1+8Pc3PyOCAIK5fQD5Lgceq2TkQtQGLXdLYnYTEdlsGNe4SiJ6MinU4HRx55JI477jgsvfTS+NOf/oQ111xz1Pp761vfismTJ2Py5MnYbLPNcM0112C77bbDwMDAiGcmei1KVVX4zne+gwMPPBBjxozBZZddhs0333zE+9lvv/1wyimn4HWvex2uvPJKHHzwwTj33HOx9tpr4+qrr8Ziiy024n2+EiWEgLIs8cEPfhBXX301brnlFmy11VbzTCqOO+44r/2yoGWRtlBYhkSoVpHY/N9NV49Gtk/WyrgU5Ida4nuVeFD2XhUBcpw9Tm49QHLTKBjwXJqqYo46gshRNJQ6TkIKSJZBJRDk+exN+0056bAzUjCvCeobrioNK0fXfTsHPb6TCs7mSq0pBmYg3AE1wZE0ZemQuqYrPUcGfkndfHRoRtjyPmG2AxmLGhZSqllLxE8SiCrnHF2Drf8c7BNzQqNd+8DBFiWFbqQ06LyexjALyFymdfi55HaJ7k8KPSBdhEAFmMRFj0nSgVrKYu76WEolm86I1SKgE5FiUvLgdttsBcAlEFuqyXYzXLJ5WdLkaJRLCTFzLfdNgqaIjYVma7L9mJZKBhQSgKfkZpZIhW4uNeORp+YysoBsc5mtIiMBSGliE6FO7wYbEckoRFc8htsDKK1hZtiAVbyHjTldNFqnxQB8qsJdIUrRSSVUEj8hRDLNPel3AKe6N5yItCeCMJJrAeF6DbgywuJRdDP752FxHfCAcQZQz3U396Qn8y9/+9vfcNFFF+F1r3sd9tlnH3zkIx/BhRdeOOLpKjfZZBPsuOOO2GSTTfDzn/8c99xzD2699VZcf/31I9rPa10efPBBXH755Tj11FOxzz77YNlllx3xPu644w6cd955WHLJJbHHHnvg97//Pe677z6UZYntt98eZblIw9OXLWussQaWWGIJPPPMM7juuuvm+ThrrbUW+vv78bOf/WyBE+xFesXMRYMABVuuMkaCeAZIAaswbGpfIxDN1K0iSSvc6LEBagyuBORkQvtjcVECRyEuIdN3s5TLI0igJjg4mYiUzotZQRincxmmh9XPNbiEI1Dy1xz8k1gEok9gBrs5gCV/q76eMsMQwfPzh3SKSWNufRgYUhCYg7puIpE0/PngdaadWfgDJQUKwjOP8FrnNbC6/zRWsbmuAsqUOMDc05Sc5WRC3xszoNYYn52Dnwv7bbektdLdQgyiAoHEkb7giEi1B2czpMJ191GaTyXiYnE3RiTyQPfkSV8pAasAdMDcAXEFcJ0IHdSyBrGQkVkockJhVDhAa04oWCY0VlxZIYxIJbc9ToQCKVaFkHLJ5uleEzVMBCJf126KkH8ut24g/zwphdIvjnQ/gXn2Y8gGkPStyJg4YBZFyRJWC6GgiIoZMZunUIi7m6U1SxXlkV243OjbM0npZywYXJQoXbETGuzuZJmQMsNRRix6QRQ9GUW55ZZbcNhhh2HLLbfEEUccgWWWWQYPPvggnnrqqRE5/vLLL49PfOIT2G233fDYY4/h4IMPXqDxGq81eeihh/DJT34Su+22G5ZaaikstdRSIx7ge8UVV+C+++7D5ptvjuOOOw5HHHEEvvGNb2CHHXbAhAkTMDAwsECyhS0sWXzxxbHsssuCiPDtb38bzz//PC6++OJ5Pt4KK6yA/v5+3HbbbTj88MNHcKQvTRZpI7hr4vQ3NdcPowltEACUzCjB6nYTEfKsNeZuZEfOHOYNQ8wtcNWOLccnSfXI6vbMDIoRHGtwrBBjJ2uVtpRW1tyhakSPD0nuTnnKTXFzSWlSgRyde8ajxn1x/SBVTFuGIEtD6sGiWoyLidX9iSULVLBmqXm7MiNlfzJZaawG0WWe2INRA5q4yoVI0npaitqCEAu7XyAW8lpFhA6ADiRVZwWNhbF90RhfAoteJ0JdqTx2woNgJf7G0w4TNL1snr43IyrZlkhEI6MbSlbgwbUBFAqEUCKEAiEUKELhlZAbCYkcmDcmyPs2zG6H9rgeZoRYg+ohUGcOMDgLmDMDPPsF8MBMYGg2UA2C6g5IXZgIlpa31s9WCHUF0gZNjUxc6yxnM025pY9S/ICtX0hpmStm1FHqJ3AdwXWEV4v0PYNh129OTpvznc+MkhxYVraUiliWXkmjuTh6koakYEgtWS4jMWJIroGNdMNco8M1hrjCYKwwEDsYjB0MxQqdWq5xcfNiJ7GWUa4meEHJDmk9EdIsUTqHnpEOjDpG1JGbFbIzdz9fGU0SkbfYvY160pMRlunTp2OVVVbBX//6V+y///648cYbR+zYd9xxB/bee2/85S9/wetf//oemViA8pOf/AQ/+9nPRuXYU6dOxcSJE/HYY4/5cyEE3HPPPdh+++1Hpc9XihxzzDG4/PLL/fFBBx2ED3/4w/N0rFarhb///e/YZpttRmp4L1sWaUIRXZtsGVWoYWqwrCziX66pNWtGu4poVYyiYoRa0nCaT7wVOzOiYl4KKfASGZg2kpHAjoDmlAVK6icIOEPdAdcdxFpIBTuhsJbIRIq3qJPbicZmNPL45xYIcxnKzn9uxMLdK5RYUGRQbWlIIURDCZWklmUnEwJ4WDSxPlYfbSJBOah2UpFbV/R/U/YCSiQUzIe8ha772khAakVQYsFKLJTwZICQKem2RelrbkHkhIKRaXOz++4+YutOCcB1C+mC5MCxoTkmA9kBKAIQSlBROLEgzURmWmmv70F5k7kyRbek32UlE4wCLPENdQUaGgLmDACzZoFfeEHarFngOXOAoUHAiUJyc6IYhWREuR+8foS+J80EmKJnIDOffavNwPl6EqV6DWBUrHsnSlE2K8yWWxe77B1dFofsulMTo+39xvszUkZKJIw8sKaMhs9nft12k161V2Qafzkf3XMcMcQRQ7HGUF2jU1WoOh3EToU4WIE7NbiK4NqK3jE6gTFUAIMhb4yhgtHRdM4W3xVJv4+UTMicWRxHSn+cWh7vk/QNPenJgpBdd90V3/zmN+f7OJ/85Cdxzz334J577sFyyy2HL33pS/MMuHry8qWua2y44Ya4/PLL8d73vhe33HLLqLoiHXXUUfjCF76AtdZaCy+88AJOPPFE/OAHPxi1/l4Jcvfdd+Mtb3kLpk+fPt/JDIgIBx98MA499NARGt3Lk0Xa5ckK1bnXAOB+0g48WFOJsoBnBrt/fmDR1gtWzwrAmTcBum0eBnOaQl2PGkCIxRUnevYcO6qArhDsxz6oiw2hu4aEudGQjp26+nUtuU6Ej5C79blpolQBC6tgHdxPm+HxIPpGAcTqFy4TqWOR0oJkc6kg3RzB0mx0DYEInnmJ0NCwGrBPqUNt2ORWIkZIQBDJzz2F/qazzh+zT5oCUMo8TpAsGBHq3m9zpW9y33Y9ZCOIOB+nHRyJTFi/3l8wmw1DghwKABHEAYhRteasZ8Cwquq2sZwYQeJ1hSSxBkir1SpGhIoBrsERoI7cp1qDeSsA0dbHcggLmWQjldy8AuSRpmduWGHSGubkO5/bRuAzlOgSQBw9aBocMpJus9W1i81i49dFk0yg+xP6BnOj467Hdm6ytuT7GSCdAyTi7taMNBNey8S+Q9g0EToHEbJ+FSPWMu4Im0JWvqMuezbcAsncRFlAuyUAMDIB+67qKujpBIJ8r87Nda8nPRkNefjhh/Hkk09iqaWWwpe//GWcdNJJeP7551/WMQ488EDsuuuuWHbZZfH9738fAHDxxRdj6tSpozDinryY3H///fjpT3+KZ599Fh/84AfnEos2MnLSSSdh9913xwYbbIDddtsN3/rWt7DrrrtilVVWGZX+FrYcdthh2GSTTbD00ktj9913R7vdHpHjPvbYY/jnP/85Isd6ubJIEwoDKdEAFiXtNyGrn8CmdUcDKFOGflzTpxq+oHEI+bWj0AkGdaR30methgBl4FEhIzOgWWCSCQHiYqPjk9gJSq427B7ncDRLmbafWGMBjBgkoNtw4+ccUHOGoBPxCQr0OKoGNxro1c+wZUeSwTIJmSBEEEWEKMAmaGwCacJQQoCXSMggnoDKFCtg99PyJC18EnJNK9jAqQQIRwk6QWUTkC2yBYjb/5xe8jmxftO79C2UfSbP59oYlfKv7LXubGF5sL9PhbFJMDxbAAIQNaMVRY3naPr4531K0TO9RdPdiSBkOVZS84BrRgzi5sfMZmrTfpODlk2yb1PbU4097kl4bTURbX5h2vTk3pOvKasSQMiaWdgi2OIxOOqYbCmbFq2c7FoCgaaVLttpjT1kRADJygMl0KzfGGrJKzg7FsMtIGlbcbY2yU3OArTT/EbfP8wkZMKStTlRh5MKSZXM5hWHoAHdxvWiEQm1qDYtE00iYTFZBDkuk+yHnvRkQckzzzyDp556Csceeyyuu+463HrrrXjmmWf+4+eKosCaa66Jww8/HEsssQRuuOEGfOUrX1kAI+7Ji8k555yDTqeDHXbYAW9+85vx97//fcRdzr773e+iv78f+++/P77whS/gXe96FzbeeGMsvvjiWHPNNXHfffe9qrJ4HXzwwRg3bhxmzZqFY445Bvfdd988p+cdO3Ys1lhjjYVebXwRJxSS8hVs+lKByMllwawQpkGHguXEFEyZGNl88Nk10pHY46yBpCuVJnCGMi0yYNaFhD0MrhkSjlmAtQNOaEaZEMTqAgOljp4TcQAcM1MGoHMtbZogJTiOwJqaBSJJp+lYiUlIhX+8CZwMMBE8EAOEKJpxNmJiwC+kfkFWIkTnyIJLc/CZQXkPWm2SEFbUJmk+NdCXI4gl+43TJkogz7TKlv0pBbYmGO3zzxowjYxAIbOx6H7ozuiFbB8YC01xG2Zx6VqcYOtBcIcli3pHCjzPQnx8SoQ8AyURWiC0AJSUuz1pogA9HHlkOTfPn0mJAGXA30/V18IJl+PqbFCWHhm2Js34EuZs0NZX0H6jvMstXAwQBwXWQa0F+Q5osipx8SMHzU2XqOwaM8DvRDUD3bp2pJ8PzCisuKMe3y8fO2VkhC+mZSSymA15swB4ScpQM6nigownpesARmrY4rZRFoSiJITCLiX2mAlzETN3TImbkBo6ltSBWK45//6yDnvSkwUkv/zlL3HNNdfgH//4By6//HIcccQROPHEE//j55ZbbjlMmTIFAPCVr3wFX/ziF0d7qD15CcLMGDt2LO644w5suumm+POf/zzifXzzm9/E1VdfjRtvvBE33HCDP3/zzTdjmWWWWWTrM7yYnHjiifjjH/+Im266Ce9617teEuGem6y//vq49tprR3h0L18W8RgKeN74SAksAEgBwZHFBzxq8LG6e7D5ITNroTPR9JkvfoeADhGGAmGIgCGCPgcP/q3svgZTDpF8rjJAC9WiqvbV/LIFi5ufeg3WbDscK78PNqinQAUZuFLtbobym/ERjVnqDpjOFa0WsCp58QMTiigFtkItjWpIfEXN4orDNWrUEkMRNN++xljUQQNBA0vROJ2XmoBKYx0kFoM8EDU9Nj/7vGngqsdPWKAqwAVJy+IrpB9GhxgdsK9HB9nakQZwewxIjZpTHAuzVBmQeJC5z12D6LkkEsSEFPOh+9NrAhBLPYOQBd4WAShKiacIJagogVAARSG3IYCKgFAEFKFAGQq0qdRWoEUFSmhBO9Iq2SAUFFCgQMkFWrFAK5YouUTJLRRogagFhFJiOig0SZ3BcwqpQQkvU9N335vVaTCgnBFMtkB4gqXmjSSBxhUiOrFGFSsP1o6aJMCSB4RoCoKsAVkNjBTvAFMKWDxLHn9iY7JodhsbmxKC9DoAykgoI6EVCWXUuhEIKPQ8vO6GBtMXgYTkEcl79PqsWaqyW4yPfL+wBmHLHh3SeIqhEuiUQKck1BrMbqRerBPyvZV/Z9VIcV7Q8yhYY8YY6IuE/gj09whFTxawPProo5gwYQKmTp2KL33pS40A1G753e9+hyeeeAJ33nknAGCzzTbDCSecsKCG2pP/IJdffjkmTZqEqqpw4YUXjkiMzNzktttuw0orrYTp06dj//33x0c+8hGMGzcOjz76KDbaaKNR6XNBysorr4wnnngCr3/963HsscfiD3/4w4gct6oqTJo0CZdddtmIHG9eZJEmFCngNmvyimtRUxEo0Wb7rT5voIg5BVtbJh/P6kPkgDg9B88AVJFlaclBa8r/7kXNkDLOmBVFSI9k1tHCGEomNAgbySoCJxV6bpmmOC9yN3diobNiJkPX6JprWFb8K5KXKQg1C7HQwG32AHYNxg1ALAixUABUpIwynmHGALURCMtmo0SiVjJR5yCcSGNkzIIDjePgVIQwIMsmRHJ8JwycbikPJmcPpM0D31NGreSnbvPlcQIZkXCrjgkloJoHT7sWmrLx5zRF32uZn6RZ9icpDEdFQAjBs0GV2lpUoKQSBcnzgQqQtZAK5wWSQnoFlSjQQkEtBGohhBIgIS+pYKARCCETKROWqMoplb4DgxqZSz3drgF2a7Zv2XccQMHPXTTtlsGo9qxIGoWsxELIRcoahrk07/3ffEcYQO9aP7VEOLHwa0OvWW62gqlBZLxRyk5txo3I2fcJcsuEBfxb9ij2Ipy+tzO3O47J5cmKZOdxE/n4S9ZCh5HQFwl9TGg3T7gnPRl1qesaTz75JI488khcf/31WH/99fGTn/wEY8eO9fe02238+Mc/xjvf+U78/e9/x1FHHYWPf/zjuPPOOzFr1qyFOPqe5DI4OIipU6di//33x9NPP43tt98e3/rWt0a8n6qq8OSTT4KZsfvuu2OdddbBwQcfjGWWWQaf//znF/mg/KIosMIKK+ALX/gCrrvuOsycORP7778/Zs6cOV/HZWY8+eSTC7Va/CLu8oSmewkb7BN/+7xigfhaqw+43QZyr5X8B54Bj8sAMvcITq4h7tBjoDGzSujTAkzIB6qAzGCXaoOdDESxXASzaARzoMkCzRMZ4GxsiW6YyCfNj1rex34cqPsPfE7IXVzEfUiGHBT4ZA4s3vye+zLJba2gMY1RR5iUwVmF62RkMdciUres/P1+FPN6Uf8fRloIjkk7neB/6EpNqyDfiCO08GDWgbzSdEcbHsyaVrmxDh7Yrsdy4Jr+T1mMkJ2nprANBcxxKHCBGIEQhORIzIRoxwtoemJSK4QRViqEgJDas3RdKfWeKeUt9kjHQ7n7mNaWgJFO1rS0rJ/RXZwh9TxWAv4eI7amzdf7eh1In3JM9yeKZpGLSkysOoetfbbdsngKc1Ok7Bwbt8OUDknS25pJDHzfZFOXLx8rGX+x9Mc2H83rMGlx/PrIN5kdJJBfA1AykeImlEzYdcTwPoKeh5Eir8CuRKgnPVkY8tvf/hZLLbUUlllmGey333646KKL8MILLwAAxowZg/322w9TpkzBBRdcgNNOO20hj7YnLyadTgc/+9nPsO6662KbbbbBHnvsgSOOOGLE+2FmXHvttdhoo40wZswYXHHFFfjTn/6ETTfdFP/85z9xxhlnjHifC1oeeeQRPP/883j66afna8//13/9F9Zff/0RHNm8yyJNKGCaauSkgtT3XcSwswAb+wlXHaekmnECkinvnVwIIDB/eAUDhgEUoJi7jWmiiRPhYLb4gQy0Z+4WgiWU/VAt/Vk0AmVQhQAPVoXhX/bxgdWdhA1ndQc627iVWGTB2kZwAABRXmcjBBqEGyETRCQ1B0jRW0OLColRqBWU2jHEmUYmhkksPlm4ebZGCQB3QzNWANqIftbzlL0g5xRZXGMkOFWzB5G4dYHgGaUsdiNm7CwLK0auhefGiNK4DKTbPmhowe11SvulQcqcREHJhO4tX4aotxYfQigQlEiI601J5LUrApEQErUsNCwD2jdB41x03lLAuqWDJbAWYBSCJoO3cTkx0WOLU16BPFGyjDR4JjVo/IqsgAbv6/4JGuAvlsRKtezREw6wo/mgxwk2bWkLWHxMdq4EzjI6WTD53AnF3DMfpWvT+3PepRmgnIBq8Wv7VEaEjbT5sbLvD7Ins9Mhalo7nOCYNTWyGGyQWzzStWTrGxhCPBm+OgSg6hGKnixE+fGPf4ybbroJN9xwAy688EIA8n3c6XQQY8Rhhx2GyZMnL+RR9uSlyKGHHooDDjgAxx57LNrtNjqdzogGTMcYsf322+PXv/41dtttN/zud7/DiiuuiMsuuwxFUaDVaqHT6YxYfwtKQghotVoAgDPPPBN1XeOWW26Zr2Meeuih+OQnP/mKsOYt2oTCgz1zEmBBu2aZABqFsuyXV1XwZKpLA/z2y5+Ri9gFziNJRilAMH4MmjBHPyaazERCBFeZnjb5fAuuTKBBQLWCZg5AYI0NUTBu6ltNMZs0wjp+10xLf55JB4kcKNxCQklpTkjHKaQjgSnJ4CRzG3QiYxY4TerjYYRCMCJ5cysHkbr95DEmafHyrDpOuWwd1M2qwfycbOmYdR4jNGQ7ar0JlmB516wrn4oU5EswbSPrLIP+duTuN9kAE1htWF26gplzImSE0wEgEYACCIQQxXULrLRSa3oQQ1yXENQqITET5sMPdZtiJRQx229pkm3YlIFXFmsA17IfOWgCKiGEZqfwytu2MKpBjxQQPc5CxxKCTleiqp6ONbsG2DPVamVpVtsREyLVnpiAyUg4QCGzjGR7lNivBjlDZiW+ToOMtaZ1bLj/ZSTAMp0psaaYUUuLy1JTRcFGo5QYkRVApEZyBuHw5Pshz0zlaaGZMxKg31tqguCaEWtOdXEoEXMhYnKmBQMlCCUTWizWLCMUnZH7ve9JT+ZJ7rjjDiy77LKYOnUqllxySfzhD3/ATjvtBACv6orIr1aZMGECnnvuOay33nq4//77R/z4H/3oR3Heeefh7LPPxpNPPon+/n5stNFGeM973oPVV199xPsbbfnkJz+J//u///PHxxxzDE466aT5Pu4NN9yArbbaaqEXe3xZMRTHH3883v72t2PxxRfH8ssvjx133BH33Xdf4z3MjC996UuYOHEixowZg8033xx/+9vfGu8ZHBzEwQcfjGWXXRbjxo3D9ttv36iS+JJFAW2uHU8Fp5qBsBGp6jRnRbzch4EZ+e+tH5OMRKTCXFbh1p+zfmEAlLOMOAaeTeNqYFn/FESHvEX2omKk1Ym51tu8aTXtGFNMCDSWwjP8ZJpVRW/w2BKLhdAMMoKyzQVLYzLy2AykAPP8cYqGl8bqH58Cq21NDGxxs3mAclcj8yvP6nJwqiLuef9ldVNsgr9eSzVytmbvgANviTlQ5xByBxHdA5xIqhPK4X+NgneEbO3nQvqQImmCBVLDCILEOniMhDUqUIZS4iSKEkGDt1FI46IEFy3EokQsWqiLUluBOhSIRYEYCnCwIO8CsPPOGihokHtePLAAk75f+w1B4jYCpUrfgUJqyAoGWmBBETQXqsSFBHXNChT882k/QRIA2L5uFErMrlBOt7Y28iAm8N+IucjIxLDvEf0usf0amt8h0WNtrNBkjVTdG+5i2aimTgBn+yldIfaXyGXBRk5ShjrSGBLWZBLu8gQlE65sEHIVIJYJIxMt6C1LTEU5yoTiFff70JNXnMQY8cILL2C33XbDdttthy984QuYPXs2Zs+ePd9FvXqyYOXSSy/FPvvsg7Fjx+InP/kJdt999xHvY2hoCNdccw122mkntNtthBBQliVWWmklXHLJJYtcjYpWq4UXXngB2223HZ544glUVTVfRPqXv/wlPvCBDyDGuNDJBPAyCcXkyZNx4IEH4i9/+QuuuOIKVFWF973vfQ1TywknnIBvf/vbOPnkk3HzzTdjwoQJ2GqrrdxfEpCCHueddx5+85vf4M9//jNmzpyJD3zgA6jr+uWfgf5Ku3YRGYiFNfZb5iaZYNd4J0gyt3gKIStNkGzBxw4gTWOK7HHe7LWuoFDDOI1MTR6sbYHaRiRSELEQiWYgsYGbNAgAcyUTGSj322w+9P1NUpImPCdDuSUBII+JsDlsrAGltLr53Hi2rgaZSPdNWx3ttqsxuEEyhDimecrJhI3TSYQHM4ek7bd4iHycCbJmZLGLVGTnLN0k1b7HDxA1wbf+FUowChQoqdmMcBApMNcMUGytEOJQFwGxCKiDtQK1kgMPvPZzTK5RlskpkcGAmqQSubi1yWs+XxZA7ueQEg5kp5xZT6wlq0qag0RGPP6G1XLh+7txmTYvNGQvGqHmJjH2FNKcWRsogXwnkbYfg6ytkYlG5fqYKyU4BfBn659f25bGd1hShrm1jFSQV9hkTSzRPP38O8WOXXhDw9pht6Mpr8jfh568IuWKK67AZZddNt/uHj1ZeDJ16lRcfPHFOOuss7D++utj0qRJo9LPtGnTcOmll+Kss87CU089hQcffBCXXXYZtttuO/z3f/831lprrVHpd6Tlfe97H9Zff32EELDkkkuOSM2ILbbYAtOmTcOVV145AiOcfyGeD8e3p556CssvvzwmT56Md7/73WBmTJw4EYcddhj+93//F4Bom1ZYYQV885vfxCc+8QlMnz4dyy23HM444wz893//NwDgX//6F1ZZZRVceuml2Hrrrf9jvzNmzMD48ePxsZXfhr5QOKg13+amvhywatUF59VoBdyEID/1BQLamhVFfogFMBuBSMG2psxUZ4oMeJoEsw4gaRsFJLD6NzcVpQ13GUKmxU9a+hqWOSgBPnZAKCAvUNEArd2adLi1Jd36mGG++AIQG9YfykgBmSaexWWF4GltLDYkGERzAmLnae5BmU+7vcXWzW9zFzR2MgXVWoOTC5McHKBarDqBJUUwcVSAKwHLoZCsRik2Je0P3xPq+5+C1DUqgJrjc2U3wVMWm4XMsnsxpXMnPaaBxTzywMCgpvJR7XwHMapGXIEqK+gnsoxPZlkQtzM24K7nIf0lQG3zaZa0GkAHERULWK5YUrdGVusYswNU2Ve6B0N2zvmaQvcMSSxGnjK30nOQegkRtddTqBHrGnVdSdrkqOvG7O5dgcQKQkWhVg4CZ25Vto6eljkfbwjeas1GZnvakLlb3NhcjZBISWRQXXsLdY2iViIBCewfpBpzqMYARQxSxBBFD14nnb+SKa17lNYgQcRqwCGEQCgLWT+uxd2pqiIGqxpDMaLDEUMst2aVDJHRYsno1Ga4dcL2FwAMcYVTX7gP06dPxxJLLIHRloX1+wCk34ie9KQnoy/33nsvfve73+Gb3/zmPBdneykyefJkPPTQQ/jGN76BG264AePHj8eXv/zlRaLw4Y033oi3vvWtGBgYwPjx4zF9+nQcc8wxXgV+XuTRRx/F17/+dfzoRz8awZFinn8j5osiTZ8+HQCw9NJLAwD+8Y9/4IknnsD73vc+f09fXx8222wzXH/99QCAW2+9FZ1Op/GeiRMnYq211vL3dMvg4CBmzJjRaCJNLpTAanctg2RlsDSLniIWyQ3H078GqTsxFLJaCWQpUCW9qaWLrXONe9eQDLRb+lRJPTv3ZtpgCbI0rCEuD7AaEOrqFE3znmnfvYHnanVg1qBONrehGhVX6HCFDtcY4hoddSeqLaw90wJndgm461NEutWaFaFWEJZNSsNQkrVubTNz86mGdScE0ZQXwZvXpgA3nZ4sBoLzOgmSu9+sCMnlKU/XqlmSQqr/ILfUtH4psUrphXUfEfu+MkuKEabctSh0pXQNVLjbU0EBZQiZy1PpFgrT7LPV3QiEStP1dgq53wmETqH7uMj3XLI45NfGsOvFjhvkWFKDJdVMiBrkrDRWg3+FhJd6W3DStBMbsyaLrc409aSkQVy8Ck2BS1RAIjuscFuqBC3rmlnHDPRbs+c0/iB4Y6mvEnPioXs68WcRghBmAiJF1PkfV1mrhYjp2pviASTnVqq7UTtK64uisGh3uSGVaFY9L6HjtPovtbg9mQtYNPdMvW4so1PBkv2rRNC1kJYIUq7GGH1ZUL8PwL/7jehJT3qyIOSoo45aIMXV9tlnH1x55ZVYbrnlhrlUvtLlxz/+MdZdd10AwNve9jacfPLJC3dAIyzzTCiYGZ/+9KexySabuMnpiSeeAACssMIKjfeusMIK/toTTzyBdruNpZZa6kXf0y3HH388xo8f78385hw8uI8EMrMEpQxEVueA0m2tcRBWL6IiqSFhReyMTFhdiTqYixM33J26yYRpti2soOGPreTE6lV0tB/vT5+rFbx68CnYg7W98JoXY4tZDYWYvc7+fF6EzIhGzRFVjOhwnbWIii0tZdNBKC28nWciFaFOACgYuegmFVlQiQOcmN02YjcylgG4C5L54IvLjxILq0ORgTm33Lirj607GgTTcv27K06gBPxN+x+arkASV5PIRWNPOeFoeuU4dM1jNkjjBrKYAwPYXpROU8JaJifzTkJOaIid8HasyCCl5nVRMmKbN58LJRdmcaiD7leK6CCiA9kjtboL2joFCyTOSEWpjwW8k8cIWQrZRCYoCzIvPB7D5shIhe1Hq3dh+1CLtXe5CmZ7U4lvKliXjUPf0+1mlOVVA+V7UK1HFrFj92pEXwsnE5TiF6SoHKG/Bvoj0FcD7RpOKKyeRUFqyaDkrmQkyepxNBITRJv/nEwgEYnMspTscQtOFuTvA/DivxE96UlPRl923nlnnH766fiv//ov3HzzzcOu35GS/fffH8cffzxWWGEF3HjjjVhttdXwiU98Ar/97W9Hpb+RkMUWWww33ngj1lprLeyxxx6e4cxiX+dFXv/61+OWW24Z9l26sGWeCcVBBx2EO++8E2edddaw17zegYrk0f/3P2n/7j1HHXUUpk+f7u3RRx8FYG4cKeuKBWLKIPS4ZJl9RJtt1oVEMFIQpQGvTqBUpC6kas8pLmO4L/1czwnDrRQ1WXVo7ccayW1uDUmuVORHbAYdC6ThrgrPdp+RWyigj5HIBbTiLkcv9Jb0/F3nleP7DJQZaDRNMBk5yItMZESLuicuJxfanGg0BkAeOExGKpxomKY9JLefEDQIWWIKrGCegfCYaZQ5V1G7qlosGN5HI66Csn0FJxji9pS5YenSmfuNNwQPWvbX3E1HM1PpMNL7bBeIu1lElIrblIr1WaVwK+LXHQBfZeef9jN3kawU7CsJB7QAoFq1YrSg5EQmrDKzWyYYaV8omFdK1QTvnMdeWExFIlo5rG8UAzTlAdL+ScmbrKdEKtCwaBiZyFzYcoLRICCUWTKa+zfFSzSvF4KQhJLFEtHnZILQVwN9aq0oo4J/IMU8UHpsrlceQ9GIk0pkwua90H7l84mohDQbyQKzAGRB/j4AL/4b0ZOe9GT05W9/+xvOOecc/Pa3v8Xb3vY2HHLIIaMS23DffffhoosuwmmnnYYNNtgA/f39mDhxIjbbbDN85jOfaRRMfKVIURTYYIMNcP755+Puu+/G61//epx44ol4/vnn5/mY/f392GCDDXD66afjr3/968gNdj5lntLGHnzwwbjwwgtxzTXXYOWVV/bnJ0yYAEC0TCuuuKI/P23aNGdSEyZMwNDQEJ577rkGi502bRo23njjufbX19eHvr6+Yc9TFB1mAhJ6w9Sw7pt/t2dWQXprioVIT1pBulxTSbA4Az+qf0iVxg1hfcHcazzfDyXgY14ITSuHvDdAYwiy/hjJjUbSa7Ko2QmIqBFYz9NPiHxgju1JgQmpK5DDoAgCeUaloM9LWlVjZ3lFBvXJV1/97GlxGdFe05kPm51sdAYI7fkmIIeCIVtDcbpR5MoRHAMoxDTprAfMgmWh7jxE4q8eKcWy6NlIilA7Q+dwGpvgRNVgvb8sANzmuAvzDCMMUGuDAtUcNhOhMZd239KSkp6XpeI1YgNEJVP5nMm+6g76dVICIZa1kQobfzaFrFs8ZVuC7gu9biggJCRvq5IaA5FJrRkEqUNhFouU2jkYeWON6yG7jT5WKAkGa0pgYuTphS1ex65pX1lWNzHOiEW+PkaM9b4BcE9wgJRkwP782rV51HvWawGJY2gzxMUpAq2Y1pORxUnZnnFLlJBIxBRc3k0mckJh5Edcp5LbkxETG2f02Rl9WdC/D8CL/0b0pCc9WTDy+9//Hg899BA222wzHHvssZg6dSqmTJky4v385S9/wYMPPoitt94aK6+8MmbNmoVOp4NvfetbuPbaa3HPPfc0kjy8UuS73/0uNt54Y6y22mojVgzwuOOOwz//+c8ROdZIyMuyUDAzDjroIJx77rn44x//iNVWW63x+mqrrYYJEybgiiuu8OeGhoYwefJk/zHYYIMN0Gq1Gu95/PHHMWXKlH/7gzE3oTqKm03NKGJEESU40SwXgGmgE/CLBgApuafkWZsqMutBM3bCtLnJ/79JJnJQ4xaRzFe9Ds3sUMlKoW5PIXOzUh/2Wn3lzc/dg6TV9UEsExVilIDWGCuwpbbMdKdupchgUKbgbQD+ZpwD+7ojA0wGCAMTiii1E8RKQanoFzOgiXBIg0LMapFnjhpmrYhIfvHcnWXKXDgszauB2hSbQIUG75YlUBZAqwC3CsRSgnKrAtICoyrEXcjd2bzYgq1ssjawa/FT7EH07EfmWpeCpn1clt+n8dxw60RDfewMVeCqzL1G/rDmG+IK/kc1KorJ1QnaNPah0UK6nywbarHpCrIXYqGxRqwB1LECNEDZrrmCu2ITzOXItP26R5JFy/ZR0wJgSQGKUGha2mSpENenlJlMgpHza5HSPBtVy4lFNqW2p8yqVmS31spI7j5UckDJAQVrrXJLekDpmrZlK1kIxJiaMLYmjKuBxSpgXAWMq4GxNTCmFitFi4EWRKvTInF3KoO4uQUA5uPFsUkojExIDAbpcSxVrLlS5VmelKyMMqF4pf0+9KQnPVmwcv/99+MNb3gDnn766VHt56mnnsIb3vAG/P3vf8dJJ52EbbbZBoAEPo9G+tqevDR5WRaKAw88EGeeeSYuuOACLL744u7TOn78eIwZMwZEhMMOOwxf//rXscYaa2CNNdbA17/+dYwdOxZ77rmnv3e//fbDZz7zGSyzzDJYeumlccQRR2DttdfGlltu+bIGH6JkbhLtLgEUJXiXRO8Zg8Fgdj18LsS5xSCBRoYqv6GMy5TTSIW62IFQcuMwDWCewcgsEGY0MHhj7jbibpUVf9NjcVSLiGp4TRMqKF3fwD4a/VBwRTqbZl9HniQjBjAtpgJ1zgqYZb59pqBvkCfVNOduCEZXyKaM8rlqvs8PnD3T8I+nrjdT1zmwaZLt9QIIlhrUPhhgCJJhKV4BmJXCDq7gyzM6ZWNp8B21evip+BonQpDPbYC6MCFLqWpzl52NWFMy6wYnvbLV07AAYMmSJFWP61jKnqdCR1hmmaXI6VAkNMiZWYJSqlO1UNi52fwr2bHpdNc5iuJ2FhlkF0pjvThNTtRrTPv3l/2OnK/NXiDdoarqiFbsTt2uOOp8B9l7wa/J3P5om5jSGnX1SzrZ7uIEDLuOASFDto/E0lVkcTLRCT4h1ZHoi4QxNdBfE/o0bqKMNj2MCmKQCSQxXFHd9KQ2h4zR7K7JVTG5LlpMipGGUuMnWpzFZiC79nQOitHlE6+434ee9KQnC09OOOEEbLnllthrr71GtZ/DDz8cm2++OVZbbTXcdNNNo9rXy5X3v//9+MEPfoCiKHDeeeehv79/vq0nBx10kGfJe6XJyyIUlppq8803bzz/s5/9DPvuuy8A4Mgjj8ScOXPwqU99Cs899xze8Y534A9/+AMWX3xxf/9JJ52Esiyx2267Yc6cOXjve9+Ln//85yiK4mUNPiig8WwygcCRxbXFtJHgRopI11IiAR1guH8xKwMwUqAKd9esOmzLQEjCVBmxgHyIuatqLxJW7o6ViIBjYSYjN0GsEuo44hYS1v80aFRYi5IOMkiZI/Q0wqSxlNEXMFDFmVtOBhjZ3pusMUE/z2kwaQY4nb8dI3u1azSc9ZEeNoFqEuJE7vw5b+nNDrBNSU02ddJBjeRqFKOcj62zzD97gLrtBZ9zB67ahfaVl8cje74xfs2URBmJyuYIBiL9r0aNSlO7MqrIqECIFAEqjSXoGhfecX5omxN3WfJxwMmE7XkZr1IfyilQRgrVbS5ZvSi5SNmC2QAi26IhvwgbtjJ7i05AgFh/bJWl6rp9SvZ5UL/6dB3lVCBbGJ+I5oY0UpwTimLYdazuUghKTC3TVRx26AAB+K0osRJGJvoioYw21+J2Z1ZAYlEowGNslIc5gdO4J1+ttI7BArHBSirYYyeaqzVsRkZFXmm/Dz3pSU8WvDAzjj32WHzsYx/DpptuihNOOAGf//zn0el0RryvE044AXvuuSc22GADHHLIIRg3bhx22203lGU54qlU50XGjRuHFVZYAUcccQQOOeQQTJkyBWecccZ8HXPJJZdEu93Gpz/9ac+k90qR+apDsbDEcowftNTa6EfhAaxQF5QYSAp8WYApAKCZVjLVJyB18ZBA3wSg5H/TeFsOectoY+BB/JYVcikCrkNWPZsUCHCq1iu4LblfVa7xTBIyv27LYiWaSs3qpEXtPNg5BCCUngXJahYkEqDaWsrcvJA8v4kk406JLLOQA8p8bEZkkstODmBjYK/D4JWCM3ctC2w29xqvhWFuVYqNg5yUHNhjOBLjSFYIA4mc3KWy+UquSuwZvdx6E+R8Lc1myYRWFLcc0hNiTtW4zW1MZ0AJTyqGZ65LZpkw4mXnY/ebAbMZ4PeCixW4HkKMHcTYQR0rdLiDIdTuylQRIRYFSKtlU9EClW0gFCnLVU7GPDg+cyPTuXNaoCiXmeGVqusaXFeA1vgomdFGgVaQzEyFpttlCkq4qFEpWjJFsbqVpVTNsZECNfoG82Exe0X0mqVGRlQLSkBAEQJaoUzZsCCZsYLRObOu2P4lqIuakkIkq5xZFjwYOrsOOTIQ60ba5oprDEHTLaPCECpAv1NaLK5Oi9WEfm1tdaMyGlIRY7CIGCqAugTqksB9BchqZDCj6tQYHOpgqKoxVNcYjFKDorY4Eg3qbjO8Mrbdt8xPdt5W92WAa3zvhbsXWB2KhSm9OhQ96cnClS984QvYe++9sdpqq2HJJZfEnDlzRqWf/fffHwcffHAjCPzWW2/FJz7xCdx+++0LrQL7pEmTsOuuu+Loo4/GlltuiZ/+9Ke48sorcfjhh8/XcW1e11xzzREa6XCZ19+IeQrKfqWIK2aRNMoCSpOFogHTjUzkoDV/Sx6AjKRLdbDMDiOhTzdidVXB6y/m+ljTvM71PPR1+6yDcbbjUjJCUEhuJNnnk4pbU0uSAkSY20qup06EyefPCBM4gV/Txjf6gH8yuZmkeTJNbSTRoBphyF0vGtPO2ZxlIDdmo85mOwFPzjTtRui6wXJ2tsQG8s3SIAA+KvgV33vhlhxS8G4kS6FrLmdZ0TsPtjdyoVmZkIL3bQ5zd6JoAfD5GviJysElON6qHwih6KDWQnRC2sAFpAhc1PVSe1HgLM2tgko1seU7wdY438Osew0an8LEiCS1OMTFTAKrKyK3RtgOYJ3dyMlSwYkhZGuSWyfSmubzCAhxsOPLkWt3uZJrOfoauKuarYd9ML+mfc/IQhAScbckCKZosKXgLDOCp9WFXYuslke9fhhCuCKh7Rmd5LHlDKhl4J62WBJAyHFBGimTBWHPtfo6bH5YCVFK3WuFO20e2D7H9lxPetKTnoy+fPWrX8V1112H3//+96NqXfzJT36CP//5z7jrrrsQQgAzY7311sP111+PZZdddqEFaH/729/GBz/4QcQY8Ze//AUxxkZs2LxI0GLMr1R55Y7spYiDSzhm4e4XATi6Bxy9pnSROQDNbxKI8NoDpn0ly9KCxuNGkDcsnagcixWspQgGOPHJK/XCX4Vq8y3lrVb9pQB44TUpxAYL9AVcy82xBlgas6X6rOV1RLXScMoAxKzANCLEWlvUxo2WFy6zINyQBeL6ObG9Piz/jwJCe5gBqCiNrTWjxKXF6LdWKThZgDKwzASK2jgLHK8hBcNiSrFbo9aaDoyqAOpCgrbrAoiFaNpjoYX0gtU2EfJhjMCAKOWVw80CFizFLKu1JGpMRI2aaq9nkCxHnMVPVKi5I6Qiaqs7qOshcGcQGBpE6AwiDA2hqDooNGDa6nl4kbaQKp3nWZ2yHenkxlPchoDgge4FYlmgKoIUvQvAYGAMQVoHrOmHJYOY+P2rZcfSn2pNBV9DI4M5ubU/slSyKTibIQSvihF1rFHF2it9S+HCnK6wXssZeWlc+93Empy8NxQV1LwWfR3tiCyJIEoWd6dWtGJ2LDENkVEq6C+VdJTMaIHVZUmaWcXsuyxfI24MSBUiLKTCFAFk+wZi3bH6MlUUa0rFNXrSk570ZEFKu93Go48+OqoxUPfeey+WW245TJs2DYcffjh23HFHtNttTJ06tVEkc0HL+eefj9VXXx11XWPrrbfG5z//+fk63uTJk3HUUUeN0OhGXhZtQpERhabuLWmvHWhbxpcs8wvn73YfbeT/NY5o2r688naew99IhpEJAQLkrj9MDneHkQsfbwPMdGnoTYWugFZqLQR/nPA5J1KRNY7qUmO3GUAnfZ7UvUNarc/xMAKWiFhmJXAiQf5aI9I6d6lpEAR4vn1kZAKaySephLtJRdd5+JplK0+ZLcXJDrxgGJtrD1ttBy0aF5RMBM1+VMAL4cWCEAs0CuuhkSFJ9hs3iERyvapzMqHBxnm5NJsrsbiIq5Fl9bKChszifoO6AtUVQqcSMtGpUFQVQi2E0PcQoZEsINtYzf2XGIW2gFRQsACHoJW08wKNUV2xohMKzzE2t/U2S1KeyavxBy/053U41GJil7yBZnOLiqbNZx4GxBuqBd+zzaiQ5LKYXfDwN2eZ4jSGgkzjz434iTJr9thjk5R4OBmHBEqnFNUyN6kIZfqOcdfBrrETsnHqnFcsxQiHUGOQpQ3FCp3YIxQ96UlPFpz87W9/w4c//GGMHTsWxxxzDA466KBR6SfGiGeffRYxRuy111543/vehw9/+MMYM2YM2u32qPT5UsRSYAPihjm/bl/jx4/HpZdeOt9uU6MlizihSNIALejWMDZ1oA1w7yA/O5ZrNjPtIJqAbBiRsOeQNQczyT3EU8A6FND7nIGEHLTntMMDjJVMKOAzn3nTljrQjhmpMAtFFCsFG7HISYb6iCcSEtPx8jLF2WQl17J8wqyxr43FH6Qg3ASam6QCqS8nEun4KSd/sk4wZ/UKdI59Xjx9aEjz3EUqLF7Agq9T4TdWiwSyytqJWHBmrbCK7L5H0rK6VjuBUqhVhFMWo2GAOxVqpHyeDE47AYxCHuoKRVWjqJVMGKEwEud7mhyUu6tZQxLE9iKBtt/0XGtrhCxFbWwQCQP3jSuJm+vaCIhGng3L3MbSbaBkRbA95QTCGpKFwq7BfARzFQ2ETqc9fFKcmOSKhMzqYdYCcztKhIL8+bnFzNhju/W9HbNEAF0DH06E0n1NLIwKER2OGOIag1xhiGtpC8mXuCc96clrU6ZNm4bf/OY3uPjii/GmN70Ju+yyy6haDK644gqssMIK2GyzzTBz5kwAwNvf/nasu+66o9ZntxARttlmG6ywwgqYOHEittlmm0Y2zHmRdruN97///Vh88cVx991347LLLhuh0Y6sLNIxFAAymJSIBFQLyJAf4KCA3nMyunOAfsKDhsmPwXYsf78KOTxy7Ju5XAOUWSeQg7YURWHJZoYBOsYwsGAvcEYmPDRY/QXdR1/PHRCgTA5I7BxZwS2rC4cGsNrJxXw2Zc7ItNTZjLiDOmfn4MrcJqtIcC7Npo3f5zsnFRkhzI8LP5qRCAHZ4iKvkQxK1hrkq0skDkCsFT5XBM1YFLPid2kMli6W9YQt2LepUzcf/i7wasSCIQQon2E7V1sjZJYfBdtGogpmFJBmWZkKjhKMzISCaxSodC5Eox+LILU/gtVNsLFQuhS6JjnX6PttUOudpiVmtQjYencDZUK+c5ucMCfNviJdGaVM+x8ZnkZWUhqTFMrz42auYRQQWdIB6wrpemT7wONocmuMnYWOzvdx+m7xRAZgtzJ5XRc2MkHJQhHJiYW5B9pcpDmCX5awc4miaYtKbnMDXdohXcoSpO8iKJmwNsTiBmaf73Szk570pCc9GWWpqgo777wzzj33XGy33XY466yzsNxyy41KsPRHPvIRfP/738fHP/5xnHfeeQCAY489Fm9605uw7777Yvbs2SPeZ7eUZYmzzz4brVYLAPCb3/wGs2fPRl3Pu4V4ySWXxEUXXYSBgQEMDQ2N1FBHXBZpQuFuAA2tJyXAnv18u4bZEZMmfnSE0e3y4PmP9EgZSLIuFWh0xz7kICBBafKUo26tgFkxcjIErYycHhuJiHYe+mZLesR6IIsdAEPBdlbgDwSpWUCqvddbmyMFrlH7E7ST5oUcAWXEIi2E35n7n2l0Zf6d1BiQdBCdAF3KMEXNfljnyzT5NrsZQsytTnmbK1kxRmgpQRE1w1RGwvzc4KTMOVq2X5w5wLP+NvaEvMw+tfncEbI6CEp4hPiISaQdg6QXhVScrqEpSpnRQkSJiAIVJLBXCU8ggErtK+S+NU1RduFkLyfIXW+WEnuUzYlZU8yyAGQRPWkS9NbIRNANbOTP8ysZwCdTEkQwkxAnPWZtR9e9ILE3SgbtbKlZUSKdhe1t8nVkfWcDbnexKvs+STUomutm1gkjFkIkyOMchIvqfMkk+d4yUlRHllZHxDqqi2LT3RB2X/uPOh8yL2Ix6oAxpBaKDlsqAaDqEYqe9KQnC0l222037LXXXvj2t789qv0cdthhuPDCC/GHP/zBn9t5553x7ne/GxMnTlxgWZ/22GMP9Pf340c/+hFWXHFFDAwMzPcxN9lkE/z1r38dgdGNjizaLk+Ufujz2Aj739LJJjCsQCKQaDQ9E04Cn6a1bsJRIGmy9VE3Imwgj/TDnetqG6DGAjwbx4KTAq/iy1rJl5MPdoP32JgcOSUI1Rhi5uLEGk+Rmvnma4JU80nXuAJzIUnkAA2DQsOlyVxsMvcWvx8Zyd2KvZkffQC8WrJVI26E61JaZ8rf4wgtLbjHM3Q1CgEUCgRtRFp5gCmNqc7cwTyWIydnKfjVfOq92nRGTJhTywOQJbOQVPwuELK/LHhcXy1QoESBFgr0cYF+DujngDExoJ8JfWwFzaRaPMUIqmugruU86tgVqwAPFnf3va71lT3Jw9y3jGAak7LP12B3takgAdkW2+B7AilQ3s83qx4uTaug27prHIWQiVQZujTQDgXrtq9i197l1PfcsHQ3r0rXNyH/v3F56biMQDXdtQzsd9OX7Bhk/bC7UNXoIhK1ubOxt4LZvwdyMhEhcVuSSlgK5Vl65AoS4zIExiAYA8PyRPWkJz3pyYKRqqowNDSEJZZYAldddRUmTZo0Kv3UdY2bb74Z73vf+xzEhxCwzDLL4KqrrsIb3/jGUekXANZZZx1cccUVGDt2LL785S/j6KOPBiCxFCNRoWFoaGi+LB2jLYs4oaBGsx/65s9/equDIFJrhf6gNwB5pv3O9dvp/yYBaEoXAVHNZHPMTQtFyv7UUPQn/MZibbB6GHlshYG04dPievt0Yg78FeTGJuBN7iNGFlJQrWcdygFn1+wYcEyuIHMPxk3EIoH0FIjeBGpzU6b7+VFGKjIQmr2psd4GhpufLTx7kC+ZZY6qM8ITpcaFvJ7OLc2nzZ3NQzanXedpNQKcTFBGJvxe/o7CiUWLA9oc0BcD+pjQF6X+QIuTaw35ApqGO2VUch08mcUki+3J9ngW6ZLvSjTBddqzDoqhgdIWaM4aI5L5PBmhaQZaW90MaqyRzwSnehGS0UjqvwSLhwFrRrDmvs4D9vNYJLumkhWysbuyjWdWy66AcSSLiaxSUmKQz8twlQT8sEYmsjiQGCXDWW0kP+09ya6GxneAfbXUOvdGJmpK9W2GZaZ70e+tnvSkJz0ZfXnwwQdx5plnYvPNN8c+++yDd7zjHaPSz/PPP48//vGP+OlPf4qpU6d6v5tttlmjiOZIy+zZs/HAAw8gxoi11167URtjXuWNb3wjPvzhD893HMaCkEXc5QmZ2g8ZKDHni+Z7HUTZk8PQeAa6vANkiGPuC+qfUZ8mtvey9UGNw/l4XEMM92mfG6kAAWB29uefgQBA6gJMPhds78l6Zzt4bMRXNGaCDDrKs5awU4ahc0TNweaOQRzldR+ffs5BmmmMG/g/kSBZxrnQCYtzIQVbenduRNJAXaMPPSOrXE0c4dZPBZ/MDCIt9MFi0QCgLlpyEFY3qeQ+FpFqMJBbW6wKu21US7FLsCxGVocgJ4k6PioAEgtKoFLcmVAicBZqYv0oHYkGNDPCg8jiPhSj1NfwWBwhApSj0wZt7pr9/Bpgn0mvxZB/htlimMjrLBhF9MKRvpa2TrZW5JgenAq0FTpMA9SR4bVaZCRRC8Unqx8HOXYi12y8Ui0l0GvHvMEstiQbAKsrIcxaEvxRRFAXueDP2vTkyRskzgfN18gCvMU6VGv8hBQTjInIKlE0SyD02smPHf06MKuF1kMPRnSDZsV65f8g9aQnPXn1yk033YT7778fW265JT73uc+hr68PN95446j0Vdc1Dj74YKy66qqoqgrHH3889t57byy77LJYfPHFR6U+xQMPPIBPfvKT2GKLLbDSSiuhr68PRIQJEyZg2rRp81QtfOONN8YJJ5yAJ554AlVVjfiYR1IWbQsFIL+imkK1kUa1W0MN6GNWDWEKsJTmOvmGpj1L5NnQxAMJT6fMTs33pndkvtL6Pqsa7GPw15raf0DBQkxuUCEyirw2hGu+k/uFuWYkjW+zerJp15t/WdYq12py0j57YlPTPJuLid6PVu8iuQyZy0ZgGbu7cbCAXLBV6kjL+e+YuJ1LKKRCM4Uis1RkvvhzI38EUNDaBiEgkLo+kdVIRnJ5qiOoZmlqoaAIsVzUEai0mWuRa5XNApSBel0/t1Bw5uZkFhYfs4QTS2G6AhxaQGiBQhsFtdCiFtpooQ8l+lCghRIlCnUfKmBxMZFJsgW5m5uAVImRsOxV7BmsIiV3oYbbWrYTfYRk6wAY1bQ9YVWtpVWoYo1a+7d5DKzwXAkZrKK9uao58SQPeLbMSa0ItJnQAqFktd8ow+Y6guvKG+pa0iBrfRW3hmUuhEVEaro+afsNt5aUCGhxgTYKXYMSLSpQUAFLChAJYjEImkY6a6xZw+pgrkoS21BHcXcSCwW7hYy6rRTR9CCU3J0AVEToEFCFgBgCuCiAsgSVJahVAq0SaI1ecame9KQnPXkp8vzzz2OllVbCnXfeucD63HHHHXHPPfcghIDLLrsMX/rSl0atr06ng9VXX91jOJZYYgk89thjWG+99eb5mE8//TQmTpyIe++9d6SGOSqySBOK3IUjBVc3NfKechOu5kvwPvN7rxXk14ioKQrAckJhIDoFF9tz6XMKDgiaPjNPMTl3MuGkouv9BkIaBIYTwPACc8OIBXsQaIpHUPeekBUIy/zgbb5E48kN8JPqJmR1BbpiA6weghfSiwLiyFKaDhufuW/lwabs7ic2GoPWzVty/tjt9gQjTQ1gPtzdxI5BICUVqbnTlONo2zNdj7UoHhnpyAlHw2qjn0lPwWw/OYEwHbivA6AB+AIOYyiFWBRCLEJoI1AbRG0QtYBQAqEFDiU4FEJESIsqWgrSjOBEwElFHdhJYwQnLXmj8FyyDKRRmyUFjX2U6kMIkYhc6zHTPKagYnJLT+5+mFs7jFSIy1PwrFYlgjchaCSJCGIE11Kfg+sKyOqq2HeB7cMiAmXNUnhOW6GFGwvkMexKKkgITJuETLSpRB+1hNSREFOEgBikAKKRcolvYNRBSEalhMK+KzzmxNbI1yq3NnV9+flXmhE6dXMKkt2LiwJcCqlAWaTWk570pCevEPnYxz6G3//+96Pax4EHHogjjzyy8dw+++yDyy+/fFT7Peigg/DpT3/aH5911lm46667GsHirzZZxAlF7uhiWtQ8f38TROS5/fM/qTfQDK417by5JTjgYmREIpEIJxN5AzSzS27ByMF55ipEpj1O970kg5Ihr0nQVbm6QSacVGTBoqphbYLw5sx5n3rO3LCa5Dn/E5mIRii8mc9+NtYGiLOgUvZbaiAlToDeYGXm5pI+39gEvhfmtkPAw54RkGqkQoOBiTJrQRbg3+yNUmhNhK+FWR8ajmO5yQXpPufPmbUI8J3g8SpO7gh1CIhBrBWs5MEaFy1waCGGUlsBDoUkHDCSEhWcGlA1Su0WPPb1ToQxJ1OUiAUSwE50SF/RxWPfK9yweCCLl+lel2bdjrlMIyx+IYss0fgTuaVETrP6K6kOS1RLhbo4cZadKbNSSKpXbuw14012PRUoUJIEyrdQoEVKKEIit5HUChHYSUTHviOUUMT8e8LJQ26hTFZLiWeC7z9qzI7NW6qHEgtyUiHEQq23PelJT3ryCpBTTz0Vt99+OzbccEMce+yxGD9+/Kj0M3XqVFx22WX4v//7P/cuWWaZZbzfJZdcctT6/cMf/oCvfOUr+MpXvoL+/n6stdZaL6vfD3/4w9hhhx1GZXyjIcQjEXq+gGXGjBkYP348DllqXfSFwn/0U1Yn1XyG7sBEGqaBN0AFiBNB8n+HQxjPk6//5841lpyS8ltK7wc1wS4BTUAHw88J6Fg+ewnEFI1pDrxZLSKRDHbAgZL1CVCz0DTgpCh35ZLHlD7o2ZWCunqIS5EFCxeuyaeksXako+eYozAL/PVbCxhV+kCW4jQkoGoWFKRjdPvY5+thY3GrREYEc3c35O9HmvzI0a0sXNdwiwhBAGLwBKaNIGOxlgTJFhWMlGSkxW45a8jTiRpRUmKVBRKb65hYCtR1J1awytmWLcv2USRCFQI6QVxfOoHQCYTKCu8VQcBlKwBW4Zug7jXRW6jtGsiDxLMdzAyv6c1i0auiuDqJ21tyrzJ3pRYCWqFEoS5mFAK4UE0+kbtd+XLD3OPEAoRYg6saMVZJY2/XM5CCwXUNrQZFEQoURYmiKMW1rSjlOSUkJcR1qkCqyu2VzXVe/ZpRsE8sBJ4aGdMqRF0vihFlrNGqGS23fsjOjIFRBUanZMxpMYaI0YG4PFVVRF1pYHZkVFEqXudVs/NYlfz7Q74TdO8HknkJQCcwOpCaFDUYQ7HCn6f9A9OnT8cSSywx/Iv1VST2G9GTnvTklSsf/ehHcfTRR2PSpEnYaqutcNttt+HZZ58dlb6WWGIJXHfddZg0aRJmz56NZ599FpMmTcJqq62Ghx9+eFT6zOU3v/kNNt98c6ywwgoAgK233hqPPfYYZs+e/aL9X3nlldhggw0wZcoUbLrppqM+RpN5/Y1YpFVWJcT9QUCaasEjo6gjWnXdaGUdUcSIoG445gblrh8FUBWEqgQ6hbYg7gqdEFFRREfbkN8yBgkYCoyhkG7Fl5ndhzoH8im2wvy6tSF3esnf584zScsbWc6jzlpmpTB/8BLIstF0Z6YJ/rhAQ9ephMNcvlKcRH4/ZYsydycFvplVKLdMFMyZ5lefBzsRamisMy1sI7OVArrcbcX7yj+YH8+1481xCejM/OPVZSVYXEZI2YdS0DA1yaIvV3Lfgr83kajcfczTs1K+0t1/bitwS0UdAmJRIhYtxLKNWPYhlv1624e6bKMuW4hFCS7M9UnD6dU6YWlwc/cnJk7Vv91KYZpwbliIjGQ3qllz83EzOD67m82VbH+zWLCT6aaw/jOtfb5BpA+LQ0l5sMgtFeL6JG5Psa7UUmEpdOGZ01INCbNWcBZPwZ5RKXWbrFkFFWiFEq0gsS0lCWGxquLm4tQpGEMFy/eDfq9YtXF3i0xGHHVfYq8rUeltnU1jbmWRTFgW/E7OxU2pwiEjbT3pSU968gqRn/3sZ9h6660BSJXrj3zkI6PW14wZM7D22mvjrrvuwi9+8QtstdVWo9bX3GT33XfHN77xDX98+eWX429/+xt+97vf/dvPnXvuuQuUTMyPLNKEooWAFoIEZ0ZCGYFWzWjXEe0qoq8T0VfV0uoarTqijBEFx1TPIbdmFAG1tqogdAolCcQYVCIxiIhBihigiIEQMRgiBgJjIDAGDTgoeOio73RUlxKDA0HB9Ys1y/6TXEzQdHlii0+IjViK0l02yFtp9zNSUWpraSsBTT2aAJ7Vo6hZalTUXCNGvdUA7Ji5OnmtBT1Hq6eRa+AFxEUEA/dzcY0yS4dNVyIVeTA3a4xGk1R4BEU2R9JqjXeoZc6UeFqsSUEkzTTaIQV8I6RgdrdYucUkQ2i56lhXjbtJhQVCU6JtOY1I5IfRTOdrGmlxfYpFiVi2tLVRl23Eoi1EoijFLUoDtAESCxtDYj8qi/2IPtfsYyMnFjml1RXJLBVZJisg288Zgc0C5W2ePB5ILSwUhUwH3xu6B5zw5O51nDL5DhtXkPWDWB+CFgYU8hQ1WFtrr2SuV+l27qQ1T8/su9qIpdcyKVGGEi29LYNYQ6BuR3VB6ASIwqFQq0GhcVJ2HjoGUTNoHBUsFW9KyWuv2XibAet6C43/0PNw10SNpelJT3rSk1eSPPLII5g4cSIee+yxBdbn//zP/+Cmm24CIJmnDjjggAXS76mnnoq3v/3tjefWWWcdPProo1hqqaX8uf7+fjz88MOLDJEwWaTTxpYswNiAhbkHCbCRX11mQk0MqTws7wM01WLyg0laZSh8IMmSY+5QgP7wE3uaUolF0CRTsFSgrAW3KLlJuEuOaucBZIdtKkDZgqqzfEUZuQDnLk7pIKmwVkrJaa4bAovkmAJguNF3hGTpIZC4UsE06fJsRAJWZFpjswk0QEoCnPmZcX6Sql5NIRyZ30Y+KiKb8MbzNm/uUcVNXG/Q1UNVNYsUONW3M1cmgrmNkGXZBWCxBxnQt9S/xH5+jPS0j1HH4s+zWSr0ZU6pWsmOwnZeiYj5eSradO08JaJix2M/B4u/sYGZJUad2jTDE4khSY4VQiOzklgq1KJh068LxsjWwtF8Brw5006o+01yk4LvJNPAUxRyZrMXIOQrfcCIVQ7omy4/jTVXS4msnxE0yHEogjmIKxZFdWEjHycax87shEbmgrnSyURFEosAk7o/2X6M9plC9x00dxqlmBi3FmSWoC7yFufSbJxJ0SB1OXJ7ELN4rgFidTJroTk2LqgKsT3pSU968lKlrms8/vjjqOsau+22G/r7+xua/JGW448/HnvuuSd22WUXAMByyy2HffbZB0sttRSOP/74UesXAGbNmoV7773XCczOO++MrbbaCiuvvDJOOukkDAwM4G9/+xt++tOfYsKECfjhD3+I888/f1THNJKySBOKQrO8GHgQjV10bSkghMDqDtSIWiE7BQfnelcRBVjMHmMRDVgkBKmgNGpQbwKrhYF3Fk2hgzHDhDBLQAK/DUCKpjsDOCM+Bnlck69ghsn7JkKm7SRPqU+eTx+NvtwDhTRxKnk3qB2YMYCgLjEynkQo7ENwUJ5gWjr3JoUhfx12fOImHeG0biDOCJids/HA5GQjpMnAax6XYHOlLk5BPocgz7GCfwGMsQHsGqSoMXLyMRvAo/z0mJoGDJ07Ac5JM02UQLOBc9nLmUaZkRiYafstJsU6IM5SrhphqWXd/TisNTSimiRsEvWzFldBSD75nK+YrhVngD13OeNUN8Lny4GzxAHIrpQ4EkTAaIAQYE6znVVSz04SBr67t5IF2Ns1L6dcw2NllExwsDnIIbzM7zBwb0QNBA4WdyLUPWoKZI4RQVi47P8olidw0SBB4rZG/7+9dw+2rCzPxJ/3W3ufBtq2pW2BBglSBmQSiJmgAxrUyCCDE4yXGQNaqWAqQ6LFZRilKkErkcmY0SRoamacGal4iToJRDOiSaRUECEhFKjYE8EYLkHCJSA/EJq+nrP3+t7fH+917XNAaDndfbq/p2v13mdf1ndde73Pe0UtrFncKGIiZtodkomwjuS9Z78vpkQAZKtTkf3UV2g1Ck2pYPE4DQ0NDXsgbrrpJrz85S/HWWedhRtuuAE33HDDstRduOKKKzAajXD44Yd7Yb0TTzwR69atw9/+7d8uW7uGLVu24NJLLwUgcsi6detw/PHH46yzzgIg83DbbbehlIK/+qu/wnXXXbdsfXmmsaKDsn/nOSdgFY1UuKkotVdCEW415r8+IcJCR1gYESZdwWREmB93mIwkOLQ3YcoEANa8+jVlrDFhxv3pxdVC0o+q2wzUzQgakFqBcZVqxqMqefTHbIHWQ/07YK+RC80m70jazepjjZgAUrcdCZg2wbNqcOaUzIVC+g8OYbtwiMwMCXKdFGACyXA1BdD79ojCXvIv6l14LIL7l+sIkkTtGmATpl07rtlnSOqIUJpbEaBDeEeaL28/t0Wmj7cUqJF5yoTernQgGok7UycZkaBWBhcoVWCuWvVZBMQk7LIPSoRjD2TX/pQ0dhXQM4XqGBhpXQFzV+v6iO0hr/ic7CQU7jZmVXGXGUoZg3S9p2D07qImbmpMDO5Ij4I6LqijEvueGTQVAVlqHmiqVk77EeqKVMOdprJfGSEUK9lgd2eC75WIWSkyV1pDxuNLjLjU6uewuI/4DIZ7jOHuVFExW6IOSAv6dd0Io26srkmSqWlO3aWKknGrI2FHX4Bp16GOOtSuA7oROiriWtgzRn2P0XSK0k9BmqaW+wlqP5FgbXUN7Kl6it7aqRuTVsbu+4p+UjHpJRB7yoyFWjHxuiAyPknWQB4fNVZSYb8XTMCEGJPCmCfGNqrYSlPMc8UEFdvrFDc/9kALym5oaNgjcckll+A//sf/CCLC+vXr8dhjjy1bWy94wQtw++23Yzweo+97MDNKKVi/fj0effTRZWt3Fj/90z+Nr3/96xiPx4veO+WUU/DVr351l/XFsLP3iBVtoSiQ+AARLkLI7VybJ/7ZzEBXoohVJdHghd++uiu4cBIaV1Yy0asw07saGiBU9FTQUUUh0lSdcMU7Mdw9JQJa1e+5Lo6VsA/n/8HZZ9zSloqUalmDhMQU1fWK4Nnr9yidatZP3DINSdM6b6pZn5gwq/PH7q6iZ/XgZAIoHLSK9ZM0ONY11qFtZyIJkKUClCr1G8S0EGRCJ4Z4hkyk+XJLhVowmMzhRWwjhY2IyZp6atHCILLXtY9i7hi4+9gYTL71uJAYOYxoST8je5S7zbEbLHwdrOYIpdgac08RUmGCtFkKNMsU0eL59L1CMSm+7uQWBtnWKpijCEmyz1tqKtPEm0UOJNzVSRSrlaN6jIMHpLvlxLTpjJra7ZXEmjMajDTX4hY3c1Yy4hsxDrav87UQbne+sXxfyr5iLhrjo2SnVjD1eh1R+L+l8zEsXkEzw5UO/bhDXTWHumoVsGoVeDSW+Iy+ghYmKDvmQQvzoGkBTSfq0lY9c5XtKSkkKPUoesvgBLgbmFxvYZSxXxm7iuwq66BF/lRxYb8hVS/uCkahCiJzYOw9k1lDQ0PDnop3v/vd+Mu//MtdIkT/0z/9Ew488EB85zvfwaWXXoq/+Zu/2S3WgG9/+9t47nOfi7vvvhvr1q3b5e0/k1jRQdk5tkDkItOShy7U9OhQLatnGYJZANiJA1vEp6VdyQ7MdqNX1w0jGVaYymtTDITwGZ/vpG20vliKWAuoHqugMNbXLQuT15RIlgJz+bKMTZ7tZVboxhKWEDt49pya+UktHlbwrZhbRaqK3dfQfvsjTKsqj5beNIKNQ1h0dxlmRCE8DdQdBFxbkOkMkVBiFOeqHtzrGXxsPG5ZsXkiP6cVTot0qaQxGpTmL+p9WBagTmN4LOg9C3eRejjNt3OqiHcw60CQCg20V+2zBTpHJfC0oXj2aRDKHEAckRk2VTpnqSKzEzW3ggRBCQFe1nO28rSnTibNvETZYkV6jqiwXjW9rBe8S0H2i6pD6/itiN0YBSMqGFEne9TX1DIvSfalURlJ1iXSdLUQ1y8v2qdZn+xvrxyvR6+EoHaEumqMunp/1DWr0a9bi/556zA9aB369c9Bv+7ZqGv2B+83B8yNQCPJEGaZwkitL3ZwKZHKGhaztOTPjV+1OX/W8DcAsU/Anq0tXxNurVHLTUNDQ8OeioWFBWzfvh1d1+Gyyy7DSSedtGxtMTO2bt2KWit+6Zd+Cf/1v/5XlFLwp3/6p3jlK1+5bO3OotaKzZs3461vfasTmoWFBbzpTW/C3/3d3+2yfjwTWNEWitDbZ4FZb7tkN+UIS3ZBFGGd8GwwZIGnzjFUyFJzA+dWRRsqccOscRYEO8PQomBuGuRayKHQEELtUPgPIdDEyCAnBYTqwd+5FoZ9zjT3LhEO5ggmyfqcZQ07UQSGdwBA1ecDMJ//mAc5QwdQleD3ZFHIghFopg82r1xd8EQhUCVQUbWunYSsn/A19x5wHjNFixIY4LpneT1my6wHcip2bXWIcWapCsISaTpLkA63bKnwzFbALhZt8d9pQ9kHVOKPmiIi2FcVINmGlL7LM6dwmGbcnoPsyz5cZngcBQHgYutEQAnNuk/wTH/9bBS7z4iIG5zSHoFbH2w8ZscgN6eRWicYYQ2ywoyWaCCfm3W+3YrlMTUsmZaqZIcSFzYjUlWDz+0sxWfPrEeelasrQigO2A91zWrw2meDDzgAVBn9wgRl2zZwnQL9FOBefKQ0oIqYhEiwBFhEel6g77W6NcJ1Lf8uzE637QdXnuhjh/htY1bLm1FA1sTPRixWnndrQ0PDPoZHHnkEn/3sZ/GGN7wB//AP/wAAuP7665etvS9+8Ys49dRTPaPSaaedhttvvx211mVtdxZf/vKXPW1u3/e48sorMT8/v8vafyawoi0U6dapr6gLgx+aujKlsFyk3a6hNc++2oO7fFVXIIY+qmBrmWgsuwtHEaqIu4gYhlxBO7IphYAe2nKzSMQhWshcTyI07iHUmtgRGvHCPPjbXXh87lLGG4tfgMVCRL79QsmlyvrOGmdgFoqa61TYvNpK2QMN5l+00KaZr8PK3zUsDW5RANx1aWj1UPebaj77psk1S0vnfvsxktyXJY48j6Y173t0WtMk1yzweiiIgoe+jkYYdcwhXmcbFuDuQ8kdzbKHeXyGrbDHpyyiaCGQiskhxV4Ut14oC5ZgYt2kVIfXkAm/bq1ILVo/wjoQ8TMFds3lvYl0ndVIOawpZMPXh2MekKxJiBilMnuYZUSvi04tGHFE3E/EWEj9lKipElW9vehjAeq4Qz1gFeqaA8AHrgE/70DUg5+L/uB1qAc9B9UtFGPweATuirtSSRC31YEgL+TXwwry6e8AIywVFBmgfL5piZ82pLS9tgsoxQ+h+u+L/0I2QtHQ0LCH4x//8R9x5pln4v7778c555yD97znPcsaD3XeeefhM5/5DDZv3uyvnX/++ctavfvJMJ1OlzV2ZDmxoi0U+YYJiHaSGTA/6oiukNtsQQ0BTwVXUq26pZB0cc/uvUmw7CCaULvBswl4RQRnc2ER9yf5zkS7k6vvsiote2jmGyIXNIfZXOD9V30skN5NMc8afsCDrrs2k6Ga7sUa7RhmSo1JUJcVEZTFklMkfqL28qiBuJXN9mIdUWmHVIAjwDL5QOfLH41smLabqsrAxV3hyQNBcr9NA2uPPiPyXc16JXUYbCLM597WOpMS65Ocuei+Kjqx1YRdrWch+6iglKJNqNocETDNOjb3n1dziCnTjaiAwzIGmAkj4jP8eQ7ytolIr7mkOaAU7PMv7SqBCUYztFBYzIgtjZEK75XOMhff80SWxjZlnSKzuOk6am5fs9g5gbANWklLZsQJ3FpIQXzzdTGbsUy6O+voyKilA1X5fF9FyEYVd6YevbqTSeC2kWWGVkcfdUIU1hwAXvdsIRMHrQc9+1lS12LbdmBMwNbNwNYRMC/7QKwb6gJJjCkDU0oHM6YsFbEtg1yPrGjQ3whW6wvHzmCbYL+A/GpAD8aUxF0rJ2Ewq1dpfKKhoWEFoNaKF77whbj88svx5je/Gffccw/Wr1+PyWSyLO399m//Nv7yL/8SN910k7/2mte8Bvfeey/Wr1+PhYWFZWl3KVx99dX4+Z//+RWZ5ntlEwqSonEA9KbL6oakQrEKFazBoIOK2gyUntGB0ZfIFpR4RAiqHOfqLMuOqQZDboMIkORVbvUVMCSL1JQZU5irAzCnwrLEdCzWAgOIVJpJDsyfc2FPJMI0ArNsZGk8i/48/L6/og0oqSCS+h5gDrckVSrLE/uiulWUCAavVFywYwpSMdOFaFKtPxHfsmi4g75a0Li9YWvklZspryepMG5CeiaOPDw5rEieCs1qgUJllNpr3EABcafrRgB3KRA92rRAW5W5XaB3OVtHaFYiqc7NIdCneIZsLchk0E/u4whqHKEQct5wKYrxmWs9pXZh7TuhIE+bTJC5yFYc24MzdAYRpl8iSxpj8F0nlbYkOh6P1acYj6+7kbW8gQY0TCw7YFufAqYisRM6aBHkhcyIm51YcITMEtB1wKo5YPX+wLNXg5/zLGDds8BrngUsLAgB3jZCGSkp0X5VqlLUsghxmLAWuQSjR5Xq124RRQrKhise7LBBS5I3CqJh3yNZ70qMCaSNKYWihSAWNIZYRhoaGhpWAmqtuOiii3DTTTfh4osvXta2mBm33norXvayl+ErX/kK1qxZAwDoum5Z232ivqxEMgHsBS5PfvPNQpYKJB6cnVwx3IWiAp1Vmu5ZnucqzlnJq4cH7nJ2YYG6jIhU4K5PpjGECBMLkIrbC4W9+vZED8lLP/ShdvcHJMuGHQhB0wI8Zz/jYjPDx2yCVgixWfidzRuUhDOKysfF3IeKuRBFZiMYeUvuI7OpPr09DuFetN7qHuNV1oxgYHh4/+EkK79uma/sdXcJ8395A4X21qttu5uVpnVN6y2pVC2AuE9HrvgceyOCwzmsYun9PCGD9XT3mOTPP7sH7ChBMmxVXddu7m5qbTKCaAHTQwHc5iItEgB33SmaAarTNL+dBhprqmJzubM1XCqBwDCImmbWdPEqcRp7JU25ijjiH5xEDTsPVxRYHIbtVfvRrjmtrhVBBCQGoivAeATsNwc+YBWwej/w6lXAfiPQXEEZCQmz3w1LQNArgVggSd86n695JRN15hoB27UNuLWpxHXOZAXx4jD3ySnBicSUOFknIqh/pIkeGhoaGlYK/vEf/xG333475ubmcP755+Owww5btra2bduGm266Cf/jf/wP3HbbbQCA0WiE8847D89//vOXrV3Dr//6r+OYY45Z9naWEyvbQgG4GGwBjhFeaa4iKryheKCxWSm6yhgBUuwK5GkeTaywglGulYUIrO42wgi3ZEp94cXaxp4YnWpdEfICCpFmh4pg06yTt/NkLTel9+zRtfPJSkFIaWEBczzSdxlL2CX80YW8JIFLzK6ckatqkrMgZ6QC1ccOmGBfhkQnTqt/RcSIEwse9gnaXpwneu+CKUFdnrLFiRCrQ3qa0LbT7DzoOCqCaJis6fEUxOJKQySCtW4eKtBdltaIlVDpOlpgNfl7UIFRepJruVkBOyuy6C5AM3ENDlZSwWpAY1m3mmZZ+mFFAE3AtmU0V6I4v8UByJTJByXO2FTnMn/EqRMWZ6QrWtVCUclsdp5/bbAfWF3PbOOJB11y9qMg7foFxF5ePCWDvewtqSWBRQvWQ4odmjaCbSMpoeD95oD95+RxvzFoXIAFsaGUajUoeqBXQjGrRFDFQsRMVaBWeM7Y2CTDjidiBZav9EWI7pQYhYJYVQALpDVkENdeYcJICS0vmp2GhoaGPRvbt2/H97//fVxyySW455578NWvfhU/+MEPlqUtZsZ73vMeHHnkkXjRi16Eubk5XHLJJbj//vvxla98ZdnaLaXgd3/3d8HMuOWWW5aljV2BFU0ostY7BCWXC2CpYsU/vqJwESIBQlflRsssMRSFGSgFE9X6gSSj5iIRJUmKIRBGo+LyIHJXVWFV3CGE7PQq/BSCam9ZBQDyuAs7uWul9dFc5EnP77IUTDuvn0vWiJirIBdBWhiRoUeOkniGubg4qQEBVowMlqWH3I3Eg7Cpqmu+Co86FiE7KSAa5opmYr2el1XrvYRG1ebA6ECMf+afkxHyL5pNJsRPIyKa7Yti/hnwatXFhH77vFk01M3FszyBwRh5XIXL37ZPE7FIXQfD+IgI7hJIzwPykLX15gbn7w3GooQKFr+RnOAoxsG6D7QihZIlJU7KPAi26cx6Imvo8To2B86ALKicJOEByMk8q3uikQowJ6sB/P8CsdKE+1W4/gz3QxBOPyKYRubVJt33jrrB6cRWVEyr7NEOBUwdSBUGYv0p4HEHnhvJMS7gAoAnKJMdKPPb0W3fjrJjB2h+ATydgPseU1QsoGK7FpgTQgFYml7S5AGFNVWuXjeZ/ER9GKR5kPo59qbtLwvEXoBYQHolXMTsZKIOp6KhoaFhReDqq6/Gv/gX/wKPPvooPvOZz+DSSy/F29/+9l3ah8suuwwf+9jH8B/+w39Y1nbOP/98XHbZZcvaxnJiRROK7LQTghINhCaD+dCba03H4gZggnhn2tkCTEwjmAJ14wjhEIDHZ7iW0cXk3M+kTde2eibxqWbx4+5VY9y7JpG1kFm4c5nSkoxUpHOLQGIa9xCYi75n6TYtlkQElZLc5aPHLownJbDPp2XsKe5Y5PMAzSwjc1JF+w0VHtGpBUl6EK5ISrzILEwmDcLPTfFC/G/99s+YGOZUYfB91n4MkSMqgtLAP8tKKvQl/5RsAGK1P/VKVtjSd3YzRC3tHyW9OdZc1pg0VSvrvKXP2+douBcTV/J+uQ8ja1YnhGBu29S117B+6Kym6bFgeAnr0C+TkRslvDUE+Szse+yJEwzpT0Fxdx3WBjwTVFqzKI4IT1tr82b7XNYmk4nhTA9zaWn3uSgJBKxQY69VvysYHQGlEpg7MMzFSpM/1B51OgF2bAdQQY9vRnl8M8rmzShbtwmhmEhl7ClXsUyou9M8NCgfUryvqKCffRxJSaTa/4QEUKy/kaqqFyYToy+y5+RUGqPBYQlxdz6Eq11DQ0PDSsO2bdtw9NFH4zOf+cwuae+CCy7AVVddhY9//OP+2i/+4i/iuOOOwwknnLBL+rASsaJjKGjmyHBhLN2ULfbARMhOicXYDy0mx3Dfd0pnDDIR1IKNJeiNnf0GD//b08jWYVG8ylEMLwrkWfaq0DwOjyxohAZ5poyfC1k+G1n4MiFu9hGWllMDunkYQ2ACq/ngF42tKKXzInhF04Ui958reu7R62MUw7Pklot94p/o0KGEJhwxhuGuyJshBxBrVqrk8+7+TKladQTvM7r0vLh4VwHupQZBnYD7CVAnQD8FcY8o/JYOhOC91H6VtSX1jyepqEx6FI4MQOkEsvwRGxGHFiTM6Vt9huwzacayYGsac7M4+dxlUmFpUe1vvb6ct4VA67U7bH9p/woNZ0GH4jE7pRBKISkOR0XqZFBcw2GKiPbgMQmautjJJw1igewqqUoqeq6Y1h5T36dRfK9Opqg75iWr05atoE2bQY/LUbZsBW2fBxYWwFMhFD3ESjHR4OxJYUx1HavRN4bPTy7e2FWOIpdVC17q36ZQ6EniJoy0SCxWSkWdYjOCSPsV1NDQ0LCiwMy4++67sX37dpx44on4rd/6rWVt76GHHsJ1112Hd7/73eh7SbGzZs0aHHHEEc94W4cddhh+7/d+D6tXr37Gz72rsRcQimSTyII+4haaA1rli6LNLigYcXFrxZgJo0pSuRoWPOuOPa6ZBlwegL1k7hVBKiILDS/x+oBM8JA0CFFZLBjIGDiRCWnfCID1MevpTYYIrTEFqaBEJihqJnRLHPYeeXsm9JV4LClI20iFCmd97YVUeK0KC4Qd0omYAyMkKmi7vJiE3CzocrTp65PWCzBB2QhEIhX6nNTq4NW2c00McOw1ZiETetQ6BdcpuJ8qwZAqzLmadGjRh5YLX51Efo1URF0CsWJljXW+AoIgxGHrMyCNFESCTMjOvRjMbVgX3MpgbQ6YvJHHoX0g1smIBTzzVqGopu2Zw5zcRH9d+KdhbYfcrq92XlsjFYhrNUhX8fPCLIDMQihYqr/LUdUqMUWdnwdv2wHeshXYtBl4bBPo0cdBm7aANm8DdswDkwm4V0LBFVOqHiSdyUTO3eHXayKudowqY1yFVJiiwywMDDnvhOBkYqq/JTWWcKiIMHLR0NDQsEJx++2348ADD8T555+Pn/mZn8F+++23bG3ddddd+MM//EN885vfxJYtWwAA4/EYxx9//DPa7sEHH4wLL7wQt99+Ox599NFn7Ly7AyuaUGQtsgm7hoGASiGYuoWCrCBXwQgdRlww5oIxA+NKqhVk19AbsbCzO3lxsoBEGuCkwRPH2OuVQyOqxwQVU0Tu+Lj5RzuzGm2T67Lmt4MVfwt3D7eepO+ZREkpQ48LcbCsMMCIyS02QSwWC6hSj6FTciHF48J5SOJUKlcVtqbo69QtFf2MtWKRNQbwXP01zaFbHSwTVAwuxjrL+NiEfLEugKdCCrTIWRAByd5U/Jh6RichEVNUnupYFtD3cdR+AdwvJhVWqC6Tvii1GKtlFirGTOYvswQ4WRuuASw4fEYAj2Px9TMgoDafVYPNdfIzmRgQuHReI+ox70Ges9uN71cloF78LhmX4jPk71vlaZTcXro+mH1PJBOJC9ZOoEtY0azAIXTOp1UsFJM6xbSfop9O0E8m6LfvAD++FfzoJuD/exR48GHQA4+AHvoB6OHHgMe2ANu2oy4soE4n6OsUU/SYoHcLxTRlcnMnO89gxkriNUlEZYwrY66XY1Ufz0dKbgHJemWkws+PsFDI9ZQtoFqDo6GhoWGF4uyzz8bv/u7vYt26dbj55pvx4z/+4wN37WcaO3bswIknnohvfvObAIB169bhm9/85jPebq0VJ598Mr70pS89Y+fcHdgrCEVYKbLwFdpdEc54xk1IhS9NZNmhYMSEOS6YY2AVA3MMjJkxZlYNod7Qh7JMIhCJVNSZ5zmlLItVIpOJ0DDWcFNg83/ObjNJIGUauiUhyEQIp0nQoxAIk2OUCoYm3paoTKyWmxHLc3ERCxJjQhpKAc0cHnCrzu9WHbnWpAVWMtErmegTsej1MJIh74XVxgaWXZ/y+ucUvG6pYNbsOj1Qp2Cegnmih1gXKB0wd6Y6AdcF1DqPvs5jygtYqAuY5wXsqAvYUecxX+ex0M9jqsSCe3F/Qp/dn6I2SKRVNcuX/udVxius1oMMTOdS10jcdmarwAe5kLUhd4myxZ+NvSks5MHT4hqB8MdECvQA2EmAZ0RaivHaNvZ1YP88lQ7UFXVnIm/U/oUBJNFjYjBZHWhznZMK7VLtGsijC+I7rKLdUUFXOnSlE/KlLfe1YtpPMZ1OMJ3Mo98hVgn+wWPAQz8A/vn/A933fZT7HwI9+Ajw8GPgTVvQb9uBfmEBk+kEkzrFAk+xgB4L6vZkAr/FhdhVGm6FFaNaMVcrVlUhEasqx/OeMacWi66GK6YpTHostmZWSAIIqX3DXvuioaGhYSXjk5/8JH7yJ38SAHD99dfjwgsv3OV9uP766/Ebv/Ebu7zdPR0rOijbRWWGphJNmXGypnr46bixq8ZVtJikGaAYY/1wJUYt8U0XVjlrZcMnetie/UXxXDPk1CrB2B2zla9ITj/JusAhpVF62eSvrPEOoUse7bym6WbX1aoOfxBzEGOxT9g5GfAsR3L+ENzNGuDCpQZ5F5aAbFJNc9XJFuFSxMGAaWwrChXYN4slAI5uz8yuCdtJww2oYGriFrmFx4T1iH8wG4iNQ2pjmwwdwr24NIm71hTTOsGEJ+gxVSLEABd0ldEVxrgHgCLdKJLak+QlIQAcqWyN+JRElMT9yj4hAdBeOZyM8pm4LAsua0Cwmh9SDE7HTmn/JTuOEQZPtaxTXfMmpsyYZ8+gFw9kM+Z9oD3396tZ92h4DeZTOemDMhwGLBuTfDTHuyS3pkG/EGTKLW86V8ZZzCWPCVXJRZVoeFigNvVTYFJAZR68fQTaPAKmPWjVHGjcAX0vbk47xBWqX5ig9lNMuVfrRFgmpoAXlKsY9tctE8nFLluD7Pemh2yUcbHYKkLevenXSfa9kwv9XVGS0S/6RWxoaGhYWZifn8fdd9+Nt771rfj93/997L///sve5vve9z7ceeednuVp7dq1u6TdlYYVbaFwSd6tEFkzP/TF5/wVR7iQqN7XA7VH0MBI5uT+ZP70ocXN8tasxWLWBSpu9GGpGBS4QggHvFRvVUYzX/zhOEKkyDEjg4J/GMaDDPM0LSYYuU0ZMw0sAq78HmiEkfzkcxGzZEXQuTDXDHdP48gSVZHcoNLc5BiKJ9sWWd89WCgpPiCCadWDe/mbe/87x0dUddOa8hQTnmCBJ5jnKXZgih08xTymmOcpFuoUkzpFXycSV6ExFezF7zRIGVa1PWXecatETe5X/UzQbrJsMGkaZNmvXnyPo4CbmWTpSQ45Tzon0tq6cBtxILHRY7sIr5PriHWzcPo7WwvlIC/IZwHdsW4zcUM2L2wEL46arnDpgvXddx2sqF8utFdA6MgCxAcjlsQJtYKnU/BkIsRhqwRj4/EtEjfx+FZgy3bUbfPoFybo+15cptTiKFaJZHXEzPVtlkc9OrWC2jFXWeMmxOVyxJIVaqTxFHLouqdrdPa6sN3vVownvmQaGhoaVgx27NiByy67DI8//jiOOuoonHTSScva3le/+lX8+Z//Oa655hp/7cd//Md/5HZf9KIX4Wd/9md/1O7tMVjZFgoybR2iAJZrQeVJWUQhspY0C8RJa0gAVNtbK7QeA9SNYFbDH7yG8wth+nBtummCq1omgmxkrf+M9nZwTvKUsdFYqhOhr7llQjWZPDgXu7DIPoZBdMiSFgFiGrjL5A7a/Mgr6mLCNglCW8yH24NG2UQdoHIfJEU7YO0VLpC6FpFSNltbMPOc88Tbq+aqo0IpOGinLJzbYpLQZ1WPe0yNTNQpFniCHZhiopl8ejAKF4xhhfCAEYrW82AVHhPhgqnKi6eBFXIqrlhcxSoChrgFMaSuRSlOAJO4rOODWgmGmutKYiGK1dF6G4g9FOSLskFsIPzKJmaJqQCALhwMjUDYF0gL4FGBGxyCfxhDCULsK6cEIrfHVYmHXoOcrBQMEbYFFouR4zIoEg2kneh7FGah6NCRZhpjFjLZx5VONC99nUzFOtFJStk67VGnPaaTqVsn5qnqoTUhCJjCrFA2HzXFllSJm1AS0XkaXtnJPZEmb5DfMtY8v+axWX1faWrjwUprMD/H70GzUDQ0NOxN2LFjB84880wcf/zxOP7447F9+/Zla+vLX/4yNm7ciO9973vYf//98da3vhXHH388/uW//Jc73e6v/uqv4sILL8TWrVvhxVpXMFY0oagg13pO1dUl5Bt2Ocg18ZyCk1WgHoieGpRsQs0IYeUAM7hYakZycTSdLj3y4jdAKrBA4zDY3zdXDADuBiOCZ5wmKIcJ3SIIm5tU1f6HTj7IhPUpai2okMvkgqTnyqLsdpXGoHKwCfV10L9MiMzVKWIySB1rRFNa1Sqhp2bRCAM9qABUO3AhJ2DSTEGhPMe0iCTZ63kFRNxKZIdNulIrU1BP1WKb8G9Ez+JdNIgePRbQY14fhVCI24otSQfClAmlVoB6oIxRmMGdxbkQpDhgIn7MYpnoa1g0EORRZpFRihYHVO26kwOw7mXWQG7y81dfX0BGyEp2CaQR17JHcuD+rDab8+QHUbaDk32LbIxm0WIVohNRhmV8MrJnnC5dawxUJq/IzhRkkCsHIaai82AZrWzho67IwD2QlVCT2AgqdWCt/GZEV/ZjBfM0xjudAqMOdVQwJRKyWRml9oAGYM+TFLPbRhXbibEAc1cSsiBcKCxjVCsKV4wqa7xWZFKrIHWXkqMD0FVCR1LAu1QCSNwDp0zDlMKIdamk6YZZ4igaGhoa9haceOKJuPjii3HRRRfh0UcfxRFHHIHvf//7y9beQw89hAMPPBAbN27ET/zET+Doo4/Go48+ihe84AV48MEHd+qc/+///T+ceOKJWFhYeIZ7u+uxogkFU0El0iwm8DgKC3vIOtCSyQRC7DThNMeVmgDXQYImRypu1QqMCrn7QHXh3PqDoeCVhGDRDgPZH8oEdHMngrqAVBdr4QJSDrjOYzBNZAEpwx26P7l4zXm0NsYigqgKHk5Mhr32iSE/pM81fTSIGYUKFawiLLm23t7nSH8FhlggUEWzXdWdw9eO7ExQN55EAwdTwtpEfCYTRrMUFJOGlR4RkQvq5AspMRX2uQj9N+KlFZdtPlXjTKhgmgopJLGMVBC6HIpNXVgnYBYK2xt2Svb5cFcm1tof7qKU9zi7a1FPsilq0VgKO6UTAPk8FVlfEfp1rpWcEIZkI6ZYrQeWcpWELHlPSNeBSDJGMYG46HrHkvHMKZUfJ2sLBq5uYe5IZLsoKaagjk6nE4Exgp1rgNgeFtcnqZIthEyvFWYR/vsePJ3omXsABdOiBI8ZRAwu4uokhEKOebNOKEkQjzpG7YWw1IGlQpI+zCkhJZZ17FjrkbDUnRgULQRjAiESsnVi/O5CCCMk7IqXhoaGhr0Fk8kEf/RHf4Q777wTH//4x5c145NhYWFBlU4iO6xatQqf/exn8Xu/93v4q7/6q6d9PmbeK8gEsMJjKJjMSqHFwKBFwPIjIgVpCNhwYT9HK8zq76zYlNdmgPkzCxPrlHR4xV5OwmE+qclCKdgi5/ePir8qGOnNP2IgMm2ZmQM9ctxE9kun/EnVFrsvP2vee/Cw1kSaCEqPyWlHBLIcSzGYPPPhFxeUktN1li4VF1M7gcZSeMYnSydrjlI8nFQhAZwGN0OfOAnCecG9/8Uze3UoGNlzltc9g5I+H/wj+26k6h1pti2ZO9E8sxe9m0qxO61PQVxT1q7YA8OZVcuOBxYXF4AjViLvTfa0o51nArL3ZJ2Mzvg5i1lKhOBRSjObU9EO3KDYBFajgSGo9gVCYArQFyUznT4Wrdpt5wQ5IeG8bxGPmW4Oao+ktYSfMwvSlgVKIwdSXYpMjISPiCXNMz+RFGgkig7VWlF7Ccjve3F7k/iZHtuox1bqsbX02FoqtpaKbVSxw1yekGpDsMVKWQrlTCpirUZMGEMLbYIwhvzWjEHy+wO1VujfQSyDfOUaJh7DAnMwbGhoaNh7cPfdd+PrX/86AOAtb3kLXvSiFy17m1dccQU2btzof5900kk47LDDntY53vzmN+O44457pru2W7GiLRTVNPpKHqoqLislNwfCQDM5I+MDgMcAiHLV9Jmhke9UezrmdGOuAJfFbk/mCuQeTZTOq5rnAVEBeYpVE5eyVWAWEWfgHx+KSWyvuPOOGwfI/DpEX4vin0nzZIKdaYyRumKKYUSBrkHBM8TnWa0E4WIFFHNbgbl1qD1EhS3zO2GVLC1NajFrQOHQTgOJZulImXQtVYueJtE+JwQhgswjYxKpG4wKp6r1LqgoVNVixRhxj7FmIRKrUPWaHWMlncQ1NPUgABpgTT2IhHCQuj2ZS1OQCNZ5JqnpoWmNPbDdEgjwkMi6SF2UGFaJBaqWVUoFSyEJ6tJlcQ5I28Z3RCxu/t82R+XIUlUjOEHnUOavVF3/ypLCdpEJLz0ju+o4PUb/bE7cvSpZJSpLXy1OhhBhHRZnUNzK5CcTUk1Wj0aDpKmANG7H4iqYq2RmqwV9JfRdBJNbMgGpO8FipSDGxCyNShwrA1wZtYrLVk7IACWVVv+lQM7tSRhkwOhkJ7m7XsxAzKSsrcaSsQVlBxFsaGho2NswnU7x0EMP4ZJLLkEpBd///vfx2GOPLVt7v/3bv41NmzbhiCOOwLp16wBIJe0DDzzwKRen+8AHPoCDDjoIN95447L1c1djRRMKBimpMM1cCNIunqtgLNq8kOuzZcI0nwMXCb37dtqWCJ9BPDowSiVQYUwgvtJiGWEX4gbyk/WJo37ECKSHafBntMJko7GTmSQdzk+LhITZNmcYVBQYi8POY8KKazcZHlPhxMI5yzA7T7WJHozb2ZT61psLjB1SVRgAIqtPlayhRD6OyuKaIp0oGBgntAlm8l66M5FNl/YlyIRl9GL35Q/rkMWeyIx0kEkh1fSjyvr1WimDYWQD7iIn9UqqWhRkZ1Cvj6QZnIoIrtKqkAdppwOIXXsej2ohMaLMgBdbNDc6krkjMu27jNEWzraQaa5l3uEEmDm9oPsMHNeKi6VM6o4UCRG4pK8QiXuPZVgiIThUdR3kpAPrhzMARMdybRkwu9XEwHrxWhYlu3D98mGIZcQIMHXp2iF9XmU/lCJZ3MQBSkgKi61jWntMGZgyYQLCAhVM1fJSSWNsIFmdpHI1685SpzpjPTrJEqfBkR8Asb86JRZBspJ6gOR6tP1p1juzyGRrrFmPkn7hCZUUDQ0NDSsZt912Gw455BD88z//My655BL8/M//PE4++eRlbfODH/wgvvjFL+K73/0uAOAP/uAP8LrXvQ6vetWrnvI5fud3fgd/8Ad/sFxd3OVY0S5PtRC4JG0hmbtQBGtLBVl1iwLcBcCQ77OhxXMxD0VdYsaQonf7MekB7M+M/SpjPwZWMWMOrFrqSC3r5IbJBYwRCCMSIjGCuFmYOwrygfAPjyCPRHp8PFYNPOkhs0sNshCaDqhWljVWZHDwTKpcK7KnBbl0jMPMQ4nOUfTZK2qbi0lRN6jSRWVtExTV/YmrFMGrPJXHKu4rXC3Fq7oNVTmsWrpXTXe3olnKZX3JFZM7ENmRisWVDqV0GJUxxmWMuTLGfmUOB9AcVtMcVmOM1RjjAIywPzqs4oIxz7pAASTqaTDbOGwM1S1phQpKN8KoG2M0GqPrxijdCKUbgcpI+xaOUW6RcDcaKfBWNVMUuKLUKsXq1A3KXKE87bAuFdt1pEeoxcnXReRrTu5pml7V3In0uhKXJ6DvgNrJ36yhKP7oxDmOQXFEikdJcRXXgxM/JY5WJDJXW8+ZoFKKKR2H7vrcdjpyDQuxfrIE4/MU8zzBNp5gCybYTFM8TlNsKj02dT02lR6bSdygFiAB0NWvQQ4XtQrdr3rdpPVwojMYY7h0TiFHTywJAViLYvJiMuFEwsfeGEVDQ8PeC2bGq1/9avzf//t/8dKXvhTf+ta3lr1WxPe+9z0cd9xxePjhhwEAL3nJS7Bx48Z9tkbFCrdQZKWmqMXt/mmZmIoSCcmYEyo70YAvFjbtDmyfJcuMAxOqBSZY2+suTOsp+qQBZpg1QDTGHWmtCxJyIS4X4fgiRCHEC5hPt77gWuUZ+wQNnieHH7dOLC1WkM+Pab3l+zVNiYivxd1lKpGmho0majo/+2MaR1qrYrNXAK4aSO9OUHBrhaQO7cWdqarG2ZXoZYnx5NaXgFs6cq9UnCML0Nees7hphYKXVPuvdgkiMKnVQQN0s0tXOJUh3Lq8bHoVNy6bD9Wc59gXJxCkhNQtM6GNt8DeqMugmZ2q68fFtUoMGHKuYop+WmIf2XpZillxW7KUdpbqeODzRoNOy5rCu4jKMe2GeE6wS9GvOdIvog7c8IRgxwnCfmEF/XhwSQ9dA5OgnvrLPBOfZCRL/7Qq7VOuWGBggYF5LlhAwRRilZyatUD3SoH8sFqLhcmJu9SdUFLOmYjHnFkGOTl3PqLi9RSMXq0jVclLxewvwhJz0dDQ0LCX4h/+4R/w6U9/Gtu2bcMZZ5yx7EHa8/PzuPXWWzGZTAAABxxwAH7qp34KF110ET71qU/hzjvvXPSdtWvX4rzzzsOBBx64rH3bHVjZhELlbNfUY1hPoUKzrKigKAKvSShJEBrcbGMDmtBl1Qnc+YcZRYVv+1wmGFl6qk4M2N0ZsquTBIOqQGlWiEXWiBTAas7VeR78U6ENNVenqL/ATiryMEUejNoU2TebAJcGvX2IUG+ZaCwKI8gE++mN7KUZ1ceC4iKgWFgig43Vc7A5r5JlE6KlLWT+4XbKomeOmJE6Qy4x+6NikrvnK1UNtQm3/jVCOLrp+IoQyFqNUKgWnVQM1BgCi/+wcGhWobxiuB7mymOEximOrn9Ue05kwtNrKenS4F4jFE5/9cIgpiATnA7dEDQjqCufUvc38jX1+az+ZkydZowygmEJBVAihicleooZJWsziF5sb4nWYW08u9jl6zy6ntZ5QKAXa/+NSA2DwMPagvR3jx5TrphWxqQSFipjoVZMiDAFKaGIfT8CaY0M0jgpTepgByRWomNSN6u44iz9awUwQZAJf85Sgbt3y0RYJ1Ls+sxv2qI/GxoaGvZKfOELX8CmTZtw5pln4uijj8Ydd9yBrVu3Lmubd955Jw444ACsXbsWpRT81m/9Fr7xjW8sSSie85zn4L/8l/+Cu+66yy0bewtWNKGoFH7C+QDM7K+CjZIKwPWtAIIQmPDuN11/OdxL7LGI/hcdV61dEAGwHZJWEpLq0Qq5iXVCq9yCMEfiRjUmsVR4Xn5zB/GumOba0rtm4RKindZHd/FJhAI8GFkM18/PQ803IklqFso9nkIPkPh8B2EKDuRC/SL2ovIjA5VEWOxQ3H++Z5KgZTZffdW8E6NnIRM9FSUVncdqEBUQa45VJrUgJD90jeQNWhi1PshcyhDzbv8bmbDPWCC7VHruwejAJPWQQVpfADVU8iAlGx0sxTEpCTDCBG9JKVxiFP50RmT2vzjGZBXFTbBVrgLLHGCcxzkrIywVzv4wIMOyF0h3hBUhNKYsc2oF27iTpsQFUee7qK9/FdLKFNr43KZk1YJmDUPs32oh1bJiAyKhsT1CKDO9cE6j+zrVQ0muTbYHPN4Aqaq1zac+9iyuZD0q+ikwHRVMSsEEElMx1T1v69hRWCBEgYA4mDyI3zI2WbV0SywB2VFYIGBCwAKABTAWmLGAigVImtppIhPVfwcASyubfxR9PzQ0NDTsAxiPx9i4cSNe97rX7VQ616eDV77ylfjIRz6CX//1X3/K33nNa16Du+66axl7teuxsgkFTBiAZpxJN1Vo+kQmL4pWmRYpqwG4EBMv0Mz7Iv2YYNchafGZUYg9rayIXypoQIK1RRcv748BrAJhDoQ5FIxRxO2JsugEzzgEbTlraKO/7IIDc/XAT3bhgkITzUm6SALq4LUB+dAaElkYpwomCRpmVUtbReIeISMONck59WgI+fJtcaGyQZMGtIuAlDTTzKjUoweDqKAnsRCVosIxiVDqaulBNHxowYNMmOCp2v9kBYgVT98H4L78AEohMHdg6sG1kx3IEnVMVF0rL1HWmjK1yFGtkjN4aD1KBCJmz2hMWJBmZGffH04BdTqtloON2eaSapCJonsqMhaRfj+yf7FbCQqq2iuq+jGZcceGUDtdyhJJTBla24HMfczmmvw6c+LOkcFK5qTYhavjjFQKdgVSibkpFU6onaw4qbMjkjjYqY1QyN5lj8Wo6FFZYl4s7oUIKBMp1GgmUtasT7aXRHkg13UQCB5YKUZmndCLo9e2gbBOSOpZcXVaYGCBhEhM2AhFkCDb+p66GvBEB0GSGqNoaGjY+3HDDTfgBS94Ab773e/ik5/8JC6//HKcc845u7QPf/zHf4zPfvazePvb375L292dWNlB2ZghFcDgBmr1C1yoIiMe0IDLCHz04MwZsQ4I0c4eTadstQxGLMRgDuRkYRUIq9iIw9LHGOL6FDnls1UEqTX7LypS5GxNIZyafz5bnkqZIcuY4ypKHh5qCcgzKgHDoucvXruigrgHcS8Bv9yLpSYFbg+fI/WRzAgQGn+PG5Hg6A7kNQGKBqp7FEJVa4UGHnsQMvcekGs1B5BWysZnr3sQMaf6JErAQoMbQunQ0kMRKEwdQCOgjCVouoxA3RjUjVHKHEo3h64boytz6Owz1AFUnDRGED0v6me4RclBg9dtbKFxtyDn0MDTQAC383oNkp5BPaNUPXoRyKWAnu3D+CcZowoKF3XVIQn07q3+BcvzHpIuNs2dXYF+XQ52X8QMSZIFC+S2IPGSgsVlDw0CqYusB1Hx50EclMxRCdJEue34HzQknB7DIxXpQFX2fNdXdNOKkR5dX2MOYZZIGlgjLCC+q1YzxFwkg7j1EBIxD2AHMbZTjQNVqrOzkgmumLKltLXtLq5tzhyNp/s+V2LX0NDQsJdjYWEB9957L84//3zcf//9yx6v8IEPfACveMUrcOedd+Id73gH3vGOd+D+++/HKaecgg996EMoRUTtV7/61Xjf+963rH3ZnVjhFgoVAGioZQRMpBzqNO3eG0Gg6WQmpCXldtZRM0KIy18Tvbim5zThCFqEjKJmQ7ZQzGnWKIul6FQYqPodc5GP/g3rYkieGsCsEZbnftbtaUCOOP7y8zAQFSVMoFZhXAlMYXEtE0JCsFoRieWIpUG/WZJMUyllA9WWOZ7K+cjGo6PyiN/i4qf3i80ZBUIqSmi7o4I2p6Bt8qDeAZlAuDxZ4HnRz4XMNSt8mda9aNfT7igELxgIsViRCXgu2EoMCJHF1WhMTl6ztPdi5bRjbOuF4Yc8nXBUXsgCuwvMIN8XtseKft8FbTKXm9jx8szqnWtEhUvl0YLPp1mvkuBuwu3guvOA9DTT3i8acioioBYV8OFt+pVoblri2wiuca1XiIVycNGmWXEyYdPMs2RC6oZIMHWVInNTkuxxRKhU0BcGl4iXGJESLo6MaV214oPDbFu2r6ZkgdgSIzEPxgJpEDaJJcKyOYlloiZCGuRtGLjvV9Dgsw0NDQ17O2qt+OhHP4rXv/71eN7znocTTzxx2Wo+/PIv/zK2bt2KL33pS/jIRz4CAHjBC16A17/+9Tj77LPxhS98ATfffDNe/OIX481vfjOuv/567NixY1n6sjuxogmFkYmhxnMgtkK09BJByuRh0y48ek2uJMyZPDU4DyXBx/8gFSDja/Y4IqSAzaj5EBaKkiwUgd5kRTLBONxxPFUrpyBmQEmFfN7rEzg5yO488rc57/j4VMimGZZF2o/4rJEKORexVSrmoebXhHNYlQZSQTULupQEnBR4TBayzQNNsVhZ5AzMvRczVP8YqQ9RjEcUz1DkcRb+3ViPCtZ5Jo3R5pn9k4SwQf9tDqwAmuqaVZqzWiOe4tTdbFg17MHJXFDn4UohPwsp2oXGwSc8MH0gJvve8C+nPS1FHy1uB5rSlcTtzIKqbW3Ivm4TzNCUW753sqWQYOma83z5pkhUIC6czH9lXcyFi8BcwFSBSqqRt/gJAJzcswqhVlts+X4H5S7K+4iS0mGGxLGtuKbhZZaaIaVWdLYjWeJ/mNTtCQwuEstVmNCRVrnWY1SBUQ+MepbDrDkcW5f1d2JKUl17gaRA3ry6NWULQ8/DeA/fnrY3kMcz/LcoJr6hoaFhL0ff93j1q1+NK6+8Ehs2bMDCwkK6L/7oGI/HICJccskluPTSS/313/zN38Q3v/lNXHbZZbj22mtxwgknAAAefPBBvOIVr3jG2t+TsLIJxRKxDqTiStQlCCGKYVl45NMF8GQ/WZSz7DdwoXzYigg/YY0AiXBWCBjrY4WQih6ajx7qOw1gFSwgW9x8ssf+QLpRIVdyBUWchmeUUhIRwqn1cFYoDlHV60ZwCr5OFxcxe6o1UyIPEmsmCwIQ3vumH7fgbYJlCBLhkizrkAt7Q32pCZgmGod7DGtAup5RfTwqevRqymFicFHNrwqPoiTPDmS6WpxnKc8RZtZg8SsDDGV8eJYoe+5ZnihIISVSBE3FSjVplaO/Tn1V0vZQC11Z0sWJayCc4eQ7Vc0wsbll3YNyMEjiQTQVbyWbQFZrim0A0rUZkhI7Ua01WVok7oHUIiOFAo2saEwPp7karD97e9ViQNj2lLp0VXtNCXRK1coAClWJD1EXpMriNmfWA98TlAZg10EmE1UOqj262oubGFjiNHRnW/rXUkj3uARhzxEwV4Fxz5jrgfGkYjxhjCeM0ZQx6i3eQ3pQIdfIPOBkYocTimSJYCXunK2xNOOWp4TWrtk0ybPJGRoaGhr2drzlLW/BmWeeiY9//ON4+OGH8apXvQrf+ta3npFzH3300bj55puxevXqJd///Oc/jyOPPBJ33333M9Leno4VTSiSyBbZY1iEpg4U/spZ4PVvinSbXQSG+mH4p10zn940Qc6FSRWYQITOXXHUWYTUbx0y4R2rm9NMe7Piq/XN+u9F5ZIm0t3uoZpwJwQcmlwVYK3WQc59H775psWdIWkUn0u0A24OQfq+CnjmvmMCKQHq1k5pHk2wjRURY0fMS8QBhCDlS2fuT5a6FHJ+KqKXJkgAd7gEWc8Xi7HSEbNmsIn7+gn2b80SDovRyVTOyI8XJEzSPCViAeMcSsCM7JjQbZp+J44u8kZzPNiTyqI4T2+sTRCqGIGco0jMApO4C0HiFWw93JpgBI0IErNgp2bNUqSdRgVz0VAGtUyVEgkFjFRYcDiQ3NLy/EYAv6XidSLK0BS0MZie4NcaIJanwmJt6VDUJZElq5iTrmgv3JxSEHbtgVo1JqT62nFPau2sss4do9eMWQXAmIBRFeLQTcU60fUVpa9SiDG5JZpCoIcVrJNjAZLRqTcykY7BPuBYU6Q4Jvvd0JQBsz9fDQ0NDfsEtm/fjq985Sv4pV/6JXz605/2eIZnAqUUPOtZz8Kv/Mqv4Gtf+9qi96fTKTZv3gxAKmmvW7fuGWt7T8QKJxQhIAMmhpjQzVoBIJEN/1AIiXEuE2iHL2ZXeX/LrByuyacgFaUMBWlIjQAjF4WRitgFTFRYRCpgghcNBLCBcKD9ZOvSQGjkgUY2EzAvTKfSCbGRgCzhZRoRQp2/5xYLe6m6GxGRBNlSLhwxkMwXa0xDBCdPDRo65CKSpAr+OaaCqgiwVDuUohSKITuAhuf3eSDrhY43EwQOUiHthWANbd66scTJB0Nj21z63iISaXOYCKH95IUtSOcgzDwDUTPaVCpmEmd2eUp/k/5fUdVSJ7uikpHMHH+Sxp6Isz1n823SghMiakvpQiriflbTHBDcEBLrnefL1oQswkddoCjIsmcSUyJIDM0CxrEHfU6qj0cCzNMCOGXVJLFajd2qjVMVEsDmckeMEQG1r5q9qwJ9h77nGUIBd28iIxJ6SIKBROpgbkxCjKQWRbg6mXUiz5PXwPENGa+TkoqOoJYZTsSvoaGhYd/C/fffjyuvvBLMjFNOOQWTyQR/93d/9yOd85hjjsFpp50GAPjyl7+MBx54YMnPTSYT/Pmf/zlOPfVUPPzww7jyyit/pHb3ZKxoQmFZgIweiOZPHjswRsyDeAMJwOWBuk4EmhT0rELIQJh08YvcMmEVuHOWHZTINqPe1frdinANGmqJTXjKWaqgfcKMwJVdYxbJ4hQyJaezk2l1VYPtnv0mICXBmdIx0IKaWB8vyPmYJZUsu8OIiEAmbVuQtWefKQOhPGYBA/Lmsredl6AzZ1+pcL98BsC9Bo6rhaIyqHRKagBwicxSaa5ifQGzTMg5bTViX1nHsvUAg0cZY5CUmQ8AyUJhjkvZ1YrDuqSaddu3ySHHwqJDGE0pcmnQKzL53kVmq6rt00gaDM+IAHfrYzE3szKcsLzf82EZtlSA16sEAKOoH1qu/m4xDZbqtdikkax3LXpdUqar4goFJiWtweqEYAi9JLVS2Gti9ZK0t4XNKdLGxD73lS1rmFopqmY6Y7NGSVsV+sNJZqGoYM0ZXUhcHcUqIdm0Ss9ArepOxTmXml9rXljPiETejzZnTirY+VtOk2tuYKJEYXfzqpDH/hn0G25oaGhYSWBmbNq0Ce973/tw2GGH4d3vfrdbD54unvWsZ+GXf/mX8Ru/8RvYtGkTan3iCLVt27bhzDPPxFe/+lV8/etfx0UXXbSzQ9jjsaIJhaRbVbGLjRiEe1AuNGewAFzzv84aZ3MQylrZgcAIhE84lJdYVhsTmkpBpJVJgjiLr7wlSaomn1AW/+WZC9aI1KukgnmQEErfy1r8LG6ajEaDicjaYJo9TANOpuFPzjZJOw5UVCqoXEOjakIZNO6hVDA6F8RNpC/m/x9njr7a2qQOGgliretg6YjYBH/V8Nc6AdBJAK8TlRFKgZMKsrXV83oYM9kca0k8dxsJIRvKjWw3yE9I5LFy4mejMR5lwc96LssAVnWNLbOQcLToG2CF9GAb1tsYzlqspX/TI62DTNRUqpp1X4o7jBFqEZAj4FmFVA9k1nXz/S1jr1WiCkSgNbJnlxFpwHxY9QhaPRpmTaSwlmlblSXhgmVT6iGae8uaRtC0z5zzF7Ffl7Y0xUNJTJCvSkhIx6+F67hH5WkiFJIu1ixhRX8fJNsTxNWul/52PcDTuCpHxBhXeGpertKGV0rXq5J1HwAaa0VBIgozRkr2gJTRKpgkfBsokfCq6ZoKobBkHCt6bZZGKBoaGvZRPPbYY3je856HG2+8Eeeccw5OO+00HHXUUTt1rr/927/Fcccdh9tuuw3HHnss+r7/od859dRTn9Fg8D0RK7oOheV8t5gEyftuf+dc74tdjFwxbf/URaKqvGqHuXVI0DVF/AGZSAAXHN1dnyjcXNw1RCtGKCGxTC1RnTfqKJBZVhh+mPQQzhk5rz/P9HnYth/IhMTEr3jB58c/kNKaam2BiJKFC6tWB6LnHv2gLgT7gWruI6luhY1xsB7psHGAfB0KEYoWh7P1MK0+c9So6OtU61RU1/YOXcqWgDWFiDOxmBV7HrUxtBIJDQ8jLcnDyRYv4lEozhOxP0GMcm8lDSsPsmhZmuScBteES7IgZCoaOxDHCJ3/k+dSU8Ljc9hqJcTjbNYwqU7PWhsCWjU81VZngFUbz+reY/vHalz4dYtInTziIpmRKmGuQoKZe2CuJ4x7YFzlvVEtkW7Zrg+o+x6HQsDdskpKi7vEP6kw3qNH7/vXhPLYMUaow6jhSgsW96ZxBeYqYa6Xv0vP6iolcRALYCxQlYDrwlgoFQtFMjpNiNFTBFoTC8kaVWDMhDkmOXcljFleG+n7nV9HUYMl9oURSU5kpqGhoWHfRN/3+JVf+RX89//+33H44YfjxhtvxIYNG572eUop+MQnPoEzzjjjKZEJa/vJLBl7A54WoXj/+9+Pl770pVizZg0OOuggvOENb8Btt902+Mzb3vY2F8DtOPHEEwefmZ+fx3nnnYf169dj9erV+IVf+AXcd999O9V5E/ZM2+nPmQZkwvXjZJrTbBNACG12aHEt6BGkImvy5dtZWHXvnpCDg8okob5STrUpQq8LLYlImOBtuvSBC8sSAnKMdRB6jWynyS4wXlUbHCEEqR/Dg/25fSZrwEP8GohhyH78AyKh40pLASNdEdQMFxBpQC6KC405RmSW4NjzyrmRxdr9gZVhZgbzEXzNiIP0JcjEcNeliFn4pOYV4ZQYgDEUBtMc+t7KaU/z/A5iI9Sqo+TLCjB21A2OQp28b4L+gOixFrqzAOLUL4ISi7RWZtmwvlUjnlVJBcJlx/rnxCwpBvQY1agyLWQiCdIcSoQO5DUdCqBkPIhbTLb220jR4J8WSsw0nePqyr8UecfkvkdFbKCr7PPGzJiiYkKM+RLHDn1cKEIopppZyy0UgBIt+Jhj7JG9jtL6AGah4EUKix687C5Pe9r9oaGhoWEWt956Kz7/+c/jsssuwwknnIBVq1Y95e8ecMABOP/887F+/Xrcd999+Pa3v72MPV15eFqE4rrrrsM555yDG2+8EVdddRWm0ylOPfVUbN26dfC50047DQ888IAfs0EoF1xwAa644gpcfvnluP7667FlyxacfvrpT5npGQZkgmcODIVDE2IAhPDp2l91s3BSQTMaf0oSYNbkJ7FP33cyoZ+y4N+lgrArsVeyNSEmWyg69S13IZ5ZXUIW/5PGZoVtjekw6wgIqjR2X+5MAAadS77ZlpHH5eFEPBIPSocKmul0A2uHV9dGCH86VwNh2ebfkCwt8PElUgG4RrZnc2UJa0l1wYt9fCn570DQLeaaNKCj8B6m1fVP+POZ/ZLXbLB/0nmdyMHmNfaFZemZpUTD5/G/bwcX2AuKE4mRk4mOxErhlh4V+rtE+Dy9qZKD7GIU10YZ7DWTW5k5iEVNJNWuCRMqE7EoHEXhukpyJGF6vEi4js+XygNy4ZZEvzblWh9QCe61SJyRCiUWtJgcW80bv75NyWDEgqOYXdFxV0jWpvlShUh0jO1dxfaOsaNUJxaZVOiW0XPNjjV+47LFkNOe6WEF8ComkNoWlj1qObGn3R8aGhoalsK1116L//yf/zMA4LDDDsOaNWt+6HdWr16NY445Bv/tv/03AOJC1TDE04qh+NKXvjT4+xOf+AQOOugg3HzzzXjlK1/pr69atQqHHHLIkufYtGkTPvaxj+HTn/40TjnlFADA//k//weHH344rr76avybf/NvnnJ/Or3pGpYS/OydoStQvDcQxoH4HELrygzPJBNq/BlJ2psyUVP+H+ptVWSmUNozIlYhk6BsXyjx9YR03qEqFhZ4bnEX9m5UiXaJz9uqgzP4N5KCnXxMHsfgfUoe/xZTMqu1TpKuRUSAhu1ZrDxzjFWGQvF9ipmVfhRYUT9xbDfLizm5FykcWCgyYWmLVil6ZvaWIBHSPnvaI4bHGehKSBd1fX3OklCq78tzZ7S6HTVWIpM0zVRlcRZWG2S2iGIOFmbALWe21jZP+u3YKtD8WNrdqn73ZlQoml+K1cVJeIOem4JAcSFQLQB1AAGFQrjV8u3ySJKBSciEDjCtu8c1Wfd0/8MIiL5XARQubo0gZlQm1EromTAo30Z5J8v69ZyLQrK6Ok3VmpXdnaqvmwWHg6O2hu1xogIq5vJm1hIZvxHaCTHmidGTzHcpjDlizFXCqDLGLC5mZPOFiAUjwMfOLJmgfI/DgryFPE9QsYCKBTAmWsfCalkYwVhO7Gn3h4aGhoYfhuuvvx4XXnghPvjBDz7p584880x89KMfBQCccsop+M53vrMrurei8CPFUGzatAkAFuXWvfbaa3HQQQfh6KOPxtlnn42HHnrI37v55psxmUxw6qmn+muHHnoojj32WNxwww1LtjM/P4/HH398cACSDjEfRQ8TY+WGPKMNJROy4K97sKuLmkjCorlKhIvSwJqAoeCZH8M3nQZBqEMhx86ZNM0qlLjryQzZyMrv1FUda9GjEyGvFElvqbMiIrcF3sbrIiRpVWss1tsPRskxTvHXV9ea0oFK531wC8KQCSEzMCN/AxKYOIhr5u1R37c0p1k7bnEqUMHdsvb0VY7qvv1eHc3dcHyvcOqvEUoauqjZP3GfSe8RLXGkvaOf7RGvLbKN6EC5ina/1nDhsjazRSm06Jzcu3p383Ly6Ps/MpGRu2npiBmQVKka82BVnc2Fp0b9BLuARKDuUEqHroxQygiFLGGzjaUK2esZ6BkWM89pznoCeiI5QDpHkRIAoHQtmdWiYMQdRtxhzEVjGCzmQtO2uguUWR8tXsFc4qaDg7lXS0xyO7N1NOKjsRkomtGtFHRapNJjG3oG6X6bokr8RMfYPmJsHTG2jBlb9PnWjrG9SHzFAlW1VPDMXqvqtlTRmxsVV0zQYwE95lGxAz12kBzbqcd2jdmYJ43VwK7Frro/AE98j2hoaGhYCvfddx+OOuoo3HfffbjoootwxRVX/NDvPPzwwzjqqKNwxx137IIerjzsNKFgZrzzne/ESSedhGOPPdZff+1rX4s/+ZM/wTXXXIMPfvCD+MY3voGTTz4Z8/PzAKTs+NzcHA488MDB+Q4++GA8+OCDS7b1/ve/H2vXrvXj8MMPBxDae3MLyhp9F9MSP3DXI3LxzYXieES4f6gWPVwlZnLDYyAKDvpjgaI5haMHkDrJ0TOE2thmFyZ0x9iGpALebnom1eOEGJj7SfJzj3JXccBdoop/TwQoJRcUhCOfL4/cg4CJ0JEIWBY07WlIB+NbmhpFVql42TTL2aM9GU1i/nTsEsMgX2TmFJitLi01B4vn6Sa1xqjWXMmXEYJsl7Kg6EwUrH5Ar3NW8UTkgpRURIB+pjS+ltp/OyyD1mysStAJscpYPM4g9xEhraER6EQwnMzA3Z4WuRBWEeadTCaCUoqQyVIKumLxGcWvp/Czq+r6xDq+mM/eSQUwtb8RbnlugfHrweIXihALCKkYa3D3qKrrUd5Tvobm9mR7Qg5OLl1IcydkglAtCF1/TKhIpXGzTgjR0RgKLYhXNPUsQ+IYpsSYFGC+ADssloIiONtck3qaOTB0ZZomi4RYInoJ+IZU2d4BCQK3c/Y6z7sKu/L+ADzxPaKhoaFhKUynU9x555143/veh7//+79/0t+MX/u1X8O///f/Hn3f484778TCwsIu7OnKwU6njT333HPx7W9/G9dff/3g9TPOOMOfH3vssXjJS16CI444Al/84hfxpje96QnPFxWeF+Oiiy7CO9/5Tv/78ccfx+GHH67WCIG4JCzWhXsxtlA6g4nEvcOJgxGRofuLdmwowBIPhDq1d8T3kgAjH48gUTtzVd8b17yzdSydxAgNjPW5o1Aadeqpu2zFe+ICIwXBwKHlJ/8e++cWTVx6z111XDmtgi/BiYOxAMumAxr2k5XE+WvZEJAb52Hb8bK4ynB6n+y8Pm8+mTCJVbJnQVKbUkV18dl035TGLt/j9JgqXgADIkH+3HtDQQlmZ9IInRMUO6m7P+VFUJGW47m0GEX6ZjUBHkTsLk/Wpi/NkGHrohghtNoM5n5l4SbMluBA2iicyI+RESLhpNZnrQVSLW4FcPcnI+nJgCHF9Mj2SJ41W3n4rNrppN/mrGdxG53PW4VUUacSqXHduqVui5YVjDnIRA5wT9MUPSF4sgZ3dypKpiFZl0iL2VWuKKgoVCGBSEFA2eaMpY9F3cI6i+liKUxnLm+AxgZplIfER6SDlFyQxk2QZJbqwf4bsyvzi+zK+wPwxPeIhoaGhifDpZdeiqOOOgr/9t/+W/z0T/80brnlFo/XKqXgp37qp3D22WfjyCOPxMaNG3dzb/ds7BShOO+88/AXf/EX+Ou//ms8//nPf9LPbtiwAUcccYSbiA455BAsLCzg0UcfHWihHnroIbz85S9f8hyrVq16gkj8WdFtRi6m8HU3rSpIZBnzdyeigXXDXGBM4GNVdy+pEdZmsnBHyIHG7BmbUtgGClTjCSSBNAiEFSvLYo0IdDKG6i2FNj0CoY1YYPgp01IjBKus9QWQxqhjJoigZUJYIgk2r25t8fmVMxo/EmFONPZGRFxTntZmiExmhq9Z1+0VgpENaLshflosRa0AyhR9Fa2yC8G2XoO2KVGKGflbj6hkHK5LQdCSi50TkxlSASka52SIyAVjK9oXVgf2jkgMQnbq03gEWxuOngZxk/lebCeK14rPgM279o+LumCZRJ2cCZNFKFvOJG+AbHiCVJu2YHiJEVBiBNa+yRedp9i1oodRotjZ3pKTCmHxQ8IthE/cgySaRia7QjrJ5h5m1gk7ZkhFxL7ACRAVIRLUDd2dJDsVo0wr+l4rbqPHpFSMYVYC0joe2brFmMqPD5i0doRaJex3BGAlxGKdmJpVAil2Qt2bxMIBTO1qThx7V2BX3x+AJ7tHNDQ0NDw5mBnHHHMMbr75Zhx00EF45JFHAAD77bcfbrrpJozHY3z0ox/Fr/3ar+3mnu7ZeFouT8yMc889F5/73OdwzTXX4Mgjj/yh33nkkUdw7733eq7f448/HuPxGFdddZV/5oEHHsCtt976pDeMJfuDrKtO8Q/27kwAdY6tkOxQxdNPivtEuDvltIyWMrMy683cMsNEGx7zoC4O5vLQ1YoRM0ZgjJkxBmMMpIMwIkKXXIRMwBpkmkIIt+Hrr2Nn1SjD/P1VE17ETaMnkudEqKXIQQVcOnDp4rVSUEuHvhT0pcO0FEztseswTe9xiRiJDgUjsvoAqU4AdFzQsRmpyBYO5HiTiBvJ6TAXBcqCh1l4Ug5/D5b13SAFyrj2qHWqtQY0A5Sf1YQ7q7MQbkxTiD//lOSYqKBm2XMmbL7sphkGJkR+TEtB73MeLmTmj28uNFyUEKaYF08rbK44LvxW17I70tQaYUpmicw/B1eMuOuIm9KojDGmMcY0wpg6XUtzKRK3Ijs6yR2l8TN2noKuFIxKh5Fmk+qoQ4Gp5hnoK9BXUB+Cu1kp8rxLQTuzAFkcAVJmNhustkvibjUiOXL/I70sObEPd7jk8pRdstLsxrVE4K6AuwKMOpSuoOs6dMXiJxijyhj1FXPT3o9Vkx77T3rsP6nYf1qx35QxVxlzrGlmVQHBTi4kqNqOBeTDYiZ6iZlAxEtsI4vDkL1p1wT8N28xdX8msafdHxoaGhqeCt773vfiNa95DUopuP322/HGN75x8P4b3/jGgQW0YWk8LQvFOeecgz/90z/FF77wBaxZs8Z9WteuXYv9998fW7ZswcUXX4x/9+/+HTZs2IC7774b7373u7F+/XpfoLVr1+JXf/VX8a53vQvPfe5zsW7dOlx44YU47rjjPKvHU4X78+sN2X1yXFAx4UA0qZbRx9xvgJl4i4G63jSUZjUIH3VzLwm3C6hm1eoqhMvTbMVugrkxmBZb+hxWA7gloA6+Z446eQJMgypfdouAWhdsXoigFoJogoncHaUk9WWmYO6eYRYT1aiT6pjz/Nlz+4sGz8yiYYSJQtvrY5lVn/Lg0a04xNofhJeYaugH+vfsQobQSBeuqFRBTKoBlrUsidxEr+MPIy+i7VYSwqIJZi6Q6tzJeYhi7m39YhAQVzRvaEbQI7MQxLSI+wzNfKz4PJgVY9EKGH9L340x2mfM2Y9BJM6ANX3PhNEOal3xOB09C0ELxcv5WLNDOVngCPOXQVclo1WIKWwfc1wg+tQyPQFyfWWXvnhqfZCx+E8ALIxdCQSZ9YP9euZaI2g8xXcIgqQasaciVi6UAnSdWCqIUqyJKBG4l/NWVMxRxUT7JF+TKvNiuaSBS6S0x+n3LK5I9hgKxpSEyC6QZXUSK8cUds3q2rGRdatks3zY0+4PDQ0NDU8F27Ztw8aNG/G2t70NH/7wh/Gf/tN/whvf+EaMRiOMRiNs2rQJW7Zs2d3d3OPxtAjF//7f/xsA8HM/93OD1z/xiU/gbW97G7quwy233IJPfepTeOyxx7Bhwwa8+tWvxp/92Z8N8vz+4R/+IUajEX7xF38R27dvx7/+1/8af/zHf4yu655W513kJEAzMqqAHnEOmSCQkgNK7iaZTPhN3GU/1nAG14UrqQgSYC4nZDlJ003bBKJcFM1ez7Kh+Tgz4EKauSYJqaBBH5cSCyJQl4Jk2Lk0ONx86oc2myA4dqaq7VdY0PCwTRNsl0rZq7M2WCPzz2cXW+M7Aw5nI08CHSjEICNOpGlxnWroWip1jF4QDTT5RiqIq7jqqJBZlCCU1B/vAnkrnpGrspEKeV6pAhz+OsaZIshfT6VEAku04/75vi5KKvTdqIgdK21jlHMPZzOyVQWxyPA9yGY50j2iArglYGVECmNWa4SRXWMrRqBlbeS1AiEdkpjA1kFHzsODjRjnIaQ1tR20eN+n/UTRfkTIkMbM2Ck55pKjHoW7ljnhsRUa/sZ4Ab9ShFgQacpYqzZuVkoGV6le3Zl1EkKESVPeVoo+udVEx2FkKF+p4FxjQjM+WbC2WjV6ijWz+TMyS74nlg972v2hoaGh4aniBz/4AT796U/j9NNPx8/+7M/iFa94Bfq+x9VXX40f/OAHu7t7KwLEcadfMdi0aROe85zn4KLnvhT7l5HcLGv4aMNSg6LCs9pYNiMTCgC4jpaHAgfAHjthbhdWLG3KfQSagtDRGCNNm0nUDWIyLFXsCFJhW3WxYMTN36rYupjIJsSZBUS+N+KhUGAaSMvEVNWtybWpNlkcQkuxwliquRx5OyZvsgszjKSJRwj1xFFIUIJQh3UyLGbCssr0iAw+Vlm5liWEQx62H1V+teCg95F8XuJ78sSyFEHTm5pPvFMt6tCVMUoZo+tGmua08yw9tnbwtuCExjTolrrTdN+ydpI+FChASVprSrVEWHebnt909osnQWolTDWlqfj09+i4uhuZuPh06NB5LIjsCRM+5bVwS5JeWGpcGx/NtKwrEMSF1Be/ANNC6DtC3wHTztZQpGJPKVslJSz3FbVWT9c7rVYJQSkfFZRuBFL3Ie4I3ClJ0YuAektTC3iFdiddKiYny0BXoW6G4cQmwcu9Zt+SvyfcY8pTTOsEfb+A6XQH+n6KWqeeBaymebB0tpUgNTdKQTceYzTqULoxxmWEOXQYV0Y3qRhNpujmJ8B0gmntMWXNvlSASSFMC2FK4loYoj7UpbJ6cDj3Q6sJa4avnntMWVyfLKPTRFPCThKhsN81qdVD6nbGuKf2eOyxx7B27dpFu29vgt0jGhoaGp4uPvrRj+LNb34ztm3bhh/7sR/DZLKrk27vXuzsPWJFEor77ruvZfBoaGho2Ance++9PzRYeqXjrrvuwgtf+MLd3Y2GhoaGFYedvUesSEJRa8Vtt92Gn/iJn8C9996LZz/72bu7S7sFlhqxzcG+PQdAmwegzQHw5HPAzNi8eTMOPfRQlPIj1TTd4/HYY4/hwAMPxD333LPXW2OeDO2aaHMAtDkA2hwYlvMesdN1KHYnSik47LDDAADPfvaz9+nNAbQ5ANocGNo8tDkAnngO9hXh2m6Ga9eu3ef3AtCuCaDNAdDmAGhzYFiOe8TeraZqaGhoaGhoaGhoaFhWNELR0NDQ0NDQ0NDQ0LDTWLGEYtWqVXjve9+7T1dHbXPQ5sDQ5qHNAdDmwNDmQdDmoc0B0OYAaHNgWM55WJFB2Q0NDQ0NDQ0NDQ0NewZWrIWioaGhoaGhoaGhoWH3oxGKhoaGhoaGhoaGhoadRiMUDQ0NDQ0NDQ0NDQ07jUYoGhoaGhoaGhoaGhp2GiuSUPyv//W/cOSRR2K//fbD8ccfj7/5m7/Z3V1aNlx88cUgosFxyCGH+PvMjIsvvhiHHnoo9t9/f/zcz/0cvvOd7+zGHj8z+Ou//mu87nWvw6GHHgoiwuc///nB+09l3PPz8zjvvPOwfv16rF69Gr/wC7+A++67bxeO4kfDD5uDt73tbYv2xoknnjj4zEqfg/e///146UtfijVr1uCggw7CG97wBtx2222Dz+zte+GpzMG+sBeeDto9Yu++R7T7Q7s/AO3+AOxZ94cVRyj+7M/+DBdccAHe8573YOPGjXjFK16B1772tbjnnnt2d9eWDT/5kz+JBx54wI9bbrnF3/v93/99fOhDH8KHP/xhfOMb38AhhxyC17zmNdi8efNu7PGPjq1bt+LFL34xPvzhDy/5/lMZ9wUXXIArrrgCl19+Oa6//nps2bIFp59+Ovq+31XD+JHww+YAAE477bTB3rjyyisH76/0Objuuutwzjnn4MYbb8RVV12F6XSKU089FVu3bvXP7O174anMAbD374WninaP2PvvEe3+0O4PQLs/AHvY/YFXGP7Vv/pX/Pa3v33w2jHHHMO/+Zu/uZt6tLx473vfyy9+8YuXfK/Wyocccgh/4AMf8Nd27NjBa9eu5Y985CO7qIfLDwB8xRVX+N9PZdyPPfYYj8djvvzyy/0z999/P5dS+Etf+tIu6/szhdk5YGY+66yz+PWvf/0TfmdvmwNm5oceeogB8HXXXcfM++ZemJ0D5n1zLzwR2j0isC/cI9r9od0fDO3+sHvvDyvKQrGwsICbb74Zp5566uD1U089FTfccMNu6tXy44477sChhx6KI488EmeeeSbuuusuAMD3vvc9PPjgg4P5WLVqFV71qlft1fPxVMZ98803YzKZDD5z6KGH4thjj92r5ubaa6/FQQcdhKOPPhpnn302HnroIX9vb5yDTZs2AQDWrVsHYN/cC7NzYNjX9sJSaPeIdo/YF38Tngj72m9Cuz/s3vvDiiIUDz/8MPq+x8EHHzx4/eCDD8aDDz64m3q1vDjhhBPwqU99Cl/+8pfxR3/0R3jwwQfx8pe/HI888oiPeV+aDwBPadwPPvgg5ubmcOCBBz7hZ1Y6Xvva1+JP/uRPcM011+CDH/wgvvGNb+Dkk0/G/Pw8gL1vDpgZ73znO3HSSSfh2GOPBbDv7YWl5gDY9/bCE6HdI9o9Yl/7TXgi7Gu/Ce3+sPvvD6NnZhi7FkQ0+JuZF722t+C1r32tPz/uuOPwspe9DC984QvxyU9+0oNq9qX5yNiZce9Nc3PGGWf482OPPRYveclLcMQRR+CLX/wi3vSmNz3h91bqHJx77rn49re/jeuvv37Re/vKXniiOdjX9sIPw770m9juEUtjX/lNeCLsa78J7f6w++8PK8pCsX79enRdt4gxPfTQQ4sY6N6K1atX47jjjsMdd9zhmTz2tfl4KuM+5JBDsLCwgEcfffQJP7O3YcOGDTjiiCNwxx13ANi75uC8887DX/zFX+BrX/sanv/85/vr+9JeeKI5WAp78154MrR7RLtH7Eu/CU8He/NvQrs/7Bn3hxVFKObm5nD88cfjqquuGrx+1VVX4eUvf/lu6tWuxfz8PL773e9iw4YNOPLII3HIIYcM5mNhYQHXXXfdXj0fT2Xcxx9/PMbj8eAzDzzwAG699da9dm4eeeQR3HvvvdiwYQOAvWMOmBnnnnsuPve5z+Gaa67BkUceOXh/X9gLP2wOlsLeuBeeCto9ot0j9oXfhJ3B3vib0O4Pe9j94SmHb+8huPzyy3k8HvPHPvYx/vu//3u+4IILePXq1Xz33Xfv7q4tC971rnfxtddey3fddRffeOONfPrpp/OaNWt8vB/4wAd47dq1/LnPfY5vueUWfstb3sIbNmzgxx9/fDf3/EfD5s2beePGjbxx40YGwB/60Id448aN/E//9E/M/NTG/fa3v52f//zn89VXX83f+ta3+OSTT+YXv/jFPJ1Od9ewnhaebA42b97M73rXu/iGG27g733ve/y1r32NX/ayl/Fhhx22V83BO97xDl67di1fe+21/MADD/ixbds2/8zevhd+2BzsK3vhqaLdI/b+e0S7P7T7A3O7PzDvWfeHFUcomJn/5//8n3zEEUfw3Nwc/8zP/MwgPdbehjPOOIM3bNjA4/GYDz30UH7Tm97E3/nOd/z9Wiu/973v5UMOOYRXrVrFr3zlK/mWW27ZjT1+ZvC1r32NASw6zjrrLGZ+auPevn07n3vuubxu3Tref//9+fTTT+d77rlnN4xm5/Bkc7Bt2zY+9dRT+XnPex6Px2P+sR/7MT7rrLMWjW+lz8FS4wfAn/jEJ/wze/te+GFzsK/shaeDdo/Yu+8R7f7Q7g/M7f7AvGfdH0g71NDQ0NDQ0NDQ0NDQ8LSxomIoGhoaGhoaGhoaGhr2LDRC0dDQ0NDQ0NDQ0NCw02iEoqGhoaGhoaGhoaFhp9EIRUNDQ0NDQ0NDQ0PDTqMRioaGhoaGhoaGhoaGnUYjFA0NDQ0NDQ0NDQ0NO41GKBoaGhoaGhoaGhoadhqNUDQ0NDQ0NDQ0NDQ07DQaoWhoaGhoaGhoaGho2Gk0QtHQ0NDQ0NDQ0NDQsNNohKKhoaGhoaGhoaGhYafRCEVDQ0NDQ0NDQ0NDw07j/weVE8wF2rkL2QAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "random.randint(0, len(augmented_files)) #sanity check\n", + "random_image = random.randint(0, len(augmented_files)-1)\n", + "show_image(X[random_image][:,:,0:3], y[random_image])" + ] + }, + { + "cell_type": "markdown", + "id": "6bdf9520", + "metadata": {}, + "source": [ + "### Model Training\n", + "\n", + "We decided to use U-Net as it has shown impressive results over multiple domains in image segmentation.\n", + "We will employ a ResNet34 backbone with our spatio-temporal U-Net model.\n", + "\n", + "This uses our 24 channels (6 timestamps * 4 bands per timestamp) and generates the predicted field boundary per scene.\n", + "\n", + "We will also use an 80:20 train:validation set split for model training.\n", + "\n", + "Since this is a binary segmentation problem (field boundary or no field boundary), we will use the `binary cross_entropy` loss." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "d6fd5235", + "metadata": {}, + "outputs": [], + "source": [ + "BACKBONE = 'resnet34'\n", + "preprocess_input = sm.get_preprocessing(BACKBONE)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "b2ffb90d", + "metadata": {}, + "outputs": [], + "source": [ + "X = preprocess_input(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "77c631af", + "metadata": {}, + "outputs": [], + "source": [ + "#https://github.com/sustainlab-group/ParcelDelineation/blob/master/models/unet.py\n", + "def unet(pretrained_weights = None,input_size = (256,256,4)):\n", + " inputs = Input(input_size)\n", + " conv1 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(inputs)\n", + " conv1 = BatchNormalization()(conv1)\n", + " conv1 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv1)\n", + " conv1 = BatchNormalization()(conv1)\n", + " pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)\n", + " conv2 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool1)\n", + " conv2 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv2)\n", + " pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)\n", + " conv3 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool2)\n", + " conv3 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv3)\n", + " pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)\n", + " conv4 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool3)\n", + " conv4 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv4)\n", + " drop4 = Dropout(0.5)(conv4)\n", + " pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)\n", + "\n", + " conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(pool4)\n", + " conv5 = Conv2D(1024, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv5)\n", + " drop5 = Dropout(0.5)(conv5)\n", + "\n", + " up6 = Conv2D(512, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(drop5))\n", + " merge6 = concatenate([drop4,up6], axis = 3)\n", + " conv6 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge6)\n", + " conv6 = Conv2D(512, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv6)\n", + "\n", + " up7 = Conv2D(256, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv6))\n", + " merge7 = concatenate([conv3,up7], axis = 3)\n", + " conv7 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge7)\n", + " conv7 = Conv2D(256, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv7)\n", + "\n", + " up8 = Conv2D(128, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv7))\n", + " merge8 = concatenate([conv2,up8], axis = 3)\n", + " conv8 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge8)\n", + " conv8 = Conv2D(128, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv8)\n", + "\n", + " up9 = Conv2D(64, 2, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(UpSampling2D(size = (2,2))(conv8))\n", + " merge9 = concatenate([conv1,up9], axis = 3)\n", + " conv9 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(merge9)\n", + " conv9 = Conv2D(64, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv9)\n", + " conv9 = Conv2D(2, 3, activation = 'relu', padding = 'same', kernel_initializer = 'he_normal')(conv9)\n", + " conv10 = Conv2D(1, 1, activation = 'sigmoid')(conv9)\n", + "\n", + " model = Model(input = inputs, output = conv10)\n", + "\n", + " if(pretrained_weights):\n", + " \tmodel.load_weights(pretrained_weights)\n", + "\n", + " return " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "72ed3b45", + "metadata": {}, + "outputs": [], + "source": [ + "def learning_rate_scheduler(epoch):\n", + " lr = 1e-4\n", + " '''\n", + " if epoch > 180:\n", + " lr *= 0.5e-3\n", + " elif epoch > 150:\n", + " lr *= 1e-3\n", + " elif epoch > 120:\n", + " lr *= 1e-2\n", + " elif epoch > 80:\n", + " lr *= 1e-1\n", + " '''\n", + " print(\"Set Learning Rate : {}\".format(lr))\n", + " return lr" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "643843fd", + "metadata": {}, + "outputs": [], + "source": [ + "num_channels = 24\n", + "input_shape = (256,256,num_channels)\n", + "batch_size = 4" + ] + }, + { + "cell_type": "markdown", + "id": "15275933", + "metadata": {}, + "source": [ + "For the model, we will make use of two key metrics: **Recall** and **F1-score**.\n", + "\n", + "**Recall** evaluates how much of the field boundaries which were labelled were actually predicted as well while the **f1-score** combines the precision and recall by evaluating the harmonic mean.\n", + "\n", + "**NOTE** that the recall is the more important metric for this case as we are mostly concerned about the retrieved field boundaries out of the labelled field boundaries." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "38e689d4", + "metadata": {}, + "outputs": [], + "source": [ + "#https://datascience.stackexchange.com/questions/45165/how-to-get-accuracy-f1-precision-and-recall-for-a-keras-model\n", + "def recall(y_true, y_pred):\n", + " true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n", + " possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))\n", + " recall = true_positives / (possible_positives + K.epsilon())\n", + " return recall\n", + "def f1(y_true, y_pred):\n", + " def precision(y_true, y_pred):\n", + " true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))\n", + " predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))\n", + " precision = true_positives / (predicted_positives + K.epsilon())\n", + " return precision\n", + " precision = precision(y_true, y_pred)\n", + " recall_ = recall(y_true, y_pred)\n", + " return 2*((precision*recall_)/(precision+recall_+K.epsilon()))" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "5654af4f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Metal device set to: Apple M2\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-11-15 14:52:13.745091: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:305] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n", + "2022-11-15 14:52:13.745243: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:271] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: )\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set Learning Rate : 0.0001\n" + ] + } + ], + "source": [ + "model = None \n", + "model_unet = Unet(BACKBONE, encoder_weights='imagenet')\n", + "new_model = keras.models.Sequential()\n", + "new_model.add(Conv2D(3, (1,1), padding='same', activation='relu', input_shape=input_shape))\n", + "new_model.add(model_unet)\n", + "model = new_model \n", + "#sm.metrics.FScore(beta=1)\n", + "model.compile(loss='binary_crossentropy',\n", + " optimizer=Adam(learning_rate=learning_rate_scheduler(0)),\n", + " metrics=[recall,f1])" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "beee012b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " conv2d (Conv2D) (None, 256, 256, 3) 75 \n", + " \n", + " model_1 (Functional) (None, None, None, 1) 24456154 \n", + " \n", + "=================================================================\n", + "Total params: 24,456,229\n", + "Trainable params: 24,438,879\n", + "Non-trainable params: 17,350\n", + "_________________________________________________________________\n" + ] + } + ], + "source": [ + "model.summary()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "9f2a8ce6", + "metadata": {}, + "outputs": [], + "source": [ + "x_train, x_val, y_train, y_val = train_test_split(X, y, test_size=0.2, random_state=42)" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "id": "0c00a8a9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "WARNING:tensorflow:From /var/folders/y2/9lp3yz856pl5b25jjzkh6d900000gn/T/ipykernel_28080/2874510872.py:1: experimental_run_functions_eagerly (from tensorflow.python.eager.def_function) is deprecated and will be removed in a future version.\n", + "Instructions for updating:\n", + "Use `tf.config.run_functions_eagerly` instead of the experimental version.\n" + ] + } + ], + "source": [ + "tf.config.experimental_run_functions_eagerly(True)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "id": "46e51a4c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/magdalenabenza/opt/miniconda3/envs/bootcamp/lib/python3.9/site-packages/tensorflow/python/data/ops/structured_function.py:264: UserWarning: Even though the `tf.config.experimental_run_functions_eagerly` option is set, this option does not apply to tf.data functions. To force eager execution of tf.data functions, please use `tf.data.experimental.enable_debug_mode()`.\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/200\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2022-11-15 14:53:18.341421: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "45/45 [==============================] - 16s 336ms/step - loss: 0.6977 - recall: 0.4453 - f1: 0.1032 - val_loss: 0.6695 - val_recall: 0.4904 - val_f1: 0.1154\n", + "Epoch 2/200\n", + "45/45 [==============================] - 16s 342ms/step - loss: 0.5303 - recall: 0.0559 - f1: 0.0484 - val_loss: 0.5316 - val_recall: 0.0068 - val_f1: 0.0122\n", + "Epoch 3/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.4331 - recall: 0.0091 - f1: 0.0144 - val_loss: 0.5528 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 4/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.3684 - recall: 0.0045 - f1: 0.0081 - val_loss: 0.5845 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 5/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.3255 - recall: 0.0014 - f1: 0.0026 - val_loss: 0.5457 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 6/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.2960 - recall: 8.5366e-04 - f1: 0.0016 - val_loss: 0.4726 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 7/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.2703 - recall: 1.1211e-04 - f1: 2.2319e-04 - val_loss: 0.4036 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 8/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.2499 - recall: 1.0090e-04 - f1: 2.0067e-04 - val_loss: 0.3136 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 9/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.2336 - recall: 9.2315e-05 - f1: 1.8430e-04 - val_loss: 0.2893 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 10/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.2250 - recall: 2.3101e-05 - f1: 4.6168e-05 - val_loss: 0.2613 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 11/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.2049 - recall: 1.2222e-05 - f1: 2.4430e-05 - val_loss: 0.2421 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 12/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.2053 - recall: 7.3111e-05 - f1: 1.4464e-04 - val_loss: 0.2294 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 13/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.1928 - recall: 2.9090e-06 - f1: 5.8173e-06 - val_loss: 0.2202 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 14/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.1877 - recall: 4.5052e-06 - f1: 9.0010e-06 - val_loss: 0.2168 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 15/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.1855 - recall: 3.8762e-06 - f1: 7.7506e-06 - val_loss: 0.2097 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 16/200\n", + "45/45 [==============================] - 15s 336ms/step - loss: 0.1745 - recall: 2.6562e-05 - f1: 5.3093e-05 - val_loss: 0.2040 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 17/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.1754 - recall: 6.0439e-05 - f1: 1.2082e-04 - val_loss: 0.1960 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 18/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.1661 - recall: 2.4655e-05 - f1: 4.9291e-05 - val_loss: 0.1916 - val_recall: 0.0000e+00 - val_f1: 0.0000e+00\n", + "Epoch 19/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.1648 - recall: 1.9952e-04 - f1: 3.9863e-04 - val_loss: 0.1866 - val_recall: 8.5626e-06 - val_f1: 1.7124e-05\n", + "Epoch 20/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.1645 - recall: 3.3901e-04 - f1: 6.7717e-04 - val_loss: 0.1831 - val_recall: 1.7775e-05 - val_f1: 3.5545e-05\n", + "Epoch 21/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.1576 - recall: 9.1060e-04 - f1: 0.0018 - val_loss: 0.1815 - val_recall: 1.2792e-04 - val_f1: 2.5574e-04\n", + "Epoch 22/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.1567 - recall: 0.0017 - f1: 0.0034 - val_loss: 0.1795 - val_recall: 3.9403e-04 - val_f1: 7.8705e-04\n", + "Epoch 23/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.1548 - recall: 0.0050 - f1: 0.0098 - val_loss: 0.1756 - val_recall: 4.8618e-04 - val_f1: 9.7095e-04\n", + "Epoch 24/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.1496 - recall: 0.0061 - f1: 0.0120 - val_loss: 0.1741 - val_recall: 0.0018 - val_f1: 0.0035\n", + "Epoch 25/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.1491 - recall: 0.0106 - f1: 0.0206 - val_loss: 0.1739 - val_recall: 0.0021 - val_f1: 0.0041\n", + "Epoch 26/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.1430 - recall: 0.0226 - f1: 0.0430 - val_loss: 0.1719 - val_recall: 0.0042 - val_f1: 0.0083\n", + "Epoch 27/200\n", + "45/45 [==============================] - 16s 345ms/step - loss: 0.1473 - recall: 0.0325 - f1: 0.0607 - val_loss: 0.1709 - val_recall: 0.0134 - val_f1: 0.0260\n", + "Epoch 28/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.1448 - recall: 0.0564 - f1: 0.1007 - val_loss: 0.1710 - val_recall: 0.0268 - val_f1: 0.0503\n", + "Epoch 29/200\n", + "45/45 [==============================] - 15s 336ms/step - loss: 0.1342 - recall: 0.0583 - f1: 0.1034 - val_loss: 0.1688 - val_recall: 0.0255 - val_f1: 0.0483\n", + "Epoch 30/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.1322 - recall: 0.0957 - f1: 0.1602 - val_loss: 0.1691 - val_recall: 0.0373 - val_f1: 0.0686\n", + "Epoch 31/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.1370 - recall: 0.1138 - f1: 0.1846 - val_loss: 0.1682 - val_recall: 0.0567 - val_f1: 0.1002\n", + "Epoch 32/200\n", + "45/45 [==============================] - 15s 339ms/step - loss: 0.1272 - recall: 0.1355 - f1: 0.2156 - val_loss: 0.1678 - val_recall: 0.0667 - val_f1: 0.1161\n", + "Epoch 33/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.1294 - recall: 0.1699 - f1: 0.2577 - val_loss: 0.1684 - val_recall: 0.0720 - val_f1: 0.1238\n", + "Epoch 34/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.1290 - recall: 0.1837 - f1: 0.2728 - val_loss: 0.1694 - val_recall: 0.1177 - val_f1: 0.1851\n", + "Epoch 35/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.1234 - recall: 0.1971 - f1: 0.2887 - val_loss: 0.1684 - val_recall: 0.1155 - val_f1: 0.1834\n", + "Epoch 36/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.1205 - recall: 0.2295 - f1: 0.3249 - val_loss: 0.1707 - val_recall: 0.1219 - val_f1: 0.1909\n", + "Epoch 37/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.1184 - recall: 0.2336 - f1: 0.3282 - val_loss: 0.1680 - val_recall: 0.1107 - val_f1: 0.1777\n", + "Epoch 38/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.1123 - recall: 0.2750 - f1: 0.3679 - val_loss: 0.1710 - val_recall: 0.1180 - val_f1: 0.1862\n", + "Epoch 39/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.1153 - recall: 0.3157 - f1: 0.4081 - val_loss: 0.1685 - val_recall: 0.1593 - val_f1: 0.2343\n", + "Epoch 40/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.1094 - recall: 0.3135 - f1: 0.4021 - val_loss: 0.1721 - val_recall: 0.1396 - val_f1: 0.2131\n", + "Epoch 41/200\n", + "45/45 [==============================] - 15s 340ms/step - loss: 0.1089 - recall: 0.3275 - f1: 0.4167 - val_loss: 0.1696 - val_recall: 0.1566 - val_f1: 0.2317\n", + "Epoch 42/200\n", + "45/45 [==============================] - 16s 351ms/step - loss: 0.1072 - recall: 0.3611 - f1: 0.4479 - val_loss: 0.1685 - val_recall: 0.1912 - val_f1: 0.2672\n", + "Epoch 43/200\n", + "45/45 [==============================] - 16s 356ms/step - loss: 0.1070 - recall: 0.3806 - f1: 0.4634 - val_loss: 0.1688 - val_recall: 0.1856 - val_f1: 0.2622\n", + "Epoch 44/200\n", + "45/45 [==============================] - 17s 373ms/step - loss: 0.1022 - recall: 0.3819 - f1: 0.4632 - val_loss: 0.1721 - val_recall: 0.1700 - val_f1: 0.2461\n", + "Epoch 45/200\n", + "45/45 [==============================] - 16s 354ms/step - loss: 0.1012 - recall: 0.4025 - f1: 0.4809 - val_loss: 0.1753 - val_recall: 0.1521 - val_f1: 0.2284\n", + "Epoch 46/200\n", + "45/45 [==============================] - 16s 348ms/step - loss: 0.1001 - recall: 0.4138 - f1: 0.4887 - val_loss: 0.1718 - val_recall: 0.2036 - val_f1: 0.2798\n", + "Epoch 47/200\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "45/45 [==============================] - 15s 338ms/step - loss: 0.0972 - recall: 0.4596 - f1: 0.5219 - val_loss: 0.1704 - val_recall: 0.2258 - val_f1: 0.2982\n", + "Epoch 48/200\n", + "45/45 [==============================] - 15s 339ms/step - loss: 0.0932 - recall: 0.4541 - f1: 0.5218 - val_loss: 0.1724 - val_recall: 0.2346 - val_f1: 0.3066\n", + "Epoch 49/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0948 - recall: 0.4803 - f1: 0.5380 - val_loss: 0.1780 - val_recall: 0.1887 - val_f1: 0.2656\n", + "Epoch 50/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0922 - recall: 0.4894 - f1: 0.5474 - val_loss: 0.1742 - val_recall: 0.2372 - val_f1: 0.3104\n", + "Epoch 51/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0897 - recall: 0.4988 - f1: 0.5529 - val_loss: 0.1756 - val_recall: 0.2380 - val_f1: 0.3114\n", + "Epoch 52/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0894 - recall: 0.5199 - f1: 0.5700 - val_loss: 0.1754 - val_recall: 0.2624 - val_f1: 0.3286\n", + "Epoch 53/200\n", + "45/45 [==============================] - 15s 336ms/step - loss: 0.0870 - recall: 0.5318 - f1: 0.5728 - val_loss: 0.1769 - val_recall: 0.2747 - val_f1: 0.3378\n", + "Epoch 54/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.0862 - recall: 0.5413 - f1: 0.5808 - val_loss: 0.1761 - val_recall: 0.2440 - val_f1: 0.3176\n", + "Epoch 55/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0849 - recall: 0.5493 - f1: 0.5893 - val_loss: 0.1810 - val_recall: 0.2297 - val_f1: 0.3065\n", + "Epoch 56/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0822 - recall: 0.5705 - f1: 0.6046 - val_loss: 0.1819 - val_recall: 0.2247 - val_f1: 0.3024\n", + "Epoch 57/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0852 - recall: 0.5799 - f1: 0.6096 - val_loss: 0.1834 - val_recall: 0.2463 - val_f1: 0.3214\n", + "Epoch 58/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0790 - recall: 0.5939 - f1: 0.6181 - val_loss: 0.1778 - val_recall: 0.2763 - val_f1: 0.3430\n", + "Epoch 59/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0805 - recall: 0.5959 - f1: 0.6204 - val_loss: 0.1822 - val_recall: 0.2818 - val_f1: 0.3482\n", + "Epoch 60/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0759 - recall: 0.6179 - f1: 0.6322 - val_loss: 0.1800 - val_recall: 0.2833 - val_f1: 0.3501\n", + "Epoch 61/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0793 - recall: 0.6209 - f1: 0.6384 - val_loss: 0.1823 - val_recall: 0.3000 - val_f1: 0.3599\n", + "Epoch 62/200\n", + "45/45 [==============================] - 15s 340ms/step - loss: 0.0724 - recall: 0.6378 - f1: 0.6490 - val_loss: 0.1820 - val_recall: 0.2921 - val_f1: 0.3560\n", + "Epoch 63/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0748 - recall: 0.6442 - f1: 0.6530 - val_loss: 0.1832 - val_recall: 0.3013 - val_f1: 0.3626\n", + "Epoch 64/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0740 - recall: 0.6545 - f1: 0.6595 - val_loss: 0.1852 - val_recall: 0.3049 - val_f1: 0.3644\n", + "Epoch 65/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0759 - recall: 0.6721 - f1: 0.6687 - val_loss: 0.1901 - val_recall: 0.2701 - val_f1: 0.3425\n", + "Epoch 66/200\n", + "45/45 [==============================] - 15s 344ms/step - loss: 0.0719 - recall: 0.6493 - f1: 0.6561 - val_loss: 0.1889 - val_recall: 0.3004 - val_f1: 0.3648\n", + "Epoch 67/200\n", + "45/45 [==============================] - 16s 352ms/step - loss: 0.0707 - recall: 0.6791 - f1: 0.6774 - val_loss: 0.1866 - val_recall: 0.3174 - val_f1: 0.3757\n", + "Epoch 68/200\n", + "45/45 [==============================] - 15s 339ms/step - loss: 0.0741 - recall: 0.6836 - f1: 0.6785 - val_loss: 0.1873 - val_recall: 0.3275 - val_f1: 0.3824\n", + "Epoch 69/200\n", + "45/45 [==============================] - 15s 340ms/step - loss: 0.0665 - recall: 0.6974 - f1: 0.6900 - val_loss: 0.1904 - val_recall: 0.3221 - val_f1: 0.3794\n", + "Epoch 70/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0668 - recall: 0.7027 - f1: 0.6897 - val_loss: 0.1904 - val_recall: 0.3435 - val_f1: 0.3927\n", + "Epoch 71/200\n", + "45/45 [==============================] - 16s 346ms/step - loss: 0.0694 - recall: 0.7085 - f1: 0.6984 - val_loss: 0.1929 - val_recall: 0.3409 - val_f1: 0.3904\n", + "Epoch 72/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0671 - recall: 0.7166 - f1: 0.7033 - val_loss: 0.1905 - val_recall: 0.3401 - val_f1: 0.3918\n", + "Epoch 73/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0638 - recall: 0.7127 - f1: 0.6962 - val_loss: 0.1946 - val_recall: 0.3209 - val_f1: 0.3828\n", + "Epoch 74/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0649 - recall: 0.7159 - f1: 0.6991 - val_loss: 0.1934 - val_recall: 0.3362 - val_f1: 0.3912\n", + "Epoch 75/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0659 - recall: 0.7256 - f1: 0.7097 - val_loss: 0.1996 - val_recall: 0.3227 - val_f1: 0.3838\n", + "Epoch 76/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0641 - recall: 0.7317 - f1: 0.7149 - val_loss: 0.1967 - val_recall: 0.3451 - val_f1: 0.3960\n", + "Epoch 77/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0609 - recall: 0.7409 - f1: 0.7194 - val_loss: 0.2009 - val_recall: 0.3197 - val_f1: 0.3817\n", + "Epoch 78/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0650 - recall: 0.7373 - f1: 0.7210 - val_loss: 0.2021 - val_recall: 0.3199 - val_f1: 0.3819\n", + "Epoch 79/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0610 - recall: 0.7488 - f1: 0.7289 - val_loss: 0.1997 - val_recall: 0.3537 - val_f1: 0.4021\n", + "Epoch 80/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0607 - recall: 0.7589 - f1: 0.7353 - val_loss: 0.2035 - val_recall: 0.3391 - val_f1: 0.3926\n", + "Epoch 81/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0596 - recall: 0.7633 - f1: 0.7373 - val_loss: 0.2050 - val_recall: 0.3468 - val_f1: 0.3985\n", + "Epoch 82/200\n", + "45/45 [==============================] - 15s 329ms/step - loss: 0.0589 - recall: 0.7580 - f1: 0.7364 - val_loss: 0.2064 - val_recall: 0.3481 - val_f1: 0.4002\n", + "Epoch 83/200\n", + "45/45 [==============================] - 16s 349ms/step - loss: 0.0596 - recall: 0.7651 - f1: 0.7399 - val_loss: 0.2045 - val_recall: 0.3534 - val_f1: 0.4028\n", + "Epoch 84/200\n", + "45/45 [==============================] - 15s 331ms/step - loss: 0.0567 - recall: 0.7667 - f1: 0.7436 - val_loss: 0.2069 - val_recall: 0.3625 - val_f1: 0.4053\n", + "Epoch 85/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0568 - recall: 0.7746 - f1: 0.7487 - val_loss: 0.2109 - val_recall: 0.3354 - val_f1: 0.3940\n", + "Epoch 86/200\n", + "45/45 [==============================] - 15s 329ms/step - loss: 0.0594 - recall: 0.7723 - f1: 0.7475 - val_loss: 0.2070 - val_recall: 0.3609 - val_f1: 0.4081\n", + "Epoch 87/200\n", + "45/45 [==============================] - 15s 331ms/step - loss: 0.0563 - recall: 0.7786 - f1: 0.7500 - val_loss: 0.2087 - val_recall: 0.3631 - val_f1: 0.4097\n", + "Epoch 88/200\n", + "45/45 [==============================] - 15s 339ms/step - loss: 0.0569 - recall: 0.7768 - f1: 0.7536 - val_loss: 0.2081 - val_recall: 0.3777 - val_f1: 0.4141\n", + "Epoch 89/200\n", + "45/45 [==============================] - 15s 329ms/step - loss: 0.0534 - recall: 0.7891 - f1: 0.7582 - val_loss: 0.2148 - val_recall: 0.3602 - val_f1: 0.4071\n", + "Epoch 90/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0570 - recall: 0.7824 - f1: 0.7560 - val_loss: 0.2139 - val_recall: 0.3505 - val_f1: 0.4049\n", + "Epoch 91/200\n", + "45/45 [==============================] - 15s 332ms/step - loss: 0.0557 - recall: 0.7838 - f1: 0.7580 - val_loss: 0.2165 - val_recall: 0.3596 - val_f1: 0.4063\n", + "Epoch 92/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0551 - recall: 0.7833 - f1: 0.7582 - val_loss: 0.2167 - val_recall: 0.3744 - val_f1: 0.4171\n", + "Epoch 93/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0549 - recall: 0.7927 - f1: 0.7634 - val_loss: 0.2145 - val_recall: 0.3687 - val_f1: 0.4152\n", + "Epoch 94/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0531 - recall: 0.7933 - f1: 0.7650 - val_loss: 0.2190 - val_recall: 0.3564 - val_f1: 0.4092\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 95/200\n", + "45/45 [==============================] - 15s 329ms/step - loss: 0.0528 - recall: 0.8033 - f1: 0.7771 - val_loss: 0.2221 - val_recall: 0.3544 - val_f1: 0.4122\n", + "Epoch 96/200\n", + "45/45 [==============================] - 15s 328ms/step - loss: 0.0516 - recall: 0.8046 - f1: 0.7756 - val_loss: 0.2204 - val_recall: 0.3678 - val_f1: 0.4175\n", + "Epoch 97/200\n", + "45/45 [==============================] - 15s 328ms/step - loss: 0.0519 - recall: 0.8093 - f1: 0.7785 - val_loss: 0.2226 - val_recall: 0.3461 - val_f1: 0.4053\n", + "Epoch 98/200\n", + "45/45 [==============================] - 15s 328ms/step - loss: 0.0508 - recall: 0.8060 - f1: 0.7810 - val_loss: 0.2214 - val_recall: 0.3685 - val_f1: 0.4185\n", + "Epoch 99/200\n", + "45/45 [==============================] - 15s 331ms/step - loss: 0.0501 - recall: 0.8097 - f1: 0.7822 - val_loss: 0.2248 - val_recall: 0.3635 - val_f1: 0.4134\n", + "Epoch 100/200\n", + "45/45 [==============================] - 15s 332ms/step - loss: 0.0494 - recall: 0.8163 - f1: 0.7886 - val_loss: 0.2240 - val_recall: 0.3685 - val_f1: 0.4187\n", + "Epoch 101/200\n", + "45/45 [==============================] - 15s 328ms/step - loss: 0.0492 - recall: 0.8210 - f1: 0.7918 - val_loss: 0.2237 - val_recall: 0.3763 - val_f1: 0.4239\n", + "Epoch 102/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0464 - recall: 0.8139 - f1: 0.7831 - val_loss: 0.2307 - val_recall: 0.3586 - val_f1: 0.4139\n", + "Epoch 103/200\n", + "45/45 [==============================] - 15s 329ms/step - loss: 0.0549 - recall: 0.8198 - f1: 0.7913 - val_loss: 0.2339 - val_recall: 0.3593 - val_f1: 0.4142\n", + "Epoch 104/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0465 - recall: 0.8178 - f1: 0.7904 - val_loss: 0.2279 - val_recall: 0.3722 - val_f1: 0.4216\n", + "Epoch 105/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0474 - recall: 0.8310 - f1: 0.8004 - val_loss: 0.2318 - val_recall: 0.3630 - val_f1: 0.4170\n", + "Epoch 106/200\n", + "45/45 [==============================] - 15s 332ms/step - loss: 0.0490 - recall: 0.8273 - f1: 0.7993 - val_loss: 0.2285 - val_recall: 0.3818 - val_f1: 0.4263\n", + "Epoch 107/200\n", + "45/45 [==============================] - 15s 331ms/step - loss: 0.0458 - recall: 0.8353 - f1: 0.8062 - val_loss: 0.2272 - val_recall: 0.3929 - val_f1: 0.4332\n", + "Epoch 108/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0430 - recall: 0.8373 - f1: 0.8092 - val_loss: 0.2333 - val_recall: 0.3719 - val_f1: 0.4223\n", + "Epoch 109/200\n", + "45/45 [==============================] - 15s 329ms/step - loss: 0.0483 - recall: 0.8324 - f1: 0.8040 - val_loss: 0.2276 - val_recall: 0.4090 - val_f1: 0.4374\n", + "Epoch 110/200\n", + "45/45 [==============================] - 15s 328ms/step - loss: 0.0452 - recall: 0.8363 - f1: 0.8075 - val_loss: 0.2379 - val_recall: 0.3703 - val_f1: 0.4245\n", + "Epoch 111/200\n", + "45/45 [==============================] - 15s 330ms/step - loss: 0.0448 - recall: 0.8393 - f1: 0.8114 - val_loss: 0.2360 - val_recall: 0.3796 - val_f1: 0.4269\n", + "Epoch 112/200\n", + "45/45 [==============================] - 15s 332ms/step - loss: 0.0444 - recall: 0.8395 - f1: 0.8122 - val_loss: 0.2335 - val_recall: 0.3984 - val_f1: 0.4357\n", + "Epoch 113/200\n", + "45/45 [==============================] - 15s 339ms/step - loss: 0.0463 - recall: 0.8329 - f1: 0.8057 - val_loss: 0.2425 - val_recall: 0.3599 - val_f1: 0.4133\n", + "Epoch 114/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0480 - recall: 0.8286 - f1: 0.8038 - val_loss: 0.2443 - val_recall: 0.3648 - val_f1: 0.4208\n", + "Epoch 115/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.0447 - recall: 0.8371 - f1: 0.8072 - val_loss: 0.2396 - val_recall: 0.3770 - val_f1: 0.4254\n", + "Epoch 116/200\n", + "45/45 [==============================] - 16s 354ms/step - loss: 0.0420 - recall: 0.8454 - f1: 0.8206 - val_loss: 0.2409 - val_recall: 0.3833 - val_f1: 0.4292\n", + "Epoch 117/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0444 - recall: 0.8415 - f1: 0.8145 - val_loss: 0.2425 - val_recall: 0.3763 - val_f1: 0.4268\n", + "Epoch 118/200\n", + "45/45 [==============================] - 15s 332ms/step - loss: 0.0428 - recall: 0.8468 - f1: 0.8213 - val_loss: 0.2395 - val_recall: 0.4059 - val_f1: 0.4411\n", + "Epoch 119/200\n", + "45/45 [==============================] - 15s 332ms/step - loss: 0.0422 - recall: 0.8576 - f1: 0.8300 - val_loss: 0.2426 - val_recall: 0.3803 - val_f1: 0.4294\n", + "Epoch 120/200\n", + "45/45 [==============================] - 15s 336ms/step - loss: 0.0409 - recall: 0.8496 - f1: 0.8252 - val_loss: 0.2508 - val_recall: 0.3690 - val_f1: 0.4240\n", + "Epoch 121/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0423 - recall: 0.8517 - f1: 0.8250 - val_loss: 0.2495 - val_recall: 0.3827 - val_f1: 0.4307\n", + "Epoch 122/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0409 - recall: 0.8551 - f1: 0.8305 - val_loss: 0.2476 - val_recall: 0.3899 - val_f1: 0.4351\n", + "Epoch 123/200\n", + "45/45 [==============================] - 16s 362ms/step - loss: 0.0404 - recall: 0.8580 - f1: 0.8307 - val_loss: 0.2462 - val_recall: 0.3985 - val_f1: 0.4400\n", + "Epoch 124/200\n", + "45/45 [==============================] - 15s 343ms/step - loss: 0.0391 - recall: 0.8597 - f1: 0.8349 - val_loss: 0.2518 - val_recall: 0.3748 - val_f1: 0.4295\n", + "Epoch 125/200\n", + "45/45 [==============================] - 16s 345ms/step - loss: 0.0413 - recall: 0.8602 - f1: 0.8355 - val_loss: 0.2483 - val_recall: 0.4052 - val_f1: 0.4437\n", + "Epoch 126/200\n", + "45/45 [==============================] - 15s 344ms/step - loss: 0.0391 - recall: 0.8626 - f1: 0.8378 - val_loss: 0.2573 - val_recall: 0.3864 - val_f1: 0.4353\n", + "Epoch 127/200\n", + "45/45 [==============================] - 16s 349ms/step - loss: 0.0395 - recall: 0.8641 - f1: 0.8410 - val_loss: 0.2519 - val_recall: 0.3974 - val_f1: 0.4407\n", + "Epoch 128/200\n", + "45/45 [==============================] - 15s 343ms/step - loss: 0.0372 - recall: 0.8651 - f1: 0.8404 - val_loss: 0.2559 - val_recall: 0.3971 - val_f1: 0.4417\n", + "Epoch 129/200\n", + "45/45 [==============================] - 17s 371ms/step - loss: 0.0398 - recall: 0.8613 - f1: 0.8387 - val_loss: 0.2555 - val_recall: 0.3952 - val_f1: 0.4391\n", + "Epoch 130/200\n", + "45/45 [==============================] - 15s 340ms/step - loss: 0.0384 - recall: 0.8654 - f1: 0.8396 - val_loss: 0.2635 - val_recall: 0.3726 - val_f1: 0.4309\n", + "Epoch 131/200\n", + "45/45 [==============================] - 15s 344ms/step - loss: 0.0380 - recall: 0.8659 - f1: 0.8442 - val_loss: 0.2597 - val_recall: 0.3999 - val_f1: 0.4428\n", + "Epoch 132/200\n", + "45/45 [==============================] - 15s 340ms/step - loss: 0.0373 - recall: 0.8694 - f1: 0.8440 - val_loss: 0.2614 - val_recall: 0.3926 - val_f1: 0.4391\n", + "Epoch 133/200\n", + "45/45 [==============================] - 15s 336ms/step - loss: 0.0375 - recall: 0.8675 - f1: 0.8448 - val_loss: 0.2624 - val_recall: 0.3927 - val_f1: 0.4396\n", + "Epoch 134/200\n", + "45/45 [==============================] - 16s 345ms/step - loss: 0.0371 - recall: 0.8688 - f1: 0.8452 - val_loss: 0.2652 - val_recall: 0.3859 - val_f1: 0.4353\n", + "Epoch 135/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0364 - recall: 0.8737 - f1: 0.8495 - val_loss: 0.2687 - val_recall: 0.3790 - val_f1: 0.4346\n", + "Epoch 136/200\n", + "45/45 [==============================] - 15s 336ms/step - loss: 0.0361 - recall: 0.8718 - f1: 0.8515 - val_loss: 0.2685 - val_recall: 0.3872 - val_f1: 0.4400\n", + "Epoch 137/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0357 - recall: 0.8756 - f1: 0.8529 - val_loss: 0.2678 - val_recall: 0.3971 - val_f1: 0.4437\n", + "Epoch 138/200\n", + "45/45 [==============================] - 15s 331ms/step - loss: 0.0360 - recall: 0.8753 - f1: 0.8528 - val_loss: 0.2697 - val_recall: 0.3874 - val_f1: 0.4412\n", + "Epoch 139/200\n", + "45/45 [==============================] - 15s 339ms/step - loss: 0.0349 - recall: 0.8794 - f1: 0.8564 - val_loss: 0.2684 - val_recall: 0.3863 - val_f1: 0.4380\n", + "Epoch 140/200\n", + "45/45 [==============================] - 15s 345ms/step - loss: 0.0371 - recall: 0.8685 - f1: 0.8483 - val_loss: 0.2748 - val_recall: 0.3772 - val_f1: 0.4268\n", + "Epoch 141/200\n", + "45/45 [==============================] - 16s 352ms/step - loss: 0.0407 - recall: 0.8567 - f1: 0.8354 - val_loss: 0.2678 - val_recall: 0.4089 - val_f1: 0.4417\n", + "Epoch 142/200\n", + "45/45 [==============================] - 15s 345ms/step - loss: 0.0373 - recall: 0.8643 - f1: 0.8442 - val_loss: 0.2694 - val_recall: 0.3982 - val_f1: 0.4424\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 143/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0368 - recall: 0.8701 - f1: 0.8490 - val_loss: 0.2682 - val_recall: 0.4050 - val_f1: 0.4460\n", + "Epoch 144/200\n", + "45/45 [==============================] - 15s 339ms/step - loss: 0.0343 - recall: 0.8748 - f1: 0.8553 - val_loss: 0.2750 - val_recall: 0.3918 - val_f1: 0.4391\n", + "Epoch 145/200\n", + "45/45 [==============================] - 16s 350ms/step - loss: 0.0357 - recall: 0.8781 - f1: 0.8569 - val_loss: 0.2727 - val_recall: 0.3906 - val_f1: 0.4401\n", + "Epoch 146/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0326 - recall: 0.8817 - f1: 0.8612 - val_loss: 0.2737 - val_recall: 0.3963 - val_f1: 0.4411\n", + "Epoch 147/200\n", + "45/45 [==============================] - 16s 347ms/step - loss: 0.0348 - recall: 0.8821 - f1: 0.8612 - val_loss: 0.2780 - val_recall: 0.3778 - val_f1: 0.4349\n", + "Epoch 148/200\n", + "45/45 [==============================] - 15s 343ms/step - loss: 0.0347 - recall: 0.8802 - f1: 0.8609 - val_loss: 0.2772 - val_recall: 0.4094 - val_f1: 0.4500\n", + "Epoch 149/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0331 - recall: 0.8878 - f1: 0.8673 - val_loss: 0.2789 - val_recall: 0.3964 - val_f1: 0.4468\n", + "Epoch 150/200\n", + "45/45 [==============================] - 15s 340ms/step - loss: 0.0327 - recall: 0.8839 - f1: 0.8652 - val_loss: 0.2782 - val_recall: 0.4128 - val_f1: 0.4530\n", + "Epoch 151/200\n", + "45/45 [==============================] - 16s 362ms/step - loss: 0.0338 - recall: 0.8835 - f1: 0.8629 - val_loss: 0.2832 - val_recall: 0.4036 - val_f1: 0.4482\n", + "Epoch 152/200\n", + "45/45 [==============================] - 15s 336ms/step - loss: 0.0319 - recall: 0.8899 - f1: 0.8704 - val_loss: 0.2781 - val_recall: 0.3968 - val_f1: 0.4466\n", + "Epoch 153/200\n", + "45/45 [==============================] - 16s 348ms/step - loss: 0.0312 - recall: 0.8887 - f1: 0.8696 - val_loss: 0.2789 - val_recall: 0.4058 - val_f1: 0.4492\n", + "Epoch 154/200\n", + "45/45 [==============================] - 15s 343ms/step - loss: 0.0337 - recall: 0.8828 - f1: 0.8636 - val_loss: 0.2848 - val_recall: 0.3931 - val_f1: 0.4452\n", + "Epoch 155/200\n", + "45/45 [==============================] - 16s 346ms/step - loss: 0.0355 - recall: 0.8671 - f1: 0.8481 - val_loss: 0.2990 - val_recall: 0.3634 - val_f1: 0.4211\n", + "Epoch 156/200\n", + "45/45 [==============================] - 16s 349ms/step - loss: 0.0364 - recall: 0.8700 - f1: 0.8515 - val_loss: 0.2921 - val_recall: 0.3811 - val_f1: 0.4376\n", + "Epoch 157/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0338 - recall: 0.8766 - f1: 0.8594 - val_loss: 0.2907 - val_recall: 0.3853 - val_f1: 0.4433\n", + "Epoch 158/200\n", + "45/45 [==============================] - 16s 349ms/step - loss: 0.0304 - recall: 0.8860 - f1: 0.8666 - val_loss: 0.2890 - val_recall: 0.3897 - val_f1: 0.4429\n", + "Epoch 159/200\n", + "45/45 [==============================] - 16s 345ms/step - loss: 0.0329 - recall: 0.8863 - f1: 0.8687 - val_loss: 0.2900 - val_recall: 0.3903 - val_f1: 0.4430\n", + "Epoch 160/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0313 - recall: 0.8934 - f1: 0.8739 - val_loss: 0.2901 - val_recall: 0.3992 - val_f1: 0.4484\n", + "Epoch 161/200\n", + "45/45 [==============================] - 16s 355ms/step - loss: 0.0299 - recall: 0.8955 - f1: 0.8788 - val_loss: 0.2903 - val_recall: 0.4034 - val_f1: 0.4491\n", + "Epoch 162/200\n", + "45/45 [==============================] - 16s 361ms/step - loss: 0.0285 - recall: 0.8930 - f1: 0.8762 - val_loss: 0.2937 - val_recall: 0.3863 - val_f1: 0.4440\n", + "Epoch 163/200\n", + "45/45 [==============================] - 15s 342ms/step - loss: 0.0319 - recall: 0.8967 - f1: 0.8795 - val_loss: 0.2898 - val_recall: 0.4062 - val_f1: 0.4548\n", + "Epoch 164/200\n", + "45/45 [==============================] - 16s 356ms/step - loss: 0.0297 - recall: 0.8982 - f1: 0.8800 - val_loss: 0.2934 - val_recall: 0.4016 - val_f1: 0.4513\n", + "Epoch 165/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0286 - recall: 0.8987 - f1: 0.8827 - val_loss: 0.2972 - val_recall: 0.3870 - val_f1: 0.4459\n", + "Epoch 166/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0292 - recall: 0.8978 - f1: 0.8811 - val_loss: 0.2971 - val_recall: 0.4032 - val_f1: 0.4505\n", + "Epoch 167/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0303 - recall: 0.8957 - f1: 0.8794 - val_loss: 0.2980 - val_recall: 0.3954 - val_f1: 0.4476\n", + "Epoch 168/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0285 - recall: 0.9008 - f1: 0.8847 - val_loss: 0.3020 - val_recall: 0.3991 - val_f1: 0.4502\n", + "Epoch 169/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0282 - recall: 0.8995 - f1: 0.8842 - val_loss: 0.2987 - val_recall: 0.4076 - val_f1: 0.4543\n", + "Epoch 170/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.0296 - recall: 0.8991 - f1: 0.8823 - val_loss: 0.3013 - val_recall: 0.3956 - val_f1: 0.4482\n", + "Epoch 171/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0280 - recall: 0.8969 - f1: 0.8809 - val_loss: 0.3016 - val_recall: 0.3931 - val_f1: 0.4483\n", + "Epoch 172/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0285 - recall: 0.9015 - f1: 0.8856 - val_loss: 0.3009 - val_recall: 0.4026 - val_f1: 0.4529\n", + "Epoch 173/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0295 - recall: 0.8972 - f1: 0.8834 - val_loss: 0.3020 - val_recall: 0.4135 - val_f1: 0.4558\n", + "Epoch 174/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0272 - recall: 0.9045 - f1: 0.8885 - val_loss: 0.3019 - val_recall: 0.4039 - val_f1: 0.4521\n", + "Epoch 175/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0271 - recall: 0.9059 - f1: 0.8907 - val_loss: 0.3042 - val_recall: 0.4096 - val_f1: 0.4549\n", + "Epoch 176/200\n", + "45/45 [==============================] - 16s 353ms/step - loss: 0.0256 - recall: 0.9091 - f1: 0.8952 - val_loss: 0.3047 - val_recall: 0.4041 - val_f1: 0.4528\n", + "Epoch 177/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0280 - recall: 0.9088 - f1: 0.8939 - val_loss: 0.3052 - val_recall: 0.4168 - val_f1: 0.4603\n", + "Epoch 178/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0266 - recall: 0.9063 - f1: 0.8918 - val_loss: 0.3074 - val_recall: 0.4048 - val_f1: 0.4524\n", + "Epoch 179/200\n", + "45/45 [==============================] - 16s 352ms/step - loss: 0.0272 - recall: 0.9038 - f1: 0.8891 - val_loss: 0.3148 - val_recall: 0.3930 - val_f1: 0.4488\n", + "Epoch 180/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0269 - recall: 0.9042 - f1: 0.8902 - val_loss: 0.3092 - val_recall: 0.4092 - val_f1: 0.4564\n", + "Epoch 181/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0275 - recall: 0.9049 - f1: 0.8914 - val_loss: 0.3131 - val_recall: 0.4096 - val_f1: 0.4546\n", + "Epoch 182/200\n", + "45/45 [==============================] - 16s 347ms/step - loss: 0.0267 - recall: 0.9063 - f1: 0.8924 - val_loss: 0.3137 - val_recall: 0.4062 - val_f1: 0.4546\n", + "Epoch 183/200\n", + "45/45 [==============================] - 16s 345ms/step - loss: 0.0277 - recall: 0.9015 - f1: 0.8867 - val_loss: 0.3073 - val_recall: 0.4259 - val_f1: 0.4613\n", + "Epoch 184/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.0273 - recall: 0.9031 - f1: 0.8901 - val_loss: 0.3096 - val_recall: 0.4263 - val_f1: 0.4621\n", + "Epoch 185/200\n", + "45/45 [==============================] - 16s 347ms/step - loss: 0.0262 - recall: 0.9091 - f1: 0.8956 - val_loss: 0.3112 - val_recall: 0.4173 - val_f1: 0.4594\n", + "Epoch 186/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0253 - recall: 0.9108 - f1: 0.8972 - val_loss: 0.3107 - val_recall: 0.4159 - val_f1: 0.4558\n", + "Epoch 187/200\n", + "45/45 [==============================] - 16s 347ms/step - loss: 0.0266 - recall: 0.9095 - f1: 0.8957 - val_loss: 0.3133 - val_recall: 0.4166 - val_f1: 0.4587\n", + "Epoch 188/200\n", + "45/45 [==============================] - 15s 339ms/step - loss: 0.0247 - recall: 0.9110 - f1: 0.8982 - val_loss: 0.3179 - val_recall: 0.4036 - val_f1: 0.4535\n", + "Epoch 189/200\n", + "45/45 [==============================] - 15s 334ms/step - loss: 0.0246 - recall: 0.9149 - f1: 0.9015 - val_loss: 0.3179 - val_recall: 0.4045 - val_f1: 0.4544\n", + "Epoch 190/200\n", + "45/45 [==============================] - 15s 345ms/step - loss: 0.0252 - recall: 0.9134 - f1: 0.9009 - val_loss: 0.3250 - val_recall: 0.3990 - val_f1: 0.4533\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 191/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0234 - recall: 0.9148 - f1: 0.9036 - val_loss: 0.3252 - val_recall: 0.4048 - val_f1: 0.4575\n", + "Epoch 192/200\n", + "45/45 [==============================] - 15s 341ms/step - loss: 0.0230 - recall: 0.9165 - f1: 0.9038 - val_loss: 0.3307 - val_recall: 0.3956 - val_f1: 0.4516\n", + "Epoch 193/200\n", + "45/45 [==============================] - 15s 343ms/step - loss: 0.0255 - recall: 0.9118 - f1: 0.8996 - val_loss: 0.3253 - val_recall: 0.4168 - val_f1: 0.4608\n", + "Epoch 194/200\n", + "45/45 [==============================] - 15s 338ms/step - loss: 0.0250 - recall: 0.9173 - f1: 0.9055 - val_loss: 0.3286 - val_recall: 0.4006 - val_f1: 0.4541\n", + "Epoch 195/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0235 - recall: 0.9179 - f1: 0.9063 - val_loss: 0.3243 - val_recall: 0.4108 - val_f1: 0.4589\n", + "Epoch 196/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0228 - recall: 0.9151 - f1: 0.9032 - val_loss: 0.3196 - val_recall: 0.4207 - val_f1: 0.4604\n", + "Epoch 197/200\n", + "45/45 [==============================] - 15s 344ms/step - loss: 0.0254 - recall: 0.9134 - f1: 0.9018 - val_loss: 0.3230 - val_recall: 0.4231 - val_f1: 0.4623\n", + "Epoch 198/200\n", + "45/45 [==============================] - 15s 337ms/step - loss: 0.0227 - recall: 0.9183 - f1: 0.9072 - val_loss: 0.3310 - val_recall: 0.4062 - val_f1: 0.4569\n", + "Epoch 199/200\n", + "45/45 [==============================] - 15s 335ms/step - loss: 0.0236 - recall: 0.9177 - f1: 0.9066 - val_loss: 0.3378 - val_recall: 0.4009 - val_f1: 0.4556\n", + "Epoch 200/200\n", + "45/45 [==============================] - 15s 333ms/step - loss: 0.0238 - recall: 0.9170 - f1: 0.9056 - val_loss: 0.3287 - val_recall: 0.4124 - val_f1: 0.4600\n" + ] + } + ], + "source": [ + "history = model.fit(x=x_train, y=y_train,\n", + " validation_data=(x_val, y_val),\n", + " steps_per_epoch = len(x_train)//batch_size,\n", + " validation_steps = len(x_val)//batch_size,\n", + " batch_size=batch_size, epochs=200)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "0feb8f34", + "metadata": {}, + "outputs": [], + "source": [ + "model.save(f\"./unet_model.h5\")" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "6ba35983", + "metadata": {}, + "outputs": [], + "source": [ + "model = load_model(f\"./unet_model.h5\", custom_objects ={\"recall\":sm.metrics.Recall(threshold=0.5), \"f1\": f1})" + ] + }, + { + "cell_type": "markdown", + "id": "23753d38", + "metadata": {}, + "source": [ + "### Loading test chips to run predictions" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "id": "3ff02d6c", + "metadata": {}, + "outputs": [], + "source": [ + "test_source_items = f\"{dataset_id}/{dataset_id}_source_test\"\n", + "test_tiles = [clean_string(s) for s in next(os.walk(test_source_items))[1]]" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "3a880ed4", + "metadata": {}, + "outputs": [], + "source": [ + "test_tile_ids = set()\n", + "for tile in test_tiles:\n", + " test_tile_ids.add(tile.split('_')[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "id": "29312c09", + "metadata": {}, + "outputs": [], + "source": [ + "X_test = np.empty((len(test_tile_ids), IMG_HEIGHT, IMG_WIDTH, IMG_CHANNELS*len(timestamps)), dtype=np.float32)\n", + "i = 0\n", + "loaded_tiles = []\n", + "for tile_id in test_tile_ids:\n", + " idx = 0\n", + " for timestamp in timestamps:\n", + " bd1 = rio.open(f\"{test_source_items}/{dataset_id}_source_test_{tile_id}_{timestamp}/B01.tif\")\n", + " bd1_array = bd1.read(1)\n", + " bd2 = rio.open(f\"{test_source_items}/{dataset_id}_source_test_{tile_id}_{timestamp}/B02.tif\")\n", + " bd2_array = bd2.read(1)\n", + " bd3 = rio.open(f\"{test_source_items}/{dataset_id}_source_test_{tile_id}_{timestamp}/B03.tif\")\n", + " bd3_array = bd3.read(1)\n", + " bd4 = rio.open(f\"{test_source_items}/{dataset_id}_source_test_{tile_id}_{timestamp}/B04.tif\")\n", + " bd4_array = bd4.read(1)\n", + " b01_norm = normalize(bd1_array)\n", + " b02_norm = normalize(bd2_array)\n", + " b03_norm = normalize(bd3_array)\n", + " b04_norm = normalize(bd4_array)\n", + " \n", + " field = np.dstack((b04_norm, b03_norm, b02_norm, b01_norm))\n", + " X_test[i][:,:,idx:idx+IMG_CHANNELS] = field\n", + " idx+=IMG_CHANNELS\n", + " loaded_tiles.append(str(tile_id).zfill(2)) #track order test tiles are loaded into X to make sure tile id matches \n", + " i+=1" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "469cabb3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 [==============================] - 0s 233ms/step\n", + "1/1 [==============================] - 0s 43ms/step\n", + "1/1 [==============================] - 0s 44ms/step\n", + "1/1 [==============================] - 0s 44ms/step\n", + "1/1 [==============================] - 0s 39ms/step\n", + "1/1 [==============================] - 0s 37ms/step\n", + "1/1 [==============================] - 0s 40ms/step\n", + "1/1 [==============================] - 0s 42ms/step\n", + "1/1 [==============================] - 0s 38ms/step\n", + "1/1 [==============================] - 0s 38ms/step\n", + "1/1 [==============================] - 0s 40ms/step\n", + "1/1 [==============================] - 0s 43ms/step\n", + "1/1 [==============================] - 0s 38ms/step\n" + ] + } + ], + "source": [ + "predictions_dictionary = {}\n", + "for i in range(len(test_tile_ids)):\n", + " model_pred = model.predict(np.expand_dims(X_test[i], 0))\n", + " model_pred = model_pred[0]\n", + " model_pred = (model_pred >= 0.5).astype(np.uint8)\n", + " model_pred = model_pred.reshape(IMG_HEIGHT, IMG_WIDTH)\n", + " predictions_dictionary.update([(str(loaded_tiles[i]), pd.DataFrame(model_pred))])" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "33186bf0", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
tile_row_columnlabel
0Tile06_0_00
1Tile06_0_10
2Tile06_0_20
3Tile06_0_30
4Tile06_0_40
.........
65531Tile00_255_2510
65532Tile00_255_2520
65533Tile00_255_2530
65534Tile00_255_2540
65535Tile00_255_2550
\n", + "

851968 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " tile_row_column label\n", + "0 Tile06_0_0 0\n", + "1 Tile06_0_1 0\n", + "2 Tile06_0_2 0\n", + "3 Tile06_0_3 0\n", + "4 Tile06_0_4 0\n", + "... ... ...\n", + "65531 Tile00_255_251 0\n", + "65532 Tile00_255_252 0\n", + "65533 Tile00_255_253 0\n", + "65534 Tile00_255_254 0\n", + "65535 Tile00_255_255 0\n", + "\n", + "[851968 rows x 2 columns]" + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dfs = []\n", + "for key, value in predictions_dictionary.items():\n", + " ftd = value.unstack().reset_index().rename(columns={'level_0': 'row', 'level_1': 'column', 0: 'label'})\n", + " ftd['tile_row_column'] = f'Tile{key}_' + ftd['row'].astype(str) + '_' + ftd['column'].astype(str)\n", + " ftd = ftd[['tile_row_column', 'label']]\n", + " dfs.append(ftd)\n", + "\n", + "sub = pd.concat(dfs)\n", + "sub" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "5bac12a2", + "metadata": {}, + "outputs": [], + "source": [ + "sub.to_csv(f\"./harvest_sample_submission.csv\", index = False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "26b4d879", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.13" + }, + "vscode": { + "interpreter": { + "hash": "1456b81e0739e370391a1194b27bc839a9f5597c29befb4a579ec9fcd0f2acde" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/README.md b/README.md index 0abdba1..3c10215 100644 --- a/README.md +++ b/README.md @@ -1 +1,37 @@ -# Nasa_harvest_field_boundary_competition +# Nasa Harvest Rwanda Field Boundary Detection Challenge Tutorial + +This folder contains a notebook tutorial for the Nasa Harvest Rwanda field boundary detection competition. + +The dataset contains field boundaries for smallholder farms in eastern Rwanda. The Nasa Harvest program funded a team of annotators from TaQadam to label Planet imagery for the 2021 growing season for the purpose of conducting the Rwanda Field boundary detection Challenge. The dataset includes rasterized labeled field boundaries and time series satellite imagery from Planet's NICFI program. Planet's basemap imagery is provided for six months (March, April, August, October, November and December). The paired dataset is provided in 256x256 chips for a total of 70 tiles covering 1532 individual fields. + +The starter notebook focuses on a baseline model using UNet to walk you through the process of loading and structuring the data, training the model, and exporting the predictions to the sample CSV file. + +## Environment + +Python 3.8.13 + +minimum RAM : 8GB + +You can find the required packages used within the requirements.txt file. + +## Competition Organizers +### About Radiant Earth Foundation ([radiant.earth](https://radiant.earth)) +![Radiant Earth Foundation Logo](/images/ref.png) + +Radiant Earth Foundation is a nonprofit corporation working to empower organizations and individuals with open machine learning (ML) and Earth observation data, standards, and tools to address the world’s most critical international development challenges. Radiant Earth fosters collaboration through a cloud-based open geospatial training data library, Radiant MLHub. Radiant also supports an ecosystem of practitioners to develop standards, expand interoperability around ML on Earth observation, and provide information and training to help advance the capacity of those working in the global development sector using ML and Earth observation. Visit Radiant Earth on Twitter, LinkedIn, Medium, and GitHub. +### About University of Maryland, Nasa Harvest ([nasaharvest.org](https://nasaharvest.org/)) +![umd Logo](/images/umd.png) +![Nasa Harvest Logo](/images/harvest.png) + +NASA Harvest is NASA’s Food Security and Agriculture program based at the University of Maryland. NASA Harvest’s mission is to enable and advance the adoption of satellite Earth observations by public and private organizations to benefit food security, agriculture, and human and environmental resiliency in the US and worldwide. They accomplish this through a multidisciplinary and multisectoral Consortium of leading scientists and agricultural stakeholders at the University of Maryland and implement it together with partners across the globe. Visit NASA Harvest on [Twitter](https://twitter.com/HarvestProgram) and [Github](https://github.com/nasaharvest/). + +## Competition Sponsor +### About USDA([fas.usda.gov](https://www.fas.usda.gov)) +![usda Logo](/images/usda.png) + +### About USAID([usaid.gov](https://www.usaid.gov/)) +![usaid Logo](/images/usaid.png) + +This challenge and the training dataset collection and curation are based upon work by NASA Harvest supported by USDA-Foreign Agricultural Service and USAID, under Award Number FX22TA10960R004 and Project Title Earth Observations for Field Level Agricultural Resource Mapping (EO-Farm): Pilot in Rwanda in Support of NISR. + + diff --git a/images/.DS_Store b/images/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/images/.DS_Store differ diff --git a/images/harvest.png b/images/harvest.png new file mode 100644 index 0000000..b3bb14b Binary files /dev/null and b/images/harvest.png differ diff --git a/images/ref.png b/images/ref.png new file mode 100644 index 0000000..f7de570 Binary files /dev/null and b/images/ref.png differ diff --git a/images/umd.png b/images/umd.png new file mode 100644 index 0000000..32c38d0 Binary files /dev/null and b/images/umd.png differ diff --git a/images/usaid.png b/images/usaid.png new file mode 100644 index 0000000..9b30ad9 Binary files /dev/null and b/images/usaid.png differ diff --git a/images/usda.png b/images/usda.png new file mode 100644 index 0000000..67846e9 Binary files /dev/null and b/images/usda.png differ diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000..2e3f1e0 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,55 @@ +absl-py==0.8.0 +astor==0.8.0 +attrs==19.3.0 +certifi==2019.9.11 +click==7.1.1 +click-plugins==1.1.1 +cligj==0.5.0 +cycler==0.10.0 +decorator==4.4.1 +efficientnet==1.0.0 +Fiona==1.8.13.post1 +gast==0.3.2 +google-pasta==0.1.7 +grpcio==1.16.1 +h5py==2.9.0 +image-classifiers==1.0.0 +imageio==2.6.1 +joblib==0.13.2 +Keras==2.2.4 +Keras-Applications==1.0.8 +Keras-Preprocessing==1.1.0 +kiwisolver==1.1.0 +Markdown==3.1.1 +matplotlib==3.1.2 +mkl-fft==1.0.14 +mkl-random==1.1.0 +mkl-service==2.3.0 +munch==2.5.0 +networkx==2.4 +numpy==1.17.2 +opencv-python==4.2.0.34 +pandas==0.25.1 +Pillow==7.0.0 +protobuf==3.9.2 +pyparsing==2.4.6 +pyproj==2.6.0 +pyshp==2.1.0 +python-dateutil==2.8.0 +python-magic==0.4.15 +pytz==2019.3 +PyWavelets==1.1.1 +PyYAML==5.1.2 +radiant-mlhub==0.5.2 +scikit-image==0.16.2 +scikit-learn==0.21.3 +scipy==1.3.1 +segmentation-models==1.0.1 +Shapely==1.7.0 +six==1.12.0 +tensorboard==1.14.0 +tensorflow==1.14.0 +tensorflow-estimator==1.14.0 +termcolor==1.1.0 +Werkzeug==0.16.0 +wrapt==1.11.2