diff --git a/.gitignore b/.gitignore index 09789967..d2d379eb 100755 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,5 @@ +.idea/* + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] diff --git a/.idea/.gitignore b/.idea/.gitignore deleted file mode 100755 index 26d33521..00000000 --- a/.idea/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -# Default ignored files -/shelf/ -/workspace.xml diff --git a/.idea/eis_toolkit.iml b/.idea/eis_toolkit.iml deleted file mode 100755 index d0876a78..00000000 --- a/.idea/eis_toolkit.iml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml deleted file mode 100755 index 105ce2da..00000000 --- a/.idea/inspectionProfiles/profiles_settings.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml deleted file mode 100755 index 2c5c8843..00000000 --- a/.idea/misc.xml +++ /dev/null @@ -1,4 +0,0 @@ - - - - \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml deleted file mode 100755 index 8e89b632..00000000 --- a/.idea/modules.xml +++ /dev/null @@ -1,8 +0,0 @@ - - - - - - - - \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml deleted file mode 100755 index 94a25f7f..00000000 --- a/.idea/vcs.xml +++ /dev/null @@ -1,6 +0,0 @@ - - - - - - \ No newline at end of file diff --git a/eis_toolkit/exceptions.py b/eis_toolkit/exceptions.py index b3fb4248..4870959b 100644 --- a/eis_toolkit/exceptions.py +++ b/eis_toolkit/exceptions.py @@ -72,3 +72,7 @@ class NonSquarePixelSizeException(Exception): class NumericValueSignException(Exception): """Exception error class for numeric value sign exception.""" + + +class InvalidNumberOfConv2DLayer(Exception): + """Exception throws when when the list of conv layers is <= 0.""" diff --git a/eis_toolkit/unet/__init__.py b/eis_toolkit/unet/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/eis_toolkit/unet/mini_unet.py b/eis_toolkit/unet/mini_unet.py new file mode 100644 index 00000000..7198d209 --- /dev/null +++ b/eis_toolkit/unet/mini_unet.py @@ -0,0 +1,473 @@ +import glob +import os +from typing import Union + +import numpy as np +import numpy.ma as ma +import rasterio +import tensorflow as tf +from beartype import beartype +from keras.optimizers import SGD + +from eis_toolkit.exceptions import InvalidNumberOfConv2DLayer, NumericValueSignException + + +@beartype +def img_loader(image_dir: str) -> (np.ndarray, list, np.ndarray): + """ + Fetches all the tiffs in the given directory and creates a numpy ndarray of the common shape. + + Calculates shape (image_count, bands, width, height) from them. Returns the array, tiff metadata as a list and associated + nodatamasks in shape (image_count, width, height). Tiffs are assumed to be same size and are named as {number}.tif + starting from 0 + + Parameter: + image_dir: the directory containing the images + + Returns: + numpy ndarray of the tiffs + list containing the metadata + nodata mask + """ + # fetching the filepaths + paths = [] + metas = [] + for path in glob.glob(os.path.join(image_dir, "*.tif")): + paths.append(path) + + img_count = len(paths) + + # Getting the size of the images + with rasterio.open(paths[0]) as src: + meta = src.meta.copy() + image_width = meta["width"] + image_height = meta["height"] + + nodata_masks = np.empty((img_count, image_width, image_height), dtype="bool") + for i in range(img_count): + path = os.path.join(image_dir, str(i) + ".tif") + with rasterio.open(path) as src: + meta = src.meta.copy() + metas.append(meta) + # Note: rasterio returns shape (bands, width, height) + img_arr = np.empty( + ( + meta["count"], + image_width, + image_height, + ), + dtype=meta["dtype"], + ) + + for band_n in range(1, meta["count"] + 1): + nodata_mask = src.read_masks(band_n) + nodata_mask = nodata_mask == 0 + if band_n == 1: + nodata_mask_full = nodata_mask + else: + nodata_mask_full = np.logical_and(nodata_mask_full, nodata_mask, out=nodata_mask_full) + + # normalization + band_arr = src.read(band_n) + # Setting nodatamasks to zero + band_arr[band_arr == -999999] = 0 + band_arr_masked = ma.masked_array(band_arr, mask=nodata_mask) + minimum = band_arr_masked.min() + maximum = band_arr_masked.max() + band_arr = (band_arr_masked - minimum) / (maximum - minimum) + img_arr[band_n - 1] = band_arr + + nodata_masks[i] = nodata_mask_full + # Storing array needs to be created only on the first iteration. + # All images are assumed to be same size and dtype, so the meta of the first one is used + if i == 0: + data_arr = np.empty((img_count, meta["count"], meta["width"], meta["height"]), dtype=meta["dtype"]) + data_arr[i] = img_arr + + data_arr = np.moveaxis(data_arr, 1, -1) + return data_arr, metas, nodata_masks + + +@beartype +def label_loader(label_dir: str) -> (np.ndarray, int): + """ + Fetches all the tiffs in the given directory and creates a numpy ndarray of the shape (image_count, bands, width, height). + + The images are assumed to be the same size and contain the labels with numbers showing classes. + The tiffs should have only one band. + + Parameters: + label_dir: the directory containing the label files + + Return: + a numpy ndarray containing labels + nodata value + """ + # fetching the filepaths + paths = [] + for path in glob.glob(os.path.join(label_dir, "*.tif")): + paths.append(path) + + img_count = len(paths) + + # Getting the size of the rasters + with rasterio.open(paths[0]) as src: + meta = src.meta.copy() + nodata_value = meta["nodata"] + data_arr = np.empty((img_count, meta["count"], meta["width"], meta["height"]), dtype="float32") + + for i in range(img_count): + path = os.path.join(label_dir, str(i) + ".tif") + with rasterio.open(path) as src: + img_arr = src.read(1) + # Or maybe nodata as zeros is just fine + img_arr[img_arr == 255] = 0 + # moving band count(1) to last place + img_arr = img_arr.astype("float32") + data_arr[i] = img_arr + data_arr = np.moveaxis(data_arr, 1, -1) + return data_arr, nodata_value + + +@beartype +def build_autoencoder_multichannel_with_skip_connection( + input_shape: tuple, + kernel_shape: tuple, + list_of_convolutional_layers: list, + dropout: float or None, + pool_size: int, + up_sampling_factor: int, + output_filters: int, + output_kernel: tuple, + last_activation: str, + data_augmentation: bool, + data_augmentation_params_crop: int, + data_augmentation_params_rotation: tuple = (-0.3, 0.3), + regularization: Union[tf.keras.regularizers.L1, tf.keras.regularizers.L2, tf.keras.regularizers.L1L2, None] = None, +) -> tf.keras.Model: + """ + + Build the Unet. + + Parameters: + input_shape The shape of the input used by the Unet: + kernel_shape The shape of the convolution kernel: + list_of_convolutional_layers The list of convolutional layers of the Unet. This list will be reversed + for the decoder. + dropout: The dropout rate assigned. + pool_size: The size of the max pooling layer. + up_sampling_factor: The decoder need up sampling factor to enlarge the features layer by layer. + output_filters: The number of filters of the output. + output_kernel: The dimension of the output. + last_activation: Last activation sigmoid by default. + data_augmentation: If you want to include data augmentation right before the input layer. + data_augmentation_params_crop: If data augmentation is True fill this value. + data_augmentation_params_rotation: if data augmentation is True fill this value. + regularization: Type of regularization for each layer. + + Return: + the built Unet. + """ + # List to hold all input layers + input_img = tf.keras.Input(shape=input_shape) + + if data_augmentation: + x = tf.keras.layers.RandomFlip()(input_img) + x = tf.keras.layers.RandomCrop(data_augmentation_params_crop, data_augmentation_params_crop)(x) + x = tf.keras.layers.RandomRotation(data_augmentation_params_rotation)(x) + + skip_connections = [] + + # build the encoder + for layer_counter, layer in enumerate(list_of_convolutional_layers): + if layer_counter == 0 and data_augmentation is False: + x = tf.keras.layers.Conv2D( + layer, kernel_size=kernel_shape, padding="same", kernel_regularizer=regularization + )(input_img) + else: + x = tf.keras.layers.Conv2D( + layer, kernel_size=kernel_shape, padding="same", kernel_regularizer=regularization + )(x) + + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.Activation("relu")(x) + x = tf.keras.layers.Conv2D(layer, kernel_size=kernel_shape, padding="same", kernel_regularizer=regularization)( + x + ) + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.Activation("relu")(x) + + skip_connections.append(x) + x = tf.keras.layers.MaxPooling2D(pool_size=(pool_size, pool_size), padding="same")(x) + + for layer_counter, layer in enumerate(reversed(list_of_convolutional_layers)): + # Decoder block 1 + # skip_1 = skip_connections[-1] # Corresponding output from the encoder + x = tf.keras.layers.Dropout(dropout)(x) + x = tf.keras.layers.Conv2D(layer, kernel_size=kernel_shape, padding="same", kernel_regularizer=regularization)( + x + ) + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.Activation("relu")(x) + x = tf.keras.layers.Conv2D( + int(layer / 2), kernel_size=kernel_shape, padding="same", kernel_regularizer=regularization + )(x) + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.Activation("relu")(x) + + x = tf.keras.layers.UpSampling2D((up_sampling_factor, up_sampling_factor))(x) + x = tf.keras.layers.concatenate([x, skip_connections[-(layer_counter + 1)]], axis=-1) + + if layer_counter == len(list_of_convolutional_layers): + + # Output Layer + x = tf.keras.layers.Conv2D( + layer, kernel_size=kernel_shape, padding="same", kernel_regularizer=regularization + )(x) + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.Activation("relu")(x) + x = tf.keras.layers.Dropout(dropout)(x) + x = tf.keras.layers.Conv2D( + layer, kernel_size=kernel_shape, padding="same", kernel_regularizer=regularization + )(x) + x = tf.keras.layers.BatchNormalization()(x) + x = tf.keras.layers.Activation("relu")(x) + + # activation with normalized tanh should be considered because it has steeper gradients + decoded = tf.keras.layers.Conv2D( + output_filters, kernel_size=output_kernel, activation=last_activation, padding="same" + )(x) + + # Create the model + autoencoder_multi_channel = tf.keras.Model(input_img, decoded) + + return autoencoder_multi_channel + + +def dice_coeff_uncertain( + y_true: np.ndarray, y_pred: np.ndarray, uncertainmask: np.ndarray, smooth: float = 1e-6 +) -> (float, np.ndarray): + """ + From Wu, S., Heitzler, M. & Hurni, L. (2022). + + Leveraging uncertainty estimation and spatial pyramid pooling for extracting hydrological features from scanned + historical topographic maps’, GIScience & Remote Sensing, 59(1), pp. 200–214. Available + at: https://doi.org/10.1080/15481603.2021.2023840. + + Parameters: + y_true: the true labels of the dataset. + y_pred: the predicted labels from the model. + uncertainmask: the uncertainty mask. + smooth: the smooth factor. + + Return: + The dice loss value and the mask. + """ + + y_true = tf.cast(y_true, dtype=tf.float32) + y_pred = tf.cast(y_pred, dtype=tf.float32) + + if uncertainmask is not None: + # interpolate the value using the predicted uncertainty + y_pred = (tf.keras.backend.ones_like(uncertainmask) - uncertainmask) * y_true + uncertainmask * y_pred + + # want the dice coefficient should always be in 0 and 1 + intersection = tf.keras.backend.sum(y_true * y_pred) + dice = (2.0 * intersection) / (tf.keras.backend.sum(y_true) + tf.keras.backend.sum(y_pred) + smooth) + mask = tf.keras.backend.cast( + tf.keras.backend.not_equal(tf.keras.backend.sum(y_true) + tf.keras.backend.sum(y_pred) - intersection, 0), + "float32", + ) + + return dice, mask + + +def regularization_loss(y_true: tf.Tensor, y_pred: tf.Tensor) -> float: + """ + + Computes the dice loss. + + Parameters: + y_true: the true labels of the dataset. + y_pred: the predicted labels from the model. + + Return: + a floating point representing the loss. + """ + + y_pred_uncertain = y_pred[:, :, :, 1] + reg_loss = tf.keras.backend.mean(-tf.keras.backend.log(y_pred_uncertain[:, :, :])) + return reg_loss + + +def dice_coefficient(prediction: tf.Tensor, true_label: tf.Tensor) -> tf.Tensor: + """ + + Calculate the dice loss coefficient. + + Parameters: + true_label: the true labels of the dataset. + prediction: the predicted labels from the model. + + Return: + a floating point representing the loss. + """ + prediction = tf.cast(prediction, tf.float32) + true_label = tf.cast(true_label, tf.float32) + numerator = 2 * tf.reduce_sum(prediction * true_label) + divisor = tf.reduce_sum(prediction**2) + tf.reduce_sum(true_label**2) + return numerator / divisor + + +def dice_loss(prediction: tf.Tensor, true_label: tf.Tensor) -> tf.Tensor: + """ + + Calculate the dice loss. + + Parameters: + true_label: the true labels of the dataset. + prediction: the predicted labels from the model. + + Return: + a floating point representing the loss. + + """ + + DC = dice_coefficient(prediction, true_label) + dice_loss = 1 - DC + return dice_loss + + +def dice_loss_uncertain( + y_true: tf.Tensor, + y_pred: tf.Tensor, + smooth: float = 1e-6, + uncert_coef: float = 0.2, +) -> float or None: + """ + From Wu, S., Heitzler, M. & Hurni, L. (2022). + + Leveraging uncertainty estimation and spatial pyramid pooling for extracting hydrological features from scanned + historical topographic maps, GIScience & Remote Sensing, 59(1), pp. 200–214. + Available at: https://doi.org/10.1080/15481603.2021.2023840. + + Parameters: + y_true: the predicted labels of the dataset. + y_pred: the true labels of the dataset. + num_classes: classes used to calculate the loss. + smooth: the smoothing coefficient. + uncert_coef: the uncertainty coefficient. + + Return: + the loss as a float point number. + """ + dice = [] + + y_true = y_true[:, :, :, 0] + y_pred_labels = y_pred[:, :, :, 0] + y_pred_uncertain = y_pred[:, :, :, 1] + + d, m = dice_coeff_uncertain(y_true, y_pred_labels, y_pred_uncertain) + if m != 0: + dice.append(d) + + dice_mutilabel = tf.keras.backend.sum(dice) / (len(dice) + smooth) + uncertain_reg = regularization_loss(y_true, y_pred) + loss = 1 - dice_mutilabel + uncert_coef * uncertain_reg + return loss + + +def train_and_predict_the_model( + x_train: np.ndarray, + y_train: np.ndarray, + x_test: np.ndarray, + y_test: np.ndarray, + batch_size: int, + epochs: int, + is_uncertainty: bool = True, + list_of_convolutional_layers: list = [32, 64, 128, 256], + dropout: float = 0.2, + pool_size: int = 2, + up_sampling_factor: int = 2, + output_filters: int = 2, + output_kernel: tuple = (1, 1), + last_activation: str = "sigmoid", + data_augmentation: bool = True, + data_augmentation_params_crop: int = 28, + data_augmentation_params_rotation: tuple = (-0.3, 0.3), + regularization: Union[tf.keras.regularizers.L1, tf.keras.regularizers.L2, tf.keras.regularizers.L1L2, None] = None, + uncertainty_coefficient: float = 0.2, +) -> np.ndarray: + """ + Train and predict the Unet. + + Parameters: + x_train: a numpy array with the training samplse + y_train: labels of the training dataset + x_test: a numpy array with the testing samples + y_test: labels of the testing dataset + batch_size: how many sample per epochs should be used for fitting the model + epochs: how many epochs used for the training phase. + is_uncertainty: bool = True, if you want to add uncertainty estimation to your Mini-Unet. + list_of_convolutional_layers: how many convolutional layer suggestion -> [32, 64, 128, 256], + dropout: This is the dropout rate assigned. It is used to randomly remove some predictions. + pool_size: The size of the max pooling layer. + up_sampling_factor: the decoder upsampling factor to enlarge the features layer by layer. + output_filters: the number of filters of the output. + output_kernel: the dimension of the output. + last_activation: last activation, sigmoid by default. + data_augmentation: if you want to include data augmentation right before the input layer. + data_augmentation_params_crop: if data augmentation is True fill this value (crop range). + data_augmentation_params_rotation: if data augmentation is True fill this value (rotation range). + regularization: type of regularization for each layer. + + Raise: + InvalidInputException: when an input is null. + Return: + The predicted numpy array + """ + + if x_train.shape[0] == 0 or x_train is None: + raise NumericValueSignException + + if x_test.shape[0] == 0 or x_test is None: + raise NumericValueSignException + + if y_train.shape[0] == 0 or y_train is None: + raise NumericValueSignException + + if y_test.shape[0] == 0 or y_test is None: + raise NumericValueSignException + + if len(list_of_convolutional_layers) <= 0: + raise InvalidNumberOfConv2DLayer + + callback = tf.keras.callbacks.EarlyStopping(monitor="val_loss", patience=3) + + model = build_autoencoder_multichannel_with_skip_connection( + input_shape=x_train.shape[1:], + kernel_shape=(x_train.shape[-1], x_train.shape[-1]), + list_of_convolutional_layers=list_of_convolutional_layers, + dropout=dropout, + pool_size=pool_size, + up_sampling_factor=up_sampling_factor, + output_filters=output_filters, + output_kernel=output_kernel, + last_activation=last_activation, + data_augmentation=data_augmentation, + data_augmentation_params_crop=data_augmentation_params_crop, + data_augmentation_params_rotation=data_augmentation_params_rotation, + regularization=regularization, + ) + + model.compile( + optimizer=SGD(learning_rate=0.008, momentum=0.9), + loss=dice_loss_uncertain if is_uncertainty else dice_loss, + ) + + model.fit( + x_train, y_train, validation_data=(x_test, y_test), batch_size=batch_size, epochs=epochs, callbacks=[callback] + ) + + prediction = model.predict(x_test, verbose=1) + return prediction diff --git a/notebooks/Mini_Unet_no_uncertainty.ipynb b/notebooks/Mini_Unet_no_uncertainty.ipynb new file mode 100644 index 00000000..5b4dfbf3 --- /dev/null +++ b/notebooks/Mini_Unet_no_uncertainty.ipynb @@ -0,0 +1,757 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4dfcd0fd-78ac-44df-a6bb-3537db11b591", + "metadata": {}, + "source": [ + "# Mini U-net\n", + "- Semantic segmentation for (small) images, with included learned uncertainty estimation\n", + " - There is separate script for semantic segmentation with learned uncertainty estimation\n", + "- Loss based on (Sørensen -)Dice coefficient is utilized due to favorable properties related to unbalanced pixel counts.\n", + " - Milletari, F., Navab, N. & Ahmadi, S.-A. (2016) ‘V-Net: Fully Convolutional Neural Networks for Volumetric Medical Image Segmentation’, in 2016 Fourth International Conference on 3D Vision (3DV). 2016 Fourth International Conference on 3D Vision (3DV), pp. 565–571. Available at: https://doi.org/10.1109/3DV.2016.79.\n", + "- This implementation also takes inspiration from\n", + " - Wu, S., Heitzler, M. & Hurni, L. (2022) ‘Leveraging uncertainty estimation and spatial pyramid pooling for extracting hydrological features from scanned historical topographic maps’, GIScience & Remote Sensing, 59(1), pp. 200–214. Available at: https://doi.org/10.1080/15481603.2021.2023840.\n", + "\n", + "### The main idea\n", + "- Learns to segment areas of interest with fewer parameters than normal U-net, which reduces the need for training data and also the risk for overfitting\n", + "\n", + "### Notes\n", + "- Current implementation is experimental and needs further optimization, testing and functionality\n", + " - IMPORTANT The possibility to input a large geotiff in addition to training and testing data should be implemented. In that case the trained model wouldbe used to predict the whole area in a sliding window type of setup. Then it should be parsed back together to create output prediction and uncertainty estimate geotiffs for the whole area. This tool should not be included in the toolkit before that can be done.\n", + " - For example, hyperparameter tuning should be automatized\n", + " - Dice coefficient and Intersection over Union should be implemented as metric to measure the goodness of model\n", + " - custom metrics are needed due to the unusual shape of the output\n", + " - Data suffling should maybe moved to data sampling side\n", + " - Leave one out cross validation should also be implemented and integrated with data sampling, so that user has reliable tools to estimate possible (likely) overfitting\n", + " - current implementation with data sampler does not create reliable test data, because one occurence features multiple times in data with different croppings.\n", + " - The other option is to take out all the times one of the features occurs before suffling and keep data sampling as is \n", + "- The current implementation only works with binary classes (0 and 1)\n", + "\n", + "- Image size should be at least 32 x 32 pixels or larger power of 2 (or at least divisible three times with 2, after which size should be at least 3 x 3)\n", + "- Using either data from automatic sampling function or user's own data should be given as an option" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "460bf658-caa7-4cc1-abfa-482416657a79", + "metadata": {}, + "outputs": [], + "source": [ + "# Options\n", + "# Random seed, TODO randomness should be moved to the data generation side\n", + "seed = 1\n", + "\"\"\"Geotiff image folder, containing the data.\n", + "Image size should be at least 32 x 32 pixels or larger power of 2 (or at least divisible three times with 2, after which size should be at least 3 x 3)\n", + "It should be given as an option to use either data from automatic sampling function or user's own data\n", + "\"\"\"\n", + "img_dir = \"/home/iiro/Documents/Työ/data/testing/cnn/data/buffer_images\"\n", + "# Geotiff image folder, containing the labels, where 1 means wanted class and zero means background. Should be the same size as images\n", + "label_dir = \"/home/iiro/Documents/Työ/data/testing/cnn/data/buffer_labels\"\n", + "\n", + "# Too many epochs results in overfitting\n", + "epoch_count = 6\n", + "\n", + "batch_size = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9ab68ed8-bd9e-4985-8b84-b5fa75d6a898", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-10-11 13:47:03.620101: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "import rasterio\n", + "import glob\n", + "import os\n", + "import random\n", + "\n", + "import numpy as np\n", + "import numpy.ma as ma\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from tensorflow import keras\n", + "from keras import backend as K\n", + "from keras.optimizers import SGD\n", + "from tensorflow.keras.layers import Activation, Input, Dense, Conv2D, MaxPooling2D, UpSampling2D, Conv2DTranspose, BatchNormalization, Dropout, concatenate, Multiply, RandomFlip, RandomRotation, RandomTranslation, RandomCrop\n", + "from tensorflow.keras.models import Model\n", + "from tensorflow.keras import backend as K \n", + "from tensorflow.keras import losses\n", + "from tensorflow.keras.preprocessing.image import ImageDataGenerator, load_img, img_to_array\n", + "from tensorflow.keras.regularizers import l1, l2\n", + "from keras.callbacks import EarlyStopping" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "77fa33bc-92d9-4079-9640-5c10c515348a", + "metadata": {}, + "outputs": [], + "source": [ + "def img_loader(image_dir):\n", + " \"\"\" Fetches all the tiffs in the given directory and creates a numpy ndarray of shape (image_count, bands, width, height) from them.\n", + " Returns the array, tiff metadata as list and associated nodatamasks in shape (image_count, width, height)\n", + " Tiffs are assumed to be same size and named {number}.tif starting from 0\n", + " \"\"\"\n", + " # fetching the filepaths\n", + " paths = []\n", + " metas = []\n", + " for path in glob.glob(os.path.join(image_dir, \"*.tif\")):\n", + " paths.append(path)\n", + " \n", + " img_count = len(paths)\n", + "\n", + " # Getting the size of the images\n", + " with rasterio.open(paths[0]) as src:\n", + " meta = src.meta.copy()\n", + " image_width = meta['width']\n", + " image_height = meta['height']\n", + " \n", + " nodata_masks = np.empty((img_count, image_width, image_height), dtype='bool') \n", + " for i in range(img_count):\n", + " path = os.path.join(image_dir, str(i) + \".tif\")\n", + " with rasterio.open(path) as src:\n", + " meta = src.meta.copy()\n", + " metas.append(meta)\n", + " # Note: rasterio returns shape (bands, width, height)\n", + " img_arr = np.empty((meta['count'], image_width, image_height,), dtype=meta['dtype'])\n", + " \n", + " # Normalizing the data between 0 and 1. Differing bands have different values so they are processed separately\n", + " # Rasterio follows GDAL convention and starts band numbering from 1\n", + " for band_n in range(1, meta['count'] + 1):\n", + " \"\"\"There might be slight differences in the nodatamasks between the bands, they are all ANDed together\n", + " to create a mask that covers all the nodata patches in all bands.\n", + " Therefore nodata processing needs to be inside this loop\n", + " \"\"\"\n", + " nodata_mask = src.read_masks(band_n)\n", + " \"\"\"Changing the mask to reflect numpy convention instead of gdal.\n", + " Invalid entries have a value of 1 or True, and valid have values of 0 or False. \n", + " \"\"\"\n", + " nodata_mask = nodata_mask == 0\n", + " if band_n == 1: \n", + " nodata_mask_full = nodata_mask\n", + " else:\n", + " nodata_mask_full = np.logical_and(nodata_mask_full, nodata_mask, out=nodata_mask_full)\n", + "\n", + " #normalization\n", + " band_arr = src.read(band_n)\n", + " # Setting nodatamasks to zero\n", + " band_arr[band_arr==-999999] = 0\n", + " band_arr_masked = ma.masked_array(band_arr, mask=nodata_mask)\n", + " minimum = band_arr_masked.min()\n", + " maximum = band_arr_masked.max()\n", + " band_arr = (band_arr_masked - minimum)/ (maximum-minimum)\n", + " img_arr[band_n-1] = band_arr\n", + " \n", + " nodata_masks[i] = nodata_mask_full\n", + " # Storing array needs to be created only on the first iteration. \n", + " # All images are assumed to be same size and dtype, so the meta of the first one is used\n", + " if i==0:\n", + " data_arr = np.empty((img_count, meta['count'], meta['width'], meta['height']), dtype=meta['dtype'])\n", + " data_arr[i] = img_arr\n", + " \n", + " data_arr = np.moveaxis(data_arr, 1, -1)\n", + " return data_arr, metas, nodata_masks\n", + "\n", + "def label_loader(label_dir):\n", + " \"\"\"Fetches all the tiffs in the given directory and return a numpy ndarray of shape (image_count, width, height).\n", + " The images are assumed to be same size and contain the labels with numbers showing classes. \n", + " The tiffs should have only one band,\n", + " \"\"\"\n", + " # fetching the filepaths\n", + " paths = []\n", + " for path in glob.glob(os.path.join(label_dir, \"*.tif\")):\n", + " paths.append(path)\n", + " \n", + " img_count = len(paths)\n", + " \n", + " # Getting the size of the images\n", + " with rasterio.open(paths[0]) as src:\n", + " meta = src.meta.copy()\n", + " nodata_value = meta['nodata']\n", + " data_arr = np.empty((img_count, meta['count'], meta['width'], meta['height']), dtype='float32')\n", + " \n", + " for i in range(img_count):\n", + " path = os.path.join(label_dir, str(i) + \".tif\")\n", + " with rasterio.open(path) as src:\n", + " img_arr = src.read(1)\n", + " #TODO add nodata handling. It could be a good idea to add 1 to the values and set the nodata pixel value as 0 \n", + " # Or maybe nodata as zeros is just fine\n", + " img_arr[img_arr == 255] = 0\n", + " # moving band count(1) to last place\n", + " img_arr = img_arr.astype('float32') \n", + " data_arr[i] = img_arr\n", + " data_arr = np.moveaxis(data_arr, 1, -1)\n", + " return data_arr, nodata_value\n", + "\n", + "def keras_dice_coefficient(prediction, true_label):\n", + " numerator = 2 * tf.reduce_sum(prediction * true_label)\n", + " divisor = tf.reduce_sum(prediction ** 2) + tf.reduce_sum(true_label ** 2)\n", + " return numerator / divisor\n", + "\n", + "def keras_dice_loss(prediction, true_label):\n", + " DC = keras_dice_coefficient(prediction, true_label)\n", + " dice_loss = 1 - DC\n", + " return dice_loss\n", + " \n", + "# Multi-channel autoencoder (modality determines the number of channels)\n", + "def build_autoencoder_multichannel_skip(resolution, modality, dropout=0.2, regularization=0):\n", + " # List to hold all input layers\n", + " input_img = Input(shape=(resolution, resolution, modality))\n", + " \n", + " # Encoder paths for each image\n", + " encoded_imgs = []\n", + " skip_connections = []\n", + " \n", + "\t# Encoder block 1, 32 res\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(input_img)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " skip_connections.append(x)\n", + " x = MaxPooling2D((2, 2), padding='same')(x) \n", + "\n", + " # Encoder block 2, 16 res\n", + " x = Conv2D(64, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Conv2D(64, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " skip_connections.append(x)\n", + " x = MaxPooling2D((2, 2), padding='same')(x)\n", + "\n", + "\t# Encoder block 3, 8 x 8 res\n", + " x = Conv2D(128, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(128, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " skip_connections.append(x)\n", + " x = MaxPooling2D((2, 2), padding='same')(x)\n", + "\n", + " encoded_imgs.append(x)\n", + " \n", + " \n", + " # Decoder\n", + " \n", + " # Decoder block 1\n", + " skip_1 = skip_connections[-1] # Corresponding output from the encoder\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(256, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Conv2D(128, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " x = UpSampling2D((2, 2))(x)\n", + " x = concatenate([x, skip_1], axis =-1)\n", + " \n", + " # Decoder block 2\n", + " skip_2 = skip_connections[-2] # Corresponding output from the encoder\n", + " x = Conv2D(128, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(64, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " x = UpSampling2D((2, 2))(x)\n", + " x = concatenate([x, skip_2], axis =-1)\n", + "\n", + " # Decoder block 2\n", + " skip_3 = skip_connections[-3] # Corresponding output from the encoder\n", + " x = Conv2D(64, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " x = UpSampling2D((2, 2))(x)\n", + " x = concatenate([x, skip_3], axis =-1)\n", + " \n", + " # Output Layer\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " # activation with normalized tanh should be considered because it has steeper gradients\n", + " decoded = Conv2D(1, (1, 1), activation='sigmoid', padding='same')(x)\n", + " # Uncertainty output\n", + " \n", + " \n", + " # Create the model\n", + " autoencoder_multi_channel = Model(input_img, decoded)\n", + " \n", + " return autoencoder_multi_channel" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a797ebea-1ca7-48bd-9077-3be7537f533e", + "metadata": {}, + "outputs": [], + "source": [ + "data_arr, metas, nodata_masks = img_loader(img_dir)\n", + "# Labels, which contain\n", + "label_arr, label_nodata_value = label_loader(label_dir)\n", + "# TODO move the shuffling to the image generator side so that other metadata doesn't need to be shuffled identically to data when constructing \n", + "\n", + "# Suffling the images and the labels, because currently the sampler (data creator, separate script) creates \n", + "rng = np.random.default_rng(seed=seed)\n", + "rng.shuffle(data_arr, axis=0)\n", + "# Resetting the rng because we need same suffling for labels\n", + "rng = np.random.default_rng(seed=seed)\n", + "rng.shuffle(label_arr, axis=0)\n", + "\n", + "image_count = data_arr.shape[0]\n", + "train_count = round(image_count * 0.7)\n", + "test_count = image_count - train_count\n", + "training_data = data_arr[0:train_count]\n", + "training_labels = label_arr[0:train_count]\n", + "test_data = data_arr[train_count:]\n", + "test_labels = label_arr[train_count:]\n", + "\n", + "band_count = data_arr.shape[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "579cf1c9-f19a-42f5-bae6-1c59c4d63639", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20205\n", + "2051072\n", + "10\n" + ] + } + ], + "source": [ + "# For developing\n", + "unique, counts = np.unique(label_arr, return_counts=True)\n", + "imbalance = dict(zip(unique, counts))\n", + "occurence_count = imbalance[1]\n", + "total_count = label_arr.size\n", + "print(occurence_count)\n", + "print(total_count)\n", + "print(band_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6a6deec0-2272-4920-8571-f1026089b7dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2003, 32, 32, 10)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plt.imshow(nodata_masks[32])\n", + "plt.imshow(training_data[1,:,:, 6], vmin=0, vmax=1)\n", + "plt.colorbar()\n", + "print(data_arr.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7a7b698a-7d7b-4ab6-92a2-329403139304", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "float32\n", + "1.0\n", + "(2003, 32, 32, 1)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.squeeze(training_labels[1]), vmin=0, vmax=1)\n", + "plt.colorbar()\n", + "print(label_arr.dtype)\n", + "print(label_arr.max())\n", + "print(label_arr.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ecd92d2a-843c-401d-9795-1ac9f050043b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_2 (InputLayer) [(None, 32, 32, 10) 0 [] \n", + " ] \n", + " \n", + " conv2d (Conv2D) (None, 32, 32, 32) 2912 ['input_2[0][0]'] \n", + " \n", + " batch_normalization (BatchNorm (None, 32, 32, 32) 128 ['conv2d[0][0]'] \n", + " alization) \n", + " \n", + " activation (Activation) (None, 32, 32, 32) 0 ['batch_normalization[0][0]'] \n", + " \n", + " conv2d_1 (Conv2D) (None, 32, 32, 32) 9248 ['activation[0][0]'] \n", + " \n", + " batch_normalization_1 (BatchNo (None, 32, 32, 32) 128 ['conv2d_1[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_1 (Activation) (None, 32, 32, 32) 0 ['batch_normalization_1[0][0]'] \n", + " \n", + " max_pooling2d (MaxPooling2D) (None, 16, 16, 32) 0 ['activation_1[0][0]'] \n", + " \n", + " conv2d_2 (Conv2D) (None, 16, 16, 64) 18496 ['max_pooling2d[0][0]'] \n", + " \n", + " batch_normalization_2 (BatchNo (None, 16, 16, 64) 256 ['conv2d_2[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_2 (Activation) (None, 16, 16, 64) 0 ['batch_normalization_2[0][0]'] \n", + " \n", + " conv2d_3 (Conv2D) (None, 16, 16, 64) 36928 ['activation_2[0][0]'] \n", + " \n", + " batch_normalization_3 (BatchNo (None, 16, 16, 64) 256 ['conv2d_3[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_3 (Activation) (None, 16, 16, 64) 0 ['batch_normalization_3[0][0]'] \n", + " \n", + " max_pooling2d_1 (MaxPooling2D) (None, 8, 8, 64) 0 ['activation_3[0][0]'] \n", + " \n", + " conv2d_4 (Conv2D) (None, 8, 8, 128) 73856 ['max_pooling2d_1[0][0]'] \n", + " \n", + " batch_normalization_4 (BatchNo (None, 8, 8, 128) 512 ['conv2d_4[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_4 (Activation) (None, 8, 8, 128) 0 ['batch_normalization_4[0][0]'] \n", + " \n", + " dropout (Dropout) (None, 8, 8, 128) 0 ['activation_4[0][0]'] \n", + " \n", + " conv2d_5 (Conv2D) (None, 8, 8, 128) 147584 ['dropout[0][0]'] \n", + " \n", + " batch_normalization_5 (BatchNo (None, 8, 8, 128) 512 ['conv2d_5[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_5 (Activation) (None, 8, 8, 128) 0 ['batch_normalization_5[0][0]'] \n", + " \n", + " max_pooling2d_2 (MaxPooling2D) (None, 4, 4, 128) 0 ['activation_5[0][0]'] \n", + " \n", + " dropout_1 (Dropout) (None, 4, 4, 128) 0 ['max_pooling2d_2[0][0]'] \n", + " \n", + " conv2d_6 (Conv2D) (None, 4, 4, 256) 295168 ['dropout_1[0][0]'] \n", + " \n", + " batch_normalization_6 (BatchNo (None, 4, 4, 256) 1024 ['conv2d_6[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_6 (Activation) (None, 4, 4, 256) 0 ['batch_normalization_6[0][0]'] \n", + " \n", + " conv2d_7 (Conv2D) (None, 4, 4, 128) 295040 ['activation_6[0][0]'] \n", + " \n", + " batch_normalization_7 (BatchNo (None, 4, 4, 128) 512 ['conv2d_7[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_7 (Activation) (None, 4, 4, 128) 0 ['batch_normalization_7[0][0]'] \n", + " \n", + " up_sampling2d (UpSampling2D) (None, 8, 8, 128) 0 ['activation_7[0][0]'] \n", + " \n", + " concatenate (Concatenate) (None, 8, 8, 256) 0 ['up_sampling2d[0][0]', \n", + " 'activation_5[0][0]'] \n", + " \n", + " conv2d_8 (Conv2D) (None, 8, 8, 128) 295040 ['concatenate[0][0]'] \n", + " \n", + " batch_normalization_8 (BatchNo (None, 8, 8, 128) 512 ['conv2d_8[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_8 (Activation) (None, 8, 8, 128) 0 ['batch_normalization_8[0][0]'] \n", + " \n", + " dropout_2 (Dropout) (None, 8, 8, 128) 0 ['activation_8[0][0]'] \n", + " \n", + " conv2d_9 (Conv2D) (None, 8, 8, 64) 73792 ['dropout_2[0][0]'] \n", + " \n", + " batch_normalization_9 (BatchNo (None, 8, 8, 64) 256 ['conv2d_9[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_9 (Activation) (None, 8, 8, 64) 0 ['batch_normalization_9[0][0]'] \n", + " \n", + " up_sampling2d_1 (UpSampling2D) (None, 16, 16, 64) 0 ['activation_9[0][0]'] \n", + " \n", + " concatenate_1 (Concatenate) (None, 16, 16, 128) 0 ['up_sampling2d_1[0][0]', \n", + " 'activation_3[0][0]'] \n", + " \n", + " conv2d_10 (Conv2D) (None, 16, 16, 64) 73792 ['concatenate_1[0][0]'] \n", + " \n", + " batch_normalization_10 (BatchN (None, 16, 16, 64) 256 ['conv2d_10[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_10 (Activation) (None, 16, 16, 64) 0 ['batch_normalization_10[0][0]'] \n", + " \n", + " dropout_3 (Dropout) (None, 16, 16, 64) 0 ['activation_10[0][0]'] \n", + " \n", + " conv2d_11 (Conv2D) (None, 16, 16, 32) 18464 ['dropout_3[0][0]'] \n", + " \n", + " batch_normalization_11 (BatchN (None, 16, 16, 32) 128 ['conv2d_11[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_11 (Activation) (None, 16, 16, 32) 0 ['batch_normalization_11[0][0]'] \n", + " \n", + " up_sampling2d_2 (UpSampling2D) (None, 32, 32, 32) 0 ['activation_11[0][0]'] \n", + " \n", + " concatenate_2 (Concatenate) (None, 32, 32, 64) 0 ['up_sampling2d_2[0][0]', \n", + " 'activation_1[0][0]'] \n", + " \n", + " conv2d_12 (Conv2D) (None, 32, 32, 32) 18464 ['concatenate_2[0][0]'] \n", + " \n", + " batch_normalization_12 (BatchN (None, 32, 32, 32) 128 ['conv2d_12[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_12 (Activation) (None, 32, 32, 32) 0 ['batch_normalization_12[0][0]'] \n", + " \n", + " dropout_4 (Dropout) (None, 32, 32, 32) 0 ['activation_12[0][0]'] \n", + " \n", + " conv2d_13 (Conv2D) (None, 32, 32, 32) 9248 ['dropout_4[0][0]'] \n", + " \n", + " batch_normalization_13 (BatchN (None, 32, 32, 32) 128 ['conv2d_13[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_13 (Activation) (None, 32, 32, 32) 0 ['batch_normalization_13[0][0]'] \n", + " \n", + " conv2d_14 (Conv2D) (None, 32, 32, 1) 33 ['activation_13[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 1,372,801\n", + "Trainable params: 1,370,433\n", + "Non-trainable params: 2,368\n", + "__________________________________________________________________________________________________\n", + "Epoch 1/6\n", + "62/62 [==============================] - 9s 117ms/step - loss: 0.9582 - val_loss: 0.9583\n", + "Epoch 2/6\n", + "62/62 [==============================] - 7s 112ms/step - loss: 0.8873 - val_loss: 0.9140\n", + "Epoch 3/6\n", + "62/62 [==============================] - 7s 108ms/step - loss: 0.6061 - val_loss: 0.6821\n", + "Epoch 4/6\n", + "62/62 [==============================] - 7s 109ms/step - loss: 0.3717 - val_loss: 0.3971\n", + "Epoch 5/6\n", + "62/62 [==============================] - 7s 110ms/step - loss: 0.2770 - val_loss: 0.3758\n", + "Epoch 6/6\n", + "62/62 [==============================] - 7s 109ms/step - loss: 0.1884 - val_loss: 0.2325\n" + ] + } + ], + "source": [ + "# Training is stopped if validation loss hasn't improved in 3 epochs\n", + "callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=3)\n", + "# Data augmentation\n", + "mode = None\n", + "model = Input(shape=(32, 32, 10))\n", + "model = RandomFlip()(model)\n", + "model = RandomCrop(28, 28)(model)\n", + "model = RandomRotation((-0.3, 0.3))(model)\n", + "# mini-unet\n", + "model = build_autoencoder_multichannel_skip(32, 10)\n", + "\n", + "model.compile(\n", + " optimizer=SGD(learning_rate=0.008, decay=1e-6, momentum=0.9),\n", + " loss=keras_dice_loss)\n", + "\n", + "model.summary()\n", + "\n", + "history = model.fit(training_data, training_labels, batch_size=batch_size, epochs=epoch_count, validation_split=0.3, callbacks=[callback])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d2f3e5e5-f9b3-4222-8256-5e001447cd39", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "19/19 [==============================] - 1s 39ms/step - loss: 0.2325\n", + "19/19 [==============================] - 1s 39ms/step\n", + "44/44 [==============================] - 2s 41ms/step\n" + ] + } + ], + "source": [ + "model.evaluate(test_data, test_labels)\n", + "prediction = model.predict(test_data)\n", + "train_prediction = model.predict(training_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "fc1b2ebc-2172-4ced-af06-7f91019cadf9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pltsize = 3\n", + "index = random.randint(5, test_count)\n", + "# Predictions\n", + "plt.figure(figsize=(5*pltsize, 3 * pltsize))\n", + "for j, i in enumerate(range(index - 5, index)):\n", + " plt.subplot(1,5,j+1)\n", + " plt.axis('off')\n", + " plt.suptitle('Prediction', y=0.7)\n", + " plt.imshow(prediction[i,:,:], vmin=0, vmax=1)\n", + " plt.colorbar(fraction=0.05)\n", + "# Ground truth\n", + "plt.figure(figsize=(5*pltsize, 3 * pltsize))\n", + "for j, i in enumerate(range(index - 5, index)):\n", + " plt.subplot(1,5,j+1)\n", + " plt.axis('off')\n", + " plt.suptitle('Ground truth', y=0.7)\n", + " plt.imshow(test_labels[i], vmin=0, vmax=1)\n", + "\n", + "plt.figure(figsize=(5*pltsize, 3 * pltsize))\n", + "for j, i in enumerate(range(index - 5, index)):\n", + " plt.subplot(1,5,j+1)\n", + " plt.axis('off')\n", + " plt.suptitle('Aeromagnetic anomaly', y=0.7)\n", + " plt.imshow(test_data[i, :, :, 8], vmin=0, vmax=1)" + ] + }, + { + "cell_type": "markdown", + "id": "897f6460-d843-4fd0-9c12-b6912925063d", + "metadata": {}, + "source": [ + "### TODO \n", + "- The outputs need to be changed back to geotiffs with the saved data and nodata masks\n", + "- The current implementation makes this a bit hard since suffling the images is done after separating the images and metadata. The suffling should be moved to data generation side or the images should be unsuffled" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8620ac73-9ef2-4b0b-a0cb-16a69036fc08", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/Mini_Unet_with_uncertainty.ipynb b/notebooks/Mini_Unet_with_uncertainty.ipynb new file mode 100644 index 00000000..be302c3f --- /dev/null +++ b/notebooks/Mini_Unet_with_uncertainty.ipynb @@ -0,0 +1,859 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4dfcd0fd-78ac-44df-a6bb-3537db11b591", + "metadata": {}, + "source": [ + "# Mini U-net with learned uncertainty estimation\n", + "- Semantic segmentation for (small) images, with included learned uncertainty estimation\n", + " - There is separate script for semantic segmentation without uncertainty estimation\n", + "- The idea is based on\n", + " - DeVries, T., and G. W. Taylor. 2018b. “Leveraging Uncertainty Estimates for Predicting Segmentation Quality. https://arxiv.org/abs/1807.00502\n", + "- This implementation takes strong inspiration from\n", + " - Wu, S., Heitzler, M. & Hurni, L. (2022) ‘Leveraging uncertainty estimation and spatial pyramid pooling for extracting hydrological features from scanned historical topographic maps’, GIScience & Remote Sensing, 59(1), pp. 200–214. Available at: https://doi.org/10.1080/15481603.2021.2023840.\n", + "- Loss based on (Sørensen -)Dice coefficient is utilized due to favorable properties related to unbalanced pixel counts.\n", + " - Milletari, F., Navab, N. & Ahmadi, S.-A. (2016) ‘V-Net: Fully Convolutional Neural Networks for Volumetric Medical Image Segmentation’, in 2016 Fourth International Conference on 3D Vision (3DV). 2016 Fourth International Conference on 3D Vision (3DV), pp. 565–571. Available at: https://doi.org/10.1109/3DV.2016.79.\n", + " \n", + "\n", + "### To summarise the main idea\n", + "- In addition to segmentation, the model is asked to create certainty estimation\n", + "- When overall certainty is high (close to 1) the loss function operates as if no certainty estimate was used \n", + "- When certainty values dip below 1, the model is punished less for making mistakes at those pixels.\n", + " - When certainty is close to zero at certain pixel, the model segmentation output does not matter at all for the loss at that pixel\n", + "- To prevent model predicting high uncertainty everywhere, it is punished for being uncertain at large areas\n", + " - This is done by averaging logarithm of the uncertainties at each pixel * -1 together\n", + " - This regularization loss is multiplied with a hyperparameter called uncertainty coefficient\n", + " - The value of the uncertainty coefficient has a large effect on the results, and finding suitable value should be automatised (not yet implemented)\n", + " - Too small values result in poor segmentation results\n", + " - Too large values result in abolute certainty everywhere\n", + " - Suitable value creates resulting values between full range of zero and one for both segmentation prediction and certainty estimate\n", + " - Thus closer (max cert - min cert) + (max pred - min pred) is to to 2, the better the uncertainty coefficient. This could be used as a basis for optimisation\n", + "\n", + "### Notes\n", + "- Current implementation is experimental and needs further optimization, testing and functionality \n", + " - IMPORTANT The possibility to input a large geotiff should be implemented. In that case the trained model should be used to predict the whole area in a sliding window type of setup. Then it should be parsed back together to create output prediction and uncertainty estimate geotiffs for the whole area. This tool should not be included in the toolkit before that can be done.\n", + " - hyperparameter tuning should be automatized\n", + " - Dice coefficient and Intersection over Union should be implemented as metric to measure the goodness of model\n", + " - custom metrics are needed due to the unusual shape of the output\n", + " - Data suffling should maybe moved to data sampling side\n", + " - Leave one out cross validation should also be implemented and integrated with data sampling, so that user has reliable tools to estimate possible (likely) overfitting\n", + " - current implementation with data sampler does not create reliable test data, because one occurence features multiple times in data with different croppings.\n", + " - The other option is to take out all the times one of the features occurs before suffling and keep data sampling as is\n", + "- The current implementation only works with binary classes (0 and 1)\n", + "- Image size should be at least 32 x 32 pixels or larger power of 2 (or at least divisible three times with 2, after which size should be at least 3 x 3)\n", + "- Using either data from automatic sampling function or user's own data should be given as an option\n", + "- The model needs to be trained long enough so that it produces both prediction and uncertainty, even if the uncertainty punishment coefficient is correct. The balancing is quite intricate and highlights the need for automatic hyperparametrisation" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "460bf658-caa7-4cc1-abfa-482416657a79", + "metadata": {}, + "outputs": [], + "source": [ + "# Options\n", + "# Random seed, TODO randomness should be moved to the data generation side\n", + "seed = 1\n", + "\"\"\"Geotiff image folder, containing the data.\n", + "Image size should be a square, at least 32 x 32 pixels or larger power of 2 (or at least divisible three times with 2, after which size should be at least 3 x 3)\n", + "It should be given as an option to use either data from automatic sampling function or user's own data\n", + "\"\"\"\n", + "img_dir = \"/home/iiro/Documents/Työ/data/testing/cnn/data/buffer_images\"\n", + "# Geotiff image folder, containing the labels, where 1 means wanted class and zero means background. Should be the same size as images\n", + "label_dir = \"/home/iiro/Documents/Työ/data/testing/cnn/data/buffer_labels\"\n", + "# A good value for the used dataset, may change depending on the data\n", + "uncertainty_coefficient = 0.35\n", + "# Too many epochs results in overfitting, the best uncertainty estimations are produced when the model can not yet make perfect predictions because it remembers all the features\n", + "# However, uncertainty estimation seems to work as a sort of reguralizer, allowing for larger amount of epochs than without it\n", + "epoch_count = 15\n", + "\n", + "batch_size = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9ab68ed8-bd9e-4985-8b84-b5fa75d6a898", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-10-11 14:11:05.825229: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: SSE4.1 SSE4.2 AVX AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" + ] + } + ], + "source": [ + "import tensorflow as tf\n", + "import rasterio\n", + "import glob\n", + "import os\n", + "import random\n", + "\n", + "import numpy as np\n", + "import numpy.ma as ma\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from tensorflow import keras\n", + "from keras import backend as K\n", + "from keras.optimizers import SGD\n", + "from tensorflow.keras.layers import Activation, Input, Dense, Conv2D, MaxPooling2D, UpSampling2D, Conv2DTranspose, BatchNormalization, Dropout, concatenate, Multiply, RandomFlip, RandomRotation, RandomTranslation, RandomCrop\n", + "from tensorflow.keras.models import Model\n", + "from tensorflow.keras import backend as K \n", + "from tensorflow.keras import losses\n", + "from tensorflow.keras.preprocessing.image import ImageDataGenerator, load_img, img_to_array\n", + "from tensorflow.keras.regularizers import l1, l2\n", + "from keras.callbacks import EarlyStopping" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "77fa33bc-92d9-4079-9640-5c10c515348a", + "metadata": {}, + "outputs": [], + "source": [ + "def img_loader(image_dir):\n", + " \"\"\" Fetches all the tiffs in the given directory and creates a numpy ndarray of shape (image_count, bands, width, height) from them.\n", + " Returns the array, tiff metadata as list and associated nodatamasks in shape (image_count, width, height)\n", + " Tiffs are assumed to be same size and named {number}.tif starting from 0\n", + " \"\"\"\n", + " # fetching the filepaths\n", + " paths = []\n", + " metas = []\n", + " for path in glob.glob(os.path.join(image_dir, \"*.tif\")):\n", + " paths.append(path)\n", + " \n", + " img_count = len(paths)\n", + "\n", + " # Getting the size of the images\n", + " with rasterio.open(paths[0]) as src:\n", + " meta = src.meta.copy()\n", + " image_width = meta['width']\n", + " image_height = meta['height']\n", + " \n", + " nodata_masks = np.empty((img_count, image_width, image_height), dtype='bool') \n", + " for i in range(img_count):\n", + " path = os.path.join(image_dir, str(i) + \".tif\")\n", + " with rasterio.open(path) as src:\n", + " meta = src.meta.copy()\n", + " metas.append(meta)\n", + " # Note: rasterio returns shape (bands, width, height)\n", + " img_arr = np.empty((meta['count'], image_width, image_height,), dtype=meta['dtype'])\n", + " \n", + " # Normalizing the data between 0 and 1. Differing bands have different values so they are processed separately\n", + " # Rasterio follows GDAL convention and starts band numbering from 1\n", + " for band_n in range(1, meta['count'] + 1):\n", + " \"\"\"There might be slight differences in the nodatamasks between the bands, they are all ANDed together\n", + " to create a mask that covers all the nodata patches in all bands.\n", + " Therefore nodata processing needs to be inside this loop\n", + " \"\"\"\n", + " nodata_mask = src.read_masks(band_n)\n", + " \"\"\"Changing the mask to reflect numpy convention instead of gdal.\n", + " Invalid entries have a value of 1 or True, and valid have values of 0 or False. \n", + " \"\"\"\n", + " nodata_mask = nodata_mask == 0\n", + " if band_n == 1: \n", + " nodata_mask_full = nodata_mask\n", + " else:\n", + " nodata_mask_full = np.logical_and(nodata_mask_full, nodata_mask, out=nodata_mask_full)\n", + "\n", + " #normalization\n", + " band_arr = src.read(band_n)\n", + " # Setting nodatamasks to zero\n", + " band_arr[band_arr==-999999] = 0\n", + " band_arr_masked = ma.masked_array(band_arr, mask=nodata_mask)\n", + " minimum = band_arr_masked.min()\n", + " maximum = band_arr_masked.max()\n", + " band_arr = (band_arr_masked - minimum)/ (maximum-minimum)\n", + " img_arr[band_n-1] = band_arr\n", + " \n", + " nodata_masks[i] = nodata_mask_full\n", + " # Storing array needs to be created only on the first iteration. \n", + " # All images are assumed to be same size and dtype, so the meta of the first one is used\n", + " if i==0:\n", + " data_arr = np.empty((img_count, meta['count'], meta['width'], meta['height']), dtype=meta['dtype'])\n", + " data_arr[i] = img_arr\n", + " \n", + " data_arr = np.moveaxis(data_arr, 1, -1)\n", + " return data_arr, metas, nodata_masks\n", + "\n", + "def label_loader(label_dir):\n", + " \"\"\"Fetches all the tiffs in the given directory and return a numpy ndarray of shape (image_count, width, height).\n", + " The images are assumed to be same size and contain the labels with numbers showing classes. \n", + " The tiffs should have only one band,\n", + " \"\"\"\n", + " # fetching the filepaths\n", + " paths = []\n", + " for path in glob.glob(os.path.join(label_dir, \"*.tif\")):\n", + " paths.append(path)\n", + " \n", + " img_count = len(paths)\n", + " \n", + " # Getting the size of the images\n", + " with rasterio.open(paths[0]) as src:\n", + " meta = src.meta.copy()\n", + " nodata_value = meta['nodata']\n", + " data_arr = np.empty((img_count, meta['count'], meta['width'], meta['height']), dtype='float32')\n", + " \n", + " for i in range(img_count):\n", + " path = os.path.join(label_dir, str(i) + \".tif\")\n", + " with rasterio.open(path) as src:\n", + " img_arr = src.read(1)\n", + " #TODO add nodata handling. It could be a good idea to add 1 to the values and set the nodata pixel value as 0 \n", + " # Or maybe nodata as zeros is just fine\n", + " img_arr[img_arr == 255] = 0\n", + " # moving band count(1) to last place\n", + " img_arr = img_arr.astype('float32') \n", + " data_arr[i] = img_arr\n", + " data_arr = np.moveaxis(data_arr, 1, -1)\n", + " return data_arr, nodata_value\n", + " \n", + "# Multi-channel autoencoder (modality determines the number of channels)\n", + "def build_autoencoder_multichannel_skip(resolution, modality, dropout=0.2, regularization=0):\n", + " # List to hold all input layers\n", + " input_img = Input(shape=(resolution, resolution, modality))\n", + " \n", + " # Encoder paths for each image\n", + " encoded_imgs = []\n", + " skip_connections = []\n", + " \n", + "\t# Encoder block 1, 32 res\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(input_img)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " skip_connections.append(x)\n", + " x = MaxPooling2D((2, 2), padding='same')(x) \n", + "\n", + " # Encoder block 2, 16 res\n", + " x = Conv2D(64, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Conv2D(64, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " skip_connections.append(x)\n", + " x = MaxPooling2D((2, 2), padding='same')(x)\n", + "\n", + "\t# Encoder block 3, 8 x 8 res\n", + " x = Conv2D(128, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(128, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " skip_connections.append(x)\n", + " x = MaxPooling2D((2, 2), padding='same')(x)\n", + "\n", + " encoded_imgs.append(x)\n", + " \n", + " \n", + " # Decoder\n", + " \n", + " # Decoder block 1\n", + " skip_1 = skip_connections[-1] # Corresponding output from the encoder\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(256, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Conv2D(128, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " x = UpSampling2D((2, 2))(x)\n", + " x = concatenate([x, skip_1], axis =-1)\n", + " \n", + " # Decoder block 2\n", + " skip_2 = skip_connections[-2] # Corresponding output from the encoder\n", + " x = Conv2D(128, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(64, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " x = UpSampling2D((2, 2))(x)\n", + " x = concatenate([x, skip_2], axis =-1)\n", + "\n", + " # Decoder block 2\n", + " skip_3 = skip_connections[-3] # Corresponding output from the encoder\n", + " x = Conv2D(64, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " x = UpSampling2D((2, 2))(x)\n", + " x = concatenate([x, skip_3], axis =-1)\n", + " \n", + " # Output Layer\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " x = Dropout(dropout)(x)\n", + " x = Conv2D(32, (3, 3), padding='same', kernel_regularizer=l1(regularization))(x)\n", + " x = BatchNormalization()(x)\n", + " x = Activation('relu')(x)\n", + " \n", + " # activation with normalized tanh should be considered because it has steeper gradients\n", + " decoded = Conv2D(2, (1, 1), activation='sigmoid', padding='same')(x)\n", + " # Uncertainty output\n", + " \n", + " \n", + " # Create the model\n", + " autoencoder_multi_channel = Model(input_img, decoded)\n", + " \n", + " return autoencoder_multi_channel\n", + "\n", + "def DiceCoeff_Uncertain(y_true, y_pred, uncertainmask, smooth=1e-6):\n", + " \"\"\" From Wu, S., Heitzler, M. & Hurni, L. (2022) \n", + " ‘Leveraging uncertainty estimation and spatial pyramid pooling for extracting hydrological features from scanned historical topographic maps’,\n", + " GIScience & Remote Sensing, 59(1), pp. 200–214. Available at: https://doi.org/10.1080/15481603.2021.2023840.\n", + " \"\"\"\n", + " if uncertainmask != None:\n", + " # interpolate the value using the predicted uncertainty\n", + " y_pred = (K.ones_like(uncertainmask) - uncertainmask) * \\\n", + " y_true + uncertainmask * y_pred\n", + "\n", + " # want the dice coefficient should always be in 0 and 1\n", + " intersection = K.sum(y_true * y_pred)\n", + " dice = (2.*intersection) / (K.sum(y_true) + K.sum(y_pred) + smooth)\n", + " mask = K.cast(K.not_equal(K.sum(y_true) +\n", + " K.sum(y_pred) - intersection, 0), 'float32')\n", + "\n", + " return dice, mask\n", + "\n", + "def RegularizationLoss(y_true, y_pred):\n", + " #larger_than_zero=1e-2\n", + " num_classes = 1\n", + " y_pred_uncertain = y_pred[:, :, :, 1]\n", + " \n", + " reg_loss = K.mean(-K.log(y_pred_uncertain[:, :, :])) \n", + " \n", + " # reg_loss = (K.mean(-K.log(y_pred_uncertain[:, :, :, 0])) + K.mean(-K.log(y_pred_uncertain[:, :, :, 2])) + 0.1*K.mean(-K.log(\n", + " #y_pred_uncertain[:, :, :, 1])) + 0.15*K.mean(-K.log(y_pred_uncertain[:, :, :, 3])))/4 # give per ckass uncertainty regularization\n", + " return reg_loss\n", + "\n", + "def DiceLoss_Uncertain(y_true, y_pred, num_classes=1, smooth=1e-6, uncert_coef=uncertainty_coefficient):\n", + " \"\"\" From Wu, S., Heitzler, M. & Hurni, L. (2022) \n", + " ‘Leveraging uncertainty estimation and spatial pyramid pooling for extracting hydrological features from scanned historical topographic maps’,\n", + " GIScience & Remote Sensing, 59(1), pp. 200–214. Available at: https://doi.org/10.1080/15481603.2021.2023840.\n", + " \"\"\"\n", + " dice = []\n", + "\n", + " if y_true != None:\n", + " if num_classes != np.shape(y_true)[-1]:\n", + " return None\n", + " y_true=y_true[:,:,:,0]\n", + "\n", + " y_pred_labels = y_pred[:, :, :, 0]\n", + " y_pred_uncertain = y_pred[:, :, :, 1]\n", + " \n", + " d, m = DiceCoeff_Uncertain(\n", + " y_true, y_pred_labels, y_pred_uncertain)\n", + " if m != 0:\n", + " dice.append(d)\n", + "\n", + " dice_mutilabel = K.sum(dice)/(len(dice)+smooth)\n", + " uncertain_reg = RegularizationLoss(y_true, y_pred)\n", + " loss = 1 - dice_mutilabel + uncert_coef * uncertain_reg\n", + " return loss" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "a797ebea-1ca7-48bd-9077-3be7537f533e", + "metadata": {}, + "outputs": [], + "source": [ + "data_arr, metas, nodata_masks = img_loader(img_dir)\n", + "# Labels, which contain\n", + "label_arr, label_nodata_value = label_loader(label_dir)\n", + "# TODO move the shuffling to the image generator side so that other metadata doesn't need to be shuffled identically to data when constructing \n", + "\n", + "# Suffling the images and the labels, because currently the sampler (data creator, separate script) creates \n", + "rng = np.random.default_rng(seed=seed)\n", + "rng.shuffle(data_arr, axis=0)\n", + "# Resetting the rng because we need same suffling for labels\n", + "rng = np.random.default_rng(seed=seed)\n", + "rng.shuffle(label_arr, axis=0)\n", + "\n", + "image_count = data_arr.shape[0]\n", + "train_count = round(image_count * 0.7)\n", + "test_count = image_count - train_count\n", + "training_data = data_arr[0:train_count]\n", + "training_labels = label_arr[0:train_count]\n", + "test_data = data_arr[train_count:]\n", + "test_labels = label_arr[train_count:]\n", + "\n", + "img_width = data_arr.shape[1]\n", + "band_count = data_arr.shape[-1]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "579cf1c9-f19a-42f5-bae6-1c59c4d63639", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20205\n", + "2051072\n", + "10\n" + ] + } + ], + "source": [ + "# For developing\n", + "unique, counts = np.unique(label_arr, return_counts=True)\n", + "imbalance = dict(zip(unique, counts))\n", + "occurence_count = imbalance[1]\n", + "total_count = label_arr.size\n", + "print(occurence_count)\n", + "print(total_count)\n", + "print(band_count)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6a6deec0-2272-4920-8571-f1026089b7dd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2003, 32, 32, 10)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plt.imshow(nodata_masks[32])\n", + "plt.imshow(training_data[1,:,:, 6], vmin=0, vmax=1)\n", + "plt.colorbar()\n", + "print(data_arr.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "7a7b698a-7d7b-4ab6-92a2-329403139304", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "float32\n", + "1.0\n", + "(2003, 32, 32, 1)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(np.squeeze(training_labels[1]), vmin=0, vmax=1)\n", + "plt.colorbar()\n", + "print(label_arr.dtype)\n", + "print(label_arr.max())\n", + "print(label_arr.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ecd92d2a-843c-401d-9795-1ac9f050043b", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"model\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " input_2 (InputLayer) [(None, 32, 32, 10) 0 [] \n", + " ] \n", + " \n", + " conv2d (Conv2D) (None, 32, 32, 32) 2912 ['input_2[0][0]'] \n", + " \n", + " batch_normalization (BatchNorm (None, 32, 32, 32) 128 ['conv2d[0][0]'] \n", + " alization) \n", + " \n", + " activation (Activation) (None, 32, 32, 32) 0 ['batch_normalization[0][0]'] \n", + " \n", + " conv2d_1 (Conv2D) (None, 32, 32, 32) 9248 ['activation[0][0]'] \n", + " \n", + " batch_normalization_1 (BatchNo (None, 32, 32, 32) 128 ['conv2d_1[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_1 (Activation) (None, 32, 32, 32) 0 ['batch_normalization_1[0][0]'] \n", + " \n", + " max_pooling2d (MaxPooling2D) (None, 16, 16, 32) 0 ['activation_1[0][0]'] \n", + " \n", + " conv2d_2 (Conv2D) (None, 16, 16, 64) 18496 ['max_pooling2d[0][0]'] \n", + " \n", + " batch_normalization_2 (BatchNo (None, 16, 16, 64) 256 ['conv2d_2[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_2 (Activation) (None, 16, 16, 64) 0 ['batch_normalization_2[0][0]'] \n", + " \n", + " conv2d_3 (Conv2D) (None, 16, 16, 64) 36928 ['activation_2[0][0]'] \n", + " \n", + " batch_normalization_3 (BatchNo (None, 16, 16, 64) 256 ['conv2d_3[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_3 (Activation) (None, 16, 16, 64) 0 ['batch_normalization_3[0][0]'] \n", + " \n", + " max_pooling2d_1 (MaxPooling2D) (None, 8, 8, 64) 0 ['activation_3[0][0]'] \n", + " \n", + " conv2d_4 (Conv2D) (None, 8, 8, 128) 73856 ['max_pooling2d_1[0][0]'] \n", + " \n", + " batch_normalization_4 (BatchNo (None, 8, 8, 128) 512 ['conv2d_4[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_4 (Activation) (None, 8, 8, 128) 0 ['batch_normalization_4[0][0]'] \n", + " \n", + " dropout (Dropout) (None, 8, 8, 128) 0 ['activation_4[0][0]'] \n", + " \n", + " conv2d_5 (Conv2D) (None, 8, 8, 128) 147584 ['dropout[0][0]'] \n", + " \n", + " batch_normalization_5 (BatchNo (None, 8, 8, 128) 512 ['conv2d_5[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_5 (Activation) (None, 8, 8, 128) 0 ['batch_normalization_5[0][0]'] \n", + " \n", + " max_pooling2d_2 (MaxPooling2D) (None, 4, 4, 128) 0 ['activation_5[0][0]'] \n", + " \n", + " dropout_1 (Dropout) (None, 4, 4, 128) 0 ['max_pooling2d_2[0][0]'] \n", + " \n", + " conv2d_6 (Conv2D) (None, 4, 4, 256) 295168 ['dropout_1[0][0]'] \n", + " \n", + " batch_normalization_6 (BatchNo (None, 4, 4, 256) 1024 ['conv2d_6[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_6 (Activation) (None, 4, 4, 256) 0 ['batch_normalization_6[0][0]'] \n", + " \n", + " conv2d_7 (Conv2D) (None, 4, 4, 128) 295040 ['activation_6[0][0]'] \n", + " \n", + " batch_normalization_7 (BatchNo (None, 4, 4, 128) 512 ['conv2d_7[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_7 (Activation) (None, 4, 4, 128) 0 ['batch_normalization_7[0][0]'] \n", + " \n", + " up_sampling2d (UpSampling2D) (None, 8, 8, 128) 0 ['activation_7[0][0]'] \n", + " \n", + " concatenate (Concatenate) (None, 8, 8, 256) 0 ['up_sampling2d[0][0]', \n", + " 'activation_5[0][0]'] \n", + " \n", + " conv2d_8 (Conv2D) (None, 8, 8, 128) 295040 ['concatenate[0][0]'] \n", + " \n", + " batch_normalization_8 (BatchNo (None, 8, 8, 128) 512 ['conv2d_8[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_8 (Activation) (None, 8, 8, 128) 0 ['batch_normalization_8[0][0]'] \n", + " \n", + " dropout_2 (Dropout) (None, 8, 8, 128) 0 ['activation_8[0][0]'] \n", + " \n", + " conv2d_9 (Conv2D) (None, 8, 8, 64) 73792 ['dropout_2[0][0]'] \n", + " \n", + " batch_normalization_9 (BatchNo (None, 8, 8, 64) 256 ['conv2d_9[0][0]'] \n", + " rmalization) \n", + " \n", + " activation_9 (Activation) (None, 8, 8, 64) 0 ['batch_normalization_9[0][0]'] \n", + " \n", + " up_sampling2d_1 (UpSampling2D) (None, 16, 16, 64) 0 ['activation_9[0][0]'] \n", + " \n", + " concatenate_1 (Concatenate) (None, 16, 16, 128) 0 ['up_sampling2d_1[0][0]', \n", + " 'activation_3[0][0]'] \n", + " \n", + " conv2d_10 (Conv2D) (None, 16, 16, 64) 73792 ['concatenate_1[0][0]'] \n", + " \n", + " batch_normalization_10 (BatchN (None, 16, 16, 64) 256 ['conv2d_10[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_10 (Activation) (None, 16, 16, 64) 0 ['batch_normalization_10[0][0]'] \n", + " \n", + " dropout_3 (Dropout) (None, 16, 16, 64) 0 ['activation_10[0][0]'] \n", + " \n", + " conv2d_11 (Conv2D) (None, 16, 16, 32) 18464 ['dropout_3[0][0]'] \n", + " \n", + " batch_normalization_11 (BatchN (None, 16, 16, 32) 128 ['conv2d_11[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_11 (Activation) (None, 16, 16, 32) 0 ['batch_normalization_11[0][0]'] \n", + " \n", + " up_sampling2d_2 (UpSampling2D) (None, 32, 32, 32) 0 ['activation_11[0][0]'] \n", + " \n", + " concatenate_2 (Concatenate) (None, 32, 32, 64) 0 ['up_sampling2d_2[0][0]', \n", + " 'activation_1[0][0]'] \n", + " \n", + " conv2d_12 (Conv2D) (None, 32, 32, 32) 18464 ['concatenate_2[0][0]'] \n", + " \n", + " batch_normalization_12 (BatchN (None, 32, 32, 32) 128 ['conv2d_12[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_12 (Activation) (None, 32, 32, 32) 0 ['batch_normalization_12[0][0]'] \n", + " \n", + " dropout_4 (Dropout) (None, 32, 32, 32) 0 ['activation_12[0][0]'] \n", + " \n", + " conv2d_13 (Conv2D) (None, 32, 32, 32) 9248 ['dropout_4[0][0]'] \n", + " \n", + " batch_normalization_13 (BatchN (None, 32, 32, 32) 128 ['conv2d_13[0][0]'] \n", + " ormalization) \n", + " \n", + " activation_13 (Activation) (None, 32, 32, 32) 0 ['batch_normalization_13[0][0]'] \n", + " \n", + " conv2d_14 (Conv2D) (None, 32, 32, 2) 66 ['activation_13[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 1,372,834\n", + "Trainable params: 1,370,466\n", + "Non-trainable params: 2,368\n", + "__________________________________________________________________________________________________\n", + "Epoch 1/15\n", + "62/62 [==============================] - 9s 116ms/step - loss: 1.0782 - val_loss: 1.0677\n", + "Epoch 2/15\n", + "62/62 [==============================] - 7s 111ms/step - loss: 0.9988 - val_loss: 1.0122\n", + "Epoch 3/15\n", + "62/62 [==============================] - 7s 110ms/step - loss: 0.9838 - val_loss: 0.9884\n", + "Epoch 4/15\n", + "62/62 [==============================] - 7s 109ms/step - loss: 0.9740 - val_loss: 0.9719\n", + "Epoch 5/15\n", + "62/62 [==============================] - 7s 109ms/step - loss: 0.9643 - val_loss: 0.9558\n", + "Epoch 6/15\n", + "62/62 [==============================] - 7s 112ms/step - loss: 0.9512 - val_loss: 0.9334\n", + "Epoch 7/15\n", + "62/62 [==============================] - 8s 125ms/step - loss: 0.9278 - val_loss: 0.8833\n", + "Epoch 8/15\n", + "62/62 [==============================] - 7s 119ms/step - loss: 0.8503 - val_loss: 0.7627\n", + "Epoch 9/15\n", + "62/62 [==============================] - 7s 114ms/step - loss: 0.6067 - val_loss: 0.7350\n", + "Epoch 10/15\n", + "62/62 [==============================] - 8s 131ms/step - loss: 0.3902 - val_loss: 0.7141\n", + "Epoch 11/15\n", + "62/62 [==============================] - 7s 113ms/step - loss: 0.2798 - val_loss: 0.3797\n", + "Epoch 12/15\n", + "62/62 [==============================] - 7s 108ms/step - loss: 0.2078 - val_loss: 0.1624\n", + "Epoch 13/15\n", + "62/62 [==============================] - 7s 114ms/step - loss: 0.0739 - val_loss: 0.0691\n", + "Epoch 14/15\n", + "62/62 [==============================] - 7s 108ms/step - loss: 0.0515 - val_loss: 0.0584\n", + "Epoch 15/15\n", + "62/62 [==============================] - 6s 105ms/step - loss: 0.0450 - val_loss: 0.0553\n" + ] + } + ], + "source": [ + "# Training is stopped if validation loss hasn't improved in 3 epochs\n", + "callback = tf.keras.callbacks.EarlyStopping(monitor='val_loss', patience=3)\n", + "# Data augmentation\n", + "model = None\n", + "model = Input(shape=(img_width, img_width, band_count))\n", + "model = RandomFlip()(model)\n", + "# May not work well with larger images, should be made more general\n", + "model = RandomCrop(28, 28)(model)\n", + "model = RandomRotation((-0.3, 0.3))(model)\n", + "# mini-unet\n", + "model = build_autoencoder_multichannel_skip(img_width, band_count)\n", + "\n", + "model.compile(\n", + " optimizer=SGD(learning_rate=0.008, decay=1e-6, momentum=0.9),\n", + " loss=DiceLoss_Uncertain)\n", + "\n", + "model.summary()\n", + "\n", + "history = model.fit(training_data, training_labels, batch_size=batch_size, epochs=epoch_count, validation_split=0.3, callbacks=[callback])" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d2f3e5e5-f9b3-4222-8256-5e001447cd39", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "19/19 [==============================] - 1s 36ms/step - loss: 0.0547\n", + "19/19 [==============================] - 1s 37ms/step\n", + "44/44 [==============================] - 2s 38ms/step\n" + ] + } + ], + "source": [ + "model.evaluate(test_data, test_labels)\n", + "prediction = model.predict(test_data)\n", + "train_prediction = model.predict(training_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "fc1b2ebc-2172-4ced-af06-7f91019cadf9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pltsize = 3\n", + "index = random.randint(10, test_count)\n", + "# Predictions\n", + "plt.figure(figsize=(10*pltsize, 3 * pltsize))\n", + "for j, i in enumerate(range(index - 10, index)):\n", + " plt.subplot(1,10,j+1)\n", + " plt.axis('off')\n", + " plt.suptitle('Prediction', y=0.65, size=20)\n", + " plt.imshow(prediction[i,:,:,0], vmin=0, vmax=1)\n", + " plt.set_cmap('cividis')\n", + " #plt.colorbar(fraction=0.010)\n", + "# Uncertainty\n", + "plt.figure(figsize=(10*pltsize, 3 * pltsize))\n", + "for j, i in enumerate(range(index - 10, index)):\n", + " plt.subplot(1,10,j+1)\n", + " plt.axis('off')\n", + " plt.suptitle('Certainty estimate (bright = low certainty)', y=0.65, size=20)\n", + " plt.imshow(prediction[i,:,:,1], vmin=0, vmax=1)\n", + " plt.set_cmap('magma_r')\n", + " #plt.colorbar(fraction=0.010)\n", + "# Ground truth\n", + "plt.figure(figsize=(10*pltsize, 3 * pltsize))\n", + "for j, i in enumerate(range(index - 10, index)):\n", + " plt.subplot(1,10,j+1)\n", + " plt.axis('off')\n", + " plt.suptitle('Ground truth (locations of occurences, mainly iron)', y=0.65, size=20)\n", + " plt.imshow(test_labels[i], vmin=0, vmax=1)\n", + " plt.set_cmap('cividis')\n", + "plt.figure(figsize=(10*pltsize, 3 * pltsize))\n", + "for j, i in enumerate(range(index - 10, index)):\n", + " plt.subplot(1,10,j+1)\n", + " plt.axis('off')\n", + " plt.suptitle('Aeromagnetic anomaly ', y=0.65, size=20)\n", + " plt.imshow(test_data[i, :, :, 8], vmin=0, vmax=1)\n", + " plt.set_cmap('viridis')" + ] + }, + { + "cell_type": "markdown", + "id": "897f6460-d843-4fd0-9c12-b6912925063d", + "metadata": {}, + "source": [ + "### TODO \n", + "- The outputs need to be changed back to geotiffs with the saved data and nodata masks\n", + "- The current implementation makes this a bit hard since suffling the images is done after separating the images and metadata. The suffling should be moved to data generation side or the images should be unsuffled\n", + "- Ability to predict larger areas with sliding window type setup should be added" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "17c0b989-3021-4a08-b50e-6622a93ca233", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/cnn_data_sampler.ipynb b/notebooks/cnn_data_sampler.ipynb new file mode 100644 index 00000000..5d1b4f71 --- /dev/null +++ b/notebooks/cnn_data_sampler.ipynb @@ -0,0 +1,426 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "eea6b025-8d9c-49fb-a093-54ff76fc724a", + "metadata": {}, + "source": [ + "# Data sampler\n", + "Creates a set of images that can be used for training a convolutional neural network.\n", + "\n", + "### Input\n", + "- Geotiff that will be sampled\n", + "- Bounds of the geotiff, geopackage or other geospatial vector format\n", + " - TODO: Just extract the extent from geotiff nodata mask \n", + "- locations of the wanted class, geopackage or other geospatial vector format\n", + "\n", + "### Output\n", + "- Two folders with geotiff images inside, one containing images and the other containing labels\n", + "\n", + "### Internal workings\n", + "- The known occurrences are oversampled and negative samples are selected randomly.\n", + " - This ensures that both sample types are represented equally in the created dataset.\n", + "- The sampler works well with sparse datasets, where it is relatively rare that the negative samples would contain an unkown occurence\n", + " - Thus there shouldn't be too much misclassifications in the data that would cause problem\n", + "- User has the option to set buffer size for the known occurences, because one pixel locations are harder to locate for model than .\n", + "### TODO\n", + "- Current implementation creates images in order, known occurences first and non-occurences last. This makes suffling necessary at the model script, which complicates things. Suffling should be moved to this script\n", + "- This sampling script should be integrated to the cnn scripts so that leave one out cross validation would be easy to do\n", + " - The leave one out method should be implented in a way that one feature is completely removed from the occurence data before any sampling is done, and then test data is creaed by sampling the left out feature alone\n", + " - without this it is hard to assess level of overfitting\n", + " - users should be given a clear warning about htis, if the script is published without these changes. Overfitting is nearly unavoidable with low amounts of data so user should be given tools to asess the level of overfitting" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "dd697cf8-b40b-45f1-80d1-e45b130a7a86", + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import subprocess\n", + "import rasterio\n", + "import json\n", + "import tempfile\n", + "import math\n", + "import shapely\n", + "\n", + "import pandas as pd\n", + "import geopandas as geopd\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "from shapely.geometry import Point\n", + "from rasterio.mask import mask\n", + "from rasterio.plot import show\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.dpi'] = 300" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "9cca6622-361d-4afa-b68d-6ad43c9f8aac", + "metadata": {}, + "outputs": [], + "source": [ + "def get_features_json(gdf):\n", + " \"\"\"Parses features from GeoDataFrame in such a manner that rasterio wants them\n", + " \"\"\"\n", + " return [json.loads(gdf.to_json())['geometry']]\n", + "\n", + "def random_points_in_bounds(polygon, number, seed=None):\n", + " rng = np.random.default_rng(seed=seed)\n", + " minx, miny, maxx, maxy = polygon.bounds\n", + " x = rng.integers( minx, maxx, number )\n", + " y = rng.integers( miny, maxy, number )\n", + " return x, y\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5c9cabbc-87a7-4a2c-9b91-e92b13b2c741", + "metadata": {}, + "outputs": [], + "source": [ + "# Options\n", + "# This is probably large enough image\n", + "crop_size = 32\n", + "exaggeration_size = 120\n", + "# Projections are assumed to be the same\n", + "\n", + "# Mineral occurence locations\n", + "occurence_path = \"/home/iiro/Documents/Työ/data/EIS_IOCG_target_area_CLB/Primary_data/shps/IOCG_Deps_Prosp_Occs_3.shp\"\n", + "occurences = geopd.read_file(occurence_path)\n", + "# Raster to be sampled, assumed to contain different features at diiferent bands, but also works with just one\n", + "test_data_path = \"data/possible data/test/important_features.tif\"\n", + "\n", + "out_image_dir = \"/tmp/images\"\n", + "out_label_dir = \"/tmp/labels\"\n", + "# Shapefile that gives the bounds of the area\n", + "#TODO instead just extract the extent from raster nodata\n", + "bounds_path = \"/home/iiro/Documents/Työ/data/EIS_IOCG_target_area_CLB/Primary_data/shps/EIS_IOCG_target_area.shp\"\n", + "bounds = geopd.read_file(bounds_path)\n", + "\n", + "# This should be given as option to the user, None is OK\n", + "seed = 1\n", + "# The amount of locations that do contain, should be user controlled\n", + "random_point_count = 100\n", + "\n", + "\n", + "\n", + "if not os.path.isdir(out_image_dir):\n", + " os.mkdir(out_image_dir)\n", + "if not os.path.isdir(out_label_dir):\n", + " os.mkdir(out_label_dir)\n", + "\n", + "tmp_root = tempfile.gettempdir()\n", + "tmp_dir = os.path.join(tmp_root, \"image_patch_generator\")\n", + "if not os.path.isdir(tmp_dir):\n", + " os.mkdir(tmp_dir)\n", + "\n", + "# Extracting image and necessary information\n", + "raster = rasterio.open(test_data_path)\n", + "meta = raster.meta.copy()\n", + "label_meta = raster.meta.copy()\n", + "label_meta['nodata'] = 255\n", + "label_meta['count'] = 1\n", + "label_meta['dtype'] = 'uint8'\n", + "burned_raster_path = os.path.join(tmp_dir, \"rasterised.tif\")\n", + "\n", + "\n", + "pixel_size_x, pixel_size_y = raster.res\n", + "\n", + "nodata_mask = raster.read_masks(1)\n", + "# nodata mask is useful starting point for creating empty raster where points can be burned\n", + "nodata_mask[nodata_mask == 0] = 254\n", + "\n", + "nodata_mask[nodata_mask == 255] = 0\n", + "nodata_mask[nodata_mask == 254] = label_meta['nodata']\n", + "# converts geodataframe with point geometry to suitable format and converts it to buffered polygon to have larger area\n", + "points = [shapely.buffer(Point(x, y), exaggeration_size) for x, y in zip(occurences[\"geometry\"].x, occurences[\"geometry\"].y)]\n", + "rasterized = rasterio.features.rasterize(points, out=nodata_mask, transform=meta['transform'])\n", + "\n", + "rasterized[nodata_mask== label_meta['nodata']] = label_meta['nodata']\n", + "with rasterio.open(burned_raster_path, \"w\", **label_meta) as dest:\n", + " dest.write(rasterized, 1)\n", + " \n", + "label = rasterio.open(burned_raster_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "099e7f41-6d2e-49fc-89e4-ba3e3e4be9b3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABGYAAAUBCAYAAADOz4elAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAC4jAAAuIwF4pT92AAEAAElEQVR4nOy9e9QtR1nn/63u9z3n5AZBouEqgSCEm+THNdw0URIGBgc03DQREAOCIMIMLpbDCAFBZYHDWoOIggRBWAMjw01hFMQgFwlykSFEbokEyQCGAAlJOJd3767fH11V/VT1U9VVvXtf3vc8n7XOeffu3V1V3V1dXfWt53lKaa01BEEQBEEQBEEQBEEQhJVTrbsAgiAIgiAIgiAIgiAIRysizAiCIAiCIAiCIAiCIKwJEWYEQRAEQRAEQRAEQRDWhAgzgiAIgiAIgiAIgiAIa0KEGUEQBEEQBEEQBEEQhDUhwowgCIIgCIIgCIIgCMKaEGFGEARBEARBEARBEARhTYgwIwiCIAiCIAiCIAiCsCZEmBEEQRAEQRAEQRAEQVgTIswIgiAIgiAIgiAIgiCsCRFmBEEQBEEQBEEQBEEQ1oQIM4IgCIIgCIIgCIIgCGtChBlBEARBEARBEARBEIQ1IcKMIAiCIAiCIAiCIAjCmhBhRhAEQRAEQRAEQRAEYU2IMCMIgiAIgiAIgiAIgrAmRJgRBEEQBEEQBEEQBEFYEyLMCIIgCIIgCIIgCIIgrAkRZgRBEARBEARBEARBENaECDOCIAiCIAiCIAiCIAhrQoQZQRAEQRAEQRAEQRCENSHCjCAIgiAIgiAIgiAIwpoQYUYQBEEQBEEQBEEQBGFNiDAjCIIgCIIgCIIgCIKwJkSYEQRBEARBEARBEARBWBMizAiCIAiCIAiCIAiCIKwJEWYEQRAEQRAEQRAEQRDWhAgzgiAIgiAIgiAIgiAIa0KEGUEQBEEQBEEQBEEQhDWxte4CCMJe5corr8RnP/tZfP3rX8eNN96I/fv34+Y3vzlOPfVU3POe98SJJ5647iIKgiAIgiAIgiAIa0aEGWFt/Ou//is+9alP4dOf/jQ+9alP4bOf/Syuv/569/vtbnc7XHnllesr4AgOHTqEP/mTP8HrXvc6fPGLX4zup5TCXe5yFzziEY/AH/zBH6Cu6xWWUhAEQRAEQRAEQdgUlNZar7sQwtHDhz/8Yfz+7/8+Pv3pT+N73/tect/dJsx8+MMfxpOe9CT827/9W9FxBw8exIEDB5ZUKkEQBEEQBEEQBGGTEYsZYaV87nOfwwc+8IF1F2Ny3vCGN+DXfu3XMJ/Pve0nn3wy7nrXu+Lkk0/Gzs4Orr76anz+85/Hddddt6aSCoIgCIIgCIIgCJuECDPCRrB//37c5ja3wRVXXLHuohTzjne8A0996lNBjc/OOeccvPjFL8b9739/KKV6x3z2s5/Fu9/9blx00UWrLKogCIIgCIIgCIKwYYgwI6yc7e1t3O1ud8N97nMf3Pe+98V97nMf3OMe98DHP/5xnHXWWesuXhHf/OY3ccEFF3iizKte9So85znPSR53r3vdC/e6173wwhe+EFtb8hgKgiAIgiAIgiAcrciIUFgpT3rSk/D0pz99z8RUefrTn+65Jb3whS8cFGUoIsoIgiAIgiAIgiAc3cioUFgpN7vZzdZdhMn4xCc+gb/6q79y3+9yl7vgBS94wRpLJAiCIAiCIAiCIOw2RJgRjhpuuOEGfPzjH8c3v/lNfOc730Fd1/ixH/sx3OUud8G97nUvVFVVlN6f/umfet+f97znYd++fVMWWRAEQRAEQRAEQdjjiDAj7Hn+9m//Fi9/+cvxsY99DDs7O+w+J510En71V38Vz3/+87Oseq6//nr8r//1v9z34447Do973OMmK7MgCIIgCIIgCIJwdFBmIiAIu4hrrrkGZ599Nv7Df/gPuPjii6OijN335S9/OX7iJ34CH/nIRwbTvuSSS3Dw4EH3/YwzzsDxxx8/SbkFQRAEQRAEQRCEowexmBH2JJdffjke9rCH4V//9V+97SeccALufe974+STT8Z8PseVV16Jz372s2iaBgDw3e9+F2effTbe+9734mEPe1g0/X/6p3/yvj/gAQ9wnz/5yU/iL/7iL/CRj3wEV111FQ4ePIiTTjoJp5xyCn72Z38Wj33sY3G3u91twrMVBEEQBEEQBEEQdisizAh7jh/+8If4+Z//eU+UufOd74yXvexlePSjH426rr39v/Wtb+FFL3oRXv/61wMAjhw5gvPPPx+f+9zncOtb35rN49Of/rT3/S53uQuuueYaPPOZz/RcnCxXXXUVrrrqKnzsYx/DS17yEjz+8Y/Hq1/9apx00kmLnq4gCIIgCIIgCIKwixFXJmHP8Vu/9Vv4whe+4L4//OEPxz//8z/j3HPP7YkyAHDLW94Sr3vd6/CHf/iHbts111yD3/md34nm8a1vfcv7vm/fPjzgAQ9gRZkQrTXe9ra34X73ux++9KUv5ZySIAiCIAiCIAiCsEdRWmu97kIIAgB8+MMfxllnneW+3+52t8OVV15ZlMY3v/lN3P72t8eRI0cAAKeccgouu+wyHHvssVnH/8f/+B/x/ve/H0Artnz961/HLW5xi95+p512Gr785S+777e5zW1w1VVXAQC2t7fxK7/yK3jUox7lyvLFL34Rb3nLW/C+973PS+fUU0/FZz7zGdz0pjctOk9BEARBEARBEARhbyAWM8Ke4k/+5E+cKAMAL3rRi7JFGQD4L//lv7jPR44cwd/8zd+w+1177bXedyvK3OpWt8JnPvMZ/Omf/ike8YhH4C53uQvuec974glPeAL++q//Gv/zf/5PbG9vu+OuuOIKL09BEARBEARBEATh6EKEGWFP8cEPftB9rusaj3nMY4qOf/CDH4ytrS700kc/+lF2PxssmLK1tYX3vve9uMc97hFN/wlPeAJe+cpXetve/OY349/+7d+KyikIgiAIgiAIgiDsDST4r7BnOHToED7zmc+477e97W1xzTXX4JprrilK58QTT3THXHHFFew+xx9/PL7zne942375l38Z9773vQfT/43f+A380R/9Eb761a8CAHZ2dvD2t78dv/Vbv1VUTkEQBEEQBEEQBGH3I8KMsGf49re/jZ2dHff9yiuvxO1vf/uF0vze977Hbj/++ON72574xCdmpamUwvnnn48XvehFbtuHP/xhEWYEQRAEQRAEQRCOQsSVSdgzfPe73508zeuvv57dfuKJJ3rfq6rC/e53v+x0zzjjDO/7F7/4xeKyCYIgCIIgCIIgCLsfEWaEPQMN+jsVsUXL7nSnO3nfb3KTmxQFGb7VrW7lfV+GqCQIgiAIgiAIgiBsPiLMCHuGk046yft+zjnnQGu90L/Yct13u9vdvO/79+8vKmu4/6FDh4qOFwRBEARBEARBEPYGIswIe4aTTz7Z+/6Vr3xlaXn95E/+pPc9XD57iHD/m9/85guWSBAEQRAEQRAEQdiNiDAj7BlucpObeJYsV155pVv5aGoe/OAH4yY3uYn7fvjw4egKThxf+MIXvO+3uc1tJiubIAiCIAiCIAiCsHsQYUbYUzzsYQ/zvr/+9a9fSj779+/HIx/5SG/b3/zN32QfH+77kIc8ZJJyCYIgCIIgCIIgCLsLEWaEPcUznvEMbG11q8C/+tWvxmWXXbaUvH7lV37F+/5Hf/RHWQGIr7jiCrzrXe/ytoUijyAIgiAIgiAIgnB0IMKMsKe44x3v6Akmhw4dwiMe8Qj8y7/8S1E6hw8fxp//+Z8n93noQx+Ks88+233/0pe+hOc973nJY2688Uacf/752NnZcdvOOOMMnHXWWUXlEwRBEARBEARBEPYGSsfWAxaEJXHVVVdhNpv1tl9yySX4xV/8Rff91re+NT72sY+xaRx//PG9VZgsN9xwAx70oAfh85//vNt2zDHH4LnPfS6e/vSn47a3vS173MGDB/Hxj38c733ve/G2t70N3/nOd6LLZVsuvfRS3P/+98fBgwfdtl/8xV/EK17xCtz61rf29v30pz+Npz/96fjMZz7jtu3btw8f/ehHcb/73S+ZjyAIgiAIgiAIgrA3EWFGWDmnnHIKvv71ry+UxpOe9KSkRcs3vvENnHPOOfjSl77U++0Od7gDTjvtNJx44omYzWa47rrrcOWVV+Lyyy/HfD739s15PN7znvfg3HPP9Y6tqgr3ve99cbvb3Q6z2Qxf/OIX8cUvftE7TimFP/uzP8NTnvKUwTwEQRAEQRAEQRCEvYkIM8LKWYUwA7SWM09/+tPx1re+dVQeJ554Ir7//e9n7fvOd74TT3va0/Dd7343a//jjz8ef/EXf4FHP/rRo8omCIIgCIIgCIIg7A0kxoywZzn++OPxlre8Bf/3//5fnH/++bjZzW42eMytbnUrnHfeefjLv/xLfPvb387O6xd+4Rdw2WWX4RnPeAZufvObR/e72c1uhuc85zm4/PLLRZQRBEEQBEEQBEEQNsNi5slPfjLe9KY3TZLW7W53O1x55ZWTpGU588wz8Q//8A+jj3/jG9+IJz/5yZOV50/+5E/wjGc8o7f9a1/7Gk455ZTJ8tlrNE2Dz3/+8/iXf/kXfO9738O1116LAwcO4CY3uQlOOeUU3OUud4nGnylhNpvhH//xH/H1r38d3/rWt1BVFU466STc9a53xX3ucx9UleihgiAIgiAIgiAIQsvW8C67i2OOOWbdRVgq3/jGN/D85z9/3cXYlVRVhdNPPx2nn376UvPZ2trCT/3UTy01D0EQBEEQBEEQBGFvsOem7s8999x1F2GpPP3pT8cPfvCDdRdDEARBEARBEARBEIQJ2AhXpmuuuQY33HBD8XGf/vSn8djHPtZ9V0rh8ssvxx3ucIcpi9dzZfra175WdPxJJ52E448/fuFy/MVf/AWe+MQnAgBOOOEEXH/99d7v4sokCIIgCIIgCIIgCLuLjXBlOumkk3DSSScVH/cHf/AH3vezzjprclGGYx3ix9VXX43nPOc57vvv//7v41nPetbKyyEIgiAIgiAIgiAIwnTsWlemgwcP4m1ve5u37Vd/9VfXVJrl88xnPhPf+973AABnnHEGG/xXEARBEARBEARBEITdxa4VZt7xjnfguuuuc99PPPFE/MIv/MIaS7Q83vnOd+Id73gHAGB7exuvf/3rZWUfQRAEQRAEQRAEQdgD7NrR/Rve8Abv+3nnnYcDBw6sqTTL4/vf/z6e+cxnuu/Pf/7zcfe7332NJRIEQRAEQRAEQRAEYSp2pTBzxRVX4CMf+Yi37YILLlhTaZbLc5/7XHz7298GANzpTnfCf/tv/23NJRIEQRAEQRAEQRAEYSp2pTBz0UUXgS4mda973Qunn376+gq0JP72b/8Wb3rTmwC0K0697nWvw/79+9dcKkEQBEEQBEEQBEEQpmIjVmUqYT6fO7HCsuqgv7/5m7+JT3ziE7jyyitx7bXX4vjjj8fNb35znHbaaXjIQx6CRz/60bjTne60UB433HADnva0p7nvF1xwAX76p3960aKvjGuvvdZbYvy2t72tiEqCIAiCIAiCIAhCMYcPH8Y3vvEN9/2nf/qnceKJJ66vQBOjNDU92QW8733vwyMf+Uj3/ZhjjsE3v/nNpd6UM8880xMZhqiqCo961KPwile8AqeeeuqoPJ/5zGfij//4jwEAt7jFLfDFL36xd45KKe/71772taUs5X311VfjO9/5TtExf//3f49nP/vZk5dFEARBEARBEARBOLp597vfjUc96lHrLsZk7DqLmYsuusj7fu65526cUtY0Dd71rnfhQx/6EC666CKce+65Rcd/9KMfxWtf+1r3/dWvfvVaz/GP//iP8eIXv3ht+QuCIAiCIAiCIAjCXmVXCTPf+c538Fd/9VfetlW6Md3jHvfAwx/+cJx++um44x3viBNPPBGHDx/G1VdfjU984hN4+9vfjksvvdTt/4Mf/ACPf/zj8d73vhePeMQjsvI4dOgQLrjgAhdD5+d+7ufwmMc8ZinnIwiCIAiCIAiCIAjCetlVwsyb3/xm7OzsuO+nnnrqSuKu/NIv/RJe85rX4G53u1t0n5/5mZ/BC17wArz1rW/FM57xDFx//fUA2pg4j3/84/GlL30Jt771rQfzeuELX4ivfOUrAIATTjjBuTPtdt797nfjjne847qLIQgr5ylPeT10paAaDbUzh2rIjw3jSVqp/rYUjYYiHqlaqX4ajcaf/c9nlKUrCIIgCIIgCBvC5Zdfjkc/+tHu+21ve9v1FWYJ7KoYM3e/+91x2WWXue8ve9nL8F//639dY4l4PvWpT+HMM8/ED3/4Q7ftqU99Kl73utclj/v0pz+NM844A/P5HEDrwvSsZz0ruv8mx5gJH5wvfOELSWFLEPYiD33wS6HrdvE71WhAa0DDE1J64swoYQZt2gB01QkzWqk2L5OHYlp7bbLTWxX0dgU0gJo1UHOiINEyMWKSTVcr4IOXvLCs/IIgCIIgCIIwwGWXXYa73/3u7vteG1/uGmHmkksuwQMe8AD3va5r/Nu//RtudatbrbFUcV71qlfhP//n/+y+79u3D9/73vdw3HHHsfvv7Ozg3ve+t3OFOuOMM/Dxj38cVRVf0XxVwswY9vqDIwhDnP3A34WuVGsto0HEkaDJ5axmLDkijRVmmgZQClAKuu5bzLR580noWkHXVSvqaI1q1qQFo+A3KsyEeVjhJ3a8CDmCIAiCIAjCEHt9fLlrXJne8IY3eN8f/vCHb6woAwC//uu/jgsvvBA/+MEPAABHjhzBxRdf7K0oRfm93/s9J8psb2/j9a9/fVKUEQRhMzn7gb8LwLgUUfHUiB5aKd9qplJxcabReeKMTUtrP8/UIYoKKgp6S7XWMqQsVHDxCMps04oJPwD8cyHndPYZLxksa1TsCbHpBkKUWPIIgiAIgiAIm8yuEGZuvPFGvP3tb/e2rTLo7xj279+Ps846C+95z3vcts9//vOsMPOFL3wBv/d7v+e+P//5z/fUQEEQdgcPfdBLEWoG1FoGCkCpjWJDBJyxMEKK+2tcn1wcnEZ3VjhIiCABdr9QRFGapMGdy4CbVCyfHsH1ce5dRqg6+4yX9IUjK2gp1QlVunU5+8CnLhwsiyAIgiAIgiBMwa4QZv7yL//SBdMFgJNPPjlqebJJhG5FsTgtL3vZy3DkyBEAwC1veUucf/75uPLKK4vzu+qqq7zvP/IjP4Kb3OQmxekIglDOQx/0Uve5tZaxX0hw3pjuEAgnVEDoiRpmfxc/BvCsZKhwoc12u58natg4NJWxljFljZaPEpSFs56h9ESemCWQTSuwfKFpFxNaEdHvysbi6Zf9nHtfCNStYGXPgc2fOw8iQIX3IOSD//g7JWcjCIIgCIIg7EF2hTATujE98YlPxNbW5hf9mGOO8b4fPHiQ3Y9u/9a3voXTTjttVH4PechDvO+vetWr8JznPGdUWoIgLIgd/NvxeK5b0kToXJcmay0z01DzvlXNIBlWLhYnbqSuQ+S3UaIMybdNZDiejwbMylkamGsoY01TlH/Bfe65cpFjOVFHhBxBEARBEIS9x8arG1/5ylfwsY99zNu26W5Mlmuuucb7ftJJJ62pJIIgrJou7kq3KlKOOJOM0+Ltx+xIxBhl49kky6gAGyjYWvZwQkuB+JJLypLEWQMZC5qhGDdsGY1LkoO7FsR6xpWngrcEubb7mDxjLl46uPbhNldGxhooao3DcPYDf7ezyKIuWI2GmjddjCDu3AMLIZu3fx4Sj0cQBEEQBGHVbLwwc9FFF3nfH/zgB+POd77zmkpTxic/+Unv+yYHKxYEYTycGxNdwtoRE2UGVk2KoZVqhYT5OOFE1yS2jCbpJVyV8srV/o2uAmWFBXb57vY3DcWLTzSAcELocDQAKt/ly4kZOUKW1kAQOSgqojgjqbbsOeIYLXOYbsz9SWkNDeUXy1gitRY/eUGgufujtG/F03Ori7huiZgjCIIgCIIwno0WZubzOd785jd723aLtcyll17qVlmynHnmmey+7373u0flscnLZQvCUYl9JEM3phQDogwbbya3OHZgzyx93a7EVEEr5ZbHjlrMjCwPF2/Glkv3wiTbH4PvjBDgWdSkaExejQJqv8xc2en50xg+SgPabq/7QlBKfPHEmUR5F3HV6meqkm5bQ0GQw3L5Qhdz3SvlViPLFfFKREhbJhF/BEEQBEHYq2y0MPP+978f3/rWt9z3E044AY997GPXWKI85vM5nvvc53rb7njHO+Kud73rmkokCMKyOPuBv+sLMVzQ3xi5ljI0YK2NhUKEA60AFRM6QmxA2kpBzRpUGlDzphtwJyxkSi16XNki4kx/X2PBowHVNG5buC/93hNpjOuTggIqI8pUXVligYUdlTKCmhW1YHzSlB/Mt/LLo0kd8ASumBgTuEaVorRuq0XseE6cKVhO3TssPCQnXtIIS6shUvF4OHSl8Hcf+2+TlkEQBEEQBGEZbLQwEwb9fcITnoDjjjtuoTRDK5OLL744askCAK9+9avx1Kc+FQcOHMhK/8iRI3j605+OD33oQ972F73oRcVlFQRhd+AJBdZHJxyTJpaFjokXWXmGy2CnVlAiZdFbNuBvkx5AJ1Zcou43XKyS8LhBqxAF6K2qdc1qEjsHoocn3thtjYaqqq5giggyOcF5K3RWPTmxenJ+mzoAtL3mgVtYrz7lCDKMtUwxBULMmDpfgr3uD33Iy1x+qM1qZrPGLQ3vXOeMIPh3H33B8golCIIgCIIQYWOFmX//93/H+973Pm/bBRdcsPJyPPvZz8bv/d7v4fzzz8djHvMY3Pve92ZXhJrNZnjf+96HCy+8EJ/73Oe83x760IfivPPOW1GJBUFYOzqwCEmIMu6QXnwR+kW5bdoO7rmlpDOsGFoXJoWmrlA1DdAoqCyfq3hMkqF9e6saUWGFfqbLftfKxemxAknP1arRnuWKR6Xaa8UJEhHXLpcH0B7HHMtZ+iit3bLaYbrufGz8nhRjRZvU7XNLtSfEmVJRJrVEeOw7V7QlizMun8pYTTWA0g3/u1LQ0Hjog1/axugJrNnGiFbNvhrzA+2/Zp+CmmtsXz9HfXguApAgCIIgCB4bK8y8+c1vxmw2c9/vfve74373u99ayvLtb38br3zlK/HKV74S+/fvx93udjfc8pa3xE1velPs7Ozg6quvxmc+8xnccMMNvWPvc5/74J3vfGfPUkcQBCFFctDKDRpzB/VmeWyHPbbR07meUHEDxFomFKiCOC3tABnu2FaSMduCsrlzDwMVo7+q0yjBgxMrmLyihNc4vLRTuvnQ9IdciEa6MzkGLLJKVpgCFhBnkvF6SD2yNDDuhUH5qCWNRhc8OaD0vABAzTXqnQbNvqpdll4pzA9UUI1uXSCboDyJayvxdQRBEARhb7Oxwky4GtOmBP09fPgwPvvZzw7up5TCb/zGb+DlL395thuUIAi7CxfwNAZnGWK/h/sETGZJEOSttxSa7Qr14Xnr0pER8LeYYOCfLRxVweemE0cU7AJJqnW/slkFA+aeW1FGvu4YZdyXlDZLnZPyh4SCj0ZfDOAgx01qLaKYlaymnhDIcZMbQUyc6Zac774Pp2VEGRtjR2uovpFMK7xV6K6Rsse2llYKWEx0crGM4EQzXSs0+xT0YSMEQcfd/IK8bXydsXUmt9wiAAmCIAjCethIYebjH/84vvSlL7nv+/btw/nnn7+WsrziFa/AxRdfjE9+8pP47ne/O7j/j/7oj+Jxj3scnvWsZ+G0005bQQkFQVgbnDWG/UotGCgZQsGYFWuiEHFIV60LEwBgrj2Bw5VtSChKBTRmhIDcAaGaN8AOOpcmUzS3pLddIanR0PPWLaRX/kYDNZNhjtUMNXDRAJqGDNqV/1vqvDiBhJaD/gUWsmDJWo47skLTsuLJLJwuuR7RFcAG76XyxR7OqsoFeUYb00gpNFuKLKPO36MsccYT7DSqnQbVTGG+DTR1K4xWtYLSwfM2QQyi1FL1qThQFhdguaAcH/zH38neVxAEQRAEno0UZh70oAdBD61mMpLSdJ/3vOfhec97HgDgqquuwpe//GVcddVV+O53v4uDBw+irmvc7GY3w0knnYTTTz8dp5566jKKzbKsayQIwjC95YHtQIY+lllWIv7gLEuUMcdEXSBiGCsBNTerAYVCTI4FxMBSzGNw5zxrgK2qM48x8XD0lkJTVa2FgwaquUb9w1l/YBtj4Pq45bu53ehqWExe1NpmGdemCCsKVSb4sYnRw+46wjUHwPTWVRQmHk6ZW5Qyli90YxCcWwOoKmOdpVpRBmafqoI2efayHSGgtdZoaN2ZDldotlRrNbNllqqfa2c145G4xrnXgwvUvSySloMZ9SVWNnquYskjCIIg7HU2UpjZVG5zm9vgNre5zbqLIQjCmnnog17aDtzoYN3MdnuWEiMGsVkxNyJxVYAgQG4oSJgYGy64aZjOMgfdEWuA3uDRLnetNXTVxZ7RNdBsGyuHHaCuVWs5U5H00bci4ZbbziIyCF/IIoRc455oMtJSwhOVrKVHjnUTRogzQ/Ujsw6FljBFokFwnXoWQzZoc3jutlxW8DEWM26Vc9VaYU2NajSw06A+0mB+oIJW2twr+PGdwnJOQM6KaUsl81xyytNbKn0AEXIEQRCE3YYIM4IgCGMZsRIN4A8mvSC17neQ3ycqn1mhqJo1zk2oJywxhK47ztVjjNgRE4zg59F+Vp37SKMBawlSAdWstUTouQ2VihtMeVphB23QYVsm+3u4ihQlvKcJph4oe2KUdeNJLdXEWH8UuejE6vlA/S9Z1WtRWuGrn48G2qXQK+UF+bXWLbDCJQe9bikRKtxunrutgw10Dai5Sc6KQxVzzJII25alijQTiL1jy1gq5PTIbEvEjUsQBEGYChFmBEEQRjI0qFzaoIcZ8IRiABsLxX62+xYMpO0AKWnhMHbAH5bTlNWJQTONqmmgVQ3UCtWRBmredINr65bl8tTs5xxsUFa2TEB8wKbpyJ/BGLP0rt1UAXq1+c8Gv7UxVDLO35Ypea/oeRcOuJP1BWBj+UQJLK88NyUjGHLBfrUCdF25mEUgwo1qdFt1zcpNMJZb9jiFhAVOBkpr4EiDrfmOWwEKCtBbFZRuoJvlijOp52/p4swCZNXLNTMYAD5AhBxBEAQhhggzgiAIBTz0wS/t3IXMqi/sgNIuv0t/KrToiFpWjBnA2aC6Jl3OUieX6GAVyIvFEbEOchDrnMoG+G2AaqcBTODfpGVDLskll/OSsMKAWcenLxS4L126qdgvRVCLD+v2Ze6Ns5pxvjpUZQvdgQoHv5nXvTSI9aLWM86ti1HHdF21AbC3KufeprR2bn3GPqpNZ954wia1oGrzybxWxMJIQbeWMpWCris0220sJV21KesGQE2sv5ZoQTOVlZLnPhljZBuzzJg46yS05Om1BfR5HWhHe5aV5n30gU9dOElZBUEQhNUiwowgCEImP/vTv+eGZ97AgetEh9sis/wlRJfVzRV8tAasG8XY2CvLpLLWBEb0aTTUTmdVUe+0Ik07cNZx65QBwnN3SywvQHgt2dWSbEDeJRKN31IwyOsxIv5N1nlGBKIkOYGcaUBm3d1frdptru7M24GsFWJSKxqFgprn6pYiCOytm9ZsSs26Vb/0linYXAONERyH3MZGwom9YyxSskQZYRwl19S2mVZMbIBz7n0hACIaKwVsVZ1bZhjnSsQcQRCEjUCEGUEQhFxiHeYRLhhTMDSg6rsHqXY56R3G1yNyfJGQkLtcNjfoDJYYtqvpWFsGKiqxgsxA/JquPMr7Gy5vzloSjbh33qBIBwPY0sFs7DqFaPOfFSLqCiBLii9TFBoSNlL4sYUSx2cLkOjuK7m/NhCvtxy3zUtrZ2kUy1dHhLXoEuqBqGIHxsrWZRPrxi5hX6ExQhKpL0sMym3Ly57zou1VxvMYXQ4dfj1YuRuTveYTt9dRJnNnjIjDNkB64nxCMcdLowrKOFRerYG57qX1t599cfo4QRCEoxwRZgRBEDJxAzk6UCJBagfhBliZ7jQ03kIOoQuV66RbN6CC2CP0ux+zZoQVRsISwM3C2xWj7L4K3XUeKndsEMtdZ5uutYIIV0mKpMVZw8SuZ7hKVD+tSNkozOpfbrvd1svYmIuQYznRY8r4HWOFn1QZFi4fvb9N67qkq35d0uQepAQWXan+SmJDZWVXI9Ot+xIRkFrLHg1VqTbuzBLEmenudaI8GatMeS48U66AFl7rMdeNe9amgG3zmOcmw/2QpqkQscSzgkx4LFefKnRB4WlRtIZuFFDp7PvkyhLUkYfd60Vmf3JAWMYgjw98UlbXEgTh6EGEGUEQhEz+7qMvGAz2WDzTm9n5j1kSOPeIWBpE3GiDng4PmvyM/cFTVhBgJM49UlbnTtQTvkh6FTxXrC6gLjHNj+VNljP3Y78kTmJoaeYU5Dy9JcwpJZZWMXGGlNNZGOnud62UF1h2ilguIVOkt3wXL90th93o1prIwg3m2cFrZznTpRvmUyYoKG1iJ5ni6K3KWRuwK46taPWm0ZSUbypLkWWyIsuZMdZmtq55IpcVWKyVCxUgh86lQivCwBfenDhT55etPTBDSA/3Dzjn/n5MHvds0fMoEeOZfWVpdUEQNgURZgRBEEqw7gzMbG/SNWAgzaUQCgu1me2fR4QCQm+AwMTRic6UDhF1YSKuRLDii9+5t4GLndUDrAVQvxw9EWJulsK2g+DMwDJhzJIun8gJhwJK1PIGeYO+bPEuEJzI9QktZ2Kw4taaxIAxFhPuGmiY+xWU3bgsYd4Mi5kI3G2Y+7CI0GWtZmxMGV2ZwS8RIKck5Tq0apaW/zKElCnSHLGUPEco4EQtZUKrG+uqN/Qs27aREWhawbfydveEEurqZ0Qe5e2rvDyKILGdtMKwq1yBkDlmaXURcwRBWAYizAiCIBQQW1Fn2QOdosGf55ZBBpmzxgkbWZBOPTu7HZm1HHMtomUi1jB6boUFxtSf7k9dosJ8yODECTQk7kw0iK9C9zf3GgaDBu8ejrEWGL2KlurHzmGXXPc/r3Pwzs6Mg79HFC+oMxToyJCuJubqQWxgR68Nrf+57iiWjGDFAFqBhua3ZJZ2f5cYEyc7jylXaxtKq9A9NSRHAI/F7mJdoMIJg6bpLGhAhI0hiEBjVzBz1nica1QkDSvw0DSjZY25tgXikNLE9TB1/ZdYD4vEnJGiniytLghHHyLMCIIgLMhaBrAD8RmATlTo3CKYnRbsxLo8KmNMMlksDOWJIFoFpxoaQigixNhlzIEubgKZRWYHpc7Qwh/4D8WIafPIO2c3mFKZgyOg36m3g1JGVOiJEi6iMXrXa+NdYgA/NhKhaEUxbrfIilm93awIG87Wc9lw20sHZNTdapm3xwyulyrOWKauZ8sWfrjnLWTZz05iqeyoAGiFDicyw63SBJi/VVePXT5DzxEVV0ga0TYsTDO0jsmJyUbPn7F4AwDVwIsL1ea1xHo3lgUsrYbcpinaWNx96CMvGJ2fIAjrR4QZQRCEsaQG+lNmQ/uYPYsODKx8ot1fbQeWSkHZwLBZBUinr5XirTKY8odBiZN4Fhzacz3yBuZNN1jwY+hwafqDHm/gb1x/WHEmsL7wiA0WpxgcFLgxsYKSuSY5YsaU8WeyY2YwAU47l8CM+hlen8DFoW8BFU+Kfc50vy7nWRwMWOJwoprOOOcCYSIacynnukbKXySK0XSmeBamclEqFVumWL48ct+Sz1zYng2J8VScqVTrzeceRNWv01r320guYHClfYFnKNYMFcPD8hFBx1qvJeHKbbZ7z+KqVtDKZYXl0UTs+tmfelk7QWEmNJYhUIkblyAsDxFmBEEQMjn7jJe0Y3N2VZ4JxJmSzj/j798vk7UaMQML22kfEHMA3+2jn65/rj1xJodMF4+hbdFrpVQ3u2u/R/LxXKO4Di0XNDiDWJ2YpJ4QqxmvXOGKYQOmF7FBYUkZw8Fl1vLXgzP1mQXIECXZfUkcoN4qMqG4Rx6z6HUpHYhFBDfP6in2TE0odoxZkjrrOQ8FqFW4OOUwdJ9iQt9Uy4eH5Wh0/xkJxWJOnAn3I9va4OxtO6+3jYqiWotCNWucIBN12+SgqzZx8V4WFSKo6MSVw7PCqdL1dV31bJ3ikKbtWORdORESk0cQlocIM4IgCLlUJD4J0+9ZenDNyCx+kmCgrrcqYNZ0S1IPways4c4tXHkoVmyVIVwNxfvImOV2YhItewq6UhOGz8N5BoX7xNxghsjpyC/Q2Vfzpl19KEhiWSsgZdf5yAx4Thrc/aEuez0SQUK9eFHssRgXqDSX1AplzPdSgSYlmFmidYENdJx5g0sHxou4oITXYAp3lthxOellPtPUBbQvpkYIY371rP+CMlgRHsbtRzftVyvKULejlMhP3gHe8tkIxBm7b8Vcp+C82HpHRBnW4s4KQ0rz1ykhfi2dCUSZ8PnKEVe8YOcFx62aMWJOKSL+CHsBEWYEQRAyCZce7g3maKDdMRY0mQOs7MCxi3RIjQjVc+8I8yZClXOrYgZHSZPznECeBXFcOIbECNY1CghW6InsE+6bKOuq4hFRKxDnAhZah0Tq0bjVkMqPGarHOVZK3jLrlqH7QFdW49w5gFaQoW4dYUyNMYO+QNTlrA1S51vsRoTh+5IrlnpBxMdaxZUIkbFBNpfO0Ao9uXnnlC11v3MCSVvsrppvmwZdnNyO8ec4GauF2VcBRnQh+2fEg+nFXgrFfBdA3QqMpHx0HyrK2Gvplrjv6p2em0c+ZY0V1pdVxiVaIUVWpHucUvFHhBxhExFhRhAEIReFNv5IhU60oB1YxgcewMIDOnYlqFQA2Vja2piywwzyUm4uifJR0am3kk840247xTmCTEEsh1IXjGjMk6kGWhmd80ljEQUD5lQslV7nPZx5jxw3BdGZcYZSdxqWHFcVwBNl3IDPphnG2chdhSYj30mslUzbsyyRb4x7k8eUA9VcMWfMc7yMvCwLuPd0MZYy6gtTN52AR9tptBZ01qLFW8qaWM4oAJjTZ4G0EeEqS8RyxxNnODGIa2dCoQaROqd1Z+Fj05lrX5yZmtz39BLyH23xcpQKMmNZhRUPIAKQUIYIM4IgCLlYv/0GnahhZ9vDgIjcTOZUs3hUlInNHoc0xm5Cm2PG9ifNeSUHDJw4w+0TO5Yhll/pANUXLDItBkavWOXnFU1/JKw4QcqrNIC55oO/LlmUiVkB2N+SeSWuSVGcn4hbi1c2O9gMl/INPkeft9z6YfZjzzviEsieKxGEi1f4ipSJErOomso9Yoy7RhaLDpBLjh+655z1RrgtECMWEex0TURaZdK2bQAnvlcVoHSrmzQKqml8tyaY+6JU57Zk24yUxxPNinmGXHkVoLcq6Mq8R+aNW43MpeFWJ9O8RZs7l0gbiHEWZh4rFmU20QVJWByx5BFKEGFGEAQhg5/9qZcBtgOd2x9LmZkD/Q57aqDExHphRZmUCNLo1trHJjPWBz8wcx8abHp5jOjMDrshFYoKJWILd3+468bEu8kq6xSBM0Po+QWz2XTJ7pzyjoFaXKQEmiikrkTdmewmDQwuLU2FKm4Wn4qqhQGebTlz92NdgkggZ0rPkkehjRk0NFgtIfYs2FVvCmPNbIzQEj6by3zGuDxT+5t2OHaMbSNSq/G5zcpYjdDVjhjrLPr8A2hjcSkFoCE/ar9u1eAFFq4sCdel8HnXdQW9XaHZqqDmGlWjoXRQod2zQeqUIs9PlbCWmeJ+R97DY1eBWpogSdmUANvCQmQLOZXynwEdvFMGEAFoMxFhRhAEYYCf/amX+Ru4d55b8agvoGQJB71BGbMPJ84AjCgQzL6HHTbbyaxU+zIPTyjcP2Jh0ebFnk1XrjCtgk5zySzyGHFGl3ZiB+Ld5Jjks4OJQtEqq5NvYwQxKuKUy2IP0cuLilo5lgcxcSa3/GE8mZCYu9ICJOOx2M601sA8+D0SJ4Mufd7sq6BrBdVoVEea1j0lFV8j4/oOEok1w9Fre4I8VmIVwJ1z4WA9GVDakhK2c13qXH7+c9J7PmNtf6Vasc5PravzCbdBanHl9iq9P5FYNL32j14P5V9fd40DwbFnPRaz1om2x5FzWWVQYPDPzMLWPBwiyux9wnbFazPyRRlAVtfaVESYEQRByKQ34x4JXuh1omnnOByAxzr0qRfrogNIazUzFKODE2cwwrIiNkhaMy6QMzBJebKEjiHrqZAMwWaqzv3CcUUI0SXCh9zbuPKkxBlvf76ehUF+PSsUG+Q0ITzGzsf/PV9Q06p1PVFzYFBdou5XFaDRCjM7x9eodjS2b5ihOqT9gOSlsY4yLb26Y8uXjV+KxcqKyBpAh+157FwLBQHPuo3WUwu1YCGfVaP59w+XPlQ/5gxXL2k6MZGII2JtpWYN1Fz1Vgdkl/AOYz7lkONOm2lhsgoRe7RFzQa8S4X1MbggwcQMijnBc/bBf/ydJZZmbyLCjCAIQoKHPuRlQZBE37SaXRqUwsWAiAxUeoOASPBEb5BbOltojrEDPQDJDiprXTHQoR0TmJQTBkotO5L5Ejck7USm7nrnCBOxsgzmmbNfSNaAIf/iLBIsdlHRZtXHAYgH+eUGquGgNzUALLAesfvQ+2Tj/ih6fwMLl5Tlla4U5tttm7JlY0WN6I8n7+ng803ErQjeeTMxP5bqDrVii4hovgXBhIfaFoVAPKRWWY2Grsw9bbSL10KJ3W+tABUGBK4RTCjAFzFt/pHyDLr7aKAyQejZc7fxbawoM/Q8DpxjkgL3n7FuTENiJnVVbDdkCoIiyhxdjOwnLK0cGe3c2Q/8XQAL1ucgbt4NP7y6qLi7DRFmBEEQIjz0IcaFyc0+BjskAhwOWpgsElA21TGk8QuCvMKZcms5o5UCatW5RQQzjT2Xn4GyjxVl6OeilUmCtDgzenuOuWUpPQdaTs4aoUiUmRBaLnptuFWqBoMVL0JhpzIcBBVZaTCWMo6cAV8giPauESeshkl5xyjnsqFpzAz4+7TJ+L+F9VnNGmz/UMGuuBN1R7SUiKg5Fk1B/B9adu6cbFtExdAhJnPzoOceuncNWmx155bl1sSRYynU2HzSz5yzbgnL0Oiujja6bcPDfYjgyLZvLm4LEWeUHw/JiTN0f06MAZJCo/3SW9GQvC8VMPyMwgpSy20/bZkcmfGWwroSijPJujRSbBX2OGF7sk5RJvwcwkxgRNv1ofPoxYjb2w+HCDOCIAgMD33QS70ZLKDch7docE8EFXZ57Mgxbv8wT6aMrOVOzcy6k8GME220XmlHYGiQktonHGx6q5W4fdLnwgk83OAptPAphhu8xawpAH+QODTwC4IAD8UImjzIMi1HSE5diokyCREkJcr03CK4QVVsUGuOoS5Wnuigg3LRz2G969UhxZwTGbSSc6sPN6jmZECqTMW295qrO0Fnnotn4gQnjtj9IzFw3HmEp8Hdu8F6toClQFjW1LNVyFLignjpZwiiPZcXAFr7Ad1p/afHJNoA58hU6daSkon1Yi0sk/FjKJwrYURssctnK6WgQ8s2Egg49fwua/n42PmVuvQN1h3bhgzVAbGUOXpZ170nz0BujLuQUaLMUYgIM4IgCAEPfdBL2w+hIEMY6kCP7iTmWBHkDmoz3WF0b1To/07zTAkTw3mNPza1vDN3L7zBZq2KRJleGiPK3BPLSma6UgOB0tlULgjwqlw9ljWbbYvNCY3RspDPuQOqWD1R/opFPVcFJgZHbFDvHUesGXpBmxsNBWN1M1PQtYLertrzqlRriUNjzZhjJrkHNp2B+pIVf4Z9VuPCTjElbkQZFMfUCVxrkgHGOXfWgfafbeuM65KuK+imzbi3olPOOdB9Ku3FZOrtQ+tDqp4ZkcWVsVG91Z5s+6jtc9MASpNniMaGIkvbTyKEF96fXEpEPK+OJfocMogVVg43MRRMOgzV9ZznIDXp49qyJYrim4QIM4IgCIaHPuil7Yso1+888qJYhiizNDjXp8jKOUkBZARJcYu7trkDjF4+Xcc31klwg56EG4vdL5ugvElT3pxBgBOiFhx82vwK4iusBSJ8AMzA3c4wx8SqoRhQQx29cMaeHseJM7DCWTiYhevAxsvi100qOnp1cG42qKq1fqkUsAWoHU0GdYGIy8azCooYuRRJMZhJu1Rk8ePvTFgXE1ZnpYwpF3UfBNLthhdjxLqmzZuom2E8Id0XKzPpBRrmyhhYb1ls3KRQgHbtKXUlNBYzsfOx7m86EXcnSu5KWDlCY8Rab1Tw6wxWslqZsKspbg8WhbOSsZtcjCmUTRQBveeOc7UOf6O8/m2/jrvf/Y8LM909iDAjCIIAE6SMGYj1OkxhUNGJO2m+P34wqxihN5NaOtgOBjGegJAQZVwxFxBnHLmDZCa/6EyypgPcyH0sFChiMWy8NKPHjut8hwOBYpcKazVjxvQ6I9YOX46CnZcQqDA66Fd2yV/7O2NxAnR1LBnfgTku5vIUE2fcceh/TulEJCYLAN/tiLZJaOurbgC9ZQRH5feQUysv5ZJ1vyMCyKB1UGSfXto5q+kMWUCE26ay5Bq6ruE9s5u9tqubgdaVgt6q2hWLtGpFOHv80C10sWZ8YTkGJzgPiTPJNHRrlacjokc3sFOehYx1yVRWcKT3xpaDBqqPuSCGhPWjJE5aIq5ViSjDtdPc8SLKCClifRtgiQJNSpQByLu0IM3IM2fbnaxzWYIoummIMCMIwlGLW/qPdgYzZnDdi5IJgrgInslmYlYxPMZ2qqfCO2/bSR2YwVxInOEGzHRwwHZmzSHK/xtew2wqfyCUYmjmKjmI4gaJNjZIKkApGXcv0pHvBa8lg5bSQMvueFveFNzvI12qegLNkNAyKADY8sCvNznphmLD3CRWKTKYpPvD78wG9cfGq1E6GOCGdblpV3ZS89a9iZZ1irYgFXtovIXciHqbE0cpml/3eeFrUlBH2WcoEGmoYOwsrdofobcqNABUpd1y0lyavVhBcxoYJk9coWXuiTMmGHB4Duz5peI1hW6ElR9Y2JsxJ9Z87p0TijoxYveopH1JiDKetUyG0Bqt70PHTuyOl2LpA3xhYbi2eFXxlNj4Z+5HW6bFhcW4BR3T397jiDAjCMLRCzcrkHrZ0A5ySeDBTIsMr1OcweQr5wCRoMHD5uWp888qJzfTy1gMhWnZAUUvpoL5q8h6Naw7k7d6APiVT4bgBo9UbLLnkTObz6XrdcxG3nRudS2G2IB8YWuZMWSsnKOhzH6dkDH6uXDj2rQ4q62LlBn8OksBkGtmLAB0TUalqcGy98y359UJULYsZHcNYN6gcvkGg7mFgtymf4+KsFPFtOHSHUH0PHLcnJg8i8TnWABbmxaUc/9RxiLErqzU1BX0/roV3naadmnpxBLY4edu4wLiDAkG7AXd5WLOMKKh+40jcJ9NzphnWo1mMVA3c1dYig1UJ7F8WbFr6SgxXlgbSxXQMlcca38srO9LfB/tNUSYEQThqOTsB/6u993OhvUG7RzEkmPwpcFYJqQYE1y2eBYlY/DWW32GWFUslVCUSc3S2kPC34g1Q99n2Z+BZt09xszM0IF5OAizM8ElWLEoWH3HWmGMGgQUDpqzXVlyltAsjWdTUtZFB0R2kBgGO7WDa2pRo9ohaxuEVPN1xdZZKGDetOKMipRTIz4jCfjicSA6qVnTHapMQGArPoKp43bXYBCcE8g8e/A2VWyX3LqyqBjElTciynAMWccMWe7ZtqEVvgHMAdRAs91Wyq1GAzOTVEScnhLWldbGaYoJPeR92BPKI5ZloVWIV0dDsdxNliz4/qFuVtQyhkvT5al7ZYpB+w9Jd9OSZ2kFVjNH28B3tzCJi/gI/ED23A6Jgzc5Zt0uQYQZQRCOOlyQ30D1z1lCmds2+cszscTrKma3QtGnJyoEA5ilmtdGg1Hy1jKuDHT1ELvJmPpb8UQzA7GFLX+Y8mddl8CEXunW2kJX5PyrqrXQsJPxU3WCSlaM4six+lmkPIl4NYrEn3AxWqh1QY5oY4QX9/z3hDUz2LIrytDjjDjjudC5/DVUrYxLSD89dHuhGwlSCwH/vJNWa0ZA6gXyBt9GlbZbo2bWM++979YyTsDM+m2Eu13MQs9jKN7YQNwXKs6gMc81GeBz7dRoSl08UzFdAhc6F3cpHM0pRnyh5MaA0f7qcqNXZXLHt6KMpu8IK6yTR5Ieq6p2O2tNoPztnluiS3+grRQE+GIksDpLmaQoE4qVwlIQYUYQhKOGs894iXENyXjL5XSSpgj+yw2KE3mvzPSYmQUF4MUHCJfnjQ32smZ6QwGGxpcZuMZRU/jg2nqDZ7rPAh1i1pXK/ZhZN9hVc2yQTAA2zkMFAGZp5AbIn3rlKQ4iPMQEA+FBmAGcqsjMd0mSnFjCuGrouvucjKVBPqvGJG6W/VXmWPoceXm7wR6n/pqkELgUclZldnUc+M/dUADJ0jYlW9iZyoKGaydzV+EpzSciCgDwRTi73VpVxSyozHHsZ7up6eqAmjWt/qeMQGvOU409pwis1RTnqsR99yxL0cVfodY1TD49gvOJ1kPONXQdGLHRX0HNtD32+SbXSDW+W2Iy3ZLtgjAFsTY0tnmoHkfcocLFJLr0EOyfTv5oQIQZQRD2PGc/8Hf7s7c6/rKYlAnTjgX6HTWTPZjZROIVIeo+URgLwR7vrW4SrjRkA+qG+YUBhQusflKrP8X2HyS23LDdPicDEeJSo83AfKqVnpZK6TMwFAiZ27/2B4LpAMztn5QY06aTssYgn5lBqt2uZg3UjkmrVsBWBVQV69pGZ+OTy/JWQUwb+/wQFyrWqiNxPqGIUxJ4PHd7PJ0Ba4kcQWfRdjYnD2ohQgUK+1w28C2qQjcexnIkFHnaZbLN/bXWMs7dZoJ3SRB0t3efQuElPN/YfgysUJ7hPpvzLphiANe5L9OE9eKX2bYNc6TfbSK6CBFWMgGXaykDdP3lVJ21k3aV8qzQXBup+5N5Qh8RZgRB2HO41ZYAtsM9VpDpLSc6xeA209w/9ZKeepYh2SkIAjcCRBQJA6AmysbmQQcwIwQHLrgvGxQ4dBHR/ucx4oyf4BSjBuVdB+feoIJOz4JwS6MXMUFZ2GtOVmfxVq2KuF3ZQZZWJNxzog6FKxl50GfbxJVJptcw2+y9axpgNoeqKkDX7f1DA1VVPUsyJ7ZU/jnBe57KxTgvmGsm0ecgwy0nevwUq82UBtDOIbc8RHRjrw3jRuZdo4x3hnNrgr1vJq/Me560ThwQ5gbj5bAFbq1kspaznmJANpWgbC1fGp33/hyqI7r9T0FBz8l7MBZzRganwgArXXmpEK6t0CZtvaXQ2LhqMH2XncZZBfp5F2e95xFhRhCEPYUnylAWjaMRkhiUFL9swkEokyb9HkuffVmOfPGVLktq43uoeb/8sVn1/kbFf3aZRGZvQ7cQLo8wroeCf70LhLYc16zs6x4Icy7ugRmMuc59o81AHcCc1rW+GDWaoP717l3JgHqKZyzxXHjlscLN0P2jgl9o/cBcPwV0QX7Z8vGbvUEYFdiMUKNQteJMKBDaWDn0HlRdml764cwjIza6Oo62Pxw+myGptsYL5hrZhzLYfpS4vTFtYhi0O0cMZtvnSJ1m3ZW83xMWTQMkLVXs7yQgcOjhNuVgJtqGxcTxsJ1khJhF3jmei96KSLWdRffYtNXeIbGkF3ShFZbPSuK7rJqYlQyFqZahtQzf5reTRtqsJKnrto67XaW6ZyHCjCAIewZWlMno/Ez5Al7FSzxnELIp9AQQ9MtfbLJrg0zaAU5gacDe84SYw/4+wELuS8mE0a7iUwFqxg8IMQ/LsliPJ2aFsVZRJiRjWeMuzoVilxfuH4vOyiES48iJM4W04kkFvYVWgLED2qbNWOl2QNuWlxxIXCu4ul0yUFRmgtIdo/jAwVOazI8VJHOZovxJq7iw7lJRpiqsC8R1iRO9ejBuljS49ShCMTKsP6mYMqHokhCvp3oP5Yr4kwTdnyr+UUjvXkcqqIgzG82m962KSFnJBMIvZdCali5aUJl3mW4nAayFjJo17fchVyiXpy3j8HnsRUSYEQRhTxC1lBmgxI0F8DvZ9nMs9suyWSQOxGTH2MCU5qUbXh8AyVWlYlY+JfEGHMFLn4vlYIUiGsDYBlPNPedcy6RsAS0cpFZWLGmMqX1opbC4EBPblhS3hhg5yJjsuQlizbSJx3qcqosHEhusUnGmdBbfDqhV3Vrc0AG+Ddxc6dbFaW47tv7A3KtnNqhv3XWEbd3t7UvLbpZfdr7/DbHC4s6dYWEhNUaGOJN81qayyorBubuRpdV727gkbHsTCz4e5mdwcYJIcGtnKTVU7lwScWS8INW2jrko1KsVE5YWbyPLhThof+1HWp5g2yLt8ySC025gypXGJmQ3WslE+xmR+t17l8UsZEJyXKDmxGLMBL9WjXbWmqnrupJFLXYBIswIgrArGSvEhIzt9JUM4rNXL+kFgl0gb9LZHmNhM2rVlbH0rEIyj4nEiilyrWiGOwy9POyALRFPwe2nMpfLBunoNICqumNXuTyls54pdf2bYGWrRaBpeHFmOIzlA82yPSYgNigHegGEe51Ua41jrSzsddXad40KLXOYVW1oXe8NFM3A2XM5Ci1/GgB1a2KugDxrIpD04N+fsM1kXZ7QPy5KTFxyiXTXJPZs5wbvtmTVOWptQq2rQlGGxsYiZaauZD1xxiuY9uPXbKngeqtuZrpZoD2IiXCx7aTsbd6R8k9IrP7k3uMeEwgA7pmj+XJl4CwPUnGVIm7LRec5ocCxEkvc8DpsmECzmwQZjtCFdVwa5F4E9bezvjS/09umzXL29j2n27SoC22ua3vsPnzwH38Hl112Wf7J7EJEmBEEYe9RaCJc+jIO9+dmF8em3c/MH6j10gs6Nj2hKRAwSgcwS6dg5n4oCGuJG0UYwDgHT5Sh5aBuVSnCTmjPxcssrdroNmmteVPisJOE/MFajuVHz7VpGcsSG5IDvaGVmNj0Sp57fgZQAazw55cN4JbbpjF/tLfMubGgaci15eKWJMQZBeVijzgGLGba35QRCsY92GG9nswdisaGssGtrQASip4DZS9ps8IBcDKNUJxxaVi3ucofCFnxwrYJCWtBLt2u/lCxSxe7M3nvgZJ4XRh+N5QGks6BtSYaOamQTWkwaiIMdu8C+xtYy4PctBcWvCZwi1rle3/S2GgjyK1Xu8FtvNwiOv4uSAWo9sTJoC/m2ijynUsjxtKs4nYhIswIgrCryLKUWcfsy6K+r3R2MhHUMwU3u5i06MD0nY0h17DeCzh1fsvotI2coetZIlgilkl2m0eYZ9PvBCmYi1Ypv6Mf1IuhQfZKO76TzEoHdSUjpgybRjKIbF5ZnPVM6tpF0vKDT5sOMLW2sC5OTWTS3YozNfOjtm5IfeuPfkLKF5dsEMZG+78zAtSUYrK9r2x7Q0UlO7Oq2wM0dTMrFJZjRIURRgwZGijY2EC6Vt2ARcNzjWTzDPMORZmYYNxovsIkSJ5D4LbE7hcRLnKEuiiptoITLJl2rsgqKxY0nGl7vfIxaEXKE7YNOt7WsgI6M4GzG0SAqViXIGPJEQJibtcbd284UW7ATXTw+gfPRCjK0Otn01Lz/kux5FnduOu6JkSYEQRhV8G+HFOdvSWaytLOt06tIFM6m0XcEwY7B5F86ZLKqQ7Isn3aR6UfuglldtizmbouBC4Wgz7fOQHwTGwZbQSanntRQGjlstiqMSOvzwYEs4zWtybcry1n7Bqxrk2RNLKg4gzJI0xHRwd+vqCSZbVA0rLWNr3fvbwzkox0tHtiKxF9SuN4ATDuV3nlyDGN73YuFFfNdlSBgGWe+Z6Li82btlkDz2FnfQN+3yAIMLsqV4SYi1n4e1EMrEgaY0kOkCPC4ehBcmwChP7GFtLUXZD7mhBjwmPtM6Gh2AEsMPI6jgyivTAjhPOs3zeEdfaZigjcDRcmdX9CgTxhXcOxMddswxFhRhAEYRG4jncYn2PopcW9VLnYEQSvc0DFGQQzdFwncCqBg4ETKIo6MlxHNxysFsRt6ZHZMcyJdxHDDhw8FzfKUPwWez/dDK3p0CeEF26AsO5ZyVIG60nJvaMuZ9wjsEC9z7mubPqJ5bUdVLzhYsFUGqhS0Wbjzw8dzE5hNj72GWQH1faZtteCO8VIu5Udk6pknzBuDHUlpTPIToRq21qv7tn7XQXpBmXp1ZVU3TR5arRikcp5vwC998ioezeF8MpMJLj6yJ13xIV30kHewKCWiqWdy5VpB1LXw6ar3X8Lk7I8WxkVWRaZlou6WQ6UaRPEjXXnv1EM1SF6rUJRUkSZSRFhRhCEXUkvyFns5bBpMzSmQ5rVQQ46r6PzowO8gpncjWNF5WXjHbA7+h1TOviJijIhscFOY++PjvbpRwsEy2LEszboRsHBCFteOuHAOEUY0JcEeKVWSKwFUkF8pPBeOQuJWCDZufaPsRY+qNoTTQVyTQivPVcdLp2wTpI2NkvUYWIw9X7j8g1X1KL7c9undIP0hBTzNxSAw6VhCUprL06OapqujLpbBc4TaWheYbk9sc42LGgHw8Z9SmkN7DS+i9rQaW5Sk0/fb/TeNwMWUWRVPUtpTIti3CRDQT5GhKIxgsaK5THLWWD191QrBV1XJki1cgKVmiErOPWoCZsVsytinqRWXTJdB2DgfuQ+L1ZczBEkvbLkJS90iDAjCMKu4ewzXuJMih3rFl5Sg4MgMOdSX1I0yGRFBuT0+iRmnJdRtl7nhg74YjP7ZIZ0yPx+LFy6g2kGMTvcbGEvgG9hYVIxU+YNOwgpgRUEChkTZLgs/czrNjizXXj9w0FxSUBo5rqGFk12e5Qc4SgQOZTW0GYJ7HZDyroi416HAkfKND6w4nPZ0EtBy9ugH8h4yNKFE3FiZeW2ZbmWMGlYMQWAi3FT+qzYODmzBnYFLl1VQA1/yXUuXXe9unNwS2YHZdeVQlMrqEahnmnYEdjgYL10pTXKlC4zYVqBpSddBp7+7qHgWVKGFoVZ5AQXr4J0x1w3YKFlzlP9h5WIB+F1UgAqoKlbgVI35jFX2s0l5FhXbfqgfdPL50GfKVtuIs6w++dQEUFRFxwnjGbEuhSCIAhxzrn/NMtYh9Cgv5vywswtRxuLwHzxArhmHDzQGY5ZGyhNZtypW0cinak7eWPT466LvYaT3Xt7TdyAl8nfCkU2nkSl3MAIADNrHuSxxNWMpiAnWCW3clFUbFhg4Ba6wPXqI+ceyFy/QXcYSkP+lcJcA3ttuOuTuqbuWW3QPadVf7+2zE0rIKSWvKbxmYYgFjYqp+Mdu8e0jbFCB7VCicV2Cdsmbhsta/iZxrPJHZjT/c21VPN5+3fWtMKK/WusG3vXJpbfrGnT2pkBs3n7mdxTr02pmPtk6+Ncm3tNlpvVbb62TIBtE80AWXXb2vzCtLvnZlR7P2V7ZcsSq0/W3am0TSndP2atmPp9DJkuZ7Tto/co9t5bSl+IXnsimoVtm2oANdftX+vmZU8xca6Tvscz4a7priblHq27vz1RMbMe9tIsOU5YCLGYEQRhcs65/0sArfGBf3rR9InbjgLpnFo2RbABsLTZIq6jNmiRsykuS7FrMnX5hmaGs1yA+DR7RwZWUXT/YkuTiFvelFYqUy2rHV31qcRVzytXfLtWyJuxp7O0dsAeuCqxy1or1XNjsr9xOOsY1Q1aei5RCWyeyXuhFFADGpUvsBorFKV1V42ZOByD15Psr+wyp9TKrnSAy8ROcTiXnsizmGvZY/Oh38dirVuapqsXzlIFrYuQatp7WyvorQqqqtxy5d3y1brfKDBWgZoIMu13tG0EADXv9g3vtbO4sVZS8zbLqmmI0NOVwXPvNaRcM1mrnBg5Fiax4zKCwqqcqWJbNzUQNQfIrbtDokxq24pYeZ8mZqEZGs3MNKr53D3XbmW1JVhULspGCzG5CwIUtMfOusUytv6uK7D0UY4IM4IgTIazltE6PaM7Bq6z2TSsiXzI1K5E0fTGvMiW9eIjptjafO91UJhB0bLcmnrpZtwvS1F5mOvZu19sAM6yNAH0Ozzmenb52O0D6Zp6o+uq7dxyaQPDg/kNJKc+cfd7VGeaq+PJfLlBGP+bJ75wSxx77kC6HUCDCD/w7x8VAlJBT7GloM2+atYAMOKM0kBsWe0cSJ0Ol3dOCmE5nXylgMos+w2Y60VEslwhlrs/sfcKHdRzljWhS5i1SJk1gHEZ9PadzaFm83b79hagtqFJbB93X82stLNqqQBs1e27CWgDNQfCXXrJWOWLRFaAU6q1ToBxJasrPy4L4N/TwC3IxRPKbT/GvMfGxnmzv5N3VjINK+JM1RRukCXAQitOWcYGaaaijEJ3fcNyGBGmYtvP1V/LofdHLxj/JsC47wHoX79F+4dTBOsWVoq4MgmCMD1aQzUN/sPd/uty0qez4oRVzIyEnaaFXvaxDmj4jzDGDDhp/cCY5C/b5HeUC1hxHnGBpv3SzWD3AnwyptwAovfFpRu6q2jkDR4qayYelMPmadNTw5YspSwi9OQFH04dn3fcUD1kBUfqRhPNgwZlpenFBpjwrG6G0k7vwAg/4S61QrNVQW9VQFW11hNVd7wKnt3S59Yux65NHuOfNVuAQBAJryl1a7L/wvOm4gh1NXNuE62rkJrPoXbMX2P10rvf1gVRkXRNOs5ihopj1AVMa2A+hzIuSU5oock7F7Tuguu6ht6uofdttf+2zH0jbQ11jfLKUKFzYavMPWcshJRGuwLU3AYcDu9HN7jWdQW9XWO+v0azr0azfwvzA1to9m+h2Ve34s5YAS5k7KREwuUq6kIx9PsQGz7gXJuljEJEiOn+efV+xH2Ysm+R39ZNk98kpJ6TWN8jRer6j3UJFNaGWMwIgjAtdMChFP7D3V+Av/nCy5aTF+20JkziV/5SXsR0tIDkEtre9ki6GYP8RWaawpmrkrQWWg67Ur0BE01zVNqMEBOLhcOt2BKmAXT72Q4xN8jyEy8s85LIWeUh5xoP7ROd6WRmhHsrMrny2GPMv/lwufwydJknBZuq3/5EV44BetYLvkuVrS9wK/BAaahaAbpipoh1l54nDtK8+9sAuFV+MNNQzXzUs8EOjsJVpSzUZcwlELTjRpTxhCfdXRNF99MVdM1cP65to2KWdSczYlfPNU8poDbmSHZ5cq2htGoD05I66JbItpZC4ejWq0O0LN1nb78axFWqS6MXdNla+gCetYlnpVUpNNvtCjr2u67b61gfblAdmbcCT4V++8S8j6LWjJzIEnufxQJLp44ZKkPK2iZkr4sypefHXTOd186PYZkrHk0yYTY1qdWTyOdRkyQbXpeFckSYEQRhOSgFvV3nm04nOPuBvwvAf3nRpYnDAJYlL+WSZSdjIoN33Aa9KJXGKJcyTlCx2xdNi24P05+MiCDDxn0ZGowkAvwOuVwVr+ZBO8OR/ad2ZcqxwMnOc2Tdp3UkfH6jda7UXN8tuJNXiXP3c+1Ro6KCAL1+XrqKX8kJc7RiQ0MKbvbXW5UnUjghIiLOdPmSL0GddsJPzjXN2cdYtrQxfir/nAfstNWs8a1T6GpJvZ3zhOU2ncaLKdNZp1TEmqZp76NSUFvWckV17kiUWGypIevE2O9h/Bkube685pp9/7iV+Sqg2W7FGaD9PN+vUM3a/ap50x6jg3Rtkbn2mwhJ/nswaFu5ulISJypCUvDfoPfvIqzM9SZwqcleFpyzcipginMr6btNSu65F1qpjBJnct+De+S5OBoQYUYQhGmxncst5USBc+57IaDUqGDAZz/wd/uzmYsWcSiZ1Iz8lCzwskwF98wlHeuAt8gZOi6VT1n8j+k6b6Ni1NC4B17shoHziAVPTJaRWe41qIPLWaZ6/aJMV5aM+hGZFe8dG7NGobs4gdfeb5pefIYzFrhXad2JM0MwsWp67oRzc172fADikqPM+TbONUeruDAUGyC01iPKWLcwO3BxZlL3mZ6DsZhxcVm44MihSKNb4aSNpYPuPs7m3fe6MtYjvEUKWyYrFLkyKSeEuDgtDVrrGXMhNCooEhvIlVtpFzB3sL5yFp3c8xSxcsq1OIy2y3aQPddQlQZMemoOs5LOQPnh7+MCFlf2HpB9nGWT3Xe58bAmt7oYG5dliYx6B5acR6pdKGFN121pK1IBcbeg1DHrgt7z0jZb2DgkxowgCJNwzn0v9E2ylWpN5OuuE1y6lLa1lPGIWUNk4jqRdkbXpFFq9bJOU9lkh9Qz84/vuIiryVgf8dSgIpZPCTTGRqyM1j++J4Kk/LC5eDJTQPzCFx7EjPL1T++36kDDXEyhqGDAnSNTXi/YLuB6PVTs7a8sBb53RFxePGEgdJ0iAYRTAYa9dGiMkzBtpq56cVMwcjDVaBOrpOmJXjQOCktO3AKuDWoGrkuDeBtWETGlDt4vIOnSWDZmKWxll7Em7yhN3k3u3pLvNg3r/kTdoFq3Q6qa5DSoqcaufzznnpfd9jamndtpUB9usHVwjvpQg60b5tj3gzm2b5ijPtwuEe5cJKsuJo+u2+sTWlo12zV2brIPh350Hw6evB+Hb74Ps+O22sDlHGNiZmTiyjqUbCpumP19Qyl638Ri9mTlw7wXw7Ri8da8dIqzjpQn/m8tTF53C9IrFVaoSCOizK5DLGYEQViYh/1/LwS2mI4ZM0NoxZkPfPKFbFpnn2HEmyD+RvuFycJuK3nR2c57nS+wZK2WUOAnvxTCeAyZMXeGYqakrHOWKVCxsUUoi1znYCCaE0skZdK/EMuoL9zMGUNqSegiljDjTN2bLFniHhmcs+dRwbdWyaEK/tLjiTAwxroveq3D1Z6AvgtNhW71I5egTtfJ8D6559+UnTS0SqOLqTKEbe/tNZo3rRuQiWnSpqf58sVEDmIl44kpsWPRvi68TVbsaTQADaXMGVoRhoh29lq21jKkPW1MQ9iY7fbe0HOJWcSE51TyG02vtL1pTLSbZg49o9fUpme+BuKX1xbSVZ0ANPsqHL5pjSMnKMz3KWwd0jj2O2hFnlmXlgusTQXEZn3LKbuy2HOmMXU2cPA6ylJmWRSkvWh/gO1rDLVnU7FCi5jOcg/8c2jJbXspG2j9Nci6+84bhAgzgiAsjlJO6Ii+RIPt59z/JdAK+OAlrUDjBBlL+EJKiTLM9lgHQSvT6a7sLCiZFcx8OUQDktLPU71gmDJlWRVEGBsnxstnKkGCyScqEg10TnJnkdltNm3SSRokHDBxlhSpfGOkzjMIOjpYX2NmzQWCzdRuhIsSPnu9OpmVSPv8u0E4Y9WRQ8xdw21LPSdcEFyunJ5gyAilSvFLZuvO5SYrBgIZQGtUwLyJt6O59YdYmXirC7lr5m9TRtTR4YWxIghNIzhXAMRFSgOq9sU0eiJN0wosc3LtbNqVL+op8xehIBQLMszd6wEhyW3mRHDunAsGqnYZbwWNUPzqvfdALbjM97YWeWVstoH5AYXZMe2xNpiwi9lFAxAr1bo1u6DNkYKuakBG2/ij0eVjrMiwomvDuj2vQ5RZlRXV0GUtDWYddU9b7iSaMB0izAiCsBAPu9eLXJBBlsRLVelOoInvQzr1kc5BLIZJLDirrpTrsLKUxphZ5CU+gYjjdei5QctAx2ZVL+zQ8oGzhEgKMhmrhIRkmbnD1LMwzgvNv9Fx6yHWDSEyGzt0v7k4KnT/MWbNE3QyPRFiqIxLJmq5FH4GfAsXaoFixdlmhHVQRLiJujeFvw2lzVjKJOtxIt/Y8+EFbCXtYntMW2d0SvBLYS1UbHlCqxL7N1yBym4P4/TYAT6tgxEXKaC1elFudSQ4EUJVqrXiadDGsVHKW8qaXJ32DwkOzL7jIvdo6JorFNxbmleG+JgcgLHWY5Gdg1n81mVIQTXA1kGNptaoDwPVEaA6Eog+YZuTI3QuuS2xotAUsW8WCYY/Bb38c60NiHVo0TWI9IVWYS27NtelFTDWwtIj81nZeFHmaBBFMxFhRhCE0Zxz7wvbmURK7gAkx+rCdvA0/+LqLf1KBs6D1h1Ktf71JJijB+nsZIky4azFFFYzMSucoY5Y6AowJM5kduxiAYFL3MFS30tJ3ZcxaadWotB11XakbH2IXM/BDlZunZhyP67eTDEjGEknq05w+TPxowbjKXHfuYEgJxxba5PUcb0yZuwzlob8rTTsMs2pdq63kg8U3KpGXF3siRB+OqgAbRIbW0NUrM21rkJmYOgCJttjwpgywfFRUYambT4D6N+r8NyJSyt/Ika4sdYyYb52W9C+9oRy5b9fUrG7kjD3LSZwD+VVFPiVCHb14TkOfE9j+4YKum6FmvrQvI25w6F1u7pYyloGRCDU4JfuXgQaI8yJbhGRKsNaln5e2cpJg2Jo7gC9UJxZxSIICRa+vrlWUeZdFnVpjgSeX5ScexC9VzFLGRE5djUizAiCUMw5976w/UAHO8zsYfQlvooZK2ZwwLoAZAhJQ53fKBN2qFx6TPqs2W8ozuSmHwS6Zc81MiBhy7qkTgJXtybxyw/L2+h4YEsOKlYsu4O0CR2wSBmmWlEk2o6krGRcepHjOHFiUFDrPvbiaGC4g82tDDVI+HyF1ycpakfyrPrtYigcwAyS22tfXsda65KqHWdXjFtSeC3tP7paU+i6ZK8FFdFCy6LALYl1KQueeaV1/9ZTd6rQyiokcg+i9TanzclkKXFIOAs/gtqZo96Zoz6ofDHFxekJBrYaYBWZcKBrAg+3QZWzzmYt5K6UNSncREGYZ+ZEUFE7NCDKcOc+qp+0DlLXyzY7nAXtVJMaBYwR0ABI3JZdiggzgiBk4wSZFKYDTV/aQ3Eghjo34YsptW+WIGRN23PmhK35bxh005JjPjzmxVj68s+M+8Jea9rZCFx30olFBo3LiLcTCEarxDc57rZHza03tSM0YtZvlKDgjp1GnPHI6aRaLSCMz0FjkNDfmfgiFCrEpDrJvd8Yiw/vWoZxZnL0P3N9hgaIvdWoTPmthYgN6qsq02RDQUO3sVeIeJIzs95rcysAWxU0dU+y50vK0sYkaVq3UnuNrZDDtWe0HKF4Y8+PnjPjTqaqCj3Bi7pU2TRjS4+Tc+7BDYRIu9GL9xM8h0MWYkPPEvvOzTjOwYnyzEBUabSrXcE+F+TH2GAwMqnQHk+eQwVstDKDDEu+ARYVL0YJHqFgNkREDAotwWJt/FpFmdj7LVYnvecVvgDMHRdLd9NW99rUfoiQRIQZQRAG8QQZOuMZC2CZG5wwsGaZ9GWeIVCsjDHiRO7MjIkFoaB6AxEL7axPdo2pC0Vqmc5FOweJ4xc6l5KyNtoLgOnyDkS7PQE7EEucH2NlVUpv8B97XnIGFLHnvgk+Z4oztFzhdUiKVgOubpqKFQOCDDuotxABg7o3OWsX50pjzy9It7Ftte7EmXmQRYk4Q9oFJ4Iw5+2CA881MDMZxizTQoGN3LNs0dDqPVCt+ETTAfr3IWElkxuYPBRJegNy+6wxYngsPtoQxc9fadyuirSEXH0ssSig8b00jECXd+hCTBJza3wfYtL4KcsQA3LfZ/bZJq7gG20lE4PE3hl9fKnr8aaJOMLGIMKMIAhRehYy4ZKxlERsgN7vkX044cAzl87stUU7PmNfvEzaxUwkzgy6TkRcuNrgjQN5JdikIHyTdP4KTZJ751+pwQHrQjOjU60Ykut7HgYYTl2bxOx3NiSPaFyLME0uzofdHtvGiCkAgLkV13R0X8AXJbj7ne3qk2nRxrpYUdEFkUFhTAxXkcC1NN1509bniogrrRnN+IGyifmibF7hucViyrCBj811Z7bbvADE4/9Qdyqt4zFlQnJEGTY/fyY+OzaXZ0UyZBE1ok0Z24bE2oNUG5Xbtpq0ozFqFqBY3BpZhrETHqt+j3HCw6astrd0Ive2d000emKyR+xaH+1Ci7hNTYYIM4IgOB52rxcBYDq8pQQzKc5tiHbQI0IOZ5LP+vrmFKN0VivWycl52UzlspNbpgKyAkBGrB6WMQM2GCNoxLWcZKCSEDF6VkfGDcQe17lmaLffaEYGphxMJ5bGojPfY8s3pm6HbUdK8AhdXxpfXFFNu0IP5w7TS8pZgoxoi8LypsQZ7vegrcyK3UWD4ebk1ehuaeiRg7Xc9tZZy8waI5RUfpBdWj50lkkquI52Ty/oL1lly/1O3y80bc8VE/73ngiUOKGUcEGElvZcgvQKnoExbdwYa0l2v6FyLvLuW+TYDRkQjn1nTmLFmuNO7TI0f109DJ6rvTCwHiMQGqLXoiQ+E9eP2MvCzTJc149iRJgRBAFAax0TfXXQmcgwfgPFC+CogwEP+jFdIoMU2nkNB7yjiQ02wvwXiQezyMs3Nfs4ZF2QINfs3sL5kHeJ9e8piy1vdJYqUYCR13BVJtTe4HPeuh7ougJsXQ2DMa+wbDF6Vla5g8ERHdxR4tii4gxbEG62sz3WuU3Mte9iUwHKxBjRCbEmW5zJse6JLcEcs+IJBW16LcJ9Q7dTt90Xs1x7S8XGKQndwawoM29aUWarAqrKF1DoOYWiGP2nVCcoAa24Y+8p80bTjW9907MmKhFkKLEBWDBIi4oeMSLCY065claCGsUmDLwq1S7v7qy7gn6CcbmiFrdAYuA9ISXLSa/73bCwxcwEVshLITUpMRRvJ+e9l2t9mrP/boe+w/fyea4IEWYE4SjnnPte2Av06GInmO3e4MX64ufEkdE6L8BujKl9wT3hCCvpVHiDuIHZhGSsjZwX3gKz3X5BmDSYbakAkdyKDoOWOwPxDopWw4qUI4vEMaFw1W7T7Yw/6wpDymREm1Gd8ZHWMlG/+dKZvJz9x86WlYozMbfIofpvhQxYobhLS8FYXhg3l0WCHntlTLl4xkSZ8LihPLj9XVq6N/joLExix8C/36V1RXXp60a1Ypc2Qth83goyQGcpU7VLL9uVpNjzsWVnLGc8F6ihulBpF0NH0+OC8y+1MsxiKvfEAM5SafIBf8msePg8pwa6Iy0BtRVQKwVo9FZzau+tgt5q91FNW/8wxzQTPRi2EJssptsU7zObBm2OwuejJO1dIMiw/SmOMZaegs8KrskHL3nh0vPYBESYEQQB3Cocvc4vyAA0hlK92Vg0Tf8lPjQrrNRkHUul0c2uko6/huI7F2M6QZGBZX5gykQ5BmYiaPwYLz7EInBpLNgRyxrohMWY8l2fM6MT+y081rMAgAmg6s/UWhEmTHslM6QZwQyTAWUnyBsoTDsc/HMuYSkLlFT9JPs4y71KA7Xyl0UOD6PizFAcEw7OugWBlUbpc5UTqyblCgUqfpB2tgKUZqJ4xdz9yP0JLTNoEGBUGhoVVNNA6QbYmUHN5tBbNbBVt/eAWnQ1wQVWQeDiBtBV5b2fdFgHuDrB7R+IMiu3XsgRJTLrBxUJoitGMe6qg+eciqkRpOelVfLsL+L+oE07y80lVArNVoVmS0HNNWo0bT45WW2qBcDQtUqIf1HrmIJzXHRFqsmJxOCjS14D05z7qP05VuXWtKl1WEgiwowgHMWcc78Xd4Nw0+mNzlgSc2Ftl1SlVjPEpNg7hq6AktqPmVnuVi4pe7H0BnNUlKF551j95DI2FgwZRPfMrDNmKYdWeGA7zLnlzBgELjTA5wbxJJ3JOoG558t1ZMJjI/FClA2g6uJbDCw3XtJpWqLJfc5g1BvETRDzKEnsXGMuPdRKwn4fECa1ApRS0FsVlAruJ4cdwBOBOnrMQHuiw7Jyx0Ta3uS28LzNd0XbVtrumXZZme0alS9OReqnq98VWncwFIgz3nJXqvtnJwZszB+gbwETBJ7vuSkNteP09zqyfR0k2oHw2VRE/+V+zw3uPtnAel3xJIzLnW7c+JsfePcsQtCKMiUxWQatXLvP3HWdfLXJUmz5J7xP4Xt5qeeXek86yynwz/HQBNUa370rYTeX/ShGhBlBEMhLTcdfZqFYwh7PMDZmQRBTxXVwcgMQUoGJijIhzpVB+QPPCVwycqP6e9c0NhAqtYLJFZ24DntqEIy+GDRV59NZN6kFl9+k9yHXgiPsjNv9SX1gBzTGXc9zWdIL1KHdQI5rywTnztbHlGtQZpqadOS1HaTbQR4Vb7XuXJyqjHaEis6MlWB/BZCMZ3TAtYcVmYfSDOPOBC5NXpsT1mPyqujl66VBxBmlADStEKa3oeu6dWOqrahJ2pfKv352n54INZZIWbMZEiYXEegHnpmVWCuE5YhYsnFlyyImepe2l41uV2mMtO9Ka2AOVIfnqGaqfXbnTf89GpsYmZCSmDMsua6Eld/G5LpQj2GVlp/uM3kH2/iDum4Fdl0ZS2/jskZd2wbjyJD0Jy0zl88Ylj0ZImwUIswIwlHKOfe9MGrqHR0whLOXlNhgnjs+5tpkDx2a+eNeUoOd2i7ajfVPdwOp8HxXOKBOCi92ZtBdd8V3bFNWBpFBjOuIhqJDbOAJeIJJm0baUofut3K4zmys81X1B82h9VLOgIiuaKOVAuqJAldPwBTlWMj6akReAOKiTIzUPs7qj2ZkhTS42CMAOpcarU2MFCKAhMfaz72T6Lb1RBkbqyu3/KELFV0BWiEay0srE+OFQgLkhuXs5zu+znjWBFUFvYX+OycoRxtzBt62wTIy+VG4Z3epbVJMfBgaYBe4ARZbuuUSyzenHmRaAYbB0z0RPceaJRSOOLdfI9yoOfrX26ZhRRnq+qn7bf/GMOBqOxhPbLfBvF+8CRCFVpSpjUADhWqnaYXe8D7m5LWkMnssYFW9csQVai2IMCMIRzP2xUU6/Z7//lDnnc4M00HKmPgkgTVGr6gF76beQMXMinvm7wUd/mJSrjC5xxG81XQieCJJ4NYwbilp83eCVVr6S6CTcW44U7lM14LBeA7mb2y3LGEgM62cWDe5A5URFD9PbvYx49gJBKB+IRYUZeg+Q2KldfUBTJwZANCBq0/lBF6uvUzH9zHinbXESUGFI8AXdALLMva6VWjdiKhgiMigxVoXurx8QbKNpUTFprgg1EtaAairzgUW6FbFslZydrns6P3xv+daj9hrM3kgVjrALxE0cgTNAdfVEO78YnViUlEqFh8tEn/GWUW6HwsKYwWImn8p5Vio0tW7BgN8F7ZjqYmKZQmBdkXAbpKp3b4s65914s7VYtte6iFp2qycPtPSoO/vUNyYajJj2ee1iDWbsBAizAjCUcY5973Q30AD4taqHXCYzrKa+7v2VrHgmMLlhroxjfQDdp3xnJegCl5CXNpDswexDnsGyfMcG5ivUODodSpjs/meqTS8z0PxbnLLMUhJRyF1HyaeiVp4JZ+QobpmZoZdhzWYJZyyc14szoxkVN2JCcGctU0YiyXcRoUQT5xRvtWKMs9CZQTfBrxEQZ8jeryJ/9LGdomLRd75AH58FAyIWM6VAWQlJvMTgvMJn/fQig5GhKF1vFLtSjfIrxOemFObpG3MMiPKxETcoXQX+X00KZfJlFtDrjgTHkd/a7prb/8WxZ0pJTzHzPaTLQN9lxS94+xLhm70f1NVsL/q9qHHuYka7z222IB+zPXOsi5NXeuYteeGDaazVw6LWQBVZhUu2zZrbVZ666bcvNW51n3+OdbdMeEQ/vt7ma52Kbxnat3X8yhBhBlBONrgBiaWBqSXp8hAW3eiTC45FhfhAMK4GegcP35gsGM4+Qyp/c75Jw8dx7DQIL5S0HXVDnQa41Pd6OniEIQuB26mPXFIZBCVug9+56O0kAtg3Je6GEbaX8Eh8GdvfwiuCYN7VshgYamdGlrP7ACkxOKmALZuhc/qss4z1W4NEXPT7HX8devO5IQH7VvZNYByLk4K2EIXNNeIH1ni3JC7VVi2nHZiyOUrXAUq3KcBUKNrf7ksyPuAbhst1Dnrhe7zMkSZhWN8lDIkBNPZ89T+Q+kZJrUIymWR+FKxOEy5hIfZds/pLEGbqKgyExzaew5GtjEJdyJOKMkO1k+uc3Rw7vpRmyvKAP77I1VX7VLnve1bfnB9Zd51m3zOo0THzDRHCXqF12ijr+0eRYQZQTgaoZ1zMqBw22gsmYa8MGJxEexxUzP0MmB+X3tsk0y8mbwRLz2t2tmjZrtCtdMAugGz2O04t5NYDKCMjgM3KxYVc8a+7CcKqEddNlAprxMSWgP14NzFwnTQWmyZ8MCLlZeKLNz5c8kvsTO1jIHgoKBYKs7ErGPoXxArDiuqRN19zKpBs3krIgO+OINI5zqMDxM7j5iAxBB1DfHiY5i/A6JMJyaaDj+YaxNC6lZaeO2X2TuPxAC/1ApmqO2ZpM5yQuSilndj0gie7di18GJyMMdN7qaQk1bPwqO/S6/cIO/MlEBuRRgr1Hj7BrsuMOjkBAZXvgAN/53QWzXSS5gkwIg9oUWFIu5Ljg0eRMdEJ6/Myrw3a2XixZj38Vx3zXdjt+ve+7qXzyaSaSnT21YiyizCkiZ3hGFEmBGEo4Rz7vdif4PXOUp0DqD9gabtecRmXsOYCHafWIyaAPeSCV5AY02EcwNC9oKaAsNmqFMx9uVXAbpC24GZFeRlYTo07H1d0D1nzCz4SghdCwhDy6C2P0TqR1hvFKYJpDdQTwZd/zY4mB87WMlsM4YTZ+q0jWtif1Jog+TW3X6hu08viK51+dS6cxUKCd2F7HcuLbt/KH4H16MXgBvk/KjoE0uH0BsEMNd+cHDfS5N/xu32VT7/SWE4o91lB0BhXJlwEDPGmiTXemYCUlYZyQHZArFx/AJ09TgpxkZEGU+UtPU9LFb0vT++7fNXBMo8SA/kGWvPFhTqotmt4/3LWb+ELmmVasUW+3tt7neFtm9jxRkruiF+XTemfzE1mWJ475hF2pQN7CvsdUSYEYSjkZ4JP/yBBX3hhRY1DdALWBl25ke4HcQ68rFtqSDBY1x5XIelNA6Al7cyaUUG/HQGbIrOw1yjUrpbbhb9c2dX0gE8P/wQbpacu65jrnVRp2kFQsLgbK3Nu0SoooMbM3Or66qz0ik9n4xAfDmizNL81EvOZ2jgtoi7EhVgMkUd7/ngxJJATNFblRNourgzTbuNbg+pur9eW2tjq+Sct2fN2D0b7jl0g1QmvZhAZE/NiktD7qqBmFviupjz7Hv3Y8zzz9z7aHwkrn1PCp/9iQP22JzyrlokLRnU0bg5OeJMuC3xjEfjzQCs8Nh+74sydj+v3tO0XPbd90VXpouKWQbrDptyj2InhDhhjFzT0D1ykVWj1iFaJPs7isSNmXX3R80aQKnOMmbA/W+viDFZS3uHDLkSi7iyqxBhRhCEllSHnAkeOWRqXyLO9Do8o6xH/IHKSmFcWBzhzCp9iS7QWbSrEaidpjPpLS0zITdOw9C2KDn3NTc2A0kvOUjMiA/EBSwOB4e60c7VhbUkiNF0y51rWz/m/WsQncHOngWddr8UWUGAmcCk3gAk1pGMWW9kFy4QZ0r2R2SgR3dXql32mbaBc+2L1UT86oLkBgkNtLXJsmrjGBcTjSOijFcmugqfInFxgsDuUbFc03NFcv/StphzYUkxLq4VI7BExIgsy7kp4VylOBYVdhaJEZM7+Bu08EOvrqZEGY7e5ECYnWurFrx5oVuRLY733tDs+3xI/KduzZ5wTwWdlCvsKmJ82XJwwlKKqj03Xale2+ws6Kh1TKO7mHmUmEDICTXLFiKW4N4TrZ8l+YgAsycQYUYQjmZSM6z2d6CbOeZ+i32n6ds0Uq5LFublEs6SrYySwGkp6xruRb7oO9R2XlId9CHxzIgOroz0UM7NiUsf6M10slZNU3QaBjpfUb9/DHfM2XgUvQwKRJleBrrtnNaV13nPNeWPsqzOWCzvgUFHciDLPSPhs5Ej+Nr9cshwI7ADBK+8kbaPBhZVc7SCTBhDxv6ug9WcONElpx11mQfXhqtDTIyZcKWu0KJH1wVloOUYuleLkGmtGL1vA/vFLAlTeU767hl6lyxyPEaWtbAtGXSLWdRtM2DwnPRAO7+giMWKRAqgy1SnrGO4dEutZ1ceyLoEJvaSi9lVKxdPSjXwJihcnBwSRyUpAMVczFOWXlMyRdqLuhiFaQl7BhFmBOEowMWXGduJ5oQb2imfyHImpKjzMcKkd6EZUE4QGercE9PkyUh1BAdEGfqXM5VOXqPQdJyzPEgQDU5ZwJCowbuU9DttS3XHAsyAAc5kWzf9GVA3yJmiszY0m57quGYEJXT3N4zZUlXBsRnWNaEoY61PYnV3SAwoebYilh+OVJBRdBY03Un2y+VWcWoP8K1ovAFe5n23cW2I61SvfNaabuha0NtF2nJ737h75mLxTBiDKoodvBQMtEqeTXbwt4xBzgbHdhoDFxh9tFBQIPC5vExgWKjWwgIzHRdlJrrmMXeq1LtjKDh1uy1YDTBC0kV5ykH+AKFAEl2FyosP1N6zpjbtrAYqF58LnahVavm7258nxs09+nu4324/90I+eMkL112ElSHCjCAcpQyZ7XuiS9P0Z4UrpMWZzI77OqPpL5RXaWco0wKhtz/jvjNE2HHkRJDUTJ1Gt8RzVGShHeqgs0rzjpVrMjLci2I++SWdappXaQBFpbV5HMygF3D30l7fYiufWF0IYz2UHk/ExZ5lhSJLf5uOdXuMO9HOzWZKQvGPs/JLCcA0gC/Zp3XfibdTXKylXvwtKKCJ3C/Tbjorlbp75Np4Ln0xqwdjAdPmrbMHtMmYNzQfYkFkYd3sNLoZbyOicYPQhZ/3VF0esKzkiLZlI5/rYtYxqIpZGdJJhJFxSrjrVSLUeH0QegwzWdBusIkD7klqkHjuJ7jOYTtoXAm9Mml//6L4OiDtRqK8OW6zS4exHPJWVTOxYNg4O+Z43ehOlHFl7tfLhftmu5lFremEXY0IM4JwlFK00ow7xr40FZJLZ9N0UoPLiCvMxjDkKjQ0MM5JP/fYmJku+R6LtaCCjuPgsqPKF2eiaebMlDNWCVpNeK8jVjE9cSNmJZPrjjHgkjd8fDu7qxV613eUZdjQbBtXBBV0mGODtkjQSQ8rhND4Jbl1IsiTizXBii/htR8SZzhBhghKreWHgq6DYxmhz8UY4jDBdL3ra6+NsZhRALR1fVLKhJQYEhT75+SutYv5FamPYZBhW05KYFXTWmxFxHY6QFU2iHVQVqb8Uzzn3rNcIMhELX72+thmkXdQAdlxfErSGJrAsPdvTp4z5IkbxWRMpkTjysXKEvttFwy4Q0FGb7VWMACgGqCaN22s+0CcUVZDnhsxZm7ErLHnHDtuF1xDQRhChBlBEFpSbklmZpldTSQn3VWYvS9Acpav5GXP+sUzs+mlHYhUXI4SCxpGlGFFFq1hgxF6+5C0sgZc4aAa4O//RGbY0TINXaOB+pnjlhWNr2PFB+vCZIMghoNMcg2KTfIzrbcWNfXvDYyVgtJNUqzKiSHlYcWDErEshFlxqLc/DdhrrVcCMVkhWE47Js6E1oS6HXwoalUE80g1ql2S2x6nNGutwbsl+gPCqGhmoeIJva5UNLLuYwBUraBRddeC3NfWushsqxSgK7+QnHDJWaHkBunMNe2PwLnbtOfBiDNjJgY22aVgjWXqWQAGgcC937lJBjbR8LNu45QAfYuVHHKsV2PBfoPPUeuQGCWuz5uC7TdU3QpKulJotisnzFRzDa2Vt0KkQ2uoWQM1V85Sxo97ZXbb8MsAYHfErxF2NSLMCMLRwJAwwpjwu5/C90Q4cLId+LBzkhM/YV0iDRPodtl4s+nLfrlbBjp8vY5QcA8915WStK2LTsrKYBGasJz9cmV3llN1MBAhQnePohVbGrNCE+c/NtQxL3Y1oMvbJwY+qZnHzOuorfWHF4smv5M9ynoh5bbkpc20Se4ZNN9T99+4LaQDnPLHeX/p9oTLJ+s2ZcuoNW8FE6Ybc31yn+0gWbMWT92y2STNSCDWnkuHE4F8YScaPynHHQ+YtN0cXMVpasEl9sxtsrATYWgFrt5vvXhVwe9jz12DtSJb2rX0RBnffUc1uhXcExMvsTZu4euQQe49c8Qml4woY2P7uEC+Nv2GCGS6ux5uCfFGo5vpCdPPPp3NYBn9t13UDgjLRYQZQTgaoJ3yRFyD6AuSDAz6B8VfKKEVAZfPVLMlpenoyi5h3B6s5pGlVXIhM2xZogD3cucsH3JnmCPH9GbVw6+uM8WnbcUZu0qTG9ikrDTstWi6gVmXHrN/Sbwe6v4SS2+AHDEgdLvKdt1KlakxF7BqO7euDqRmTkd02LLq31C6A7O5bmBeg3VhyhFnstwpM0WYtlDMYI1LWwXPBxdvhR6CkeXJqS/UcicnLboKFC13L75NcLjWbcwbplzcUtl2P13T5XzJ4GtZxGJrhdsGGHKzyd03ypiAq6XWlxswWGNXLMNA+zvWAoRpc8KYUJMsKzwW4sKjTaylaqeBW1WIKUPqXbMKS5HstGNB3xX883ZtAaBmGgqt9YtqNNSsfZex98hsmnThg3WwAc+ksLcRYUYQjgK8zk2jnPk8JfYCZ33yhwYcTBDJGFN0SpLBKkNsB0Qp6K0KGkB1ZL54IQi9DqSdKQzNnrkBR6zDH+sQRGZkWRNsV57g/uQMuKr+0tr8ij1kmxk49pbkbnS/UxpJe+qO3NDsZbKz7Ll2pNOJ59/OINqOvbc60yKm7bF6E7q9jRlMJsSZ9nrwqxqlnsXBVZDC7ZxbHGeB0tiyKbZOJmEHFHZEMZAGdRuyrp8mMHDo0tTDxusasKihaSfT4tC6dTPQGrqqOlGHWA55K0ZVFZqtCtqtpKK7mXDy/IbBkDmX2OjqMblxu1Y5GCrJK2ffDY+HsZCAyjGhW07Y9veDa4+8hlyblkpLoxMmTdvdbFcmXgraf7FDbTZBvV9mnKOeKxnJlyUWbNn2WxQCERidO5KNG0PahjBdSvbE1arZECF0VyPXcBJEmBGEPc45974wtvjOchiINTHpUpsk7eyOju2UeQO9xfKn2NgP7GBQmc6PZjqZsbICfgdnqOPrhCekB5OR/Hur1pC/qKnlAE1rYPCb6Bz2rGnGiAcpSmPwMMd6wWlD9wyMqL92AF6p9uDMzkyJi9BSOsCJcsas47IZskThXHXs98ixug4uVky0SBnL2QHJUGwZ+pk+C8aiSM37afSCqQPoBfO1LkIDizfFcKLQXDuLmc5dCXFRZrtCs7+GrhSqWQO1Y2bGg6CrnnCVE6tlDR333vshcO1d+mpMY6EDnSW6Po05/+z9x5SXvgOmfh/QPEJS+RAhUjXm35wIE5H0tLU626pgl/dWMw1YC91lPg9VYOFi3JK9flcV76t4brvzNq6PshZ72qRjBZoia7YNE2c2PcbPbiC2OAXDxra3G4IIM4Kw14nFJQgYbCwXiAdD0+VWyVg5TRvpw1rKTNJJCDuQpjPUfY8MLGNpWegLL0HMQoaNg1J6voEI476TAbELRqrIfkMwLiPdAD8xu5fbCSwRZRbNK5dG+wPYSpFlQ8k+kbgeOVBBTdlgrUPnkRr4TeRCMkiJm5CXKTcoImky+3DBc3vbUmKI9Qpi0vHytUU0j0a3dDq/X2+bi58xUJ4UWrvVoVyaXL7Wwq1WaPbX2DluqxuEAl09iMXQweZ2uHfdaky2DciNyzOSMfcreswqBfUVCXw9V6pGAzsN6qYVKNS8EyVYSxUFNPtqzA8YYWYO1IfnUDvtsdEYbgvgCS7unuj0OznWXwE6EQbatw6i+yfu/aJB51fGEt73uyqw8YqQa5FGhBlB2OtQ0/eBMCqpwIi9QK4FQkPs5TRlA0073rmKvBsQR17GxS9VOqD2ZmjDDcExU1FRYaP7m1V+0zGjs1nsoJOKMoQsd5HUuS4g/E1GJMaPbvSkgYxbKwYbRHK59cITZ2KEFllDbnMFZVtodiwmIFhoexYs35wuk/b+DtbdSHDd5HNC0lVAazkzB1TTtDPmygbS5F2uvLhGoetSeN5gvtuApDQoL+Nm5Fm8EPGn2a4wO0ahPgLgh+hXUy/Yb+/UecbEy5ri2AzGBKxe6gBjQ2fxi855UgHJWm9MkObIa2tjyahGAzP04p3xB5llpbeVsT7TUE1lhB0TGHdKcYZayQBERO124d10w++6E8pdX4ITYtX6Y/8sArEY2igrngw2SvRZxA1b8BBhRhCOBmjgyEXTCQdLMTeCQCCwnzfiJQJkW1OMmWX1rEeclUrusV3eABLWExHBxNvJdBzpyjJjOx/hwJTWA3ueBdYydFWX4jpB493EKAzEmMWU4pHt8CoFXVeLB58OoROlU5iOc+50y+h0c/FkcoPoct+ZNi92PTx3HlsWWwZquYJ4J96m7YsspqZbN4B5A9QVwofWxh/qjiPijC1HCGdJo6zKqs1st/babk5ECsus5hr1jkZlXZg0ExeDXic1sHpVKqi5O5dEfbLt4AJ1bqg9X+b7abKAwyuGvseL7m9GWbMGloE7zsIsOnAk55W74pGatc+RruFbR5ZYCOZcX2Il4+p6EBsqTC/Zj2BE6JDke2W3iDJkUgo1825YsM1ZFktLexERfNPv+S5AhBlB2MOcc78Xtx8mGFAmV6ZJpG+P671EBjrZpbMBxctCZrKMl1+8k+N/ZpeY9Q6IpMGk3xuQ2O+55zc0QA77d0OuSGE8l5wi0Jktrv5MOFszNIu28CpiNkhzpaBMrBkXv2OC9IsIxb/w2qZW38p4hjlGiZ5Z1nn+Pi6WSo7ulVp1jhzfy0OpLl6LFVe4/JSCrqruUWmChAEoVNBooEjMFtbChUKTqIN9GzL4CoWnMG37vdGoDs+xbQZ0asbkGYjzK6mvU3X6E+1YznskN1hub3KCtKFRoWPJlkFjmcpSpjSQsBs4G7GxF0A/I42QZNueEC/C985gLCWzb3VkDqU1mu32wWtXL4L/LJfe99h5hZt1cJ4xQaaXWD/t7Ou+QfU2SmhZRJtN8iW85xtlpbIoy5xgEUYjwowg7FHOuf9LRgkyqZmxsRYkrCgzQXnCPEZbRHAvqGDbUNpRCxczG1MaM6V3zjlBEInZsZc//b13DHqdOW7Wv3d8rG4NnSv9OxK2k5iRZlYdIdd5aabNtk4Bxp3JL9/oTl9OHaGxK2i948SZBShZkW38c4u+BQtXR8caI8WsZMJ6EbEg7NUfpVqXpqpyrkY2/pdzZ2oaKK3Myknas3RxaRjLG1Ygiuw7KMaQc1ZNG3/LCoXR4J6rEmQmJLX62hQxaJwwrviVyjwrBKzu+q1sQLlJg7wxK9Dlppuzb6PNqnsVlG6gGt0K8Y326kEv1tWIWFL9eFlweYTurFFRZoq6sUn3f4DQQlEwLCvgtpCFCDOCsAc55/4vGR6ERiwghjpuQytcuI/cALOgsU+WP2LWu3Cnc6qXUdMG9dNgZrDIPqFQEXXPiW0f6gO5mcbC42L7D12eHNGDUlQfglmswuO7dLrPJQOxZQUPVSYYsK5ad5dBF60Ui9TfiTtirMiUECEH2yoLjWtCxQkaT4UMbBS4QUvsOQu+03TCY+gAu2mgUQF14hxMOVxJKg2YmDM0TVVVbSwaBGmyoqrf9narLem27PbiW4EnFluGQWm4lWN690bZAZ49lwmsPJgAqlydmEpYiMZSW0Tcp+eesjDMsZyZmE0RZMJrnBf/THWurxOI5aWC+6KuLWrePstqBu/kdaU8AcVt957TSBm4fd1G2yYO7Afw7/RYd2PIamYXiTK2/1W0OuZeY8h1VFgLIswIwh7jnPu92M3CJzuaKVEmNUhrtO+/DHQdzdx4ECadhZgq2NjQ8abDXRyfgIgz7Mufy3co7sKANYfX+Sq5LJrfv2c1E+7nxQLpjskmx10GEVGGS6fQNDcZFyASN2nSgZRdockIaO3gY7HnglsZizNlH8WAi0IyuPfAcpre8xWLvRAsT+2C21pBBmbb3FwHE1/Gq7KR+Cr98qi0pQ0RhXRtnhUNMuAms+Kh6wQ9v0BccW5RriCB8G3OdfA5s/UpaJPd4CrYFlJkzbSIGJOwPuDa3GULGQtZq1kC4SombA2ms8cZvNaNBmpjVUTr89SXKDUhMiJ2DkfbLpn0lPL6aF07zR1JzjdnYqP3vJg2KrdfNnB6UXFmN9Zb2m+YoM8gTIC4V4kwIwh7jpHxZLJfONzMoP3rBZhkjh3R2A6mM7WFQSSoXo44w6U1xiyZy9srX2Rw7XXCUiIKR855BcITm0xqVi3VARoS2kgHNpr/VC/zRMyVqTtm4YB+KUt0L8pAeYqtDOg5ko5Y7/lKBMd0wsc8WAra/g501iMmrezBCfqiJBuXwroszQGtNGDzy3GdckIczAC0at2XbIwYagHTZegLPiQtFms1UzLbbtMjVnyTWK4UWANS8YXWiTDPSQLqTkzMEgcAVEQt36ig+JtMBX+55jGsK5gpdV+tW/G1e1cqEwuK7K/Nc6fBuxIO9AG47SVxZbz9idC/Z0QZym4v/15kE/tBK0KEGUHYQ5xzvxenhRn7m+3chybploxOAF1Vh81jQZbhNrIQJeIMfamUxP3IJXd/7f4LtuUR7ciRDlqys8eVc2gGMmZF4wZnE6wwtCA5pvjZgy1rNYP2WukG45ZPZa7VJEwRyHPAAo/iBRmnYi/QD+KrjSgTG4yAiDORetqrT05YLtvfrn7kCyn+cWHZWhFHdYGDmdWgQusWNE3nrkXck7z0GzhBynOfwsBza9LUyj/PZbnx5cI9R1x5Nj0wZ+o8bHuRvfrRLh20jLlH7po0KGvbBiyy1oYVY+xz1mj37Lvnbo52YseIMl69qPrtU847kY8bFymirWe0zygIq2SXt3VjEWFGEPYIbgWmHErFk5SpOciLeyJRJsVCs4tDnbRMk+ahmdtUHsnAtTGrkcLOpdcBCy1nogcBWT7pTF7RY3IEKZeOTSMr26xrsoyVukpcK3Lrqr1fngXFQmX070mWmDWBa2A4eHDpjg0mmLCYcb/H4qZ4bn1+3mE9ddeHdTlEL65Nrwww2xUJJUnK0nNPQisYKWVWabLPqxVU7LE0Xs7QtUBw3xvVH+zFiFj1taLOcjrFi1qJeGJR8O7h0t5U0YaKMVSksb9FGSs4rFGoWLq4N3L1uHXhPZdNa0mjq7YdqIwoS1fqU9rsMyDKpNw1ad/AO8600W65bXstNW8x547ZNCZyPRPWRDgxdxTev0WN7AVB2BS0/wLPPmxMR9Wu6lIRl6UlizJK9zuuo4i5L0VM6l1eYwLX2utkyHaliLlT5e6LttPVBUYl/1JEBYYgndjhNM8hCkSZlVvIDMX/CQbxtp6EQlD2s+XFp4jkn4Lsny3AjP2dMLhc7EjSA9Jg39qsYGTFmND9iOvlVME/L0HdWaqEUFGmgsuXfa5NWXQoENEymvJpusR10/1zA7PM2XB3CjRPc45py7bw3JiB24QMLaNu9wmfqdi+feEtnsZQmuuAum3Rf0l24YCFnmcxFdLPQU6suHVT+c95NW9XarJLZyutoRodPMtgP8fw3I/IP7udc8/0yqYAvaXQbFfQW6oThDUj5GwKpD8KdJMRVmQSdimbVMdWiFjMCMIeJRUXYOHZQ8aChLNOmGpVjZjZ+qg4BwMriNBrUzLwHHsti1xzSl2kMOC60CtMOp2SGB2DAXvdb3b/7KQ7ljyjMnhvGCuxsZYAdilVXVfG8qLJP7cxrnCrIDM2Eofn0gSABvj1UAqoWhciZfdLxZPhLFBs7AqbB3V9CpfKtsei3Y9bbpXNm7gX9coP8hvNz+UZsZZh8um7NMG/RkPPMZ1NX1I9KXWNSj1T2c9aLxBz4fGbwlRB85fJQEDnonRU61aTa72VfO+scwaeuh9p097TiSYb1FgZCxVSzr71V+p9ap5vDbhVGbVur2PYVimgqSu/DCGcKLNmYs9uLyYO0F6Ho9TyYh1sYtyv3YYIM4JwFJBcLWUsA8JErOOd615iO+9Lmd20L+rghe06J4XWP6XXkw74R69ixH1PHKe4WXP7NceaZpcSFSOHAhGnltLMcCvJxZWLxhHITJvtoBKXpBIhbSzhIDspTFFxZsrOshEeMIcnLHAm/87Fx5v9hRNl3D7GLYlfsciIQGE96LnyAd7qTTb+DGvFU7VphcGDE7FgOKLCi4ljNGg5o3gBLM8lL3/fnLZ/KazI5faoZcLnW6tWqNZbrWuNmpuKkZms7yq0YS+4xsgk7WMJAFBN05d5R1h89NoA91l3fxSg6wrNvgq6VlBzjeqIseCZa1Qmdpez4ElZDK/RNY5z7aJkT3wdpfFMhM1DhBlB2AO4oL/sIGJJmU7Q8VokzsDU4lI3a+XPrHqUnnNgJTBovRLG5ViE3OMHduM6NbmBBr1smJnMwcFXjpVF5j0ZXLo5c/WrmDXYIvWYusu5LvTADPGogevQdYq5cJGVeRZ+7gosZ5IDdOZZze6ER1ZNslYqThtTfQsTHeaVO8jX5N42JKYNGxcn0gYtKgbWgZDEXQetoTQ938WyHMsU+XrPalTImi6/o41JV5MK299KQdetS02z3WZSHWl/0kr5AdKJCwvLlIPtMYJEytWUtP2D+RXACrTEokRXCs2+CvMDVSt6zVq3STVrUGW6LLk2cMG+YHZMJZtvOPkQNJvFk0yRFRg3kk0uXxX0WDa1nBuOCDOCsBdwgwWyaVmWJuH3VGBgZvBaEjx1kk5flrsP/ZKaUfY7juG2kmCzY1YXyko/tqoRmM5aoSizEnPmjI5HzrUrHjRweWaKCIvWUzeAnDfQqJwJP3QnimQ/IyXxZiLHrYxFO5ku/gFv5TF4OL0+oVBirGbYVY/gP0vcc2KD+SoqvNB8e+XmTyAVvyZ1Xv5zTgSkIWuvxvw3kAdf1qLdJyGnTcx5F5UKNCLoLPfcdaWgtyvM97cWM2qmO5dDy8D7bZnueF7+mXlE2+OxZUy86wHjLqXQCReqtTxqtq2lDNBsKagGzjImDDhsiT9bi4kz3DPI5k2DE5vYN57w2ovNw7fNPTY5Bs1uCWZNhdEqcV82qcwbjAgzgrDLOef+L1m4g5Q1iB3xAuPS5CwOSjq5k87SRTPJsNKgn5uBlQtW9fIfWnEqsxzLEGBKY9QslhezMdaJHrtSlzcAmK5OKt3GLXErNGGCZ3OMpUzusRjhejLk0pQz4BkQGDQVIsJt3o620zhQZm5FJpJukYhJ8uxEGuUPJjjLvUwXOjbOTJg3g+dyVQ9mszsw9SsmxIxBRJklELpGVwrzfRWa/aoVD7YUtg4q36JwpDXnaMgA1Msn5x2y7NWCIgsG2PeJu3AV0Gy31xQKqGYa1Y5GfXjeil/o99FWUs9D60Ou/Ws0YFeuqrvVBvW8H+lrVwsyAGsFVlTnVkG4sIVZzUvXpr412iz7bnbixLJ1n8MGIsKMIOxyhl6a+Uv25r+A4zPFZWUbLENkgDZJ8GJCL9Boiqlf6KkVmHIDDAdWO26/UTNYGcfEZuqGZvCCmRN2QB8pc8pCIQZbp4MOzyYFNXQ0XXwTz2R/RDqDbEIHdUQnM1xqlm7v0jV/uW1UZAnjxCjliRku7kyQP/c9uz7Z/chfRX+LuUnRYMiRMvSIBR62SfaCpMb2s/lEk1o5JasXTRW7ZhnnP1Wg/I1gQbcWXbfWMs2+CrP9FZot4MD35lAzGxkbee4qqxz0DYnJi7ThOW10QRtazbSrcGrWoD7cQM2arh2w70ibf6RcqvK/L0SqrUuglWp3U/1A7GxbzF3LDRUHWDetdVDyftZmktLurlqXOXseaqYBuxpZLO2jPN6PCDOCsAdxnTzTeacD1Ck713TgWLpyUnYneYpYKxl+4dHrEZvpCqxmdOQacGWwIsPgwDvWITP7DwVYjp4T07EdvczyQADdHAZXv6qWLKJsUkeg0W1smUol68hky+muyF2riFiZElYr7ncw+3AiR+gWAfBuS64NTVh8kQGKFXCy62pg0cMeZ8WiXnyKblZ50BotFVfHpmXTCd2Y7EAtFF4TdSzplpDLsp7LSMDmWAD7XSeQrHM2fZF8K4XGDEab7Qrz/Qrz/Qq6Ao7ctMbWwTnUkfChhf9OXuZ5m3aJjZ9m64h9hsk7epK4XADvSp76DtKW6fY/NQOqpnHuSmquoeZNV+ZYmjFX32WRdNUEdAMoIjZrr38FwFgKhWJTMssp7tUi5E6SLPvZjsWai+Dqv9ZQDdry2XfpVmud1Wy34kx9uEF1WMNb6cs+t5E8PnjJCxc8od2FCDOCsFcZCmQ7FQMvidz4GLYT7HWGk4HnCvJchjsR01mi4hdbBksVDPTCILQTwcZfUHCDvNFiTC6ZbjBJFnXT8fLiO9W9DsIIJl8m0pht5+JZbGyCwFQKF3w5AWvl4Z4n81sDABrsKkahUFGhm3GNBN21VkwxixJXjiYhsoRuTAAvqjS6nw+NqcOVM9yfnKMnwNBjM6xlnJn6tmk3GtOxHmHNZdvFwdgwqwjIycRmcz9p//PY5zm3XQjfhaPbj5SL4LJZJE/rBrFdodmqWjemLYWmBnSFNg6KFVinjtVSQqQvoatWzFSNbkUDMvOxrMDp7PLQQNS6orVS0FBzQM8YAXlgImgZ0D5TnmW3WWZcA/BWuSOuTQAwh2un+nny4vkqRJlou8cFsLYfqYgx0b2IWROHVjq9uD0mhoxqdGf1YvZt07XX3MZZI3VUmTyV6iycQkEzKM/RiAgzgrDLiTb0QUdcQUU7f1kvRyIcrCJeyJigwMnOdMxlqORFl9qXpJVlzWACvJbO6lDoAKco8HP4AiyYCZ+MnNnwJbgd2c7bpNY3SxJAvc5Y1XU8uWsWeya59iFroDDglrZR4k9MwAA6NyQSyLdHzIw+JmbklCclzlCIC5PvhtUO9KyolLKm8cSioTg0gYVMLx32fBTmB2rM91dQc93Oeu40Ztba7JNZH7IHP+EAeKJ2qY3dNO45DS1RbXqlaQwHhi8vm2OTnstCdKUwO1C3s+z7WksZKGDrkMYx3zniYqCsHW4SRZnYGvZ5JrGNJs/b5msHuSADXgDOncR8dgNsYtVrhSNXvsp//lct8BddJ90KA9q1Pe2115VqRQH7eCqz825lbNEzYsZFRSHVWR85YcvWucq4JQHATtMTbmj6AIC6FSqrmYbSDbRq3eioG5OuzLtrrlsxLbDcWlVcwk1ChJkNZT6f46tf/Sq+9rWv4aqrrsJ1112HQ4cO4dhjj8WJJ56IO9/5zjj99NNx3HHHrbuowgbRW11oIAZMLA36su69nJfgWlIyozTp8pwlv+W47JQOHuiuC8wOaAVP6Ii6idnYJSnXriBeTS+fKSg414VjeUTSnEyYiaRTNOsdqzdefAwi5EV6bPScYq6FbBkz3f1KoJYRS5uJDOOt0O9Noo4MBfp1M9GMyBGzlmmCfWJuV6HgQ+LJ+LPXlXMrGuycZlgE9WLyVPCumxN3yHXUCtB1G+tj54QaO8dWqA+3gzs117CBRblVWTihuLgeLHlgmCpPKGJ2S9o3cDF7lOpNeHDplMS1WUqsmdAic1nXdYI4I+0S2b6lzL4bG1+UCQeE63Ldou2mbi1R2lh1bTuNLftbhsVDYfvbtQ1wAq4VJtTc1Bkj0ISiDBUWbfvsWUNoOKufkpUmV4KJbaONiz6A9nwqBP0pdG0gZ+Wk0IkOKyQ58cm4yfXIsWpKWVbZOhJawlg8N1a/LN1EroJSyv3OWn+T/mh1ZO7qqiLXXFdwLk4Vmnb7PCjXUWg1sxHCzJOf/GS86U1vmiSt293udrjyyisnScty5pln4h/+4R9GH//GN74RT37ykwf3u/jii/G///f/xic+8QlcdtllOHz4cHL/uq7xsIc9DL/2a7+G//Sf/tPo8gm7l3Pu/5L2Azejy5njB9sGB00JMUKlzPkzWcqS3obkeS3TTD5MLxXcbALY4LasRQUZhCcsL+j+S3OFy3EtC2LyTEbXn+jPfE5UD5Y5AC12Pwv3z2kDCp+JWOc9+XyXuheGVjBUoCupnzZ+aMzNyOZDxRn6N2dZ7ox93MpL86azjHE/GqGkVtBV1S8vKVMvJgy5RoDt3JIyKdWKCuFqTTRdmMHaVoX5gS3snFDj8Ak15vva3+aHW8uZ6gig5s3gzG5sdb51xXQoydMTVojgR1euGhKeuBWhku5Ty2h3E8/a2mNrgAwOdfvZWkAcuHaOfdfOyI5rEGBS2L5QA9g4GwB8a4AGfsDTEOpCohEV3inOpcd7ZuMD+17dcsegs95VaNscK2pXyhsobxx0ImIGXxCnLp+AZ3VqDeYWDq4/NVP2E8PzVZ2ArOylsdnRbGycmKAcTgibtTHwonWZlLtznzX/kfqZss5sJxeVZ71zNLERwsyUHHPMMesuwmje8IY34K1vfWv2/vP5HO9///vx/ve/Hw972MPwpje9CSeffPISSyhsJIy5vWuAoQY7MqHPf5Gp+QIsZI3BDByzRZ4CQWASUi4h/MQES2kslHDG1/s8zxldgrcYKGDQNS52rYkZa3RmZyzerJq5jot2zBZwbcjCzqSFZadwlk6LDGIKxZlR5z1FXKVQSLFUgG6sNUdwSNhmhp9DK62qS4AN/El+iw2OopZeYbmVEWNq1f8tKGM03k0DRAf3bmYznJnsJ6MrhdmxNQ7+SI2dExSqHY35XGHn+Ap6C9j6oUL9Q93NwCbqJMckz8oKrCW8VfsqI8pYiyMj1gCAMvcsJUQNZxbUySnavFXchxJCIZyK8I12z5FWQGMEGitEOAsQyyYMqhvrjtgJxroC9FbnXlNZlyJnZdAdrgE3CLUD3mj/iFokmOuhoYFGGasDEHEWvlUIJ8qY8vuTVWjdgxRa8XETrrHFCl5UkKrIEs0aULrx3XAs1tomdGVcl8XVEAOTF4PWw412ceqs6AagXV5co+t/quB5jL3jGuICHr7GBt6L3D5KA9VO07kyWaxQaIXNo4w9J8yce+656y7CZGxtbeGUU07BHe5wB9z0pjfFvn37cN111+HLX/4yvvrVr3r7/u3f/i1+6qd+Ch/+8Idxy1veck0lFjaBMZ2sXBenVPqlJtsLseqOJieulL7IB16wUV/dmNtYaJ4e+81l4g/cUzMRPZe4NbCICDM0Gz/56k7LvkaRulbs1jW2nKXWLYjcg7HPTiAQlriidWbcwTGJ46mVSTKAL1OOaJDdoOzOHDy0lKkqbxtrKcMWusvXd2nTnUDlFbS7LqwrFADU7ao4s+MUjpwAbB1q437MDgBbh2rsqxX2NW3MGdYiYNXxqiwZeZZaibj3m70/RpRRcw3MmtbSAFU7kKVm/Znl6Qq2mBi+FsbGoArrh7meziUIwKETK+hqCwe+O0PVNM6yY4oYKJOuumUFFeJmozVawcBYqbYjUWsRQN6zzo0FbsA72J+yIkMDqEoZFztyIlYImjfRdOj5u2fXPBduIK9bMZLGqVknfdfm9hprIzooKzqEAh4hGRdlWZS2BVV4nv67vtc/ilpK664+2pW4wt2C9wWXRrfvcNGH3M876zjTfjbK1Vf6vl5X33PdbIQw88pXvhIXXnhh8XGf/vSn8djHPtZ9V0rhKU95yoQl4/na175WtP9JJ52UtV9d13jgAx+IRz7ykXjIQx6C+9znPjhw4EC0DK985Svx2te+FtpU9q985Su44IIL8L73va+ofMIuh84Yeyo1v/sYASV3fy7tReLGlHSeR5vGJ2LosL9nMulKDADf+c2Ik+OW8R7T4Z9gxjbqKhMjKRjFLRKSTBQTiX0Ogus6pVtA6hkuT4w/KDprSskY+HLnHS1n2IksEX642C3cuVGXHa9QzKwgaTt9a5WmNd02z4FbvjynnL16of1OJ/ptNhfnJRubF3O+MVHGyy9My3Wm26LqbeDQ8e2AspoBWzcqzI6p0GxvY991c2zfMAOwRHGmZGCzJEHIc9Mj5o5Ka+g5nKDmuY0Gx7NiZVjWHHfDTSFi3RjiziEi4iizfH2907RxJ0hSh0+sAGzhwPdmqA7P3eOzkVDBZB4RMog4Y1H0eyDepBYxaIVX80VrUCvcbiCMfh8gfMZtWY01iq4V9FbV7mdWONJYs+sPrTvWCgPKs7ZQc921eVw5x1hpLuLqnDNpligPZ3liP/txwxJl0+1/nSXtcLEXISYe9cQkV56w/SOfM4279xIbIcycdNJJ2eIF5Q/+4A+872eddRbucIc7TFWsKKeccspS0v2zP/szbG9vZ+17+9vfHq95zWtw+umn42lPe5rb/v73vx+f/OQncf/7338pZRQ2h7PPeAlAhRBOlIl0lEa5LhVSIqhwjLG+ycozZxBo9xnyo038PrzyBhmkFZhmFwsTlfLFmQhR0WFBxtSvniUIuWeTWLuM6GClVjeaeiCVVfcTcZ48V8YSeibtEzcOqWcv5ZpY4hoUwl0j7hjqGmTTnuuu01/DLZedega9jvRAuXSjetu8YLwIZyu1KytL05VB2f0jFjc9UYbMYjrMCkxbB9tAxDs3m6M6fgeznQqza7fR7G+XNIYG6sMN6piL5KJCSSom2AhrLsvgc5qoq92gWfXdzrT22gaaR07A4VhZc/ddNUPWjdntGTSw07o3KF1DNUA1b6v14ZtUUHoLB67RUDsNphhdLu0aurgzGtXcCLLBYJVbzYwLopoT/8tz9wVpN8h+njgToQ3667v7tJZ9gBc/Z43YgOMOI8KohrRfmfVtlZRYt/KrK/bbvCxRxtZFPaLvyJSr5PiUexP9Pb7s+/rr2zrYtd5bBw8exNve9jZv26/+6q+uqTTTkCvKUJ761KfiIQ95iLftXe9611RFEjYZN1MFMgOaf7gzV2XgOoElQkuulUzJqhgrJ3dmNndQEOtMhS+nWJrO93zcBbHXu3fdw1mogVnP3PvB7pd5vdhzHBmMNoktT0aZ2GvX22nxOtMTJOi/EBsfJ+rqNFwcNs1Chq6LV2+miOnj5R3OwvnPlbc9Isj04rU0TfuP2z/Ra+qeYb5s3jLtNL8K0XR1KJhw52G/V92/XlBgup8r0MCAutGoDzXYvlGjPgRAaRx3/CGccLMfAicdxqEfm+HQj2ocOaFdRlVXqn8/LAXPWpLULHgB0Tpry5cjIBpRRtd1Z2kFGCsD82+oTcgse7T9Xicu3kcgopfcD+Y6Kw1Us1bUUPPWQqsyKw3pWplrMFF9Wia6FZFaoQm8YBBYYyTf77RuRs7ba2PC4hRcKtVoqFnjLFAG6zF9vpd8T+w5un+Nbl22jDulmjfTCi+5dTrl0mfFrQGyRBlappxyLdh3HCpfL6/wn6F793VpsaKMRvvsNANBhvcou1aYecc73oHrrrvOfT/xxBPxC7/wC2ss0fp4xCMe4X2//PLL11QSYeUEL4LowDlwtUiR+n3VHcLYyhVTiDWjYphku1ukxZWuEOZvaoDAwbyQvZdcbnlImajA16XZ3YMxg4KoAJRBViei8KXtiV9TExMEOMZ0NhJuiuwzYe45516UvJc51mQpVjFYCnouUXEmti32nNjtjflnrSFcUFcFu5qRJ5jQtKvgbwnUxSgXzq3LiD6eOMO5R8Xqqju31mpo61CDA9/T2Hf1Fq7//rFomgrHHHcE1Qk7mB2rMTu2jUUDG4BzWQzMDBcNVobyCNNi21z06kjnHrL8AcVC78EJnlMd1qmEQDxomWT/2evXaCPIaNQ7Gts/1Ng6pDsXGyoCbqpAo9ETCljhJMeFtOT8BsR67l+q7DaQ7lCMGdsHWYpoFutPJYSAlTIk6NruQezaeIIv+VhgTV1E7vUi+ySDDKfSKrkvtp5ZIfPo02U2w5VpDG94wxu87+edd140Hste50d+5Ee879dff/2aSiKsnKHGLnSTGSBnSc9VE4uJs9Lyje1ghLFqBuKnDOYb7WxF9uP8mxNpaeW7v9hrPM4dKZLvGEYGnh29HHwpJYMwJs/oAKtQPIyd7+j4Sxn50Tw8WJP7RBmCmePBWFhcrBkOu09saWhlV/Sg9T5DxMmBuCslB+rB0tXOpcGcYyyujduPHs/FhUpZzdDtjHijZg22b5jjuG8D1ZEa1+t9OLjd4KY3+SGObNeY7deY7wOaLYWmrlDvNGmT9zHP3LpnTQdcVnt3RyloGwR4gWc4J+B+NmHbv4ALmJderutIQG+mPBSb51acUaBL+GpjpeNWasJi7hlLw7pmlUzmlGwn+WSnn+t6zZU9J5/IvVwYUg7PJWiR2C9LINruUfcwha7ODpSfFcKspbx7/tAKf0M0ifyCtsBzx42taJgo9yAasCtoedvQnXPMTftoYFcKM1dccQU+8pGPeNsuuOCCNZVm/Xz961/3vt/qVrdaU0mElcL5D8N/wcZiYJSw7Fg0uflvJDEBhIM12Q78pXPTmKIjEnbU7Au/0dNd85LrMmHnKm31NXFHPpLWsoXD1EobscCjjrEDMs8sOZIvQ1bA8ZyBYig0D4kzDREvgL5oYUUZuxx24y8324vJQtK12xQQrQOUWIwB52cfawesW5SNoWDrrwt+GfxuUvPSJiJP9AqH7wgb06nRqA/NUc0aqDmwc8IWjtx8Hw7un6GZ166TrStTmNRkQI61Vcn+i1A66EzQq/dKQZmNRe4jtto1fj1NCqAlcAOyRaFJlF5TY9HXnh8ReMjfahZsjzw/mzI47xEZWKcoXm1vTDmWcUxpFovGnqLphKyqPlT0OSX9QeZZY5fq5tBEoGD631aYhFKtKGPyW3QiqrWAC4uyJOGz138IRKhNfZ5XwK4UZi666CK3EhEA3Ote98Lpp5++vgKtkSNHjuDtb3+7t+2ss85aU2mEdZEc9BRYzYQDqJJltO3xS2Eo6CVHRHiwTN7pWWT20c4e5Ao9id+1IisnDHUKp+oYZZYvq8NZci1zy2/SnPKeK2aQ0P5QLka5524qS40lwwbmVeScqFk3dZUbImtWlogsrjy6t80vrxFAQ1HGxZcx5xQuj02EHE/gAXhrltxZPiuscKISjVND86vRP4Zce1q+vquESavS/YDDNE+bpjL3rVZuMKx2NLYOzrHvuhrb36twaPsA0ChsHaygGjNYMPE/lCro0Ns6smpXlCV3/N0yySk4IYOry4xIU/yunfp8h2a1E22zdefQlTJWZWhjmdh0tW4tjtAGlUYDfznkRneWOrttAJfok4QD4zZocOJ9uUnnztWHWPlCF60cd5oq0ratk1SbFTmv5FLd9BrmWMO7v8PXJLufrnz35zYg9ATXfeT9++AlL1ws313IrhNm5vM53vSmN3nbVh309zd/8zfxiU98AldeeSWuvfZaHH/88bj5zW+O0047DQ95yEPw6Ec/Gne6052WXo4jR47gKU95Cq644gq37ba3vS0e97jHLT1vYf3kiCZDkfhZNT4yu51jAbAp7k89f9+U7+uU+ZVAxIIiq5lCBjvyjFijUx2qEdcstuTjSlnG4C8UJXrBXs1uqWxj15RzSUkVJbIr+0wuaSC8lKXCU3FQQhGF/iWdSboCWjR+S8rFx+YXQsSZXrkC9yQAnaXLXHtWL7ryd6SxYZxbC/Xzp3FtAnEmiRFnvO/cedG6p7p9q1mD/dc32PeDGrPjalQzha2DCmpuy430QGET44CUUGLdl3IdKIVpCzbiXVvajlTKE2Wc2FLpdklmz7oNUA1al6ZZA60rNNudOENZt1VvERlWgeEz32OTBBlKQbmKrYJKrJM3hfDdnttuEGKWrq5ukOu3sDXd1kACCVExK/3S/uNuutcTsuuEmb/5m7/B//t//899P+aYY/BLv/RLKy3D//gf/8P7/v3vfx/f//73cfnll+Ov//qv8du//dt41KMehVe84hU49dRTJ8u3aRpcf/31uOKKK3DxxRfjta99rSfKHHPMMXjrW9961MbaOeqIzNaHHbbclZe8pDPFGW/wtMwZ/oSwxJ5f2GFcVgM/hY/+guklA/42zHKbGemxszZDPvAZHafBFScmEgwGXWcmMeEn1guV7txhcoh11jixIRUfJPOZKx7EpWIUNdq/vp67Dzl+GSJYKICViHwuKGVwvNa9gd4gVewz+VL5aXqizHzeXeO6cuXrrQ4FQJvflW66VX68umd37K5Pz12vCcqTW1ed0GLSnwPVEY2tG4GtG9vt9SGgPmxW0FnksdrUwSawmOufDfTJnR83WOEsXDmLpt2OcX3TSvWfPw1UO7p1jwPc9a8PN60FDeCsuTQqICfGxiYwYOnqB31ldlqFa98mP4cAawXMuicnRICVWHkvEw3XRgwFZHaH5Jynbv/zYmYN9dksQRlYsVREmSx2nTBz0UUXed/PPfdcnHjiiespTISmafCud70LH/rQh3DRRRfh3HPPHZXOu9/9bvz8z/981r63v/3t8Za3vAUPfOADR+Ul7GKYGd3SgdjYGSfOImfVL72F8luWK09IhmgxJvZJTJRxs1HWpSn2O5PfaIsWG6PGpm07y0MmrKHrS1DO0OphoeBzE93rXqd5goGSmyWF8i0iejvyFhwly5hn+6EnBJaN7dA6VyBjicZYrgBw4gatT3ZFEUX3sX8DwaSXJ53pduuBBjdlrqF2ZsDcmJhwljJ2U2BS7pUlHIcyg3X6vChNXJgqc+9IXIJeHuS8QpGzmmlsHdSojyg02+0y2lsH4YKz7nq4Aeoi1i85bhoInt9Ue7JJosyYWfO6e09wMS0AU2fn2g1AtWr/VjsN7GpjulZAjXabIhYEmy4sDKE1eQfkD7wnYxUCzZAb3ARpRSeYShjTP1zBvVrWSk12NSR/8jXyXHGTn1Oe+zrcWzeEXSXMfOc738Ff/dVfedtW6cZ0j3vcAw9/+MNx+umn4453vCNOPPFEHD58GFdffTU+8YlP4O1vfzsuvfRSt/8PfvADPP7xj8d73/ve3pLWU3H66afj2c9+Ns477zzs27dvKXlcffXV+M53vlN0jCzZvVzOud+Ll5p+apBXIvpshLn1SLyyL/qSmPillbucrhdvJvZ7qSkxJRLQ2P1G3S8KoOeXda6RmZtl1D3v2VjmygFWUKCD7jHuNobesxir00N1dcG6PLpN4CyHSNyUXpLOuqYraydQkHqZcgUK62Hs+loRxV5PzgJHa6imAeZzqNm8PaaqOsGHcYdyA7TQoqLSvOCUsKbwY9DAc1f0xBd3Dbhnu3Ur2TqkgaY95/qQRn2436EfZDcOoJcg7NprlrLyY61Uwe8/ZZs3uOoaEu+QqLWCbqspceHVSkHZZ0ihFUznfjDTasfWMd8NqkFlHgOzrPOqJluWgSYfFhFlRga27q3Gs2RxZtK0mHeZq5tBnch6RlLu8LFtE7YPWZbgS4gbBaBdkSuToT7kQmOA3focL8iuEmbe/OY3Y2dnx30/9dRT8dM//dNLz/eXfumX8JrXvAZ3u9vdovv8zM/8DF7wghfgrW99K57xjGe4Javn8zke//jH40tf+hJufetbT162z33uc3jNa16Dqqrwy7/8y6hKzOkz+eM//mO8+MXLFQKEQqi580QzaKUWNlkrrSzIkLvV0D6DJBr+heNyhFYypcdOOVsw9cxDSXDekCndzJIBJgfKNPKlz8Zt6lkrjLNCcwGASZwUT5yhz33h808HgEWMrYvRznJ5UoOQZal7YkWjWkHEui3Z7SSOi7vm9nMYiyZlLePKENSrsLNq8ze/67oC6ooXHklZbPwW7pxjUBEmlr5COxC2gpK3GpuNA6K6/f30gfoIABvgVwG6Qhv8t1bxMluWKPyNZlXxyALowCV8NrhBDfve9cRFPq0x5RrCWrz0Aj0PXSuNtm2raVqkKdOta5zWAExAab2loKHQuDpmLGjQ1rt2pwUsPldBwnKWWoZOav1T+jzZuggF1Gr1FjtjCd43/WDtBdeBEx2HXK0nnXhL/JgSHwfasMmt2TMsn7h++m6drF0Vu2ql8De+8Y3e96c85SlQKzDrfNrTnpYUZSjnnXcePvShD+HYY49122644YZRwsY555yDr33ta+7fV7/6VfzTP/0T/vzP/xznnXce9u/fDwD4zGc+gyc/+ck488wzcc011xTnI+wRClwbwt+GGkrXgY+lkXK9yIRbftdLPyhPThqDVP1rtnBskiboyGQc0wtSmrF/tAOqyL+CNFmWZUpKO54FHRr2nMeY0y/YiXL1j7GiGNvpaFcFMnFEGnKPQxcR7n6mrDliDK0oMXSs/UeLwT0/yzZHdq5LGO7RNOQfrUuh6GWxadbk+obXWvVXsUDTdPkB3n3UdQW9vQVsb7WuTKG1DC1f+I/LnyH5zJO0feuv4JyqIB8iEqi5xtZBoDbzZLoC5vsV5vur/nG9/DOePVq/VmHOvmaT+dL3FuvixqQ5+D4roN9nMPcm4o4UpWnbNdWQf4zwZ3+z9aWpFZpthfmBCrNjFHZOqNFsTzSEWVU9s9jzov8MkwtLmc+bcyuzFklbVSu0rvraLEJwPRd1+WGP3wSRqqQNnRC2TWHqMMCPGWg6SVbZ9m8gu0aYueSSS3DZZZe573Vd48lPfvL6CpTgvve9L1760pd62970pjfhxhtvLErn2GOPxSmnnOL+3fGOd8R973tfPOlJT8Jb3vIWfOUrX8GZZ57p9v/oRz+Kn/mZn8EPf/jDKU5D2FDOud+Ls0WQSS1abCMZijD0+wTiDNuZ9FwK/P2jFMx8hnmOFmdIvIDSa+91AlKzMiWdOG6yPDZo8kx9icXAIi/HRAe093mqDs8UL/MJOgWpjkmIs5ShgkzyAIUSMSbmhpAkZx+vLmYVpTyP0HKlRICyMWRCgasCUFWuntNVmwbhLJXoedC8uCDBVQVs1W3+NX8+LsYGFWissMOVlWxbSIi1sXJq1Vr0VLZu2nIZa5kdjfqgRnWk/a3ZUtg5VmF2QLWWDVwRFnnGl91BX7TtKSwfd33ou4++PwbdmzLu95hnMzYZE85825W4XL3LnbzQGmrWQM10G3up0W09s22hiTHjXQ+btFKYbwOHb1Zjvn+aYYwTmkqYcvCYelcuktYQoSCr0FopbbXizMJtSizPZQ++p7qWNq2xrFJk4CyyyGf7vG6CxQrbJh3FYgxl17gyveENb/C+P/zhD8etbnWrNZVmmF//9V/HhRdeiB/84AcA2qWtL774YjzykY+cLI8f//Efx//5P/8HP/uzP4t//Md/BABceumleMELXoBXvepVk+Xz67/+63jsYx9bdMzll1+ORz/60ZOVQWiJijIrCgioFbq4B70ftT/rzA44+DSXBucXHPPRDWbQlxofJ2HS7MxnU/7E5Leeye5YhiwoJnavWqpp6yLuEDnXwcLU9VGBtyMWZ71VhJj7nLRkY7YVXetVWSuMvVf0+ofXjwoxSsGN6ogo48SS3r7o4tHURJAmv9vPbUfXHDM3LlPcWFEp6LqGqnT/vtpdepYDGiBuQZ4oQ+PJhG5LZhnvMLCxd74VOb7x2z5t02+Y+68BNQO2D7bnqStgdqB1NVENMN9foTpStStPWUru79RunCX5bigx96Qw2HRqxcSx77OUy/Aiiww4IcZtJPWVlJ04H7oA03a1pmarFRBsPBrnVlUSH4VYixQfS9LY5PrTwxusu0rks6zT2Q0D76F7WegStS6GFoEoT2/hJNKsq+3fMHaFMHPjjTfi7W9/u7dtlUF/x7B//36cddZZeM973uO2ff7zn59UmAGAAwcO4LWvfS3uec97um1/+qd/igsvvBA3velNJ8njx37sx/BjP/Zjk6QljGesKFPqthTdJ+i8xw8eJ3D0fOdDV4NYuXJJNfo0xoT9voDYkV1Oxi/aUfCCGhJnrNizUremoCOwqPVWsYn32FgyVDQL0wjTmlgQZQfSjCiTql9DsZ+UXl6f22Po+pfUp1gcFu5zjLq7jjnPQbhsdf9388F7fskOXcAMuJWethQ0067xGejOUsbWA85KBuifDxWaTH4KaIWmwOUr9n7orLh013ZojWreoNpR2DqooCtg5zjVujEdaMsxv05h2xZnysHqiMHvSuIaLFiuGNxzHHuXrmIG3Janqx82iG/3PTcNAF18Ck0mI8z2NkHVWs3YODTE9c535QL//Ofel0Y7V0VtBU36214iaHO9VbGcIA3oue4CwOZYcE5RrlVe6/Dds6q8xwbuLYlrQ/ovmxRvKRR4o22WiDO7Q5j5y7/8SxdMFwBOPvnkyQWOZXDKKad430tXNsrlJ3/yJ3HXu94V//Iv/wIAOHjwID7ykY/g537u55aSn7A6zrn3hfHBQaSTzgka3mEDbfVQw+k6V9R9iQQpVWZFEr2VM/gZSHugjKm0WGIvw5IBdolFxdD+tkwTvIi6wRP6s19gBm9hGSxVhoiTsPiJuYqVMNShyF5NKhUojzJxx7BkJplaoUUFtExRxubNZ6Q7U/UhOEuz8DcrXC2pUxsVmDy/f8TbRzPIostfe6uOBNYo1CKmJ4oFbaoLmBumR9tCcpx3T4lFjn++/nW2cWnawMUKuu7SyRGWvBWnbFli7wzm2PDxcqvozDWqHY36cIP5/nbUrLeAZrv95+JSmGs0qn7E2sTC9FYRoL6UnID24feUm+3ge7pXr4aPzS2fajRYUSU3DXOfuba8rb8mEO4crUWLCUarmrZ+afuuUwpt7VSA/TRGrLHiDNBa8AxZGuw24Sb2XAUWh521lW2Hdtl5hmzaQD9z0oqu9Ke598bY9nXspNUEbIIb1aazK2LMhG5MT3ziE7G1tfma0jHHHON9P3jw4NLyuvOd7+x9l+Wq9xBh8E/An0WPzSZH3CM4YmbKsX+OeSvEqKZp/9JlYkn+XMyVmJ997zwyyroo1k+e/hv9Aon490b3AeIvyJiPdG5Ho/RaFcYV8SxJmHLG7vvgtU34htPVZpLxcmJWLpbQ93tsMNxE8M0iwnPhrCQK6F3n3HRis3AxX/2xnd7SQRzgt2u2XbR/6fPrymbTIWILFU2apvuX01Za16W66sQH2xTPtb9MNokZxJ+b8v65soVBjM35qrl2s9fFM6FEILLnkdw98rsN2lrNu/ZeK6DZgrsOTY1o7JwYbEyuiQYNmxJTAYhPKLBlDOMt0Lqf+W6naafi2ozCtAdq3kwTx8MSWBWoWUNcldqJB9W0q5Vt/7D9LWcSKLRs8+P4BNeUWpLsFnLjc5C2vD1vs02ju7b23zJEmbCuTFl3OHImxlZFtE/Tf0YXbrOmjLGzanZjmSdk49WNr3zlK/jYxz7mbdt0NyZLuELSSSedtLS8tre3ve+HDx9eWl7Cajjn3he2H0hcADfzWsN1fLOD4Q50ysd00JTWwMyMjGpA2+XamfgJXH5Rn3i3MT7bNwlk5oDOrkZfirmD0DGDVW42izN9TaQ9ZDXD7Z8iyzIl8gIduldJU1ZyvB6wKOqVMeeFntuB5UQ2k/7QbHxJx8qve3aQXvX2SRGbCS/u4IWzcCnRkJmxiw0Ah+53NpxQ3cvQnwEGwE9DhQGBuTbSG6zRBosZNAdpU6sVevo6FI/CttJZt2j/OykL91zSdJ2lELGUGbK08dxUwrRo/A8jylTOkgHO0sBrQ9VwzI7QGmSwvmZa6e0pwvo15HKb4zKxoLvuQhS56QLQGlorI1AqVDOgPjxHfbjh64uCHy+GWLepYLbCuXbqrv7pqo2X1Foz7oK6lXhPJbHuZMz2ZD5TPG+b8MxuQhkC4isZMWXdwPJPyl4/vwgbL8xcdNFF3vcHP/jBPeuQTeWTn/yk932ZwYqvuuoq7/vJJ5+8tLyEXc4UHTI3a924F4YL0hfO9Pds4v2ZK2+Aa9Nl4moshYxB5UohYkC2u84CuDzsADsmguS6BBlyBbSeEBaIMr380R80rgLWjNhS4GYUw80G1+g9n2uvkyli9yv4nT2HMeIlsRbRMZEkg56bT9X/XceCnFekXaP3ybpkmOWue3mE6Sfc1UyK/e0NupgbtgzkeJfugBtXFkzRu+cAqOxKOmgtZprt9nqoBgt1qJcVdH1MrDWP2KC00LUqG/psUQsxKyDGrOli4n4oKDPv4ZCF7gV3vUosMk3sF2/yZq5RoUE1U6h2GldGK6pAa3+59kb3b3ylzIpP5PkyAoVuAJhloqFNj2ZBd83ByZ5lEXGrZt9lU01mrIKx9YqyjgH/2DyXUdaJ3OdDlrpgxlHERgsz8/kcb37zm71tu8Va5tJLL8Wll17qbTvzzDOXkte1116LT33qU962n/iJn1hKXsLmsmpfem85V6CdRUUDjcofPFgiljCspUyMdc7yrZvMF+mgcOFGakz6RJwp8WUuqXvcy5sV6MJziHQmemLJInEtEiwqkmXHdiADrrFWNyxjV9YamCVdSYBVIN4+UFEltJShFjE29ktocRNaJ7l4GcE+tk7aQZyJZ2HdHnRdtdfCitVj6gtpS22+mp5ghiViL0m7v00m8/ihGDjuuwacS5c2rhDheDjxTCbrba4L525bFSeTZLy1HHfbgms+ef9hrPttZP92CXkA81Z86eLRkbqq2iWemy0FVK14o3Ya38Ua1hImEKbsc62J29QEkdI3ZqBatbGftBOWu2fGWc3kPkPret5Cy6CEqzNlbXFyhvJcZ7u1hHw3pq7vcjY6xsz73/9+fOtb33LfTzjhhOJlm9fBfD7Hc5/7XG/bHe94R9z1rnddSn4ve9nLsLOz477/6I/+KB7wgAcsJS9hdXzgMxf2tnkrhSTit7CzaQUd+tAVouejHnYWtYkzM2v8Dr0zf9f9ARGbcT9djwlFmYX860vhfH25mc3YCk1jCS+X6n9mRZwVdRYGXdlC3CzyyFgbNJ0CH+x4nJBwv7zso7P3I0WZbEpd8cKOcG4cg6H8skXG/raeGxAHie/i1RNqyaJUuxpLVbWDuX019Fblrr/iBB47aLOxNezA2YozKlGm3rkxbZ3WrcBt497YMtYK2Krglvl2iSi+refO3e6fQ8bzbwfK1U77T80U1BytxQx3eNIdMa9Y0ed1TLyiUtY1gLL3t4JbPSjrPg6Ud1cNokydsrFPqNsRFNDUFZrtCvP9NWbH1tg5YQs7x9WYHaihtyuv7mml2hhRNS9sqUZDzTprsI2Ga4/DZ8Tso+u2jWv2tddEG/Gqbbcy69OyY8EM/TN0YrNyVkAuVpciaZn64Qdpj+S5m9nt5Rc8NlqYCYP+PuEJT8Bxxx23UJpKKe/fhz/84eT+r371q3Ho0KHs9I8cOYKnPvWp+NCHPuRtf9GLXpQ87h3veAf++Z//OTsfy+te9zr84R/+obftGc94BuqaM1kQdh1V8LnkiY2JM5lxBqJBEwfcOUoDD/OFYMSdAcYKLUsXZ3LEmGW8WM1sYhGxcpBzCK9z6fWLrTzSfunPbLJliQUQTLljTYlzq+r/FKuHQyLOUKDOXIqPTYlTZFus8z6qzMwzUVKPoktZc22FE7AZIU+pdoC2VUFv12YmPiGOWvdNZxXCWAXE2kLaJprPzvWJpKOaprWYsduVgjaCjK6taBcMRugp2XRNWZPtZ/Cbdw+a8Lfg+mlAzTS2Dmls3wBs39gKNGOh7x0O1r2xcLC48PO1xIFpss1QrYCYFZy+4JoMXYfs6zQwyTCmbBYXoHfeCiaYd+IMADRbCvP9FWbHtqLM7JiqXb59v8L8QCvYeIG66WDdWN5QV1pF69UmazMForeuFJrtCs2+Cs22QlMT6xknKmf2Q5Yh0BS8r634Ysvfv7eccN1aNNr7vTFMcR1FlNlzbKww8+///u943/ve52274IILVl6OZz/72bj97W+P3/qt38InP/lJzGYzdr/ZbIb3vOc9uP/97483vvGN3m8PfehDcd555yXz+djHPoZ73/veOOecc/CGN7zBsxQKaZoGf//3f49HPvKR+LVf+zVo0lm6053uhN/+7d8uOENhVxETVjgxZOL4JM6sOvR3tx3FqnIDBzeooLPT4UojYfm9zMLRe/65sDMiJcfsRWynhTJ0zkynIRRkhsQF7t8gJfWW6yRSa49Fha9Yx2nk4GJon0WtuJLXNyZmhfvQvy5d1d9nYrKtj6hAbdvDUPxIrIbE590tgR1ud3l6P9h8mMGbFUtIvBk06OJaWLGEFX1IMqFoY8vA9No6tyJekEleiwwLNe4YNWtQH2mw/wcNDnyvwdYNQDXLH8zmrtQXHrNxTCSsx859dDtakO8keRDLjG6lMfJvqO2h6XgF9J/tdkUm7WKj6S2F+TEVZse0ogMA6AqYbyvM9yk02+0+nQjBiBE0z6azNFt2jLdFiYmz9Lprcr5N3Qo0eisx9FvlQD/j2emJ0EZ80dtV+8+skOfFFiLtqzaijN4yAl1wr3tlWfT8N0Uo2ZRyCMVsbIyZN7/5zZ4Icve73x33u9/91lKWb3/723jlK1+JV77yldi/fz/udre74Za3vCVuetObYmdnB1dffTU+85nP4IYbbugde5/73AfvfOc7oTJMBbXW+OAHP4gPfvCDAIBb3OIWOO2003Czm90Mxx13HG688Ub8+7//Oy699FJcf/31veNPPfVU/N3f/R0OHDiw+EkLm0WuCXpotj4iJktpAC9v8EJjNdhBhhVrhsqx4k4QuwoTjacxEFsj2zJj3S9ILvvegIgJNBycPzsoyqlfsWB9qXQNybo4JmbBxKJCGKsh9dzErGti+y5tZm/oGiwSVHGZ0E43/Z7CWpxw7knUMmbeBqCxsShYd6kwf62hNFmzxYg7dBUXL9aMUtBNkK6LW0PyKcHEzPHyIW5b7T40j/jzmrVqlok9paHaZbNnDerDClsHFWYHtNfWaKuZwQZFptcF3uecut6tGOV/Hiz/XmITY+mELiZm4AxbT0rf67EJAd2JfqoxqzTBWMzsaz/XhzWqmcZ8n4KuAF23v2tjId+fACL1k76nNvga97DNUi/mkxGpFIC6tZLpYkEFAqouE7IXhrPqYfogvtsm2V4pNHXbYCpl3UtBBDy3p3FVdR08QDdQ0F3fj/TjeoshLHJ+q6xDqcmpTavLwiAbK8yEqzFtStDfw4cP47Of/ezgfkop/MZv/AZe/vKXjxZKvv3tb+Pb3/521r6//Mu/jP/+3//7UpfkFtZAgzJhgy6pneiEs8dalOoJFr6JOxkI2HxI+bL8lcfEiokNyFLWNrl+9pwpNv28219u3kxS5jGkwxIVZexfbsYuZGiQz1l8mbroDbo4X3O7yRvwkQ72IgIDI8DR52PTBoTRZegNY8rbxWgpeA4iA6xe/rlpxiwCbR3gxI1gNtlf9rkTLNrOvYnrYgmDClvhJXA9atPtdtO1WZlo3i+zQjjYIKK2/avbNtWJOGbm3hN1AvpLxgfnQJ9R5nl11kI5ol1FVn8yKzCppr0u7epMrYUC5gouBg8hJlDm1sshV6eVP48lrpNDYn9OXmPhYpFMhBNkABdcVtlo0KlsBiZA6Opo3mpsWpvFB0wg4AqmDmpUOxr1Ee2Wb49ChJpVrIDYyz7WLkfqUtLF0rZNRpTRlXHRtIJDBTTbRsiYteKVmlvro8ZYCQXloOS0DbluUEQE8U4hfMfY9IjQZ8+1E8tNfWt8QZxl6GfSf52kLqyq3xgTZQbIcbcW1sNGCjMf//jH8aUvfcl937dvH84///y1lOUVr3gFLr74Ynzyk5/Ed7/73cH9f/RHfxSPe9zj8KxnPQunnXZadj7Pfe5zcbvb3Q4f+MAHcMkll+Daa68dPObkk0/GYx7zGDzlKU/Bve51r+y8hF1GgdWLfaG4jjyz/G4JXoeZM78fKIsz6S/JP4zREK6OwhEM0sZYHEQ7CkDc6mMD4Zbh1ZVKBjOcoiMy1LFMHxz2Uv064+5n2KkjM4P2ezt4DgYEUw1oRqYzuGLSAnAWBEsZpE7UyXTlHRBuoteMWy3Jfibbe9Yp4bFoj1UA9BwAEktxqy6+C61XNvgoSH3U3Rg1jnEB9WLlkBluZQVvGnTY5RmKoOa8OIsAeg4xSt8NgRChtLFgUK0o02zpLlaP0m3yQb0MmbKermXJ1txnY10Cf0ooTw3sIuXtXWPzDHjtUO4kQLFbqE23gWoq870VQ6sdjfpw0z6HdY2mRheDhLi2uDISVinO9ALd22e/rrxJBrY9YtDB9de1ai2FyKReKxjrdpl751apu7g6diIEXTsEoHOHqm3fSo/vBzH7hudoV4iirkltmxq0b7attdcpdu+0hjLOF7QPFL5fbH910jqwjkm9UCjeCxOLRxkbKcw86EEP8uKmTElpus973vPwvOc9DwBw1VVX4ctf/jKuuuoqfPe738XBgwdR1zVudrOb4aSTTsLpp5+OU089dVS5bne72+G5z30unvvc50JrjX/913/FV7/6VXzjG9/Addddh4MHD+LYY4/FTW5yE9ziFrfAPe95T/z4j//4qLyE3Qu7ioA3UAheLHaAO2T+n3jxh0t2Rl+CVhTyju1mvEYNDhq0wTC1bk1SG9VZ6JB9HCVWQu6Y+AxV8iWdmCnlXCdYd4qJ6YsypoNTmVsQdESSDHW4BjuLiRk+Lq2Im0k0XarfcbubWcBlDtI2xZViKec5gSDFkR3c1TvIzqaS9se6BsXE2lzXIE70CI7VQV1TUF3sAvN8ee0QV38jQgxbbm2eh2AFPoCxuiFld1urvGepn3dBJ968FzorBUDX7aC5dSNRULpNry2bVQv9NnqKQNexpZ/t4Gulz+aiVjFTkutqG8Z/GagH/vOgnPjfWraAF2VGXJfoO9OICdWROarDFbYq+71BNWswbyo0NTDfp1DNO+HCls+W1Yof7l0fExxWcS9tTBhrcTRvfFcwItjYMqkqItTCWBDpVjB1rjwq8swkLFVpkGTVGPe0Cn3rF0ZQSsHuUyk0JFahE5BgJ2aqti9jr5GxknIBoV3i5GOj4S6aLVtl2yWzk3WrniLac44b/AawzMkiYTE2UpjZVG5zm9vgNre5zdLzUUrh1FNPHS3yCHuXwU6mmSm2ges0nWUotV7h3AbYQpE8OFEoHDwxnfLWBFf5x1rzZZK2ApIm/WG6g0TMart0ysWZ0HWiOM2pMKJMO0Dy80vmz7h1aWLqzBFay2S5s3Gw1yvYxVliwc2EKvh1x3bSFh6QFXTOh6wBSjtCpQPKkhg2PZY1qxZ0UCcdIKfaA669MUKHbkxt4dqq8Fh7fPiM1yS4KeDFN2iX0Q6E8FxRJsw3LFuMUBgK0uitYhVLk6sDKVeTRgOzdkC874YG9U5rudBsK1QzBXBrJZBZ8CFyLb9irnvUgmxl4swGD8ayyT0H+lwEokz0HTPFoNWJFxrbP5yhPlI5F8Jmq8Ls2Ao7xyo024DSCtv7K9Q7ZrUzDff8WzHGCQ0kfTv4h0b/9wXp3I7Ms0BWSWq2K7MsuGonpSzueSWil+1/2OfbBBlXMGKzsZRp0EAREVlbocWIy0BgxeMm2YwATVyinDXqCMvYockaXSk0+4ww0+jWsHBm3h1bZolzItpU86b93QRs7q0sRQTC3D7XJG3FqtqA2Hs7071SXJc2ExFmBGGTqfstZ/TFEaxE0hscU+uZxAC4N5gj7kRRaxlOnGkAQEMpDTcnHemU2xcxm39gTdGLEUHPlbgycfl4cCIC3X/Eu3W0IDGQZqxTkbTCMebHulJmFQsUnxPNe/Al3ovDkpdZ2En1gqVG8uzqQJdG54uOso5RrHOzYle1vgA1XI/HLg+fjCMw1Xmn0knGlUjUtQpt7BYLsXahOEua0CWJmM2HxznxIvUMM7OybjBq4jW0y+2iq79U8AnaqTZNe26mPVM2iDD8tnpCsTO5e87AxA5mNQDdoNZtnJn5/grzYyo38OvS1E7gzS1D7u+9d0nsPTYFG+wWsBYXLosVx4dEmRFw7jzOZXveQB1soLba1Xma7QrzA+1y2VCtRQVgXeyqzo2n0f7zO2u8vkk7oWEEi0a3jyEQ76PYy8C04bHfqLirt+iKQ/D7IY1u3+O2vEYsUaGAbMRhZV2TrBheV1DarkoET6C17kJ6q3LxZtTM7+Oppn0R6artT1iLOGqh4iYBzedkbDfTJnqThkAnLulWdGmXR2/bU123S33P91dothSqmXFZO9zFyAHaa6LhXysqwKXgBN1dIVykxBlhVyLCjCDsYugsR/vyadyLtjfQtZ8jrk2pjh276oc9nuv4z3U726OMcSjZLxbI1Qkl1joj5hoQikOxme6Bc+rvnLnfCokFpAsFIE5csmbIQ53k2D5FIlMQkHfQyqiXV/vXm0UM6klKhOo6hpF8S8SXETNNiw4CuTpKLWym7Cj20mCewYUJRE9vxrkgD87KyIkqjEDLumyGv9kYBqGlTSCceFZgnIuDNv+Zgagzu6f1s2baWmaAybojUAEqKRYx20qeXTOojoomA9vbFU7a+BVK10CFNr6FsQBoV6TU/WsYpJu7OtuYZ22SAZa977tRnBnx7OXnSdpeTpSJ5Z1pjZhjddqJB8B8XwVoYOtQKxZWs7ZozXa7vdppiKjgP5v+OwdAA891ka7mMwTnXhe6gOmtVmxorVph2pCuWNYFUJnJsW5ZaFPYoD9HY6tZwVjpBk2lUB3poqMr6+ZLRKFq3p6st3qVade0ssqUjVdnrsu8a3xsG++JUeRc253gxY5xnRXSd6uOzJ24pOa6tfjZpzDfX2HnuNZFrT4CqJlCXau+VR61oC2wkglZtM1Yq1Aq7GpEmBGEXUjPPzgUMey/XicJaHsn6H5nxBnPrNWa6c+DtOjMS22meWxMGFMOTQdFnDVL4I/bmUIzwgtIh6x0edkS82l3XdD2NWNCQ6qTm3oh6/7sX4l7U1IwoeNRcy01lDHh1i6/rLRySATzYwezA4Emkx0ZO9MWWIbRfL2lT1N5cecxZC2SGJAt4q+9qLtSKT2RZ0ormRRT58HV3dA6JVW/OZcl89cGmqbPZX+1KzMIckJy47XDujKBSRNWitHy2zZhaH9qyRimYcsRWgJxgpY7p+Ei8uVoh+bVkQZVraBV3Q6mdA0101Dz/v6llK4ulorHdtQMmMLrnBJJxohNgaUCEHlfhvnRciTyHQx+y1i96gqo5kB9sIGadc+pVkCzr33orTjTBrVFvw3UcC404Xsz1tbbNsN9D0UKKvQCrUixpdDsr1phZKbbFZPmjfe+7t8rQCsTNK5R4OL6dOdlspo3qA9pVEdMH8wIOAqAptHKjeuTskHp7GYrDLmT0f17TO8jZ83sElPmHGhjav7MNKpZA3V4TtKvAdXGC5rvU2hqc/2twK6Ubz1kr4VX9nTdXka8lRxrbQCLibwbKhBPxQcveeG6i7AWRJgRhN2MEUycRUvVvuTZmYIm+JwIlOui4Lff8sqiVJumNn9jM76B/7InyATij+3k9VZJCQMAR2CtA3IGorFrOMVsKekEOeEECQHIMCo2jVlG0nXERpiYu45Pylw2Znky1qUoONYGmATgBDOOUcs60/xLyhiwicH0UpY9ntCQeiZKr2WYTuJ+UQavX66gyK1ypMm21DMQiDI2L1Whb1ESCsnM6nE23lexG5LKvGjoP9Os9U1G/sV1lxtsq3bVl1kN43agoWbGTQINW5cmeWYyhPeUq0KWYEOfkQ21mskWnJZhQePpGuRdFRNlws+FhCvz2Tgo7VLZGtWRti7a++aujQJcMHxlBCW64pD9G05EeXkzGxmrTs46uOd2PQdQERekufYsX2jwXQTp9yD7aN1+tsJERc7HtXEarZUO4NqvUNShFoJ2X1bsMOevvfMPr4dygpIifTjnkJoQUap5u8w3tGqvWQP0rAUbPTqA78rE2qlEUWHPIsKMIOwGOFNbBJYtILOjINsZU3e3nLZ9OVLTfXuoFWdqQKNqO9axmVkr9FjrmqYrS3QQFZqcUvcnex4NOZ4Odhi3ADRoOxSk/Cy5nVE7ONKBKDIo6oRpBJgeYc5APuzgDFq4uAFol5eNLROzMskmNfjJMVfniAkCPTcHDc25bOR0aEiH2aaVYnD1rBWJM4ukE6v74UB00Nx60YGT6j4vHHfCdupp+8aIIW5fdOfm2jJaBsbqbmiWM7SgiYoyrs3SnssUFx/LbudWrxuqi2F6aWs6cv703HsWNvEkhp5n117VCkeOUyZY5zZwrcLWjbOeOJMVUJzZr2d9MJKFntVIO7CuldpG5bWAlaCfNxHOF33ObZ6kbL3JGbKvWxUNaF2XjrR9COsKY8UO9yw15Hkl73jvGYu5vWa8q2LnxK0mqGYaNeZdHDgTU8VbKruunLtRTzAKJ6yQ9w5SuhWa2yOMC5Ntz2DFGRUco3vPLn0OnYBUGWnE9j3oMVZwUrqduLP9IHTtno3t0wq93TLf9cEGao7WIsrGmBm6Z4KwCxFhRhA2GTrAiJoDmx3CDhEZMERdPxojvEQ6uu3LW3WWMEzZXPrWQiYUb8xAxQvIZvcjAxtFBxdDbkpkkMEtcRuNY5NCwxdVXF4YnLxmO42MmEZjqPDm0ExnaAxtz8iJMh6cixFDtDOcYpGOfqzTZ35TGEib5kFYRkDmFKmOcfjblEF92TQj15stY3jvVtHRzRj4eaJKaHlHVyNyM7xwbYOzymPzJp/pwJIZRPVCDDd+2+WlNyieav+vPcYKy04A7s6Jq8PRNj2nvjNWRVOiK2B2nMLOcYCuga2DFeof9pvXpFvIgkwaGNsy0L5tmsVcFpyoXuLeWHUDcjXUZuS0KZF9YnXbLgVtLU6qHXQ3wk5KzIklBRVWS8pIrokn9BNr0qz3Ne1naN26W1XaWD7DtEWmmKY+uhWi5vCuseaE5cAq0Fn8xc5RE6sZDqb/E31OrDuVcW3Xc+2skjxrJHsrrHbf7t6ea60AVfnN406DrbkGDnUCFV2Naa2izKIWLyIoCQEizAjCLoHOQAPmI5nlcGar835HfnjmdbgzHMY88NJ0dsFGZGka6KpyAx4qLDmXADOr5eLSGFesUJThOmS9+AskpkRqNpWbuefTH+5kD81Oeyuy2GNAOoXuvnk75OcxhE2eHcAl7nfKzD23Yx0LmJqRbhjwlqKdWTqJJZMo25jrNzi4Dc9rQPgI3SSW5fI0SowEqQurFmUSsPUzdEMKvrsZZrsiU5BeMh0LvQY0fzM46VnLhFZcoXDEwe2jTfhUHfzOCdQDwX6jMaRsOx0cM1oEidURO6CsgGZfGxtC1+i1hV0Z88TKkvKUPl9FeRa4Ae2qAKBjYk1Z9xVr0RG6zNI0x8awicQx86xIlRFmZg2UsbLoVl0igozpIygnrKITX+k7JUOc8QSLlLsWU2bnemWf76arK3q7ciKX2mnaumzi3ThRxpSbDTAMsg+6c/P2c/nq/upO3DFWXDEiFPeucYKLe/6VE5naUvXbKO+aGAtqK0R5gYytm9cMa3839YiVJ1YnxjxnwlGFCDOCsEtpOySmQ287FeafsrFmwhmVhnEpoDPRsY6U6nohrGsRSS7XyqMXwNj9tfmn0+qJLJmD8KRbhW7/48Ju+ktHR/IyYgy3uoMr46Km3hFKgvrmDhZGW+ww8ThyYpj0BlT0nOzMrDF1tjOKnovZRJ22YhevjHzpII0VZ0rLH9T9rDgZA4MkXrhMp7nSgKrc80OfL8B30yTXJZqe+dvdG+X/rslgk8aVCctgCd2l6E8RAcXb37pjLqOtCM6tJ2LHxFQ6qBjKQrexILZubNvyrR+aAVZlBfVUm162vVe+BPSZm6SuZlqi5Tw/GyPehPFfYm12ILSz7xuuzowV+xnoEs1atXWrsv0fKx7YPpAJmKvNcs/14blbUrp1FTJBZ+a++MrGIDJiBo0NR8sUdfWlQX8VPPckhXZJbtQK8/01dA2oOVDr1lqErn5k02gz5wQgeKLMYJ8l4rbljgMRXlJYqyEbv6cJ6jXViMP+le32aereHgh8e4m9dj7CpIgwIwi7hG51AeUPEoC242EFEmrBkpFm7yWZgHMbstudMAS4DpHXGaCDGvfCteUn0fhI/ANvoMjGhFBeTIfJOri0E5KYecq6dPYcQxNqbuBFZ+GWTarTbX38w+1D4sFQHJpSNwB7jez9tTEF0Hb8+CDXROgh9SiXpHVZ7LxGkKqr4YCgv4Nm6g7jthMMinTVDkxsMFtqLUPbFZdk4tRKB6CLELUyGitehOIL/SmYxXXQ9pazluntz/xO3S1pe838HksnFuyXHYARlyXvGg5ds7Ezuk3rYrB1sMGB6xTmBxWqnTYQqxdM1Ll+jMuG5hcy5Bo1KFwGaZZa85SIM6t0fRolSg2IKtpafuS8tyJtzNAxITGBwC3PPm+XD1IAdN0JMs1Wa9kD3VpgVI1GpVv7EruqpNKNF8Mleh+tOBNYMVOrEn6CC60QVJtYLApAY8TKWqGpgwbAiDiq8beRDAevS/L3jMmAwdg7zCSMgim3E5BsYsFfkN81gp13CSUufysWZEpXshM2AxFmBGGT8UznzTbFCBxKAVsKWpueAxso1Yo75LiqavdVZKYi5m9cKz8/iw36a7ZrG9Hfm0nqyhv6M+taQbsRNPnN5KehurKHblpVew5sDB6bPueXTgYzvd9T787Ui42KQ4y1kl3akjumyzscFHTfh61g+oJCtDM2BtvZzOlgxPZh3JxS8VjaHUg9ajTCKMA9f3+bD8He59zAv70yp2AGmlr1O0GDg7ChGfihwXRo+UbytTPKoYm4H/+oP2DKEY9oHt1v3mhlWiJWMzTIrtsvk7D9UPOmZzHCWcpE3d4a5ndGdKEumaylDsmHO5b9HlkGXG+1cRuqWdO/NpyF21gajfrwHNvXA1tmIFwfaYbrbwrOeqckftIELGNQs/HBgSmc2GD7BLoNXtsGfO0LW7b9KZp4GBBlvHd4VUFXgNYKirxnlQaaSmF2TI35gVacsW42+7SGnrfWKNUROKFEb1VtmY3lDRVke3HP6OSTJuUjVkQ0Bo2uFJrtNphvU7fWfOpI0/WfahiXrHYVJTWzcWfMdWPFvcWErimtmOjxXEw4DcWeA0CuHc16GULGlOdr3fOt2xa1rlwzXBu4rsDkQhkizAjCJkM76Gbg1Wtwjd+0FQSUXSGJEooy1vrEDuZiLxJi6t+zwmEtPszvxhxfad3twswyJ8WGyMywI3MZ2BRFMUgKRRnaEeUHVubQJbzDF+oYLDgoK9kn7Ch4HeCIgNTriJJOMBt7BvmiFktmwOIhxnaEWHFGqWjbEFvNRtnnjyvygh3gvgjlCxZTdFS96zDk0hQLHh4eF1j0uc0aZiUXIiqD/B1ws+zKHBdlcveJWci4YzgR3h3sC2TtfYlbcEyB0hqaiu/0nikNBM98Fpy1XaLOcm5LWe1sROhxBMJEbKAzudvUJuJiiwCYNT0XGkt3/e0kS77QvShtvBKg2acw324njXSlUM0U9I1++bFVtW6yldH+bVMLdHHx2EwyCmKtFWvVCkgmvow2z6Ry9Um7AL9qprtYOBTOmi+S56AbWcjUQgiXP80i7B9NlX8sXlqOa15hOVJ9h6nfgUmCtmnZbdBGuWDuMUSYEYTdSODK4AayJS82I+D03JliHQE6qElZoQRpqLlurWg4YuJKE/xuhSYm2ObGvRyIKGNjKpiwduzuvRleMquYDjBME0mUJyfYXG69ifijx44fMqXlvhdZlmR0NksDAC/SgVpZnJVoAfj4SP7yqFiuSXWsvlFLhymh7dLQam52/xzIgCkpfnBYwSRWnoFlvnurqnBuSkOELlokTsWy66nSbbsfFf3HDL4L94+d41QDiiF3pY17Lw2RE/ybs0S0BljhIeE9tlYUOfnbvHLaCg1jWaL9VaEq1QbS3arQ1HDv47bgQFMrVHXVBgwO9A9dK6i5Pca3egnLO2TN5voCdWWeZZuWcgIMGt2JFE1EkDHn2nUO+mXplaGOtx29ci/bzabRfddi7f8+JT0L2Sq4J0Dv2njx6iiJsnX950507i2NvuRLGyMr3hxQfO135epzuwgRZgRhNxFarQxBOsb+SkaM+MLNJlNLELMtHXci0qFgBjY90333Qziapy9XdAMeK8okOm/ZA5lwN+4cw20LdLwHBQmuozuWZa4AQN0/JiqvuzaxgfzA+YweyCJDlFmSn3j2zFbKgo0j3GdEB2z0AFORv2EHfOSKNlGrmcQsckzsSw3cqWUhZ7HirUTnDgzKQJekJpY2fKbDdZqlQDDqXc9FVstJ0Wig0qh3GjTEpavHimMuTOLiNGCls1SWuWqadclg3G+imOeYTuyUBP7PHTQOuaCquSZuVDDPJdBsV5jvrzHf38VzaUUPQDXt73pf1Xpdzxtj3WsEk5z3AAP7nCp4z7crr/3cdG2Ymuuu3ahVK3o1MO5U5p0WXGs/7hpNz/xmo/GCtm1BGVf1HJI6szIS1rNh3eLun2eBSyzlbKwhdz5ht3XVKy+V3MNNWRUq9g5aQzyeTUKEGUHYDcQsVazVS8OM4+kgzlicuICTNC4MdwzN2m6ynTeg7SjYWR2aTkP9pemgPVjeEuisYSKDjtjS36myjiKVTEog0eRYL74HPFcu+tclG3RM+6sRjSvzFB2eIj/kgZfnqmaNQ9eZ3owVAC9wNnN8kok7MqNm18P6Hn6PnYOtg2QFE4/IgI8u9116H7V1r6yUGwgkZ8uL0iblS7lhRo5hxQlLRmew6BlLtW3orhML4/rJ5c+6QsXa8XAAbgcdIzvB0aC2s/aFVFe6G6DQCYI1xWDIrccb5YbEzfTnCCeFFMeAAdID7VIRixFss4R1aylD31tbFWbH1tg5rsJ8XxtbRmmg2tGoj2gngMy3K9RzDaXt84AuhFlskqmkbN77h8SMoQN581y658RMPOnKWNl6/avO6sg9e3XVWgYphWqnAXQrMkEpNPvqNuAxgGqnaePZhKTq0TLEwFL3qgVIBvKPbXcTCqat1AB1t0qKu8uyCp2SobJlCPYLt4vkPcS+g45iUQYQYUYQdid0NnduZgNVF2emhx3A0NWbgH6sGUSO5xpzk2ZfdOiLMJ2JaOR06GCLxsMB3HLgYd5D1jLZUIHFfuc+F+BmEW1H16wg5Mf8SJQnmXjh/kNkBOIdQyjojXrZMoMSCo034wViBNxMZRd7SfOzhWPKtEDHYeFlsqMJR0SKEiu7SFliA9WUiKcrhWZfBWigOjJvBz/ONYgXBEZZNeTGXABTJ932uFgQ7dznCmOJNHttb4yhWDLUOifEPAO6rvxBh2mjuBnhXJIrDc3Nerne8izjoSuILctihKZbHLx7yXhi8xLKUrpC41LIdV+yOCsZX+xstivsHFfh8E1bYQYVUB3R2NIK9ZF2OXc6gaQb1V5T8n5g22mbrRWxgLx7Ebz7qSjTLtdt2pjGlKsBK8q4chGxXZv+lq5gVp1q/+mttv1ttrq6rRTcCk/FAulUFnapOC8Tpe09K0o5ccVtC5ty22e1r5Kqa7PC1R+jwn5Ydq+vp3ef2LDEdpbeH+8dRPL74CUvnDbvXYQIM4KwoZz9wN9FO7YPBlxUlKHiRdNAVaaHnuwI24GAHW11ygSrhHODmAr+6k2cOShnwUCh5r328FhHIQzsqVSZOfEaUHTgs6L8iuFevCQdBdUfzC5oMhsLypleASgcJSGrQ2xX2YBC+8zM7OA/cXBusMApOy2F6UUDmqasL8zvnpUDZ0ExBQrtErXbbXtU7TRdu0HFGa6oY8QZimsnIoJH2DlMES5vHbs+sXgy4f4xgSVmEWn3J+nb1aey7pUTgFRPqIRGb4W8Kes1jWvkAp46gbQ8vZ6L46IkXWDLk1t2MMzoCmAT5wFgcwaRVPwg1ghhjBKv3HUrSswOVJgdqzDf1/60pRWamW77VCbALmDqZaW6ALyN7kRu924KBH8u73A/so93nDsHuCWydYVOYILuBBqgaxvCZ1N35a3mDRpUrevSvtqcF31P6HZJ8Fr515KUx2PIiia3ftA+w7KtSGy9qEgbVxEBiggsyTbIWjG6FR7B9zdIPeSEhcnepQP9ro2y7ktB37v2/rRbliI072ZEmBGEDeShD3pp24m1Agh94VOT8PBA+jKIuT5UGhoVlFvTtaxFZ184YQyFnCCc4fGh6X7M9Qnxl9DojuuiLwbldwYWKkum6DClpUw/7WCgSDtVkY4ZO6BmzdO7/XIH4L1BSe65m06AMxNX2oxJqSg48kIuM+bDArAucsS9rr9/MHs1wk2CnUV0/S6S1oTXqR+XKRCwOcLOoZegPxvtkbBWcTP1dLnuVPuX+i1lPUPKwMZQGnR1Q9chrgDME+VYgOgAgdazIXF0mYwcIOZY0Cx7kORiWSwjLtAmwFlI6v5vQyKVrV/VTvtFabRWMoCJyQIjgph+FBEslGdeEbQV5j1v24mYtXDU3VB1goymA3tulbeIdadWZrKOTmzNNCo0aLY665s2Xe29a5u6QjWfd02z7WOG5Li7jA3eveSYd3pLuXtm3/saRoj23N4SFmJaA7Q9Z+ogW//sdaH9niU+Wzn9pyzBeJlWiBzEzXndloibiAgzgrDhuBcxM/vaLj9pvtNlslOiQNVOz2hqXaNUvPFONdi2o1KZAHOR/HsdKUZoigXa9FZuSrgwbYqlDCWcqfEIB2GeqIa4+MAOCMa93fqxbfTw4DZBVJxh9kt97x1rg0xylh2cBUQwY2brjOuAMysoeCsylM7wkY5Nyr2H7YRkdIiGOlbJwbBxYexRMdfLuy7kZ9K5z4o7VJnrrGlgzgXEnv+fvX+Pta3J6oLh36g519r7POfp7qehu7HFD3mFCBEJBBF9CYTbiwlGAzQiCgQBwQDhEoXoh35Nt6B4aRKvEBKlSbcxAZU2ihDy9tdBjQrEKxIiGpTO9ypIA/3czjl777XmrPH9MapqjqpZNWfNudbaZ+/nWSM5Z++91pxVNWvWZYxfjfEbM9dEhMCmUE/xxA5OEZ8e+7mTcf1Z1ljUYFEK7iwAr4N3pF9PDGQd12UUQJ1AUuk5v/wpcmmBOaVB4T1nerhwDZyurqVyF9qQk7vaLi9uvh/L6y4HwOfAjmzItHHGNwOmAzaPALIu65Ibe0yA3RLMTQzWwDggo7PDXCICGgxhyWlbfciLA1FIrXM58Ncf3jAl/RVAU0yHLbp9ZrQ2WgZ1ABmO1kTye53vMzs2hIshwnNSY8znvi/trccY5w5QIcOwxox0RbZuySTXDwGhiouJCOD9JUT5NT4VDc4cUyYOxBaVMSeFMOMldeTShI8zVQ1hiKHeswA4AzNnOcudlDwpGQ0KgwZAcoZIFEaUq8BrAUvaVCjHcNHNfxxuRXk+BDtxJK3qOhqvzBrJbeJ6c9fiY8T17dF9E+93abNOEMKUvb6y3z04M5cqe5HMZHOoUZbYu67nwCMkyv/KMRaF5BWM5JPw+Ew2Kr4oJh0eQIratlW13xspvc+CcgJFVVen267XSS/FsEcE5bDWW2YcrqDWYn1PBnipzhaWa0fPoN65ubCEPxT5dVLPQg9KaZJRLbnQhoXKedFbRIWGMEm4BRGD9vb2PGdK8/kEp/h3PqTglEJ4KuG7EUDj8ce9cMmYPYN6wG4krMl08rfpGaaTEEs2AsCQ9yLzh1wkc4Dg97/Yx4KNcSf/iMICmWgIHfLlqTVJZ2bixnHBNBJOZfYMY21UXints/6eLUB7i6ajAdyZ8m4eFYLyYZB6rlFb1qzrpwhtcmGT0hGAsRDvmTQUiQGocRI+1Hs3kO2L1SDWWpnpoyWHF5OSvsMD9uoUkIzWA3UgEnmdzYXWvcrkDMyc5Sx3UUoLY87oKCj5J1MQs/W79kaprAlk7dhw0R46bmMnSrQCfU96fUHyJ9a63UsfNCmnFjjxfaBixGc5dFKpvOxoSkFQRlR5aV8eeJJSMtxqvErCqT8Qt6E0HvxJoTs9Y+vKtfnyh3pWKl6Z2H8wDxw9ygthMitSWtZKmU5pL/2ZgjKDsroGHMwZ5GL8rOEUWbN2RZ6FhTWj5C1DvUWUUQ4YASvR2FB8L2lTwzqkPRhzoQo5LNqTAU+JFb4IduEQEaCUAwQ194K/p2cHnhYAsxVjcOqdCUDvSIhbEsL6fuD1OJnUKPhHMgJe1YAMsGyPXFr0TJl+zgnI0cC2BOOADdNJNiTTEZqdgC9mZ9Hc9KB978h3jaTXvmzBGwPqWIU1OUnJd4nAxIOOkQIbRBJa5NUelTqeuiGttd0adA8MuCGYHYPYgplAlgbDtbKPqFvJQxTWxPJarcGvLFB0aGjTMcJpPIjmhcnplog5YzDM15DdL7hnxUWWvGQW615Lny+3Lmlv3ikuvFw9U+vcGg+mUnmEIX2708OCx1kSCqjDMu8NV84tyBmYOctZ7pj8vt/zndPOLDnlZ85D5pju6dnYWkSgTHRttImrNuqFvbTJ6euV3HrKVQ7/xZ4zc5vIFCiTnGov9aSY8h4pk5TOVDKnWGfun/WMKYA9S8JjomuWnHKzuHgbZ4SGzEwnkKr3N6dQ5a7Jfe+lZj7rd5oBSSNupGx6ZsT36vunxBnjk9mEjiwBnMl+R6P5GrxlLI9OvIOkxOO5chPJ8c7kXOFJvxei2KNQ19+7nywGHG8aybLkPMFo6h0DQVn2gM7JAZGceEUc4iUgewUOA8xRt35kJT21P8AwfNUaE2kY6dq1Ncf9tKIobg36C5kjfn9mIhh2IUp7metmZ2F2PeDCnPqGYDeE/bMNQED7xKK96kF7G4DliHtLhyGFAxjVEL1Eb40yVJ23jrGhff2ly5xEWPbsJTJYfXNNyLcGqpcAa7n5U9G+STkCOOPXg3AgoACZ3Dyd8xTV+tRB4XqHgjJT39V4IKlrshxrwKDicgb8SeofhSb5Iswwllz6i3DNCJTx5eUOrF7FcgZmznKWOyS/7/d8J4CxspnlUkikuLBVGLBFL4XC3/rUaOTFMzqxlZ2RGxquBwak3GUg0GFPUTnhxCNj0JxYJmOKl2wkRRAl92GpMRPfrZQsgWryvEsNn6AY6bGqnn/Om6OUoWaqHeVTLSkvGKKFcLussbxWapTbudCK0Jbh99mMaXOKn+pXcnqRJ6KU8id4RybKqrl2UtHLyNzp2UGna+rUjnoL6uzAK+G+19cCmOCtQQQ8UQKO6OZpXolwrV7zJvqSSU5+uQF408Bu28HbsPadGVmDbUOgXqWRX0H2vBjod+FM1HPESXIMXXxyDMyBoAeGVNy6MbHA+D35CfQIlPH1Ll8/g0eXfz4fBrnk8IHc+N6KIUg9XLifvk+u4csG/UUTvrMtoXvY4Oa1EiJ44bzKGgbQCTjjidEZSDwkhzpifhxZZO2GBCxyYEGzZwFVXb12I88tIVbDv0lvmdJ7XzKW/aUenAcC78pUONrIi6hU56l4ZGYk1lN5CGVCRvfIHSImelbKIzYpx3i+Wr6mdA0uAXVeb1LhrIF81yRgk/NwDQF7DSVlJXqWyXBTJn0afZ/q+PpZzhwzQc7AzFnOckfEgzJTcvDJ4ELjKBt2kZwa+d9ZgfApKV/wpEmVgLAZKMK9UN4YJLhNGWdJwDwY458hmxJX3b/kuSj5feb1zW7mufdf8LhKFZlZoADx9yPQZ3QRB6BgsSRK4Yi/g8N/eXF9eRLS6FKZU3MvQx48maUnlfTd1oAn+r1nuQuSsvw9NcZXLhRuoazxhvDjrnRf+NydotNepSdKFfXSmPUylfo6+Z3Uu5wdc6U+JgqhFwAGMs9cuGho4wCE2MYr4xhS50ZcFq7Zc33u596i/URAGbIAY2ivkMcnZZ9CSuXWhGhmgKincsK7guvrlLIE0J7bO7iV1NHEDNqXy8rNHfbzoqEhZKgX75QQZd2ShCtdkPzbEGwLkAVMN5Rleqh9aSAoHYX9eQPaAZxpFjpS9fYbWV9JhdKyIWlTI22g3nnydHY6/HMBKDN7qKQ9JiHzclgDJsAB3YYl4OZtGeCJXjCZfUk9/7Bu8vDO74HU7HdBJzc0ZAXzwIqhkNmLMd4Hwt9BH9CVEyI9JeU38t64gHh+pmq1v6+5ZS/4OyxnYOYsZ7mjstpFe06mTtkTAyxqgwJ3OLmPQMiSAOcyKkGBMv5UKIuiJ3+vOd30YMjC9T53SsJEyYak61F8In6TYmU06Q1NXxPqQJ2x6/e6NWFMGZlVlksnTShv3un9Qwx3+qXa7VNX+FqPsMyJePZ9lYbNirGxShZ6igDI909a1tx8KHigiTKOcGI2GeZVMZ6OvU5pozIHFtSAglkJxoaAGujdP7VOsVYk9X1pPyjOiFwdUljSp97gc/WQuj5bb6H9g/Gn5ot7rz7EKfYUc/f7rEi+Oc4oyRGVLwJn/N9z1xPD7K14T0KMcVhnrNnlnlVHk9rQwYq21XifLhZd70Jw5pSSTQ890z9lA5KG9Zg8upq5JtsQDPxJDtQwOxt4ZtgIwW5/Sbh5jcHN6wn71wLdJcN0wPZFwsUHGdtHQhjcXluYnRUumN4GD5Ywl42B9R4+aZvCniNpuT0YMwDCEG8etW9KeBWjubHCd6VBgdqxmetP1T9R27JlQeYiqQu5AkSekRF4d8r5XeiPXEbHkXdT9PcKUObI3jLFsgv6ey7xQABlfNgrAdyagaOMhv3AWKe/g4d7k3ICSX7KB6n3LgfK6PZ4YIySfo3CoYhkeq3p+1eYnIGZs5zlDkjJW+Zk4EwikQFdMgi1zCjjkctjsrhHqQiTbAWRkZJ42Mw/Q0njm76vKgUiMht6xugfeRhkDd3hnskTzQj4Gbdjqo01cpD3S+Ga1ZIZA4sl40ETvau02OR0zN9zK5IaVyUvpkNcp/388tlF9DzUdTtjiLrY/WO1586J5OC1MFl/QqhETdrqdD7nQJkpD6UCR02OUHjsaYQBvHZgeWi78l70SrfdNuI50DPMrg/gjOe3EMBGtcmPh0O9QSYMrjCWeqmULEnGFEPDewEcSfcdUsrXcEBl5OCxe4fd/GtBmblQ62FMI7vuRUYcp5/JOPKk5uTGOO19qmyvRxhwA/QXwM3rLfC6PbqdAdkWFx8Eto96l8XJzZ0UlNHzmGgU6jE00LcDaHYWIAPbMEwPAV86BnUE0znwxn/e2wFMPUa40tCcpDN9P6p1Pef9p/p61IYlXG+5+48h6R46AVoW1xXdFzNS9BA7Np+O7vcpT79RA5PPPNDjvWOc11iYD37vT4uyDkohVgc5Wh+P9y0NqpJh5xmjQKOes/pM0NFUHWuSBbzS5AzMnOUsrzSpIRgtXQuUDbDcpufjVj0BpfOake+GskqgTBTCROq0IGR2mn3ao0gu7eZUjHV82oLyxj61wXBms6oAkRbJnKFUrGdCkc4YoCWQZxp4ylSwwPivAZayp2MTdRxCKp0Dr6r5LzJlASgS2VZLQsbtQRlO51sme9LoeZgDX1QYt1OAjQMC1oZTHCUUI+XB8O3S3kGRJ1HyLCVvPqi5ODde3LoYfs/VowEbBf4Mp+ZiIDIswEYMOL+WKlCGN478tCVJu7u3AJzB2w3eKgGQ6jGk+8XpCRiJAfQWDCPKezI2xcmN4tAm4O4BE0cAZ6rAmlI9T7s/jswfIuPTRgZpug6HfTcFZTQ3DQBuIHOiJWAH0L4XbLozzjulhW0N+geEm00DsuT+yfpn9lYAHZXOWuYiDYaqToMd+mT4NXhn9IzmSoAYNgSzt4FLxt8Tru0cIfBKDxktI2LWHMjv9BZxTIpB2TgEWV2/sC2LvW1qx9CRANMgqQpcAgYjte+A0BtNLTDXnvS5Ms84HLZQ8rkCLB2/mIQwDdeEgwoe/g77iyubPLDTmACoD7oEwjpOnYXp3J+pTqx0sbJune+OV5ucgZmznOUOSMkImTNyZ8M7/N8VJxxVSvmUG7XfhJv4s1GoiwdlEqMncuUfGS5rFOHlqSP1PYvBmfAlxkpMSY4QvhTJEdzs0xCScSHxDamX0DEoPU/Cj+ABtOizvAJW09fRdW58HmLYRiE7HjxRCtKicrJeaPoi9Tf7ayoAhuo2iNUZQvtqZMaDaHHfFkCZYPxMebj4a0N7fJkL2+ANIk+Anrh8F9coBVoLYa530WmcEq3BJPesJBwd3Ap3BXUe1GEHAjBMZ2HZwKcW9mu1ADiIvXByj6PHKPzvK8InvfeB99Jy3gccAD8aQpvuihxIFAzE/Ve9395RiUJDDmmn9+gqrT9TPGJT7fOeOJZB+x7NDaN5ssPmpRabRxe4fL7F1Ye2sFvA7AEQsHtNI6FMN8I7ZVsjXjEWWTA3fObDMNx3ZIYQL+pZUl/DgT69DXNSnkU94xHe9zjr0rivxoT36QUZgNptEUvm+xodbFaSdX2Uurtynq5eW/wa5UHkpeXMtG1VnynQBMBw0AKEcDty+wa79TXoed7TKPcY7LIqedJ2IlhjnNcNELL9+ZA9MiBr5RmCXuGfC2VwRgFDr3ZvGeAMzJzlLHdGphS1yPhVHibVLtIziPsiKYRhBFdEvd7mQBkoUMYbPO0MKLNCDlUI5skMCxtoTfdqkCAYI+VyjpENYCoG+WAQJPUs8P2SGr+5a+ba6q6dIiadmwfZdxU8HsbXTymfupyD07YrhTw1dsP3/QrAR/VbdG8Swz4KOawCpNz7ySj2o3YeybBeC3jlwFNibRSNU6ECiIGY1MU//Vv324QXWABl3NoNWKB37yCXJrtnUN8DnYRUcGNAxkTDddQvQVGm0K4hdMsCHcHAisfAVhR5smJkSErhWoNLrx0ZwyiR0TrjXeXZtxlgMqKRsmt3hyG0aQaYPwmvi5Zc3RPP+oo++VXhEdl9q7KMICHULr6keOhkkjnr28AknDJ7uZQ6G+0jtO8F6L7a4eJmj81LW1y8sEX3TIN+K0TAIIhXQWMAZrAL+wA7gIcV4OL4Z0L7PWBgSLhaWgTOG9+WKDTKt4soGL2HjtkRr8zIU9T1m09hnILWyfo1mrd+G88AEjWZhA5KN50C7VNA0RFA1ElJ98pj8OYcEBrGzkOsv2jA5MLn9gr0BoCeYfrehc/FXmaa18VuTDxs3LgNPGA9g8iGucGNB39ciKy/Nwnz496BPC50vLQ3n+UMzJzlLHdeRqCM540ARkCIl5OHAE1sfNV186DopHw0JxVfRWEPWHJikZIfpu6u2Tq8fqTBmZk6AOTD09aQyk49W83GWAr3CMZs5ebqFcGMQlhs1xwYOWW8GaeQrjySmRwTNaGDCxS3mCBvYbm5d1gIWdShg+E1ZMcsRe+oZHwexKWRePbp8quzBXkJ4VrqM698lkiOlYQ1IMe7kL1humFjUAaxIZaAMsKRYQMoo08ahzLTSgYjmY371xghavfPYVlCiBqAG0L3wEhoRccwO5fCeiKMaPTeFxojUZsthznpwSNvMLKLsSDKG4FaTgqC1IYEJ1IOrTxwbz4xMXJ1++gWASi9LiTvwGfc8UTeZm8FFAEC8a+EEgq3DHmwsrMwV3tsSEL++gcCVHrQllt5QKYh2yQbGsaiG6+wHHPCOJBFsqYNaxCBg2Er5SWdfCS9Z1Z3oTj0BMAA3hZAmdC+CsDF/56dr0rvStsYeZ5qScZ6tKZz/HmxjAWyCDhym+Vir5kKfrnoPVbOd1bv1jaExg5AFjkPGrIM7kmFJg3tIJZwO9sQ0DaBTNvsLdorgGwPYs+9ZEAWEjbr+MyoR9hnPJgpBQ8/InAmNLzq8V5VcgZmznKWOyDv/envwOf+3vl02QCq3OlvhTR4RLa6sE6iEA/u/9Y/R2XVZiAI7RkbMzWyJvwpui+6P3OimAIyhU19klxukZGf/3zE+zNbUKZfAmiEwQvKh7BoD6i0/NSDpgacUdetBQVIGX9SXvm60mcjAkAFJDAhnhdH4AsoA6CeK0S1x5/GWoz4ZcohiM74zY3VhRKyQKw1NCpC8Wp4OUagjCp/fDKfNxKyJ8I2+Ttz3ZxE/EElEDPMJTfmGgO0jZxCTpysC6Ajc6S/NAC3aK8pcGYQCzBjegvTGSE69X1iIH3nQOM0TE+3X7JrxM+zSjw4YwHq4ApWwJWBGBOed6bSQ+W2uMlmCbwTORiU8T9zp+sHAjaLQBYPMBJQvWjkQKVCm0f9pMGPEjjTy6IXzqzcWijGZwO0RgzDMKfkHh/GZ/YCmphuWAdlfY/X+5DNLRieNN6/GLInEg9GcQ5sX7JOVu4XMem96l9SxjgN+wd1iDhmpIz871qWHl4FvSenRvjvkXzvvZX0c0y051Y8LvSB0trqpuZqdoy7MTMx36mXjGLswlN96nkACBm3HN8Y2/z2GPYAI+GwIMDCgPfWIf2Q99FbkM+sZ3yYlOwjtiXhltOhugk4E3Q4ZmTJvF/lcgZmznKWOyoR+VbmRCMSpcTLzTSkb14jMycXo2tT41RJ3qOH4ONemWhwe8yBMpmNagqIyX2eJ38db6zHCFM5lF3+NpSLqhCmWrBEX+/+kTH58Ixab52566qVQndLCpikOJEaIzUhbKM6vDHv59xKQCYCdyqun2yzN+BV+FLx2YKxHQNNvhwdQrnEgCOnyD01rozEQEnJx4PoVJ/qel1OCeg9qUFAJKfvjQFvGvk9N/ZdaBDtLaiTh+kuHOdMQ2if9GhuemBvBYDbAy06udYMfDQhbIMxhBGt5fvJgZOFsSyAEYc04hGh68xpfak9T8WT9Lbk2OSnWNg3HhCu9ShLQaVDOKQmxpPmfAkcG0SOS0mAUEZs6JJ1njZ9Zi57MMGX78dpP1wz8kAJ11nhlvFgTundLADxi54mOUm/ouFnIG9l6Rvq9X2lPUKtpUqFGpVfOwQTXS/aq72HoeP28WtRKXzq1sSPBwXKlADsk1SfgBzDXi3jzewg5LyUjBeC9CdTPKZTnYsF4GFCCEsiy2FNlsNUB9g0BLsl9BeCtjXEDuiX8WV6dnMKkd5FDWTdsDbMiyy/3qtYzsDMWc5yh2XMIZCchOifkaHhjNepU5Z0QQz3zih9x4jddZtujvB3iaeMljmyXn/NcEPOyI5BnGKZJeXQGbjhBEqdBsQnWYc9z6EyyrazRpSBS+kGf6jMgS9LQSMv7oQeGIMaq/raGwJpe5aEmhU4FqLvM3MgG1evT8iii+VHMWRQgUvV4q9PyzLDPKbMHJO2H89InvXcSN+vWiujkKUpT0T1rDWeeNnvwnjDfF8TgZtGAE4HXPOmEbAiE+7lwTwxMuXk1GfgsBunrPcEsBk4LyyDdjYYasEYAg2gDGMZSD91XWUoHvmwOgWSnbkHKuUWjMMgmisl145UTtSuOLzFhUqEQ4J8u6KPHagpeEPsUSdhR8MHQwabzLMka74AQxOAjKp/UjQoM1q2lY6g9LMipxojGOckBcj8b3Q5NMrSpCWEYWmAJpHc3hp5zfjr1DjRYZ22MUF3Mns7rEWJrCLKBQ7TZbWqk46DhSHmk0JOB3RVsqGY86j33EV6vFmACeSzL0UhXgDz9MGK96ok60KaDA0gZCNAv90aB54B/Zawf8a1x4No/pC1g/Auhb1TyhDvNkeIbT0ZtrTPc6i92tf7MzBzlrPcIZkLO4muUYtXSO1Yu0lpl36nzNSECEx+p0lKC6Sm0aaeMYSi+4+syBX7JrdJq9OfUehK2j5nOIcwGa3ckdtWuQy0ZMvXvx/QD7PeDTlAJTW4tcdEem8BlIk4NdJ7Uu+l3Ca81lOpIBEQoN5XEAV+LDqVnJPU9bjoMQBXt7rPJu1Ly9PiuQ7C+MxMrghw9PVyUJSKYGF0gpwBxHIAzcy7qJGjhKhopTXhlhkZDXosV6yji8ZFmg57BKrF18qppGRgYiKgNZIhhhA8AbLhBu70v31CLjRj8BzoNwbUGEnZu+8Hpd6HOLQGzBTNyaxnYg7AOmStzox1QjxGZ+vIgEc5r8AcMX21lObgyrDSk3jv3AYo494PgOyawd6oVtdImFFZVgG1waMqrkuHR0yGA5sBPGDWepVqV7athfGYW68PlSmdy+kWJY6TEYDsn7GTMBQP9Ijxn5Sj9+WRhyAGACwrCtRRZZbAGZ8yXLeXjQeLAHbpzGU/KD9ntUzspbXh7zkw7CTiPFRkfSbYjRHABMKh1NxASH79WGcMntrkiKUzEuZak3jT9hLaRmBQGxME25AqG8P7iw46Hc8MYSAEZpnYnrfJ+nstYLYGsA1Mr4i00zn7KpUzMHOWs9wROVhp80ZTojjnDM3Rqa0GZyYMyFGV0YbqPtT31gAsLqwpuicpp9Z7pAb8GBlFuWf1yoMCaEblp+AM3OlaZODHdS32gjklKFMrJeDkWJ4yKTijPRsOKHfy+XM8MOm495ja3DtTANYoDlxLxSlyNpRpTqyazxYhLDByC6YM8MoscecNYg4EN64Xk3v6NSQ8TAF0818vNMaWgzII73AEXI3aMp6nc9fIhclnI++hwudT4r133OkiiASUMclilL1XTlHbxxyRO7Ih2K0JinFwIbfyDORSV1PKz0OIxk4U4hQ9ZwJAFto2OTdG4MwMEFMZXlsKrT0KSPK0QvROwDGztP5slxkKYwZw4Kp/7xPtOyjrWnif+oVW3Kz7MFfG03q3GckCBTV6TOaeEF5KjqSYkj0ul4lOeZl63p3wzgLw4v6O2sp5cEY/g5X04gMvmrrdz2HtKegBiLUG/AGHfsXxkc7HIx4s+nXcun8hlIgA6gyaTl6on5HBU8vrn+mwiPQVB/wQQJZg+t7pE25zdqGwPiU2AAl1cvO82Vlsngj3THvlOG4IAaDx/9g9h90Idw0T0F0SugeA6YH2CePiJYvNy52QC9+hufc05AzMnOUsd0T+75/5Dvy+31NJAAwMho9XnEteCtE9mDwZJ8RM7VPcFDqONSUhjSTn3pl6TeAA5XjGXhm79A73hedTbcu6x6p+izxcFCFlUEx8jG7IAjRuT5VSsWRzShSBKoM65wFTIzPXFb1l9P1zhqpOV1zTpLVjR4kYnY6MNCgvWAbOLJGlysec4k2ESTJZDYAq8Iu6MmARyq0cGzWklksAn7WZX/TpLPU2W0bVPFTcM2P+CdVvkTdSxVhI+9TzKfgyWU5IQ0y/r2+uWAaos64dCFwtvDGwPJQnJ5+i/gWQxqfyJVaA3mAYELOQpxrKgzM1UgJnckBpSSaMn2i/WmAcLQIJaw4uTgGY5ACOExswhxA8M0GdyNuIE+Ng0QCiN9JLZacHPZnr7iQgMzXGtCpVASrLhfoi5/GiuHJq5/PA2TMU7All0zVqGD8Z7h7vWeyXQq1XubAYf2BgNwZsxEuE9nY1f1+QQz1c1oDPtaL4WHLoJ/lDsZ5jAMODoK4dwbNxpLf6AxSpIBwmKfAMltUeFc8fYoTDILIIYbHNjQ1tZgLsxog3lJEkH7YRYKbfEvoNcP0GwvWbLMyOsH3RwP4KobmxMDtNePTqlDMwc5az3HHJGiZ+0fQhCw3yBq9aoCPm+ynJbC7pxno0AswUlCmGenC23jmpvT51pZ0KxRjdZzDE4bp3oI38cK3acHP9dZALZya84SQy0cbQ1zUhTKVy9KndAVLVD2qcB+4Af06/YJh58GCR8XJMUMbECnbpXrIcTr2ApI/87yND112Xm0dzc2tyrJx+rHoFMyL8HbVj/AyaZDIQWCtOrKyXmAKpQ91AIBQdUsUU+lF7ienfdXmFdyT1+rbr53BrEADuGc3OgjsKZI72gUH3QNKebh51MNdOyU4BSvYKPEl0Vc/hMPaoRuwhRk3p3ix4kx97R+M9mniGpeWP2nSLoMFoLKVtz47DAUQkECwReEOynLMd9sOa55gD1giLQOOi3BUgBpgf/7WATO048+EnviwHpJFhoHfvHQyfmYrMkGVnxNcHuWdog8uq5tbfgo+V2ne9Va/WYJfBBy0EULaQbECs17wMqFa7jhSuP8gbR5e79n4vwTsIzqPFEyHDhf9wuCZIoe6wpwU0U0KYDeDek/ve842p/vXvjpUuQY4EmzoBaIwLV9SZv2w7eNuI5w3c78O//oLRPQP0Fwpsuktz8inIGZg5y1numFQrb9rFvGIn1nGxIXOQN1pceUGcoqu9R4rgS8Ab8uDN3CY3Gf6xRLyxV28RCwABAABJREFUMHVJzhvG3ZuNf66U1IBdooDnFKw1isFiQ/cYSm0qJVBG/0wBmuIJH41/Tz0WFgB1k8aFN4hzdYJnx9UcsLhEDjIQZ/pDwJkKgExJzuhPjVv9/N6YDyScM+XWyKr+sMm4WyJ6rCZu/WF+pl4yGkzsAVghNSSn+UYAjRd9Spx64PjvJkDXtF9K/SQKbz+sT624lF8/J0ff1DG2N30m3M3V2/PwfA35A+8sWeqspCDKQg+QOZJ3JppdQ48CwNyC8bConUf20onC1yrboY24sGj6P/X+PMfTU7OOOv2HdLmprOUDOiaJa009B8oqL71kjY6ADrXmRckMXNiRNWYAXVT9lB4QUGCvQXYfHR0kOoCHB0Cd3cGXYTij3e0/zsujxLFzMjnVmEhC972E8FFiIdSFA65CeG6iQxbL4VG5Xu8h7eVMGOnA3iOKXQrtASxiGAeg+XWCGyN8ZY0PwUJ0KGn2omRvXoZDhACzB5obt8/1DHS16d5emXIGZs5yljskOQVo7nQ5Aldyp7lacptKsmGHzbbCc2bq1Kq4WWrwYoFissb7pboM/wxr9STjjJWpE5ukSaV2ZjfZGWWgBpSZHEca+MgBKKmofTPrKTMH+gSQEJDdOtOW0t8jozi5vFBt0Wj11+ee9xQKX4130xLDwKr35fometbC+5SMIzTElC+QKmMtPck7seT4eXJE6dUpfjEB5Ppic2PfK7vhNJPAsC7jxEynOUBGThwLvED+OiTvYQLsEHAIANzz9AjKtSjTBLttYEiNB+81Y70u7tbthqR6AzCMmsuFl50byxW8I6WyFhthuXoO5YCYuvdp8s6cguNi4Z6oT+Z9lhdNJj35/mr0gRT81fdOhZjcNck8a+2hzJT38vjiie/TvSHKhKbrc+OAWXHCUKwvcXKt/srvNZHLTyHhhAJlApltZwd8L4BBQ5kBnDk2Ce8xQpMWShRGHT4UzyZSepPnTKvVdbNZuuAPFN367sPv0/2SdL8TTG+D10x4X1bCXCX8FS58CYGPBgyYzgE4O0ZzQ7h4QcKcwMDmigPfjdm/usOZzsDMWc5yx6S0senvw+/6VFjzcpQ2Y6W8jIyWZIEn0JhzA4PyELvOzhjiGXfy0feTLuCVm2MA5ldspis9SEacM+qzNMtSKQPTrKxQtJliJUb/rOagmej36HlSUGauXMSnayFkpKaM5LtlJ7rTZTKp9xnmhfux1qhY6l7t76m5Ph0TWXAJw7wgKHJgZ9zs6wCUFNgr9bs+Nb9zGRZUmmygbl2ZvTYXdue9Nmrb5Y0UIsCdNkZiOV6b5sDTCS4SAWkI7XWPyw8SuAVAQPdMg/YKMDf9MB78+s8AWTUGvALfSrgKgCEFd+qKPjWWDwEQZlz2R/Xoe+6ioV6SNSDtqWXK48moud/ZwcCsAaK1zD2LAxonyz3y2DqKZA670r/XhYXnPlMfzhyU+WtGe6TTAzQ4Qx2isCZg5iCOeQBSMoeAgNpLvJdN0E8x9sQxw36twZnJduTErz81QOstADRFUMaHelmKgKsSSe4oHD93GSd/MMBk4jA2/74dma/peOD68QcPXkx6IOQPjREANuqHn3DExLYV7hkA2D9sQP0Wm5ksbq90OQMzZznLHZOskZkqsCmYosgY2WVa8feNsjIpwtoiAezI+C2cHHP4r1qOGfYxEu35MtcsZbBWATJawZzY9HIgViii1I81m3+ioGvQpRRakjecC+WnfVAy+goZG8YV+XeRAbzUyRw80Bc0vEHpmm1zRqY4JObuWz0m50AZ/3vkZjzTrkrjIA1HTOdX6FtK73Ngrq7miCfth8oSguBl5VbMx9SgmfMeM4jGOBOBWgOO3ksCZKdiABgDu20QstnwAkOj1gvFMggWzZWFuelhtw26hw36CyMnmp5cM7oeIWyEAQlncvwBdmPcKSc5Akgb7zHA9Pq2xihfDFKrE/U7Mr7vrSidojg2/R7lPLVqw5pr6vblBHLvOY+tuySlfaIGvFISHY4dQY2K9qLcO1LgjP9b1CwOQD9ssmZnvLdDWJPWX50+JYkn4NIsk3jJZNbArLeU6gf2YAAqx1vtmnDq8RXxeiH/XhNvotUyAt/kRyAWDn8rcMYCZieKWwrKSNasoe2mc+/NAqzCd+VvBBLg7oGEOgUvG0O4ee0W/+69/+8DHu7+yxmYOctZ7oPkNoUUlNGgyqy3g7tfXzelZJmxl4xWjvzfUxIW+VrlPLp3IqTAV6tOXE4SghIak/k7gCTjfsqBMyNZaLCU+CYW8ZPkQLi5flMeB0VDU4+pgvvsqCmZMBsAw8mYzZzkpXUl9y8Fc/JfDL8Wx/cCMO0kyl06j70kp9fMQMqZkj1xKyiqq8l6Vzzz6rqmeDZSQFGDghPzdWjTRKPSLGIhI9sEGJOuU0Y8ZSQDCaG56eV7PfZnQaJKMM+7oAOiSG8NmHjI4OSuCRk6dDiUN7QdoaNtndcNHLBjKYy1g0g0c8+yYiwFjjQzrEmTWXxq5bZ4SO6ieJUBNAbhgNgTYSL8bLV3CJL5eGrej7nylxj3hxxIKQBncv/N/Z5KzvhPDX5S16Ue1V7n0X+n3jVTwgp06RncGAmxrPGOZlUzUQAGJMRnaO+94J8J3j8l0E55UybPUvLAjrme6oQY4EwSgbD3dFw48VKgDJxHzJ5BPYH74aDIvyPbGvQXhOvnCNcfKmCc2SMQAR8DaLzvcgZmznKWOyxpKEq0LiY8HzXr2WiTyhkLC+6vYsTPbFZTWZ5Gbcwod8X7j7kJZz2E5sufDI9YqJhN8+XUfbZIptJU5/o7DZtThmPk8eJPyVLlQp2kSjgTh+tTvpClUgvOaLBwGEeqiTOnwlWS8Xaa8mpafLJPFHvL6DpLEoz++XpqiGfH99S3/ygZmkrPO2mclIC9YVyulhoDIxPGoOudrD9931OSAFY+BMDf39z0oJ4dWSPBsAGxjbN9aaCvFzchIoYxQgxpelGquR0AKfZZNrwBNjWm0/d3TOCDELKNkHWZTaYAhRq5Lf6Juwj8lPZb3R+VfbM6vNfL0+6fpbw+uXFTuC2baYnUSVC4sLIPcpel3icY3gMPCFxRyObX0JpU61HmPL+msI08BqWMirFk4/q8zjF1bxhvt+lJl5LzmhRY4ujQLIAyC2WOH20kXDj80mX6dX3unToA32cABAnw4pmCvHcMWYA3gN0CtmX5eXEH17tbljMwc5az3AMZuYiuUGBGLr+pcnVEQCEnNUZErWKWAkLkT6h1HRn9Zdyo5Prwe2ow+UtShSpfwTHcq6dJRysKWGLYlMZUaWx44KZy48/Fl6dSBGegxn/OIHCK5RRQVUMIPAr5WzHHak6AZ0EIHyrQkDOAC1LyIqqUWfLhiXFTM/7qiSzny1otNe+QfahOAYwpjPFZpTcFfWauFyCRYfbunStyxaiMDPBZlAlPvDClmEE3PWhvYS8a2ManOCX4+KWRxx8DYIumtzB7EwG5tjHCGUAEs7cwOyvj2C8ljPF7IZJTc9/ckoF/iPFEFLh7/IlylL5ZG9i1dT1tUOBpyYzn1hpPmFoPmGie3iIXzKwcAvJBgSE67DFtQur9BTWfSlVNPQYj9oZhjOZ6aZ2LwZuZ5wxAc1K3/9U/bi9EVhQ+LzQ++Vh7fnogg8ExhuU/bx3/V8+DNyDz8daZkqSAjGuP3RjYrQ8Hdet/pJcOoI3czGotPWI706JyXc9JVkd9eTR/IWFuRn6GNNvuGRsDbB7LGtI9ALgFmhsCHgvnzKtdzsDMWc5yn2TJQsx+150BCrQXwxRIk1M8lopJ2uObMBtCk/k+UXxGXBpL96yhu4aPJpWaQZnJiTaqSpvZlGQ9h4rXuqbkDJs5CWOjoIjlwtfSUKUSsOPeUTF2fUYmyXoLrtVeSu9u9HmOh6m2ramypX5OeTqNnsuPZd8Wr1DWcNc4I6nWW4YbCu7jkXFzqtN/PU9Hc/aAstLPtdSAVskYonQN9NdkZNFJZEkS41bSorq01tAGFy8HZGqq18az45EhK5k1hAfAgBoCddaRQcZ7iGHnedPZYdwaAhq4rFIAWwFDyLrUxkaesR7QTeZSDjSpHbfsSCe9cUEEZgG/KPUQvAXAZVHY6T2Sg+dGqe/TtfGUsmQtLLW3miOspEAg3l/T+Z/ZAyeldGnByF/9HtN92R2aZDPkAdk9dBZMSuvjQTch4zL9SKqh6AYmAY7ZAGQIZtfnqzrUWy/3TCUh0Q+ZIHwsxn1o3bO5MCHyhMicGTNLdPOMfpx99zmgpuRFbkt6ir/V7RmdfEhWwt2aPWG/I/QXBLNjtFdw7+7VLWdg5ixnuUPy3p/+Dvy+3/OdeYUtA2YUU+JZiOeB5fhUELExFDbMdJP3JxwFT4RQXsn9/FhS4LqYBCAyAIvct9C1MyOhvyZAmaOf5M2EiE0aoDYdM+6XdGNXp3VV2ZHW9KOu03s4WYCs371pfG0mXGMyvTUWGjsmOZ1c8tqS95Fm78mCPQ5YmCIano0PT0GZcN+RDb017t0Jr82oPFXuHG/K6mfJcpMg36bcujfjQRiF8eWkdm7k3P9n+nvp2J6sPpqPFE7qbUsBWIEF2mtIeIEdj+EACHuvRQZMb8E7KZM6duuuGEIMAm+GU2v93NTZmNcmw2tW+2zpczLI9S2HU/N+YxyhZS/AU8477UQhDif1EjuVjMJvjvgQNBiDlC7COszUG4fHrDsVVd/R+Ulmxm20F2W87eKsN5VEsAUDfDpMeh4gifaosCfnLiyD5GmoFm8M+o1wbVHPwlkVwiHVc2bqCyEzlKzRHM838fjLPPuxeIQKnjGj9+RAI+oYhiy49dw8qm0amHb/FrdbCyW/lzDBSU+pzD6U28PTgwcXmtZ4YL9jmL0BWYP+RjxpNlf2OIce91zOwMxZznLHJA6vKChxGRLWaDMK37sTypn6Rtw1JaNjSibIao8lcTszwJCX1P4KrrTj9kzHIPtrynVMcsCEd7Jis5k6iVtCOFsraXiSVg5S4EbLlPLq2zB1zYyinSoCU+FJi7JQZTxlhnLWKeXT4WcqM0xJZsgyAYy9kDwImwFpsyS2njck/WpuXClFqzgvSvcv4H+ZBB+qT6ExgCw2maOpEjkz/vLAQKniIwKZh9w7tQaUTnNd+BK79KW2EQ4A04vxQHDdxJAwO2YZQtoDyjKwt2h6jvvVAazcEOzWoL8wkoHFGS5mz2iuejTXPajjqO3+YKGKK2LqezVmmQy4NVLHXjZAbkzsFbSUO2SBHNtTpobPY0lZZW9DvzdM3b+yr4I3jOrvdN24j0bbUq6dnNELjJ59lg+kZk7k6g8XTN1MyvMiAUxG7VfllZpEABtCf9Fg/7ABN0Bzw8BVj8bvcZxpM1SfZTx7xTsUAir7PXNvQck+NtznyvVFpWulCoUEULcukA8LRcSbE762Er7E6aQLdeTbGmRRyDqy77UaDHF7Z9Y7OfU0LQE7Vt6ncVxCZisemsTnMCYvZ2DmLGe5DzJpuCp0W2UFWaLE1HCALJY17uYz4kGkoDwmCtwar5hchqEUrBpz/MwoPmufd2pz1d9NecvMbdBF12kafpauMcn3WmmsVRw1wbAB2CbMPeH7oezUWKgNWxouSJTbFJQh9TMHWHhJSYKxbsyNJOvlMQOUaKkEmDRgkfXsWgDOHEVGYNKB5ZXGvg4JKrVjxlNmMVi9pp+O0beZ9xfNn9w71sCnIfQbMSZMx6Is+1Ta6vQ6uLsnxgpZDp4/4RTbuOtIlO/ugXEEkPJ3s5N7TM8unCte67hRnR/mKoW1eARCzoTnUc8h9Ss3BG4amcd9IbTpLsgEQHQsoGeUJlfXHS7CJDATpCJEMl07mQA0BgQb+D/Ctc4jawBwcHzQLOJuSdb9E4a3lTNOxoBy2CmjzysqmAgPC/X7Pp0bS96L1YMbPuRGt4fU71PtdICM92KzrbSDNJBSoFmL+oyHCny4j8TKOFCEPCDgoRw/0FVT/N4IRJ7iOcCs6N0F5MesV5eieUQhTGnU5yplNYebx6BOJMk8K5Fqj7xxS+87rcu/14zX6aS3bgKsC8AlfcGNhDHtH0gZ1JOQyL/K5QzMnOUsd02mEPCC0RwpOHNhKLn6fF1Eg0E8Z6jUypHDm0bgDDAKoTiqG/LchriAo2OyXQsVv9kUuiVl0o+h1DOmdF0qNdfnvBJy97rxxqUY5cwYXALKRNd6hVJzFUQFTZcze4o8I1XjsUR6qiXl7AmKz0zZXnn1oGKlR9aI62Sm7bX9kYKfBxmXk/xLsXEzu55FhuLKRh24Zk6BkDUnpKHdzWCGTI4/NzbCia5TtsmKAm03BjCOmLJzxthwo/stBmi0+FNrb/yZjmEdD4RwcUmbfbpuDbqMykuNR1dmtLbOhXH1FsaNBW4J/VYmUXNjkc1GlZZ5IjDgrpAJz4UKL17LUpnYM/0aTfo6Vbcfc5EH4h3pt6xMgN2TXiphL43uyHw2lmqPjrRtGvRM2xFVQMO+wwAZiturbknDp3Q9fr57I52NcI2YvUWzs6C9jfc6XY5aB4NHnNsbPcAHxsjKHbWH3NrVQDiovKRhzrl+yXCmaY9e9kCQArMC/5ZxYaNeb7VD6FbYb/V2VTvvZiQNuY6/jAZg9Kvv49GBVkUYk76eSTwyu4cNds8aXL+eYC8AswfMjYTOvtrlDMyc5Sx3UVKPiNTIVcasDtMZXDsXpFIFZBMqEGYWjdJTkYWmdUwaXQk44+45NiizBEzRBkJ6anESUMb/XArOpL/7MlKX1LTN+gRLnyyPDKgM+KPCSnQGpqwkIXVLOFRG4zg1tjP6R1aBDH/X1Vtuz8z7TUCNWW8sp7xRz+EESpdTboh7nzUKe04SoGwRr012rlTeu0BGYZnRl8lYz32HjNK6xIOiApQp8iZFdboxoY0NZSxk0z2HAp3R05qgDAcelwC0CUARvFNcuc21kGeSRQBNAGdINAQiCvdQCDMY9o7s0GUOJ+vttYRH2cYZY84g8um6ezKgFoPnTceD8eUMySgTjLYfCqfEcV+7Z7c+3KEJ+6U3kkLoQdFzMHmBhwADtZ5xJwYfpnhApkKB9b472/8ZDz1yXgMRqS0BguAV9q9TdUUKGC3xWjyGMLJ7k/67mqS3MF4mw96CV4O6NqcDMEuIjfOE4xBq5BqZ2VP93z55gOd5so5TxovZW7TXPchncwPi8F0AaABrDFiFvpBlIbTvWda13oJhgB5hfpOhyIPFPzMbeWg2HDxrZsUvQTrcaeq+ZjgQCqCM9xICYDqH9YQ1elirIpk5CFxyUBS8HgP4k+yLGhVK3ulsPVnARurqnmnw0v+rwfWbGN1DC7MjbJ8ntAzhJ3uVyxmYOctZ7qikG2h6+i/kvu5vvwgW+Ca0+JPqKQLSWePiNpWVzAmx7pPRqbtSpmoM3dEG412GU1AmtyEmimOJ+LUoyUY+xxUwBTjMlV0lKZjifx+BJG5zBuVPSwDAmPzn7jSI/Hgln9EFRbflXGxzdR/p651bcwoYpdwSIzf2A+ToBJLZSqjMHRKugQNzrGtXvqgi8fgC7qlsWAkWAjmHSs47K/f9oR6BuvwVZdUQwUZu9UpXTu/Xxi23jsvFncpSz2huKHAMCbmmlaxKbn4ZZrQQj5ZAyEpD2dwaWLd/eGDQ9O6lBpBm+F4fEIirOoP6Huamh+de0CfI3Ei7xb5z5RMLQa8ygrIE2SMboLD2p+GvPqyJPFgDFzKiUmp7Y+02970pWcsjNiElPrsq74uaUKcpD73Ey9d7F2Q9YgpG/1ElEzb8tGTpc85dP7f+ZjkOE2/YKNTHhwoxJBSwIiSeCbCtQX/ZoL9wHCMWEtLYM2hvYdS6hE682EKigE0Dvmyxf9iie+DWEAaaPcPsGM3OwuzswKcGeQY3ozEMomENYjggGnZwkEnBixwopvvTj1k7EPyz+ue9icQ7BrBEw9DvIfxa/tCl5gAlI0vGS/R8w1OpXznsa/KOFCgTnolHerhc4+6Hen7AeUZ54N8/N9Ds4Dw0Fz/yK07OwMxZznLXJCx+E9d4Jdj/7g1MYKywZk6dJsuuCFeokmMrsRUuy9rwi2PXYyW9yBESis+cVJSexxTKmpLaDTf3zMqgjDKjpHZK5vMimbQ2vDnZmIGRQT6fAjL/fcguYAGAMSIcduBMth9LXkFR+cn1UdnqRLdSecllVkrD0ZaEu1RlwvBSMgRTILDy3eiTwCkwYPRdraKXgloF0LE2fOlYhKZMisNoDqxZKsnp4hQxtbRFXT5zTeQZk9aZeyfeYPJ/uhCk/kJcx8mFElEvvC7eZb5hDuAM7Xs0nYW56oDWn2a7E+2GYBt3r5WGknGGjJV9h0iIghHWWQFz2IiXjbnpYfb9ECpkABjjPGeMEANvzcA7YcgdNEAMGncaXiYRVfPb3TOac8mcot6i8YCMx5haAiwNdc3tPYeG09yG8V/RxqOBph7U43pDkRgDn0YqE2Gdd14WcOwAKI/tCllESguMvJxyktUZgieHM7a9h5nim8kSaesiGkJ/SegupQ2mE5A3cMQk9dG+B+2dW0m/AZ7dYvcagycfZtBfuufvAbMDNo8ZFy9abB4LQGM8N5alSI8Q8ATDeAVA1utVyXNwZm91AKLuJ3ZAViAgNhS4ZIwdwiSJXOYpz9HVjzPTTe6B3nswPXxMQ53JAU8V3oT+OaPn88+GuF98Zj1iBK9Gfw8n7zuEwwKgzqJ9YvHwVwmbx4R+SzCdkD33F0D3zB0Bv5+inIGZs5zljsl7f/o78Lm/9zvLF+gNQ4EyQSwAik81sjIFnEyckBxTcmE/VaS6Crxaknq0nAIwAWxYfa6VnAp37SpwpqAkj/p4LgwpvSdTbi6r0QjA8CFGveqDuZOLEsH0sTwQcpKcwhdPjhNwKSgKumm5cZMabZl3mXPPBpYBNDkpciPlFFsNmKn+mGxrCZSp8RwpeTJBja9JA2Smrkys/uh7oMrgiMa3A/pCv5ZAjVF7M4Tqo4vyoMxRRI1XRjImglFUaI/lIbTNlWEbOG2vAZhhN2JI2S1h83KD9skedNOHPYWYwR1ADYE3YkQFxTrNkOL5JQptsq1kYiIPuPYWIQTKAnJCbQDbS1czhuxQjYBK/VZUVbO3aG5IuG5ydVaAnjEZti/DBUcRubTeQ/uDMTJ30ODH8G1wnqwp/xbuCZ5MxvWbLYwLLQ7MFSxNz6nM2Pdf3wM8pvZgKqdDTOlCczrMXHuyodYKYMh5NQ5eZFD6JwJvFPmDLDNgogCG8ZNwAMKHLhJgvcccu99Vnd4TlJhA1gow47xmzN5i/5Bw9SZGf8kO/BBwZvuSgXWA8OYxAde9w3d5rP/4Z/BeKq4/orHn985ChrjAH+MBZJvRG6zXs3wfsoBAnfqeK95jVC8N4AkESE4zEsJxefnnygJM6ru4glByvLYSVNkY9gzvNarLd7oDu9TlTcdor/bYvLzHM43ypCHCk9+0wc2HnIGZMzBzlrPcAyl6OWhPh/TrxFiqOoEueSlUeCsslcVhP1qU8ntMg0gbZKMNMktUOA/SnEpGz+3bt8YwcNmRJqXSqJ29N/WICQblcHnOEyQqLqM8TtaNZJwtUICWXFcL4owkF0LlP0/+zvJOzUnNeMjN8Rzwu1amAKCMR18N4Do5DpLxOgK91Lgg/ZykwNcat+oElKlt99R3bHmcmhXK8FUSgZTeAGKG6S3MnmA3DYiBfkPoLgGvpNsW2D/b4GJLuCSgMTRw0ACDF0tr0F+aEA5F3XAiK1lTnNFiXRiCHp/GgzrkeBU2MJcNzF7ap+e8z/Zk9pJGla0BX7j6L6SPW5LsUNx5Q3GiIwtfTRm9HiCAJgHNAQQlOWQNnioPuNveIbptzeAlAPZzWQFbRf4qDFZ9Zo0I3CQO8InCzE4pS8PGprwcDwBrqiVtpz5MUka8/jsltY0O4tw6mjvQCSTgfp30f09NTcsgiPdce9WADcM6S5QN0G8NTGeA/XALEYGNCSANrOOQaQC7AXjjgJnWghvGzrRoHxvhs+pIyuuGSa0TSEQe59HeygHsiPrWDN4wgYw68viNw36GEC/lyeLr4WE1z3kYLdFtB7DNt58EODGyjkfenCmoTepnAZyJPudhvR7sCgeweUJjxhBK5n4P4az7Hs2uF5DN2S98sUH7XIuf/8t/sv6hX6FyBmbOcpZ7INGmqIES5nnjQbs20ji1nc5uoMnLBp4Vv8G4748UolT0EKiVGYUpNv5RfcpWA8jkZJYkca0s8haY6M+SseD7qMHYCF8LxuUMfN++hoZqiEZghrS1UE4u3KdUv34Wzy0DzIIyR83oVSOZU8UcIFOUAjjIRNlnqfYyG82DinsWynS2K/VH5vl1aFQEQo8MExQ9fg71ckrH41ymtIh7pRnaG6WHTowof03Wbd1/5pXxZrie9hYNOU+XBwTbAv0FBaXabgl9A8AamK7FpiHhZejs0A6Xzrq/kAwn7Z5j8CYCpHjYL5wLv15/+wvC/iEBMMF13XQMdm02N4z2qofxmVh6htlz6FQhCXYGAglfRMo75dukSUhr5/IA0Ll6fJ86I+3WvTRum8ftyAAHGwJagDrEWa50nUpGxu6U6PX9NjyUbrOehVLi84p49jTYFbm0ACkoM5JoT1F6of7eEwE7YEJCgzAAZ7otDTnvFKC9Ei+97oEJGYr6SwOyDRpyQLAVUnBsGgAXQN+Dmwa2Ndg8Zjz4gEF/0TiQxsC2EK+6HTAQEg9tzYU7k94fXF/58MvSPNTjNdrHDGJglwtpzlU5kWhwF5gcc1muLQfEWJftKtSh96YeAVTPlpFK2GvjsUbAoFv7fiMFzDDLOt5bkBsXAtYbcGMFZGv8fUBzPeGa+yqSMzBzlrPcI4nI2DxSP2EEcE7hj8qj6Gf2BGoB6edSOYoBnFOY0pONA2TyfmXsl+7NPuMtKHijECcnqTE8jCcM42nWLRrZ8RTKKH1uGAyT75MDxljghtCnQmFsD6etIvNG1lpwZtLjanFZvi3JZ4nXR5kEuXLsayMnbXMwftS1NTIBAM7xsNTI3L0j8GmKWDoUumCdmLpW92XO6PHAhR8nyWBk8orrcAztS0l5BJgAtDTwwLhtwewE4AAAso2AK1v53uyFeJKY0V0SumcIN71kb2ofO0edAJy6Hz1H/BE6iwog+4wYMhCXdQU8eTDFNkB3SbAbCDCzIZie0W+kXZvHjgvCKfPee8b0FnzjQEar0sn68QSdItcBQg5c8Rwx4R737nwf5yScPAdim3iPTK/Lyh004I8uBW8eMfQQMng1XT+sp7MccbrvRVJvj9EaeGpZehiVu/6IINtsqHeufrVPUMkIr+jTOW9N9uAws2wroOD5p6v179TsZI3y5LC2geMcMcK/4tvVGPAlgTYGxJsw1y+f79HsxPtP5rSUQZbR7Ny/Gytgr+eZ0WtbUW9zfWakbTkvEx/6xEFngoBSup9GHej19Uzdc15VBU+ssH8Yiq7x4aAABCjiAcgR80Fx2ejGaBCt9BipbuFxJ6Vi+XDVwEFDPGSmag0stcBW3U+E9olGtF69cgZmznKWOyg5nhlWi9+Is0FLQ/FGnNpahGnSN7+5e+V3JsvTU5HCJhadSGsF5SAjcMLAnSn3VKBMKYwpD3iMT16KikNi9Ec/UyPdf7dESQ7gDMWG8oHAnybu9H8PZRNSXfSUXjGT4Ug55crNtxGQOioXZVAmfcdLDYGp9+iB2QNAmfT9PC2JiIAxzO3R/J4aj4V+WOSF5JXipMwAyviMSg3B7A2am17IL4OBwO42Kk8/ZyywIfRbgFuAesl+0V5L+IBtCP0lsH9IMHtCc0PgjgYCShYgh9hGWTWEFBiSvckCZAjWMMhwnAnF9YvpxEjy4E0wEowYVSDxzLEtgToDA+fi7k53TZcAh95jJun3kNLbX2bz1hc3ZgSqZ9eDCRDg5J51R/ROrarrmPeOvCwq7osODwrerrcJyGi5rXcxt1ccQQbuFvdBn3iR+H0lePQBI08TfTnDzUVtqLuXXlKbdBsYag668hoIabi1QGsEqCUAppHLXbnNlYW58QC0bhQc4a2sHaaT0CftmRh5iUSbggI3WlknGJAQTq8XJwANw3nXhDXFr1euLVFVGXAmN4dWzkkPFJm9BXPiZekBkwQkjQ6B0kNN1c5xODBG+yH1wx5ASR3c86BOGgpjgJ13lNmdgRngDMyc5Sx3ViZJgMPiiug0m5WCv8b1Nlp4E2+cEqBzcuW0UlLD1Ru6ZIBjeTFM119R9loFeMl9OeWuRPzqJR1PkYfJhKTPnLsndw1znRdDpRSfawqAnJGlJItLDbXaMVnKNDVHuFtVXvRFAs7kvGeyXnd19Y64UA6QuXCsJd44VUS/QHlsZ8Jpstcl5XjyS0CtrcoN3V4IOONBknYn4ExaliGS6AGfccR9bbcN+gc+nayAMqbj4Flm9pK9RFzfJdSo3xqYG+sMGSmoITu4xjvwpL+Un+J945VwAnViEHiiXx82ZW4sNhZorxzxsF+WWtH6fVYWAALWwLiMT8P8Nb2VsBjPbQBERgN5TxkficWufxvjwJ/x+wuGVkZGBKnhC/9OK+Z8DUfM1Hy4q543M+sOqfdQLcm+NToQ0bY/q3XzNvtopU7lZZGX1VqQ3d+r72PFG+O9ylyojvaEG8Kah1BEIgb1yO8NYQ8D2MLNWXeJBiO04e+86aQNCJ5+3rOO3LwSLxgjXnSdhMNwykMHXceQEU570MECkyTUvpjEozPN1hQ8gRywMgpd93VmsGDfnik9JQppPlTcuos9gzQI5/vCxum4J/fwVA1I+j0F8UZrqjrYIz2H3WdBrSjoF69GOQMzZznLXZYpxc4p7GxJkm0QBW8ZfX0Vp0RmM5HP5xfKQ04OJ43TJRuU48fx5+EjT4JSHbchE0DJ0vurjOAlyqMOr/CkvG486frmx88CEMeDPh6cWVFmLmtEJCc83fTj/WB+klG55b8D6OgV0wZjSd75UdqXhjF65SlVopa6+vviDmjiyAuncszPrleph9hsgQWFMv0sU57mxwnhdt4gMBJ+RFYAEx+pFI0Dw0BHwyty/DD2soW9aNA906C7NGAjnC7UA3YLdES4eNHiwQctTG9w8zoDuxFwZvOYJBTqRtKFcGvAmwYwQLdpYDcUQqNs6wEhAX3aawB9sv4w0Owtmn0ctsCNPJekpxWPmmDMO4OISXgjQIDtKYQlBMNCeecwTCAO1gZm3wh5sd26vaaDy+5kA8CTNfKVF2J1FpPk3tnP0jrvg8yBTVasa+9BsCpkUZ/aRzEwK8o6lqx8T3r81HDARR5gpOqtXWOnrlOgjJ8nIYxFe+3RkC0nNaQj0QdhLstaRBqcu8fxVonXnZtjltHcSF3cuLXvQtY+7KwryghIFPSIocgoC1+PUGb0zgizXCpR23XGKQyfMzgwCQCIPU9Mpg6W/+IDFl3nwPE4Kk8DWpUhcmG8WQ4cwNEBGMegzJSknHWjOgCACNZ5IIZwMf+MHnDRz5x43MgIvGdr4InlDMyc5Sx3WN77b94KAPjcT/2u8ZcNgXv305jg6VA0djy677aaaHHNrIspoJPzQAEOBzyOCZjkAJmojoL7dE7xfhpATincY3UYyMhYX64op27Oi042NPCzqNJ6UCYrCVlqCEnQOn5GSV4LZuTGSqRwJUrVZD0l8M7XMRdWlBDChseeUsRK72lBiFnW6EhAwlOEM1WXOeehlfZryYMoNTiiU/3MZ6kUgRz30506Ugj/EXCif7gRY3XfC0GvLseBFGSHB/Qn0sQMsydsngjwcX0hgEp7bbF9YQ9gi/1Dx7viU87uLWjXAcYMz9Oa4bSbHK9DM8yv9gpo9jyAJkExH55JuCco4j8gpiHjUwLo+HAIbyTarRBaBnAGNhiz1NngIQPHDcEkGaG6BwbdpZTR7BgbJmBXvxZOAbEHhTTdN1AGGNayOb6YnsNYWTXlj8gTd6syZSxnJArZ8mvOVGjLAhBc18luHtmGpF/VfItAbn9YZjUZsy60VBkPhjZBeWm4Z/JeOxCw1164sEMLNNeMpnfZ2BrnkbeRuokJxgJsnCcMhjXHkwhrotnZrEM5SfVmryt3PIDlcM/kSWxZvQ+tb/hyCkBMbizkDihHuncJnMk9Dqt3NwMERn9XlKm9hPy78J5PhhMdM3luACPd7GmHN99FOQMzZznLfRRjwC0QmPDdaWv1Ije3wLtFez5k4ESgTK3CmrtuBVHfSZW/BW6qqzepIyn4Y/fgzEXqpKSuUP/s7m9Teuf+e+SN1/TvWu8jfbp1RDto0dhfCsoUv8cwz5VyM2oLDdfNphX24r0PdOpTDVZMPO+SuXMI6e9UmaO5k2u3eza2R+AHSYEb/VkKmhQk9ZYJHmqW0ewkO1F/KafHXl0zRDDGBu8YbTQwTPhbYvYZm8eM9tpnOAIuXjQwPYSbwQo55vZlA9sQTCfPYC+lLmIeTrXVHCIWYKa/dOBPL6FR0vbBqNPZOcRuU33CLvQJAI+I0NyYtjRkYjKQ7FAXAHUGzc7CdCQg0l76gxoKJ+6BDNm1yfTD75rXIoQrMELGmJxExk4wYHk0tapB/rsCyqRrTg2QuqTt5K1+rA5jvBfgTIVhW/4SgcDbh+RQbxcDNEXPLkDWFyOeKmQZxnLUpiiEB1DAh7smBTsqhL1HTuSZ6415H9LEaFm82MACvvauPenTjMKHvM7ACpBxbY9vxLgwL4nePAodJsSeQOrzsG63Q1kDH0/cXzHo4gGxApAzJQvAmVlZ6Fmc1TPg1lTw6Pvigajlwbt/qYfqq0DOwMxZznIP5L3/5q1jvhkzKOHAgciz2hyOQmq4Jj46s+HkMtMc3KZCvYcof08tTCqRGu+BItiWkvpGN3H+c/39VN9ZpYwEgomkTmAIpUo9NUqgTK1obKISp1gkmfFe8qJZKpHCqRWZyZuUK/rc2PSnmf792EL5qTeJl9K7mHhHpz4li8Z4biybiefU183JnGdMhbD3Qmll0HtPFxin5HckoaoN5IS5ITATCCaad2zIeTNKuWZvsWFGc2OGMU9CmEk9S2iR8z65eLEPIAobYP+6LcyDVvhiHHEmAFBnYfYuhIklw5LdAM2VA2R69UweHLEs7dVcFhgMK9oPJJMD186wTvi0rj60ixsBa9gTBe+tpNlmuYa3Btb1ZQC4ekZz7dztLVxKblbApTy3a7z0exoKAYy8RXPgXO2J+J1JvzzRhtXzlJKfR5AcGemdloJ3blb8GtAQGCTk10zTno41OlYAECFrXkMOwKUBNCndxygb2sBA3grkAWp9vZ4nzC6UUBplG8BuCGQNzG7InmQ6OAA54a1Km6o5TXKPs2AMjgj21d+k+9J/vTGwjRm8//ph3aAuLivLiaO8TgAU3/VB+2VmHM7pIVE/TwFBLP1v9jZ4pHo+n2oOqBw4+CqXMzBzlrPcJ1GeLKPPvSxV9ij53d9e4TVzVBAn+b3ezVy3B/mNZK5PkntKsbW3JlNKe8FTZIknwuidzj3jmu/TcRE2aj1WkYCLSTmJK/ZBUhrnS4o4BQCneAV4SgnSXhWK/yKID8vz/AE+dCdxuc7yBvnrtNu2r3NCjqJIHWCgzobm5bxasm1A/KzpPVOZqZRLdmiL9j6a85AyBLttgnJvWxLPEIJkROoZ7ZX8NGkGFd9cbx81alz0wilj0KvraKAncoYG7S02jzhwT/SXBvuHBvTAoH3SC2/MXvrE9AzspDP2D+G8UwDTAe0NuwxO7jS5dSFKuj9c3xIoytBB4BB+1LcG3QPj+Gs8N442COU6G0KhGnQ3DdqrFtSzcNIAMDvrDD2LxrvP67mlXenduGdyYb6dS7OtuCH83jLwSLj5QvJ37kTc93mYm4zYaHml8M5ocQZ7mlJ9lZRCLTJ9fudl0sBVY5zg+E2cx6NR9y8pl4YyPFAfCH2Nm6PGgTOWQliT9fPEjVU/D8CqDX48t8IvErx8Ar+IQ4EBBPzYl2UZ5qYP+y9fmsClRb3cY3bi7Ue9ePTNHpoFT5Vk3mkwpejxU+Z/SS6Lv/QeSFvJUOcJzKmzsoWSglz0IYlvT89hPQEQ6wEepC7JhKd4iWYg71WaPp+vP9EvpsaujUNQqwAZ1R8jXsiznIGZs5zlvsh7f/o78lwzOUKwHLeIXoVnPA5SwCW7aB7j5KqweK8Jdygu7DVK7oynQ+67RYDNUuMz8/6mvteyiMcjNVyXglA1njSAC0+aKTsFBFaCMtHzp4rZjNtsqgDOKf4j4r6cTCg14xNJ5FNmL30vXrGyJWVUAQnaW2buPfqyUw+pyrWg7K21EEjNlFkc93Ou0jWpwIM3BS97FxYSuufHc7KmMgnXSn8hp67UM/oLx4dC4u29fdmiuekdh4z71zNCyBQw8DpEdbvv9KsDh7q9Z4o3mGAgGqGFADCMYHyQGk+eYLe5MWiuCLQB2ifOgHKAhgcHZ/lFNHjYu2FkJH1394Bg9sAWFu2VtMdnbrIb8Z7xacDBDZqbBu218PK0V0ISTPteUrAyg40BebDAeygYGvcdQTqeASbjjErViSnPmgtpSvk4NEkpt2IQS7hGxshU8yfipbonknq2em+pqaxXi8WHP4RKgUPCo04ulRwegY+JrUvvrr9UANTM4Run6zEG0NGP9VAf4LKqybWEzGGfrnsEVDPQmABMgBkNrGQB8muxVUAxAfChLm69MbseditZl6SxCMBNe9WHz0LqZRPPG+/xM9pT/LqXerf5fkm7Ts8734+lRUvX7/vThW36kK2wnubq82Bb0t7JbE3Jc62VwCPk1y/t8SRXJDeoNhT19HhdnJVEz2Z4XSKxT17lcgZmznKW+y45l9aCV8ViVDoL8hx/AZ0KWVpNelsIi5oqd4pfIPfZZF9UxgLn2rf0tOQUvB2rpQD0cAMUyVe10ToHyMwAkTzSNdIXn++speNaZ9rwMhonmlvIpGCnu8+4jGJBQVTPYJSzeW14oDr9h0FMqJpTslJvmVIYm/47UZBHUjRChp/a8yduz/LBvHiN0HxGc2F7ufGSGeMD6aTub3W9BhvVu+8vGvQuc5JwvCBkJzIdi+fHTR95jUT1aHBGj5GSd2X0HBidmjY7MRCFUJed4eGerxcCYUOM7csuy1IDAURu4qxKABSI5IonhBBcnR3Ghyl4o8g2Llyqc9/1zmOoE8LQ7hk5Ze8vCN2zQL+FgDgvAe0TObnmlsC9kT5hBowJYVAAxCCCAEGkuZTdO/OeNxJeiSFEATzc6wGuRoUVO6+mkNqXBk8FD1RFYTlh/DGiUOIDwMq7IMOzogzaLnzGYMwF4OGOe83U7P8eSMCw8E+CA0qC3hQ+GL4LhndI+5zeTIFQN5Dahpt9+YxAsKtFP5cHNIwLs4zWVvW79aAEh7YLyDuEHYawGDcZNRkxXDpuDYiE5whrpmpr74EWxPOMXJsTQEauTedkLGkfkpX1mRToRZYHEmJdn2ur3yc8mFOtuxV0+iAlfbMWuBwd0ilgTtd7xHUpCm93AM1ZzsDMWc5y/6S00OYWZrWYlzIWZdnrUVB6zHjzzrYjV0/pOl39wjW+loNmFDvsNsgag65G8SsqiHPunOn3UyfgxfbVXZdKMLZuK1SLSLwHcuDMCZTrUcYxrSBxck1GSu/9WMBkGoakwZmslE7P1Ofe+At/N04j78fPM+KuGTXQK0tUfj9LuX6S+kehW3NK3pxyegzJhdPp5w+KKlAkqq5JA288Gacn9xVPFbNzIUGWYVR66Ml2UmG9WPJ+WEKfhDR4+AxIADWI8bR5zGh2QhrsjawQxuRtIO/l4/tMpeu1LYVwJ38y7uvZPLFodoRmz2iurYBFnQAsxnPxNITuAVxqXZYsLiS8N0CD7oEjCHYcFaF/b1xWK991HngiAC6sgw2BN96jiMKzmL0FwwRiVh/WxC79LyzDEAsRcQJ4RYTBGMCZ0Ff+eJ2HNSYXqggg6w01ep23aOREXmuAjCWrvtMXz4XpTs1t7a00tS7dFxmB5Go9TEHTOfHjKwOcR3uWK1e/lxDe5L4PxwGMeL9OD7usrFWen0nAINUeJRKWRcMWTAgcUDE4O+xN41TKNOznpUMeHb7TAyAWYmUD8bhy5N+pN+nifZ2FRybi6Yn2CagOVt+7aT546MTzOJq3Sw73Kq7LHlrVPLeel4fsvem9iRfXXDrzV4ucgZmznOWVLhXutEEO1XMO4IoA6oEWfa3/PevKn429pnwdS/oJ44180endVPm14Iw6EU8V9FOkJQ5tSwzC0fdzMpe2+FSSs20zITy1gEzu3mKWpBOL9r5BoxRxgiijfdwe0opiWkZ0YQU4AyhlWSlvpZDKBXM8K4lRehgxIoZQo1Ryz5zzoin1S6lMxG1mItjGGyMCcJiOYTo7ZGdJ7kndvotr2cw6NpBPqkwiodBQWXKPfEk9YHZ2IPlFfD0xQoYmBCNdgTLup904UKoDqBMvoYsXewE5PLDTsRjlvcu+1EnGqu6yxf5ZwHRiEPaX4j2zf0gwHcHsDdorRnPj0mQ/tti+5F6569fgBQO1brY+7ImGVLAALIx43Kix7TPd2JbEEEzmmg8VzJJ8lrhB0lfhT/I9QGZwmIG0UHy/VO0rdgDjxCsgI1PjsuaEPx2r91UKzxplAJu4L4SO5UBa5S0Dcvfw8AI9kJYVDxyoNPfR135t7AEDC2YKcztXDhOBGog3jaqXOgaaBCBqHKahwBn5DtKeABpxPB71IUMOLPcAVePq1c8Srhn6b3SYh/G6G0jCi90o8zbyykkpBea8GheGCIW2lkBdV2bElVUSGto7y3W0RhKd+057v92inIGZs5zlvsltuzTf1RjuGtHtjsJqEiX5KT9fZChPGYteDvBU0DJLnpq9qfKUZUZqsmDVGgIjMdNZtqayTaRSnf62pl2IAbxJMK/mHSfhi0ExJgUS6Xbo31NQJuflkWtbZZ8ewqm0RI4CQs4BjtlwreT+3LUZICcyplyoWbNH5HJPVlJAewAiCvuaU+S1FAAyab8CEQPIVYOIZ4yTHiF8LpQxOh1VRTgQinql8DOGcIadHYc0NASQCeFRZmfR7BhmR2iuATaAvQD6S4a98CfyQPuY0D4B2ivAdCbMOc3npI0wYgCOwJMb44iYJQ03eNg7xMOHYVvh2iAroBJ5zzcNbFmASBm4+p14sA7OCJ1aW5wdJR4OyPJRnQqUH5WbeK9FXjPuXYZQQeI4LKIkNetA5DUjhuNtA1VHlUr+sdn7S15zSEDdaMz7D2PAIKSizoS2DIUieJ3whtz8RzQuCACCJ4wDRXoMoIoDeMM8D7xPEHJwlnLg9RTCCDQZdCf3w3vFpP3jQ7LsvM4zhKWmHckxUM1qn2UeAQ2RZMKZw3WHjN3EYza0ZU40ODO1Xug155TAyX2dvyeQMzBzlrPcJ5kLjSl9XrgvXWgP8gKZin2da2Oorw4oyF2jFcepzCXy+8wGtsSFNNSf2XB9Wbnyw32IT3vmQJlRve4XZVzW9kP6dzVIUwqBmfOsWOF+vsjQyCgpa6UW1Dn0+9UKjx6fJCf33NKgoDruDOrtUH5uLShlYWLGFOAwjDF3TaVitZTIOrqnIoRD17Oae+kYCmgK0GRDHcWYb3Y2eJFwU7GOLpGaddk304ck5E6bDQXwJXLH9waclXAIneY6nJa7EEb/U0hbGY31BKSqf5wh5sEOCVUysBvjQr3E6uovJDxBCH/huGcAeiD8NMYC1AHNDpJ2twPMngMpsLQHw3tKDdsAFCn7jAC7kSws4s3EQn4K8R4ynR2yrSj3/MjrwIdzKINRvNyMy6TFqm85vJdgFDvwztLQzxHwx8vn5GKZ2NsCj0jHQAuXbcyFf7G+rmDQLpG7FM5UozNMAKSLxfi9PjGsMzoczOAFQopsN+I6wgCMBk+ZtExftB5vzmPOczL578kQ0PHgeePJe02yrfh6mAPoOZDpDsAxuzDAAOpOeKyiGe+pniPKPzsQ78XBQ0mHQmU9hRCLn8agcb1urkoYF/IyNyYqdf5ZvsM1EryPMH7us5xMzsDMWc7ySpOcglC5+U9mpTmSl8acVPHFHFjGMWTRiVYRGMNYsTSOQ2HqGdQ7LnHFlPppCuhYbMwWXIYjYtIlAIkykg6RKJQnC07NcALpWPmJ/iiFN9UqQtk2OPftydTZk4WqX5M4+uh0Oz2dz4WlaSLH3DVTHhm3KKWwpmg8TxlxpZC8SWXX/axNL577jsUQp84p7pz8O4VMva/kVDcQXLeEfmPArQl9avbWZVJSc92SeIaUTt+tM7j8e9FpsEnChmDIZQsmmN7CNgb9ZYPugeOccSEZ/QMJHzI7AWfYMPY7wn4v3i0+hMl7srRXjM3jHmbviJStBdilum3cs7lQQH3iLqmArXCmkIwp20pok+fLITv0l3++lDiTlJGmSUCJAeuAL3LhISOwQoVbcWtCmmIAML00LKxpfcawviXRACrBgo1LA+88JXKZg1aPcz/Mjmg0HiU8MifH4OWo2Qu056MdQJtAsu1CA9MwRfEykb2awDGQqEOjvKg1tb8wsBcmAtqoU3XprGuC0YXw2vRQiTob1ul0/GrPPt0vJTA5ak/h3jRL0JwUgZrMOPRrg+smBVhX6Ah67y+897UHR9U8bVoXY7Wm3WfvtHsiZ2DmLGe5j5Jzk0xDFjIL+qGn84u8EGY8RZ6aGFpsQB+jzmJd2mDUHi/aJVhv+BOvYClh8FQWrCxAk3pUTI2HmXFWDJ+Z8vrJjfvku9oxuprcWt2flZFHSi0oCjEWgTpgKp3jzB5xkWdzLuQ5w2UEVhwChB04h+Y8okpjdMpr7qDwvKnwLe9FlANl1og/TbWOeNeK54WEMBUydWH4DDgtCB0Iao2kxbVbl/a5Y8nc5NJ2DwCza6gHOYBgmPnQhcizhuJ5GMhjjYA0liSTkgdypC1iCXlDs+mA7cuSXrfZG5i9eNJcvGTRXlnYrbSjuXbkvY1B/2ATg0+KJ4YblZHKGXSmU5wpVurvt0Y+dx4u9sLAboDmRtJik+UhQ03Up/l+1sZuOGFPPMSYfBc77zjLYJ3Jx013/xqOZURlx9iMpxvbIbU7MTvgCRnQ84D2qXcYeSQc8MyHcVZl9K65tswBLxP7xyiLEHuUAIFfhhsPrLi6eDDeQxhLGGcKSFFFDYTlvk435gy5ce/GXg/3k8M/qHXMz//4ITj89JmVvBxDT4v2+XQ+LQG9MhLKZQWCBfcjBfL6Sel/JDrduM1D26UslPdotXYs9j7LhTNNHi6cwZnbkDMwc5az3CdZsoFUbjo5A/XgWNJaVH6hrA5NuAuScU/Nebss4o+Ykxmj+yDvmSlFYa4NngDYZ7ZJPGVSUKY2nCl7Iuv/zLg+T0kNB05WNAhXO18jUBXywEQjRX8OWKXepQl2YUwREenUeCmNE03UnP1+PKZr5VDPt1XeXV7WElAHA4XH9y8ZK94jy3mIBL6VntHsrfPo4IwR6/48ZB2sNRR9Ox3eEgyvRhncvQJl1FwFC/AyhDFl+C9Iwo8kI5l6psQbEHbIUuWNPhCF9NwBHAHQ3DA2Lh1Qs+MA/LABcAnYjai81s0R8aSxITyKhscYmtkP74EcGOSzaQFA00kfdFsTACRAPFmoQ349TP92oJx/Zn/CHrwBMm3ymaaGtMG+/4b+9aBTGhp1sNSWYx0Y5gxLDyzFBw0HGHqlW1bqH0cBOfWavdBIPqZXspCKK1AGCOGF/nv5zPG8AFmiX7l42B98yKzMXflbQGUOnlrhUECX5T1BFdE2FLDh27JITLouxvcHjz+/byYHZDm9YpUXbAhLROjriJS49FyFQ4BoHdJzJ3N4QLrvCoBPdNCXimUBkKYk8TY9aM6eZVbOwMxZznJP5HM/9bsAxBsHZRZouUbdqDb8qYwzw6llZiM6cRhTjeF9NFCmZjM5ddhWDZFnLlwJJWWiUEaFR8TRyCIPBfMoNt5m37flcttP+PqqwJpDxo8zxibfS5bwD8H7wsCd+Gu39dRraw5A82NHA2cZiZReLzNzrNYDbE5KGcmqJAUHQwEpoldoYG0IU0lIwlG8Z4npPP+JdbxAdWWfiuwVQDhRNXuLFsPpOzEka1QEHmGYw47slhtCf9GEe0J4A+A4a7x3CAmI6I121mlzAdrZYU6z/Gf2AF+rthoCdYzWEQGzAbpLg/6CQiiHbQG7AfoHhO4SaJ8Az/6KxYNf28HciHVqcnNXeQx4b55+A+c95OYVIYQ5OUsIRAPHhrRdEfyqcUrq/qG+BBjW1/cW5D0PAmgUG0+RMefBn7XG1IwXSMmjizoHyrRGCGIBoFcXRWApLWqbBs5nCdRv24A8FQBWDGtxv2jwxAxkupqoN5UA7CnPtpJ4rxDbEOyF8p7rXAY151lGlsehSiiUXwPKZLnRpkEZ/9kInImeB0rHKvVt7NEX7tPiPU+cN1HwFkxDx0YNTOZs4ZpR5qnwfP6nAmWSNaBG4qxxBX1RhTRFOoWXnHffWVbJGZg5y1legbLGwyB1+cwtsKu9CCbkIMDl0DCMpy1zyuixFLx081/RZ6vJVKfqUtwlazdyP9ZHRkwybnO/z5ftjMjbGGMrYtyzYsVonuQ1qpWZ517TLzmyagBPh6umFIo06c49PrWcvSZTHpMDEBz/xpCJaFzOGoLuoynIji/EOPCgXOFgDFJnhVOk8cS95Ih3Oc40NWqzb7SUN6rPGZgR2AEHGBnAWAazCSmu2cjJfgrIdA8Z3TOM7UsG3QcdMLbrhzHp1yNDwj/TDEapH6P91nvdkKT6dhwd3ADcq5ArENCo51MePnEohAOoiv2LYWwoA2xYE4aBEdrqs9x08feLJNcmNVdrvBrJynOXvTMTo3kO5HWHFjXZ9HKeEvdWpjwxFQDBiYcFWQ4Zw/w1cbkYgyYeaM3WhQjwMXuLZm9jMMZL4hUzKqp2Pz403EiVk2Yzq9nHAugRQNpyv3BL4WAkkA7r610bRn2l1vuIlLnURR7gLYAyYb7lvG71nLCOw8q49aoCnBlx5lR4I43kaQGnd1zOwMxZznLPJLuRZTYb/d0imYl/TaXkJprKsU7J40LTU5MKL4MjbgJLDNPovemNurJdS/rsUO+i0v0jcKYEjKUGaXoypMNAKsI0sidU+rrcGK85iauUUwCS40oo+n3S/djJZJu0IQdE4yuQ/9pMPE8OeEjqqWnbrNwW2BUBdiXrgOKfc2VO1VPj4ZJ+5owbATTknczOdzXHciCMDgc8ZL31JL2UtDoAF86AcE4iwz2ufbYl2Fa4WbgT8IG1QWAo8LREXiHgqGxuyHncACNyW2bxGDEAd0Oo0QaA6QndBaEzhI4Q5kVzQzA3bm57Et+exXOnAeC8mcaZmjAQARsEXhrPkUFpOAcweC+AYISVVd5LOv1KRiylP4c5mktDTcxSVO9uSUCPHO9GUVIwYK03nFUEyIby3hNLQ7VznjzJZydP83tKWRMWq8X1sQ/3o54D94x8H18XxO8/yuNGC1nA7GXOUsfBayYaG8m8CR+f8F3UpIse8RElUkqA4ffMKXBx+AMIBMYTejlb50EXykC0psqHJWVsaN8IlFFlldqa87Zn7flT2v8Tz5lQVhqev0RO7aF+z+QMzJzlLK8UmXD3rFFOajbMEYfHyj02NRZqDYdJYtpC2SNZSs53W7L0VC9RlLMnVaVTjwkp9W22X2tBGf/T2jEoo0521gBKx3SZPbYSX1WeLShAteKNnTlFDvHpdo0L9dQ1WSW4YvwWFbcKULdEgLtKCiFLVd4p2mNjJQEwMWB6Bm5cxp8qj6lCWyZDzQ4DZ6aIltEzQAxujAAvQATgkGU0NxamE9DDeO4cqDZ57hil7AfS4SZeG1KwQ2eg8T+JrdD37Am8s2iuCM1lA8Cg3wggYnZCjr15zJLRqSHYbQPqTajbXjRgI5mhYOPnam4sNo/FO8ZugO5S1rH2CWP7SNKfm5te+qQxQpzcyjW2IRiYYZkM4Q55UEYTA4fUx4rTQvp9bEiG8JUIkB0MvkAWPBPeFN694tqJT/bj8VUiCvYGX/Cq6uHe97juam+XCW8aKQBDf96H0/kc2DRhXAMIe6hc6z5iBuyQLcxzQqWiPc9G761xoZaOZNqHFQoYY2FYkWQ7D81oL+A6oOQUUgQeM/pwDoQpHn4W6hr+QJjLAThO69Sfa5Bah1TlXnl2DU50h8xeUNJBcjwx4dBAFvKy5MKaorIn7tWSjve7PDdvUc7AzFnOcp9kLuY4s4mPFuaEc2ZJFpsg+gSPy4t/fH/ewFoKyqRlHV1SBW4Cza/tv8nsP0eQkRdL8cLc+MiUUzgtCTwmuSpSQz5nMBIhEKdWGrQ5d9zRNel3qwAein4C8XubetfHVjzDM2vFJae06+udxwB6YJSpYVUjEoBtTlYqVSPQYMIQ09dOheoU14ac8qp+nwRlavqxBDKmfWkF0DA7G8JX5sDmXF1L5FBwJtsmdie+vUUgCgbC/kB7i43l+NSdtFHpABdlJBE47Cns+FzI8VeYnQM7jAAn3YMGIAkD84an6aVf4ch3DYnHAKgFseOAgXzWXjOaKzEq7bYJYVJMJGUDoCuG8Z5lLJ3Y3BA2htA9INy8zuDJmwn9BePyNwyIgfbKCDDTMwDhgwkhlw3BmoE81ewZzU0/EAXrvvZ95g1sg5D8angRsXXkPWhGKYLhjT69kSZ7XGbeReu9WuOX7uECtAlIxW6p8tw6WR3CjxMPHhXal5WI82MoB1hR1m1JpU6Q6mHD/ug+cl5UYczqgxCj7h+NIUR7svc6Y8eZRNYBMr2kw4bPWuaAxRG5dC7UbHIPG38+uXclZS31aM1dP6fHFutQU5B6m+wpNAFgUEy8W3qEQpN8e3W68yBKx5+Ukre9B2eKz5zoe2vDBe/aPLwDcgZmznKWV7joDVO7LAIYb565RXINiFBYbKsMg2N7tMy1/0B34Zzra8m4n5WVm1sRLAmnp8OmXR0iof/OhLJUA2O5MA/HuRBi4FNAaImSZcTY8CexQHwKnXP1HzWxUF/uxK/2/VYriu6dV82NqXEahZFMlDHjYVEFQJza6+wUnBAzoMykZE9Qk7Jry9FjqmfADop7nsCyXMbScKWDiYJz78WKhwosgTwwZTwxqAU612xvJDcmmv+eh4E9sChYBtAgcLuIt40N3Em8bdBfGNw8Z8BEuHhZAA67IZgdo2UIMOLACbO32DzqYPYNuJE6qB94NwKpaUsAnKdOQwNwAMAT/Op3bVvC7rWEq9+yx+WHXOOlX3+A/TMt9s9ssH25xeaxRXPdi1GrvIUAgLdCTNyyhdnJgurDGnwYiZBTC4g38oTJSfpxzhCemt/+/SbhFAwHfrs2CfkwT8/RFFAmgFtJMw4Apu9H+0gwjGkA24ndkPflLFkXlHHJxpVl8/PsqckCnWMq66CW4AlTCkfx4q/xc0/VMwCj/j4JOwwcSSqEJjsep7ycMuFmszLnHQVEfZLd9zVgl96TmztA7MmiJW1yCWCsEV2WBjxYfT8BzgAAmuV6Tpa4H9OHULm2h75+pXA5PWU5AzNnOct9kRRcWaBgp6ELU7Gyi8o+9Rq8EqRYLFlDt74gv5HVnrbMZiDwMvX8yXdByc15rpxAqsJKCl4za8hMS23wCqTdGPQXol02N0KkmnPfXlcPjX5fqnytBuuAunngn3XKHRsYAxMLPKzSGPiigbhQ5gCDk/ArZcCNSY+wOSOHptfUkSgviDIxZu7DMcA6Ve9RPQtzPEXswyTcGthQFNI0eNYoY9v67E6u4T3HXep5MBxYJaCGq7cx4I1Bf2nQPZCb7BMCGOguDEzrrvfj03G+mJteMi8Fj4EBBLYbE7hi2IEIkceJ80BhIx4f/aVBf0noLwj71wDP/aaX8QUf+Z/xG//HQ/zzN380fuN/vwa0I2xfaPDs/9Pg2f/VYfNyB+qtGLsbA9uzIw12z6j2dd4Y9FvhuPHZjQJPiA97KhhtRRJdxM9U3K+MB7ldGIu7tr8w6B4aUA9sX+rQXHX5+V/hxevB48mx6cc5OOgri9ZNb4QroA3svD2OtC/cBZHwEwfwTnmhskOplqylbv4wkeN2GvaYoFP6rqzVT1dwHs5JFkTwgAHyiSwm+0HX6cCfCKxIgZShJe7/FAyd2o+TvxOvsej3ma6Y0k3msk4V9ZO5g5yknEPkvT/9HQfd/0qRMzBzlrPcA/nc3/ud629WmymA8iI7o2QdEsqxCExaaOxNnhrfIqnYEs+J9LNi/6UnEDNx8pNhRkeS2VP3nGfCxNgbucovbhDERbsl9JfGEan6wk93OlqriFS5TFecNFWF7uROL0vl5kCZnHdTpu2RwphyhlTIMZT23FhfCkJUhUEx50EZ3X+j+ZwpI+3PXMhkJUdPjZws1DMnLmyCjHGnp5l2Mgfjjsl1h3a/9/1MFAAB4whFjSMtta0BGkJ32aDfECQDmQM3ejEkbUvoHjawGxO4NZobx/nSq7gOfxJuPDBCgG63JxhWQIb3+OgvHJBDUvfrHlzjD73u36MH4arf4r8+eBPe9MzL+P+99Hq82LwBl88bbF9kmJtOwnmI0OxciFMKEjQOZL40kvmpIZjOoLl23DV7K7wevcvgtfQ9a0AQhfXJAd3cDmBj/8Dg+vUG1AHNtUFznT/M0KEbI1LijtFeS77s8NwaYMJg1I7WsQrDdCSWxcvHZ+liF+Jjx/waT00mwnuAskE9XDBhOOu55b1gtPFuIIBOpi4BRKUMgs8wpN6pA2VyHtn+9xIB7VGJ9HNeMFqSUJ3sdX4Zz3mXp5dPHSAYT8TO5bGaC7seYzuT9Sz10p3r71IYWZRCO3yRB8EiLqe7MK/usZyBmbOc5Z7J0lPZcLIxtxlWGYcOnMldltxbIoxcevpdGzZzTBLYQ2VpFp8qI19v6HPvKjUaK9oyycsx1x5vbM0BLIVxuCg0yvL4Whcq0NyIsVJLpip150GyQ5XHo2Vy0s/L7gywFKLA8X1xezJle5f3wklrkZQ5AXVq3l0xWwuwOjSqmqh35j1M3uv7CIBO7x79nCsrG0bAgQCyRlZ5DSWA0snWSCMdw4ovodinVmV4MqLRB2MRECPagSQ+fXiYk60RA7sV47/ZAe0No72ywitDDW5eS7APCGYjoUimF4Npwwx0VO4TljXEYFiPPHjAjTyfbQ1gEMDf1gDtY8L/84HX491v/D9xafb4ry+8CY9utviI13T4iNc+j3//hufw5I0tmpstNi/7cpwHhwN7LEOyNVmE8BFJNS4ZpUxH2JAFSLxoDNmBoyVZ5yI+lYJHzEi8/e7DQpsEfA3949ZW10dozfBd2G+AwHvDyf0ujbr+zN/j+zjyxvDvyIjHhnhpLTf62L1nP77EWJ8va4138iqZAWcmRYMvJa8ZPy8Jw3slB4I17ncFqIVrgRCy5rONFZuRvDMtc/tgOk6nQJYgubDeTPMCyW1Uob5AtSGjW0j4m3o/HkjhtAAH9BJcSGI8/nM63qQ+nQI26TNlw17Hn2W9fCIAraDvaMBLt6XSg+Ys6+UMzJzlLK82qVXQC4rCQRwqCyTKIKOkRCI8klv0lsnJsQx8AOVQqymyxsRzZQ78yH5f23bflrnQmFMIO0Np5zgogEBIuFRqyX7XSnGu1LQ1d28wgipuT9+vL2+GhDm6x2QMtkPFJKe4xzxtOwowNj8WgiGf698CeDNksRkMomxK6rsuxoCjo/IFIFifLPLeYO4saORhhMhYbHbCEdPcCHmu2VnYrYHpAdsAtpW29AywMQBamL2Ql2a9ORQRbbBd/RreKA4rC5gdwzCj2Ql3Cf/sA7znf/2fAhZdEdgw/vUbX4cHb3gC87DDS7+tRfegxTMfMGh2Q53+/TY747JXufHPLHVsCMZr6UTghsEWAubARGtcxPsRbEga5n0UnuBvUmWTA76MGo+dnJn7fnjgwF+zF4JTe2Eky1TPoL0drbnagAz93at37fcmM3hJASTbVrjOAUYWoD2P9r3cYc/oM5L60HPI5pXj1qghHV8qk4B0dSELrk3IfqXegUjbtymsOzSM79BG3+cerLQcspNFzSqAGbHeMbFn6Pv0O53wgAl7hRl/FjdOV5N8PwJfCs9REgXmcCY8bNDBfAWiFwUuFgX0TIa/T7z4Y4QOaUm5Jj0glX0XI0/bozXjLDgDM2c5y/2RnOt7Kolb/Eghc1JUNCrBjJGhMmNMTYECS06lJlNyHiILyH+Xbog1Bn4150zp+6lwlVDH8POQUKSY2yKjXOgTvEzZoyxLB/IIEfNA6NjFn8+Xc7uW7xSvw5RRMPwx0d709kyZWSNtQlKjIsrqwlimzGJi3IXTuPqycmUvDd+Z9JRRP8tGQqac3FyYEjMxX3LXLZ0vCphdJBX1hTIz68xwEeefTYOgnvTWGQLoVUF+zejdMGHA3AxGouk9gS9gdhabRwS7JdiW0G8AuyHsG/m7uTForyyamx6eqDNu07BuZIF1Kx41QhwsDWiuDJ75AA1eBczotwZPPmyDD/6O14DffAP+sBs8wQWIDZor730A2I0U2z4htNeE9sbC7MTzr9l1MF0D0zvwo+PgbSI8NdJzHkgxHQtg0nFYv+3WhJAus7MCeGngRr8/Z4x7ktyQaQcC0JibHu0TCW8SIl6gv2jQX5Jklroiqd+9W+81kBqXuRAisgzayb12q8AhwGWvImmDBcA25i9CvKcVgWQVllaUZM1cNGeWev2d8uAoJfJ175UbF2rT+Y5z3lsOrJJwPeFq6i8kzG77yAqYqD1mEu/M0mEQMK//pOFDw3tM+m9ESK2VgJn+cEDjnByLFyf0xRLJ6KCHZoKM7tVA0VT9GHSE4J3bHDZWb83z7BUiZ2DmLGe5J5I7KYgkJSyLbh6U3EAOWgqJKEmycSwnPx0r7dmY5MK9i0Q90yRZa/r8Ff1R7fWQbLCHysio9/X5NqfEnIdUWalUjF2QVb1T3jOHKKUlEEOdYuVkVjmckZySNMUVtBj0mTOEp+peM75K90y5KtP6sZXlG9DPWlgbls79YvhVdQHK+MicPk/WUwnKRCTKiUTPPbsWTX69HJQ5lrGYG0MWgMnsS/5zIjHmew4PJuEtPBg6nXzX9ORSYLtiiARb6C3aJwDvXPafZwzsBugugX5LaDbOsGMOHhnRHuSMd53VRj+GN2oDCa9lbK46SeN9tQPtBRnmTYv28bPYPfsMHpkLdK/tQb17D+4fGzgOGalHjGeD1jhPoOveceZsQFvA7Ic2SznyLP2lgW2A9ooH4KgTI7x70GD/rEGzY2xfZFBPQhTrgZjo4eRfBMr4kFCrOW0IaDxfiZRhNwBYQBuztxJ21DtwhtR48F4Duu4AysqzmZs+ECR7rhuQm346DGpCwvxyJMbybhE4hzTgOpuV0ksVUKl0jSmQpzp8sbQOq73VG9CGoD1k9NwIHkNJ+wdgbriODaHfEvYPAbMnbB9jCJljNT+KZWU4pnioR39WykKns4ZmOVmiG4DJw6CJurJSeDeR5w+rz3RTSlVkQKaiZHTQo3nGlIrJgDJy/YQuMCWHAJxnOQMzZznLXRZN+ju5ONeeok641xfL85vEEZT2dIGuNfIOcSUe6poAaPRGcki8t5ZjlYMVRv7qeg4EdGplgYfSpFQoMAd5Ky0op/aaWTlQqQnGhiYxHLker3jJM++qzuPtuO7XU21YDNAkXjJZUGbt+01CCoN4oEt5J9TKkBUlUZ5HAF5lgcc+wfftckYkWSEJ4QaDYek93XoMnyuJCCiZA3AA12faGA3p4i1LyIsLTbKNeJxwC+yfBbpnDJrXGAE/9kB7JWS6Zi/eJGkqYB0+FY0pHtYw3jRgugB5FxgSb4Nnf6WH6Qz2r2lhdsDFixKCBZbnJQv0F2Lw2Q3QeyIUboKXQ3/hvFicl02WR8MQuGVwa2BhYRgO1CDsHxACqbEnezXSL5GhqX9nDOM/gDhmAEzcPPYeMtxIXSApv7EKQPL94cG1jBdN/NLdtXsLOG8f1msiCWAnYwNZr0Bdlk/BbqyVENfcepjTn5L5MDoYy9zjwXu9zpX4tEqEq7MSAK3hfh9mJ+Szrg0qbMmHJOn5E7JiaRJmkudrdgw8JjQ7RnPtiH9992dAmRzfnP47EE2r954LW51bq4rh4brf0rEMSHp3fYn/PuXty0g+ExPG83Du3a3Y9nK8L5FMrNla3z2UeqAUsiUVxXWecn9/tcgZmDnLWe6L5DbCWkBm7kThRHKMuOxDJfViiDaPJYS6a+RI4MwkiaMdKzhHBVcWAIJzJLH+miHzyQENrfRIWuoOfEoQ7Ngx4Zzt34nTrynJkQA743pEsstcNjxm2ix1pUAR8p9PloXF9Q83FxT71Esmd88onG9mvuVOH40PQSkZA5Otl/qs5nzg+N2tCV8qGVpLJRe6ZNXn1MSeM7pfUpBJGXWANuwc6GhdVZ4DRhF0mo5BT8TrxHQG+4cGN68nXH8og1ugeWKwfQm4eJ5w+WKP9prF8yUCRWMLTHsDDpwcBriI1w3vUXP5azfYPG7RPTAgCzRXPUzPzsuE0Nw02D806LcI4AwbCbvaPyPGtm3lOe1O+HTaazs0iSGE5xCwhBsGIOCMhK2wPFfHYrh3BDQYh7bo/vZ/a68WB+hwQxJaBIB6Fz7V9ZJKe9MEMCASx8vD/p1pYtQpfMaBM40CEsSbygFZAezhiXWFAStZhULGOtZ11K03aQhNlp8mV6beoyvDpHPlhXFPGNZkx8vjQ738OsQW4W8AwhPkQVBKDqj8Zw4oZJKpue164GUJDWz2NkovHvSn0mGW+jys0Uv1oAVey1mQT4NIekxn1peDMmIl9c3JMfb/aN/LtD8HwozqLQGRHlQjyu9pM3M2V95ZlssZmDnLWe6gfO6nfpf8UgJglrjclpTeKZnjr6mQKuOi4rNJWRjXPcv34jeTpR4dd2gDypElr713UlZyXfh6ct5TaRvSk7e1BmPppK3mhCc3Zg4KWdJS6sPSc+YAjanqa0EZYAzKpEVRYS2qFH06OxnLn562F9sjZWYBmty6ORW6lXwfjReD7Cn1rHBStz7hdp4kA+cP5p/bGzsurID6zBiM6qhvarauGd6jXPlh7gbCZIz4CeI0rIBP46uzx42MD3+pPnlP1w/vNUACjJieQTsfciQgxDURumcZ9tkO3ZMG3BqQJbTXBhuiwbMAiDJM+XaOxpAfH+Fv99NIH5hdL9nirgzAjpfG9a1thxtNR+g3AsJwA3SOuNi2AzDT7IDWASlm78aCIzIGQ4AW49rYuvpuGNveZ7bCACY5UCaAjP65Go+A0ABAsFsnDQ8eF4mQB8L0eNFzRaVl5hCaNi4nVy7t+pEOE4iYex6wipyORCQhWOH+SiN1RrL7RqIzFA+ApkRfFuYAjb9z0m8N+gcCypmOBYTRdbk5GD5xzx/C1AAV/gS5180XP4eKQLV/rhlwJvuYiUdn6sGSJYNPQj816FD0CEnbkIDqi/QJPWbTYg8FXIrr7MSzzMiiRAMZr3idYtwD5FGGptJ2mo77O6Qb3xc5AzNnOct9kFoPmamN5pbCYUbVlgxtLRWg0THCmRZLzSny3DtZ4H66WI7sKROd/vvN9dBxk7l/6j0WPRCyMfJKgTuSaKO8eOJUuP7kUqPwAvEpYSreMyZNAR0KGQxk7eEBYHQSuVjSea4JHdcUp8bKMdeH2ndZNd8KYyfwhFgbXO1H7c/Nbw/K+HFnjEqH6w2bquZPS+X71e0ewDKW5yLhTQmGec9jrp4mBmWypMD+eZzxN4A7jl8DCOAWASGlM1jCmhpDaHYG7RPG9gWDfd86DxBg/xC4eR3BdC02W4Pmps9mGJIGZcAZFx4zSr3MLPwmBAEH4AEOv7YAzc4CjwDTGTQb4fbotwTbwHHPAMIjA/SXwuXCjUF7zUPaagPYBjCdhKCEtMaeT6UfjFH2qaLNEOoiWahUP5M3zll5m7jH9x4nhGHeuvdiHHmvz/hDJjHqfX09xntCCcRkDzzpvpUGRGvyyFD2ddnIeyRIDeCoAIEolKNgnOfJ1sv7U/aQKL2MHJjm57f3PAPEo6kldBcmlEcW4jET7nfv1Q5tCPxIHuRiGVOhn5SXlN8qaM/hXSzZa9N+T+89eO324E66h5VCpBbqXqMDmEMBmdo9c+K62nCvgyUdzyk4c8q6X+VyBmbOcpY7JsFb5hApLOx3koQrPbHOKW2HePokMkUOO8vjU1W+L++wcpbKscKXogwLR6x/zdibU9iORaqclrkGZFmcQaHklbBgbIy8D0YX0DB/9CnpVLjOyKtoXOfqU7AcKOPd8JMwg5NKuqZE4QfJtRlvlMW8Ne5+TegbQJYpEC0nOizIgx7pSfCJJcflMxJP6qtAklHf+rbrPvHXelFu9dp9P+U9IDtkRQrEvd6G7SyaK4vL5wmmh4QPXQqgwS1w/aGE7mGDzSOD7csNNo8sNo+E1DeXWnp4eFdHwhEUxrXBeD6psUeWQ5psuzEwFwSz93wh0r7+UoCj/oEDVpznCfVAvwV6xyGzfYmxeQLhffH9ZQawhcFAa6AJiP1zMWMAXNxn5LxvPPSVrjMe5PEgMPlMP64cMKL3HfZX3xYl5BsR7lVl6b73f/ZW+mEGLPBEspHhXlpv0/Cb0rh2a2lWX1hh+E/tNdwY9BcG7D2gOkUAbeRlNd57qoPzVHP3Oq8oZgKxdeAKhrVDPw/F4KoH3sgQmK10fw0oM+U1o78r7R853SizR2a9lab6PsPrs5zT60Dd8FDPkRPojEEW6KSL+u3sLbNKzsDMWc5ynyTdpCY2umoOhtqwnSNuDFkFvHhxcmq6UuaM5qoNZ9EGdgQgLPdu5ja7xOj07Zglv9NFJEqqllx5c3ISo3EhwFULtujrDiXNK8rSEKbcfVPPbyTjWgDYVrRdj5Gca/lSjpfUhXwwXgmeoHMNMjMai6OY+4qxmuPX0eMl480x37AxKOMzxEidHP+sFQP3UEMIUDSf1yrDS3nLasQCRBOxECp0aTEfjgdnGJJKO4B7HJUNZlAHbJ50aHYW25cNugcGu2cN9q8h3DwH7F7H2L0O2DwkdJeEyxagvsGmZ1A3pICO1tWafiIKIVEBMPIZjVz7yRnbprMwewOzFbBNOGOAbmfQb4S8eEiXDYCFGHj/rHxmOqC/Ipidy1gFDPPL/94MRMJSEAKIQpYHDw1gCJUjjLxFZCxTMOqpUwBJoVuq18/0MgcsDd/z8FODBVPvY2K9jThT+so2knSaB6vmPGJK+0ieWHbQd+zGoHvYwG7knfJuAGeYJHzMPEpSVbm5wY14XwEA9QSzd983FPrYbswQ/sfD/SFduR2A41WAfA6cUVKa8yPAymT6uTa83+T7/uhSAw7V9t+adbzGu1t/N9V/pfqnnvEMwhxNzsDMWc7ySpBjgCaZRTc6FaowhEvcIVFKUn9qc6icwCivkhQsmeFiiNuhyqhp/xJAZkJWcfdYLhq1s+WVvJwOMRxP5Gk0Kb66tMmFtszx0USy5FlW9lnk/ZQAkANnjG9PfJ9vY84df9F4OtTgP+R+PY5B8bqTeuppcGYq1GKpeC8kb+wkxuTiuekM9qhsL09ZOdaAexhnukkKTCremwKJpbXEz0EPKqiQG3fj8MOHNHUScmO6Bj67T3/hSVRdKEgDdA8I+9fINe2TXnnO8NA+TozvJNxPnsEBF5ZDyBODwBsh/6UeaCyD9hboIbw4/WAYc0OhTc2NlN/sxSBnEt4Ze0Pot8D+IQEwsC1h88iGjEnSpwiZk8Q7DQG8Ea8egB0ZCRtpF91gGE8a+IPywjEAWQKTz3bk32UMPozWwCVgsep38TjzpCiuP129ZIb2ar6yIuin+TTIZzPKg7xjbjJ5Bu8ttUSiceKL9c/WEGxjgjeScAzJPzbSz+zSqYMZZs8wvZCAC1DmirYAGRKOGPg+oACykcTewW4kYxn5OWQdR43rU7N3Y9OHtmFCp0nlwH3+YBDlCLpCdUbH2rqWgjNADODX1lNz7ZRuWQNyLtTlDiLrf5XJGZg5y1leaeKU/ZoFcGqx1Kc9U1kIcmWWiF3zN2SMoDnX/ANihSdlaqNZCypo1/VMf1cb8hnJ8TssCkEqeUudwsBbMH6KUnsqlMhJgLkKmQxh8jI3rhZ410yG47lT3lI75VQ8btcIlKk88Ry1sfQMnhehBqwt9NMssJG7b+RV5gw6l0pYPlxgPOZEhUAxIY7N94BMJmRnln8pfU/HkgPnfOQF6f+lXkdEiMiUNTiW80qaC2P1YSojY5HyQ92NN+HZANprBj4IbF52TXSGrN0CT95osHlAeObXgE1nhbiX/TqrDFWTrC80ri9K0+wM8mCg7xFAHrIM7jmE96EhSeW9s7holfcLHFizI1BvsHsdYfdaYP9a8fh5hiQ1N/WDLsANxMAnB8qwfw7Ha7MRbhsQYPaC3pidCWUE41yvO76PXdhTAKH0ewCidhM4gMElz9l0DeOAaNIAQLCrs5c6GTRKZZ0ShA/twuhZAv+Puj//vDNjsiQKhIn+9u1pCP3GwF4YB6C553SPzgZCBM2AhYBn7g8XxqfSuZP3xiIBOVyqbJ9SO4QreQCQIWCc7y/LQwr5fgBZpzxog6j3P/LSrfW2OFQvWXJfyWvY9/+EBILsY8vaQ4hDZKknzFJAcqZ57/3p71hU3itZzsDMWc5ynyXdwFYg2P73aYOgJntNfXmTRs9a9/bbkNzmNdfnJSWucKoxmfFBF8vDzyg+HOPP03uybSnI0rAlqUgrvPN13LYsyqqUNnvWa+w4IEtcpmpOTsGNbIeJuWoEfIi9X2JDWEKLMqS8E+Ft+brmDWp2VkF05RRQtRYc1aFdSxXpOXBgoRBPe8nMnSzeuTUxFYtgeEfeMRPeMnIxxz+T8LKqk/lkzAWPFkJcrzM+mxsBZ5jEWwUMdA8Mri4Mdq8Tw/XyhWFvFeA7szanGZzc8xID3CfjjobQEXJZbyKgJ6A/BPSMhiyaG/Hq8SFQnj/E7KTe/tLAboD+GQZ1Bt1LhO3LNBC9RuS+HqxwAIkz2LtL8bwBxBOHjcEGVkJgeteFzlNDwmE49KtthI/E89tEa4oDAHxIl9lbeUYfgaPCn8pcMQ54YbUcO7DTL1Ej7xn3bnL7l94bs15Pfg8OXiSuqckBS24tKe4nw2uIx7IDKyX9tUG/FWAGQODdMs6LKk+KDzfn9DrKks7cj5dGed9sYoAv1INhnJsAytjQD6U1qxyOlP9c7kn2KLWuj/ikDpW5MpZ4oqQhdbQCnFnrAXpKb+Hb9kQ+y6ScgZmznOWVIBmjaRWwMbFJVWXASbxDUl6JSFFaa+zMbCKnyNRTlGRzLfX5nGLopQYAy5UHYLTh1777HPfM03I7PRaB8XQd6TuL/+bEgDuqzClAtwRepXMkjecPf6dGVlTG4e1I06HqNiwSZfSOvpr1IsoYSiXgeK0XjeZI8M+beMscJEcKeTxEIgPY8+AEYmIaPlfAhNyogC8PFqyVJAwihG+E/nfN6C2aK4JpHO9KI9dyK14JAGB2kuXIp4GmdI8lCh4I/m/fDxG/Tfo+nJFPnR1STKderpbjLE+GACbJckUAt0YwFQbaK0b7REKd7NZ5VmzEQ4Z2Q5+A4eobPGa8CJ+JhHAJUCOGuukN2DgOnD3QJBws1LP0nSOn5Q4w/h2aAVDxYVRggHr3ExxAmRF/SWY8kwHYCrCTAgvBw9YBboH7xQMqJf1I6zv6vZHUNcq0BamjnGktAQH18wERWXUAZBQo5L2xyCKEnA2k6O4Zegzp4F2IHCyHzG5DWxCygrExEra0UcCM9x5L5psHDKkvZCZT5U9J9kAnF6aU8cI8WA9YugaW9F6FV8nfaq3K7QVLPHqWHjKUvIjO8oqTMzBzlrPcNzlQCZ8CD2KPi4zRNlv4xLW3YDCkxK23nb5v6pQ7C84kCkEx9CW5LysrY39123JtPESmQKpqb57M9zlX9Po2lcfFoqxKS2VOsVoxP+Zj4P2FCrhQmXKKfeGPoQ9o26wcu8wCKON/kuYHSe/zfZISAOfAkxpwJgMU1YJDtwFOnlQMADZgUvtHibvHi/KSGe07S0GrwrqgvVZoz2gt0F8YdM826C6Ea6Z3wEazkwxHm8cWzbUyUJPxwI0YvACGFOaOJwSEEP4UcbU4Y5g4SXs+tVaqfggEx8YAltFe9dg+ImweN+BWSF4lXMu3CWBmkCU0Nxy4Z+zWhPKEs2YAdqgXzp1+K+FPZAlNwwH4COIJgFNxIUbw884ymAwCjwvJvRyeZ+J9ZsJSSPWnhOO4MWY98OGe2/eZ458pgQXBe0+HKdG4bu9dM+lx6UEiYOC10uASQ815BdS4vjUutE1IlaG8nhCNAfKAoX4e7ZXVOGLf1oVGeY+ZQEYt/wLw2DuwsOcwbkpr9CrCdy8V6/6xD4Ryh0/z9ygwDVDvifNjfoms1F3WSE5HWJ2Z9Cy3Imdg5ixnuWOyaHFcAdJUbUwZI7IGNEhlsdfOQs6F6FYaK1GrJQdu5E70DiAmrSYCngJaZpSEnEISZXDx9VeWN6obKBjE8+15JZLBVYWhrTj5GhkUOe4DDaZohT0NEQHiEJGgeCojKwB1eVBwcQadVNaGJGUk8K6MPk8+MySny7nx7cGZI4YsReLfl37mXLgfVs6HW1T0ARRDOpkAMgYMl84YiEEZHQoymiduvDGDVRrwY4jmdwmhGZYBA3TcBP6OfiuEqZsnjIsXeyH+ve4lM9PIsw7gltBfNmJQ7yyoB2xj0D8wYCK0TwDT93HSHctCJhzahSInRjQWdP29M8zdM7VXFtsXDKgnl4Fq8PQJwAXEyG9uLGw7ZOxprzmQxNrEIug3FNYVJgFszM4/CIZ1wvpU5Ul/O6DDdAzsbPgugHUuXIuNAh/SZcFQ1A8eyNEZoHQa8Zx4/hgNzowPBjiEVg4hR2OdYs7jUu+hrHCX+B6Ip5EZ+peYYTqAe5aU6YYGoMT692NiTxrv7UIQ7xjjxk1jHKG1/AzEzx6UsQzTQ8iD9xzX03vAZzze7yNoXNXmibUzhLr5cghqTz1Az1wbrrtAfygd3JS8ymtC6M9yejkDM2c5yx2T/++//v/gcz/1u1bdm26e0+S+89fI9/OAzJoNe3RCfCSk/mBApkZSQyjdTDOgx6TBtdawym28hc10FuTSBvws70oZzFlqWC4dO7cfXlULeNa/iypANRlT+RN1lQUqB6bkQBmgCE7UnHAe1P8nAg/GZOPqlDMBJ6PsTH7spv2Re+dL1pW13h6HyG0o0Uu4GEwCQqX8DPqnAmWK99S0bbQvKWMbAygTpGc012Ldmt6IR0kvnjKSjUl4NnLt4cZERKqBXLUldJdG1tvrfFvSp8pybiBZU5RhSCwhPZ6bhHrG5QsWmycEsoz2Woxtzy8ixrwADv1lI1m9SOaD5zQhdtwyfjlx1/hwl+CFo/SFyAvJe1lEDyb/UWfRMLv+chw5jjMmIvINoTscwGbhXlFprTsJsxmyXw3PBkCFdY8z5A39nf14eAfhGeML68K5fXuGNYgbExv4BAFVQnY1B5Cz8MkQW3leD5a4voN7J9F4U9mYfBu9d4wAB7ptDOPeo9n7EDVHbJ0SVBf6LSVTvssHK1nS51Rycw0T7zjdZ2dC8FZJzYGf0hlzba/xdD97yNxNOQMzZznLK0UyhlyOIDaVqc1qJJmNoiYEpYZ3JQoRiEIA1P0z/DdHkTUb6pR3zYllVjGa8GyJZOb7CEibCOeo8nKaA3/c98dS+nIu6FPXHVJHkJpTr3Cv67N0fE+dnin3eCCeA5NzsgAa6PqPwiuz4PmrDP6aOaX5cXyRGpzJkQC7cRa8bo6lqCYhStn2H8Mt/jakkhtpMOwq1xxgDMro0Kel7cuGMGXGmm9vz9g86tA+xhCCBASPASYAjWNX1UaQAwwAoNnZ4MXBDaHfSgiJeLS4shy4Q+C80aXaPR6/+T6kXrySeEMwe8bF8/s4xMZI2Ir2ymBDkh7cZbIihiP9lSw/2xeEM8ZuCHYroU/tNWPzxMLsnFeQJwz2RnoK3Bppk2QFkvcqYbtwXjLST8QQDzb48nw7lbcfDTw+3JBwzDAUepQAXgnwRuk4WrjO6PdVEyYde1do0DfxupB4pnjPcO+IOsmEZJJ3Cd8/ZmC+YQ/O+P5pAavSom+uLJoreXdgwDSe1BghZMl0diB15gLgoETrlUfZnw/wOp6T2fYVgI3sZ/5P30fF/nF7qB57a59tZd8s0WFulZPxLFVyBmbOcpZXmNS6xeeMt4gJ/9DT7UrlfGTwlyTZRIuZZW5LlhC91dxfOnlJ5GiK0UplYUTeXNn30XibA2UK9UayKBSo/lqtLC8dVwePwzWeU+6e0O6UD2OmTZOg57GV5coxfnAb0qIJMSGoDwNIsv5MgsWL6qe4X7WxFxln8pMwAUKe0HCpkjVEzBZxpqKct8ycLAGspuZNCQS0zvhVoFADAMZIyIjnTyEWclvXJsla5p8FMDs7AMmNB23c5SHsxl2um6jfa9p+Bcp4MmFu4uejzjpOEgf69GLQB9LX1oAMBX6ZIUSHnMcNO6JgBzDdMNobhm0JN68F7FbCorYvW2xf2g8gimtXyAbkwUWDIXTGiOeOISthYN6LY2MG4l5HLkt6LqpwqBBhyQxmCqnMczICZFjpMpXJAkI5br4uKSNtSwTORF/qijkQ7+r9Rsh3bQzWJ+9fAEOVocsIKNNvhtTnZAG+ce+6Y5iuVyTYCoTJ9evMWnPXAZnqupHoBgp8iaT0+W3JLfTVaB7oerVUtqHKW+ksWTkDM2c5y6tQRjH+KvZ/cgE9lqtmRmpimI/qGVOSYz5jpUJ3LGLbVFL+jUWcP8n40PdG7yrnebGqsYW+njlhPpXcJtgX9dlajy2d7WJp2ycUsKfGBXRsJTSMXYr7Chh7JmlQeWrNyQEO+jPtyaF5f2pkiffUqWSNJ5MOY5oKEcuNUcqn1F489iq8tcYksBBwgJ2HCwmBb/B88l4Jnqej5wCOCE+M947hECbix5oG6cJn7ZDRibohC07EneIMcLj02L5uJsAYQnPdDaFWjj9Fnk2ACvG8AHyB7LhpfPthxFOmuSGXIpldCIyB3Yi3TPukh7npXQYm/35YvHXCcyGABLYVbxswocWAYfmsQD70yvDw3HIB5eeQBYxO1dXPz6O1vHTh74aA3mbucM0reZUo4CPykAk36jLc+7AAGQ6hS4AD1lwdbGi8PyhQBnAAYEcwBuBeCg+gj/OYIsugPY/m3Yh/6bZkxVp2FGN/wktmEfBS0BNPytOi94AT6kDH9qI5gzLL5AzMnOUsr2bJgDMAquNuq0Im0o9TEALjv+8jyRyAo4Rk1JzULSHiy/EOLd4oPY+AOtkvtSFPrLiwPi8HnBTFp5Dr7q+67xaN5cUgSYkrJQ2zmanvZLIgPr82mxwAjNKc6q8MAZvGGaUc35vynCwJyVHX5cLS0vCpVXKb4MzUWlYwDgIQXOMRp+zeCIxRKbW1HJPXIirLEAAa+D4Aea7ofcl/PlTJ+BAQRjBo2QK0t2i8QW4QMh817Ih4HShjNwb9ZYP9QwPbEtpri+1LHdpHe6CzoQ/EW8IkYTQC0lgigFp4TpMIJIK0nToLyoUI8+AR0tyolN9i86PZGdiGwnMyJf0TOlKexW5NNG88aNBbyRzlyYU9v4xPBw0Dyd7k+zo3v71HTSg8Hv9hnV5hqI4ygEUgWoNsunMvuc/Vnj0mz6VhXXLPS27oyaPrTTqZEzS8H3I/bTOURT6TEgwkLbq7zTqvqIYECFN1RJ5790DfqtU1JiU3RvxHuT4o7SEpcOHX5afE87Uqg2qFZHWgyj3oDMaslzMwc5az3EF5779563IC4DUuhgtPJtcg6VFGhUP2LevSWh5x8zkK+dkShVCd1uZCzkacQBPvdO3GtxaUWWJMLn7PpXeQCQFZ2v6l73hRyvXS+zmR63HNsx9Mpp3xKDiJknUEXqYaDq0g3ihqCH1jQNbA3PRieKbeLGnq7EO5YAKhafKMa8qsBWdOBeJMhAYBlaCxNrSXZF+qeQ8p2FfykMEAoGWz7yThJGw4jCFZm+G8oDjcgx5obnoQM7oHjeNzMTC9CVmJAAEuugcG16836J4hbB4JT0zzeC/hVZ1kpqIQmmhhdnCZdgRIsS1h/2yL/QOD9tri4vkOzXUfgTMR5w8D/ovgUaP6SfeBue4jbyEYyi8nDnzqHhiYTjI+0U5Ih7tnDPbPOO+Yq97xmTAsHAFwawTHgHjOwA79G95NeB/AFICg1+k12RkjrhfvjeLbBXsUb5KsF00E0OgHjoG48ByK38ehoOF6n/acmCOgDQRwa8DWRuFggRCaVfmvZkkBmtlDC9Vfx1pnD/SCWQ3QTIBTIx3oCM96DnOaljMwc5azvBKkYrGs9m6p9JaRayrKnmlTblGeU+6PpURUG90HhDfNglkFA2rRadBM++YBt4n+XkQkl5RTMkRTsCfz+dEAvRPLCMAw47m0WJmp5ctIv3Mnvov76wQA4LFlap3ItlEZeRFJKMTART9cmu2vHDijZQFAEDLNJPdX9632njumEVAxnkafVUhxDAZDn8efpZfygfuLCiOTjEEcrzMJp8J4vwNgrfNQMCCX0tl0PJQ3ajOHLNGAhPUAwr3SkHi0sMs8RCxEu/0WoAeE3WsaUH+B9roH7Z33i/sXuGosARtJi9y3hN1Dg+s3ELYvGWxfouDBI8+IIjir00dLAzn22FB9GIz8KU4xgktZLf3DewuyScYg9s+NACx5D4+m6wejEjSAQp7Y3GWFAqbBmeKzToWXzBnD2uNIz4la4FN5l6XjLHpm7zGUDbFhwJKEPIGcB5KFdUTT3ABgCt5F4XlLj5ZwZ50EZDiy5NaUp7U3nQTEOmJo0iFJDHJyzt50u3IGZu6w/M//+T/x8z//83j/+9+PF154AQDw+te/Hh/+4R+OT/mUT8Eb3/jGp9vAs5xUqr1m1m6kC7xl5hblVcbgTJ2nkMkNZiJ2d8gYgVihBcr9n3Npdspc1oB3n98KCFFj5BVAlGnATP2RM2TTz9IT8Nw1+vKa8XIgP88qBUSHeh3KD3SoguZPe1m9v1LI4itAFq8hLkVsMUQhJylIMyMjUMGfdjtCWe2pUczwcQSPokk5sQE2Cc7kuHlS4ASI+LGiIlIwbumciThMfF2Ztck7uZCEBZnIqB6vFSH8JHgyCDjDDqCh3gEgBLSPCJdbA7MXcObqQw2uX79Bc7PB9pHF9mWL9nEHc9NJP/YWDOPaIeX6NNZI6FDKWdWGtvmwqllvEB79ovqHXBahoVxiAWfaJ1ayL/USSgMj3j7WpXImBrgBzM6X5d6DS6XtyYSJpc+Y3XiicVOmZHY9V/xczAB1GOZ6unZOgDFjL1j3RzNv1E4RBvs5wHD9DQaMo0OygN0gpEQ3HWD2CrxyfRbC3HyZwYNP9c8R14NV4dIVcnCZub259Nh+rCXXnZRDZk7m6poK1QKmn/UW5a4c9txVuRPAzFd+5VfiXe9611HK+q2/9bfi/e9//1HK8vKZn/mZ+Bf/4l+svv8Hf/AH8ZVf+ZWz17344ov40R/9UfzET/wEfvInfxK//Mu/PHn9J3zCJ+Drv/7r8cf+2B/D5eXl6vad5ZUjNWmxS4Z1ym0y6Ra54ORUl18r2WsPNFj9cywOT8nVe0iYQCYjQKk92feZA1UOacvcvWsM+UO5NBA/+xrAajZFdg2AMnWyWtvnRwjHqpIE6GNfN5GANHPgTCYk5V6Jev40bECHm1DHAp6hxmiDWEA1oEzO40J/18ARyHrGTvnBoDHYmyveAzxLPG0OlRSsrliDs2M8WQ9G5OHWur7mMThbCPGoarsGvGdiE0aE+MCQWcqv070dmqA5JXwoEKl91oEmbNxnNHizmb3F5tEepmNsHjd48sYWTz4M2D8LmD3h8oONS7ltQb0R3hlgCGfZWzSGcPFSD9MZNDsOfEnk2pbzLgigR2qb1vRrOjxJDHzTswKgDLhz/DtWndoTYB15sgdmAMC4rFBmb4byM20j1BFnV4VyTOzv5MeKv0YBbIx6zjFuEuJoRtR/pVTbcjGSZxhASvYpuFV7TQdYVxf1DqjjYR5RzyE1dkhFfiAoMxfmeu/2jpIk3XKI18jivX/ioHDynqnrF4KaWVmrB03Ie3/6Ow4u45UkdwKYOaY8ePDgaTdhlfztv/238a3f+q3Y7XbV9/zsz/4svu7rvg5/42/8Dbz73e/GJ3/yJ5+whWe567KIb2GmDH3qP+fmOudBccxN+hD3zIPdO/mwjRmIQaHo9NKpXfJ53KenOn1aJTUcD1N95I2uXDn6vsz3a8K6Jt/XCbMaLJ0n2XsLCtAacCcYpqpfD/I4uMOiQZhovitjdUT6GxWgtNc5QKYSgPSATEjB7KuyYrEFcMa1U9qf1KNDD6bSa98RyY537VmWgq0TXDO5Q4VoXSwZJGoe5jhLonYoDg4mAlpJm+0BiPBeev/TRvulBz2IAXQMYyyaa4RQoP6iAS4amN5KlqN9j7azoH6DzcMGzQ2heyheJN0lsH9AaB82QsBLFLIX+RTTZBnmpsf2RRPSU2f72/e5ByqJB3CwUkZzSf3KRgiRu0spnzqL5tqGNN4hxTgAJjN48jkwp3vYAEQwOxuyWsEBqKbv4flTjkZSO7PWRXsGq33agzMFEHU0H9Vz+zAu/3uQCaPWrwdTQBp1DGNZwDs4r64uAZUwjBko8KfoqbdQTs5FdiwZkbHHz55NF12Sqfc2c2tRnzvU0zYpp6jvxnjfWe6gvOKAmS/6oi962k1YJe9///uzoMxrX/tafPzHfzze9KY34eLiAr/8y7+Mf/tv/y2urq7CNf/lv/wXfMZnfAZ+4id+Ap/+6Z9+m80+yx2RdDOY85xZFS4zt4lnjJSU4Lbu1Gvqu/W7iT69A2O8ESZEkbEin6n3gCwQQ6OS8mpj1lfVXRgTtWFUmZCDWY+oEpCTC2VYImtOk9bWUVOPOuUvASeLldYlSnPihZXLnuZP7aPrjxUuc5vZghaIPhFOPSK8UR7GfRSykBZUAUamY9rPEU8muhFDX07kEQylYbwM7y0LyvhwlTQV9YmIphdJTd3pmAyodAbcUuFOi0+YkVnrVB95EMZ76FAutIpUauyGgL0dnCecQTt4VcQGHTuOD7NzAKDPUPTASEanPWMLiEHtDPbNyz2e+VWgfUKwTivnFtg9awC02Lzco7limH0f6tS8ObY1IZU2CCHdMvWI123f7yvW3GDo+XXEjUsmoLsg7F5DABu0Twzaq168fdRaSLbBkJVIUmfbFug3BLoUkmSy4k1kdlaAMs8rAxT3/pzXqTZKpwzu6mQGvt2GXJhVJltTbk/S60LqCbZmvtLA2+PXC+oAOI6eQKIMaS8bN369F417llV6lFrjby3k+hhSqSNU98kBoMwhZS8ux4MzGNaFo8sd3PNfCXIngJnv+Z7vwdvf/vbF9/27f/fv8MVf/MXhbyLCV3/1Vx+xZXn5pV/6pUXXv+ENb1h0/W/5Lb8FX/EVX4G3vOUt+MRP/EQ0TZyn8PHjx/j+7/9+vPWtbw0AzZMnT/D5n//5+K//9b+euWfOAiBRTldlzpgHAKYyPOVkntR3tohVEp0clE6sIuP2NO3QknW7XkoouFYOPZ2p8ZzJXZt6xaRyV/hPVirNxwjhmpNiaFuN5Eiij8BpE34+LUWtZp3SXidT4UAFbqVZUeED/m92IS68MegvGvQufbJksOkRkbWukQKwfHSZWi+OUac2Xp2U9i75srz+aM/RqBz/mfeMsRboAW4aSQVNjkTVpfv2fDEjLpZMmJBun3CAEMAW1ItxbLeNZCq6JDQN0O8aoB+8GDYv79Fe9Xjwa4T+ssHutZLRqHtAYNPAe+2MvBw0sGARAC0JnzKghkF7BG+bqK2HznsfKuNACzau63zzDIWQQekPaT9ZoLmRGEE2A2GxB7FsS6CehOi4gs8j9TQL9fk2REBSfo6UPGnJtTlNV06QPo5AjjSU0npbmAcwa0Jy+pr2qh0udICL6jfv0aUziQWvqBIoUztvC2tMqsvdSW+ZY3mgVEiUDXHJu56SQ0D31HPGg4vAYXvOGYw5udwJYOYNb3jDYvACAP7yX/7L0d+f9Vmfhd/2237bsZpVlI/8yI88Sbkf//Efj7e97W34wi/8QhhTdjV9+PAhvvVbvxWf/umfjs/5nM/Bo0ePAADPP/883vrWt+L7v//7T9K+szxFyRhRq5jSK5X30cZxxMVYb+irgZgp1/UaV2WnXGeN3NxJ2Ak9MzRAM/y+sG9yBncio2fNPNfSerM8MFMcETkJngD19Z5MVozzEV9GaU7OhFpoqQ5XypRZJJu+DXka4EwtT5D2OvFnHWl7MwDB6O8cuDg1xgmwjXgI9Bdy4r153MvpdnLKH4rVYILXprWnTK6+NR5WS+6pvDa7hvg2l4DZxJjJrlVI1phiA+KyiDEABI5zQ4ctgSy4aVzYiQIZybdRgx/ldS165p7lA9fPprcwe4P2Ri6yGwIuGzR7K+Eoux503cl32wbEW7Bp0D0g7J8FugcN9s8YbF9qsXnUSZhQYewxAWhIiHMtB8+cUd8u8QiMKgj/SfWWsX1kYTpCey3hNOIl1IBb5y3muWU2jrC4YzQ7AWfIMpprITrm1qC/MPBcPTqqMNvPvq/TJlqWtNcE8EaFenUcOHiqHtV7pQTPgxx3jxofquyITNokQE6m7zWIFQEyM6CRJ07WoXUwDkwMbVN1L3j+Ir+eK+NOgjFaKkIcs7J2H5vQx1fxLR57Lx3NpYXln2BvvzeeV7cod0EVXiVXV1f4oR/6oeizP/7H//hTas3h8s3f/M342Z/9WXzRF33RJCij5VM+5VPwl/7SX4o+++Ef/mHs9/tTNPEsT0v0Yhi5a+fAmvjfZFm1dU/cM1vfxH0HyRqgpPaWNRv5EWTsZr2gX9e2L/N+l76brNLvDbGSAVVSCDIhOEcX/8yFsU2cqTfXv5l5JwUoZbhUb0HSuieff2IOzHIpFdaUxaJPdvVna+bnKe9xoIw2ZsR7IjG0a7y49LieGuPR9QghLZJWWLwYJNyDxwqy6sNw4m+M/NPePr79uXdY815PBDjnwvjCc1R4IEXjfun6lCnfhwxBpblm5RUD7xXjuYD8CTP8mMk/z2h91l5Z3sBmASLaqw6bRz2aGwEu7MbANgIaREa0ZTRXkpWpuQb6S8KjjwA++DsIL/3WFvtn24GzxZezNeEzGdcK8G/cNSrcyfdHWG9m1sShHz3AhaF/9hYXz+/xzK/ucfH8Hs3eAgawW4P9wxY3z7W4fn2Lqze0uPqQBrtnpR3mxmL7Yoftix02L+/RXO3RPNmj2dk4TKz0vmuMSveO2c2/yWeKPsSoXvH24ejZR9cl4XS6f8mBJ/qQjd37HziozAiUicaYC1cynQB61KmQKjOE34VyGxIrT68xJwBjDxJD8b9jSzq2T+mRXFjfDg5rXiOJB1fuX7XU9tsCyepZZwFwj4GZf/SP/hFefPHF8Pdzzz2Ht7zlLU+xRYfJR3zER0is80L56q/+6igj0wsvvID/+B//4zGbdpanKQtOKZkw7W5+C5tsUWE9JReIlql69OMbZdzkFILbam9Oigrk+O+RAXOqd7xgE59VOkpl2eT7NXHwSyXp60lFIde/ydhJnz1SzifKCtdowy5T3hIJYIlJfuZkIWCUrceX42VtiNWKexaTemv3fmSM6xrJATYz95IF2isroRzaKNaShg649vmUuCVvkmIZOVn7ng6U2fAxdc3UXJwCrLNgiXUgmHWLjDFAa8CbRjIJqeu10UKWR55NJSMyBzwFI8gR/jZPOpgbBzyQgHTekLYbA7sRz53mpsf2pQ7bR9Le3Rs79L/tClcfxugvnLHt6hJPFM8Uy4P3xN55BTUulGprhvCW4GlhA0hJvZV/FeCMBmhMZ9E83mPz0g7N4z3Ikf4KIETot+Ip1j0A+ku4NN+M9qrH5uUdNi9co3npBubJDs0LT7B5/lraHtbDEnhSMW4dmKKzEpW81PIPO6wtA5AH5wHjyH01kFI4JAMgIUfpOqrLCQDd8Hx6TDFJGWbfw9z0kka9H8aS3TSwF/KPWxkjxB6MdGVWektPAaNHlaepZx1Bivs71h1Y3qrU6IuZa/QzrwVWzoDMtNyJUKY18gM/8APR31/2ZV/2qkwZ/cwzz+BjPuZj8LM/+7Phs7k022e5H/K5v/c7n3YTZqUq5CIbbrG8rmqiPi1TYUinNhwPkRlX2pxXxRIFoDrGGRgbm5pLY4lBPOILwNM9Gsi802rupfT+JPYeqB/jUWx65rvie6oIsQvhcYfEqpdEGyaslP8V5Rzj+uz64MM4iCQUyHOnMsvw5RmumRxI6I0kxvQ8SLhq2IVPNTcMsxdPmcjzpWadqn2Pd4wHYDSOC3xMOiyyqpwJKc5lb2AnGbJGBohPLY3x2C6FEU/OVYhh3fhsRZ5fBXChNoi8L2hv0ewsmiuD5lGD3ojCvn9osHncon20F8CnJ5eOWbWHpS4YBM8JBsHA5e+2HJEHSxsB6ntw04CIJqdzNNf8HGPJcgXL4F4ALc8lY10aZybC5koyB1FvQbsOtOuAfTfw4DyyaJjRP9xm+3BufR2+l/lObIexMAX0RIUgehd+nRMAJX5+7jnmnNF7mhpTY6+JmYHMPlcjh+cNQIxqp8/0FsiqWULnBg6jZTpTdt7c5nryNMJhc20AFrXjzgEw6Z5SepYFz3gsQOVekUc/BbmXwMx//+//Hf/yX/7L6LOv+ZqveUqtefrStvFrXJJy+yyvEPGb2cKN5FiLY5ZoeOLaoRFj5Vy3L8gaYCQbpnKkB64wig+WRDk49sa/CJzxUskdU4yn1jwfQPz70kw4a6RiflT3yUxZtTHlJW4e//ksOOMlHY/+z1MoQMmJcciecsicKPXnyDOhsg5vMHrxgIr3mrC+gym6JpIK4yn6mYrrI9tKSmHbAKYjmJ1waxBUaEPNmuKvOYbxcsvGTxaccVIz5zQv2aJ1y3s8NJB3DoTwjrTs6H0nPDG+77UHRcojEq5LJYQZMbC3aHoWTx1DIbTOz3chdpUyzJ7x4IMM/CKhe2YDJuDmdUBz06C96kC7Xh5FhTZpAALWgRPE8OF09kEL2xJMJ+m2qXcgiYEDMhicrtNT49L4XhiuoV7IrU1v0V4NcwBEKuvSMO4jsCHwEZWrlP6f/h6W5f0wxVFJS73FXL953p7Af8MQMMvCJ7wHoIiCGQL+TT5EskaNnll9nxmjqaeXB549KDPn/VRs1tMGGU5xkLC0bv/7TCj/nZFcW4/Yf2cg5fbkXgIz73znO2XjcPJJn/RJ+MRP/MSn16CnKMyM//E//kf02Zvf/Oan1Jqz3IrkFItK74pje1VocCdcf2zQorasiXrTU/SqMmeU0aclpQ1yFdBSkOhUciZE46A6cx4zxwRknvbJm5PqeRSMvvj71e+W1en+yr4YeWR545QI3MoLHKWOzclcKFWFZLOUaJtO8ShkCWiN68g1AG0JRJ4gYfWeGdxKRp7uErBtE9pqbjhwfYS1U8vUiWcCGETyFEAXYH6Mllz+TyVhHXOZlqSj/RgBBEzUN8RAHUFlFvKfMceeaBPvLJu63vOUwIJ8KmPVXm4cuOLAjYsXgM1jQndpcPWhBjevJ+wfErrLBm0SkodGQBLqhs/JMmjvCHlbQn9psHtNA+oZF88D7VUPzizEKZmxnv/ZjIJJH6F36bqVaE+TsN41BsxD5lF+5sIRIHOx/Frx/Sh1Zy4o6QL+I8UlFafdHt/CBEQQUK6+xKtployVE+8kM/ZkYrc/UwcHRPHgJXNH9r+iTIVh3vW2P015Cn2UO8g9LNT6sPa8kuXeATN93+Nd73pX9Nltk/5+y7d8C37qp34K73//+/HCCy/g2WefxYd+6IfiYz/2Y/Hpn/7p+IIv+AL89t/+22+lLe973/vw/PPPh7+32y0+4RM+4VbqPssdkEz85xI5tkvhYnCmUvGqCmOa4te5z7HMhVObpSEzuXtrrssauAUAYZGsCWNa8h6nlJapsJHCfXP9fGxQLFd/sY4RV47PIrLeS6wE6Pr0wQPZKCMLdNSeTC8FZfSaweIJEFkrSXkpyBg8J9aG0Wnj3XsWmPhzMYJNIOEUjxmge0hgw2hvhFPE7IZMKtUhiel69pTXtjSssmZPqZ0rtUDO3OFDBNAA8Xgtee1pkuVwLUfAxJT48crak8SH/oClsrTd/h7vhebAGeqlYZsnwtfSXwCPfvMGpttg+9gKqfBVP2QoGgEAjhfGyHjsLgimh/PakbzO3LYRQW0aYkkY98ckeOLDt1Q5pPqVCUBrAJbQKXvZDhw4qv/kERLvpEqp3SOzz5HscSElOZK/lddLeIdaHNl3CPUCsutWaUzF2doKQJhVKE+lTnhnDeNTgQ0F8Hq0duj19T6BQ7fc1js7fl4Bcu+AmZ/4iZ/A//pf/yv8/eDBA3zpl37prbbhb/7Nvxn9/fzzz+P555/HL/7iL+Kf/bN/hm//9m/H53/+5+Md73gHPuqjPuqkbflrf+2vRX9/zud8Dl772teetM6z3JIsdFdfC7AcCs6cKl5UG6LVxuWhJ/d3VSrHwjG9ZuKCaXSaPGUgxYZ8Mj687p1wcAw38EgplvuOBMroqip5i1aP75oYb5TfW9p3xffrlUmlVGYz/ZTakiiixedVZLSeXFLIUZN2pPUdWSJD2xk5qdt+tp/8mGuSvxdKdjzrOowjdN0aF8IBmA4wO/kZ2qpDocJYLLQ9eb93WU61JxTXHOW1NLsGBlLsiQZ68MABBZH3wRRXw9S7SQ3x3gKseJqAmL8EMiZsYyQMrpV01BcvMnavITz+zQA3wOVvNHj2lyEAzp6jOqJ5zQB6htlZbB/5tNXW1WkCR4lP3206lVJclZeumTnvGe8pJgCx75+kXZbl2b3XXc8CmpowuQfw90Cjc3I81M4pCxDb6KMieOU5lgOYDPEe0t51HpwBRp4zS2TSS3DyPt/G9XWfSpbqMUvAJ+3FtmaNuhP99pT2gbs4Vl6Jcu+yMr3zne+M/v6iL/oiPPfcc0+nMQWx1uIf/+N/jE/6pE/Cj/zIj5ysnh/5kR/Bj//4j0effdu3fdvJ6jvLHZADFuOpRXXqlL5m8wonYFpOgeDXxEx7Dgb99x2VkOmhRg55jgMIVsN79Z4yFe0tjhldhnITByCKuy3cd0wJ4EJiSGQkN/6zYz1XR2WfL/UuKGZE0Ibj0rm3kosAvfMA8IbrAWM0+0z6XeVOo+E+q1yjwvU141h7AtVcn4wnbgndgwZ2a0AdsH1kcfGCxcVLjNYRoEbtnvM6Ag7u35FMeY5VjmE/H9J5cagSX+M2P/CpcPy+ZtoapR9Xach1BhxJX+xIVRVoNjlf03nECIZ5uVHqWXRKd5exyW4N+ktpS/vE4sGvd2ifMPpLxu71FrvXAftnCP3GgDcuJbZ7d9x64EeAINNZbF7e48Gv73D5wZ2Q8/YCEPRbg/3DBvvXNJLFyT+/UX1CqmwN+th8Cl6/vzGpdNAuJTQ3JgCY3A7t5sal9t7I54Gk+ZT7uGo/eX4ebbxPja3cwUK6jzmwJpojo9DH8fPp/pO2FFIer9S1XsmGdlmnjcH7gwEgvVYu2Pd1mbV6diT3yZvnLIvkXnnM/Nqv/Rp+9Ed/NPrsNsOYPv7jPx6f93mfh0/8xE/ER3/0R+O5557Dzc0NPvCBD+Cnfuqn8MM//MP4uZ/7uXD9Sy+9hC/5ki/BP/2n/xS///f//qO25Zd+6ZfwtV/7tdFnX/zFX4zP/uzPPmo9APCBD3wAv/Zrv7bonl/8xV88ejte9TITfnFoDOjUKefsCUbShnDtqTaPkhF4lwCZmVCOFBio9QoqksImHi3FttRIJhwkHRtz4QOjk6WiUe0uzBwTnMoDaM793tctF3MwTOIyJipI3/2BBIIll/yq0ztf98r5UHy3Lo1wGLcZwGt2TM956PjyCqAMkzpNryR2zvXhpIdXsTDt/jCAjHJiTrANwW4FNGpuLNorRnMjHgntdS+ZmXo7MuxWe4lNyEHeKwcQDZf6cum8zoGTs8TLQDEkgZvx5zSJnsR1Dp4Rhb6xLFmdPGhI/jkKITnhWRCyFwl4ITeavXARNdcSdrR9zLj8oMH+hmB2QH9BuHl9i2bPMDsWYt+9DQSw1LmQOZ82em9D+1k9g20BsjLfPIBFLuIqhDC27mF6BH4kAMLFU8E/ozpcQpSEvVjucWnDhVjcXWYJxop3Ebm+PYlEY4Gdd5C0M7zvEr+U+jtkUrIEMjwAK8YNgzTcLNpHF873Vyggs7R9VdfX7sET5L8j/TZ8rgAZH7J3AuLdU763exfy9gqWewXMvPvd78Z+vw9/f9RHfRQ+4zM+4+T1fumXfim+93u/Fx/3cR9XvOazP/uz8ef+3J/D3//7fx9f//Vfj5dffhmAcOJ8yZd8CX7hF34BH/7hH36U9rz00kv4g3/wD0bcMm9+85vxfd/3fUcpP5Xv+77vw5//83/+JGWfZUYWKsWHLqKrXdDnQggW1A8caEjcU6kCZ5LxEPVTEgpxlM1c1Zc1jnLtAEYg0ex7TXlDWCvJEymNl8gaI1e/j7n7dThR+vnatlUAZMW+KbXDn+ot5dKZCcsKRoU3YBzPTXFMT4EyGU+ZKfDvWNnWfB3sjLGR4VXNiQUxMJ1hx8Zlo2FnMDtQJp2/VfwyQH68LDEEJoyPY8sUOOO/L92XkwCQeAPXYAB4S+D0Qk4pATE8eRCGVM65tpXmhQZn4NpIAMNE4zXig/IhRy1gGwlfIsvYvtwJAW9r0D0jxL0Pf8XCtkC/JdgWuP4QA+qB9orRXjM2jwnt4w6070EubGgUmmVdzR2j2Vnwlc8S5RuHgSPHjWN24UwGFtxTIJwNRMmZUMoxf0v8p553tnX8TH7cdFZCrBSR8CkNVc2Tp1Omp2FKgBtuGUCPGAGc8R5TAZzRhM3s3r/i08nhdrWeMZNzZuaaV63M8clkwBl9X8S55jKbhbTplYcFwNPVeafqPo+d25d7Fcr0gz/4g9HfX/3VXw1aGSO+RP7En/gTk6CMli/7si/D+973PjzzzDPhs0ePHh0N2NjtdnjLW96Cn//5nw+fbbdb/IN/8A/whje84Sh1nOVuyHv/zVvll8RlGDjOIj7lQrnULX2JK+ZUWZMhGnNyRONizq24GIJUCgmpDBWpPTG7lQ1yhiukisdhTqYM6orQhKLotmfci6cMeWJvIC0EG9d6NyT31YyBXOjIofWW6kgl50qfgjLhdJkyz1NYx0J9KSgTVU7Dv3Dj9GPWPle2L3U9tXPThWbYrZD+2pZgN85Y7dkZY0kdI8LQBcDL2jC0uTKPKHNrfq1oUGY0hwvhZqW1PN9QDv/IMkwn4T+hjXMhbRmC0WGOQEKLXJps/z2sS1ft6gzPZ8W7hboBhPLASLNjXLzQ48Gv97h4ycJ0gG0I/daRA7ufdmvAGwlNstsGvDXgrYHdNBIm5IxO6i2a6x6bRx3ax86bKwuYSj1sXFsaN9d9nzGy4zG8KwdSjN6FWqPZlR+8dibWqWMbszndQ4c2CTcUorDbXChfGO/pWunHLxBAmXJbjhOulLbx6FIK37ktj+VCGFFJvx19nh5YTNWhfmfyYAyFuTBUcpxH83Kyd6fKP8vdkXsDzPz0T/90BEY0TYOv/MqvfHoNmpDf/bt/N/7CX/gL0Wfvete78Pjx44PK7fsef/SP/lG8733vC5+1bYsf+qEfwqd92qcdVPZZ7o+sBi4S0YtxCRU/xN381uWIikAuVj4n0ec1fBBHBGfK98d/r1ZeZ0KxamXwalAfatBljiNCK/xLZEWbR5wVQD3IpOutrTtz3Zz3x0Ex8Wl92RC7TB2ZMKXR+0hAmazrf0GyruH+s6myvOGyYg3M9qM2EEtATQ6siYxvg+5hg92zBt2lywKVtN/zdWTX2hwgWvJ+qnju2TFwi+CMNlgjr7iKqvTcJGvj+em5YczY6yg3n4rGbuq5Z638K7U310el+U8k3CltPIaCoej5mlT4UePCkey2Qfewhd0aCVPaWTQ3PZrrHu1ji+3LFtuXGZvHjPZKQplsS7h6wwYvf8Qlnrz5Et2zmwEQCsCK43chAu17NE/2aK67bIgdIPfYjYQb9VsDu20cuAMBjwprV+w15OdM/D0bcoTB4lVCvfMu6zgAmlHfn0Cya58GZzyI5t+RBuwcFw63BN44bhxAeIM6Ds8x3DMc9kTpuQO4UwHWzsnMXrSK20SXOwVk6J+nkhV8LkGYy/O4BHYnhwYyf1R4n9XeXOU+yoFGT1t/nqr/1MDQWWK5N6FMP/ADPxD9/Xmf93n4zb/5Nz+l1szLN3zDN+Dtb387XnrpJQDi6fKTP/mT+AN/4A+sKs9ai6/6qq/Ce97znvCZMQbvete78IVf+IVHaXNJvuEbvgFf/MVfvOieX/zFX8QXfMEXnKZBrzaZU5DnXDEr5RA+jyqOkeT6WmXcuxXfKf6YQyTHj0OoP/mfCD1YC6odWu+cjEAZ/bMkPnrA8KDMl7iFFso8/8FgSMyd2hZlal4uAW5qQ6FGp9TDzzAWDuCb0el/hZw0HcMKQDEAQOCeHTfvOKQpuz6YCTJsHabileoDjbTiOlTT7z58huJ1iVvC7tkGN68zMD2j2Us7a4DwRe9lDSizVKbc+yvbkBXNLeU/Soqq81JD6P/RPF3iSWQkDIcY4/eqQ6TU5yWuiSywGkCl5NrSAGZEYU39RgiAhTtGnsvX1dyId0t7JWV5zqXuGYPrDyHcPEfYvoSQuQkq05IHZ8h5IFHP0g/IrJEkvEnaCOXetWO+h7NeBCGMRwNqrn7qlNeQ8yh6aoSnLqwJkLUsyqgU1jsMZMnudwPrvLuS8rQHkZdTev8fI1xxbm1aGC54FEn1gWyIrWqDtUGvIA3sOp6jyOtFlzfx7N6LDQ5cDWGwUCGKiQsEP61xPCNn8OVuyL0AZh4/fowf/uEfjj67TdLfNXJxcYHP+qzPwj/5J/8kfPaf//N/XgXMMDO+7uu+Dn/v7/298BkR4e/+3b97K6nC3/SmN+FNb3rTyes5S0ae8gKeNe6OJFNgztQ1tw3KHCtrUmqIBqUUmDQwa1M6L30/T+20RhtlUQpV9Xua1cJzGJyonV7pH5SqjAfDEpmbt1MKZc6rJf0+d31BAR6BD85AnO1L1Y5sWFGqtHqj1UwYqGtCMfW7Z3X/Ad4yXo56+k6De3t/QeieAdonJIalOl1P0wwHWelhNyWTXFNry84B5AvKCm1KvI3Svyfnu/bAwMQ+sfAZw9qcQxE0OAN1nTPGgMQAS+onK2mo1c3C+ZJyDSXcJrAyhnwWLyYArZEtg+Xz5qYXYMaBANwS7HaDfkvYv07avX+B0F41aC0PoVEtob9oQgiVgVVzlKO9z/Mm9dvBq8XcuC+b+H3454iAVgfcekBVhzf5UBDbEuyFcOU0fS9hXCNAy912Ap0kJ9yYaJ2JABrfjp6dx0xyr6GBUya3Hqa6hQZsuLz3r3r2if2h6t5D5NTgjBLfN3r/TkFQUu+DALAlABYEE40vLxpIkbWLA1+T9yLjBugfGMACxoUgkhWvL/Zrmc7w5tLRP1XA8Sx3Uu4FMPMP/+E/DGS6APBhH/Zhqz1PblM+8iM/Mvp7aWYjL9/0Td+Ev/N3/k702fd93/fhq77qq9Y27Sz3SLI8DFoO8CKo9Vzx7ciFydTwz9QqEb49pVCKp+EpoxXUHKHhJHCiFBL/bMSIMlhMcSD4GHPv8pymerwV5fQALwsAY6+CREIfDFyb4XPAKU1N0p6lbUmAjGy/u3d1ECCT1pVIZCTr5ziB4pqd2ws5eyLumFSieH5P9CtGCsF7tPBghC01CvzlOUMs8D2s67Mc70BuzQleFKUxrLwo/MmsJ2xtnxCaG3/qj8HA1OSf/r3XgDIrvVQOAmSO7dml2jQ7NhUgNwbsKfKWWdKuLPifXBN5N4Hi96/bqYw7kKsrCVEL3hYOkPDtEqOdwzjLCgug0zjOF9tS8MqwG+FiMT2juWa0jzvhw+kZlg3MDePiBXZcR8DN6w2IgYvngc2TTvHWiHcHXTSyPylUPPJo2biwjYZcim0H0CR70uxY0LwpUIZtO3gecAB3LXxWq5DBaeia0L8nExW6Eshc1d4NAGwxAFOMkRcU6+/StpbGlZJ07aw+LKsIWbwVUEaXc2IAIhe26fWmAAYb58liNcDsfurr3N9+nAdx6xJ6K+NA6wxe7MAP5AEZ2xjhfGpkPJm9RXvdA3t72mxjZ7l3ci84ZtIwpq/4iq9A2959TOnBgwfR31dXV4vL+FN/6k/he7/3e6PP/vpf/+v4uq/7uoPadpa7L5/7e7/zVuur2aT1BjUH6BwtLOoOhC1Rokz6z7Ss5YZZklEmreMYfTX5nrSyMGPg5Avn4edECNNsHywEFCJZo/CYtJ8r+zVRoEvzpRg+U9OehQbwIslxBxCguSEm35VTbAOJ6QpQJh8K4gxg36eM6X6Y4D8och1hpsyKMehDuagH2mtGsxPPgqHtSRmvFGX8kOcocAeFrzm5NgFllnh+ZauvaXrOeLbJP8+xorkrwrV+/Hq+Em9dZ9pmknnGHNJckwcpGvlnN4R+QwGwCcKA2VtsnlhsHjFMD3SXwP6B40Ch+Fp2gKLnPkqFCRLG1Ax9FkKtUpkbCxrXctws7EiyWVskYd2ZLu7UEhGcF8DRWV3I8c8Ux/rIayzXjoqxmlu/DwCwjy4n1uXyXtjJ8/s+Nuqf/nxU6BiIjf7W74WTPcrPWeUBPPDTCFjjPS3PchYvdx7d+G//7b/hX/2rfxV9dtfDmLz8+q//evT30qxJf+bP/Bn8tb/216LP3vGOd+BbvuVbDm7bWe6fVBvQTmpDVZZ4zaTlvhKkKk11Qcbu3jT6PvWaqSknbV+VLPS+OMTTJh1b1WNiBtzK18Wx2/ihOkxy4hlJRnHUnlFrxknWM6D0TufAman3WvhuZNii0IdzSnMSUhB95Q0o70GyFrRNwwUiA3Ia6MmVk0qW60h959sVvetUMU/blHxOlrG5smivh9TD5A1ry2WDtqL990IqPXuidaMU1pSTJIwpkgpvutx6VVxXtNdUqGMMmgRpCGyMePil7dOeh8F448EbIyNDJh+pmBoCXIYv24gnTCDM7QU1MbseYKB90qHZW5hui5e2DXavB0xP6F8kbB65+l24Rb8x4qbivWGSfuTWwF4Y2IbCWG5uJEwDHoQFQKoTA8hDw98BnPSeQg2hu2zQP3BlM2D2wqPjwwL9vDnFnJjiwYuvU16rfvKqtYoZEnJmhr1K88bpzFzFvVKPax3uWHjuqkOZ21xHpsJxtaz1nCmVOeHtpr8PoDljen3JSWbdJ5B83AsZt+deCut8P6z1xAxq9f0ODN0aIbhWIb7FsTj3/LfgkXSW25E7D8y8853vjP7+tE/7NHzMx3zMU2rNMvmZn/mZ6O8lZMVvfetb8Vf/6l+NPvuLf/Ev4tu+7duO0raz3G353E/9rnFoxUJZYjCX6lgK2pTuL4VBTdUTEZbeAa+Zg+TYm2auvFtyEz4YGFGKpzaAidnFeivxCpF1DfDKUe2YOKBPDjnFmpwzmjx0aZjYSt6MWZB2ApByZBbzYMLS/poyJPT7VfV6Q6U2hNLL5LUpWGVVKFbh2qx4T4eO0T7qYToOIScBmOl8+xODq+advhqU7iSEICeBYNrfkr7n3NqQzJsSOBOVk9Q58M4oUCbxgGEYELE0n8scObLWYZE3SOBm6eXxmx3DdG4dMcDutQ26Zwy2LxLaJ52AJnuLzUWDzROD/bPOI0YBZ8QM0zmujEa+I99fUKf7htBfGMFuHHDS3PTCk2F58Aig5L3pd0Wk6FClbHvRSLsfSBvMnnFxIxmnaD9kP/JzXr+PY0pxPVFjKYAznnPGf+/C18i69+5CVSJQxmIIY1LhjxqIjIFKJOve8PskqD3HT3YqyekipwBnlpaVCQflqe+d1ADG8r4Y6C0ay+AdwjsNHGhufHBjhkxePWIxGEKtsOLwKeX8etr7xEwI3W1xQ91nudPATN/3ePe73x19dl+8ZX7u534OP/dzPxd99pmf+ZlV937nd37nKN322972NvzZP/tnj9W8s7xKpHiqsnLxXnTaWGpDRnJGUFRuutHPGLT1hLnrvWV0PVXlz/R96jVTJAmdkVMqsGn5ub9nQz6W9ndipIVxocfELSgj0XvIjT916pWTHKngKrkF5Ws0rrWRsUZq2jzz/RJQZrW4dlaDMu4z20pGD26dgelT4/YSRgLtLaPKfzUrqDXgZSrVfGYlI9XLRGhddJCQG5MGYJvsGyMvqkLdCUcJL4zTIXZeKkwgRwpMDHQPDK5fJ2ERzU2D5rofnqeTNNqbJwTq9Im+cGSYzqK5sQIiNgRjyBEaD6AMyN3nOTt6C7OzMJ1Kq53j/BkBDhQ8hLgRsGf3GkkrbzpG47xkzM6C9n14H6FfC+Ni7Xyquj4zlsL62Hj+EgHayAMqqQdUGjKZeH0degA22fZjlDF3cDCxvud0mrl7FsuqAwvlqZbxusl5murvw1dWEFMNOAKxtxMxg3369z7O9MijsZVp7D06mBzp3omO9mre82rlTgMzP/7jP45f+ZVfCX+/5jWvWZy2+WlI3/f4k3/yT0afffRHfzR+x+/4HbP3vuMd78Db3va26LNv//Zvx9vf/vZjNvEs90ESvgovBy1sB3kQDD+XgjMHy21sTJXeCwfHA08oEYuApAwoEYhKgXkPhoWgRpGwMxfaUSuJkVN6fmIeitb11bQ9Ncgqx1KJ9HmNp1JubiwmGdZtX0G2ukYWATF+LPjwheBFoNJrp14iM8+RC/FbQiQ+K7rs0nsI4Vn5sR4Ua3LErA2B9jycnHaDh8wrIgx0CvSoDDlZ0w95/oiJG2bm+pzXTLqnRV4zZviS26SOdN3NnWgnIXtSfrzW5PYZ6hhoxWvG85ZQZyVjEwG2Fd4ZNBSyxpi9xeaxRftEymt2LmMMQwBDl4K7v3Djl9QzOA4YAGhuWLImtQLSyHO49MOuLZrnJs3opPvAGoPumQb7hwb9FuDWTS8LtI97mJtOPjCaDZ7GZeFEgIYW9f5KmeaENFln53JExtrjIuxfyB42hOsARFmrlER7xl0LU9JtSjyu5I95o/3gNqTtSe9NPKCmZBFYpnUw5NcdsixEv43P3ucryhcZgY1LvManDjBv8TBrdOhZAMZfEXvikeVOk/+mpL9/5I/8ETx8+PCgMoko+vfP//k/n7z+b/2tv4Xr6+vq8ne7Hb72a78W73vf+6LPU7ClVNef/tN/OvrsW7/1W/Hd3/3d1fWf5ZUno037VSJrSR1ngZNoUzhun/rTM/2vWP/Mxjg2SAdlZ/IZiZADZUbkgSs2ZuENSD/k8d/pCWH6t26nSZ41c/+Yu6eywVOn5iUZud4WQJmVYOGoDxcqpaN3X2kM15a/VCJ+GQzPl54Erq03O4+Ccn1ExS4JdclK8eQbMo69Yevb5T0T7isok44tvXblxl3FO1/ERzWxPleVUxpfJh6rNeVF4Q1+Dfa/GyPcMnNrcwHUHebQxPruQ6eccdVfGty8rkH3TAMwsH2ZsXkiZQip6HCf2TGaa4A6KINw6F82ylCM2qKM6c66sCnPaWNVCJMHdYaU8SVnIG4J/YMG+9c02D1rFDcHsH1k0T7ZDxmjaPzvTomf1ywgFfXuX2edd4Tn4FH3jEAY9x78dRqUmVofn5YXxVybUlBGr5HHkClgaO4aIF67lu6dIXxxpk25clnAGeq8J6UNXDRMVLUOZff+KVHvY9TOU40ft3ZoCeuCX9vU/v1//8x3nKYd91jurMfMr/7qr+LHfuzHos++5mu+5tbb8c3f/M347u/+bnz5l385/tAf+kP4Xb/rd2UzQnVdhx/7sR/D29/+dvyn//Sfou/+r//r/8KXfdmXTdbzzne+c0Tq+5a3vAXf+I3fiPe///2L2vzcc8/hueeeW3TPWe6OfO6nfpf8ojhmVhGWHSil08ScMjulMJW8faZOJGa9CdaCMl6mvGMmTiemyq8GefzJ0szG6L0FlmVtGp/0Tno33XY8cs4dnQgwPA4P0N9nyjiZl9bcCemM5N7BrJTGQ+bzY4OJOZkio9YyUr5DAUoZLxkZS099J+bs0cZCqT2aD0J/piQYpIp3ZPAEGxe5pL1PPS5/6j0Vvf/ybZ5am2pl6r5RvckcCkBDGsaQWZsm2+e8/bSkADPBpcI+khFEDFiSDEa7hwb9JUCWcPGixfZRjx35tElAiKsJIUmA3QD9VrIgYecM6JaCt0zkcRkqRQi9ICuheToUwz/r4Dnj78uv22wI3QODm9ca7F5HsBsBjFoH8vSXLUyTnBmrkJBc2MltSLQXT84HOI8qBlk5DObEQGbtRuJ+VJGahzoK16Vj7VDPmkrvism9QnkBAZn9a0n7akKqKsou8hlOXCMfTtRf6mvNUeTIg8iq5SY6gMq3w3vNjEjC72KIk9r7o1cdPE+Hj+4c0HpH5M4CM+9+97vRdV34+3f+zt+JT/mUT3kqbfnf//t/43u+53vwPd/zPbi4uMDHfdzH4c1vfjNe97rXYb/f4wMf+AD+/b//93j06NHo3k/+5E/Ge97zHtCMkvvud78bnCxY73nPe/Ce97xncXvf9ra3nUOfXimSLPZ3bSGrBWTurMyEh6zmoJkLi1oQTuPbMVmPksnTfmBSuVhsAOowj/SztN7adswpeb78GnDmiEZRVumaDMM5EjgDVCuc2XtWKuY1YXX6VF5uOvECVROPXysZI/yw8hDCQGxjYHpRQinjq34SLoy55j0FcOcQ/jGCWlvcXJ+7p/h9gSeEcusUJbwo/js9XsLvsTcXOw/AcA+zGObTTfZFDcUXgFEmSCajBwb9hb8WgWRah0eEsbgx6C8FxOkeEPpHBNsaUCsktrY16LfDWpESn0Yn3B0k41S6HvUOavBZibzBma7RzGCS+q4/hHDzIUKGunksAM3Naw367VaIjfcM00nGG7Prh2xma9bCJVJYN0vrYRTi5oHYnpPvMWAwJGsCN2YAK3o7Ga6+eB/Rz7FWZrwrWBng4y+Tnyj0X+27W/MsE2Wn8/vQJBkjKbQ3AmdS5OJp6PrHDokzSSjkCOOVZ2eUM9Gd5Q4DM2k2prtC+ntzc4P/8B/+w+x1RIRv+qZvwl/5K38Fl5eXt9Cys7wSJHjLIFYcj7pIV5+CxH8vAVpOCsoconjUuH4WpNpb5oReKEvrKb2HKYOpxgAKis0caJVVxtxPo4wdd7qbTTeu7zPIe90cWWbJo6uBtVgJXDyPb+tEbGE9ESgTfeG8BFTmmuJJ8BI3/RW8PqnMrUlZTw4NOFWMOf++2UC8Bxwg4LNvnRqsngNCnio4swYo1MDvoXPevYvinB55QGEEUiyrz/00jKkMTUAMxKR8W6OQ1oYEYNkSto8YzbXww1y9voHdCBdMTEwsz2JbQn/hwJkLA3NDYAhww84bptg2Cxe+JJmgYCXjGLn02p4DjHoGmsQjJLOmc0PYvY6x/5AezWOD9gmBesD4FMPRDYj2h1JY4617fyoJ4EzSthFQBwzez8ojdhE3XK0c6VCiqPf4j/VBjH+EOb1g6bs6ZK8oyBLPveLcXerhZDTp91Mar2k4tgNnjrY36DEPknUwDf8iDADuWUZyJ4GZf/2v/zV+4Rd+Ify93W7x5V/+5U+lLe94xzvwkz/5k/iZn/kZ/MZv/Mbs9W984xvxh//wH8Y3fuM34mM/9mNvoYVneaXKbYQsSD3ys+YkssawuBVQpkIit+PkZKB2E9LvoKQoP5XQkgnOiuxzVbRxTbatnDIqN1NsTNUAOAbKmJHfj0K0vFCq6pxQepcCmKuUoZqTrqWnkUv5cxjI65fe0KirvtienBzTA+qYwnAn+gJMxQb97Z2CrvVOOYUsIs9ccH8NF8ykIVUgocxlfhvxPqTegUaDEHEZaJAHlCZO0yc/7xloDGxD2D8k9A+A5jcYm8cdrj90gye/SQydyxcItHcZk3xTdg36S+DmQy3aaxOIgwEBEbkBiCnuWzeW///s/U2MLcuWJgR+y9z3johzf959+V5m/XTS/GQrla1mUIJCpCihpiSSHoJATGBSAuY1qQktsholPUCCEXNANWNQQwY0r2gJ1CTVnTnsn0ICZZYqKyvzZeZ77957zomIvd1t9WDZMl9mbuY/e/uOiHOfL+mciNjb3dzczNzc1mff+hY6FjycCM3Jw/VynD9K2JQ79UDHMneT/NTd8JLzxU4EhPkQmuNMaB+Bw0dG+xhYMp0waajzAvZkIRBF23L3/9JyTFiu1Anjd2AIdSI4GSM2lM6Ws4Vd2R6jUNUR+zX9bNFaaA3bc+15M8fU1rpTIM2m86YBh5NnQ18Ttblpy+sX6jNrbtC9SjZaCizEXDOQHAM9xuP7Db7G34q9SWDmr/yVvzIK69nK1pb7N/7G38Df+Bt/AwDwB3/wB/if/+f/GX/wB3+AP/uzP8Pj4yOapsH3v/99/PCHP8Rf+kt/Cb/yK79yUb3mRIh3+zm2F1LgX+Ikzn1/rZZCYqUXxgJdlsnyckBjprzSDt3s4uPSHbwZJtAmAFCkp1e+z3bt5rKBzYIzJbMU1to9+cJnVpxyC7vWyS/071pHdNSmM3W6Nr17YiVhZL2nJTpLBnNIQ0KyE66duzZgy8zZtYtvTYdKfQAYGXEMx7Ssr7ij/1q2WuTa2BRbZZPMPJWwAeL05/g8A5TX6PiFsCerFQFg/dwTdre5FY0ZZWb5hnB+cPB3AJ0R07LTuZe6NqLn8vEvevAPTuj+7F6YL8+dhNOQ6M6k6dzD/XGAnbrgYIUx7Q8O3UODlhDSd/MQvcQDQwxNBtCTaNn4lkBnoPm2wfGnhPs/Y9z9LAjmcmDeBLCTSiyaqTbaer6pXScz9nKfpIhiz4PeTCzbniDgk/7+Ji0HZUabNxeucaZsKpw3Yx6unV9G8/zStdpawMS+P6fAEN3cQAZm5CFOS697hVXfgQrKxCpPvM8ikG1AyPhdtvakNIvbboO9SWDmrdov//Iv45d/+Zdfuxq7fcdtNoziWsuYI9aupTOu2SV9UQ2apWJ5mV3VB2sW3rd22mbAjFFfFGjVs2MjP6ekP2PNvrQDQ6bISioBMqX72bi91/Z9MfxFP9po/TFasFUWgJMsuK0YJyVQZmu7gOVWs2RuyvREqrYCBCQGXMdgN7Bn3qzD9R0zy2yZHSOFsLKlovRW0Ln2fVH0Fhh/bp7dJYCrikv3R0L3APT3wPkzwvG9MFeOPwXaR0b76MEHh745Ag749pfv8Mf/xx7/h1/9A/x///5fwGf/SFg2AKLT1ZzkPOrS+4thTIDM154BAvhOsin5xszxzAA1AIVwRkqZnsQAeg/qwoROgDsDh/fA/c963P3kGe7sJbuToypLY1NweqWVrh3fVU1gQvjANDJAVrTcEY0hQGaMzAnMqt1CW8eAhiPmKGdsiVKdarYmFGlpHQs2t5FUvW5p007LuPR9OcveKetIjVKJ2zouvebacTIjXAxgAJEcxaxp+fW4ccMz0lfaU1k1jpZlbvw5tB2Y2W23N2JWX2aR+v+V9trivLUF8EtQ7os7LVu+JG5QZgLYBd2KGu12cepXzLT3JXHvuXOSiwEn9QhAjOW16u7rrXRk7DNVAOYuESm86FmqLZ4uZfKYxdXVz9AMWDkJHldi2FdbDjTx4PCN67TsnuOcs9HYSq7JYXc/W5S+lhP5qdtUeMGSkISazYVHzbEJ0+w82TE5gyab+0aaUzVwZur9QcNPfwC4Adonj+M3Du2zpOOFR2SmdPdywk+fHsAfWlAPdPdNzHxEnnH44HF434N6P4AiUQsDcU7nhiK40Dz2aD90oM4DThwyNGVnKz6/LOyX5sQ4vHdgAtqPjPZjj+abZ1Dfg5sGfGjAB5fu1muxr75uqc99yo5jzyDnCgM3fc+tCl+aYjheY1Mivwa4FnCOx89KaXNgYXiMlLFsLk5Ftle8czdop2s3SyfbLDnuyv68BLjTuizsQyaAWxdDJePzOQFmA8g2qkLq7J0xU7QdmNlttzdgLw3KAOUF6BZgzZrdy9IL9tYClVeVPec0XxLDu2E/X9p/icO6dHGgCyvdIQTKO4A1JwYYwgFMbP6otZaI/l4KgG0EnK0SCn3Lu0SlmHGMF4zVBeTGYUdrAMZL5o1NQmJiYZAx6k3aYS3v5zCMaUsrar0AsLPFlu+MKsCda4igwvLLz9msYiL2e/dTxvlMcGf5uH1kuN7DnRnNKThMDcHfObgOuP/DA/6w/yHabxqcPwc+uAOaE+P4rRfdmPAPWftK/WV3WwEZJgJ5yPU6P+jV1NhnHP8DN5IJ6uHHZ9z9TICh5lnK6b6SJBmLROVzu9XzVQDtlyYBUHbAzTbAXmJO0Xdu0MqqihQvnfedfV4J45d9fn3zq76LQhhNNbQ6fw8sYV3m9Z1bayxi3NY/H8J5Kiev1Xvb0pZcj0jCICFhjdxQkoksP7Zq+3uxaDsws9tu3yWbi8OdseKL7UK7ZmcbwDrmwEqWwVWiq1vbqnq/DGg3srBQWRYqgLr2Qm4KysSXt11EmUVwDs5MLZy2tlu29cKyFzNUpuzWC7wt2+nChe81c1d0Oi4ZV57FYeCQkSqAMmNAa/h9VfjNbgAKQL7pr6UZ0OLnGr6gY20k6p5dx5oVKrefzdXXllsYa6NQGbN7LUws4PjtGdwA50cnIUjve5AH+t7FlNLcSOYl3xLuvvHw/8BBl/v+AHz4i0BzIjR/X9gy7uRHz5ydf7kNgsEsDBt39sKuIQgzpGQF9gUAuOcezfsTqPNg58AHJwwZBfrzVMI5y+SlLGcfuGEOruqB5OdWAIQExLebGXNzzy3eRVPsDYb8IwUfp8dv1WqATCHc14Lao1T0E+Wmda+D7onW09J3YmCE2OdzE8CNh7Kra7trtfCA8fmVcTTJXgpAo5QH+KBP5RsKzDaAPBI9qNHYf6k12yduOzCz226vbL/x67+1eOKdBVumJsWFdisnYemLLFk437Aeyct7q2u9kFCb2ipK78xCam3WLc7GWjy3JO4bdpoBIMm8NFPXZGHmaRHgky+ai9kEbmCzC0Fg9TibXChdI6R4zXVvbbVxtZjyvmwOKx6z8r5H12LGiPO1QBPh5xac2VgzY/FmhF53ye53DQzQzEM6L1XGTnVercxTU0bMwMnj+HWH5snBdYzmqRe9hiAK3N85UM/o76WCh286uK7B+YsW3YMAM49/oUf70eGLf0BwJy9CwUAMHUrmXSfl+oOD6xnu2YO6wJahleOWRZTYvX8GPT0DTQP/xQP6xgFtKKgfnzPola241jVWmjczB7kElo8AmyXjy2qyYdnabnObmqOQAQOVel6yEZiE+VnWLWfv6wBMjp6RrE9yBmXNRkLc+fEFfR05hlMwt3b8EotgfvpZ7dho12r65Hbp2pfy8S7tI22UH/vz+HK73HZgZrfdXtF+49d/q/xFYWItvXS+s4v5S14WC3cWXqTNcmHWC8wu/KYW7deAM1XndMHO5MiZrIg1JgwX5mlwxUEW5oWyCOoETQNMpfa6tc5HybGuUqYvYUhdarXrVRZ6k2KEc7aV5sFCmxr3U0DH1OeX7IIm19Ld3oXnzdXpkrqsKvOF+2wLY8IY/Fpr9p4L891IJLpkcfe4Ph9dvKte6BebDU2yFwUWQ0vwIY326YsGxBIedPpMgJs2MF3aR4ZvCc/fZ/DnPfDRIdE5yUAZ1YDggwO3Tubmszhd1PthTp8VZM0YJj0DfQ/0vvyuSVgkOv8MdXprpm2Wh+YwFogUm1Cht7SWq2qiOEqxsUs3AovNMtFW4fqpMLW55lpwdSrErMDUsmyWKOyuLN5rGLyXaq/dbNOyDDIWjQNo5yloDwXg1GP2HTiwsd7QoH9DtgMzu+322rZgkl21wFtIW5yifs8BP9eESc0dcyvLnbXRi32iHy4Sf7tl6EhtMWwWCEvae3anvrboqIU2WUDFnjdHR88WBGQdBhWeXLHwyTOLXGwrQmoWsx6suF6pH5fuiC1lZ10Rr/7SwrX5vLJ0vpgLa6qJZC8ub4lIp+e4u1wbq0tCbdZYbczdYh69yWbAhU5GURi4FPqCwnGxkPL8NPuuzcGEJBQTKdhROhfjNhy9XxY4mtQFNsvBob9z6N45nD4XcIB8g8dfIhy+IRy/le98Q3A9cPpBj+NnJ7jHIw4fRVdGQpVCKJRqRRDAIS02GKCO4XoG9X4IN1EkojSP2b7l8J8eQgQ0Dtw2gAsiv46iszeAb+rscahSZbxsCTAuKD8Hm0bhOYX+z9db1l7UP515b1TBXT+e26ppk3PLQsFKZhMATL53/KB1QxhSs88CLTPP5OiYUvn6bCsjRNOhT62Tpq6nHy1dO+g4zOfNNWuA0nd2TNTmY32GiQScdWzAGcR7Hb0nau9Lxph5tBuAHZjZbbdXsSJTZuUkVZzIV4ZEXbzYvnCH4FUA8vAym9W8qbyU8gXYaNHwAjsY86lUQ1+ONAtmHJLkWrVK1F6saTlVIKjkACV0V061ZqwIcF7XjG1T3DGb6os1/TTzPNbAgJItZs9cQlNeu0CzGRgm7K1mE6qxk9b0x5wVHf/45fj5SebRQFGfAmdKtoV48er5deE751qR5S3qsIltOaYN26FafgEsStpuRfaaCAZEcGP4yS2he6A4P3bvCOwAboGn7zc4fUE4fQX4I0APPfquwd17oHlUoWBJf00nAzhQAH3uHZonERamzjAGanW1/WmYDup4c0Og40Guc2jhj40IiBIF4AWAD1pNpi4xjKQP7/JXFkWtij5PjLGimPRLsoBm2mw2/MeziEAHzGy2zBVro+K6Cma+KQEkQMqeq7X91HM5s1GUhliZdYuuRZY8/9k5I8afCYGtzq15+OUt5s1CpqxJcfMAyCSi0MB4vZdrcgVg57/7v/+fN6v6d8l2YGa33V7Drgpxmfiy5uxlL7m5ndupa5QAgDV2Ez2F2k7C2voUzi/ujiFbSNwAnJl1jLNF8KTIYG4F5/LSUI5Jyxg8gFmUOI5K/uwJaLTSZtVX2ol66cXsLe3SxdULUJmtVRlj+bjfODSmpmOw5LxNx/IF4X2XaBq91RDVlxQqXtMGVWZTaX6wjtWEJkzRljp8S7+bc2YrNnKSnLSTPwgwQz1w+MDwLePwXsJjnn5IePwlxvl7PfDQgwC4f3CPhz+R8ANuBZRJAB8amDi+kamZvLBlYv3y9rOOY+GeyEEYPvcH+GMr124c/FHYPEBgTTRDmIkPujOuY9HC6cI/xlTgS9lqbb70GbVMR2OxT0DI/e2qFd6Lb81K4DQxJAQtMGdmQ1/XJG8oWL6BOGK/LAkVi9coHlAOrY5AigEh7flT84c5PjJ/9bMeiKnl9br2WkTC0plrtq21DAtsKCDtSwVXB6AMZVAGGNhGhmETP9dDi/2xG7ADM7vt9uJmU2MntpUQYmUBkdtNHPEZq9F4N63HDDg1XLiwwKyq/E9kYnjpnbvMas7SJW2aMG+mFj0Z9X9yIVFi1oSsG9bBSMo1KWnjmVOLoQlAoMhy2spKY2gmpGJx0TUwZI4RlLOHSiEGc+VM1Gk23OJKcGZuUXqRw77y/HKh5WeiGP6UiUq+Vedrrb3EfWwV4mXLGjkDa8DdKefOZoq7whaFMNnnNmyu+MbB3zn0B4JvgLsPjPufdlJtRzh/5vDxLzQ4f79H++UJ9w8nvP/Tz/DZPyA8/OkZYKC/G9JW670yCbOlP0o7UXQys3G+MPxX2RbcOnSfH9DfSeiSZHgSgJ4Y8A3B3xH6o4Nvgf4oTmr7xLj7psfhmw7ofATYNP32pK0FwUrrhwILKLfICgr7ChaYLTJl8DLP0xJW8FQoaHnNVgGhJufdifdw4Z1R1HkqMVDmQoh84R1qD/XZGsRa9ryP9Ovy0G0/HGc/i38Tgb0HNeEBtqANO3CDdXPJxLv2qpC5MIZjn+XjZhKQHo4hQpyrYp328KVZ24GZ3XZ7CzbhLF0sElko82rq+xXnzjlLm4MzwDagiS6uXGVxUbnWTQGBBTba8ZoCW5bswCwAHBJhzlK8NpnjnAurv2zhpU5TI3+z18UBMCf8u9Rm053OONaLxqpZMK51zmfD517QkkV47pTVQJ+Lr3Xd93LQNmOkaAvKndK2eWv2Eno3L2YFfatk9zmESS620TxfcMyWnmurGUCKxQBmSQSYCAgpsZ++atDdE9pH4PDBo/nYwXUevnXo748CqnQE7wkfP9zh+MctHv7Uo/0o6Y+4IQFGLBOGpN04OL7CVgmMGXt/BX2KkdPOiPO/PzZ4/qrB0/cl01P7kfHwU4/2g9TFHwlPXzV4/j7h9CXgDwIGtR8dPv8DQvPk0TyufKiuFVhdqaGSgxPJHFAK97ixjZ7JpZosRGNwhGi4T6JVDvcaBnBy3RJjpVZnaxYk8T4Fc/IQOWDIrmbOy5/1yHQphDBSb0GWoc7D9XUdSQGEoQQ0YniAGoB4GWtmxi5eU5P5WTrfhF1Vi4jtEOaQBMyqlLtbtB2Y2W23t2S3QpM3CDG4GCCqlBXjxG90z8kCGIVrKVDBEy/C0S7OsrrqC/1ap3oSQPB8e8fvGkBghnWTgDilc4cjl12vMpbydlub2WP1WH/tMCtthw1AyVJbJWN6K5bflVakuldYTLcAEKa0hS55Rl8yZGjpsWuZSq8K0hgQN2V4TKWEmy4vZUmGnyXmjdk5H47P3iNBVPRSYExAE0mRffqC4A+Ez/5YAA4y+hPsCM0z0H7jcHYHNB8afPYHwPHbAIS00j6uKwwGR3Ad4M4sWaBU9Nc4ueTC7Jy8V+W6gI6H4Tt/FIHip18g+CNw91PC3bfShr4BunsnejjfA07f82AHuDPgekJ/lPqyC33qFrD3bmE1No0P4t/BioyPG9nScbQKJLJzaOV7uwkzu86Z04GrgTL22cvqHMGUWEb4yh6voIlXUNEwU/LNpuz8CM6U9GTU9HnPwR/LlMmPJQb15jMA8AQiDw5zVLImXcOStVWbeP8smtMVRJm6fnJ/+fWDqLeGKnqAfDhwB2eqtgMzu+32wvaj3/5NCWdauJjIJ9fa4veldiwvvUbxJbHlgqq041I6Jr+u7vxUFlyz7VpgyryULXX8FokA+2wBUS0sPa/YNlYbJolTXjl+wi53pBtvFB6Uf3YxeHZNfZZkQrjGNni2XiP1+JRtNcdtzRSZsqXXeOnQ0k85vGptO20V6pkWMJ4DVW9hBAbr/KXeiAtSuBbYWbJJocLdDUnYz0FSWruO0T56NGdJQe3vWnSftTh9JsjJ8WuCO7e4+wnw5T844/BtB24J3DpQ5+HOPp3XQ/1dxwLa6DzQAMQE8r28NyOTMThejqKQMACgGxxQbgjcAP4A9PcMPgQAhxn+QDh94fD0lUP3DqAeOP5M6t6cgPYD0JyB/t6h/+wA95wCUKOumXp9XTvup66ZhbQkljE1XtquBYrStaY61gEArKwjqkDQXBVKYUAZSMNEkhWKXRr2a0EZy1jpTadQk7JvmascEAqs3QQAKr0TE/ZLVlpguBXFgS0IxDDi1gxSYGMO1JoBZ6T89P25jH1aWR/F/gdKDceOhnV1M2jXJMnWP+H3z61tB2Z22+0V7Ee//ZvlzEwVm8rksdhuoP1wjYNTCxGJCvxbOavVbEsZY2PiuEvtWid28vxCtqmrw95iQYVFRMFqwtGrRDnza+XHaljTnM2M7TQ2HMnicC04s6kT/coaRXNmM6q8NiijP0shmUm4Xs3xuWWY03fYanP/mwV3Vor71ubQkhEz0IdzTJaVYluo04XceY0HBGVdA87EY7KKRMFVBUAk81JzYjTPwmyBl++6dw0+/mKLx18k9HdA8wy8+yPG/U8Y7UcBNRhB40VDMBips+QZ7BD0YA6gntE8ezQfz6ASwO1oqJfOp+qoBsAGANwJOH4rDJnDe4brgO7B4eMvOZy+B3DDcM+E43ugeWK0H+UeiUVzpnvXoGWgeeqKzNvNQJm1ayVmoGeQ9+k7jDJRVVoYpnKhQHS8TOmQJfN34d0/x9ywzKUEoIr1BdLMPApQmmvWyg1MlNiuAWAhIkm57iAAjb2WnltiBV36biilxs6vkdWBFZCxbZqzerwpgxoAXu6NKaxRERlokzYRerdona4C3RliUhYA5mG9zOO1lbD5nPxuQTMXbnV/B0/aDszsttvPs12hmp+zeC4FZ2avOZVNwaT3sy+QRRRQFOpsr3lhSMhbSTNc7JMFgMsiAeCwMKn1uxX4vdq2fomT+bkSnFkDxljw5lJ9mZvZLcb01pkiKjZPv5454A2DMy8JdFwyZ98i/GmtTWpjZA7xNhcUYJj7zFEExLF0ohdBek0SZogek4RCACmbIvk82xWf2UiJQGUPNM+iEcMhlXH/4PD0A8Ljnxew5rM/JHz2Rx7HbzpQx+I4kSmfsslQQ3Ed4fl7DufPRA/msx93cGcPVvZB0BxRUEZTKRNLfVS3hg8N+rsGTITje0ZzlrHhOkZ/JDx9XzJHdZ97uBOhZQI+Au1H4P7rHu7EkR10ib3Yc+XCxUrzZQRplpQzHDSrh4Z1wGJSn0u+A4qsmPi+837QW0nAmUKZHkObWDBVWUfKRFHGi5eQOrBk9AIzqGEpuxQ+bkGxAwaASO+xFM6EDEwwP4U5w8jXRkwEaijOEeR9mAcozg/xfpsAcHgv4UuGYSXgk44RljLhBnBmLnS48l5Pxly2Zk61cSCdOHEdggmhD+we1V/UjG4Ivxc1etr0nncb2w7M7LbbK9mP/u7fTFkzCx2bKWHJ4mJ4C/bJRk7XEqbBZgv6SohRaXEzYppom71xNoO11xIane2vEe33MsDoGtsC7JjcgRwtQNKfI7v1uLJO3QsBJsVrb2hVdt0Sswv+NwrKvKRNsY+mbGr+LjmHW4MzRTFSa7rYbxc6wJHRQqPPhouGuclB0t2qoxiuxy1AcIG2D+OYcLo7HFkx2TWIJt8/1KtTyFGrASzHkJff/QHo3jk0FJgzAPwR6N/5wKJpJNTpYwc4Qn/XSDYmB+AcAJQQcpT0nQOev0d4/AuM408J919LmJJkQ0Jkx9j2JwRnuvcCFun1Hhz8QcKumhPDt8Dzlw7Pv0A4fcXovpQ2dV0QMn7POH7waD+K8LDrgr5M52ObFLuUbjjususk30dgACJsH4/LgLk5W/FuyIH/2TVAae4rsUqmTJlJgemhfRHPVOaQDUGyzKEcgAnnJqAHEM9P1mumTOr9ACU2LilfsmOZawKJ7ksps9IoFX2hjYQx4jBKQuAQABQ/ALihbLbPv01oEJIfMBqQTcttwqqYMYQ4Mc1GgC2XR6B0Y8qyYoL+Vc0iIyp+UG4vCnNBmskRGXNqt5LtwMxuu70Fuyh1bfq3XVCNjrNAwzVO0wZO12bgjGmzRIx0CRCV3cfihc0nYosXpVwWPl4UqrPEyc0WYPHjGjhjj13jRG+kp1L/rvDhRPhVdfx+QkDfKtsyC9pCyxlJU89w/M444GvFbJfWSc97s2E+V9qS+7rpvVtnL/t8KmtSkb0Wd251/OYnpaAKE4Zd7NK18noFB33E4PTZ2DL3lMzHniU9tANwaAAd88ygcBC3wPlAYNfgSIS7n53hTgx3ktviI6N7EJCFeg8mh+5dg9OXDu7MOLz3cI4CyGPmXgTgpZVz2Yn4rm8cKLAVbAYm8iy/h3KoE7Fgf2jQfdbg+UsDzDwzfEvo3hGefsDo33nQidA8EY5fE+7/lPHuz3q0Hz2a517K7M0uf64vM8pchdW26H1nfkaGVG4OMZNgnsXnsnrNT0IXr1vsPWmojnOz9SQv/YvOZ0zlDITSkBfImoycS0NlMnAjZ61QYJ9RjxA246Q8oqhjMrDUwk/nxqyYeL0Qlps/p2x07LQuQPxssjkscMsCLqmAbzV0W3XziEDEotWk7KA8BAw+AL9cBDRG75qp1OMQgFe0eZCGUcUDBlHn4js1YyYSD2VyQHsIBA6AncvKZ0bQyLpQiP3nwHZgZrfdXtNu4cgsdRKXFpdTaY22yS2BjIvrPRu+VA9ZmbpeacH/6mFLhZfwolCPWr3XAm8TIU3J+ChcU8+5dAwtcxCnOnTdtapChq9kUwywxEr9ubWG0y3KXWBLNI7sMbcCYD85DZZgb71+alXh0tLYL6z3i+L5utsfwg5AFJ3/pBx7jbAzblkvozlG2TT55xruA2UI8Khuto4cQoHEwXciqktSrm+cgCQtob8jwAP9UcKCfKNOK8AHBr3rwG07lEuE82citHv/Mx+YD6ZtPA+RTSz6NYevCe3HcM8kNyCshKziClqYMCZ/cHj+nsOHv+DQH4HDR8LxZ4zmLADN3U8J/cdGIihOwPEbxvE9o/3o4U4+sC8wsHGAOM8kO/tT766FYWGz83o/MDgk/IaHsaMhbiXG1QUhTNEqzMer5rDSpsISyxIEjECZJgAjDaQ9ehI2iH6fpZpOnrUcRGkgZSlg5AloGuDQJmvc9LpkPh9Xn3JQJmfu5GCrAjQ1MCkzESQ2bKmGyscreyZeWp5hcilIMxTEw9gzwFmRmTizftO5xZ4/vpFhXZd8Zn+azwkZm8eAO2lfAdw6+KMTxt5uRduBmd12e0WLGZrULtz5TybQDan6pRjRXMvlEtp6yXkqMn2A2zt7C8GI0g7plHN8barstTbV9osWcaW04ktCjCaYLSNwpnJMUscbhzXJRSe+u+QZ1DaYYvlsOIbtOKyOsyXj+tpnqwb6vLItCWfYCjj5VMANa2+1zovmqdJYD46MdYSqAuTh9wjKWFHPycqFsqOzZso0VP3ouFtR3zlLnNXwkWfQWbIf+UMjIUTmWfdHh+cvCacvgOO3QPsoAMbjLx7w9AOH9/+YR/PFGf37Fu0HgLyAJP1dA99KPTUd9ig0iAHXe7RPjPaDOMWHD4zDRw/X+eS4MTijP6VNuSU8f+nw8S96+AcP/8ctjl8Dhw+M9pFx+Ejo7gn+EOayHugeCM++weE94fCRgbMHuOQ40/wctmZ+s++ekgPvMmaFmvfCINF2bDLmxiV1y+fRJaznQohJ8n61bAc9Ru9ticC+OY+dAw5De8X7VeDAE9Ay2KaQzupWqmf6PQ0p2Tmwz+y9mv4p6agkppuJJf5LRCIrdSz9ndcjB2pzsCljmgx1dfH4hDmj4U3hX9SfUXHg/BZqAuQFmwNkRr/b7/P6l0Cw5J4hQG5L6A8CyviDgMq7lW0HZnbb7ZVtbYamNZZMmBc4TFVqeGVxsAU4cyunobios79flbEqBWg4LjZeFpyp2Qj4KvWpLvyuAAcTyv7KcpaAOPbYZXUqhRuUj5sux54/3jGKPzcARWsA4OpxNNX+14JES3af8XoAwJSDfy1bZgnLa/V9l8QWX1ob6JWtFGpUZTLk4Ufq/OW77qVnVcETBRiCAzViyiyqdAoiR12NfCdedRto3KejsTIKsxVn3DcSPkVnhoMHN40I/P5vetAfNPjiDzx8Q/jwyw2+/d91+OH/9mfwDLz/vR/g3R8L+4QPEsbkeuD+J4zDhz5qhQw3MbQH9YzjB8bhUdJxtx960NlHNkysX94Weq8UhIFbgA8MHCS8qXlmHL7tAADNqUFzEjaNbwHfyM/u3okWzbND03HU9RnNg1Pv8Uve8VMAu3XgDaOKeh4yMhFJM5RYIFuYZj4K107qnNkobC+GLNXrtjRUkVqXgpMWYDHsMMvwuSS81zxdkyCcDasrFUAu+TOtG0gYOjBjGeX6juZ+2/Y5+BRAiyJIPHrHyzkUTmAGojgwkK4JDBBsr7sGnEnKUdN5VcdHXs8ZtpBkjguHMhIw1TcO/m5gyrgJnaifd9uBmd12+w7YJOOkZguds9xRnHMSLxGUzM8ffX8L1kzuAM04QsMCVD+YOOa7aFNMlqWsmezzSyxn2MzGw9fAxaTM+piedMKXgiUbjN3NQL6Ss7Ipm2dos9Jc8FLAzaJF9YIyrq7vnEM4lXVut9QssKKMDE91MCVnQNhyzDFxt39qniiwERJn15ZX2GkmUEz1WzSTLQUNgdiDD028BxfOZQJ843B+53D+gsGfdWDXgHqgfyA8/RLj+7/8Nf7pH/4j/L2f/hLe/SPC53/4DHfyIYSA4M6M47c93CkI6aojCgZaByZCf9/AHwiHDz3cs4frGO65l6w4eltBJ0L1PhKdGiL4g7An2kfG3Y8bcOtw9xPg8ChpuploEJH1Uq/mGXC9MHlcx/GeQTRcO39m7By2IqPRJKuqNHZMyEsS9jYqeHDwL9Iaqz37vjKG83pm9bLixJEZU6tbwUrv2vh79b1PEeSTLETZesseV7xmoQ30GbFhgVo3J+wsH8KZKMwTImxtXkS2XC2PkYzr/HsA1ZDxpG03sMjqCew8ngKXNWyS3SRDr7qZYOcxK4xcYhHOMgrDPKBAeXWtCJlLTrsCcM12YGa33b4jtrmTYxY7S5xba0vAmaVO0nqgZ8rJzl7KtZSDKi6YCQy/OeBlA+dtFavKLlazXeEYa6zlmfa9ldBq8ZwNgYbqwr00vl5xbCwGbeZAgKXtZkHMAqB5a/2pOdsClJkqa8l3id0oU9V30YrP3Ghn1yzq7c5/Yac76koAEUBh50A0gDurrejkm53tCiOhCiZbUMZJfSXFrowb8gx0EorBrUN/73D6nOCPAH1s0TwD/ZFw/pxw/qrH9x6e8CdPn+OP/vD7+HNfe7inAKgcHVzPoA4CyjDDHxxACLow4lz5huAP4lg3jx7t+9N4w6QZHG9odiZmOBZGh28d/J2EYLUfGZ/9Q7n/wweP5tFLtqajQ3cf0gkz0J4YzZMBZJyEbIEQQCEMGhlbbtSsBbwjEyoDFhSUM2yJVbbxHDFaO5WYIHMpmNVK7/dFlYBsYi0EZOz3Iw2bcF1/dOiPLmoicSPiv/4Qxi0Qx5EKRZNKP2l4DYa/qRMdp5wJNmQTUkBO2oGdZCaDoxB+pEAJDyFjsXz9pfRSotFxTOM+S8LQLDBdsNom2OQ7mUjC9KZljoubLMqQikCSC4ozfapBRJ4lY5z3cD2LqPduRduBmd12ewM2Sp392ubTF1LppUoOkyLAVty1JtK5WT3twhbjl3rVVizuLgFl8josFmzFhgyJa21mQVG0lVnAbikAvMRWtXN+7FxbXONA6KI2/7gS7qTfxeuuXeivdXhq7BszL9T69qXDnErz1IsK9Nb644UFk2v2psSKa+wWdUp0nlfBzwIAUmYq6AEUQwVs2UWtmRILIQelYQAZ/V4dc7u77yXspSyWHoAOrZ8pKzpizkUHlBupc/utw/GbIQU1jh6nvsGffPsLePj9Ix7+9AzX+WGHv0dgyQD9sQkOLqN5Eh0XJopAiXtmuFPKkklClA4izhrnHs3WQwRuJWyqe3AgD9x9I5o17uThzizshjtCfxTHs32ScKnmqQd1Hv19g+6LNjB8HI5fS72py3ba18xxpWfQOrmzrAB1YF2cZ+N821BM01wVfdU66KULzv/oklPOdB7KNMGYmKtL8e/V4cjZc+jlPXXphpZlKQsjxkVQpr+jACiGqrYUQuFIwmRYzvOtAzsJnXFnAWGo58ioQbJOLaxztZ815I8ElPH38uwA4T3XMdxZtIbcuZ+eN4r3iljW6HPmIVTOlDVi+tmNowysnrwmaFxGdu7sGj6wyCJrLn/X9uHZR+U53i3aDszstttui+wSxsgaYeDVzvmtdqDnyq04ynOWh4PNnb80287SkJ5ynaa/q9Jf8xf/VF2X7sgVK1FfbN7EZnYMq59P7NivtVHI3AXnXwXOXGMLAIY5Nsutw5u2YPLckp34WvaaoMxIw2nJfBpAGc4AYN1dHmUFAcZziWozBL0DCYviCD4kYUomVMCGcZBPv0u+D6CMPzZgRyH1c2WnmDCeSwNY4wMrxTdOwoMagjsDdz+Tn8dvfQB9AHps8Cc//QLnn97hF/6Ycfj2LAyjZhDZUCfUHwj9PYF6gnv20mKmiZpTEPu1c34AnLhx8K0LYAyDei8gTichWP2dw+nzBud3JBmYHhnNY4/mLA3atw00rKE5M9r3PdrHHu65A4jQv2txfkc4fUlwJwL5Vhzup8q7sfAMzYan2lA0C6oVT7INE7opC2G7KjV2Ya6enasueTcuDaMyz5WGkk2db0OX5AMeMnfZekbwoFw3Ns+BDVPyB2GKde9cDFcCAD5A0rk3hP6IkBZegM3+jkKKd6A5MY4fPNozR+CG+myuSYAG8zGbegfgrb9rcP481IWkrMMHL9pJUQiak/lktf4LC4clFSof6qCsHQADsy7OWZxozyRFj0Bh84cydDIbaQiGa8Zrh0vKgeNnj0z9FKDerWw7MLPbbp+oFcGONU5wzRlYs6ub7Y6vrq/5DqjvGiy1zcONFoRzrQVltrRrncxb7JLHMktjpgIUzMZAY0U9awtPwsWg2sjsglxT574AgHSTcZT3yUaZmrbUFbqV3U5o3FzjGhZSyb4DIVFXg2Ol58DR4GiVGDelc5Zs2mb6NZG6Dwwit/nn8ViK4IoeQwWB2lTYc5iTOIQG8EFYAuyEZeJbQvvEePixOJyHD8J2aZ6Bux83OD894P4bh/aRA3Dloh5MDO8I86HrBNCR6w31oN44TyYsK7KAQrpu1wHEPrIFwLIeUD0bfwBcT3JfHuKwEoUddI5aMs1TL8DOuQeHzD79kdC9I7gDcH4mNM8NDp6BTIB4TXaj6GSXHMMloIz93WWgTsiws5ShMvfuWQwkT4GPlWsDGIfe2D62rNdYnzH4Yq8rIT7DeB9l7QpgiPRddmOkY2pIB60AirDEZPyD5bnQcvuDhPR19xQAGsh4doA7y2WaswhYu+cwpgvAQa5ZAxgAwbL0wv0rEMoHAYDA8iy0j0HwFxgyKRGApVmIlB1TAqhtiCRRysbT9s4YhnCm/jTc41Q42+y4q7K7eNStbMZKDCtjpOGouyW2AzO77faJ2iJx36XgzMLFvgUn4s683VXB9IRuXwhTxy1akFSES68O/5lojxyc2SrUaHXYUqF+S4CvSct2QSbPyRd/SwGDiXGW6EKMXu7j71aLKuoiMdkJywCJS8wuzGv1WmhFtkwFUKrZRfdkx/wGzI01oMwWDJblQtDXX2tpXRLbEkyZESn/5GwKOMl22kdzJGvaa+MoxkwlUy8YTkCZUYpbe/0SOJzpKcm5BVBGi+kYBE7BBGvG2SU2gIhnoHXwRMIWeHA4PwhL5/DRo31kNM+MJghpHt97PPzYwZ0c2kegffLi7AanlqNDyQHI8aDe7JDT8O6lswgDizPOYwc9/pEyCtg5+KMwZvqjOMrxnR92zdnJ782zjxofKdASLtkHJ5sRQ6xEw2LcD0WbAGViWIgNtQlZlYYTJiYU/e4CMd01NrteWhF6Ek3f8T6kZO8ZMdV16xItGQvGWOBF1yzibANwQVfo4CKgKPUOzjojjj3ROeL02XdI0imTB7zn+N7WelD4uz8MIIM7A63N39RLaFzzzFFTqXnqg4YSwC3J2EKYO0prL/uRAWW4EZZY89jLvZwbdL0DQjggRUAL0i7eg5wTLRrLOsrHrn7Gmho7BVPYmUWGsmYCMBNlA7JMdSK6TMPmkbmfRZtyU+csYscaIC+G/mEHZWZsB2Z22+0N2EX6MqV44EsW6yvPmWKl3ILBMVoM57oWc7bE4bTHzLTHWjDmzQkGl+xWYRQVcdhLzY6vi9k+AehYxnSqjOk8C0zmwF1io3FS2pW0Xxeew6uAwhXijNXr6G5YUk79kqszyc3YmjHxUuydRXV6Axozr2K6K5yFykSzz4A35yiIEVkP6UBKxm4GnCa28Dm+aqz4AXQopXpWVs1orvESWkQM8MGDmxanLwjdA6F9ZOAjok4Gk7RF+9Hj7mthsjQnhuswCJXq9fsBIAEA6oOjbRgDjFB2OEbPT+6BIWyXs49zu4ZX9PcNugfC+QtC9wD4Frj7liIgBKiTnqXebghoA7Pn7HF874U9EzRCosNPBq2eEzQvWM5GIACIEWY81oipMVLWMjq3DFlcA8iMNq8g40vTfPc94Al8MM+hjk03ADLcyNiSPoCMAQVZCOiPDv5ISBgznobH00GAm47hyAeQbsimJCBiuAYBqiGjwtQy3hgtJOW6Xsd18jk7ikCR6L74AbSI487WDYghU5UQK25ovIYM4Kl7ZrQsIX/UBT2mACLG0EEzbxFTCmyU1qaGEcMNRRaWlhF1bmrDyCOZZ0bgjJ1rL7VM0/Ei27GZqu3AzG67fYr2Ggv5LKynZKtDkQoviNlz1yxuvBFaLLGDSmEcc1WmehvY7+ZeWluwbVYzBJZQnjewxBm9AJCxC6k5x351lohSddbUcWZn/+rwMN1hmrHS+JoUkyyFOV4ZspTf6xpgdmtQZu31tijrIh0JYNw3b0Bj5lVtCpzR79UCwyE61yUno/T85MdZdsyEs7Kojyf6rvg8ThwvTh3AbZs4QOwGlgA84FvxjLlxEgr0KNlO2kfG4b08m909oXl2koHJM9ABpOE3Wj/H8M4N82J4V7reh2e8EsLb+ah/Qb0fnMmDpMX2LaG7B05fyiThm6wAL+eqMDEfGnH+lYlx9ji870GeJXMTIQi8EpwjwIcEBLG85ZsrTAQiGnRAMABncn0Rmh2FhQCJZshFNjUvr7Hs+rMMmdrc4wBGIz+dA5xoB2m4GltgxlESRsSO4B2GMB39EcC/OKbYACPhQ3+UPuWWJORNmTgOEZRRoKV9Qgh7k7TtXllgTQBuOmGNJdcksx7Tj0xo0pDpKDyjtX4x4yqCgsr+8CG70LM5jsKx5OJYtFmVCDSkDi8ZhbGHAVSNLLqCbksEOnuPyCq0bDAVCFazwHZprVJ6fhQIqoS1jdYAVdBQFnY/x2+6RbYDM7vt9qnZSy/gV4Q6LbHEQZpZ3KwOV3kjdqkWzZY2CcqEv3nSQZhwZqfCDzayyYXm3PVrju7KLpgcq4W4/DVi10lRt2jHqefkymeIieIC+xbhQWuBj9FYnWFpXQMCbXK/pTl1Diz7joA3xWdKNT+sAGvcwR5OyAXUKT9W/7agSymkyQIy+WfGrmE6ldgxVQsOm96HPzQ4f9Hi/HkjbJGO0R9J0kh3EuITM9UAwlxwJOFHzHA9ovgpNzQwUzwNYE8ItxBBYYopqn1LMXtNvJfeV1gXgfUS5jvWUJZG6nx4TyBPMWuUnAjTR4jhIcqcGEA3cbjdM8O1jO4uZKNq5R95AvtCO1fDkG1fAGACsR+cWHVsiYDDhGvEISNWLPjKZ3Lh2qr0Pl41j5Wc7ZYyZH1gxii4xiGrERBAkJ5j38MFcd0jgXphtLTPfQRxYrHBWdf6+2bQSgKQMHCoR2SKgT1cDzRPPoYJKTii6dwBBjlEvSN9x7PDAIwo60b1bQpaKKN5veekaUbv6Ag6lUEMgoJY4bmO6boL7zczt+dCyxE0suuNGHrH0+/hfC5M6l8Goof7RTInlUAZzZQl15d7FMnnwlopn/enQk1/zm0HZnbb7ZXtX/nnf0veSbpWrDl1r7EoX3rNzNG4NvvJUvG8VWW54WU3yZq50G6hPVO0KxZyuU0K9dbKyB2mibC2VxV7ze9Jf+Wsfy7t+6VMrwUOdZVhVVhAzll0bK505It1Mm3IjQOCU/batgbIufWYvHbuK/abjtENdYDegtnFf6TcW6dXQ5UciuFIDBLmRVImYQ5wyT+/lhUzsgI7ZvL9YHeZCegfGnz8xRbvf5nAB+D4M+D4DePwQZxM3xLAQPvsQV04LYyb7t6hexAnunkOZYfQH2ljxOsAg4MF4+BZtkwy9mLo1VDfONYdwd81kiL73oF64N2PheHQnESTA0DCviBHoIMTJ7gldA8N+nvp6OZZ0moTy71wQ+gboL9zQZ9Ewp3Qc/pcVPTXyv3kQc/n4Dh7AWeIgK4XcEb7PGMeUA8BZ144THlLQHkATih+z+psHxz6uyYwUwRgEC0Xhjur8x1AGgKaRylchaXZAxxSV8d6U4AQHIKQNSKYk6SB5lilwKjiJPRO+RbuzBHM0fvxLYbwRmdEeJljWFN8p5p32XDtFOC175U0tXY2H8fr6VyWtTUZdpcRnU7eW6W5PYZADnXKz81NrmXYXioArPNiaW06tVYYMbOGZwIBxAMQNYPiuk9ZOYHVk2SK5HG5uw22AzO77faK9q/884O2zKx+xmvsmObXfIE6rF58XFKn/PiaI1Qov56Cc6U3lr2Ip0KkytdDOK9+TOIkVl7KsZwZdsEke+YtgTMbOa9vAXC4xLYEBWdD8pzQsmNbFcC60hiY2/m9eswUxvJW43AKeNlszGyszfQWbL7PaQBfpsawHY/2OAUK7MczYYelehRNnS7MPF9zfWUcyfhRxgjig6QEfv4+4enP9YAD3HODw7fA4aM4qs9fOpAH2vciaOqPLj5n53eE0/cIh29DSJOyDNg4SuHG2Ut91HlyvZdwpy4DZbQN8lAOHjK4sCN09w1Onzfo70Tj5u5nvaTrZg6pfUMjkPzwjmRD34fz3zk8fSWD4Pgt4fhtD3fycCdh8fgD4fxAUPROhZ9pKXpdYDcAEFCm64G+j8eRank0DmjzOCyIw1v4+Ja25n26ZC7ixg1jMrQNHxy6hwbnz4QxQ6ztLAwsyUAEw0JBZNGIaO8wbuLYc4Zl0QAgAXGaZwlPiqDLaLMjOPUGzHDwwBlhIqbi+oQYQMdw5vyUqac/5eY5qAonDBFtIwMSSdkVcRQOFzZzRVoOJc9Lep/mODv3B6AxATryfi2EaLIPnBUFvOESkWq7uabslsnwKmCShaxsmTi32Lncm/NjW0xf6ufddmBmt91eyX7j139r2BmYWbRGm4uDvYUtLXvjkKdqXVboy0S7FLjJdgs3tUvaK99ByX4vjZtJcMY40otZBxN6DGvsKtAmv/acZkP8I/sya/9LHOsacLXo/jLdJs6dzoITtyrsqebgOxMysMaWHF4M41t3mTX20gDa5myY17KXmK+DzbaZUtst24W5yJKJ3wGIQpeq3xCyCJHHUA7RAPpMjM0plmYeQiXnpc4k9RWHzfZ5rR20H1oBNx6/3+D8BeCeHdqPhOO3kmVG2AWM5iyCo83ZR90PFWbtHpQ5IKm0Nd0whcxVGl4hgqsSxsQNAWfRdSH7zgv3L+dRBFeoS+9XNGIc+geH0xeE/p5w/AZonns075/BrUP/cBDdjdBmTMG5Pw+hUOcHh6cfUAQLDh8lxMp96EB9g+5dSMHdDiE3yhiaNR0nQHQWuXXA/RH0dDIaIQQcWvChFQHXoPnBTZOOx4yZdetNCBsmC8yD3Wo19rX2J4dwIu0H3zj0dw6nLyQkrX1ktB3gepYQpDaMNwcQU9STcSoq3WsonJds4q2OnVDPDnDeBzFfn4AuhOH9RpGxhYSFItOCKHr7FqM+oAA0kufITlkUPq+bDBUFFBmvYQz57PkPwrrkXCgjfXaqfaLvfqMfM6dBE9dzpXWcCZlKmINT82hYy5VYOdaIBbwhBdkAoGe4AGYmejeMAPrqvOzHz8dbeQ++QduBmd12ewXLszAtETstOuArF9ZzTvzVZhb7l1L6Vy9wSmwXR9tP/Fc4VVUnOGPiXKM1clV/LghLSj8wzpO5/tr+vngxWwOGFjwPRaE/1Hei1iyAE+YImfSStbFTG09bhsIV2SNh9xKFcVlgiFU1k3y+E7muMz+1nbMXZ1HVxvMWgMpLgjIFPab0IBqPncIcE//OAJn4d8hkFDPsBKeanIshEJfdw3VzM4JDU7UA/nDj0L1rcPqK0L1jHL4lfPaPGHdfDyEdYGEbuGdpl+5e2A3ckIgDE9A8Ae2TpMuWlNhmnjZhKmAMbAZA/q7OFxSPJfagzg/OfUPoDw79kdAfCf4Qbuu5B506sDtK2EPQzBDBVxEcdofAhjk69PdA9w6BfRHKOIv2Sxsc7vZJ6u1O6X1pO0/3g/wgMx7ZCSOG+h6AA98fgeMhaKu4AdCrsDOsbQ3OTM03U99N1kFBmYOI/KrOiyOSrEJehHQPHwTgc52AfNQBbQACFZyJujCWPeMDKBMycDkAnkj2cxqAWwC9nMj62Mf35tA3I1BG2S/hOAfJfc2OYziNZkCTOnA8xwrqF8Xq9V3okDJATZuFy4asTgbk02eDhrCeWJdMp2ZUHg0DygJCpb5Nxl4JlAGQZDrS9Ochq9ToPW3PsyGjdm1VCNdmz0BDCViWh4dzGBPFUOww1/2d//E/GN/kbgB2YGa33d6UraGpXrsAuBlIY3bobwLOLAFIrmHLzJV7QXnLw5Muc5auZp5k1NZSaEm1H2ccliWhLKvM7g4p+GH6OwdDolPF9fatCufNVcXufHlTL/MztueUdohlzSjVf1THFY1WY9bZsrhyrH42Ac4UQZnMpsbMlvPN1ZouCy0H3dae++ZBqKUMmilx4gXlLAlbq4J9kTLvE/ZDBGl0R9ucS0RRvLTWb0v6ZjaEdSocNvtucMgAZa/0B4fu8wYff8nh/JkwDVzLoA44fCtpeAWkALghNM8e8MD5c4en7wu7gYkAD7QfGXff9Dh8fRYwx9y3bxy6B3HI20cpg4gHhgImxqsHCEGv49QBdwf0d41owzy4KFDcPAP3P+3RfPMsGi7vjvAaNuMl5OXjL0pK7eZZMkkRSxYpEIPOBHcOTAIfdtwdobWMF07rnPaJbewMvLPt3xCIGIzD4LjfteBDk4CF+Tw/G957pV1a7jKNrQAiuIF1BADch/dp59E8Eu46jlmZNNxNxX/dOatgcNJVXDdhq/QUPnMxnTY7oNH3RzhvNmOkvr+9PBN8BpwCgyFcKobT8KBJI6eGjQhKy2cMz4ayPBScGbUZ5DsBM+UB4aCz4g/NoGnDgBXlHZkFZXT51VhNmNBu2VxGdq0WM4SFn1YEWzeUwroj6ttoG+egizITPQyww1WWjYZ7cQIkpfdKce0/XidoCvbd6rYDM7vt9gpWAkXmXqq3dEBu6ThsVe+kjuo4lha/14R3vWU9hxkNmEVWW/zoDspSpzPfsbliN/mqsbfw2jWx32vHZQICleqmxxXArlm7CNBcedI1490NlOtaKOYWz/6bBqEz23SOfsm5KJ87rylDf9+i/vnOLiwIUzg+CFLbTCKsoUw1ts6czYCcuUV2pLZBCZQhxIwm3Ejq3+5B9FWev5Lj3Rk4fY/x8c87vPtTwuGnpwiyiJgpx/NO3yP090D7ETj+jHH4yDh820sqX2BIfxzCnshLaErzHDLdBLaEZbvW7jUyEp47+PsD+vsGpy8bdPdSdvsI3H3T4/5PnuA+PKagSHDC/YHw9EPC0y+ImGz70aF5lmfn7qeE5olxfM/CirFgUYFBMd0Z6ViJgEzCgmFh8xya4TtX8UpHDvsV81NB5PUSW3ttYpbXZsdDSJBmYQpAiYa7qX5MbHOvYsxD2w9CuOHvfIOCIJnEIGnRqQ/juw9Zkjofx3Ua6oIwboCo+eOHvhfwR+qXZIEavYuyjY4kvIeGsQEOTBAKwEv5fSosn5DRigy4pQBXECNnZOnWS3WKa5cB6CCHAZzpDZCoGjHebJSU5sBsvksYwiVWos6xLu3HRDQ4AYMYBFWDLoDRZpOpaE7mu93qtgMzu+32irb2pWoX/pcsCBY5DnOL6gvYKDcDZ6bsEidjCaizgjWzVtB3iV0SLrT84JWgTP5VpZ/zsXrVeCg4a3kdouV9tXIBzITRmFhU98RxZKDBEDteGju51kyBMnORJsyUrQ6DHFgzifMJJPTvGiNisYbRxnaR9k/BYr/PPCNFqvxbt1tr3+TP7AJWTTF8MjjaqiWju7rsjSNCJEKuek4jx3EpvHXmGSiO2TVtVQNlDk5Cfx6aoJcCCSkhCUOS8BFJ/9s8A9wEpkInzq3zLLot98KuOX2Pcf7S4+EfNTh+YBy/FtFcDWPQe/AHh/4+pOB+DgDL2Qcn2RfvN3Fstf07Dzp34Mahvyec3xH6O6A5AYdHj7s/O6H5yQfg8QloW5D3Q/rtuLMP8IFx/ozRfUFoHgkPPyZ89o88Dh8kBKt59qN25DY4vJ5iBqDEmeW0riN2gWEMDKKqg+O75P2V9mn581VmnoepMJZF5QDzcztDNIKYxB8/Cpule9fK6+ok/SUMmBRUK2Udmg29ZWG5tD5k5rLropzRZtkbOt4MGy/qwJSuaVkoPHw2gDZhTDQKUtIQ9qQgC4X26bwAPyVwJswlWgaa/DkHyFFaRft7GHfx3WhUwTWkyjJwSe9Hwwm9uZ7OgSAJXcrHytL3fARoKl/rzfQAw8s8W3ouimB0GNcBlOnvX1g1+xOzHZjZbbcXNiv6W7OXZrBM7ZBNWhaKseUub6kNVrXJNc7GEnCqUHZNh+Bqp3oLtgwwvHxL9ZwBPGaLvmLMLj13EhTJFreT7Kol5S2wxfdba3Nbr4XjdZHeRX6/EwBVPWyhXJ+aVtJcVoepcLYlulo1s8csGUcvCQzNaT28aYbeNWbDCAygle6IL7j/nJlnmQ+G9WAHATNALM47OxecGVd+tmogKdaPq+HYmXsKjmJ/3+D0hYQUuY7hupB16SxhTNzKNQ8fPJpHH5lCmoPIHx1OXzQ4fUnoPvPgI8MfAd8E1oKCURo6oCFTdxQYM9KY5AXwKbWN3dmXkBZx0NXBVV0bf4CAQCxhLs1TB3p8Bp/PoCY4YZFBIQ5d+wE4fONw/lKu7c5A88Q4vPc4fOgEGPDpXMcNwR/F+ZQ2k3ThCs4kITElVtUC5tRLhUZOvZfy+kTbeJ1FDKAXYIIaGXsCSnAEZ2YZSnPPhZ5PSEAybkR8Go0BfizLNAtJiiEwTdgI6MNz2QwixkMq97SsAQiSOjCRsIQaYQU5yDnyvITzw7yiOmwD22oAZLgdUAxilrbUtqq1Uw14CymuY0gVFQT67XxX+Nwyh2x2rHiNWNe0f5KftsykjqYuqrPjOLSTmdvzOTXRnRR9ov7+BV/Cn6DtwMxuu70xm2PE2B3oS3ehZ49f6zRMHKv3cXMnOHckr90BXgnOJM5yfukNF3pX0aeXOA1T5b4ScDMubACYElZLyQq7kbP3WGqHZIGBpLykzLiAC47BHGv3Age9Bs4sAgALoVxLwZnJsgv3kbd37fmfm+vW2C11bfI57CbXmtMqectgzlIAeek4sSGWVkehUWcgADReHa/wfGooigrbqpNu9B2uBsovfb+EZ5db4PyZCKwevxWWggr6ajppFblV5ogI0ooj2h8dugfC+XOGv5PvT195fPiLDs2pkTAlZegQQjtxADQ4aKXQoGVRA3vjHIuBQcCS/ppV8Pc+ZN35CMnIc+qArpN2sk4xwlqgIfg7wLeM5iOh/Ui4+xnj/icpIMCUVYsQwm4I3Mj3jiTlchQwzUJrAMTwpLnnsrphVbJrnkU9d2KzoOjo5hth9jP93TLDCmF4Cdimz5uXsDY8S/9GFonnNNtYbb2zxBJgbtCXUf23aApueDbP88BMYRIdHMAJRtgEIWMNKdIx7VO2jzwHYeyEMRjLdRxAPSRhWnazKr5zFZQxIIjrZfyl5y5sl+ImmdSPmCQkKhyXMmxM04Y5IYZH5XObMyCPHRM5uJMD4YZdBldg8mq4E4eMVBP3rOs0NoLTu5VtB2Z22+0N2Rra/U12dhbu4qyxa5yU1c58aeHyQpY4y2EhYBccW4aiTLVJdUzkL93RiRfooCy9tvm+pj+yuq8nGCij0AOsuJYtd+U4Gj2TFpTJnJ/ieAjP3xTwIvW/YBzNhI5cbNZJnaDkv2ZYz2uET00vUi+YC249p107d069MzJHMQk3MVZLVZseNIhuRmtCWb18H/UYzDMkO9HD8zVZVz8Wrt8SWE6uzxAHsgshJEF7AzDOY0vomzZxVImVNeLgTg7cMvy9x/P3Cd0fa3xDOue4nnF434tD3JI43VYTxIAoMfsKkIIrCrYcDzF9cn9EnOtcCIGBc8DxABza1OkLDjkAuDOh/Qg8/Cnj4U97NE89yCOkcA4Oez+AA6pvw0zwBwLIiVOtoU32hZunti72Q72PZkEZ/blmrVQATKZCl7jJGBlTZa79Ll5M2CfxGjHDkk8ZSDSE4ibvJgtElNrZ9nv4RcJ6kfRRZJyEPo6bICFleQRlEjABQXxXgBkpJ7yH9RAv5SpjLIYrIQOEQ9gfg0LmpdA2hAGQIAxCw6Hs2GZ59+gaMP/MWlwvDl+o2LLOc9RyOjfr3KQivMrcCeu3CA6F8GKmYd2gQsAx9DgHY6bAtvw7BayysNKihTGjrDvXVcbybgB2YGa33V7eVr7Mr4lvvohRc8Md2bmd80/dkqwPI8f0tjc92aZrrl3ZbbOLgde0iwFJu2MXbEvGQ1JWsnANjky2sJlLnz5/vTF4k5S5liZfsiX1qRxj+2mr5z2fCxMHf+0O7oXXv+TYajuv0fN6y7YElAk2hEWoQ5Mt7PN+NAy0qK0QwpjyuWDEWotfXDY+bgbOMOBOjOO3LBlqTiKIe24aNE8e7YcO3Do8f/+A0xeyE3346HF479E+9ZFJc/jgcP8ngDu5yEA5vA+Ai9ZT7z3qhYjX6dEEx1JvrrbIUEePBmfv0MDftfBHB/KIwr2HRxHsZSLgsweACF6zHPEwPx0+9PjsDwl394TmzDh+43H89gx4CdHqDy5mCxLGEIKuDaOF+NndOycpt+HhzjSuvt3t149GzvNCp7RmlXE/ue6y4KQNI8nrq89N7Mf11ZuzvJ7sArjlQz31OY0nzLSRuY/k2dG+N2ALAXIdLVIBIc8DIEQCtSm4MGSICuOYAQ6hWM4bYWJzTWX+IAiiNDY8TkELvX9CYMQggLxOxnw31CfqG8Fo35iQq9gUFSZM8mcGirIbhHGVucSGiZOIimt/WJ2bmAnLZ/NWpg9XSwue20x408im1gsEwAlwi6dP5L32SrYDM7vt9h22l94ptnZLnZy3bqO0nNfYFs5Zid56TVlqeXzygvutsWaq1O0CbXstOLOKoq42A0rMXt+EWyVWCoOoaLmUxk85PezGC52NWBNbsvpykOcl55Zr76Gsl0Xjhba1PITJ/v7WAJsldVJHIDh70fli0SlguMh0GYFvCmzSMM8U+z8Hd7J5ybJmZu8n1HmrMZykm+88mifCkRG1YM6fSXjSoSW4M6O/c/jw5x0+/EXA9YT7Hzf4vAPax15YNcxoP/Z49yfA8b1Df5CymmfG8b1PHPmYMpuH+dP1EjIUAXdkYzQJYQQ0Mw4TwMcW3UMDbgjtk4f7M9HqOH7Tw5168KEB3zXycwSSAc3HDu/OHv4Q9GLOnIQecUPo7yQFeONIxIk7DBl8IG3mW0S2h9afglbHIqDFjpM14N1M6HbpdybUQZmo2RHOKyRbjmmPrzAuvbvjuJhyqmkAASqbAZqSWtvR6tKM0iYH4WEwBRHZ4Tg7L0yBhTp/kmfJKNYQYhp1xhAKZa7LTOA+gHgKVBhtGplrOIwtAsjBnb1krwqaNsSQDE6mLrmeyzRAYcec/RwhQ5sALU4BJ4Rn2dyz1XSzGZgApGCrmufi2LHPft6+cp75bO3Yy9uDIVpGpNnAdqvZDszstttr2ATl/+LycnvlxftcvOlbYc1MhodMORwr2Q3X2pxDOtumG4Azt+i3RZTx/O9LxvbCRfe1Dn/CClsDzhS+mxP6nR1XpfFb0ycofZ8fZzQ6ltbh0jEzB+zeUktmyqoiijM2eT+2n94a6LLUJgCmhNmUO18zlrTZ7I5t5j3Ujs9CA9IyxueMQxSXD7ISMEE9o3nuZUfcEfp7B98A3T1AntA+OXT3kjr79IMO7uRw+NYF55Hjrn3z7HH/k6FiImaqorg5Gs1xVx7AwCQwTl7p+RbnMTiR4bj+rkH/ICja4YMXVsvZD4K9BychKG4Ir6C43mFxcn3IHJW3JQdGhIJJhCGjVkiPTCePFp2Ix8Ic60zWHkw/q8V5Op+rr3nfAMn4ThzgCrjOnhBTFMdjbZ3LoMiiqlTKRAgtQh+AoSx8SX+W5q7R9e1znh1jwSjNUEjQZ8sAKHquC6wpRwHoCfOGhjvpOZ4lA1KvwFClPAQQTweCMk16gJpQd80EdXAgNlo0XsKbIiBjWEEadgTicXtMzVehnqoPw62wZezzoGFSodGkHzAM3Ni2vY+Mtprg75T+1+g9RgT4QXBcwtiysUk06M7k42M050t9GQJ08c/rju1C24GZ3XZ7QfuNf+E/WnZgRh+dZZ+U9AFW7Kwuod3fdKd6JdV8UZjAksteymhZuDC/dfhSbqWX7KRjXAqzycbMxWFDtd25V7DRTvDMjmfc3Zzo5zkHPbb7lHNYE3qtXDvPNPHiOiWFeo1EBQvOzNycUvss6gUsvM0lc8GW89iobpeO87cExixhlNSs8GzloUvDF8bpC6KdkzpXc06ydZZKX/PwMx4zx1TKbEuNGfYQJ6Ul9HAhDAPwDaF7EFHd5gQcvm5CxqJQB0cxDMSdPfAcsip5PwAv6uxFgNfUX51vbxzJEiCjTicwOLvZdwIweTSPXczsJGKsjYRkBFCmOK9ZwMdc1/UeOEtl2Q19yo5AjoI4bAjxIMYQjiJlE1AM05jd0DB1uDqUFRiDLzYUJjmRhjA9FSmOeinpfD+u+7J3wBTzMsAjAnp4Baiy+uXl2LFhyituci2Y25gyjhBRKs4LDGwYz6NrKyPEitPaEL0krNaEOsXr6306gMlJfVTriTEIZCfH6bVCm/WI4tij8Ki8TgjPCYIY7nHQyNE6ktXb0ftoTTiXTefdc/EaSywBr5Ln33Qyh1Gi4Ix+X1k7jhhhCMBkYEpZlttuY9uBmd12ew1buRAvhnzUyl0JzlwykV+6cLnFecXvFzoXixzbUhte47xcaVPtUVuMXsNaqFqt7ewLecsQqvwypTaYe64uFW28pC7m85LWiqW2T9WrNkZfDJRZ005XhtzMATX1E697FpcCvZPzl+2PjcIiXs1KQP+a84LFBXpvMqyQCYcgMhmWMD4XMyAKCn1SATtrmkdL30nFUMsFVmK9DSLx4gyThzgrpl7NiXH/Z4z2owA2x28lOxMHp5UcA2cWIMP7IMIJEEkaYkkrTXC9B6vjRoSiUKmtU/xg4p56yZ7kzh509qZvEXUy+jsBhppnYdNEfZpYCAbHLji6Ag5AGD+BAWHBBwVgNHxDriW/U0dynZMvBAJNW1X7bu3G1pJ3Ys30OWjScKGBcTLNnlxjQ9rjEOLCoW1t/SyTKvxdtGyusGUP17MXTzMpjhg1RPCtkwxkDSUgoJ4PDGNglGkI4V6a7G9l3MQPZazpXbGCMs0gEEyMwCwz664QemjFhkUfJ3yXRemUNheYIJmkbDYpIKSuH0AZqZc8H75xUsdGNmobBWQseJNceMn61zbaGJwRwGyqgMq8nW0s21BSdP5ma8Lviu3AzG67vbStWYjbCU0/uhDg2NK2AFmSl9XMS6R6vSkHaEvwpAbO2O9vYRuDB/E1W3wJh4/WXnIpS2BL1sxCwLE6RlcDo+nO5NrxXwLGEsfTjtWtx9JUeVsCVKXrzJT/lkIaL7UqFbx6vHFIlrb9a4E3C8J8iseh7KxGkd9sZ5bNblSLnMMAAQAASURBVLEFUt6cbfVsajHaHtCd/OB0PUkK6PajDxmYJHOOO4sn6Q+io9J2Mm8wnDiFTUilfdcEYVyAHlmACm3jEKoyxcbIQd/4fbh/d/aD8+g1/XcAUkJ9m1PIpBTCm+AIXpkEJaAqOL3oWZgAkHc7gSNTIgEpAGEb3Qu7iLzD4YNH259B/Xj8LNnYmhtziwC93CkFEFO9a1hIMt4Rnf2Y8jiWVQDMkvqYay0EU0fAydQ6acl4z0NvCjbJHs2ABW4CiyQwrhK2Fml40SCQi46zBbJeMwN85UUbANAwjjxHtowCCjHMJgJIPPSX9pMzLL/Op+BF4RZH74fABhpSfIf79OZ5oQDGHCAgldNjOAKYxbJh7g8LMm3mIaUJOIdximwggi21Z2yTdeXPse3AzG67vaD96Ld/E7/x6781f+Ba5/WV2BtLbUoPYumEXQR1DHA1y6C4to2mnMySZsGGfXLpS63aLlswWUplTNG3XziMaW48LKW6y7Hj82YX+pmWSxyzWRstWjwttDXaL1Urse70c1P24t3bBeDMS9oW19sEHJ8IGXyToASwCCAq7sIC0+FKWwJPtwICN37HaiaV7qHF6csG7CSrUfvEOHzoAhPFHN8S+rDLzo0IBMdygihrckxLUSSYGAKKAHDel3fYgyWOu7nnZG7pg4Nr3nVRhJQI6CU7kwI1PoQ29XfibLsuaOx0ChIBMTW2Cd1ImCaMgXUTQkvYEfoj4fxOQsFcz2ieXfi+AEJcaFNMPqZ5cFYAhOBJN5CQIZVD0ufC0dipj2FfjFkS0LUMYQXMwrVsOE600Tsz3bBI/p7SMjPvlGSMa+iSU/CN0ixNTWCDKUvKM5wbtI2kDoiAZ3IPniGN7hPWGDESMWLnAQ8HtGa9adk9ARxxZ0AzQ1lR6mR+G7HQAjBnN1y1b83aQJlgXGDTuJOX6+nQbjMAyzOI7dgrv08SECV/1pB+VwJXqqBM5Xtb5n/7//q/VL7cDdiBmd12e7M2mgyNc5tMtnNinQt2xZc4AtcsaqfOndVAAbZx6l8i/OiFHIyalV6gkyylDDC5aldjCoRZAwTNAVsbtPGWuzfFhc+ScZYvgCbG5xItgSJQsmTML2XNVMp5aR2l3LZg3awFiPXn5K55Zc4a0kPX2/0tsCLXWlFjIzppqIMyL2wXX/8GgLsI/xJOnxPaR8b9n3VonsXxAoyTGY9t0N8RmhMLMGPGmYIy/UMj2YyeBvCDg9NfA2RGQGuNTREcwBHA3fkgptoE35fADeCPDc5fNOgCq4WdsAKOH4Rx03R9qhmSABDWC0QEmBTISXU/AO+A/ihsIQCDuLHqj9TmuJrO14QtHkOl955ljWnf6XvbMkeccYi14XnZfFsDzWvvkYRdouwRIIIkEooIJH1C6Z9zQL3OscNaxOjKKBOmFdHoCFz4LKzHA3xAAB4BdwbgKcqejMAYDH9LVisGdQLooPcR8InAIACQhAd6uOIUHs8B4tjV9NQRSFF9HMOOFHZZAagxn3FD6AMQw41khiJmuJNoOblOQgcRroWji9fR1OAiBKwAzWSXpH2D8liNDCVd2inTMwfXfAAenXv1Of5Ttx2Y2W23F7Yf/d2/KSLAhdj33EZ08BJQsRRwqIgnrg3JeE17Sw7LZF1qAqkXXudaWxJCNnWd6o5LbTFWWoyuZelkL/9b2+zYWqpxMXHsrE04f1PhBpOL4rUO5dbC1jfuu1tTpBeXn4/vGXAmt+9CWBeA9F0VwjQ0W9JbmbtHNgOSqSW6UKUyKlZimKneCvVA+8honwVsoZ6BhmI4EjeI6aQ5rNjJi/NodTlUe8Yf5DrNc4fmsRtAQCCEMU03RUzLrA5Xz0AzsAbye2Yfrt8MDplkmGlw/rzBxx86PP+COHiH98DdzwZRVTkYyXMzTr9snEED9kUGQS9tyAfg/EBganD4QGieegG5SmyTleBaDipYqzJlcq0Odbgts8ie1pvnxrAqQARGAKOuAGWSunBhzciSnUnCdIZySOuDYT4bxp3006wovYo4h3f6KG03SfgSa1YiBd56Tsa4zCWhfi6kS+8I6DmGBMVxqktlnYcCOIMWQAfpTM8DIBHCBZkkNbtDmjFMRXYtkEjZMwgtNmP10Lk837MLIYDBfBvuyYvGlIAxwpJxp0ExNwoGt8M10EPYWCYUC6F+JTZLPpaLoe72HaYAF2gQAGbEUMMhe9T4vfedeK+9oO3AzG67vVFLQJlS3LK1EjhTCkfQ319Ls6BiVaekcK+6QLLskMUL/mtZM1nbrbn2LDgzV7cNw4E2ZRnUABd1yoCh7nOhZ6My3obzb22tc1lcuBeYSrVy1wo+vjaD5VJ7i4u3mi5QbtXnqfDMjrJYZeV80pZvIBg9mcl7u4C1UC3jknO3mD9yAHQqjJblP/KM5rHHXXDKuSX0TtJMnz9v8PgLDr4F7n/GOH7bC3DTAe7ZR+FPyw4gRgxxip/1wmZBpx+grBuRWeJwep2/x8dFXZTAtGAIo6F75/D0lcPjLxGef+DhngmH94S7b3ocv+5ELyc496kTHYAXFJx4nTu9tK9mhWpbQgdxavs7gusJ1DsRA57IADPKIrQy5LKkozScYJ59BzDccB1d0+n1LVvBlhWEgCWLTXqNWqalRCi5ei8z6wxk7eIA2/kicBsAAbBJ4SzVTLI3AaYdjEPPA6ODo+aKyeRl+40yBkpIe03efoeoxSJaLYF1hiCuzcO1ozlKMhoJOOOlr7pw3yH6KeocGTZZHpo8iFIPAFEEcjQVd6ivP7qojwSWMDwEEMWFUMD2qY8MmdhOQRRZUmuHew0ZpCKI5hB1nbhQz9l08iPGczi2Gdg5SdjhhK0JGd9NbAdmdtvtFSzXmpmL11xkaxaXBmD4JLQNJqxY5xx8sovljSjpa9gy9verHOdK6NGSfsuP3UKUbRacmTjvWhvd+0rAsSbIm9TtCodtsl21D81iPNGaWQAg2rE0lZ40ttNKUHJOEHRrS/qjEsI4N2bXPA9T9hZBok/d9Nkqvm+2ZMdtzLJbPZZK19Vwmhxk8OKE0bMPu+UBvGaguyM8/VDAhsOHAMYAgJNMR+qI2XTH1DGo4RjSEcNFvIFiyCAhyY0OwEhZU4XLgA4BFnxjkvvo7hy6B0L/wPB3Hu65QfPMOHzbo/1wjo50ydSRZABoCeycsHa8sBrICSBEzHDPHgcPNCdCryyF3s4llT5BfU6rAuX5uqnEDIX5XMM77CFeNE7YOQEq8ncnmZTnzjrClfro9UbvsooOmOmv5LwAFuq4JMcjllQSJsSQjGA9Ul0gu77QDFPmHA1NYg8ou4KbwJZpQzakPmC6ftBGiuFIISOY9wHgaOV834reEAA0Z4Y7u/hMCQPFwz17AXNq7zID1LGCOX5oKxW7LgFyEgaGRBNGQu7MOAusH24J/Z3D+UHq15wZdALaRy8aMgoCdQFkU0AmMGzie7AXlp079cOYtUwrQpqhLGPCjHIuTTE+LTgW7qs4j2T2KfoUr207MLPbbq9kP/q7f3OdEHD2MtkqrOetUOi3AAqiTdHNlyzYp5zYuTKyc+0CadK5XeI0VxzV3Nb06dyxF4+x8pp74vjlDtUWbB/9eauxv7rsHJwJtkhotwbGVMdHviM638lXg4pLbUE40Fb9VnZAZ+o11RclgDI7j3ofr3OzRetrsiJzdufCcMlrMkBN2guGQ85ZfJYJ0ckaMrOYzx1E/DPsiDdnYYYAABzgzv2QHtspK4BDamyC1xAJR+I4szrCeYUCCKBOJyPdBbdjPYBLJVOHUHUx/EGcZG4A6gjt+waH94TDxxCS0XlQ62JGnDxLVGSUOIf+oUV/H7LwdEFbh8IcEIAt1/fwvQPdOXAjrCJxovP2D7+EtpP2TMeH1ZAa3WM4XrLi+IEVasCUGB7jVWR26p3vhrnMzBMx65Ayovq0jEE3JZxS0gfBxLvDMliTdg8/AoNlXKCE27BTtoyTkJ/kGIrnRxAh9rH2oYAPqinT3zn4O4f+6IRF9sxgVp2lHDxACGuTz/2BIijjDxTZNL5h9HeE82dy3OED4fgNgT72ElamQFTSriiHWgXQMooQj0K1XATSFJxhJ5CISC65oe7hGSdmYXZ5xuHR4/BNj+apE9DKBbDpEMClg4vMHau7I+CNaM9o2yehRCQAJnpfHiP5Mzdj5EOGt1APZfhIGwzlKJMptuluq2wHZnbb7RVt8Q5vvtNWOydnhizcIX9Lk2eVXjlhs6yftSFMFY2PkSNbWuwXzl3t0L6wE1FydC8eE6PFXtm5Htm1YWYXttmckz/rQF8ThqFtVWoj0x5rsiCtASyWgi1Fqv+SvtpiHG8YwmftVsDOmuNvBs688PxxSVvOMQ43YWzdWuzd2Crmadg5V8cLCEyCDkAbxE0JOP5M9GeO36pILgMdjACp2Q8PrArqGTgI4OMPDs44lsnmuTIymiEEiXz6rNXuYwgnpphdKpbZupBRRo5tnoDmiXD8Vu4lB35kVz9rx/DM+9bh9GWL5++J13f44IcyGCFtNyK7gBqpmIZ2VAEfAKR1z0KTE8vCP6KAMItDjJ6B1kUQTPV5ODCUimM2MJlgMu6wgjm2zVm0SWLbcOmZGNdz1hQcIIR+IyPui1ivyPwIoNDgiAdQgwjsQnppCwSEMeWbAMw4SB+FLF5ECO3lIrtKRa39geC6LBwvtscAGhIDcByjrtgRmjOC5tAA3nkfQpxc0B9yDv0dhXHUAT55gmRcWwAygEBxTPbDeOLwDMO5mKZe03z7YwhRIrlv18n4dCH8kDqP9iOheRQNGHf2aB4l1tAHrR1/cPIMH0NfMAbNmTD2EuFsZeUFBp2ARPpsOxmvdm22cMyQAmHIwgJ52GSQA0PZyqQJbLDRZtMLzsmfqu3AzG67vbItXpjfwDmZvNxS0OiGdsnO+MWO9MQLgyMYNjjK8ZyXcoJW9P+UFkbNru5n+9KfqeuscPJEm96S3VWq06uClhPgTM1RLYn65WbLqoEzeszFKWcvfS4K1P4l9pbA5Z8nqz6PS+erChAz0h6xx1fChaq6aoXr3Wze5sHJBsy4VKfSheHt9T4k1EKd0T7oZbiecf9Txv1POhzed/F816k2i01jG1ILMxBT7zrZuffHRpzr3sdQjNgGQQuDQXDeB8AA0yC554HxEpw/BWg4sGW6O0J3D/gWcD3gTkD7UcR6oaAEjdsq9olqdbSiseNbxLHgzh7uzGAVgvUAQdhCeEZkacRQGnYAcepEegAu3dnP+zD+9GYuDA67gGjSD+xDJxuHXsN7B5YN0vsiJMyMPGtUBNHM2iTRbckZHUuNhnqpVgk3AmQp68I3LgIrIABBTNqOK/2bD4GhZNaKCsxwiwg6NgFEaE4yxnxD4JBRSEJ7MDzvCcA5XFvCpoZrUcdy7jOhVYDRpM0GAc2jQ/vkYlaw/iAAh+sI7uzgegGWBDTy0GxL8DS8h3qW8DNOx6b0ixMgpVUwxsHfkWQHO0q9m5OMM8dI6icp533sD986+GOD/sFFthI3iP3gOgEbNV32yOzzGp8ximBSspa2+n+lsZR9Rh0LkJlP0Yzi+BOGHkVNoQR0fAPMxbduOzCz226vaNdoyxSd2zc86eUgy4sCP0t39y9B862jcOluwEa6N6ttA2Ap6dcR7TjbrZyjt67WQQm/LHC2psbbJmOwEk60yKac2Aycucoq7TsFzsTz1l7nAks0i1aet8bm+maxKOJug5UW9TYMt/TsW1Cm1LQGnEnmSDuGC2NtBGAWHFzNPLSpZRoOxfd7DEvxaJ7F4dJ6SohDOLYH2icWAdDeGyAV0pZ2zguhEcyIoQ4WAAg3D3aZE10bzxNzsOhmeDBrKt0QvnSUkJTugXD+nNB9RuiPwlYAh5/quEdtFPnP9tEQFiWeY/vEYbHDwpZhoL8XVg55wJGXzEwdC7jEwhTSfxIa4+HOBIQQsND8GPIsIx2ryf0y4P3gsIdjRL8ndiWIeJBroeCMNkPZ9l2VgCyMAfSZe/8ZYEX7wlo+j6eaRuFcBU6yd6YP7c1O+2DoW+k3BMAwAFOBqcQNIQrb2qr2QBOACAF+OAB4gRGmjBzmKGrdKHULAupQb7JR+RQIIAVVVA+npzT9NSACuh8JzbtGwuFI6kUdD8BdAEgpgBhJwgIWUIY6PzBktF2VWdSGUKyDEfMN13GdjNn2sR9YLowBkOLhfBXtVU0cCVVCzMjmDCijgt5s588E0EqfM8qElNGmc3EeSpcOKo4sGHKF75NOFzBmEINOn6lSqPZuY9uBmd12eyVTfZlLGQCzE9zUC37BgnSu/EuAldKCYimdf47tUS1zztG34EQFIJkNJZm7xlLAoXBciTX0GoyYKap+LRRqlH7RHDsJzlxppfJvqqW0ISgzCbiu0T26JsRqSfnXhp5VbOk4vXQ8XzwGloIyOeMns021tF7RFolbL7AiKGPasJTBKsl4Ys2OSQvq2GupM+O3BWeS+W7GSEMaPANnU68WQStGPhdmiOrAhOs0g9CLBU6jLknnJWuueTZj2FJgmUCdvt6HugRHMLR1qW9TkAfiSB4cuncNTp83OH1O6B8EjOnvgf4O4IbhOgLOWgbFsI88S05cTzQ0sBBagjszDl3wLAk4f97g+UsH3wCHj4zjtwA/exB7YVEwgRwBBxFYHcJfGNSTgCsWkFHQcA70jiEa4e+GQkrv4R1HbNgwWVhYCZAppvGem8ctyyhhFiKCPMlnwPSGiKOINwGIOimaHcl1Cq4RHAf9HpPGemBhsBlbAYzRtOg0lM0h9Mu3AUTqAmMnACEDi0bGrFMtpQA6RWApA6kiFhBAIADJce2HHs1THzVckj7X58sAaUMbDmFdAp4EvRcNSeNwn46BZy/jnUNY1dkHlksf2yFq6hyUXgX4I0XAqH30yfMpbTv0fdSNye8fBmApzb8WyAm/a5hSkYGj5gWIjfXQ+y7pTREBTtGrDOhRoOsTf++9hO3AzG67vZItEVy9xAG/2laGkmymTVKxq8pb6jjm91xwhK9iKywFyQptv4V+A+mmY83h38BqTJScAWHFFTdhOqwEBzZnal3aX5dop0wt2qdCDwrHrNGtmazPlgDQDW0NS2bpOWttSZjZJ2+ZEzgK67CW6CIYG4lrGpCB0t9rgrRSjxDiY46JYreFsvO6rTUL/k7Oh0BkzwigwzFFryOPxhFcE7Ky6PxZeP+M7l/ZQJ2X0IMQBqHglzIVyMvuO84YxKiVaWN0WKJD6AByItbLDYEfDujeHfD8/RZPv+Dw+EPC+XuM7l0P8oTmieCe5WfzDBzeC3NAQpkQQ5CStlbtjqZB/65FF0I6mmfJVAMA/X2D7o7gowOd/ozMCtUZYXGM26ce7rkfdGHCPdk2S8yOsQYgOChrR7/n1qXnquNptWiAcqgelwHH2lrKhvRkv6RWZENm98QcGRTRUdeMYMCg2dPLsY4HoWQFZCJI54e/VcA6F6eNYW6aEjuEu7Go4oJIRYGHARGzUQUNG47sFMRMSyqMHQVoQ9+4PgCaDdDdiaaMOzOO31JInx7GeakN87kLoZ+ZkmchYS15Bp0EFFTMlB2FZ9cw1BoBMvtjCHu6CwCOpskO2aZc51MgRusVUpaznQtiSBUS1pIAvoEFFMLiIihqM6F1wgRLNq1K65LImoGEADoXQpWytiuxJfO/C5nKdkttB2Z22+0NW77LXwt9qi16AczSvqvnvaYtCLFZ5NjfaFc/t0VZl+asUM91Qq6XfTdZD9MHNebOXNlTTJW1oN5S1ssn4fAmDqb5mGeea2tz43v2GVoxwKa0Pa60LURwl8yTudWuOQeaXwvYfGd2DRfoHC0Zw1aAc8wYJCS4jb0kQXawQ11iOlvVcQnnaogPgDHLJqtLrMPa94YNxZmw2vih3g+sBA1r8ixAQs4e0t1voqELjANsn2vNpMJEcGcPZhdZOeo8x/orKBNTBQcnip2EsjjRrOnvGzx/1eDDn3N4/POM85874e7zZ3x+7PD+mwfQ37/Duz9iHN4D7XNwOE8hFCPTUslTiPuDQ/fO4emrBmDg7hvE9OB89jg8As15ABGcglexgcXJb3pGE9rVnfqoCSO34+L15IPM0TX1AQI4Y8JB2Ek2IWX+xPCoUFYtu140ZSVZECyyaRaMOwZyNozUS5zlUmhq/CzQY9gJo4gNUEIecJ2PwJb2VWSoqZOv55AzLBaplzuLv86EqCPDjQFjMNQ9gjidj2mlOXSThk4JCAT0d4T+jsLn8ly7jiM4I+UhMGLCWG2B/qA6LQ7dwxHtk9xb89wPz1fI5FRcjxCBzEMbWT9OgJbYH1lb85EGTScQfMw+FTR2CHAe8blQDZk4RluXPNMAgPjcIgVvevM7Q8KvtO80RC3oTfmjCAE3Zz+w5HQcmbAlBaASK32WAzJaDwzHfldYoi9lOzCz226vZEsnqyXOw61DQ/L65E7Q7IR7iZZJrhtiykh2HbeyK/RWdIG5ZUrhfAfjRV5uM87IrXf8t3DQp8p+VUto52VQJrfF4KPaHAh7LVC5gSZRzUr3eksdqtkyK87a6nFUcLRuGlb30lYSxbzGauPZ7hTz8D2HnX70SEAGguyuoyFxXPScBGwOoA+PHefVz8naDZBgyTjoeXjHZfdbD+kKxykjoSGQN+8hZUCw6KxwQBgSXQmf96EHe5I6IDiaBPhjg+5dg+6dw/OXhNNXQPelR3PfwTnG6dSCP7S4+xnh3Y973P2sSxkAQAQjtH7EHENJorZJaZMiMApUo0O1a6iT1MvJOzIwIoiD09/5AWQqASCGDVBiwSDiUyGMJQAzICDmxqqBOwkQhXI9LBOHUJ5ntVj7cQbKRGYJIRkDNvxHx5voAgWmDAeQ6ywsrSYwQAAEpgsCOBDG2B2huxdhZgBwGt6k7RSyCHEj9fbNwHJpzgH06U2f2ixaAHBWIekAgPggomvWRKrBkjy7RoeGHYF6QnNWAekgSv2gYUYO7ZPoDzXPPdAR0Pvis2t1j7h16B8auZ8mZ+5wBM2YSK6jYGQAmABhyVDQl2qee2GEaRiXPschK1OcnzzDaZpqk5GpqA2n6dxJADNupFzR8wntbYWSQ+gdBY0YC/rosyUopwnHU5Cm9LwsXN/sVrYdmNltt1e2TxlNHqi2MwdOLFSv0srZ2pawD3LAKDtvNTgzt6CPbJzlRW5mFzrir1LXFfV80cVCPhZeYtFyK9bbJeUucFiX6llNHXsJ+2Xy+C1ABmPf6TAmFVKthSxdYZpxaLQtnVxbfhVB1spxhIStEbVb1DHuUQ+LWmsz82byzs8cemIAnU9CYGpplwHEEBIJ/5Brs6IcjAgaCCvBOE6UOurKThDAwQ3tot+3Dt1nDbp7aSTXAe1HgP+0Qf/+AWdIWuwvvgHe/ZHH8esO7YezMF20XgYIy823Ljq0zbPH8Vv5vDl5xGxAjJAhxoTX+ACwBdmNyBrQLFS9uWcYcCV2hkmBXAipU8CAnROnuXUDQ9anLIekexjjtZ33kV3DDQY9DgPIqJ7QSP/I9pdhRti05woWQO+mR2TG9HduYKyYOinrSBky1A99HjN73YnYsrSfABwKtAAC6LRPHMEc2L5xwgITRghiGJ2COGRBOq/XZpBh9oABehrqpSFrMYTH9qcVIqYgSn3v0D2IMK/XVN6G/cEUUlGHhhmJ3jsBZSQEqUH3IGBPBAgR2rCjwOIxTCC9vyDkm7SBHTs0PMfKqJH+4SEj0znoz/TmWTbjI9XcMSFkrepPiUA2jJ7UkKGNYvp40rA9b8rGMNfkNtpoYBbwUkFGbUtb5m5V24GZ3XZ7I3btLurk7vqFu3k1u6aut9wFfyu2JXNmXLb8fDHwQ52MEiBVsNELGhi9zGv3kIyJinaJjr147AuFqxXrVdldS9hOFVsabjPHmkmepzWhiheGalxlGzBu1rCqSoDO0rC6xVYa46XxvvD5+WRtYyArKZo5cZqjI83B+YtgGlIdJS+ZcoZnhOJxNiRBdoV5SCltrdRfE89OkvVpxtgHIVej45HbKFW4vQ9Nd62po0vv5aDlIScO+hpJViEH0aQJIVz9vWSxUfFddxKgqL+Tmzq892ieGYcPDv6AIS3ys5fQpUcJlYBnxIxG7ICmAH6E+4kOJIkDefgQtG9sGucAFKhoqRwg/7gRcCZhTsVGNO1mwzFyR9FjEIDV70z7J5luSpo85lpA+T0wjEEDxihgFc8NIIR+Z8AXAdkElBHQi2K6Zt+SGc8EDx/DiPxh0OYhFgZKDFfS58MNDJrGhp3xsKahnnF4ZGFmMSJThjoJs5H06xiescCaUYYMaRgXIKwYJ6E1ToWbtT4s445tu0SWFSKYKv1WEcFlRhP6yT37MMY0rIoiUycJRYtjwdRT2+bgYpaqKJzL0icuAFzaDvJz0DQiDzS+H+YHG7Zk5xMOujPxvAB4ZYBMBPjMmI4bpU0QKQ5gTdRe0lDPjH2XZLFzcr8UQpqqOnRZmFIy9xTOSUDo3SZtB2Z22+0TtFXaHPkiciOxzqW73LfeKR45XJZKucb5nFuAl9pxAhS4JTgj5cvP0s7cHHug+H3pPmybXONQ1mjea8w49aP6L6zbVWMvc4oiBX8OnLGWLWbix/mxGR24ZJfo/SS2FtC6FFS5YtyU2vGSPsw1T0ptN3de8ZgFz7d1vm45H7yUjdpB6e/X2IKNgyJl32vGFiTO92gHPn4/OEJRJyI4h855uBMACENjsq/m3hWEsUNjwSNlP6gGhTfnW82XqedT9UIaRMc9ggW2Hk4GPDmKDix5P9yfOrjOAYcGnoDuocHjDxr4I9A+Mu6+FjFTBWkO357BjnD4dmC5REaStp3eU48AfngR0W3MPeg9EmIWJqjDbPUvgGH3v1FOlAAI7iwhG6RCzxQaOzAt4FiESgGUMslYLR1yLn2kVSwFCOmRFcgLH+e6JKWwjvzzLAQkAi+jd3j4PojGDumtw0EhvES0Q4QR0x8pijs3zwxSdJCkPhLehEFDJogx67nxu55B7GIYjjJcLGOHjg7dvdRNwoqGdlHWTs7IIs9oTgw+8ZAdyUmjsA+C1S5dyxEE3PGaiQgGrDBtynnbe4rvUeLQHr0fwoVsGGMMDRpAi5RJRhEoop7Bp4GhFttDASoD2A3jhCKIKoUagFEt1MGdx2BIrJNhnURAxrkQppauVYdrCZAX28UeU2S/BEFxhjyrFbZefDeaeUueDYpjPwKoNlxvt1nbgZnddnsF01TZuS1xOlbv7G6hK6HlXGAXMWRqdS44hyOHtPayWbvQXmIz7bq1M3YNsLBYk0jtCsButHNinQCi8fXN51rG1rZFmVaIVHd+4874RBjauou84ALmpcCZufImwOIRQ2qFXcPsW329ApiW74izZgj6rrBmdMGdaw2stZWslKQKyqYpPTc+CAHndTPgKntEh39glwQnf82zqPdg6P45sBe1KloZE673QMdIwicW3Le9ZwrAChOS3f+Y9jiYAgCig1Fpr/CZPxDOnxH6BwAM3H0tAAidgOaphzv1Amz1nFzD3ndkU2goEFwRGNHzlK3DodoKzOQONICY4SdJha0Alwm/inWyYJC973B8LDeARxz0NOAkLbc+wzFsDCy3quBPqR1tuI2aG/4YwsZMVTmrfwAQ+yCiq4LNUTuEXAxT6u8GsC+G04Supg5owPF7CTECOAjRdvcirNucGMdvh5TN7JSpZN57BLATIKe7l7ZqTsLAsW0hAtPhHCftQIwg8jv0pbJkrAhtTKUdADUfwohUV8idQ9iRATuTbG0Y+lzZZAKcCMBInWgumRNC+6egjPaBTcUtKb6H60VQR/s9NkAALxoasb3c2YTZQdvDg859ZIhp6FwSwqb3qHovChZmoJ62f6wTYxhntq0sYJKNY3kOZ+YiG26p4aTafpaNZp+/rcJFv8O2AzO77faJ21sMCXoNjZFrQ8Guu/YGnXCFlssmgMYaJ32BhsLivqhRwUv12RoYuMRyurlaVrfVIWcTTmCpf/M2vrjvLwFn9LxrbSE74JpxXWMn5doa9rNlBVcc2xIryiyKaxIoL2WbC2zfMIQpsYkxUgRQJsbnIHqpfoI6Q/JQEQKQ5jELpOXPIDHL0LAANA36HzHcxDNADkSiHcG+ch+V+1dAhlhYAK5DEnpDuqOugqgKBGilo45GqLPqpxzEiVSx1fYxZLE5iyAs9T7t86TKg6MJhjBRlI3CDJaGGZzaAJpxK6wPfxCgwxEDfT96VlwfgLSeBye3G/RzkgxTsaEKYyaGdpj02Rw0WQw4w0FbZCqluvZvMXw1Syech+omABuQzhMKVinglgFToBBac6ConeI6Rvuk/RT6womwK/cqBIvAQJHzJLuRhC65HnAnObe/c0FLZWhnm6nJdYzjBwk1ajTjFqdzqTJyEuFhP2QEw9lsXmlGpcLaIaZ317ZQvSTTpmT7Oob4UQTxYEK0Bn0X0972vcAKfg0sqST1PMLzZ+s5AgQhoEzrIoMogpU6Zns/XK9nUN/H8DSiYR6JfQ4B4+z4YDufKOBTm0ayMTiM2crx2qa1ecnMSbEfFazMz7Fg0G6TtgMzu+32glZjytzU5pyupc7uwuNKzk1RO8SWtYDKPvsd6oDAaMGbL/Kv1CgZpf1M6rRw53UmLKYa/qKLiIlbKIZ5lSw6LDTdJwvGwUXABA0LmLcIOF5icyDVSJNngn2Qt8tmbTQLjJjF6K3txsDbVH9sOeaKTL43QOe+hoFkzy99vqnNAYb5+8MeXxpDieMUfvfi0DgOjhxJJiJWgMGROO6V8ovhhD5IFdtNaSegyPnzBv2dEwf6owcTJ2FIxfueCCclFfnVUB2DGRe9LQVnXFpmfD00Ljr49z+T8JXm0aN97EBnH4tUod7qmGZhAMCm9U2EZ4cshpK1RwCG7kHynB8+qgYOJ+eAIeKlZwwAVHD2yeoDTb3jQp2tE8yNbUOtl5nz1Fl2gS2jwJO95fy5sHXIQz+i1ke4ARtWoscqsAaE9MgDKCJpy4OmTCvft08+hprF7EiaclrDxRqENNeA64HDRx+1X9zZCzvnjtDft+CQoto3wqRRQMH1ISRI71eXDH0AN227KWPIgoba/hEIGZgrCq4l85MjcDfo26DzAqgZBpNcWCsiDBJuQzpzb/R5LGhhQhvj75mQswU+9N6UgaNaRhF0yfSIAAy6LhzApaC75DRLWA7GBpBSfjrDIgv95yiOCzafS+UC8JNsDtEA4tgxNZPVaWSF5ylubHiW59TMWUwAOROTpuBSvq7crWg7MLPbbm/cShoLqxgSS3bEb8hEuFQPZLPr5Zbvql34ongpZ7UMNM2cVHJQ1tLyL2iXKrPDhhpkYUsjs+DRVD02GLMXMY0q1N+r6pSzhuZsIWtl9TxRu06tDlks/lX2gkyopfpY210w/BecyNe2a/vqxUHTHLSoAcVTbZs7Yjp/B2fQGx0PCkBNrskAYAQYjC7DEMcHQzYidYwk/IPQPg0OFLcEZklxvYShE+unfRDCtaSwQpuY+mv4ZSI2akIhtE2aZ8bhfQ/33A/hG1DHtA4cax00tMhq2TBnfah1agNjphVxWtcbRzQ63YOjT71PGROGjTDUYQAAhkYbiyMnYsAx9MUBrRPwCYiAD+n52ZxY1FwqWOyzHNRz43CUpH9ZATgBUOAA76S9+nsCWPorpp32HEV8h6w8CGnUAXeWC6tQrbJxAMA7BJFgQvvs4T5IWc3Jh4xCHJ+XZCMqgGv27xjqq2BIoyBatlEU+zaUHUALCs8oN0Padup8BGbYuQhAJX1NHnCie8OtMIVsn2i7psBSKkocQT/PYJMGXACIYbMt6tzY+0AYVyE8izqkoFLhPc9EMU32CIiJTJkUhJGxMgBmOWNnBMqoaX+bds8tsnhGX2QgGBDDnbiwVhulvd9BmUW2AzO77fZC9hv/wn+0+pxNdnbXhKcAdcBioUOxGjiqXeNCcCBaTrGcuuYGL4wp1syWNrsQXHAvpX4ZhcVc2C7VPk/imTmt90K6LIDLwm60nEvPiQ5buvhZYouc/Lwt5uxFQYzp+kQ9ia0Amle2ScAQGPpnBQMmjpt8N3i3aSuN8zVjX59lxuDoAIPDF9gQAIzmhTg5+Q54kuo5gENL2HDsOTqlzVkelOY0sATYkWiIEMGd+jRtd81pyq3Ashkd14eHNIQaRHFZB/hjAw0TcR2DzsKQcWdlQSAtfwKcjk5oCWxmyWLDnoF2yHKjmW4k5TDSMJNQJoJeTWQb6HdBX6eoiZG9c5LvncZ5hQw2as0A9ozqjlD3WC+U5wB1hoO2SXT0QQkwID8Nm6FQ1jB3AFZAVtoiHKMgH0G0WFrJoCUZlhjNOYjfhnAtMA9skIbCmA63/8Ro2cM9S5iNPwiLaRDeH56dRHPNNlkG2keQzWMANXNQxralfedopqzAIgFRwm7SOiWmTKO+XLYyvqL4NkxfRm0UBnGPpvPmOqZfvD02XDOwdTREL2ZBCscmwI05PoJzbSoSr6mzo0aOzSCVMcbUbOa5UehSP7DeLCgzAjXtz7n1iB3btbl5B2RW2Q7M7LbbS9mKBeWS0IdFi/tLJsQLARlrFzkeK65TBX8q91sCZ651JItZQirgzKJwpq2d7dJLtxLylL+Y4wJyZZ1m27K0+Mzb6wKgCVjQn9cwbEphEyvqNmUjYT+M7yER9Vvh2G/BYimKp+bOyWvbyjDL1e1Se3YLu/LxFOvMvgGWzG4YHCx1vnvIbjxzEgIgoQcGPCEyzzonIs6z8ynkOHfyaN8DTcsxrIEdwTugv2vgzowWEHDGhzoUAJocCI2fZ2MsAY0sS7EPgFKMQWlE2wVA2/kYshR1Z6yjx0iYAUn7wDh7IZVzkooagM0oxI1Df9/g/HkQtu0Yh48CCEQNElu2hoAE1oH0yeA8RtYJY9DuSDol7SgJTXKDk6zHKNvByPHUxJyXALNLRFSJAUbax5aZASDRTSHWdNbD30wAh+xMvkVMVe3OwpKJ6aI1nIQRQRoZF6EuwXlnB2HdECKbw519GHsDqGLBzdgutXaI4IceO7xH2bP0hzPtrJtroW/1/DzsL0k3npevoIgCekRozpSypZD9dBzYWQyhsQXABLbcIRRpYLwApFnDLLin7B8NLQu6RVa7RtpIwWK9zzA0lakU0maPhpM+m/q7/crOAfbZLb2TShtnJWAmf+9ZkKh0vFkvvcTm5aduOzCz224vZD/6u39zUmNGX66LQjyW2A1R6hG7Yo3lTtScjkAVbFl2uRog8pZ3rZeEL83t1k7aXKiTBWeusGuc9oT6XWM/mbE0qmtp3Mw58EuemTlWV3aNJf20tp231EhZ8iyPAMdCO+aaQleNnTUgmgmLWCrSOgVuFbWRpubdAthod8PHTmy9qN0ym3tXLBwjUZBXHQftn8AaiOlkS2Xn2gnBC4rgTKEeeVgKeh/YCqlwroZPdQ+ExgHNE8Shm3H6Uyc3OEXq/JXGVzZ+k2eezS68AiLq8JowrOgU5+EPjhJnL8mO5BBDWkb30EgozvmdNOLdNx7tB8n4FIVv8wwutfCKGAKCFGAr3PvgRCq4g+F6oW0sk0LLsCBVAkZMhS7V3k0wfdB7yVjVZP2n7BIFxiPoNDjmrpPQIzYAgwBYcrAFt/zRIWbnUWBHw9QCG0e1foRVQuEaDAqptTUVdGSAeMOOCmFWpY0WDljHiHllzRG8DeGhVN9FbgRDBifb/qHusY0UhNDQLs9StQ7xmSFA0qjbjEGx/eXZZgzHJ6B7j6ihwnFOGd+XZitiDOAutyFLU5uCfe7MotNj9F9AgeGUAU7xvuOFCmBNrLs5pbiZaI7Ny84AyeK6I2fY5HVDupaj/JnebWQ7MLPbbi9ppZfSxMs7WoFe+FqU+KtAGWD97nEWk14tZ8KpTneePj3PaBwbn/5MrMRmyOjcVcppPPH6NloNyhSuWQNn5LsrUJ9gV4OKQBmcmbE1z+6oHScoxpfMCXZsFc8P97cW4Lx4floItKR1mGekJc7sgvF9FfAJpGDiS6TIfm12zlrQZGl9p8bBGgAvOHXsENIFByeJHBz84Fj60PGmbAV2qswHPTZ7PyXslpBNJglzcWREONMi89S9xWfJgCqa4tk+d5MOlV7HM5onAUOGbFXpznZyfmn+s8eZkI3IFNCyNPNT4yLQIc494J4Z7rmHO4dU3K4Z2gHSX/7QgFqGD897rneTZGYqmQlVScJJLLuh5+AcFwRm9TC9RIFJY9ui1O6jd7cZMz5kxBItGB/qSiDHg2ZLAJQi2yLUiymwjp56+ENIn+3MAOglVbSKA7uzZAUCMGQeagcGhzuLrkzz1AlYFvrAPrdR4DneAASBmWJbFN7lQ6MN1U00dpKwJxQBuqFdBjCQVH9Is3j1mUi0qWMMKVJAsqF4rfE6CkhC9kxZOfhk9WL4MGR4UsHvmNq8G0BRMtexv4y0Z1RcuGTxnb5g7qywmCff3woWGQHjnMUm10f8uW9KLLMdmNlttxe0H/32b461Zq5YUE8u2i5wGJder3rN3Jbc21w9J3ZYdqvbrPbBTPNt9hItAQkrgB9b12Ko2DUhSnNWCltawvhawJpJ+mCpU5vThzeiBefgjP28aLds75XHV0GZbHEcd1nNgnHU/hXmgx6/ymphYLe2Wz4PU7bmmraf5+pbY6gtBX7CsRQctihcGvpfdq4dKDgUBI5hHRZwUVAn7o5PAYEzYQIRHGdxzI7vVbgV4gyqg6aOr8MkI2aJDlRu8XnvPJwNCcnLM/epz9mcDlPMamSAD009LWmxJTRFwpeELdA+9QNQkN2Pbxz6dw658KoK17rOZ47t+P6T0CPTjxEgUkdbBYsjC4gic6eUjrvIAvEz+kNTIR0ujC0FCQGozoqEvmnGHgAMuJ7hTqHd2zSFNocMW+5pAFpcGFMqnjzcCOBOHu6EkKWpBz33kr0qAIr+2Aq40LjA5gmZd+y4tKBLeRhFG73PDRBBHqBT3pGFd56Cph4CYFlGnAIZjdSd+gBMdQMolRQVAC9/bILeCwSw7CS8Lg8XKoIpKDyPCtJ1LHXsB5BtEOM15Wd1GhpsAGWiCDkbMeYMOJzVVizZElAmVk4ZV9KW5JywkAI4N1pL7Gv2RbYDM7vt9sL2o9/+TQDAv/xX/q/FibPoDMwtBLc2XQAvCA3YzIEvXW/tRF4BeV4kze+ErU2X/ZI7C7fQCCnSY3VRVVuQ1tpIj58C8HJnrXbcnDNXC02au96C60wu1PPrZmNhah7Iy609l3Ng3CR4tADkvWo+qDGR1lhkN5TrLAvXgijq2jmm5By8Rtx83mavxZRZa2tCDJd+tuQaCI5gAGeUqeGPDn3YTXfnCuNCxxIDRe9pom4RVC6wbcgzmsc+iuwK2DCEPVEXWBM9wE0jIsIhxJQpOEKFSWXt7rTNnJNW3pZpQI8loHBIEe7vWvR3oifjj4Q+6Nk0JxFBbj94uE6u7+/aGL4igAkAkjTaT185dJ9JHzRPjON7xuGDR/vYC+C6FJQBkIiu2veLZWTYdxWHkBKk5eRZdCKro8BGGB0LJPM5MeB6D2aKAMFwXABlDg7cGHAq6KC4XvSK+tahewisGwbozNLOTz2asy+zTTikcX4OY1/Dm5L7dAFkwwC8NG4YHsoyMfeifWevo6b9kYS55cNpJpSvaFZcGEhDwbRvTJ3z51XuOzDHOsR7JgWyTMgXAPGgu9D1hjmigFNyvZ4DG09A1pHmjgEuklu3IVT6a7jPyBAzwHNyL8U2yvohaYA6KFNk7nrzU0OUCuFstjz1f3ar2w7M7LbbK9nf+R//g3WZmm4Nzsw4RjWncpa1s/Talia71mq7qm/AVoFCC3a7rxIuzejpU2UtWdxPsiuuGasVaq1cc6LcuX6fa98LGBsjmyg/B10n23gKnMnKq4EquS0BZ/JzR+cYAMSet4pBV/vuGnAhnF9eVA6AHef1n5gvqnPbIsd0WujwKmr3VLjX0nbMGCXfacv7lyWsiJxkI/IHEqbAsx9AisK5CuyI0Kg4QrWUs7kVx6VngH2icRNT4Grok461JJzFFrJy7Jr6jMQ69dmoaOfkujbjQnkIbSECHxr0Dw3Onzc4vxMWB3kBZQABoppnAaL6g0P3vRanzzUMJzjEPeCPwNMvEM5fMtyJcPya0JyBw4fA8uh8GlZiGBxJnTWzEQmwMNzXADiRebYTYeDSJoOjVJhWtYds+EuoixV81TJs+wuYHMAEUiBnYBrYOVZSXQ8Cx751MbuSbVt39imoYBlPARBwJgV10kbHVrIgAUO4HGmbmDrHcC/5gHpOhIwHnSCKY0O0gEybTs2Do6G2QP/O3udEJihrURPIhbYN4uAjRgsJSylvx3FyifF6egBPTIYwMhpBhbYq31MAcr25D79Ov6U0h0yFJef1GP2tIYvOXf5e2w3ADszstturmqLHVhR4csE+sQgbnbPUybx0UV4KUZmzKabBpYDKCzsVZUHPcb23Zums2gHVS19RhzWgjP49W8clDm2hzlXmxhxDJrdrGVlzZZTqMzM+lzroOWiy6eIney6L7J6Z53MWZNqgfrm+0GyYUCnkrATgFPpokkk2cd0XWZSW7sv2z1R75+EYLw1ibzFfl94jJuxoykqsGQqOYs4UmDo/cSYvBRU9Jzv8NYvjXOs3xdiqAPHlcsufRzHg0Qmmfaau4wBuNWxJAJn+KA5o8yzZl5pHHwVoAYAbEQJ+/485fPwLHmgZh584PPwJwZ1YhJFJALTjN4y7b3q0HyXMhjo/iMG6Qp0sYATjUNv79aYueq4FZbJQXNUiiQBKH5ztODcNc2IEZVTMlhUIMPWIzB1IWB1LPWImJQggEMN7IvAzvBubnoHn8LEPwJ4pW5x6HsK2NJSmD3Qg58AHDTlrwAdRrqXOj5hkVpw5GS/582NBjKQAkz7aPk8B/Eh0fSyrhEyb5xs2pT5m831uJZay9k0hxChq3UwxFZeE3rP8F8OSdCyZd/ygPcUjcKgIBi+Z81F/ry0NXRr9ThTC7BzQuiQ0ML/2bstsB2Z22+0tWJFWua6Ii3ZgKxN2OY49q1u2GFt1/Snq+hpHoVTGjR2NNWmyL7KtdrIXLNAvCWNafc4lAN6U5Q6o7hot6fdrx8ZUaMUKxlexDWthVPmCuHKJpWK1o+c0D6EKdamCMzP1GFmNVbS0L5R5Yhau4u0MC+ZFVho3l1hhHF8CxmwO4GzBNlxS/msvtEvj1f69FJwJ2hHNM0AdDfoujLFTMeFsxRCGaxlfFWPnhtS70fG0gFT4qYzabL6dfN6Xrjnsu0TrkKeYHg4GnEP/0OL5qwNOnzt07yCgzBPQPjHa9yG0JkuzzA44f85ofvEJ7aHH6fkzuH8IPPxEUQw5rn0cMjhJeuch/EYyHI03J2Kf9gB7D2Ia2syG7+i9WEHgHLBzLrYj+aBxUmi7qKtBAmT4ZggzikwOPzNW1Sn3HNOIR0BImztz4rWdVH/EMl7idxaIahqgEW0Vf2wS0DERcs4d896UZ+9Zz/Wm3exypMq4Mr8GICsBhhScAYZwLxiwVYVnPSl3SQrlAojf0Pi5teFjmeVzQilkLn6fsyWTkFotMIBujWTA4lZ+ChuK4boAeJksTUn2Mzbja6FVx+iSc4rAFuR5AwRgMiBiZPftWZhW2w7M7LbbG7RLdT+S3fQb7ojWRDEXgzO3WtwvudcbhTqVWDSvoW1zsWbMDHBSLHcJA6Yg1jd5jl0A1jRplrIDtrS5MXvhuHortN+EjXKhk1l8/mvtUmM/FQtGEGPUVTmH8A+jCbKmvhvOP1eD0W/VavXd+j7WAD5rmHFzx7I6vR5knGzAzN3VEDcGO8mwQkCiL7GJKZNAUyi71LuZZIxF4GQdID4KVyidx2zCLRDn5xGbryGcP2vx8Rcdnn4gzm7zDLhT0EXxSEAZBUGIAXcinN4f0LkWd+8Jhw/A4dsezUnjYKSf3KkfHHYTPhXrWQKTDEjDcEMbmftJwpfsfZp2iSE94bPBec3YDIZVYzM/qX6Ozcol1zFNHXRRXMgkpAyROE/XGBWhHgBEp6j3oHNAUJpGWA0EoAl6NSFDlgrKsjPiyjmbpBZOX9h8UTBp+Nv2R/psRRZaViaN9Xkj4wccgoFs38QCs7IIwzjV/u3Dy8qEACUZmRCe60oWqEXsUA1Ba92gGcSGcUMGLOsYTRfGZ5+nJtdrknn2K9efsLXnpGNq/KwAEF0qIvjWxftNwgJ3W207MLPbbm/AfvTbv5mEMwHTk+ic8z0CaG7ovC7dqR8twF9zB/aFaPxbpnZebbqIWrAwt324SPgtOblyjTWaSPnLP9KY3wBqsdbhv4L1svT8ml3Kmik6eG5BWvVrTe937jrqkMRNYrnR4sJ97nqvabcCNdSm5rW1132Jtppiv1zLqJyZ4wcGRXgYKvOVHXdJCEMAbnT6kx37iesvbE/iUCefhqFIWeHSqkERtCnEmc4K0tTFQCI8zNkzV5wvavPuwncKNw7dA+H0FeH0/QDG/GwAFIg5AQJAgG8I1AN3PwWIDwCAu58Ax/c9WiOQLBcIjqt1ABV0ASQzjFZZv8sZL/aeVL9HL2HTPqtDr057Pk7C3zYjVCIsHP+FysXwJwJzCKVjAWt8AATcWbIAUccR+GFQcIJhRHqz9rA6OyG0J2rmkAAOvnUCCARAxq5Noq4RkDBUrKaLjqU5zcERU8la4ZlMWMcKXngz1sxzOLrO6BpLXoKBVUMDuyNpIwYcgmCyOcY+4/l7swiYhnprlifXaSYj+brxDJwBzZQVQ8Q8iqDdaJ5ZYlNza2F+mgRk4j2lz0UCaPUDzDYKN9tt1nZgZrfd3pgtBjqA8i6BcW4vCW+6yQ7+rQCQtY5OfmzpBfWJ2qoFdsEWxxjXdlJL420NOJPbNaFyW9mFuhHXgCtVXZRL63ONzThwKbgzMW9NOdRL7omD0xFFSbNrTZRx6bhZo/tTv7geuP76s7ZQU2Aze8WxN6rHteGuWr4ah/+I5CcbhyI4HRTD+zieQ50Fkgfh11H5CyyCDF1gOHgPFQalJrBmbPiGgjTqHPnBUU/Cdggpe4YK7bqExbj08yaEZRwI/QFgx3BnQvsROH5gNM9ybd+4ISUxAJAI1z78qcf9T4Wp0D4xjl93cM8hZMkZ/QoNk1FGQ9SY4ZCtisqgTG7Zd0nbaZYqGlJ9AwCdjeZKFlJZFApnucEYtuKGm6Z2cOa5hWR/OkPSOodsSzZkBz0MCBQurH3vPXLRWCYC2jB2GhrGpTJ9PAwIguReBibLILir2ZcS573Eik3aZP5ZSJz2pB7D2IyMFwsm8XBYPDc3fbYo/NGn30VAxQPUAU5BUTt2tNkMeDS6DKnwsykvsHuayOxUwEX/Hp4BpnBNP9yvTkl5GFcR5Fi64TgR8lkcR4WwxUQ7iZCE/o3WAdm42m3admBmt93eipmFaHHBn30fdV6WOL4LFrOrNSMKehPECxyhfMF97S7yQl2B2WttzCzaZHdgaajHjOVU83whPiUIt1ZIePxSHgOG45NoqJPdqXkNxsxcO2+9sz9XlxqrYAYwWRPStkQjaUmZk8/9UnZMsWCIY1ZaUG8FyszULb//uTnOtmd1IX3N810DAPNjKvW7mrm45LxLAMk18/lUvebqNmXqSJACG2E6socEMEAFWkEBvLGZmvJnt1KfEShz7iJjhoiAQwu+cyYkQtgWyW1HPQqTXQcC6oDDeFSgwfbdXKjCqLIVZw4IuiAO3X0T02JTR2g+Eo5fM47fSPiRDwBBsm7oRIT28AFDKIdnUMi6BEDAF6rPe7WQmJGTyeGoHmXTtoeARwBC+vKge9KIZHNMVxzLTp95+WX4W4ENf6CQ9lquQiyAzKAvEoAXBZuU3dEhgh4jUAYQJlC4v6FRBmaDHh8+HpzlGB6UNd0ccyoeqDe5cN0TcSkagThaDoBYpzhOyHy5xvR6tlxr2iYhxIn64d6Td2MyAaRVqWoPBqHxCByae7cixoPAs8/YUCkYXLRrQXO7lvCFDGegCMokbDADGo4AJ8AAkBvV8+fEdmBmt90+FatNaqN42vTvakYb4DpQZOm5pQX21uyUNeXNgTNry7vU1l5ryzCIhYDHrHO/JZCSl2U/L9ktQvTWgjL2syk21o2sBLQlu29Y0IexrPkD50LeZu1CBhI5jBeltwwJ2srWMMa2DnPSMoFyuWvGcs2WlrumjBma/SpbCNJYZsAAEut3AFunyjizAIKIaOV5sHPUknvwHuj64Bz5CBAwEfBwCFolwfnWcB0No2EBNmImnmAqhosAHlnQMHmuLOsESEJ5pA5De5RMd9D54OAPssXePgEAoX2U8/yB5KJegCSnOibqfAb2i80eFNsthsbAOPSGNeIwhDDp5z0n8xoTBZCGMZpQNGVxck/D/VPPIPKAc/CNAxGDzj4ppwhkUCg3/OQGYIeYhUfvtTl5yTJ1HtJga4abgaFSmKddyOtlx1cS/qb9l7E5MmRhltXCadap8feVjwuhLBE8y8KdaiwQQniODMilx4/qPfOYjbRu1GLo2VCOrZdq/tSsmDEwB3Li7waUUTaUN2M2EcUeALhNQlQr50YGlDLQ8vVcAKATIX6igU2jYA5Dvm+G+9Jn+WL9w58z24GZ3XZ7K3ZDR24SnCkdN2Uzu8qfqtV0eYq73XkbXOPYrQEYJpy3KUbDUuZAdfGd747lLJgldgloU2HZxL4KbTdKz1hyyG4Ntt3CsQYm658w5yq2FqAZWXZfN33GNwS5Ft/vQlYDMLT3LCMwnjBRidpu4lQdLh1jtxj7c6DMIiDiQtDqkvl3TRvYnXxmkFMdBQwOmwkvYY+cpzHUeU1/EQGNeDrsHKjrpR6NG0CSsMNuM9BoSmHJ4pICM+J+C5gjLI3BYYy6JcpOYY5gENgloTxqtfdMdOw6ARnuviWQd+iPgAtsEN+KjoxjFh2Vkx+1z2Sa3Ry4z0V/GwTWUD8G963j7H36nYaPkBH/Ddmw0kQHLPoZxKkDHhp6CDlCfE8KYKVsGcRxxCTgVPMk7dU893DPPeAZfGjEsQ3itJMpn9WK74ehbgCSULsk7Xt+an49RgSI5ixfL9WYJCObYFGr7lJ8l1mJoKwfFjOVS+NL+1DvtR+XNwL6MluUnVOfVU8gDGM6T0lerat9V5TemXNrnhIgE0CZyLiz92PYXsqKEzYhxSxjEv7FUD2dqNNz6uH0frdgkf8c2A7M7LbbG7Bc+HeJrd8Rv4FTNbcb+BLMk42svuBc4CRWwJWaOByAdPGxxtGYeNnOgTNp3dLPVo2N0gt2q7AjuwBcW+aUQ78EAJtzfKfK2GJXf6qctbvvSMHGVYLDr2ErAJI1tmreW3DN1XMoF577mi35Lp83tgqZsz+X2K2AyDdwPSYkqXaH8JHy8bmzlmR1WlFndg44DvNfZOoo20WdxVHMCccdbeIQd2WYJhGMCKE73LixM57EtmAAKxpMW+LUCbOkDcBL+8HFFLrEQei2C8K2ZwFlKAOSgIn3UgRRCu9lImEaeS/gVNDoibv6djPBOq5aTtCwEX0aF8PTknp4zZTTp+8pvb6yi2KqZiRlkAfceRAIVpaMe+pjO3DjBgHYmKXHD/VdYSNB3XDven1yiNnFtG0UHMjDRCNrZQubeyZKwAEwiBCXmC618te8MzkwPMAYzdsFK4n9JucwZgCjGYBqzXdL79OGLQF1UIaCrlVDA1OPBJSR9N6S3Ys8D1pbeks9C3DMhevsNms7MLPbbp+45Y7CVFpj4oFlsKSsxXbNonmDxfZW2Y/i/a9dgCwAZarn1YCemfJrZa3NzHMzeukloU0xjGAanBmPebPQntqlXsKeuQac2cKWhNpV7OLndymraCGVenW401sAhiaM5pzTxML4MLdU1AHK9S0uAaamQMIlbbo10LFleaV7KLXLrceO3QCZ2unPQiFKWVwm24cIaAfIhbPxE50gn2le8HA+HxopR8Nu1JhBpw7UOfhjG+ubmzBxXPx9lDa6ZgqU9AB7D+c93KlHGxkjbswkKzi+ye59uKcE4CiEvNh3f2QMZQ5mbAMtuwSGaxiHgjjOJSmuo0MbABxt+DT8ZXjn5Uwb8gR0Ho0n4ATRkum9hC4ZUAbOaJIsAAfy+uVmQTzbvhRCc5iMKo9lbWQO/AgQsWXCHFOytUy6Qn2H+0lZTNr+KtB9ccirhkyhAOa7ikZYrOeC7+YYhitscrNhqkzbpzUmkDJkAjCpoExMqR5YOnp9dw6p673NTCZjPRHq3m2x7cDMbru9silb5mL2QmYjZ9vSfxeAM4vtDTlTL5aGb9WiYl5QddV1TXtXd2jmwJlsh88eU2LUlD635yflFmKSJ60GvFhwZom9BcbHNQuPBfVfMjeUPl89j9TqsgLIWg303ajvSs/AJazBf/LXP8Nn399+qfT//r99M33AXEhTzbZm08xd55Y2dw83uD/VToish8yxKmpUaD3CufH3hW00GpM5C0CdG61DprkBIDhSsqtN5ME2WqcL2jXkRQw4iNcmY4wIaDJ/zbBA4kelW7L6LkAAagQcIQQmUAgPKgnRpo0xaGxItheYNpX+GDJmDd9xjwDkIAIMEVgpsVvCcRGU0ctHLY38HufBUklrXXh3ecDBhzYKrJveR+AlYTDloNVKBsWsWL8CUGDAMdxZ6luaF+fm8tL8OrqcPgcXbN5F5lrSP+GX7NmvhgGtMNt2CghWtaMKdZj8zt7/wg2OyTpeaCWwCwigbPipDD2rKaNhfsQMOjPc2bBlfKoHpc/viNm31Xr4O247MLPbbm/Aai+4SwGaScdcJ8e3gmK/NCVer2ntmutPOAebAkbGSbGgz4gtZMAZ+dxWiOoLNmPzaYBr6EAFUKldM6eKA4NmSmX3cdZWhvtcVcZLhlao/3QBuHBTuwaUWWjVBf+M1ZyN5PMJp4Ea3ASUAYB/+v/0Jf4/f+ebMXPGWinccUswYotn5TXsVoATTz9fU84yF+YqISVM77aPzGXzec1K4RouuEKtA3rzrnAAtYb2xbKrzaYMBaSocvOzAL1llTGDfeS6DHomweHlvP10nEftDROGBJTfZeb6kgZaxVMJdDaOZwTNzLsvhkTx4KQ6J1o+WQiTXJ9S0K1k+r4KTKPIFggZpiQEDQPoYp/nCMoU+n3BWK+O2TkmRw+IQNJQbwuezY1aBorzvwXfkvXJpfONBeaApE1K2aRWrynzDa2l644cOPaDwK3Vv4vWpAVesj68hhWb68kkIX4NYvalyHIDEsCQevO7H7OrgOl54r/9f/7NCyv/82U7MLPbbt9RS14yl4SVbGFvgc1wiRVeuIuPvaVl4AyABKAZhfSgANItGAeTzn9+/tTO3EIrXusSUGapLe2zpaFmE3YRqFC47iU7mrEstSX1XjOeJ8orhWIsvt6Chd6mANWCdvn//XffwPcL2i9bjOeLb9cQ/vd/9YvVVYw21T8lZ32JvQY4fo1dA1ItPbfEmlFb6CwXr7u0fmssHxMhLAoAWN/9rQlRmngHTGmPLWJPqi1g38yazVpTe81QePcpGDJVXs7odCQOauMEkGidsHvCdxaQScChxeFFSLNOxc+z80tgzYU2EoRPrpsfzCETF4OaoCkSrj/oztQBhMiusOUBafgLIIwtpoEN5LBunF+7dp3aiDOgpt3QutYo4EVF5jQBqj+TrNls/ZbM8WtDVi0oA4Sxj3StZcc9h382Wx2GMT3Zhxkj+k1tJr1x24GZ3XZ7A1ZzurYKb7oJKLPkxfqpgDIlx2TNwuGVwBlgO1bO5AJ8DQtm7rv8OA2v03VgDiTZatgdOWvZ7lSaFWLiHGu1/rvSaV2k43OpQ22sCFSU6NT59S61ImugfvgsOAMsv/fCuLm1+Z6n2S1qpk7CFMjKmd2HxjKm1tqQszl7q+wZe6+lOfrSey7Mo4kD5QCAJAtP8FJm2S+MNKRiwqnd3HL2i5qCDPrnimcmP26xJtkl4ajhPAnJGug3xRAV1b5Zs64pAR8BsFKAQbLNDBsd3LogqBycWWbDLDLl2roEJgrBpLju/eR7aDVQMXertX4y7cYMYUDYzFs2fGWJEYYsRkC8B3906O8aycLFDPhGsnB1IgrNHqn2ktqWc4++t+fmh7Xhkgvf1TaEK58DjKpPcc2yJnR4LjwqF9+12ZE46kkN5yeaSQrOYJg3amnbi/IJOyhzke3AzG67vbblE22NVl97sU9YiQL85ifJ12LZXLtrvKLeI3rvG3OGUnG9hYtxoL5QzmnkwPD3BDjzomPV9F8tPGwrWwRS3NJeeMwtHkNL6vRCjm4OjK8790p9qY30CHKbYvJ8snaj94WkgpW01OLEBt2SqmMSnB1kc8drWaVNRmFEpWMmmnNWe0xtImw2n/9GjE5Nex3YHFGIeIp1Y3Uu7LvGHq+iwEGPxoYvRaaMsmMcSdrfhkCe4OABP9xTUcsvB2zCOMlFd1VAVeu9SEdmAiCoJoAYMTUo+Z2JA2MG4xCu6JCX66bPh7CMjDPPALchtTxBMvgo4PbUg3oqg22VNpjdbMjqFG/Phk7N2dqwpwlboklTej8UhXLXzP21sCq7zsotCl0XQJmkcnJ+xGvyeuZWCFH/ZDZp34DtwMxuu70FK2kJWMud2pW21sG9GshZOwlv5SgWd9dW1GVB2MfqsIxPwOaYDuUvKgvvKYfkSubW3FjMFzyrHevKDlf5WgvqNjGur9WRuvbcq20lw6LmPKy6h5XO7mJwL+unLbRyrnbM1+ziTtgiGj1Q78elc/MS6v015a899tIyVLOCCP5AADmQl51+dAAF4dQae6bY768BvN/4motCnEYncXwHFHfYS8czxxTWtfeHDeulwOBgRwK6ZBsBkjlGdFW4xSgETBkjEYAqpeYe1d/e3/BZ4sAq68Zq8RhGQyKKbL4fWfisNn9WmTylY0EJY2Zc1vj6MQtS48AtoT+GlOiNgDHkIRmnOgZOPjBZBdh0XdAmmdS+ufy9tmjOXTIfLT126tyJz0ug/SZAbv4O09Ale+2GEAep6glh6NckbC+Otaxu2RiMZX96S983aUuT4e222243sh/99m9OHzBFGbzU7I7NjK263opyq+deQ02/sVkB1uvKmV6czFpOZd3q3mvtX3jBAxh2JEvx7Pn5+feZoN/FL/UMICgvJrPjrxlnKPd/cUxMgaxT531KdiUQefH9zzw/q8rdEpQphdu8EiOuCMrYn0vM7vZe8uwsCSW45vxLxl/lHlRIlAJwxY2AMz4wJziki1WGwGZZ964F819wM6DEJLuZQxYZLBPggtbFkYQl3R3AD3fg+zvw3QH+2IIPDbhpxBF1JEyZQt+pXo2mCqYQekNnDwqgAjTsyZUzGSVmWQuqx5KF/UydW/tsVucmd8YpYy6Ef0yI41kElMvhwEM5AyjjDw79Mfy8d+jvCP2d/AQB7uzRPPVoPnY4vO/QPvYCbk5tQGLiXX3hO5uz8VO1UvmF6y0pK7KJ9B+Zf8ouMvhIsR5TIE/lO302i6CMMsScC/o/WYa0pKBsXafvMPMuywHASWbMJ7hZ+Zq2M2Z22+0TtLircOkO4hsLnbna5qjAG7wY5lJDXrU43WInOKc8mzKnQkkuqfcWdPb4/cw1RqfkO4XX0JBL7V6gBF8yfoo7mjlAVbr/NxjaVjRtl6yulzBhFu+Szo2nrA5zn11yzKyVdlxXhDguAWynnCdrkUFGQBRy1N9XXK9o2vdL7i0/Nh/fa9hXl8zleT8sqHeS7SW8azU8A0wx245mG6qmOF5a30ufezvfW7vBHLL6+VjyvGYhrdEaGrQ4rJMZdvQTcMIHBseBwHdNUg55hjv1IO+H8xUgaZuQylvTeQenVwVtexuGpN8DvnFAI+DDMEjsPenmC4SdAyTsBDtHFh3a2vNhrci6GH835TDHzDujcsp9NmKk9gxHbD6X8LPmJGCW63K14WAWnCmsVy4285znYTlrsqNNhXyumi9jOenYHcoavuMCSjN5rRrLs7IJxrV5omSmjJJeX1pJGo8xGxoVz/0E1jRvxHZgZrfd3oD96Ld/E7/xL/xH8kf+cspfwHYB89YcuNKCt/YZ8HaR9IqzufjcS3dxZ/pzNc13ITgTrXb9uV2iOabMGqu0Qw0YSwDKbFxdk1py8u/ccn2BQj2nLAFageqia9EifqnVxtuSsVvZ9bT3enONoGpYw/Tf1eLyhe0WbIiV88DWi9fi7u7UJVaGp23KnNFjtn435OzC/PcKQ1DDl5hdPJ7d4ECRo4FhE1Mi8/q5Y+kxb8CmtL9WaZFNWQYqjJ5LmL+DPgoBgGOwZlbSbECegZA6W9NwU+8ja4adE5ZNQ5FJ4I9OdGUYINVgMYBHZDwwBMzps+dWf/Wc1plVRDqzytqoCHCH56PUDwlQVQhLitWITNXhniLwhAXgIgPUezhdh559LDc+BxbULNnMWife+5r302jdLGygWXaRs+MtBXPyeygCDbX1ngFdasaEYUxEDGem7QpW1ZKxmklAETAp1Xl45qYqz6Oyk3IJ6bP8aUxxb8J2YGa33d6IJeBMwfJFin3Jb+0AbbbIAqYpmZfaNSyJLcouheTkZSyl8NvjZhYsST/XjsuvPVHmknEzOxZKO55zoU1TthXQsMTJvPBaxTaZGxN5W5R2NS9hDFyz0/hWgVFjo7beKnzEFllz/tbaGlAr/+yFQZzR+fmcofXa0vQ+pwCYWwAya40BOns0fiA8qJBpDL1kBrHcBzmC6yUlcFHY9JZWaseN6lACYTYHWxUYyJxIYgxOvh5X0ebgXkAUJgZ1PvQLQJ2HO/egpw44dwMo0zRA20RQRkM7YnjO0QGMmElImWYK+FhtmIHBw+nnts45G8gA+Vxgko3eLdn8UHofq5NfDU+BAR6m5tAs/KqkO8OgKMwcP8fQBgDGgIc5335fTYTAaRvrPVbnyvyzAJiWsLDyuB7aZsTISk5Obrto8R4tLhfGAWkZo5NodL2E0Rj6pRrKh6y+U6BMaQwoIMTZu6E2JkugjLbfqC94O3/i58B2YGa33d6oWYekuBjKhPRGOyvAVQu0q9gGc4vrl3IIr7mOacNJcMIusnLgJHdASuEfK4CUKUvGSqUPLu1Tu1iulnEDh3l1W5SOt5/lfbGlWQdizmme0EyoFm/Bm6Xsgyss31VbFmIzM2dlxy6vi9Zhugx77SkGzCybpwAsUli0bu6YlsbmjK2j0y84f6mzU7I1YUIl8OdWdmH5NrsS9V6EGJ3uvhO80+PCWGhIwlvIhQzbAaypCGbezDYuv6SndtHYt/Nh7R2R6YxpCBAFRkwERFB4D2u4xZnhAHg4aX/PoOcedO5B5w7wAyjDd21gyFAIY6L4nAyAkJlPQphTrJ+Te/KNAwUwCB4DKJczV6gA2FmWZc/p51m7AKiySG2faDvZ8EUrjDxKb61MolieqX/PgAvCy3r+6PoFICGLjkoYOpyVo7+yASEcgf3MxmNhjknYLpw+x2mdR7cR74XNehoFcAINlUGZOXDUZWFUph2Gz03YqQGIwDSkWw8bstVQ8nxjzFwfyMZA0EkaGH8YnqWs/pPvXQPKJFm6ALhetJkuYQH9PNsOzOy22xu34iQ85QS/lV3wW4Ur3XKBu7TsJc53HpZSCf9IPrumrUJ97Is7qcsG7VZcmOdtcSFAc0noSzUT0pxNtcXCnecqWJfvjua2NYB1SehcjaYe7BpR05fMzLBqFy7rl0t38BaP09rYaRYcs6XZR7PkbNi/t2AXvpX3z5UWmQE+6MiQODDR79Qd7EaEgdES/MGJWGwfmBsBIACwPQvpBgwZtUufjeqcWJlPJp+j4CgCAPUAN0ifYWYJJWICuqD1QiRfO5L273tQ30OzMKmuTARlcvC582iY4U4ZeOBISDNRcwbBERVn1JGTkJ7GCUgT7jkJs40hQ9k9xMbIGq6y6ZaHLEWzzrcbWB+x2AKTYQDfhvXJIKZs7iE5yVSZDFDhVOwWUX+pGpYGxLrI88EpOANzz5VQL52v4rvKaRpyuX4MMaOhndgDlCME5vnUuuSpq7UPqPfJczwCLVc8hzkTBgpKtcLeggvt2zOoxzB2gHJIXKGtOesrbsgIV4csWgpi9Zzc86zl482pdpO5vxDaWUoPvlvddmBmt93ekk2g1MMXKya4WzADllzzFteulFWj9V5d/lJHJdvtA7CMMTQF0Ky0rWmia1gPk4DhkrFaAzJGO2JX3GelvZPFS40xsKRPcpr6lBUAglXski0dsrWgzEvPJZktHQNXhyZdqo2kduvQsoVzU7oLvBBIvsS+I2BM0VRHhiFgASB/B4ejJwfWbDQMNM8kGWkI4qxz1vbXvhevmacW2qahzBM2+Z5R0CU4pNRnxyo7pIGELrFxLH0AxnoG+gEoQdtkjI2QmciESVHH0XmPziYjOtAusGM0i1HuIytDJpofgIboUNcYRD7ct0tpJxEYsKBM0lYV4KslcKCwSNsAMaxEnXwbgmWZPmYdZ8Eebl3KxglgFTsBJkEAOY4sGzYMM4rOv6mjsjZ0LHgADaXOvL1eHiJFpr4FLWMKjOfhnGJTpWtvG6LFw08Lvsw9H0sYzEm7m9BIwAOeQOwjo6XU76V7Ic7qFgEzAX18K31JPcMFAI00XC+bQ6bYckX2DQCEZ4T0OYxjaqKxdktsB2Z22+0N2Y/+7t/Eb/z6b1XBhjcfp1l5+bzIwn2OLj1npcWt+XvEXFp5nZoDvhQEmb9ABhBdGCJ10RhbwiAqWaZPc3PB2Pzy9lpT4RxLwZkcZCrtjJZOvfS+p56rpSElxq7d1bpF/232fMxZSStpqd2QvTCyleVXAZkt5uQl4UvfASMGuA9BEfqa6VlCmA4O3YNDd0dwnTg73Af2DAPke4xo/JeMl2vCgy8Yk5NsxEuYhBNWFxQucgMGB1zfea0D9cGRt8+x98Pz3ASx3yYrMYArCfARnXEGeet0GiaICkEzRv07GfphgQnHAwhDA7BQ1IkptLkel4cHaYidbxy4lfeX6wDiISRGCsAYlMnaRkEZH1Jja9p4YnHoXUgjTp7hgoaPphIX9oc47+7McOwjyEAswJFv3MCyCCAB9d6AMob94w3YTMN3se1sOJlpN6csnEbAiWoGtYIt1eGr2UjIuMK4sQk9KANskmNKG4G1OrmgnxTamR1C34W2VnZfgR1UvL9sPekPLoR4DuLnFMfUUCY35fT0u5VtB2Z22+0TshGltWSvtav9EpoBBY2Q0kIw2d3YuF4lmuikZSyoGuV1M6fWttMMOFOkSV9q1754c4f4gr67RBclsZXgzGw4k/5c0DaL+n9tmNaKNpwCZZZSnG8Fytjfp8DN6cIuqNzac/IQsbVzsfbXTKjZVXarENO3aEvaf64dWP4bQliGDYDuvsHpywbnzwjkgeaR4Z4DOOMIviVQNyMIPAV2bNVHtXLWjM/gcJNxKG8KlhIBjlONkDz7spnf4/zlzXcKojQO3DQCypBqYgzlJiFnwBAmE6gaZDIzEXNggeTvmgDk5CBHgRWjqbs5gDKl0GMOTrXWD6plo465ihYrfhEcYr2mhuPQOatLZIBxBAEm31MUwMf7Bv5ovu8pAJMUARUFZvo7FwAi+a559knmMh0/vnHo3jXo7wiul2eneZaMT1avJ2VuUAj5Ge5xALowgGhe5lGCD6Fups8IQ/rs2mZi6Id4TaTvwbVs4irjJlujJJ+r/k8IKyuJ+Sb1NfWScChpJ98KqAZmAch6H0KkBARLrpvdQzQF6QiDlkwTQLMewrqxDJlXZtd+yrYDM7vt9onam2PQvMSu6RQDpOZE3QicmbSJl9I49nemH/Nd6Tm66YoX4magzOILlt7+PN13L2FzTvTGO8QX2Q2frS1Amde0WTHENVYTULSH2Gd4ql8uBWfs+VPlrhkTE2zAyWvVylrAnvjULe7OG2dJW4mPsmPsD/J3c2K0Hz2aZ3F0/AOBnUNz9uA+E/8s2WsAZbXxWehb0ahwAHtQ1wu44IIWRnAC9ZzFc+LU3J8zD5mFYeIRQn7G5ybitV7vg6SeDUUgJDGfO/5peQkwREM7KOgAoBpqMpRj7je7v0SHBkhDT1Szo0MMyYm6Rq2Dv2sE/GPAnTzcqU/qGsNg4s0F59mIyeYZsazIrHcEf2zgjy7WhTqIjhIHEISlXv7OoWsadO8cnr8g+APQPAN333ocvu2l/RsCNSGtdh/Sz7cC7gBAw5wAf3kK7+Q9ZfViHCI7yAcxbnipZ/NMcMpC6dNyiqFSahaUUbADFMOspA7r5r4l+ktT77Kl7xwF9Ti0OdPARnKn3ohbZyARUF7buqGd+ODglXVkwqF0XJXvmyVEbbdFtgMzu+32idqbAmVq9kIsmpGwXH7ZpbvEG8fqL7XSy3gUkmRivktxzpOx0wv64VIK+iK7VOvDXEO0AJZftyZ0WtztvXGfvygAdsEYfqvifJeIQV/UvlM73BUbMZxeA6Awz3YxJa09bkVZi6/91m0OPFpwv/mzYf92HePwkdE+MZpnhjuJtoI/ipYD9YBvHZwVI93KtthwyBmoU+VRCIPoAHfqQN98EKf8i3fwn9/DK6tA9VmWzHkVra0IQJj6DEFN2bOat6kN/4iMlFA37TuDz+SgSS6eP5xDMUQozWbDkYUyabFOAMMNLAhgDIA5AUpEwwVRzwgITBnVCzk49PcyziQ1NA33zwO4Y8NWRCPHw+rZlMPIBHDr7xuwk7HOXkAUTxIWI4LYcnJ3Tzh94XD+nHD6AujvGcdvCNrYKuBMPdB+7IUZ0wuY6Z6lHdunHnQ2HrwFRGxfaHvQAGL1dw7dO4fuITDVPNA+etx9LUAEWdAKGMZ63neluaLWt6X5JQMo463k74s5IwLa4YRZLTwgjpsYuhTOp55BJx91l/LNlkkwJh4T/u4ZDkMWMur9aD1aWn+PRJd3q9oOzOy22xu2ucXNS+pxLLKXYM1UbFFbvHL9ppzGUjiWnvdS9V7j2G4GyswwE4pFloA3NwgGzoEy+nuJQl46b7GVdGZq18JKIGHNGMjD2eznFSvtSsZ2XKB3sNauCd27WSjFpeDUrUCKvM9LfRqsOPYvuR6wTejLW7K58Ttz37ZNrYPSPPcxCw8ZfQvfDg6xb0my/BAP4RPX2pb9YAH/GUvq3rhBWHfG8ue0NufVmSvmIAtowPzuGOwDfMOMqAFjQ5vs8fZeSvp09tnTj+O5GMJAprqixPohGjKz5fNN0LuJpuKsge2hYAm3Q1iZOyHWgR2ZzFEMHwAc6jyajiRDlQGIIiiThYZz2wQ9ForsCtcx+nuHp68anD+Xzw8fgMNHLzozDLgOcCfG4T2hfSS0j4zmJMLNxAxmiuFeGmZFZ48GA1NH7yNqAalgca/O/8BiU80Ub7IBsSP0x9C8vYA0qnkj9xeONTo7U6zQVc+reYY0DG34YAIsL8zxRZ2h0vk2xEhZMjqOAvuIeoY7+wHQWhJaiYyhBAzjvvMmjIxn1zCfxCbyG7IdmNltt0/ALmUyvBhwcwm1/oZ2FYh1EeNgWfmrHPFcEPea9s3PXXiPNxPjXSiKe0ldLnZ8dIFzQRlL+7WqhXQLK/XxgjG06N43YJZtcd+rNJLy+7pgDCbF6XVr7bCV8zxXjunTYt9dUo/SOFm4mL/YlrIa1x67pJwLyhUH2AsfQHfvCSIuCqQOuwPQj8sY1WEN8LqFrWGQMmJKXf9wAB4OsOE4a+bMJfPlaG604EkmgBrZNI6lnRUEsbhRCH8i74VNQgSAk3pzM5SXXlv+oxBGReDItLDhG4m+jIaehDYkxhiI4eFzYYRSMi8pKCJ1k/AUf3Toj04c7o7Rnn1k8HBDsHQg1zPY+4HZEL8w2jYZEzc6920I1+oE5OoeGpy+cHj+PuH0PaB5ImGJnRntBxnch/dOGDUtDaLAnRwztNEg8EveBIqFOce3wtLxB5eEaI3GVwBvNDuW6xiH9z2aE6N7cPAN0JxDnyEAJRTAK8YykMLaVMhfiV1CSPqbGRiFSxXOzW2SCZmHLSkgo2CMEVpee78DgGWuaze51jJgtmQLfsdtB2Z22+0N2b/yz/9WMQvBm9OTsbZixw3AZQvRFTbbTnPO6QWOzFpB4FngzMbKW3Cmct1oUw5z7nRUQqJKdZ279qrxWdpFDL/fBKR4ofC02AbW4U8clw0ushacu+W9v1LYX24Xg9AbLxRvCrLN2S1A8bkyt7peDRxZe+4l75+pY0rAlEsZL4luAjPIibviOhYKDc8891P3/kY2OdQ0rAZAkkr5xTZkKmxEIMyvyEAiX2E6AYiptc3fIAI8Ac2YrRC1Zsw5I30O+87WY0DgjFGQhONmDCQO4sRwob4h7bCGN3HrAjuEENVvghMe62TDtM4eLoA7NPOeZaIgjix1847Q3zv4I6G7dzh9TuiPEiJ0/BpoPzKOQT+meewGxoYR5Y1ivwZgivUsMC0YAB8czl+06B4IrgOO30C0c+z6JQAsOg7JMIv45OFOmo1KgB3pX2Rrj3DB/D1WCeEhh8VzEwXQLrZz6fEoXCeKES94piLQ1LiQHUmvjciwUkbXYtA0v2YFlKlXavx8jsb5brO2AzO77fbWzOy+5RTTW++4b+5c1Kj4W5a/0F7CcZq7Rr6jVoqrrwoEViwZF5c6HTM2Bc6stsri+pp6AFi2mLHrsjUO00JL+mJB32k9VrXjEmBxih2l39fu8ULg5yWBiZLWkL3+qG83WBi6huAT7wLpbrh+tqCc+pdXzJW3AmduaWvLr4Alm1+ndn52vZI2E/WiNQNPAuR0PGRXqdRp5KDS+FqvZskzbpzjwvc3t4kQ0QjOOP0wA2XyEChgPC9oVp9cO8QVQtD0uVdNl1FUFwNgcegNEyYVDg/MFaMb098FUIEBdwrMEzbgjIq5MuJ8k2jd2HZScKQ0R2u/GZYMGor30d85PH2/wdMvOPR3cm7zBNz/mcfdNx7uJELXzVMHOveAc/AMkGWGaXUy5z5fB8XDwz36FuiPBCYJBURgxVDPAnQBYGc7H0OqbQRQpAttqELH2h6x0SiCGQiMo8QCkBPbKzT6YpDDZ7oqhWfZhp7aUGJyw/dWWmmUFj2Mh3iJPrSBjgUFVi4AfC8S/Z8CTf2u/rvUdmBmt93eok3sDAF1hyQ/bqnl5V1SRtFuubAsvDRqL/ziubW6vREmAFDpg0Ldljj/ybFZGWtEdTe1mUXOajByhTNTK+NaDYicSVT6/KZ2raN6hUO4Zu64ZbjlqK1LIqH6+UL7tX/5y+srNmdzoNlbsUvZKbnD+1L1uMRW7I5z4gjLTwcnjlx04Mu7zyPGxWuIcE85bj6r85ZtvvE9MwGk2YUaAitIkIMyhlGTgDZR5HfQQgEAzu/dgjJRTNUP92Kv1Yc5LtOViWCMk+O5IfT3DZ6/atAfJUyofSK4U8h8EzRmYMNkAvMnZsWxzrQJcwEJe0I3++J4Vac+glsEPoi2TP/g0N0T+gcAHjh+zbj7hnH8usPhfRdFX4kBODcABIyY9al0PcnQwwnDyRp5xuGjl+eI5J9vnYjO+l6u1zNI4nOEyhJ+VTDCnfqQKUw+zxlVVisI0GeQB3BG+8UCJD0n0jSJjdYo6fOdA602TMiCM1ErhgagSMdHBNliwQHoC+OPPdXFqNc8swvmvSKQbL6zfQ+gDEzvVrUdmNlttzdqxGZBkFnN+bvoGlUHdQOn6Ra6BIVF0pytvo+VDsSsqGxycPrl6Pg5QGmijjXxxMnrGZsCD0rnLQIa8gWx/bm0bmsW8DVnsFY9s3Cq0pUvcChvqh1za3vl3fpL5p4SOD0CZ1Ya98CHn3T47Be2Xyp9+Ek3OI7WrgEtbs1QvNYuqc8147AGOGzZxjAOfnDwiAE6+4QFeWmK3Rc3e3/2XbvkXV4LAbvQdB4ozQXVdw/RwJpx2XtDARkfwls8gxoHdm4IWekN00HZDKo5Yxkf3g9pspUxEwCeCPZkoW4ldggfRDPGHx36O2GLWF0ZfwdJt+5FRBfMcB2CdouPWi2A1E8dc4aT8Cg3hMgwBe0YzfbDA9tGAQ/fSoYj3wCHj4zDo2jEHL/p0X7o0qw+jiQblw0r8gwmJ01H2h5mvcrhs9hfWfd1jObRw50Z/jBkXCLP4J6FnQMEzRwHYj+a66U9PBh6ryTNzyyMnIOEhJFnNCcPOvlxXZiF9QaAQsyigA1D6vCaCHRkvXguvJfS9tIMWgAGMMgIiWsWsBAZOXyu7B8d0+D4rGhb5EDdpM08p9bfGPkfM+sjBUx3W2ZvApj5a3/tr+Fv/a2/tUlZ//g//o/j93//9zcpS+1f+pf+Jfz3//1/f/H5/+V/+V/ir/21v7bqnD/5kz/B7/7u7+J3fud38Du/8zv43d/9XfzRH/1Rcszv/d7v4Z/4J/6Ji+u126dtyYR/4aJz5LxkYTSbgDNb7QDXFtl5+dkL4Cp2xYK6r2FBzLEmVgFuM/V/s5pEC63mVK8ejwt3gLYCUoZF0QKw4JVsCYC3yEzbzuks5d9NtcXSOi15nvTal9rv/90PoGb8+bXjpQjKbGlvEQBY8y7YAhi8lQZKwdmJwAvrjvcgbLoIlHktx6VUpylwespKx5Q+Cw4r5V55sLkNgvzv0bOoYIBTyoOAFdQz0JnMRNrmHiCyosAGbAOAJmM2JeAOxJlW7ZfWDeWOKmtC1O1c2FAAZQj3P+3hzjxkEnKQcB5QyK7DIobrOQlTipfT+hFL1ixWwFCu033WontwIGY0T5JZDGfVaBF9JD55HHq5XvvUD2K9gfmgQsSRldOaFOKRuRMqZbWwPWBZKkW9HRbAicPN+xZRwNf2mWUsFZ8dZSEdpT/c2Qt7KQA953chjf23AqISo5wNytZN790R/EGOc2cWPC7LUMbIQpKAAI5BtIJaivOTiPSak/V9E8da7UWZjuNhjGagTM1WrG2LrHzLAAKEvGQZW/bz6ZrsZuxNADNb2sPDw2tX4WL7wz/8Q/z1v/7X8Tu/8zv4+3//7792dXZ7A7bGYbxEpEzOqyyC8t2iS8xR+rMYhjMshK61/F6uBTcAVOteo3MmVM4L6jgC3ObCTi6wS1kzt7ap/ppy+JecP1XuKo2eCVviNFwMFlzjXL5QeMzcznYOOm4Bhi0p49oxHUGUWwtVb2EvAchc4rhPhY7acrcGUV4q3KkE0tSONVYdR29BXwa4aT1Kc2EO3i6x4uaSSZcdi2E/MFycMEpAIY30WcYeWT0YhPWJHz6L56tp2mkFZlSjxhtGQ2m+UPZKYEO0Hzxcz2geQwp2A3p4zTx09jFLUZFFakO0GBFIiV+3Dv094fwZwXWUADzi/DOcZ7jnPjZamqrbpGYOIIZvXExbLdeTNpcc2On6jsDSlsxp39vQH89y7TOj8Syp5hHuxUnWpgg6KIPJDdcBMIBaulkAzRAVWDY9h6xR4fqNlOuPLqbeHo6RlN4KjmhbuU7fK6YflBUVGEo+hschaTduQhrv0Gb07OE6j5FOkQ3BjWBf4V2ehE5V5v8SE+4Sc8MYSJ8JDEwhDPcLhOdwSlttt8S+c8DMv/Fv/BuvXYWL7cc//jH+9t/+269djd1+3q0gPjtpaxbThR3MkoBi9dwFNrdzXz9vBiCaBJfGh1eZL46qIWpTdmnoWi386K2CM2usBIQA5TavLUYW3aeO2Q0Bjps59t9xJtVau/p+pwDjmfGwJRPrzdvSsNWllPprdBFK4TRTLMst7CUBsUvaZgoYWxQOPAM8YcE7tHLN0jNy0Xs8X7swi1Psg7aJc6DGOLp6zFk0U4QF4pJ1DzkC2I3XKArIaNiSc5FFwERDOJRlycR7G4ADAAK29H4AAHy4cU+gPtQBMCwZ48Tn4VrhfqOFduZGAA33zDhQSHP92INOPmF7uKh3Iuew1YiJgMcANlAI+XE2A5CyWBwiY8bqwCTso8qmIAECpIRnN2qtOAIHaRlrg16Q0YdhaVsNOVOQ5fCB0TxJViPyDN849PcO3YMT0WEHuF7YMM2zhDu5kw/AjrJRAjZhwseGygwgij8I4BPvK3QtBSYMdQGUsW0GxP4VBlZoa89R6waeRyydWSs852s2tpQNxoQBaOlD6KZlFVnRYgAVYtxuFXsTwMx/+p/+p/gP/8P/cPV5v/u7v4t/89/8N+PfRIR/59/5dzasWdl+7/d+b9XxP/zhD6+6nnMOv/qrv4q/9/f+3lXl7LbbIruEUr0WnMkveS1bZsFCb85i5gMjxraF5UJoNv64drwcNxyz1Llce99rwZlaOMpFQM5aAPAGNsXmSGzB2E4Wm1P3c6lT+Mq6L5fYJwUC5c+83a20nwEjR6tkn9S9vxXbYke3dv7U8/MWdXnmmJJbzgVL250Qd8aB4b2dgxaLAJoF82AJnLG6PUO9Km0RAYVQiGMMqXi0wMyxDiyapPwAFLABP5QlE0N6ojMOaaPGBWaIcVITcAvA2Q9fqVaJ6QuC9HOiIZO8sziIC1MqLtwgMnuIw2e9B87A4dszDt8OoEAsOzjcsa21HhRuyJqmZlbAA6ZPOAVJxGsfgKU8U9RQZvoMRhBCy7prhoxUTjRjSpmUYmhVADLiPeptei9gF3kpLwAn588bPH8hIWVa1/aJ0B4Y/pnQOkLzLNf0rQAuqlEDEnaU1Y3Ra5JhWImeDxLASkOoBGxJ2zjRw2EBqhwB6MbP1iXM4do5o88D2OXvGknNTQOjyOX9mc9LllWz2yJ7E8DMD3/4w4vAi//4P/6Pk7//6l/9q/in/ql/aqtqVe3Wui6/8iu/gr/8l/8y/rl/7p/DX/7Lfxn/7D/7z+Lzzz/fxZN2e7Ud2Jrw65veDa7Ets8eA7MTNGFLBQnLu4EGnKksUG/l2G3Nhllc3soX86b1nBKlmwGfllgCyiyxlwRnLnU0V17rkr66lAX2IlZlBWAHZW5ttfZdOH9fdY1ry3oJYGdN3XPQZercC+elOYAmP65at4JV54baXJuvk03diAic6UURHPj+KMBFo4yAAVhKwBgtP+iXCDgzhDElmXNImQMDmJuHXKl2iobmECNl09b6gwRkisyYUipw20bM4j90PgVR7DFWU9AN94++Di5hVJa5F+iOjQFnlLWiosnmfti8b1SIWHV8yDn5PvTdoE9U2QQJ9bCZteL9AFChfyYRXu4eHLq7oPNzANwZcB0EeOiEXcQE+IMMAt9o/wOenZBz7HU6Hu7j7NF6HkAbAPDCytGQK9eFOruhEM3YpewfZogQsIaJOQ2DC6CTTQu+wJYcq8CjhNO5kKnLgRhoP3rQuYshZTp2amPl7/w//oPllfs5tzcBzFxij4+P+K/+q/8q+ezf/Xf/3VeqzTb2a7/2a/jJT36C73//+69dld3eiJVQ7JrjuAnLYwX49yadKbUltO0Kc2dRWNVCG+0+lepTOOci/ZEb6M0sOf4iJ/QCkGa2vBUsFXsPi8CZCQAtKWNN6N+l7IA1gMmMLtLFlrXlpBW0EN4ccJHXcYopk9vMuNjN2CWhOPm5c5/9PFhpDtiqLfLxXJlvSuuNGkCjVmXSLJ0LtW5WSyXXrqi9CxwkU1FeJwPU5PViLQ8YAJvsesKIGDIPKTDDMA4qMvCezbn2erZol86XCpj4yMrAKC01gIFlW4gfKYrIltoqB4cmTDVyiu/0AIAoRjO6rtXfcQW2cuhnUHD88761ujI0nOPOnH6Wm9XvOTj4A4U03fJ1c2K0jyGE6cwCtARgRvvZnYZMTf1dAxWXJg9QQ9LHHJg0Gn4Es+nXYQhDi4AWYptoKBx1HkzOgB0CmPhG6qJhVuDlIfI1fcT8O24czp+36B9C5rAW4ZryDFLHEoYFRFHk4rtyJxWssk8WmPnbf/tv4+uvv45/f/XVV/jX//V//RVrdL3d39/j/v7+taux2yvZb/z6bw2v0pmJrOo43sjevIOxZlE6u9u9cHE4Y3Wx2mzRWyhzFTij93MlOKPXfXGrjPXR/V8CZFR0JS66zy2Br1s9r4byvsRm26HEUKiVXXtuKiEHdozfkn03Kba8IpwuOj8l2nZhbBZB2VsBCVuFAC20q+aLS8e9tr291zX3vVTb5hJ7DYDoGiYcsJyVVLDFm0D2EtbhmwNolhQd2Q8QBzcXwU0ODiBADuLkTqQBffJbUFAmpoXWuatnUNcl5cUDnDAjSoDvaBOoKbB0s75Q9gI7imBBMoXx8EywH9qkKI481Q5AEnpt015LvdLTLYMlhjBFsEGBIlO3JjzLiXbNcD0qCs/oPZr70N9D/WI/a0iVfoe0LhzD1QTYIGa0FgjzAXTQbFWhrxyG1NySFpyAluBduIcmgFQnwPV9YEQN9zmEOgGu98J4kmaL96RixQjfqRaNMppiHRXsqTRVHo40x+YegTUNob9r0H3W4Okrh/4OcCdJod4+MZrnoE3ELCLWqkek49iATCPwdLdJ+2SBmf/8P//Pk7//7X/7395Bjd0+eRtecKmt2mHeeJG4aPH9lrQvXqIuFQf1IsHCGWDlMr2cKWBoeTmTTm12zGzZNm4/j+G3i74pq43tpTsyBebM7PFT1zX2ooLJF4UbvMJ1rZOTiVQuFm5eabVykv5Zo2+Ui3faMVQB2MbXDvf8HUsaOttnedtcOzfnQGv++5ahTt91W/MsG+bD7PmOBtBh5hLX6LmJc28/4Oln2QiyDtc3X2s1RqBDWubo3Wo0RACkISuAtIF+RBTCPgK7wjRQkS2jQEaoRwwVASR8KWQ4KjJnChsRI4Cm0hbJvY/up9xfKgo8XIMR+CLDQWG+jMyjwjUjq8cBjEbCdhrj3BsdGxtCI2Fo4TsN6ymtN4LeDsPBPfeSgSq0l94Da930OghASM+IGZYQ5vM+dOvBwR9lzLcQ4CWCT0RRL4YJAviofk5gVjEoYEUpeEc9w/UYTMPfrC5S6V2ahagNHTV+TnJ9PG4I/tCgvwshXkfR1WkfGcf3HodvO2k3z/CHoP0TMoyxA4gpCBpLmezGTLXd6vZJAjP/6//6v+J/+B/+h+Szf+/f+/deqTa77Xa9/cav/1b8/UV3IbGBw/YWFr9XsEWuuqZaaafcWqlurrDoKdzHpWyC2nkjB3UBqJEvYC92onNAZuaayT2sAVSAMjU6fF7sj1xM7wI3ehU488LjdSvAo35A1rcXOlzXjPfS36OypkCZwk77SFOm1m+6M1yqv+6KXjJPLTnnLYX0vOb7YEX7Ls4gdGk9alap31J9slezrcaYZQjgQnBG2RHE5Xlm7rlG4T3ImfZJKayRwzvF+pmxLtlcodobzhShoIHnQUPFlhEYOaOsNqY+mgJbBVddN6QAJwrvLEcRtBjde35/U5si+jkPc1tpvWDPT8N6OWaDGkAiGhgueb1sVQMbhUkZLnrcAFjEekHAFriQsjtkrYrCuxFs0WcekmEpaOgAiDo9EuLk6u3SA9SMAbvYDk5AjP7g4FQDRs3zqFsl/Ge4LygIE34f9eHoPcexbL23UbvmY3lm3RdBpFZAneYZaJ4FlGk/9GieRFtGGFwuHhvrwZD2V22dtzSPfQL2SQIz/8V/8V9IrGGwf+af+Wfwl/7SX3q9Cu2221uxwuJpsaNT0VXYLMzlGn2BJXZrh+AG9R8tSmcWv0v7ItJtK8eXNFG2cAIWARMmtjz5uDBOy1pK5esWL3Wt03WBM5K3QWm38k05XAtsMdOkBryt3DCbioGfO3YxG2YpIFkD+IDRXFANvwu/xzSvbwlIucAWM2Rew/KQp4qNQknWgGY1oG7J/V8ZCvvmLbR9UW+Gsp+j53wBSOMGLY0Su7g6L+UfqcOrAEkGlMQ02JmDD/08hqc4oHWjDYRYPmMYjyWwREEV58CwWZ7G9Y3nek4BHm3rRtgKbK8TWIuj/mj0PjEezybkBuCEOSKskrRdJ8NESdggozCy0rFavwYhRC0DqSywlQNMWncFbUpmAYq8XTwBjkEs/cRkik4Ao/A3cbwn6gEHD+plbPgDofu8kexPHcP1qsfCyfjW8c4IAI6vAzE6X02tF6trLwvIJLeSDzKTDh0Imak82ieAOqB5ElCGeg7CwCEDVgivA7NEFdr+2W21fXLATN/3+Ft/628ln7206O9f/+t/Hf/T//Q/4fd///fxs5/9DJ9//jl+8IMf4Nd+7dfwL/6L/yL+tX/tX8Ov/uqvvmiddvt0zbJlanZtmMQsOFOaRBeyKRbZJ+6IjMQQ1SoL8SUU/9GOy0QbTfa9XUhVFv010GPtmKoen9GmJ53lks2NNbuozU+tnVZwzrZOhZ7Xz9YpiQdfcsnS4vja5+aCnfvciqCM/r1kfrDZTC601eCy1XJA5uTU6pHvJgYaP+cLf7Wsv2p9rJlZ4kJ/bZd+KnPnWwBl1K7RsbG2BHRZCATN2ScLxJTMtEcCCEwM5URjZAE4E53nS7fjI0umF/ZE0MsQ5krQIFHHXQGbwEoR5gyGuY15qEcBGI7phGMYkoTdsHMRRGCiyC6wzrHqjmhGI3iT3jsHXAzQwtmclIKQKIMyGP6Oxysoo4CTwyBsPMUuslaa9yphOHk9yDJp8nlW52n9U4tMQCAa17EG3oxYPGNGSqybjmcXonRD9ip/dOAjwR+GvndnRvPk0TwLkKbgnt5bTCMewTRTpaxNp56PZN1RYskk6biHvhttHnmGO/URDHK9ApcctHWy8dExiIZ7kTAtcw81oGy3on1ywMx/89/8N/iH//Afxr8fHh7wb/1b/9aL1uE/+8/+s+Tvn/70p/jpT3+K/+V/+V/wX//X/zX+/X//38e/+q/+q/hP/pP/BL/yK7/yonXb7dO1NcyUopjoNeXnMbhrLWeTrN1FXFrua1hJt6AG1KwxuxtzrfN15flLxlzJ8VwcLqU/S2NLP7ff2zbeMEytlAVjtJBJji/c35SDBtR3scz9zQINmcZAtC2d9C3adQ075f/P3r8H27aU5cH40z3mWvtcQA6CGIVKNGBQ0SriDYMaLx/HEmKVVgiFJZZSRkmJpRYJ6k9RQCBGS+Illv6RRJCTIhXKxLt8+TxSaiI3E01KlIAhCalgVO63w9l7rTm6f3/0Zbzd4+3buMw519rjqVp77TXnGN09unt0v/30+z4dfc/tCI/SJPdP9vyrvZ6Of4GxWpceqy/lQhncjrEG2pmZBA4YvlndX68YqgiAGiz5/HG71oTRzc1jDURkVewpQJH6u+bdm6ylJsQQxuLgjsuW0ntDaA0Id16xI49cWIzznok9YFz6ufIKYbxboKx3SFR2Oi5pDLopNkxnSM+WQZpju8NQIWU8QKjHogvtcQTOyHNVB7+T0CA2DEOyiPBaT+5YYeC4jWk56P+plszw4TCfjMNGx3PNkPBAaI3y6si47zSVXJIubMrbKjDEGqQV4LV11gloJSyB4e6F9ZSJyuGOOneEm60nFvRdsqSISOmbjTy2IkKGQgionRzIOKd/pI2Hj3beWKT+PZnnitNHJBclmFw5NmKmCVeOmHnFK14R/P30pz8d99xzz3EKk4BSCr/0S7+E173udXjFK16Bpz/96ccu0iy8+93vxnve856me97xjnesVJrrhRpvmRitO2vc7n06JnhCHjUkRYVgZlW6p7IAKJSjbgHZnm1Lu5TanbumJb0g3VqX2gJ8GZdaNKT6TcnDZw7iRc+SHjqtC6rSu7bkAo0j3tzfrWNLYnFTRc5kCDZW7DPOL95JzmnKMJ5SSaSOlG1BhSbVUbCAx8iVzj/CZM+82PORe6ZSv6zBofpMYvwdhZElQBfvI7Km0PerxvVOGIFZIYCzjiz2Q2JABxMpCXPixjuOgI5D5tx3yoQwuYIKDWCvTDgTyX+UhwzL48YsJ9brxyHZGdkHTdLyYuzjuqXPnjoxi223wM6w8yrCOvSLdxsG4/JN9gOBsY1EyTH/jOFcPkom0QdiQmZ0fzyH+7rTPgxMaG3CU215NYz3iLzQJozJEhzdhfKhSr5MEfGWBUfAkHCzoK1GG4fgQ/SE8KK96sz0N3lpPMccURSQgfZ+nwZtN+qhyrSZSBFDG1hcKWLmPe95D37t134t+OyQYUyf/dmfjac+9al44hOfiMc97nG45557cOvWLbz73e/GG9/4RrzmNa/BW97yFn/9hz/8YTzzmc/Er/7qr+JpT3vawcq5NH72Z38WP/RDP3TsYtyWSGotNBpnqdAKl97B3ainGtKnQNAsYdRGOzIxliIKasiZyemRxWyS7KPIGeK5sJgK3Z3iM3H9Zio5U+qDcXmZ51rifatuyxpyxl3H5DH8IcrEQsGDpri77Qxgml4LqZPw/Ct65xACiXXvT6F2LHDG6Zz3mivTKZAyp4ATImWACm+DFKlQas+UR+qK/WARjbmZ83ZMHLR4sVGwY3wnoHc7q5lhT83ZK4hLG+IEDItRB+uhMsqHeKCEIUbuwshzxOnlEE9K42GgQgJHCOt5BwBDewdzQOCdNBDR7hhrN/bkSR+EYxSZO7JEGkOipLRQPIFEkxvZCsPv4GSnBIHC6reRcLchWUfGkOtj71Sur1IixT+fJdbcMeDutoveHm9tr1OGnDHp6DDNCmibtiG3TL/QMjy2Xauovkkom6CkkiWUzI0DSaMdNygxiA/7AjAEnRgTjml9GyaNDVlcKWLmvvvuw+Xlpf/7sY99LL70S7909Xy//uu/Hj/zMz+DJzzhCclrvuIrvgIveMEL8OpXvxrf9m3fho985CMAjCbOM5/5TLztbW/Dox/96NXLuuFqYtEd+wS4xefchXoTWowy6o5JcK3i8Bsx9dlrhIJnwS6em7wZJk7UWa+dmSRFiZyZK97LLRIm1T1jcBbTrVkY1SzwcuRM6rvCzng2hGkKEiFT2TGWhihQ5DwAue9Txr01TqlWQxOOTDwsQgBuaEdNna5MzrlxcRGCpgWpfFZ4XEcW6J1ZrGoNQ8qkxgUS6sjCkw9iIJfj8Y2QM74csZcwp9MDAM7jhCNOnO0UF8l5xgR8Q8BahL9dUaIwGv8d8/wjPRZCeriyaqvPEs632pMPmhAHvs4I0RCM51qHYTISEEKEZEtmo4SS8J7wCzZshvoSesw+ufL4k7J6Oy9bQm94FlJndO+iMOe5uoLrRvQZXKhdPz7pKal51msI3VsvMe0/k8LOTb0ev190PqVt4zxvRsfLu0cW8+a82xhX6nDxV77ylcHf3/zN32yEuFbGc57znCwpQ/GsZz0Lr3vd63DXXXf5zz760Y9uHicbsohd7KkhdOUxY1DOCrvOhdL8TwZT24beRwXWavIETouQojHywW/3MX3GlAdF/P8DjOMeDfXuwLZ3ZsebLmLiEBoWsY5EqYzR7mg1aVSzIx/s1DLXtLRV5lq2n3Bu+xP7Bq33UdgS9cyJdmGTO8O0bkr9JyJoRq7m9IfLI/bsWhpLp8k9y4Y8Wryyjryw4eyTufBaFm7xVlWQxOeNfc+PDc5TRdlTji6VCeewXizu5Bk/DglhPGW4McKRDjTEpFeDx4AlHtyi2YSIDASAFsOJTB5Kew0P86PC+oo0fJxXxegnJmX882D4AfmOg4j+rzG0hyZjXGITQHcyIGVcOwTXFMb64HqtIZxn02VvwnVoqJB7b0ib0Dmh2qZyz+iICBL65PPyXimmD4lbPcStHvKyH/oATQtlUsZnLy1heCahzjqos86fgpStL1sm7fosXe1LmCPBpdlQk5e23H3iXRRhu8XaNTnStiZkcUOIK+Mx86Y3vQl/8id/4v/uug7Pfvazj1egDD7/8z8fL3vZy/AP/+E/9J+96lWvwk/8xE/g7rvvPmLJpuG5z30unvGMZzTd8453vANf+7Vfu06BNiyGU1rwByjEDc/CNWXv1/B+KqbJkDIAeO+HmKSJdxFLu5AuGdGwMFhaQwVA4B1EdxNrtUa4a3JlzGlNkPvitip5m9WGBCTD0uJ7uZ3hKBQp226FMKhaJOs+YXDGoQDJOpnZj5LppvRElvaUWEOf5jqTMYfwAGoJSW5pq1PRHpoDvyCO/qZIhKYmkyTvurZjlegBJ8AqLlU4flSMQ0PYkA2F6oRZ4O6VD1n2Pg1KB0cJCymNJ0k3kCYaJmwpGVra63DMSngXB88LhKQMQMhwl7Ye6iTn5RB/rKOxrSL0qcpWSWjceHgCCGYc38nArhidxkfeNV6LJiKWaLi5vUdIOZ5j6aaCgjnly520tZNGuwiqbSxxZRBG5Nf3H18eDPovjCdW0Be8+Hzn0zTkjiVrHOmXmJ+ynrkJDyJ3n/Oauf9NL6x56g0WV4aY+bmf+7ng76c+9an45E/+5COVpoznPve5ePGLX4wPf/jDAICLiwv89m//Nr76q7/6yCVrx6Me9Sg86lGPOnYxricYAiItVkb+uEpG16GM9zjuvnQNEkx/YrEdY80wsFZBWndt0TjjkDBo4zRjDZlcOcxF4aKcv0GMr6uo+7h+lvKsaq33KXnUIqh3bpFI83WGfsPRsS3ipFnNIEanpeWUkmwIE0P88bty6SRyaQd6MnSnd2640VzSpCGdg4ajOlxnQsbhKj/jivZBzdifHY8T9RqL0A5EAVeGAomagyNlpBiGJkvOmDRpoeikp4cfKYnnqzKjrrRKKAKWnIEfSxzRIpS24STW5lMKYieHR3QkR0zyu3TInJwj4dnn1UBwxDWTl9dLYSAq+1TRQ4KEPqevIfmmCAMpgJ2EYyu8t5KqsDsoSpsigK9DTcvDhUhJbTRanFhubz4TQgRhZzWesID1uOoBQb1jBMZkWArU0yXSpjHlIzo0NYhDcwXSm3MbJuNKhDI98MADeM1rXhN8dkjR3ym4ceMGvvzLvzz47I/+6I+OVJoNVwnxArgqFMIiDplhQ2jQlubRkHL3r0EmzMSBE0PO3r8QDl3vSdfzTN2mdFyqJl1uIZ76P/nb18sEMmVJJLVgorCaNQ0Qtm+myDO6YFhCpyVR/8l6rg034sqX06SpNK5z7c/2WatBMIh9ZgivWtSGOHFIjVXVC6G27JoRh15dZcLiGEiFzJKd+euAaqIggzi0KRnqJMzP5DAJd5sLIWIWmABjfzk9jVgI1nrIiF5B7MkJRC5syX7nSZn4fhvqNPxtPSKo94MMQ0l8uI40Rx6rnTsue7zR5MKZ4tAj4RfmhTYjfdY/696EvjSNedr+OK8h/zPUQ/DTq3T60njJuB9KuNGf2j6St5dF0Ofo6VeDDgyTT7zCLtVV6jvXhr2td0oOMWOKFvD1YvqFHEgZR2r2pP0q64aG5vr+FNsfcdtu00UzrgQx8wu/8AteTBcAPvETP/FKeJ58yqd8SvB365HTG64/7n/DD7KG7prECbfwPLimTUlDI77uGGDynSPAm2xTZrETu4QugaROSql+5y74Y8G4hdCs3dKYdvz/kyAya98bNJSXWyyuiRoSaYF+kiVkrLEKMXHXPcZUQqaCQF4NpXw2EmY+aua3K4TSmFI1Jk985nSoBckwFfKZTRgD6RGNTSPbyOqL+HFEAJCWGAAIYUF0RZQahYtoaUgUWDIleEa3sFUIhW3BEPH2+Z0WjikXOXXJeukYomdYTHOhSqN2Y+rNHPlsnge9+T/1pMmHL0Wki3ILe7LQp+RPr4Pyj8srRj+pfGm6/DXJYg9pOFKJgmjXmAuF6Q9dB911yXksRwKN3g9uHCZzRyotLRwRA0+ODASiq9eI9KyxBaiHFa0XWj9Xa1g7OVwJYiYOY/rGb/xG7HanH4V15513Bn8/+OCDRyrJhlPG/W/4wfJFCSM5ObhPSG/WwjO1o5oyimoM/hYDrtHYm0NCJUmWJb17SF6zkFt01tbZHEIlcx+tx1VJjwXImRTWIjNr68bv9EoZiFJSMilIIxMOVTOGFMuSQ9yPKgiasS5OIunKstOdw4OFhsbeEbHRuwb5kTLmW+6vxTHJ86WQ82qZ+mxXvU4iVIWvFq71mFivfhHpFoHEi8HD9V36DsS2iSM4AO81Yz632jCWdKBjk7YeGuqs8552TlPGeSIIDXPUtl/0AoiOMtZCmCO6O+vNYPN3HgxUgwadGNdlgUj2pEdEoDhvBtGr7P0ByDjAb+zkb2c9nqj3Df0u7g+BF4YlgAp9JuVJIjR8vcbPwT4Xp9vSq3E7crd2AvpGZ8KsnI6bUqGdzsx9rbZ8cF1cXjp+64GgG+5te/ecDcF57ybTch9v4r/NOHl240//9E/xe7/3e8Fnpx7G5PDe9743+PuRj3zkkUqy4eRRq2vAXVfScChg9qJ4yi5VzTU5zYZaYqdRHDBGVdx8jDkaFcQVdREcY1LkdGNaceBFTU675NRjppv6JUVEynD/r9khZ8EIO4c3MpUaXTPlHRiJD9K/yYkng3GM9NiydB+sSe9Yi/m1nnktLEFsrUj83044fGiumyNJxgJGNNeNK4U+IbQTVB23a3BcMyG64xOT/PiiMYx3sfeIYI4ytmK1cN4MgPUaAbBX5nQhMXjAeKhBgNbl79Lw2jPOK8R63IyOnyZp+TRixHZTUHG2TkRmbMcEL8TofdZKD3ppnozTENp8R72CqvNkBOvLnjKJOiLtFoDUu/+IarElwrizeSfaI9hsoQQZ1ZHRxGNI1on903QCEA8dAIFmDvtObpiMkydmXvGKVwR/f/EXfzEe//jHH6k0bXjzm98c/H3KYsUbTgusKG0JlYthocmgOnVXlZIP7veabu+5tKMJw6E0qbXW8dIim0ukt6bHxpS0/X1cP4wIxIOIllb25xpPkFMnaLKL64kLb66NqtuMMYSrQuIYgibXV3LtEhivdNdPVRzRO5Vgzd07J80peebym0qoL3HPMXFCJMtBxsDrDA0k+JUiPDkjbBpSQEP6k3ioMDg9aprq0Wibtz85p4saU5rPdE8zdjoww7Xeq8Ke6GNOGJLD+0tsLDUiuWGPitYD4ey+EsIQQfQ0oYBcYhbrLr+cR7UjlnKoIU8zY5MGLMkRkmGhF09mbOPSJrbHkCizscloyQXPT++P8hLOU0nChDNFx2vH6afsi5FHJ2vHuv4bkpQsajYgmHob9REX5odI0JiDez83NOGkQ5n6vsd9990XfHZVvGXe8pa34C1veUvw2Zd92ZcdpzAbTh5V4UxrYIpLMXUPPjU06KGMwkQqnqdKIK8yrdHEO9ObJ36eOBzGLUqz8c3Ip3nb4MB9exGNp1z/aelfEzWF2PLT8KWUB02FBhHXB7k6G73PkQBkvHBZZZFeGh/X6lsnRDgcFFfguVNi6qnvNpQRhDW1wm/maLiwKBea5IV0d1QwleaLIdwoCo2horVeuNaGLkFivEh3aSltvB4SoUFUN8SRSF43xIn40hAoIUwozU4OpAzZiKOaLCMvB7pgT5HLmTHMeWi4euL0Ybjn83oyRJDWh3tZDZ1cvimdGUd+BrZMjc4Zk44PaXLt6+BCY90c5trZHeXN2GIle62EpHdKUJcDYTey97g2SbRT4PXDEXkWrGj3FRifTw0n7THz2te+Fn/+53/u/37oQx+KZzzjGUcsUR36vsfznve84LPHPe5x+MzP/MwjlWjDlUDjbqofYGPdhhavmbVQYtLXQrTTwerA5DwKUt9PCc1ZcXc8F24yNQQklwb9O+dplF1kHNDNdZLHWYyo/dYkqBZLe2J/Yz2kbJ+vqctJi0vOoyZKc5KuRbQjPPyBYbevxiBfc3yMPQ5T3itTQyJzf18H0Lqp8KY8KKKdaI6AiRdk1xorhsnFR2yPvFBa07CLa26+i0OVhP+HINLy4EhnR5J4AkPp4bSmTkALKwgsBC9WS9PUjshQQT7JECUMebeEndR6dnHPpIUYjgSPvXq4EFdtj5cGLMEBuIAwwYzf8XN4Et4eUV71fiVJjrD+BWlwqi0EbUuoYbydauQFct7qFd5IImIkR5sOGa9lgUQfmYKorPF7t4i4/m2Gk/aYiUV/v+7rvg533333rDSFEMHP7/zO72Sv/+mf/mncvHmzOv2Liwt867d+K173utcFn7/oRS+aUtwNtxG4E5pYdluSCX4GRux5reHkd3jSzDn791pI1EeyfqgQYGH3J0wwQ+gcEFN0bxbxyMiUg0VhV2pS/83VN/PdpGeOdYkOjSl98wCoFSZM7vpxhqIjZxJ9JefNlfs7TMSllTh6N8YUL8K5WDrP22GXsvR+5EK4Fny/ku8ETZvpc7eFN+KUsZTaFxX9OHifBTCEHNXPFXGoxmiss5418clCSW8dZjzz7U1DcZSGuOwhL/aAUua0prMOkHK4PxIhDjVX3DXw3jY0D/8czoNCI/AWSgrzxo+Tqsq4rVweiWtN/iptG7BkQiLPGjDveuDZEhNmQb7psrlQNC8iL6Jj1yPvz1GdNNoxAEbvxMgLJp5Hve4L+ZGR8H3JyxYY95GkV2vb5xvSOFmPmb/8y7/Eb/zGbwSffcu3fMvBy/Gd3/md+OEf/mF8wzd8A/7e3/t7+NzP/Vz2RKj9fo/f+I3fwItf/GL81//6X4PvnvKUp+BZz3pWVX7vfe978dGPfrTq2ne9613s57vdDo95zGOq0thwgrDiZ0BoHATxnHTHkHpzMJPMZIGzJbCk50xFWouItdbuVNeEdLVq+NDrk26l5TZL1kG0kzNXP6X1vqZ+FrdDzqtApo2gWf370AvcJT0npqLW446uO1MbjvH7mPOSceNY5J2W8thhveGA8c4wF+Se85rLXVODpdpqbv7H8lo8Flp2nLl7JiAWzQ50zTjPCbSNRYt4/l0l5MIrSm0qov9r8BoqOWh3rw4/q7nHldEtkpX9ssPQ/vH8rrXRI9E2ERtGZcKTwIyFdjzzIVPmfi8YzI11lLzpkNYGadmY8+VB2jtEAloJv/0vSL14j52OXM+JFNOvWXKz/lpTpvFcyr5bBcJIaAC9AiCHtreEmAbsM/JFGIHb0Ky0A4MyQYzKOdJJQlQ3pTaP60pGHrQjHaLwfdM1WkQbRjhZYua+++7Dfr/3f3/WZ30WvuALvuAoZfmLv/gLvPzlL8fLX/5y3LhxA094whPwSZ/0SXjYwx6Gy8tLvPvd78Yf/MEfsITK533e5+EXf/EXISpZw+c///l41ateVXXtl3zJl7Cf/7W/9tfwzne+syqNDaeF+9/wg7j3yS/1f3NEQ8nYqAlDiVEKZRkh5Z68tvt/7jsXlzx3Hohc0D3oO3zkyWZWWAlD3tUSWk1EDGckzEHULjkywF03Kc/KPpwNp1kSByJlasaJ1uebHOLUAmJ4Cq3DsUmKekO0RGRUGMsbTggpQpMjTuaALEwDcsZ9vcCYcG1FglvaYCLRWEvOsOE9jO01vrG5SEO4j4I9OrszmjY0dKcD4tN2XDldGuYYZj30wT48a0oLDOE3lARx908MMwsImcibIshTRtfE3hfk3UkS7QjJBO5EJu66WrAhvFHZuFB2T844HSIY4gIaEBJ5qYAaQqQ0RkXzUW58oKF6wellCVSHyjPv5Oi0tOs4bq2MkyVm4tOYTkX099atW/jDP/zD4nVCCHzHd3wHfvRHfxR33HHHAUq24bpACzGKH51yTYCJ+jXsoBq7J9dOMlNAd8tqJ6kl83dIubueCmrbN7PopeTM1IUATyQWbmI8HejfoxMURGiQpIzLY7TV7AVU7e7wEbBafXJCwLWQVvDR3tZyZC6LOcb03PTXwIJeM83eBysiW5aa+WnJduAWbAlM8Zahf5/s/MMh5f3nMKUNavtzgVDJ9mMN73Ez2v0X5JocpBw3oB2rhA2V8hos0oj0BsdjuwW0PyEqKn+vBmJHKe+dI3QPaJueDd/RSnvS0KRFEmrx4LXXh5o79Fod2EnBcde9m8v1eA5PiA9zJJgRaBbmeZzHUdRONZ5z2Y2oWLNRa9b+G9k5jjhTOmg7tlw1yIVi1nwWeDYxpGPDBtRIv832A/d5krCMQro21OEkNWZe//rX421ve5v/+/z8HN/wDd9wlLL82I/9GJ72tKfhEY94RNX1n/AJn4Bv//Zvx1vf+lb81E/91EbKbGjGb73+B4KBthiLXhr4Zhjm6Z1z4X+qkJoEmBhlNr58TfKnAkvrASR1CWKjotElv9ZDYS0Dv5mUAdoMlhRBduAF7+onqRzJIyPVL6d4yjTX0SiGv+1ed3pKcky6Ll4ureNc7Rh7hdBEEC2kJ5N6L9i+yuk96Iz+BoMrRcJMwZzNGq7f6ug3hUCVZws96ckL2ZJTgtwJTpxWlQ8tcsWQgzhsVr9Euj5ECYFUAV1eJg3hSZlc+sOcOXfTINAyESJcQSqSL9FeAQBhjwL3IsUA3IlFrmwplEi0rEdk7fjG6AGxGjRkLBmFErnbLYE36Lkc5kWusslz1UF0icy1YZ2M88ukZevv2o9hK+EkPWa+6Iu+CHqlnZnWdJ///Ofj+c9/PgCj6fL2t78d73rXu/C+970PDz74ILquw8Mf/nA88pGPxBOf+EQ89rGPnVW+n//5n8fP//zPz0pjw/VDdreMcbP0aPGU4d6NxE6LV9tviOVdahGQFb9d0EV98UmFIU/Ydo1JpoZnaglJKj1f6ZqSPk1wb8llOibhnAFUcNHNprkiaD0395Na9/EDPtdSu/x1mYnQTbyiPKsYeBPd+JvSXiL9tb2nKkntU/GWGaGlfme0eakPsmNv3M+1bjoRJU5zivD7UbBWn6XtR/qt9whIkTL0/7rs/TWc/gPfZr4tXRgSjGe87mwZ6OlIUvrysiEtQgDS6sVIfn+clo8+n/M68foyhCjRQlrPHhtWV9vPK+ZnL9xrpVUgjVeOOf2InApF0tSKqN64+4jXCzv+u7plqkVoDfSAa+ggrCv1HI2bdsF75YkmpjDELhPWThGOjJPCtg1JYylUeAQF5SMhvTpqn6SHbqI9HXLhZOYC84/QqCJEN4Q4SWLmVPGYxzxmE9XdcBKoNpITE22LOHB8fTBxcumvuJCocu+OiYxTCAs5gZ3puUK/XFqrI9eWR67T2XWwpM5FA2JCaWlx8Kr+tcQuYhTGJMhudjWWrv+Um/kJvP9ZrOxxuBpqwpQO+FyeSEnoUiyS9qliSj1PfTeYvEYLz1RxCuRMGL6EoQ0JOeE8Y0waA+nmyQfa9gmtFHbRm6mK+F4Tzo7xIlrSeyrG7hmbQF7sVki+b0oBKFKuhEcHG67c68FLJbg2s+FXs/HD5QcM3j06+pyWKZO28KdkH38cDY4MzyF+jyyhVEqXC+kbtYse/WdDJU4ylGnDhtsd97/hB/3/g8lVMce9Vhp/1TtvxIVRC0CdmSMc9U6WF8YHJGVcGf3nrjxzFkG5uN6Vnq0Y0rTAoq7mBB3WIGHSqSX1gu/mhE24el+4/hdZ5MztF+wCY/hZE0EeNOQiwlIkXLUrfaYsSdj+lSVlGL2Eg2Np3ZslcerkEQcappSq25U8NwH+PfV9PKWjMSGkadBymFTMw2CF/tM6DobCsuSnATQkRHfSewcEpIxS5v9KkVOVxmV3dRKEmLh6oh4jpbHLXdOTcKlOmB+bjjm+WaY9UWKk3hnufXKhO1KaPIkHiTt5RwvY8CoS/sU9K0U8znOCwkw95EIx6fzJ/Yzy5xATaJw+C5e30pCXPcSFIqFNQx0tilR60ngkOc2i1lAq386uL8XgPuLq8YqHyx4Tm8fMhg1XDWSgqzXUOOOGPXUo3pXpJPSZhOqkmXQuertLUzYiFkHJxdbuZHCnYSyWdy7/GpB711xst5ykk/rM7/aeGq7Abn51mAEXquY+XxlsH5kaR164h/Nua8k7WQZadz4vYgDW9pVDerLMbe9DebRcVc8Zh1Sb1tT1hP6QOxluNJZG8+tULaccsX504qb1HVwhr5Fgbww9vi57vcuj17Y93QYQAGkFfN2x0Jmt7tgTZ9ReSo88HNgjjt39sETMGUy/kjKv2zK3TZx3DMh7Qsrsw3bIsdymIIRssV5Kpr4mjL2F99OXgeibBOFEJdsmKiukHOqRhi5xcz218ySgIaB3AoCA2OusJ0oz6BzCzIfoLCGzV4HuESsCzKTt7yDvWCB+TXCyIa5XGJvHzIYNJ4r73/RCAOFC5+CuzAJWxAzDoJzzKlkRI0MjFmZLYe7ia6qhH+0WTGq7yrJXe64UUGPYZz06ZohdViGxCzPl3VgiFKlk5Ex5/lWFmTlR0kQZ5pYje3+pHKkdVhrn7jQl4kc41g5dxfg3SwhyjR1Ibtf8ULuc12xHNbszPyGNVhydlFkYS8wdrAdN/Hl0feo7F9bkNFz86oku+nOeBgC/qUZEV8VemZ9oEc95XGgBswDfUY9myY/dUz31Mu+m76fuOkfKAOG4TkWBvV1gP3c/7lqrmxPMB84bsmfsiSBMzP0n+myKTeK9kDAaI/1pUKiY42x9aGtHj9LKvO/ZsYC2DfUWdc/bp/txiUjRYvC00Z0s2jlZMvMqk/xHxOYxs2HDFUBRMHYJRLsK2m4Oib02JyH2mhg2URnWGoAjw4CLs286+SdXTrf7sPCucYsnC4BQtK0hPS79Yl9hvILyJyTkMtTh/6csQmvDEeKs5zTXDM+JtPET/j97ihTzzK7tlnrX2Rj+lN5BY7rN5RtpBCDcIopOZ2KT4HaSa97ZtbxkuLwT44jXtjh17ZmWUNVWT4lUeNES4+7Ueo3LcOS2mSwufpWQqWM61wcesRyRmOk3QluRXdTv7nvPAuf0YY8/1s5DREfjJxW1VePFfyjkOzyfW/QKCWCvBq+KDtbzxJbB3dOFfdsc0WwLSRbQgQchh9LmGhNKzYY6U2/lIH14jxgvTmyv9/o41INIDQl4jxoxCGW36iAKTQgUNdS/7oZyB7+B0d8jfRvXrhUeJ4DJX6h+CPWSltBTGgJjYWCOWBp5hAP8XA7bN11H6eRA0lBEfTMmBwPYfjfSlQFGmyG0PSlR4+e5DU3YiJkNG64AVhX+44wVOsHvFUQPUGHN7ElCKxu0s07EqSFdDkDKVCMVTpUzMIkbb9WJRktOnEy8ePUpJFdpAucMtgyyBEaFe/biizPXTpxYZQmSX3yw2dSMW8T9vsYNf7RD19qHlx6n4gURTZuUjd1ZPCY5M0X0syaElaaVIqyWQAtxNDfdpRATojW3rPH+r4kVxnHu8IEABaJ7VriFJWi0W+wDaVJbkQW31hBSBmEh5XnC2lcVArJBv6ALfwBaAUJiEClOaLEA5boNvE4A0NOVKHEAIQyhRL1hHKwmjT+NCYDuCQFGiHkNEdRpts5yIe69PU7c/S0ERD8mZ1o29prscNveAhpqJyGk8N5CgV4RIa1MXRASK4WUppFDr6DjgBilA7IKMH0EUgb9w4VhjU4zE5Qk0yNyhi1mQmB7Qx4bMbNhwylj6UVE7QJM290KysKXcOAFBjuh1gh85hZyS+3cFibyJkOblLfaKGD6TdLAb223Ury2M8iuSqBs6/PP6BvH2gX3u2007t+1k2+vwtiQeO7SwjFrzDICqRwpE5MaJ2PscW7ep+wFk5tPliKJ4t32GiK8Nd9TruMSJninXRlypnVsLLT9pA2pJb2vYq0S5nsPTY7Vdp4vgiyCqQdDYsxIaeI4D5g4jSrCXw+eHrlDAGIPDv4oa/K7G389nAylvaeKJ15oeBBgjhq35Ys9VUqh2UWvXhcuRec558HjyBlRsWHE9M2We/yz9soc8+36uyevohO+OmEIFWc7MXOi0xcK0mfqi9WT0To81l1LaCgIKuY8+k/iuQWCzVou35OZp68YrorpvGHDbYn73/CDVSEmKUyOd5+qhXBKXg8trrzc3yX9g9x3MjQ0KJqMAbrz3gKm7IsZ9nP6RuYkgdsBWSM/cW3t9bNBtQBIvmze9hSO2ucJ+p7TaKhxCafEh89Lj69rxRILe6ZsubxcuRcp/xRwAsSHQG4cdeVIhVCkfqbktTCW0JQpYk29riuCSfPW1P4d9x9b78W6d2OnUqzIq/OQ8PopcdiH83ahJy0B8Jo3ztthP07D67w4YiW3GKY6J7HmifMy2at0GpL8kDpiTzGS1kOGkAxUsyU4OagbftzcEqStmWfOwXufEJJDZe9YFlHdutAqsVf5cCjX3hiuSR3UQEOt0oLgpJ9JUx88+ReOu2HonelbIiYGGVKG3uPD6a4yiX4kbB4zGzZcZUQGbc2ExYLuWswRqKRlclhhYD707iEblwvkd4TJbuBSoWi1JyclyzsRo7LP6SOnrq0xAVTPp9ZDqnUXfK63TVAuzkglxvaUvsrFwY92+nLpMt58gRGZMQSTSGlSLAm6c5hK25YjeazoIVAiktcuR5x+3C4nou2Sw5wxnPVQyN6gh99z5+TriFR/WYh0HLRphoWoeU/MaUijdzn2FE2RzwrAjhAiwoWO6JEnROAlQwkfK9AalLdXo2f3pzcF4/DwRyiOTEJ/KNPMaMSw35GyBdeVxmwmTDXrpZ15H4J3qhPmUk3aEI4skuvakLGX814NdUs1djxZheA7U9DMez+hjxvNJKeRJAGvoxTmJzQGLSVXLEvOAIw3DBdGWLse2cBi85jZsOHE4U5novADXs6IbVnEMBoP1aKx7u9ISyHYDaotxlK7kCXjvrFMub9rFxJLnHTj0ilftNyM2NQOzm2Zm1niCXzpXfsje93UnmhlLq4zXJr6SybUiBNu9IaVxLBLmzN4Ga8F7t1IPVMxFADkecmiZeQpU+M54XAAkjgmZa6kMXrCZMhJIzPOuvG+etxnPAMABAunVb1zrhJy3l9z+vJoYWkXpDRJ69kSenlg+LGeGlomQmVSq67ICxFA6CXjxumdHEiZ2CPjsjceL44YkIMXivfwS5A0/tmY8BdPOgnyzDRUKPK2DPo9DWGqnaNd3XEkjw3FiW1FEbcR/aFtkwlhWuL9CmxzZct62UPcvIR48ALiwQvIi715nJ2EvmNnTtXqOnP8OSlnEokQq7j/sCSca8OdNP3JX2zK6r3zEt6KuZPLWNtgC2dqxuYxs2HDdUO0CxK7RJb0HppOOQJGk+3IZf+QRv+xFhgzdu2qPSdomoy7dJjociRFtbcPEQOknxUJPjeZL0GsHGrnv7Gso5MU3O+l9CaooR7pCrH5wrk3I20ERovD6n4aaSAUEeed0pQ5NfIg0t9KhXxtuD0wi3SvXbzQXe0Ddq2T17ipGfczNgubnkW8CHWEgYhPZvI3hHOeHxeEMLosgW6N8coZ63TAkxBCKXuPNAt5TlBV2xAkey3OOn/kcZgw+R0XPZ6rvf0WPjv19uC8ZZpDt+ntOmwjrXSwwPdiuVpAK4VAOJ7kT+8xp16NxYdpn1nCw5iG+QRl3iuIi0uIi0vz0a4DOtOO6nxnPCn7sRBwsSycHeJEoP3D0OcSlohR1ouIgLa10+LJHNpQrSFTCq3bwGIjZjZsuKLwxhJnkGQG+NFCe25YCocFFlEHNQQb3OiDXf1c6EIlTtrgtWgmZ9z/DwmySzj6fElw3mIFbwlff8xu+FEWPRJhOFOJJEosCLP9opBmSrzb7+rGO9XHRkJQu3j9KeEUw4VqPZ9OqcwOzPw6KeSQW+TGOIVxYwlMbccGb4tinqUQ5MT9I4FcilRfSNliLk06yMX9XMJ4UdjQJVYfBDaPvYLoe+Ots6sLhhB6/Fz+uGo5fk56nRaAEOQ66hVD6mtSH43nU6VG85UAwnKSutECwwla/pQhERJHC3g4xnO64DbMelI+IYCuM+0jAdErQ7j5Phe3f4Utw42Nvi5I21Av1Mjj1ItWAwE5k/agJcLCibHZ2Qa/+Z9ezKaxIY2NmNmw4QohtxBiyZbEwFpKp8rQXHHhMUvwbwEDnj7zLOOX1tESLtYWS2nWtCCnnzKL6Ft70bXSYrT15AF/mgJ1DYfZ4aw+UryE1DNyZZTkO45QY9qxqoxTCLlkGJYzFhdou7lpRPezi7SShxja+81scHWbG7tPQfNmzrUroVY7Kvc5d03gUZHrE+77yCPtypEzU+bEY5KcVOeFjt2xt6FbnIN4bbjQG3ut7sbP7tvQEi/muGLYfIbFbxCGlKo2pQFhPEt0Z3RCYp2uGNRTIxiTguOu3f3anGrkHlmKsfcF9XKJnq8KcX3TMvQuUSfum0mHtE1MGNGyTYUTdBY21IzW3ahsuw56Z0OVdtbziYb/dxL6DNZDSg/tFPMrEmWPXU1uAAhhZr/WAtAINGS00gPJ5kLTOtt2cZ91/ZY+X8qGO/Tm3DXBpjGzYcMVANWZ8ZNiaswjsbU5YiFn0E3WeZmpwj6ZCMnFnNeC2UFJ1sGUPKbqqjDieMMHkfHC4JiaBE1tWRInrU0jlU5r/S+kg5M7MUH02p+ykfO2KYJ57iXbfeo4UgWiTTUIH1aSMkdYsAdjQqxl4JDpN7MJmbUXqafo6XOCWOp9CN6t2oXMdQgRSLy7s8etKdpTU9JyXixdKVwXxBYbe71QUsb8TTwRYm2YXP+Q9h5ttGbkRW9PASKeEVoHP+Y0J0IoxJo59FQlf1E4V7E6SrFWUuuY4kKAeksUOHvWaqNoq7VjTl2yP0y9auGeyZ5GRDV5GPKHa0fOFvZ6Pu7n4hK4uAQu91b/hmxydAL6fAd14wz6zjOoO3ZQ55352UnoMwl1JtGfSajzDvpMQp9LqBudv07vJCAQPEMAzlaJ5yRnawA+raAvcralrxcx5D3aJBz310DfaEMzNo+ZDRuuCO5/0wtx7xe+BAA/gcSeC6vupOXcgBsXS7EhNtn1dc6ColDmkdcQDZvJEQELIunGDAxeDxPQshOcvY4TrIxRivOf0o6cR8xSmjUufaaN43h4AEFMfJY4jbcuSaiQ/0jw/69BTltmXJbM3415uzGI1VjgQEiZ1dE4NsVtMZk4Y/r8ZE+ghJZQMf8p79QJeKks7u02Mb1F5qiVcAivmer0Fxp3Jz1TaS5u7UPk+kBXxnYGQ8oY1sKcdIPRIj8gcDM200ikldRj6CmjR1OHIWOk8XaQGtj3wP4SYt8DN3YAdobEiJ5r5KkVLeSH+hdsSJbPm0uXpDlpcyb2lPHaMePypQ5noF46dLxNidLG5eTmUKEMUSTs0efmtxoIHkquCSuwS0gldcOQMWoXkSYk/96GNunOPv5eQ+w1ulvC6gjBb1xQvSHtPLI6cupTPwiGuz4MmO7iBX5J/oHXTAyBQQ8p0mDivEBjoekN9diImQ0brhFSjH/q+9L1uetYzDR4Z2Gq8V6rGZECZ/TljNOJGihrhT5MIvRmEEEsaB2mjPuSce2+X4KQqQ314MT3qnZsYeLjKaI6nbrgyop7p8izmW1ZTSJV6A+N+vkRSILacSClk7MK5hLPa5EzS4VrxmlNKUsJSxK2C8OPw6mQpkAD4pAlOywWCx2ec03ieg34RavupF940uOug/KTUBqWfC7o3PgFL/WIjDxozcIYwJlZyRtiRw1hNtIUWAeLaZA04I/pHs3rrhwARI8RARG8T/YdHXl/xeND6plVODc5YsIfbc3MrcmTf2j5Kq6NdQPZUCpgCPuKQpc8qeXClTphT1iSxitmZ71i7pDY3yn9qVayN2mKfiA41JmA2gH9ufHI6i415KWG7gTkhUB3qSAulT3KPfRYUecd+hsSQgPyQkH2PQk9EtAg5Flqo0br9PhCyRkGvo9plD28NiSxETMbNlwhUK+ZKahZ7BUNo5qJtbIsB8EahngpzSUXAIm0AoOK+47aDXQXKXF9CVx7sf0pNRm37FZzzzzHRX2thT0xltnTMgiCHUrAnNAR6M1gMXImzDgyuhtJtZTnSHO5snVDvssRc3NQTYAO/5/ktVTwCju4xozDHG80mkbu+zVJNJr2nHwq7juUdst0cVSAE+hcq9yrpDuF+JuK2JuylD5DghTviYiDordM7C0oAGgE84jznglEd6UVcrVjuQbRpdESwA6Q0p/m5IkEVxYCGhYfEBcx8ULrLEeu18y/NeOQiE4XouRPnF6ClBnZK7HnKAn3H5UzIl9GpJoTFFbCeJm4azriJQOYMKpzicu7d4aQkbDeMgBgyKfuApB7BbE3p/wJJQAh0cM0Z38u0J8J9DcEdjcl9AO9Wbj3Y+8foTRkP/QdoTRE75hE22fco9D6oR6/UoZ1qqxWEWNrsmSjEKYbbpiMrfo2bLhioHozJaQW04uQIm4Xp0ZXJopNnaWn0YJGoy6Xfz6OnDG+agmIGiSMyVRIWwprkGEjvQ2uHJyR1eJltBRq85hQtipSJmfULrBQz7avXwAI/vMl82q4xoOOI/H/D0TKUBx7LJp0b4un3prlWAt0nF25LK7vpubQJdMfzcmxdlGsFwHYkAYdpLEGcvVwcojf85mad8n7lV20+7kPIw0Th3GIjCbfxV9GefR2Yb1XJDRIDORMnJ4U0Gcd9B07qDvPoM+6kJiPPUDicubICn8T0xfJ84yeac7YG9tVpD2KOl9swomykHYTipAyUUiVtp4wuusA5xmzk6bO7Q+k9MSZayvjPWLS7y40ugsNuQeEMvmZUCWF3c0e3U2F3ccUzj9qfroLDQhgf4fA5Z0C/Z0S+zs6q0EjoXdDX5AXPXYP7NF9bA9xqXz/FNp65kR9Nln3cT+wBI/XJkJEKLofd78NqdowDZvHzIYNVxBzPWeACTvfKy+OVtmhTO2wZogCLnY5STLEaNV+aEHGcyZGzohe1AuDwSjtXFhS/ExL6wRwZWjx3HGg5UwY6imM3KLpjqSL6aZYOkxsIXA6K019KUXa5TBDF2Kqnsii41DNzjtXvpq+nhrTlgzpS+Xb8v2aYWgrh7kdmoxI6WaYD137aqNzoe2xxiIcL5b2bmlOK9fnC95ks7BmP4vJADjvgrEnAWs3KD0+Fju4hyyYaTp7ZTxftAa0tNog2npZOo8IYrdIl4t9LwSZdwhxMcVzlmqUpDDanGhpkxov5DlgNiSoDg2AsaeMtL4LEuH7B9fuZB6n6bmQLgFAA2KvsXtQGW8ZGEJGSw2hAHlpSBl5qzfEh1SQFwK7Bw3hsr+zw+VDOuxvmL8v7zQaNXKvIS805IVCBwXs7YlOSgFdwudC6RFhEnj6Es+Z5P3kuhG8pxX/9YY6bMTMhg3XBRMXItXpzkFUptWFibmds8b7DqofUYOFwgaWrvuiJ9GS3y25EKPvS464c5iz2NXUgLZkDDUUM7oRtQut5CLyBE5vqepzS4Sh0XZcc6E2EWy425S+niIH4+c/tocLsL6H3MrkzFrICUrPTfNQoVizcCw7JQ6Ji8GUy5PrMQHmyJkKIj0mdQCY0BVK3EchPN5rQ9kElIKA9HMJvU+E1I8naZxgbuCFUkLrpgUH6u1Smd5IBDl77fD/ag9sMQjs50koEZIxURrcZwHJ4wgOKaDOpfk5M9fIvbEF5IXRjpG90YxxIUcC1mvnQgfpQBv9Gd0B+878LW8Au1sC+JhAp3oTWiWjuotC7MJyYxQ+R8sfIEqDiv4OFWd0lk7B5rjK2EKZNmy4okiGNC1pjC+xWDoGnFHAhRgBeWOiFbG7c+x6myvjnHwSabOx1WSinLoYcMdPpv4e4Vg79lPTS/WXVJ2X+hiFcMeqRrtzPq3w2tHtU1836qXDuLK3oLUMbnE48jabEooSh03miNdTICNKqB0/M678s9I9BlreFwI2PIJL+wqCOwkmOX6PTpE58Wfm3teF2qmqT3D55cYeW04aWjZqDy4USEXHT3PXOU8G6/0iFNH/2BuRXrFXg25I8M4j/L+yoU3Ok4Z5BvosKC24uXpw11a8r8m6ikHScu0X/xTLlEAxpJs8Q9ZusTox6MQ4RCpF0lhSRnfSh5jpTpqfMyP2e/OeDg8+XOLyLkPQQDhPmd54yuxJI7sQNte3LhV2D/Y4e0Bh96CGvDSX9TcELj5O4NbHdbi8u0N/pwlvosRecMy1rYeRd5YIr022CUO0+bTcD7CIrXG7YyNmNmy4wvDkDDNxpk5Xin+yWDpm+1hoIWdaUEGU1KBJIyDTBknBu/j/M1DVb9YGt1hNLdqPUaYYQsDFpEPCGtgI3cwdljJoYrHDpdPHxDCH+J2Z216pUKATxMEFf68RqhfiJ9r2k5DUxCjfuqbuzCTUeq02oGph3zD3B94rmXeVtZ9iUkbrQbNEO70YDZAfwWmZBHnY+SL23nDt7+aVSPDW5+vDoIaFfjXBnUEVEUMRkQXj9PTohytTLs+kXcuFMSdA9VU84cLZO3FYmDRkiyNj1JnzkhlO7jInrgGqi4SNC5t3QtlwpVvK6M/cVFYwGIAG+nPg4qEStx7WYX93B3Xejeo4IGe45xAg5QzbYCx8HKYVtBUlaDZMxhbKtGHDdQDd5VhrYTpyZTyBBfpctO7k0fCAnGv+xHZY/Yjkgn5JnM7k9p2zODq1hVVL32AQuFw768fqRJgPRfh7IpKhEXEfOACqDHaO1GwJR+D+H19zCiQyV76pffxUnukUURsaWai/kyIzcu/uqW6r5sJXajxIK94NNowCUUhG7PlRQwLT0CFKfnAEuiQn8TnvFHp9pFfihZrJ/9317iQf520BAEIC2BldGV+ehE4KdwKjhzvBKyJvTH1l6iIRCpk8dtp9Hx8ZPro/0wZxnhEpMxsVfTJbJwmdNCfyq86sRwy5Xl5o3PGBHrozIUlCG7FfR9hx4LRv5N6I+QoljEaNMB46l3cJ7O/C4I0Ds7CXl8SjSjPhSiSvVPhRUjMo6hcjEqfQRzbkcapD+4YNGyoRhDRlDI9ZJMqpLQZKYUqt5T2yt0VNvHQKTdcfw/19rbo9NQKnFm6Xihra1FV6RhsF77gQ/P8XQkp0Ol4kzN65v6rtHGOpdyAOMcj9XDOcSvjOQTckcs8chVisdYJUE2JCZCXEO/uBp0WtJ2vN+8h5nUpHchBSJiJbhu+HE5XoGK+lND87CdjfhqCxWZEQGeykD5XhQmtYbxF3jQ3L8Z8TjyDvRdMK6lW0VNiKIm235Fi5EOIwbp++9ZYJ4OpeG2Hfs4/ucf6h4efsY3vIS2XImUy53XjnToqSl9Zz5pbC7pY5sam7NGmoM4HLuwVuPazDxcN26O8gYU1BnxqTS4OnEBljc+1Q0UZCa/zW638g+f2GNDaPmQ0brgG4U5roTsoapMyV85ZZerc5Ti/nTcMhO6ktWL8jt9Z0nouVw9UF5yq9pLF+Kh4ElWXw72QuZp25pwXBDmpqt3cGasqTPV0mRk1/KLUz169OoV9cQ3Lk2Ejt/C6X/gQyo2Xcn5If5zlzIiRVETXeSjPfk1Toy2wwZIvPw5MzCMgJf4y182axJ/sEgrJxGIz7Pi66+4565MT6Nc5DhYYLqXDM9+Q49Qhyp/Pk6p7xkmZJmMQz1aab3WSzaLZDVhh7uRApTepYXirI3vQBLYQ/NUv0atS2lNRLhV5RPRihjJeY6GFC4pQREO5uSfQ3BPZ3CPQ3gJsPl9jfYUiWc6UBQgDFni3V9l3Oc6nXw3y/uXosgo2Y2bBhw9VDLfFx6IVRaYHYYMAvQqpFOCiZdoW0P2Zh5kKAEwBdFMzJCblypLSpjg767rSGSRwDnPDoqZVxQzNG70JV6E0+jSI5kyKiKsiZo7y7tXNey3zApZn6nkPr+xeHM9HfmfyCdpQwR5qTdDQRwOXvp2SEDX3RMJ43VAg4OMK5Yqyhni3SpR9lnqmjEdnPeO0U2+WQ83/rRlkLIlLG/GFClABbLT6kDf7EpSqk7FZlj1yXAoBCdwkIBXS3zDHclw/tcPNhEv2dgDoD+nOJ/lyi04C4ZISiLXLjThz2NiLmbD9wIdp6zTq/jbDxWxs2XBPEpzSdVKz8Umid2ONF3FzDoOb+0s5+44S1SDjIRCxq1C9hlNUY34cy/lYKfVt9IVUIm+JO3wJQVbeU3GnSMuA+W6B+j/buEMN9dLLFNcPa4UWTvGPikK7GftQskp9BbXhRMo8Z3kEnQajO8ZJJjQNLkf5Z0sj+znicBgtVr6+hw886AUgbrlQYQ+O+Png4wKYBxCf4DeEoKaInvD4WDJ4Cf/qQez+6BNnEtdshvRtzc0hJkyqjXeY0ZbxoroY/ZUv0avj/3v7dOg/Rfs89gyVb5IU51Wl3s8fuAYU7PqRw4wMKu4+ZdnFHdWvuWagHVdBnnXdXRDpxmjhRnw8EpjdMxkbMbNhwjZA8QnsOrppeAVfemJxZ6nnWrpcDiqdxu7gO1UdiOkzZ0awFN/FfkT46RQNiDqlQK2TYhIa6rl7U5jQhjmXkZZ6zlew5FW2UtXBIcmZyGBPVPpmAZF/OkIi5E2RyeRTf21P1lEnhFBZq3JyRAiVlolN6HEakDNEViT/3bRqFqYxOIHLlZDaUdGeFgaXRnIGUQZqp9yLWnKGEygiJPky9d0dEfaoeS4RI6d6M584ihHuK3KNlSpVRDOSUKZMez2FM+sVjvV3yqecj+bkwKcCUpbtQOP9wjzs+0OPsYwoQwP4OAXUmoHeWREI4Vrtj20chdP5a8OTN6CHsd8qSUifwul9lbKFMGzZcU5yUYTYFXGx6i4FXim2f4nJ56PCoyABf+yQszqW+RCZkj6Zs1ZiZsng6BiEzcaGRClmoIWda2p31eKnMZ8m8A3D9Yeou9yEWelPzoG7u7vGWLO6Ud2QmKUFxLJJplq7MFSBtj4VkyOwph95lvBlGfZ0ukjMbBkGoDob/B4QKvTYiYAadDelDPKr0VkD6tiJCwkKww8YUDZdmj0Vfrnw2zWly5W54N3Nz58EFuTndpwQWKxtjPwmnI2P/7joBiB0udkb8V+1EQCKZAoVkkpCAhp2vnFaQ06F2/dFFY5ETvnJ1sJEz07F5zGzYcM2wuNfMIYyzePdlqiGdM9iWwEzDYgkcIjQjtbDPorYecqEruWviPE5w0dDuSdGW9hw0kTKlHbJWgnTp96ZwbzKUqrTLW4lqTyCNwQimmNp3U+9IyX18xjO7cKxRWBbBmmK8i+KAbvat3jLJ61Ii4RmC7KQ3Zdb2buS8HlKISRkgGPccCRJ4GWhyHTC0g81XO28K6+HCvTfN5Kb1jqiaA3Jz56xxoHwNOw4weWafP/N+pjxOSmWbFULEhcJr7UOWoOEJtTXssrwGjCYCw9b7RQGiB7pLDbnXEL27uL7d3SlNzrvK5ZUuSJT2VZkPThSbx8yGDRvKOOQieA2j7VgCdAshJw456RSRhfJfZAFwSO+HKW2/cPlcXdKjKukuafBZdN8UjBYd/otMgvSEDWBcb7W76VOJtFL6Dbu8TR48CyJpyE71ukuVNSZoruD4NhVNJzTFc8BKbb/aWMwIrvrPfebtbZ98P9aon9a+ueY7GpMyMRHtx8BEfdOjr/1YLobTjgA4/ZHgdpJu8jSpKGyq5XmSnsANY0M1AVQzvjPjUwuRGxPs8fx5DIj4meh3C5Qta9NxXjNaWw9NE7akBQxRgwKhkukPWgrTdztpnklZlxmFsddMjGseurs2NmJmw4YNp4WlDehT0awoIHc6T8lQmkrcxEaEu65kXCTj01u8Zo7hKt+6cG0sX6sHzKht3CkHa1RLrH1AiKDRpXanuBZJd/IWl/bcd639pPaI8KX64CFC744cWhIftXps6GjhnF2A5EJZc9ccEUnPjKuIY5OF8bvDkTIUThemywQVRKFKQehifGnu3WG8dopaJDXjam68yHzXNPesPI+n6qSV+FicxGHImPjvVYmjFDmjALHXkL2GVgK6Y+71czVPqDhvGfc3JKA7AQEJ7JXNRwCdS8demur8G5qxhTJt2HANwZ3QdMzTfSZjzoR/KLf1lfJYamJ3RkLO2OP6RdPJOlNQqrdUyFNrHlPaZ8W+U/ToIG70LfowS6E1dK25XDWLtLl1XymQOsJUzZtDgQvROED+sfguK1p6qjgw4dJMaF93LN0/56RHxnV23CICucl8qBCwJCf0SKLl4U+rSRclfKfi7+xnzDwU23LZ8Xehup+qUTMJpMxN70tLmBYN60r9cCj1n4VQZXcx9e5PgtprQBPyRYMQvKlMyf+DI9uH0LzAGywa/5c8ye52x+Yxs2HD7YyU2+uxsLR3zFTU7tovkN+s3RXSfocKacqC7uQs0RbxzhBNe+2QtzjP6JrFRQcbxARZJHYug34RCVty13o01nGxHg68a1576kjT91Mwp69y9x5Y5ypHwDgX+qaQIoLcfaU0q/Or2dFfKVxxKpL3XjWvmbn98lB2CQ3dJGWmorxeQ4bc5r1kHFFjF65aAULBaJGkThRTROiXgnhICU3S9nkW+lYc0rSAntbBQd7ZRfOf49moaDsOv2l4VQm1G13V40fC3pK9QnchIHoB6bRnADJ+6JA09B9r7/mi6QW2DwphCZogrQ1LYyNmNmy4DXDQHQ9MIBtOhRg6MGpDh2K0nqBRSyJMCWsa4RBt2bIzNqE88TPHi8Q4zCxbP5HhVG10tZSdGuGpe6YYUjlSQc07FnPqYj6H1U7oaFnc1xApJRxRNyYUOq1rn5P3nqHtd6DNiCl9MOnFUdCf8tdNzLe1XFV5rEHKLPgeUG9R/7ckJKMd3+JnTYbyOZFfAQhoI8JKj1GmhE+vAaWG445tyEiYUbgwDjxJavVconwDVM4vR9NzmapPVpPe1PtnkEWre7za8gmtgUuFrtfoaL/qCKmohBUujggawPc7bjPHkTMb1sUWyrRhwzVF1elMrYKc7nfFJHelQqZixAaO+zv+P8HcULFD1BfnBn3Q4yZLrsIZ5E6FqcrT/Z+iIWRJRwbKHCRdfambPCkXe31DXdbE52ddpgv11OotU2zHCf0j+f4stZhL1XWubpYKiVstXFKMfloxh5Q5KKFzZO/Q0vyQHf9zpMvUsL1KnAwp4z6Pf1rSy4yZw0bEQMoYjxeEOjIpWC0O1Qkoq03jTsoZ5lh7v9aenIETVQWGtqwZH2vn0au+6dVa/iPpGXEagfM2LirToe+CCy9WGnKvIHoF9MarUXUS/Zn5UecS6kyOQ/ZI6JM/ccpp0zniUjb00Q2TsHnMbNhwnbGUMcotbCt2XDhx2WPHnlYTEblnK4i/lfKegqzg7sz2rdVFmK05c0wjMWcoROUqesC0hI5VPHNL/bcK89J0AiNviqho1N+mhmwkj4+eaMwtFTaSJadayza1rx+NOCC79wuiJM6b8pziyrMYkXPgOq4RB63Rk6oRgV8azWke6j2h9y81bsRlicKIaP8L9Dug4eJBdGf7c3zKU3Q/tIY54cb+LRP75JG3TOk5gpP0GmyYk0WtfZPrB1P6ZCpktLBBMeUQBoecbZo6qCEbfuzmexdy2hliRWhACAUJCfR6uG6U53DaEwBoicGD76r0nyuIzWNmw4ZrjPvf8IPWTbZyByb1XSNSE8sxcerCxylxXs5bIniOyLOiNu3a8hxVNLp2R3DqTmolUmKnhxa583nlnq+mzuIFQgtKJBY3ltS0x1pClUv1hSk79MByO4erhJzq4Lf7/6mK+84mjU5oF7dqTE21QbTwPymxzaXCTlrEWVvey8r3mK1Tcm9IsgDojRdMd6Eg99YLhvbXhKctAL8SC/Kj3pM10MyYk9uYy3gNsWkujKZ3OUWSpPpBrq8shJRd1LLJkhJxTo0Nqc/SRK7pr+JSWQ8aO15IQJ1L9DeM9wy6cT/zotbuhDKBUOS6k/Xv54YmbB4zGzZcdwiM40gZaCEg4gtTrvst2TO7g4dGvKM0msjITkjRo4Yxdg4hvBujpl5zISyn0C5ZRH2PXSiWdgQbvGSuHFJeJq3PFRvIc9/51vy56xvTiPUiWu9d7F2o0fqhmFJX8fiTa/+qkNN134NS+gcngBbwMDwY4nfzBMmy2Sj155Y0HOJ3gJnfY7AEs0tLhXpa2r6H1KtLKA1YQsZ4KVjvmZ4vl5YSQgweCS7/ZDlKSBEdc/r7ynoisbdctXdco+f2Yij0IYclQp1zXnNZj5rI7hFaQ0OYY7SFBqSGOhNQOwGcCehLk5GEgu6t+G+qL9Zihhfbho2Y2bDh+sMN8KkJzMWlar2a++uxPVXoRJcjZYqIDQKg6t61JvKUS3wracOlO/XeRXAqsfO0HKe6mJtSrpReDrfAWdLjI/euLRCWR9/zWWLaS2AtUjC+ly5oue+uuIG8CnFD66rhHZ8aytnSL5Njr6uHWBT21DC1v5Xu40jJxvya248uxEuhnxrGIyHaCNOdCDRrPHYSqoGEyYUEZsfwQroOXL9b60Sk2FuG855pEoc/xBiXGBvWsoVKmw0ceZMlZxQgLw1xqLrOHu1uvWBseh0UtJM8cvE09nQxX5aaNrnic86xsREzGzZcczQbtiX318pFBZ1YkjsAJUOrlTBpjf8NJq/wq5GeRyrtBRaTS6M1zaWJs9mCwqeyoDxVMmYi4ncgadDT564NQ1rCQ2TB+j64R9ixycQc4QWM2/cU3q9j44B1UKMbUU7kxMejteqTCwNK5aV0fv4hJ1zF78TIKwZ1c+MorImD1ibcSSloKYGdaNrc8cnEBE1LnZ/gfLa0ptUhMGdeWc272vbrJDnTK0ALSABdZ/Rm1LmwYU0C0NIcrQ3tw5iEFf0VPcIjt099HLri2IiZDRuuO3I70RnjJvg9g3xgXXRrjYmWBR9Dsiy+MOPqkuw4pJCajNl7JhhrWSzk6pstK8C6+Z5suNQJGqitmNrHswK3AEQHoGtI0PWBLt3PdM9+fDAc9OSxU0QqPO12JmdmhgDOHduoB+e16JeH6ktL5KNNyIaO3wGqtYRId6NEIFCvGBeaFIfjKnNKjoCCTkh8lsSy5yJFzGdJ+7mY22ZraHblkPI6WshuyHnD1NY7S+7E5IwDteeFObGpuwkILaHO3DHvNqzOetHoThgvm57JSBi3MI0Gr6YN1diImQ0bbgfMndiWXMiWDOLYWFpoN75lcZa9Zs1F/dKkTCvobmIOiT606E7QEgvHa7r4rCK/JniefeoX3o27H768WfDH/++H8hccu9+3IOdZdIp9bWJowzFRs4t+jAXBIbTEsnnE9dIiDrsmlgx35NJrSV8K7+2SBSVnYOucDampy1ZowBx/DUBqCCnHxI8QgNTE62CcuD8Jp/LzZmRCsg4e0tmSBqnLtcmrERYIVwfSYeep71uEhVkw5RZaAxcKu71GrwBoaU5bst1RSQF1Lo0+ktLALYVur5P9pinkbEMVtlOZNmy4DeAH+MQCSAsRTvonYLiPytR0b8UkFtVF6gSkqjQa6yuZjxUabEnH51/yfkogmPwj7RG2TuaKw7ZgrXRz9XVouLJkytO8GJzwbKLDKqQMAHzWUx9mPHFixM+9YJscZcG6dH9dglQpaYZdBTJsbUyogyn9K3WSC/WeqX7Xr2AISBFLvf+pMZXR5xFKD2Eac2E9DgIEoVUCkHKwaxLvX2qhW3Vimksz9Uzk+OPVwbRni03nbEBz1LMcbEIRfn8MpE5UarnHbaoseqoa1YPhoDREryAue8iLHt0tBXmpBv2ZM4nLh3S49TCJy7sk1Jk7Msz+cmWN2mHDctg8ZjZsuO6QkcsudWukwr/MfXRyjz1Oqlywp7h/rrhgrpn8RjsYcfkZEbuaHYNFT39BRMosjOKJVBSZWPzss9L+mPOYSO2i1iLnybCge/JkVHpapPrOGgTE237rw1CcC3NjnrIT+Iz/5+MWKlUZJaHEg4eNLNF3KZZ816+Ct88h0Pj+r6UJ1kS+Cuc5sHxZgmxq5/glkUhvdGJPwgs4u4MfbTx4L5ngZKAJZaZl4Y65dkebS0CDPkci5ARY3rOZbEAdZByMyj9avMf5J73E3G9yg9U+GciCBb025oyFCwtzz/XQK7WzUBryQkHuXX7m4v4c2N9p/r970JKNjoyB+a2hfdjU0W2oa4aNmNmw4RrjKV/0MjOYdmJszADjSYgLI7Kf0wG+Oj4+tdAuhC6s4ao6KmdGZX/0fKmdH2IcTEHOVTVXt6kyLY5SHglSpsmYr32O67x4LBg2nAv0Umk70DZUe8XrwozcmAtZl14ObvyZiKR499KoETCOCb+lDNep6UwNBV2F9G0f2xcL4+CQmYtyi6JTCCE6unbSzP5RfTxyKm/G85f+DtKUYjQa+TCmiCwxabQVx9xs8++EJwtEr/kFuyVrhJT8vN8y3y1NLs7ZsMh5yeTydd9xGzydCa0BbJv2rp00f31qjImI8tF1uY2hVpRO8apNhrmdHZeiflXMVwqYk8QUYIkZIQXkTqC7JY34rwJ0B6idhHSnMzkdGmE9aXpDNWoNk94W1jQbGzGzYcNtisAAoLAGQTBp2Ym6xWUTyBgAhZ0dIcO/R5jr6VC4n9upCIiYYBfHiqClFqEJcotDfIIVu7iMjApzXZj3IovSiUb3IjusS2uOpIzcQ+gFHSKvGGvlVatB1IIFyurf1WgBdG2EVY+FFcjQeKwqES7u+tUNfnahP2/HuhbNeUTv4RoEzaHfnRJh58i5mGyJr6kGN+6kFtPcfBS9G94TpRP2KGIBaAHR94Cy5e9EuIB2v7l3YElSJvbcy90z530vkTLcc+baLPDSsGlp+1mvIRTgyBnaN9h+kGo7gUHEtuHZWQFf531F+9FCBI3PIrEJ5j9vPTXJ25rai/3ubmpo6b4w4U3QxsPGk+SuG3eGqIE7uUlj86CZiU1jZsOGa4zfev0PhDHJJO661uhq2amM420XMWrXWFBXkEw07tdPRMLWHxenvdACpngyAvPsPta6sm1pO8UxzuFJDUOMd5BPshz2P1R7J/5x93KEYIylQzfinzVxyLxm4hCLzzUQjDfOIKY/GPfz+P7FcQyvrql5lrSWVhZlzs0tRS2NAyE1ls7qO3TxtiCW7M+HIGW49i31idlIjceptGPvzsz7oi15oM8k1HkHdSYtYcO0N0OsuTS4zRd2Pqnx3psyr0553wvjiJYCeiegzqT/8QQW1+aRPRJoAQlYrw2Aap0kkQsJbdhs5PRkku9JwW528xGnOzMFo3Lk3pVIwoC+V0JpyEuN7kJD7u3R2R3M6U2WdDTpw29S6kPqFt0G2DxmNmy4jeB3pSQaQhyG63LxydkJZSEPl+TOIJN+0tuEpHOUGHqCVD0Wn09p46EjiRie2zWqaNvUTjAlVmIDeWQk5spKf+fAhX3U1vcp6MOsCfp8Czxr6t1p1bbwC4dUeQ7YLrUeDUfxnInbD7ha/ZXz+FphLHTzyykLSLK7440Y3VvxvMn+HWmlJPO4bpijwZIIuwXALmKzYwY3Z7n3I2gPukvVMK+h4n2YMpbQdzg1Ti84RjnbRAtA7yTUTkDvnJisIQCE0sBemXAypx3j4LweoY1HhtU1gQSg5pevlugTGknPl9L7mWr33Lu6pAdcUWcmroPe6M50wnrDuHuFgBbatokN0Ys0k5x9ICRw/xt+cH7hb1NsxMyGDbcD5hrVmcm6GIe/QBx6VahOgpxhyxFPsikjJS77nB27ysVZrZeM/7xzqwYMuz+551FuIZQuZ+2uJedl04y5hN3cNE4RLeRWBWIvtlntZfsHG7o3KvcB2yUOETgFHEsTqZYcW+qaBtCQlWCntuA9cSreM1MWTVNImdry5P5eDJwO1AJ9O3UsNIs5/dBtxsTz/tQ+FXusxJ40vYbs+6GvdMIQCSMB3OhvmejvOY+P1DU15Z+DuE8kbEwtjQdRfy6hziX6c3ON3Bv3EHmpILQA9q6yMJABJMyLekammm3xo5sr6mlEns55t6P+OXmuLoUzJd5ho0MJ2yZ68Gpyr0vnjEx+DNfCZl10YdqQw0bMbNhwzZFiru/9wpekb6I6L0zYT6yFshZSBEENeTHSarGGw5QyC63Tk03lHDTFaFhT3JFNu2BsZ8ufuHf03NxO4waDIyzk/XsSt23K9d55a3GIjfOVn6dlwcsZuat70cQG8Fr9nfMkmJvXSu/lKRAsSVQQva19Zsp8M/LQWfi0lybE7/BKhAxA+kbC0yx9Ml1ibqVeMqV+l6rXeEzL9g0BI6jq8iUL7S6dr38mbsFcQ8q4z+cSrVPGjCrywoTAqJ2AOqOkg2vv+Ab7WwDQehBnpuGptt60gP1et+0D5OqVeyYfzo1Rvyx51BW92ri5lyFnSmFUgU0+cZwwOjEKQgkIpaE6CS1hN2Tsbx/DZK/vdZjvxsvMwqYxs2HDbYr73/RC859Y/8PB7oKMJhJ3mkDFJLg0ccPpRABIGwdxbLePURbhxFVhXLjdgfinaAwsILQX1GPtwrdyV40VOWbLML0x2TRTOjQUCdf1QOsm+m4ySnobS94fX2v/Hj1XRqOm5d2iOkJtJzqRH60BpawAYCb/AxFtyfzpux29/80x/IU2ZdPj9B+4z+J+fyzvmqm4IvpJzVjoeUZ9YyR6nCIZ2vJYHQuHtjSFrEX9K6ibUt+LQ5fcuBCHmWT0Mfy9jX1daA25VxBuwZrLO8pP6EJ+re9czfhCv6+5rsFTVWhA9grdhUJ3U+HsowpnDyh0D5rP5F5ZMoCxpbT9od/7Hz7vKlsjKp9/lkTdBnNn5ThdNd+mtKYS/WLyPN4IE6qkIC4V5EWP7lJB7LUnHI1mELzejCc+I323DdOwETMbNtzGuP9NL8waSywpQ//PhLWMMMV496TQTAHIjBFIJ7es8BqdsNkFciSuzEElrqkMa0rquABIxrSPypnNKtSrIelNaYNYNHh0kkYLgUF/l67lCI9WtNxTYfRm+xa5d/QOEgIkqwfEpZkra7KgzKIhOB3NZTzT8DoGCTG1zFOJh5J2Q0wythKsrXnn0NIeByZjDu5dU3iuWiJkRMgwpEzp/zW4SieO5Qj/YI6paAMnBCuInTC/fPSPoc1q5s2wfHXvR7zAXuTQhKlj61JjXARXF+JSQd7qcfbRPc4/dInzD17i7KN7dDd7iAtliZeKPAVC+8T1AULqJPvCUps3DkzYfIk0yXp4FkjC+sM66q4DUH7XlCUY9ybkTPaWnKFkqSQCzpQ42zAZGzGzYcNtDndyU4wWFnwRrREOSywERiK2DeUsLbCCdMnJSMRACnbBcsVMLMKLC/A42Tl1VlMvjelWG82pcjMGFRUMTe6QHWjxnzupihpr7u+pKBE7/m8OzC5hsSyUnHE/QgAyjDtncUQvCl+uhNfM0nmx9VC9q2qJ0HjsaEynCmt65sTtfRW8aGLCvZKUaXqHG0KQkqLcx959XnEcHYW4Ei+X1A+UgtgriIs9xMUe8qI3f/dRWhYtHgb+mtqdf46UKaTfZH9MfV85z5bSO1nzHrTYFo40662XZa9NO+0V5GUPedmb75jNn5FXMmDGSHvalT6Xg7dGROq0iog3tQV5rtZ0qjw8E5hC2CbnpZb+RNpbKO29ZoSKvbjbvIk25LERMxs2bDA6NKXJNjZUEq64OTSHEsxErSG0hHvoyLOkkogpgpnsSi7hnEHrJ04fNsM8sytPnHRskHGLPMZgaSJlZqDKGKtdmM4pS5R2cjc8k0dVnSVCoZJpUwMr/pr0hbjsRrixgzrfQZ3voHfSCADW1uMSrviknKPyMWWmvwFUGb6LosbLyy9A6XhK+nFDqEAy/SXJklaDewUDPfbCm4WGumids0qESpKAaUiDS+eUEbfZyEOGtMdoQ0ip6Md8L3oNcWsPcesS4rK315aJkfCDwaYZ1blCuv5z459ymwbjn1RIcnIzhs63JRzYm22EwnjHet9WEkFCa2gBqJ3E/q4Ol3ftoM67IO1qZPKs8pw+IObapFVetQGJyYSI+w1A864EIfya3CMGDZpNY2YeNvHfDRs2jJANYYq/ihafsUDfIYmYVdG604D8s08WIlVEmBnGyKXCxPk8yXXcsdpBuxHDOQcpmgyWxU9OKGFCuxXTUkPduLYIjqJPpFXeVaus87kg4oIArAFGvrYGlpbC7FB2RghQXDrdhBnkyhxShrmfG3M86OkUhxZNLUFpa8QK/ww5AdPF8pySfss1B9g1DcaQA+ZbjbgdK/teTpOGpnOVSJkWBKQMABc+GRypLgENCQg76ykN9BrYacQrwljgflS/uY2l1LZ1BeHq0qqZ42me2XYtEEGjzw71PjTmw4Y3c4gIg0Akmds46irKkd0QoWXMJ5OcbzIYEXNrgsyTxQ2hxMZf8M4JhBscGhDQvi2991KP43v4XQNsxMyGDRvScAsbusBhDBqK5IRVuC/IdsLEtypqjLGpi84SSospGRIdOQPA7DxFC3IKZ9uWHoMafkz5UkZXcreb1l2kv8Gl59OxZW3eMWv5vCa9OXH9khH8taBtOTKwZELDJ4FgRzgiK1LHX/uTNG5IiB7YuUXQVHKlb7+tBikRVS+8mbmOxVyPlcS9WePffXcVwoByqAhFXC2vhZA9OWUGwVfjLRPkFVx8BFJmhbZLjVUBKUMJGc5LtwOgBKC7kMTpULUpwmn+BNfn2pgb75kQ1ixqNKVq5pWSt8naGHkxJjZ+Ih21JmLfeWBoDbk3x5ADgNhrM2Yu0EdbSJnaa1L3cd5RixM2LXMP6WfFEHGtzXtHTxhz9qKAIU01hlO0NkzCRsxs2LDBYAKx0BRXm9ICmeBZcBKoCBUYPceBdrJy9ZcXCB68b4qeLTmCo/CMbNoJLZm5oQuTjMEUMs8sZMV1qTRrdvtSEIAGqU+O5OLKozWEFtBx2ePkNQAFK7TZWLbCAuaQmLVbXYuaMZQQ1NoS3iZmf4H+ORGrEuEzxzw3BtBFw5oed4svkiqF9dnwpYbNjFngQhsWnqdyYb5OOwYqui7XznbxKADv3ZLqx1kCTIh06Fiq7jOhMPHf7HsV38+185oht3E+C4SWBhDOu0lEm3rRZblxh5ZLw3tsxqc3eeFZ/4Ee5TMq3pzxjquvGUR+bryZPT/Vti03Rueat9ded05DeBsErrk39d9Z2IiZDRs24Clf9LJgHA5Y/NhrplKzYWTsxDt+mfCEk0ccE4+2UKRVkapPzpBijPAlyJAlEYQskJ0d7U4BOBaYsKapqK7z3LuSWABrISAkDAFTsyBw+fTGAJO3eh++JKbE83P/PwFkF+A5r4/UcxQWUunF4QqkTONCYXUifAFyhvv/5LJMKoQYL9xr+oVFU3hvgpw56obFDMImDjsbPb+y4r0FIgaA8dgD+Gu1DnfrOS+n+D6OCJriZcelyYytbNtTfY44KRHOzYsgzidHNjhEXrpx+QaRXkB3RotMe28XDALAvWqet72mSXSjliLIy81R2OtAeyYIMyZ9kGqSNen9pbyaZtqyq3jPOG+lkidZ/CwaITnj3i2r94MenhT1m3nePlvyAW4/bMTMhg23Oe598kuHWG0CdpIgpEzeK8Mlkl7EBBP6AciZFr0Xj4bFVjNBswL8bnJNfcaLZs7deCoqjPjszncF+TAiMxKLv9FR3aU8alG52OQ0l/hdXR39nUgwJtGc9VTT5lxoIgelIXqYOPIewF4F3x0VOYLRInuyma2nViN4MU8NbqE1Z8c6t6A6JdI7sbA7Sv5TES+0K8eAalLmWPoM7jm4OWHh/uNDlhxc6FJVOKYOwp2EUoNN4k6No+mWwq/jPBUGbZmpmxNR+JUAc4KduybWTmnBbBIgM89zfbr2nRUCeifQn0uoMzkQM709cnkvIC8VBJQnC7Jgxjene6LlkJfRQTMEkJQK8kINJB4weJZKsPlOsgErQ9paTmVMXbukV2PWk8sSXMHGl21D94Hv08rYCJADKaPlkTfMrgE2YmbDhtsY937hS9puaNm5yxhaXlAMURgGhyUX0y2YuHg4pj5Osh4rn6WVlMmSUZn48ywa2niWd88Siw5m960Go+unLILi2PCke/1AkmlFdpRjUosLp9L2FCe6jprZt5ciMEd6BoDdJc3c1Oil58vKfL7IO86RFbV9oNYr7pTImRhzyZrUszWNIe3ZpvJiNzJawYXTtCzep4ZV1NQjtxCtaTf3XkYaMg6j+caLjEYEjv0dHI3trk95xTiyJSZn4msSqH3Xq/tRRNyMPGUymxojcnhKW8eaZsz32TwZuO+F1kMzdQLqbLDzhAJ010HvNSAAeQEIqOj9Yfpb5OmhlQZ29ujsTkLLIX1TXkvYuKxtqC73zMW5aAECeZZd0Ph9gELfKOdFbCuXhMbQnhomZMl6zmghTFsIAOqIu5PXABsxs2HDbYp7v/AlxRjWWQKaDAIjhDO+5oCbiAoaNu75kwKrNN3o8+QJGjZm/WDkTMp4bjEqIvG32agkZZJaM0vHvOfumbloLRnk1adv5RZ49rPRTl9OH4bTmsmB85hD3I7lZJbAaFyKFoCx+HOoQTJtsZ19Z109qyEP7ppc2qvjGF4oU5EiAeY8w5HJp5EnSCu4e6d4VKxVD1O8KOhcST1dohATrxVDkQhVgiLvf+fqhyeVk59RzxjY/8efEdQsmEdwYsSjiwX/f2B6261Evgbtk+jbozA1AGKvjccKMIQzAdAdoIQAtLSaZSKrb5YslxToz4xHjlAa8nIQBXZljcN2R2G8wTMw7XtgUoaWZRYs8VZ7IECtHmFI0mhv5wKAjvr6b//W/6+52BsGbMTMhg23KYo7y3MnehouwcVQTzFia/RT3DUVu+NVi7hWbwYiKHgUz5lWLYDcdQ26Can0Sh4ttULAIy2XpcmkE0ITuVDjdRAvkAi4ExRkJ6AYf+RUS6b6ukyIGrcscnza8cKd/jd6ptr3rlTPwffxzu0p8yAz9EAWRcHVfxYWSGvuIqh4vHVrPqc6ljV4dDgMXhQISRk1uKcIcp+fB2j4kbuUW7xLANKEsAwF4GwDsB46WokxOQOMvW/8Pel3nj3VSfIkriO8R1p7MaKwkuI8V+M9E4UBV4VS+vW4GHtmJsou9go7paEvlfdq8ZozIHVlifXicyXyFBpDiNTlQMy4Z2RR0lqpxYQxdgkNmZJgsg/zYjzRq/KuJcgjHaUgrHrDLGzEzIYNtyHu/cKXDENoTCRkdUEKCceTKGPgBMx7zTheI7DGXTPKd8EQhKlIefU4nFKo1gJlCUgZmp0eX3c0gmUBwb41wMWac4bV2PAnhmnc37QGrJCvjnQZaNqf8f983AJPwKN555kifs91ZICX2jK6P0kCkV1H6qV08qKG3Lh4DKTGlhMKq5rTlqN7U94utUiJxZ6CCHtqfkot4DzbkvAiCk7pcbYH+ZsQMt6zhpIohEAZPOfEcD9QCE3KkRDOA8ddm740xsi7ONN2TQcFyIgQmeoZGmGWvhUtn01fdzKa4zXEHsaTpRPQ+4i0U/B1PSbWxwQfHZcBoLtU0HsiKOw9dqJ6Yp89/LvZWyZ+DxLp54i8XHlaQTcvhByTaIvPW5RY27A4NmJmw4bbDPc++aWD3gQ1JCowldgYT0SMcCtJP5VPUTC2wmhpnqRqDKGSmGoh7dnERNYrKG2Uxd+tRo7ERWB2yprqYIJxmk3/WORYBUrCobUeHEPYnjNcMew4Kw30wAPv3+Puj1/eLHjg/XsjIrwkYlLGobRzXNG+7qhXrcEKo0/CaIdxYVLvmP2W1vkMD7xqnNg76pESmS3dQxHdP6ePzD5uF1iurq0XiVYCdJc90FwhhAr1nhGw5AwwkMmcXkx83Db4Rf6oXAnEHg6ld3ZSHZfqt7QJFSPjYVJMOw4XFRiTXgnozui+BKFEVowXe20IkyjkG8QOCdqG5KudwCwpk9AALtV4TuOeLTO3j0Th42eaINSe6i+5ubsKzNjCh9CZup5FxjB9jA1rgiPM7DUKXvNnw3RsxMyGDbcjiFZCjUZGlaBmdE8KgVAc6MQ3/E65+RYX7hmjpVULhMv/pBEbZFzoh1/E854snLvyIqEbOsxnlmr/jDZZzCX8VEAW+06DJhuz7wjRTkCdd9BnElAwbuC9xjvf9ACEjRWvbe8qL54ZpAxnPAdtmNpJnuGd4UUsIyN7FuJFCRZ6t04JhVC6RXBq7yXTrsnFfom4aRHXL4AjZRYharJ5avPO5LxmiRaF1oCwXg9wIU5SEq9aPXiNOG8WJXyYUChgHhE9EXlzUI/MaOwphUs2o5acWVAnRTj7IZofhW1yCAHVCXM6khZGZwbKkG3+WkKwlIgemq/XJXRfat5b0iHjXTRqi0wdVYWRkfoIwvYAQC7IUjR4YK3i2cnZk65MjjwT7osNc7ARMxs23EaIT2FKMe4xKDkzdad3JF460iKJykPcVtmF2ILgjtNN5Z98/tTESY20xO5XKhZ4MeNZkN8xSQKwHj/JMI/E3wBYIm2k7J9BtRE0AbNOcFoYcz3P2FAKQs6kM7a71lJA3ejQ3+ggLxTEXg27kn1j2SqImeqkUvdNWfBT47xyzAj6N3lni67vHGi+3OI9Fb7ClXcNsvCEvcTWxqohaVNCmFZA7Hl6kDA8ujjlSKbRjr8AoIB9D3G5N+EwZ1b1ypEyLuyFOcbaa8XEcCSO059xnjgBka2TJA+tt2ZdkEjbrnRvSTPElD8xHtSUoxYV1/vwTiECMXTAjJfdpYLuhSdNxN60n9/smTh/ew9GKbxmkOjVQAJypHyMUlskyJys7UnDYnsF+dFbELcuoHcd9B03oO8QQCdXGV8DG7E0lme88pK2JpdOqg21NqcziQMToNcUGzGzYcNtAkfKsJNTrDPDXSIKRgQBDUniPg8/axjIWya4BMFEyxJ/xt2XOop4ipAbW3/UIGB22gLvoaUm+JiccTud9CP3fJld3pr+kAqbGi4YypR1SeaQ2hlLGFDNRsOcOi8YS1I2EhhReqbvEUJNGFIlRSL4U5aE1QOwCF2UG8oz8Z5m0nGNRQiGMuTI6er3uyBQaf4j2hbta2JB76Km/ObmMdkDyvyeLL7JjYGFsJgRIXLdFyyMl0zxHfeaMgpQyuwbSAXsuOOMbNIJkdFAOHikP6PZ+mdFgLlitvQbt3hNhhZn7j2WNlNCg8Z40Iafe3FZIWyImbbhMwpQYnCa4OZzVzcC4fvk83IvKiHGra2iziX6c2ns1L1CdwsQaoIrJkeI19RtMeQMhpT5yEch7rgDONtBF5bYc04QPAoifTeYViOfbQLAS2AjZjZsuM1Q2kErkTMjUBY9dt/ldoqDvMJCBOmXwjJSmLA7ngJHyjQvXkdETyKdXLnnCP4R4oMFZ0AxhuCq4RbeeCafteywEQ+nJLmTSKvoldViFFca1p/6hXfjrhW0XP7kNz44+oyeABIQk5fm5Ayxd2LAixdnwJyFRa4flNz53f0ZpJ47NT5md7djTzvXoaOFKtX2KgmuAzi+fsxS+dfq/yR2vI+CeDypIFiqCAkKhtBZAk3z+MJIhgY7UllZT729U/odTu0Z2Q1ShMSmgvd08dnEpIzEOK0SMoRSU50lvDOaPAJr5z/uvZg7nhBPXh3p/oT6IsLrmWirbeLzz73LUVtbiseTMz4kzhWnM6TM/q4OagfsbgrIvQYu84+RBBF4LqJ23NlJ9A9/KMTD7obutT/KfQ5KxI1/BsZWGxHClJBKhNXWkIajDbaY6LruBPQBsMn0bNhwG+DeJ7909FnOxbgZaiAwcjuEI+0Ycl9VHjMwiVCZmCeXV+sJDyxyIR2pMDGNwMgZh03p4X6vPSQqXZuZckwB47HDphdr6GQg9PCTzJbr9zmDMpd2JYkkOqxCygDAE/7OPV4jxmTGl0n0CnKvIG/1wYkWq4GkP1lToaKMxVA155U2STy6ouw1LvVxevFYeAgCYqbn4WzQeuHaI66HBcb+2WQE9cgo5DU5i2MRJnMQtVVVXSsFcdlDXPbA3h5zvOuMGyElZ1zfyOnFxALCQLiyoYLAnDAwOZluSL9Q/gxKc44pn8iPRanQ59R1tZ/XgOattCdKqDagsymCE5NS+Ud2iW5cwDtNNDhPHSmMwGwjUeYhorGH/p4KZTY29JmEurGDvmMHfdaZeqnYGKA/9HP6e/iitt4S90wgminCdw+B3XZttNKOjM1jZsOG2xgcI7/I4LqUTsiMuORDYHb9kR3EkWBqaWc+lyYBt8tl/sN7yvjvXR4JodLcc8aeK9kFcw0hk/hurhbPFN2ZEtEz8rLK9N//9roPQ/VRH492W1kdH0qCag0pgU//yntIIWl7j8vvDMYlTgaakgZ9b2pDIwGM9XNyegBA88Il1paoRtYjKzNGHHNsS3g6erSEH00Zp6d6A8zErHCmGIGIeuUu/BF3lFchZWJU9BvRa0PKXO4hlDahlY6U4QSUBfGGdGFlCoOQMDfXxGLARKfGX8NtTTsCAs5DIP34rciGMpeQ06rjMOXd4e5hPmv2ZE6VRVPBXOZracJutbThSw/ChDDtrX5NY94jLUFEfzuSMSaOC/MOV+7RZ2TcqQsBD+eiICTWPctSIaIVUga1Y/zRwqyuETZiZsOGa457n/zS7MC9xMKsfFGD62iMA5IzrYvM1BGI3GKYRUQyLGUEBuE5NiTMH3/pLxrKMBb2nTe7cl453NHcxaNMp+Yrh+Pg2VAR0qeSYVzumoyb8Nz2Ur02JxZpSuqAJ6t8/uMdK9WPy8iVvba/tmDKvbQcpfyz1y48Nsxqz6gsXH+eFMa4JnL111KmEybPp2IUDkAFaEE+zxC7t9UipaRb5MdbmHrrFcTeKYYKI5LK1OU4dMalh/D6IBSVkDL94O2hrcZW0I6pNErPmng/mgldLu3cd0uPFVMW961liMZFrQfiKyZlgk0dK+CshQld6i73/nvRq1HaKVTP142bXgAmt0frvMsT/PadskLMbJolsXmfWAU5E6SLkZ1yW413K2IjZjZsuO44htFP41g519FWVD5D1tOgAm7ya9nFj/OqcmVuRWl3e1S2yp014p0hok2r7DOkylIgQKq9UwrCuQ7JRXrOU4JeQ3RBRvlnwkpYLxZMIJek8KRMnH5JA8rpNEABQpKL3YkkzMkZNI1TQo3ouPv/CFzoWW7B4/6/4ri4mqB5Md/KxQfNe2r+J0zGLEGcNr0jpY2HXH9YWBB6KdK4CVM0oIQApPGGQCehdzK0GxR/GxX1HbScwr+Hi3V4n7smKUQ//jxZn1PHkJGXX6KtUh4cS+JQY2L8DI6cK0Gbo9T9CU+qQlo2muNH73FsI5QIxQURz+tTyZlBq2xs57H9dQ3ReQ2wjbFpzMzGRsxs2LBhFpLeITUnMyw4CdacAFWDOaSM+7vGZbXZe6G2njhPD+o14/MK0xtN9gk4ob+qctDfcjhqc5zmQpM5Y6DEn7uysP9fC1lyqXBEOAO36yx6uytc+Y7FBCL9/9D+6y7qFhMdjzFlF5eEhC3yzIlFVNIgX2DsmzXurUxQVaOReJ6DyaQkc1zz0dFYZy2bDquMAUoPC7dOmlNrpIDuusFzxkHqgZxxdR8fm+1CkyCSRA5g5z0Z3pMDHQsdFh0jmLxYcHPTku/sIUPFM16qI7vEjcvmRsB6lU6xE4qbbXProLE9liBnPFL2DpeuiE7YmmJzcQSb+3MjZBbDJv67YcOGRZESM1vbAKjWaMF04zz2hmklcWKw9bQESoZC9AxcaAVbJi8AOKEO/SI4FBIsGlulflMh5sqVVXM7rEuh0uMHiIzNWgPPuuhjr8zv1GUNz0fb9FgeNYfKl/NQWgwJL5Q1Frqj+iLvZxKnQMTE4MSAZ8wXk8fUnDAm52lBPsvWeVZja/n2yGkY1b5jS3l+unFW9Bryooe4uTcnMQkBfWZEUoMTbAJyJkqMkDKjsY1bzTgiphPGO8eLyCa8ZjLzW9KrZWnE7+eh3tdDjgtujGTHyXDuFO6n1gs4QYy7MWXQF6qfo5cGt5k5xbak95byGH1WE4IZi1RzxJrGKKRpwzxsxMyGDdcY9z75pezAWsQM45idKEg6hzg5pYaUaTU6qwy1BnBE0uru5zWTaEaoL/hdwoLx2HPAtXcVYZHarVwSiTAjtm9qbUKXrHaCiBeNhXRHyZ3Qxv+VQWFcCtou5Sq/BuipNDXvJ10UTSVB5oRB1WImQdOMUogLXdQXFjajd3iKlkkJJQIw0T6rhNqmFtmuPEpB3LqEfOBBiAdvmbFMApDO7UWn64XxhvF6XDnYcCmnVVJqN1fO8elN8TXkeyY0iVtox99VY815qCGd1cssMPSVhO0g3CbEBO9ILewR3SIx/2fIomSZZlxXY6eyfSkgSCrKUgonDAoV9/v05tVoQ20jZxbDFsq0YcPthkrXy1hYrBWTY91XdK89ZLjTGvdX1WmqfW04E/2bu6YKKdHLlhAnYJl2jhfALRo8JTAhYckyLNlnbf16l/pe+bAlLSVgw9LEzjSo7ridcT15d3BN0oYLEzgIUlpCpXsakPMQ9KKna4fCtKS/RL9dY7w+Na+eijpt6tfRiUOzkCB3W059WQyZviB6DVzugYtLQ5ac7bznS3I8JkddayUQCP46clpTL4jhvmBB6e6jY2qK/Ha/S7pBzLNyHg/F0M2p706NUG2FxpzPvzB/zhI1dp4qLg0hBvFeDJ/5sCONUXRuTXh4tgwC5F3T6xAJhwwLq72uSIiJJCFaDmu376Z/JzFuuA3N2IiZDRuuKe598kvbb7KD+MidtHIy9EZIvADJxBezOJD4Wi1aXUzjfOYawE1l5jRm6HdL5xlP/C1tl9N+mYlkW7cSQ2vrcATvBoLFgT+5QgFe6Fdoo6kg4U8ZEYFHWl22ufZdW2cGOCJBg4i0SnzPorAQMloWwwIndPkOF33xvVP6mO/jzriesshfom8vTc6civbNEkj1pRXD6WrnqINAG2IZ2oSkABh28qknEu2/dLHoj68exjt62pIWAqIThrCONWlaEQgLw/fDpLdsRuNjhJyHYytaN0BK180UAS7NF9qdrrST8EK+muTjvEc6YfiS3t3o0tdl2y2e15nn8HMOLAkUsTOTNhPj+ptA5ue8sUdlov2xdNJSVJ5k/THkjNAAet1OHl6TYfuY2IiZDRuuOxoXoimB2KZJKzNRBEc5c6iY5FITTCtpUjsBH8OrBpixaJ25qDmWxkhygTfR8Kk25g4ZLpGC1fURiBYlbmdYCKAj19Md4Lj4HAl6ogvdg4ZURQRxipyZIshMFx8AIC+t/k9sSKc8zZYgZ3CNQtROgZxxC5YC6UXrfDTmcCFM5LNDtNcxxnN/rPFeQVz2EBd7aCkgznbQu24IYZLWGyb3znl9kcGlQtiQIyEsKcOhhQCh7w8lV1VIAgV6OLUohZ3Wzj9rvQ90HpxAyrjfSR0eAeidhNoJCC0g+37sWGFDjcwpXWb8FFFoUfO7Qp9Hw6RHSYjIS6jVQ2qp9siTWjUJjMen5s0VhpzhCEgPUhdNJ25uKGIjZjZsuIaY6i0TuJtqNLlJF42/1l3VFePjUxPW5PCrhbGKIX0KCx2KnFdPrp80unDThVLSWFk6pKO1nkdu12RBqIbPgtNFqKt9vOPpdhwz5ZjqPXblMbWtc+SgXXyAjp8UOf2MVB5cPljWE28yDkVkxu/61PdrCdTsTpfA3HsI7zQAQfnX94az5GevPSmDfW/yPj8Ddp0hMaMQJK0IOSMEIDU05PAZPZEp1v2h37vPEf49em7iqTMaSy0pIy57I1YMGI8O2QEQ7DwTI6szRL7XNWPSIfr8DGK4GDrXa/OIOj/v6E5A7QT6GxLdLYXu5j4UuE/VU0rTjn6uEYzDnoBfclw5NTtrIrQAdGdeKHpSlkdUtxs5sxw2YmbDhmuI5h3fePJCuNve6mVSveibEMpSTPuYxvsCiBdei5FFc+uD7qikJuCl6rwkwDeBnJmFWiHjlTyVqgiZRFlq3sNjE5HHQu7Y1gCUtNbI625pDMeYB5mJ8HeUfirfXJ9yC6LV2u8UPMmu4HienaMY74mDkDOBJ2xbyGNr2fx75cllu6PfSfjTkaiXS7xbPyJnREjAwHhgsGQn934xn1FPs3g8FfbEO9H3EJc9YPVQBHbQHQbPxcz72RRuEqPFLjqB96PYPzSsTpr5k3rCDPokpqNpAahzAWV107pbYroNFBEHQ3kr5/NEWougtd0WCDEr2s6FPjraFNjImVWwETMbNlwzPOWLXjb80RDGNAphSsTn1qC0GMxqOCyw46CFgEC9Ns5w3/iz2qMI1wI3mY6EA5cyypzGEBNXbzKu2JVqza9VkyZFzsyJlT+BBWhydzUKX6oiZeI0UyQBDteXS2PCwUOaHGoNSwHW3dvf79ZfvbaaGvTeMM3quP1jLbZO4H0Y4QALGRaFhcasfktCENYkZ7JzSOJ6d01z2Sgh7Dwd7M67lhLYyYFoBvh3isISOPF7Kei9jHdM8GdHbmL6kQA8+Sps6KhQPcS+h+j3GETXtUmrI0XO9cuIlMnqiSTm3GC8X2Ez4BAwIs3kAzW2zZy+mtCA6AFJNYkc5OBlldt4rNqY9MN2e9jqCKVNIu46Z6/UjlMHbmehMXiKJb735AxwmnPGFcVGzGzYcM3wW6//gYGcSQ369PNoQJ09STlYg2k8ARfSnzgBjfKQwrgIr4BDuZ+ndsRXyTsiNZLkDFeGqfU85b4aHZr4s1rDKZc+/X5hJD1lpMBolwqoNoKSO2SJmPQgjyuO6ufh2luK8ckg2v+T8ZaxC4uSNkJugVHwkKnBZDL51I3rK7AIPVX4saCBDKoKA43g8+gH8Wunu+S9ZTjdHXICU0gcOyIe/rowQ56UcWX960+6G3d9/PJLnbf85kfCd5eba2oJcCkMoXuxN2FfSgO7Dup8B5zJcboFHCw8rgbx+JrTc1GA2Gt0UNAC6C6MjpC7VjvBaK2ThIr27c+Pr87zUTvvKGU9srroei50x6F2nFwhPG2kXxXN5Ryp6j6fHLqc0Eji+tli64fbGFO1yzds2HCV0OAtA2C+AbzyyUsxWZE0Qk59oVGB5GS60rPpaJJfJVSiVHa3k1Rz3Zz8Up8feAGYI99mtwEXIpDBqL/VtMMM0GcTeobxmEm3iIhIMYURiL0IhSInLTH1EhMy9DrdyeGHW3i6ctRApxc3o/pzp9qUkr4GY2WAA7zDJa2yIo7l9s+I+gdI9IXSSW4jUsYtGqWE7ro6UsZ9RTW16EqFWbUEoZ6kPFJiFVIGAD77Kx86eOK49z4iY6vHbmXqSty8BN77Qej//S6I93/I6Ns0dmO6ID+qhljKU4TO7Uw/E0pDXipDygDQZxLqxg7qzh3UjQ7qXNoNi3GdAxg8nrTmSZngYgF9JqHP7c+OjM9c2Vyd1nqJ0PItEOZc7cWcuH/D1cDmMbNhwzWE85oJhM0cMi6Uc9jugJHPaZAsuADgdqLN54nd6Bl5HGIXqnrynCNeyi0cnQEhmV2oUnhTLr8WY2SizkZTXZz44nOSNhP3fttd5SCtKe/Cwu9qSbh2EUHiOeF9SkMkpCvYPAhG7vp0LMpVY0UxkyFpJUQ6YUmUNJRO/L1pwdw+ttjO87FROGnKX0aet6wloke766OwJXotMJAyuZOL2HLZayghk7nvbb/1YfQ0fCnxTF7w92IPXPYQvRFG0bsdcL4D7jzDp3/VPcMNMzeYgr9v7CDueSjkQ+4yJ1d15ILcPEjGvJb+uZqQOBduTGw/33Zxntbj0GgKAaoT0Dc6aAkzTgpA9Bo7pYE9Y5OlvMMtBu0j86N3AmonoZxXktaQew15oYzGUG5wbrFlD7TRs5p9mvHM8VjYtr+dsREzGzbcTojZ+1pRU3dtYYIZxQznyrASAlJmwbyOQcqkQiAWcxflFvVMfgDMgrWWnEnpwOSQm9hLejI1aPGuIUTVodG88FOaXfj73etCXtnPFtJ8yuXHYREStNS3U1DaaPyygqGMkZ+BJ2WsNlCWYCmVTzm2Tfj0YjQTOLUeY6didC/YF0doEGmd1DdPiZRxSIQbt8KPNeQUOZY4iUFJGXevXSOP3sGUFk0kCpyC6jU0CYNinQ+Uhu61PeZeAJDQZ51536Qcl2FJ+0IK4MYZ9I0z+4FJu9guGV21o4UzpepFaXPSj7Tjl7MtnMcQhGmjznpMdQK6A9TOXWd+2Pwqx7Jh89DeQwk6KaAACCUglAgrMCL1An2VBkx913J2wTiciLsoPb7F4U8sajxzTmWeuOLYiJkNG64xWhYSS2u/uInkZGKdTxi1ZAeNn24mZ1JkHBFrrGmr3DVVO1juc85r69gTe00fd2VeYJEo3M5dDaHp8mY/r8ksX6/Jdq19xjmeKjXlSOVZ6mNTYD1nRnDJ6fBaLp+YlDGfUfLEJklDo2bUXY6UaRVuHeGUjO0F3rsiSZa579rA7YATcgbgF5zV4xPAj0UTSCnW08aTPXwfLx86MFzLftdrCEuA6p0RKo51cUTuXaBzA0Vlfw0F/atuuVrwHjO2fgXgjrAeNhLMuKmlbZO9htQwbUAR2y0VdUzfeUMCmbApJ/pOPWqMBo00c0E/bow5BEsVEro8SfFoZPp/4v3jwqdbSZ0AUuD+N/xg/poNRWzEzIYNtzNS4SvXCHQCPVWiqGhUriVGS4yb1PfBAjWz+A5EIhcoU/P1cxePXL6pxX3OI6hYjvTz0XYI+mrjswUhhVOOa61NH6SMB9blSbZB6v+5dHK7oUFIkmNY8ummTnYaPAvc3w11RhanVTuk9J6pOCVChmINz5lCaE9Rx6w0lpZOHzok/AKUDjiWeMgQxU4vpam/ES8aDzn81koMDn9Ws8WcgBSllzkGmyU+M2CfUZnjsX1ZO0FOkaI3MwnGXiuZfJOI75vq8Yd6G+cotpCAqdtOQO2Ed1zBpSLE2fBOST10IS3JOyTFcOpXcxlcX9f2WHT7ueWFnMiwFkNzH12vh5Azzch4yaQ+LxHXrC19aBvgmmIjZjZsuKZgj37lDNoVB9OlJv4coVKKf68SCZ6LlNBdA5JGpUyc4FKZT7LuWkKMSFmC38eaiCsN4WrknmNFLx7ZCSitIHJHNANFjxgZ7yYGaaSNMv5UhfCaHE6R5KxGIgQgGzvvhXSZdyKDuUa9WSBUVjZ3NHctTs2DLYelyZnEO7hqHydk0MHepQpycVJ/5dIlpMzIHnH/72A0RaJQJuSI0EQoH9BOznhSZq8gesMC+LClToReLMB4LK4RgCVlq0JLv74Ki+GI3NZSQJ1J9HeY/3e3BLoHBeSl6SwmDD20eSQALYwGzFRCZqSXpHSgI+Pnw06GnUgOJ3y2zI+HRk3fz3nY+L5+FfrUNcZGzGzYcI3BkjNXDIEnxqk+yiE1OJaIa2Z2d6tClGgIT2SQ0sX+am21xiJxbtu16uh0w5+f/pSPm5d3Jaa0xckaoMfuAy3dRdt/6AIzeOcYwjWV1ITHLgn+svlT0vVUSZmZqPX4WGs8Phb8wi1xxHQJblyvIj84UoYR6h3mDZvo6POwfEkvwonz4uCOoQcdJ0k85GqIlwXKciXAbcjknp2MMT6scyegOgF1JnB5l4TaCex2AqIHZK9MONkeEJL0H+iBEOvN6XjAcmNiEOKkAaHNcd26k/YeYTyHlS6OqQGW7AeVm2E5vZhJ41lmbDhpm/wKYyNmNmy4rljTsD6Qx0Ttzt21mRyS+i86+LsFIyO65HKfwCjEgwshum47fa3g2i96V3QPPPD+Pe5e4RjXB96/h+55b3sOKfHfohbDqSFBjmUNx8b+J7Q2O/tAUeMpIMS1/yckdexCBTZdTscgibhPRe94MewGFaTQ7ULKFMiY1sVHrcfGsRCQM5HHTjJ8ITqGmk9Yh7+p0K7TaEnVtfNIqAm5kIl3MPJ6q2oDehqUENCdZc1tKBXrPcf1hSXmsgX0yibbQTM9fr2elgbQDe0SnEjnPGU6cwqSOhPQEuZHmN/uOaCU95jx7dMDQQjoksLLcX+xGjTGe8r2NwzkTBKHsGkq26o0j3MoiQsH40Mi9HHDfGzEzIYNtxumuCrmdBxWQIthG3uCeE2UK7jwpwaOP+o88xy1Hi+HCCmjeZ3ywiSLSZoxCVACK0rjf735AUjXT6PFgQd116/UGNL9+OucHklN+F/q3qOhQVNokX5PSBA3tmhRPh0tWJxopNkyIbzkAW6EAAEAAElEQVTg6KSyRYvR4JlrCfSldJqWQk155o7vzDuXelc4TZLmvpXpK4fWQIs9Z4oaLaWjtaMTmTych0wuXCspaJ4ei2tE8Kk+SKnMwj3fjhzv7QboSH+Kqx9uAXxIj0PaT4M8U+//1I01zlNWCujOCCQLrSH25vSroF1ce3XGY0bvzNwmL4HuQqO7pUyIkvNc0vDvy5xNqRYE4aI0TxF1pFMK9ZlQltY5PCZPOVJ3w7LYiJkNG24HuN2MGi+aeLA/EWN9bnz2sUIzmo1tWvyGSbc2nymeMlnQPmX7zmp1HHugLCn4mxP0nQsmPU0FB/3XxNgRGGK+GcIllW6QB7NQKKLy+Y++S7bQGNU0Lrg+58bTFqQWvAt2NZaUSf1d8V3r8eDXHal3iPahKeRlUvR7CpZ+f90iLNf+hOBIHZNdJJlX2PyJ9eVGO/8Kg+CvE/u13j05QpvPzJ70I8btGZdlNkhdVfW3XJ23guSrBQBh9GL0zpSpg4K4cEwRhrq0BIerB9kbvRh5qSEvFLpLBdErH6aUyhNYb+7hQv1Er/Jj6VokTY19MyOsqRbxIQTa5ks1zzavmWWxETMbNlxXpE6Tqd09jf6u9c5YGtdhwK8yKGS0+7eElsyhwJAzq5Vpgjgpu7NaU7+thmtcD7X5OMTHwk5ETX1nd68TZT/Zd3GicVxtsAYCnqKJTEnqfOnhe49ajYJSv68kZUpkC/2+5CG0KGYuSFIotXfu+xIp4/7fTM5kdp6PuuCJhXqVGjxiCmLkIMdLAxWkDKLvV/RICPRElBX8VQoanVkRRaQMK5Aap0fei6N5Fdp+VKprF5rjvXLnQJrwJC0B1QkIKaB7bX5reE8aCtEbMkbvDTkj9vbI6t4IMNegFHIzB1lyGxh7863pQbOGflFmvEkROULDhBo6zaDOkrVkbXAS3rTXBBsxs2HDdQcdgxfehVoaJSNoDo5h4LITXKochbZZwkgvLTyWMWyGWOyDCDdXkDPNBuiSXmIJwy1YwJWOhY0x8z1uCim4pphCytA6CkKVkO9j8XcjkiPVniWjf2I/mCIIfxIeMwv0e/adm5kmMA4naUvE3ez60ozxckZog88zIlVGzxSfnqS10WSB8KFLKW2YHPx7MWWxW3F9oJHhw2bS5DNnj6wxSs7xBGHbp+QBJwQAq20Vv9e5uk99J4Vpf20Jmp2AFoaU8ZrOSgPakDHahm4KpSF67T1ljrX5x8KFaElhSTzNe/PYa1clZ5ZExbiXJJeVNqQMiJ0H+BOrNiyDjZjZsOF2gJ2I5+BYxMYh9VEOgZLxUUueLB6SBN5AbHXNpsJ8R9GbOYZexhzDzC1s3P9LWJKUuc3IGIo5fXMuSZFcDLX03dwigQFHxhzUC2YOjmT458baeD4pjsv0PU99n8g/iZkLQm7jIHmNEIBkxqmcqO8EzCJnMhDaWkCWjHG6MtoK/cIdkU2uD9rLh2hxk/b0B548P8b1kzlCnM+YIWe48YfTp2HClZ02jzqTXuzZC/r2Gt2FIWEAQGh3LDY86RHnU+V9xrVPlIYpWyYNDtYzxIQSA4BAIOIeY43xaUHvsdq5jtZXknB2IvW0j5yS7s41wEbMbNhw3WEnFC0ExJKCBitgjYX8ovH7J4Cl6qd1suY+j4WXU/kcDBPCnFYpwwIx6Gy9MWnF+hY5so8jZeIFe43Y4qKx/oeI109gSvljIiMZqlSVP1kIcid+LL1DKzAQBKcyFZS0glbsE0toMMzGHM+dhesmq6uSOWK7ikCiqPBCS5EzU9+1MH/y/46QM8RjKUAq1Expww1kxI0P4TWaItsp8cqeEpfznGHS4zO34UhCWUIGRtxXCujOZNUpcq0jvHy9hKRMso4aSc1mMH1NaJjQrJiko1iTlFkinSW9DEHm/pTn1IbZ2IiZDRuuKfykTI3xa47Y+KnZ6Tw1zCWnap6v9P3a+Teh1rjIiAZeRYPB12OlYZVbAKTCCpKLnApShv7/lN+nQ2B0fGttf3OXuVtjzxkOOW2DnLeMgNeXcEfBHh21RNRCWLK/tno7sljQ02QKauaJLDlDkSNfGknyHDk8mQglp/0IF8IkiGaGvYaKmrLkEy2TYWXC71uLNWe+z8yN9OQqFjSsSU+cJ20okrzoIXsBtZPWYwZwovaihw8DcuFMqfaN9WicZ05QP9xR7gndlKY2ietRFO5fc6xaKu3adGpDKamWEpixa/OaWQQbMbNhwzXGIrtLB8YSOipXcqFojawldm9TBNXS9VJFAqyFFiOSI2iW9tSgRnK1KLFtmyXeU2KcZtvbCfgxGBEMwXfzi5jFVTDqastIhRIxP/RpEbCu/kcs14Haew3B3+tAytQiHbI6b+E7hEY4jw7y5VqhEVRbxufFXAMkPYK4dj5o26WEvWvry27UBc8kkPeaoRi1ozanBmpAQgHaeswIDXFhrpd7bdo5ImWCeYqZl5wXodH2IQRMIvR3UTtHCOgzpzEDyIs+0ME5xfc1N15RgivZnyMbwl0X2CmJPnJl7e4TxEbMbNhwO+FUYkFXKMeVVoVfwaNjFSFlJqZ7dUOl5mSaxgVz83e1mED25HZMy3o+9I8FGsAansmQBm63EjONslMYj1ZCbqHDHkXdWhe0/+f6rtv9rTn6eA5KHmoHbOvUgqO0yKbX1CzCq+edgh7GVcMUb4LROOKIEgkIKhpcGPPZ96pkU/RW4yQ6aSwA43mRfU5GXydGKsR0sr2Setejz1jPIkrKUOJJ2jJqDAK3NSG5bjNJwhIvAlIB6K3Htq1vryUTjXO+Tigp4z7TYR6enAEpO+0HhKxZQkRYCyNkrM6l8QrqBbAf8hEzPaXm6N/QtpgTjj5ckNqoSZAzCdz/pheWC7OhiI2Y2bDhukNjmOxOZRG0sKgf91lqwjsUq99keB1LD2UOMscuHgyu3kpGecrAPMSRl5nyCFFnYAmERqwrK7tw7Mv5mnudcUy8OqSYfMLCtmMWIUUcMu/5bBHeVBgJORp3FeQW0C7/I8w5bOhDNF4d3POB7jYzY+cqIaAOh2gD199rSBlLyPgxSAmga8gHqDpGeNTGLm8p4cRq2RPxMpoxQXL2WGhfnkqdtZPbRBLCKc3YBXiCnKGIPURtOqJXgLJ6hiktKyZNTyTF1yf0Z5IeHMx7Xv1eyfA+udcQ2ngBBbpEEQnU+t7Oav+VdKVqynSUwxxuQ2zEzIYN1xTBwovGEB+TnFlQaR4oTxKnPJGMJvOGOpkqWllTX1PSjfM4ygI9d5Rny/0HIsg+9Qvuwt0PX34K/pPXfij9JbPjXCIEiqdiTDWCbwekdI+Y3e1mr69GkemsgOU1ANtPV/BSWayPM+EYJ/H+zLERcqRM5CXjF+KOHMns2jsEC/N+fDJQDrIT0MZVBLoT3kMnBeOhgdE7JqgOioyIhBl11xwWNneeomO3BKAikoPqXbnNjxgj7w1D76BhfqGoEiDm6rfidKYWgWotzHPJW9Eux0hfiM+vhCXf8djGLYVZ5jYsa7ysT0Iw/ZpjI2auAD74wQ/iDW94A/7sz/4M733ve/HIRz4Sj370o/HkJz8Z99xzz7GLt+Eq44gnoqwJOqGkYmuPiVrvh9p0TmWSTArQrtXPao8V5o52rHAHb0alwSyEXoWUAYAnPO1heOv/9yEolbigJBjL9MmaGPMrjUMT1tb9X0cCitXjVLxTzSFu16XaraWeVqrTqoVWtFjjtLCmhjwsHuK0Bjkzp+5TwtJz29OFLgFjjxVbDy2hGS119elfdU9raasw0pFaeixpEPmOwYYz6cEzxvc93yYI9WZq8mHImRJiD8GgDic+a5iBbiNMYlJGAF4PJ/bQijysTsGmbBbxnpjOUvdsyOMkiJlnP/vZeNWrXrVIWn/tr/01vPOd71wkLYcv+7Ivw+/+7u9Ovv+Vr3wlnv3sZzff91/+y3/BS17yErz2ta/FxcXF6PsbN27gqU99Kl70ohfhiU984uTybbimcBNKl5n0KI7tTbMQciz/KWCJssQGacvES++N72laFCSE9xbHXE+YVJollPQypqYrrdVn8d9e92Gonmi7xN4UvYZnWeyv0RGo0uwIf/pX3mM/ry9yLrSL7WPXlZw5Ety4vNj7E/WfJgF4jlgsvQcVISUx5uhfVdVTgZRpyqdikZeac4reZrZ8pbQOjtTiuNFGYLWpJLyuzOg7f2O5vktzldAmrPOB9+9x98cvv9R54P176B4QMORHQDYU6mmSrkgyrXwYZEDOaFjSYTh9SpO5aM7pUKzQeSKEMy7vSBDYn5gV5cOENXndmalzUuoku05ACwmvkaO0Cc8CqkPdjoHaNpxLAJ/is18XnAQxsyTuvPPOYxdhEfzIj/wIXvjCF+Ly8jJ5za1bt/DLv/zLeO1rX4uXvvSl+J7v+Z4DlnDDVYF3LwWuDfniMHnXM7eAXql+2LIdKKQrVQ5u8ZBNq2GRF+z+HypEaKn+rSLjcsIxotnviJ6C6jV0D6NXAGGNZ+rhoyEU7FGjdsdZRwtuDaglhEQyz8r2i8TJJUfBqY1tFeVxC5K1SE2/++szpH2mkuxc+L1d4llrBHzNl+myV5djKR2thFDpyWHpd4gLM5GJPOJTd6L74rm+6LmkNd75ho9AdCYNHZADzPUOFSHXusdh5rRU/lP7TkA4pt+D2hPlYtFepxPjPW5yZC9QrsPC/BuIAmfAtndK60ZK6DOJ/lwCQkBeKshbPYQWQCqE7tTmHwaz5+gr8IzXAdeOmHn6059+7CLMxg//8A/jBS94QfDZnXfeic///M/HJ33SJ+H//t//i//0n/4Tbt68CQC4uLjA937v90IIge/+7u8+RpE3XBFoIfwRhB5XfKBdcvfJf79AnZRCqOLvWvVwiteeiPHvd2aW1C2YQpQcyoie8pzSLBq0FKa9JIa/NdDd6oHL3njPMCEwiBbgZtdx+JvzxKkpU/JZTnGXfw7WGANLaSZELSeDakK4vx0YAq3piNxaZJ65dAJSDapJ5MKO9pJClxxJxI7pUchOKa2TQuP70XQKDCfeyl1T6aGZFESnQr2AHx/ZOnfXeQ9F5lrp+lii0Qp2RLXHAjN3xXnWes2MrokJfgaTCCA6ttQQL6P7M0QOA0/OUB0jm072Pc7YBVoKqDMJvQO0kJB7ZU5lclhYL7EZjflzoZzNuOJrhauCkyBmXv7yl+PFL35x833/+T//ZzzjGc/wfwsh8M3f/M0LlozH//pf/6vp+kc+8pHV1/76r/86fuAHfiD47DnPeQ7+8T/+x0E673nPe/D93//9+Jf/8l/6z773e78Xn/3Zn42v+qqvairfhmuKyHAIJthjM9/Hzr8VE8ubm/xKIVeH0o1ZRCA5scPp/5zpNluNpfpUa3vPzFc7IcrOuITrTkDtBPRu2LXs7GkX5oPcagK2PeoN7kUX52si1y5La2ocGnMMfW5x4XRsoqNlnb6ElgJC6TE5UxO6xF3TQMrMHQvm6CXkFvRZHRqGMEiN19nx7sRDAeceNRwI/XLjVGqhXzhdJ1lnJeIgtnsA31drnm/UXxKEzOjI+yU3AirSrCFnSp8Hz0Sz0uSz+KhqzVyTQ+wtE4VxzrYTInKGetNUaXe5OtbWS3VvxkmqwzMFiz4jRTR31Yr4zsVJCJVfU5wEMfPIRz6yibxw+JEf+ZHg7y//8i/HX//rf32pYiXxKZ/yKauk2/c9nv/850OTgfJ5z3sefvzHf3x07Sd8wifgX/yLf4GHPOQh+Mmf/EkAgNYa/+gf/SPce++96Lraswc33BYQIDtEZCcjNeGvsUiZYagssdtaVYY1Fn1cGSrSK6nrF9Gw0zWLnHFHkBbyXV2AeakQplgoOE6/4V2pNcZEr0w8ew9gN5Av1NjWwpqYCW8AwR37yoDbAWWN+ui5TkJoutTGc8mNY+9+rg3H19Hwg5QmRC7coFHMewkB9iXEK3NpFMvFECo1ixOWvMmMkcdc7Mx9t0f3x+Fbrg7jscqTGhi0Z+L7HaioeVdq8GhRXuOlFo3/munfSS+SBk/kK7eojcvr2xLBnkDoqSnGhFUKkfjzrPpx/Wiq17DWkJfOXQpDGLFDggivxez3vDBfxPbcGuPKleu/VwiyfMlp4sEHH8S/+Tf/Jvjs7//9v3+k0iyD++67D29/+9v9349//OPxT/7JP8ne8yM/8iN4/OMf7/9+61vfile/+tWrlXHD1UPyaNyWEz2OjDku6VWgIQCHwMz61WL44b6r+WwRTNj5jQ2GSW0Yt1Vt27l2Tv1QpNpo4TBAoTSEMoag3CvISwXRm7+7CwV5S5lrYjftqfnV3F8Qrox/Tg5SnNwYlsXcfpQI9/OhcaPvYMUtx/esUj6s309GYSZRH5g6VwTpJsiZ2h3qk31fLOaULXlcuftRAHodfhZ/D4TEi/vb/oheQ/S9+VEqnR55nqY6L4UnJZ99IhGc+y4zhgmt83nWzG8Rss8ceM+M63kyaJncu2V/JtkGzvN06srWefAoDdErdLd6oy1zaeZgc5JYGynNYZYY+cQ8XH3Snw2niStLzPzbf/tv8aEPfcj/fc899+Dv/t2/e8QSzcd9990X/P285z0PN27cyN5z48YNfNd3fVc2nQ23J+5/ww8Of+hG4yHeLV16kTMxLGhWnOyKi44mzCCBUnUQG6CxwC+Qn4xTIopVu8jut/s5FCoNTgBt3hALkXRNx+X2GtgriL2C6M1vuVeQFwrdpYLYkzIRwzVIpqHqnWFPfzyOHdIzFUsI1x6TzJkbAhGN2S48LiQW3LXub1EOPeDSr0U0d7id3CmLgklEoC3z3EXIKM+Zi9IccXNK4BZxXPsF4V4pAlkiPImJIWUG7woEv/0YpZQnaNDbzxJt4euy0X4JCApVJgiqPUJitF6fEKodjeG5dFvmTA0EYUo6+iwBWpZUmYQeNiRYL6sJxI8fGzhbpCUtW8/C1pPoTTnNh+2kHVfORe879Hx9lTY8riiuLDHzcz/3c8Hfz3rWs3DHHXccqTTz8b73vQ//8T/+R//3+fk5vv7rv77q3mc961k4Ozvzf//u7/4u3v/+9y9exg1XF/So7CJBk/JGmDMgL7DLsKESftfP/JkyrFM7J/Hip7gYit3SK4+WPdiODT3qtQWxARv34UZX9axQKV20wBqFvTZEzd7s3gXaDQBLzsR5+7a7HYypVJtcxWenO+ZTy0/fW63JwsoRe4nOk8s3V8clD4C4eDN2bosE/QRytVQWn8dCBPQiYpwHBK0fXjA3JI7Dm5k6I14wPomAFGHST33GLOab+1Wu/ybG2hZSpqmv12yMpbxhJo4dLEkP8ESM5v+f9M7mypEiYJyHVM5OlQK6k6Nn1Z00noDOU7D0nubqR0X14Qmf4fsWTPGWS/aZAsG2mkfMVFtqQxOuJDHzP/7H/8B/+A//IfjsW77lW45UmmVw//33o+97//fnfu7n4qEPfWjVvR/3cR+Hz/mcz/F/7/d73H///YuXccPVwr1f+JLhD1VpQOQ0VuYQKi07NZVYzJC9amEPBYzcbZvunXLTtDblvHsWQ8owTbV1Tuh0QSSPnJYSkJI9zhXa7Nqxx+2m0kS0Y3wd0eIBV9O+hw5nxHrGsy4sSoTGEAZSSKu4KIw1mSYY71mSJrHQrPGg8WnmduAZsjP3Ti0Zxndq4YDJ/pjxYhgRxtRjgfZDS6KYcKRh0evJmNxqhOZtw/DQMX08FrrWqHuvg3HXeecQMsZ5nrl3C2NSpkQ0LtrO3POknjF+f5aaDxzRa1EMrfLXYQGPMyeQLw0Z48I2HTmzMwRN7Ulepbxc+7t89NJ1ySDeTFsStC82pb1tqh4EV5KYecUrXhEI5H7O53wOnvjEJx6vQAvgj//4j4O//9bf+ltN9z/5yU8O/v6TP/mT2WXacA2QM0qOvCjJobRzeSqG7MktehPlmVxfKz/f0dqRW0CWnnWl98MvzjoRGP6AM2JRdO3OLmpbcQCjcxFMCQXgFigtYW4Lg/X0WAIkXdeH/ILT9qeBtKhIr3Vht2bfqUibJWSIaDYbmpTTcIrJJ3qrCP8/J1xrNmbUOxuONBdRuJIPPVLK/LBET+i1MQpvskS2ljL0sInDauPnCvLItE9kC8X9hQsbSoZ2NaLqvojkmNzPMmNNyas6Gwrr0p6yGVfb7wQM+XImoXciIEzUuYQ67wxBw7wO1fUVv0udIYM0IYPWwhKhlzkCOSYRcyHuoz52YmuF64iTOJWpBX3f41WvelXw2aFFf7/ru74Lb3zjG/HOd74TH/zgB/GQhzwEj3jEI/Dpn/7p+JIv+RJ87dd+Lf7G3/gbTWm+9a1vDf5+3OMe13T/Yx/72Gx6Gzac+kKrxrgZCTw61EwUcUjWEpPLCU5Q4fGXMxM74PMlNVOmLJzjnfwUDvxOVJ0E4i92Rv+wsDHXht+vqutzRNKCRU15poSsRTj26TgBZuhROXIiudCaugBf6b1pEmnNuPGbxPLPFp9cwqXjy8N5BqnyOLvICTM1mNkeSVIm5ZES38eNQVHokYhIGgBAh8FrJgpTCrxpqHeN9ZYIhJjnhpfFHh3uEegcxNxT3X+mlinON9PntUjcsxCqNQpbx6u4v8nCvCYHjyVNyTit13c1ECB9UgzaMweAa2O2f1agabzDkYjlDQCuIDHz7//9v8ef/dmf+b/vvPPOai2WpfDP/tk/C/7+wAc+gA984AN4xzvegV//9V/H933f9+FrvuZr8GM/9mMjwiSFd7zjHcHff/Wv/tWmMsXX//f//t+b7t9wvRCEMR0YRUJlIpKkjPu7Rdz1qqGWTMp8X5qYgXAhkWvH4LsFiIFkueYYmTVGKiXrUu7hxyAnRjtU0QKGMUBXW/ydCjlzAKLtJIzRWjFr7loSxjR4jISX+H5kv5t0okwLojI299P4PZ7RF4tjYG4so+Wo0Jc6uIbWBARlpKRJhvzl5oDRgo4QPNn+lbqGhgtFpLQP02O8ZWr7VlL/KyIJkoQHbX+tm/PPYUQITrmvhCqvM0J81GAxbz/qgqYhwJwep2EE8eN+6sPkSHmYZ5hEZCkAAhBwXkL1j7QUuM3LJef9VYnGDdW4cqFMr3jFK4K/n/70p+Oee+45TmESUErhl37pl/A5n/M5+Hf/7t9V3fPBD34w+PtRj3pUU57x9fTEqg23F+598kv5Lw4pjDlBiC836BcnhKWMghP3KppbvqUm1jnhZEdd/KZcrHP9h1n85pDTGqhxnw9cxJ3ob5D/+PZT35FfBDUu1ClyLfdjcRKkTA1SYTWelLF/J4gXQ8og/O4U3NNJmFTSfX5qGcWQrkcmZCc5vtEyzAz3o+PErL43NWwkhcKqoBg2GYcuOcQkCwB/hLb7GQnP2r9tCInR4qKFGQia+d6hqk53KSYapVg8vHp2iFKROBSjH74chWO5K1H9PLnTHeP3Tdn5MQ7tss+/KOGs3RHa2hBCNf1kTnZz+9NKochXZo684rhSHjPvec978Gu/9mvBZ4cMY/rsz/5sPPWpT8UTn/hEPO5xj8M999yDW7du4d3vfjfe+MY34jWveQ3e8pa3+Os//OEP45nPfCZ+9Vd/FU972tOyaX/0ox8N/r7zzjubyhZf/5GPfKTp/hze/e534z3veU/TPbEH0IYDomaRmXHLXhRkNymFpsG+Ul8A4Ce2gPXPCYKWXIZPHZkd5hbPmdTnVLh3ymRd7VVVCCFYBTXu4xPLUU0w2vT97rMEdCAcIsLfHJY2zGrCRwhO4j05NtmwNLg2jT/LeMOE+kUJEmvJftPi/UOwiMdJ7t1gtGeW9Hpw6ZS00o49nwRlTNVXhdeE0BgWqylSxl+rvV2gOzpP2R8ayhLlrZlxb0r9sfVOw2hSaae8v3IeXQ2h03GfyfUPzssn8C6h+VW801qIJJmRG0f894n5wc9hzouPgnpnidAzRiBdZlceMydG3itu3CvUd+A1A/BtKE2d+Hwcqeg8EVeeXw4eWpTwXNtwWFwpYua+++7D5eWl//uxj30svvRLv3T1fL/+678eP/MzP4MnPOEJyWu+4iu+Ai94wQvw6le/Gt/2bd/miZG+7/HMZz4Tb3vb2/DoRz86eX9MzLQe/R0TM3F6c/CzP/uz+KEf+qHF0ttwIOQMgoUM8ORk4RYHCTdS4PAGaVDWxmdPKeSfxOIzRpURFv590jshseFEDMDmhU2JUKnpF1nRxPDvyf0jzoMzkHILSSmAnvl8Dq4KyTGhnCfd/x1qx6wpO7lreUTVEJiJuWj1sbWC3MyOLzlPuui7VDonN3/EdVERhjT6mzvSOhb/BQlJstf4xbYSQGc/dsQN1ddagJRxv4P7C5omXBrupCaPRu/KGrTOcez1lfZejpwpgunzJlE9/M6Qf/TUK6E1dEHDB0pDRBsWlJBx9TDp9CEgq/t2kBDQOOuW50gRZCVQ3aYNR8OVCmV65StfGfz9zd/8zRAHYPSe85znZEkZimc961l43eteh7vuust/9tGPfrSZ2Gh9rkPUw4bTx0hbpiVEY2kwQoExwbHYgkiGxlrKCK6K3Y5dYxOXzjEKmzG1rSrum9MGx9ZRmBTilvI6WFifpLZ/VIc9MUfQBju2a4YbVWhqXEXUjkGLjlUtmHpCFrNwiHe5m/Qj1sbEUJxiKFAqXIm8R+NTd8I054QbpU5FWRLNZUv1p1Q9ua9FdK3WYRiS83gBIWDcyUsRKRPriECR/C354kkZIczR2C6UqdGzybefMuEoXIi1T6vynWBtiUY9mFS/yp2iUy7YQEqMwJVPRD/gw5zicCf21Ky4rLS9U4t9ugKV9qjrjhxHzZV/FIJKwn5791vBnTzn0HRCU2q81aj2yFkLLePVpLErEU629ji2YcCVIWbe9KY3BUdAd12HZz/72ccrUAaf//mfj5e97GXBZ6961avwwAMPJO95yEMeEvz94IMPNuUZXx+nt+F64yuf9JKjCv4ujepdSooFTmPhXJXjspQmxhxmn9JQMgaol9QCpExqYXHQhWq8I9lqEHH3ZI6/Hd1bCVpHyXbOLLLZOh0trpk2ma07VNAaqKyDquc/EQR1TU+Lia65kmgod05fYjGcgj5RAtl+SvtFzS7ykjovDFYdc+MFNDPu+LydFosaFsVJELJGC2GOuKbHXHuxVu2vgZTDqUuOPJOGqFE7u3DvGvsU047xvDYinlqQavOCllVusZsiElr6QNX1E0+0atKfiUnQRJia+07LyrmIkDVCw/TNoM81PFAJmjzzCXiPNhFNK+S1YT1cmVCmn/u5nwv+fupTn4pP/uRPPlJpynjuc5+LF7/4xfjwhz8MALi4uMBv//Zv46u/+qvZ6x/ykIfgAx/4gP/7lIiZ5z73uXjGM57RdM873vEOfO3Xfu1iZdjAw5MxdOBc8jjoDGZNAtzOWSLtRSeFuG4mLDprQN2JDx66tVC7J8sbnUIRxnfn23USnBv2oYyhGflUe/B0k7MIMWPRm1qQu8+nGKCnbsCxfTXRZ0/iWZbWfElgVghDDbg5acF5Kl5gswRnJqyWBQmzOabWQlzGOFRl1E9L9cqRBPQdYEJPAg8IxvuFnuAjIhIkJF1cGch1jhzsxPB/upDvCFEDQDsh1sQzJudbErqWCv/USofaJoQgmPN+ZDW4MppmqfCVWi8/+v+a+XwW7Bzt378onH30jkKMvgvKWeuhQfuAEAA063KQqrNAaya5aRLai8cKxy9pBzrk+kfNdScx993GuBLEzAMPPIDXvOY1wWeHFP2dghs3buDLv/zL8Su/8iv+sz/6oz9KEjMPe9jD8H/+z//xf7eK7b773e8O/l7ypKpHPepRzadEbVgPWc+YKV4jbhd/5bAXFgWjYPIEcSByChgWArERdZQd97VJmQjsQneFfFZtx7mL35l9TXYCiro50H7kFkRCBO7mQb4knVqcVBjLMUF1MSS/iOD+PkX4E5kau+FBtRLcPDNRxN2Ns1XEPef9QcmWILNxIn48B98nThIVQumeZAk+DBfRIy8h8p7ExIu/n0IbT5ix6O9AdGhhatYTNtSTRgzeMeq8Q39DAgKQFwrdpWoSIWfLF11PSRKtxjZJ1TuSmAdKpMwoRIhpN9/nORI51gXJ2VT23fNEmoYdMyaMAamDJABTh8i/O7oTEUmoTdGpRhERwU/p4rnPfR05HaI5cxz3bFG+7v/HHBdi27N07RLXbFgfV4KY+YVf+IXglKFP/MRPTBIcp4RP+ZRPCf7OkS2f9mmfhj/+4z/2f//v//2/m/KKr/+0T/u0pvs3XDOsuZBljIOiMFnlxE+N7uwkkTpxIJ5IqZFTK/w647SdHBlz7EmcQ25ibzJyjyAY16zpQheEKZfoFVDqz5/+lI9bLe8YtYTMoYUNq5ET2qxAsKini1AZXnMyKBAYw0IW5L3UwRGyKRytjSk5U7HAjsmYyboRQHoBGy1m54TlLb2bznoApVCY62LPl0BMNyJlRO+Y4ciLLqUVQ74XvQb2vQktcdcJAXRWI8YRMS4/Chuy1N+5Q3+nRH9Doj8TkL3GWa8hHtQQ+1hhON0vUjZFsp1I/wzGywRB4O+J74/KUrOgT3mulTwbvJcP4+1Er3PPMSJnTCJJJMeK3MmWGAga7nvnJRV4ZnKkoS9D+n0PNIIaNYhGdQPm76sajln4/qTmug0eV0JjJg5j+sZv/EbsdqfPKcUnJeXCkz7jMz4j+Lv1uOn/+T//Zza9DdcD1FuGFfdaSoODwWQPEG53LrOjURQZa32+icKoB9VROSJmT87xzunK3hipdqlqqxkaEMn+UEiT1SnqgQfev59UjhIe+MAemjmRqdlL5gTi6APx24WM46A9aH9duN/OHjuqvErswllawUxg5DHD6cgclXgrhJEG5EFOzJS5bxSaw3l9+BsE//+FkAudaO0bzcKbjNdGkOeY17AZEdJGay/e67U1OL0dTqfIEzRquN71z05Ad53RignClgT0mYS6sUN/5w77uzpc3t2hPxPoLjR2Dyh0F8oTJKU6jG2jlBdcfjNl0BRp8oRlxizW40MldFpy4sw+xMuJ5VrdnSyxkpoz6fvBf19NylTMrdm6U0M/i7VcaP9n33P3p4jeFdIO7DzMkXKpuYYpy9GIjcpDDQ5WvhMmrq4iTp7d+NM//VP83u/9XvDZqYcxObz3ve8N/n7kIx+ZvPazPuuzgr/f+MY3NuX1+te/Ppvehg1VyO20ZdDkKdOyKFh6wC95zTgDjMS/C+SNnhacotdMCk07tf6miKRpRGm3uaYfnnr9umd455segIi0ZoLFgrY7w1pDSwnsZPhsqZOqEsdkl07pCa47BVImhxoR7MI1o93mUnpcGRIePHQRl+yPRzJmT9UbKlhsOXIAMHpMBf2fLCHjPEPc5xVE3FJeL0uPR6W04nCX5Bie2pKlGjK0frg+QwiV4Lqe5L/rgE5Cd10YYuLyd8cdCwG9k1BnHfZ3dVBnEnoHdBcK8lKju6kgb/VGW6ZXQ12QUJdRPdDH4sZNRfpKYa5KhhHVvMMlz7BeA100HsfPROrf6e44ssF9KKBCj5McEUnGLqoPFJatYZygz5cIVazeOEH0PhNNoFSdJN8z4vkkJKbPa8x9B7EzCh5JKRzcBlIa97/phQfO9Pri5ImZV7ziFcHfX/zFX4zHP/7xRypNG9785jcHf+fEiu+99150XYe+N1b1H/zBH+AjH/kIHvrQhxbz+chHPoI//MM/9H/vdjvce++9E0u94argUIPvol4jcTx0DsFuE93dRLC7s+hCQwpjKHlX77LRRlEiM06dNIgxiZwZJZKuQ06bpylp5t61yJlV0oxIFB9aBgD7cMcQfVSGme2SMsiXQJUGSA1iV/Jaw7rVAM+5v080jtn0ViBjhBurBJgdZM8+2Q8Wz74dOdKMhsIoZRZl0q7ia/sq1Q2K0egd1RwuWYG15oB4QwFa86Rj7tnjOuM0eVLeV1GIkz7beTJGS2n+T9MX7rQlCb2T0DsBZY9KFlpD3LLEzF5B2LFwEBLO1wWn98bek7MdSLidFhjrpcSkLNevo/edm0+Hsrp+qzEiGmMI+JOqIGz+kIDqCx5ApPwRObMYGkkZozXEEDIY/t/UjxPjiydn+uG7pcMOF8XmhXLb4qRDmfq+x3333Rd8dlW8Zd7ylrfgLW95S/DZl33ZlyWvf+QjH4kv/uIv9n9fXFzgX//rf12V16tf/WpcXl76v//23/7b+PiP//i2Am+4fVDhrpnF1HCVeGeN2dnxE7OLUfanNAzldgaJM0oWWVzGdeF29VzaDaEU1J02/rnqYJ+htLOa+xy8m/UoRK+hXNX1PDM8ZmqoW8nl3FykzW6yPV52jVCL7KlMOTLiGAbjjBC0ErL9pfZZazx4Fq43f8S5C2dw4UxLjYlrIqqPQPfHkfc+nMZ+x4XRUNDvFbPYTAj8tizY2fDh6PtWtI51yXs5jw6uzjJjdDJ0JTXnKzX8kLbSOwl91kGf76Bu7KBvdNBnHbCTNpRJor9jh/7uM+zv3qG/s0N/bpYj3S2F3cd6nH1sb7xkLhREr8aefIkwoaK35egUnwwirZgRKUPHJeLt4dukIsw1/WWur9vvHUHjvGekSLe/DssXP99iaPEuIZ8HxGJwzUCI+Z9uHJoUvD/RWEv7dLi5EeXl2qtCWyYeC0pjQxZxyG7LXBGXecOVx0kTM6997Wvx53/+5/7vhz70oc3HNh8Dfd/jec97XvDZ4x73OHzmZ35m9r5v/MZvDP7+iZ/4Cdy6dSt7z61bt/CTP/mTwWff9E3fVF/YDVcCX/mkl+RPY1oJs70lYj2ZjLERT7SekBHw7qxaiiBNtxBpQoGQ0iIs93UgVOYgjqfO1scBtRri7ybpMCxozCymHUHfkU6QY2TJNSuTI1lyhkFKz2GRd+cABNpk4jTRh9hF3IKgZLU6k1DnxuMgFPy0/w/GsytA2lAPCweqb6LrNEYAuyCjBPvo+0w6HKERLRxLizEu5GoqCZMF59HCacK4UKPoxCQAad0ZLg+XjsLwAxjS5ayzPxLq3PzfnLAkzW9L2vR32LAlR8hcKHS3FLpbPeRNR8iY0CXzOwrvqRi/h1Af22+cNwpHzhS0jwIk8m4N+c4SJJzt5Pu+/b3X3qMoGHs5z7CRp1P0LFMX+Nz1cToJjZfAgy/umxwZ6DysLCFNw7mS3omeMNOEyJ5OuNePPSu85xw2z5prh5MmZmLR36/7uq/D3XffPStNIUTw8zu/8zvZ63/6p38aN2/erE7/4uIC3/qt34rXve51wecvetGLivd+0zd9UxCm9fa3vx3f//3fn73n+77v+/D2t7/d//2Zn/mZeNaznlVd3g1XB6kduubBv0J8cRUXz9h4TLmVS+Il49ydpV2gSoxHLXcNNbBKBkZqMosMNr8LFWd5qEl3Qcwpc1E0Lzai4v9zC6PSDjiT12okWZXQapoImlqvyTbRTD+Mkerj1WLepUUNQ4gwaacWG1eB0FxtobywYDEFJVYCYlqDf5+Chd3ixZkNF14ReBZagVi4MCYFiL0ajmAmu/9hYmF9F0mo1BhU8gotjF3cbn6qj9V4VDbvysdld+XtNYRy3idIk0/cZ3Th7IgYCTMvEw8ZfaODOu+gbuzM7zPrJSOMJ426YT7zxMKF8j9iryAue8i9DWHqlTlhTKlsfdN65L/UwQ8do4LwoglEPTcnpMqSHRPJ2MreH2vEWL0dcWnqaeTd4+ymKR6XubklA6HhdYB82xXuC0Lh/IdE4DiuCzH8+FC4LjHeZkJgAwJrRRyMnDkiQXPVbOFTx8kSM3/5l3+J3/iN3wg++5Zv+ZaDl+M7v/M78amf+qn47u/+brz5zW/Gfs+fpLHf7/Erv/IreNKTnoRXvvKVwXdPecpTqsiSruvw8pe/HIIMFj/+4z+Of/AP/gHe9773Bde+973vxXOe8xz8xE/8hP9MCIF/+k//KbouUpTccKXxlU/iPWVmDYaM221s7MXGS1VYDrdLV4FUiIzeDYRMcLoI3f2y146Ot2xFym05Ud5iCMQSi7O1TqNZC7VhbvHua6K/1GoJLIJMXR/c8Gjx2Jqz21lAq+eMw2L1VcqbcwFndB24OkzuXs8t34oGMje+aSHsYsgek02fo2LRfzQwoq0chDZkQi68yPxHhL8pOM+R+KcWFWPXkuNFU1opcrw3QuK+HkvPGxMZlhTzoU6WkNFdRzxkDOGizjpPyKidQH9DYn+H8ZBR5xKqM8sOeaGwe2CP7mbvRc6dJwj1cBk9y1Q4z56InPHVVUvQRuNMky4VKu2o6NpBNHlYsglnA7kf16bRWMiSG3NQmmO09h5OXD0H5acEqwsf74j2EJl/vKeTu7bWCzAImdTB51Pqpfr6HIEcY6m5e2VyZrWNjA0BTlb897777gtIkM/6rM/CF3zBFxylLH/xF3+Bl7/85Xj5y1+OGzdu4AlPeAI+6ZM+CQ972MNweXmJd7/73fiDP/gDfPSjHx3d+3mf93n4xV/8xYBsyeGrv/qr8bKXvQwveMEL/Gf//J//c/yrf/Wv8KQnPQl/5a/8Ffz5n/85fv/3f390/PaP/MiP4Ku+6qvmPeyGk8K9X/iSZKTOyRjbzu0UQCDuSz9PgY1b135ydkacoJOWwmC82TQ0zb4LjRdfTCFGn7GguyxLTXQ5wctcGRaA25Gmf3No6U+LTMycJsKxMLOt3a5rTR1OrrvW8lU8U0kAuHRC0xJ9iQXnqTPlmhrUjFMtWHLcyIGMZ/60mpiUcaGfQfjN6VnVdBOAju2GdLJkgrQ74zXkrwS0YuYkCqKJAsnMJalqquwrSa+MBgT3tLYb3cTQ2mrB2O86co27TtoBzC0oFTN/urBK99st/t0Cmei/qR3Rg9sBYg90N3t0VjPG99Wa6lwxpDi2JbLjeMojI3Utp4kzYZxKekzWlgV8/2OftfRM3GeKEGpOZyj3nmZCt7Sz4Vz3hRUHVgrCp200tVLPlSt3TM7QTUrOTqrqdwVbprrvLjF3tNqaG04OJ0vMxKcxnYro761bt4ITkFIQQuA7vuM78KM/+qO44447mvL4/u//fggh8KIXvciL+j744IPJsKuzszO89KUvxfd8z/c05bPhtOE0ZaihWDtZ1CwSa3QXqpFa3LjPE+7igQ5DZMT0NyTUmYTsNcSF3YEB4I7YFAr2Hu2PtDZxxzBGpdLQyj0rI2pYmsCWWvjF6S0Rw92ArHcTULfQSJWd0zaoQcW1LSTHIkZ7JrQv/rvZTb0WqRCmI7kp0xMzVgF9rhbX+SXrg/TFUdseimSpBEekiT3xgKBfuYU0zKIYejopM/s4XQ5SQNMFHeDHcSGlbQwNDWme25EyQDDfFEmPGuJNYSAr3G1xuql5rJAHDdVKjVfF8qf+jhe/XFgIWyjhNz/8R1JCQwFK2HAneyx1JwJSLCZjuLI4coaesCR7je7Shiv1akjDdd2YBCY6Iz6kuHYuTM1XUYzAqN5zfWUKMV6JKfNYXHbtxqqEQHJwbcqmjL2OBZA8AZPkQ72c6BHoo3DwTBgsO9dpcp2CJWnlQBLa0+iEIqFcFe1En5Eeo+3e1dhznAvlrhobphD+rfZehixrRWndQJ9785pZDycZyvT6178eb3vb2/zf5+fn+IZv+IajlOXHfuzH8LSnPQ2PeMQjqq7/hE/4BHz7t3873vrWt+KnfuqnmkkZh+/7vu/Dm9/8ZnzN13wNzs/P2WvOz8/xNV/zNfj93/99fO/3fu+kfDZcHZS8HmI3w5SrbskVsca9s2lQzpEyxMhzx2aqc+P23N/RmVAmWIOAuIY68Ta3WwzrzgsJKzBo0y/Ni1z4yhKLwZxr6loLvdawpxajYW3V/5E2ROPtFf16KqrD+GakO0LcNnHd17RFo4E6JZ2mMMfadJ1RWRnqAmC5XehU2i39/yDeMnVecEH4xkRkT+9aGO6ZnEYGpDvFRwyLnynhRzT0ARjuleTHXZobSzjtlprso/Sq+zUXNkXFdrk2cGFL+8FDxpErQwjSQLAEIS/25CQt3RHWRjtGnXdQ5zsv5uuEV/3iW1oR6rNBWFUoQO41ugcVzj98ibMPX5hTlvqxyrAjZcwCnIStJYiAZhBvn+pwW0ycUyq0v0a2GBdelfHO8ddFujlOINmnS8iK0fgsx15ILnRI7yT0uYQ+s33AarjomLhBVD8iUcdRnXD1SnV+vF0HR0bD9FtbllS553q9TvVsMwUV+b+BSeHtRbt9rnhzJr8RmD6zYXmcpMfMF33RF0Gv5G7bmu7zn/98PP/5zwcAvOtd78Lb3/52vOtd78L73vc+PPjgg+i6Dg9/+MPxyEc+Ek984hPx2Mc+drGy/s2/+Tfxy7/8y/jABz6AN7zhDfizP/szvO9978MjHvEIPPrRj8aTn/xkPPzhD18svw2ng698kglhyg2CSy1CpyyC+YQqC+Rdp6NdNyGgziX6c3vKiATkpfWU8Z4vgFYwu/iRe76G8J4yXn/G7waJ0Q5vENpUu8PQuhOR2sVZOlyKplEoY2B8kF3nScjtItfc23pLRVbJXZ/KtmN38SagtAs6KmeuHkueJalrZ6IUyjQXufBCt2BxXhRJHNJt+4B1n4If6xwyXhzO9X+O01Nq3JwL0cGP/cJv4cd5uw/dOEPGG/tx8ApRCUBHtqTKO/U54jEv8t4Zyp2AvZ6+/8X7qOdpajvV61kMBI4QGloY8VcNBYHhRBsa8gvAL3rFXkF2AujN99oeb22IHHKDArz2mxTQEn6MlZf2pCArAOs0ZCDl8C4r7b3xAo8L4uVq7IOKMSAGmVe1AETUsZKkZq5PlObqgig6zTMI2Ut56XCeL3QOi8lJ93811J3YyeHVd/dGtoJmbBRNvak6Mg/0GOtYxch4jo3KGl3v3wlHyrj+Jofy+HJRfk8YLx3Wiy+qx+C0Om1tQ4ns2H4M75CAfPMfijrvqgqRZprGpOc7pVD0a4aTJGZOFY95zGPwmMc85uD5PvzhD8ff+Tt/5+D5bmjDvV/4Etz/phcePuN4Mpq72M6AnSyaEkiUTQNaAv2NDv0dAv25hFAa3S0d6MtogWBnyREufoHXKwhVRxZMdsWf4iaaMupKC7kpi86Ke+iEPKWfBBM63cl2mDFZn8SOzETdkRoDp9Yd+BBhTLlF96qkTCrmHwj1Cvw1TL9gyrZEaNvUd2JNcMSy0IDGuK7MDe738u23hEbNp37BXbj74cubn3/yGx8cv7tcqA/3HUXp/XdjXkZTIpgrOTIHGBEOo/vicnLPFXmXmIWmCQXT0fW6s/fFY4qACR0+l5B7CW2JFVd2rxmzkz4vF1rsPhN7ZQgZpc1JQXsVasPZOohJEl92RyYRjxkhBDSkIQcy5AqL2G7IgQ3Viz6oHIdXWcTXbuA4XSCt4ygkgxobRBtiTe+Mxp+2oUkSsERv4gFThEwcnmbLOeRPFviEeAAQkEbh3GTGvjDviLBGivDX4xA6AvbdXQpT5lMmf9Y2qCRjSp9lv3dyAoSUCULVNiyCjZjZsGEBOD0Y93sOQZM6hWkOljAWWIMxZ6QnXDv50A1j4KkzJxoIiB6Dced3A0m+mpl47SJFECPV3FdRAWtPLq3eMQfQopniLTXaZVlw8beEh1gyjZb6WYmUWR0z+3CzDtMU5EgZityOXIaUcf9fNBwTGAlFUlAvAH/t2nCLXDsWpkDHQo7gOTREh1VIGQB4wt+5B2/9fz9gtMVyYUe597vF85Mhy1rTrCYCa8osBLATg2d4/MyjOdleZsNX1LkT3TcLZLFXpnyd0Xy7vFtCdUB3CXS3FOSlfR+U0ZCRt3p/D5QK8+XKRMoveg3Qk6MAE361gydn6LOsRaDGXkweqfk7GouK4TDO80MlSKoU4jGPDZXRRvRaiKJQxTgkSRNvPG28Y6T9WwqzKKdjjR0P2edN2YjEG8qjt2WRetRfR55S7v9uc47YlMK7wIyfNfDEkcwYyM1xtL/G77oQoR1UsINTfTW3kcASHracVBzZfIDBuyi6tplkqhz/klpTG2ZjI2Y2bCjAkS0eFSz1VO8ZR8o0iQPGO2fknpLhcrCd4ZIXj92V68+NUSgvNXYPKkgbxjQiAUoLkdQEfGysJSY6cfEc9JGMOHF2wcHtQi+901TArH4cvc9LvhOptEbGbKqf3i47UZyQpA2VoJ8v1TaTSLSU8c4Z3iPR0YUJM8COgQNBnRLoXUMLZin8t9d9GKoPtTVyC5jhovADKYFP/8p76jKdskAh14+8Bd21td44Nd4ZqbQq8jDaamKUZqgtQhZThDiRl+4aQEnjeSN6DS3N3Hx5p4A6B9RNc5HoFXYP9pD2pKV4IyX5PDEUAKUg+h7Y93BhT97LRmvoHiHZMIOcyYUZ5cups/MkTY/t09w4MOf95O4lJ26l55/GPJUbZ6LPY+I+JjNoGWv6QJC2vd4dm80VmYy/ZYLa3lJrK3HvNvXidAdOOFIo9Xy0jCiPb6P3lKIz9eCIVC3FECqogNgLiAvTYwmlkndg/EiWNOJO/dswHxsxs2FDAo4kEWiYuBdYSDWRMsGFFQZfI6oMxsKE5P9MVY2GmWycu3QHyFsa3S1lXKIpKTMyqMa7Ph5rnqhSYZw145C77TMxIsr8sbPT06x6xxhDYjFSxv19IM0SlpyZY6Sv2deXqpPCjnOguwCk6yP1/pE6LO1S5rD4bvxEoibl4ULd8QcjXAf30d+nCtWbBXd234Fbb0W7wKrkGQJyPbkvC9oHXUgPuYUN5+TuDx6G7PCX5tboniDcx7W/C02iZDjjkREvpGKvR6E0djd7L+5K9WKEshfaMqsOEArY3VToHlTobvWQF31QPgD1c4ElXozHTA9xuQd3NLrQejgCnYa/NGAyIUMRj1dMOslFeIHMmY0MGcNePgrjiewppSExHoeCvyU5XQ0gpLoO30VhOxBtR8D0E3odN/7TYmXem9hTmr8GyNkPo/fSvVtB3x7btskQPfo7IhPLXp1xOCIhZZwoeg8IbeaCYAyh+kEc3DPFG2nxJiozVwVl0hq/9Xs/kH+QDU3YiJkNGyI4D5nkmFlYpLhJ694nvxT3v+EHq/PlQpiWDo9wBuEkN//Sbl3CRZl3uY0mGwFAaXQXGrqDP96VL9t4ARJ/fuVA+9SahNICWCOEqRnMQqkZK9dxddmo0ScT70sJJ9xfPBJu2SNQA5h+zOwkjkQbC3W3SrhZymsmh8p3PDemOaP9FMKTjoZ4V74GkSeWRxx+4fqgIz8S8CQL5xmQIRiTIS8JTx3/EV1QgRBEJOzDHyesdUjG0BAXd1qX3fCQt+zx2G4X3JZFKNPPupsC+iPCC/4Ke/qT3CsTthTohqTLP3pOWg57j5bCeErsZJDGHA+wmvAiU578u9Ssy1H4bnWvZWasCfTDvEhyfA2ge0PMBYctCMCJ5vprJUJyJoJ/RiEACB924wlD6hGjYbyv7HgakgCk/BmMCQ1CrjRu6gSkiwzfbY6M0QJeWNsTjoq8HLX9NxJAHsLy4bVe3EEX6LU/zSq+n0NMTiWfIUeI2c9u27lnRWzEzIYNDJYy4GvJGS6EaS3NitmGwBo7+3Zh010oYwReqLFoHDMJZCcFztg64AJ2tGvWchJTpcv03PJlwy9yiF33Z3jKJMuTy/sEPUta9HGCa+ki8NQ8HJb2CCuFy8V9Kq4PxojPwfWpk9D/ibHgmHTqnjEHBVcXqbGqYVGRe7+DPkYXgTQfsjOd9Jap8DjRIlwODgtYeK8YR66onTnGegh50JC9GsgQRb1VFCBhhIMdqOaLO0JbkgVibh4o9UkSpuTTkBL6zJIytBxBCAmMx0UXPv8o+Xj+pWnRsqVOTARY75ipqL2/xqunZkwbiei6dutJfQsRfDfcAEs8uD8wGnNH5IcUw3hMvGUC8oUmISISEDZPDWghw1czJmQICcSdLKQFxpor9nnpNRySei9CwJ8eF3vC0PSlO3peGsLzooe8CN+TFm9O1z5U/0f0OjzkwtnGrfN19I4mvWQ2Auag2IiZDRssRloyBC27ofEA9pQvepnfZfit14cufynvnNykm9WnWMBAz+7iMa6Z+cRE9ho32VASRvQa8sKc8ODzap0YUoudpb1RasM8Go7ZnJxHA1ZfqM7c1cy+a4F7+wF2HNdEvBCL3Yg5xAuHq+At41DbjyNShheADG9JLVaaxtJjYIU2vGpGdCkkJH+zGE+g3DWc237uerlAHXLeOXGIVO7eSPAWMJ/502fiha+0f3fmRJ3+hkR/hzlZR+41dg/0wCX8MdZ0gSu0NkKsxPVFKAVx2Zti7wDoaHFaImU4L6LoGi0AIYQhYigZ4/4bh5FAQ3RiIG5avdXiMXbmJsgS80/JyyZJFpRg611ADCfqUO+mjDcYJUEgxejEo+Aal10nbKid4Bf5AmH9M6RMLn1XHq9jJETotULfbdeuLtSKXMeNM9XeM5VjkrZElSNKReQF2kLUUXJmmPcmEDHuzlr7IibEYhwo7Pt2w0bMbNiwJFJaApZYuPfJL+Wvs6gdrNkdurV2TbndPKBsuNIdk9xlhJwRPexvHe1WzZwAHLmx9CK20I7ss69VlhUxMkgig2ppcIZSKo67WTfgwMZEWbib7F7Sstf0jyvUh3Ko2f0N3Nqn7hA25pu958TIjzXImEOEilJPqdEpLL4c42uHL+liJZdRaouc2WRw5C+ZV1PeVyPvN/o7ztuHLGJYKAMhqUHDgGISwaVDhTdd1nanfsjTpuXqzorou/AH7znh83ALWnt9HPohhPFooW1BN15Sz+z+n+s/QoxJgqgugxDmHhDChD2P8nLXMPOHK3eL9gt3fyqP0v2txDG9plbHJtTki/qjGupRu7bjRGYpvIeULoZNmqPaM6+jBnzoOjBsyBHPD5dX0lspJgRHeehhHCF2VqqtBmKykdzLlEEos7no06feRBPgyZnoMwfOK3tSP609MdHmEZdjwzLYiJkNGxYAHdTHLpZk5yGBKTu3I3ImcU0LkmWwBmVgHMU7FTlEC0jWENCwpzoM6S26GDiVRWysJ3MkzN7pi3eh3WcngqW8aaYIRtaG0GgBiI4hVk+lrx4S1OBOeNoF7vMrvzvV/WeJPn+CRG08Rg8aB+vV+yiUl4T+sASIDxuKv4vLTtJMEQnuHYwJBYIRKZcLS4p1kjQhQ7QY+rswK1UvdkvyHvU/4hmjzqXflRdaQ1kxUNFrc5qhhjnOWpuCyL22ejAJQtONQ7TsQkDv7AZLN3jnQGkf0uQ3Gri6oPURzxHxAluEBIFw1zi7g96/oMh80KYxEcboYpXGhKlzDtv3SblYXRDnZVIzBjkHZO955U4VEnAe3UP+OrzWfsbaspFGTepAhkGwnHivxLoo/rPh+eizDokOZGFQb6DlxUDOVMD3bVKO1HXJTSp3n9CedHJ6OWz/5+5PgK4rFiFDauabONx285A5CDZiZsMGBvHgV6MfMXbDDFnuqjCNhTAlj1Lce9Yg5xbnCW8Zbwi4idzt9Amyo1cz/i98JO1qyIVV5bDiYm2xPrgUEcMYXVN3Jt29Sz1jbDDXEjXFPuwMWmAID7gN0WpkisR7c9Cdu9ibYAnMfN/nere43fCSXs0qYsMiCn2I9cXcwpSGtUgM/6+sttEijnsOm19S7y1eLNprg2vcfKkU0EefwbYVlVBxhFAcvkfrgoYr7QT6c2lIE7vgVjfMvd1NDfS90ZLpAXlh26u32hS9GtKPiCDhCKPOPea4XHE/dULD5tSksD6dMKnvV67NSD1x9eE0cMRemeOz+96UYdeZECZK4syYL1idHOKVNBuFMGTWQ5J4kYheh9fF4vBcuSkoCdCJ8XdSBO9O1XutdNP8OhovtP1HIxD5NfnTG5myuPc+aVuGpJb3nMm0w+SpN3pXg3VAr0zokRX+FXs19FmuDRmyJuehVbvpE6AUEk9JmPi60ulOGxbFRsxs2LAgWkXZ3D25e9lJa2EkSZlRYXRoFAWJhEZevOs0GFKwpy64ozkF1Jn5Tl5GYoApcBPFMXadEyfNBJPiFd9lyPVJ//3KXjM1fb/1PakyLlPGDOmfqfCLFLwmhHMRB0xYQ+yC7fI/Fg7Ub3NjJm1Tzp37qBh5lBypHBPAHX9Lf9fc77C4V2PcxqX5QCIrOrtau5SIObcg61VY/k5CSGk8Tumx0BGC/h4QIWH9606gvyGwv0NA9oC0mjDotd/kcKEhyc0h5wVjyZrYC4MN/aFC3Lk9G+3GNphndnNFLHJMFqeOSDJ6KMqQSdbu8HVH7+HqrtDuLNG3JKK+nCSOIi8NXy56kI8j9FS0sI9+j+bA1JxMvQ45jw9brlH4EmffZJA8rCFRF0G6sQcWIe/Y/uvQJzpjRHI225DkHjdnZevB6uCIvRkHtBBGGwkylAFIefBZpPKo0omptSMmeHGfakjvdcDSQ9GGDVcW97/phbPu5wbKObv+8T3xpFsSjEt+bwXRmiCHXb3R7hbd7fPXjPMJJulOQO0k1PkgUKjO7PF87ijAmQN+1SJj6YWee+alF9SZ9LJtfQAE+gdcnccLK26hxewYTypD4u8UquptdEKBDn+7a+xPymAxCyqEMf1iIGjcQqTaY+w6otAPXF/nfqbAt8mUcpLfRydlBFDvNdJGwtSmV4UojGakGZPSLVCwu88IQ4Qqxo2krkccNhcvdmvgSAe6yKfoFcTlHuLiEuJybz1o7AO4U4668LQjmrbTp3DHovs2FmYTo7tp0rq8S+LioQL9mTCeCF4gdUzKsFD8WJV9P1wYiqZ/F95FWteOUIvth/j6XQd9fga963y9tC4GubHCewzF9gx5vuzfOTALf7Y+o02ruB+5dvftz9VXagyi5E7c1y2EhvVaYUKK/DUhKePLTewcLnwpuI/7idNhfrQPtzIEpPsZ2VmKKSMHek/8vnHpxflEBCkF+56QtqQhXVyYY4yi/R7bmZyN6K7hwhfjtiggeIec+DIVkt6wGDaPmQ0bGLQY+jmjvDUeueRxs1hIR0pYjU1EmEFY2h0vOhBHOzKjOF16qTUsdSehdtK4YncCujOTbng8dqY8te6YGO8MV6ezBEquo6l7gNDQYOoztdhYY4FYrZXCXRPXfYVB3er5kgw5aLy3Gu594BZwsZhhLh9BTmvQ2h5La96HYEfzGF4zh/BMKcStH8VTsOnmhUmZxnYOFkMaVcRMSjdmLqo8aLiFu1u4aA1RS4zEHhaUsEggGS4RXMQnUgyv6DWAKFxHAlDCe8b5UEUhzFHQnSNawkWf8tfbBXPv0iQErn1+d+y1PJNQO0CdCQht7hF7Hc6nUnjvG+99NrHpg80mpfljiQl0RAbwiXKLSljvAlhirvdeCP7EqkQoTzY0RgyaRal5q1WfJKjP2vc42rQS3kMIIWk1yizvoTkiO+092fC8lnmmZZyKiNZSHbHjSG1+atwXcvZoNu2c7VZp13mvMymHk84EEejOvROa1FuhvZPEy0Jg3yGOXNqwGDZiZsOGCkzxfEnFwNbcR71icq6MqTCT2t2xqsU0MEwilqBh73EGpN/90SOiBEJAnRlSpr9TQu0MIdPdMir2or9m3gKt5EzKvZbgoPVDXNxpvrGhVUXu0d8xFtTrqNGDKl0XgGuTlPt34vtkCEFNOWKjOSfItwSJc6hwoVQ+Nf2g0F8OQerQfGYj026c6G6OUKm9bi1kyXDqYQF43RP7JbwGgxxPMoHHgEPD87EL1kwaSVf9SCPFEKp2ISXEoIGykwB2JvRm39vda7cZ0XnND9Fr85kUUOcd+hvm2XcP7CGVCUtSZ8azFEJ4gXx/utJe4fyjCnIvcfYxje6CEfglO+eL9Fmq4ZHycjIVguTpjam2swtRIcRwXLjUhuginUcoxYaFJD0X6J/0moT32yTyagq5QcOXgmt4xqu6TK7uIy/m4WS7DPHQ8nkFqsqsNAQ0P6+lysD0vdY2S4qalwidzDwZlGcno92jnIFC2oaGS1OCpnKzbon3PBgD43GPEtEbFsVWpRs2ELhwpqIbL8ESLvVTEbscU70aWr4Yk8uacKNNGkTRJKulES5U5wL9uUB/bi+7UNjd7CEv+sFFeipS4VPcdcfU8JhZhlTbrwUuj9l9nuyYjwyRirK0hDDFaVaVfYqLfwaclpPQ9r046+xiDj6kiUXB02QWjqDhklwwW9AxLQibWxi1Y/3iKLz/8RhWI85bc91BkQil8XpiXkukt+FKKhwTYg+CkhcGFzpZ6GNB+8fjkvvhwqkA/jMpoc93UOc76DvOhv+f76DPSOgS2cDQUqC/U2J/dwd13kF3JrzXkDYS/Q0xjBEW3S2FGx/Y46737HH+ob3d4FDh+LbQe52zJZLvTy5UyWG0KIYhuNx3rm47S05Z/R7R94TYY5KNs2PsFG3rNzW/jR6H+YySHkPYUQPBQftnZwk8Zn6v3dgbQrQkWFIGCMvKfNYyfrjQpVFIVMq+icKa3Iac8RSL/qa2NSUca/p0YWyNn30OUt5Zvh1sWwSf125CxHmkNGHcWKoX3OD0YzRtG0LKnNI8c02wecxs2DABNbspdJc8NUi2esMEaPDGKKaV2hXM7GpxCvJBEm4nwtmRzrg8l+jPzXfdLY3upjaiv879OidYVvm8dHGy5vGuVeC8HSYi53kxN91SyJtDjTeC77+1hodzTa/AwZ59rbJY93+t4Y/31DvpD6uQewXsFSA1hM7skqVi5edgTdKHwciYTfQXWs81Y+MUo/QonnqVbdc6hh2TlGHLakNpRE4p1oZwuJA+gJwQRbU1UNh44DSg6N8ljxtmd9g/l/sRwofZaGl+cydaaQGInYTWdr50C+5Owp9i5HfJhzRUB6hzaU5UIlouLuyRllVeKshb++DdZeeJGe/0qI4L72nyXcr141FYkqlrsVek7kRA5glI6KhvjMod2ympd64ivDvpyUzTzHTxoqdDHHI0JRwazLxk8y2dulZzKlsRCfut2jvb35ApB7NhMkLOy3QuEnZR0N/cOMG9EyUP4ZY2iPtI6d6WUCyHiHSmpMxIG2vDbGzEzIYNEWqN/lpDPnddy0I7uJYuytT4+MLqRQY3MdYuAig548oC3jD3O353SFzebWLiu0vg7GMK3YMK8lKx+TYTK6c8SSyw2F2DlKD/Txl0nhhoeIaqcBK/8BobWsmdyUqspbmzGJwRZ3c43TPrjmhSUFByZu1+PnFB0II5REjzWDchVC4VdrYWOVqD7KLpyPwzUCaQfIiK/5usYh2BT8gPgfEzcx4PVU1RaH+/qGrRT7BEiyFaCaFDQ32EJWAjYkATbwLnHefmO9nbazs7v18q7D7WQ0tDzkh30pPGoE3So34XfgrIO5Qc2+m4UWNbpMJq3MLvEua4bMB6HQBaCd/e3Pswej8b6yMXFpOcH5mymBOkUKeJ5zOPNrkmbrwFxE7x3nQeVfZXqozEZkh6RcYEKOOBMWmcTW0wRBscq2zaxXbxnHRm3BusExqIKVYDzOo8jfRxcp5hGyZjI2Y2bDhxLLY7nFucuImEGqS5QEeXViqECfAuxrozsfOXd++wv8uQMgAgLzXkLUPKiL0aJkki3DtCacF4iIl3KriyzxR3bfXEmnpdTAS6e2v6XvG6xE54fF8rKeN+01CYY+kXjcpO4uk1jCHn1yhSQJ93oCeqjLCkrkzKaFvZeybZHo0kSrFdJ4wBub520mTfkZEVAfbjOu27SHutuPSIR8RadR9oKVD9BFdGwArfk4UqmR89+ULK7iEFlF/IYHiO4LkV3GlK8lID0JA2bMpryfQDievy8d4jESGzSj0l8gpAF+Epr1t6NDV91+Pjs93/KXmjiG0gBNAxITeO1OMI1IRGSQpF3Q4yf/s+kyOrspmlSSauLoNxL/rez3uz7YuZYz/XH0g5kwToiu/6qC1a66fCs4oi2CCipE0cblkDIcK2peXwJIo5XANy2OyB1L5fDqdDkexrqqBbdwzeMGAjZjZsOAE0C3dVCo+NwBlLZIcwEI6EGN/nM2EKGC3wvAeAFNjf2eHi40wIU3ehsbtpjvocuWa77HILs9hFlXFZLbnkTglxqjp5pARusduy8OXuZ9p0VW+RiJxx+VHE+SfJu4JxUON10+LBcHJGRUzQuIWbtAZcD/M9uZ5Lw2OKEZ67Z2WvmWBxMWOHcNRPcruzpxITv+ZOo8DRPWiS42X03MlTe+LTlxKYrXFFoeKykvyF6aw611+jMCmjC2JPYiFEz6AvAxuqY/IVe4Xupl1c9+RkJaUhtfa74L5uSSjU3LEtO2dE9dQcGu0+cwvxmJzx6WpoJUxYqxDGI+lsZ8Lb3PcRWZc8jAAI26NBsJUtP1kUB/MWR87UIHWKEC1PKiyPEE8ByHOPFvAN4UzN5U+mhYEwCDb9YnIEIfnaSKBVIRFSbk4+S1yXQY40i8eGqnlJAYDm+7OvO/O9iMdMJlxPnRl9KqPLI+D17JS1KRLzYbWMwobVsIn/btgQ4Tff/MJjF6G4EA0E0aLPPdyEGO9W0O9qkCFlUi6zWhgx0/1DznDx8HPcuqfD5d0CagfIPbB7oMfZx/bobvVDDD37rBVlpEJyDffWGlCcEN7sOOwpJx+UJsNW47kROUHAlHBiqQzUm2V6uZYlXFrqjRUoZMqXxejdgZmZO2EWYd31nabZus7tHNfglLzkjgkR/RwRSUFR6/Xg+3sngJ00P3TxkRh3sgue0cXMYob+9LFwKbmHerkkFl1eoFUaYtWcvmRPYdpJ6J0Vvt8Z4V/lTmWypAyUhtwrdA/u0d3sfXivC3nyCyYViqwuPf6ZZw9J/pFYKWNX+PHPLcLdT8rWUOH/BXMdKzAqYQgbe8LVqE2cV4L98X2kZnGfs4tcesoRDaHIatZOIGFrwWcg/YaQywGhQeszImoCT4ySTRJ4WOjgd8qGCu6Nf2hZGYw8ZST5cXDvu5T+nRkRKK2kDL2/EPpLPWuDfpLLk7QbZ2Oz72OqXxFSxosnu5PqbJsbglYN7zz3TrkxytoLZqzQITkvBF/HXJ3E73diA3XDOtg8ZjZsWAs1XiaHyrvhOh0brxTEUB7FQkeDvTqXuPmIMzz4CHMstrzU2N00p0h0txSEPT3CYyQWt95EULuzZXZz3R+rFacNDYbKkp4z1IhbUmejNo2WZ1l195hcsxR0tLDwO+oS7OlMrKcRQ46eVChfDsyuXe5vfxvXD93CjLqNXxM0i3PSOhA4+Bg2kAd8meVOQpmV//hLHf0hnOaMS5ukUyKti4tWpqxksRuEQ4LpqzISwbSPpKUlm/z9hPCwiy5/Mo2GPfXJLWSFn3+0EBAgO/sreLIVx8yYlHGfuXct/q4WzgRg7nMLVZeHdicWcYQM0ukAyHrMFMOv6DP6m1KL/Ybnj0iIrJcMYD2NwrLkvA6DeSxlX3Hh1RFGc128CQRG5DauS6a+2NCwOeDGgczYkPQOKY0nri9FfTAZis31JweOlAzS5LW2Rl4ypNxCA7o33rhJr2RmfmQ9nBxpTjEzRG5DHhsxs2EDg9988wvxlU96SdtNpQm5dsJOGZEtRA9nMFWUZXQKBjdZxKQMMN4NEoDqBC4eInHzEQJyD9x4nxH73T3Qh5oyXPHnLKgqJw23yGHFislzLF6+HFqEAn1hwrZeVUtl5JWUN+jX1ISIDcGl8nL1V0rXh+oxC8US4nrzfVHCzMo7u0PuysLcP/xhf8eONcL8o/shjyYwsfRrh4JN0RGK/28+IIuBhMG7RBlOGqk6OEZREvl/+lM+7sAlQZK4CxY+kX4Ml0YQViSjhamw93UDYSOUfZEtQSb2ynuLxn3ZhaAICWgcgWDl5pocYRB/RsciaoNYEVF/DRNCLbQOwqgDPRkrAOxEl4d7onLEtkrJQyAu6+ginpSJx/CasNIUIWK8odRYBDeuNwa07yXn/4mkR0AW+QwLY2rUDjWhzLnrWCxEDKRs2Zr8kzVa651FQycjMsb3887m44g7pQb9RgGgs8QYJU+UeYM8sakU/IYPJShFNG65/gfktb2IvX9lNn+uEDZiZsOGU0M8UNcQPtzkWEPwlMR+mYVNNh5XDLuE6lz6UyTE3pzC1N3SkHsSO9+6y18z4TVM2NkdaIFRG5zsJMTt7C5R1MZjJlvzrfWC4Yzw1cinCK1lLF1Py08FGv/659+Fux9eeWZ4A97ymx+ZRco4TCIsDnC6E4eltGtWxcRdxxavmSmk4ZLgxnPdAw+8f4+7P3558/OB9++NRomrnlK/9xsR9ZsebgHkCZnAU4Z4tfi5w84bdgcbnQB6E7aUfc/oKYdrv0PkPeX0wYIQJaBNBCFF2sTHkPv8IpvDH8sr6wVIOUKgJNoaewpTuyrn0Zc6ecjVI6uBx6STeQ6TT7kPTA4NTo1DSrNeYimylyO5uLKwIYhCpOfOhD5MCvH4OMVuc2kE95IxOzUGp/LyY7Ei/d0Sr0P68J87EV+9M2Sk2GvgsjdX2/4p3HshwjJRQsYfNy+ECRvTkg+3Asw1ziMrbj/J5HGq9vAVx0bMbNiwJFIkCXcdRYtLbur7ljRrjwOl6RRIGT9RdQL9mYQ6M54y5x/UkHtDyog4jj++N8YRFnV+nhQkrl/XT+7shB5joeeiC9BU+Mci3g7OIHGT8zHaBZHhx+3aNRpwKdTU1Yhgabh3lFaHVUgZAPjsr3wo/uQ3P2Q8Z2qIgCVJGfp7xT4ziYCIPQq5MWhtYmktckZjIJa9p8OkEi4PpfG/3vwARKK753Zuk3OcC3Xp48RSpHvNC873B0/ECKsZ00nj+bJX4VirNcwpTioKUUEYvoTM+xUt5LPX2vJN7q9S+LAhH5rintWfEGV33u3x36M2qd1UoqSMUsM9qQ0m6zHDkTJB3WQIhuD6lEeHI1kw7mtJwsCl7cg3925KDSHlaK5Mhc5oZRbacO+Fsz84t11vYxTKVwOuzlTi2YP5Ncw/5XmUHZNThBet19Rpgf6eCQ+eO0CCpMl6N7l3UjpvLgzvQao+OIhBEwYARK8gBCFtLPGhtQZ69zdC2915tDjPPFcOSspY7xrE4200L/u+liBkaL1sWBcbMbNhwxKIjZOs0cyM2KnY5in5p74rkTL0pISE624O3gVZAZAC/bmAlsDuJrC7qXH2gNWW2YcT2GKD/RKurREpkwwDSCyois+SMdKmGlZx6E0qrXH4TF2+9L6lXVenhq6wOGDMc1yWJTVp3vo7H0UPEbqz20Wf75PWtd3tvo28EoRAJ4HP+PKH1mW6BvnQSDq09n/u+mSMfzah8TuZ1fJgFr+zyM8Z5EyMkT6Yru93ayA3VoxIFP8Fxg3pk4nGYzH6T3bhni4oN5YzRYtc+43Qrx1/lZ3XJDkxx5EOAbHfRsoki8yNOVPeYxuOJSI7QWA45ttoVejBtuFIlJwNw9gcnpTxBFxkN6mhvmMPHa5NU94p7vrA8ydH6juSRA6ZVhFneqgj81tAQ0FEfWaUJs2XyYJ6YK3yLud0dzAupyctpNmgYUOdGE/rGCntGw83ztrxsWh7cMnQy6Nxlm4kAuFYNfKSodm4elF6rL1SA9If9E4aYkZrCM3MK72GVGagFMoSf2rwgBnGIzHoWfWWK+oNWRw8K0UN6ctIFIw66ZE26a4zru9xDxs2zMSk05lSuz6p6+Lraxe9KeOCu8b9OGX/mrLFZUQ0aKcmUwHoTkDthphXeanR3dLobvbmFKY+rS8z+xjqRoSiq+53RXtMya/C0F4KjqgppVlLJpidGkIAOO8Z4kUzpYyzkPLkcpi02J323RRSJuVmr3oN7DW0susWDfS7DvuzDv1Zh/2NDpc3dtjf6NB3EgoCShlvAaWG//fRu+7acBJmtHMJI7fqQxFsc3daS8lXvoMAFjNuA/dyTxbosTG9IvzpIilCm70nqqvU4r/wXZEYi+dN7hI7h5kTlSQ7zg2hGICkx1q7PHxepg1Er4ZFJtmhnkpGrrZAd3ZCTzJIlHFU9pKXDPi+EfcTf/KMQ3Qq09Cnh/uo3k86xIQpawaufUZjU+0Y4J7DkzWVmwuZn9r+Qt+nlh96Ly131bPSNsl4cwd1Sr02Eic/Dc9UYTMy40JgswBDHxEYfhDZgkwZsu3XYLfS53eednI/6MbE6brxw2hSqeDddOSm6BUhbux45AgcIKkXwxKVo/KKoJ6GfJ0HfPWjb6jE5jGzYcNUtIYaUcKD/na7UHRSS+1GTS0jI7IXnBBRcI2v09gQ0GcS+zs79HcYfRlzEpNGd1NB7qPJTqaNqGrMWMSxeRMSapi06gmjnKDwMfQ2cl4Ds0KbKEqx+xnU6rewWNBzx5XF/eYWQK3hSqO6KBGp/j5tLlUC2GE4eleY+9ROQO8AeQmIXkD0wzZW6j0Wdm0utN3pa3lv6LWuD9f25UJeVcKLUV4t3ilVXjNTCRpmx9EnOaVrNuo55eD7wYGGm6lhm8XQRAZZzYra9Atp09P4nPhueEKfXWhfKtPH1DBPaOLVw+nDLBFaOmvsTui6BV4fALRSENqRHQA6AQE5eLE4cF6lJQ9ed08clkHrzX7m69OHi+i8dy+XJR0HIvsr8I6bMEdTjxF3gk54AZ04hucKNMaA2e/9EgvkQPsl8T4mNY8KbZIk31t1d4I8o/mFenSRNjEZRPcG9jeGsTJlzxC7PPDOotXkCIvKtjDEBgnlo79pvo7gc6FyShgPM60hIA05Q9pO7K0nmhDGK2cnR6RVQMooDCLCXP1Hz+hPStuwCjaPmQ0bMpjkNdOKFGHjwA2AtZ45lfAq8EwZ2IE64eKvOgl1LqA6ABroLkwI0+7BHvJS+etalO+bv8vsulDkRNqmkDLm3rZQH7ort7ShnhMCrFrIcGhZZKV226J2Sy1sufAs3mhwsde6uu2zZcc476OBGqt0t0ubH7c7JvcK4rKHuOzt7lvolRb0sRT5UQuqHXPA8LFDIPseznjW6r60YH1ynghLizVm0yyOvzMyTnjrBbv+1LMiM9b7/1MvGf8hd5Me3r/e7nY7rxgMdZJawM4Z62ePSVYjR+2ssCj1WIg8PIyHrR7qQFgvWB/6wRVQjP9mQpFom+j4e7ew7Ek5onvidKhHZ25e58j1YKwvzRmMF0VQJqs7oqO6SmnxVM23LfMZ7e+Jvp+zOfxnKY/ulJcEtR9dmA5T17k5I/texHVAQpyyEPQncy1j54XEhcqOI4asUGUPkpKXcc5T0PVtP7bA/lhPmr39ce+NhCFlpASkeddL4w5nHwjfV4dnzPWvDfOxecxs2FCAI2eaj89ugZu4p3rKkJ2Y0d+5NLhjLbnQJQ6R54sRHwNED8jeuHh3txS6mz3kRR+6e0dYZMFAJuqRTkRiIvS7g+xOQnu5UkdhBovZVq+ZSkHbXHtxHiCt3iqjHb6G+3wZghjvNCmTw+g+auSWCMU1wIjbZl2e7TuZ3J0i1woNaC2G3WybhO4BeakgLxTkzUtDyuyViV/adVDnO4AuMKWAOSVkgkZQqi+XsES4X8aID64pvBdxe9D3Ycl+snR6ayCr+1JB9hf7T8X4kFzUM3Ngtj6ZvGrJi4C4dt6bUoTEi6bvtA6Prma9BpZfpCxJEBvCQKK/IU0I1oVZ1KW0qsycXRDnHRVYhP/n+gslXCJxZzeOCSmgZUIhuivYNcB47CAhZBzxHtgnqfBYej0zB5l8Md7gSi1gY88ZMpdwY1Z1X0i0E7fw5oT8PTnjQOwqP99iIGBSorFVhwRE82cxZJimydl2qX7R4NWVDfFxc7eyp6whrBc+QfKM8XwV2Syj53ei25aE4e4D4IW5/XcuZEuCX1vQNDr7f2qn+jLlX4Tf/E8vzn6/oR0bMbNhQyWaCJopRENiV6Uq/QTDDiBwF04fDS1GE0SAnNCtgNmFOzPH8MlL4wINBSv2q9hFYatQbqk82XtawjcmkjKrYaKL9RSkBAoX9x6pfJ7qRS4hPFw/PtiiO/ccqUVJqYx24aAVIIQ2gn5uYSFNOJNQgLy1h3zwErjcQ1xcAheXwI1ziO4u6GibWnvDmSFnWvtW6frCu1bU3KFpRHlN0aNJ9YNZbvNz04uxsPfRlDBRTkQ69V1dejStmhsSc1DcF0r9j5aV2awIFo801IGO/RzpIyvyXhhNC/IaSBjvIBpG5MITgGFB5z63IRF84fgFJvt9DoKIuzoPBdmZNDsxto2YDSy3WM6KyQJ8+2kdnqhEF6qJULRRWeJ3h5IZwLDAdvVLOKd40yNY6JP+GvSFeDMuujYu83hut+VriJtI9cXk2M29t5lxLkmIuLLS08LidtRASg9p5Pkmws/zZCvY2BLOQ5hF3FdJHrF9NWpbQpYKZzf4/hOlS+b3VHkpMedJMzG0VdOcsaDH/oYQGzGzYcOSIIPnQV38Uox4LPYryWeJeOAcKUOPB1Rn0mtfCG2MPSgNeamhe2125C4TomY5TDV8yWTdukCKtQGq0UL40FjyAxv3Dosb+SlU9v+4nVjvGrJ7GBioVHuA5rsSSrozvgi5x6b1YsvOew0ZnRkRaDAAyh5Dr3bmGF70GuLBW8DFJfStW8aQ2zVO660eMQu8n1Vo1cI5BCpJ0kmE5oIaM1UGdkX9TvWuyj13s+YVU8ZJIpwRIWPyFMEiLbtAy31+RSB6BVwOhr8Jb5DoLvuwz0ShReZmMf7MJ5zpR9Q7JgcJO7AzPzQt6hUQbWR5cgYoalultMRSSI37saemL1uUVzMYDxQoPaQXk5iZzarg3bLvPUfC5k56E9rc566gXkdNnre9Ts+bSo31S4QAkD+CfCgsRqSLL3twmRh/HpNicb/N9f/RwxTIJ4xJEh96qUi5yO/ghDIpQyLTFct9z3i3jfoI5xUTFzv1mIde39xm2IiZDRumoMazpTR4pciU2vtrykYho98uD/K7doLVO4H9XR32d5rEulvahFZoWN0LMwELP9lFk8cclHRnJhrP1QKWicltdF3N5zVYfCc93KGpafMsgZICSxS2L7ZzCzlBybQZYUwl47k2vSqx0RpPMWVsJC1hFoy9IWX6c4nLuyW03W29obUhZS4uTdLn59B33oDuwhCAas+HJfpawZutase1Fg1hM+1kbeK+RMhaTShhFRL6XYtjqTQToRCcblMKi4d/0bmV/t/tCpu1XlQ+fRDiZUp/XIJQ9+GQD+6BWwCkRH/HbhAGheZtg/j/VQWOFpaIxh27yOYLKkwYZhwGRI/VdtfFRLfWEEIM2jkcCMER5jks2IPQE+Tfc/93yZbrYPQ+SNmrPfmiUOgaj+bgu7hfx5sdhKgJiJigTPZz+wiapDHq06mwLE3qc+RJYk8e2pPThEg4jiFkzIsQhwEHovccIRPZbymP0eQ7pjD0u5TIceF9iW0DgZDkCo7Cjk8lc7+FMH3IesvoPmon7vSlUlhSquv4th3qsBiytWERbMTMhg2N+M03vxBf+QU/1HZTjSswvS5ebNYOhvF1OTfVCaSMmwBVJ///7P17sG7NVReM/rrns9be+9153zcJIVIRpAIRAoQC+QiXg3IzBOKhSpFKlSC3AqySUFLWweIPkSQE6igFVlGWihcSJEhxUfwUjgghXI6ffCTq8TuACQkVIajAgWCu72XvtZ7Zff7oHj1Hjx7ds+d85rPW2jvPqFp7r/U8c3b37NmXMX7jN0Zjf8fi4hk2brIOdh+UO+M9zD4qU14BZXg94vtDQyQOkhpooCg1PYDMqtCXWruuS2ao3PwZa7lfirCdpawJUXfRpxuxZHq9p9Lbql/U/4zelLpRCGMKBmVWlwHcDnA7gx2jMpvdAHgLf/cO/CO34M8sDBujJs7FJA/KGDyw3rXG7FLjuSvnjbJmdDE/TB8LgEsrJGlTUUCqLHcLlDVhaVtmgLDM6Gs5TAxLygqkk5SuK2x1aajlIeBVAmViknBc7mMOqtsYbwszoOf9zOkz2Z7eKIOPh3idNyaAK0t0HwHcGD8T1iRvN8ifSYIKsZ2FsVtz2IjvpvJN39oyB7QskVruM8bY1PqqBtBQmbP54UYxFrJ3RDeYCVAbfbjHxVxpxgQQxVp4Yyc2CNcr5B7XeO6WLtZm+MUv9/niQwyeDCCs6NJFiFKlnakfCCSzAaD0u5jAN4JoAMJ11sPDBr2cQv665i//3ZTt4qCMmxys3ey3kxwkJ2DmJCdZIW/4j6/KwRklRCF93isScS/onEwSih3/1gCYuTLYZ/0GSDy5YhdusLRZpY0ntsn7ItlvBsrEts1Sx0l6lJE1OWnkfVJBWc2+WXXbtUjTQKhShnUDSwVnKt4jrU5JuZax9rP1bSA9ZS4ykrS52zHvghfNwRsbxmTAPTFcBoXJOA93ewfz2N2gyHoPf+s8KHFS3BUqVJ3AZU1mDdaV87PXEF4ynnqA14yyroULaCC8NDRJKV8pmwMPc3k3NNH2x8r9cg7OzkkJytQkM8DJKOvcg1ZIa8zNvc+1TC+1HOof3k/7EebpS9jBTPlVOGNE9ukacI/yBiuhGWU7fT4XhgiiWRs+l0yZ2v3ewMOVIS+S6bokhLPCQJD3yrCfGpusRySYWgNIevLtqXMnY1Hq4AyVo96vtacAR/SmZdcTGOHiSYKcMRVBicQS6R2DLdA7fg8g1y/kMzgxJgXoa6yd5guQ7+myH/lJRvwZsvGJ4FyBgxmnz7y18GcD3NkAd2aT49NYB7MHjAlhz3JepOffuzR+jVVAeum0SfczkGjc/kS/k9TlBMyc5CSHigRh5hawGitmaZ3etxkxrbJXADKU5He8FfJcDBcew0Xc4FwMZRrDUb3V2FTe9t51vhdU2er+DdgEa5XpJV7URR5X4eGThk5PWU2vj7wmfbDeqqjRZmVba2ETh7yDuTrnC2kr+V1CdGePoBjZOMcuDQADNxhcPuMsFEn07wqNP8Tv5+uNmlx1K6nkYqkZm1u+v0NkK5Bv1qjuAB0zWcM0ifUc5d0eIh3P0RsGVU0WqtSXvYsUUuGPygZbC8r0XtPfkAD0eWuBMwA7Gz3uYe0wdNqLMyEprQQHh6lN3Tm0pFEumRNWfE6/WwSDt6YnsfGT2kMn1lDIiRlAIS903SqRJwvJuTQXOl1j4PYwc1sinUkN6V3TCJyRxjvlfimcgIpTMMsPo7y/LAdK0QATQ3Sn9xyOekbBFilE22dqoCKBMk6M8XSvGI9ZPfkfBrFdAz3fTNvEGM7ejbXwxgOjAUzczyMglfTucxuS/lsHuwcC269Ev6Z5Qe/NwwwhdMrQ/JLPLMc59Q8PscpuuoYN+oNETsDMSU6ytfQsWHPgTcO7uKo+rYqe22xgyLhzmwy+RAXfB0MxXbp3MYRJLPRzxxleUZhEk5q7VnrosgvkaNT2I4WEFEkQs5sqAAH0ts8qkGuN0zWywlN8iFE/S6X2Bth7WBuTa0dDyZ1ZuJ2FMWWOgGrsuBQlBn2z4+sPkN78LarIRJm1a4Aqnf0YwJCq9C8YX0vCM5IcA5wRooX3tdaDpUw3LSyq635mCHnywhOb82q2nUKOCji2Th6iHBXDAPhpDSlkq/0xHjSgsg5kjg4O1hBTgn9XZcnIv6cjzROLQJOaQ6bBhqlKT7L0Vl465XM1J1glXFqTYoxpa03HHqezdPQ6uxM889AfAgxNhND4ewcSS6YHlJlj9fC8NOlaB31N1vrLGAB+AjE5M0uONW18iXCnlOgYmJhhJgCjNEcBJL3bjj6EU1FoEd1rMOXakzoShVt1StLPmOPAODeFpZFUDg45yTZyAmZOcpKrFo06qS1wrU1C+7unvloMao12O1js7+5w8dgQ8lo87XD2xAhcMmpjBGIMbRqKF3I2t8yxRFCM1e/XGJAr7rkuFkBNuHE0G1KTfZB7044RTlQ1Dipz5VDWjJobZ6bO2v21XDW9OWyqYoOXb7hwMM7AjD4cR59YUHVARuZQkLR8OT9SyM3GoKnK0mHJLLv6Zg5oqHynJvG1Rl0DNgVYa7llaFzVxleNDXkFQEtVGuOhCcoo16wRtQ7BEtOYSGH8RyOHs2UeNqmCC2EwTfOML/4z6xtnRPSCYcZMoSm1kKgKwzixJLIPGyAmGZ8+Mg7IuJfXVsaulhdlDZtQ1TFm1s+5cKWU42Nun2bvUL1mCYNTsGa8AUwEDNSxwtqc9TudABr3kuxZJSMLrC/EqUJZQuGlwoHZGlglhYMQiQlDjg9qtw/hVjEZMVhS4qzNYOOLz4V4dLrZuwhKsbGbxhvvL8BeuJS70fC8L2DgDH+8tOfnoKCmi8t+SUCPY/3EmU4nQOaocgJmTnKSlfKG//gqAFieCBhoK0N88eZecIl8zyg4zeo1xUMmfxssxtsDLp8x4N7jQVmylyZsCsSUIQ+khw7KyI3gKnXhypGox5I5o2MrUGaNZ7+m2G3RpiLE6dibNoX4VJ6lN0SrO25e3NPqs1qIVe3z2bAAuofmkQfM3mPY+xA2eCnCBmttsyYofuzvqT01IMOEEzg6FOIt2C016cnj0iq32p6twQ3JVmjla0gMAQbOkPSs473JgA84pW4rKfp/RZtqa543YZ+ixJfGeeByzIwU8rZ7a4JxMeLhlg6QMfOyQ6wBPERlLlQ6FTit/RlIzg3wWlk0/qtAJLu3xvKgMBhnCsMeqO9/xfpLoB03sNck3mYsjnzt14+kpvxhxVpMBnjUF2nf6wkr5kcx6w1tP092aIMGFiC2g94fZ2Bx0EWGzjTbjPTu5oDeWV2mygJi31uWV4np2wlIMlOycO9oPzTlWBV/F44ers8LplA2thM4la+RZnQhyS+Nq9FNY6txUpdkXpX5ZUSbExuI6wo2fGnK8k5yHDkBMyc5yaHSoodq3nf+u6Tr8mKZp8kgbAxJlihMBR1TuUyCF9Zgf2fA/WftcO9Z4XjesyfCsdhT+5A2GeN8qWxbUa9XEogJGqqqxNdkJrY799CsKOMGyubMlK2E02g7GCazUptT8ru1xdf6Uasr1sfBFA0EqhlAXeLzeeWzzxj4CcBcsjlXGBZogjN527bvxy0YEQeBPGukxyO9RBr5I4qcKPwY1nQtLyv/qgAGe9gzWwJQ0mDYavx3igQ4CZRx5wO8BYZLBzOa7CjfcC03vnC1DoIbKhKcUaXHQ16732FKKszLabFnlqxJmm4zsN9RrtPF/JHOBGqfZ/OVQIKZuZaMejpZKJZnMJ0QVTVmNazGTyEroQ8BDPPvLD0jZwS2pDfPnpLgOIE+xuRMNSAPd6F+rYXEiDA2eo5C+D7JnTMyIXxjDU57jGRVpY6LdfDk07GtqXbW3nQEeq2tjCGTfT5MY46H7aXxIvtgdMKholdbEw2UyRhZPI8QkN5NwYIC+sLWTrJaTsDMSU5yDCHPEcy0SR9LWmEfok01yZWnmLvilsXFoxZPf6jB+QeA8ydG7J6O7sbBwI+MUlkxbhLgw9vCN85jhBJpdE3gg1YZ1/IybJ5Ykv/+INNcF7T9YJCsNW+5khvnWPKuWcDExH+rq84U0v6yNg1RqSQGPqjMRvm1azYDO6VB0Kp/zZagefO1ejeSbu+oMuebLJmVYDjPMzGFPZiYh2JqcwgNEPmFDJAYNU5xEHwwSkxsazC9Xy8NsDlRQJaUm6JT/0j5Rah+HjJBTJq5dXlm/PUmW66xP3nujSQ145/nDolgSgjtKu8lvUsbj3R8tBnHYNgPBh5WZ04XTj0BzvD2iet6pMk61NZQEYo0AWM+rReen7Kk5Ttq7Y8Ks6jG/FaLUC4xCG0ysPDeT0dV07rjYgJdO+SsMvG8U4Fmams81hpQ5lp6BqR3qzGCsxxjYj1d7MzgoEwlCbK6R2mhZyfZXE7AzElOsqXwxYoUn5qXqHYfbWiRmptt2r0KU6VMQCzcpOgS1TtumOPtAZd3B1zeNRgf8fBPGgwXDjbGxALM86htzFQekIy+ljJc3UyWGh0clGmxLh4iWRyuM3PPIuFeIWA1KKPmeKl5Wdk9S/PbzF5bqQuY76/FfZr11YwHNBo73kTlroWkeJSgpNM+1D86plQTxLbGTyuhqSYKo6MWDpXlejlUekEZuZ7LdWpujWcAzbEYRU2lewmYXjshLFVUvvcqa4rtUelzAmIIYBh9GNMVer+Pt1OC2EVyA8LCNpOePVXbP2vjQvncGxMMWc1oV64N7cLEUKjNSzUUSICVvbJk3js3JahV8kYB5f5ivIcfo+7DjfeR5dWCfi9cOC2LTjqqMjMqooJJ4ruMvdfYbxOLc27ctN4DD42ivmi93xqwlwHGAqCWwuZsFfjnieINOxmK3jMDfDwA4yN4qM0JqefzNsd75IlI6Shq5wAXjgdPDCReZmWs9uo/GludM7KAChjP5mEWenWSo8kJmDnJSY4p1qzzbCdFxU8hTD2eoxnR6eZhA/I7C7czcGcW+0cs7j3LYP8IsHvC4OxJn64ze1/1PKZ4frHJ15Rg8m42pRecoWsMymSQ6fcHW7GuARFrQYpFimyvojwzRpux43PvpwYwtm7p6JuM8q4oplvnTSkbWQdrs7btmcvKoH9tsaaeW0MdT3Vw6hBmS++1s9d19O/cXJDU+4NADrk+9b5/rrzzUEB5TWqkMJgInJlbI4+ZMNh0AESacVRh2qnrUgRlODADlqA07EfQw/v4c9ORsTKkokduGijTCwRqkrE3YuJRYB6A6QmNlsZ+EUIhjX5mFMqxzpkJlKODhQn5eJxwuF9vckv42pqNTQkCUDiKZwY8zSnZ92Tcx+tDyI/JmS7eJ5CneF5Nz+vV+2oMJjT6p/Z+BIvCAGFu1U7zatUR68nyALF71LWar4WNMTcHvvNr1FAoeY0CAPGyUj2if4s2a23igItojyoacEYixl6r77VE/hmzLc7rFoMrYzhFoTybJ9lWTsDMSU5yqNQMVldukgDbiHpAAiM29CUi2qQyZbhiO3r42wPcucH+tsG9DzHY3/G4+7vAnT9yGO6NKXTJjE7PDyPDiGq08aXhTPz6ufhnpuCZm6ZMHyIpASx7po7nK/KhNBgCTSWn5S2VHsEZ6Uq8ewiTQdxbKEOKcpc9M3+mWhWtps28l1Jhm361OwuHyfiYQjWYr83k92hih+mCMM9Lr1gPm63W9s1YV0ABQmXSmwOBF8dtIA3z6l1/e0TJvcA/B5Czc9J9rIyFoUL88yxsYSNpjodOY0BeO2uQyOeUCarjj+fjmvJ2jCidBWy/MAD8EK93sTEP6tYwA7B15WuTocdkMDYYg13CDUmItQaYmCN0jXPTXg3Ajwj6DuXkIAAtzhUzeuByH+4bBuDWLoSW1Nb61I56k9VEuhooLp/TmNKoZ/dmTjV5bwI8+PyI6zMHcfh4106r4mXydsnnAXSGnakkE/bsHaTP7BTqI7Gcnn0gzeEcaChyts0Bf7XipfpQe3eteyt6fGs/KerpdEyl6yk58jBMa5wCVvFQziTW1JM7u3C6FoDEuirmNo1DGu8EcsJM3xEg0wPAn2QTOQEzJznJFqKg2t2e5cpGuqp+0Qa1bha+FH6J/w0Gbmdwedfi3rMtLh73sHvg/AmP8/ftMdyPLve5UIGo6M3G8jsfPJim//QXVUT4kkwQSV7UWuLhq5ZVjAP2jG6gWOXwjxmdWq4qmgJXaWOzXQtZMrLsZlkayLPGYNCesVGGGidf+w4bghJCXviSx45Srhaeks2JhfNhi+c/XihO/bsiAe+BLMRVIvNokNTGZy18Q4IzLellzbSua4DirfEzB4ymz+k7mbxdBYrDjzcmHeXL8MfUppSbwa9EEm9KCNNCxlN1TMjQY+rreNLL7JrZA5jLHBx0Kw/NTgAFgS8x7JuSBo9jSHhqTDia2BhgP8JcXAKjg78FALsug1HrC3W9F/tjZmwP0WCN11SdPtw5lOJQMfUZOdsIe+d1IgJUFEozADCRosLzmWjvhP8umTjxHnmkcrpEgDOZIZ+Md4/WsdB0SVc/8zZX1q/ZcmakycJZ6kDirJJKCGkXY1lbK5muU+iuYGOmVWYtXI29x/ROTb62qseUe58l0j4BMlcrJ2DmJCc5QF764leHXxYq99miS1IzPg9kDVSZMoTMOw9vDdy5xeUzLO49y+Kp53nsHx3xyP/cYfe0gx0nzwmnRWplxyNl9DYxD1PYyJQj/HhZlfvLZ8H0rLNK49Uo2V1KSo+IEK0Qgwzg0qUR1AIOVG/eAikUjppRO+dlVAuvKJiy/E5ASS2fzyuFRbbqnSyQWSo5AD8CT757j7vP3n5LfvK9IxxM8p4VhkUjAe5Dq5BtxZZpyZJ1pubJJOEG7tz4b4W4HBLS1PDMLpJK+ymfg4/AjH6RhxkBWMDZ4MH31gA7D2sN7MWogvDGI7FCVcZhC3y5SlCmBnJ1nk5YXcsa92eJlLUQrzkgQL7PCihDn3kXNR8eRhEaAiD+PbrAimFA3VRGBGkqOVdq+0+VpVkDCdmzZawieU1WiVIW9R+vi4GJXuYR5MJZMrLP5V6Znagj6pJtFqBI9r1ce4hFQWFjwmHRAmcyliDry1o4dutvVeaYhqxe7fNaHpeCRUT90kjOS/d1CTFdZpxj1KZqHp3aKXmszUaMmyLBtwYM9YL9JzmKnICZk5xkhbz0075d91I0DMc54yfzVi0xHHoVBK7c8L3aGviYV+biUYOLx4DLx0fg3OHsA8D5+/YhzMnSRqbUJxU/qRz3KI9LRIAynk7nSPUhKn5KW44seU6bbTa3WrI8NcfPMaXWj4rHZ3VZC2UWXKnUQ21dBCQx2Vpx+e03P5mcowCKEJlQp3zfFUMAkzHhgcBMIw9tnBsA9BAbVkYPqHRtsuYY2I1ktl9ap590srgy0JpyT2iyhDXD21brv0pi02MJD4H1QwSeEcf66Mv1NGa3Nj4k0kz3jz7sAR7TWLcoqP60JyTRTnPZ6pmXJq5ulbGkjkWsgIpzRAovkxuysi4NRORjnIMzsnxZNv8fAAYLb8+mvZCYIN70reM1pqesm18v+0Z75jmAgIcucbZcZM8U/cFAgOzaGjjD2DfNd1kY6+F/7R7PjonOQlkqY1rO01Qfr1sCQUukxiyUQGABajPdnOUJysArIWr7Regpf2PNdXfhOtsEreT7H8Xpc2nN9MW1Wo6YDPQR69+N3PM/SOQEzJzkJAslgTKZh4L9PmO8ckkbnZJArrn5ax4rpV4d1Z8WaOMBvzPY3xlw8QyL+48bXD7mYe9Z7N4z4OyJSTGu5mVQT97QQZlau7rDmWTeAUoKyY5MhQcMKgYnlXEkY6O2qUoQYHnBCMoAGdXGZMeUewP4weZ9wJhNJFJ5LbxbFVHBD0Vx3ox9oimmsvpWXTX2We3yrdqtKK1d+Q3idd6bzBgP84iVJe6fPFz0fzRMTbzYIMWNm0if5+8ymyMtY+tBFGWep+c98Nm09SuU3zmQuBedgy5R2aZyuo1mLmtClmr3HBGUyWn7YQ135wPcuQW8x3ARTqSR3neDCDIawIwxfCmBkWFwGxv6dwK04/powU5BOS7glLM8OvecJUwZRdR1usE+AgAzYuaUt5nvWkxfYwB2slDmsSfGrnqfsibRvTzkYq5dvc8jWSd06g4BP62EXhnY4cN6S6BGYicwUIByyIh+40lX03WNRLtqU1r9w8rOGDzK2sXL4ScTZU6CBITMjOu5NVF7V7V7NEaPFAlgCxAMI+tfCZRp4CPE93y/pL4T4yPbHxSWd02KMFtN0hiN75P33ejzvEA0b+KYVPPDHSsp/ElWywmYOclJlgrbHDLFuUadXFtHj2LBr2G/NxP/mdwYd4PFeNvi8hGDi8c99o85nP8vi2f8d+DOu8ep7NHpCq1Q6ueMk2JDYGBC7yaRmDIGcWPNFZu0ufn59hwifmDe3WMq+lS0j4YIfBnjblh7RldY8Yso3pi5RvNmdkgyHGYUj0wxXfv+uj3G64o/RKrsOT7++TWKwTYZOKjPfR9DP+Lvqe4Fz/zAes5aOSCEHPMZa3T5qR0MnJkb673zrXct4tfNJVjn0gk0dM0ta9IYdmcG4y0DuwdwQYUohhLimjuSfRLAlnBcNoXoxucwbF6NHipbhmTLNVyCXUsYOYcaS41xUoCxPHyJe9VrjiASbiBqeghnezkC2VhIJRWdwAtWpmh/0rMGZmjSdUYPKynmW8PYNzLEjQByjVXBAFUygjnwBAzwxpf9MIgmyPHsBOLQM9dZ2fLz2n6fnX7F34U8tY+uk/meWDk5mHPAXqoxlThIJsEVoAS0+f+NelSguwbIaG0UjKNinDRYQdVEvbwOPh8rLEla+zzvj3i9h53mi2Q7UTVLQZmbkmfrg0ROwMxJTrJGohLRXOR7PbNbL3iNOvOEiiHZ73jLYn/bYLxt4M+C4nr+PoNn/P4lzt6/jzce0EZtUZenKAHwFl2nKPGcMtOHCF6/IwMxmZBBASD6cY9a3QQ6xT7Q8vyQeGS5QwolrQbuoeP6A6RXcUtKhfpl57zaqC3HEPWdHWCMNXMZNTxwKdeV7NOasXNV0gMQ1DyRlXskO0n7fK0ckkS5S2pzAcje2+LwOrk297S9MU4X92VKah6MbeMBu49gokc0xCKwsp8+C9cGgzj1/ejz5/dE6ce0H2unNh1TethL8h2sbddS4yljesSPRqBAbaXxS7+L45+lcZwMdYvc6OcGtxzXSt4LeD8tX8z7T3WoorF4pE7GGWtSvJ+S8NJHfE90gBlHmL0L+XBs/uz8nixEXWNe0DvgbV4CytS+rg0F7X1KFoid2h/KKgENPm4Sa1eCM3NgB/9O5kMB0w8zoCn2EwejlP2qmvxXnnLay9bR2u1DwmoPO5Ur2VdAAkjU5NqiPHlPcU0MBUzXyGfYTZroZnt4KzT3JJvLCZg5yUkWyEs//TXM2zCz2cyEY1RDSA4xgjWDSsvHQgrvYMLx2LcM3Blw9n6D8/cMuP1Hk6fdxBMtNgE8KkonbejSC1NeNyk4KdGvi6AMizFeygpYJZS8zXSCQWtzGDgfn8/kf0vxSCc0SenZSKubuOY55Yoz/+4QwEQqJbXvlyqwG4mcr9K4ryboqwmblxx0ixZBPqZaxlqhMIMp2vQZM760PtsQ6NpEGVwDbqwERGZBskrsf+9zZsbZHEVdYxNoyveWstSgr4ANS5T1rO/SngSYvcfu0qV5QCGqIQ+ayQxEM0bWIC15xAijvDMRnOaN6z0GfFPR+ov6fANwSGMuNNsCsLHE+tN7lbURQm+Q36cxDNhnmYFuDPwwlECOLEfWS6wYlhw3zAc7hYDL54KYb1x4nek+ukfZz3goj2gbrAe8hd8BKUGvtTmrR4IUYO/GxGPbGbCotkFrM7WBPmf3FPlGetcMCpFWALa0/gmdY1Fy3jnwg0AZ56Z1MCYb5qFUlPskORMqshg46OmnBOiiyAk0hUblnwHKfjvHyNHASd5OAqUUEDDJklP1GnICYK5HTsDMSU6yVjRFWx6BOGJSMCobZRcFVDIcGh7wTMQCTUlyE+sEgL0MuUvsJXD2AY/b73E4e8LBOA93bmHvj0GJ0KQ3l8GMTDkvZkCZCMaEzZrKz/8nIKlZ3lpqpvDkJ4+sLEtTSDoV8aqBO9Pe1BbeDKmoFTf1Wpdi/Gl1tDxBrXoURbkwUjPPpp+8SRuxZ1LJjbnYyhW0GIyQYClycCYBbEpsf94oRNBUfC7nUxx7aQ5xG6ln/Vkg13KaQ+9RzdfYDgDdY7U4OePA8lTRwmzWhEB1iGY0eGkAesDuXRj7xsCd2fQ5AHjLCuLVSy877Q1eVtyQq6bpsxPRkiwI460afa260v1svaZQ0cj+NcC8Y0gD6oUUrAny4nOggTEkCoYkN0qNYMxIUGaJaPUCJTuBAUxaUlRjbRyPNrtH2xeq+3nsf09sIv78XN8SyVzD6UiYgBQKfbGhXfIZVOHAjsJUyS5t6Q+srOI6bW/ucmAhgFyDuJcD5JxdEvWAVh6gQkdptUPrN/ksNiQeBwdjJKgOMZ5a+pFWv+ZkrbUvtWHFvKgdtX2Sa5MTMHOSkyyRJawRWsyJOdNYUKWHqatOqdhKURLlYjBwg036hPHB83j+hIPdG5w95XHrvZcwlw5+Z9lJTO3yq9JzXKvw7hf3kkHJE/0yoaSmmYHa85qWgjOHJsfsSfym/L3KyNWAIs0bRl8faEgXoSFyzK4FUJbc12LRHAJK8Vt4MZrHtkL57fJmzVYe/58DYSqShwCWIN503brmXXsumiuMg+cx+slQXls3z61RO31pbq2X7bpGmTuhJDE2maQQVmbUmT0h7XzcMgCa8nqkfXMqzw0W/gywo4W5dBGsP/TJjiQr1oMqINOZM6cwVCObJRiTJg83AibDUjI4ZB6QSrsypgjVS4DL3J5kTAhf0aTHqBRgUCGVPBzhu/nnqV7XCjWmz42BoX5tMUYpgTIA7DCdmER5bmKBHq76LAbiHWaNEfoB3cP38jmmBy9bJKhVhddF+XeGofi+mLvUVp6XS3PS1NhEDXCmGuKqMVeKiyrP2GMzKODMbB6YpaCuthbUToJi77QrROwkm8oJmDnJSZZKa6HlSjZdW9kspGd5ked6DlWXoIxBjAE28BYBdGH1nT3pcPZEPAnjMjyAjf+b0VU3geZpJDVDpUqFF9dzzyqBMjtGLfZMSc9AGa+Xt1QW5K04dvLQathM6yjG2lHITLrazRXaOQ9+7f4aJbf1jmRC1FbOmVZ9neNgSWiKGpoApD7XlBl5Co3xwRPK2TJT0r45EC9ex0GZVs6VSg4E9dkeUpnCJRfc1DpRzuZr0Zq26HVCD19ay47pDaE8ANSa3bdETjEeHkLsMOMmYxXeT4ZoTFSSAHggfF8YbEjgjDszGO9YmBE4e2IPc+Hq68BVgHnMyZD9fwV11kIvw4deH2OFl0ADHuL/Wi6MXmFgTsEukeErvEnsnW0SCi6ZOLUxUQO+pE7TAIxUVg2F5tDcz/qz0hZjYkjVtJeaEfBKmEtxX42lURMOuBSgUdnOxEiiMDgJhmhgXM2hIkGj1vvl5bPyihw4mvPTNJyQNZlzonJQq+Y4kmzkuXex8XqlJqfnjDEhD7OOcFPkBMyc5CRLpJOKyWNQ1SMSJf2zp74WI2BOaLEVRmVIuAsM90fYC5eUZO4F1oyZJoV6zcbRusUgA2Wm2HMf4s+h9NHWUvHGV6nLwlOzVKQiSu/g4FMPat6l1n10SlIn+6u4v5fBApTAJsnSMd/rpRLK2+wtCriShCVbbuUjaSVR1K7JQpzYtc2Es9rfPKTSozDcMlmbD+k6ZTbUb0OlkiWtDdLfR3l+FTLUp3kGQM/r0SFynVAZABV211rRmH7V0CVbO0En/MPDERLYaA0AN4UNCIalDEvxQ9gjxjMDG/cOfl0maxmPh4TBbihV54Myt6sJwWkdlEaypm/wzxWmibaWLJlzVSdTC4ihZ2gWnH+v6i9z72eOodCRdJz/rYY21fZW6YBj+QuDPmQmIBOAGtrT2HO9U3L71dhRNVYfv9WI9auT8dculI1T79u5WJptYzraITq11r7K5/lx8eJ7ceqUGsLeGpscTOwISS3WgVhvC4w5ydXKCZg5yUk65aUvfnX9S4nms8zpyTNeAWeqooEySp2qwaEmHJwUErN3sA4wdErFGJVgUugsCkOztmBrymH1+oXKaTJ+Ytv9wJRAprA1jerKiVDZ761rtO+bbZ65YEHOnbnPFsucQlrLlYMIzsi4b9GuzCslPUG9IpW+Jff2Ak5Ly+VCRjlyAFNtjqZjzxgRWYJTyf7Sxmlt7LK5kdoRQZlFbLIrDBHaWlbPGWX97FFYa2ypJSKPOZX1S8OuZvgl2SjJrJTWc2kMsclTwb+g+SqMQCo7YyR1zJuYm8Jbg+HSw14oRyFz6R3bG/dfzbHRMy9pfeCOk1BmvMDmY0YFZAgEZGwEv7OAFYuvNFxrhhyBb07Jd9Upa3OrFcxLjS1ZzZEH3RgG2vti53rYO0dSWBOxX0giAOFhYRBZX6OH8SPgTAhpolRMcm+WwEoF8OF1FMLZsjWRuYFqdW0pHUzCalgS+46DV73gYvWdNhxQPH+TYe9DO3WqKY1wJPl7tZ2VNWbxHLgK1t8HqZyAmZOc5FBpeZQoqR4tyCMpMsq9S2XOCCWF3IhF18Vkv2MMW/IAhZb7wTYNTZKDvY9c5vQuIxR7iE2Hn8rBPdgeunGqyZw3dAvjdOZ+GWrRpdRJinytHjlOuCLQMtyiFy87caAx5tQ294zxGk15jiosr5ura0uFkdmTgACj1nhkgWm8ilO45q5vfZYMpzSucoOuq50PMDizWhrhDHI9Cop3B0jcEn4MqhAZ8toUNgaPlYi5+xlbY77w0FPZvljXKOQvJX83SKFMtL+GMN3pO3sPGO6NsBdje4/hY1tbRw8A6bM6OmTuVEKSbA7HHCPGsBAxLQzIx7w9ziU9xewdsB+BXcjtkU4ZKhqmr8vZHtKSpcmlW9cuYcfI48ATQy1+UGNb9LCjlGdSw6pm9ssC2KKwJn7vEMGZcQw5ZUaf9ubsRKipYtbOavWxERM4k4SfKCrLUXSJ7JFrqsSCV6+ygxvMmBpoXbRJSeRcK6vVNl5XUxgjMrHoCQgdFoAyC+ZNM1lzpQ+7nKgnIObK5ATMnOQkM9LFlCGRiyEPzYibrTEmeCf4xlfzZrRkjobJPPsJnUdYuI3zUzb/VF5+b23jykRJdkqsiSVShGWknBiifc4HpgwwHZfaXUdnu65xA1rSb9nzVJLOdseSU59LA5wphl1hSb31cQCz5/OsrfH/pfluDgBlsrwiwigvcvlIo0UZT1kZPh//LdbFnAJabz8BX8ozzdxzUGLbGySLAYojgVFV8LJCz98EWDkSa6YmrdC9bJ4k1gabAxw0jHuUN4Ah1iSFs44+hN5GcIZCmEJobkiWai/Gvj2iBkZeg3SBMxyUofVwUK7jY9h7UBJZT9eODubiMiwL1iaLIOU96VmPi/a3jdZqno+KqKEXUD6TITb8KGwuc6EjXHpzzVA7OXunR38j8JTtvwmcKepECOdj78S4kJjJw8FUdEjvzBTGKuuvCe9H7d5Ydiqq8ahd4fq1shYyYxatla35XXPOse/lOG+yariDizEii6PYV8psH3e+q5PcDDkBMyc5yTGE0T/5UYdVmQv7kJ+RQlaLSbZiQ7MATGiLGQMok5InGkDG66cyjpQsclaEIWES/Zp1VVTm+fHYnArvjUkhWZIxdJDSfYDB1kzku5FkCiKnITOjT62zkkNHVRIlw4Upx1MCW1SVKb3hlWs1sHOpCMVkznDoEm5MZvTkWrlmmmsG6eh6s/dTKCGvn72Pai6jLaWW1PuDEZSZEWJw+DjGpzwnK94LGVqKETLX7mbi0yVhfQvWtLnnK0BM0T4DkZOkBsrE6ydnRixzMHA7A2NNWGLi+u7PAmvAji7tb0uA+5skTXDGsT2Pr7few3gzGflZgXEvMGYCZehzrp8wcKMI9xDtWTSnFuy51T2xpUM58b9FfZ9oMC/yMmeMc17kGAEvzsiZAX0SMyb+nmrj4IzjiqSJJ2Xa6SQm/h0fM+K+APra6Ts+bqi9dG3R0HZfHbS28v2z5cTpra+V+2eJztfNcGt9KcaPMRN4WhsbC5llzbCrhY6oY7ErT7JcTsDMSU4i5KUvfrXulecL3YySUFWqepSCOYWavp89gjsYglMcswnK6l43tvJki6jns2hsGt0Mm7mNLwNlAO8Qwzt4ZSifJQM9ZkClJRt1JY53idQSw7auBZazaJIxw3MrGBOPQl0uRbK8KuuGgZC9yq8mc17aJV7cA1gyXcINybl5a9j/pGQPBtY5mHF51Tz0rXXyijcTkKCKAsiE+x9sUGYpqyiTFlAh1o7A0jAFy7AnEWqNPdObz0a7dynDIYl85p6kq42ySlAGyBmQvt1WATIZH41XgzB3vAeMDcCMjWDN6IERdVDmGvLJpHoPLZfnU2Oguxd6iUEEZ6IUbD7OVBpsOKKY5SqpysqxVYTdUlMb8ySbX7TGavpXFbyicqgRnUCMeEeZsVox+o2L78KHFdYPJoYWte8rnB6yfgm8kb43AH4Y8nfKboEDjLUZq8bDTh3NjthO7V24X1ff3ZKwv8ZY6tJ/esBkqbfxROTIAeFUZqucjjmsMqeWMlY6gfIWa2epnECZmyMnYOYkJ2Hy0k/79vBLj5IihW2k6e856aW9yuvpnhm2DHnlASRPYjAggcSSkWBLy1PUuWH0oO8ynEPWNR0H7KejVPkpTFEZCvXlxwd3iTRCjiibsxtaIpkyDVl8ikYLnKEcGcSW6WpApTLOyOEGAaOgV+fOFiFLsxdO8zyj/UsRiiDdSzmd6Kj3pOC3mBIVpXd2bLE8Hdp3zRPWHnBpGkfAKs8kGZnGxj98AAbgo5m1AMxqhnU0vKeL8hvwsmS5GhijFdX5SNq4zU5Nius5hXBoiaibQLAxcENgfXhj4Xce8EghAdZ44JItftLY3SI87cAyeuZbMVf5XCc2hLbGMoZRwcCyEzibgGBr4W+dBUOfwBlfCaUp2tj4sqHXVBOxMiCVswuNRQk0AXkoNvWFzCnDTzebaU8rN4o6rkefvQtPjJRk9M+ACojTgb1bz9+z9zFUycNYWwLrmv5nwuQJAI1JjhLjfa6O0j7TCcrUWaDN2xL7J1Ur26Aw/LRk5r0M3yVSTajfqmdJnUxX6dYrKgBubc7I3zPpyZMkr68AWSe5WjkBMyc5CVgeGblJraWGkywBXFaUPRs2wSiuGbvEALAmUXDze0VhWhKwmYW+eyNKz+zrGwGBMzDw8KBjUykUi59cUyi9vRvp3CZ0pHwTW3opipOQgPT+ZVjRkhNVmgo4N568z+PR58ZzRTErrlkiB9CudaNSfE4GeW+5fFzxfozz0UCEXAjldA5YkEZNeRoO/c/f/dSmKkPmIUj2e1BCxZ5ndz50uIs5T3wAHgyUcBxgGpuNXAUyDKh24t2sMMOr8A6TyESx8tkaMmtwKnVy8LwaYiRZR2DPMViMtwaMtweMt2gPMNm6n/Yyz8qrtHH1+N5iXrBtD6iApqKubH2nkCMOYPPj1g1C2IQEZ+K1dEqM38WYHzMD0Mr2SQcR/2yNLoPKWmfizh9DkvsL83R7zLGC2TZluV5abUJsi+Yk46Fh9FmnblHMKYYvptN7KpLtA2mdYTlNeHkWE8gTy60xYDbRT9heUjAGZZhcBdDratcCFvaxJLVTMmSWgCTi++Z6P8fs7JWa47U1dh9w/eAmywmYOckHvWSgTE1kYrkemVN2WlJTbnrLM9O1lJ8lhF3EDZLcUVzB0Dw9K5T2bjGTdzTlg2kJefLYJi4VWhWcWSIt7/GMsVr1rM2AICTSoF4S81t6mUgREqBMZ9/MgjHyb8WzrUon86XI1VEDS+nvTsW1Wj70/q566pgik8f2Kx3nJsBqYtMBpClLUEZtk6YgtRRe7f3FNcFLZTi+A7OfbvIPuNLVXMO2fjY/c0SwBCCBacxoRhkfUzGMoxn2UWuWofkf6k9siYXhKN3GWgf7iu8/1XaIce0HC7+z2N/d4eJRi/2dECYyXHoM9z3MCNi9BzxgY/60LrkG8LFIHB63YQDFuwZE33NQhv63DJCRgACXyhgEMSbk2rOE7cuvTcb/VF43yM+bG8drNfcQgOxgBfZZOv0mts1QE7W+0YAAWmvnDHlWlpqPRwNia6IZ7oOZjrBuhGRpQHxicNY6XAIHyu+z7eRt1b6T9ylzLWsvD/8RbdxE2B5aY49uJU39ec2648V82hJkmivrCpnlJwlyAmZO8kErXYCMlFpoBYk88nQJmDPjadIov4VE5ZiHMEE5vSgocvTHguc/hiKrbJKZgs+bN5c3wPYdN6qKLHvGGOZSYyzM0ba1MiaWw3yTa3qXTEIYLm4UqI3nJWF2GvulVh79XmkXf/5FANFC6QVnCiFWAPesktFb8exqp46FpKWiD5rgsDIeW+KJZYYJlDFg6wJrH+KJNjHUkSdo3UwOZSrcUEk5sHx4z0VOj/h/vi4wlkcKw/DZ99wY3TIUsmBJdd9X+UKyr+g6rWgK1bDlZ7wsyZpw5xaXz7C49yyL8baBvfQwTxjsnIe98LD7kFPL7t2yvuoM5VLbuqW4adxkYUQVpkoCuChcRZ7OxJLPFuBOliDXxmsq63d3+/OxFEKIYluhtAPTWquFCYb7fLouE942Tb8iRoibhmJKzGvFvBTSBMKB7P1r88EbKrtybydIk5L/7pT3UgPvZTuAbCw19ccesGAOZFjDOuafeT+9J+2EMSZd+3RNV9wYXKgC11vWw/ePOZ20d59d076HbO++qXICZk7yQSkv/fTXhJhqTQGR4Iv2vfydU1kPkQo40xtTmo4NjYlFzehDclENdMAMyMOuO5bIPAOFx5X/6RGORwWKzSc9x9Yb74ryehkymhxsDFP/0fHWQDkml1DWDxXNE1sBYiQzIHj8lT7T5tnMnNlaMkDF+9zzDUVxrIB+WegBY6xVhYcazUnW78jmkjdGfO1DIlBMiYiXMLauVGYUz1nG39btACZvL29TxSstRYYsydDSVcLYhd4BKacRkI3TZphThY1VXAc+H8o6VOncVyiEw51ZjOcG4y0DdwaYfTh9abhwGO656VhsrzzLnBw6RpaySguAorJOdzxHYspkYUwWPPlstoZS4tfInCvebatOecIfrX38c01/IbBSWaM1sKarLT1C7Bme6LaWO4fpceq6J/QMtYgeHWoBCJiBK+kUTqR2pnZ39Kv8TA2ZbK2rx15HRzGOohy0/9TAJjfzrK3PZ6R731nAmlkMQG2oA9dyEF5pzsQPQjkBMyf5oJKXfvpr9C9aSlEtkaoW3sS9Mq5x75ojf2fEmwDIuHMLdxZOq5hT8o9mePWi9j3KF4VaSNYBfd0qYgu6ulSmVm6qV7GZeYPS4yrp5b209RkGVyESMFnIvukKx9HKbpShldc95htx4emUI25QM8O8q47KGFJzjiy4n5cxAV3BQDfWwI++7L4h+Ke9HWCsg4nMg83BmQbbTLZ/VtbO7WOFsNSmEX+WCpBB3KbN1wgWRpdEgIiHSpHYuvJdnm+mUpYCPHobGRcO2D3t4e8Du3vA7p6HvR9AGbt321PupYGzxGBlY4yzMJrhurR+duoiCVQDwkk9Pv88FeuhlyvrkGya4pny+tXQKAqdbUjBGpV7hgSqantGb+gVL9MhZ2PU+tyY6f07wYKrOAWKfCnGNK/3rfHK9CdvAEN6pQMAj9aJnOkodXpeCMeXDeVljE9zANOYyyGggEXG4jyqU2COec2kzkrO/19b/6K8Pkv6dm6fm9kDizFfG+cn2VxOwMxJPqhEDSUpPE6di58W9ys2RC5Z+S0FqNLmWTGA3xmMty3Gc4vd08HA4jHsXcUsNWCldHgLUh9nXhzFgEiKkyi75cGSyn2NQsuvXSozm94xlYo5Q7bp0eBsMKkEa3kJlDqqCrVyT1Ua1601TntAGf47MXJUaSjKGdV+g/Cc7tw2XDrqS2Uwdo53SEz79H1U0tPJNvuo3G/B3Ki0uRmeUPNa83Iaa0w3qNNoX0uycIehEvLVOw94lRTCsFW3xzmt5t2iP5kx32LNqDKbgyOvI3284vmMB+ylx633h/+HCwd732G4r7BBtxAZnnFgHdl4Fu84Gz+drNuUOwyRBeLY+5s5WcnT6UvGiHWN6Sg1Zknt9CNqj2UKjRqiPPdgDFTIwpmVftHmWDGGEYz9CqMyG4sJ9ACMNxOY5lFnrGhtqbSLnGQcHKHrq0xfAnIR2gTnAgPIxfeYcpex56e6JJvKh9O6QiLtIeGzBVi4ZLxvMfe2mr+dbFINCOliask9ihKTL9X1tOdd6gRrlcVloX7S3HfnIglOspmcgJmTfNDIF3yGwpahjctNSIpBA5zpWTwboAwlowPVIenBa4TllfHWwO0MYJBOe5lOLaJ6+4pd7S1f4TWp9ncEZRIbQQFb+MYqFeCqgS3/rm1cUkmpPNtcP23tCa/lF6o/h1aIz//XRPO+qg0qFYsMyJkBYnqSm85RaFclSWUg4azHsGDNIIEXa4G4Wm6io4oP/7QUy+D9Po4CVgVlamyrmhwjhn5OaC2lvosf1wxtYh2lz5esjR0sM15nLXzBU0NlMYe83kWhdL67riLHhzXwu2Ak272HvRdDl/YunTI4ARJHmkBzXucO1kxRFmcPaSAIX081Y4iAFTMteMXypRlSHFiQYIL1wDjjmJLlRZDAWMBjCO2w7Mhj/hy1kKaag6AHeClCSk3x3AXoyOpIDNM5NlEEN7Ljt2dYmyUAEE/HpHIiCATENozKyUxM3/HOw9Dpb7xtsu0u1pXa6PKEyIjP4gHjQjOKEBxN7+Hf16T2fWfIEAccD9I/FckYIPJzIL1nALq+JL+rgSmtPqr1Qy8oswbE6mSpAsjmqDeA3wV6md27aazFufWG//Tq5W05SZecgJmTfFDISz/9NaX6kwALbeESXsYaaKKxZQTlt4ghr3ky15z8lNo35ZWxlx648LCXrBEbePyAUulYnJsmy8sg65gUKXLnFCeTFBv59H8VnOmRJqixwIMk5Bi2baFEKcZBFtJkOxrRUIabeQgqyskSharnWjVfwgZS0LlryugMk6HqAb9imWtHtuak9Qgwe8DQOBk9YAA/2Cw866hSM4xqwOmCNnUDbz3C+47W8Bq7AOW6BCAYWFZe1xg0nQBNqmsLr6YY+wBbV8VaozJNpe3d2Z6c+RdAGXcW86U5xBOYHMxlZMpsHb60QLK8ZrH+6ljzU0LtgnFYY4jMNkC5XgIcGpDBQAkJWqR3SLpILVx7APwYXrNxLuUI8RjUZ6cy0/oj2TXyOeTza+NH9hsHZfjndGy0vJf3mXSmccZRBFOm/w38IMrgj1AL9eAHQ2i5YiKjhX+eMWlsTId8NkwMHs2xF1k0nk5m8iGXYtYaMV6SMT4XIq6BR1w0oLKX3TnY+ZM5V4oazqeCKqh/LxMSL2W4NEKXN5fae5xbh9mc8jsLf2bDO/cmAuEAUJ6GepJt5QTMnOShFzWvjFBGmmsjX6xbSjLf7Grx2NKrU6uHKU/dYoKhafce9sIFYMZj1qiUohkTqYojrscand6MPighkTqq5WsAsIx6e0AYQ6+s6ade1g0ZR9mpLkr7M3Cm5mnsoNB2beysDC0sh4y6OS+YBrzUylsj1fFD0oo95x6jNbTjufZsLE32WJrfXpwOJdtn9PG1giI9lck+4+upNhYXMEyuKumvN8jamY1FBcRN45WxbbqTlK+luMv9Y0kR2rt2ikEmQJFkdMf+4e95LodFbR54Y+AGA3cW77+IxoFX2tnr1W/JkvEs2VMScOP7bgJsZH0crOh411IXEYZ95tXXgIviOSK4xRk89DuxZ2oOoyEY/d5O9xjnAnBRMC19Bj542Jx50GLKaIw67ftUmWZwe8F68SE0qLgO9T7lVaQwT93YL5x6WuJkUzk1i9cj1wpizlgbJ1b5jovHGtjLmwknVdsi2m54fVljGZgU29pir8i92NMewHL6rDkdsBkmqLS39resd1EuGClX4dwQktpLrDYOoM84mtOz0YmucY3g8/gkx5MTMHOSh1YyQGZmIZFJCquL11wiVSDzVBXKaE3xOjSMifZl52H2PpxSQUeHchRcq75lTFyx8NwzZnSTYhT7W2PqkPFI+Rm683P0hDFpvzfurypZou836VsqT5Ylw7wq4IxK427NEwIkGuBi3cBqf98r9H41pUnm2aHPVUmKIC9DBzCzuTADylwnW0aT1nxIJ5wB6Wja1C/ynmOzEfjYktKp1EpQpjtX2AJRgT3vseo0IGZw5ayF5WAonxcqm9Ejf6e1ptYYKHNecAVomkuaOcu6NOyHl+mnsVoFUo84XouQCM46cDq4UqxXjM1YsDmyG5nhPTe+WKLXLOQmVTrVU+xFXuQlieUZOlLbTe3lc9UPBjBDzIFSgjsZIMf3cv5sCfzwE6C0hDGkOMuK9Z/nWQHC8xhWTytfIB2/rR6BzUAn3jQIA7ii32VzRFsDCZzQmDMOGbhUDYNK3+cgOweYC0YJTxqcvScTctuko8xzcMgPJrB+jKmG+c6F7xoPYO/COI7leWU+zzLPtPGgHB/eKzdtbydphgbz8cmdShJsVfqMUiEg/Y8mWHmS7eQEzJzkoZMv+IzXzCu2mUcjX2iqCr0Tv7fAmTmRHhXt8+6ykOir9jLG3stHPtBI6WEyLBE1IaX4vhYTHL5HUlZW0yq38mJooS5cYWFHlx4i3PAs+q7XEGGeunZlbGyLpIekJEme2VaKi1SqOduGf86vX1N3MW5aselANwh102UCnhXDNnr9W+E52zYmV5RnuIvTbdx20cCSjaX1rovkswqI0QV0y3KkAkwGbWXdrIGWU3kAP5GpmexerDF8vZ5dbyUTgBub4rSZqrA+NKOPSX7j/ubFdVt6o9eWJ4Ea3qe1fY6MJM584Ouudr1Wl/xMu6dgsMRfIiPV8P+9Bwi0HSIjZoj7RmSbZOUPogksZx8BFCb1iQaksbHoaIyF+xO4IUGLglmHjHGUGe2ybwicGTGFp8j3JRg8VXDbAt6L99VgKKU28f+1+uX3QAk42jz0KBMFlGld451IFi104tSumWcyY1x/2FqlrnviPYX6/QTKXI6RzWVCyNtg9Pr5mI3leqYPy2dV+2uDBP5FWVkby3LX5s9R+1JbD0Ry7qC3RSWOH3VfAbFS/jwGxBg+93rC40+yWk7AzEkeKilAGS61TR1oM1aUfDETxbehSEEqJfnnWb09ilzRZq44xI3uMmxUclEOdVbKmUkOthXbIdXFvMRzp4VMVG9x2kOxQR/pqNlDDL0OZsWs13hO5mwk/r3wsLdvJGUl9j9PFFsLbZgrcuGztsCYXpEG8ar8Q6K8B1Y0hkbFENWM79rRx/l9dQ9pWV77vS4pC4A+Vyu2YCEd9PvqPXPtoDK19UCsW828QJKtuUYEKFMIGTCWGcLsHh/3GiM7tca0qons59o4dD7kTLv08XeHLOEva/NmMhMiWzANG8wNTWbXMsFaUHUTXicB5zFkpgAzeLt53cQg2cfTG50LgIz3iU3nnYXZDYC3ExvCR+OXh/1QmzQjMTIpwFk8/Jl47hUg8/AbblDy55Z9LAEWqf/ExMa8bYYu4/3kfQqdzvQmabyz05JC/9v+dYPAikpfFc+KHMAomGwd9dbmOw+HzsCZCBiG2+pAk+fzoHBcsmfj4JsETTzLreM9DJ08BYQxAwcTqFT52ObAtXzfNTCtBpzEROPZZxuLlhagCfhzcHFO5DXSuaKtSQ2AXzJjpjDVB1kBenDkBMyc5OESisGtbXz877nFilFZM8SYNnUOzqhtiZfDoPA+dBy72GMEpo010kZrR4cuMSivMpFpAc4kQGbq+0A7ZuFaUvs/BiizQgov8RVIF1uo5pnTPpMK4qAor8Biz3IVHOm8ByjBLP5ZS1RwhiU0fZikGspCooGNC5T7nvAg/n57+7eHUdLFOFljpB+YP0e7t8ixYZEdP56xwGoGfTQom6EuTNas1T7bb9ICCx/zUhhiP9B80UACDspIxgKgGxaV/DBp7LhoVuw97DjGtvjjHI29Qgp2l2R0KNJkcWjSCq/R9BfpyW7pEhKU2Y/AOE7hw3Q/sWcMASvxPQETe0aCRHSvBBl24jl4aMUwfZ5OEGroRouEAJYBMCPyPnR53YhOLT8gD59pjTt+klFLWBlFGFH6orJXEwPJGKRTlGS9rTYq+51HqT+UOVl6+nwCd4pxncaBA/YE4Ig+F2wnmJB4Nr8fgR0DBJAw7S8+nwvGAIOBCqZpQt9pgNfcva3yhNTecS2HTrZW0JiMz1YFH7MCSvBrlsHFf+dz2WJyjM6scSfZRk7AzEkeGnnJZ32nfvJSEQ/p2wwZvshLJUqAMwD0eG5ZVkVhUv/GMiXbm9ge50F09RiZPFWxwhiuXn8ofVxsgtLgK9g+8bhUMhbCO2Ub6nXJBrkMFhtTjVOtksg+WarQShBMMq5WAjIkNUWklYOnyB+zUHHSDP/ZfDJHkLUU5qXSrGMuSWrj+2xuNvpeVUQVL6bazpYSeZWyVDmv9OfEsiwBQrm/kKKeGf5aWMGBUpygJI14SljK20aApvAuF0wZadjL7psxXvLwBscM2Cte69eEPWhGk/cTw0ayB4gBUCuHizCWpjY1rq8Z/1QWJdd3LoAyxFSg+5yHj6FW8gQynkgXQD0cnLZtWre5I8V7FKczDZjqqQAHVTaBADnT+mIMjDfwcBk4o52qpjEDCrB7zd5f0ZuyfY8zUKQeRO9tjEmmI4spK18T6ag0bAy3xnOFJVSrQ4KV2XNJsCWrB/zCcOKVUU73iuMkzRkn7wvvzUv2ywzAxsHgraUKuilrvporxrOEu2JM94b9hotnQBltzIkk1bysh82hddPkBMyc5OEWGWsZpfD21CR9ry+qYZESyfYO9PRU45mlcgBMSnVUgDWvthYO0ETpW1LzDq31LCi5DEi4V8kPlsUJY/LcdoQCHCRSAZt5TslY2NQQt3o/tdq0GGhojR2hWM6HYOjtqVZdaSfPrZM+syaM98qJVM1yii8mhbXVV1u9x2OCM4Vx2wPQrP2+JisM6Jqhtbiv5Hxd2hQt+W0PEF0kvl1QMXcEVMvHOnBGhhjJZsU1NmMHEEOUgH66tQDVRD8blMZHGo++8Npn87pmMLnyaPFrl9ZYqLF0lXCPDJTpZTLKuuZ0C34NBwEjE8qw8KVmGQprBojDamTPIx/B+3i6UzTOGUhgRgqP8PU5QLqNAupWQZl4XwbgI44lMvzlsdVUFzsSuTsn1NahdBorgcAi5yZ90/gpp0tPOzQGlcI2zvp5IShdy3njbQDG8g/ZWPQeANNdI1OagxKes0WAHMCLdfC2FFLRXZJTM32pj8U1LN8ma1/ex+cnf1c8DLDFgptri9auWpskILNlHp6TzMoJmDnJQyMESiSmiEqh5pTQuElLaSk8kp4LXSHpohYq9c0ttnyhLDw7Jm5U/nDv4rXm0pBx3NIjG59z1TOuYfuQsbfwvurG2KE4zLZnAzHa2E9fir+pzUPoB+NYHoLBwFibnK1byuw4nGFtzIGc0wdXM+Cvel5dFUOH6poNm9PuIVk6nxcya6pHNs8Br93AXyinlb/FS0Now3HX9a4NcnCGABUgN1IjkMIBldnTrmo6vmDdJLYCTObxvxH5m+ZCVnpAmQw0r1yqJTNtAQ2pDfXqq/NHCU9IBi/llHEedSNyAnYylowAENTXR15/xKFG79ux8mADIGIYc6BipK4Rdd7POdE4ICAvaYCVs1JxaBVrp2hP6hdj4EVIWAqHaTHROBOKOyA4e4oILfGwAiNPVdKcVJ1hseo6P/p4vPq0jhso68vM3y3nUfqs1ZaCxUb3sfG3lCWizLlQpvIMLZCEJ+zdQjTAT84zzRapgVonOYqcgJmTPBTyBZ/xGmQn9NQ8TBydHwwMBB2U3y/ouClXjELTBVBVIJbmW9BEvdewspl3M1OmG+1ZLFt4hrTTAugjX16Xf99+xu7nmqHkLhJxfdP7pEj3SSdKXT2SKWBsfD7/M+7ikWdvu/z/13/3vuzv3vfRzZThykFnm2rvY2k+oBthNFbEzHl5V7Tdj/PXZFVwY4q8bUP53lThiF5D6V7C/qqBB1VwhoQr9lfkHZQhfKoR0wl6FuCM82pegoyZGLbDiUWAsJ80QRleRwcgU4RTSNGSAStSWy8XraM1WcAeqI7DFigjQzZqBmPNQNecO5qhpbWJAzJ06ehhLvfTNRpTwJgpnMnFwak4p0IdeRjUFDIT/8QIHykpWTucS+CMgQmn8owjzN6FxL87C7+z7ZCP1vNz6QV5Mh2vDtxm4X1rhI97PtfjMeW8nqJdoh1VYScXhf7MATA6kQsjIvATpzfpysakNaTI30jrzRz4IZ8PYq4aMzHIEmvGJ9ZMzs7zE6AgARN+kpCZ2swl08dpXpmY6Li2zi5ZVzqA2QwMabFWZHsx866h7JMz5a9hBt1kfehhkBMwc5KHQlYl9KQNkGeQ56IpKzWWQWPD142lxoKsNUV4BRJbhsrxpVK6FAgqFluuNGwBZrSU+9p1ArSRgExXyIZs6xYJQitylA3r0Jw+Amw0AzYHZQDgRS97HG95w/sWGfWz4U6HsosW1PsgyvM/4y7uPmv7dylBtkXifTI6vTFZuJlqVKWT10zynId76+VXhYdGaoAvtWmFAV/1lMuTrhZIK6/SmpCwQqxJAH5RPr0Tqq7XKyvfiwLS9IZaZmxE/j8v8irYbNzgJKaEmmOJ2qR8LsCvOe+4iU6ejCWStQlTOVIX4X/XwBliq4zsmQwLD/EeiImVYW0IF+Z6BRAM9kKviKwZoQtl9fB8IsPURkMnHol2Gu8nW9WF45JxuQ/MZrcDnIUfhrCWyH7QhJgkvaFwgjXQ2sdX5yGb27Pk80jnoGgDgMJpoa4hhpjhJo23vF0xAbT3AQyiOvcO5nIPYw38+Q7+bAjl06mfaZxH8Ixei3zOgpES+3gwyBYPmWsICOCMdioUH8NSaN60GMEQay/l0isS0SlzNytEmbMy/xP/rnXS2loRY3cJKCNBnxMoczPkBMyc5OEQz476ay1GdMoMLaCeaLZS05r5GxXlbK6ZcjNoSC9lNquXbYoHJTLtOWngEOPYRsXXR4WYPLRSuFOFgTJHyytzKAjSI8z4mDXmDmAp9YTrvO2N74fjlGWFam08YC5HmPuXMBd74HIP//TTMLsd/N1HYB69hY/9v39Itf4l70cFINHup9l6GgqurHtpXpzrFDPgKKAMEEG2N74f/rIEe3tj7TWjqOnNs/l1vZLaZLPFlRmwvL6Fc27lWlCcyuTzdXmRtLyuyrjm76h6xCljh4Qku3TzBPQDyHN0tOYQMyqXAFTcoSLrWyKtOhezaWp91hAeaqKWxyWdsgLAxqOCGaslO1I6M+YEOJM1QDGGFTHCiMMQrNeQwy3mccuAGWb4WxobMVcLC0GagB4XryMQIPwfctl4GO9Ap8vQMdgG8R05ABDGtvcBoNkbmGEMAFJk0GwSBqiwbUrgoj1usjG8cvxmiXPl0d/FxSx8iaSW4yWVYTIQh8KbzH5i08D5jD1uiAXlAMPHXfws1EtAnYOxNgdLCiaGSfcUc4yzXHjba+Bjay4PrK0tYf3RlVBXm3Pys1pqBCqCHBBzayn/k26fW7961rfKGN+EbX6SzeQEzJzk4ZDGwp0ll6XvZPiSklxrukluMJUmCPS59n3tO35fT34Sb8C8YvNc90X5JlYyS9Q6JAOGvJEWAMx0jGK1zCMDJdchvUmFVxqGNVAmJFSePh6dZ8kbMR3pm5SW2Ia9By49cOmAixH+/ghggPcGnkeieKAW2qDJlqDHFvlU5Dy8qaCMlN/4+QlgO0TsYPBxf/ax8Idyakdr7SsSKqKkkec3sTW6V5mmayprgjy2uelV7wEElhy5Gq8vTymq3wqsHLeKUTC3L1FbjC9Ddug73lgOaKiJfoG64TQnHcyElvSALUuZNtw47upL7f4aOANMezX7P4EbUpIRy5Lk8nJMJayHvqf/HYr70p87C9w6C3/wMSzBCmMm1k5yjlD7hxxIIGDHATA+yxlChr6xNk/aOpiJUcFZGGe7UBd9frkHrIXBLjw/ndilsRriEczG2hRqpOauqQCbvbLJ/sBBlZpRnn1o0ndVQEhZzzKmoGdHpQPwwwCcITKnJlDNDCYBN2bvpnVassFc/Ef2aQIA9WegtqSxSuBjbXy3nK58bM+9F3lqE9vfut9/a32Rc8j7KR1Cz97E11U5j1O7G+2ZY1odKD/3f37bNgWdRJUTMHOSh0dI8ZBeWO6JinG02T1aGUB74W01Y8VtrfjR4nQBUoDi9Zw62tpUlntqG4U1QJvM0CBDxUYPDyl5qY7kXCsMmKREPKyZ4K/quTqNIOMmhT995hHYMvvgCfVnu2DY3X0kKM5nu+T53FRWe86V51xhoD1o4jwW54WRYjzgC2p2BGc4QFFjlSmKZpPNxBTW3nfUNH5ZPpWCmag919ZCfWQQTyFByQTsPNls1jhYaogAzGhtbRKIwBbSejwbesruLYCSRnJTlZmwMIxpSVhaz7WtvFY9IF2VEcbDOTgwwNkDVtwTrwmnCMmKxJHTsj6IezT2QmTLBHvaMdAFSGg76RrWwlsbmC/EahmJbTwUZRrvw3pEjBpDp+oIC52zg2j9MpTg1k5hM3R6FBB+38fjr3d2CoGRfezj8djWTrlHCLxW8i4Vv8t+E+9u9hQgKZXQ8ARcyW00MjlqeY+yfFQMlE+JgGvJuqkd6Z1E9pI89WgXv9+78EOiAFpZUmipDzD9Q0s6nM0JL5IbS+F7DGtH1/p3lWwPuRdqf7eEruUJkvm9xsTTzoQ+LcruYdq39p0HURd6GOQEzJzk4RAWmlSIZddwSSg931jid5XF7VpyU6jeDyDRSqNcaRhGRTklEKnwXKcL/MROSicz0L1McW6dMLBEpEHZkmMDJZUTGbYIneCyanPlnjTOdKD48/0Y2jlY+N0QqOy3z+HOd9NJG1ROzXDuFaFQ9hhTkm2mPfOct/tBkCa7QlP8l46njHZdYKVliGOVOi8+rrW7AoK3nrPq1ZTzq+WR3Pr4z4wVuPFgOuCo7DBnTTRMy7mkhi9q0gLWgLxsLSG6SPDcnovb9F/B9FkiB5zOpIIzCkjihwh48Hfg/AQk8razI6q5QZsZZmKMyJwe2d8JBAqDy8OG79Nm7Ce2yt4BOwSAg4AaMtRHF4YGMS1iOAsHidNpmdYyDxQ9L/Lxbdg8AmBMCJOBGaZQmagneM/u589cgFMuH6tr/QjeTycVDQjAEGE7vQBhA3gs9jsRnjSb/NWz64xhTCEFLJVAWQ2oAtJ12XiT12rrkxfvmn9OfSnBrgJAZM/DfuessS79qWON68rNki6ubU6V+3qYMfJvDlopuWmKd7EQkOF/Hz1H40kWyQmYOcnDI7Ukvlz4RuCQTgQISoVyudxTrnhN0o0ZTJuTR5YvYPbetdKTe4WxY9yZhTu3gPOwew97f8RwOQalbYhx4gsX+MXPKOmqLVljoB2Sj6alQGxkLPa+/wTyMTFjjD0nUIYrB8bA74aghHewHa4jNOjK6ejHEJkTYME9mReW5xNRnjUrWwNIOlkDWZ4ERVq0/EMkeyb+O2cVpHqmZJLGdyqZS2jupCN7qr8NNPfH9qO5v9XebxFeW90r6EIwwwfIwpayCtn+Ax2UmepkIRPxVJhuoTY0pAa+lMnwlYK0U3ZqzWuxxVpiTAJWPOVsietm5shAmK+ewBlNagaedtINF8vqZu3yA2CCZ6rMs0feemKqEFhkJgAmADdjAG5g4QuvQAQLMIGW1MZk6FPx4rucWUTt43u6TfOB5mYIixLPQblrLPL5I8GvOUaDZC8xJ0ZXgmEhc0nKkzCApuV0kTkWKVGv+lx0UhOU+cNBE8Q5awFv8rw+oc/ZeK4xj1g/pz2CwDoCWLguoYAzxe90jcxDtxRwlzkLOcMtu479zp9VA7O047FJiD0m1+W0ngpQjADNTkAmfC+qXKgLFXuJBL4eVgb7DZITMHOSh0Kq3rGKF4BAmaQ8X46gIwr9XPK1axRvJwptoLLmm/VRjMwlAIoB/M5gvD1gvB3u2z3lYO/HcBhKHGenDYo2g6XMiNVtbDW/YcCqjIQlirrGkNHavXUC4qKOdtnGIxylev8yKN1A7nE0JjBnhsp8q9kUK15Ry7BdmptDu/7GgjJLxfk0rzK22lgBdSpjrOgP71OIG5XXuqfWn93KIRtjc+83+y4997Q2amXytdO7xvg6YD3xBqHPGBiSlds7t7k3WhqVnWI84ClHRGN9LfZPDs6k9tB3yPZT2YcqW6SHrSCTNx8oTbZMZT2h/5vgTFfdKLz7APJcG6x91XHY4zGnz10ObhRSMxLhcjAjHajk4X0AYeTRxhhsAGw4OGNjaFPFyZXAKI/MeOVMnuLUKE2ScZsb8SF8kFuWPjeSaR7VwBguGpiRwAAq10PmsZk9xVJjHPCqWjqQrefsyvQWvgZydgoYYE8nX3kPnA3wdpjGqkPW/2FtsBmgkJquAUNAqS8UzxLBQGJhaWBFfOYkM3Nv8Wl7WphlDWABezdZyLAv6+X7TSt3ZVaM0m4CHfmpVDPlbMHu7wkxPclx5QTMnOThE6kM0Wc2alzcE+T9RMf1PubNGODPZs7a20DUjUj5HkC+OCavx7ThkjSBhUOlZlREsMhH2rzbBXBrPLcYz4DLRyyGxwYM925huDfC7kW7med1ti4m1f45pmxRB1fiDjzNQRN1Y+Uijzmlr7kSF5kyZj9Ox6imGwz8EOeItV1jbUtQpitJdrXMw9p0XTLL1rAG8GSsBcaaHwzMaGEvXWJAFTkJCoVQat65ETJdNq1FrYTfqZge1k+nUl2UoybcLY0Cb5CSvidQxqPb2O4aa9LY7kkwrEkrRKChnGfvwnnAeJg4NooqasVwZoRsD6AbkhooI9vMDTC5vmt9w427A2Xu+O5jhCg38yFx4XNDPm8NXNBA8XgsNTFjMmYKD9OGaJMxagJiv4v9zxP/pjZFY9RFEBIe3vvAxNgNIZmsBs5IgM6VAJo3zMRPJ1jl7Zd/07gPc9zGPjWhAh72xdsg+4IBE1OdvrwmFBIdezGPjWHj2ZgyKa865nIwtAskXsAIIZDGOExMn1ZYpPdlTpMsGXBHfelZUB33Oetlfm70rpvdOQk1loycZy3h80ADg/hzKyygqt4v+4uxjHokyznUIYv0nyPoqSepywmYOcnDJXIDrW3GJKS8jES1dsDZUAI7R5RWgrdMyHO9gbK6ZVypNwb+zGK8NcANJnuWi0cN7j/bYLwF2Avg1nt2eORdI269b4S9cDlAc8jiv9GGMdsnh+bw4HKTNjkfT2kgLxoQlLIzYaDFRJCISRe9mVWtlgMgfLw1QJnFIoz1pYybraQbPBXPLhXfHGQKOQO8AfyZxf6RAfvbFsYDw9MOZ0/sMewvU0gJvw9AUiBVZdEqnd5aH0Viy8kj3vH+FE+1BNOq/Ta31vM2gdq/nUXueXsXAD5S1D7qCdPV7vc+OzWtfV8MF6Fu5OMthh/Ukvtm9WqgmAx7VNlatGe321hcr92jgUeinXOOkS1kLteDoTwujL2lJvQkEeBKMadMBCOAAqDJrpF6RJPdEMsyrDzjAW9jiFHQnzhAY5wHdsMEbhjTZ/hyloAzSDlm+LHhAwObCDA2JoQVpVODYojRxnM8kzSWkddBLBqDWSZejeGRrXk1pq3jc0EUwNfgUOIUbhWZKilpf2SKB3Zk1AGMgT8bloecx3ZpzI3qfnuILsXDyCq6QnoPB+pbWciUMqeyvTR+xv9X1xs+7xTwJpTH/lAA8F7H2IPqlPpglBMwc5KHQgoadvaln5gAIhwD1gCjKzPsXxEok5rYqo5vzGxxVxM5dsgqRVRRMIgl489sYMfctoAB7IWP3ntgvG1w70Md/LMv4PcW4//vDGdPWZy/fwwe/KiYdud7iLL5xtITYsC/bwAGN3rTsxVFNXmNXHi23QB/+yx9R3PHR1DG73SmDDecZxO0tvr7AMBLBQCkEXLF8/sqxBvA3Row3ra4vDvg8pFguJ3vDHb3xnC61uUUmhbi1xEANmcKr7k3iOuiKY3uWAZdl6TT8JgVBZRpX18vg4xQCusJtpqiXHMRivzSUKwlz90P1GFVOJOUWaq6R+jPIY4Rnm+CgLYaA0oz9lO4DUt0G++XOVZSO5T3U+1T9d1Dt8d7mQZHlhQ+kdi78X9jwvoKlldCOZCgasQBU5JczqBRwilSaHFmQOrrJAeLUq6XaEwa54JDi0LDnQfcHt45mLNdeBYjMtjwcA/NoI31ee+B0cAYl7P8PIEu1AEUUmJUwKoKdkm2TGxHwTCSY28woR96mBYrAAF1D2sxzFp18Bw1jNWDnTi9zuVzblUi857w2FY7BaijSdEvSnitKhqInNUvr2efM9A/JcqOkuV8UfqrqQ/1sGJqIaIF06yspyfMeJGcwpquRE7AzEkeaHnpp317qQBK4aAM90oNJniqSJEBppjXq5AmzbWykNLiTwZ0zz2KHLRIR0XanQ/Y3xngbkUF3nmYPVLIxHDhsXvKY/eEwcWtsNTYC4PhwmG4HxJCzsVUJ+kBTa5zw2h5HKUIRgEgjI7Gs1bDRlrJhHs+MzEB39kQFJLBJI9a8KQ7BNStTNy8JjHtnOHao1zU6q0qQBuFRRwqxzD8KNeUGT3M3mO4cPDWwg3I850whS55nY1n/cMaZ80U305hOYxVs4hx1/0gCzpHJDoOf/gJWIAwcHxM1gk/sVpasgYc7LmFzVc5VnleiCIEI9XB3tdWe1VcP433AWyPoFwCZoAS7KB21gw4BcRLdUEZPwsfRc2LI+pdDQweUbLcHxyU2Y/AbkiOCs/Aj0xYv9fyZqVgIMPmtyxj7xIY5BkoIxPvJgDX20lvAlLi4JSHJoaHexNCJ1OYuIl5ZRLDxDGjN7BLAAUMIbEIxjBHQLL9MnxugJD/I50eFb+XpwZmyVkrc0g7eYiBOMkILtgyyMN717J/WwCFdCIulda6QXpAR06rtc6oQ8Lti/Cj9EX9eTTJ9oXa2iWBQpKBVV1hxVBbF6UrqEi6V5xsV5NDdftQ17Q/zYbGn2RzOQEzJ3nwhdNlufDYUb6Qc3Tbsm2VGAGdMbUHy5IFLirJvd6EVhLO1c/FDCE/GOzvDLh4fMD+tsFw3+PW+x2Gew52H+O69x7GDTDjgIv37gAPnH/A4+zJSggTq0P9Du1n21JmabdA3rZew39OmZoBZYq2aUmIZX4PDfzJvo+K/C5SwbnilowyU4QjGI9cWVDKTZIBOb4JRvYCPUuu7VLirlHUd0rSs07EfFPD3sHet9g9ZXF2buF2wXgzewe/s0iZzYVCGeq1cLtJG+d5WzxR4XsMht42S6l4G2vMq9Q+Alla88+TIc8efaXRro3rYo5pzz8DHmcAEmOpGCqf5eVI+13FyJJMlN5nJS+539kpLNUiP267J18QCWP51NbTAlgDCoBrtv0SoOl43mOGMjb3YWLKkE5CwMMZnWpoJ7aC2PObxiSJNaH7aAwOzMKmd0csVbCxReFU5PSxwiB1LoToeATwA3E5oZAjAmjGMdOpKCcNHzSpbmdASIkB4nUsJIljMTub/c0BpDRfRhcAxjiG/dmQPwNdH/etwExatjdoOZISSMjfV2uvn3MkHcnJlBIkQ4AInEkzQB17LVnDwk7zrxWChOl7CVpnIsNtO9g+HDSR4VqmqkAr+yb0eb6WrdJk+4p2HFsXvtHs74dYTsDMSR5IeemLX10qYyRJufNZ7La8vqS36srQVYqq0AkPSeYBV6TV9lXPxY0Pa+B3IcGvu2Uwnhu4Ie7lI2D3DubSAR4YRpc8sMOFhd17nD/hsHtynBSBllwzMl+8i4bh6Q0qnrf5Dt/Mq6swcUIF8TM6JlgZPOkZjQEodIW8RiN0wJIUpN4xJU+uYMJBp81FeIBvohzkYQUprfH3yxF+dLCX7BSiCJZO65tc+1Aa+cyLnqQn5E9rm6wnlV8X6hMCZ3JF17C+YqBB+iS0XQ+3Yb8vfBb5ntSTf2bySpBk3l/unW+FRvQmqNTa1nrWFMKLuL7H/h2n9qigTO0dak4Qpc4CXONFz6yL2eljsm7t1pmkv0v3xrXGaAJFGNvID3FVFl76Fhtm1nFQW0viGEvgD70jGxh0Jp6YkwASvmbwMsDui+FNxsScM85PoD2xZmj/4aCjl+hYDEmitSrWkeomwCay/QyfL9SmMbCAjInHW1sF4I3g3ZQY2evjVI5B5fuULHdgsaBzoAz1A+oOjM2lwsRJez2NCfbONVm9R8/1pShb3TeETt88eQ19c7rYe2Mf9bBcjpafis+vBWBQkrV5e05smBshJ2DmJA+utCiZfAHvNXxvCCijScaW8T4lKy6va5e9+NlE/L/fGezv7HB518KdGdhLj+E+sLvnQjLf/WQkeRvoSLunQ2LA4b7H7uk97P2xvgEoniTe9tlY3BbbYE7pYUZnNca7pwxZb0MK40MzfGvU5kpbvPB0ZnTaFWEl/Ph43RholLGG/bGlcA9bdqpHfpl819fuKWokwjZDtJuYl9B4NxmjLBrTkwFkfLiewlPEO/MjyvdbM3AbMhum1vhOA2D4d0kSKBL+NMnTP81Pw9qutal+pLA+f/U2RfDCM2CI507h5XGRc4CDMgqzK62/C0CZrB/m5hwHmaIRTIwFS3kn4tqRedZn9l4OytQo/lwOAajTes3euwwPVZNuAvlzNBJtFgZZZL6E+0SDbLkopnvAQBFgMUO3dx8ohLFlUr0MHAqf0dfMGGTAiPE+Hhc89V8W3rSLsJEfAvuF9BTJXqbPB9tmdUlAiH1etmEIa1zGpInJ7Hk4k8gPI8GZufCTaW5heh4X1uMsk05rDWfvwXik/vc9OsZaaQGTxJSh39HYI1vzVAPvuDSYq9nY1MSL9w3kQKYod/Ee3lonGVCyCIxZyCLVGHGLcvRwOYEsD6ycgJmTPFDy0v/t1dMfdIzjnBdcQZ8zZbeiQF61NEMzDJKXZ1I8+8qVXoglCz33Snpr4AaL8bbBxaMhjvrWBxzOnnDhGOz74+TJiCAODGAvHexlZNOIk5gyA2bGo9lqZzV04ABR+2nDXDc9uVaWKmmcTp3edfSKpsSnDSn6u2WAkTInjeYV47Imx5iPc6DMVUlm8NUAPfH38z/jLu4+q9y2P+6LnnVQW97y0++DO4unbaltXdBJCqhRTRTLxtai9zBnPPFLC08tQmiW9+XaMUerB3J2iY3efW5kyeu4KMZ+RtEHfd458Bte1MWgDC825gkz0ZinHEZaXfU9yyghAlO90/HFh4EyWhvUY7w5k1aIt2a5QTxO4UAYWVkmvlQ5trkeQuEi4hmOrn/wMcZyiKV28f+RjwsKczJ7l+autxaG8pElIN8A3sLsIeYWATsi6TCFujn2t2Tp0LLE1wwl94z3QDrK24d8W4jHWYfcaDaATymkxwFjBGdoUeHJcgnAaQkHTE3fOMryAHH21Ox94n2o7dE/b66VCphRBTLpb6292ue+HAM0R7I+0OqRgAuxeOnvJSySTjlIH+hiSE+/b8JuPyXjfejkBMyc5MGVuVMqYhhG2gx2ptjYvDGhnKFWyPUIV9K4d62mJIfr9HJWCTM+SMH2QwBbxjMTTsrcA8M9j90Tlxju7YP30ALufAd/FvJVGOcDYBPDryjPQyGKcbTYM1Fhmqh1HHMzmwFnvKL4LgJoKuXznCBZPhr4qKwCs7k4svLq33HPjudz0HlAxjYdAJC1lJja+DB8LtMzs7h5EBCiGW2GjXtezIhNZFYpawCUZoAKymwhn/DnHsev//sngf0SWkYps2wZ2c9CkZ9VRmVOEvGdKtxzTWAKNcUj5c7JnwPZPDEwGYCWhYFoXcauqx3XnAkPyajtafKUkLl+6AldyhoW/xt9qIIYITKX1pxI4IGHWCZGYue61yO8DA7y0Pym9qfP2d6v9XXl9JYMOCEDUQIyok1GLiT0dZZzCwmoSOMM6A8bXLKvMWYMtTMBIlzEsdwpdMhhAlZ2wzQWKe8RkEImvTEwg01zPLGXJRDR0OMyHS21TTHe+dpiI/A6IrSTQpu8B3YeHkMAaqbtkrU7zkMC6kY/lY/amh27shdMhVgDFjA81PmiMHPUPU2wVWb39waQmT6Xaxbrq7yNSvtHn79LcU1KSK2td517RsHymbmvBTJr98yyI0mkTpvmRF7mGkb7oXIlgPBJFskJmDnJAyEvffGrs805Sx6nJW9jm3W2GfAEimAb/w0Q1Wiz06ZqHGBGVx773VHeGknsCxsUWD8YjOehA8+fCCe/DPdYvph4IkFS8CP1PZzW5Kbn6aH3F21pfCnBlx7DZClYsCK3BgkHTKYPO+qqbbric/WoWVaHAdJgMN6XbcnK6t+ok8dcftHIJUPSAyyWXvC8jZo8/zPu4pFnb7+t/dd/9772BTNjbo4WX3wmjUPGlAOAt/+798B7hxf+uQ8BALzt370bflSMg5qRH6+zO4sXvuSx2HaouZ+6jOcNFMRuUCaCxV3rWyPJNDcMTeVazQNMbZgNuYLoO14+U8y7Q223kpl3RWu2DNFqMjrTzTMvMTMecwBl1Rgq1ogGwMYNP4Wt5bnxVNlfC9bQoLTZIQcqlD7JDLQD3n+xVs86BVDOHQl0AGWbyUgeDOAHwEf2SUxUTKdL0bXeWpidhae+AOt3bvD7Kc8LZx+FZ/IxLNMkoCc841ynTEa0MSYkPx7DqVeGmD7eJGM/jOupTcZPWdjSmJ9jjgJKONuMnsPG2GrDuKL7JEbOirGlMfionaHwfD5lv2tjiQkB1XnyZ6o3B4LSu+I6fmsuFZVVgKXGGqWxAA9itVRA3i6Ae6GsBbtPoMzNkxMwc5IbK0WCX35yQJQpPjh+IGiT2YbO/7c+p87i5ixQHJTJWBASlNHu2UI4Vd8gsGAGi/FWCGOCMTh7csTuqTHklXE+nJiAsDlMCUdDLpxmot8OsGPTWOE10jIYZgxynjA5hD1EenVr8+zqE+490i6YDKqirbNl17/rBvtWvINeQKjFlDkGKAMAL3rZ43jLG96nM2dkws1KOAyXLHypV9iYcZd5QxyldPbpg3gPSoWaGSSeK47OF6EnUwWVTu+lbm8APqS5ZJaVmQA9/k8MbQAQjw2uDSr9+bw1ed4KkhYgWfuOe55bouVT4MVIA73WhuI+9hkHY5Ry5uZnlQ3JmE7cMDtEmmXwfCpa3/aAJTXjSQNt+ByzPgdnEjvDlMBEiyU1s4ZmrEjt3ct3LZhLWb6gonAxJihsy5hw0pHQwTD6kM8FCN9H1grMlPcl+ARssDpGl/VZ1gLvS6NcMJ1n20upbaxlgE88bWr0wM5DnrwTkvgaeLhwDLhRyiZhzihPL28pwCKBQfqzBa6JdytBRJ6jxjuvjlE+brhU264+P5URARYFNCu+i/p7Mxxrbl2geamBLpUxkInIIzSvv7Wbk4mcdzVQZm35JFccuqSG857kqHICZk5y7fKFn/KqXDlsULmLZL4Rgc/AGSmUmI68HpLOe0MYM4ACylCuFgC4DIqFpEdvGsKUypxArATK3ArKit0HcIEDDMUJGSxHQZEQEzgOIHMsOTAhn7cG460B3hrYCwc7jukNForJLHNoAs0Kg5sxZTgoUyh9nWF7TeP3SHOG2nro+H3bG98PN5aFtMIENNqz2Rl83J99bLonAR8cABbjQ4ZJ1eqvCU9UWvOoW1uC0LHN1Th85kn2QzRY+JqpGKNqnpIW+DA3r9eOGzsB1AASgNCUFDYT34PzMBTmEMcZ5ZrwoylPK6O+JEWeAeV+Z+GHMJ+L99MAP7I6mOc5M2KysA1RUE//LQB2s/VH3rYQXJ1dr+l7WeyWhoZsM/fO0/iXgFoLaNFkyRieA3f4dQvnxuw6qb2/Wl+32lkDQvh3FkgxrVzPMj5eYiagypmQqFcrN2ORmCmMBXKs+vy9EUtHaW9Idm7zci7H4Jzje+joAUTGzA7haHCjjGsCGp0HBlskUp9ljFq2CjCALAtja4FrTKea2o0yb1GFsVMbN1VGh9QzmFQTq9OPAwwlt4bQ0TWQRozD6umB9H8GvnAgxBfz2mtzrMKoXCoZeHEI+7tVLtBcK7vD4bde10+yuZyAmZPcHNGAFam8ygU3LuYJnJG3mwBjyE2+6hm+RlFBGcsYKIry1APKLFpYRW4ZWMCdGYx3LMbzcArT7imHgRkkReJIUhiiMZS14UCQ49pkbjObC3VyHjAA5QeqhjhQWUzUJMHGlAoWTQsByjSbPRg4upFt3JT3IB17SsovKVkUsWZN1tyUxya1vV2/Jq0294KQbvSB3VIoZ/ECDbSBaL8BfK+Wpozrany7SLhaTVQ6xqNYyUhhgJofTDBwNNHWicHAD3Za97wvLDsjFN2wprLn56yHVm4v3pRa91UYC7W8O1meLeeRsTpqwuZkUW5cn7wB3M7CjtGDLsGcStsp51bBMJHVcCCV2sTzVhBw4H12WZGcPtbL27BYxLiTvwMdfarIorxAK4yeWakZwpw5wQ08GkuSvcK/WyBqAuchL6dq9LJjmhcl+6yN6zlZki+IGdehLnE96V0J8KL2sbL5PUS0iSwaz/uLGBhg70q+C21sMlZSaIMJ5RuXlR3AuAAOmXEMTqXdAJwNcR4bhJPtfGDAWEzjReyLyfiO4zrsGz7vW4UtkecSiWsZ2FqgiaYvybE+KH09I3x9qyb8bZXHUgKoqQAIlPF+ejRn8rEh8svI/bCYs5Xye6SaT4rJoc4gKqMnxHWVyDyD2ue95WzNKj/JpnICZk5yrfKFn/Kq/AMNneeouPcwIyXuY5uaMF4z5VNsXA8EAhx0hWBQGQMbabizuSpcJbluj5DiTmDQENgy7sxif9vA7Qx29/ITmCSDwxtMOQoWLP4PfAIy+axMoTLOY7h0wCXKZJpSRHLTKu3fC+YUNw4FnTmNGaXexAY5kswqf0J68swcMk5q7cnKPJQNxL2ZFZFKaBGiSKAMN9hrQAwiwObZexeKtz+zcI/s4AYTTknbR+CHlWGs0PE0UCaNq1yB1sboJjH1IpxT5j3h19XuL56FmrR3MHYIjv4hsmZiIuDq+zMM1E9AmgLy8TYD0z5VrBOsHlZOAdBkbVCAtw5wJCvPQAVJuk6Kk83pnZM9YNpakew3N80n6ZRRQQP2d5FnQmO38D/lI5nGaVTy/gYg08w5t4FxpYGPWo6NUB81Km+sCEKqSwyFyllLEShxLoV/0fjzzgDssIZs3Ehgi5L2JoMf4bQmOkEKSIzqtG44B+wRT6Ej4DsmDM6eW4Brcd8NTJppjsdPl4d9ROZNLUk0gHw/Z/Mzy5PVKzN6YtPxwXTtqbwcWIMNfW1siFsK4Wzx1C4+B7PnQwpzyusVTHh5r60krk4FTOMh/d2Yb1swdYFtddmlLPNuOYEzN1pOwMxJrlfSaQTI44mFFyF5FXnS3kZyM4OG5+UKZdVGTe0dYl4SH8KG7J55gbZ+Hq64x7rdbsor44aYH2UMRqQZXXi2AcETzxW6ufW+Env7QIIzPZub9+Ho0Jp3ncf+C4MuHetblInJaBeMi3SJje+S3hV9PgJPvnuPuxvnY3ny3fvq6UVLWTD8u1oS4C7pmCe5J1Pcrt3Qq9BIqn0GBrE5MAZDISXINmwNMMw4keUzD+ALv+iZfW1qyMd//gxIZ8r3kQEHHTH1NakrywKUqckCJh7tHSnUMiXxQnPtyk/H81WgLIU7ZVSyeKJN7TkkOEPOBmAyPiohiL2gzNQWxOfw9ecVjLssJ5Lynltsp6NKKxSh5xSryvpQDSXkekmtvNaas9I5pPbvRuBMvVI27g7UN9JR22Skt67zAe7xEgRIfSfWQzvtgxlQxBjWxtq6EU9OPm/h46AJTI+ob3b2MwdzeVhSz7tW3y2ghNv6/Hsp5BCbm3dLc4mlBlTu4+yXCM5Uw9WMCXq/kjy4G7jlY3PJ9TNySI671jUH6bVr5zm/b8k6LMfeCcS5cjkBMye5VgnsF+ibv6R4CqU1U7w4JVZ6x66JKbMadIhKvRuCApPYJxWvdE9ca1M4KMPCp8Zzi/2dwJbxAzDcA+zlFBNNORrcWWznnlg9Xvdm13J6aO15SDYCCSBqrK6q8tJQUuZCoUKoRchDYpSQnt9+85P5sdJAOj3LXI6FQeLPBvhhAHa2MNKS8aaBMjPe5gdKHAeGG/OZvKBsDcqASxlGRaCMyBWQMf28L+Pz/XEANqACsnnuPa17y3sU16610LLnB+rAZo9oiqmP431mrqX7DWt3bEepgDNQJrIdw3oK2L3HQHMr1pnlQpDJKqOTIjENpKEapRiLFSW8yAM2IxKUKcLY+J5kyqNfs3q3lE4wHEAGylTZIEIytpQcF/wdVIADKqNW37U4Hyr5RmqSANgDdScqg0KMprrp+2nsF6Hqo4fJYisZm5SMf8nwkuVycJvYHLshgKpU1hjW1pSLhtpAjELeTWnPBkDzkq8fGeutxYZibGNN35HgCv+7x9gWLJuW5KeW5m2ZXctl2WLeqc5TEYakhVYWDCnlGebSEaiMs4VyeK7Gzgtb+V/m1jsNiFurP2u58h4SXfxBkhMwc5Jrl8LTURMtptQq348I9HT23U1gYnBFt7VpeBtP8dmZwE6JpxtNBW34MBlThpRwpBwKbhfYMkAAZYb749QWkQPHktGkhECox5gCurHxsGwEccNshjp45TNANxRj8tJUdkW8NSF0ZWcD8Dl6UPx8dl00vJOSOfqQYJqMxyEkTPTWwge0IBx/CtZulz+D3iCmJCuU9BvFlKrFcUepeUW1crxWnvQUEoXbmADI1AACIwaLBTAC7/yVJ2B24qSiOKfc2YDxkR3GO0OYu0/uI9PNZ0b2J3zeowCAt/7C++H3UVlWQLaULyCxeUJ9PGyxV5Gdfec81xUJB2UOXCMSaybmfko5sbKLJqM0nTZH/UbsptiXVbDIhL3I7yy8cyHpMgEaPIyJtWt63AmM6d4jO6RF2af1OwuDGyxbl/i1CyoVw3eVLH3nCijTlBoYw2XB3tsDyLTmgZoHpJZPp1cW3LcoxKpRhvEAKJSFMZ8zIIYBLUm4ww3h93R0NgtxyeYFhUYBERDiDTdTnpthmMp0LuWVScd2+3jKlA9JvhETAWfv1PlpHYy6k5YHsCazALMAYwwD9Hmem7n7MxBogSwKOZYADHeMZjcKHYQBbdnnYPevAAfXsFpkHcX3NQeaIoscD/KzNXN7K525Uc4WYV4n6ZPOFH4nOclx5Gd+/TuTN9BwZZVv4M7FI00dsB/bilMH0r61hGSuSlM6FJtMyCsZQ5goX0tSlMXzeLNss6pJ5kmN3iXu7bOjx3DfY/e0C8djj5QEzySjgcf0Z89IDJqaiOd56ISMVv4DsP6ORt/cOKX75jwYkSlz+cgO+0diYkMaJ7U6yDs4hrxBsCaAMtaGI4UHU8aH93hS2BzWjFAuV7bpk9Jdq6/nmZg0ldeYbNcPNhi3KeeQC33tXFK2PVH8rZ3i8YG832pK4AhgH/73zsDBYrRDOEJ7D+CeA+67ALztPfxl/H9Ext4J2J3RmU/UL9xgN/l3RfjHWmYLJdXMEhWzdWQjJTStWzEnVnudQpoHlEOLkhADYg7T/y5ca0cf8vpcugBqS8M0zo9q/R39uGr+VMEZVmcE6P0wnWqTrVUtw4kbHlet1CfwcAEow3WO0U8AKitrrT6h5c7iYWCt+4r2rzXcjuDw6GXHpWegPuSWB322s9mPH4YA6ER2tBl9zNEWdUH5fmR5xkRAyE7lGAM/DHnZXPi6S2tv/F+ub0UOIlsZH3FNS6K9ix72h3Php7V/sevDPbQ2+/SzWMRaXs1NI+eIdMSwuZUzhpC/K2W+HQrKUH/wn9576xWVjZrVyWksaGymY7JTtHI7wpvm+uskx5ETY+Yk1y+0GRJ7QpwMQkYj9uN0A0/2xjYAMmpyemRPG9Yh1XML1lxCMU2ZJWAkHUutMi4WN7WoJ5QzgTLElknOCudhL4PxMVx47J4aBXMn/rfPjZS59i0BsR46ScYmdIPLA5p3ule8CaFl4x0LtzMYnh6j0alfnxIaUjhNnIN+F0ECUqIVJaRrszZmij+fpVTPeKyuSkiZHZCx782AqHkxcC3+l+YOprXHANkzGwqFImWf94v0/nKl1qEM9eQMGsY68zE3lN+Fo2Pt6GBHRMMfka4fi1ijpDPpyic1c78WgpMBxZHJoh7bLWVBnpm8Hfr6mtonDS6NXZMKQ3ad2SNsVzaGTfFnyIDsvEAJfizyeM/0Qy2xsdbHKVTDIoF4+nV6XZuHMfVKxaCbXVM4YFbz+mvPpDE/6auZLnjQ9r41SVKL5MfCgVacmkPvDyaFNCWGZwx/D+cJWlAC4CI0hoEsxUk/xoQmOHZtbJe3dgqhqjE+OJNN6JocsDGIx2rLJMJA8fnBUlsfi/oXAr2iD5psR7pWAJ1ZvXyuCFYbD59bI93jUmP3yEtq47wCyFRFecfEspx1NqzNBdS6pxOQkfKgrVMPspyAmZNcv9BGbcTmwT2lMscKNxjpPsrNEFkn1QW+FtO7pMm0x5iZjQr1BV4aJYmpEq8PYUwuo7BuIpoBJCQkxgSGC4fhAhjuuXASE51ywGn9ToRaNWQJDfpGhbgslLm2a/HVSZa8bpngjfSdS/Lqi6LJ1iDjTIZUWBs95EMxh1TQRCp52vOsULSOBsp0tuX5n3EXd5+Vb48f/2cfP7j6t/7vf1T39IJ9ziUBPpVCE6gamA3ufIg5TQB7MSIPP1nZscT28T6cyJTGkVLegvedhWqQAWGQ2DKmF5QhWZPsULsflf4eGVAECaBgehfgoCeip5idsiWMlqnO2p6F3Ojh0tnfasJ8ulV2rzGJbRcYdeEaIxKJhzZ3VZ8bIS1HyMJ8KFIWM1UBZiiGk16yIkg3aTHXNmLSPCjCx3jPeCgAMhsT7cojlLOLJr3OWwtjwpxJwzc6FCSr0ERwJQkPUYrXhEMVFMXMmFRf+RC+nHtAOXcS8M6eoSfUs6GXeoN40hHS3/z7okmyO+fmz8L1Us2hxIEXIGcB8rnDgTixB64B/XibZmXt/td734IE9ABm2c9HkR7gXsiDuk49qHICZm64XF5e4s1vfjPe8Y534F3vehestXje856Hj/7oj8aLX/xiLIlpvYnyhZ/8bUg0RoiFnBuNpBwZky8qwqs1C8qQLGTILGK9NK4pYsazSjCBHRGUoWub9y2RGlMmayz9Hzy+lFsmnQplY2gGkIcwdfRnD5D1IMus4lVcn98gDbMuQ1qcqGWcx3A/AHr2onJMEjAdyQyEcXA2FMBmLS9CqFDbwbcx1Lslo0ovuK0Fmg0oQJmt5OO/5Dl42//+Ljg6RrTlfY9GwmTMy4ZO78jvbEo4a+K8DQwo5KDpBsredKqRL4CMVe+vNT7WAnQLAZqUJ2ZmX8iBZQHKZBfmAEgwrEwwRFWGDgEDetsWS+X5m4CwzC2TQu98FZSpyly/LwXaDpSaQ0BlBmjH8EqjvPFOlugDN0ZWgmEqttEL1Ax2ypmWfTmtCYEZE38fkBguWX6ajBGDsHcBEzjCAQIGllD4TZUVIeep9v6dn+pjz56OeubM7kZ/9MhRx8yShNpRMviSzw8NkDlAmjqIekNjT9He60xd+nqt6OSNZMuqHneduRQ769b64+fe9MqNG3MSKTcCmPmar/ka/OAP/uAmZX3kR34k3vnOd25S1hJ56qmn8Imf+In4rd/6rezzr/7qr8Y/+2f/bHF5v/M7v4Pv/M7vxI/92I/hAx/4gHrNH//jfxxf8RVfgW/91m/Fo48+uqbZ1ypf9Il/KzjkGNOFjlVMQskxSQYWYgHMK/YtISV8q4zmHVKLw0+nd8RNnpgymcJxqFAOGyqLQCCxwVB+GyCCMvf2sJcxvpk8qSwHDk/+2SO9z3LjlNcZSSyUufHYMBoXMxr4+DWkMPiQC2jvApjm8jGUPPkM8Ex5TQTQ+bCBaD0hdlzpe9svvR8v/NxwjPRbf+H9IflxJV7bM6CE97EZPazxeOFLnxnaMBikpJItqdHo6bv4vikJtzsPcVdTLhNlPMm2G/FdH/FNZbEcBKoBWR/moVxXo8DKJL5ZyMEAwJGhOAPKpPIwJYiO6zusqTMgWxn/amOhZ62prDOFAWHNlHNIAXSWsB3DNdxgXeBxXvu+O/dxvqYVXv9UFsq5QIZ+Qx6otXIOPGudFMNkDpBV9xDSe0T5MpSlAM6mnL1AYsG4nBEDNr6V9cwbhCTcyhqWgXbELpsZuxr7wYtnkGDgVvpc11w5ZE5ljg8FqJIsvhooo7FAGVtmaeh7U+bWxArzcOk7qYbh8qp4HUvewYGswbVyyiVzM+RGADNbyp07d66l3m/91m8tQJm18v3f//34xm/8RlxcXDSv+93f/V1813d9F370R38Ur3/96/HZn/3Zm9R/bPnCT/62oJzSwu4ABB+yHg9MImmQgK6gzimtK2J7tVj1Y7BXeH4X6aE8KPSHn3JS6ysCh3aR6utCjoqUF4H3P5OUt6IV47yldCqMh0iVoVSpO9vQNHCmttHWwEF53YxkBi0QQL0ZwzkdDwrU6eTVCm/IDt5hIHcVUxu6PDkuJczlQu8tngTnbWyI8zCXARwJNgQrZxj0BLsLAWYOymRhhcRwOMY76gFjekEDzXtJt/iOhLxbiwFiVojyO+/DBbT3OJHAUn0WA09lWcB7E1gz9O5Fwl9+0sx8W1l9K50T/KSnqgMgYxf4Vftel3FyKJNr5n4JHrSZq7Fv5bt4WI/K4O9ko/CJtSxfDmqHD5SxzUOcPAAzwBhXTj8v87/Q/DXtud4S4bgAoIDdE4A0tSUCQvH55kOdqc2Nz3rCk1YklC3WdAa6lJKDYVXwhoeRqYySjoZ1MtbUWzXwUIRQdbVnpt5ZR8icXBMgU5OHzTH3oMhDB8x86Zd+6ZXX+aY3vQl/7+/9vU3K+o7v+A688pUlVeyTPumT8IIXvAAA8I53vAO/+qu/mr77nd/5HbzsZS/DL/7iL+LTPu3TNmnHMcVcRs2UwpfGEbgok62Z3TAdociO7k3U0ZkwkFSOtrgcuNhtDcp4G5K2wiCGDDEFZQF7oUUj5h79dG26Phge3oTjsf1gMNxzMPuwsYdwCaZtkAd1jQF4iAcHuBJAhv+t9nkNHJrzANVyGx3I3EpGFiV2FUwmVTEZTD6FpAdsrQIlZcZwrHqtDyizVc/B10lAldrtMR2/zPrdDxZmmKw6d3sHXLhpfteMEB7SBGTAk9ZGe+nYKW6KsbXxnJt9X9rzpJsnAycBTBxYFMnEVwtnp1WYahmLUF6L+JzOw1sfkmJ7dkBvXLvDrwYp4acB6Ehz43zI27SzADtmOwvHILaOVxKhchFGTvaVtlbNnvaidHIE+yg0Di52j4+JTGXZcmywfERJrpO235AuA0wzxhvlPTCGjPZOVr6nnrwyi+tJp/dgmg8SADUmhJ7BhrBc7wPry8Y5hYpeGPUWrmPROkTt42FUmXAd1U1rHAEvGGwWFnhVshi4Ue4tv8h1bXW9kAyZAsDxyfFTyy3TBPMX6pe1cbeFnqGxZABss75dESgzB5hKMHCzNAon6ZYbAcx8z/d8D1796lcvvu8//+f/jJe//OXpb2MMvvZrv3bDls3LxcUFvu7rvg4uht88+uij1dCjOfnJn/xJvOpVr8o+e8lLXoJ/8A/+AT7mYz4m+/ztb387XvGKV+AXfuEXAIRQqi/+4i/Gr/3ar+HDPuzDVtV/FfKFn/xtkRlDbgMPjA7m4hKUvyTRvgmMGQzS8ShDAGcydJ6j8Es9/9SWK2BhJFFAGX9m4c5tMKjvsWS6a1B9pT5JrQ0FslApkRSS8i14a8LxlbwtjrExOvIxVDezmTZfqzK/xgs9x5SZe54lieD4tc6HI5mTQgbxLpXySMFd4WlfJY26uDeR/p4ta6ZMOVfmlIqcwl4Ra3KwIM5dMtzDmgTQRX5nYzJeC9yaLO3xkR2McbCXI8xlfmQ2GRRdwsEMMjIcWzuOlTwQnWtPx3PkoAzy8EhguzVgrpwKvX3u/sAwjPvRfgLj6GRAQ5QppT5vzJTjKRXI3v9c/ykMnYOFktAPFn4Xxnt4BgXgWsE8PYp05xHqGLcL18VWjpWbbshoTpzZPXvjPbkFZJGOZwCW84cDg5gMfBsLovDvESlEXmMxJIZvbS+J4zyBMzVAgn6szfWswQS9lgE/6tirzKGlQJdkg60eexXwPH6pX+89ipOXUAHEZNm1UDFtPebgTc2JgfnnXwTQMEdmC9xfJXJeybGw4VxbAkYtDVk9yfZyI4CZ5zznOXjOc56z+L6/83f+Tvb3533e5+GjPuqjtmpWl7zmNa/BW9/6VgAhv83LX/5yfM/3fM/ici4vL/HX/tpfg2cL0Zd8yZfgx3/8x7Hbla/pYz/2Y/GzP/uz+NIv/VL85E/+JADgXe96F1796lfjH/2jf7Tyaa5IbAzgJlBmPwJjzGFiw+JkvIXfjzA7xCMRgez43hHbGpVXBQJoyXfPLMZbA/yAeIJH7snRpMqMESBMuFgpgIxIqst4wFjGtEBgy1gEltLI2kTSiOGvCm0+LaCBvlsKzhwI5mTPN8d8aYhMBtcttfZr5dSudYxtoHjtihh6oKkYaVRq/v1WIU0y78PRvY29QOyccjkY+NHDep/nGBgs/JnF/vaA/d0B4yNTOReP77Bz+wDM7N10DPFgpuNflXr1sIv4Xxy7VxH602XcRlGV4NrcIuMljt3rFt3oZu84AurjuYUZPQbnwvpNjgWQxzGCNmZaW/wAGG8QY9/yNVvJ9TRVGssYWSgVY9csNso0QyOGs7ozm1hY1TxiFbaMzNfT1Y41xs6KkOQl45fuObhMKVfpCKpILbyLfr8Ko6wGQNT6M2OZeTuxadicysJEY1689E4ZcBO+j//beG9qwxSeXWXOMEBiYvTQd+wayQYh9glM/vy9oUkbS7E21/QBJSk2zXHVUaoxY0gYIJY5JkQIWNEeB4AYODPPtGTeauNNBSdXhofNyrHKXShXonudZFYe2KjZp59+Gj/6oz+affZ1X/d1V9qGX/3VX8V3fdd3pb+/7/u+D3fv3l1V1g//8A/jv//3/57+/tAP/VC89rWvVUEZkt1uhx/4gR/Ah3zIh6TPvv/7vx+/+Zu/uaoNx5Yv/ORvA0CghJk8FtnCOyUrhXPAfgyLPmfEUBlMrjQXgSYENmg/QuSJSCHpL8J+c+nyZ6k8l6rQDBbubIC7PWC8s4O7PcCfxxOUpIciGgyTQRc91RGAsftwEpO5dJPyERV0Mzpdoe9s50HMkWPcBwHKRLlSb8FSo0QDsog5Mbqu48sXsUi4osmlBxytKWfyMuGpme3/RpmZkTFUfoyvfpfutfnvdB8pUWYvQsYGC382wO8s3GBjSAiSoQ6w3+P6ZzoAFS1EJVsDPWOZxHUn+34jha+qtPWsv9r7YmwZKufK1nKuCNc8tyR8fprYv0ME3h6J4NutwDLxQwwFYgzDae3kwI4NrKpdDM+lnyzMy5Ramqdjgt10XHDrGTslJaDfUfvjXiVAR7Vv2F5XOAZ627C1YbIhm2fOWKH1qnvPuAFGGFC2V30Oba85thiaRzFJOp8DBIjw8U/hSLuw/mJnq/uD2bvscAVD5WnjPI1pUYgM7Yl6axGC2dr70r36WOBhJLI9rWu6xmDrPQoAKQco2A+7lue4k6CMH6afqZF+eo9y7S0ci0pbBSt4jRR5AdnzqqkPjjlnF6yv6ncLpWeMnNgy1yc3gjGzRv7lv/yXeN/73pf+fuYzn4m/+Bf/4pXVv9/v8bVf+7XY7/cAgC/7si/Dy172Mrz5zW9eVd5P/dRPZX9/3dd9HZ71rGfN3vfsZz8bX/u1X4vv/u7vBgCM44gf+qEfwnd8x3esasdRJVHuudfDF98DSAamB8Km5wnMQbEp8E3Sw5aoOw7wALWohWsYEalB7LSOIWxmdu8iECI8LDOSYqOtgTu32D8S2Df20scfB1yWOWFSAub0Dkyk4DMPvPMgzb9q7K9htqz5/ghexmqYT03Is9vThjkv8FolV9btfDgmmYDOnvh2qnuc5hsA9dkL0OoKQ6BajIseef5n3MUjz16/zX1cPJEJAD7+86ff3/LT74PZu2xN8YOFP7dwO5vmkL10OPuAx/k9Bzw/LEy33reHuTcmIIWOJ6+djKWJHab1IxQSf41jLoTRAKBjrWtTau5kKE00cG4mTC27FtOa5SPIwQHjo4uYP+oJRVEmFhczOgbAD2GtvXx0wMUzDMwI3BoM/JMj7D7klJm87eRRxvSc5IGGVYGoZmhuMiLRt9fV1iFlDfMDG7+j7KcVe+gxDJkDwYEloQzSq/5Ba9AI0PfYoJI3CInp+SEP1k9MFyCxJ4wPmdcTe8YihGazk5oSKBAZbXllPumOBjmILtsESAfCVK4xcY7TnLQhJ1PBtmH194zBNO4afb52Xi5iR8h+iwwak9Yyk+1dGahMuj0H2Bz7jtXRnJ90WpoEq1sstyOG4h0kPW1ZEvrfKHMJE6aZeuAm9d9DLA8sMPPa1742+/sv/+W/jNu3b19Z/d/93d+N//Jf/guAAI587/d+70Hl/ft//++zv7/wC7+w+94v+qIvSsAMEECrmwbM/JWX/wM8evtDgyHoXApdyry8fNPUjL8i3jj/rnnvGpGL0lqFhHvLuXfYBLq4twZ2H0CUJRslLbakD3gDuDOL/R0LNwA7E8EtMtL8BK4UYTtxI3U7Gyjs+3FqLwNzVBF9shoAOxaTpiJaH5CsSlyoenYWtLkwGJlCpmzQ3FAI9Ozp/nrcvqLk8WPZh/w5igS12jNKujH/e+E8rBk/ayi2ZsBBoExLPuHPPY63vOF9AQg2CBMw5eeID7D3GPYOuOdh4QHcAgCcvfc+/D6+L+4RngE4uHzc5z16lOdqSeFhBLreb9Ojy3+ndea6lD+Fxp/Go4nGnQHcEEKu3GBwcdfg3nMM7AVgR4PhXkio7QYTuoaAJyB/Lh4GISQDZVptlSFvC/IsqH0cn9Htwn40C5LJ59LCaLcWaWQdANJo/fPBRONfxbS4wrmZGegM0CUgIJ1qNgLeucBu9DYDBMoj4Uv9MehGBM7MG6JZaJNloTgjAijjIHQ+Cebk5dVyEvWEll0FCJjaoc5ttgYZMf8lqCwcqXRN1udeAbJqumdW78xDaC2vjK+qbAFI9oJEnUD6kjWwJ0fRKr33JJvLAwnM/Lf/9t8KIOPrv/7rr6z+t7/97fj2b//29Pff/bt/F8997nNXl3f//n380R/9UfbZi170ou77P/ETPzH7+21vext+67d+68rz7TTFAomCvR9DXpnseyt2L88+j6CNjSi/Vn5HuES3x2+O5bBygcqOxabP6LTiC4fh/tiPoidvO/t8iCFRAGw8DST74cnoirYFpXw8t3BnBng6fkFGZ01q7W31YWszuSLvRgY49GzKnbKloqR6vWt9MrfJs+9pHmR5SZwDnZJGik4BygD9oOcRDLQlhpQd2FHFAN72S+/Pjr5uibHAx33e4wCAt/8fH8DH/pkAgrz1598HA4OP+7OBOeOHmNx3iLmZIkV+oJwx8ah5M3oYM1nh5mIPuAjikBFhW1Z4fPYRePLde9w9Atj05Lv3+hHeRUOUPuwAadQcWGItvBZQRhpQcb3LEqRjarOP4RLUzv0dg/vP9Ng9aXDrPWZaK8ngmKHbVwFvyQql36PXmZg2afy0QgEWyHT0OguNo+96izUo7j1YriiE5rqM36uWJaBM1Wg7cK/uTZKcDGiYwFajE5hosjkXD5QIYaNmMICXoZxsrpETIjJy0smfgMIKUfZczoRh8854H/8UwI/QNQxMYtSpz0/hU4LVsnXeny4QUuz3hYOE5XssGDJQfueyJNE9lUOsG6bv871lDatd7dMe/ZSkVefSeVGrt1WO4tDjMjdmZILqRXmPTnIUeSCBmde97nVZktxP+ZRPwSd/8idfSd3OOXzd130d7t+/DwD4/M//fHzN13zNQWW++93vLj575jOf2X2/du2v//qv3yhgJhknBMpw4AWYkiW6aQPzg00nMwGYwBm+WWQLdHsF6tnUzIC2pxKYjuvulMzg4UYvEJJF7h3sxQhzOfaHoIhNKOUHIPbNhcdw4WAvYtl7N/Uta0vWzl3IkWC4oeX8coOpR4mWOWoOZCJVy2/JhuDBwZ6W3uevgXLadQ0pcsaQYsU87ouElKYN+lRTQGtKfJYHh33+wpc8ll33ws/N/+4VAmWAMI89XxuIYbYzsJcRZ3CU/8Oz0DLA2Bzc8kaELTWEP+Nv/6engB1b+5ScLCnx6pL8IjOgTAbo1oC6jvdPoUuZgn9VIUxSeE6UzIjzmSHFcw6EHDIAYNLvxgcgfIiMRx/BHUsnbs15NZeAKolNE73786mkcmmNCc7m9ASUYf272Uqp7/UeH6v+GyBXlYz3KtuwKtEohRLChhCmvZ/mqwlhNWlL00BPljTbmDiHpL7nfJZbbP45TBYOabwAVSKbNR39vZv28IJJI5Jwp3BIcqLwhMFzQERj/HclwObrvWSl8JwsXB/uAWTk571rnvhMDbmZ07Xo+1o/rQGAl9yzZk3quGct009jQ92EteaDXR44YGYcR/zgD/5g9tlVJv39+3//7+OXf/mXAQB37tzBP/7H//jgMs/Pz4vP7t+/30z8K6+V8ta3vhV//s//+YPbtpmMHvD76VhsYwKNf5cHyXvDgJfdAD8M08bpwBRRcSpFDNcplOwF8vzPuIu7z9p+SvzXn33/9AdtrjZ4TYyLIUwz3vxi0wbyTchMwJS99Ng9PcLeH0PeGnbyy3Qv+z0aS+48hEEN9wOgczTFdqVn46DrhSRlp+rNOQAwYvcnZS2NYVbeknw1suyOe1LdPHwtu4AAUAAUHy5DI3jIBQcSZpgAh0rG6ukUb47MKPE5yZoM8CmJJKYEr0wZDxcL49tg6u/eviS2CYV8ughoeAhl0yfDYAtRmVOAHuuvSGZIxOSyAODHKVnm2oS/q8IxsusN0jHd1JdZBSYlT/c2hPm4MwOcAft4BPruSYOzJ4DhYro5JE9nSbjn8j5xzzuiF5+YMHNzTp4Mo17T2b8eE4hPJ7wB+ppDY06uda4CCm7FhrxGUGY16/aA9lxleNVcXdnzHxhKBiybr9mePQAeQ9L7MLq8LVoerKJAD9A8Y58ZmPb6yb+LYVVFOE5Nt9DmaAvQpnknw4k1IKLyLrQx2wqbmj7s3JsWOhdSfQvvq4YctfRibYzOjNnsRLlDQJu1IEytvZXyChZ8p/3TCq87yfXKAwfM/MzP/Ax+93d/N/19584dfPmXf/mV1P3Od74Tf/Nv/s3096te9Sq84AUvOLjcZz3rWbDWwrnJ/fX7v//73WX//u//fvHZ29/+9oPbtaWYcYRx8Vhs7yPowhgx3MNrDBBPN6EjssNC6SZKqvfhqG0gKPvDMHmSFZml8w04CigDAC/6wsfwlje+P4JTwesekiwa2HE6RacvGaFyDCnRzye7DGb0MZnwqII+QfGfFAI6hSPcNykBq8ILekCXnk3uyEkGi02f17tJ+dM78VDeG7Dq+dJRnrUyiH2W0ayVgjjLhXmgauFu2X2YuWYDWWJ0HwtUfevPvy8wZUYU44KS+6aEhFzIm6jNVwJXBqzrw5ritRboa1XFQRkOxGhMDUF5l+IT+8RkQFZq+3WJCKcqFV2k/DKUY2Y8N9jfDvftngaGe3FtNwGUSes6fyxuXPF9LAM/hZG2IauvR9J4lqDZdb4fbqzUwCEpR9o7VodCK+1ZGsqzpUjQe26treomVzwuMnBmZ+Ap/pDpzs39SeQ0STlqGBMtfI7Z9SzVJQEM2lO1XCqS6cHbq4kEgXrlyGFQXdIAnHoScM+BSU1ZosMV+/oGY/pQ4Lmj/b2ArVxnDnFm/NybXtl/8UlWywMHzLzuda/L/v7SL/3SRWE/h8hf+St/BU8++SQA4JM+6ZPwzd/8zZuUa63Fx3zMx+Btb3tb+uxNb3pTNzDzK7/yK8Vn/MSqQ+UP//AP8a53vWvRPe94xzvyD5wLhsgw5bFIYAwdbUhsGQCUW4Zokin7O5gyS7kxXGTLWADD0PZAkDS8d7/xix+AdgBRz4LNw6nsYPDxn/sM9nnlft9YZNmz8DwHqS08R8IQvLnEwAk0+rxNZAwYRHCGCEsm3Hf+gTEcAbylvlXbaGY8Pek7jXp6KP0UZZ8XyXa3UDqXMCI6JHn4oY+BQkTYU/FeNQ9UqixXLAtGjfZsC8OZehS0avuoGUcEVT/+zz6Ot7zx/ZMyz9vhGdPNoOybaGR7qeQT9Zt7QHv7be6SYxhKEpQhkaw7uly2kZg+BBhGRkaVWbGmiQcYHZ7eXQxB42PaG8S8K0igkh8CKDOGXM6w94HhPgIYE9dys5+AmixkSwIygA5ytcLcxH2tU6UWCYWt7tle1/l+pjCOxjs9NkvmJksjD8R1hQ7MJaWV1wL9xmCSIwBkefJwA5wNgfnChc+zdKOYbyy8NN09AgAxsac1ubZvFn9roAztm8oc7WaFtsB4/nsR4o7U/i4gUO5JPdK5d/UCkb3XpGft0SNJlly75Lo10mIQLg1DW9D/XE5MmZspDxQw8653vUs9Vvoq5LWvfS3e+MY3AghAyj/9p/+0O9SoRz7ncz4nA2Z+6Id+CF/xFV/Rde/rX//64rMPfOADm7XtH/7Df5glO14lHiFsyewA52BirhkPJMZLWiOkJzEegQhvpqz3TIGmk4cwDOrxoUsXn9GhyLkQMvY3Hk9ZGJ24IwEq8X87ImE1VfZGp8Kd7veYcltIw1oaADa/144O5v600R3NU9rr9UztNOXfUiGpfbdVG9eK9zgkVCOJ7AMJzvAquZHU08TW2PO+bSRuDDxpsmT+vu2NU5JfMwAf95LHAQC/8cb3VfOoFN7hncmOxnaDZQo0U+ZHB7OPZdDx1TRuClYbr4CBtGsN6q3GVUMy5kgtTEYYHCooE39SThwXEyVvYJB2JTbsuE7Nc0PPZSZgyQ+A2wE+bv3DhYe9BM6edrD3fQY6pZPOpPHFwtyKfYPq4vXz+0hYMtMs6eZacR4GtO6Laj9IlfclhmRVKvsIHxPH7N854GV56F9fnVm405HFG4SjtdMHPoQ6eYAfmQ0gP4GQHFMyfBcE6kyHKQDI9ScCbSTTlO+HCgtuFoip6EJFvy8EP7O8hrV1VwOx2N9Zfhvt3gbT70qAyB6myRUlET+G9IKiLRD1g3Utf9Dk0O38SuX1r389Li8v098f/dEfjc/5nM85er2/93u/h7/xN/5G+vubvumb8OIXv3jTOr7yK78y+/sNb3gDfvqnf3r2vp/6qZ/Cz//8zxefbwnMbCLWhPClsx1wtktx+8XpDQQGjCxsKeaW8doGygwh4ys5HTQhpP1AxSGdrGIw/URpGc0Uvx+AGohYfbqYgSu0oVQ2aPLSDvcc7H03KQkEavH6NeU/GgtZP/b0DbX70A1vaUjDBhssT+pJf28m8d2md7whOyDlFeEfGXbKDxCAG+W9NJknZIjXvH0tcGbpI5i2ArFE+P1u9Cn0yO+nL9Jn4sc55XMJYO4s/JktARznI8vCTWwDLg65BzK7WfTnDOV7+gBNUIZ7RjeT2hiYSzxLoMxgw0lG8eA9vuY328rXlq3WGSk0Bvn748/JGYkG6ThpeGB3Dzh70uP8Aw67p1xItp5CgHxxf1atn9batEYrDKSCHQDUQZme0AtF/GABa6Z3I9eAlmTv8vhG+FXLqj2hm2V0daCM9rf8jv8cIps904I5T32Z2G/0Ywk0N+EUpoHtk0Iv8soaR6xjzk5LOqkWlqQJj7Kivq2s3fl99fW9+z0tXS81Bqznc5x+if1EfdPa6xTZZJ/S5tlVM+uuoL6j7OknudHyQAEzP/ADP5D9/bVf+7UxvOW48opXvALvfe97AQAf+ZEfie/8zu/cvI7P+qzPKkCmL//yLy+OBefyS7/0S1VWjZ05fvXKZRjS8YSI7BZ/tgssGudhxhHYjxMTxtLJIg7GuWlDJGSeFFfujSWhjbBXUVyp8GfHvgKZwawqqRy4EcavVwwB9X4pdH0EAYb7DsO9cMJT+N5mSgopKhhM5t1JoQX8uVDZFNYYSQsBlwJoqF3bSrLY2b6jF0CWaAABAABJREFUKciHgH8qqFJv5GRU0o8A4BqS3rE6ZhuAjLxuhRwSwjR7f4U6ninxJGxMyz7zNhwjX5zGxkOZRLjOXDt6+rWa4JCDMmx8bam8zVL3JZAgxZIxFJL9Osr/JcOE1gybFWv1nFFafsjeT2GsAMMFsHva4+xJj7MnXADE9w7m0qUwJrXMuP9V56UvAb5Z7zaVXfuuJjTmTVxbuBGmAUMNWRr69CDIwUyZa+yLam4j9n3LwO9eS44Fmh5QVnpvAqCBRdBBd3bSf/i8IRBniCCO0D9D2SWoowp3imnXamw4H0PItXGThb1EZwBdT99v8Q5aDgTOZJdMyrnQywWgbS8rqxuwONY8PLTcDv0wc5Z19uEJyHnw5YEJZXrTm96Et7zlLenvYRgOPqa6R370R38U/+bf/Jv09/d93/fh7t27R6nrda97HT71Uz8V73nPewCEPDGf93mfhy/7si/Dy1/+cvzJP/kn4b3HO97xDvz4j/84fuRHfgR0bPiHf/iH43/+z/+Zytoy784rXvEKvPzlL190zzve8Q78hb/wF9LffDPzxsDshmmhGd2UFBgIYAIl/R3jEYMyKaI1CDtp/JwMIyXedWvqZKZUc1AGM15D7mEho8UaWOeyJJgalTw/bcqrYSzkyeEgi6y/+D1u7t6V/bapWPHuKrG+PGHuJkfotoCbmyqyryqSGUOJUZUbVCa7Pp8HRf4LZe6o0mKBbCjbztl2eVkOFPlYMQ+WtybmIIji5LzkN5l8zdqob45pAFeVOf4MDcp66l/LWYQROE8XYZu2HzkxOBdikpgR4cS7+2FPGi7DiXqJJdNImJuHrhiYwcDThigBIKaEm1pSIW4gHjAPCTzT9ovF8++61lYtB9kHsRSgTO27JeVQcTXbm8bcUDnRZqnwd7qinCJkKDm+6Jj5+ryKJbDCpO45fS6TBGdlVBwD2aXc8Jb3rF3j+H2VfDNFG2qirU1SpMOidl3rmgYQ3J0guKYrHSN8aQlbZ+XaNHsIgyYtwP4kD4w8MMDMa1/72uzvl73sZXje85531Dr/6I/+CN/0Td+U/v6yL/syvOxlLztafR/1UR+Ff/2v/zW+5Eu+BO9+97sBAM45/PAP/zB++Id/uHrfp3/6p+Orvuqr8I3f+I3psy2Bmec+97l47nOfe1gh7DSP5H2wNvw+WGTZdrnXOnoQgxIrFnK+IdSU1I1EejinkKk2kyHdbw2ctXDnNhkq3gSF38Y8FQmUkYurZWBFrU2aF7aHWsqZOppOIm9ds8kt3TAZk2dR+UruGj9M7qrNqfZLFKdeJbOjf9VTuYDw/qIS2VK+yvCYBR4tGYd+JKbMMSUDqBjTRQOzAMBcjDDWBINbZgUXa04AJOgdzCn/dVkDSnUnklwitbZqgAyQ96cNa7JxMXWycjrcVUk9NwKKF67lhDGjhzWAv3DYeaQcMylkEKRI6+uMykBiyUcLA4if2qWwldJx2guBvyKvSWKb5iDiA5eLoCNZJjdMH7jn65Q5plsa24pRfHjlsQ5yGh0KnnbcO5unRwNNvG+fiEfhhZkXIx6YQOU5IClKMk9NrUxgytNig9OxyKWozvdJR/POh3w6Rdis7uhSm1LbJxpAkoFBOvkq5c6pVbAQlGnIQXlSenLObCE9gIz2XSVUbbVoYegbyYmBc7Vyw+JddHnyySfxYz/2Y9lnV5H095u+6ZvSaUTPfvaz8b3f+71Hr/OzP/uz8eY3vxkveclLZq81xuAVr3gFfv7nfz6xbEg+7MM+7FhNXC+uVFpT7O9uCD/RkM7yxQCBThp/eDiTtyF/gSdq6lI5ZOFmSXJlews5s9jfHXD/mTs8/SED7j17wP6uhd+ZqQzKWTH6lO+lKnFz97v4/DsFWKHYX64AMCk2uLnwCq2vWnTMOWqtyuoRf9b6oKe+Wl6eLWULCnFnGVnuH9HvgS2GiZHg6Lhe+n5GoekIrVHvOZKQ8jhHWS6ea4b2yxMgAog5UMxUnyvvtcZjNzpY58AjRM25Ac4t/C0L7AzMzsAMAM4tzJkBzuPPDrCaVxHo63cR3teS6nvuGGNqiFelvc1rzdSvAGD2HvbC5XlcWtIzn64qjwcxYEYHe+GwuzdiuDfGRL8L20cGGElkhhYMJBkqUQsh4KEadGnleeUc4iETxSlhD6kspfgf0xjZMqcLLxNAH9C+4l2r84j2Gu8nvcP0OasOEXU8Ly6kvfZSSJOXc1Tmm9F+soJ8XaeTa0Kqo65TpTw68X7DWdbafSt1FP19V37vKlDpH/EOFs0LjQ29IpT9KDLXthoo0xpHvSLey6F74AmUuXp5IBgz/+Jf/Issme0f+2N/DF/8xV981Drf/va340d+5EfS33/9r/91PPXUU3jnO9/ZvI9y0ZA88cQT2T3WWvyJP/EnmmW84AUvwM/93M/hV37lV/Cv/tW/wi/90i/hf/yP/4H3vOc9eOyxx/ARH/ER+IIv+AJ85Vd+JV70ohcBAH7jN34jK+NTP/VT5x/yCuWf/MRfw//jy360/ILCmyK9NAEv3HPglQXXmAmMEQwL431+FHRNevK5aNgBb4+2CYI859PH+9sDLp4x4P7jBu48eEvOnghHVKdyKBSJjGnUFQdvDfyZDbkvANh9PCJ774JXXwBFycMqy5HF1zaDGijTe22v+PRP+NPoJw81pddTdwBVWn3GVnlzceNzouQRaSfyrSh22TX0i9HfOx97DAx9UGU2VMdPRjgXfkITl4/7gmdu1zg0ABXUDZ1Z73/HONW8zgRUafT3Fn085fziDMkxD9VsSs+cqKy5XeUvqSfKZHSGDhkQ+sPtYhjQ3k25hmoiDDCVgUl0fu5kMCbmlMDUpwpLZjapN28HvzeygdTQ1x65TuNnRubyCs0ZK8dg1dTaNMv8WFJmTWdYUfYSdoKBL8fDIXvsQuliQvXsc/zzyKzx0rsT57LKUtZCPhH1Ug9kiiFnzsXruxldfE3pYe0slKwdxPhhurm6Jx3Aoq3JwcD6nCxdw5aO5R49jDOngBx4F8L7YwlossnacpIrkQcCmJFhTF/1VV+16VHVmjz99NPZ36985Svxyle+cnE5P/ETP4Gf+ImfSH8//vjjBXhTk8/8zM/EZ37mZ3Zd+yu/8ivZ35/+6Z/e3cYrE6JgN74P8K6yGmSfTYqpjy5sQ9f0bgxzi3HaXJFwgi6AgMJnrIE/m+rYP2Kxv2PgzgzcDrAw8IPP8y+wOqbTk4DiuNkI2HCvNPYBlLHxGNoiAbLiXS36gTGAukQDQHoYMuS9yeKfuXI0/aq2ZcFmazzLxzMHJC0EP6rhbT2i5dbhZSjUZElBrx1fmZ61kl+ndTLEVEhFWe2VGUrtnHJxsEJQqbNQej2Kk90wAk+9Z49HnrX9HvPku/fqsd2zoAxbhzaRBijTbBMXNr6ojX6wE1OGWIAe2wAyxxJlfGd0f1eOZfreXrg8JEFINo4ZWFVtCgcJNcB0DpRpgdJa+5yHcWN4hkaeB1VuMChzVbJ1WNQxwqx0VpsCui9sj7p2xH2Hr1kprAniugOkFo7D27s4tDPtvfFvdiR2dg2BMoMp76Xfa+GHMczYu5CnSs0h5WeOpiYR4ZDVd1XJH9XTN9neKNa58HpFhStBmVr+mwc25LA3DE8DZID1gAyBifH33kTKsvxmHSc5utx4YOY3f/M38R/+w3/IPruKMKYHSX77t38bv/Vbv5X+/vAP/3C84AUvuMYW6fKz/9/vwBf+qVcW3kMu3pgphlYz7izbKOfCh9ai9xQWAuigDDNq5GJGhonfWZjd9OW9Z1mMBhguPIaL+Ch7D7tnfcGPBB8i8HI2THlpPGBHNzGGXTiFCR6wl8FASJsnUwRCZbF9QonPT2Aqn3FW+a4ZAq2NSXy3iPYs2iXbXwAc4vck4v6loIpkRK0xmokNtJb2TbHqhbQAKKZoVWVhe5YqwMWcady/RLGYPqgbmIXyMbrwoQAqfvs/PYlPeOnjAIC3/NIT6QhtYzw+4fMeBQD8+q88HaYugYA0//YsbIfTzIF+UCZ9l4+zfFxP/1fLaAB0VHf3u6uspzynjDuLQHlMhpvCHFpyaBig/Hup0VdhjGlru7s1YP/IgPG2DevvPY/BjWjll0m5Gagei/kwAMphoZ160pqfc6AMA3wMTB5eIRT5RSwOGmcPUOLdQ0GQrvknpGaAHiIa4Ly4/NocPZT9YCr7uzk8SfAqcIYDn1pz+XzwlA8GZT/IzzTjWtapMLiznD/EipPMGWUNT6AOrSmJ0YJug1z2TTE2qR9GEbKVrjc5cKXp6x16xqo5yPLuVHXVY6xFG5QpARnpjG2BpFVR9ualupPKkD0CA+ok83Ljc8y87nWvy/7+03/6T+NjP/Zjr6k1N1NkH91k4Opn/6/XIMXQk4Kaxd1XNnJrgMHC07HbQDKCsg1Do5ZCWdRaC2zahGKRlc2FJ1AMgEwAZdytAfs74Yfk8hEDb4GzJz1uvdfh7AmP3b0ArJg9o/pbTKDMzsKdWexvB0PAi74xe4/h3ojh6T3s/T3s5Ti13ZiQHJkfjc3BrRRyYPRwibV5U1gsLY8TXhJP35Wzh9prkAxX/vcs2CHyA62SNcws1q8SlMlYPZxVJD32yuad9Vkvfbzi5S+u4X+afMPf0qO1Jha6l8bfLGP0zbHpHeD3PvywtWocDEZrMcKE00v3Hn4M1/gR8Jce2LN792V/V5+Xg3/ymQ6hUle8p13SaAeBMpTrKoxFMaY1OTaNvLecuXET5+P+7oCnn7PDk8+1eOo5Ay4eGzCe25I1AKaAk0iPfEOydYnP94VMtixckf7nIA2m77sM+1q+igeUPXNdXmGeo+ngPEjQwW6S3kSva+qsMTQythzfs9I4ZHv0AWNnjs1TvYY/v5xTyWh2MOMY9LO9m5KXV/I7JZ22AkRtEgosQPVMevSYRl9ne6C2RgD5c9Ssx1rfKtdsoj9o69ERQlqrdS0V79OYMhG05yfsda8JFbtni/UkyQmUuRa50cDMOI54/etfn312VaDDJ3/yJ8N7v/jnVa96VVbOV3/1V2ff94Yx9cp73vMe/JN/8k/S38Mw3GhgBkAAViihGt/M5ILOQQYTw5Yi0MDp8tkC1dicloEznUa7nUKK/C54VC8fHXD/WQPuPXMCZnb3PM4/4HH+fofz9484f8Jh95TD8PQIu4+a+mAAa2N5lpVrQj4Dos5GMMvEBK/2coS5ZEmDeR+yn2KxNtGYsgYaozZ1hTHpp9YHLWkp+RJcmRW+MWpGq6b81BLpKUl0AaEsy404o2nTmGPgnaynMsZ6ErmW9yhtq0kPOKP11YFUZLWOhqxK8sfuDZXrBfSBgPnfat9WgMKQHBLwdOqxIw8YJsPECeC4JczozUP7JpBYa2s3o+EAUEOti89DiximGT8bO+qbU3Ar8/Mo0vF+vDW4fMTi3ocYPP3c8HP/8cgSMpVwSfKE05rdyEWTlHMo6wPN1Y59Lt2iXaJ5tTs97A8a+HKVYRBbJPE9ZgjTscCZqrCkwGaMee9oHnuo69la6WWHFCL3v1piWwJpiPnGkwFL8LQCwMi1s2DxkCNN3JvGVc8+3vM+WTnV8crXGH5gB9PDi8M2JADdwZ45OHdMS6/rkWtYzzK2TGRneXr35HBma0m1j2qO6Lm6ZTGV2zcFd06yWG50KNNP//RP4/d///fT348++ihe/vKXX2OLbp588zd/M/7wD/8w/f0N3/AN+IiP+IhrbFGHxDCbNO8Teh6T/0IxZBiiTOIJ90hZ8l1UbsORgiHh7fIFLJQ14+WlWOqYhNftLNzOYLxtce/xARePGQwsbOHuH47A0zH0KLbV7IPS4glgkF7y2GazD5G8ZuSeqKjgdG5Cehx4MDYor4Z+n1Qw+pLxznqsCuOT7lugsXl2Y/rM5+UcYtAJQKbWhu66ZM6QeD8gnntNwjp+j/ZdSwk5cHMnWUPT1+joxWdHMMqbbZRjE/q4txeUlNXAxJBEQwYJUeJ50lYhKsiRNZIupDZ3Ah1XGE4STtUz05HRBBjTvFjbli0U7t7rK8BXWS5Kz6SFCirz8ATDDZ14OQdhUggrL5+HPUjDpkMpL8a3sp+uNmhJ5JpzRQlegX6joYdRcYy8LmtlDkzZop3Z+kpgnxxLW4UwcCCg5QY+cPz0hGQuzjkj1+6l/cH6sJVHjfS/qqPB1Nez9EyttvWsh7LOKku81MNTG+f2pwX9t2qc9yTZXVt2Zx1zdWdr985MoIwC9NG6lOlVc+z9jnYsef7Fc+Ykm8iNBmZk0t+/9Jf+Eu7evXtQmUYsDr/4i7+Iz/3czz2ozK1kHEcMw9xRQkG89/iWb/kW/MAP/ED67CM/8iPxt//23z5W844jDJQJv1ACTjctQkN+XGFgjphoCLkAxOwdMLqgIw8Wfgegsy+z+heKHywuH9nh8tEBl3cMxlvA/hEDdwYMLH/0+fv2wNNjugdjBFxcTBYcQRIMJhmBAaiK4U7ep+tT3gaev0LLQaApVzLZ8FbKdEWxmgVlDOrghEwuqom8VzPoDzBYZQ4aCaqsAmVIojIjy1BBLSVJc/ff7PPa5t4FqtB4UpSHoo+PrYShUyldWB6AIi9MEvG5vXQwLD9UyFeDdCpauEi0r0bhZmM1A2c50Ki9Vw3QOcTIWTpXIjDtrQn5suI61XV/CzDcwtDvDumbB5G8CfvN7mmH239ksHsSgAmhqXIN5V7R5GUH2oBK4xSOdK/ihc7Wh57QxQZQmF2qNaOVR+YKQZktRBoca8CZY4I5tWddY1jJMjXmbFnRER5uzkFwBcAy3+eqRqcMNbS2ZDD2iNaHGpOEtS053ej7jvegPUexLwPt/q2wWmYP7FD2NlXvFHpDTZbmReF7tvy+m0kKHJU9k+0HI9MjiQHfGCfkvm6F420RBslTDsgyT+DM1cuNDWX6gz/4A/zbf/tvs8++/uu//ppaczXyG7/xG3jhC1+I7/7u78Zv/uZvqtfs93u88Y1vxGd+5mfie77ne9Lnt27dwg/90A/hGc94xlU1d7W84T+9WvX+GhdPuLi4hLncw+zHEAowOoDHYpJoyL3nC/QRN/iYU8adW+wfsXjqQy2e+AiDp55nsL8D7J4Gzt8/1U9e5ZDE18NcOpjLMbFgKKfMeBbKdDubAADjdFAmE0ZnTYtqbQOkclJZ9eeUfVjtU9EeNexBi8+tGMA9ouai2Sr0gQxklo8nhXwtUVq1HD41o6dVhvb3kufUwAbOyvKdm2/H+59TFHrq6WXfaJRbrf7BGlAEpbWAGWZ+WMXWeFjrYQbxKsY4d0afjoROR0PXKO6V9iVhwJbnY02+v1pc/SFjX1FOm7l3zMS6AwC7d7AXY+iDJWyZWpv5mrFEcV7z/LPe1vBuz57Y45E/vMSjv7vH3T8Ycf6BwHwscpl5xpriCUXpOx7iRB/bzpAizWBb+sy+Aj7OyRWysWqyFSAiy1mSB+1Bl2tjCFXDhxUAYaFIY7Ln2rR/cAYbAMr1l0CZGHJvRj/lm/HiB2jrBvJaIa18aXNjc9H7tNM+NBuCzJ69yKFTe9bW58cC/KiKxtwtnpevZVexrjlM778GxHNwi42VLd77EkazxmI+ydXJjWXMvP71r8d+v09/v+hFL8KnfdqnXWOLrkbe/va341u+5VvwLd/yLXjuc5+LF73oRXjOc54DIIBVv/Zrv4b3vOc92T137tzBj/3Yj+HP/Jk/cx1NXi8RWc+OCL24hLkXjy0aLIw3QGKVSGU0/m9C3Gv6ll/noIczSeZIJ4iTjoU9sxhvDdjfCcdg7+8CF497wHrcftri9v9yuPu/LoHn3wnV3RtDcwcTDDnHPa1xoxxMOoHJ7j3sZfDAk8KgemaL9k3/17z+08Xxv13YsVKyvmOI8JYV+To0ui67J2OsrK2fSdPzGEEYdx5OxIILp2eRoaX264wyqYIyM8rAFpthNaRBhGRUN+uWB5/V4Q1ulNHmTd7VL3zJY6vL/PjPr9xrDOi4bUPH1Deoxl0Gn8z3JIBHddwu7XfNc7oyCaLf2dQHiKdSHRTCNFfnAnZYlxj0rXlxvR72DsOToS3ubIA7s1N4KdXJQo6mI2YNsvAlnx8068HAp0YemqL5PQo0KfgKAH/UMJ4Wy2+hHAssqYVSPsxy7cCTHBe2Lzy6Rw56d6RHsg7yUpcEckZITwhPTWrMktq18fvZOdsThsbWUnVv4mGTGhNbtOkqhdqrAaurpGfv61i/uupvsai0fq6Nrc5Q1B7J2s11DXFk+8O+Lt4kubHAzIN00tCx5A//8A/xC7/wC81rPv7jPx7//J//c/ypP/WnrqhVG0ljwVF/55JyyrAFbWfgC9d53FQInNHKowV3yL9r5VLx1mB/OyT5vbhr4XbA7ing1ruDQX/rvR7nHwiJfdOjOAcDCx+TgxYhHyYm+rUGfsB0+ktE+Zt7XxbysMAINAi5cc4srDEY7o/x3ppHZ6UB2NOUFPphSnCGX1fj+NU2zgoLgP8vmT0Eylw+usPlI+FY3LMnHYZ7LoJlByiR7Nae074OkZ6Ej7NAXrXwOSCqXV6PQXgwRXcEnnz3Hnefvf029+R7x+zY+iyp31pFVeS2kUCplieqn12m9CfLlVW7pyXEIgthlvkR4TdeqK9FU+eM9PT96GERT8FLiegxrQ2RSZUdlU2fW1mpApRljegwgOK443kJCqCQ1s5jea6Bo4QEzOYrO1BuksHRsy6uBdPWhCRs3jfa+NAA4ivKWUQSgHzSI30+j4EsaXc4vAJ1I7vH+K60AYjtqBnlYp63xHjAHxIumo7/9hkQkNp3oBwCCmv38fHdVW5rrVo49nrnVTVHD1COHSPGwYbrdtMRxx0LrVCqkxxNbiQw88u//Mt429velv4+Pz/HV3zFV1xji65Gnve85+Gv/tW/ip/5mZ/BO9/5zua1n/Ipn4Jv+IZvwNd8zddgt7uRr7EtmqfBWuBsFxVmsTHFzzRj1jNwA6gYvA5hNVqzsMXNjUJb/C6EG9173OLyUYOzJzwe+YMRj/xBMFZ29xx2T+fZdN2tHZzHRHu3JtkE6fSl6C03Mf9x+BKwGbsmijXwMryBbdpV4XlbbEhWPN6y2AEhDEFczg3F3sS/vcq5zN9S3K/lXNEKmgNllDCrbAPnoUY2nLIy3g6nat1/psFwP/SzvWAn7PgVQBUT9ZnXMBgqz1gABUf2amlK1hbgTG/d2e/s73e+6UmY/lRT03gYDD7h8x4FALzlFz8wgb6xPxOuSiCrtl4pbVTBESB/f8ljhgno0K6T8fG167R6K8w07V5qPwcMvTUZk89oa1RLaLwvjfE/1GBTgdp6eT1AjR9zAK3IC5TlecCU54Ur4i6Azqn81tqizeXKeMu+P/ZaUHuHB7yva2d3bChLjMYHyhBakhumAiinvuHrwTWAM6ExJjC1vQ+gBA83lCFP8fq8IDava2FODWaC/L64j89j1vfVnGtzuX3ks/D1Cwg5ZrQ9dIN1ZG1C3tp93eUcAMosWpOkXlALYaqBMlqRK7u9u90aIHSSK5UbadF/1md9VkCtjyDHKpfk1a9+NV796levuvfZz342vu/7vg8A8Hu/93v4tV/7Nbzzne/Ee9/7Xuz3ezzjGc/A85//fLz4xS/G8573vA1bffXizXQqEyW6BRCo8YNBSuxLmwMdUSg2rGKjpBMuYrlc6fYeMF5sgsrmbwcDBw8gAhGUkNeERJc4t/C3DMxZ2LfP73s88t497D0GxngPy1g44y2LEQa7eyOMC20IiviUv8QPgNuFkCIbDcxEk5d5ClI/sgWX+lAxHqQRnCUfIyPeGFSgj+w+1ZBZ6CnVQpK0sgtvqaZkrNhkyQD3JgBtfjcde+52BuMti/0dYLyD9L5Cg/Q+ypgOM2tM9Xs+FlvK1A1lJMgxxpWnVtjdoTLLvKmcOFYtywOGvWPvmMHgARgPQ0AxB0cbbL/ZZyXg16A07MV1Xeyw1nXa55XxpnomrQmhpQDsSPkWGmW32qn93Xv/AfNg6uvWNQ1llsApYGIKAaCQobR3WUUJ58wVuqditC1VjpvjrALKbB7OdEPXp+uWBw2Q6W7L0vfdyAkyFxZ71NA7JolBE/6a9neuazaAeL3QHOQJ5eVzv2Dd8bWiw3aRa9ZsfzX2iUwf8z6AVangmzFQV42HLUCZ3ndP4azAdMS4BrSplbH94brkEAbwSVbLjQRmThLYMw86+LJKaOEyPoAxdNyoVGbBvBd84bDTppY2lkQnH5BYM5q3OcrHf+7CBMrPtMBHtaeSjSeVJK+yIeMgACR+Z+DODNwOsHtmMXjEPkDJ0uCbagWU4ULUVjoFCg4we4/dfsRw4VLb+Ias5YLpZs7MScKFFpanMUuWet4Rn+Xc4uLRM+zvTPRgtzPpx14C9jKMGb+z8HsP43IlaS7vTev7gjUkwRntGUkqSlWm7M54yHtD39bQ4OX9VyETqDrVuSxEC4BFBqoSGMfnB1j4Tn7/8tjvIv+QV8ZDLXRpy9ARYTCpz2EnANPEXFlTMtsVoMxNEI2ZZ6b/NUOHAHUA4YhwBpxTaFexRlRO6JoumqjjXaG+QtT3xQ26BQr2KoNnY0Dm2GyZLUKkrgoo6JG17IPrkMzA7WQX8hDktWDDEkngzIByPjrmUJw7QoXmIOmy8Zln8+XNnNRmGB5etJv1r4HJQpqqTGXeXgCwPuS+SknK3fTdCmNdc9pkz7KgyIPG+Iow4KliPwFsYj0v9A26jo/xqB9kjGYeMgas6ttDRdWVToDMtckJmDnJtQoZ+cUmkRYF5j3Yic1MblytjcaHo0u9tTlrhoytEXjyPXvcfdYR8lG8b4Qbg3eZn+BBizQp+eNZMHgwengKE2gh6lHUZGhzG0/cGOxlPNnogNwpmoJRTe7bKKM4XalXamEZCl06GVyDBazBeGZx8ZjFxTMCCBO+Ayjpsr0MJ2wNF2X/zD336kTFJBqzYAmDorP+mgFUVX6qc7Vd/lUYDIck+a2JN2AKlU/ASWFc9IIyXEGW1xMoowGNa+fEQinGgwj1kzT9LPFtT7uuOERBrT/KBEBPlywZp8ZjOh6ds2Y4GMJBGcP6koQlBNYrWTZx1DCmhXLdxn3GHOhwOhyzHbV6b1qYVU/Oka3KOkQK1kHFK8/7flFfN3SAVSL1S4dSX23dq+yXEqitzlnZL4JtYcYjvSvp7CRwpparcUaOnU9usSxJ5isAlKST+8ByDx82HoDed+uaFgiX7Ruzzd5GrnHNPckJmDnJNYrXlFQSC8AZGD8CFIoQw4oATCgzW0BSUjLmzZAGvxk9vPFlXK81+O3/+BSw01cifz5gf2fAxaNDYFc44OxJh7OnHIb7I4xiuJOMZ0Nop4PIJRHbb6IX1rIEa7T5jz5XUrkw402tucqo8LFfEJLZYgMlk3ebV4CWudvltbHt1Y2hlYdmJnzJ7SzcrQHjuYU7N3BDnpfH0Aa897AjcPaUw+6pkPjXVELK5h+QGqF/nfUXzwOkMWqkVN7zKqUWM5vxbJhW25A5SvLOYyf5jcinsSYm72ZAxFIPIoEcFApDoHFtjlfur8qRAI8pv1ZcU+O6tAiU0dp4CINmLcDjfAgjVc+t7xfKL5TeHT+1pSGFl50bb3NjYIZaftVgwVEZI+xZryvp73UZJsdIeNzLjDymVOtPLJL82tr13eNuBTMiD/mmL03M/afnOewKO6E1h+a7vIfvJQvWAy1HTTXfTK0YbWzwdnI2xwZMioPG2ZagW5Ri/6VnVwEZdl0t/w7JYMLlNceNYfcL0I0+u4o1qCfU/KYB0Q+znICZk1yPKKFJScQCyRMiBmClvVLxMBwvF7vaveRl2Yd7s/ACYzDC4PLc4t5dg/GWwfkTHuaeB+47+H1cvOXC5cP9xnmk3BGGXRdW7OQ5t6OHdyF0ZmkyTdknhfJAfUK01oE2Hqh9IgGBWp8Xn8ewjy5wZslC3zDg0qYqvE8pkatobzhxKQAz8B5nTzmcPTUpe34wcAMw3AfsHiH5Lwvb4KEm8vl7ACmNStxMat1Z7nRtqdT2brKLlYDi+WcuP5Ih99tvfhJ2jlIupaJgp/xD1sLBJJB48pjSu5/uqYqiRKa8UrvQYDMihFvSuCoSxh7YYQeePkHrUwKTEhBxoKa2RVjTEdg3PWPUeD+BdNo8zqjrNaTSlL8zr3w1RKLBMFgjh8zHLedyETJww+WYBpPKgt2w3OuSlrNg6bO2wi0PkWq5AiQs5rr8XS1cAPm8DBHyUoTNyPIlkCCkeIaZJMCz4MzctY1yb7JkYUUkfB2Grp+p5WQfiHctr8v0O/H9BuDXEpHv8wTKXK+cgJmTXI+IRSvbsGkzsLRDRi/FiMh2YUZrDWyJnxvt+9o9jIGSQB3DTkvyHnYPwHoMFx720sHu3ZSYV1u8PALrRW5kEfAJpzEh5Suw+wDM2EtXsmVMfG4GDMgjdlO1PYZ8h/ejC5CRBioDZ3pFba8CqgDMeC0K0d9rMihZe300wIc9sHtyyrETgBuL8dyG933JkrcZkyeFlX3gK58DrF0+/acBNLX+XqUYpDLr9yyO1a8oarNlXYF0J/ntCBnxA+C9n0CZtSLYIT7OeQxmGjMc7OtJ/txTF6tzqRQhkUB2ChPAxtohoEjHM87mQzhAqL/XKp0mOgrUpJ7ABMr05KAACmMgM8g0b26P8t573VwTG0o7fb/J/OfPGZHW615XlspWffHAPPeKcMuM4QysHqNbglfcONXKlTlnJOOuaszOOR/p71YfaImA2fU9IXe97ONiranqgHm9mxrvawD3Q5g0tTUcuRPOAMxmoX1csS+y66icPkBy83nP2Oetd3QCY26OLPUxnuQkm8gb/uOrknfaDwZ0PKKu9PnoUfblhgaxoFCyrfRdNIbiqU5deT8cKeysPg8MTzvcefeIO3/kcPakSwZ7nW4b87e4nG3B202JNMlIs/sAypg9uycVGDcBeoQlRpfSd4EZEH4m739/kV3Vij6fY4lo99BnqW3RmGpRnbOyzizc+QB3a4A7HwIgcz+8w91TLoAysc/tpcPw9IjdU+FneHoM4JsA1XJGlajU8B8zjXP6G8o9QHVsLumnXk9zak9LFjG2ui+9XmmAMtQnhfeK3XsIQJDCgc4sxrPIlokJhNVQNQoT6nkPG4Ey6v2EGxAoHMGITcCS68w1syDPQDE26P5D+0Dxtmc51/j3KQmnkFobOtp2U+ZtckCIUNGb0L4lBgo37G+8VPSpxbJknZJyxcyAOWmGUllypJkAGiZ9rOMZtGspaTgPgdT0vcGUOUh4eVr9dNw4yjmk5nRsiRLC0wz72kJYiHqPnsfvWSIZeBZ14ewnCgHsfohjgE6PFeCLyrqpSJcOtoUo4f5zol37hje/cqMGnWROToyZk1ybaKEm05c+gSzeGBgZpzCTsZ4kO4q7ca3caIxHCPkx8fjqixH20sDfd2lxNqQoV9gyrTCf6e+48Yweu3s+ADIpbIauk401KTlwXqH42wnGDVifGyonGlvwkyemJgZ5m+h3T3/78nqlXTz/Dy9LsmZK0KHeNN72FIoS2QlusHDn0RCmTWr0sBcOds8YMTaUQe8b8T3TfWWC6nZ7MiAGiGNZeArlc1b6TEp2j/T693jTFnqXatn6NXbFknK3lMIjtED59AbwZyHY24xuYssReEmhiiufi5JN+13IaeSHkK/GeuR5WphCvRqQkd8dcOy6Z8p/ChHla9PWopweckw5xIDOjbbwn3cmMTrTekHebj4vHfLcBCxsIT134Y0VjZVGwBH7a/MQGOYRz0AZUedNkJ7wzAdS5vb7q2yHIqs9+Acm/5VjXTtYwTt2gprS1tpnE9NwcriEsEgzrRFAoTeslrlcfUtlZp3J9OcD6szCi+L6aWhPpversWoa71sdPzPhYOlkKv69cp2qd1wj6PjArkknAXACZk5ynTLj0Z28yMgWxzKfCtsELKKVNSH8pChn4vWkaVQeb4N30V6mioyF25lwSpQz+fHJKogSN93RT0a5AF0IILB7Ym+41Ec8o7vMa6ElDTVSYUd+T5Eh3iCAENQ+lO3LK2D/S3BGE34dMCXfVEKBSjArfF5njcTLPJghbeAHG/N4xJ8YLhYSdoZ8PnTMbToGGROQRUFL3poJlHFsbHDQRb57DspYZqTFcaKBMzWp5bKZPepS9E9VaseNdxnteRnVsJM5oEhbB1a0h9rUpZSINvnBwp2FY+TtxVRWmmcaMIe8riZV3CCAMimvjMghdcyjsLWQoV6DxbDnchOI1H089gMoBxsxNiB53jFwZqR1l4XiynU6HZuK0ulgTDvJpGYEdBhQW8ni8px49tFnTpSbxqRoyXXnbTlIVvTzlqFaEgDRrmndX5UrXJuW9EXa+20EY0i4o00a9vw45U4Qqyo9IbKaQ7ESnlOTKuu0ck1xrXNxv4lMeRdBmSE4aX3Pc2jlZg1ojJEN16FaWNwxZGlyby10L0+f8OCsww+TnICZk1ybNPOgROPWxN/pev69NPbywvOFJVP6lGP/uhdKEzze+0cGuB1w9qTB7ikEhkVNsSDj3EDdDMhIM/HUH7t3YWMiUIdvhtRm8tBysIcLZ1FkcfsmJjaNXnvGWsnOdjpkPdbCayQ4k32vlSF+l7Z+baOjZ7MG7sxGUIYM4wDw2UsPXDJDOwF40ngFrIgdSIoVq7PwnA3874aSo4kAuJpsmgZFVR3PLZBDO5q7dq1yXZGoOAKR4H08x+KZq2cpONPqa7GW5Ewtcc3oM6r+Iu9YYm5ZjLcGuDMDs/cY7kfwVc7NJbLW+OjuR5Ovs34DUEYbV1zJVo6y3lwaY3uVAk3jLIInfkTw7opFy3ifYbjBS87fPysPKOZMqkcLd8ga3R6Ta42CJcyR1rW1vVoeIfwgyVZMASpjrp5jyJJ3pjGMe8uqXac9N+/PFgC2tv6jyRx7lIDWQm+j+4VuQqwaUwdnmm2prbdCqnlqZthB2bVL5oC2FpMTzLkE2AKROQ8LT32wMNR6DXjaAzBl7QbU99O7Nh4iVbZwx3hRQRkq5wFcjx90OeWYOcm1yRt/+W/lIS1AyjPjrUmhJPRTxH7WYqTJ++jya8zCxSoTAkUs4M4t7j9u8fSHWFw+Y8jAk0CzmH40ujtvZwoL8NErPyrHbntGRaU4V0poOzDwRnskTqcHQElvgwIcfoqwqBoA1tqYmDHL8zEU4TxA2ozroByrVwPlasJAmRAHbLIjyFM59F587MszG/LQMCDHG+TjiB3Pnj0XexeBnWOnvzmDRIzF9KhavDeBM8WPEfeWG341blkqQOKUoFafzkkWkrZUWuX3AhVEa+Y/QsxQ+dmZ9PswOtjRBYKLjT/Gw8LDwsEaD2s8jA0/5buU8306fcmdWbjBwO0Ca8vsXcmaqUjKk7VGQZL90avMEpjJl4ItmTJbsYGW1lkkFJ+ZNxXpVfKr78xPLDy+thRHi815dVtMGRbaueYZAWVMHyiBsejyHxIGTF27Yb1SjgHKrH13W0orVKcGqCwdN1VQwC8obyMwV+1vse7N7rWKZDlNaL7TDwGTUh/j7OKKzjvbN9o+oDE02Y8f7BSCOxj1eXuAsk3GLa2X8YczPfrXYtlIU19D14yjit7cs/4uGuNzwvop+7j3PdSA/pNcmZwYMye5VnnjL/8tvOSzvjNTYA2xQQAYCkvSRENzowGcQkC4V1KwTZZKWFgnw91bAzf4DNgocqR4srJrZVK+GLZBxEWd6gvlIhn72QlDFjAIntiCFkz943165rC5ZdyYXFloeVuXbLCcQYEpREqeZFCrQ1P6EsNK87LwvqFkytwz5BGYMp5OUkECU9xZMJiBcDT2cG+cTlvRxpgcRzReE8Mp1GcQDe80JvNn489gWBmynuTtiSFwZBx3hynVRMnnkZ1A0NiQ1bqTssSUvgprhULOVrd9RriH7Pmf+Qw88uztt7q3/L/eoyp25DH01sDdCsey05wd7sfk3pXQqPI5JJCgvxd1bK0VHj5J7K84Z+buA1DPbdNKELrmFCpeV6csOXZ+vrASQOe5Iyg3kefrRcH09MU7zsrmbBwuNYOC7mX3H8LiWBqm0ZK0hrl8nYFFxjI8ydWDMD31NUNPgHI+rBh7GbNBKW9WNvbuN8NTF6w9XQZ3DWTl/UBsb+Werr5e2G4YBO2N9C52LwdH1Ft7qlHKC+1EeBgK+eJsOqYTV5vdUXcVWGT9XbCo56TYr5fdTu1ZxDiSbKOavrWkTjnuTuDMlcoJmDnJjRNugKcEvHyzZspdCB1BvpCwk5mCjZwDGRz4mD7PFzjNcDTRNrH7mKjXh99rYrwPp0FlzwYYAnZ4qI3z8KMBvE3tyE4iKgqP5YUYpLAfGOgLKKPAm9EHKug4Fc0NBz+z2XYLNyaMycCZWQOPNt+M4RRv5YaVNORMrIuxVShfTDrJiSVW9oPBeMvi/mMW+zshmfOt97lgOFMiSlIIuFSOVeShRsbXnzOji7JxpzFPSg9Vw7jl0srbUrmmls+G2lEY/8mAp4skMKmPo4LBhPy+RTLznGbAUUAZAPiEL34W3voz74V3ep9IFpbZh4TT5jI/5Yv3wdr+qFK1D2C3LKJxc1kLqq0BZ3oNDbYmLAFnNCVZy+sFYKLfg33Pw5N6WE+aYl0DhjFjyNJnncbqHLi3VW6RUIcAq04C4GYAMpuCvKLcg8oUY3m2vDVMwSXSE+67tN4aW4ES0AMlOKPd19seDqLLnGdArsOsON0nyQxop+sJ8dCPhADV18+eMavtZ+qz8DqU9bPYa48Z7jO3v/F3EvPyhPuWV1X0BbMbTmv01coJmDnJtcsbf/lvAQC+4P/2HQCQaPucHeF5zhTyuDkHY0wGfsjQEJ5MsCexYBmrzDcoD7N3sJcGu3sWxgHDhYcVR3w2JQJC7sxivGXTqT/20mffTw3ABLh4MgomsKnLwCDKfHxAotCTAamFeKVEuPxzFfSZqVeTCLLo9wAFwJS8xkjgTHgUniwSRd4c4xE8/XYCZIzz6fQPP4ScH5fPMLh4zMDugd3TJrSBKUSFsUxKEgdoMkYSUh9nj1Yznu28wkHvvziBCXVlJD8Zpm98Fu1Q6NtZm6UeaRTvWnO+LdDyavlJlO804/ltb3gv3Ogzr5s3CHRtZXybxK7yU6y797A7i4992bPU9rmdDcey76YxaPY+sKdGDzu6Kdk0B+J83ve9oXsHKcu1MqXEcVy8K40az98DHwO9gEsPOCPL7ARnaL1YMuaahh9zBNB+VIC2EXjw1urKMjkYOLNTUa7T2jEDmhaMxwUKdfGsmrNihRRt09gxtf3lJDdKmuuMwrhtGd7zlSljQgFnumQpU6QmS9YnJotynNSAWS0nzRLZAEDSQpSyvVaCGj3l0XVyPRXMPwCzgEMNrJOfVdcy5tBrlZGxmOl6MebXiroOA+13RM5qyk1J3lqmCz+o4aEfjHICZk5yY+Tn/s9vS79TeFPGjohGUgJlxohSGANPJ1aQ8g1MNGlrp99ri2fPxhSBEeM8hotwhp+9CEdcaycHVY/ptgjhM7dizokRsJfsewlc0N7kfPjVxDODOAAwswkmEENsnMbn7TR2AhQKpaqxafHvu5S3JjiTH0WZ3ccvI2DAsJOvsgvIkxBBmTR+okFuEMLIPGBGwOwRjkA3yPspYXPCqMsoxhNIYZIhH/uQAwHp5KcSWCqeN5U95faoxfMX7C+I8dixuWfhhK3xNKOYJiBLecFFGFdnWVmbNCW7Y/660cOPQMrZAwQgL4b28bBJs3eRxcYM03ij58Y3G/POhHxF+0cGjOcGw32P3VMjhsspb9Q0lzCNf950o3wmpFgXt/IGEwjOc2ZVciN1AS1awslWmNOS8niZvLyZxNaHhjFNIYXMiKAklXSCCGfH0I/GDJFtqTHx6HJh3M0q2lsYCgeOryabh0vt+y3H90mSzDELVgO9YoyvyTUyW3+vB/9Y40YC0FHmnrUndEaV6KxTw8ZqLKKKw+IY4g1KfW3JfOcOELauAkxHqpxIp42V5tip9YfGSmyMs8Lxc+BaW71P7pu1trB21BzQq8EZaTec5OhyAmZOciOFWDQkX/AZrwm/OEygjLZwGhPiUlnOlgyU6WDLzC5ezLiq0trp0swQRQSOAlNmPLdwA7AjBkdsp3GsEm3TiSyQLGSr1g6FuaEKBx+sD0ADqL2i/hmq53xdDJwJlYo2iw+zjcYLQ3ZK9suBkWS8csDMszwvOwu/szAjcOt9HmdPhuOzd/fomPJ4nTFNIzl7LKpnlMdu+7LPshtZn9AzsbGVmBvavfF6ddPVjGC+ybfy2yhSzStTuy2GIi5R8jnooDFKVMN6pfLJczglMWYC8vaToZ3WEECcuhX7hRImGpNyThFDKyT0Rj7eCRxSx35FtOtrskCZK0LLOGvPT0BiVvaa+ufeT63cOU+vHN8t2dhASSCsc8DIgJndZEkUp1sBbN2e/lfnX8faWqPj3xgPqWLApM9r7ACSFtD2AAA2N9FTfdPao8mh4Iyqy60IbarqhOJ+DRyoM1kbzzY3H+iajK3LdGGpC2wwR2pgdvczzH1Hemw6gWnShTnzQ66jW4/jHnZXC2g+2rzqBWWovwB13NTAwuZ7PAEy1yInYOYkD4T83JteiZd+2rdPRqpzgQmzs3m40gDADAd7Rns8+d4iGGEmrG4Fo6K4aTLY/WBweSfUcf6Ew3DB8prEZ1GZJT4ACN63QaHMi0EJ1BQaaEpmHE97AhBDLgjUQAYAVVk02ndg7dMMYPq+ZqDO7QnJKC6fKV0ijAICSSiB83DfBVCG5QqqGUnFu5VGxkjXofRo8Rhx3k7DyhGer/Cu/bQx947pFrMgex7mXauN91rsOab+mEvo3EygWLRJeQ+tx5ZltAAJ6m9+rZnaR//bqCSm0BTKYVXxRNEJFu4sDMTd0w7ehPxTJik3fBw2nucA4WFm2f9Av4JO/RHXH8rHpK5rc4yn2rvQ7jkw2fPWIg0yVSHnieY1dhrtDTX6vVgPioS4cj2otLEKfGwggUWJwww8bQ+gPlPCQbvlhgM0Mo/FMQGRretogQq8vi2kyTRRmLLTxQsNxxU5rDZj+bSubz0jkBw8VZFHbLf6pDJnivBo55PDhq6vhkuKtqpScSiFNnl4WBjj4TPnlFgHFV3zEEl6mgZiK4ykPKzcZ+06KC/XkjDflvD30QLmhV5wEEPuJEeREzBzkgdG3vAfXwUA+KJP+JthQTljsfscTTchZGFNAk0AE6W/ABPIaIll+8DUcGcWg8uV89YxqXAmetNDOfbSw8STWuTimjFLeFM8phAXXp9BZL3EzZVuJuMS4T7yrFDolzu32D8SduLhnoe/dCGx8YgQksKUh5rXwIAddR6/NzDlRqZJsTHWrmNGbnoewCSWlCiG1znkFdnLoNHYfWBHZKFHWm4ZLgrQUlKUp+qIjmsolEaUWcRrkzHcYpy0qKo1o1hRyKa6F+TgYGwcLWlwkaC5Au7MyeKQqh4jraK0TDms2FHGQNvwtQbeMdaWB4b7IzPay/tTf7sKKNlsu359AcoAZcgTCVPGipxBRcHTOCzKiWU1RYJDWwIwS8s6hgHPjZQh7/uMVi7XQLFX5GGHyIDApjHcwzo5QDY5wUoanrUyJauoJhpL6oaCM1y2Ys/ka3b5HXBcECiTlpFekTlGggrOaHXKpvQ04dghPWvfcdL1yvWh+NsYZMl/FUZ0tR1LcpJpYTRLgJee7+h5h9LB4yMLNWvPoaLloJvTTRl4UzgdGWijJRfWvlPb1MtCFc+RSQ8gp32uldXbNyc5iqw8OPgkJ7k++Zm3/D+BwU5JwuTGxAzrriSaXGqgDJU7GDhKMGsQknzOVRHBnPSn87D3HW59YMT5B1w4qcUDKems3ITlDzB5ap0HB2iovuBtmICSdMQ3M8JBiXA90ulE9x+zGG+HY6Q9T9IYjUxDAFRauDEl1Y2LuIun0XQt6JkXlf0oMuWFaSjw0ZDMTkWK/U/9ABPfwd5PrIYhPLOWmHI6Ir0BtqnPNj2fTEqdxoTCkqmCMto40IQzJjgw0pkgtVqeVk4WY+/L5zyGIjwDODWBLAJG2Ps0XoAyAmRthaHRPAPlKnIRZN072L2DoWS/PpQzHeduxLvv7KfWZQKUmS1KAXOmL33WJ0no/W+oJM/KFTBsaAxkY6EmCaAO/4f1wWY/BVvGYQq/5UWJvYrT9fl6Ha6ttIUSkYuE5Ad7QUXI42oR+1a2f1j2E6XbwN5yLG4oNIbSfnVEu6Yn0emWks2PhaBd19xCDi7Nh5Uf+d0LcGCu/Uv6vng+6ZSrzRn+Pa0xNH+8D0xP0tf4TwyrNRRyWfvhIoGMTPcT//O2zolkdyTdzEz7ZAoNNtM+W+lH+Xdr3Sze4dxeKRkz/B72vJIht0gaa5m6l8u+EGwiLYQvs4eWrJ3HnmMnKeTEmDnJAylJ+XUOxtqwdsiNrZLFXluoy888u96A2DIuhiz4Acgo/sIg5eEwUzJUpGuH+y6FC1lKDkoXHIpQM8MegI60E1U1ITVxQR+A8cxguG9SLp/MUPXx2iHkyQknioRn8jsLtwvsG+OQ59dIDasDKupnJpZtDfwuaB+FgUMsJPhkIKevjEl/y3wOE7NnesehiaIxEehKh35XvL88L0y4jzEzxnzzzpgTnt3H3t1qwyp6YHrYLyk/ypzMhKU069rScJopa85oKJ6XPGEUsjO6lGQcgBqOoimCAGDTvQ2gxU5jqWx7Jc9IqojX2Tg2Ho36Zf9xIDoChcVYXCKV8jMjXwu1mpMeVoRStxyX+lqPKhBX9zyza6uJKQ14Est0X0ywnr1vYuDRKU40TluAo9hvUp3i2Q4y1LeauybsJ6FMlC5BDpo+wFJbszVv+laJQq+qz3qZm8eoK2MISQbWsUSsXdzw3qrPZ0GCGnNG6rr0Hc0t7TruxLQNXUxrYy/gorVbhivKNrXakQEs+r4Zvuv7bDGoWHPQUrt5v5gpv08r51BtbCcR7OK6LjHl8CuAGOFM8YMNn/uow7J+7NEz3/DmV85fdJLN5ATMnOTBFO3ITb4ZycWzIimXB1pxotOJRu7cYrwTkvbaeJJPtldotERCsIe4YHqE0Jm9UKijYTQrPZtKTaFWqKnGedgLj919j/E8gkjOY2Ce/9DGCMicWezv7LB/xKZEpwDgBgO3Q0yi62EvGlmH596N7IZhYvAY78vb6IOR7o/XMsovB8oIQIJBMJLiBmdGP9VNw8n5XCHQQlyytlM9SM/IjV1i72TPT4bw6DLFvWfTbI3bJffNnspUMY6rYEJvfpE5qY1lQbVe4s3kYOukcMdkvVyBlaw76bkj4C+OoW5WkmBPtfJT1YzuVaK8w+x0Mw5S+b7nmZWtjPvW2KmAMvz7rjwtSh+rObPSl3qb5LvK5hbLJZaOygZKo6UGyvDxw5bYLEH1TRM+pwAdnJGydRjDFciDlq+hmd9l9ma2zynlqVJjIs5VpQEYG4MzW4aBzRrfS0WeUkROKNmHHOA9QGoAQ5I5/U0C0mBrYAZSx+vAvquMizmAvVsUpk+h/0vwSNoWWhtZ2zdbBzrWPTUFA9OV6TtiIYVTZCc9QG3rVYGfJ1HlBMyc5IGUn/2/XoOX/m+vDn9UEoR1Ly69CoJFYJSch0Xc7j1jlKC6iPLQCQNh9NI9EmiSCkzhOYkeBPWI6MYzuxwkII+yGT2Gi/D5cBFCrcw+Ml7I0xlR9/HWgItHLZ7+EIvxFiVcBtwu/L97ErjzRw7n79c6IweFCgcIdUPvO5HAB22MxM6Jm79Mcux3BuOtACzZSw97EQ0mPykQ2WlISvtbyksCZVrPmvVFrI+/ds0g7O2XHkNmYehLukcwsVoenfqcWJjLZun3TaXRp3CiLFcTL2sQ6wn36HPasDXxVB4PyZpL12TGdiyOxmtDZFkTQBzLnUs2PicEXjBQJhZ8ECjTNHCOkeS3Acp0sc8km6XK6puua4JlLHxpts44D2QIExcVlNESiSsnD94IBormbc8Si6Ls9yVJvW+YzPX5jXgnKPetOWO3x9jsNki3AJk3Nh5V5sKK9eoQUKbov8So8wXYEQ508Pmc974OyhiD2QTBNFdpb1wicn3kAEjUfRMITUInkFo5GOuh45swlxrj5lBQpdauWplLn6Oqb/LxGrG76YKQ05If5HGSmysnYOYkD6y84f/zarz0019Tv0CjgYoNR4vFrBZnDdxZMO4pVMdexnAfJayAEgQbbpMbsWLyhXTOIFAX5Pwe6VUAAM+YBckgHD2Md7AAxvOY9PfCYbgIQIXx0egc7FTOYFOS4ItHLe4/y2D/DI/xHPCDhz8LD3r+XovhvsGt91nYCxvAHWq/3DDAvUC8j8rNqji1SvZRAmfY95TE1yCBMeOtZNnCjBFgcz5/jxDKBX3m8jY06d1KguDishowwJ+r9syHSGOszxr7B4agFCF+rfoOMcgYiJHKUoC2zHjnRnK6T5TBbz+zMPuxCUDJ/FKt+bxJstUVwtldALYDZVYaN6p0tinlI6B1ju6bmz88TwOxhzz7jAO1Nc+uFb/PzP/s2oyxxh9IPHcNGFoByhyTJTA1RABJEpTplRsIzrSMqkNDXnrZLEvf4SFGZzMRdVflG6NSx9gTGw62LcOYtPLVz62BiZV7jxTKbXw4zagWStkMe+K/a8AprXOtucpBHg2UkU44RPVP2/dHBi5jclxQQuCDw7u5SOZO7/VMpgwA9bKWzJXecTUL7pDTKTQuOW/CHtgGo6rlbz1nTzIrN5X4epKTdMmi2MfaAiOzv1fu9TaEwBDLYrjnklHPk5NliRyB2RCH6QSPyuLcXlOnJjKjiscFk/E/lZcDEGQ8hmeKbBnnY1I5A7cL+WRgQrjS/rbF/hEDdwsYzwF328HdHYHHLoFnXuLimQ4XjxmMt21IqEvhHvQs2vPPSdzwJwAMxeolj8bOQJlI5RxvGexvGYxnBnYMuX4MJQEeferr8M7CRsWT59WeYXqW/g02hdHVlI4OUGaVkljJSVIk7q3JVRtHBxj2Rf/MzXVSDgcTfhgLIbxblpsoVZKfjjaxs8wEEpLy6rw6n68MkOnI0XNd4FBTekEZiqUHwjxm62ABstJ3QGGwZOOGgzLeTwxCiL6y0/1N0EbUKYFAVTmOIFMBLFK5LDfNmoSzhxo81TZrTBn+vKzt0zWVxt8wUIakJ6/MdbZDyrHbdWj5184oauwPPW1bypAhqTIh4v8U/uxpL6F9h88zmkecHcG/4z9cap+zpOJcRyhOLdTWO16mtVPbwdZN1v5UZmIFTsmKg9MM+pqyRhp9UQUn2LUtMPSqc0A1yyfdN40Lvl+VulARznUCZa5FTsDMSR54mQVnKgtwK8eGJmlz9MBwERP4XjoWqynzUSAZcaZ5KgcLkeD3MwOuMJyN+OGP6wE4F/PYOGDv8pOTgJCo9/YO460heGQcAkBxOYFNMn8BJeAdzw32d4DxlocfYnsGjzvPuI8PefYTsM+5j/EWijrzRtbbz5+jpAXzTYZfLAxhVo9nBotxgN2H92cvQh6cFJLGfnh4SsperxjUed6SWDcZ9PzIZP7cwKSMOF8AaXPKx1rjaxPhSVxX3i8N/y5gruNkjPkQAm4IY3qnVKZUbjOFEpMiw8IOzaWbyozzw90eMN7ewZ0PISdTeucLAbAZaYUbzZ5IVzmJCY0ye0Qdl4cY1L0nRwDhmah+76fTR5ZIrc+kkQOk37PEvtW2iTpqjKyaOMA4F35qYNABsulaoq1jGgDD5xmfY8D03vkPF5qLxwiNu4GyBDjLnAmN+/g+UttPliQzXlp2q1zdQdXeEzeXzrE118dquVkYsV6Wei+fP7QmVdadAuioSRWgEECMmNMFOAMwZ9j0461N+1F5OqWZ7hfgDOmPZgw6LPauXFc6RZ0L7JlbjJGu0EQFtFkii8av0gf5GGLpFXqkBc6c5FrkFMp0kodCODijhje12DJ0SWWx90xpDKBFADEM30zYtfnN8XqUiyVPQMpDX7wBfv7/+FszTzzJS/70d05/JMMZwbPrADOYQHkFknLszge4WwPcYGJCMDedpOQ5MDH1izchJ4uPYIq3gN/5ZByMo8XTF2cYn9rh7ClguBeODm6euEQytxn4eEMEWmRYE+WaD+0s66HEwcM9h+FeBGhiGBogPDgQhnqtSbLNjIqrKkuyXUAJylA5/H9NNkiMKfNwZOXKvzXpDVNRTgkwNp8rWc4ZXq6abHi+SrrOzLSvCpBI1oQlYNKEXEt02ejCqzSA35mUFBsAdk+O2N0bY4Lww4EYGRal5piidtXq0/qDM/sOb6YummG99J6WZHllgIwtA9TnEvM+c4CgqlzzxJpamSlnAso1wJhA/x/ZZ97DjIh5uupgmVHWB6+sE2tCLTZTxMUaWoiyN6qgDF3e+yzXGOK0pu+2DB+rlT1X39KcFjVmwJJ8H9L41YzhZjnZfrHOAG4K33cOBGW2GLf1kHsE5cv4HNgoHI+0h6KZW6YZxqIA0T0hoUUuGUBdw6pC6yi7N1vvFgDRrXfEx6/2vfx9y7DBg/PjVJ0IUYcVJ5QC0Md1Q8fafI6dpEtOjJmTPHTSE95Ujec1pvjhYkaP4b6PTBlkBjYweRnS9R4B5Nj7jC1QnMIUZ+LP/7//Jn7+339r55MGeeN/qIA4BBTwOoj5cmYx3hrgzu3EJImUUSTaqDDaET6zY/BquDMP//9n78+DrmvusmD06l5738/wvsmbhBAULUAFPXwE5eQr5jkkaFAsBrFkEghoKVipr4QjHmLeQBIEFCkQC8oDAQlaQCF1ioIAGZgJXyCKxpJRZDriAEhI8j7Tfe/Vff7oYf261697da9h730/T19V9/Pc995rdffqNXVfff2u300FvTds0oO338T933ganvbLF3jsfyh0D3rEKoEw1XT0A6RfNn4AEpEo0aoBJbmGF7n9TwPyUmF3r8fu3gHykqiKfNw20iof3xZTB12FGTw1EK74ZAieVNrt1PbVKhluVZl5McfZa3LbBmWutFrNmmEXTrSmVoWT9ZBrW7iVOLrKZyeKJi28DPqI+gz5+7mT6PfGv+hw04TL6R2VnYf1D/d/WdvDAwkJrUl1TAKU6AlWJ68r/D1IlYVTs8XcyHl4DnB+U36zgBjRRtXChRzZ9jiSeFAoKf/MYEFXxu3vOn62Tx1LAqt5y+RImZESdPzc5p9LmUoXEjElipI1wdVXq2jJbVfahjnfrY2p48n1C933KMrRxHXGvvsXlplD0Cf2GaJdiDk3i/NeLXbc5dTapWqTWPli643fPbMRq2asMjW5uUgc59zqC0lE7vOS8KX4Gq5RkBUp3kpMfEuus4ltTqbMfsTRFDMNDzfih9fEy2RkREuhzOqmmcSQslMPNw3AsfJMCEfcph/98S/Lti2HN75pTM58/Ad++bDC6yacnfGMUZ2EW631oUuOkPHtgtWhWHJGazjFCgSg9xry1gFaC+heQNzd4dbvSTz9t3vc+MPDkC6byeLD9nHBi17YSe7Ia8FNgIPP7P/aHCOsasmkCyTH6iblU2TMFKjahvw9fJ/fz6+wJ1UQlADS260Ur2HYOqF6AUKigr03ZhybWwVLTfZMZfBmz7CTaC0EsCMqGZqxyBcOo5Qj7XKkiLqQ6G+asMDdfRsSd8jc87Y87x1I1UslEMIUQMtApDpyKDmXGttcSyVt4K63yra4UMsh3TmZgEytsEZ9PiJTPYHi2gZ2BTqQ+6dClQR5KLkJE0x5mnvIELWM+19LGXq11KxEx8eJ+QPv0XMuRcog2o5yf864tOB5McLCkLtHbTV4LrlTcn0smbwtCSM5NeIwpOL21rxjOSVtbryS+o5mPyPPqHDMR0hjEPKFKFqLSJIS43PbBl8ek2J7VF+lWoatNt49JokWlFt1DU+pnt14Mk7lXd0udw7hx6BBspIz9e56lNEUMw0PJYpMgRMvRnZyJERkKmnVFfFqP1HOuDCl+KE6mvBhGSmTwuvf8uXATgJSGpVMZxUAe2PKKw/WJ+fSeOV4k+JgUjOU5146agefGrvbKTz+9Hu48dglxJXA7i6wuzd47wQr8EtfACr8X2gMK9DR6jFVEgitIQ/KKmQYUob+z4Geq4mBQdKgLuaMYhIHSEzgMi/2qf6cmJwPbYjKWTOLDtfGXPmVdQf3lzffTpcTmOBpQs7QgYqMFCjknI98S4TzXZJQF8YYvHugsH/KhTFpxGoZgPwdXya1A8OSzaeuk1jJtjZS8unU9VEo73eIDX9HRtqx6lHnyNPo3nWETLwd8W4IPBhsfX4yEY+wKHkTeXiND4w8mwJTzOi4ZkwmYuXGkv254wna5frJeXi5/ooVPzV+QivgmKvB504wpFCiLNjq2E7SZ5yvEaMS5cd1M+rz75vE9zklbW4skiJP6LMsO+Yhzy9rhK93Enonzd8i+uFA6p98v1BSJvoR3LMF5f1dFMJH6qtWJafKKoWfMxSSe5xacgrWONpfb/EYh25Hw/keIR+vc0IjZhoeWrz+518efiDIxG0CoUEZjNKkE9YLwH4+9fC1xAEIEZMdgG+A1//ck3j9zz1pCBn3QPaGxNbs96qHuOpNWE+vBlWKOwb3q4DtC0BbYkZrgdsXV9jtFLp7Avt3WkWKAxNGw6tlkOyHgOwgBsranhd/TMzLyh+L88+JJ20UU6chbjdpRw1YVYODG/RgOD6ujrWk+DkD2QC5SdOUUadDyUt+6cQsroNdiXL/ax9GEvvdAEAQapggL9w9ITQgepvd62CIwDh8MQZr6A3m/kj1SaBG4DcBkA5f88+xzL7HwtS1kwKZ2Di1DJX8B/cS7YapwTP5fnJSEZXlFS2p7aKVYY5YdtuPQqLcMcZG8gtXkmvNZWkbfYhVsFH0HLYEqDPwHKWkfwQQTxDXJDXKxjTrvDNSZZ8cW0wgU+G8ayB61m1GRNHnBBf+mFPecD+p8rnnACKyJSqbGgInw0WZd+8cH60lysDkfZN7X3GLb/G+iWvAh+THRbrPJ0K/AlhvPGUXZPVO+MUMn02WLEhpIXz49qJwtYbZaMRMw8ON6MESr66XlqE7AXVh0mX7CU380IonhaMVFcF+XuspMwdvfNM/GgiZ3mQjElckFSEhLcwEU3mixmebuejQX0ibLhzYvUOif9sN/N7vPx13/tdjuPn7AjfeoUwKaqXhMyKRl0DyQT8xsGPjbsVgyBqkMLYTF9mrIWSFrhJxAwWGiAobMPetPuyXzcZDBj7aTjS9twlVgkSYHGxMhbTkBhac30spCRMjo2BhUznWgpB+UwOKsUIINqaeEBZuhQmw1wppKy27E4A23kX7p3rs7vSQV+njKL0Hgm1SzyqiuhldWxWrXcXk3FzEZS8MQQEwUjY5T6xatc1owhE/F1Kx/HSCE6urcquZJIuJFk7F2JmBNkVMvrgypbBkIpNx6kiD6MlJTjzxIx45Ij6ehxSpiVyu75aSG5yPRYoAWpOgoQaqS8qcUjZMlr/0/VEzJjwWOTN1j0yoaIL3lQQ/oU+NiabqL1WGJMoPsiSW7E9In0XXWqR8KlL/1GCl51qWnKHVpfpBkrGkEMHCrFvQHLKWusVNp0C34yBRcH4aVkfzmGl4qOFUMx//QV8xfDjjpap2AmpPCAA3JxJ8ZhRNB/r+gW8meIPRLfDGn96elHH40Z96KT7uo77STBxtmJHxv1GDFw0Qvtg7YzCn9xL9TZMqW2hg/05gd1eg/98d9K7D7g5w+/cVdnf7KGOSLack5kLbf+KBfYyYbJM2S1Ms0yXZT0KDyqFdQbFuBRuC/X4WUgMXbhApiDGo/wyDz88xUWnCS1HqXcG98OdklYnLS5FfsiMZd9y4Q9t7c2cn1DY7TuB7QIsTAmJHGuiUWAc1HiB5RdW8A0oTOCGhuDQMyT/DjknOLEEsw3ZS8J45BxbJwSt9TsdwRIKbFMTPR7LiOyhzovKIOiYk2yS8wWZ8zydWmM2lKkaTFNqm3KC9+r6q9R/IkS2BMkwE99jDiDkeNtexP7hjXOJdtBVpNQL1M4pVvZUea0u9mjhyJheKmW6IYH4nRuFShmXHYVIpNQw3Houfl4r/Pflu0mZESMkZ/xylzz5KmLCK6Mp+T/rOpQuZIkJiQtGF2PvjEGL2uCZFUE5tM3xpt7chpC6EyY8nXTuZ8rUU4bi54WhoxEzDI4HX//zL8cIPeYUf1E9NZkbZmNxzTEUrfwBbXtZE2CKZTWlD/OhPvRQv/JBXBAamFNpnorFkzIWEupBQO+Of4dQy3X2N/V1lQjd6oHM+Nc4clVOjZMD2F1dGMGHWPhzL1ZkOU4rfZkNZ043LtItuo018sgB52fnVxGifeNJDVSNc/C/ZPjf5ZF/SNQPNFVYCSwcgydCg0XYT5ZI2jzyfuuHP9/3Yp5U1rALONDv8cIMZ1jDOHj4aybv551qcNWj4I0NKnBITJrBeRWbv/+x9QQbHZqPofwc3QCXEh1ESqXDSEZEy43aNmxAqmey2IBMO1076f1yn1obIkdJ8RzM7JUiZsG3836tOeAuue6cSepjVMg7nRrRwZBF9Zywi8c4IRZPgHOFY8g5cQDSz77Mo/Laa2EvdT9HzKAgLV+nt1oIhAcASAOy2lJBxiJ4Zi4y7C7IQnQq5unNZyrhttYBZfJUw4xNl35k7hOeaEObauQNHpDmXWKRhWzRipuGRwRve/CRe8OGvApCexDh4osANWmyabGiQVNnxqgEdgAvPVmu4FdDh61M+7AIPBofOkjJ7k0L7cKvD4bbE1S2Jq8fMJhdPmT7oLrU1DjZKAeOr4ciRVJ0hkRWDpg/Pvni1+ccRSxKAPpDjKplk0urJylLQ9hRxM1H+SJlTgrg/lCYTrzpFRPXg+tTGbhWhJ+yAO/It8ve1LVf3wJ0/POCxZ63/qrvztgP0gWt//rmS+rxGWTNtpsiTcWMyAV7MdzbIEYlEgj5ku0O4wkphQ4K0QKBMibOp+H29L4AhZZz6b2QGjcwzLVDGaGhlr0lGcePaOJbqD8dDJzdGYTOuhz0eFD4Dov38PiWTTxqaxH3nCC432LcTrOs88X/YsDT8qGoFv6ANqZDd2WrKpZlnasMjF2wHoK69uXfGaFxBEzFUtKekbJlur4Yw9Ykos1OubPr8I2bDgQdLbZOP9I4LVDMTKFcX17WBkjMAIKChIYGeDGvdnMS+b4XWATkDYfZqOD4aMdPwSIESIi/8sFdO7+Am6BrWrwTorkISwk0Eg8GFm1w7FceZkDLAkLFqUBDZUbUUnpS5erzD5WMCh9sCl083X3cPgBtvtx4ydkKqdwJqB0hIiKvQ9yBlchuHfrkVcOcVI5SG7nWoPKHlaZBwKcWsfs/rF2pEx05g1VD/qB5OkUPbXInURL1GNh0MZCvl2YtQWs/SAW/OTJrgN99yF4Kk5R1NApxCKZow+gk/VSS4Sbm9Rs12/LnPtSulsuO282WK9Hbs53TAlbhHRqFa5wx3Xbl7kbab62tlfLKgNYSUbDhlVmHnyPeUxD+umwvlEQJBKuxYmUPJi7guSrx0YvQZ165gRVyIxalWZ4MeFwAXLvgomv6eExapDY5QZo3qa+l2AEbvkNr39fyw25qNo+dCioTmECtVOEKmRi2TqnNKEdMB0IakTtZJ/Lcc/PNiDTKXC5GKMIf8K9mnJCRpSRviuvgQQ/NM9sNXmpiAjBVc0pKUx03D9mjmvw2PLN7wsy8r3tZkwoAZ6PeOiLHpoOkEkz78/WfDr6cmZQK4sKULif7WzqhkbnbG5LgDtASgge7SkDLdpTEN7h70kJc9ugc9ursHdPd7oyLiXszOUFiTlwXjX6KlgNpJ4xwvmNhWYV/SzswXw8trlN1GMz9TsIqd8QQ2GhBkyhomRQX1FayI5cyCOTXJscEaMqdQuWLJGVZyxq95k1+3n4DuAX2lgYNR0ejeRalIKCWg7W2sFYw30cEQL+5zpYfPcaU8KRMc3wYeLaPrugQ17Ti3MCZgIGCYNLUeemISZZUy6JnMRshcs7HEv5SUKUFiWy5FrK/KhUdJGRp3ErIw9EMayJ5B/VPexPIwRKSvnZiUscehbdrdhm1Q+ixee3Xe7TNpCl2w/1lho2d6MtyYIpdCOyorHJ8w40/6zHApsOkPR1IQQiSuK2kuTfdJ/bgMdHHbED0Ho+/mkCXs3y5zFKmHM52OxzbsvUXKiL8b9Q3G5abAedqMtp8wq056NSmT2EM6hTtNCe9g/Sdd+GzD8dEUMw2PNDhyxilpgpVmDRuuYx+UNuOP2dBtQ/6O0riuYdK5Ntyxf8zHfzXUDZdOG0P2Jg10DzT2dwwpc/GUCVuCGgbmoxcGfcnBmIrqOEU1mXgN6foAp4QZXtDjMn3ZYiiHqg+SISGaL4eDJgMZP+Dgzp22R6np3+XIDqCJ10wpOTM5YZyhmlnFd2CBkXA2dImeG3frBZNB8llCKePD5yS5h/2qEcb9mCPeSN9OqXg4SffRnw+aPJe2NP5dGzVtlgiUMiM/DapeAUL1SlROABI6F3yfWt2m3+WujUChJeZlL7LHoJVdOhXT5pOrTYojYivon7VWvrfG0tCXFVASHlTjO5HC1udi6er/YlCSNwNWbbgi5oZiec86YJpEz30/U/mQ9MHhtmXIpQBu3BiPp+zfo5DNFGmUwVxfHm4RqLgsMu7PnePRO4epl92e/E3HvQCWP6sy2TLp/w3HRePDGhoijMgar8gw/jLiqjeppq96o55hBvJqJ9Hf6KB3MkzlfIb4idf/Q/zUD/yDIBW4loDaAUIBN96hcPMPD9g/dTBpti3T7lJslxASfuUgSmvsQ5iECWHyabwVUcFEpE5cTlBethETbRPD8bvP/QqPJ2vIjy1zSDWuw21WQtYUOfVZapA2lfranVtmBWgKI0XU1qDEmSCT9djriZAy8XUIwKdchyTHIIbtw4m2/TpWaS25x4v6NqovB0ZlQvc/NUGcXDFkVgFH6c/dal7qGiOrrub5YpQmrOGsJ2Ps6iAlhQGfNSn1XBmRMnQSwZE7CVAieCAvxMikMSgzWqkNiW9+QH1MVZ0nyCXsM1ReD1LmDLFFn52dQoW594vVmIXlnRpFhsRq/A6bmrwHHllTRAanYmG2GV0f0biN+6HvHd3J8TadhNpJn6rZpGsmzz4J891OQu8l9N6On9c8jVQlhIVk9RzSYu67d6V3tu4k1I0Oat+Zc8QlmiA49VjhUUVTzDQ0MHDkzAs+/FVm8n3QkNazwKhllCdstFsFsA84tZdQFx36GxLySqHTZnL4hjeVh06dAm/6vi+p2v6FH/IKADCp9yYe8ADG2whA7wT6G8YAJBkOBfgJsUsvm3phFJEz8SbuJY2xAsgpM1JZrKgaIzYYdd5EJUjKm+dK/+0xsSs4yWOpKH5qW271bCXCJqmISmzrUkMGoVBB2+gOOlTLMOqHUeYnhkyIkc3iRq9tZvtNwN0Hp8LEqp2/jyKCDYiuw3gVtkPwbGbvMRp2E5Eepm3MPhxxEp/zpMpuWC3lVo3NsYmQ7EmBkfwPfjea3WYtBUOwkk/rikKYro1KhmJlYnmuUmKqzOuAlOJxU/I+4T1W9Uw9smqqRNE2Us7E6rxCBGqQRNjTqD3ORLZyKZ/t81QWPfKs0J0cnvvceC+Zsc/VyzVGBP+Xhopl77XUc959nXo/LQEdc8y9RqW9fFILJO642eQGDVujKWYaGjLwnjDarNTKQ5SRKVbK7CX6mzv0t6Qxxt1LqO78VTNz8IY3PxmsTDnPHfoTKzREr4iyxJAyl0/rcP+ZOzx45h6Xz7jA1dP26G/uPKPPoUghY8F60Nj6ffl2ZVf78Jbhe5NCnKzwaNhsVMqGXoV1UZIgVvQMq+zlbR9+R3C9JQcWowHp9ED+2AP92augFC6UzisfdLCt7gZTa66vAiNSDZ85Iq6DGngHZnlRiFbqmsyZ/I4ULFs+JuJBnB637RgYrcbmvBz8QDs810Ur6VYxo6PzH3uxCKUG1QwlMhI/k6TM1Oe0nsggV0vJkzIVCpyAUCxUzsxWJnB11LT1IYfr0y0Md93/nI9FFc5BXRI9A7bwUKsZMwA4Wr/Qa6TIe4Q+j6iSjo5JuR+uLKsUTCm/R4if1VRl29Pfyfgv2sYfp9bhc5cQuELrYDEsp87hlZaJ9nNqoAmk/O5G5wOZ+zAmqzMYqXvJPoEqeQ4po7RV+yveYsGV689Pe46fAk0x09AwAUfOGPVMOhTAMf39LYnDLQmhgI4xnnyYQJVFg8+L+Y59SWmbgM+SVodbEg+ekLh8monP7e5r7O9K3Pgjhf0dEzoFDC+QpTGvtIxBQeHaK8z7j34uAN2ZMCs3EBpMn902IvuyHWd4cplyygaco+uNlOfLWNgvKSS9DXIDjVFsOT/o5o49qWpJNjAcXAQrfW7FLR5ckNU/ZSfuQ1ieu3jNP2xM/FqDFbLyFVzbrt1rozCL1ckQh6ABw7mNDdYpEnJ8YHz9DpnV9Fjd4bxRptQqKd+XGiIl8mEJQn9qzs/o2cI8D5htksXp/Pds/Y8oCVMyid5SKZTzxag6j8ecfC2oq/baLErNfC6gZH0mk9pIEULJmRixMs+9I4nyRjhCRgg2a10SGdXtpMcK10bY/SIliFNjD9uk1dLsuIOWzW2/0PduUuVEz1OmnBibejP5awZmHMtt0qvTk7WPMBox09BQCPYhJoQZZLt0vNY810hPMUzyr8PgYAFSacj9pEMNk1wX53q42eFwS+Ly6QL338V8v7sjoDtgd19gd8/14zaDf6EBDQ0oYf1FEi/yaFJoVoYKKphqshS+X5JGjm7yrnQgZ177pc2RRNk6mDCKYTIiPLkwUvyUICNFD8gLkDpG5r4D4ZE8BDsRdv5GI2NfHf4yZTjLEYc1ppJC6+TgODsgnTJdzNR3VkiZJ6tIGeU30lkCAmBWLWNCZiJsaTSpY0yAWUNh33ZmX0WuFUcKg5C7MdmRm3TFH8ebZmT7qfuRI9YbxoifmdkwiiPhOp4z7npL9e288heekKkJfJTR5hjILupE97yAgE1BaOBCD7kxDHmuzCUHivdjSJnsew6V57LkPZghc2LM6YuUgma0AJUK79oCfhGLqayiPxq2QyNmGhoK8YY3P4mP/8AvN3/QgTEdrCtAXirstDTKChuj+aM/+WVHa+epEZsnv+Ajv9K+rc1kRN3scPn0HS4fl7h6XKC/AQglIA+AvALkAUYkI2BXcrSNIBom/LNBfVu0NqtTjpyxCF7AjjTRGFQVAG/4iXA/YKVVu0IjwCnUrzhmto8mj6zSpfJchQNze67J6s6IlHGIs375QsCrMGj7gBEpE/vBlBBsvsisSiIkqbTAoJohKp6c2WxRNiJ/jXKrdEzZXHlbekFwg7+YlGGIvRGm7ikXhharFktWl4OwQ+b7uH4phnAAt53i73/vZxOHG7HPkQX9nyFl3Oe5iUARQROFZdF6HwXwIZLHb8e5YM47Zmrfs+9PxmesGu49V3HvpNRxacWKfRYpgTgUU6fGMTMwUikyzxjOe4iGfQuJ9Lsn9U4vPA9Zs1tPnq//3kv6LUXbrBn+GDzDlfZ+ew3njeYx09BQgde/5cvDwSgQeM4IpbG732P/lMlitLvbG1PbRxhv/OmXWnd949VyuNXh7rM73P1jEveeLXC4DXT3gRtvA279gcaNP1LY3VfmpUIIEJ9ZhV39zYWYRROo4MthNd5N0KmCxfvTuEmXm8QLEfhXTJs1Du2rWfWZfDkn/FMmy1saP2+Pf9wWQqhw9SZAiZ0aEiu7utar8HhpfcSDRhyUJ9yqV1dn9mFSkUXbsHRwOOHbUlTHMeTMHClDSKiUSeRUCCG0hnjQQzy4grg8AAfrJZMqx13TUg5qlo7ZZqJO9M5LgRJx2hMXbhI0utY4FQ8QrmyvrHIqeXYUTRCU25YQUXNSfT/koJmGFvn6HAFz21fjZ8ZN4lmPjVJs9byaKneu5wfFjHvFeww5LzyOFCH3ZOCP5bIgdcI/5zi/oq38kTzixRz6+ZSCI85iFWe2Yn5yGQoDD5utEbfdtyG/W+35yN1jk+1rOAmaYqahoRKv+w+vwF/88y/zklCzuGs8UrTSEJfahzG98Wf+Ua6oRwZOMfSxL/hqXD0mcfkMgQfP0ugvzEti/5TAjbcp3Hxbj+5BaLLsV9I6Ad3z6oipyXz2ez2UGYQK9RpCDdsAMMQByOpe5Qt8jqw6GeZEMjaV+tW48kZz3YpmBZL9nNdG7aHGpAwZVI4bkS8qIGUAv5o2Io56zZvgxeWVyH5zKB3kcAPPURYpsc6gqbSMtdUzJSubxDOI/l08edHaZtDrgasDICXEfuyjwD4XmHAl9nf3kcaglnFmwnbbVEidUz+JXocDZ8msmpcYDR8T8fUXZ7XKKYAaRtjUT2IF1IS2Tflm0N9XO+ZjeWFskKmpSE2SA3fskcJ2lD0t8TzLhZKVoCZc0iMOW85tv+b7hyD2sXHbBNd9yTVW0r7CsLdR/0fP1tL7p0qBdoKQvAYeTTHT0DADr/tPrwyUMnTF0GVvaqTMGD/+xn+IB09IHG4C/U2N/rEeALC7A1w8pbB/5wG7O1eQD/pAyeDhV61nVC7ITwwNTwR44sFlFwhe0sJm/EmvqoxCYdZGrKiYMzBNZMDwK3BiGByUrLAIDb8a5VRFRWE3SA3oMitbetgmLiM5iHKfudVFAR+aJtR45YyFIxRq1UYrDHLW9oOZVd6aE6B4JZNCu3tPj9WJbhMx/jFfaOCgzLPjoICEuWGQXcn9kJXjSWWMq0szbYxVI3F4WkdWrZUhj4afqKxSpU6qidwuS84jqzjURolEs7tMtaHh7PFQnLfUM+ZMkZ00T2QiyoKoAbnnyVrnelU1WO4dsTaoosYv1rhxDMaKHItRps3cOZJRZs5SJN5/wAaKpmt0rzzMaIqZhoaZeN1/euX0Rg0j/ML/5+/739/z274GUB32dzW6+yqalCBMl02JMPu9x0gCkqg8UGQ4toVI8DGsSDhSSFNJvqDbTLEVpF0ZlcCc1alVkHoBTykk6MohWclxShyfMrzA0G4ss53fEVrAhCdZ3s4ZJ1NvmuB6cuFriZj1EgPhWZixMjWL4BulEGVWJbf0kpkBH+4X+7WQiUSoMCHtd2FEjiQ49MO+nRx8FCgpw6k7uJCiqe+Dg7D10PI78h23nyK/iI5XzszAaGV1KblG72kXnkX8dHy4KTn2Y5kJn7vyBOCf9efeZmDbNsamySlj1Gps5Y+1drn2GcX6tE2hcuGjVv1UMi7JbhP55pz7te6fa+7ZRp/hiqi3iSecBxnjBZ5iJOun+cCOITsSzhovsimStTN6Z6xpMh570DScBxox09DQcDL89ou/FADwf37+15lJsxDD5FnYFWyFKJXxQAYMgwc9TDjpy5+bUFE4UsapYgJjG7odHWCYuqYyCLi2aIjg5RzvM+sFGw14Zr+kSWYoV46eMhumvh/xRDMys002P1GuaxMHl8lGxPW5MjtpvIw6Ea56uUGvbesw+Eq0gfO5OafJwRShNoEqA+FcHWseGyUuyWpljCmSwYXUBKE1uw6660wopPNFikiZYPKSymLiG+EG0+AfFVIO5QvG9yFIKeZWW/WgulQKGjIMPVhDeRet3rrzl5qATZr+9jrob+18t3ZynfbOQCk5c0oS59wnp2uj9NoafVYbGjKF+Bkzt5w1QN+RDCnjQ24BjMJsFzx31772isYd0VglgD0nNKPhWWQLdEQzGUxyprw6PhcpwsZ+5pMJ+DUSO57hwpVt+cmQ8YU4Z3+rRx2NmGloaDg5/v2rBxXNCz78VealKAEoEU7SaiYpZMDDpjUlabi9AbAGhFbGFC/2I5kLEaoVigidkmIdtzBjoBZPTFLZAIpWLydIjGpFUEZdlBygWtmw2kvonSFm5EFBHEz96sJIFuSVNYAlhFwSAjx5U4MCkqp8MllAqEztH2MJubKF9wwiEpYjT0i9gQdNHEbTSXstyYGUyfnHxF85FZ0Sg4LFraT6NiMsM8rW5kLr6KTDDba1EJGwz5YtrepH2ePu8u08B9DU81TZdOzBf6nHifv7mCTJdVD0bI2zPf4S36sVIDSs4a6E3lGFBnnepPxWTqhoYMdPieYE93303Bp58znF6op9v8p9JjGQMloPZHqOZKLgzpXSA2GjE9tF7wq3cMZhrefr2d6TjzCax0xDQ8NZ4Y1vst48Gt7jBYDxBtmRH0uaFLnY54gQGpbjZaw6JGUSK/gxqKu/jn5G3jj0hZvyq2APiJBTZNW7Bn77gnCjWEGS2zY3WBv5gWTqq4LtX0fK+ExZ7rO9hNqba8Y0xlxXk6QMh0klUOGgLQqhGmXLivpgRKokVtiKUDrAZ2Lkt0Zw/QShR1EbHCmjFMSV9aOicu9OQHcd9H5nVFSUlKH3D/ERcH5DI/LFodegKbDHjRfjNkf3TvL6cOE/fsPoWbDmKnKhj8C0cWfi8yml00ZI1ZHyYTj2hOQ6ToDmZEbiQrVy5Rw9QxV37Zc+2xYR4+Z/Lcx76fD4HpdP7NHf3AXvG9ZfLdXmGc/k0r5ObTPaP+MBFmwTe7bQY1KRl9zMfqaLS1PtT/aB8+Nh3hNzwrJGSQion41777j2qOicUxUxc67n3J/Zfed6GDWsiqaYaWhoODu84Wdflv3++R/3VcNYRhlpQ+ATM+edEvtNaPtP8AIP/6bqF0/ICJgVekfEuO17uzKmbBk5NUW8MlOwUhOsoMSKg2i7KtCVHrbiwlWkNREb8FlDZhcGJ7QlZnbCKx2cb8mQttztT8p1E2k/wFthtrDUlyAlu4/KXVUKPkXIbLB6OyJlLILzE3mciF4DJAuS/58qOCghQ0HvEZpGm6a1jj4L+jaVLYmQMqN9KKRV4+S2yWCWEm0J6Cq3vae0EBBCjMO9kLi/jowm16/DGmqD+LosLW+162QqDHPqecyF1K7wvBs8Q8yPWzzwYxXGZySJRFhiaTs4zL5XSt79NOSZKlAoevoum9mWUtgxS/Z6T/mB1VbFlD8ap9ExVLRYFnja0M9I2Fvy/VFz3eaSJjQcFY2YaWhouHb4sR/9f+NjX/jVYWYdm3pWOBmq41cEIEB8RiQABWjocExBJPgu7jmWEwfpdkX0mVP0SAHVCZ/O2q+ESGFImQMJpYmRIzkWECDsyghgJrbM96NBWqysSQwEsgOqtUJfEma9rn5HfGkJr5Lp7mvIS+WPlyI1OAsn4WX9np6EV5IzBcqcmsl88fYlx3kCUoa97ty5DMKdRJowSYF6xkxt6srrhjrH2yB7rQcyf0do9PYz6n2TKL8Gq01wcteFm8C4vj9hKFPQrBTnvcFc4zqEKeXaWHyeNjC/XbXfpggXjpxJETBrhHlG9bv3k7xU2B/cQgHC7JOlhMyKYM//1FgEYL+fvJao+sQ9O6JnsMh4dC1BYO6rtVHGcO0LdlregFGfTNTB9SFVfvswdjl+r3PGwwGWKMYajoJGzDQ0NFxL/Pgb/iEA4OM+6iv9yrnw5mraGGheSKiOvJ3cfEppiIP5W3cS6JUfuL7hzU/6zV/4YROZt6wqxodVudClnYTuIhWDAmSvzdxFKz+xdMRRViVDBzBMWJEbvNROhmq2T5IylNBaitQAITGYCHyAtOnfIESoh1dW+LTYqfAvzvR3CZiBP6cimNNvHMmSIl60Pz8VZM6J/AwmVxe59lNCZqR608F2yXIiUmaU8j4me7jwqqA8QmTmJjix8oS2E0hej6lrZomsvW6HsH+EJFmvED6PToVj1n3upEwO1d47FebuZ6dYismZ+LulKHl/KQ2h+lmi3lUQnb8kKeP+z70TMwRNEQghIxTJyqmsJ1hHFtVKi5za1oWqSqSPb+lx5epOfV5aF1X7cMQ/dJ5oaSTM2aMRMw0NDdcbMZkB+zKHkQr3t+ysSgEutEheKXRK+/chJWMoaEjVCz78VaRODETMTvhJr7YTNi2A/kKivyGgJSAPQPdAAZcAdgLCbeQmy70eS2crBgVTg+nge0Zl4j+fGpzSSW1NvHXJYKBmwEC21dJMnGWvfGgIBAzxduiHDE0TEvd4EryWSXMVSiYHCWPB1MqvywYxeSxrm/lWYHIlP0HK6Fi5Et8znBx9gpRJIlDmICTyPDmovWfAqM1T9zNz/dHsTsPndvNaQhUF92kK3ETOZ62yqsGonQ8DziEcaw0EWfeOTFgtrrP0uVT63OKUMnORKyOnliMo7pupyXZt2ErWY408N7kFI/o/3Yci58UVbeezu/Uuu5vN9OauW4bG4vqtqC+FHQS6P7lmRs/6KV+9onoTYyf6fXCcjKdN/L37e/ROsOrxAKNxH10wOjcG9dFGI2YaGhquNySgdtKoIygEBr8QAXBLVD/6Uy8trsaZEr/gI15FJmfw/ibozQtSd4asUXuBq9sCagfs7gOiF5BX2nzfCyNDVTYloyhIizgx6XEDhNELPEZK0p2C24abHJdMxEpi9ScGybqTweTXfIjhMwDoNaT3+6Gy5czAg5Iy4XiNb0fNYCZxTEsmKdlJdqpvqUfQCTN7lGBS8k3RkQ6YktzHvzMmvlQZo9VAZAVpU2NSxlXrBvDuInL3SpxyO9VO4jczwgJF2iqkTFweRzhNtPE6hPrEoH13HdufQnxNVKksj/38WOClMolEWUWKocIyV1UMTWUvKvUCK+3DlMdKjuye+o6WQb9zm8YEkMuIF9ePhfdklzi2qJ0pJXJMhCxqS9x3TFhT0A6STZSqZ0aHEbc3CgEfZQFrOBu0rEwNDQ3XGj/6419m/V1k8AMhfDy3fKDQPVDo7pv/5UGb/WbgjT/zj3yWJaqQUXuJ/laHq8c7XD4ucXVb4HDTEDSqw5gYchMaP9EbBspLYdJ9R9VVDBLZdtAV8ZRahrr5Tzn7U/f/eLAYm9pKAXXRob/Zob+5G0wTCSnjVTE0uw4lZRJZDoIJNsz2QYYI2o7ob/qTBKl3ahUrxqLsEnEbUtg6A0Mm00M8+fWgk/8UEUB/wOybGng7Uka51OnRSqYlaEbmv1yZ2v3oMM03qUfowXg62y7J/CSuq8nwLoCdSCyB88cSBzWEAtg2rvXcapiHqWfBbHXBCti0HprlJgHaNyXPzBJShn3uk+w6R80ylcNWz/WUOi73zD2owODXlwP3DhbDM8WW5ULAR+8Dt3vFeTX1kLZnQlunnmc153epqTLbDqey7sdtz75jHAIFZHrs1XAaNMVMQ0PDtccbfzpUvrzgI7/SrC5YTxfA/P6jPzmPjIlBy/mYv/Q1xvD3QuDqMelVMibMCRA9IHtAHswETR7sJN2t+NvJnZBY/FKMV27o76O0jXGsfU5xQb9KrZBPZfJxn7t6Mia+XpFAslypnUkzKnsN9KQc7UJHhkGG5hRDTJv8wJo59M1XkiZUSznZe3WIRW2Y2MaDM87XAkBa4eI3dIQo2S+3Wpsri37HreZKnVaxIBrQxveWleOjH+oWPaA7YDShWaCSmyRusKJSptcQvZElGk8ZGZyLHK4jaZN8dp4ZSts2x/h37etobRP0KYzI3kDxSL5KvccYsKrJ+B15TCwMzVpk0h2HPLnPgvbB+Mf02iZm6IAdCRGyz0oN6UOaBq8Z5xtoVcnuHGY8WabUK8HxRm0u3q8CwX7cOyrzjB9dlwyhMsXBVN23mQWyhuOhETMNDQ0PHWKiZkv8xI98KT7ik/8p+gujkOlvGl8ZP1nThpSRV4aUcRkYnFGw7E2WJq1gnXEKkRiceFM44oEhejWO96cDuokVx+GPCULGNY1tVzSAjOqM/Tp8iJgYvnPZt2hbhIYdGGtPOAWT5oQEPFDKEFKHtreUnKlOV8mEd9WQLZtPdJeQM7nQtUICKlaeUK+V0bHTwXoN6ACf+rnQeh0YrxezTW5W68KbyPEoGMKGu67iY2Ak7TlsarhKFWTC3ZfrZkw5Z3Dqw3M89i3b5I55EVlzxIne6D5gJvSp91guZDVQYKbqKsQq3mwLQa/lEZFFf88RyqWEuAKE1Pwox4ZzClc2JWmEGN4Dcd0TSF6vcahpaZlRGJFrz+QzgSOU4pCu1LXpIAW00hBCGJKftil+n6XKcIjvRUbRmvJebNgWLZSpoaGhYSF+5v/7/0J/YSdijoS50pCXGt2VhuAMRoX50Vx4Bx2UcIMeRtY72sQqTlyoVBIFGTbiHwDJEBhPeEhSPwcS3jIiZQSMT89OoL+Q0BIQCjYMzYRS+LZoQsqk6km1cQI0rClFvlSRMpmwIdq3yYH+1mFHc5EIVfIEz0S4Qb5sJAnIydVav7EjAxEQDJAyIBp8WfScunAdRxSSY5oMkyidSGykzlrdV0YOYaKPMk5GyrDPsui5vBBTIRzx3+esJhqBTFidVxR9B2l7n7Ogz7GFpEzx+Yrri9uwwBCZO3dBu2ru8Zik4VQhnfnRlkAIVCSpEFJaNp2tZsc95c1mQc5/MkQqDrEqWRTIKWVSoWEUNCRa2neXfX8FIeYlpEyMcxxTPMJoxExDQ0PDCvj57/xiCAVcPKVx8Q6Ni3dq7O8A3X1DKviJHeC9acwfiQLpS596YUyFZWgm9AgrDKAzXiG+ehd+1MlhgOvUKIHXioDaSfS3djjc3kPd6Iw3EAldov0lNCB7BXmlIIjqaDSgKRhgxKatSzEr5Kl0YO3CYOLNmONMTpIKQtUWkycpJMqbnEzSwXrkCSA0rJ8Q41kQ7xt/LgHqD6FjUsa3OyRwtPOw6uSg3qLEUOYYaLryJFj/mmXnYnXywPWVbMTMw4JSFVZVOQXviQAbTgq5RQVv3m3fUe7HJwjQISEPgDX1nUtKzb4v55AwhechPpaAnCkhDTh4hax95kppUmCzDaDPdzLeiZ6hvlxmLJR6n3DvGu81k/Hyio3OAyLJHldxRj/ueEcNDY+n5N7UAt7vkCpKz1HN11CORsw0NDQ0rIR//+q/j/0djZt/1OPG2xUunlLY3Tdmw9Cw2Y1glDLdQDywUDCpnnuyOlMB0auR8ayTolcPKCsIj0FZQL5UJI2wbY+66HD59B0un9jhcKuDurCr8X5VzYaAWSJGHDREr8xxuUFb/AbjQmdiI2EHL5fOqF64MlPHXrJPIfkxklxr0neJMiYHZKUToJI2xmWtRehwZEo8KHeEjOK3y6760sE4NyiPJhNeLdMR0hBjUibf7+T6qBlxRbL2qcH21uqFmMBqg/8TYONQoNKJbRZciMSGSF33sbJTdyQ5gFdzkmvaEr7BIsIWZPWWyLU3Og/cOV3dU8jXTX66xHMtDuNMkUHxc38uiGIyLJ8hyJ2fC/demUnOJO8pjgwqLGtV0u86XfcPGZrHTENDQ8OKeNP3fQkAYwosegG5MySD6F1K7GFbt+Kh9tIQMDaGWB4UAPKCBoyhbcb0LoYx7FTJgTEnY04iY9QbmPQGq16WCLIrlND2eG3qay0tOeX+74TNbGNXLKkawhFTQVYlRwaxVr9pcAPBHGj2pgy0IN42JR4t8TYpZQsJ1xFzpMqx0XPtgKvEyDmux/09B6mQIurT4tuA5CA+adZIy8+FPlmjXnNd248zJB5bnyu/i9pf4Wkwd7C9xiRrtEo8RybfcC1wMm+rhRNA9r6LM+4JhlT1z1UgDoWd8vuaNIIt8Io6u3vIPg9p+4oMb90Ch/s/tx33u63LussY7xQlxs9Z7wfDND3TlynvF39spN2jbVPHQ5/rpXXSfkqVWTG+m4vk9deImLNBI2YaGhoaNoJQGuLK/qH1QF5YokZ3Av1Ns4IntFGFdA/MCEQqFU5Cqfmdr4BRBBDDPGoEDOQHWcFgYir8JdgRUHtyDFbdAhCpLQbJrbakilBAd18ZA+SDSymMQB00Io8cqUNCSkaYMvsNJv4Tahm6bwFG5EzcrvhzjvSwhIcfOAZEhC1DFJgNroVEf5r2MJ9XDPCS1yP1jlHjcxSoNxLnJhtqVDCB8CEP7t5xardou+xxuO1SPlGZQfqpJ25B5pKmlHkocW3O5QShHISp2HeERxx6SJ75/nkdGbCXoIicybw3zs5Amj6novu9uF/ouzX+jNtcR+V7kl2FGe3gFoD4MlfpSzpmcmUx75iA0KG7x0OxFDkTbTs6fqasEUoVq4mFkrO67hpGaMRMQ0NDwwb4iR/5UgDAR/2VfwIAED2scsR6pCjjrK/2Av0NCS2A7kpDS4F9r4GDNb3NrNroTngTUvr5CPTFHQ2+Ri/pAlKGmvXqTpowJCkgDgqdDTnSQgA7aZQtbsdOQHUDu9TdN6yDI3RgQ7eCjEiOTLHHq/Zm4O3Dm7QdYNN04xEJ4uOwKzDHOyZrBFwj6XcTEafcSJjbFg9IXf1zV8Vq21+ALCnjzBW5r5f4HrjypzYhpIwhHDGEBs6tz018UiaWZBKwxsC5akKVLOQaD+ZryOWGdbFmn9eQwom2sF4xMq9w5K731P1Et2WNYheoILYmcAIl0ZTqJYWYkOEWjOj3pE+KlEcptU1UTkoZkyxe8Mc9Ugoi6qfSchPf5ZAKLxstmlFUPOuu3XP8EUTzmGloaGjYED/1g/8AV49J6F00qVZD9iZoDbUDDjeMgqa/IaEuOui9NGE+xO8ihZHBoatHDz9mQz38xJh6wbsMStQMdZfx3uiMya/ek9h+AUOsaG0MfS97CGfq25swLnEw2ZeETSUOwId89TekURkJF/o0rH6yShkywfY+IRVqmVKsWZaDVxxxGRhQOcg6xgSVrDznPE+SKbKVOffioEx/Wl8CF+qmbWaPVOhSUX9wnjLuc0eKuOuc9jfJwrQZJlaXgenjpN8vNoKsJMCWmKKuipZl5OjY7LxnfFNoJiVv4guYd4a25H3ktcaWG/mw1ZAy7rvR8a8YklLdt3Of9ZQ4mdqO2yYmUOLnR0WfjJ6/E7PVuc+5pB8ZxtfD1DlIZS2b6wFDyxuHnmcIGg7tmXht0IiZhoaGho3xf3/Pl8CFLzmiQRwMKdHdV5AHAAJQO2EUNDc79DZTEaRMTkbnKyBy3+kgm4Pu5GCc2EnoC4n+RmfJI6uU6TXkpYK8VCRj0nBM/YUcMiw5I2CnkLED6GBlk4McygxIlXiXuN3e9JGYLbv9Z5o7xmm02bJi88jYUHLKYJIMpGLSbfGEuxYlgzqGuMh5NJhfDBmDg4K46iGueuBAsi0JQkpRcqoU3EQh/pz5m2buEvH5WULATREdC8m9U6+Gnrp+AOv4HF0H1GQ+epjgnu/uHo3JmPiZPIWCbaoJp/gezy2GkDpWJTZzWZpyYMKIq+7rqWdcCdlrF6JcJic2K9OKmKO0SaH0HVi1aMFul148C/6fiZOT648wWihTQ0NDwxHwUz/4DwAAH/ex/xiwyhA3eOouJa5udya0aQf0NwRELyF7aSJaejX2zHCZeia8LkYyaymDDQMJsF85FEMoR2cGwMqGEemdgNoZGbi8MuFE8mDUL86HQ3OTYB/CRdpuPw/i/jvHvgwTZL9ipawHj4bxsRl5j8jBx0dalU0nvFRdHhx5wJAohQMZdkBEwsn0WuFC5zKprBngFXoL0O2FJWXQW7bQEWlUweLakfGCYEMIuHZk5PpOLePD51LKqlTZpaDSfm9qqScVcX73DS+N0gnDJOl2KqQmpIXZarLlnAMyvlSnhAvf2CT0JiCpB9IUwEDozyLYw79rlTKj5winDkk8K0b3c/Ts5Pqxum9T77WS60VrCAzP31F4zlJFEPOu8O952PGDYEgY6rWXGPuwfVThUzRnm6JnctQGqqYpNoUuGats5f3WcBQ0YqahoaHhiPjRH/8yAMDHf+CXAwDkQaC7r7B7IHG5EzjcNGSCUIDsO3S9BiAhDozMJUXKJOLaOeM61mNGwBIwEmrnvF2MF87hhsmk1F1q7IRGp2z66t4OoogaQhw0OvSmfTbttZvsmg9p28TwGdc+BQgQpU080JAiaDMAbzRs6gfAkDn+mAtQEq40OXjODZpmTq7WyMCTBB0IZtqXMosdfR+UbZRjuDpAHHpDxMi92b8bwoomwUnwC6//kdkvIRUHJRdTjyNuSlZ/c23mdskM0qdCKnzxS+dNE0TQ2ZmXPuo4M3KGflaNnHk7wej+rKizZPK5ygR14vnAvreJEe1icKbzycZE20TkTHK7pYiMd0fPae8RhOH/isx2Zp9lnbnkmRy/x3IhShTJ67iEnCl4V1cTkQ1HQSNmGhoaGk6A17/lywEYgkY+kNjdk7i6LXG4YVQz3ZVAdykgLjp0D3ozWIlGptkXq89oEK5GxfsM6atFMCjUVq2gpYC6EOj3wnrgmDJkT+qMB8dukfCgjOmx/Sxe2fQZNGibBPEK8BsaIka7QX9E7mjredPf7NDfNG017TI/8kpDapr5iTR2JilD5dVCghBTUXkyPmeW+LImyEJpCKh0m85h5b6EkPEfiFDpgvE16bMtKUI2ur4TYvAjqlXr0JSqU9mE4u+oR4Vdhfcp2zkSpYac4bbxf+f7tkRS34iTRwQlK+VnQM7MRqyMoYhul5xKxl37KYJo1uRzSiU3g6xIKlAmvKZKlRul52LUDhcutDYBk0MhORMkBpjZxiXPxtn7rm3Mu4Ihf3tHnCcaMdPQ0NBwQjiC5mP+0tcYAuEgAPvCVHsT0iSUhlR6CPeIESsaaLhGPHiJB79EaaI74xfjMiMJJYbtvAkqIBUgryzhcaUs4aHBh32AVx3YNmqIQCVDVS5uou3IGE9MRaSMujCeN4fbEodbhkASGugeaOzu21CrS2VDwtYlZUagq4xc+a7Ne5N1Sx7MuRWZCfpRUJqCM4dYkp4jZIhps9jvoKU01+K+M+F2c9pBXfMiL4Nslgw5mIgazyNyTfsNmUlALpQh3iZFzsj4ftGjdpeaT8aYM/DOZRSJtzt7lGQrOQfic02cATkzC06t5uDeCY6Ej98tBWEp9FqeCvOdBHdvr01cFJZX7kNSdoyj50uiHaXPhiLEapiaXbWGVsyz0ykdM4qQuYivpcVl14b9NjwyaMRMQ0NDwxngJ37kS/FRn/hP0F1J9HsTLnR1W0J1GloAe62BSwx+MxTxyr5THTDy7xhOFaM7qxhQRl2CXkMIDQhAdEYV0mkN0QvsHmhc3DXGxeJKQWhltrWhTHRgZHxtXGWkfT0MYSPh1TmwGaiEUz9EISrBwFAAei9xuNnh8FiHw02r6LkB6E6gu7RtUTDGxFdqHP6UgVuZq862RImnaFUrUNkoDUAMqoxEiFPJIHOtVWraxiD9eCVGhEyvyXfhgFTvJaDttequwUC5MlEZUdqMvqLzvPhYBPVPIHXGK/G0/NiEshaEdBnuDTlZ1lQfpCZMizOVXGecU7rsM2nLFhPW2XVwzx0pQpIgJvtn9F9KVbpJH1QoOLYIGeGeA/5YY4VFIkX4UckZV0/0/EuqZnyKRusrpN0CCN/e1Hle8lxceu2wfXdkddLUWEJo4PU/9+TR2tMQohEzDQ0NDWeCn/qBf4CPftHXQN4yYU39hRl4yIOAvi+8Hx6UMsoDmqHAhSBJCX1Dor+5Q3+zs2FHRtkyhBOZ7X12pCuFTlki4mDVAgLoLyT+7P+xx9Me4xL4LXt9/Ocffnu4SioEVCftMQ3tcwhDrczf/V7i8ukd7j9L4nDTlCN7QF5q7O5p7O9qQx6RtNo1yJEy7Hfks+QAThuSQFz2w98JQ2Fgg4Ew1yRH4FmyQmhAK0vOkLZMF8Rs1+shZEmEHi5uQK2FNIqtnTSfWdWWpNf3RAhBkbyfK8t5KrnL0JFBOrpm5nrJMIjDCoMQxTmED+onDUsm6deGuDkHUmZLLCBOtzqH5Yqr4Znj9nNtY9WXhce61MR1ERZOrmuUcTXvBZacSfRnLgRsM2T6LWiPBLQSwbhHAFZ1y5ex9rWeLGuOAiZ6H1W1dcNsbNfm+f6QohEzDQ0NDWeEn/zhLwUAfOjf+GdQO9jQCqK2iMNB1DCA1R2ATkDtO1w9vsPl0yR0B+zua+zuCpOVyBrnigMAmKw4XhHslDJao7+9h3pMJkiZ5Xjui57Af/6xp4bxjIQNnzKmwTR9NlWaOEVFv5c4PN7hwRMS954toPdAdw+Qd4DdPeDG2xV2d3qTLeqw7gRtRKQUThpGKb5XnGwsCmEQsGnFDXFi+syOGzWAzqmYMuUniAyhzTVmFFlyWN0kEzKX0ry/1UFLge5BD9H3/noMPGOiQW/QN1PhWIQEdPX6tNhuQuj2CQwn9dhssmTwzfTH5LmcObmbS96tNXE5+mRuCudEyqzVllpfieiZcAyS19WTaxPN+md2IMq4iixLZ3fNLQRVinDflew/icprMX4+HMscdvRc8mS+hoYcxj+Mj9gWbUwR2f69UbCvxyjceyBojqFqazhvNGKmoaGh4Qzxf3/3F+ND/8Y/G1QtMaw6Bh3MpHcnoTsJdSHRX0iovXDLScOPTWcNIFTMBL4rZgVK7005Dm/5rweIuyZd9e5+D3GpzOAoattUlgG5l3jfj32a+ftCQkF4MkbYlNsu24Zpj0AgKOhsdqjHOlw+JnG4LaA7QPRA9wDo7mns7yrs7vbo7h/GfVeTpSJo+7B9ciWXm1SnJlNR2sx0vdEHKWPgJZM/YTNvdZY8UGLwvHFzJ4hReNNIicLB+8kIQ7BIOSZTrBzdhNRhbP5MU0rTNudOYZxamzPqFeRzZ/hLB9qE9ESPUDZfYvhL2sphyQSCm2TPMvucgan9m6nkhlhI8tDJ69HOEVVGknAl0PuNKmQqj/Go19oxvEFqsuBFSJFvSw1vT4GUsTygIrZIpPfZoh1LkHtX1oQ0zUhg0HA90IiZhoaGhjPF7p6ZkYoelkCBeXF3ljyxZqlqbwgZtTdprQEzyN3fsca3DxS6K2XVMPAD4cAsWFgT3ZsdDrdsdqMbwwtf3lUQdzXkgx64VECvoJmBY2rY4QaGikyuDzc7k/nySqO7OkAelPcVGa2WCTOx153A4XaH+09IXD0u0F8YhczurlHJ7O9o7O/0kJeqWpkyFyWrZtl9Qfang7OcaTMwzwcm5SljzZ59NqIR4Va2ih2024XX7WRo6EvaEhBeBwXLDJIwB82TIxhCgPy1kiIJI7WNV+nIQULuj9spf6jPtv1MSGlk86Vwx7/iivMak9BZXglTIWURGjlzBpi4Xzc9R9Lda2LkHePJ8gVkjCl7jYbOREK5t8oknnuvckqNBJYqo46lrKoF9ZzRHQAlAsP3ojav5PfEZrJyvxcXMv8CDtRiK2RoajgfNGKmoaGh4UzRPbDEzGFI3asFfNYfl1bYqR3UbjDPFQdAXil0D6zxba8Go1kLZ/wLmIlqf6PD5RM73H9CQu+A3dWw7e6pHuKB8sqW5MCGUXSEkvNoAGEJIjZ7hpW7a5c5qhNGEeRMfneAUEYpc+OPFG7+YY/93YMxJKaqm4WI2xybArtzEm6TKXCqXVqHREYiu5OZ2KTrG028UoM3d730vfUwsueYKc/vIsKBcmq1T0vjG6SjVc0R8aaMFxL6fiAhgdBXwEFhUM8Q+Xfq2II/BUw/UFKGXitEMh+QM9Qfh3jxZJFT1swwfDwFwTMpw8+EEjRy5hEDJY/lcJ84+GfLDO+Ys0EmlHKNsJ+aTEo5ZQxHFNXcj778OYTDRhgZE3fkS25hhPNuWXC9jfo0tYhSiozBcna3aCFIQAyLZI2gufZoxExDQ0PDmWJ35xAMkIQ2KyMahCzQGvJgiAh1RSaczkCVkjJODeAVKDZNcGfVMreGjFDQwO7B8PKX93vgSvusUH6CyylcGPjt6fHd76EUgnAq7cJp3MDeppZWFxL9TYGrW8boVyhg/5SGvDIeOhfvNKSMfNBb5QUChYQ5iPpBy2BO7D6INkhkt8iC7DPOPIFxu2PTxq6MBOIzUnAfwqSIBsbXCYdoMh6QM/F2Vt017KCDa2/oVw1xpcfEkBDGV0DNHHAy14AmA3akCDxXL8SwMivEOMzKHROpi6030a4S1KyWHx1HzihynXFORFVVO3Iqg1jJ5/6k5CUNVVo4gTwnD46idx7q79e1yJm4jbXt8AsOenhXzSlnFlIhY5zXGFWbcvts1b65KhnyzFx0HcfkjMD1IzobRmjETENDQ8OZ4o0//VK88ENeYf5gJ4TwYSeG9+DTjQJ2ACAEhBaeJHEyc3Wjw+F2h/7C+L3ceIc2xMcVefErDZBU3SZzT6h0GWV+cGqcxGBBXCrIg1PVuMGfnbTvLCnTWeJoL3D5mMQDp+a5o3HjHQr7u8qHaonLSBXkMzdM+JFMoXCQXIWInBnqShQUeLtoT3asPUHh1D/DlwlVTEwuTUzWzYquncQ5ksR6C4k49TvgSRIAVi2DvBqF1ONB7x9CBiWPgx6DXZmNU3kX1+2q3XDMvNVElSUOG6pxTmTaatlfaLgSIWTMh+YdYupz926klDnz1f0pIiLux1khggnUkDOlYP3KUmTblHfalsiFBU+1xb0fVgTbx5wS06JISbmwPcl3dMO1RyNmGhoaGs4Y/iXf62DVP5CD6+EXASQHW1pYS1c7IdYCQCfQX0gcbkmoHdBdauzumBCoTisAF/m2pVZtqCJCCt7A2KmAHEFhs/O4sCVjamwImv6GwOGmwOExs+v+KZiU2E8dLCETpcWOPEVWmQSsOblanB2DrDyXlqW0T4EdKIGEgKKSbJ8dS43l7Bn59UhqHn0PwGdCov4ufkX9YHyQzHEx9TED9tTkKSAfRzvZfzSC+yhpZixCMjOXRp3W7UEIzOuIlNHwdT6mYyGXaeeUmEUgJPypgjliRCDHnwU49ep+JcnKhrAwOMZ9sZgAoosnnEG+/fwo1+0cf7bUPu69MQNVZuqcQpRDJjNfSu2UbQM5L42ceTixTR7UhoaGhoZV8Pqfe3JQfriXNjeQIj/GzHT4CWAnxf2NDofH97h6fAd1w0489bCN8akhg2yilvFgJMShKR58SJJrZzyp9QqZTtqQKuN1o24MGab6GwL9hSF5uvsmhGl335nU2rZGJFEWtL/izzlo+L4ReoZHAq0rqrd0EK8Tk5/qyY2/Rob9HEGnLjpjIn2jg95bksypWmKiK9HG4Dsn97bnR3fSZOK60RlDYL+6bq4vR9SJ2HyXgoxaiiYNArziKdVtnCyeFpfyMlhDml4J19+LJ2hUCZSpK/793MiGc8O5EldLrhltvZa0y6bm3hv2R9B7GFidfNmS5Ko6X9E7mX3XTux7UqTegQyy44k1MEWk0LAh+jtXTsLzZardfvyglPkpabOUbNtzCljuOVraRg85ftdUKeAKnvcNp0NTzDQ0NDRcIwQhQwVgX9jCpJy+fKKzKhmjlAEAtQMOt6Txp4kMYEer5CMjXztYdcmWNfKEiRCAhFFrdAL9XqK/1fnMUtqlUJaA2gnIA3Drf5vwpe6eTdtNjYilDNUd9PjJKmCAibSTsXHtIiSyBs3yTVg64bHqmbGxsfvfrsdJkQ5FYz4OJk60bGtS3VvCR14pM3nrtc3GpWwW1IRCJl55LDgnbgJJr8GU2iU4ltT1Gl1D8f3Anj+qlllo+Bt/NmU2WnQ9VXh+5MqbO1k+J9+VtXHM49qkHzmFTEC8urrLFDGT9wpX/5znXGnmnRkEudk4VEtUkxUrvE+K+89hDoE/qrT++VWMxFhi8rNcGfHXU/eIzcyn7bgkuZmYfmdvrijcQtHUyJqzQCNmGhoaGq4DyKAomW1nIlOSJxkkoC4ELh83aSflQZsMUALob3Q2BXU0KO+kJVuYVTZhJ7/OdLeDUbJIQFNuJx7o7wQO+w79hYS6sJmmJPxqLD1GedAQPYzJ7zuu0D3ow5WtElXHTDLD9dtoAjIjHOnsoAGhNDQACeVNduMMXun9wxVMISXUzqif0AmjfHFpo214mqsXvbYZkdSgkOEGxLTfbbaqnBxcC3O9+ustdd7mDERrjZ79hqc/+dmJScW1vNZ1fK2yN62UZncrbEXKsFn0EJExM/qk6JxvScpEmNV/KxMVU21YZHw8l+RyoIoVzvx9bZQQNVPIZJDzH+lwW92VdW6VOXPhNVJK9AMYVC9rEG70u0bOnByNmGloaGi4LkgNBAtezm6AraVRLajdQGD0F8KoZDSgOqTDP6QwTUjUKewkXXfd6DvOj0B3ElePd7j3TInDY8J6xrgBkt28N2oeedCQlxq7+z3kZQ8cFIRS8GmMSfrkLSZ5UxOR3ERjauB6skmp0kbbJMVAlLi2aHj/n6IJgSNWhDbKmNs7qJ3JnuVCmUyWMA2hlUlp3uuQAHKkDDURzsTox6A+MLozJB1NvV1ErEXkXs4HYJOJZQVOcd2UTMKmjI9z318LguYE5Mxc8qp4vzi7EoDA0JdmVnKYQX7E6Zvd5zlUHXtJmxaQN4GPViFZMGUizCG37UmIzAS5UHNMs0N3MvUHGQTp+CijjEz2XSIMqgbxNV1LXM3yfTpTsrhhHhox09DQ0HDuYAgZN8DgBrfJwYAA9E5C3TAGrLt7GodbAle3AdVJyN7s68Ka2FUrDV4CrhS/D6kbQkDvh+/7GxJXtwQunxC4epoJV9rdM9k8VCcge0PI7O4p7O72kFc0bAnQkKHZ31JShgtrileREqSM+7+0/nOZgPrsWgnTlXgiNWq3IzIsqaJ2EnpvzaT3At0Dd6EC3b0e3YPeEjKRsTAtj/5Or32iGEtBE78iSvpMeV5QY+3gc+LZFKPaLPLEmCIOubCokvAl1z+l1/TZTTpLkAqFPCJW75tUqmsgnODaY566h+YqJ3LX2qjMGedgzX4bkTMF25eilrgpIoZXUEBMkQtziKdcudXl0fdEhbImFZa99FqJ96fHWXTe1nrOxOd+4r49y+fuI4hGzDQ0NDScO2LfDWaCGr/w6URTd9bE1Zrrqr1RMuzua6i9yXjU39TQl4A82LChw/glLoi5cCBttikqnUrBpRUe+ZfsjJLCob9hZvPdJdBfAloCV7cFuktAKEBemTZ29xW6+weTtceVKWW9EWwtVH4iQute5BdzBKQGhKUreqnVTi0Ave/Q3+igrQpLdQJqNxhKC6UBAUirkJFX/XgATUOY6KRwQsESh/RpKaD20qu3ULPCH4VvjMijGg8DUtcSuX/N9TTf0LX8c3csRUTww4brvjLNhSdx5z4iTKeykJltyptRcp3Oup6YCW22HLL9oud2Qsma839aAzmPKe45tAST9SD/HCj1Yln03mTUlaPfkSeDlqLkOFchCrckiq/7c+6aoxEzDQ0NDWeMj/+grxh/WDhRdKRMf8Nk29HWW8apUQQM8eEGCfJg02XfMyEn8eBcJ0gZobVJ1C2NUmG0+gr4EKqrx4cwJ7UX2N/TEEpB9AKH2wKHW2YEYzIvKezu2NAlRepcY3Vryhgxs7pUQnDQ7c415MSh1NuA3beT6G92uP8ue/QXhmSTV9pcXw+A3b3emvsC4qDM76kBdNQmmg50JA1314ElY4L2KkMAuTCmkoklvR7c9kJjWglWiLmrykObll1HcyZMKaSu/4bzAw3vy2bX9ZNGXaQSNNtO1Fu4bdV2Ez5q8WQ16dMxMjae0ZaggPCdXETKlL7HZ+AYoYMl78EqL5bCz8cb6nEWP8mTZan6j4nV6qshUDLbBu1ppMzJ0YiZhoaGhjMFS8pQpDxn3MqoVQ/0N82P2gkoa/YrHgCi17i46o3RrwBEDwhrBOyz5nAIsu1YUoaGEQl45YzemTaoThhSiL51tK3r0ql6bDscQXSnN0oZlwXHZdjBSitOM7BVKEFp2tKpNixZDZwKMaHl6c6eX3t9XT4moPaGFOkeGD+g7oFROslLopCx6ipTqAj/BwLSpmSV0fjJmAKFMmSMuOzHhEzcv3HfRyvnXm3j2rtC2MKxVSXnpGKZs5reMGBWH1FCJr7HUoRloUowh2tB3DlyZiPVQRxqXA3u3CTMa9l6cskCMCaKa87P1LZzjnsWMUae0SJ4b6TVMhyOFT5Z3C9rXY9LTO4bToZGzDQ0NDScIf7i//PJIVyHTmAzq2xugOEmzD47TrR6J3uXiamPVkrhw5UAmOxKFi6bUyQUD1YfdaRkUXuJw2MdLh+34VO9xv5qKKG70j4d9u6e8R1xn+/uKHRXyqsfXJl0Bdiv7i7FxOC8dOBGB15FceQro3ZVumpF0u9sJjNq36G/YfyKDjelIdIeAPs7RuXUXRmDX3mljKmwy3ohREjO0DpI2BLX5/76dhNNGakAtA6v3xTYtOikHb0jaYyRscsEleyejVakuTLXINkcTrFSXOXL8zChlgBYizBw/ev8wdzH8bNzwfMoeQ4rjyG4NgixUHSNnDKjTMLbZPIezBna1lTPbV5ISNDf17wX1ygr+36am+WuIiyVtmMtnOR5x3gCPjLP3WuIRsw0NDQ0nBH+4p9/GYQ2YUbYAdpNCjMZAwI/GasgONw04UvQhoTZ3VU+FbUjZcTBhXu4t7WtgkkPLbSG4gYzOxtKYhUU0BiIFGkzPt00aordPYH9vd7v2t1XuLohoaUxid0/1du02BriYLL2QOnRIEK7EBaFpGltNTKZOtZcTfSgE4kFEzB2pdR/mSEg3O+ZlVl/LE7NBACW+FMXEv2tDoeb5vMb77AGzZy5r4RPw80ikYp1NFGDCW8yih3plQBOUYX42NyuuXNCsk7FnjSjVMFc089MJXOqOkvBkZdna/i7Juamfl5Cziidjl6Ky51Rz+Q5W2oSnDC9n6x7IQlWTVwD00TInNTaG4Y6rYGtyAuu/NlIZWqaWOBqaDgVGjHT0NDQcE5wk9hYKTMBl4lG76TNTGMMWOWVhrxS3ucDEoMyJlpF9WXlVh4DhYJpm94Zn5H+pjBhSPcNwSJ7jf0dBaEMSdM90NjdJcTMpUIvjGKmu1To7vWQD4bQpVGWJZoKuRMQTn1DFTRA/aA8/ntCPUNxqvj0LCFDP5sgOrJEjjOO3gkcblpzXw173u0mvfGU2T91wO6pK4ir3rZThKoY93vsBUDbkLvOCVnkrnUA43TYLuyN9FPRZI6GLtE2c5nJJto65b2RXQWuMRieiVOTIJz/xnUPczpbcmnNMJ0ViGQWqeu+lpCgZHcJOZPJsOebVkPOcIjJgIyR+VrIlT0Vrjr3Gp4VQlt5PbHHJYQJp1bhQlK4Y6oz1rlhN7v3SwnGre7LhpOgETMNDQ0NZ4KP/z+/HMIa6DrVSqxeCFb3xTAI1TujYFBk8tw9UIMJam+VAQqekAmIDDYcKfrdKhSG+uEHPboD+gsJKTW6S2EUE72CvFTYPQWvbJB05nvQ6IzsxahjtG2HU1po7RUSlJTRe6MEEu7YnQGsNgMZIbHqIIUlNPyXZEQ2Z4W7cHt2AsutALo2cYQMnRj4CcyghgnCG1y/WlLm8ukdDrek95DZ3TMeMru7GvKgIB/0gDP2tSSZJxiBNCETtTVFFPlrQMbbM2EZHOi1RDJaCHKt+TZSD5x4tTVqX+2gfOvV2FMTh2vjbAkPBqu29VSTrJTvlZx+zpUqKIIJdnxfRYsR1f251XN/ZRSVXUEcnKtyb0qtGC+MzCJoCTkT7pQhuhkl1px7d9N+Lb2WK6756/IsfZTRiJmGhoaGM8DHf9BXWA8XMxn0IvRYNeLgSArn+XEhcbhtTHZ39xXklfahSqKPsymRcqjZo7QTaoiRf4fsBJRlfMzkeJBDSKGx6zXEfeMJ0ykNCQ0htM9q4+qXu2E/0St0Bx2QTloI420TT+SVBqxSRu0loDTklTAHoxEeXynoSlNi1Snst/FAzw/o5vgbVJIyyeOLSQVyzThSLviuE1A7CXXRQe0N2SGUttmU1LC9S33uqvHEnDbhcXessa9Svn4d+7G4pEa5ECFOas6QMmonzTVAvJBypAw3+QvIGQ4cKeMbQvt52N+XuRSZDFVA/Sr4dRiEp3yZzj2cYHH7VgxjXPU8x5Pl1HONIWdmqUAqVQtbXtNzz2n2us0cH3tf595hheFQNcdR41lV2/fF25Nraeoa8t/Hvj5u3BCbzNM+o/sUZncsMTpOHUtDwxw0YqahoaHhnMBNCN1XZCCudxLqRgdlQzr0zmWmAUQPk1XJecgAXiVDoV1WClcv/S4iG/6Pj3l82XGxx2NJg1HdIlC9+IFar6B7e7ydUXPASZivOEnGBOgAisvaQ/vOFd+BH9Bx5pPxIK0wC1M2TImuLHsCxg5KSTYu38ZeQejetJ+oZdSNDofbRgWjOmO43N03aid5pQzfJQVkr9A9ULh4h0mtDsBk7rrfQ1yZHzfITXmyjCTmcVam+BiFGF1/7pi0EMZXiJAyKaNgX24i/ChQywRfMIQMEGT/CNw7COGzNqFAj4srP1YpXEdzx1QWn3MnZxxcW2cZfi+cyM0+z7l6S9qT2Kb0vE2RjQ4l13PqHuDq2xqLrtu5hrYEa5MyOYPg+FjX6uPSc81vIIaFBS4DYFCRHt41WOnZ2UiZhoVoxExDQ0PDifHxH/wK9vOx6a39vzNqh6vHdzjcFJAHY6Tb3TOhS/JgfGVYRYEcVDZxOmuhAXFQkDb8SSvgzh/1eOwZHdbGnT88QFuPGAGG1LCgihUBGzoijX9Or4Gut8ogqmxJqYxqEJA2GELLLNjyORKmUkkzUuhwGYwsKaN20oew9RcS2qVCtwbK5jwK4EZnjqE3iqZBNWPSl6ud6Ve501C9gDgIr5YSVwrdZY/dU4b882FPtixDlDAqGAbedyZFfPjt4L2S4v7wKjA9ZOty/TZFYtDryP/NhTC5Po72DdNvY1DN+FCw1JGvB+6ZQI/9OhEyUzjnY0k9m4+FRWFT8bMpN5lMKstEcrvYFyxXVqlKqmTSPPpuwg/qHMLkqsyFp0hmBlsf32oEaqW323iDsH9YAn0m5hA2WxsjNzy8aMRMQ0NDwwnhSRlOsQKMvV8EfIiJ7mD9VcxkdXe/N14ySpNQD6ZMYcmNvUR/U+LqMYn+QkAoYH9PYHdXmaxNSuM33nIXwmZz6h/bmQxKl2pIS9yb8BfvEeMrC5Ud8We6B4IxU0Jxoi2R4EJZDo/tcP+ZJgRnf1dgLwV29w4QV8pkctpisN2JusXMKTKmJFuJIx60OaCRmS4ACKC/1eHes3e4/0wJtQP2dzRuvENjd09BXyrIg4baS5OS/G5vQo9gVS8PFCCkuX56QF4aQk94Qs8qry4PhthxpIoI2+OMeOOwJXfNBoQMF7bkj8epoeRg8Nu7foA3+o1JmWLQuu3xxW2dIo2SmJN1ZarIwuIe1oF/KjvOtT3eFVfTq8JEaN0p1U6M2rauEJqVVL1FnxWRYtF9S/dLqUDCkNp0G3Ko2b6q7Pg5tMHzxmGuQfCsd++aChNLzgj3fE8ZSjPXhsMaz5broPRjyaZTpZtvCNCImYaGhoZzAZcVx6lbLCHjJsNCa+ye6tHdN4MQeeUmmsAoZEmYyW5QjwS0BNSFwOGmxOEWzOS8l+juGZ8RcdX7wZa+scPVhZ0sP1CDsbANR9LOZyQ2e5Xak0m+XaJAceKOfyfR39zh6ukd7j+jw/1nCTx4poa6ALoHEvt3dLj5v3e49bYeF28/mHTNjjRaAa7fBWlwdvCWG9yQ0Kxif4GUH4vbRQpc3RK4fDqgLsz33QNA9AKiF8BBQ14q9DdsemkNCKXQPQBkr7C7N6Q5d/4yngDplTH0BUJSKDCedseW6g8QMsceAk3RTr+jK/kSGC12UlImFX40NUEUAlCESHRmxUDg6xTWG5E39Lji+hsWIxeu5f6+tuTMqVA76ZoKsUoYxgsZbZMjhDZAieqG+zxW22XLYgzAR99NeMuwZTOkQRaMT8pSkmFLIqq23EkFZNxfU33HfV9AcC0xd1/1ObWBfw3nkfeGn33ZqnU01KERMw0NDQ0nBvvydqSMVbfoTgQTVXHQ2F0qQB/sB4wSQQooabIYOYNXcbDfK0D2GvKBxm6vDPGgbSiMNQv2gww7URY9AAzfiV6FoSa+ccIQMor87f7nBkfRoD0IGdpLXD29wzveY4d3vpeCeLf7ePYz34ln376Dg5L4/73tGfijX3869H/p0N0zWaBGzFQtGPl90QArI++PjWgDw9gEIaO78O/gf8Ccr0uFG+8wcha1B3b3gN19he5SG78he86Nb4z250z0PXCJ4NhGEwy3+iiEMfW1qdanEKQudwbCtm9Ery35o0yZO2tiTbyOjDkvTIibHzjr+ac19rJRGAyLnerHqXm8yifqD86voJCMySkBuOvKfZ9d1WxeBg2nBjWMJ/5VPlMa57nl9luAVGhJkfEuYzCeuwf5BhQQKIkJP1XnbEXOjIosKK7EdLemvKUo9p2KQ7ySBeYObnhXLSF9NyVlEvWtVgenWG44CRox09DQ0HBCxKsV/EbW4BSGnHGhSvKyHxQNOzkoYwSgpfReHf3NzviPXGl0qreZmhTEAbi4VNjdNx4zkGKYxKshW5K2JJG8UhD3TXpkHyalyEw99ujIWNPEg2ufXWovoS6kSfsNQO0F7r5Lh7t/XGP3J+7ivZ79h3jfZ/xP/D9u/Q/clg/w80/7M3jtO56L/rdvWFJJBWEuVQOXWnPODBETHCfjDRC0iw7Gg+8T7XG79QrdvQNu/57CzT+U3isGypAysjcG0COCiHrYABAc2UIJi24gLALCjeznJ2duP5K6VGgYVZVAKDW3xzkY+w59YVRPTLtABugp1QxNgx3DkkKDokumvW/i/qgkZKYQhyv6z2PTazDbPcTZP7gJGBdm0jCB1HuldBJWco25a1XaZ4V/rhNydka5JZP/rPdHRkkyp65c+UNF0XO+QD0zWfYU4SDC52xJOBhbTGK72ntty/szeSy0r+PFIOoFhui7GJEH2ZLj2OwZZe8dSt4vrcuX0ciZs0AjZhoaGhpOCaeMAZncEjgSRvfCjD/kMPk2+4dleVNfp7DRxidEaTEQFnpIow2tIS8TZrnRS9qlUxaXypIzdILrGiymB6JksClgfWRsGuwHz9zjwRMSV7eFzyh19TTT9sN/v41fe/sN/NfHn40fv/0+uLE/4O1P3cL+f11gf9cqfXrND4inSJTSiUoFRqSMBVWQ+Ek4IWFSZJ1TUJk/jKJEHhR0ryA6aXgwQm74cKRU2zmyJf7epSAdxeUnRsmuTEfK2VA3AD7MwWTdsgqcuF06Q6r4ujEoXxykhtDC9ycNUwrLHpRAemdD8+IU3yCTgIlQsiUI/S3IubWTWk2v0UdswEwn01yYScNMzPGO4faJ1S9KB/e3+z/5nJhAzsdkEebcvykCOLcNffaQ3909P6WuCJ4/U8/aaL/kPVJBFE2ZLB/bR6WovpnXGrvvjOtk035Z+fmfPL8PKdl/ndCImYaGhoZTw43fEE28icmp0GpQFbhJfSfMbJd40ai9mWyqvQS0MQSW99WQFZsYA3toHQ4oiB+IG2TLK2UGHlZtkxwEZaTi7KBF21TDMNmB7j9D4s6fFLh8QkFeCXT3jJrh1u8J3PoDDaE6qK6D7m5BdcAzemB/V+HiHYOxbRHohGPtSa89HxpgRS/xgH00CWeghSXbOmHCfA5DGJkAGbxr/0+wsqY5FUlAXEUrjjEidcxY4TOoTmJFi+htum6bRQqdudZ9+JJts4g7S2N0P8D50xDjXrc3dx3Hx6kFIIQzzpZWMeOOK6reHccCMqZEkh/4SNl2aGe2vCSl8Tkjp+awaCTMBlhbaeXKo0q+qQnyVj4Zme9nozasKP47QZ4Em9FNbH8GzyQuTDnzTMr2xxG8sGrOx1HucReGynmCTSwAzPGXKd1nidqlPRsfXjRipqGhoeGE8N4WQDTwAhCvrjkSgxovOlNfQVffo/2UUbqM6warKvGqHTtZdESOtBPjYGAZiw0UTMNjPw6M/w6UIfR3N8CRgN5pdPcFbv5vhcd/5z66+4fxaiQtmxt4piaBSwiZmNQhf2vr66M6CbW3BISASWF9ZVM9Kw30pm81xHgSzsmKBS3LnmPnVcP52dBdNYzCKSWTdyuzsckvQ9S4FNnu9+S5Bsz+VnmjbUiUO++BOowSSkFlrv322rOZwIRS/jrQTvEydS24drjtRUIphvBe8rtPzNFqMrnEYUzBvchNFk5BxEykOl5cZsNpsKIRsA91RAEhA2x2Ha+lVGBVD1NKk5THSS0JQs3PibdZkXomrjqe9Ce8aKb6LaXwKamf1lPczkQ5HFLtilXH2TBU16eJc1VDniwxCZ5EJszo2N42DduiETMNDQ0NJ8ZogGEHCybkA0PKaIdoddLF9gulTdroXkDaFMNwmZOQWKmiZIwjFXbCy9B9hh7FpMSOBzvWb0Zo7RUMAEZKCOeF4xUggFWBaNz8IwWhJK7+yJjZQgH7pzRu/pFRxIjLhNmxm6DL9CBrNjIpZn0YmiVWtDCkzOHWDv0Ngf5CGHJGAPt72hgUXymfdEgDhGzQhGwI6/RqEXv4Wgpg3wHUU2dqcpDrF7pvlPbab+IJO/AZjIhc33sPSUuEuGOKCZmgAlcO+R3DsXuFkDLZo/yAm/OHSZEuQgCMjKmKTFkBzguqyk+iFkvUEWsSKI2MSaJ2lf1kyIVWuvcVMgRN5jqsnfwuIWFyRGu2DamJfck9u/B9NFLPVJAzXBumwpSy5VQiF464lR+Nu/6CRQMgfR4m/IDWbufs/kySowuJyYfYr+w6ohEzDQ0NDaeESPxu4ciZ/IqJG/3Yf5SAOETfBWXyTdECUBcSh9vGIKR7oNA96Ie0p/HKoFUlaLdiCgkolZx4B2SQgPGV6aQhgGBMh2/+4SUu3i7R35A43DaT190dhf07r0wZF7vxZJaueHl/FX6gtcz3wNUBP/F3ZIGGJZmEIU3Uzv7sDTkDDWhJsl1pDGoSm+nKkWi6A4QWUK6t3odG2VGYJdAEzLnWyvu4mP4Nj9sPhBH1G/e7xXBNWaKIkDJmA5FfQcawnfE8GpRdw3b87jlSBios36lw2IlHKSGg4mMt260EycxKlgAFYM87hjboQvVBCU456C5IHR9s9whODs6ekKHg3kHa/+MJ1eAZW3BOa/tgLS+P4nqXkDJMnbWGvKN2rhxaWfLdFiipb66ZcbhT5l1Ft8l9vRGJNEJBQoEcqtvYSPOzQyNmGhoaGk4MPwBzxr52chagYoIlEjPeJCFjlTLqosPhdofLp0mT1efKplo+JDxltLYkhFFESPQwabfHpMiobktESCvPcNmD5EGh0xq7ncT+qQ66E5CXxD/GEkEp8kc4/xFPeuRRQ9QIe7xGVWQVDy4kiQ6iNdBdmhTkQknTjwrY2XTe8kp5Y2PfF6Q9vhyBUZiTsP4DAplBWDSRCAazk/4PQzsEJWWmshal1DpChOqQisnM6LxoHX5GlThAelWfK8uBnocMKbN0YB7vryUhJXtHPlHV0kokRa6cKWPXOSjZN67zESRkrh2Iya87x16Z4NVzGKndAiycdFJsYbSaTF/NNkDz28WEd4FSZZQVZyNlxFTY5pw6S0I9V1Ua5soSApB6yAgYh+Vy2y+AH6vRd3b8vat+qqoFYaOzVXeNlDlLNGLmzNH3PX75l38Zb33rW/EHf/AHeOqpp3D79m0861nPwnOf+1z8+T//57Hf70/dzIaGhiVwgwYpoWEm8YEcF9hm8uJMajuJ/laHq8c7XN0ySo/dA20MZq/6MCU2EJrp2VTHsOlSRUnojMvg0ZPjilQCoteQ6KEPYsgs5FdhLfkUh8UIeP+T0t6apUwgXi+w4zLjmzK0vbt7QCcE9tJMwqEBcVA+1bgH8RgRVnlEszYF5AzI9aCd+kb7AalrW/A/Z0hJjsMjzq4FmAEup5ChappUuY6UCRQyfF8nQ6ZScF4xUXjf5H4xKoxmS7LExL40gQpGGNJVdy6ky32H4TyufY9PkTL0/ylMEcNbhj4V9MtkWEqT6y9DhvRMKj2nnq0bnpMav6ea7aoQPY+mUnbHXmEp4/BcGSmsrfYoMTXfot4kqFdMnB47tX2MjNfMaHdHyvQaZiVGBPvG/RBm4MsQ/TNJmWqkiKBG1pwcZ0HMfO7nfi6+4zu+Y5Wy3vM93xO/9Vu/tUpZNbh79y7e//3fH7/xG78RfP45n/M5+Ff/6l9Vl/c7v/M7+Lqv+zp853d+J/7wD/8wud1jjz2GT//0T8ff//t/H+/7vu9bXU9DQ8OJ4d6JZCA5ImVKsSAkoL+QuPdMk8L4xts1Lt5+wO7uAcJ6mOhg0GFCd/ROGpWP80gpUco4KM0qe2JD4qBMp36gKVrd5F8Kv3Lrw7/sNhRziJjReXDeOzAkjPtd62HAJg5q8IyhoASIEAAdsO3kUB+t0hJOQXdFhICIUj4H4UuUSIlSTCfTZMfx+TESxsCUyAlJGbATOA65VNyads2UiieF1P2RUZDE1z815zSfMaoYN1EhK6o0rMsrp+IsaVPtORXWGrRz5eQypBX0w+QE8Jz68VjIhL9O7keRCaHVjpgPoIfn01T9G4SxcX4mAH+PhjsmSOvUNhwYr6skovdlqm2lar0cGRWXkVNZJJ9jBfUcE6P6U6FmJed16jsw52HqWsjUO+r3Gdf/ov6fUGc1nA65Yde1xK1bt05S70tf+tIRKTMXr371q/F+7/d++IZv+IYsKQMAd+7cwbd+67fiAz7gA/A1X/M1q9Tf0NBwIjhvFPeyrB1Tz3nJCruK39mB6wHY3+mxf+oA+eAwGMvSZno1hB1Q9jY8x4U8eWKpohk6/PHHQybA7if2mDFmszbbURzu4sqZidBXZmirvFImxOqqh7A/8qAMkRV7orgfwLx1OUKBmgm7Y4xj44OBdXictH/YiQkhUnw/9VF/SRjVlvWv4cpz55fuG/R75AETtJWdMAwkWxLOT4cos3Qn4FNdZyaO7PWQQ1yWV5VZItKF0VmCxXwWptwOJjGd2Ve57ZxapteW9FSDIoxrxxYrmMdYFU2RTQXQYob6qYEHJf7mnI8UiUaUjv6ZH3h7kWdnXPeS9lRi9E5JfbfU04nzMSkN/UwqCYd2p46hqomZvqDbcEiqAQvqPAaC91SsBKXv36LCmAUVVzT92C1eRO/zUxNWxWikzFniLBQza+JTP/VTj17nm9/8Zvzzf/7PVynrG7/xG/GSl7xk9Pkf/+N/HM973vPwjGc8A+94xzvwn/7Tf8Jv//Zv++8vLy/xD//hP8SdO3fwile8YpW2NDQ0HAF0MNGJ8eRVoGz1ce4kqJPob3boLwT2dzW6ByZz0MgINTaUlcJPtsVBBYoZbeXETsUxR84sSCaqwMzVeqywq4xzV4ijfUfqCADO1NK0zYQjjRQxSkR9Jv3yx8iQlg1nCgmnEfwgfWJSQ+pIpROtIStGZbhBboH0W2gE6d1nQ5o08cKGMQEISJl4Il/iKUNXjXUnTVl63FbnKeTUYUKrYTHW+UL1CFbAadiS3ofKMpeBS5ROTs/NHDelbuHaN8PDZjXj44cIq5mP1tyLOWWTb1eYjSlLqJWGwhVe5yn/k5IU0GFB3EOSebalFBgl4buFqGl76fWwlsJlrsfNnDavCT8uUWZcEoQ9VYQvjQtmyLj4+0T5a9zP9HzULoKx+7QwprPAWRAzX/u1X4sv//Ivr97v3/27f4dP+7RP838LIfDiF794xZZN4/LyEp//+Z8PZT0Ynva0p+Gd73znrLJ+6Zd+CV/8xV8cfPYe7/Ee+KZv+iZ8wid8QujdAOAnf/In8Xf/7t/FL//yL/vPXvWqV+Ev/aW/hA/7sA+b1YaGhoYjw03kqffETtqVSLJd6qXJxQcXSlS90WxnJpG7+woXbz9A3u+HVfyODC5I2JCr22cT6nvj/aK13UdCQxlyogCjQV9qwBNPmt0vpZNCDtx2bjB7GMgXERMncSYk2q6IiBn5MTDkyMhMk0GWlMkNrKLYe7YOQnaZjchEJPKXcaqp4LjpqqTWPguUI2eES7PNNbNkUCij4Lc5vjIWYxk8bJp4GW2n2e2o4fMI1BDSmvyqvYC80pB979VG2euTCydZQ3q+xuB7aRkxOTB1TOdCSJ0IR1+Br8lmJsPnGEuqcddt/Bx3SkGNZBgqh9VNgKe8ubYgDRc+w+IJds7kd6qvrlOWsFnnXiEkZ4CAUM+ZN7s6q7Cx8q+2D+i2HDn0hp992ToNa5iNsyBmnv3sZ+PZz3529X5f/dVfHfz9sR/7sfjTf/pPr9WsIrziFa/AL/3SLwEw/jaf9mmfhq/92q+dVdY/+Sf/BFdXV/7v5zznOXjTm96EP/kn/yS7/Ud/9EfjTW96Ez74gz8Y/+W//BcAgNYar3zlK/HDP/zDs9rQ0NBwZHhlivmhU08/eStYuaxdcXRhGGovIXpg/5RCd7+HfGDCc0YpqBEqFEz7TPt9JiQflgI2UHZqlWjRoHBqMpHzsKDbSHLMWgPKhmi58Ao/aaB1YyCuOmbCAfBkhK0zHmD7a4AhHgL/nPjYIvhBWM3g0IfTEaIoNlSkx0sHhkKHZfiGxDOHgnZE58urlbYIwHZZyXZD4T4FfE/CtqzXkvPVEM4jRo9JRSOtH5QE8gAf4raJ0e/E8QHYvs6aelLbPOIkzFrYJL1vzXnNvY84UkYOzxKtwIf3JZDLhsN9P9qGez5y6sUMKVOtSllxwj47K8+MfZcQYVuQPiX9PlKIKmD0Ekq9VwhpM9X+0Xs826Z8WTWoKWt1IrNhdVxbj5l79+7hu7/7u4PPPv/zP/+obXjrW98a+Lp88zd/Mx577LHZ5f3AD/xA8PeXfdmXJUkZh2c+85n4qq/6quCzH/uxH8OdO3dmt6OhoeGIiMNmnDqDTt7ige0SdYivDFAXEv1NCWiN/VPG7Fde9qEShO6iwfoDaBuG5fw0sJODooIgGEA4BcDUzxLEJBIwHVqhBjWDOKjBM0WpwUMFGGLLbTYGY+o6EGwjnwwd/vg6LLnlDIWDH2qoDMD53PiU3SSrVlFYCfWtiX8cHBGhFKBUQLz5MqwPjfdN6YgHzEQ41uTqukPi3Cf7d7RqnCYzaZ/7bbth4D2e6OkhBMkZYQsM56xXwfEPA3P7/dWQJv1Y3hosltxPsVdJ7jjm1LOBjH6uL8e5TFw2af+W4Qq56yGR1YlmoAuIfos5fZAy/01tw2+gxwRzjFJypaSsQpQcT4mXTNyemj6uJRVGPmXHAFV0yuh94LInct5ohedo0tMNJzjmQpxruxoMri0x82//7b/F29/+dv/3M57xDHzKp3zK0eo/HA548YtfjMPhAAD49E//dLzoRS+aXd7b3/72kdHvJ37iJxbt+wmf8AnY7Qbx0+XlJX7nd35ndlsaGhqODLuiI67UkOVnyxVlmklDGFWAvOwhL3uTTYhKe7nJuwU1ZPUT9q4z5IwjLOYMAujEbwWShhooBuVT0AlCr62przIEhT+24biMf4z0pIxXt1jyZKg7ZZKrRwRBqi/G4TT0vJiPRkSEHPd9PJgcnRvXtqhNmp5jGs4mMBx3qn0Mig15E/4xLJjigv0oKRNsA/g068qe+4M25s72fjT+SfCeQt4fhrbTE1VhW4XSkAdlrqeU0W8JTknoTIVcrRVetQYZy2DJxP4U4CbVtaviye0p2b/03E2cK5eBzBHIIM/JwOQcgDO9p/fVEoKshAxYJSxl6tmUUw7ORK7d1X02kyw69T1SBOYdRE3vHQIlLBASaYXkVep6S75rgzYliLQNSdSTkGUNRTiLUKY5ePWrXx38/Zmf+Zm4efPm0er/p//0n+IXfuEXAADPetaz8PVf//WLyuMULlNqGYdbt27h2c9+Nv7n//yf/rO3ve1ti9rT0NBwJGhtJpW9C5vIZGip8WJI7UMm0vKgIO5qiIMejEl9OJKwo4Wyt3c8eTefRW3h2skcQyAJXsE4lpPvelPa6LMglEe5NEZMFqCorz0J4EkgSwTQPiX9EmQCyRFf3LEHcfBhfWY/u08ngF6NiKmiAZn3SJGmHPvZqE0cyUJj9RlyxGNqYrfCRIbK2EfeOa4NLuRIGUKG9RxwH1kFjPssnmBqbbkyMuk9tfnlIiTMkuln/j6lKPHESmENLx2E9/2ScI9TY3abU++AuX07IyROC1ivKT0mT+kzMGrfMVRLs+pIks3L2uLB9Ufq3UDqPoXKa4kZ8NxrutRXhzWFtgpQr/7sRNi3lCSMYUO71w4RzPbfKcJdG06Oa0nM/Nf/+l/xUz/1U8FnX/AFX3C0+n/1V38VX/EVX+H//mf/7J/hOc95zqIy3+Vd3gW73c4rcADg/v37uLi4KNr//v37wd/PetazFrWnoaFhe7zgI14FgE4ehonc4pf/1Etda4gDILTyYTPFiCdOzoOkZCJNV2wLDV9nIwi3Gj4eJPPuAzFWrkhLSji/HElSJQNAN2F6SRUxrm9tH4k47oYjPAhi0idGTn2iO2nIGTWcn9HglsbRdzCkHBAcNz0uX28q1M6WNYnENTAKUSL3RzFZQ/YbTfRGnjc2bA0wxChHcPpto3vTkjLaqa2If4G7j5fey4uInY0UKCw5Mxe5Z0EFGcC1I548buK9siFWaesU0TWX/GZUY0FZGoECRksBH8bJ7R9/5vZLTLo3PY+UlM2BI6DjcuJto+9GBEessiF+b9yxpzx0sv0TlTsnq89cLPHCoX/PJ3eG90iwoOQ3iM49YwK8Bs4lZLKRMueFaxnK9G3f9m3Q5KZ53vOehw/4gA84St1KKXz+538+Hjx4AAB4/vOfj8/93M9dXO6NGzfwQR/0QcFnTpEzhd/4jd/AH/3RH/m/n/70p+N93ud9FrepoaFhY2gML/wEieCxQriAk5UHWZXcyn6s3ogHK84HRSfaQsJXgsnoyL8lMyCx5R5FZusIEypZ9v4xzjtFmlTHHSFl4nY5L5j4x5EyWg9+NLEyJg4NAgL/lJGPSoQgJChQNrhzaX8SA69xZiJhwrN25kd3xhza9wW9VsnP1IrtludyFCLGIQrrGsnLNfx5Y9UFo+Ml9bnNNb126yc76ePL/70pEs+couOqfV5lQgtrcDaTnQUoCX8owhrhSrV1ETiPpZG3ltue2T9+lmz17Ci+TmLCPhWiGYe+FCpfkm1x7yJaXoUnTI0qcg3krtml9+Si/cl4RrvQ4zh0iW6bQ6y8rGnGxDuyocHh2hEzfd/jO77jO4LPjmn6+y/+xb/Am970JgAmhOhf/st/uVrZX/RFXzSqqwTf8A3fEPz92Z/92ei6brV2NTQ0rI8XftgrATeQIb4jLFaR9ZuJjt5Ln1UmgBChgS+30qe1NcGNBhpc+BIwPbGK/Q7WMP9NTEZ8m5U5BtM+DMfJkVHOE8GREoFKgAzSbL+AGOaOBvPSeS1g9BNjimgYETI55UoJKKFGrgHdEQ8dcszuuFcZbDJtDo5bM59x2xHShO7ni+nk4AETXV++v0v8XxijaNErbwIsOE+gBaDXyGqE5czrhKuf+yzp5cTVu5GvDEVJmMN1xyr34VpETo7IdN8zKDmGWP1Ug6lnVvb+Sqhd/HexwoLbx+2X8d/ymMoSBP5YtiYA5pa91C+opkx2wYG+37vEOcj5AUXn8mF8hjScB64dMfMjP/Ij+N3f/V3/961bt/AZn/EZR6n7t37rt/BlX/Zl/u+Xv/zleO/3fu/Vyv+Mz/gM/NW/+lf939/3fd+Hf/yP/3F2n2/91m/FN37jN/q/n/Oc5+DlL3/5am1qaGhYHy/48Ff5Se/ISHQuIkLDqxzsj4PLHhR7gwxGvoOpbQDtFAUYyIcIk6SMFOPB75qrucTTYzSAd+SJOwZgIEvcTzeQJ2FGJ+1Xf/3EOzeBYVZYfZkF2aemVDL0eEcD8bhNlljRO1lECrlMKTTTkwgmWRsMSgsmg7F6iCWm7N/OZFf0xsjaH//FoPzh1D9zyCavkDoo/5O6DpegmJCh19NUeBCHksl55vodGW3TMlPt5No0gyjI9dHUdd8QYU2lzUzSZ63zxN6HLNGbuV9L1CUlyhput3gzSt6k1DlcEzNExTkoNmg7tjLkZsuN/Ne0lOYnFWZGF2tWQsoYeGqbo+CYXjYNk7h2HjPf9m3fFvz9qZ/6qXjGM55xlLr/1t/6W96k9y/8hb+AL/7iL169ju/5nu/B533e5/lU4C996UvxAz/wA3jxi1+M5z3veXjiiSfw1FNP4a1vfSu+8zu/Ez/6oz/q933Oc56DH/mRH8G7vuu7rtqm3/u938Pv//7vV+3z67/+66u2oaHhYYFRypCUunSRvtb0MrG9V8dIR8BgkOEe7OoeU41vU6YJQmtonwpIB8cStAs8wSAk8sqgUpVNBqwpoWuL1P7vnK8LrY81jWVCkkbb0Hom2zxNznCkTNKUUJC6nT+B3Y+Gsrm+CvcVQx/aa2WuCqRqsEnaFvjJkGMIrl1CgND6qA+DI5rUXkJLoIOCuBpf/4EZs/ubnIOp40i1gX63+cA7RXS4e2aFe+tofgQzDYCvG+mylufNZsc99UyeYQicwlwz2VFbStpT7FXFKCfoxL0iZCkHf+yp90imfNboVq/QnwymytyS/Bn5xM2BW6Pizh3nJRN58SzBFHHsq9T858WYc082cuZscK2Imd///d/HD/zADwSfHSuM6dWvfjXe+MY3AgCklPiWb/mWIEX1Wrh58ya+67u+C5/3eZ+Hb/iGb8Ab3/hGvPnNb8ab3/zm5D4XFxf47M/+bHzlV34l3u3d3m31Nn3TN31TYHbc0NAwDy/4iFfZSbz5W7gJ75KXIhmM0omsUQmYFMC618ZwVpsMTKbuOZMea3irAHTgBysZUsZ/3g2TbwB8uMMKE8DYfFVgIFAmfXziiSEnVQfG5VmSJFkHgxJD2yQp49rjiadBARQQCxKGYJGkTmtgTLNTjYg3DR/iEx/XKj4HGXhyxoVTSUAcbLsoYcbVS1P0OmIqIEs0S+ykJlrsBFoK33clIRazJuFLshvlypnzzFmrLW6fqXucTjDWaP+Z4dQKhmKknsknNg3NKjQzxN7o+ZULOap5T048x6eIhYD04AiaSnKg9Hk9yzwYYXvn+q6sYYw+WUaKXKF9HKtk6LnfQEHjUEL4V/dRybO14WxxrYiZ17zmNbi6uvJ//5k/82fw0R/90ZvX+9//+3/Hl3zJl/i/X/KSl+ADP/ADN63zcDhgv99jt9vh8vIyud3t27fxpV/6pfjbf/tvb0LKNDQ0rIOP+6ivNNNdSdQICwmZwPckHkRqbdQ4KqF8qKnbDUg6ZpEp8f5PZtAh6getYcJkaDaPlF/KCgONKTImWKniJu1+w3CgtkSSrD1pMHE+4nYmBuxOIYIgk5LdRgLaKbTsedAaIz/jQWU1tCs1kaAoWemLywlUS9nwGdtXQkMm+ooaTnvVmOOrnH9MP1bLVK0sx4Nee81O+pi4fkSZgmpV1CgJcpjYt3qlt5SEbZOMxVhFtUV9wNzfR27THBVIap/R53SCPvE8zipcGBIgd4x08j0iUTYIpynpv1J1x1IcjZxxiMmW+PegYIac2Rg59VPDo4Fr5THz7d/+7cHfL37xiyGOcLN84Rd+oc969J7v+Z541atetVldv/u7v4vnP//5+Mt/+S/j+7//+3H37t3s9nfv3sXLX/5yvNd7vRe++Iu/GPfu3dusbQ0NDQtAVv6d38cIOePbxGfeR2Y3mLT6LDNXakj/W0HKxGajaiehLjqoGzuom3uoi50/hly8eIps0AJjA+IpXwy6XcbbIqhj7utBM14qcbw/R8pMmRYzPguska/iszx5PyIXQuauJWfYLEVAfBUfbiyNj7x0SidCU5OPwOtHkRi+WDFF+kg4Y03XD2Rb7xlCj58Qln4i0iuIS/vTZ8x5Y2+HlMdD7JWRO++u/e5HOYPgsG+S4O7VXChgDmuqZCIskt/HHiQPgRqmBMfyuym+1mIkvIT882IDwqzEB4j9Pr5mMtdQVuVRqJBJhsrGv8fwfZgvb8vr4tx8ltZSjmXLoedEYcjIOFno+B2wpP+W+OxUY8LLruE8cW0UM29+85vxi7/4i/7vrutWSVM9he/+7u/G93//9/u/v/mbvxmPPfbYJnX9t//23/CRH/mR+K3f+i3/2e3bt/EFX/AF+ORP/mS8//u/P5544gm8853vxK/8yq/gB3/wB/HN3/zNeNvb3oYHDx7g677u6/DTP/3TeN3rXodnPvOZq7XrC7/wC/Fpn/ZpVfv8+q//Oj7pkz5ptTY0NFxnPP/5XwUhYY1lxViiUGPSyYUKUYrdETDxxBFID1YZ2XegPuiGbE5aAPKgIR/0RrlAFBWalkPbzgxCNQoHRg6MPFcLkfesoccHkMl++DUlougqKDt4LiU9agdBHAGS6R9DSMihb+OVXxXVb89VmLUoPudikrwrkbfHCEIGXCicBC8vp7Dn3KfcjaUu9H5yq5vxJFSTlPAT7c6d36TaqiKEYjCdttchGDNsdr8VRvBLQ58y2GSCkZPjPyLEzVqoUUrkzntJyGW2zNQ7Zi1UXBdZJeQUqIoil62JQwFhFKtn6HdzkFImreVtdOyQvJSqpAhqWDDyIbtMqNOxiKujqGHa8/Ja4doQM69+9auDv1/0ohfh3d/93Tet8w/+4A/wkpe8xP/96Z/+6XjRi160WX2f9VmfFZAy7/3e740f+qEfwvu8z/sE2z3zmc/Eh37oh+JDP/RD8UVf9EX4pE/6JLzlLW8BALzlLW/BZ37mZ+K1r33tamqi5zznOXjOc56zSlkNDY8q3KBWS2FVEsPnfqBAzU5HK3LMZzZcyY8T3ffRJF/nJOhUqcKED3mPD2EJGimAvh+UDGSQGgwylA4y+wSTZq3NGCg1XmDaIjQGLxRiEOuPceXBDWcMrBnyJBj0zontzg2amGe4H7RTUibYwChe6HfU/0YLqyCxpEVsghyQM5ivhGB9WxwpE23n+46D7XOBKFxIDvfKkM47GnRrXvWTI49Wiee33jOjycLWGuW1Qpbc/muusC41pGyrvdWIJ31zn5Hxe6kqHJYJ+zsFkuTUTFNzdt9qpeJxQ1dKyq2t+xikTLaOCXJ/dN4lgJ5e09H/TJ3J/phxPcfnfBNSZuJZu3n9DYtwLUKZ7ty5g+/5nu8JPjuG6e9LXvISn43oWc96Fr7+679+s7pe97rX4Sd/8if93xcXF3jta187ImVivPu7vzte+9rX4lnPepb/7Id/+Ifxgz/4g5u1taGhoRzP/7ivAhCF9bhJMeAnlprKTb0KwP7Qzyg0zKSThLiIYBI8sDYuRbA3RAXy0nRCfgilIa8U5KVC96D3BsJxyAf3kg/Md237fOrp3KCYCVNiB2gMgVNiSlvlgeHCi9x5Y9o9XSfp/6h812Yq44/DdHQnoHbShC7tGFKGrq4qTULY9BA6E18fiWMZt30hKRMrZSSy10xRub58kOufbpu/vlaVlOcUOdzAf6sQ7LVDgQrLqhrczyVYHrEwJwCLQxBmTbqYPqYqO6/GLD0P537e1roXJ8rhnjO5586c51L87siVmw9BXvHZWICpENjpAqbfY1pgUMJ2YngHzSHmau5JZrvcOeJUTUUhwhSZ++3Y6qaGelwLxcz3fu/34p3vfKf/+93e7d3wV/7KX9m0zl/91V/Fd33Xd/m//6//6//C3bt3A0ULB+dF4/DUU08F+0gp8R7v8R6j/b73e783+PvTP/3T8Wf/7J8tauu7vuu74ou+6Ivwyle+0n/27d/+7fjET/zEov0bGhq2wcd97D+2KYrN3wJ2sugMSN1qvzNqVYA3XmVktcItWXqiQo9XtulKvYINmwhXPAGMSBmvlGAGEmaSL0xGHALdiZECIthPa6Af6o3VGJMgxqrBgKJgkF+y8peTYVMlh9CwviiuXXRD13/gFQvswGzoh5FSIybL6O6OyBBiuE6C0CRLSPSEyXKqp5Q8SYT1Bftjug9HxaVODb1OJkiZopV+R2ox4U3cdu5cc2ECa8L3o2QUVscgZx4WrGQwe61xymOP1EouM9tqZZ4Tcoa/8X26UCVTOzF+qCbSjJHulNcOW4xf6El/lywrPl9bPodzauQMat5NTfHy8OFaEDNxGNPf/Jt/c5NU1RSxie6TTz6JJ598srqc7/u+78P3fd/3+b+feOKJEXkDAG9961uDvz/u4z6uqp4XvOAFATHzcz/3c3UNbWhoWBUv+MivNC/kOB5dCR9yoaX03i0AIHoNeTWs/jhzVwAQBxUMCoN0v304+fQrSLEmMhobJD0DmEGESOkr3aCDm0gpbSbOkg7EqBKmYLDiiIrAMDfcJDuJXyild6SMcGaBQkArYQivFClD9nVhZKNwNdseDfj+G5ExnNeNJ1AwImWycESgEAOZESml/DVVmYlicjBt4/pdWFwxKTMRmlNkmEnO+ckGsZmV2aN4DFw3HCNsqfnXlOO690npc7/keVebqafUYLZk3xxJZEOJgfyCw6jqEhI8s28Oo3ZMKFRqSBlfPipVL4yfzFBg2J9J1N4PXFg2U/wx3gX0nLT3znni7ImZX/u1X8PP/MzPBJ8dI4zp2IjJmj/2x/5Y1f7x9n/wB3+wtEkNDQ1LIQEtJZQNRfEhOQcNeQl47xYBT9bAhaHY8CZH2shggANoGONb0Wuj5hDCKmpc3YZJSZEGQIIYIav8Oe8Rbr+w7OF36g3jJuglpEyQStoOrgNCYmpgPDHBq5GWLwIhrtzxBwSNU0w5NQwSK4law8QT2MFlor1GycQtJ5JznqgnBjdYTPZTZmCrhTDHORG+VDJYDMyEE/UdFUHYnW1TpNTh0tkHJBvBdRswF903NZ41pyQCzlSpE9+H180nYuvJYFY9kTB93xzcO84/HzCE06xVV+J5MoUtzs3IUN9XFlZS2tZs2zJ9yJId0btv1IbCd+MkmGceDcvewoy5BNfhefEo4+yJmW/7tm8L/v6Ij/gI/Lk/9+dO1Jrt8IxnPCP4+86dO1X7P/XUU8Hfjz/++NImNTQ0zMQLPvxVXgHR3+hwuCWhOwAakL2GfGDezrJXkL2CVtYQ+GBIGaG0ETj0GvKy9+X6sCcFs41/yUcDDdj0wW6/hYM/dv8CBQO7j6wMZ0IYZqWVLlsl4yaBFQP0WKWiOwyZjgo9UmJSjO3HDBkTFjakis7XOQ5J4/qbVaX4HRzxo9MrseT7lIGih1NbFXjKsANp7rxF9Z9ssJkInWLBkTPuc7rZw7qiOYfsyNzHjxJS18Ia18iS623Va7XmXirA4rZVKgfZfTnEUWEnIphrlDWnrGfptZULVw4/oO9q8vkSU/W51/BWRtkr32MN6+OszX/7vsdrXvOa4LNjqWU+4AM+AFrr6p+Xv/zlQTmf8zmfE3zPhTEBGGWY+g//4T9Utfff//t/H/xdq7hpaGhYH1oKqL3A4ZbA1W2Jw02B/kIOT95eQ1wpk3r6QQ952Ru1TG8IGnnVo3vQQx4UtADURYfDzQ79DQl1YcKg1E5C3dihf2wPdWMH3UljFktUGYHpLl3R50zibEpsY5Bn9++V/TH+I+KgvOEqZxKYlUZnsu/UmI261N3ZQRstk7TVFJImK0btF8IokDpLjElZptaRw3kYkTLC/Qh/PIGZMoZ+5Yxtc0jW6fqixFSUOb6g73odTDCyppOUvHFg6qeriSaELDpvCcNiT4AdcxJfYQDJhaKFG/DHdR39Jc6CTKoJheKeO9dgslJryB1jibkrt+9qhusU1KNjQXjb6ia23POsZt/czCtF0rCkfiy5GD9Dsk1Z2CdLr8FS1Jw/+g5ZBUzGvcnt1wjF3JCUWbpQ17AtzpqY+aEf+iH8j//xP/zfT3va0/Bpn/ZpJ2zRdviYj/mY4O/v+I7vwOXlZdG+Wmt8y7d8S/DZR37kR67VtIaGhgq84MNfBbgBi4AJH+mN+kVYpYvz3DCTTXjSwxnMegPWXgMHNXjISEDvBJT1pVGdNGTNrQ5Xj+3Q3+qGlNYxIpKCg5/Q7ztD8LjwIRdedbA/lpyBazMZDFJyIzloKxx0sAREYkJfkmViNAHOkDO0PH8cRJ0RHF+cVjsmRgTzw8G9kWn7PAEWnrskOROXH5/zCTPisKwZxAMS556qWnIDV3KOfDYp93ncrtwEactMMCkVVKa+SXLmIcBZkDJA+jxMEZIbXTOnINhydS5pz1blZp8JpyLK5hIwU+SII2dKPW2IojIVllNVfwnWIhgiLCFzasmZufVObregX7ILGFsjHjtcAwL6UcRZEzOx6e/f+Bt/A4899tiiMoUQwc9P/MRPLCpvLXzyJ38y9vu9//u3f/u38ff+3t+DLnjAPvnkk3jLW94SfPbX/tpfW72NDQ0NBXAKCztgkgeN/R2Fi6fMz+6OQnepSMppGBJEwKsyXHpkDztJlb0Jd5IuqxPMS1YeNLr7tkxXtxRwZq8+RTY32JIMiQAMhsQaVsFDU10rY4hLMxUhIiqmBnaMUifeh056R6s8cdluMr/yWCNZXqK9xuAW0yQMIRw8adQPxyDI+S1e0RfM7zMGkUWDRpf2GqSPuPPOhRoxBOGIOIvJs0hNBCG8amqETKrQVa4PrvxCpdfQmEQnM6qZJeqGzRBc9xvWE/frktCApZhRxuor+DPqnvpsLugkk5tsJq/bkvcDUKViSl6Da5AUNSitL0fKHLvNHApJypLrKVZWTe4zsWAyB6t42VBw1+6Z+lMFqFAmN5wGZ0vM/K//9b/w2te+NvjsC77gC07Umu3xXu/1Xvg7f+fvBJ99y7d8C170ohfhP/7H/8ju82u/9mv463/9r+NVr3pV8Pnzn/98vOAFL9iqqQ0NDQm84CNeFQ64NCAvFfZ3Dti/s8f+qQP2dw/o7vfeLwR2Iq93JixJ76QNR5LAbgh7EgcT8rS726O7Z8Ke5GVvQqEue3T3Duge9IEPiXaDX+FCf+xPN9RBtwHg1TEuXGk0SJqKuy+V/hJZLUfAlMptjQJJeVLDEx1k4OEnDjRciJbBTH65sCb/N0PGsOmtU9Dx/2FY2EBO8G0EYEN8SGgaLc/vVNaPKQ+a5CDVhXbFIV2uzyMvnFQ5wTEVTkaSK46ZAecmpAZZffTE5xJMKLkcViVqpibI56Zi2IKUoX1QSyZfA9SEG21Vbw2WhFkkn1lLiY7SEKF4m5hMnvp8Asl7niv/moB9nkdeXFPvkVSZMUZ9Vxn6NUL8zLgmhMfZkfwNAc7W/Pc1r3kNDoeD//u5z30uPuiDPuiELdoeX/M1X4Nf+IVfwJve9Cb/2ete9zq87nWvw5/6U38Kz33uc/H0pz8dTz31FH7lV34Fv/qrvzoq473e671GvjwNDQ3bw4UweUNSrSF7KydRMCmK3QRcudTBdmc3EHETaRtaopWGsN8JBYjLHhAqUKYEmYt6Ui5RKggFXz4AuNTJTnUACYgDIA69nyQL2H1s9ghtjW/peEeTePkxgUHalTGyi0kB97ef8HLbUTNYF/YFAD2MSS8zUXbhOtru7w2EmYGZwNi/hj0+18/+w4i0KhrMJ/7QacJk1N6or0aYMBIszZJVhKieVCYZ8yW3pC/C/xNlnQUqzaxH5sWp3481sarJlFQA1rh5Ltaa7Mw5vinjzQoDTWd8uuW1O1V+tdn5KRDfSzPPefIem4vSe3NNlcuc+z8iM0YoeK6seZ3OmfgHJsGJtnILJTl/u6J2HPOZe2I0Qub8cbbETJyN6WFMkR3j1q1beO1rX4sv+qIvwr/5N/8m+O43f/M38Zu/+ZvZ/T/qoz4Kr3nNa/An/sSf2LKZDQ0NBC/8kFdYxYkg82o78T/okT8JQCbRZPuRuavSyUGm0KY8dvFMa1O7BjS3RerF7JUmg88NQFYwOzPw00xmIo+cuRyd7BRK2EWs6eQG68JlTCJ/+xW2MTnjytUZ/5JYFRPDKSS8l483c44GPjmCJmC4ov/ZOskfri/JxNqTM9wpFwL81cJgksQZf+ZW4IpWKYMvo/4hXgpr4miTzjUyacxYRV90fCuv8G5NQgTgCJK1iKYVwxK2JmVOAS5sqXTbrAH8WudvLaIkJjy4SXxJXRxxskIbi8mHzHOFlrHa/VtIdsT15YiWZFUr3l+j41+ZvF6K2r6Jkbte3vDmJ+c1qmFVnGUo05ve9Cb8yq/8iv/74uICn/VZn3XCFh0PTzzxBP71v/7X+LEf+zF8yqd8Ci4uLrLbSynx/Oc/H9/zPd+Dn/iJn8B7vud7HqmlDQ2PNj7+g1/hSRmWiPDKD/u39eTQNGzIe7YQ/xaX/Sie4LvwkZy3htuchPQMoTEIJ+0ahvw5KIgrFYZWSRBvGlK/EGxmovEgXQf/A2CUFNGKOJc9KROa4urV0oZm7e3PTrLnJMhKFYSRMT9RmJWvw4WYSfeZ8GbLPkzKtUtkBk4xWZdahHXHQOXS8f+BT4se/bjPPRJ9yl3D8QBuaiAYb88SX6QsGmIWZNmaMHg+q1W/uRN32t8zQxv87lv1CT22iVAfer2zniJTWMNs9FgTKM4fawa2vKZLDUZrjUhTXjK57auwRjhIypeK226NMKfcd7QOSkRPhQQXYq3rZi65kQ0d28ArZ9V7hV4bubbGXkfczzXCydVxDVkIXeIu23AyPHjwAG9961vxy7/8y3jb296Gp556Crdv38YznvEMvPd7vzee97zn4fHHHz91M0f4xV/8RTz3uc/1f//n//yf8X7v934nbFFDw3p44Ye8wvzCkTICo9UxvZdhWM7BpZ5W7ApV0YSYTgbiCRQQhkrpsQImIChovYnwkhI1xNQ2bFaeCeIl2D4xIcqF8bBhJvEqWKTkCbMpWdJgZ861I9GCfnQghFqwMjVaKXWNi/7OIHkcpN3Fn1PYa5gLISgNgeCuA1btFRN5JRPaWDkW1XMWqFBXbE0qbdYnE/csRfBMK92vonx2n62wUkiT337i/qo9f6NnZeL7pfXUlL1mHbWour9KyZEtp0klxEApeTOD7Kk5Rzk1TTKErLItU2OKKcVI3Mbc9T9qM2lr9bW7hlrSorSfl9xf3HPjuihmHvb55dmGMjUY3LhxAx/0QR/00PvrNDRcF4xImanJtVe4WI8TKSC0GCacWntPE4fAl4CQBbHyIZ74a46UoVB6FB7EDgKcZ0uc0jNuizPcdWVhmHiPSAkhhrpqMmzIcf2xyayQKcVHop6YgHEZsOIiLCGldwL9jQ5aAN2lCfUa+gCD2iio2x1MbkU1bGOOYOIUQJMolGFzZSUnONEAltvOnecpv4BSFMv118AcgqCGCNsYUxP12ag4lqNNyI8RZjBzwjU3JKR2v6ltj3rvRDhqWFsCnIrL98maviJLFTBTHjGlZTBIKtlqij7CNbRWHaXlrPmOAlD9rEjdH8cMfYzHmQ2nRyNmGhoaGgrxwg97ZfnGTh2wG7xIlJXra2X+VzsJ0Q/5ptMmdglyxkmirUGv0IyTiJ38O4NcPTWZ6TXEVW9+30nj3wJDurh9ObVNcOglpEQOU4MEMgAS2hwTJWeC9lFVU67YlNlsF2eNIttqjDNXpVZAo4E3T4ak+yvp27MmUr47o8boooHspB9NTGgkFD1Qmp1cbDLxo/dHaqDNfR5l6gLA+vqsNlHmri/654kmxUmPhqkJS+q5NHVtHAMzyBm2708U8nBqcuSYSB1r7KOS2o+9N0uMdenvqWdjXM5IbcvUswJhsJQAqFZlLSCZ1lLw1NSXW1xYFdFzZK5HzFysodBr2B6NmGloaGgoBbcyHr/stPnHe44oM3nXUkDtpSUHpDX4UoCQNuWzHogWAEJK418SkQ3swJGqYJQ2E8J45T+3oue27TWEUhBXB+ujAkB0gLRtghjUNDFomIobgFiVjP+8BEx4Uoqw4AdUqfaBPfZRuxLKG3FQpghnjKwTdQWDdBBF1bJJ2WTmJQrX//HElZtgcpNFznvBDbZXWmUOSMiSEBDAEzQ1xEbq+stKwmNyJtcmt31qG9bPh29HMXLXXaRmOvbAexVCIkXQnNKIcypcrSa8yyJFBpyD0uTaI7o/SyalVUblMdz6ikT6OZnYN0sKrUTULCGDN1FlJQiq4nCpI+AY5Myp4d+PZ9SmRx2NmGloaGioRZzaE4yiwRu32u87AXXDES0KUAKdEqHdiDXjNeFPhW3xahBL4DgSRgl2MCl0yCVN+de4LE8lMfCOlNHOJNjWPfJj4bxtSFvYEDHWR2fc3iDzEjHPDZQuObh+V+R3DciDHo7BDcLpZFhHHUvbz65WiizZwnoA1dj1V0xgR7H2RIUVfO53CMvmBuasz0iCWKk1GY5Xv5cOnlmSpjSDmNuGbu+uY5j7YETgRaum1Sv4OUTn6dpM8kv7+dSY0YZYqVFK0Jw7rkW76TP0GPdG/NysRaXapIpcOiZyhsu5zxacl7nHniOWiheWpkjjOCT7VERI1NfX4t3wiKERMw0NDQ1zEBEFwSRbDyoZLQRUJ6B25n/dGY8ZoSR0r80czg5Ecu/IOOWx2T4kKISGNaC1oR8yWkV3L+Ko7TRESksJ7G38klXt+DI8sUIUHB1DygDmYDRDWKmEQS7GpFGwj1Xg5MgY2oGaZFzQUvCDZTXxmQ8R0+FnevAHCokxnSRiAsR9E28f9Yk5HgzhaLavze/MxL8Ak6vDMjVS5Q8uR87UtDE5UBxl9Qrrmdw/WWHdpKDIy8hep0IjH4KjyPmsATd5S4XTremjcQqslAHpnJALLTmbiXUFaLvP5hhik2UuUxBRdDosJptiXzYO7r5kDGdr6n2YriEP2yelJr7HQhFZVEO2nIKcWTEbWMN2aMRMQ0NDw1JwChptwl6gtQlckhpCAf0NAFpAXtpwJ42BcBHCpHu2+9EZu9Da+tNkVtsjDxPjZYO6CVonoGU3UuL4EKteAwfDXohOQEtpiY94GXj4NQjDcoMDIUamx0nYfqLkT5Blyqph4kH1ZNlUHRMPWDwJNSZ1ggm31r5+n/ral5Wo1/XNRPti0sqfA+L3U4WSgWBByBJHqGWLjNQ/a6+05xQ0JZ4Tw4f8pGDYp3BF1Bp682nChW2nHittEmFPSd8L1+bRTmc4+I6PFTgrSX8SpfdZZqIVnMPJa2z82WaGzisivueWKNpKnguz+mKpuS6QVrSUqmQoQWTLyr4HE/XlyeN8H651Hc1W8+V8dmaWvxpxk3j3cQtC1+L51XDt0IiZhoaGhgL4bEwpxAN4O5EWAIRWgADklYS4GFQSai8hoaAPdj7fCQhIeNkGk0WJQ5BZQFpCJtggMfiRZJKoosFSIjRLC0BIQ9BobZva0bYwgxVKyjhFT0faRSdqzsiXsBZamHTVpgKM1CZaiiF0CoDmiBZOHcMcn+9+evyKfB6TXzSMi5QVTMQoEZMjZfxkZlBSzDZSToTiFA1gC419iwfDmQnrZLsSGa9mTS5ShEABkVHs7wP4ex9I3A8gKqJc1jG/bbhv0FfxxC32ugDKCdCtkZvUMKGKq2MOmRm3eWnbzoks2xBzlRul+5So5Eb3SWG52XuFu5/pPZirZ3Sf6oHQoe9XR+rGiyNMW33RBYdXvAgCFJEOswh2orqtDvliFEZFu628EDALpZ5vBKub9T4iz57rjkbMNDQ0NKwFMhl2k3ajXAHEQaO738OlzFY7YZ/AEvKgrEHvUJTzmsFOhqs18cs8HhAKYYgSbuXHheBEIU2B1DsuF2R7ISCE0/f0vnyhMSg4UgbFDhKGOOIGCfHARSAYsPq2gvSVJZG0HLJfiV5D9PyxBANv2gY6SKRKGpDftY4GwyJoI0Va6cB8Zg8pToce7sevnKaIMACrTHBLPGFyKJ08lAw4p1aBJ9tVuMLJqxbSfkBBqFYJmUoJOg4TabdHhBannvEEzZmRMxSpiUmJ+fLc+moRZ5XKqX648km42tyQO7fvuSlnct5Qx5wEx/2SrLuCnEl/yT+Hi8KXAB8GPHh5GdWpoOGPBeUteSZnMYN8zClVkwsL8TNyBmmwpkeQ7/uadtSGI8V9O7Hv2mFp1Gfv1KFhDWk0YqahoaGhFlMvZCa0SfQK3QNA9hr9hUR/S0LtBERvJ3ZwE30T8iSuengT4E4O5cbglC2OlKETNqtUgdZmIEjIBz/pzE0oI8WMNxeOM0JpAEoNK2K0HWLYZ9IrxpItVEAEAMaKmJnZaljjY0PMxMTUyMtGYERqjUyKfdmEwHII2h32Ed3He8/kEH+tmPri8pntfbsymYT0FHF2jTF7kJ5bmSaD6SB8LoWS7EG1/U/LZEgaP6HQenS/xIq2s8GpvWLie2bqeU7BqZwKsGQSubbh9VJwz5A1niuTKsGJ0Jdc6CK3Pf2uuP0pcmYKI1IGJsRZa2gX/rgAuYl81fUyM0Rnsg7Giyv4fwqsv1d5m85GOXMqLMhu2HA8NGKmoaGhoRaVL1eX2UgoDRwAKTR0p73Cw6k9RJSKWigFjS454JxaGaQDEdH3EPevzN+7DnonTX1XB7P9zb0x/o3JBT94FAEBoaXkjQ7tPt7jhkwKKRmTnNwSUsaFL3kPnp6ERAFwqcnFKMRoaAvrw5PxePDoGXKEkD0sGRNhNGmm2wfHkFC+kHIcgnZnrsMkyYTxcScnQmJsjlnSxlG50d9LJ5WrrpKWTIYilQRH0ASqmcxkPT4fufMUIFPmJDlDQprc9kX1rDWJWJOESZFeHHlSqhzbarJ0iknYkfx7Tjaxq/FLc7sUkjVVx8SR8Gwl9rv4fqTvSGEWTkDDexNtnSJeuGMoCfVa45mafKfO9fYp9KJJ7p7ZJfsuGi3YVFe9CmqVqbXmxKcmdxt4NGKmoaGhoQBvePOTAAq8ZoDJiYBQGvLS+M5oKaD2ArIXA/EAmGxISkAcFPReVA/Ygs+1NuE9VwdDVsDwH7g6QNx7AOx30Dd2gIwkM6l4cBcuZX9PGqVK+jcGQsaSL2xd7ncNCEUmv8oey8gfxB4f3EEhIEImJ960fBfzHxNA8bbx3/FEmDYvN9jXZEJeKCHnZOLjCYbtYx0RBkBaHeBWcXOYuAaDTTNFlUwcuIHmyQeS0TkqUtAUYm52rRFicoZRwRUrLtbIHDKHlEntoyrulVMbc1Z4R9RMupfUuzZpk3q2rUG8bkr6TIQKVoOqVB1SYaec95R2qhlS3mjf8ubQ/ivy31mAmuf8LCwkZ6ZAn4WpRZwA9tnjCXWJ0z9rsPyec+PbhtOj1nqpoaGh4ZHG6AXmQkfoDwOfmahXkFcK8mDIB7UnxrYOnQCkhNAa4qqHOKjsAJiVldu6XFiRFgJ6v4Pe74bQKMD8HhnqjdQg3JvCebsIhMcthGm/PQYtTYpw3Q3Zm/ReQl1I6N3gDePUQ4ZoMe1Hr43XTu+ORfsBrdA6HNzGbXZQeiAduIlvTAg5Usam6HbhUaNtHWT0f9Q/LAHliCd7TQQTzoTZLfWYmIIghsOjyX5UvlDaXCNOHTVlkuwOY8Ux8haTu1LEUveiVUcVnrfRtTgDS/f3/gH0Jw4lrMUxJxwTz0/WLJj+cM/hXHlnhJp7O94n7+d1vfqBgvphAEg/T0vKWXF794wYbTfVLjlW2IUF6+Jnbw22JLhS4WxV1/NG53PR+yMaK5xCGTYiiGaWkTsfc547DdujETMNDQ0NlZi7uiC0m+hbBYuCUTVIAbWTlsBwhIddhfPkCk/OOIwGjP1A6kAC+kYHffuG+bmxh77YARd76Js3oG/dgO46v2IUqEUK3xJaGPJF7STU3oRKqZ2E3klDyjhyxpEx7hgjJY6b5ArF/ETkzLAfEiQIISncT3A+3HZ0JROeQDMmwvZ3R9DYbWMTYHP8IiBq3N/BINGSTjSF+GjwFKVeTpFK7OAzRxbEpIw7HoUhjC7KEjJnQlQ72Du1EqaIkElhIXkxSerEZF0J+RB7NzDnb/MBeYoMSJCPRwc1F64ldRYeQ3Jyfw2x5BimJoYB2VhRpts32TaGXJ2D7LFzpBL9vYveFwsx55mbuw5LJvXljWPeJckFi/glHW67+XOLqoSjcYHvC/v+XkXhuAC5+2dE7ERjlobzRSNmGhoaGmaAkjOeZKDIDf7shFheKcgrjcNNgcun76D3VmEiYCb0O2lMhK96iAe9+Z8xb+UHVmQjR5rc3EHd2pv/Lzqoix30TfO33tvXgSYKiijWOjUQ8KEzTh3jSJkLaerZ2/8v7OdCEHKCKcs125n5qpDEyA6oY0VK3Bejfhr6yO0v3CDG9sVQvw7JHd8/w48jm1yf+FTeQpg2OcLnYMvlQDK5TBEjOXImdbwB+aaY/nFeQ1YRVWKcWYJ4MjA1OT35QLJUabAV2VBZZtCXMxUGAeaqLHL7cZnlgOk+nDoXc/p/qYokbjP9e4FKhbs/uIky9/2ofUdAfB/TtnA+U3FbJ8mZGZirBhjts3TyTe8/+17QUpqfrjPP2tjbbW5VCSJlTj+sThpyz6LUMZeoW+c2o6SI6J3IerKtQOzlsEn/p7469Xu2IUAjZhoaGhpmYpFypjc+M6LXUHuBw00B5SbwUgwDNimBXkE8uAQOajw4Sazw6p2EtsoVV6YPGyIhSob8kWZA58J+Ykk1maCPfjoZlO1WAvVOBmFK2ilIKFwKakWIEETkjB4PftiBhNtOE0UKB1dPPPjzZEx43Ckljt9egahpMGp/2G6StSoa+KVIiuQArXaln/ZxdPyBeokYHsZhPuaX6VFcqBCqH/XFE7uTS67j/qxRVWw8gE+hhgALkMtAtCZSipUl/bRFH885/ljhlMFcHyXOayr+3bel8Dpceo+xE9ipcmufJ5XbTD07ksqQEs+tKXBEhMTw496VnHo0hfj5fQLVxpx+8s+gWM03WRl9CZXXxRZV2lU07GwDX5tqZBZlip4XjIlxI2POF42YaWhoaFiAN/zsy3hZK2cwSAbFhpxR6C4V9ncV9vcMG6L2NvRHwBMc6CxBQzD1YtVSQO+NKkZZksR8gSGkSmF46StlVBw0M5QwBJE37u1s23bDD2z2JPP7uB2ub2RvFEI+LImGDhFShYUcDyw4pOTF43h+BHXF4VsuLMkTTJ0IDf+cIqe3fXawIU9x3a6eKGsUgID8mpKNxyvjObDqLf9lNKCPJwrUNyjC7IFc5cD2rAaMqRCimv3iz0vJg4rJPd0mN1hPTZyzdR8bS8OHtiJn5oQ70f0zOIfQpiISpQBTCrtTIRuOU0h2FN8/wUYi/KELLu5v58lGVJtzscZ1FCuy5pCHLKkvybsl9nZjG8KQIxPkzBxSJnj3klCzrEq14n1wioUFamjMKdri7RrOB42YaWhoaFiIN/zsy0afaZF4adMJhga6+z0u3n7A7q6C3kkcbnXob3RWiWJUL+r2BdTtG9A3umCwEEtqhTWu9USKFPBhNrY+3watA4XECEKMjXtJuZ6kkQLKecikCBBtVSwH7UmMgKxwJIf7YZQzkxNPnVeqsJ85MoaEP/nihBj90LKombP3oFEDOeR/elK263dgePtGbcsNlKaNKaPzXYJo4sBNPuZK4dnBea4pJ5y8xcRY7CFUhLWUMScgRkbnuZYYmrNtSsXBhQhdB2xospsLb1q7/K0wNTnOYY2wR7a/CpUnVaRMQVlBfy8NOUy0cerz2nIcgmNn2s7uT+8LSkAdQfFTfY9EStkUkTEoj49zz9cSg6UEaSNnzguNmGloaGhYAW/42ZeVT8wkmeQrDfmgR/egh5ZAf1PicLtDf3uH/uYO6sYO6uYe6tZuIEgI/IRSMYMcHf24OgG/audf+JKoYIgiRu076IuBhPEDSauyMGbFpGyOnHDhUdyqpB7MdTn/HK7fRn1YNCiP2xPVmzH0C/ZzoJ43vr/tcbqfPi7bFcgPxKsGSEmPHYxJKtevnPliIlxrrUlfakDJ/eT2P+aE0ZObQTsyDcgMzNnjyz0jlpAQhYqO3OR+1E7qmVJS9xSmyJiUZ0sNavdZO9zsGmZBWhvFJEHqvkr03xrPg9H9mCNGmMn5EmTbvYCcyala1iS8a8vy6pI1ccwQLq4uySxCZe75rd5fkwRYw7VEI2YaGhoaVsIb3vzkoGKhYAiFIOREA+JgPGcggKvHJR48Y4erp+3Q3+xMOm3vPTP2ewEQKh4IacEREt6ktyNlOtPevTXr3Q2Gvb1Lb72XQciSV5FY8sGj1+aHEBTcQGrk6TL63n5ZOHEqzpJgy6GKI5eBKc76NEpp7UDOAwA4zxmfdcv1CVXLBI3lCZEkiGLID4658Diq6LHbJCchpO7icKmS9k4QFUOl+dXqc1vJK1bOBPsMv0+SM0dQhsQqJs4PKEkklYTw5DD3+KZCiVLKxDlYIwyNQ4JQn4vafU/h1bQopMm+p2rL5zfMvWTqr+P4GEb30VSZ0XU72neheubknlwpRF5ySaSMgmf4zQB51Ulqe18Hh8wizlkQI4VtOLf3a4PB7tQNaGhoaHiooDUERMg35Ab00cRNdcDhpoDcAQMDAnSHfiBCIkpduzoKvSgGYztXcThBd4oYk8bbhC7J3hAMUinvjyKgTRM1Bs8UJnZ8JAUWAtDakAxSQEOSAhASJ7Q8GmpDjpcdIE2EYoxCVlxb43OXAzUrdW11xIkvX5cPSHMgxzMaUEXHypEyAaEDjM+5+7iiibUrdpPyf0a1cw6DR6G1v2e0EAHBWV8Wwmu4BDPrCuD2Z+r01wbT/+77LZE9z8eY6MSmw7n+XuNcYOjz0bFPGCCXhuwc7b7hvNQIRs+dGkwS8RVlRe+RsCBRtN1UGEjyWMmzTWhA02vInu9F/ZRoG9fGtRG/O1hyn77PY9SQUNy2zHtjCrm+HpFk5HoIjq3XwSKYfy9g2GbymTaH6J0ySJ8o0x37ObxXG3g0YqahoaFhTSTMU/lt4QcVLkRJHgB5pSEsT6Gtua5S0qdY1hgGAZSsGWUzihATMj4sKvByIdu6AYxVlMgr46cCbcrQUgD99GGOBkLRYMeRM8HApteAJYGE1j6jk4AYT2zp5CAaBKZIjGCQlfKgmYKrX+mh/3W0b8Xga9aAKR7kqXBwCAxlTg3+t1pl5WL0PRHg+mruKvHUQHUGgnNAJ1ECofqJmWCVYBXCo8YDJlbs5ciZpe2ZQVpsRsosIVHifWm/0e9qjjvqe/a4F5IydNvrNPk6altzk/mFahX2Pioss+gejMiCkjKPhWoPoDl9PXH8pdd98fOuoI2UtAfgl3bYthQ8i5Og75ocCsiZhvNFI2YaGhoa1gYjWwfsCzGY6FmDXkuGiF5jf6eHvJLQ3bC/2gto2UFeCsjLfsicZAkBDsmwC0sGBV4xZPvQ3HZofxCi01uiZIqEIoOoOQaEQghAGiKKM+PjlAeeaHHHIeWggOEmUS7MijO/LViZcoOvoP9S+00M8maTMu53hpRJV1a/0hjsnto1OvaiiQZbgWlf0crjQnKmPCQiQ9jNqD9L0CxZVZ1CQuWQmqyMVvm3ahdFLaGyAUHH1gGkw9BmkDNbgvdKyn+/CLX3PqbrTxmvLiIRRyb188nhOX2YUs2UFxCRE4n2rz0BL1VrxfX7d/IKBsemwHXK4Z53U8eY/N6R9r7wFY+3Fsd8TjesjkbMNDQ0NKwIP0kXQBDU5EKcRLStNc81WYsUut54zSibglpLQ8xgDwAS8krZkV2iAdxYQJPvKCnj28HspOzKjxvz9cSrxJE2cnxMZmPB/+4r1PyANvKyiI2OY+JhNEgihsKmfeP94smTUexI//to+8R+ycG04o+NDgKXqBNo2T4LE0MYTNYxc9A4i2Aj7Sg+7kD9VVD3ESe8AQrqTLWbhtONwlm433NtKCUyJhQe3OR3MvSqtO6tw5Jqy4+9c0qvn9rzw9V5JOTunVUm7scgRC1mE0lrKPNyxc/ogiAchiD+e1a41qkIgQS0MEpXj0rVTy1qFIml7+JYderCmPw7GGDJmdH4aMn9P0cBeKr3YsNsNGKmoaGhYSW88MNeGahhAPsidQoX6j/jyBE/6SGqlB4QvYTuNdTeZkPaESJHkzpypIitkw4YYlIGYFQALoOSEhBSg6a21kIAOxntTwZBPoVkpqOUgI6YJRGRNTFZFMdvjzNQ6aHtdnsddw43qJHCrF5OITEoGlYFwxVMNxCNiTj6e2o1ODWYSsvBeaKO+lisgTmToqWr5tn9V/L7KEFgRH0OKB1wl5KMU/vk2lEDTnlzDoaZQNina7dpheuGDQnNTMIXh6ctRLGXRwVmH88UWTHRj2z98TsokWlvKnw01xenPodzkSKc/LGcEXlUe52OSJmIaOJUOC18qKEUjZhpaGhoWAEv/LBXIjaAc5Nm/+Kn5EEnB98Ul73HQcN6uQhIDWMO2AkTwiQAuIxKxC932NeUM45zh/88XMEZ7+u3gyFngrZJERIedHLADkzpqNYcGzrbPpJCWwsBdKPdEZjn0jpJqNWgjBl+d+FPxx4QBaFUQoxWzOhqXmk4kAOrqkhlfVoRk31YQyTNqHuSnNkaG5EHrBHjEk+UuIwSUqagfUnMVYvE7Srp34XHksSRSaFJ34kYqeubUcixmzHn8FimzrSOs56cFpIy6Y30MDlPmKpnq6/tm0K1ydp9Poskip5FS4mmEcGTaN9SZees86EBeVDbqYHOhcBu2BSNmGloaGhYCdSfRWtYYsBqZOiqinThRHZHRVeSYIgZpW2IioLoxyoULQ05I0aEjvtV+zJ8uX472x6aDEmTlNeJgSors04NamkoEd3E8QlWO0SPO1a4eFKGEleMwbFWpH+IF41b2QqPIeqzmok9M4EcDX4pYcQQTSXIZv+Q4fFTI+iScoKysK6iZi7OdtIWG74SrJV1Y5PjXhpyFOHk5yd1PEsJsxNMdE7Rj+egulh83NHzf1HIz0ywpr4Z1dLSNrH7V0763b27xT1cdA62MBpnyqChRkvKzIHtQ41hzNYzK2U5VdsSpWLDQ4tGzDQ0NDSsgNGEXwNaAugEAAn0yhjRikFF4omQaD8HoTW0C3ESgIaE3rmBqRiRGT59tSN64ve8tv8Q01+/vfW4AWC9bQQhb4g6Izhm8ocg27jfFSC8eW+u9/wBBH0QkFq0nigjVRw2xREydHua8jgYbCUm1LF5s+5MhUKGXSyckTDTpizmGL068+GaelAxcK3xK1hBLZObOJwjaXO0NqX8kU7gVbJI2ZNr75oEyRqhSFsQNlyZXJYn7nsCPyHNpHIu9da4VtiI/JisNvFc8sqNohfbeL+4jljpkTaZFaP3cPAd9/FKfTQVknVsHPsajr1ifCZGF07swJgzs158MZppbwMaMdPQ0NCwGC/8sFeal3E8KXDERq9tCJAFUcp4uJAUECVIREiovYTaC8iDtma8ZLvcS1+Q/xNmvNDhIDQkLGxbKfmSQ4qcIcc2Kocqe0gTdSdDFQpMO4S2fcumukboGyOHupPZqhiwg00yeBplYqKmw1yWJ78fX16qTk4t45EYwC0aKC+UYufqTvo14AyUGafG1MDcTeAT2be26Lvk6nbcvlPJ7HNqGmCeWeYpUDERY71mgDIS9Zohp644JhmQUx+u2Y6isjhyZu2MfwvxsDzLs8dhyRll3/XC+tWtcj3QxRru94aHFo2YaWhoaFgKpYfsS9QUzhMaUZiOHlQw5u8xKeMRLcb4/Q9qGABIeL+aoTw97B8TBHQQ5wgPYcuwoUNauKrFWP1RMgGgkwVLzrCeOAXQQoyUIb5LSErvlAHfKNWvAyXLIgQZqDJeNUP4mt02CqcaH0tYP/f9FCHk/64gZaoGyYyZYakcfq2MGFsTDkVIKIEm23MOq51T5sAVxEVR/6fKm2tQfCxsZfa7MVhlRSZs4jpPkrljXZMMKTHondp/7TZNooKEO+q5P2Wa6BPDK3yDD7V/n7IZmkr9pbiQ2tKMfQ3XCo2YaWhoaFgIdrIWq0sIweIzBkUkDCVlRsoOrSGvFIQShpShL1wdDQq9giYaJOUGTEKY0CshIHoFqTXUTppyFLOfI52o8S4Hb3hMjpdrR/wRJarIACZQqQDD59xKlTPgdQoaRu3iq+dUIkoFbdWdBA238m3zhYRlFk3gM5me1kCaUII3IE5me0qk4J7KIlLbvnjCtdrxbxDDfxYTXLKCyrbHfZ9J6R78XkH6TeK6TgSOuRq9Yh8ZAl0Efz+MWMtIfK2yrjs2M4B+yEiZkv4xi2xuMc6qZtz4bqo/5hqfx5/Hz+ypd0DD2aIRMw0NDQ0LkZa60o3Mf9QgOF1eqK5x/4uDgjhEoU5uskxJEmmVLr5OV0Y0UAjSYLsBPlVKmFmyT20de7rESppcCEwqhImWS7IbBNmYtG3BxABGx2FB1H/HkjM+Ljzel3gEBeobb5TsyK6o6TEhhsT1MEUS5FbCFCGA6He5QVeBKSUlZ+jffpvc8czEnEnRLLLmmAqIOR5BHErUG3Qgv5bPS4qcmdrv1Cjp99zE5xTHtUGdjYzhUZMVadhpejJdlakpV9c1Q03Wo62uybMMkdL+n1A1Qxc3tias5mS6azhLNGKmoaGhYQFe+CGvGP6gXiYaED4dNPznHpkXZ84Lhao0jNmvUboINYQdudTTQgPomVV1p3bhFBEQg68LMB5gTpjNlmQCMhuaQcuICCglrGIwihoNDIa8pQOj2JA5JsksdzVSy0y0K1tfTLYgPNZ0wBXS5MwMI8hzGvCeQyaZk4HxkOG9iijxqId9F5hJA1hXQbMF5hJSpySbtqrvEc7sMpU6mUP2mZJ6502UyVd0hIfpAhJp6bM+7scUacNtV9KeqdCys3lXxSbAld4/row1SRTfP42cuZZoxExDQ0PDEsQpdd2L0K2iaGCkjkmk4KVlxvvEWZ/8wKXXPlOQ4QxEmKaZyRDgwoqCgRRRRwhYBY49hHggNE45jaE8+nkwcQzrib/XyJjmUbIlzqxE2mQ2In9rU/HYZHa8X6zQ8fUSfxnhSDYaNuX8fGJfmZpV+kyYVU5ZNSpvxgQ6l3WE++6YA+JF5MzCfinGWmqZCRR5JsXPoRoiIpMa/KHEMcmmR6E/j4zwfWT+r/W3cih5xiz1zNoEKxv+lhBcqWOkPmTFizMlbcyMJ4rL2BoulIksoGx5LeSIqVGdc33SGk6GRsw0NDQ0LEHkbTI5aZoJdoJuSQEhBAAFDTma4BvTXeG3N940A/EQkCVWSaMtx+B8bLRGYFzHtcUTGk5V4nYE0gNIqr5RJmRKRN47NCNRkH0qGJiFpExYh0BOcMISMhxiFcPCzEUliH10Uu0JYGPczf5MeFIFjjV4y0nkV2lDzb1Xo0DYanLPlJs3StbL2hGHRh2TSDgXs+AtV5bd+Vyqbik1dF4LG7zHtkSJMXmOhM4RHal9k2TQhOqGIxbWnsivMQGvKaNGucSFz04iMZ5gyziyys/7BpK6uWf2OZAiNeqkhuOjETMNDQ0NC5BTiXhwA4TS1exYhs9tqzWEtoSG357WBUDZibrzK5HCZGESwmd0Ei6rkHIEiCUtAGMMrAH05BhdHU414lUkCEkSOkgl7QqUIVKbsmH21RhnYjLfDSTTuB9IvRUrakLDGP1Gqa65ASBbL1X+CMyb5E1ltWGul+SkgBgi+yYWDL62HDRODdpPPVgFUH7etp7EJzAeUFcSTiUeM6ckZdxnZzz5n421rplj9U+qvSc8P3OfEUsVMdzkOrsNDYkCAjUqre8YE+JasmRJm3LZs6b6t1bBNImH6BnCvZdzJGNNuQ3nh0bMNDQ0NKwBmgHIfTbhmeIRD3ZrVlcDM18jkRC2Oca0ltlF20l7B0tE2EPAODxIWHIGQgzZB5w3jOLL9+QIJVG0BqRM+8T40Ck3mEWYYpyWS74fTU7jP2mqbWqiG2ykjRcNAK2E6ZdMiuw41Gn0dZw5agrR+Q/8QhwS5z87ECucRNUOpEtQmmL2LDBXGXCCwf9m/gHNj+B4KK0gLDoAAObrSURBVLwnR/fIlDn0Q0Jq1ZAJx8BUiE56R141Q8s9N8TkTKm6Ihda5n4vIRKyfXzOGZ/ixAIJ1Uw6UYRmF19S+6z5fn79zz25rLCGVdGImYaGhoYlcKQDhXtJq2GSPRqYTE2ESgbYnKKjH2KRdIeAPPFhS2KoWwuRJxKoobF3vnUElEaQSjsgToiKxIdK2G10LhzKbkNjtksGxIxSht2Mql4CpQttY4aU8QVxhIyrI23enJw8uc+j60LE25LV16CNnGmw1pOTta1k9NcSiX6anCRnBtVLwBFmQXum6kk9Y1LqmFNN6qcIhxqUKIOOeZzxdVKB2dnI1ji+ExF1a5Iyaz7TZik6ComENdqZC5Gin5f2ZS5say6m2sCWX9CH50Zwjf3vCu/lwnvu3I63YV1M5NdoaGhoaMjh9T//8uEPjqQhYI3ZUiqOFPwEHP7/YACmjPpDeD8ZIEjbLQDdSWhJyAeBgdig2ZoEQ9wQYsOFRo3i82PyQAigE4agcaSMgjUuJnXOyWiQgNDa/wTQ2tTbR/V1po2D0XCucBH+j0SYidLzzrEvAyRMTI/7yBm8MqRM8Dcz2IuvG/f3iPDBzNXiQpwNIZQhZVgwmbQ2bcvEsyVZRlzWualiYlXYUlKhhKw6FhbUlZ18nVIV8xAocpYiflZmzxUTxrR127j6JttpwYVtlTz/a94ROdVNaTvpPucGbtGpuJ1rPAMbrjWaYqahoaFhIXwYTDdMhJ1RrbGzHV60paug7OoSNemMfEaGHYUNzRkK0nQy5pQoVvUCraGTS1hmW+dLYwgYkwGKlaakiAoJSwQJT8p4Y2FEx2GJHL8CCAGhlC0zZgxIuBM3luFW4qPsCYHcvCatNs1iReueWrGv+dzVUzghj5U63Kqd+70Uc4mT0tXa1MrsuQy4U/49o9/XguLP2VplnhXOqV1rKkRcWStkukreO1v33YnScK/pNRKXVfVMqVTAzb1XS0M+a57dSxVGc4gRt+9SP5/cNrEa6GxIfQI2DLkGGygvG64XmmKmoaGhYSFe9wtfYSbPVpmiibEuBEgKbbPqvYUCYTSQcb4piqy0W8IjIGrUoC7x++mhDJ8eWmlAKavIUVY5M9EW6sGiST3kx/dFnInJ7UuVJxSC9C8A0SvTLrqJKzvetxPD2y9BxNTEvvttt1QjcH42zMAtqRSyCqlTEB41q7UnGWzXDIC58J8NVzmDflvDY+HU5r4PO2YqlKau/aPdF3Ga9QJQVcUW7dwq1KcYNf2RINFTfZMiq1OKxi1x7PfDkuulhgg6GjLP1uT9QVWvM++7hocLTTHT0NDQsAU6AVwpnrygRsGJdzH7efTij2OX/SqSIzQ8ESK8MiWHYDJvSRkXEiWu+kFRsu8AadUZVOnCKU4kKVsD6MP04txA1vvXwB7LxIBF9Co0JpbChkmpkNCwqaSFZ3PE0Gdciu4Ycf/QY42VFAtWzJyyKDifGP4feRXFbeA+W9quI6A4Fn8plqoB5iifZmJQkiXUaKX70/2OmdVny2tuTtkpf50Tkkgpk9STqMaOdW1U+P2s3Q+be/dklJecKuVc1IG1iI9hrlqm5HzMJiBO8c5by+PJgrtmGiHz8KIpZhoaGhpWgJbSPFE9kWHVJZzHCfl/8gU7sZrCxZJ7MINDdpXFv/iZOlJ+FxOrQ2GbbLmOlPFeNUPdcfm0nVqKUOVDFTdOwUM8Y7zvDXccMyZgMXEzIpNyBquZOkfngmynKRlDyKVJ74mcoevCAeOcFbrafa7rJGVTlJCG54RzVcqk7skza+9qypmplfiVjntWiFD8P0Hw7F/51GxB8jwyqPG4qsQaIbNJbHV/x/dW5pp2YEMSM4rLta8vel9di3fJI4immGloaGhYA85fRmuIgwKk4AeXcQppAMJOvLN+Fu7v0nh3uNCVmLkxZIZ2ShRLgnivlk4Ah1BxoQGjknErgXbfwMMEwocV+VAkmj5SjQkOtz/ddyBqiGKGHoMntqyap3chWwpadt7vh9036h/TBowGnHQFL5kpoiRz00z4fnUKn9SKYrz6n4pPX2hCyhlClh57G/wxSKk2IgTXZo3/EcHJ+3/L1eozVn9tiaL7j3t3bIgqc9PCTHEAR/KPt5/rncWFq85RlbE+b6dC4bOForj/mCyQc416ufdqUXnkOVh1D6ytnJkidpn6Jtsbbc+qHRfi5O+Dhkk0YqahoaFhDcQmrS6cxsKTAXQbZ4kimUlXZiBdMljVwpYREQzOyNcTSSlQFU1nU28HbbAbOBNiS8J4UibeNlCcRGFTmfpHkpqR2oeUrfw/efLEEh6mbUx53MB6lPEI6XNUmIZ4MbmRMyxdcSC6lJw5O9B+O/bkfsMJ8hYD+Vk4V8Kk1uB3jspuxn0X319Txqf079n+Vtc0s1OJmmjq2s/17+LnGh0HnJKgORLY/po4/jkqkFFY7xQKyZJjofaaOpYS69q+wx9iNGKmoaGhYQ14lcMQIcoNuEfkDNnfqVwATE8iyODHD44SaZOpX4wvl26iYDJHSfiQIK9mIQa7VO2jQRQzUozrnFDL+GMEWJLIZxjSMPUTMmco1/4tpf9uyJCFcBBXOnHJpMvOxtEXDviqVndLyoyVMZmwKQ6lprwPHY41QI9VTLX1FnrLrH6O1s7KcyIibHS/VXibHBNHO7dHPO7rRN7SZ3vJwge3n8dCQmZRv53gup7yjGO3Y1BCqJ3Nu4gj96e88ArP69kcY8NJ0IiZhoaGhjWgNSBl+OJ1ygzqHULNZ6UeVDOOWIjJGVtOcTO8Nwn9EMYg1wlLYjWJG0z1Nr6fTCCFJGFO0aDLqWk86IDUkT1uP0oO2WNzAxU2zbPSliyy5Az1jRE6CBUDbWOPPLiB68RAOmnUuNUgmDMmLa2rUhUwdxJQHNt/ZhPgzUGPeWYoogOdiHBhAKOJysxwJxbnZNhL96WoDNeYDFOJz1tJW+N9Umq5mcc9NUnzxzV13299H0bHx5EcxyBpltSRCl+tIdOzIbCV7TgHcMczGeY7I/yyRj1a1Le16rg5SJnsM1jzelhyT10nsvRRRTP/bWhoaFgBr3/Ll/NfxIaukhAi1ocFyv5EKaS9CSJnEEfIlXDSFm1jP0sNLh0R435cPf7lr4b0y6NUzIL8yIjo0Tos15EycfmuX2h7ez1kWlLa/w1lfoSyPj5UMu36Yyehd3KsfEmoFVz/0Z/4+xKUmtzOMt2jk7upweYRvCSq/CQeNSwwmeaQ6+8UKXPWA++1SJn4uwnjzWIiscabJXcsc9RREUonc6NnHPdzBpgbwrLFtnNQo/iYek5eJ1VEiqgqQmRcXvKOnXqXXpv3zwrvgCXX9Byz/obToxEzDQ0NDSvh9T/3ZJ5MASFn5EAmjJ7EJOsQtB69XIMBTirzhg87whDy47aPV7wIOQMgJFlsmFLw48qIMgZ5Mkk5Q177Q0kZ8IMFTetUyhMvpi/N36ZMmHCrXo/6yZcTZXGKia6Sgd8sAqUE9HzFPzVlVHy+yiC3YR2sNFgfXZ/nTsociyBgDDc36xPu3i31nYqQCp08CmqfPxxqjU4rMEWer13fuPCxEuhhwyT5G71ns/2QMuxPba7Tv6fe1cVE6zEQ1cNmt6zAYu858n2VQXLDWaCFMjU0NDSsCbtyHShCqKxWmLAbEyIE678irMZU8/Lf2H/GocCDxqtl4nI5vxdLuGhhgq3YsCgRKX4oceTClUjYFGeS6+XI8XEJ+4WU0JKUScK9hC9DDD6/LhRKaggtjh6LHg8m2cFQpJwKlE2lZrRTZr8JcP2xWfjSifCoSrQfmWOOr/3YW+mcUOmnkzOeLTECnoWUOarDCn0ah7ysTdbQsktR/RxkwnImy7hGIZxVz03XB8wYhQ23iRIiTPmcHeWdvcW5Ic+mpaTMFJJ9VJGxk+INP/uy5Y1qWBVNMdPQ0NCwIl7/8y8f/ohXl8Twv1efdBK6q1thmoKwBIlXyySUN34bIDTwFURxwpEyXBrqmAhSJNSIrpbb1VlXTkDK2P/VTkLv5WCkLAEtZVin/Ur0PXBQ5n8FH+qUw6ar6GBW+aZIGfc/49GQxJTaZsXB59b9VYJrt1LN9f8ZhZVcS5xZaM4kCpUo7t5aulK+aujCiivpaz0/uOOjk/rUsZeoJFnUvoeZ85067qM8Txecw8n+oirVnIKJGytw250Ixwr3SV2nU/WzaqL4upwI42y4XmjETENDQ8PKGJENgA/pMRs4AoNmP8J4AEOJEvpVZsDvCJ/ww6EOH0LlqtDaEEUkPGkgX5i2uPKch4xGMFAwZJPwpMpo0BGHS7njiKTSwfHZcC93XIFRcK8hrg7mf6euidNz+7ZNDwRLw53icrOonEhmV8UwsSqX8dKJ67huMejXLiRrhqrjOp2PrXB2fRDfU7XkUAU5MxepcJC57anabmPUPKdWu3YSmROTqOyrEhJp8bHMUFDk2kbHI7NNxgvILi50bYtnQmnYVBFSRPwESu77oF3xOInWc10I64YsWihTQ0NDwwbgBzwkzTQxwB1tGyhWqEokt/KU+E4KQEviL2NDfWza7oCo0XpQsoBkjwqOAX7boXKmLR2GECQrs/UkjoYlbwYSiX7n/WjcAISELPn/e9KGTobHr2AyXnF9kgkziEmmor4n/j3ZQZ2VO4uCgakrb01MrcqxUvSN2/RIYG7moDNBEJK5cduKCIW1Jx9TE+ocuVaT+eUahbecE0omyptM3OOQncRzO3lPcOc7erdsEeK1BJO+McxnVcTORLamkkWT4r5iFjHid++xQ55zmPPsD/bJPVuiMY/b71yOvSFEU8w0NDQ0rIw3vPnJpLlrnBqaZmEK/FSAImUMq5CJtlM7aUKmgpAaQ44Eprsus1EnAPJdMGAghr6moOGrUAEkxu3XejDtVbYfyMDCmAYrq35xn9ty1dAxOiCSTCYmdLYfJMzPlKpkLUxkgQlWu1L1RtdIyQBt7Vj2eLWwxOvimDh1/Vtgqs9PheuopqpGpeFtsi9OFFq1SPnHhYQtyOY0eb3MMTifqC9GLhwsZRw8SSrQZ2ytSmSq7xJGupxS5Bzvxaz6VOswlDlGQJaU17caTmQKvHldU75RGPr73K6nhgFNMdPQ0NCwEQLiAQi8T/RO2sGv/VzbTEbaLmd0ROkCu8pBwoBGBE/tGICEBwmtgQNlWGANijWgLFkAF7pkSZUu5PU5JUjgpyKFIXEkN6q25Es/DFZHgzoaxiQBrQSEU+YIQspEqbeHtthfmMxQdFDPqYT8fvEqaKGfgKtPC2QH7FoYU2jaTq6eLKI2LhmAneOq2jmqSjzOXBVRbXw6c9upNswu60R9W3QP1KhnCuoqIV44pO7ZZL+X9OmUypD529cV90n898xzyh3PEo+eUmVO0T4bXadbKmyCY0m8e+Pt3bVG25MsZ2NT3LmI75esAgpYdL3WfJ4vLHNPTTyDuHPWcF5oxExDQ0PDynjhh7xi7JEC91LU8J4usHyKJWiCFNmQ0EJH+5ridDwJKH3JkrAhDUO6COkULmS73GDBExsm2KkEnkDqAAhJVm2I8oaGLvm6ojJijafrmy5S5TDbBB9lji87YOFCGSaQLW+0mhWRMQsH+JOS8i0GyxuSE3QF2f19djhzcoYiNUDfql+LTC5JVrtNzy93jjLqt2MTlDXHzxEUXFhmaZnJ7Zhru5oIKigzLt+Vx32+BuaQMsk25O79MyUnJpEIPaLqi6x6JpHJiZZTphKd3iZYACkMHZ68v2sJV7ewtSCJQzDeo/fA1DVUQBCf5XuzwaMRMw0NDQ1rI34x+omwU9FQVQe/quS3o9mSgjTUwpdZBSefhvDkTPy9GdwkJimdDLxenCooNRDR0TEJSZQ/RIVCQ5fYMqgaprdkUkf6UQgjn/a+NuGA8OxCRmoGe5F6hh3wRROCSVLG/R6cH2bz2r4qICXWOhdbTtZmYYZqYk0lyhblroniNh2LnImROX9F7VhJNeNwipXtycl2gpyh+wYo6ZMCMvPU6r0l52KJSuFY5z/o3yjNdXU5YPafIBSq+6dEwcJdewWqr2Q5mX3jhS36jp5LXCYJ18T3iMdVMa7RosGjjOYx09DQ0LARgrTVZNAzeuFKYTxSOgEtpUkN3Tl/F+HJF5daW3fSfOaMe0vj36NJeUqGzu03DNoswdLb0CMBn9FpMPINM065/Wg9QV00MxPdXymehKA+MksyRFxHcN4PiSxMWR8AZvvNsEWsPZed4hxQMfDdipQpre8cyRuPU53X+PzVXru5DCkFPiul4TLJ8BH391r9V3H8yeuJ9smCiWHOR6YEKa+WVe4DEmbM4azvNYugjfTdOvF+ZY+tYn+/i06foySWmHfXYGJfoWEXmDQ/ZnGYIGxKEYQKpsYEM59BDadFU8w0NDQ0rIgXftgrg7/pS1qLyGiX+K94HYuly70xryNfnKmuYzjsZ0EIQA6EWPH7k/3ClRhbr8aQEjtuM+zE35JKiCcDqVUbF7IEp9oJ4fvLmf3SECbuGOOsGZJ8vlA6XbNfdXjN1Ery1CCSUcgU1T1nNbQwvp7tA+YYl0xSTr1yXotTKbVOEab0UJ7XOZO5qZXrCcR9UfJs2azv6DFU9kVwTaQmyK5s2k8FoU1LsMXzP8A5KhMWeqSkkHrGJL3aRhvr5QsrpL/n+Cht/dwaqZGiemND3lolDUXx+6aRM2eLRsw0NDQ0rIQXfPir/HAkFQoUD+68QW40uNBktUl3JBRHYSAflAhVAxo88aJJ2BHdBhgTOy40aSeAHoY6caSQFEOa7Y6EWDHhRyNoQrqkyAFXjidnXAOZelK+MiRMLLeqTFEy4D7KpJGbyBUO8lkyJLVfzUB4rQHc2hMDeg2tMbhvmI0ir4niwsICVlc4FBIARd/X1BV/XjhZjAma0bGXGKwSn7JZ2JJkWPDMWxNzDYEDnBMZQ/vwBJPwrDFw/O5f4HnGjZ+yBMdK5tPFSFzL4RhwfrhTvP2o/JXDKxu2RyNmGhoaGlZCkCraf2j/J4MS7+/ivvcy2OF7aA2t7O6lE89JcoGQM8iXqQUM+SEB9OHnghBHSdm8DNN4i17ZNthy4ok6nWRH6hearUlLGapi3P+0jwr6imaVKNl2CosnpLkQiFNiaWhOPDBcc9JFlWRnOvZc4i9RUwcwQ7W1Yv1rHGOSSI2eLwLjcNAilBIAx7gHKwhXTj0zfJAgKBNZ6aauEVrfUl+VYsTPCO7vlTHn2M71GZPFxpPyXD8m+ytWudLPcvut2DaPFa4zLTAa7wxtMNeyjkij8QJdORFYrYZs5My1QiNmGhoaGlbC6MUsot/9i1ePHPY9weF8WnoNdDDkjGFnBhWIIgObVFhKbbgKs1It+sRKFlGjpIgZfpDivrMfUHLGxWZrbZQxnRjqVQriYDtiL6DFtD1ayeCuZkV0k0H51ECQyvxrwoiigVjWnPO6I0fCpULpjowS6fka11dMbKT8Sra4ltcuczRRWZpJbMuJydyy55CUXD8UhCcm1Qs4AuFQc5wLw8BymCK5riXxkkJM9Fe8Q2JMKU9LQ3xH76EVVI5TmY82N9C216i2iRo8aMZJt92M8GOOwJmFRs5cGzTz34aGhoaV8MY3/aPwAzoAcSa+9N0Yv7zjgYozk1N6UNUo9zf1l5lum/G34V/MnEmsdkSSMuoWbpKXDw/S7O8juOOx6cJFP5jn+TYrAL3KTz5o6FdmBS/+occzPobpwdMsw8JSVKhoRm08gQmtNxaMfxaYf9L+5fqZu3aTBodnpkbaiiijq7Jcv11Lgu7IJt9F9/SUkaa73uOfNcBlvSnIfLM1RvcjJZe5/qLPiFID040w9Zy51lipH3MEDGtCzfzOvX/p5ykEdWzsQzQJci1rG26udwJqLwc1cGXbUsc/+74l7XDmxA3nj6aYaWhoaFgTltDwYUMW3hAvQS6wKhLyv5BEheLCnWidJU2jbdL2H2Yw7w2HuVTeE5lwfMw30oSMJzto+JZTxfiC9NBeCWDXheRS5SStRLpfhGP7Hywx3EyBrLpPrXQCzEQrle0hhxl9VmKqWIQjna9aP5Tqa+9RRWFoIsUSonJz5NrCeDGNzENrvZW47TIKpKMoaE6Eds/xz/YStUxuu3jbUmVN6bU26bUEZFNar+q5Eu8vAAgBtZPQdrgiem7HjcAdN6O2FRpAr33oVcN5oilmGhoaGtbEaADMbKPNj3CKmH6cupp7cQbqmcCsNzf7G/al/w/t0OPVLle+ALTzmZH297g+TX4mwA7ylDLHf1AmE1NAHlnlTNdBXeyg911o+huVPbXixqE6vOOcJngM6EA7twI8S33AZVDZEP6cRGTgnPO8NVITlinlxZrHUlrXufVdCrm2bq0AKuqnIz4LgvaU3ruBMfyJnlslfVSyzYrPHNqXp7oXNlNZzkSNEmYJ5pQ1KIPPqMMo3C3WCejdMK0OxloTBsDpsgmpEiNnqB99dl2e+Q1NMdPQ0NCwKt740y8FYDI0jUKbGHz8B7/CkxMQAthJQ4AA4zAQ+yKO1TjmQ7qSmq8zSOEdmt8MShwhoDt4Isil0BbOA6agHo/EKpYLXRqRTPGSAfWbWRH5UKyyMpIrsGeSWYRFQV+e68py0TGeYTz9ll4HRzGnPgdM+cycU3auufd+Qbam2J9sFrj9j52xprSOje5lSs6c4ll3NGXSCudxK3KmuA/YLI5n9JzX2rRnojlFyh9XpACK045zOPNFpAYejZhpaGho2AAlpEyAgzLhShImbimKDx4GkVStQiYihaQMC23JGqWhO8OKaAn4UUavTTXC/F4yAPEgg4ORmacjZWz6bRBSyLRBBiTNJia2tg/nTpzPkbwoRfXxlg6EtxgQpiaSqbrOadC+MaYmlscgZTY32QyUfhsTMKUT2pKMLhNkx6Rij6kj+RzkJq+JbDeTz60as3Hmu1Fo7ow6RjgB2b02tjTgHuHIfcUZ/dLvuOuPfp7tmwKD6zhdtgMb1rjBu8GFCg31DmHduX1YjzSgLOSxYp+ie7Lh5GjETENDQ8MJoQUghBhUISI9EOcLoBMWjAYCjshx/wdqGfKZU67oDiaESZrZnlDmO90B4gBvzqtjZiYU3gTtT7XbZ2Eixx0MZiSC79iJSMYnJQen2KHl1K7kcWaHQSz7QqxmQMkoDRZNDFLS6aUTp9RE118bBe2o+X4jnIvaKOUPUeobUXsPrEnOjEhc+n+KlEldJzWIU7sDaf8Gh5rrLLpHqtqa2Jc9fxP3OnuNTvlzFGLxNXCGBMyaZsDnol5box0psiX+rqau+JrjVGLUpy6uf3NMEDuir2tIjshMeulwbSrFI7RocR3RiJmGhoaGE0NLAVyYx3HSaDUOY9IIVSsMKRNsT0FfzMKGMwkNdBL6QprMAjtAawEoQPQK+mIH9BrSGfR2GGcfcOIdGHLFkx+WPBlNBlxYlHTbCONlo8SIlNkUM+oYxb1v2M7VBvIVSoPk6uWxJkz22j+XScwUOFPLWZL9hfXnvG7o7+zE50yQJWVOgalJTC2RUBNiUpiRLRXeNBUqUYKU2mFqu0WTP9pH0TtwC1SpiZhtSvvyXJ5nc8nZtZ8Tpc+hqWdUNbm8lWrGZpecpVyOkTP1bXho0YiZhoaGhlPCpVyc+J5F4ct/RNhQkseyKXonoW50ONzs0N+S0BKQBw29E9C9NAQNHSSoaJLPNdOFK3UIVrOzgzshzPYJBPvPJENWy8JEFT/YZtC9RXhVKvzgGDiqlH8uckqJyjTkxyY8aieYdL85RNKsYywhJuLQpULMvq7WzNRSSiSs6Omy1f3kzm8J4bcK1gx9ahhh6fmqud9LPFRKPptbfjXmKrUEgE4YdbHLNCkA580XqpQnSL0VCaNjLgw0rIeWlamhoaHhhHjDz74MLg0098MhpYwJQFcaOcTfCYH+Rgd1Q6DfC6jOqHJUZ0x/uVWgUYanuHyy2s1mBXJGv+44ZfRd4vid+qYoc8oMjAZKKWyo6Fl1wjPRn6vVVehL4X4fTfjcNTt17U4gmYmqBFwoC21fJba6Rqcw59jXuKeqSc9kQeR6zdxjmxFfqeuw5NqUotyLaYXr/VxQpZa55se79TuoBkszJ02pVOIf+v2S+mrbPUf9lS2fuwZLSRF6z7pU2TIas829LmrGbYX30TkpIhvyaIqZhoaGhnNEYsXFG9zV0upRLHY8iNYChkA5CMidCSGRh2HgYZAnhJz6RsREjDL/CEmdfE2IlZDShzCFXjNHGExUSv9zZaw5ON9ikB1vU9LetSccpebNS1ZCA++gc8nQc2Y46bXKmVYyqV0DVVwcgpfwnFrFN4lbNd8ilGamWfA5oMislUONmXLJ9idC7nhPoQisCUnLbb922NLcULml9R1dpSiFCf/uAHEw3nni4L7MPFdyYEzCA/86d6+coR9TwzI0xUxDQ0PDiTGVwcmvwsShRDlEMfpCw0ttvYLFvuD1TkDvJUSvIa8Uugca3ZWG6G3MNDAKJxAaxgjY/pg6rKFvLvSH/i9hsjFFxsduAJIKuZk78PL7uhAk9+OaN2OAu/aKaWpFsvS4g7Ywx5isb2ZfzEFutdmdn5Ot8NXcY9cIW1yns85RYZ8G1wdVfG0RNpjLruTUL3QitJSgWWqQvZHPRMk5jT1Bsh4e11QRtOReOQcFDcVc9WDN9rT8ue/E0vro2OBYBFMJ1E7gcEuivyWhbGZL7r279aILRXwummrmeqApZhoaGhrOEdxLtGR1JJGOdTRBJyvQqjOeMiZltf36AMgrZYgcCaC3xXTCEjHKKmEwECtB+yfImUSYwuaD2kw/TOGYA5u5XiHjgqKdo8wWweenNFjFiv27dPJ+jSaRKXCKs6X9W00MprCwf1d5RqTIGEpo1xIgc/0hcm1Zye+oBjE5XOv74farxpnddyXKmKntzgm1Cw9zlIdz1S81+yzxXRvtu5Kni1EOk1CmLd6lWkNgXhZKB39+Wmams0UjZhoaGhrOAE4184IPf9XILyaIW069TBXJgkTBhAD4FNPOBFhpmx7bZk+SgOgBWFXMsL8JVxKWNXLt1BoQWvBexFSXScsi3jJ0RedUGWNqBztbDMZTg1rXB6UThdK6xh9uoEaoQHCuSzJIMZPW6zJJOgZofy417DyX1dbUs6HqvE+RMvHvFLmwpqWkDFdXLmRhZXImReatOhFuOAmmzsPo+wpSJr5uSkx/c8TWFOnFfb/o+caRoRX3lVAa8oGC3AnIKw3Zq+mdcm2qCemrUCDG9bzhZ19W3siGo6ERMw0NDQ3niGgCQL1mdKB60AMpQ1UsHnpkqqs7u7IjYFZhDgqi60x64i4aFGg9ZGMig+1gK4WhDkoQ0c9pewGTErsrI2GmBnJViAeaFauBW04yakIIqvbllEyZYz6niVTRpPDMVtnPDTWT7WN5SlwrHHNl2fmHpa77I7Rjtn/MI4q1+mctn5UYs73EJhSUU+VOva8XH6t9j80J78lizvtEa8iDxu6eMh4zB23GSrm6IuIre/6lgFZmScyrZmY8l9q9fD3QPGYaGhoazgiB30z04o0zNXlSRmngoIzfi1IjxY3ZeFDEhIU6Xw+jjpG985axqR+t74y8UhB9omxCypgytU2vrWzY07CdJ4WkOwamqXr8swZ8zLVVB3mF0JIBy4aeDyUYyc6DL8X4x23LbH/qgVvg/1OCRsrMwqkmgEVg7qUaP4nVUJvVbg4yzw1/X7t6Yu+jjX1bpp6Lk8/mY4ZFHuH5yxlNn/p5uQRF71Qy1sj5grnvF9U1BxXvitXOF/WcctedBsRBoXvQQ172Q5to01a4V337NfNMaHho0BQzDQ0NDecIopRxEDaTkfvdkzKWkAnUEEyWI1ruUKhdVVcaLhNUp3oIbTxm5EEZJQ5gMigFYSNueZVT2SgTuiS13U8MbeoQ7Lead0UFVh9ULwwrWNyeORmITpC9aHIlPg63azgaUv191DCmzD2UC+lbVXHAZWU6chaU4Fg4cuYE4Pp48j4+Fo5wXtZSbVb148ZeQiWhQGvcVzX3Z3V9GRXosd4hotc+VJtTNoeNyiyKpEhGdx209+JDj6aYaWhoaDgzcLG/7mXvMx9hUBgIOsF2qhpOEUJf+oJsv3NZBAxB0z1QkA/68YCQ1uswClVCoJBJDtCPEEK0lfLGg0v9uxJSbY2PI17J5FYGg8+4fifn9ViT8FTImvmyrh/Pxf9kCsfs3xSWDOpz19rc+6x2+9Rq/aaTlbUVGbnJF06nxMidv9ir6LorRmqx5rEWlRVnApvA3Ptobsam7PM7s1+uvFVN7o8INyYTvVEVFxNpnKfbxL5aANpmfVrSb6d+DzWk0YiZhoaGhjOEI2coEcOm8nWeMTvpf7CT0DJaWSGDO01Jm53dvxNDTDTxldGOwAH5PwGhNOBCqYQApISWMghdKilnVO7MQcTmEwcupGClSdyUB0ipJ03SPyCDU5ot5+TyHNoAM481VvmnzkfqWp2aONRcz6uCU6CkjH9TJr8l93kq3OgUCpg4BCNqf2n/16geJrdd41lZYti8Eh42ImrO8Uzds7lFgrg+/2wgIUmzCZpjKbTWSANPw4pzdcSQwpAyArPv39ptG46PRsw0NDQ0nCne8LMvGw8A2Be2hO7sj7QkS2IQ7kx/tQDQCaidtL4vMN4rHMhAYvRSVwhjvYn5sGkHRubDOUzFsgfNKhhg1JRXjSN5GxQNVhNtSe7Pec8sBTdhHfkkPXwTnBoc89hXM8w+AtYKl6hC7v5d4h21hHDZ4plSUCY3gabPjdR9m1LwpbYLztE19Mg4yvNrrYxfBZg6Fvr9XD84rs+C7dz4oUb1wmWbzLQ9bu+qSFzHgR9fRg1X3Z7E8TbC5eFA85hpaGhouCbwcdp0IBClvgaG2GY6MBj8YIZdtRRQezmkx+41n0jAm9lZJYwz96UZlqTdRtq/E8gN9GpMBc9mELKxB0AxKtuQ8xaYNfGIV65jNcIGfXQ210AhTkWO1NxDUyaeq0wson1OShptSYSUqmpS6buPjKlJ+FwEBuVrKxuOkTXrTM5PDiX3UOp9y70LskRKQT2z39tMtqWsj1GCzKlV+K0C+p7b6rr050wAQs+6T51XV8N5ohEzDQ0NDdcAoxepFEi9W+PMST41NjAQOUJYdc24juF/Ojoig2pn7uv2gyVjXKptqZm03bDhTXYbmsEpZWhHtj2biZxDSkJ/pIH7Wn0QD9JG5dYeG2ecuhbIwNdL4IHlk734mnxIsBaJsnT/1UnA646YqHSTuC2uv9TksMDLolSRWLJNHAKz6nkv6LeSRQAWnALwGj4nUmqXWCm1+rlJtCF4Jix9fkeEX44Uqj623PmOiZhU84QYjcmK2saROxrh4tpMkuWRfO5eEzRipqGhoeGc4SSwjB9C7PrPvfw9KWOJGBrAqi2RInrYVNsmPXZYJsJVKU1IF0HaEQfGxn+XDr64gZAUJuPBnBXXh2ggDWzrvZLyJCrC1n1M2hP4EqxFylwzzLk+Sq6JtSdmJeGIa5KMxUgpVeZcD0v2jcugqCEMU8+5c3r2iegeJjjWRLFEHRKAXieZvtyUbKq9riquG46cmY3C5/GoPqqQiZ7r2fYkFo5o+F2qXorkuctlYivN0ubK5TaJFhaqriEB6E5C9KopYB4yNGKmoaGh4Uzxgg9/1Ti0KEHKuM/YVI1CQO8ElHfzt9vYsoRTpNAJL33ROyLGqmuCOigBQwdKNDMTRTyIiY8jN7mIVsVOOhjhVrNWmgSN4u8nBqmpgehUHUmDYG4icOoJXtzfjiDsFk4mTn1cKyM3uM8pV0rLKEVpXWtizn0wOQHOESZbo+ba3OA6Xpugy10LWyo1XP2zUdi3qx3DkZ9JJe0uet8W+MflCOVS4tjsEJEyTBtKjoutszQEsQRbnUoXxmWJocVK14azQSNmGhoaGs4VAtCwZItbmUnFLvtJdvSdDRNSOwm1lyZzUm+/UqEu1mSAAqDt770esiyBjH+oUZ8zj02Z9ykE5Mwc35TU6mbRIHjLQUnBaurswXqFEaIb1Lq6jmVuOAtLBoyRtxI6rO9Zcd0wQzVUco2cIuRpLRTdc2uRK23SUwz2uiPvkeJn5QqE+KMWynFMYmyuv4sWgOBd7maj+rhWJl2F1sOYbI569xgeSg1nhZaVqaGhoeEaIkijbeXA9EfL4Qc2HbbahS94F74EwGZmMgSL0JrETgNwfjI0gw8x//XfTaEm6wK3+0M4PslOYGf01+IJ8ZaDQM6vYUZ9ml7vjyj8vRCpyErvkYfxXtoEORXNnHATLhXuOU68Tt2mOKNgIs13URlHwGbZmuaG1jEEgGtjSeas0uxKNd/n6hsXNl6UCbaLszKVvAsWpJieBb+wFFYUPLtH4ejpcoYCEotgFXjDm59ctH/DdmiKmYaGhoYzxMd91FdCCAEgCiuSAqOsS84/hsD5x9AFKBG94D0pI0y5goYwOV+XYAeRlhDT7znj38zKfokvxllOJAuyD5VIxJMoMDQE8gPMVEhJsrxjZ4mpMO5czQvhIcGSPlhjUrJGuNIxw2UCLL2uOZPrkkl0apvEavqs598SRUkuu9oMxO2fCmcZtYH7uxTunFxTnzEWtceywbEvvWdzRsT++sj4EY13Hjco2UbSH/RaZDNeliLXx/FzYeH5EFpDwxGO0dgwVW8La7pWaMRMQ0NDw5liyJIwhDN5M1/tPF6Mf4wmhI3emfAleRhe3OL/396bx9tRlPn/T/e9SQwhLAkkbBL2RUA2WcNiMEHjggjGIcCwBGYcHeWHy8vXqEzAEFEERgQEHWURdXC+ygjjCAygzIAoOogiJOyGRQgYUJYEstx76vfHOd2nurr2rt7O/bxfrws553RXVVdXV1d96nmeGmUUpzshJXFler+nblKS/IciIhZ3hR7efUnnRhJTPsaMcKzN4K7RogxRuTsQBbAGMcUaUdKQwVvjduIaEExCnq24wU+mTOma0ghFaVYLrjuSlRk823UXsSYLE2L8LJd6K3JPqo4bEwJJwFlj4FqN2Fda+RT52qLqg3Lfa7bLlmIoUyG3J8MzqdyZycYVVajXKO66uFOycNdrD7nyww2qlUCYAQCABjF75mLqvnOT2U735csyn6knzjBicTeob2d83F+VTHdbGqV4lDOn5YUX1tuFKYqoMz7uijWjElOXKCI2bigzAOqmH2XS4o8nou6W2WKZyX7gox08Duj2xgllxIlpzOTCEogyWYrsYuPSllzbHS+emtqtSsBpzOQ3ZKDfEDs1kaRemjLRsrTKEctvbF+mequwz+etKRKCtVMXsY8/VtydTkxTQ2VxnwLco7QvkWyFrXRp4r9u+Psjcx3CNVr1h9wGDP3NGIRjZO2hySItICIIMwAA0BjmHLiIojjqrYZwExnitrrOaCfd2DFsOKKRiTFRRDS0ptMVXDpE8SijaKR/Qm63n97AJ0qsZRjnHiXbPUnY3lHr68yJMq4DI+tB1QAPMoqKM6UPRisKZChdSQ99z1tu6u0jbIjtq2h7M53bxMmRFTUIAUQFBZkiK+W6c3VpevbFoliXXreqHCH6fAf3yVIRFxhUCw78Z13Zi1hs9ahi9yo+DzGGTC5/F5cmBTrLW779eV07f+807kxRLByfKaCwyKWyoOFiW0VEOfd1p/KCxgJhBgAAGsCcAxdlXZWIUjGExT0BJo4oilg20j91BxSjEyIiRjS0pue2NNKziOmwvh9ybvWy98OIfCBo7dutMdENMiETB6xjwH+60aKMLbKJhuWkURsDJySyeBah8ghg2cVPKnzbRN8lUv59FfjsAtWYdmyLb2wXXVwqX8uRIrEtfIQdh0m5bqLsvKOWy7NV8LkO2h5V7zD+s6G82vK0ZKcqsQ8KKRaL6ITPQqKM+G/TsZlCydQi1l2M40VKGfzX4jPRFMs64AyEGQAAqJkj9/8C0XDc30WJKOsGFPdWR2Tv2uSwUZYfxCSbKSWmrqqtKCW7Byi3NZWRWNOIVjUF46RoByaywccAWdC4DEpVE+9ScY3vUISyBpm6HXdC51Mw1gWRW8wgsT3ozlXujOJBlWJPVRiD1arwtQ7zPD8hF8g0hIjt+wxKRAZTvWXKb8pX1+cHeB9ULlZoyltGH98E8dMmILTK7ccm7YRS+6UQYw/RAtl3/GQQcwetfx40IMwAAECNvHPvhURxTDRMxMbFfWGGcYJKT5SJOpxr0nD3u85QRBEjGreq0xVpOr2JljToH1P4qitWfly3ZFSIMqX5e8viEdQhzpQU88alroLGPiBqlsBVRVnKziNpl45iYhMmTq7YiDOlCThFdiSSoCtjkImya1ybEO3UJ9Bw0fQqckEqdDxHLc+dQZTJUdBatEl9i6w/cH6+RFdrnzTqoODW1y5AlGk+EGYAAKAm3rn3wsxnFkWp0JJxQSKidCel0e7kjhGlLk7xCKPhtR3qDEdEcUTx2k73ODFAXKdvVSN9P4cY9BsC/ZoGSl4DqSJm+yFokogho+yJ3ljEpo3J2mXyfQnwz04oKyob6wbx2BDxZrzKbWNdkVDGPSjbhcAjhkd6XhMEV80zo3RxKrG8Zez6V1nQWUeBN0Tw8LIFDpU4kz/QYDUjCaZbOqHaqWTDBOWhHoLOIFo0DhoQZgAAoAbeuc/ZxIbj1LqEDcXd2DBEXeuYkZ6wMhT1rWdGe/FlWFeU6aTbZHedlOLR3jEjnf6OBuJLWDWoUfoxW5oO88cUcGHyHvw12K+61lW7MrftLULbrZp80ylRlEn+L5rvm9pe0fg1LsdWHiSYn7A61r1Xndj2QxXGRnFKI1DZ08m8zKpRQeMtGxwxChoOCwpSsc2xHD7YnFvpDkiJu7SjS1MumRZY0uTKqHiGMltxi+2iCYIscALCDAAAVMyR+55DNG6IOuOHui/eqGf5sq67o1JnXNyzmGHEhvov3cRipjPc3R67My4iFhNFLKZOL6BMEvRXbhJD/cFMz3qm0OBEFvy3951yt40xhmrCPKZpyqq9GPelinKVkI9s8iTb7UQXYLeKlVTZ9sNiObypQZSt5Hn2FJMKCdxlkIgQDu0/+LtDmKQ2oj+uoM8pfJ0FRRCnrFz6IbFcqjJKXJyI1O9k2fdlxfeJmFCupKw2dW4jAkOQaR0QZgAAoEKO3O8cYhOGqDNhiEYmDneFlQ71XsRdS5lszBfqbpOdwPqDSjbUXS1hMSM2Lu6+5EdGc6JMKuzwk7VOz7ompm6MmyR524GRpYVMZYNfLnCyLL5O3YSoB+fBIQZt9pRZF6rAvxw+A3+VG5FJqFERQkxtlJl8AdeOQuJR0aC1VVHBanqmXXtaNXr3eyUGBVYhvj9ty91o4b73fjeV0dbtsfB18psMuIhGkmNV/VVV4ow3XPt1dWlqzDUAKRBmAACgBjpDMa2dHBMbimh4dYeGVnfdk6K4K5hIA8JFvS2zO4yGV4/SaKd7fiLsRKO9GDQkf1lnJl6MUdTpEKO4N5vrD77EPLWfJdT24m/QpLAMS6FCaYmToronhVUT8npd6lH83dZVgcK2IVX8F1kevvnVJspY7K6lK5t25xZfawEbFx5VoOKygtaqyuIoVJRmBVm2WJX0gSX3fS5iTP8klrGeaMrkWbadtc9W0y59Q51xUESBu464OvzYL7NtdgLffuuOrweCA2EGAACqJA3uRt0YMT2rl6jTDdgb9dyZiLrfE2NEnai7ZXZEFMURRSMdihlRvGaU2FBXnCGi7vkjHesVFBbHfWsc2wmIbDtH7tzaBpQdRhH5rcg6UeHAJzcBcs2bH7Q1LP5Oo1YfbamwDk2TIdeJjk1+pqDcrtgGA7bJ3wmZKKPo36SijNh/9s4NEpi85UjbpcuW2Lr+K9RW0Z55BMPVEolvbxW6DSWYhDZnocTiPRU8T21mkVW96sRx/nNl7y3btjBgfcxYB8IMAABUSDTSITbcDfQ7fmWHOuMiGlrb6bowjXT6Vh+J0BDFxJKIwBxxb9tsNtIhNhSng6FotJPNUBgkpgONKCIaEgrH+2LzpsKZC5D4Q9cpyoiDwLIG3h4DnyL1kRuUZrY3D+BWUePKWqPcXYrQwPrTTWhM9a6LueCKaIHjEkQ0pLueKl9lHipRO3EHla1gm1DtitSEwJw+eStidpTdp5Q6KfYoe7Cgt/z71iJPX5fHIs+2U54aa7VgwcJd3ZkcRRlTP1pKO9S5sBPZx2mC1UyrgTADAAAVEq0doZj1LVtGx8UUdYjitaOp2JI5PrGeof5AQVy1pN6OTVIyvsiWhVSJMsl3Fa/oKSlrlShAfIiiAzd+YBgx6u9uEiDtFAsXkNC0WpSpcbCrC+Bre75LPq7nmdIpxT3BRZSxdMGMSDNJdu33CuwIVQiV4OOzM1MTJngqISgkoa/TIr2MRRl3bUWs43SUISjoRBdb98GxiujKlvm/KMpYktmhCbQSCDMAAFAhbNxQ14WIMYrWdmhotLuLUrrFNX9sRD3LmeQL6g/4eD/kkb5Y4rUq5iq28MfXKdJUMWngY0VUPEkZtMGrzqUEZJEJGbrnWCfcuE7sQk4EiUpqx56WMvzvynKFCGbOuxA67kJknZ9MQCkab0KsV1kaYv04ulLYtgvZrjVFxIVgFi5kaF+SxRBdYO3QLoQipoC9VfQPvvVttJohIun22QHeM2VazShFmWRtLia38veeQYgy7QfCDAAAVAgbP9yPCcNY14WJD/YrDEKJet5NvLUM445PzlHEQZAOAMjwnYjMrFYo66CJCDmasHIcgjrdb7i2Vqi9DJiptmqHINdJU1OtkULHw5Eiaw+GyZnNLjNBxCVLC5ZC+cmeCUmdOLt2SY6T1puDOOPqzkLUrLbtU5aQImVoyxfZeMF1gafM9791P+ggztim6W3ppwrsrcyo+3vEWDe2IBFRZOE2yfctHUZsKIY403IgzAAAQIWwqG9uGo0yok5HvUqSDCw6jGhI+J4XS2yD74q+7LaijOF6pFkFXJ2snALbuhI18HqbImKEjEVUpzgTMO8mTTiDoItJZTpVMxl0CSYrioC6sslcrkxlssKzD3GO5SGKPpqdh7xEGUk6XoF9CxLCFa5MkceUpk87qrNvKNtSxyctrzJZWs7oxC5RuLK6LsPzn7ue3tiM+VgiF9g6GzQPTy+2sJxyyikURVGQv2222aaWa3j99ddp++23z5XnlFNOsTr/mmuuCVYHURTRk08+Wer1AgD8iVh3dSNjupqQWMNIXrCZl66i97ZeWZLtPCIjFvKKov6fbX5txWML2VaQBBCsgSCD9d7qYBCSunCtk4L1FzGza1Kr2hSRWgzR9Gk6jO4ikiCjGXc5WaBy13yKELKN6vLwjCXTXSSwzKdBhBBomvhsJe3X9Ow3TfhXlidwe/JxPZSlUaT+nIVTzbsqTUvsq2xm5prA4SwyvMta8pyPVQbOYmbixIm15Pv5z3+e/vjHP9aSt4y66gEAoObIAxZRRESdOOrGjVnHqTL8yzgNABen25GmYg5R3vKFP0dYBZauEsrOFwc3sm2xJZ9tVpnS05piUWJj8WC53adI7dfmgqu5dQEaWS++u1V51BPf9m3in5SKjUDiG5/Bw2ImqRO+35LF1zHG4pDFmuDLYRBnSmmjRZ8p10mUpv0ar68plnUWlLpDE8nfVb7PpXM5C1idVY2Vq02V7YoXZesQYx3JvA+iiCi2ePdAWBloBk6YOfbYYyvP85577qFLLrmk8nxVzJw5k6ZPn153MQAY8xx5wKL0390dP4SBTOKeJA4ieDclbmUk8wI3mOort3WVDfJ0EzX+eOFclwFnyIFQYYFHY+7vkj8ANuR2UasYaxeOIrvf6LaZtgimGyKga25nE8frKHuy74VLH+URcLjNhArAapNGKc+t7D7J4sfxPwvCbp3ttTShT7MrmOz60wDRln1NUQqPP1TPp2as5ZQOaDWNEGYuvPBCOuecc5zPu/fee2nevHnp5yiKaMGCBQFLZmbt2rV02mmnUafTXfmePHkyvfbaa87pfPCDH6S3v/3tzuetWbOG9t13X1q1alX63emnn+6cDgAgPNJBVBwRsa65KRs31HdP6hnPRIyyqya9F2/GRF82CUrEHN3gRLebkskXO6Ao04gJkM2AxnHg47xji0+ZQiDbwWUsIlt9LOseCGJBle4UuXxU1nGBdzXJF8S+DzHVT06QEfrRtA/lAmhGZL6exlj1+VDWarrGbaJKVDuVlXGvQljKiOnkEHdvEttxxcEmbK+zac+GbPcuIsnn5GtRC6vjeizEGWMsJ9H9Nh0rcr/z40ddmqAxNEKY2WSTTWiTTTZxPu/LX/5y5vOsWbNou+22C1UsKxYtWkRLly4lIqIZM2bQvHnz6MILL3ROZ/3116f111/f+bwf/OAHGVFm8uTJGbEKAFAfbDhOd1RKXpb94G7d73PnRERRbzttot4LtZOoNlF+AqIhN2h1EF6cV28cKDo4CDa40E04FKvPhVyYxPzqFkZkwUPHGlVet2THNSVVbituMPsvlJZmVxQTTruxiP1hh4iG5Hm20eLN2kqizPbctBX65B1JfbHT+tTIQ9SxaNdiHjZIg1U3UJQp/N61fdfw7yVJm5PdO18XUd9r8jqvivd9r+7SDSYkC4OsqvcK8KIRwX99eOONN+gHP/hB5rvTTjut0jLcf//9dP7556efr7jiCpo0aVKlZbjyyiszn4877rjKywAAkMOG4u7fcO//vCjDw61qZNyViIg6HYpGuS21GSMalQkJYuaSNK0KLS5JFnuJN2J1SgY/SBKDvypMqYPFlZHtpFLE7LvIgC9kIF2QQfo8q3AVRnTBdD0C7WaCeovBKHV5yPIypOE6gdYG7NRdJy9uu6RZgLJEn6IuX4WooH+wfU9J71tO1MhXkix9Zxcm22dDkbfqr18gxXMkpFVG+zVZr1Xe7vg2J7mfsvI41UsBIboKUSZUfTdmvAWsaa0w86Mf/YheeeWV9PNGG21ExxxzTGX5j4yM0IIFC2hkZISIiObPn09z586tLH8ioqeeeop+/vOfZ76rWpwCAOhhQxFR3HtByl6SvdgxlQsYZQYATU4PdE1Bd6gxCRmK34JOuCCEDDzW7UUlouiePdct70OjytNj0kqkmajakrovCX+c9U6h9C2xWbEvzS2mbEoUcIPHYJLs1sX/WyuOKM7zodD95p6lqoQRXtgIJv747HhXNnwsvqq6T82zI9axdZ3rLH01YEvtZtMIVyYfREuRE044gd70pjdVlv8FF1xA9913HxERTZkyhS6++OLK8k64+uqr09g2RES77747HXDAAZWXAwCggDGKRrv/zK6MmV+OqXlzp+f+xE00cm5RNhK7aIZtclUqGEQvY54dKQIRO1DnSrFMYPLy2RYHUiEGq6o0If6Ujso03kmUKYsyzdVN7kqW7kzK5Jn5uUrrudcfMl1/pgkGnLlfPfexNO8x/ixVGmTWJ2Cz0M6M7UaTh88E3TlOlM49Mflec0wrrB9k77Q6XXerdAk14SDOOKXJu3t1GLGh7IBQTPu2X/6zZ2agClopzDzxxBN05513Zr6rMuDtI488Ql/4whfSzxdddBFNmzatsvyJiBhjdM0112S+g7UMAM0i6jAi4gaDUURErPs995JW7jRAxO3O1PuHyRddFtxXtrW2IhCnTYBME1Kf+QIEHZDaBsg0TMaClilU7IYmrUo6MEiBCUtfga3A0k2Zp0nMtbT8sakj76CufP+nqCtl2rJrsngum7JLTkhCBNn1vYdOwpzC1Ud/socIZCqH9QmGvFXB+TWEjJ3ijU1Ae9d3XIhg1qpFp3Rxq1jyjSBnISYI1ZpjQfNopTBz1VVXEeNeuPvssw/ttddeleTd6XTotNNOozVr1hAR0RFHHEGnnHJKJXnz3H777fTUU0+ln8ePH08nnnhi5eUAAKhJBZg4IpZYvPRWZCMyW2N0D+idM9SdvEdE8lUg2xgWquMEcUAVKNM0kMnsLuHp2lAIk8jhKMqUJhqUvRrftECdGto2OA4mvvDige1zEmgymUvW5ppcV59LfPb52D1sqP/vFE9hOFM3Fv2AbVuoK+BwYXfSAluPO+WfPAuWbcy0Y5dVYNiC1hTO95R/3m2sZwrkX9ZuVUp4q5iQ7x3PtIyCWQAr3sbSYURDg3pxg0/rhJnR0VH6zne+k/muSkuRyy67jO6++24iIpo4cSJ985vfrCxvHtGV6/3vf7/XzlYAgBLpxY9hPUGFjzPDhmKKRvuuiNKAhr3BAxuKiaLeqaPZ361RrCCnAxiJKCM7Vpk87w4gDD5rGSAGOL+Rooxue2fsshQU2eQm+AS7IWb22uu0nVBmEghkeaconzYvWV/nWR6V5YhrO/A5pyiV5if0O3Vcb+spKEg1gga9d2Qux42vv0Agjkx7aZ0wc8stt9Czzz6bfp44cSIdf/zxleT95JNP0uc+97n089lnn0077LBDJXnz/OUvf6Ebbrgh8x3cmABoIHFENMqJMzERSxWWnuDCWH4ww79U4+7xrDfwjYpYoSjcl6SD6N7Kl5WFTFJm1ts9iri4OE3CZC1ThSgj5OOErVl3gwbHbUQMFurVBoq4S9ie29YttTlkbpxEDoJIUi6VBaGijopM0HwtFZq8Qq+8JlP70vRJtuJM7jjGKCK9oG+aaEutZkhowyp3PJcd1FyfP4/nyDf+DWhgPSgsikqxcMI4oJW0Tpi56qqrMp+PPfZY2mijjSrJ++/+7u9o1apVRES055570qc+9alK8hX5/ve/n7pSERFtvfXWNGfOnNLy+/Of/0wrVqxwOufxxx8vqTQAtIPZhyyWboscUc+1Kd1xIaKIFzCSY9PBW37C0XVr0mReYLLGIkrLF8WkfLnntvlkjKKRTncr75goimNiUdOUGQ2WsSSkg6c63YZa5LLUJFzjgmgnR6KQIu6aFEo84dMqIJLwoqOTABnAVSg9PZL/W/zOasceXf061H3jJnGe5OqJazeuVmC+MWKSc20sFYruVGUjzvCub9pt5p0LwNTPRUFXpYGlhndWbrxCZBT/gmMQMYPCbVwwKP3aWKFVwsyKFSvoJz/5Sea7qixFrrzySrr99tuJiCiOY/rWt75Fw8P1VJ8oTp166qkUx+VNgC6//PJMsGMAgAWJ8NKLLRONdnrBgImIUfeN2RNAWDpo5kSZDhHFhsFLwcdetQqtDBwnwpU3GmU96yBGrNO3lmnUoEAMJugoxihFmeT/joPNzARmKO7e/6LuTRBpCiGb5CknjrKg2qrjXK1fHHdK80Enehgn744r/779AH/eQLsCBcBWuLKdrFndM0v3SVVcI5ULbyikdRLaEs1W6BnrgkzCWHxHNSEwfxPKAIy0Spi59tprad26denn7bffng4//PDS833uuefo05/+dPr5jDPOoP3226/0fGX89re/pd///vfp5yiK6NRTT62lLAAAObMPWdz/kIxB4qj7b8aIOh2Koih1T0oPjaI0KDARdQdyvYFvN6gumSdDqSWOJE4EWZxvQc7sfLR3TcluAEM9sYkfiFYd+8QhP9NERfq7LP0yrzHATlJjGZvJaGUTcdMuRxXFcKkKW1HGZMVUV9wSU77OlkcBCVEfKncyazRWlaq0VMGBS2vXph3DLHYuzJzna10jy9snjQIxkxq1WFIBlbWxhjIW73mbaZUwc/XVV2c+L1iwoBtvoWQ++tGP0ssvv0xERDNmzKDFixfrTygR0Vpm9uzZNGPGjJpKAwDQkhnsRkRDRNEo9QdXquj5vWO7bktxemw80umfGwvHi0nIRBnh39oYM7r0qHcNo4yiTqf//0SUieOeOMMd31BXH36CEGpCYms9k7UGEI53Xd2CKKNEdo+DBPW13TJa9X2VMWIcsH4OLHaV8hXDVM9jCHFGdu9V7cG2Lmqf+Di0JZvYLaHwdpWjgBPKMgKhmtz6TNYyPs++pYukjRhWe3utCFVfUfn1J5ZlNbynx8q9HhRaI8zcc889tGTJkvTz0NBQJdtU/+AHP6Abb7wx/XzFFVfQpEmTSs9XxurVq+nf/u3fMt9V4cr10Y9+lObNm+d0zuOPP05HH310OQUCoMHMPvSL/QGTOBbrEFHElAF8I2GSw4ainrsTda1SUhcnx0JZrNRJRQLOTzmz2xJR30qGE4tYHHPijHk0UNkAUVYWC7FG/K7Uskosb3IubjbnFmXAd3Xy3VWHiOxWq0sKkpsriuM1eG+RbTpOUxe27jJVWsHo4tkktM2FyYUq+lvZPbXpP2X3wWTJY32vqnArkgWcdtnNTHeM665oIEMjxIk6RRm4MbWG1ggz4vbQc+fOpS222KLUPF988UU644wz0s/z58+nuXPnlpqnjuuvvz613CEimjp1aiXix7Rp02jatGml5wPAQMANnHhxIuJfytzASjXpZj1xg0Xdc+MksC5RVpxxdYEQt7CWreKIuxMlokynV14+2O+6kW6+44a7gsyQXHQSKX3yI8aT4b9XIAsQ2P3BLZ1KB2Bl5TXAQYULtz2bCVSDcJmUeO9ApbDaK2NCJI+LlT/OFC/IdI7tFrtVWiCY4siYhK7QgX5dCL1jlfdzHDIYtyxNC0syZVou4ozk2EYIEA1hkAVWMLi0QphZtWoV/fu//3vmuyosRc4444x0N6IpU6bQxRdfXHqeOkQ3phNPPJEmTJhQU2kAAEp0OzXEEbFkwmtYxWBxInL0rFN67kIsiuSWM7KBIm/potpqW5iEy3Zcog5180+sdvjrHIq7QtJwTBTHzTT/dxEZfCfXoYSMNK6QWjCrhAEWZ7wQnynbbXVVWzkXKYrlbSldlElPlhcoor5g4JRcBX2DTCioK46NCVmZTCKH005igQldj4Xbg8t12i5w6I4PGNMtQ/LujasVQ4EnGgtU3CsgoxXCzA9/+EN67bXX0s/Tp0+n9773vaXm+cgjj9B1112Xfj7zzDPp9ddfpyeffFJ7Hm/RQkS0cuXKzDlxHNPWW2/tXJ5ly5bRHXfckfmuqh2pAACeJNsyMpIHiU1QiCIRI2LEiI9V42zKnKysJbs8Sc5Vbo0tsZRJXZeiiCjuCTFDEbGhoWy5Hc3WS8HRXYmImmPx0ARBpAll8KCyQKzi5Mym7TjEAQkdS6XIsVbuPjJ3EYv+yhQ81/isRlFwkcXWWqYMXEQYL8razl3MRlP/Rdtmmq5P+UNtY+1bb76Cru9xoB40C291ib+3/fKf68kYWNMKYUZ0YzrppJNK36r6jTfeyHxeuHAhLVy40Dmd66+/nq6//vr084YbbpgTb2y46qqriHEv0/3224/22GMP53QAABXBWLpaTB3W3wrZYmtjFvXii3QYxcmuR1EvqG5Cwa2yjSTBfXu7SBFRb0vsDtHoKNHQELFxw0TDcd99iTOnbyoyF4jMID93QgXXpBHqKqelYoyM2i0fCljKFCl7aIs1p2DAqp8MYq3381Vgcmraia1qpAHWibyuzSouUAXxSorsWGUKYqsSQnOiWhm7nIUWZWTCruz6YupbzfDHQZzRUtQ6xXtzAIU4U+kYCfFlWkXjhZlHH32UfvGLX2S+G2uWIp1Oh77zne9kvjv99NNrKg0AwJVUlOnBor6binQA3XuRRqMdika5UZg4KNMNxvjBWrLLU5q/5PDeVt1d655O6rqUWsiwniiTWstERDH1t8WOolYJMrnvNcEhqwmY2bvnTbHYCUENgYQrmVDbTqKSYyvENJktpS3r3DZqnjCqrDZCBPwNWZem2DHixNC3vMrd+iTlyV2fp2tjJfVUQl5BsI03Y+r3M+7QwvcVv6vaQqht7GsX+H2AG3JrabwwI8ZVOeSQQ2jnnXeuqTT1cOutt9IzzzyTfl5vvfXouOOOq7FEAABrNAMufZDGRCSR/BiTvR+8zpIl7osBjJtcZXZcSoShTlckYnFENG6467oURWlZmjwgdB5Y1SHKRJR1WWsohVYeSxZqyhhAK90xKtp9yYWq3AdNIkKZebvkKcvbFBA4e2JxVxGb5yUnDvOCungc515KRP13gYOLnFVZSFJ203NbwmTQ+EwLwoRP/1RU8LLCV5RJd0jkvtNYy6qu32eXLNClUD3VJY7w+Wosd0DzKNsYvhCjo6N07bXXZr6rylpmr732IsaY89/ZZ5+dSefkk0/O/O7jxiS6cs2bN4822GCDIpcHACiB2Ycszn7BWHeyLbycMxY03C5HRL1BQIf1t8cWe2mbXpuzYkmLohBliJL8Ot2do3r5pm5L3KCRxVEaV6a7JXZc+4q4DnG7VSUGk/iyiZJ20gK8zLkDorqnwSZU4rNIBduBZtLVdVkM084aEdOJy0v8k1H4nnlY6yXlSdqR0eWn5P5NZbHHIurG7uKzZ/2+Oep0eu8RyrVZVd3bXLNLO7HuXz2RBqGXIbxDG2fhoNtlyUbc7SQLNax/z2VpJdk17fprJFT/2npgPdMaGm0xc9NNN9Hy5cvTz5MnT6Z58+bVWKLqeemll+g///M/M9+NNVcuANrA7Jk9UYazfCjklsLv/DJE2QGcascnyURCK8gQ9eLfENFIb9cnolScISKioZ4SNDTcE4q4mDINtpaxCg7ZINeLgXJhStBsw+6LU3DYgiSryla72xDp25lLrCKbNG3TqgHb1XgXMaWOFX5TW1O5F/HfWbtMaQIlK9ugS2wRoX+JKFy/ndZDwMlfTpSxQQgG7ZJX5c+SzTWJxySx3uKYWKdXYMVCTWkxnYCSxlshQZxpBY22mBEtRY477jiaNGlSoTSjKMr8/c///E+h9Mrmu9/9Lq1duzb9vNNOO9Ghhx5aY4kAAFKi3p+IbDemDhfLhV81E1f8+EG3xArGNLjTDhI6LFOOTDwZPu2ou+MSGzdEbPxw9//jhpy3xq4F4Vpyq888gstXpdfVuxdpW4HZsTVBRRmJ64p1+qEEPYsJm6l9WlmDlEzovKuMU6LLz9UKRRRyuomoDhbEO3EilVoHCe8CW8se4V1TdMekTD303iVJmkHbn3C9ZfTNpT8v4k5YRc63JMSOWMAe1CsIQWMtZl544QX66U9/mvluLAa8FWPswFoGgHYgtYDgfX3FOAG91U8rn/pMRpH83yo6gvjDmcOncWZiImIxUcS67krCzktNHoDoJj82sTEquTZdrBVLf/DGr861DV+LJdXzp0hPG4wygNVUkVgSugCzMisQU19VaRttULBL2T1I4cViRb+jClYcMUotKNOmYhBlfC1tnO6bcE3KdiH0e66BWcU2GIkrIRXsNmXb9uUnO55kChwcC8eqklE8x6pj8V4BoD4aK8xce+21NDIykn7efffdaf/996+xRNXzf//3f/TAAw+kn4eHh+mkk06qsUQAABmZ2DLi2EucMGQsaLjjdDubqOBWTF0CGKZBJEf5ssT9XZaIiGKWDnDZUJS1jpEJB0UmRRZbiDuhE6/4301uX2XAX6tqMmmoA8QQ6GN0NbJF5kqimxRJJn+ZSZtu56be5LWawNJux+uCh4rfl+FWVkW9yNqMi3glplFF8FjlbkqCuKOsP8P7xbc+UoFEIThlyuMZhFRbFtvnNRBe7bOo4BoTsU5fhmIqMViVPddWdeW3Oabx1LATIAAhaawwA0uRvCvXe97zHtpss81qKg0AwBtuAp5xU5KtiPEDW1MMFA/Tbl6UiTqd1DSeDccZgYeRZpIRetCTDNirGExJBu9tG4SKE8G2ld8V04qvVpzh77dpJV313Fm6F+XKo7KgSVwWe3E+Mrvt8OVQxBtRFj/g46MKsGwbZNhnkldoYujYd7gIeraWQbnjxFhBithBXs+vQhS0FjF6/w7RZnLiDJFaDJDcJ1vRT5Yvn0ZV8cGc6ky2SKAQsUznZixaZcdqFhpsLGXEz4P+XhkTNMiSENjRSGHm7rvvpocffjj9PH78eDrxxBNrLFH1vPHGG3TddddlvhuL4hQATWf2zMXUX8rq/k8VyDWdgBH1RRBxgGwzuDQIMtoVsST/mIglIzw+iC+3osmIqnupF8wnt6KsWz2tS5SRBF4uirb8JeRXNzr3GqsgvY6TIeXvFq4gSjcS7nxlu5WkJxJiUs1PwGyehdCBfb3ODTTZsHFL8RZvRCGuJPcaZ6EuZBm4+yBzLQpmzSYg6wPKyssHZVlkQi3fLlTCMO/yrM3YvY1J222BNuJreRWMAXjHBQOx6lpJI4WZmTNnEitph4qy0k0455xz6JxzzimczsSJE+mVV14pXiAAQPnwC6FJHyMGco2j7G5HktUtq50oVGbiBjKiDL/bE5d/WyfyThOQJljKVFGvskEZb+bdIpNv1QS6klVdfrLkO35QnSdOyiSTtDraaF0TXOtrDdxmXevYOf5KOrGuxlovlGAnI1Ney/ugW0BwfYZ1fYCLOKM7tohrWu5aVGKrjQUfTyLKqI633MktUwSb8YYjPvd0TFOmRUvynofVTKtopDADAABtwbjNMe+mIztWXHVUDZYUcS5M255Kg+EqAkayKMoLSy3FduAdPL6NjqbUqetKWoMHdspJQDLp0VihSM9JExYSDWVpkJRHNimrI+YR0FLYEqPTfUewUO3HgPT9YXCJE2Pl2FoQydyPePcl2TG6cpiwuQ+296uwgJM8vzYLLSpLGFXsMxFRlNG5OnPfWW+JHnjBGv2WJfyiXUPfr6B6IMwAAEABotG+qKKkw/KDNO63HPxAqUPy1TKLwVQudkWShmxnpTgiiogY9cSZlgwWVANsWZDO5DNwgB88EjWyTRjjy2QOtvHXESY+mpgvZVJVIFwxz9CodhkKlWaVwYKd8+oFbk3cRZ12i5OUgz9He+9EVypN23WavPMBrCUT/ya5FIVCKljJRJXQQb1lcedkgX9lMbE4V0mjG6RjLCsQiCpj64HWAGEGAAACoBu4pwKJYWInHdAmA3rBtSEJtmjaYSH7pVqUya3oDtCgwSSaEdHgmfzKdkDxubYG1YdVHBmTC5vNdvO64L8hxBkxAKhYbgt3RVvrAVdCT6wLpWUpBnqLJh5YXw9/P4cU3/MY2phTcFxL0d5rdyF+oUB1WAnijMmKx+veK+pclZ5t/xNcmPLtcxzjxUCMGUAa9P4GdkCYAQCAEsnEdiGLwY/lJJAPHCzNU5aW7Pg4WVljxEiYCJX0Um+kDzrvj518ltEm8aYF5XSdVBuD6rqimrzo0ouiTDm823LqNkjZ+COSLYetknMRaTXnyOrY5xq9LGUGLWClwrIih6XbkVFslVi2uE7stQKEKQCtkEbRdhRq5yz5SerCOL+jeNcmnThc1G1INj4wiNGyfipI/wWK04J3NKgWCDMAAODBkft/QepXzuO9cqYYaNnumtI9WC7w5NLgLCuM8XIaRCmuDLyViW6C2CZxpiXIthw2BQ3NJqC5X6IljIsFjIWFgDRLm+bRkfx7SHZgHtG9IvTkqozJmpMoY3i+ZG2gDMHXZmctE9J4I7r0hXNTQohWvCuSa30pREOX59Q1z8pdo4T6MaII2l0JBcQ3IggyADQRCDMAAFAQrfsSUc4NSYZq4G69HapspTRzsCYQYMUiQ5XxJQZ5VbD2rUkLIpu0iZ+dxJn0R43wonNTkpG4EgrweRsnm4aV8kQQZYoVd50Iw1sm+Lo8FUH3fHm3R4fdfqp0mQmapnif46z6J6070T1RVk+OQoHKqilXt3y6EnEphDhj40JURUykbkYObkDcu7WW+DolbMWOuGwA1AOEGQAA8MTaLSmKiA3JXWRc3Qxy5/GCTLIDyJDdoLzt2AwYMahsAZ4TC+PE3DZYti5IsGUa1qvrfDoxEXW6gozKWk0UYXT5+oiQoaxMnERCmbggcSF0ncCbftO5KTpNqEP1q0K7t7oPmvdH+jzYWI9pUNZFINcfHxFDJ/zk0vIN+p1LXN4v6a5Te22qRZOilqqGaysaa6qRrscADCgQZgAAoCiCa4tNXBknE3bZ8RK3jEhiKWA9oGqRe06pg0RxotgC2jholgqLCssUn9gpmTR9Jz7cM2Sc8FqmlfnMWOomlcZ3cklScVk2E6my24yTSOT4rOkEOatA357IJt2572zdnBwsI6WnG67fSvQwbd8cCBfLJl8RwCcwuLSuQsSBUeXtUr8mQXjAF10GhorHVYNsITxWgDADAAA+2ProewRezCXBCz3JzhgiMRWzlGmJKFMZLaiPNg2++GfF6IIUctJhO/k05O0z8TPieZ1FAqL6thnZgN+mHNI+0sFVyYUilkKm+2uyXMombrCIcBQg+WNMvxdy7yroEqOzmrINMl0aLnVuCrofIO9+guFFlza9FwaWIgs7nmJOLW50IDgQZgAAwAdua0wmWssQZV0hettRR4w5vXQzq7Ccq1Iuds1QJF2RwwANNAGtSbxshZp3AeSP554dqdDDp+M64TG4aQTFYVVe6qpiIKmXMp5/2eS7cP3ItnYvARcrxdCB221+94oTJFhJerlkhbIQEdKJyNFqMznP5I4me99mErDPMIQ7VWFsBTGL+xWyjJUHXi5AoyxFHIKYS2nBohAoDwgzAADgyJEHLOr+w7StrS7groDSdYkXZTqdXL6sJ8gwfjeh0C/2Frk5lUbRwdYYxRTg15pY85yJZLahFr6XuRSIgo4Q98MpfozpHI0IZcyipmZncptpxGTIgGvdubrfiOdK8/S0hJCWRTY5N0zwteUqIs6ozuUXLxwu3dYdzScIvC++1luufYfVMQV2bXSlDc82T+Pj4ZQ4lmr0dQNrIMwAAIAjTivXvLUM90I2xs3gBJnu95wrUxQRi+P+jjHJQA3iTHmM5Wv3wHnlXjG5SwfaFs+ON7L8OVE1ed5tLCrEc6RCjGzl28GNpAkD8NLKYNnPuOz2kxzvik8AVFfXGOO50gMVrlHJO8PHcjKE+6BKoFGkXcTVrpC7ViahckUOY6w4mUgs3sMSgvuCipBZAo71sRTQAmEGAAB80ax2Zydxrsu1WVGmm15P3EmEmJ77UpFBWWayodmxJINoOSIOPAZ0wOG060zVNOgeBLXq4FbcifST7jQ4Lx/wNxYONLkyacQRMW9+0q5tC+Kz3yGimAmf7cvZhHZXShk83Jl8dvdxwUX4sTnGNElXtSethYs4gReCzgezWPOlV56IIuGdaHd6iPJKXR0rxvk6LK2fKqXk90wRd6Qm9ItEJK+jFm0kAOoHwgwAAJSFIGKYTK/TFXZFgF8W92ZwPUuZnKjiiNeOKclAQzUoK3E1qC4/8sx96Q2WxYlGbahW5HgGRCyzmrgWiPEh3bpY82wxTb3mrGX451knxgSejLm4e9hQd5uXCaR1lkk24bYVcVWWl1aBspUFinJ5at3qKtzdxzU4cZ2ijNjXiGV3DTQdApnl3iBSxjXWMnZI3g8u4oztAlmPsdAexhoQZgAAwIE5B/biywgTKe3gSxBljPCTOH4Cx7ktJW5SOqytPFyFHX7QYDnoaLTFiQleLIurncw0maC7FDkGxDVOXEMHNpXhOIjunkPZeuGtZ4RJddFBd9CJbRUY6tEkYpQGL8g6iiamsmWECs4Kxpi2wUpTmn7mB9b/f9H+jH92k3eXLLYTmevMt715necY18knjxDPj9OOYJr8Cz8nyfNZkst0Wc+x7B6W3meI9WJTT/w4ysGl05bb7llofzCoDQgzAABgyZEHLCJK5nsRpbtOZAZflgNd/c4T/IFZU3UbQSYtk8/2w+KAQByMif+2SYPcVkpl1Lo7hMo1pgnUZCpttVNMUXHGdackWX68QFOyoCZ9psW2IwYfZvnnRPZv2/xFik5AGimgSnb/KbWcJbYb63acCfiuOdeESajUxFryWlwo0GcG3RWoonvoGocoVIDoJC0fd7FC+IjTFVPZ7lJwWQIBgDADAAC2MJbGsuBN6KXm0uIuMhKRRDmRk03cBFEmjTljWe7CA1NXAUAjzjRysmcibqIq40HBVU4rQUb3nY2rkY+VCy8GyfKxaf+2z4mi/kRRJaIon6ZPuSyoVbi0oeCuZrk+1iTOBJgw6lyNiqC18jIE0M21McEaQGs1IxM9Zc+nJohwWZYpKlTvjKa3d1uxJvSChau7mBeysYBqbNAQwaYycaYIDakrUC8QZgAAwJbR3otziLqDTXGSKxk8U4dpV8XTUyUmtmlA0+T7jNgjWLXEkkG0MDFsgihik7+snD47pLiim9g0Fp9VOg9xxlmQ0R1rO1GzPdbTXSkjrApBU4lIG6vH2iRe4XKS1qch6LAtoScewZ6xMlaR+RhcMr3UwyVAmZWm+DoLJb6vcqJgO3B21XDMT+p6lSsD6x1bXsdZduDnUNha0LhcR1nuYINOpYJVnTsvYdenVgNhBgAALIk63dkAo5iiKKLMq0+cXBV5MfZerJnVQtkExyYPn52b+Be7bmIl5l9wVdyWsoSSRgswMnwnvSHvjU4U0bgWaSdWvOVAyS5IGYFEh0edySYC0jamCNjauvYo4hLw0hRImahvySEGUh4SThCFaoeJiotbiur3nGtr+kPxG6psFxILIiLhWFtrNMFq0zquThQRxYxYR7AQEy1ALevBxhqoClzcg1QWLC552OQjO7fyeFA2z3fDRILK2lCdokzy/wbVO7AHwgwAAFhw5L7nUGQwNTcOrmxFEu6Fmh4vDoRcAsOpzPpDr2YHGgiIA83kc+snqiFxdStLKGOwpotlxP8msyhTYZi8aVc/PSeC1mVTHKez9DK5M4jpqNIzlcl3Ylgbnn2Q0SrDMHG0EWAK150oLgYSGa0m4NxW84nbbWqBKbMOM6RrPenviTOZciTfJ//3rIdKhQdFGZN65NuGyRLDtR353gddOUrpA/h3ySDGV3F1z6o73s4g3oMxCIQZAAAwcOT+XyAainpjzEgvsIgrFUpz7/x3skFyzi0qyUPMkyTHycrWEnxXSxs/EQ1BDZYyoczAQ90bK1HGsRy57zwCK6vEGZv8k/OLwN8n6z6qDHT15lCnJrcZLcn987CWEb/3arcyEcJDlPC2phDEmUy5JOnq0pAiC1DMf2+yplPRsF3vbNzDbMQZUxqmc22oLZaKjYXtIGI79gLAEggzAABggPVevpE4quokq7a9z2LA3zSB/oeIhEGrZhCqHMSpXv6hLGJk22G3aODlukvGmKBMS5mmIHuWDJNQY+wix3oL3d58RAHj8aG2Ya3ZXJ5FkXnXn4LlKxzXSmZl6SDOmEQ94yScE2ds8lLuEiViKr9N3xDYzSsokvLw1kfJZ+dkK1g4aNQ7b9CEijZdT90WPMALCDMAAGCADfVG/4y5veR6MRGiUdabRBQbkEtftFW8fE3bZwdCN2j19dVvNSoXJP4e2IhxAdqGMm4Gkd2KuqUbX+h4Ca7tocjEKUTbEyfHdbdn7Up/HQP+JI4JubctZZKWooVTOo6ipZPYIpzHB4lX7owm2WGJz0vpluO6S5ptDJvkuA5lxbUQAo2rYOyQZxMD69r0WZX1KYMkAthci4dVpQvWllYtWDADdkCYAQAADbNnLrY/uPciT3d54QJVRqw3mbCwlLHJg4ikL+PKXHlKGIA1ZnApybO+wJOabdFl9yDwfclNRGwnPfxE0bGtK1ftbV0qklNc71nJgYatixE1xyXPyzUi4CQhJzwQZSf2DYlV4iTKcGUOLuY5CCm6eCQ5ccaqIP33XSq2iMF/RUyiTJH3pcoix9FSR/oMOFq8li3omBY1QAWU+O71fh8MklA2RjAZgQIAwJiFF2XSybFh0pHZerdnas+iqB+kssjkr2CsBOuXdAtWX6oYbNY+oO2wbrtr4uDKUaDhV+h1Apu2zh1XwpO8ZGnyLipiWZuAbywK1fVWXZbQ+fNlYFHXvZTFUfa3OCql73K+fl07shBlfCb0mXqQiSHJQgHjFg+S7x3ycUII+C3ex0xA4CJoAvJL60JXN0Ja0sDzHi6cwYMsK86VBf92PQdw2PQndb+fJWXkg6Lj/rYLWMwAAICCVIyxcN9RBqmMovx2rpQfqBWa/HSyg2ttWiWb3hoJGJeiKVYFpVLxoE85iLN1X+J+s52MOLkvea6g88+GVJQpQtt8+Ys8gzY7vAXuY7T9mkU+LlZvrhZCYtoZy5UA+MQXkpaBf34dAtJ7EVNOlFHmUUSckV1Tkq+D1ZI0Xc2OTLZWSfz7SSaY+ApwpuNtdmbCZN0CfutpIn2fWXLfX2ScM/BjpAEDwgwAAOjosP7gO5lwcBObjCCTmHInA1Mi5QBP99kKn4mPbELmuHNJYSzzqW13CQkh4le0YXBkLcooE7Bz0QhZF9p2IhGTTG3KuWz8c1h7MNww6SjbrKrPkcVC0u0M51BHWnN+jx2zVIgWOdL8LNIL1W+FmogZXZwsXHGsr0e2VTa3K1TGmtS2LKry8dYtLueJaeh+4/qLXAweSyEp5DusrH6zDe+mWhAF5or792Ljjmw5b7tnYcHSgKqAMAMAaD1zDj6XiIhu++U/B0lv9szFqQtJzjWJQxxwRqO940Z7L9WhKLf6VuYgyDptmTjjS0mDFdtJVJmMpQFr4VgylpRRp9oYEOJ3FkKpF021lpGt9oYuq0t6nqKMDl0cpiJCnIsow4s4svOCTNCFvtbGYtBJKDJZitig6A8ycdeI+rFoiMIGVZBdgyqmjChWybY2Tw6lvvWPSrAqErjcyaUzEGPp/eaNaC1ds/gOBh8IMwCAVpGIMKrfQokzOfgBG2dFQ0R9Sxnehz+KiMWx1Jy7MsQVnwEYUGAwGY7CFjKOaReaRCoCvlZqVVWFyFEWonWJptxWz1gNExR1cFP5/XAWdy37SlW6OqEktPhXaOcmIrmAoVh4yKShQ7YzVJJP5h6pCioXhoz5qdJRlcMURFzmtpm81wWBxjWmS3KuyzG862WTLElllGWFU0fgf2fqEm3qdk8HQYEwAwBoPKIYwzSDtyRgr2wF1Vm0iSNiHUYR9bZj1caYEUyrZWV0jEURZDBS9kChpPThD++AR4wTbZ26bJFrOZmybb9GcUZXDtUxIYP6tkWISQi1vX0NcXScJ6Ea4ULb/qqKhxMQn9gzCS6uOF7IRBGemLLbZLvumGTTN8nyFwUbl92m+H9HUUagcY1Z5RobLURcrCrEjKre042OLVdXvLG2vZeAEggzAIBG4yLKaOmwNC0WRUQR0e2/OCtziHRr7Dgim1ceiyKKuLgybChKBRpprAbDi1S1EmcSiJpAWQOnJg7GTNdaaZlDDgpVq8fJdw7Poe8k0ikYsOqzoZxOZWvz4FcWL4H/reFI7xN/TT6ijKof9bCWUR1nbF8eVjp19YNO7jYqd6JEGFHFYdMJOi6Csc15tgGC+W3AiaTB/J2LVECcqSI/17QTysqjMZZCZfeVsj6pBf0zCAeEGQBAY5k9c3G4lb04WeHqijJERLMP4YQY1buPfylyL83ctp8xI5YsAQq7UkgHRaEmRg18aZcehLTgsSEpGhjYdH4ZO205DXD5SU0AFycXZAKNUrRRrYJrRKQmCn0DRSDTfmPb57Bq25aCjMkdr/BE0dN1qugk2yR8uvS3+ZMVFi8ySxWVdZuqnynS/7jmZZtswTaAALz21FZHRRY8bMd5DV9sA9UBYQYA0CgyFjLOW+LmX3y6wJBG+B2ZksWzKKIo7v+eIfk+jjPnGJFMYLQrRGPEp3iQB6ti3ACb410mqKZ8rXG0QMmcGuj+KdOxFYwk4szAtC2XFdYqRdwA/ZPPMyJivbOUuMueBYVFGocd6sQ8QlgpqN4xYiwT6/Rl1muiOCMpQ5KnFp0Fn+kc8TxdmVSxd5LdpgK6gAWLGeNowVhEDJI9i7pg12Vb6djuoOaNSz+WGw9anqs7roELb6BcIMwAACpjzoGLuv+wfGGJgoqPGxOfhvJ807uP9eLMaH7vZ5hY5lgXUZ1tZBiAF3xpBx888QKT5yqT7wCrzRPtEOJM0IGpavKjW+lOTq3gPuQmMo4r33W3Fe29CmFJNwA7h/gKD173VhRlFJN4k8uiSuQoVDZVHtxk3JiHR5uy2c1KazUTMO6UdWwp3XEGYTa9FlEAEgMGO1yX+JyrXOwK90eOdR3CLUpMsy5KdW8q2hcX7YNb3ocDPyDMAABK58gDuoJMREVdPyxEljLg4sSIYlFmQFelq0cgUYb/d5BJfzIpxKDCGnHwrqtr2b1ytSzg81W6BCX/NuzcYiRwMMRMeU2BPMvaGrtkkr7NKrpVqOC+tqhEH/H7gve7NHFWUS6pKJN8DvSuCb6qr9ilzEXAz1msCGmqBAwWSc417Xok4L2zVMH3rOweaIMje95/mWWJ6l1r0zZCxlkpYmVF1C1HXQJNGWJMk8Qma1oWJwzYAWEGAFAaRx6wqPuiUxmqpCt+bi8VX1EmYqx7LlOXKUNvVyZzwvlBXO5F7zlxsh0o2A4sXAc1VQfca9XAyBZh0qqLGeFyv4vWlfbeOlqgSNOqwnJDt8VtQ7GzjmJu9ScLhCsbuPsO5ityn/SaIBUMmKkUZYjkAkUBsdH3uXWxElPlobOsyQgfNvkL56bH2Dx3mnpO/y11Sxby8BBojO/jDstbJsnKJLHAsRHIbUR33XGm++qaJ5+G7/vE1r0pFLL3TenjhrLeZR4ByLXngdYDYQYAEJwj9/9C38pEfKHFkVpYKTD4txV3MuKMzfmGF2dmkNC0yaAwgYgYdQeXyapmQLer0BQJTOmNatIaKvgfuQtdKtEjyOQul6jfwDOXbh1bhtbsXhWMDuvHsCJyF2dUiP2Yr2m+70TCgkKBe2XHScqkzUNh8ZETZVzTVaXlgW1MFunv3PMdEfd+JkoFCf5cWxEhCLJ4NDpxhj/ONgvLxRirtsyVt+7+xWRJU0b8lZDWO775E/lbi6rSqw2X/hOizEADYQYAUB7JCyQ3OZW8hJIXk0Gc8bWykeUvFYi4lWX+9zQ/xc4d2oFKiBepz4qN7Phc3B59El4DloKrS6ZBZkKQwZTNvSkS64OjrIGs7Yqo/GRzG+kmoM8kU4aQggzXllTuFtblags+7kk2z1yI+1I0DZ1oZ7qvISckycRatILQTbZNoozBjUcVb8TWyjF3nI9bj6qMEoEmSLpF0nBNz6UMqmdMXHBRpde0RRgDJuGirXHdRNeqYLG7qhI/XPtTbKc98ECYAQAEY86Bi9LBTKGXtmLQFCyujIVlDr+tdvcLku7S1P3QDQ5cKqFevlwQQ9nqa7DBlqc4YyNeBC2j7rfA22PqYgzwhDLTLuyqZBnwstQBungPTDFwHNDeC1+XHxdrIds2ZjpO1o4tLGRqiaug6HuDi5YmAYX/v0CuPjT9RAhLGVNQb9n5uZgrsufARmAVLQNdrd18nkcP90Pr9uHaJxji77hY59RlRaKzLq3TqqVKtH2Yq8hStUVKHRamoLFAmAEABIMNxd3wLaGC4AqD+CDpZmJ9dN2anNNNhBjGiEYTEYlb7S0qTIlYTOBszJm7/1CsCPfqIDVxD0EJftmVTiJLGDBZxQjQxDKwwWowXlGw6hCT/8yEWrSqCBicVUkZA2femlDmNtfDqn+SlcsgPvtO2IKIuBZ9mfI8b1fXJHFWXptRpKkKNisLwK463gZpbBQZqjho/IKI0C6V75ci/YhPrBjTsR7ijsmSxMdtzCcQexk0waqldiqKj1WYAdhNDxQHwgwAY5TZhyzOfXf7L87yS+vQL/YGu93PjCSTibJ2D9FMamzIlFMi2hARZeLR8AN7xijqdLpCTCci4mNDqMroWk7VBE6CzQCzdOuGgvfXFEPBtLpc2UBUZZHgsT14hipEGT592Yq3mK9iIhs60LQWXpQRy6SZaOsCodY9acmJLjILwajXn9rs0GSJUSxzsRbS9EvOll82grZHnJs0thYJ/3dxe6lp0mTVRoUtvbW7F0muWSnQKMoiDUTsg4NLYuZ4kYIim+l58LU8KauPqTzw7SAwCIKHpxvTWLGaGhRU0wgAwBhk9sy8WKM9/tAvdkUZG3gzaRGduKJ68ci2ZA5q2aAxtxf84FkUEQ1FWmuZzMvRttwVrfKwiMqx9CkJfqtO/jsnQtetlyhIfcFBtAYR21/y/OieIxW2K9IFA2km90W8P3W3Ka/gyb59icNW8akoY7inyXHeA2xJeazviaJcPqKcaWcf6zLJ+k+TKMNbNxLl27qp7RvECh9UljQ2WFvF6T4LYqerW1ah59rHyibpF8W/QARrn4HKYvsMYeKtwPcdr7JALBtXd1UwkMBiBoAxgsxCRnrczMV0+91yy5nZMxdnA+fGkWbXGAcXIfGlo3sJBRZfXNyYWERpLBkWEUXpzlOkdhHizs2gMRtPvxcpuGpbOPhfhYHnXFcpS9+tycbiSzwuQN24XJdpJxb5SYqVdfEYzzIpk/RZ9eXL6hgk1Gv1WrTOqMJqQmhnUU900D4LKguXEsSE3Pl1rUQ7B0Ln/u04oTeJjDZWfjJkcWNcy6NLVxm8VrQW4p4pm+dEVh/O4kBBQSXntpWxPCtvzdn1veTa78gWHGyDuwdxF+WoW1BvFHW7GRWwRsZ9bBcQZgAYcGbPXNx1MXLwBU/PIeG8qGtWn/ybyLTKZBkfocbVAGkZxfL0rjuKiVhOQCGjKGMFH8eiiasjvmUqMKDRDfq967rIdYgUcVFLUIgNUiFPEevESpBRbAOcmbwVdKOSUXRQmLFSK7priw9liTOy55wXYEb7S+ZOu70VLZ8xKLri+IwbqH/24vm+YkVuAp3M1TnLQCdx0DcujSwuUu/fPjsz5dIW0uPT0caF4f9vOS4obJkRcOemtCwjHYpGRyka7bkeD8fEogD56IrgK0YFzN8mro1tfC/+vIGyvgm0m2Lm+7LEGZt0B8EdCxiBMAPAADDn4HOJiCgaZf2BYBQRiyOioVhiwtz7v+qFzYsy/P+5ODLagU/E5WHC1jomEwS4VxzVJMEhP6MoQ5S9Fp+Xsy5mg2zil2TrE5i4iVgKCiZro1p2kVGhcz9ztZqxFfZ0O80QycUYLn3bcugoGijTBW1aVW5XW6U4w+Fdl77Bin0t4gKKMjzBLAA4C5k0zTgiZrJEEtPpBX23KZf0WXB9Hl3gBAtRnCEq/izZWOloj1HE9nESBMQ0GOuKMutGiUZGuxasNK7vVmxKzvM2uLbxItYsVsHiFcfaWtqI5wyUOOOKaQxZhjhTouAypu9lS4EwA0DLmXPwuekEXjTvjZgkZCTL/zsT6FaHasWd/81FSHAJ3KuYlBYbvKtFmYixvnWQUI6MCXWHiIYDbQ8ulKEolQsZjkE5XcsV5DrKtEiSuTtpJsmF3ZQyibH8vzvUtRRQTIaqoHCgSg8rnkomF45tXYliS/Ug98hVoBGfjRJiHtj2ST59g7VlXZx9FqzbirCbkZiPbGIckZ1IYBOANpe3Ini3rP3ILCm88LF6sbTeS7AqX6fT7d86RDTaoWi0QyyOusH4R8NbzdiUqUgdJ/fMpj06W3s50oiFj7owjQ9aYLUCMabdQJgBoKXMOXBR9x8xZ1URR3JLFX4gJFiz9ANLGsQZj9W+wtYerqsTsmMLBIBLZS3RWoef+Ir5FNjFJEF5HxzqItjL2cOiSXmMA43ceaKoi4hN29DlZZoUZXYYMxepkgGcUGaXCUihbF1W4m0QBuzy4OCSQb1Hm+GtOqTlUJRJiUs/anOcop3aiC42opOrW48YjNZ4zyViWIqqH/ec5KuuRWXpprPIkbqcyMQZQzo26fsQ6pm2tb6JuDEJSyyDk/qwGK94BShXpKsSwlziDtm88/i2XnThpVEWqDLKch0yjdUCx4kDwAUIMwC0kMR1KSEzSRgiok5/kJUKLj4iiewcbqKlNNV2xTagaoj0eCQWDon1UUaAYdxAKBNk0LI8mvggoXESNGzqVhVHxeSSVYBSBYNQ1jI2lgVi+zLVt25nGSLz5FB8zvm4Gj3KHIQr+wNLqxdlPAyHVfpSJxliG+fzYv2+I0OAwT3fv0cx2QWiFgnV/yjytH1mQ98f3eQ1wWkCXpJblkjO2tRydyRxMp3GiBID4JJCnNEIh1b3RiKyOhMijUR4joloeIiIdTs75rlTE1+vMsEiF4/LEpnI5Gp9YzommIVd0yhTlOH/bXp/l0zo+xfMOg7UAoQZAFrG7EMWd82VZaJARF33myFxFU2dntI6w8c1ySI/LzSTG/+BXT49ncWQctIobjGtKqt3ANyS4szYigUitsKCJF2bCVJpA4kQgowuKCBR/3plolVynC7Is8N9yA2+dKJMiImQK6IoI3m2+ElLiHgyLkEuvcmJM4lwROH7vV57iGKhb6orOLhFey2rbfH3rgoXSNs4HkWQugJnDlCZW/TdlXKCge5dUUKwaFHEkFq7OC4MKfsCXqSNGbFO1I0rM0SUqqRx3BdnCgg0yb9l8Xr441wElDLxsX4ZSDGnpdi+m1zfYWM+ZlALgTADQMtgMTcCYoyICW5Icfd7Rv0JfWaLaw05dybVYEo22eKsS/g8iUhudeFjkp9kFWhAoXvJpfEBiPIr9snnRJSJo7TeIsnKZ9A4OA40ZeBls4OE6jhderVdn8pigWvXUhGKb+eqSRKfvgZxoqpczZW63BiTz2GalGgnU4Z0ywySWkob6bCuWEIWE05b1yCd+XwvvyAUmYgn7TegICP2AyY3pbKxjlMTCGUfKLonJfGi0gP7J6aWE7wJl+2zY9kWfPtqm/I4TTZFcYavFIkYXVb/4rKwII09FHCy3JT3fKNp4k6XFYH20S4gzADQEmYf+sV8B9sTZdKJQs7v2V6IycSaSZZ/09U8kq962YgGvoEnfdIg0sdl6AkoqauSAhb1t8ZOj+twQTs6RBQng8OeKCOsmPNuT8mAuYoXpFUeXD2Uvf2jdFDMucLpfPGDWkAUCbBctZ+5MPnNudHprE8MlilKDGnLMFq5iP2DzURIFsS4yh2YbFHEoEp+s7au0gh1mfYdMkB4EbcmS9FQRuHJveLckEJ93WifVVGckZ3LiTO5enEJ7qzA1E/71iEv9hr7K16cGRK+l5Qpk54kWHLTaNJEuoznzIsifVbRYL6+u9U5ohrPNOYegEqAMANAm0i2iOx0/1L4F4dMLEl+zggHnBATZV96UUxEo6xvLj0Uq8UZH2r26eWJWFeAEV++iThDo6xbF4kwEyVCjGEnpsTnnxNxjFutxn2RzGqXrEBU4t6imGRX4TKQI8AExYRyclHirlCm2BrS8hh2TCl0HxRtWNneVO5PlhOoIu24UDuUxZBKvitwr9O8K4pPZUUBi5tQ/YwsZkcxq0T1b3VMhFKBxRAvKkPvvjiV16Nd6YLO2ojrrrGIbC3xnC1uJGmoyuBCG11HardAdcGl/wkhqNRsadO2tgSKA2EGgBYwe+Zioogo6lA6qAg5cc+534x0+tYeqcmwW36pRUbdke2L5t3pUDQ6StFor96HIoriOK0P7X3o9ESWjrCyJ0MYAORcmELVoSZ4p+vAzHpA5yDm+ZSh0ICySL0agjo7l8tUFo/Ak84Yrew80tSkk7cCrH5F2yXYqhJVkOyiuKTjIvqV2CfbTk5d2mdI8SR02UpHDIAd+plQvKNVbV/r/mt4XoyCiyZNXXpOVGwl05bgvNLA0kUIufjhs6BR4aYLRdC1cfE3n7Z02z0L/QsHKgfCDAANZ86Bi7oSQBwREeu7zaSxZvhem19hpr6FTG6FUTfS6VqIEBHRUEQscdWxmVyLi+824kzoF6fLC1wx8UutiUZZ+kfrRnpWL0PJBhBCWgXKnCRRVqBfq7xLPMcneGvSZiSDO3HgqIpLocV35UwV2NeFgoF/g+JoBaeM2aBZwXYe4PM7rigLkl/1DjH5UU1KnAbEIVyNTP1lEYqKkRaoJhtFBGDZuy60KJOzUkqoe2InBLP1buseE1yXexb6uORYUx/vK36o+qkyhZSmWWh1M+73p6UISXUt0JWRZ4nX0RYRD5QHhBkAGsycAxf1O2rFDh1MMsgSzaC1sUTE8zm/bRZHfTcmE6Z3VeDdirR4uovkAhYz7o9IOoGVxenpfojSnSMoptT1SffirVKU4fNqwkAgJ8rw/ycyWqRYryoVNYUWBJogg3mPZ6DIhDQ30XGIK2N7vg3qe6Q7KfwzInsua38mfISBhpjdJ3Xn+nxqRRPJfS98jwRxTynK8N8VcYXwfdfZCDK+O+tp+kNTbKkqnxGZNY6LeGpT1qqvJ8F1Ml5q/Ye0UhTHYUXFmbqEnYqtbmTvIrg0jR0gzADQUOYcfG43SKvwPZMN0pLYM9IVyq4oIwseygs+mTT5HZ7SH5IEJYXVrgCVYAXiEiTYMFnJDG4sXEkYF2Mm/Vq1A1Uicpni0dRAWdY5QQaNBYQKq0FuoIGWt1WFx2StaPsRxQeduXrZbdXL0kq3Q5ywHbhTHq5lssFGGPYVUXxN+ovk6YitWGkz2Qg5IcmkxSTvPRtsJpeh6jmwNZiUgltllx3Thqdp71BbTK5gReJi+ZwrfaZEdznQp2RBxqWPa+szAOyBMANAQ0ldltIvev/nhZP0N054UXXykt1OpDs4xPx3ySxOV1Du35HkuzKwmWgoJjA5q5YkHd4CQhaEdCjuWcFQf0VfsqotsyQIshIfwhS4pImZlyuRJI2QrihWqOrUsp5kK1lGa50akZVLJtCUaU6tdHGy3YFJ9vzK0qsb112UyopRY8onILrnQeZ6oksnd4xjIGgj2thgGvHLV5Rx3M3KJl5LKTiKJ859Rd0uYRVQ1f3S5uMjglnEF/MS4hLGwL0vi1y9tyB2DvADwgwADWT2zMXdf2QmSz2XGdb/IWKUHbAyjTuMKpZEb7ehKI4lg2dxVbGXv+zl3EQlXzM5kglREaP+ttjc7thsKCKKhnoxd+KsBYzo0iJMHK0HMr3JgCyYcHofAvlpl77jEzdoUJrhqtwIykZnmuwROFU1GU1+aysmdxNTDBmddY7OcqGfgKW1jOx4GZJ7XlVMCSOuz7Tvzl4VDOK9hD6XbdGF/iKUdU6ujBZ1LH3OA+661ob+oypRRnaf21A/Pph2iLO6bpu65kRObR8t5G9FzYsQbQKuSoAHwgwADUR0jUkGjVFMOWuRvFmsxEWl5xIVjVJ+EJzsHBT1XtI2A0tenBEPbeoLRrSyye2CRJRsb52zqomirjgT9z/zafatlVhve2xSTzIGfBWpuzqebYO5gYetC1VZq0KB01MNrNoUyK/I4FDnFqXNg7dM458X2bMjFZWp+6wFEPlKu1emvtTXYqvEbddDIN5rZduQxu3Sp1sWLuKM07PSpj7eoqx19Gl1T16bEBg4RB+lig1mHRRbR4P7IwDaAoQZAJoMFxum+3/ut1GWFWtSoUZudUFERBHLuC91v2KpqBD13r6Mc8lhEcktOWSWM5mXvvDZBolFiJP1gY1FiW5HHJmFUOK2xAkyOWsBTpSx3h5bUWY+mLDN8TKUA7gaJnPSHXzEr2RFKnHnEOU5MmsaXSBQ7jwrcUZW/3VvJ8+hmkz7Ci/ae2Jr7eISB0nn5tKQOiYi6+cwFTg5AdjLOqNBbUyLwU3J9HzbTtydJvm+u64VpBJRV9Z2mtBOFDG4qhaEVG2kTYJ7o2hLP1QDzsJjw4V54I9u7wMAQE3c9st/lr/AepMUFvXcaxLBpPfC627t3PPB4fvsqPcXRzl/f8a556SHc2KDfqcMxb9ln22xfdmojouj7J8nqSiTCDJRvu66B3KWMr3PEXefcjgOTOraPrsWPO5bxAwDGkl6/DnScz13Xknah9hOlHnw4k9DBlmqeCCVuv2YdkNLY0PJT/ddWS9lRV63vbqmnYnirLJsDZ3oaC1kLHa7KwveHSRkENYQFH6uXPuRJrYdmXBdAzYLCqXnGSA98c8HiFDV4FzPTXx+QWEgzADQUG67ZyER9QaQcdT/4wSZJEBwP0gvo6jTEwZE0YRRX8ThBZo4JhqOM8JDJs8kfe9Ba7GXR+WDVR5BlBHTywx0bHpTZ9HBr+5qHUj51rVq9VYz+KjEtN1la21VHKMxjPIe2QT55SfvHeF37tkMtZNIafcraceWoowMqSjcAEQLKeUEUBRixPsrOyWS/9sKQ9re6VLYfkcmenrda3FbYmCF1b30EBBloojqrwxCt9FgoG1q4a1Tg9Q76rt1wJUJgCbTE0eISG2BwvrHpv/usK6LE2VXXjMT/WSVX5akNMaDIX8bPE1ZlRHpXbDJO4qI4p4rUs9aRhYkuF8wwVpGTMu3rEnyrltacy5nvAtEVaQing4+CLVpZxRdMmVYRZh2VPFwGzFaTY3lVS9VQHJdm0/aDB/0fNDg+u9Q6ZWFKJ5oA32L/06Q9AOFA7w6iHUueZQ14S3sHiO6NtjGMpOdp3KTCLkroG15Smy7Re6l8/3SvPMaK6K4UmCHQyBH5cpv5eKPum8lEGYAaDAsMwnJWsHIJuxsiJsU9gY4spgl2p1/Ml9Smqd0hyYJjXa9Mb2okmsS48MIMXYifgWNCxbM+EDBNvkFJrWIUm2bHkuuoQDSQWCSBTdwyB3H1WUIdy9lOpK0rHy5VUGHi/h1t2yQFDLYpjYdlTjDwwufskDBhvNtJlGNs0ZxiR9jSqdCtAGeZZiCPmvwaZ9lxAexjX2jc28MUiYXAVmHzk24SHvi27QusHsFbTaEKKY6T+sG5bKTnJiM4nCjGOqRVzDENjmWFyIC0rj3FQgGhBkAmkxEqdVGlKgk6SBPIYzwOzdpxBklvdXanBAhbD2dESM4jFYeutWwOl7aneQ6ep9Ti5PE1UsTTJmSuun0XZ6GIiLJ1uOm/NN/x45WMkJZmMHnLHMtgbYvTeGttgzYCillwE8etRZRoYIVtkyUSZCJMzYCh/OEWSeudIR/yyxJcn1QvkwykrKWNch1ClzOk7Q7m7bXsIlOeu91VjKy/rTCiWORe+7TvpNzarVm0FFlINFQ4lEBbO5DJuC59v1vk6GF+GxbFsnn/oGaPFy2pJcQxKILWJH2MQXvGeq8nSDGDAAN5vZfnJX+m/VEmsw21T3hIP03cVYTQswLfrIvTvxzQoAYp0YjoERcsNvg1DV4E2L5iGQtmbj/x+QmysjQvUxNk7Xk95rfx6mQ13BBorRVJ35VuOF14IJqdTjI6r/4nHUotUbL9S+a+CGueZctyjjT0vZiLTyIsYECxgjKIbQT7/gtYrIB0hDTyxEggH1wQk70bIXHHmXHZVGlHew+W7TxNC9J/CXZbnlV02hxsUzqfBZ5d3obhDImsSpBe4DFDABNJ9kZKRObo/cbLwzwExjBukWGUkxJd5iJ9MfZpqeDs0iQ7voi275Yhu8qnMYnui++cL8l1c9Yah3ChuP+fUlEmTJe4JaD2HRXLt0xBYU06UqdauAZR5nt15Uork+1UldkwGy9+qcysw/hYtIyKjGdFlaWI25yElHvmVRZzVAzzbubWKYMIbew5Vd4VbGkAokwxv4k53rLfbCNv+KZv7elVJmI99nlvjdw5b1sSzdV7KSQLp7i86Hbnjs93uX5qct9CYRBtN62oYHPKnADFjMANJzUakbscFWWHL1JsOwln3NjEf96xxhFGZtJp+OKmBHZqkUZeVASK4ZI5hUUCSuw3YDBcbmiDFe2ois3pVg3Je0qsbSS3BPVVtJWyQdcqculo6pPTjCsfJWwQaJO8F0inAvQ75e0hzWnyoiogFWFZ59W9i4v3nhaxjTuOixR7VIVylrHC7FNyd4lZbyr+X83yPoncw8U1nc6Cx3b+2g8ThV/Sbr5QvYYrRtTmVZoIAimvloV7BcMPrCYAaBNMOqLBdzqSSIQdAeAcX8gJlp/kCEGjLgbiMqaxSX6voc1Cx/fRUmo2B9C+axi8XDnBH9f6q656MDW1gLJk4gR0ShLBxXOu0px6chWJhuxEl3m5ML23te4KqZbTeaPCUYc99wz+Qz4/ixgXiXgvLLv8XwWru9QVjNi31nn5FDXRpJ+sMA1i+3e9x5oY23JAuXavBNtjqsypowhL5t+XdXPBHv+PeJ5OFnPyNwxk//rYi7ZvD8LBBS2wtVSZ9Co6X1r08c0/f0H3IEwA0BbiKgrzDD+M8sPQPltmh3eJ2mnPyrr/fvfRcSJQTy2g0bxmLoDrPpuvd3DGBi4LEK6IASGHzCzKCJb+cp2omMzILcWcQzCodYFwjINL0wija1rm009GEQf3QQkuCiT9l9cIGvRNab33UANSsvqF2X5VBCAVbcDUZXYBhn3meTngrAqJveyYNTWO8OZvlMhCju6tsQHm9bla7uNtmo3O0kZiortvjFh0ntQMDBvJi0XXPJViUZV7YAp5FumGxkAYx0IMwC0ASZM8nsDndTlJiF52acvUqYWZ2TxXVQv+t620N3zuulHXMaZmDABsJ5M14w0Dg2RkyBWKTYWGQHqNjspcxdl5IkKFmKWyAaR0vPFSYcsJoMMcVctEZfdnmzyk/1uuGfOFhsKcYbIXqDRF8iwOq2yvAgwiapa0LSqe9W9tiyr0/0t6dpdrR2KpBc6jeDCkYWFgTLgry11vAOLtFPF7y73OdOOZP1AajXsmZ7DPRMFJZnrSaZdyfoucfMAFfy5uv4vkFWLqa8fc5RgZezVRsGYAMIMAC0gHskHdGXJttaMs2LhFQHFC1w5UU58rTv9Y0QXgogxYp2oK86kX7oNhoKYUfsELnTNkxHJAv/mcF5lNbj3NHA3I9XAwGSFEUyUIarXlNpmlViFbhXaFNA6QDvwmuBW5TbVmwxJJwKWcRbS67PtE0JfTwihJ+Qzb1uegvmJ7q1FLR/qXIEvGki8mwjrT+59XO3qFmVs48YVFBGdymGy3gvtwmMQZ1QuttbYllEWRFslSgd8L6oWMGTilVgXdT6/lVnwlOgG7gOslgYTCDMANJgj9z2nO7mNIqKhKP8S7rDebiVEJA4Y+DGLLohvZsWf+juhMEZRFBGLe8pMTF1RpndcKs6wvgVNkdXh5CWfmWjljvGLWaJFEG4ixrKWSDb1mCkk90/FoMl1xyspoQcHml2RVNRh0uyy0iRiLK/JakaBSxA/m3QqH3DpxEuhDopMvG1cPqR1yT8nusmY68A5lKgSGp80fScN3PGy9id7ZnTua/yETYxFJDtXzK8otU5WQsc+Culy5puGyk3J5PLkg08ZNbu0SXd6dEDWZm1FGSsBx2SlU5GrknXdSFyaxH/X9fxVmn+R94btM8IdJ2tLEGUGFwgzADSUI/c7JxVJIuq9o2Uv8cRyhsSXpsfqcU98iYh6K9mCGBSzvktTp39OKs7YTNQ9VoelAodtGrqXqHRFjp9N9P+Z24o8yV+0rImy5+lgUdQNtqzyyW8wyWBBtoqYBoi2vAbbVciig5EyBjNWA3XL+Eq1D7Ya0O4qN91uSqymImXwmRBbHuvTJpP7p3IjdL2/YjpNmaSoLLy8yqMLzO77XKpcI21dLk0WfarzFNfhNHm2FlftDnOduJsCnNukpY2zZAr+K0PnyulpORP62ak7/kwp+efGyZHfe8Nj0SfB1G/WLYyBcECYAaBhzDlwEUWdngCiMI/O0ZHvpiQGqVWJNSzquUNF3d6fUZTPNzk3yafDuTYR9WbpUaFVKtXxiRVLMGsZzQsxzUM8pMOy18aVKyfOZBKk7EkNw3cgE3ryrFqVDxbk1wfbXU40aOtX1Q6bJsoZAnc6k0wwes+aaG2Xm9CodihhrO/Gyfd5tkJFkYmjcE6mWFXfvgCCmsu91E4SBGsokzhjU1em+DUZahbaCt17zzgtQdJ2IPMetBV5yFA3ru1XEYdK1Y8Q9RcSTOnJyilr86WLEDLrwBJdl+xOyj7fMuoWZyrDVRB3sch1eF4Rg2awgDADQIOYc+Ai6feJ5YryZacLTMq56EjP670AUrNdXklQbePIrfYkrlZp8rbbTTsOxLxFGVuTUdtzEsGqw4gNWS7XJSRZ+b5IQw2uxaDPBSlrYFA0yG8hbFaLJThZBMgGZr67hIWO7+AIb/ZvHTwycYnU9BkZkUYT0CnNl+9bPF3RSptY6OpXZt0gfufZJl3wsShQup9Z3lcXzG2q+bMULzHZJICUEefI4vmRXkvJ9yDXxxbdoc0yqLiszdsKs1Kx2WdMk7HoLVbPzv2cZX7qBTb97+KxrRF3fN+/lueI9WbrXg7Bpp1AmAGgySQWK3Gvs9XsFMO74EQueoFsEqAys82s2vSOGWVEMaOI4l4Z+ysq2rgzshXuMihg6UAkvORsB0JJ9eisaFxfmjVNOKp2LUkGFi4TRJ3rhBKd2wBXliQPl11FZCJFmrZs8sP/7mv90BCXHJULgKkN2QTyTS37cj+w1FovI84UqA/btlTq5CG5BhehyfO6TZMp3TG2ZvY2+ZWZRgjqnOzkJrZlxBlT9U9V9S0u+Thaj2jbuEdaqrZg6juki2DShKLsGExmJaQZk9i8u63FkgIikK/wXZvLok7wFJ+Hoi6GujIYxhy69gfai+NyLwCgElIxRojzovIZ9yQTT0WWXm8likXUF4mSc+Led0lQ4p71TDTK+vFnyiDkqrHCWkYb7I9zwch+L3zW3R7xWId76f3SFfKo5OWdCA2OuJbNecAmmhN75qtDmVZSJ2VYPxTpE2ytORR41Z1qBGKRX+6ei8+ko/++zXeVwbcR2URZFdejZHHO6h6L7wmPtBKXE/6vbppSDqKSy2HhXlno2dDFpKkJnftT0fRMx0mPlS2GeZQhaDuxLJPKJTlIERTPYCP6aiLzIqMw1lDWDS/Ek7qduCxggfYAixkAmkTSEXe6OyJpzSqEYIGplYyo5GtcJZQxZ7gXQxLbhSWCBXcOi7g1H8aIOl1FJopjdbBizXVYbSUtnOMVKNHRfSl9gfJlk6XBJyErgu0gRUy7AZYQImWZy5Y+0FC0DZVlR9H4O8YYMyq3FdPxoVGlrWh7svtuFV9KfL4tJx4yS6rM5EMRr8aWUmIZudwrV1HF1QVTg4ulmepYn4mgLC2lW1R6QH+yUjbasijarU1dhih7LcE+BddnUxmc3ZwCv+dCxTEKlY7NuWmbcxVkBOtmYwwoHlVevfttbeEjJstnJTzDRdqvKW5VIXQWrUXTIpI+P9JjHN4HZYphoHogzADQMNKdehhRZhckkrtGpGIJ14kzoVPXumQI1gOMBEsarkypOJMeT91dnDqdrsXMaM+aJGJENEQs7qcbwge+bFNu20mB1aCJkd5qhsfBIiH0QNzGhaENeNdL3aJX0cm4b1qe59s+I9ogm8kkgrc+EwKHq/JW3mdhUiIOfFu5stiAINCqoKfJb7rz+GNtyAngYhvpfSfLt4x7LRP+itKKNmnpphGs/FW8xwOkIfY/NuKULcn5pccHUbg/SftWU6w9Pk0dkqDtyXmusWRs+pzSsREXLfpubXl1MaVsFhFBa4EwA0BDYRF1rWZi1hc9enFbsgcyolHWFUeIiMVxut11ko5u8s3vZiLdljp3kjCxSr4eZV2LmdFO38WJxU4rP04BfosEW5NYpBhfaIZdG/iyK+sxImurGdF6SLrC4iJ4CRYRIScvRM0dEEjjvEgoa1BXyM3KhdACk29sCZftX/lziLzM9lVxZ3zEBJu8nHC1cKpJiHGx8NC6eQYpDJO+X7oZZgsqFXJMaKwRlW1EIg6psLG88KXqeF+1i9YOyMTYImnJKMvl0RSnTH2i+WKldSJ5tmwtBqX56vp8XRm52GBiGWoR1styBU5wCPartbJN8pP0XaD9QJgBoIF0XYS4lx0fjDchs0LcHzhGnQ4xiruCThz3O3nJgDTt/JXuHVmxIbWa4SdCcTeDnFuTkJeS0JMRy/RS4UMiyqgGeHmTUfl1abfRTj6rqiQRyCIiRnlxJoOFm0lRVxwZoVwZdHlXuZrsumpnoqkr4d7uOKYBpTjQN4kzUZS6PVqfk5wquVcu4qDvvS5kkVWFa5rjJDrkcyYzpbe5F8r7pgt2yh8vWFwZ25Cmrq0FJ038HFdRRtkWA7qy+vTloSg7bZX4WoTQMUyKvltCLHxo07Dsc/uJqceiyng5KnHGkHfh9uOya5ltP+y5EBYEPu8WiabADQgzADSVOMqLILLVxMR9KJnnxN0gvIyEgarotyp5aUiFBjEGDO/S1CsHiyKKhiJiNNQtbaf/8o64t2tp7iaqgSxnBSReW0aU4Qb3vEmxdCBTxap2RP177DnhEj9L3dgU+IosRcWZMlZ9yo4LYMTV8sRnQOfpi25dDklsiZwVhSgimxAH7J5BLnkqtyiwRYwfVPOgOqSAVUSkVU0UlW1LyDNnKeUqyvTug9RdSSEK6dDVWaG2KTx/hQj8zDUdW7e30IIMn6aPOGMUTi37WT5vXQyb0NYpRnGzKbi8ay0CY4fo313qX2vJ1KR6BtZgVyYAmkSnt7NRT+xgQzGxoagbM4ZfqRNXLVj/vFSg6VAq5KSdt0lxlwXSlRFzg+dkB6k4JhqOiQ0NZV9UvDWP5UqqrAxO59lswZ2IMr34OHwZnfOToHXLskk7uZ+BCD1hVd3LplqLBMV3O2sJ0noUn9O6JvKKgMQqi5XslzYzc6FfU5C4Y4ZcPa4N2z62SJoGxHgWprbp0yf6WiWJ1p26tsYiyr8beZL3gKsoI37m26nLZEfI17pOynrek/ec5H1XCYZ+07UsOhFM58It5mmdbwNiPhGRvG/VtEv+ObapG5kFcWa8p3gOxP5CWtYqxQLVu1PXL+jSkqGzbnOxcJGVyWDhp61n0FpgMQNA00hWqntWE4x1/5kLvEvUe8n1xBh+R6ROh6Io6rs0EWV2K0lXY1TijKj693Z9sopBk8SWIeqWK2Z2ZuYyQlsZiNYLycusQ12ZWvB5tnrZmYK9ebwvowIDc93KrE+gPZObl5VLhMUqUhnCEVEDJuIaxHq0cmuomrJ2ghJFZse+QdYudTSyHVR4b8X2ZVNfJvcepzqV9f+qe+8pNFkhi8ugcs/weGeZ+li+XrXlDi3OuLh8WeBsBSKxvtPVg00dufYBsnOyCRjqJZBLmW29KWOu6NyDLMphtAq2TszUiTRELHAIyFta3j7HO+yIWIYFKqgHCDMANIQ5By6SD3YYZeOgJBYxQ9wxMfXFECKKRrvxYyLqxZvhjlUNtjPm46PZnr8v6OS/T83JY9bdoYmI2FDUEzi636XijAzHiZ/vBEsMpqv1t5as8hiFh1CUbB2hGoipVqZt61s5kJYMyHXlCE3o+DFEZBwwSfOTnJMOjItMlGqwpili9m5yUzHlJ01jrCBOMBx30VK2T5c25NBWM+3bM01VbBZZXhlsrGSSvMuigkDj1u2fn7gVfOZkn1NUbdOijakEGlkMI5tzZWnlT5RPZkPFXvLtn4z56+6hIXh2EdcqV2sd03GNFMxFXKxlfFyZdONHiZCpBGLMQABhBoCGEbGeJUvPGiZiXBwUxvIOiDERi4eIDVG6bTV1JAmTvmNPXtbSgbRpRTMZBPS2z6ahoXSXqBTdoFAlzgTw17VyB4opFV8ydSQGtVOVsUjeHtfHT7AKT0wTk3YyiE8haEB8DZ7QfvVSbK7XYkClipWkxXdnJVkaCnjz+FRoKSI0OVrQyCaMqsl84yYBZVkjhUaxC4upTp1EA8vjVfFgVGURnxulUNSU1f0epfRNBSZuVs+PxiWOx1r0r/LdxGcbMK+clbJH2uK5XmIcUaZftnl2c30pb1lm05YGXSjg++/kHVtElOEEmMy9adi4CZQLhBkAGkp3pyXqb0Od/iAuH/U+D1E3zkuHKIo65sEnn47ob6568UpiTrDe91Ecd88b6p7PKA4TI6X3Ugo2WJIE/OX/n5lgkkGUCYTLoM3kXuCEMGjjg2mGrO8kCHMktjNVsQJXtc2qq3QwRJQbEKkGtL4Db+XxwqRdGZhbRqi2KqYjGSBKy+8zIFdM/kNiM7msXMBxMbP3uK9F4vIohV8XiwuV0FZUvNMJeLp6kp0b0AWgFvHPxx0w5PNlsQU5X8dWQotwn4I9l4brLuv++aZrY+Gc+52/Pk1Qdqc+QebuJ+Y1iJgEkcCB3ceUBSiQguC/ADSE2+5ZmP2iw7qijDaILDcgiyKiOCYairoCTRznxRd+sGP6zBExSgWNNOiY8EJKAzHyxXMwT8+hCDxaKC3VS5Mrp3TwU9Gqdi0vZUlASOMphpU2ucVCvSMOZd32yiUVZWSHW0zsg6Fqr7qAwOIKXIUrbS7Coq87SdkT39qsakq+T3wAT74flwmU/B+LqP9+cQ1+61E288FyUca67Y2yvEWpQxDqqvAJ0qo6P+8enZ1kq1yDlDGJ+EClvIAdqL+xEe697oXKDaekdq3ENfCsJdo6CXWNfDoB0mu0EFEkPkwP4/VJxqaq+9g4i09QCrCYAaBh8GJAbrvszIEsE1yXDSUDJOoG/u10uv9mjGhd1uKGDZHc8kY1cGFC4GHVKmVGTCG5S5XKDF4067dYrecneUzlFiATZRTWRKUPEhSr4/zKtGll0Nd9SWsxwm213v2x+AplRuCycNkIPeiwqidZO2iaa4lYdy4BsQPBC6xRTPKg4Q5oRbJBX4HVUWeQSlLfF13fYbRGU93PoveZmxzqRNVUEO4IwrNj/jYBU5s8cTL1h2pXMOEL3TtWkqa8MMzePUm0XFUdlmhNquamEJ9qIenTPV1NbV3ApO7ZvjjGKFIWjROH06QLjjVaj+7+t8XdFQQDFjMANIhbf72QG2D0tstW9clRlImNkpyTbmWduI50OhStG6Vo7QhFI52uW1SylTaflmxFxecFzJ8TU7aXESbCzgMG1xeUbgVDNsiwnajzq4M+k1RFINhcGU04WBpo00zuk3C/VdYv0qJ4jh1sVoWLBFDUmnzL4O+px72VXou4wuy6XadLW7M5zme7UEv4OhdX7Z0CWnITMjEmhW+bcJm0BUesc107EPsX1V8gVPWZsRgUtrAW+yuVBU4pqEQZInm98MHz+XeS+N6r2nJCwFR3ynqWlNl4HyTXWuq9cy2jgyWLrC0q87EUeirFYKHp1IcSqa1fdZaxNmOJgs+HaIElWvENGqL4ZHON0vtrG/xX4NZfLzQfBBoHLGYAaAOKCPuMGzCzqP//KCZKt2nuENEoF3MmGqIoZsQES5y+mCPPyyk4oun4QCvjVoNyVf4iwqSw0MDNZuW7KcHcVGKc4N9PlB9YqYI6mnzhbVbxQg/UnGOhaO6PczwZ3apX3YH9fFZtLcqsM8fO3VvFfVC6UiSnKdqZTOQ0WaGVjmnls4J2IH2mbHal0ewuVOg59XkPaMSEtMy6elS5YYiioCbQqW0/54MphlWRdInI7T1OkudHFvBUQa59JPWquecqwclkpWRsi1y+jRBlZBbCJWwEYGWd6BrUV5Nfo3GxPgnQFyd11Lp6ArUCYQaABnHkAYvSf0ejfT8gFlHXpYkbVLGI0qCq3ROSH4g7pucIFUdd33qeTu/gxFIiEXhE9ylFVH8jluKM2oS6+2UpsUkkK67SwHmZVeLEAsmiPB6WCM6DfI96Ma5QqvKxmDiL3+fy4s23NcGcyzA5N51fNP2BGHi5TAyCukl1/+8sdjmm3wiaIsYmKAIuV1ZnaR8fKDmdqOHqxmQjAAWksGuHwiIlk06od6lDO07eBelzTvl61V6rqsyS61W61Nlcd50CuWe+soWRiJG8fQfcicxXlDHda692r7pvNtu227rl1b14oqCtbpVAD4QZABoIP5BMrGJEwSRiXQ0mYqwrYjAiVTia7gl9oYOxvr0M60SpaXdibZP29UmeifmraUArCkCaHQGk2OxEU/AlmYhcibCV5iuKXplz5IP0TBomLFcXbX3pux8c376qyYksHcmqscvAyWVgUNakvKq8bO+dEtfBpU16AUn6mFAiqVUsC4vzWy2IlRhPxrpeIq5vTz4XpcgORw4icOWWOqHydsijqslV2dZkJss39Yly4dAG53tUx8Q7UJ45S1btQFCDxGJONvkv0v5l7dqrjZmsD33Q3Q/+HR06NpAqPeF7X+tj0C4gzADQRpLdFEZ6A5WoK2iI7kmZiRTjlBvZdqEd6ooyvKVKIgglqzCCabEsqKvMusdZoDHhO2HtIQoq4sqaLjBhKpq5DOwty8m/ZJ3icQjHK10W+Puu2dkkYz1UQJzJoXGJCI4gdoQcvHgJC1UF8bPJw9HqK7e7WkNWEAdiVTCwQJNr5wVFF6fn3bd/N1hlFrnPWleOzIH5flB6vqI+i1rUqCbANqKJ06p5Ur8NDLRttHAR3NAyMZBUfX0Dr7NyPK1rXRZhXN6vhUVHU1/p8661fZ85plt40cYyD6JqF7hAeUCYAaChJFtPR4yIRjrZlyu/21HMKEotZkQhhrrWMKOkMP3tCybdrbljoiFJYYRBayJOdP9P/R2hiOS7SakEAW6yn6SdvFStVudDTBCT8zX5ZXb2qIgiL3Pt6nKyk1csj/2uHGD5DG5lAppBVJOVPfTAJjOg15QlOPwkvMm7LSjKlbGaqbruBp3QO10VjAnm5VojScc0achNxguIBsoy6tw4+EUDzrVKKWrw/1aU0aW/4uvFxTpBJ8po8y4qUvjsEFcERzdak7hT1qTVaVIcYNwiPp9KbPsBnwDSpuMCPSMZZIHSZdgEwLc9lj8meW87uvNZpW37vW8+oBVAmAGgIcw5cBFlDF6Szr/T6YomKkYTC5CeQEOUWsAQEVEUERvqBvxN6VBWgOn0/xFRrBz0pR1/Yn2RpNMh7RbQ0ngzkgGD9RaaPJYvSenAKbEG6sj29Sb55LmMmDd88orVJ90gybrOetuni5ZV2jwMA7aqBqJOSISFSgYttmKFOMgLSZE0Feel7pKqcyDONAsfUYaziNT1P3UM/oPEd5EFO+W/N+1QpLGw8UFmpWmLd2wJ1yD+Jqp49hWT+8zE3iLYc9nt1in9qvpLcQcmWeBrX4siG0u8MiyVHIJPB81T9xmAgECYAaCp9ESDaJT1hYMOZbc15uPGdCKiXnSYnLXJUM/NaZRRNDpK3SOHKIokEy7GWbs4xAvwDtYrrtRSJHWR8kIycIwSC58Oo6jDunWSxPOJoq41CVH+evktV4Xvc3nKyqE7R8DoluRLTN12Igt6nCuExcCLDCtf/H0U6yD0oN4nvSYNsEIONk1tUrZaqAqEmBNcw8WaCU6IOrQNCNlUZPfGNEFymEAZ+yOL/kJ5nqpdKdybTIKNVd/pMnkMFIsnLZe4IBAgforREsEmSHBN5ILX8m60CZKdmqRlDy1CNQTr8YDKSky0SCsqnhRwFfNud0X7Y937MET6AfCpm6Y8x6AYEGYAaAjSFTru5ZpYzXSD9bKcK0rEHy++LNN/szTQbRTHpHz9qNIR0xsi95eyaQCeHBNCnBFfsMn1cO5LfL11BStu9bRwLBvFJNYyXXHg6SrSSI+XezD1sQ246DMgk4gAqsmV8yo5X5d1D6yKiE5luAqIq4ziNq2qc2THq45zQdf+QwQ8dhlo2/QxbbQKChVHJJAYobTyUIn/Fv2QVb9g437EWVWEEMKtRKLUPbb3WbUg4EEZO+akVPkc6CxtFZYwOUtdWbI6QacgZU6OVRbMyralc+FLEw1Q2AJpBq+vGvrqMu554c0TmuomDYxAmAGgAcw5cFFWWEnoUN+VSRQPSJj48+cncUTElaeYiIZiIpVrQnKeAtWAL2JExG3vLfXz1q3kSuIb8PFmjBhexkrTfM7diyixmImzwYF76YqDPVXgwZAUmSjkzpMKdWKG+hVKK0wTfQ3GeAkhLSJC37OmD4QKxzRQ9Bmu7V8loMgEI5c4ASGOs02jySKNzXNui01sFt3ppkNM1j2eopDSJVPm2iH059o+N4QLiAyTWF4TQVzIHCl7xzWvdB0XUrQT9UD9SG4nJnHMJWufaSxBRiyO++0upDijEYRV8aUqF2dU40rbXZk4QrTTItePgL+DB4QZAJpEJzsBipIXaWLynPODl0ykFeFSElhiaRNTz21J+L0T9X/P/KB4AyWCkWk1VEScQMhe5iVNdtOdlSgRYyg7QI/Fes6enwseq4nNURSfF27QAL7KTBSTdBssBbdaBxuugoMYFLCoYFfm5N/TGk3ZnkOIk00XtnhaZkHjPdkt0F9oA5C75CcEni8D38DGMuHIuoy81WmVKKwbTPerTW4SwcuZ9JeOgetDY+2uZ7JC61kKM95lXfOsW7s9W6Qlphu0XblYTQZwew4lHha9fun5LXo/gSwQZgBoAFHiXtRb0Uv7WZ3lgmq1UbR4EXedEAeCySpiIgYRZVfGxZUQWZqq8iSIYpG4UhNy9VEg8/KUigmUrpzmXnCSl5tMuKkKmwmW1Q4NUaQ/zmHVXQymbKqbdIVH5mbG5acdrPhOjF0sMnzSl8V2CZFO3YQMUmyblvOOFA2NfePZBlxWQm0nCNYWeDpLFYc4KNr8HN0fZH2f84RGY6Fpfb6hjcnum7UFTvL/kO9Cj2dCZxkbUnywauMlxopxuh5ecC9idemxq48Kk/t7+nXy7PTGOJGsfWnanbSeTPfFsh0HaU8Vu6MqF+pqoC1iKbAHwgwADeDW35wdLK137r2w/yGK+hYhnUjuLsVYzoUpop7lTCwcJ6ITZQyWO8HQrGQkW5Cqfu9/wYkympe8qyjjHRBZAj848tm5qXtAdmU3c7xP0NDQmPILveNQmZYPtunWtW22Luhv8r2ri5LLNavy1sWdEX/XmaRXXacF25LTZNhiYqjqI5zEEkfEtAsF37Uoi2pibdwRsGzLQa5sZbnkWBFQlOF/Fy0dXN0pZNY4PMl7W3kPC1pyiW3UeUcl0VK2oqDzVosu6cEKUTVmxCgmK/c500IOb+lctSheo4Vl7c81j/BuTMp1668Xyo8HjQfCTItYvnw53XvvvbRs2TJ67bXXaHh4mDbeeGPabrvt6K1vfStNmzat7iKCBvDfv1vkdPy79jirt9KSiDjdnj0VZ4j0L3FZXBxXZNY4JhSDG6cXJr/DlSZ9XrTxEVtUq/m2A1rTBMs3gn83IdWM0HPgoxp09iauYswYlgwmbN0BilrKaHD21y4r7kiVrjI6kaTg4NfYLm2u0XI3r/T5qqreKhT6XJ9v3bFO/WNA643cZMYh3cJxR1TWpj7X5hBUufbJm8OE2SjWcdfLv3fENEKs4CfpuATyTYtbxXy9BotGJ6su2bn8fRStpk1tWdfeHZ4H6em6NmO7e2ANNMlSpbHWosCLRggzp5xyCn3nO98JktaMGTPoySefDJKWC6+//jrtscce9Mc//jHz/cknn0zXXHONd7qjo6N07bXX0uWXX0733nuv9tjtttuO5s6dS4sXL6aNNtrIO08wtrjlgcWV5HPkvudkvxAHfLKJecGV78xLn1vdYhF1twS3cZtR4PoyNB7vsfqm3ZEi84PCGqbgSrJzvYkxWLh0Sp3ElBHTpuwBouMk32eCkhGi6rLcMSErV1I3ujgCTRnIVzCJ01nHFE/cbdJl9Sxzadq4/OgsY7woKjZ5nq8VmKq2TlTlqYslF6CMtYtVg4rKelmMQyjeQ+E5NC7YuOTti+0iAd+3mvr5prkHBySJSxnFRMRtFALaSSOEmZBMnDixlnw///nP50SZovzhD3+gE044gR588EGr4//4xz/S17/+dfrYxz4GYQY0jlt/e47T8XMO7Fn+mCZgAkpTZSGd1C3J9oXNWcv4oBJlcu5RklUil52JpK5blBdhWERdE+VO/nvV4NlrImSyeOAsaUrbpYGoXOGhjEFfAVEm+S6Y5URZFInV4LIldgtwEidVsa80WLsVFdyJSVaWiMmtZYzPuMRKwwaXmDs+6fsSNA/be6K6py6iDP+7YreduvqTQtZUJca2c8Ekqjtdm0ok0cSNs3rXatJL77/Y1hQCrDZv33e07v2uco9t+TuDiPrXMNQbn0asO94DrWXghJljjz228jzvueceuuSSS4KmedNNN9G8efPo9ddfz3y/8cYb0x577EHTp08nIqIXX3yRHnzwQVqxYkXQ/AGom9vuqcZHds7B53b/oXux974XtwyWCTVqASbKHWOMWePzm+Q6WCf7ss7km5g5RxGxoSg93qoMOkxCSEGLhkJBQHW4igUhBncVDxBL23FFGOxK09SthoptIvls25bKwqatWpZBV9dlTXBtrGlMLiPaoKJlCKouQcfHMjbigk2MFhvxRtMGQrfdkO578hOaMSl3FtVtY+2UHfdFFn+maH4uYwHbMYouZlmRhQFZmiF2JvRYkMkt3I02o20DPxohzFx44YV0zjnnOJ9377330rx589LPURTRggULApbMzNq1a+m0006jTm8748mTJ9Nrr71WKM27776bjj32WFq9enX63X777Udf/OIXadasWTQ8nL9tDz/8MN1444105ZVXFsobgLHGbb/8Z6fj5xx8rtZyxsaqJnVrKsOCQzHxVb2q2VDUC/4st9pRXQ8vQEmPGcp+5+b2ZXeM9UTAJHD5bKVpOEY5aErODTQodLVuKs3lxQZTe9dZV7laPFXlwuQxkNbFMpJZcQS7P0UsBAIGXE2+K4MyhC2TZY20L2qINUZKRWUJ2WZN99Inj0ZYCvbQlcXaJZkcrYYUMWikuy5p8jSVSZWXkipcg2WEEmWS/5e9W6SEiBHRaCdNhw01qN8BzjRCmNlkk01ok002cT7vy1/+cubzrFmzaLvttgtVLCsWLVpES5cuJaJufJt58+bRhRde6J3eqlWr6MQTT8yIMp/85CfpwgsvlG9x12OXXXahXXbZhT7zmc+kIhEAIDyuQg4R0eyZ+Tg+oQK2BUlHMWixdd0SLYlUaaXllFlISAIDp8eoyiecH3THpgIYB8iB8nOdZGgnxzoffh9BJJQVi2mgWoW1UYD7lVlVdggc67vzDU/G1YBLn09LFBdsY7+4lEGHqm2WLbSEPLYoRa+5zDpz3c7bascsWTYWgrvvPcmlW7FwFuy++Ih+sq3ZPV0FXdykrHDtX113CwyRjg5xpy7dBgiyfANtnc6aGicOONEIYcaHN954g37wgx9kvjvttNMqLcP9999P559/fvr5iiuuoF//+teF0vzsZz+bCV580kkn0UUXXWR9fhRFNDQkhlwHANTJ7XefVUk+qVtWDdiIMzlkK0UyqwnD+SyKiIZatjNBgMFYsKCvZcRrsRDWnNPi0ZWxysGpqxDl+IxId6hxKVevbLLzy4jlFNrKx/W6bSb+IkUmzEpXnrIn/VVsUVwwELCru6nJLapImxoYUSbBdWcxVewo13oIlY4PLu8lk6tTaEHfwhVeh7LfVLxflC5wEGdaT2uFmR/96Ef0yiuvpJ832mgjOuaYYyrLf2RkhBYsWEAjIyNERDR//nyaO3duIWHmT3/6E11++eXp50033ZS++tWvFi4rAGBs4OOW5UNGALEcCFiJJrzQYjhHJgIF2zayoL94MrEwWqQEosgKcogJtPZ+lXHdTQzaaGgzLvWc297WNQ2FS5jOKkaHScwIEUTXVYApJUC4RZ46isZZcT5X0jas0xAn0wGEHt31Bw0oX4QaXMx01nKFrJxMFi9F76lqh6eExDg/zpYnhJVfIUqwSPHKtyiSd6fWxa0X74c18f0IrGmtMCPGUjnhhBPoTW96U2X5X3DBBXTfffcREdGUKVPo4osvLpzmt7/9bRodHU0//8M//ANNmTKlcLoAACDDxy3LhzoteerCOBgNtCuEq1uGdGAXMOZNrWCl0IiuvYg7o+nOK2OypbLq8U/QwarAcKytBUeIILiuQpdXTC7ZdbpM5HsiQ5FAtbZt0XRsKzC4guXuj6zukvvjsjOWzIVJLJfu+fAQdvg2YXXfbF1mJTtWtgLR5dr1vB5Nio8EyqOVwswTTzxBd955Z+a7008/vbL8H3nkEfrCF76Qfr7oooto2rRphdMVxaZTTz21cJoAAFA3wSx5ZNY5yceQg5aqBn01b/mcGTSb4rhoBs3WVkqhzKyr2Oo0xM5kMmwnF5p4ME2maDmTCWbhOCOKNinWpSkfb5cag9DDT6TLFCh0cYSs4MUacZLPiTPKcy3KpTsmlzb37Ns+FzpBqtLnKhFBQljtSPoHb1FQJgIl91eHYCmTKZ5POVximlXhnhSaAuXT1meTgoyDwrRSmLnqqquIcR3GPvvsQ3vttVcleXc6HTrttNNozZo1RER0xBFH0CmnnFI43ccee4z+9Kc/pZ+333572nbbbQunCwAAbaMKSx6t+GPAZUJgPfCvaFDpPRExiCpWW8eXLXA02b9et014QshglJ5UuYOSSxlCuqBI0yZys0SwReO+0kixTSbEmCwqHO5LEWGJiPTbH9cwMefFNaPQJqnPUFYQVuKMxfbn0u8ULkvatKm8d80g4xIfq9YdFkFptE6YGR0dpe985zuZ76oM+nvZZZfR3XffTUREEydOpG9+85tB0v3Nb36T+XzQQQel/16yZAl997vfpVtvvZWeeeYZevXVV2nq1Km01VZb0axZs+iYY46hAw44IEg5AABgLOAj/sw5cFHG1UM3CHIacIsTCo1FiDTfKixIiJQrmqqgz8Fi/tSBTPgpe9cv2e5k1LcgqWrQ3bjBvdCGrMrn4r4k+8mxDnST4ap3dnLd9SgX5ySQAFb2dafp2/Z9PRGp7HJpt58OhcZNLETMpzRdm/47pChThBa746bPpcZVLSWJxcdZjoHBoXXCzC233ELPPvts+nnixIl0/PHHV5L3k08+SZ/73OfSz2effTbtsMMOQdK+9957M5933XVXWrVqFf3TP/0Tff3rX89YCBERLV++nJYvX07/93//R1/5ylfone98J11++eWVbxcOAABjhdvuWVh6HnMOXKQVZZRUJc4QjekVzQw29RCgnqytNkxtoEXm/2VbzeTSNLjd6Oo/nVDxaQmBUJtKYVcnIq1VUGMoWSAOPjl2cXnSHJe5p6Y6UMW1iVnfakbMD240eQK/i5XPkiSoe5vcXoGc1gkzV111VebzscceSxtttFElef/d3/0drVq1ioiI9txzT/rUpz4VLO3ly5dnPm+88cY0Z84c+tWvfmV1/n//93/T/vvvTzfeeCPNnDkzWLmIiP785z/TihUrnM55/PHHg5YBAADGAj7iT9uCKwe3pClbJEoG2rLBtmoAHrhMVsGk+f/LrLB055Uh0LgIQTaxdxy3aNYixtCwnARrA912qDuJ1VllVLCqL90VTnGc7jtjXAuFC1iTJoZlWxPYuP7J3JysyuUoehSalKv646QMsXiRJYikPEVifCX9te+zVuQZ5fthn/N1gq5luWBB025aJcysWLGCfvKTn2S+q8qN6corr6Tbb7+diIjiOKZvfetbNDwcrvpefvnlzOfzzjsvjTkTRRH9zd/8DX3oQx+iHXfckaIooscee4x++MMf0nXXXZda07z00kv0/ve/n37729/SjBkzgpXt8ssvzwQ7BgAA0Bwqiclz4KLsF5ZWMyoRpg43J97lyilvnwG2q1VRnZYrTbOaUWzvHRzRVcNgeWBMKzZMVvn2ULKFmymgsEsaLsF9myLKSK1ESnZjUqUddNtomXuRps1pd2qy3P5aebyumCGvWdWX6sTnJlh0Oj7j1nVlSLcpzyDwo1XCzLXXXkvr1q1LP2+//fZ0+OGHl57vc889R5/+9KfTz2eccQbtt99+QfMQhZlElNlggw3ohhtuoFmzZmV+32233ejoo4+m008/nd7//vfTa6+9RkRdcea0005LRSQAAACgKD6WPLNnLpZ+HzFGLIoqEWds498oy1Jk8lyly5eNC1MTtkVX5a9bIefuoUtcJythRxYQ1cESIBeXpfd/qfWCR3uocvVbNZm2tfJwmliacGifynIZdxXSWGkp2qm4Q5ZJgOCPD3YvLdtnLj/VeUk9xZLv+XPE8x0s2BojFtj0f6H6fJt0XMQbPm2h7dpayYHm0yph5uqrr858XrBgAUUV+Dd+9KMfTYWTGTNm0OLF8sFmETqdjvT7a6+9NifK8MyaNYu+973v0fvf//70u5/97Gf0q1/9KhNAGAAAAKiS2+8+q/Q8Zs9cHETcaW2QYhMVb8memRzIhIjkO35CIk5OFGUMFpA3c5BgDaDY+tcn4LBSnPGkrEmXrWBgu8W3kiZYMSSIZbEom1hPTkKLrH8pcf5iLJttf2fY9r10ymgzvs+grYji6zpVMJ30mWzScwacaY0wc88999CSJUvSz0NDQ0G2qTbxgx/8gG688cb08xVXXEGTJk0Kns/666+f+27WrFkZwUXFUUcdRe94xzvoZz/7Wfrd9773vWDCzEc/+lGaN2+e0zmPP/44HX300UHyBwAAAGT4iD8qS54cDrtlSQkwQHaaCPtYw5QVqFInCPHijG16PCGsfgyr/4mo4mMlEtLKpWkr4YXKUWfQcP7+epTBZRvj/AEs+39PkUPX1qxj14iue2lCOlO07G9OcXKK4HKfROsnldtgEVFGTMt0vMoKMKS1TtPcUEFhWiPMXHnllZnPc+fOpS222KLUPF988UU644wz0s/z58+nuXPnlpKXTJg56aSTrM8/6aSTMsLM//zP/4QoFhERTZs2jaZNmxYsPQAAAKAuqrDkSXfXKjgRddqRqSnYWOnoJk8uaRfEJ0CuDplVhTEQMFFtMSNMgWtbjRCPxXhtZU1yZTssWYoztq57TuKdrbWMoozG7darQtZn8AJMnX2ij3uS6RyZS2qRvEEjaYUws2rVKvr3f//3zHdVBP0944wz0t2IpkyZQhdffHFpecl2ljrwwAOtzxePfeSRR4gxVomrFwAAAAD6eO2uJQZY7mE14UoG63WvuLoGPBYmJbkJpi49j+stLDw4uoZp8/O9ZwWxtQYKlReRwb1NhmW9pFuVE+V2tIkY5YPlemwZH6SeJHGSiljhyM7VllO02lGUTfxOLIepzLLfSxX7TAKFaOnia20X8hkV3Th9zpf9mwiizADQCmHmhz/8YRrcloho+vTp9N73vrfUPB955BG67rrr0s9nnnkmvf766/Tkk09qzxOD+K5cuTJzThzHtPXWW+fO22mnnXLfbb755tblFa2HRkdH6eWXX6aNN97YOg0AAAAA1IOPmOOKSvypDW6ylEzqynDdCZKebBLFTbKsLZss4unokAkrLtdX1QRaWR+BxBmZKMOTXmeNC5Q2u2MVtloyuUiJW8PziDsveVDIzUuFq2AhaycecYRKQZWvrHxFBJsi54HG0AphRnRjOumkk4JuVS3jjTfeyHxeuHAhLVzoPmi6/vrr6frrr08/b7jhhjnxhqi7y5LIhAkTrPORHbt69Wrr8wEAAAAw2IS05LHCMlimaZI9ELjGqZDAi1fi967iDJ9OZaIMkT7YqW0sjjQjfcFDXFfV7l0mwU27C5Vsl7HkuepQditsy12V+DLYWloVrjNXVyTRIiZUuiGQ5Wkr1vQQdxdUBatX7UII2kPjhZlHH32UfvGLX2S+q8KNqWre+ta35r57+eWXabPNNrM6Xyb2TJ06tWixAAAAADCGqcKS58gDFOKP5USq8vgWCaJ44CkuhRBIfCwvik6g+Ym7ykXK2TXNY+LM59ukYMkmTO3WemcxnauS7HjHLeFdxJlgde8jzpRF0YDj3u2aj0tERKz//cDuJDjGabwwc9VVV2U+H3LIIbTzzjvXVJry2H777WnnnXemRx55JP1uyZIl1sLMgw8+mPm86aab0vjx44OWEQAAAAAgNLf+2k38mXPwuZnPuskiP1EsJIC4WHSI1guWkzJf9yRVWlUIFLy1U0QG4cWE4+TV+fraFINDZgGjgj9ONWGPyVkwHEhCtQFXyzdHcSYVZfhTOHFGBsSa9tNoYWZ0dJSuvfbazHdVWcvstddexDwa+DnnnENf+MIX0s8nn3wyXXPNNVbnHnvssXTeeeeln2+55RZ6xzveYXXuLbfckvl86KGHWp0HAAAAANAmbvvlP5eeh9SFy3YiNqgTYJPlACcm5EQT1/gZmomvKkZObZZTnmjLLBNbfNqVx25QuSQsBc3gQmBZrkc+oop4vipd3Xmu15McyltF9cQZldVMFX0jKI9GCzM33XQTLV++PP08efJkmjdvXo0lKpeTTjqJzj//fBodHSUioquvvpo+97nPGQP4/vWvf83F4Sk7ODIAAAAAwKDi48LFu2Slk1QLKxtZIFjfuDGV0JvYZoQFnSgTEF0dtcWFicdq56MiIk1AkbDS7dV93YdM7nL8v32sZ2RpuO5GJ6ajQwzQzJhRnAHtpdHCjCg2HHfccTRp0qRCaYrbR99xxx309re/vVCaodh5551pwYIF9K1vfYuIiF566SU67bTT6P/9v/+nDHY8MjJCp512Gr300kvpd1tvvTWdcMIJlZQZAAAAAAC4u2T50ojdtfiJre3k0NX6wTB5bqMQY0LmepdB3AJc9rtDmsrfJK5UvBA3EHXvIv44BuxNf7MMgJ5LJyL1VuaCOJP+BJGm9TRWmHnhhRfopz/9aea7008/vabSVMeiRYvohhtuoBUrVhAR0Y9//GOaO3cuXXbZZbnYOo899hj94z/+I912223pd1EU0cUXX4z4MgAAAAAAA4irNU8pQg4/4eRW9TOWQvwxRbYA5tIZCEGA7AQO5a5MDlYwqvSN9cjlUYtVko8bU1kBgMtI1+TmxIh0IZuIKBdzBrsytZ/GCjPXXnstjYyMpJ9333132n///WssUTVsttlm9F//9V80a9Ysev3114mI6Pbbb6dddtmF9txzT9pxxx0piiJ67LHH6Pe//33u/IULF9IHPvCBiksNAAAAAACaSBU7axFxAhC/NTjQ4uOy5hJLx+XYVoheMtfAKnZkqgOXANBgIGisMCPuxjSIW2Sr2H///enmm2+mk046iZ566qn0+/vvv5/uv/9+6Tnjxo2jr33ta/SRj3ykqmICAAAAAABARB6WPMLuWkRknmz7xgZpECF335LFJ2oFpthLNuJenaKJizWYR7yciDFiiUmMTpwx7NQE2kUjhZm7776bHn744fTz+PHj6cQTT6yxRNVz2GGH0QMPPEDnnXceffe736Vnn31WetykSZPoQx/6EJ111lm03XbbVVxKAAAAAAAA3PHZQWbOwecOhDgTmsp2pSpa9zIRg0+zDrFFdU2qsrhcvxgsWHa+7ppZ7z988N/c72BQiJjPntCgUhhj9Jvf/IaeeOIJWr58OY2OjtImm2xCO+ywAx100EE0bty4uouYY8mSJbT77runnx988EHabbfdaiwRAAAAAAAAelxi8rgGww1hLaNLQyvOFN05y3enJFkaTUMnzPher+laDXF00pgxskMURbr97rPsytZSBn1+2UiLGZAliiI64IAD6IADDqi7KAAAAAAAAAwsPjF56topSxejJrfjEuKVuFHUKisRXlRuTwbhJtlliVHUF2dgTjHQQJgBAAAAAAAAAE+qCLCciD+i25JuC2zdd84YhArXQMaNwVaAMcXFKZK2CQgyYwIIMwAAAAAAAADQYAptkx7CDUlDIg41RZxJ3ICiAYjYETFmtRX2IFzrWAfCDAAAAAAAAAAMEFVuk24lxpQcX4YXL6xFCtvYMmLZfYIge14/RJmxA4QZAAAAAAAAAADOBNkmvSA24kUOlbBiu0OUqzhjCPabwKLISWiBKDM4QJgBAAAAAAAAAFA6Ptuk+zB75uJiooWlkCJFFY/GY1twlSuTeG1V1SsoDwgzAAAAAAAAAAAGBteto7121rKxmpG5RmlcqGRiUrpDk6M1DWgXEGYAAAAAAAAAAIxZqozJI0W00JFY10CUGWwgzIBSWLNmTebz448/XlNJAAAAAAAAAKB+Lr7yWOdzTj/hG8ZjlixZ4lOcViHOJ8X5ZtuBMANK4Zlnnsl8Pvroo+spCAAAAAAAAAAMMLvvflndRaicZ555hvbZZ5+6ixGMuO4CAAAAAAAAAAAAAIxVIMwAAAAAAAAAAAAA1ETEGKIIgfC8/PLL9L//+7/p5ze/+c00YcKEGksUhscffzzjlnXDDTfQDjvsUF+BQGNA2wAq0DaACrQNoAPtA6hA2wAqBrltrFmzJhMu4/DDD6eNNtqovgIFBjFmQClstNFG9P73v7/uYpTODjvsQLvttlvdxQANBG0DqEDbACrQNoAOtA+gAm0DqBi0tjFIMWVE4MoEAAAAAAAAAAAAUBMQZgAAAAAAAAAAAABqAsIMAAAAAAAAAAAAQE1AmAEAAAAAAAAAAACoCQgzAAAAAAAAAAAAADUBYQYAAAAAAAAAAACgJiDMAAAAAAAAAAAAANQEhBkAAAAAAAAAAACAmoAwAwAAAAAAAAAAAFATEGYAAAAAAAAAAAAAagLCDAAAAAAAAAAAAEBNDNddAADaxKabbkpnn3125jMARGgbQA3aBlCBtgF0oH0AFWgbQAXaRnuJGGOs7kIAAAAAAAAAAAAAjEXgygQAAAAAAAAAAABQExBmAAAAAAAAAAAAAGoCwgwAAAAAAAAAAABATUCYAQAAAAAAAAAAAKgJCDMAAAAAAAAAAAAANQFhBgAAAAAAAAAAAKAmIMwAAAAAAAAAAAAA1ASEGQAAAAAAAAAAAICagDADAAAAAAAAAAAAUBMQZgAAAAAAAAAAAABqAsIMAAAAAAAAAAAAQE1AmAEAAAAAAAAAAACoieG6CwCayRtvvEEPP/wwPfXUU/Tcc8/Ra6+9RuvWraMNNtiApk6dSrvvvjvttttuNDzcvia0bNky+v3vf0/PPfccrVy5kjbffHOaMWMGHXzwwTRu3Lhg+axbt47uvvtuevrpp2n58uW0/vrr0xZbbEF77703bbPNNsHyIar2mn7+85/Tb37zG3rsscdozZo1NH78eJo2bRrNmDGj1LaxcuVK+vWvf02PPfYY/fWvfyXGGG2wwQY0Y8YMestb3kLbb7994TzQNvyps21UAdqGP3W0jaeeeop++9vf0vLly+mVV16hcePG0UYbbUQ77rgj7bvvvjR58uQg+RChbRShjraxZMkS+v3vf08rVqygNWvW0GabbUZbbbUVzZw5k970pjcFySMBbcOfKq+pjjwHsR4H8ZrqYBDrcRCvqRQYAD2uuuoqduKJJ7Idd9yRxXHMiEj7t/7667MFCxaw3/3ud075mNI1/S1btszr+n74wx+ygw46SJnulClT2Ec+8hG2YsUKr/QT/vznP7OPfOQjbMqUKcq8Dj74YPajH/2oUD5VXtPXvvY1ttNOO1m1iyJtQ8bPfvYz9t73vpcNDw9r85w6dSo77rjj2P333++cB9qGP2W3jWXLlhXuM/i/q6++2un60Db8qbrfWLVqFTv//PPZjjvuqM0njmP27ne/m/33f/93oetD2/Cn6rbx6quvssWLF7MttthCmcfkyZPZiSeeyB5//PFC18YY2kYV13TwwQfnvp8xY0apeQ5iPQ7iNYVqGytXrmR33XUX+5d/+Rd2/PHHsx133JFFUZRJ13VMoaNp9TiIbSPENZUJhBmQsuWWW1oNkMS/oaEhduaZZ7J169ZZ5eOTB//nKsy89tpr7LjjjrNOf/r06eyWW27xqEHGbrrpJjZt2jTrvE444QS2cuVK53yqvibbwXPRtsGzYsUK9oEPfMA5zyuuuMI6D7SN5reN0MLMD37wg0bWI9pGsX7jl7/8Jdt2222d85o/fz5btWqV07WhbbSrbdxzzz1s8803t85jvfXWY5dffrnXtaFtVHtN4p/P5Bv1OJjXVKRtfOQjH2G77747GxoaMqYbQphpcj0OYtvwvaYqgDADUkRhZr311mN77LEHe8973sPmz5/P/uZv/obNmTOHbbbZZtKGfvTRR7ORkRFjPr6davLnIsyMjIywd7/73bk0Nt10U3bkkUeyefPmsX322SengE+YMIHdddddTvV3xx13sPHjx2fSiaKI7bvvvmzevHlszpw5bJNNNsmV5X3vex8bHR1tzTURdVecN9xwQ7bJJpuwCRMmGO+ZbdtIeOKJJ9j222+fS2f8+PHsgAMOYEcffTSbP38+mzt3Lttmm20yx9gKM3XXI9qGXdsIKcyst9567JVXXml8PaJtuPUbv/zlL9n666+fO3/y5MnsiCOOYPPnz2fHHHMMe+tb3yoVBN7xjnewNWvWtKIe0Tbc2sZtt90mTW/GjBnsfe97HzvuuOPYIYccwsaNG5c75rLLLnO6trrrcRDbhs01ifcV9YhrKto2NtxwQ2MflPwVFWbaUI+D2DZcr6kqIMyAlJ122okdddRR7IorrmD333+/tsH+6le/Yu94xztyDf0rX/mKMR/++AMOOIAtW7bM6c9lpezTn/50Jr9x48axSy+9NDcIX7JkSc7UburUqey5556zyueZZ55hG2+8ceb8mTNnsqVLl2aOW716Nfva176WGwR+9rOfbcU1bbfdduzHP/5xpm2orsmnbTDWNUfcbrvtMuduscUW7KqrrmKvvvqq9Jznn3+eXXnlleywww5j3/jGN6zyQdtoR9tYt26dcx+R/M2cOTOTz8knn9z4ekTbcOs33njjjZyIO3HiRPa1r32NvfHGG7njH3/8cfa+970vl895551ndX1oG+1pG8uWLcuZtW+//fbs1ltvzR37l7/8hX3sYx/LHBvHsfRYFWgb1VzTAQccoGwTLpPvsV6Pg3hNodqGSpjZcsstc78VFWaaWI+D2DaKXlNVQJgBKWvXrnU6fnR0lJ144omZRr7hhhuy1atXa8/jjz/88MMLlFjPE088kXsIb7jhBuXxr7/+eq6D+PCHP2yV14IFCzLnHXzwwdJJQcKPf/zjzPETJkxgTz755EBdk7gybdM2GGPsgx/8YOa8ww47TCnIyLAR7tpUj2gbfvzpT3/KmSHfeeedxvPaVI9oG4xdffXVmeOjKDKaQ3c6nVw/s8EGGxitZtpUj2gbLGdGv8MOO7AXXnhBW8bzzz8/c85b3vIWK8ucNtVjm9vGbbfdljlO/HOZfI/lehzEawrZNjbccEM2ffp09u53v5stXLiQ/eQnP2HPP/88Y4yxww8/PJNuEWGmifWYMEhto+g1VQmEGVCIV155hU2aNCnT0G+++WbtOfyxZQozJ510UiavU045xXjOI488kjGJGx4eZk888YT2nEcffTQzARw/fjx79NFHjXmdfPLJmfKdeuqpA3dNYsBeU9u4/vrrM8fvuuuupfiBtq0e0TbcWbx4cSb9HXfc0eq8ttXjWG8bxxxzTObYo48+2pgfY4wtX748N3i87bbbtOe0rR7Hctt44oknckKOrYn8rFmzMuddeeWVxnPaVo9tbBsrV67MuC7vvvvumfIR2U++x3I9DuI1hWwbjDGtxUZIYaZp9SgyCG0jxDVVCYQZUJh3vvOdmUZ+6aWXao/njy1LmHn99dfZeuutl8nroYcesjr3Qx/6UOa8c889V3v8Oeeckzn+uOOOs8pn6dKlmfMmTZqkVXrbeE2ixYKpbey8886Z420sHFxpYz2ibbjR6XRy7i1f/vKXjee1sR7HetvYa6+9MsfaTKITRFc3XcDXNtbjWG4bl1xySea4Aw880Co/xhj76U9/mjn3kEMO0R7fxnpsY9v4+Mc/nh6z3Xbbsfvuuy9zHhGxrbfe2qqMY7keB/GaQrYNE6GEmSbWo8ggtI2i11Q1EGZAYebPn59p5CZfff7YsoQZ0VztoIMOsj735ptvzpy79957a4/fc889M8e7bMEq+sPeeOONA3dNtm3jjjvuyBx76KGHWufpQlvrcSy3DVfEtjQ8PMyWL19uPK+t9TiW24a4NbZLnqKryxe/+EXlsW2tx7HaNkRXtbPPPts6v9WrV2dWb+M41q6gt7Ue29Q27r777owFVGLdtuuuu2bOnTZtmlUZx2o9DuI1hW4bJkIJM02rRxVtbhshrqlqYgKgIE899VTm8xZbbFFTSfrccsstmc9vf/vbrc899NBDaXh4OP38u9/9jl544QXpsc8//zzdf//96efh4WGaOXOmdV5iuW6++WblsW29Jh5d2/j2t7+d+Xzqqada5+lCW+txLLcNV6688srM5/e85z202WabGc9raz2O5bYh3tfVq1db5ykeO2XKFOWxba3Hsdo2/vSnP2U+77777tb5TZgwgXbYYYf0c6fTGch6bMs1rVmzhhYsWECdToeIiE4++WSaPXs2ERHttddemWNff/11Y/nGaj3qaOs1hW4bVdKketTR1rahw+WaqgbCDCjEo48+Sr/+9a/Tz1EU0eGHH15jibo8+OCDmc8HHXSQ9bmTJk2iPfbYI/PdkiVLrPJ561vfSpMmTbLO6+CDD7bKR5ZXW64pwdQ27rjjjsznOXPmWOfpQlvrcSy3DRdeeeUVuv766zPfnXbaaVbntrUex3LbOPTQQzOf77vvPus8xWP3228/5bFtrcex2jb+8pe/ZD5vtNFG1vnJjn/ggQeUx7a1HtvSNs455xx65JFHiIho0003pYsuuij9bbfddsscu27dOmP5xmo96mjrNYVuG1XSpHrU0da2ocPlmqoGwgzwZvny5TRv3jwaHR1Nv/vgBz9I22yzjXUaTz/9NJ166qm022670cYbb0zjx4+n6dOn02677UYnnngi/eu//mtugGXDQw89lPnMr37ZsP3222c+L126VHqc+H1Z+RC195oSdG3j2Wefpeeeey79vNVWW9FWW21FREQvvPACffWrX6XDDjuMttpqK5owYQJtuummtPvuu9Pf//3f0w033JCultjQ1nocq23Dleuuu47eeOON9PPmm29Oc+fOtTq3rfU4ltvG6aefTuPHj08/X3XVVZn7r+LHP/4xPf300+nn3Xbbjfbdd1/l8W2tx7HaNvg2QdRdWXdBPH4Q67EN13TffffRhRdemH6++OKLaerUqeln0WLKZvI9FusxVD5EzbmmMtpGlTSlHkPlQzSY11Q1EGaANSMjI7RixQq688476TOf+Qztsssu9Ic//CH9fbvttqPLLrvMKc1ly5bRNddcQ0uXLqWXX36Z1q1bR3/+859p6dKl9P3vf58+/OEP09Zbb02f+MQnaOXKlVZp/uUvf8mJOVtvvbVTucTjH3vsMelxjz/+eKF8ZsyYkfn80ksv0V//+tfccU2/Jr5tfOtb38r9vs0222jbxr333pv5vOuuuxJjjL7xjW/QDjvsQJ/85CfprrvuomeffZbWrl1LL774Ii1ZsoS+9a1v0Qc+8AHafffd6fbbbzeWs+n1yIO24YfoxnTyySdnzGNVNL0eedA2+my77bb0pS99Kf38zDPP0Pz587Vm6//3f/9Hp59+evo5jmO69NJLlcc3vR550Da68BM0ou5Ckgvi8cmqvEjT65GnbW1jZGSEFixYQCMjI0RE9K53vYuOP/74zPGiK2On05Fek22eNrStHm1o2zWV1Taqoin1aEPb2oYNttdUBxBmgJIzzzyToihK/8aNG0fTpk2jww8/nC644AJ69dVX02NnzZpFd955J02bNi14OVatWkUXX3wx7bvvvlbmZi+//HLm83rrredk4kZEuet45ZVXrPJyvf7111+f3vSmNxnzato16drG1772tdzx1113nbZuxEHwlltuSZ/4xCfoIx/5iJUg99BDD9G73vUu+vrXv649rmn1qANtw50HHnggJ/LZujE1rR51oG1k+eQnP0kXXHABjRs3joiIbrzxRnrLW95CX/7yl+kXv/gFPfbYY7RkyRK64YYb6NRTT6WZM2emA8hx48bRVVddRbNmzVKm37R61IG20WXXXXfNfL7nnnuUx4o8/fTTGQtOIvtrq7sedbStbXz5y19O40hMmjSJrrjiitz5EydOzH2nyssmTxvaVo82tO2aymobVdGUerShbW3DBttrqgPzMiIAGo466ij6x3/8RzryyCOdzhseHqZDDjmEZs+eTW9961tpq622osmTJ9PKlSvp6aefprvuuouuvfZa+vOf/5ye8+ijj9Ls2bPpnnvuyamdPOJEXtY5mxDPee2110rNiw9CKcurbdckYuqcxU729ttvzwRvPPjgg+m0006jvfbaiyZNmkTPPvss3XLLLXTFFVek5R0dHaWPf/zjtPXWW9P73vc+aT5tq0e0DTdEa5nDDz/c2sS1bfWItpHl05/+NL3nPe+hCy+8kH784x/TU089RZ/97Ge158yePZvOP/982meffbTHta0e0Ta6z/43vvGN9PP1119Pl1xyCa233nrGtK+99trcd2XfryrzakPbWLp0KS1evDj9/txzz7V2d1XlZcrThbbUo2tebbimMttGVTShHl3zakPbcM3LdE11AIsZUIibb76ZLrnkErrzzjutz1m8eDE9++yzdMcdd9DnP/95et/73kd777037bDDDrTXXnvRUUcdRRdccAE99dRT9E//9E8URVF67vPPP0/HHHMMMcaU6YsPrKiK2iA+5Cqrjaryats1mdIUEYWZRJSJooguvPBCuvvuu2nBggW0zz770M4770xHHHEEfeUrX6GlS5fSW97ylvQ8xhidfPLJGWsuXTmaXo9oG/asXbuWvve972W+s7WWkZWj6fWItpFnZGSE4jhOLWd0nHzyyfTVr37VKMrIytH0ekTb6O7Exgfwffnll+mcc84xpvvMM89k4lYkjI6OSmMXta0e29A2Op0OnXbaaWmcn3333ZfOOOMM67xNbWOs1GMZedV9TWW3jaqoux7LyGsQr6kOIMwAJQsXLqRly5alf0uXLqW77rqLLr30UjriiCOIqBtM66c//Skdfvjh9LGPfSwTCFjF5z//eSuzsze96U30pS99Kef7f99999F1111nfR28sFPmOVXmVfc12bQNnosuukjbNlTBe88880z61Kc+pTzvzW9+M91yyy204YYbpt/99a9/Nbo0JdRdj20+R3Ve6LZhy4033kgvvfRS+nnDDTekD37wg97p1V2PbT5HdV5ZbWPNmjX08Y9/nPbcc0/69re/nbG0VPGd73yH9thjDzrqqKNyWyubqLse23yO6rzQbWPy5Mn0//1//1/muwsvvFDqFpXwpz/9id71rncpTdptrrfuemzzOcl5X/va11LXs+HhYfr2t79NQ0NDXunZ5jlI51SZ16C3japA2/A/p+q8ygbCDFAyZcoU2mabbdK/XXfdlQ455BD62Mc+Rj/72c/orrvuyrgUff3rX6e///u/D16Of/zHf6Sjjjoq893ll1+uPH799dfPfLbZoUNEPEdMs+q8mnZNprYxefLkzPHXX3+9tm3IyrLBBhvQokWLlOckvPnNb6ZPf/rTme9EywlVPnXXY4i8mnZNoduGLaIb0/z5853MW5tWjyHyato1ldE2RkZG6Oijj6bLLrsstaSMooiOOeYYuvHGG+nZZ5+lNWvW0KuvvkoPPvggXXLJJbTjjjum5//kJz+hvffem37/+98r82haPYbIq2nXVEbb+NznPkf7779/+pkxRmeeeSYdeuihdM0119Dvf/97euSRR+iOO+6gz3zmM7Trrrumu3MkuwImvOlNb5KuyjatHkPkVec1PfPMM3TWWWelnz/5yU/SXnvt5ZS3Ki/V74NYj4N4TVW0japA2/DPp+q8qgbCDPDmkEMOoTvuuCOz+8FVV11FN954Y/C8xFgB99xzT879JWEQO4e2XVMSKZ9H1zZkZfnABz5g3VGedNJJmc9Lly6Vrpq3rR7RNux45pln6Lbbbst8x++6Y0Pb6hFto8u5555Lt9xyS/p54sSJ9F//9V90/fXX01FHHUVbbLEFjR8/niZPnky77bYbffzjH6cHHniAFixYkJ7z4osv0nvf+96MxRVP2+oRbaPL+PHj6T/+4z/orW99a+b7X/ziF3TqqafS3nvvTbvssgsdccQRdMEFF6Sm7FOnTs0JvbxbFE/b6rHpbeP73/9+uqPadtttZ+V+ZkrT9Psg1uMgXlMVbaMq0Db886k6r6qBMAMKse2229LChQsz333lK18Jns/+++9PG2+8cfp5dHRUue8879ZCRPT666/TqlWrnPITJ/WqQZmY14oVK5zyWblyZa5zkOXV9mtKULUNWVkOPPBA6zy33npr2nzzzTPfPfzww7nj2l6PY7Ft2HDNNddk3OH23HNP2nfffZ3SaHs9jsW28Ze//IUuuuiizHeXX345vfvd79bmNWHCBPrWt75Fhx9+ePrds88+S+edd570+LbX41hsGwlbbrkl/fKXv6QPf/jDVrGHZs2aRffee28uuLC49W5C2+uxaW2D3wb3m9/8ptHqUdYuVHmp8hzEehzEa6qibVQF2oacpl1THUCYAYU57rjjMp911iy+xHGc26de9SBOnTo1I+IQdbe/dOGpp57KfOZN33Xfi+e55jNlypRc2YnafU08qrax00475b4ThRYTW2yxReazbPW7zfU4VtuGCcYYXX311ZnvXIL+JrS5Hsdq27jpppsyA79tt92WTj75ZKv84jjOLSp85zvfkQaWb3M9jtW2wTNp0iT6xje+QY888gh98YtfpFmzZtFWW21FEydOpMmTJ9Ouu+5KJ598Mt122230s5/9jLbZZht66KGHMmm87W1vk6bd5npsYttIePe730077LADPfnkk9q/Bx98MHNeFEX0yiuvZI5Zu3atNs9BrMdBvKaEMttGVaBt2OVV9zXVAYQZUJhp06ZlGnSn06Fly5YFz0dUx3Wma7vuumvmM6+02/DHP/5Rm15Z+fA7DJWdV1XXNDw8nP5b1TZ222233HcTJkxwylc8nt8Gj6et9ThW24aJn//855nzJkyYQCeccIJzOkTtrcex2jbuv//+zOdZs2Y5BfQ77LDDaPz48ennl156SVnuttbjWG0bMrbddlv63Oc+Rz//+c/pmWeeoddff51effVVWrp0KV1zzTU0e/bstP386le/ypx7wAEHKNNtaz02sW0k3HTTTbTtttsa/z7zmc9kzmOM5Y4RravHQj0O4jUllNk2qgRtw5xXE66paiDMgCCIJsLJVnYhefHFFzOfN9lkE+Wxu+++e+azOMjSsWrVKvrDH/6gTU/1/R/+8IfUB9aGu+++2yof2W9tuSabtrHxxhvngi26Wk+Ix/Oxj3jaWo9jtW2YuOqqqzKfjznmGJoyZYpzOkTtrcex2jbEZ17lbqJieHg410+I75mEttbjWG0bRWCM0c9//vPMd7zbm0hb67GJbaMKxkI9DuI1DRpoG1maek1VA2EGFGb16tW5wez06dOD5vHiiy/mFE7RdYXnXe96V+bz//zP/1jnddddd2UCDe69997K69l8880zgQVHRkboF7/4hXVeYrnmzp2rPLat1yQOmlX5inEhlixZYp3nmjVrcoq5KPQktLUex3LbUPHyyy/Tf/zHf2S+83FjSmhrPY7VtiH6hLv6sxNRGvA1QRUAsK31OFbbRhF+/vOf05NPPpl+Pvzww5Um9UTtrccmto0qGAv1OIjXNGigbWRp6jVVDgOgIP/1X//FiCj9W2+99diaNWuC5nHppZdm8pg+fTrrdDrK41etWsUmTpyYOeehhx6yyutv/uZvMuctWrRIe/zZZ5+dOf64446zyuehhx7KnDdp0iT2xhtvDNQ1TZgwwbpt3HrrrZlj3/a2t1nlyRhjN910U+bcTTbZRNk+2liPY71tqLjssssyaWyzzTbafsFEG+txLLeNf/mXf8kcd9hhh1nll/Doo49mzici9uc//1l6bBvrcSy3jSLMmTMnk8e//du/aY9vYz0OYtsgIrb11ltbnYt6HFvX5NI2TBx++OGZdK+++mqvdNpYj4PYNkzXVDUQZkAhRkdH2QEHHJBp5Mccc0zQPJ5//nk2ffr0TB6nn3668by//du/zZxzyimnGM955JFH2Pjx49NzhoeH2eOPP64959FHH2VDQ0PpOePHj2ePPvqoMa9TTjklU75TTz114K5p0003tW4b69atY9tss03m+P/93/815skYY0cccUTmvJNOOkl7fNvqcay3DRX77LOP04vchrbV41huG/fdd1/muKGhIbZkyRJjfgmf+tSnMufvvPPO2uPbVo9juW34cs0112TS32uvvdi6deuM57WtHgexbRARmzFjhvG8kHkOYj0O4jW5tA0ToYQZxtpXj4PYNmyuqUogzADGGGOXXHIJe+6555zOWbt2rbTz+9nPfiY9/uGHH2b/+Z//6ZTH8uXL2dve9rZM+uPHj2dPPPGE8dwnnniCjRs3LnPujTfeqDz+jTfeYAcffHDm+A9/+MNW5VywYEHmvIMPPlirwN5www25a3ryyScH6priOLZuGwnf//73M8fvsMMO7IUXXtCec+GFF+byNU3O2lSPaBtyfve73+XSfPrpp53SkNGmehzrbaPT6bCddtopc+w+++zDXn31VWM5b7755lydfP7zn9ee06Z6HOttI8FGVEm4/vrrM3UxPDzM7rvvPqtz21SPg9g2kj+XyTfqcWxck0/b0BFSmGlTPQ5i27C9piqBMAMYY4ztueeebOLEieyEE05g//mf/6kd2L7++uvs3/7t39huu+2W6/j+9m//VnneHXfcwYiI7bHHHuz888/XKpuvvvoqu/TSS3OWMkRuq+Kf/vSnM+eOGzeOXXrppTnT56VLl+Y6hqlTp1qLVc888wzbeOONM+fPnDkzZ8K3evVqdskll+Q6rc9+9rOtuKZdd92V3XvvvVbX5NI2EjqdDjvssMMy522//fbs1ltvzR3717/+lZ155pm5fM4880yr60PbaFfbEPnYxz6WSWPu3LnOaahA22hP27j++utz5+y4447sJz/5idSt7cUXX2T//M//zIaHh3PX+Ne//tV4fWgb7WkbjDG2yy67sE996lPsl7/8JRsdHZUe88ADD7Djjz8+l/5XvvIVq+tKQNuo75qSP5fJN+pxbFyTT9t47bXX2LJly6R/opfABRdcoDzWRhhuSz0OYttwuaaqgDADGGNdYYZvrFEUsR133JHNmTOHzZs3j51wwgnsqKOOYnvuuaey03vve9/LVq9ercwjEWb4vw033JDNnDmTvf/972cnnngiO/roo9m+++6bGzQnf3//93/vdF0jIyNs7ty5uXSmTZvG3vWud7F58+axfffdl0VRlPl9/Pjx7M4773TK64477siY4iX1+La3vY196EMfYu985ztzZthJvY2MjDT2msR0iLp+/tOnT2fTp0/P+fz7tA2eF198MbcKTtT1Dz7qqKPY/Pnz2WGHHZarayJi73jHO6xXSNE22tc2ElavXs2mTJmSSedHP/qRUxo60Dba1TY+8YlPSM+fOnUqO/LII9nxxx/PPvjBD7K3ve1t0nfLhAkTrC220Dba1TamTp2anrP++uuzgw46iB1zzDHs+OOPZ3PmzGEzZsyQpn/WWWc5XVcd9TiIbcPnmvg/V6sI1ONgX5Nv27j66quNfZDN37JlywaiHgexbbheU1VAmAGMsbww4/I3ceJE9sUvfpGtXbtWm4dMmLH9mzRpEvvXf/1Xr2t77bXXckGldH/Tpk1jN998s1deP/3pT40vB/5v/vz5bOXKlY2+pm233bb0tiHy9NNP5yxnTH8LFixwDgKJttG+tsEYY9ddd10mrU033dQrHR1oG+1pG51Oh33pS1+SirWmvxkzZrA77rjD6drQNtrTNnhhxuZv4403Ztddd53XdTGGtlH1NYnx5XzcVVCPg3lNRdpGlcJM0+txENuG7zVVAYQZwBhj7De/+Q0766yz2EEHHWS1WkVEbJdddmHnnnsue+aZZ6zyeP7559nnPvc5NnPmzFzUbtXfTjvtxM477zy2YsWKwtf4wx/+kB144IHKvKZMmcI+8pGPKHflsOWFF15g//AP/5Azr+P/DjzwwCAr/FVc029+8xv2iU98QupWFqptyOh0Ouwb3/iGVjQcGhpis2fPtg4SrAJtw4+62sbs2bMzaX7yk5/0TssE2oYfdbSNRx55hH3sYx/T1mHy95a3vIVddNFF7LXXXvO+RrQNP6psG+eeey7be++9pfFp+L83v/nNbOHChewvf/mL93XxoG1Uc03igp9vHJGxXo+DeE1F2kbVwkxCE+uxKIN4TWUSMcYYAcCxbt06euihh+iPf/wjPfvss7Ry5Upat24drb/++rTBBhvQNttsQ3vvvTdtvPHG3nl0Oh167LHH6IknnqBnn32WXn75ZVq9ejVNnDiRNt54Y9p8881pv/32o0033TTglXVZtmwZ3XffffTcc8/RqlWraLPNNqMZM2bQzJkzafz48cHyWbt2Ld1999301FNP0fPPP0+TJk2iLbfckvbee2/adtttg+VDVN01rVq1iq677jr6wx/+QE899RQxxmj99den7bffnrbddtsgbUPGo48+Sg888AA999xz9Nprr9HUqVNpq622okMOOYQ23HDDYPmgbfhTV9uoCrQNf6puG4wxevjhh+n++++nF198kV599VUaHh6mjTbaiLbcckt629veRtOnTw+SFxHaRhGqahuvvvoq/e53v6Nly5bRihUr0vHGlltuSXvuuSe95S1vCXRFWdA2/KnymurIcxDrcRCvqQ4GsR4H8ZrKAMIMAAAAAAAAAAAAQE3EdRcAAAAAAAAAAAAAYKwCYQYAAAAAAAAAAACgJiDMAAAAAAAAAAAAANQEhBkAAAAAAAAAAACAmoAwAwAAAAAAAAAAAFATEGYAAAAAAAAAAAAAagLCDAAAAAAAAAAAAEBNQJgBAAAAAAAAAAAAqAkIMwAAAAAAAAAAAAA1AWEGAAAAAAAAAAAAoCYgzAAAAAAAAAAAAADUBIQZAAAAAAAAAAAAgJqAMAMAAAAAAAAAAABQExBmAAAAAAAAAAAAAGoCwgwAAAAAAAAAAABATUCYAQAAAAAAAAAAAKgJCDMAAAAAAAAAAAAANQFhBgAAAAAAAAAAAKAmIMwAAAAAAAAAAAAA1ASEGQAAAAAAAAAAAICagDADAAAAAAAAAAAAUBMQZgAAAAAAAAAAAABqAsIMAAAAAAAAAAAAQE1AmAEAAAAAAAAAAACoCQgzAAAAAAAAAAAAADUBYQYAAAAAAAAAAACgJiDMAAAAAAAAAAAAANQEhBkAAAAAAAAAAACAmoAwAwAAAAAAAAAAAFATEGYAAAAAAAAAAAAAagLCDAAAAAAAAAAAAEBNQJgBAAAAAAAAAAAAqAkIMwAAAAAAAAAAAAA1AWEGAAAAAAAAAAAAoCYgzAAAAAAAAAAAAADUBIQZAAAAAAAAAAAAgJqAMAMAAAAAAAAAAABQE/8/kLe4BNJbzOYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# the pixel size is assumed to be square. option three means doing square buffers\n", + "#TODO add support for non-square pixels\n", + "buffer = occurences.buffer(((crop_size / 2) * pixel_size_x)-(pixel_size_x/2), cap_style=3)\n", + "\n", + "# for developement purposes\n", + "fig, ax1 = plt.subplots()\n", + "show(raster, ax=ax1, cmap='viridis')\n", + "buffer.boundary.plot(ax=ax1, color = 'slategrey', linewidth=0.5)\n", + "#occurences.plot(ax= ax1, color = 'red')" + ] + }, + { + "cell_type": "markdown", + "id": "6d2b6c58-e6ee-44aa-a616-f9393a4f6541", + "metadata": {}, + "source": [ + "- we also need examples of areas that are different from known occurences" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "50210619-9c4b-4f51-8b69-356446b07350", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "\"\"\"TODO current implementation just assumes that mineral occurences are sparse, and thus hitting one in random is unlikely.\n", + "Different measurements of similarity such as mahalanobis or som or distance in pca feature space could be considered to be added as options.\n", + "It would be good to have variability in the examples that should not include mineral occurences, altough it is likely that random sampling produces good enough results. Some spatial stratification stregies could also be explored\n", + "\"\"\"\n", + "\"\"\" Current implementation assumes that there is only one polygon in the bounding geometry\n", + "TODO create multi-polygon implementation\n", + "\"\"\"\n", + "\n", + "# Creating oversamples\n", + "# Finding examples of areas that should be different from the known locations.\n", + "x_coord, y_coord = random_points_in_bounds(bounds.geometry[0], random_point_count, seed)\n", + "df = pd.DataFrame()\n", + "df['points'] = list(zip(x_coord,y_coord))\n", + "df['points'] = df['points'].apply(Point)\n", + "random_points = geopd.GeoDataFrame(df, geometry='points', crs=occurences.crs)\n", + "\n", + "# Finding the geometric difference of bounding polygon and known occurence buffer, to find suitable areas for the random points\n", + "buffer_df = geopd.GeoDataFrame(buffer, geometry=buffer.geometry)\n", + "diff = bounds.overlay(buffer_df, how='difference')\n", + "\n", + "# Filtering out the points that fall outside the area or inside known occurencses buffer\n", + "sjoin = geopd.tools.sjoin(random_points, diff, predicate=\"within\", how='left')\n", + "\n", + "points_in_poly = random_points[sjoin.index_right==0]\n", + "# It is probable that some points are at invalid locations and thus there are not as many as wanted, so they are added until required amount is achieved\n", + "while points_in_poly.shape[0] != random_point_count:\n", + " x_coord, y_coord = random_points_in_bounds(bounds.geometry[0], random_point_count - points_in_poly.shape[0], seed)\n", + " df = pd.DataFrame()\n", + " df['points'] = list(zip(x_coord,y_coord))\n", + " df['points'] = df['points'].apply(Point)\n", + " random_points_add = geopd.GeoDataFrame(df, geometry='points', crs=occurences.crs)\n", + " sjoin = geopd.tools.sjoin(random_points_add, diff, predicate=\"within\", how='left')\n", + " added_points = random_points_add[sjoin.index_right==0]\n", + " points_in_poly = pd.concat([points_in_poly, added_points])\n", + "\n", + "random_buffer = points_in_poly.buffer(((crop_size / 2) * pixel_size_x)-(pixel_size_x/2), cap_style=3)\n", + "\n", + "# Random occurences inside the square buffers\n", + "random_points_per_patch = math.ceil(random_point_count / len(buffer))\n", + "for i, geometry in enumerate(buffer):\n", + " if i == 0:\n", + " x_occ_coord, y_occ_coord = random_points_in_bounds(geometry, random_points_per_patch, seed + i)\n", + " else:\n", + " temp_x, temp_y = random_points_in_bounds(geometry, random_points_per_patch, seed + i)\n", + " x_occ_coord = np.concatenate((x_occ_coord, temp_x))\n", + " y_occ_coord = np.concatenate((y_occ_coord, temp_y))\n", + "\n", + "occ_df = pd.DataFrame()\n", + "occ_df['points'] = list(zip(x_occ_coord,y_occ_coord))\n", + "occ_df['points'] = occ_df['points'].apply(Point)\n", + "random_occurences = geopd.GeoDataFrame(occ_df, geometry='points', crs=occurences.crs)\n", + "r_occ_buffer = random_occurences.buffer(((crop_size / 2) * pixel_size_x)-(pixel_size_x/2), cap_style=3)\n", + "# for developement purposes\n", + "fig, ax = plt.subplots()\n", + "bounds.boundary.plot(ax=ax, edgecolor='black', linewidth=0.5)\n", + "r_occ_buffer.boundary.plot(ax=ax, color = 'green', linewidth=0.2)\n", + "#random_occurences.plot(ax=ax, markersize=0.1, c='slategrey')\n", + "random_points.plot(ax=ax, markersize=0.5, c='darkred')\n", + "points_in_poly.plot(ax=ax, markersize=0.5)\n", + "buffer.boundary.plot(ax=ax, color = 'black', linewidth=0.5)\n", + "random_buffer.boundary.plot(ax=ax, color = 'darkblue', linewidth=0.3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "90906719-c4a7-4e82-a004-0dd01677fa70", + "metadata": {}, + "outputs": [], + "source": [ + "patch_meta = raster.meta.copy()\n", + "patch_meta['height'] = crop_size\n", + "patch_meta['width'] = crop_size\n", + "patch_meta['count'] = 10\n", + "\n", + "# feature patches\n", + "for i, feature in enumerate(r_occ_buffer):\n", + " bbox=[feature]\n", + " out_image, patch_meta['transform']=mask(raster, bbox, all_touched=True, crop=True)\n", + " out_path = os.path.join(out_image_dir, str(i) + '.tif')\n", + " with rasterio.open(out_path, \"w\", **patch_meta) as dest:\n", + " dest.write(out_image)\n", + "\n", + "# Non-occurence patches\n", + "for i, feature in enumerate(random_buffer):\n", + " # without this the real feature patches will be overwritten\n", + " i += len(r_occ_buffer)\n", + " bbox=[feature]\n", + " out_image, patch_meta['transform']=mask(raster, bbox, all_touched=True, crop=True)\n", + " out_path = os.path.join(out_image_dir, str(i) + '.tif')\n", + " with rasterio.open(out_path, \"w\", **patch_meta) as dest:\n", + " dest.write(out_image)\n", + "\n", + "label_patch_meta = label_meta\n", + "label_patch_meta['height'] = crop_size\n", + "label_patch_meta['width'] = crop_size\n", + "label_patch_meta['count'] = 1\n", + "# label patches\n", + "for i, feature in enumerate(r_occ_buffer):\n", + " bbox=[feature]\n", + " out_image, label_patch_meta['transform']=mask(label, bbox, all_touched=True, crop=True)\n", + " out_path = os.path.join(out_label_dir, str(i) + '.tif')\n", + " with rasterio.open(out_path, \"w\", **label_patch_meta) as dest:\n", + " dest.write(out_image)\n", + "# non-occurence label patches\n", + "for i, feature in enumerate(random_buffer):\n", + " # without this the real feature patches will be overwritten\n", + " i += len(r_occ_buffer)\n", + " bbox=[feature]\n", + " out_image, label_patch_meta['transform']=mask(label, bbox, all_touched=True, crop=True)\n", + " out_path = os.path.join(out_label_dir, str(i) + '.tif')\n", + " with rasterio.open(out_path, \"w\", **label_patch_meta) as dest:\n", + " dest.write(out_image)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "c28b4304-fbf3-4a70-93b3-346da7db0143", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "diff.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "dde46d30-9555-43cb-b575-f48d3603b047", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "204" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "01ad42c8-f31b-43fb-8188-afd32b7a79f1", + "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.11.4" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tests/unet/mini_unet.py b/tests/unet/mini_unet.py new file mode 100644 index 00000000..578ffa28 --- /dev/null +++ b/tests/unet/mini_unet.py @@ -0,0 +1,61 @@ +import numpy as np + +from eis_toolkit.unet.mini_unet import train_and_predict_the_model + + +def test_the_mini_unet_with_uncertainty(): + """This is the test with uncertainty.""" + random_images_training = np.random.randint(0, 100, size=(1000, 32, 32, 3)) + labels_training = np.random.randint(0, 1, size=(1000, 1, 1, 3)) + random_images_testing = np.random.randint(0, 100, size=(1000, 32, 32, 3)) + labels_testing = np.random.randint(0, 1, size=(1000, 1, 1, 3)) + + prediction = train_and_predict_the_model( + x_train=random_images_training, + x_test=random_images_testing, + y_train=labels_training, + y_test=labels_testing, + epochs=2, + batch_size=32, + is_uncertainty=True, + list_of_convolutional_layers=[32, 64, 128], + dropout=0.2, + pool_size=2, + up_sampling_factor=2, + output_filters=2, + last_activation="sigmoid", + output_kernel=(1, 1), + data_augmentation=False, + regularization=None, + uncertainty_coefficient=0.2, + ) + assert prediction.shape[0] != 0 + + +def test_the_mini_unet_with_no_uncertainty(): + """This is the test without uncertainty.""" + random_images_training = np.random.randint(0, 100, size=(1000, 32, 32, 3)) + labels_training = np.random.randint(0, 1, size=(1000, 1, 1, 2)) + random_images_testing = np.random.randint(0, 100, size=(1000, 32, 32, 3)) + labels_testing = np.random.randint(0, 1, size=(1000, 1, 1, 2)) + + prediction = train_and_predict_the_model( + x_train=random_images_training, + x_test=random_images_testing, + y_train=labels_training, + y_test=labels_testing, + epochs=2, + batch_size=32, + is_uncertainty=False, + list_of_convolutional_layers=[32, 64, 128], + dropout=0.2, + pool_size=2, + up_sampling_factor=2, + output_filters=2, + last_activation="sigmoid", + output_kernel=(1, 1), + data_augmentation=False, + regularization=None, + uncertainty_coefficient=0.2, + ) + assert prediction.shape[0] != 0