diff --git a/docs/experiments/Deep Q-learning in XOR-XNOR.ipynb b/docs/experiments/Deep Q-learning in XOR-XNOR.ipynb new file mode 100644 index 0000000000..7bf4732d26 --- /dev/null +++ b/docs/experiments/Deep Q-learning in XOR-XNOR.ipynb @@ -0,0 +1,763 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Implementing Deep Q-Learning with XOR/XNOR data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This notebook shows an experiment using rl-keras deep q-learning to classify XOR/XNOR data. It is adapted from Mordred Yuan's [notebook](https://github.com/NeuroDataDesign/ProgLearn_2021-2022/blob/main/Mordred_Yuan/Week%209/rl_classification.ipynb) testing the performance of deep q-qlearning on the CIFAR 10 dataset." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Installing a Deep Reinforcement Learning for Tensorflow 2 Keras package." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "!pip install -q git+https://github.com/wau/keras-rl2.git" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Importing necessary libraries, as well as the XOR/XNOR generation functions from xor_xnor_functions.py." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import tensorflow.keras\n", + "from tensorflow.keras.models import Model, Sequential\n", + "from keras.layers import (\n", + " Input,\n", + " Dense,\n", + " Conv2D,\n", + " MaxPooling2D,\n", + " Flatten,\n", + " Activation,\n", + " Embedding,\n", + ")\n", + "from tensorflow.keras.optimizers import Adam, SGD\n", + "from tensorflow.keras.layers import LSTM\n", + "from keras.preprocessing.sequence import pad_sequences\n", + "import numpy as np\n", + "import os\n", + "import gym\n", + "from gym import error, spaces\n", + "from gym import utils\n", + "from gym.utils import seeding\n", + "from sklearn.metrics import classification_report, confusion_matrix\n", + "import random\n", + "from multiprocessing import Pool\n", + "from functools import partial\n", + "from keras.layers import *\n", + "from keras.models import *\n", + "from matplotlib import pyplot as plt\n", + "from sklearn.utils import shuffle\n", + "from itertools import combinations, product\n", + "\n", + "from proglearn.sims import generate_gaussian_parity\n", + "import xor_xnor_functions as fn\n", + "\n", + "import argparse, os\n", + "from PIL import Image\n", + "import keras.backend as K\n", + "from keras.backend import set_session\n", + "from rl.agents.dqn import DQNAgent\n", + "from rl.policy import LinearAnnealedPolicy, BoltzmannQPolicy, EpsGreedyQPolicy\n", + "from rl.memory import SequentialMemory\n", + "from rl.core import Processor\n", + "\n", + "from random import sample\n", + "\n", + "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Gym Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We're using Gym to simplify the training. Gym is a toolkit for working with reinforcement algorithms and allows an easy way to test deep q-learning algorithms. We are defining a custom Gym environment for classification here because there is not an included classification environment in Gym. [This](https://towardsdatascience.com/beginners-guide-to-custom-environments-in-openai-s-gym-989371673952) is a helpful article about custom Gym environments and how they are used." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In our custom environment, we define init, seed, step, my_metrics, and reset. \n", + "\n", + "- Init just defines the parameters the environment uses. Init is pretty straightforward, the most interesting part is the action space. In the XOR/XNOR dataset there are only 2 possible classes, so we set the action space to being 2 discrete classes. In teh CIFAR-10 dataset it would be 10.\n", + "\n", + "- Seed is a function that is used if we want to reproduce experiments using random number generators. It's not used in the XOR/XNOR experiment.\n", + "\n", + "- Step is the function that takes an action in the q-learning algorithm. This function defines the behavior at each time step and adjusts the q-matrix according to if the sample is correctly identified. We set the reward to 1, and the punishment to -1. It also adds the g-mean and f-measure to metrics at the end of each training run.\n", + "\n", + "- My_metrics calculates various metrics for a run. The metrics we are interested in are precision, recall, accuracy, g-mean, and f-measure. In addition, this function prints out these metrics for each run, as well as an overall confusion matrix, g-mean, and f-measure. \n", + "\n", + "- Reset simply resets the environment to zero so that it can be used to train again." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class ClassifyEnv(gym.Env):\n", + " def __init__(self, mode, trainx, trainy): # mode means training or testing\n", + " self.mode = mode\n", + "\n", + " self.Env_data = trainx\n", + " # print(type(self.Env_data))\n", + " self.Answer = trainy\n", + " self.id = np.arange(trainx.shape[0])\n", + " # print(self.id)\n", + "\n", + " self.game_len = self.Env_data.shape[0]\n", + "\n", + " self.num_classes = 2\n", + " self.action_space = spaces.Discrete(self.num_classes)\n", + " # print(self.action_space)\n", + " self.step_ind = 0\n", + " self.y_pred = []\n", + "\n", + " def seed(self, seed=None):\n", + " self.np_random, seed = seeding.np_random(seed)\n", + " return [seed]\n", + "\n", + " def step(self, a):\n", + " self.y_pred.append(a)\n", + " y_true_cur = []\n", + " info = {}\n", + " terminal = False\n", + " if a == self.Answer[self.id[self.step_ind]]:\n", + " reward = 1.0\n", + " else:\n", + " reward = -1.0\n", + " if self.mode == \"train\":\n", + " terminal = True\n", + " self.step_ind += 1\n", + "\n", + " if self.step_ind == self.game_len - 1:\n", + " y_true_cur = self.Answer[self.id]\n", + " info[\"gmean\"], info[\"fmeasure\"] = self.My_metrics(\n", + " np.array(self.y_pred), np.array(y_true_cur[: self.step_ind])\n", + " )\n", + " terminal = True\n", + "\n", + " return self.Env_data[self.id[self.step_ind]], reward, terminal, info\n", + "\n", + " def My_metrics(self, y_pre, y_true):\n", + " confusion_mat = confusion_matrix(y_true, y_pre)\n", + " print(\"\\n\")\n", + " print(classification_report(y_true, y_pre))\n", + " conM = np.array(confusion_mat, dtype=\"float\")\n", + " TP = conM[1][1]\n", + " TN = conM[0][0]\n", + " FN = conM[1][0]\n", + " FP = conM[0][1]\n", + " TPrate = TP / (TP + FN)\n", + " TNrate = TN / (TN + FP)\n", + " FPrate = FP / (TN + FP)\n", + " FNrate = FN / (TP + FN)\n", + " PPvalue = TP / (TP + FP)\n", + " NPvalue = TN / (TN + FN)\n", + "\n", + " G_mean = np.sqrt(TPrate * TNrate)\n", + "\n", + " Recall = TPrate = TP / (TP + FN)\n", + " Precision = PPvalue = TP / (TP + FP)\n", + " F_measure = 2 * Recall * Precision / (Recall + Precision)\n", + " print(confusion_mat)\n", + " res = \"G-mean:{}, F_measure:{}\\n\".format(G_mean, F_measure)\n", + " print(res)\n", + " print()\n", + " return G_mean, F_measure\n", + "\n", + " # return: (states, observations)\n", + " def reset(self):\n", + " if self.mode == \"train\":\n", + " np.random.shuffle(self.id)\n", + " self.step_ind = 0\n", + " self.y_pred = []\n", + " return self.Env_data[self.id[self.step_ind]]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This defines the network that wil be trained." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def get_image_model(in_shape, output):\n", + " model = Sequential()\n", + " model.add(Dense(500, activation=\"relu\", input_dim=2))\n", + " model.add(Dense(100, activation=\"relu\"))\n", + " model.add(Dense(50, activation=\"relu\"))\n", + " model.add(Dense(2, activation=\"softmax\"))\n", + " return model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Processor Function" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class ClassifyProcessor(Processor):\n", + " def process_observation(self, observation):\n", + " img = observation.reshape(INPUT_SHAPE)\n", + " processed_observation = np.array(img)\n", + " return processed_observation\n", + "\n", + " def process_state_batch(self, batch):\n", + " batch = batch.reshape((-1,) + INPUT_SHAPE)\n", + " processed_batch = batch.astype(\"float32\") / 1.0\n", + " return processed_batch\n", + "\n", + " def process_reward(self, reward):\n", + " return np.clip(reward, -1.0, 1.0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### XOR/XNOR Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Get_xor_data and get_xnor_data generate the XOR/XNOR data for the experiment using the functions in xor_xnor_functions.py" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def get_xor_data():\n", + " X_xor, y_xor = generate_gaussian_parity(1000)\n", + " fn.plot_xor_xnor(X_xor, y_xor, \"Gaussian XOR\")\n", + "\n", + " return X_xor, y_xor" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def get_xnor_data():\n", + " X_xnor, y_xnor = generate_gaussian_parity(1000, angle_params=np.pi / 2)\n", + " fn.plot_xor_xnor(X_xnor, y_xnor, \"Gaussian XNOR\")\n", + "\n", + " return X_xnor, y_xnor" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This function is used to divide the XOR/XNOR data into training and testing sets. Input training percentage as a decimal, e.g. .8 for 80% training. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def divide_train_test(X, Y, train_percentage):\n", + " test_percentage = 1 - train_percentage\n", + "\n", + " len_train = int(train_percentage * len(X))\n", + " len_test = len(X) - len_train\n", + "\n", + " full_indices = []\n", + " for i in range(len(X)):\n", + " full_indices.append(i)\n", + "\n", + " train_indices = set(sample(full_indices, len_train))\n", + " test_indices = set(full_indices) - train_indices\n", + "\n", + " X_train_subset = []\n", + " for trix in train_indices:\n", + " X_train_subset.append(X[trix])\n", + "\n", + " X_test_subset = []\n", + " for teix in test_indices:\n", + " X_test_subset.append(X[teix])\n", + "\n", + " Y_train_subset = []\n", + " for triy in train_indices:\n", + " Y_train_subset.append(Y[triy])\n", + "\n", + " Y_test_subset = []\n", + " for teiy in test_indices:\n", + " Y_test_subset.append(Y[teiy])\n", + "\n", + " return (\n", + " np.array(X_train_subset),\n", + " np.array(X_test_subset),\n", + " np.array(Y_train_subset),\n", + " np.array(Y_test_subset),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Function to run either XOR or XNOR" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Use this function to train on a set of data. To run XOR, specify 'xor'. To run XNOR, specify 'xnor'. The default is 'xor'. You may also specify the percentage separated into training. The default is a 70-30 training testing split." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def run_training(x_train, x_test, y_train, y_test):\n", + " # Generate data\n", + "\n", + " in_shape = x_train.shape[1:]\n", + " num_classes = 2\n", + " mode = \"train\"\n", + " env = ClassifyEnv(mode, x_train, y_train)\n", + " nb_actions = num_classes\n", + " training_steps = 120000\n", + " model = get_image_model(in_shape, num_classes)\n", + "\n", + " INPUT_SHAPE = in_shape\n", + " # print(num_classes)\n", + " print(model.summary())\n", + "\n", + " memory = SequentialMemory(limit=100000, window_length=1)\n", + " processor = ClassifyProcessor()\n", + " policy = LinearAnnealedPolicy(\n", + " EpsGreedyQPolicy(),\n", + " attr=\"eps\",\n", + " value_max=1.0,\n", + " value_min=0.1,\n", + " value_test=0.05,\n", + " nb_steps=100000,\n", + " )\n", + " dqn = DQNAgent(\n", + " model=model,\n", + " nb_actions=2,\n", + " policy=policy,\n", + " memory=memory,\n", + " processor=processor,\n", + " nb_steps_warmup=50000,\n", + " gamma=0.5,\n", + " target_model_update=10000,\n", + " train_interval=4,\n", + " delta_clip=1.0,\n", + " )\n", + " dqn.compile(Adam(learning_rate=0.00025), metrics=[\"mae\"])\n", + "\n", + " dqn.fit(env, nb_steps=training_steps, log_interval=60000)\n", + "\n", + " env.mode = \"test\"\n", + " dqn.test(env, nb_episodes=2, visualize=False)\n", + " env = ClassifyEnv(mode, x_test, y_test)\n", + " env.mode = \"test\"\n", + " dqn.test(env, nb_episodes=2, visualize=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Train model with just xor and just xnor. It outputs the performance of the model, as well as a confusion matrix." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjUAAAI1CAYAAAAuFQuYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd5jlVNnAf9nsbJldehMMRfiIUqUL0psgRZAqPREQlSKdgIIUwQhK7ygJTaogSm/SQUAUAYEIghB6kWV3Zmd2J5Pvj/fcvXfuJLll7tQ9v+e5z87em5yctHPe81YjTVM0Go1Go9FoRjvjhrsDGo1Go9FoNK1ACzUajUaj0WjGBFqo0Wg0Go1GMybQQo1Go9FoNJoxgRZqNBqNRqPRjAm0UKPRaDQajWZMoIUajUbTNIZhbGIYRqo+Jw93fzQazdyNFmo0Yx7DMBYxDOMgwzCuNwzjFcMwPjYMY7ZhGNMMw3jTMIy7DMM4zTCMtYa7r5qRg2EYv6wQ2K6rcx/bMIxOtc80wzCWLNh2PcMwzjQM41nDMN4zDKPbMIxPDcP4l2EYvzMMY2fDMMw6jxtW9LX6020YxoeGYTymzmn5eq+BRjPaMHTyPc1YxTCMqcApwA+B9jp3i4BfAL9P0zQZrL6NFQzD2AT4i/rvKWmanjxsnWkxhmFMBJ4HVlRf7ZCm6Z8Kth8HPA6sp746ME3T32ZsZwPnAVvX0Y1XgcPTNL23Rl9DYL862gPoAX6RpukpdW6v0YwatFCjGZMYhvF/wB+BlSq+/ifwIPBv4FNgErAosCawCfClim1XT9P0H0PQVc0IxjCMdYAnARP4AFgpTdPPcrY9GjhL/fe+NE23ythmY+A2YAH1VQdwJ/AY8BEwH7AKsDOwhNqmFzgyTdPzCvoZUhZqLgAeqvh5ArAMsBvyrJc4vKhNjWY0ooUazZjDMIyFgeeApdVXLwGHpGn6SME+44AdgGOBddFCjUZhGMavkOcC4Lo0TffO2OZrwN8RQfkLYOU0Td+p2mYF4FlgivrqTuAHaZq+l9HeROBE4KcVX++bpuk1OX0MKQs1bpqmYcY2BiJ0HaW+mgZ8OU3Tjqw2NZrRiPap0YxFrqIs0DwBfLNIoAFI07Q3TdPbgG8ChwIzB7eLmlHEzxEzEMBehmFsX/mj8nsJEYEG4KgMgWY8cBNlgeZWxJzVT6ABSNO0O03TnwFHVnx9iWEYyzZ7EqmsYI8H3ldfzQds1Gx7Gs1IRAs1mjGFYRjfBLZR//0C2CNN0+n17p8KF6Zp+lpO++MNw9jKMIzfGIbxuGEYHxmGMcswjOmGYUTKYbPmRGEYxlvKifOtVmxrGMYShmGcahjGU4ZhfKYcof9nGMa/lYPo2YZhbFiw/yaGYVxlGMZrhmHMUOf0gWEYLxmG8SfDMI42DOPLOfsVRj8ZwoaGYZxuGMZDFU6xHcpR+4ZqQSGnnZMrjrWJ+m5dwzCuMwzjv6rNjwzDuMMwjHr8VeoiTdMuwEXMQACXGYaxQMUmRwHfUH/fl+VHA3wPWFn9/T6wfz0+W2mangPco/47BfAa7H51e7OBpyu+sgfSnkYz4kjTVH/0Z8x8kNVwqj5nD0L7f6lov+gTAhMK2nlLbfdWHccs3BbYFpheR58+z9h3HHBFned0bsb+m1T8fnJO/4I6278bmLfgOpxcse0miGkmKWjvlBbf+zMr2r5GfbcC0KW++wJYKmffZyr2PabB465TsW8XsEDGNmHFNk6N9q6v2Pa4wXwf9Ud/hvozHo1mjKB8Bjav+OraQTjMZGAG4nD8N0Tg6AIWR5yS90JW1PsBnwOHD0If5qC0JzcAU9VXdwL3A+8hAsuiwNeBLRFzQzWHAgeovz9HrtnfEX+LdsTB9BvApgPo5mSgG3gEmdzfQBxkF0E0BfsACyLRQFcDO9bR5g+APYB3kQn9ZcQhdmtgd8AATjIM45E0TR/Ka6RBTgK2B74G7G0Yxh8Qc85E9ftRaZq+Xb2TYRjz09dBN9MvJo80TZ8xDOM14KvqWBsCuVFYdVDpPN+vvxrNaEYLNZqxxArI5AjQiUQ7tZqfAk+maZrpc2MYxglI1NUGwKGGYZyXpumbg9CPEntQFmiOS9P0zJx+GapP1Ryo/p0GfCNN0yhn/3mBZv05LgJ+mKbp5zlt/xTR5uwK7GAYxsZpDR8o5LzvB76b9nV0vcowjGeAs9X/j6ZvJFDTpGnaZRjG95Gw7XGIVrBN/Xx/mqZX5Oy6HmVT/5tpmn7QxOGfQoQaEL+vpoQawzC2Q6KrQMxpzzTTjkYzUtE+NZqxxBIVf7+dpmlPqw+QpumDeQKN+v1TylEo4xDNzWDyfxV/502qpMJjBfs/kifQqP2/SJuMBkvT9LE8gUb93gHsj2hvQDQ3tfgU2D3Njtw5j7IGYjPlpNsS0jR9CjhH/bck0EynrO3Kwqr4O9NXqw4q9+vn21SEYRhthiQF/BkiiJW4OU3TN5rsj0YzItFCjWYssVDF35/X2tgwjJ6CLKwPN9uJNE3/g+Q0gbID6WDRWfH3Srlb1d5/ecMw2gq3HERSceZ+Uf23nmt2dZqm/8tpqxcxdYGYa5YbeA/7cGfV/y/MMjtVsGDF3583eczK/RbK20gRVD7LwCxEKDoNMQWCaJsOzGtAoxmtaKFGo2kQwzDmNQzjR4Zh/FlFJs2oFoooJ/KzitpqAfdX/H2rYRhHGIbRyDFL+68APGAYxvaGYUwu2qEZDMOYaBjGPoZh3KIisr4wDKO36pqtqzavp/9P1/j93Yq/F8jdqkEMw5gEXFL1tVsVDTWS6QIcYJO0gahAjWa0oH1qNGOJTyv+nr+O7Xeir2C/KHBZ0Q6GYWwK/J6+2YeLmLfO7ZoiTdO7DcP4PbAn4nh7NnC2YRj/RjLhPgrckabpRzlNHIf42iyB5CzZCOg2DOM5JMfPQ8BDqYQCN4VhGKsAfwDqrTlUzzX7pMbv3RV/T8rdqnFOo+zb8jFyzb8EnEt+mYLKDMTzN3ncyv0+zdtIUZlReBzle7szci1+imiy3mqyLxrNiEULNZqxRGUis6UMwxhf5FeTVtXxMQxjmaLGDSkEeCdlFf5rSBjyv5GJq6ti88uRCa+ugoQDZG9kEjuCsglqefXZD0gMw7gJic55v3LHNE3fMgxjdSR77d7I5DkRWF99jgU+MgzjDOD8NE0bSkFuGMaCwAOIwAjwDnAHkszuY8rh0CA1t1aiPg1yb+1NWothGOtSTob3HhJq/SjiQL2vYRg3pGl6d8auccXfzeaFqdzv3dythOfTNP1j1XcXGoaxAaKZWx641zCMNdM0ndFkfzSaEYkWajRjiVcQ4WJBJBx5FSQ8uVUcT1mgOR04MW+SNwwj12m3CQonedWH3wG/MyTj7AZIhMxmyARmItFCGxiGsXaaph9W7f8REql1JLCW2ncDtf+8iEByLiJw/KDBvh9CWaC5CjggT9BUUVAjEmV2Cijfi4PSNH3XMIwDkPB+A0nKt1KGWedpRAgbByxrGMZi1fegDtar+PuJxs8A0jR93DCM4xBHahv4FXBwM21pNCMV7VOjGTOoyf3Biq9aHXm0hfr3I+CkAoFmHvo6h2ZRMo9MKNpIhWLXamsOaZr+J03Tq9M0/WGapjaSH6Uk2C0JHFOw7+w0TZ9K0/Q3aZp+F9E0fb+irwcqU1IjlK5ZD1JAsSgibemC34abU5H8NADXpml6B0Capn+hbLJcknJByzkoh+a/VXzVr3ZUEYZhrF1x7G6k+GWzXIRUogf4gSE1qzSaMYMWajRjjXMr/j4gK7X/AFhM/fumirDJYwtqv1ufq38XrhF1tDLlekENk6bp8/QNkc7KVZO376w0TQPER6PE+g12oXTNPi0K61YmsEUabHtIMAzjG5TNTh8CP6na5FjKIeQ/UH5X1Zxf8fcRhmFkJULM4+SKv68uuo61SKU0w+nqv+MRYU2jGTNooUYzpkjT9EngLvXf+YDrDcOYWrBLI5TCn5dVGpR+GFLc8IQ62vqX+rcNyRCbx2H1dy+Xtyr+bsbkPJD9S9dsUaXByuOkBtsdEgyplh1Q9o36UZqmlY6/pXD0Uni0AfzWMIz2qqZuQLIeg+SZuUI9K7WOfxjlWmYdgN/wSfTn98B/1d+7GIbRTCoAjWZEooUazVhkP8qD9obAk0YdRSaprYV4Vv27CBnlD5TG5QrEL6UW91T8fZqaPKvbO4DipG4YhnGSYRhbGoZR9C7/uOLvFyr2XdwwjF8bhvGVgvbb6RvV80LetjmUrpmBOAJXt28YhnEa9ZVGGA5ORcLdAW5IpZJ7P9I0vQ8RfkAch8+o+r0H2I2ykLcrEoK/eFZ7KgT+FPpqHn+kciANCNWXX5cOhVQh12jGBNpRWDPmSNP0E8MwtgBuB1ZEHIYfMQzjBSRKKEIcig0kkdmKwFb0zc6bFWFyAVJDCSRsehPgXiTEdnlgX/XvX9S/RflW/gi8ro75TeBZwzB+h0TVfAmZ5DdD/CeWo2+25Eo2A04BPjAM417gH0jiv1Io73coa4K6KZcPAIlyOgo4yjCMZ9WxXkFMY/Mhoct7Us5g+xiStK0RLkb8ckzgMMMwVgNuVX1cUrW/OqK5mknfGknDimEY6yDXByRS69AauxyJPEdLII7XNynNIQBpmv7LMIxtkHs/P3JvNjcM48/Idf0YccxeBQm/Ll33XiRyraGaUTX4HaIdWwTR1qycpulLLWxfoxkehqOKpv7oz1B8kJpIZyNq+3qqRKeIiWBvwMhp84wa+z+OTBRvUaMKNzKBf1bQ1tO12qL+quEfA9+q2nfpBq7LQ8BCGcffpGKbk3PO80cUV9P+FyLcPVz6Lqedkyv22aTGva9725z9J6pnodTGrnXut33FPq8AkzK2+SoiDNdz3V8Fvl3HccOKfZw6+3pCxT43D/f7qj/604qPNj9pxixpms5I0/RIpNL0j4CbES3Np0g0zjTgTSTXzCnA2mmarpSm6bVpmmZGNqVpegLwbSRfzSfAbOB9ZNI/EJlAP66zf39DVuUXIFqbLuB/SPHCg4EN62jrO0gSwfMQgeoD1adZ6u8HkaKOy6diIqk8/n8RYeJgxM/iRXVNEsRM8m/gemD7NE03S6WuVcOkaXoJYtq7uaJ/HyHJAY8E1krT9PVm2h5ETkY0eAB/SNP05np2StP0z8B16r9fo6+Tb2mb19I03Qq5Jr9GIqM+RK7L/xBBJgR2AVZOs3PftIKLgC/U3zs3Edmm0Yw4jJyxW6PRaDQajWZUoTU1Go1Go9FoxgRaqNFoNBqNRjMm0EKNRqPRaDSaMYEWajQajUaj0YwJtFCj0Wg0Go1mTKCFGo1Go9FoNGMCLdRoNBqNRqMZE2ihRqPRaDQazZhACzUajUaj0WjGBFqo0Wg0Go1GMybQQo1Go9FoNJoxgRZqNBqNRqPRjAm0UKPRaDQajWZMoIUajUaj0Wg0YwIt1Gg0Go1GoxkTaKFGo9FoNBrNmEALNRqNRqPRaMYEWqjRaDQajUYzJtBCjUaj0Wg0mjGBFmo0Go1Go9GMCbRQo9FoNBqNZkyghRqNRqPRaDRjAi3UaDQajUajGRNooUaj0Wg0Gs2YYPxwd0CjGW6swFse2AiYCdwVu/7nw9sjjUaj0TSDkabpcPdBoxkWrMCbCPwe2AZIgF5E0D86dv2Lh7NvGo1Go2kcbX7SzM2cA3wbmARMAeYBJgNnWYG3xXB2TKPRaDSNo4UazVyJFXhTAQcRYqppB342pB3SaDQazYDRQo1mbmVpoKfg95WGqiMajUajaQ1aqNHMrXwETKjxu0aj0WhGEVqo0cyVxK7/MfAY2dqaDsTfRqPRaDSjCC3UaOZm9gM+AGao/6fq7/uAYLg6pdFoNJrm0CHdmrkaK/Dage8B2wHTgauBh2LX1y+GRqPRjDK0UKPRaDQajWZMoM1PGo1Go9FoxgRaqNFoNBqNRjMm0EKNRqPRaDSaMYEWajQajUaj0YwJtFCj0Wg0Go1mTDB+uDug0Wg0Gs1YJ3LMeQAP2B8pnvs34CQ7TB4ezn6NNXRIt0aj0Wg0g0jkmO3AM8BywKSKnzoBxw6Tm4elY2MQbX7SaDQajWZwcYCv0FegAWgHLoscs23IezRG0UKNRqPRaDSDi4MIMFmYwDeGritjGy3UaDQajUYzuEws+C0FJgxVR8Y6WqjRaDQajWZwuQ3oyvmtDfjrEPZlTKOFGo1Go9FoBpeLgBlAUvV9B3CGHSYdQ9+lsYkWajQajUajGUTsMPkYWAd4CJgFzAQ+RUK8zxjGro05dEi3RqPRaDRDROSY8yF5at63w6Rac6MZIFqo0Wg0Go1GMybQ5ieNRqPRaDRjAi3UaDQajUajGRNooUaj0Wg0Gs2YQAs1Go1Go9FoxgRaqNFoNBqNRjMm0EKNRqPRaDSaMYEWajQajUaj0YwJtFCj0Wg0Go1mTKCFGo1Go9FoNGOC8cPdAc3Ywgq8BYCDgN2AHuBa4MrY9WcMa8c0Go1GM+bRZRI0LcMKvCWA54D5gcnq607gXeAbsev/b5i6ptFoNJq5AG1+0rSS84FFKAs0AO3AUsDJw9EhjUaj0cw9aKFG0xKswJsIbE+2SXMi4AxphzQajUYz16GFGk2rmAwYBb9PGaqOaDQajWbuRAs1mlYxDfio4PeXhqojGo1Go5k70UKNpiXErp8CJyKOwdV0Aj8d2h5pNBqNZm5DRz9pWooVeEcBpwBJxdeHx64fDFOXNBqNRjOXoIWaEYIVeEsBWwCzgbtj1/9kmLvUNFbgtQPrIYLNU7Hrdw9zlzQajUYzF6CFmmHGCjwTuBzYExECUiSC6LTY9c8Yzr5pNBqNRjOa0D41w8/PgO8Bk5AIoanq7xOswNt1ODum0Wg0Gs1oQpdJGEaswBsPHIkkqKtmCnAScPOQdkoz12MFngF8HxG4lwY+Ay4GTtemRI1GM5LRmprhZRGgreD35YeqIxpNBb8CzgOWQXIPLQQcDdxnBZ4eMzQazYhFD1DDyzSK78GnQ9URjQbm1O86jP7JEicDawBbDXmnNBqNpk60UDOMxK7fCdwKzMr4eSZwwdD2SKNhG6S6ehZTEf8vjUajGZFooWb4OQR4E5hR8d0M4Gng7GHpkWZuptaYoP3wNBrNiEULNcNM7PqfAV8HDkK0NtcDuwNbxK6fpcHRaAaT+wAz57cZwC1D2BeNRqNpCJ2nRqPR9MEKvCuQvEmVUXndwCvA2rHr55mnNBqNZljRmhqNRlPNQcBpSCj3bMS/KwA20gKNRqMZyWhNjUajyUSFb08FOrUwo9FoRgNaqNFoNBqNRjMm0OYnjUaj0Wg0YwIt1Gg0Go1GoxkT6JwTGo1GM5cQOeYCwMZAAjxsh8n0Ye6SRtNStE+NRqPRjHEixzSAU4BjKGcwbwNOsMPk3OHql0bTarT5SaPRaMY+PwSOBCYB86rPZOD0yDF3Gc6OaTStRGtqNBqNZgyjtDTvAV/K2eRVO0xWGMIuaTSDxpj3qbECzwDWBpYB3gCej11fS3IajWZuYR5goYLf7aHqiEYz2Ixp85MVeMshqd0fAq4AHgH+aQXe0sPaMY1Goxk6ZgK9Bb9rZ2HNmGHMCjVW4E0EHgOWB6YgNuQpwArAo1bgjXktlUaj0dhhMhspRDo74+du4HdD2yONZvAYyxP7d5EU79WCmwksAGwL3D7UndJo6sUKvDZgG+ArwH+Au3S5grFJ5JhfRXxeXrXD5MNBOMQRwPrAIsjiDqADeBM4eRCOp9EMC2NWUwOshdiSs5gHWGMI+6LRNIQVeKsB7wLXAL8CrgXetQLv68PZL01riRzTjhzzBeB5ZJH138gxb44cc0qNXRvCDpOPgZWBoxEz/IPAIcDaOleNZiwxljU1HwJdSAhjNZ3Ax0PbHY2mPqzAm4xMOgtWfD0B0Tw+ZAWeFbv+zGHpnKZlRI45H/AkojmuXGBuB/wB2LqVx7PDpAO4VH3GHEoQXAcxs/1Vmd00cxljWaj5PXBqzm/jgBuHsC9zPcpp+wfAV4EXgctj139neHs1YtkFEWKqMdT3OyOaG83oZj8kV0y1xnwSsHnkmBcAF9lh8uqQ92wUoULWjwVOQgQaA+iNHPPHdphcP6yd0ww5Y1aoiV3/XSvwfgKcg0wE44Ee5KE/KHZ9rakZIqzA2we4DLkHbcgK9Egr8HaLXf/OITj+ZOBnwI+A+RE/glOBq0doeP9KiFYmi6nAikPYF83gsSXQnvPbeOR53T9yzEuAo+0wGYnP6kjgIESgqb6Wv40c82M7TB4Yhj5phomx7FND7PqXA+sBVwFPAFcCa8euf82wdmwuwgq8LwOXIyvSNvX1RGQAutEKvDy/p1YdfzxiyjkCUfMbwLLAReRr8oabtxETaRadgNZwjQ0+BYoEFRN5bw4CdhqSHo0yIscch5R/yBIO2xm577hmkBizmpoSsev/EzhguPsxF7NPwW8pYmoJBvH42wGrIJNDJVOAo63AuyB2/Y8G8fjNcANwVo3fNaOfK5Hnv5ZT8BTEvPKHQe/R6GNRJF1HHjogZC5jTGtqNCOCpch21gZZSS0+yMffg3xTTg8tdsZsBbHrfwbsjmhlutTXXer/u8Wu/7/h6pumpTyG+PbNqGPbZQa3K6OWGRTPY/VcW80YQgs1msHmefIHlg7g5UE+vlnj9xH5DsSufwfwf8AvEKf3XwD/NxQ+SJqhQfnIHIA4DD9BsSnqjdIfkWMuHDnmIZFjnhY55q6RY2Y5lc8V2GEyA8kYn2T83I1owzRzEWPe/KQZdvJMKb1IevbBnqRvAbYiW1vTBtw/yMdvmtj13wdOH+5+aAYPJdjcCtwaOebNwPaIz1klHYAPEDnmbkCICEDtyDt0XuSYG9th8u+h6vcI44fAs0j+sZJWuBPxTdPvz1yGrtKtGXRUIrl7kEHYRFZVnwLfil1/UAdiK/AmAH9DymVUThadQBC7/iGDeXyNpl5U3poHgK8h70oPIvz/2g6TEyPH/D/gBfo7xfYC/wWWm1sjpCLHXBj4MeKjNAsR/AKVm2dEEznmZMRMvjtyL68DbrbDpHtYOzZK0UKNZkiwAs9EQliXBiLgkdj1i4rstfLY8yHaor0R7eQ04JfAuUPVB42mHlTOlY2AjRHB+xY7TN5Sv/0GOJRyFGElM4Bt7DB5bIi6qmkBkWMuADwNfJm+5SteBzZQ5jVNA2ihRjMmUOUD9gFKq93bYtefVbXNeJTKfoTmp9Focokc8x7ElJrFDOAwO0wGM5JQ02IixwyAPemfbLMbSbx41ND3anSjhRrNqMYKPAM4H/g+Yl4yET+DT4D1lV+KRjPqiRzzHOBgsjU104Ht7TB5ZGh7pWmWyDHHI/ctLzr0CztM5hvCLo0JRmTkh0bTAN8FXMr+OiAOg0sitmmNZqxwMeJnU00KfAY8OrTd0QyQyRRHZ86jzJGaBtBCjWa0cxTZycvGA+upjMYazahHRTcdiOQsKuUvmoEU5916bnUSHsXMQDTKebyh72njaKFGM9pZquC3bsQBT6MZE9hhch2SiO944EykhMJSuujl6EMJLL9AHIOr6QB+PrQ9GhvoPDWalqKKR+6hPgaSp+a62PVnDtIhX0EElyw17USkeKVGM2aww+RD4Nzh7oemJVwCWMCRSCh6ijgNn26Hye+Hs2OjFe0orGkZVuDNDzyJaE8qwxPfBdYdjPT+VuBtBvyZ/rk7uoE7YtffpdXH1Aw+kWMugQirb9phUqSi12hGPZFjLgRshuSpedAOk8+Ht0ejF62p0bSS04Hl6BueOAVRl5+J+AO0lNj1H7IC72fAGUhSvzZgNpKk7PutPl6zqDw9ayL9e34QNVejmsgxvwRcC6yPCKYTI8e8A/i+HSbTh7VzGs0gYYfJp8DNw92PsYDW1GhaggqtnkF/jUmJLmDKYCW7swJvUWAnpBzCY8AzIyUXjRV43wUuR8xhKeLL9vPY9c8e1o6NMCLHbANeRSLXKsOWu4HngA214+TIJXLMVYHvIM/33XaYPDvMXdLMhWihRtMSlCYiK9y0RC/QHrv+XJX62wq8jYC76S/sdQJHxK5/+dD3amQSOeauwO+QkPxqOoAt7DB5emh7palF5JgmcDWwI6KlNZBFzMPATnaYzMrdWaNpMdr8pGkJsesnVuC9CXwlZ5N35zaBRnEa2dqrduA0K/B+W4/2ygq81YH1kBIPf45d/4vWdnNEsCXZAg3IZLkhklJeM0REjjkJ2A5YAngJ+EuGtuwwRKCpfM6nAJsiETw/HfyeajSCFmo0reQk4DL6T+IdwMlD3puRwdoFv80LLAbkZj22Am9e4A7EH8dAtGGXW4F3UOz617ayoyOAaYhfVFZCstmIeXNEoXyAfgF8DzEvPgMcb4fJqE+EFznmJsAfEXNSG/LsfRA55uZ2mLxdsekx5Avuh0SOeaIdJrrGmmZImCuEGpWAbWfE3+Jx4LGR4m8xmrECbx5gE2QSeiR2/WutwFsSOBGZhEBW2L8ChqQmjfLt2Qs4DvHN+K86/vXDdM87kcyhWYwjO0dFJdcA69C3wjjAZVbgvRK7/t8G2L+RxLVIpeWsCXIccOvQdqcYVRn6eWBhyj5A3wTujhxzdztM7hi2zg0QJazdQf/Ell8B7o8c82sVGpsvFTQ1GdG+TWt9LzWa/oz55HtW4B2HVDz9FXAqcCfwjAo/1jSJFXhHAB8iE9FVwHtW4J0C+MDiwL7AfsDiseufNoQCxYXApcDKSHHLVREn3eFyyg0QR9dqeoFHi8xIShj/Fv0FGpB6Mce0pIcjBDtMXgCupL+g1wmcoPKzjCSOAhakfy2mduDSUZ7i/kCyNWYmYoraoOK7ovvSRR0atsgxV4gcc7vIMVdsqJcaTRVjWlNjBd4WiEmksmDYVGSiC5C6QZoGsQJvN0TlPpm+WoijgPdi178MuH0Y+rUiUgeqWjMyBTjICryLY9f/9xB363QkImTJin51IxP3D2vsa6ttswrejQNWa00XRxSHAX8Bjkau2auAb4fJg8Paq2z2IFvgBJgf+BqSHHI0sib5hRbHASsiUYYAvwFOob+GbSZwiR0mSd5BIsf8MnAbsBKi3W2LHPMVYEc7TOLmu6+ZWxnTQg3gka3KngBsbQXeorHrfzTEfRoLnEr2dZ0C/NwKvMuHydSzK9kVjEGe9ROV4LM8sro8B7g8dv3cQXegxK7/uRV4awI/ABzk2bsNOC92/Q9q7P4e+ecD8E5LOjmCUCaNWxlhpqYciooRpjV+H+n8ByVkZPyWIAk1S5yDmEi3RYS8cYh27UlkUZmJqlL9GCK8Vs5FXwceixxzeTtMiiIqNZp+jHWhxi74rRuxD2uhpnGWL/htYcSGPhzROZPIf6bHI86cpUF6XuDXwJZW4O08mEJY7PozEPNXQyaw2PVfswIvQjSL1abiDuC81vRQ0yR/RGovZU38XYxeLQ2Iw/8PyT63WcC9pf8oTcxukWOugURBmYg/ztM18gpti4wX1e/seGAhYHtkAYAy5W0AHAAsCjwE/M4Ok88aPTHN2GasCzX/RVYBWUxkDK50Bxsr8CYgg1qearoXUTsP5BhfQe7b67Hrv9fArg8AhyAmxmoMsn0fvoWECo/UaJVdkBXvFPVJEIE8QPzDRjSRY64NrAV8Ctxhh0nnMHeplfwK2BsRkCuFzk7gqCKzy0jHDpPXIsc8CjEtjUfenU7k+dvODpPZGfs8jzhO18s65Ifwz6N+v00JNJcg17odeZc3Ao6PHHNDO0xebuCYmjHOWBdqzgJWp78H/2wkAqqRCXPIsAJvGcT/4vXY9fsNHsOFFXhtwH3kq9VnATc122cr8CzgJsRXZBYw0Qq8B4B9Ytf/vI4mHgLeRjRJlQLMbNXnLMf4dmBPRqhQE7v+G1bgLYf0cQvgEyCIXX9EZ2uNHHNBJOngSsh17wHGRY65lx0mQ+5vNRjYYRJHjrkO4py+qfr6HeA4O0xuqbV/5JjtSOTQR3aYjLhwdTtMLokc835EO7I0ktU5VCn9W8GnqFIYGb91q98BtkEEmspxvB0ZI/8QOeYKOtO0psSYziiswnvPBA5GJrnxwHTgA2CDkeZPYwXeusgKfGlkRdSD2KQvHAkh6Fbg7YWopauFxBJvAuvErt9wAUIr8CYC/0YipyqF7VnAP5CCmLnXwAq89ZGK4PMjg2SpBlSC1IH6OvnapWtj19+n0T5r8okc8y9IePOEqp86gTXtMHl16Hs1eESOORl57qbVmmDVtucgEYK9iMB9K/BjO0zmmtBnVbT0DbLfyy5kcfIe8FdE25dFB7C+ipzTaMa2pkZNgsdYgXclstKdD4ms+HPs+iPKAc0KvBUQ80m1wOCrfy+o2n4h4NvI5P1Q7Pr/HfROyootT6ABOK0ZgUaxM7AA/Z/JCchqf13gqawdlSbj3oy+JcD1iMYuL5/LdMT+XzdKWN6Y8urxT8CtlRmTrcBbHlmFvxq7/seNtD/aiRxzeeAb9BdoUN8dTu3Ir1GFHSYzqd/s+iekYGdllN7OwEqRY64xtySqs8PkPWXiOgsRbMYhQl4XkmfKBCLys5SDLFwWG+SuakYRY1qoKRG7/itIQriRzIlkr1jagVOswLu0ZNZRuXdORjQ5BmBagXcjsP9gRvIgWpAidqH5JHubke0LAzIRrk+GUGMF3uKIySpL2JqECLPHAvcAW9N3IpmFZPO9rd5OqhpXtyCmoCnI9d8OONUKvPUQwewmxEl9NmJCuw04IHb9Qn8S1fbqyPk+H7t+V739GmGsiFzbrKSD44E1hrY7IwflY7Qe/a/NRGBZYCvEbDdXYIfJxZFjPocIuisgIfznAM+qv5ehOJ/aJOBfg9tLzWhirhBqRgmbke+r0gb8H/CKFXg70T/3Dkg48zsMrvD2T4pzoxRFRc3BCrxJiHNuG/BE7PrTgM8QIS3rmZxFRjSVFXhfRQSd+QsO14WYnr6HrAgPQFaDbcBdwIGx6zdScO8gxLm4MqR9KmIyDBCN0oL0HYi/i2gJt81r1Aq8HZAkgZNV/0wr8E4Gzh4JpscGeY/8ZzlF/J7mVjYnP7fNPIj/yJALNZFjmsPl2GyHyTPI4qOyPxsgSf6KwuK7gHt1PhtNJWM+o/AoomhVbiK+CCBCS16dlZ8oZ97B4poav9c0PVmB5yBh9LcAvwfetwLvVKTKb55wUfI5qOZ3iLBQlLnVBD6PXX9W7Po/QUJIvw4sGrv+TrHrN+r0eDjZ178N0QS10/+9mgRsqoSwfliBtwFyLRZFJrb5EEHpDCQZ3WjjOeQeZwljnVSZUucyusmvZp9Qfs8Hncgx2yLH/FnkmJ8APZFjfhQ55rGq6vZwswLF81MvkuNm76Hpjma0oDU1I4cQsSNnmaDerPCZyZwYFSZiXx6slcuDyCp8iYzfeoCnrMAbV1112gq8cYgm6nvAPvT3tTgaOe9LEF+LkikpRfwUjq701VE+LVsiIZ+1BPP/Ac9bgdcOmLHrT0cSizVLLft9lsADMgivB7yW8VteJe8JwDlW4L0Qu/7DdfdwmLHDJI0ccwckomwCfUPRz7fD5JHBPL6KSDoAcTp/GAhGUD6T2xBhNYtu4Mah6IQKky6ZUUvP3iJIVe01kHd1OImRZyaLBLjODpP9hrA/mlHCqNbUWIE33gq8RVTkzGjnHORFrtTYJIh3//4V3xVpQ0zg85b3TKHMILsgtVyqw7bHI1lz767UFimfl5cRTcv3yXYenYwINrsj5RceQgSP+4FtY9e/pKK9LyPRTLdRnG0X1c8TEOfwacCnVuC9bAXeVvWcbw5Rjd/zTEW95CckLKrkbQB3jLZaZXaYvIQ4eJ4A/AGpx7WBHSYnDNYxI8ecFDlmgAgy+6N8nYA3IsdctYn2jMgxV44cc93IMYsc5IvamKJqGu0YOeaCdpi8BZxP//pWHcAtKtfLULAOYgqrFqbbge2buV4t5n7ytdezgF8OYV80o4hRKdRYgWdagfdzZIJ/G/jcCrzACrz5hrlrTaP8StZCop3+i6TxvxFYO3b9pys2vZBsFfUsJKprUPNdxK7/FJLh9gP6T+BTkayflZEttyP+QPNQbCYyAAsxr/0PWWVvANxpBd65VuBNVBqahxDVdJ5GpMTbwA7AxUiirlICsRWB26zA26bG/nmcRvb170QyzOaZD8YhzspZ1DI5GIxCNbsdJtPsMDnfDpNd7DA5xA6Tvw/GcZTw8VPEL8tBhOTS2NaOmPP+2EiBSeXT8R/gaeS+fRQ55qmRY9Y9ZkaO+WPEDHcdUvT13cgxfaR8y/6Ij9p0xCH2J0jdsqHiO+RXj5+AZPMdNlR5hO2QhUDp/ZiFCDpHjbWUAJrWMVrNT78FdqPvxLYHsJYVeGuMpIR1jaAEm1PUJ49zEUfVb1COFpqBCBk/Gsz+VTAd8f/ImiTagUOBC6zAWxkJx27kOZtMOdV6iR8gxQHPB5aqo71ORH3+E8oZSKuPcb4VeHcjTps7I9qSD5CcNbnmu9j1/6SqkZ+CSiin2r8L2Au4QrVXWtmXQlS/XxD9FABHFpxXOyKMzZVEjtmGaPkOQaLLngFOt8OkFKZ/MlJMNW+SNhDTytpq31rH+xoiyFRrZ45E7ufJdbTxHcQxvVr4PgT40A6TcxgiU1MOBvmLjKLfhgw7TJ6JHHMZJJ/P2shi70o7TN4Y1o5pRjSjLvmeSqH/L7J9T2YATuz6fxjaXg0tykdlK2T1PgkxxdwyVCHAyuH1WfJTnP8vdv0FVaRWgKSRHyhdiACRZb4qMRsxvx0Yu/7tVuBNKzh2F6J+/wMyec2D+DSkwBGx619a1Bkr8BZGVrOTgAdj14/U9wZiojsM8T36G/Cr2PX/ZgXeVGA/JNLDQJyDQ0SAexXJa5PFTOCnseufU9SnsYgqengPElVWLSjugfh5fURtzd00YF87TP5UxzGvQgTULIfZDmDRWuUeIsf8O/mRgp2IVqkNObdf2GHyeq1+tQplStsJMQlmXbdOJKHdP4aqTxpNqxiNmpotkUEti6nIyzqmhRrliHs3w5fP4m2KQy1fVP++U2O7RsjLBlwiRTIKuxW5eoqSmBlINNeilE0VJd+ss63Aeyp2/dwspcpxuV9OHuV3dLP6zMEKvAURLcHilCeSrwNHIP4NqyLXNes8U2pHno1Vdka0kpVak3HINQwRrV49mtmJiG9XPWxK/nObIObPvGSOJYo0a+2Un4G9gZ1UDaNBzYqrBMQzEfPwbORZ66V/3ap7tECjGa2MRp+aHvKdMVPqG+BGLFbgbWUF3l+swHvPCrynrMDbWa3+Rwyx689EIpXyfEtOU38/B7xLsXDRKgzg9qrkg7eSHz4b01egqaQNMaG1kl8hRTorV8bt6rszVdbhLRDTXsmJtFN9dh1ApubRzoHkJ2U0kSSHtQTnbuDxBswW0wt+G1/j9xL1Vqk3kfO7rM7tc4kcc2Hl2JynnbwUybM0mXIRTgMZNxPEl+1XiMN+y4gcc0LkmGMhmEMzChiNmpq7gItyfutA0uKPSqzA8+ibh2ZxxMFwQyQ/ymAe20QS+P0QSR73F+Dc2PXfzNnFQ3K+7I4IkinyPB0Ru/4DIFoLK/C2R/JJtCOD92xE0Lgc8ZOYSNmkNFP9vxlhu1QS42OkWGmK+L3siDiKVk58nYjm48ictsZTHDrfEEoo3Zts01kbsKcVeAfErv+EKuq5J+KL9Dri49OqAoKjkTwTZ4mPENNSnuAzCzGV7ho55jcRf5i1EMHkUuBcVeKgksuRsOss00yM1CirxRWIFq6WhhFEsFg9csyF7TBpWHiNHHNRRGu4OSLATYgc8/fAIaVzixxzceQZrBYuDOR9+CXip9Qyf4TIMddCfADXVf9/BjjCDpO/tuoYGk01o86nBsAKvNOQAaNSJd2JRCpsWZ0nZTRgBV5RcbeZSKHIlwbp2CYSubMJ5clhNjJAfktFPOXtuyRSB2kmcG9W9JXKEbM7UuDwA+Cq2PVfV9XIj0Icn79AJpPNEF+Vyns7CxF06hHCZyAh31vFrt+hjnEGktV3PJI75XhkZfoI2eUVeoDfxq7fEsdrFeLeTb7zZS8wucHMxqOCyDEXRrItv2uHyQdN7H8y+fmbuhHH8VWQekql+kEgz8yHwK52mPw1csydEEF2MuX7MBMxSW1gh8mcul2RY04CHqdvlF2P+vwQuLqOopVTEGHeprheWomZgN1odtzIMScgPoZL0TfFQRfwqB0mW6ntavm3PW6HyYaNHLtGv9agvJippBPYTAs2msFitAo1BrKaPRHJhfEZkqX016N1YrAC71BE9ZsVwdEDnBW7/qDk+LACbw9kZZk1+L4NLDNUqfqVE/QPkbw1iyMRDxci16aWM2iJLkTDcWDBcQxE+FmR/uaLmcCaqmZYS7AC73VguZyf34ldf6lWHWskoEwgv0ME1C5EQ/AI4qz7UQPtLIY4UVdnju4ErrXD5CC13arAzxCt5gzEnHOxHSadKnrqQyRyqpoO4DA7TK6sOu4kJIHfj5H7Nk6dh4H4im1Xy5ylTC67IdE7E4CFkOctS7h9D1iy0WKWkWN+D3l3szRVncA37TB5IXLMrZFoqzyh5m47TJpNc5DVr4cQ36QsnrDDZINWHUujqWRUCjVjEWV6Oo18bcTFsesfPEjHfhSZDLKYAWwSu34tx8hBxQq8rREH8InU53w8E9EMHY1ogmYhpRjOil3/f6rNpZGJdkFkUpiJTDgHxq5/XYv7/z1kks8SzGYhmrK9WlU9XiU93B5Zvd9fis4aClQ+mKeQ6J9Kc8ds4E1gJZWHpN72VkByvXxNtdGGCC3HFLWjcspsgeQ7OYD8kO8n7TBZP2N/EzEBLknfZ64XMXstU6nhqeM8irQXJyLFGzdQbV8E3FGHRihAcvNk0Q0cZ4fJeUrA+ohsoWYG4Nhh0pIAC3XdZ5NvRu4FJtlhMqr9HzUjk9HoKDxWeQwZhLKYDjwwiMdeqOC3hOwV7pASu/49yORyNPAP8utEVfI4kq9mEeDLiA/N31UkEqr0xHJI+O7JwDHAkq0WaNSxbgB+mtPvCcjE+9OBHscKPEOZZ98EzkZypfzDCrzrrcAbKh+69RGfoGr/jTZE+7ZdI43ZYfKKHSZrIFqOTZGQ6iNqCDTLIubcWxDNX5FvS54G8NvIu1EtRI9DtJo71XcGgsoWvA0iKM1EtESfIFrmUxEn3tWRdA3XA1fVkTBwBvmO+D0oZ34lfB2g/l8pKHUgZvs/NnIudVAkjOmVtGbQGI2OwmOVJ5EMo2vQf3X7AfDnQTz2w0iF7ayyAxMRIaJulA/JPMC0qmikARG7/meI4+G5qtL3S+SbdCbRX80/EckFcyzi6Izq359p8fW1Am8RxPSwMPB34K7Y9c+1Au9oRMCqph043Aq80wboE/Y9xN9sIn2fo+8gE+eglSmoYCPytSLzIA6tf2y0UVVi4K1a2ylNwQOIn0mthVsXkvU6izXId0CeBwk1bygwwQ6TRyLHtBGtzAQka/G79Df9loSm68lI3aDMY0siz62bsT+IMDbn3OwwuTlyzLcRrdCalM32v6us0K1MfosCb9lhUk+kV/U59kaO+SCSfiNLKHtsMLQ0SrO2IDDdDpMhydmlGXlooWaEoCKFtkayJW+PaG0mIgLHvq0yS+RwNpIUrlqomQn8vt5wYivwpiCagf2QZ6vLCrzzgVNa3f/Y9buswDsdGZSrB/RudfwsM9VExMfBq/dYyon7u+o4jwJ/LfIxsgJvH8TpOUUm9+nAZ1bgbUR2MdASpSSA0+rtWwY/I3uCawcOsQLv50OQcbtUGyzr+vcwsPOrh00RYbKWQNOLaC4uzvn9U+QdyNLkdCN+Og2jTEpvAkSOuTH5WqQpiJZpjlATOeZywB2IKQ7kGfsMER4q+9kJ/Lzaf0k56GZqyiLHtJBoy/WR82tTiQgPb8TMpjgaWahNoSzYpKpfeVGHTaGE2GMQh/LJgBE55q3AoXaYzM2Rg3Ml2vw0gohd/4vY9XdDaiBtjjjoflvlMBnM474BbI2sGGcgk043skr8cT1tKAffB5FVYzuyCp0XGcB+3/peA5J87Vpk4inlL5qBaHCKVmp158ywAu94xIxxFlJs8wHgUZUdOGv7lZBQ4UmUtRXzIPf0DooLks5S/R8IeZorEEFv4QG2Xw9FvhmzGfy0CytQvGDrQZ7vlxDh4r3IMWdGjnlt5JhLVmx3I/ljZIo8ewNlQYrNMYuW/ogccykkWutrFb8biIksRc7nE+AJYBc7TH5dbydUtNbTiJZtIvLuTkYWKA2bY+0weRHxabsXMWEnSJHKDQahBth5wEmImXwS5dInTyuNlmYuQgs1I5DY9T+NXf9vses3tRJs8piPI+r6zRGzyZKx6++fFU1mBd78VuBV5w/5FuJHUT2ItAPbWYG3wiD0OY1d/4eIKv1k4HTED+IbiKCTRS9SFLMmVuB9G/FzKQkobcjKcy1EE5PFYWTnozGBZYGbyE5a2AVc0QJzXVFkkcEgVnEvYYfJu4ipq/o8O4DL7DCpN7Nvs8TkJ12chThs74MUWl0TuTeTENPd85FjLgGgcsYchJxHqb1E/f8oO0zeaUFfnye/9Ec3oqktcQb5Ank7cIUdJovYYbKBHSaNZhvfA5if/sLgZGCbyDGXb7A97DB50Q6TbyPvTZsdJlu1OlOxyr9zAP21aRMQU3NLEwlqRj7a/DQKUALBHsjq6SHgzlb6qpRQvhy5Bf+swNsK8WlZTv3/WeCQ2PX/jvhs5PkfjEM0QS0Lka7o02bIBLoGouUYj4Rqe0gBzOrBrovigqGVeGSbciYB37UCb0Hl51PJyuS/Vwmyil4GyQlUypnSgfgttcLf5Xzk/KrPuxu4WWWDHnTsMPll5JjPI9fwq4gvzK+ROmWDzV3kCzUJonW7n/7XyERCx49DiqFih8nV6jwOQ+7ta8D5rdI22GHy38gx70Hej+oFwWz6JhrdoaApA1mMnN9kV7YlP59OLxIdWU/SwX60MqFfBptRLvlQzVSkDttVg3h8zQhDCzUjGJVL5SzEBNSG3K/vA+9ZgbfhYJulqvrybSSSpHIi+CZiitkcqWOURykNe7PHng+JCJkIPBy7/jvq+z0QH6RSnyYjTrLfQar6jkNWt5OQCestJFy73iSGdsFvs5CkctVCzSuIpijLn2QcEvmyPeK3sDNyT/8IPNSiXEDnIT4lm1AWmqYj+X4Oa0H7dWOHyb2I+WFIscNkVuSY2yHFIk3k+ZiFPIOHIJN0XvHQNmR1/5OK9l5CKsUPCOXIuoLqx2sVOWn2QhIDboMIn+MQE/CuDSbjG4jAOgN5T7Mce0u+Ry0hcszJyDnvg5zr9UhCw2ZMr7V89XTY+FzGiBFqVGba+YHXh2o1OQrYAXEUrIwkmQcxY1yNmFoGHSVcZWk9UN89RO1nqanoIivwDkGK8PUgA26bFXi/RwS9izP6NBHRhOwXu/4lVuAFiGapS4VwN8I75E9+ExAfpGouQBJDVkf/9CJmkeeU8PK4+jREqQ5YgQC0OpKQ0qQ84P8R2H8IHIRHDHaYPBk55jJIDpc1Ed+Z39lh8qZyti0SIFtulo8cc09Ey1kSNKdFjvkjO0z+pCp+76wcdb+OOCj/NUPD8WdEY5tFitRja5arKDvDVzOeFhXPjRxzPiSH0VIVx1oDODpyzG/YYdLoQu0+sqM2QQS1Vvg9aUYRwy7UWIG3IjJBr4RK2GQF3nnAiaOx3EGLOYbsQaYN2MQKvC/Frt9w6vkmWBgJH82ilLMjj04gKKghlYvSDmVlWd4duQZ5k0874rB8iYq6eq3RYyt+g/hfVJ/fbERj1M9/JXb9F6zAOwKZwAxEyJqODLDbNauNsQJvLUS42whIrcC7Gzgmdv3XKrZZHnHWrjYD7oSk0vebOfZoxQ6Tz5DIvmreRHyLsoT0HvJDvJsicswdkay/lcebAlwfOeZ2dpj8RfU3RgTfPG5C/H6ytCkvIaUimuVBRKu2Ff2fdwPR/LXiupyGLMoqfYPaEUf63yCRiXVjh8n/VCmNE+nb75nAiwzsmmhGIcPqKGwF3pcQH4M1EBPBPMiDeTjygM/tLF3wWzcyEAwFCfl1i4pIEcGs2YrXPydfO7QzxavtCVbgbWoF3glW4B1sBd5iTRz/JkTg7qRsPpuOmLFyB9/Y9S9D8v78HDgHcTb9iooyaxgr8NZFMh9vimhgxiM+EM9YgVdpIvPIzg8zBThB5fbBCrx5rcD7oRV451qBd4gVeMOeXHEoUWafQ+lvUkkR/6bTW3zIs8h/jusSNFVum2vIfg+fANZqJEtzNUortBvij1b9Xk0Cfh85ZpGJuV4csp2d24DdIsdseKFth8mvkEXMy4iZ8SPkmm9WuiaRYy4QOeZekWPurzR1mjHKsJZJsALvF0hBwywnry5giVJK+7kRK/D+gqyQsugClhoqvxor8P6OpL1vhFnAl5q9h1bgfUF+leaSU3DeszMNmcwnq34YiGbjwib68XXEpDQf4mB6+2DmDbICbyEkPPWd2PW7rcB7BvERqqYXuC12/V3Ufm+Tr1H7AnmWpiCOtCUNWynD7E6x69/XyvMY6Si/m19TDoN/CKkD1axmL+sYU4H/ka8V77XDpGbZj8gxQ6TKdta205AsywOqe6eKj75D9juVADfZYbLnANo3KF4g9QALNOlbU3TcQxEtZ6l0Qykp4T66VMPYY7jNT9uSn3iqGxnI56qBtopfIdcgK7nc3UPpKIz4sDxA3yrHJe1F3qD8EQMLIf6UfKGmDVmNHUnfVXCi+rMA5VDZkvbiV1bg/T12/Sca6UTs+i8gK9hBxQq8pYArkfo/s9V3l5AvTI6jbyK1ImfO8YgQdCd9r2np2t1qBd6Sc9Miwg6TO4A7IsecB5g9SFloZ1OsUaw3qd2W5L9n45DcNf9soF9ZrKj6kzUmm2QL1nVjh0kaOWaERMNl8RGiKWsZqpCnj5xT5Xltjwg6R7TyeJrhZ7iFmqIHeBwt9LgfjcSuf48VeGcg9mKQSboTqVrsFu1rBd6yiPnjO+qrPwEnN+PbovrylBV4GyLRRJsiwsOtiB3+UrKL9P10gBE9FyA2+Oq2ZyMak5OQEhI/R/xITMQJcV2yVdyTEXNYQ0LNUKAivP6K1KkyKff/YOor4AkiEJ1MtgnqfcQJNc/kbCCagAvqPNaYIasUQOSY7Yjv1hqIn8s1dpi810Tb3ZFj3o+EbFdf+x7g5jqbKhK4JgMPq0RzzwI/s8PkMXUOB1Eu5nkPcJYdJnljwEfkO92Wfh8oJyJJM6vf6Q4kA3KrTQcnZhwL9d0PIsf8qXLU1owRhluouQJZhWY5ms5CMlzO1cSuf4YVeFcj+RamImn6H6uRpt9G8s2UJnqQEModrMDbAJnclkXqztxab7RZ7PrPI4Nz9fF6kHwapWMZiEBzdT3tFnABEub6DcrOrzOQMOoD1TW4yAq8S4HF1G9rINE+WUKNgaxGRyIukoeoWoBpJ3+ln9I3ZPoiJEx2OcqCTYJMiA6SWDHPqbsdSUY31xM55irAX5BnaCpy/U6OHPMgO0yaeaYPQ4SNKZS1h7OQ5/j4OtsIkTxGeVqUkl/URsA9kWO6yIRe+SwcAOwdOeZGWUnw7DB5NXLMN5F3pNpE1EELBF5Vf2oJZHFUygI+AdGm/G6g7WdQ9L4niF/ikFWw1ww+w+1TMwEZPFajLE2niOf692LXH8wijkOKKiOwLpLS/IXY9d8exGP9GREGqleGvZQnuamIEJAAW8eu/9cBHnM8kmnXRMKWG60Vk9euiYSu74tMCrch9agyV1cqGd+9ZAvsKXBf7Pr9BLMm+jS+Veeo2nwY2Djn5w7kfCoFtZJT63qVeXdU+YZDgf2R6/UQEtmyD+UCjVnamg7E52ggYcGjHlVH6G2kRlf1xD4T+LodJg0noYsc88uIlnBn5D28Hji7ujZTwf7zIoLRUpQFm17yNW8zkHexWmuXAv+0w2S1irbnQ5LYmcB7SDmPyjIfMxA/rD0qcusMCFWWYWPV/0ftMPmijn1MxAep7kkrcszXyM831Q0soaLkNGOEYRVqAKzAmwj8SH3mR8wHv4hd/7nh7FcrUdErtyAr8dLK5F5gr9j1W2pDVsJTqaBjvUwDvtzqvgw1VuCtjUzieZmNO4Dvxq5/f5PtL4VE5e2ATAARcGwrhG8r8O4iP+/QF0hEzq5IHhqQHDeHx67/jxrtHoqsgrNU8JVMR0pjDHaxyWElcswJgGmHSaZ2MnLMLRCzapYv12zgQjtMWlqQsRbKwfabwCrIwmhTROAo1WjKIi+RHohw9lU7TN6JHPNIpKZZyWF2IlIC5D2k9MlnSILLewc5M3AuyqH7l0jaj1lIVOKxdpjUTGcROeaPEd+ZrLQM99thsm2Lu6sZZobb/IRa7Z6rPmMOK/AsxP+jeqLdClmtfaffTgOj5N3fCCYyYYYt7ktTWIG3DrKqXRVZNZ+DOEbXGlQD8gWa2cDZAxBoFgOeQwoQlq7v14AbrMA7MHb9gRbtDJBU9Fn9N4ELY9c/U4Vl92bV5Mro80LIgJ7njF/S9qTAtmNZoIkccyVkjNkEqeL8InBkKUdMBUuTr/1oI9/JdVCIHHNZxBdmcfVVijjfb4YIX3lCTRE9wDyRY+6C+KxNpq9GZ3/gBDtMNmuy2y0jcsy9gcsoC+UTkVw9m0eOuUodWpbLEZP5ppQrhs9AghD2H5ROa4YVXdBy8CmVOKhmErClFXhfaeXBVKjxWw3uNpVBGqytwDOswNvACrwfWIG3nRV4RY6IWIG3H2KS3AlRG2+BrMwK8xZZgbc04ieUx0ex65/UWO/7cCT5Pi/nKZPUQLgNKW5YbVbrBA4umdti1++qR6BRbE9+GvkU+BtSNmDx2PUfa7zLo4PIMb+KaIA3RxZyJmLyvlNpZip5nXwfpm4koduQoHK2PIz4xUxVn1LF94cRM1Hes5Ag5qksepHzzKoRhvrup8oUN2xEjtlGdibzNmRxUTP/lcpTswOSLfk65D07DFihHk2PZvQx7JqauYBNyK+sOwvxc2gqIikLK/Amk5/aP4+OVvahoi8WEpK/JCJAJ8BsK/C2i13/qYzt50dSvVf7AUwBDrIC7xpVPDOLKRTXgSkUpupgV/Lv40TENPCPZhuPXb/HCrwtESHjEMTx8wXglNj1q7UJ9TKFfK2dAUSx64/qYn9q4t8OEVI+QnKpfFK12amUV+mVTEYmzUpn0kdVO+1k+6Rd2pKO18c2iEm+uh+lTNX/pexvVblNJ3Ah8hxlRRmdrupjFS1k5lPHHk5/k9XIf35LVdVrFqdVZrMH1EczxtFCzeDzYcFvBq0fNDZChKWssN48UuCGVnZC1Sh6AImoqR6Y7rUCb9nY9asnnx3IL3w5EdgPyBNq/k3+yjRBtD8Docj0ZdT4vS6UBuZsslP7N8MjBb/NQMwaoxZV2+lRZPKdiviK/DpyzAPsMKk0B2Y5zZdYNnLMRUo1h1Qula0QTci8qt1O5B7vaYfJW60/k1y+Tr45dSrybq2DmGc2QJ7zL4AT7TC5QlX/DhGtRsmp+Awk4SCIL92COe2XTJN1ETnm5kiKhVUQ086FwMUDTG5XK4t5M1nOB4XIMbdFTHkrI+9WAJxSjwP0aEH5dm2PJMxdGinee2aGCXdY0eanwedS8geHLmRQbiUTKH7ZeynnvOhE+rZD7Pqtfvk2BL5M9kqrVG28mvnI16iYSA2qTFSxxlPIvtbdyIAzEG4iP1HaTKT2zqBgBd6aVuBdbgXe3Vbg/azekg8qKuoR+ldv7kEmnnpzpIw41AB7FxKlNA/yzLcjwvwVkWN+rWLzhgRSO0xeR4qi7ovkQDoCiZJpaU2oOpiP/He5F3jXDpPX7TDZHMlvtBzSzysA1GSzDOJkvCVyrV4BjowccyfEATgr/80s4A92mMx53iPHtCLH3DpyzNXVtafit+8jebA2QjSM/4cIT3epiKVm+Tv5C5Uu4MYBtN0yIsfcHxkfVkfGrwWQ/FJPqVxBY4WzgN8j93lpxC/0jsgxDweIHHOeyDF3jBxzZ5WdeljQmprB5z7kgd+Nsgf+LMRxdbfY9fM0E83yBOVcGFnMQoTZaYip58xByiK7Cvmq48lkZyd9inxNzQwksqkPypflW0hl6peR5HMnIpNBKUT1+8C/rMBbA1mZ/jOrGGUNzkZyySxE3/emEzhkEO4jAFbgnQIcjWiqTCQM9lgr8LasMwx/J2TVvCdy7ycAjyFVzAcjg+5QsTYS3pz1jLVRNuOBpMTfI2fbVzPMVSVfjD+qz3CxcsFv46jQxCmNQL+FiTK9vKjqNr2OvHuTEKFgNuJ/Z1HWCHUg2uWfwJwyD9ch71gpqvKDyDF3ssPknyo0+wL6m7nakUit7agqhKl8ddZQffl7XlkEO0xmq+isC6va70HGr2FPFBk55mTEAb36/CciAuXeiLPyqCZyzJUR/9BKC0BpIfFL9ZycQDmKbkLkmBcAxw111JzW1AwyKmJnf0SouROJoLkYWCV2/YcH4XifIS97nnZoEjKxzYs8pEUC0EB4n/IDXs1s4L9W4K1mBd62VuCVau88h/iRZO03GTEJzMEKvFWRbK83Iir1W5DBeANEU7Qa4mzcjSQafERt818r8EKVTqAmKuLoAMqrxlR9/gnsHLv+TfW00yhW4H0DEWjaKU/IkxHNxJ/qcU6OXX9m7Pr7I35WGwLLxK7/rdj13x+MPg8h/0f+Kr6NvgLBzxGhuHr7TpovtjoU5OVXgQZMzCrT8IOINmce5PrMgwj4iyOOs3cjUZqHA6tUCHq3IivySYjmaArikP+oWo1/i3xftqlI0sfKvmwNvIssUP4MfBQ55qnV2p8SdpgEiGAQIfdvFvAHpIBnP2F0GFif/OewnQarjo9g9iJfi24gC8nJyLwyL/K8/Bh5noYUrakZApRgc5f6DAUeUkTvWGTFkDX4GYhAcxDiSNlq7iRfU5Mg0Qg/RAbECVbgPY044x6CZEPO4g9W4J2P2HW7kdphU+mrop+KDM5Lxa4/ywq8JZEBvdo3YTfVv32KTkJFaz2IqJYrr2MncEHs+oPpl/Jj8sOxJyNO6A/W05AK1x5obaCRxJsUF0Z8tfQfO0z+Eznm2kgtte2Q+/4EkutkRGUtV5qPrwCfUDw+tyGCej3sRN+abZWYgGGHyTYZffkaskCoFv4NZOI6A/FVKzJ3z8kPEznmGkj0UfUzfTSiOTojqwE7TG4DbosccyLQY4fJoGhFm6TWwmKgAQojhfnJfx7zFodTgBMixzyvVUkb60ELNVWoGjw/QOq+9ALXAlfGrt/SyrHNokogfBcRSB4EnqrO3xK7fi/wSyvwfg0ciCSuyspnMQkJc22pUKMSAB5H/gvdi6hmKzWF6yMJCZ9Sv1cPFqUw3EuQlygvuVhJJboD4jPyE7K1UZOBXa3AO7aG1mJnJF9OtWDYDpxrBV5uduMWUIoay6Mu35oxytNI3a9l6X+NZiMmizmoLMA7lTQCw5VILg8VvnwmssjoQZ7ZovG5XzbhyDHnRxYKe6ivrkdMTleQn3xxKvlmrrXJNwcbiFn3ZvLf8w76mp7OIVtIn4xMfr+p9OOppui3YeQp8s+/E3E9GAv8BdHW5BUYzqOkERwyrZoWaiqwAu9LSCryhShPYisBh1mBt44y7QxX3wwk/PQAZII3EcHhWSvwts2aWGPXn20F3usFzaZASyt9W4G3PTKILkq20NGLDALVE9EEJJndeIpXN6VVQdHqcB7kvt2MJCnLM7F1Ibb9Owva2o/8CJQE2MUKvL8D/xmEjMx/RZw8s1ZCJkOYM2WkoaKUtkH8g9qRe17yETrMDpOXYE6agH0RgfhNNj4mjF3/naHvcU2uQDSV9UYtzqLC7BM5Zik5ZOXYZSPPTtG70kl+Xqv/UexkPQ7JBP97JLy62u/lC6CyVtY3C9qaiDg6/6tgmxGHHSZfRI55BqIdr8xaXPL7GYx6VsPBbUhm8sn0lRu6kbEoT5YoJTscMrRQ05dzkNVv5aTajqyYf4GYA4aLvRFH1cqVzhTEGe9sZIWWxV/IX211MgAnNivwFkQmjFWRFeHLyABX5PE/jnztwwT6hp82SwfiIAwS5VPUl89rtFU0yUxBIkhmAuOtwLsYOF4lQGwFFyM+H9VCzSykflgfoUbV39qVct2nPwGXx65fdA1GLXaY/DtyzKURbdraiB/XdXaYvAtzypOU6oC1IwPw8Vbg/SB2/WuHqdv9iBzTQjTDeabGLN4FKoWzMxG/qcoxvZ72JgKfRY45XjlHV3I/xQKRgTiuL4asxA9GhKA2RNj8fqkCuqpdVTTfjCfD0XmUcDoyzvyccmHRO4FD7DD5fLg61UqU0/b6iPbvG8i7NBF5v15H7n318zYbuM0OkyENSBj22k8jBeU7MYP8Vf2M2PUbVb21DCvw/gWskPPzTGChvGrbVuBthTj8Vaq0Z6jvnDrKD2S1uRHy4o5DJowu1f5Anc8TGi/zUE0nsETs+tOswNsZydWRpW35AKl5lWvvtQLvJ4itv57QzE7gutj1f9B4l3OPvwlyn0zKAuGLwHaVeX5Ucdj7gTUprxhnqj6tG7v+6xXblpK3dde692rbzRFn0W7gllr1pkYC6nq8T3YelpnACrHr/3doe5VN5JjfQxYXeeNLtam1E/iOHSYPqv0N5JzqcnzPYAYS6r2pHSZ9tI2RY+4LFCVofMcOk6VUIr8fItqhp4GLKksYqKKZn5L/bqd2mIzqwBUV1bUA0DHUE/lQEjnmkshC/z92mHygwtYfRbLSV0bRfQysU8oBNVSM6oeoxUyk+HpMUQP8cLFUwW+9FPhXxK5/L2JmCZB8Kg8gmp+GBBor8MZbgbeuFXjfQlK0T6U82U+ivuepFM6eRzMCTekcupABf/eKOka3IedbqQKdjUwCFyNOmUUEiDanHu1LO7CPMmO2BBUhtxgSkn0YsGHs+utmJC78MVIlvVIFPhkZZK8CmeitwDsVSfg4A/hU5b3JXEGrit9PIdfwKETF/oQVeFcpv6mRzLaLdE+fsN4nr7PStBij7+LNRHzNRgqdFJt53lHbzEYmjy1KAo3CZGBRjFORFAy/qP7BDpOrEYEniy7gysgxf4LklDkYSXToAW8q5+xSO9MoNi093FTPRxB2mPTaYfLpWBZoAOwweccOkydLZSbsMOlETIsHIQk9H0TKyqw81AINjHJNjdKufAexl38I3JAx2NfbloHYlvOEh5dj1y/KGzGoWIH3Kvn1mWYCCw+iwypW4O2ImFpK2p5GMhaXmI1I7zciL0BeREYjzEScEScgAtsVsevHlRuoCXgXZNBdEhESUkQrNAEJ9d4tLwGhKvdwGVKHajYiwOUJX18gwuJtAzutxrACLwKWz/m5G3HM/h3lCs8lOpFiobtktHkl4nRarVbuAI6MXX9E5t+IHHPSG1MWfmLJzv+t0TNuHEYKneMncOoK3+HF+a3SZjfErr9HUTtDhVrpfkT/StIgwudJSARTySflaeAIO0zmRAlGjvkaxSHg9TADmLfaiTpyzNUQYWoSZdP8TKRMg4OYuLPGg4+QZICJamdjJAI0q3TDN+wweXmA/R+xKC3OV5FxJxrKaKC5jVEr1FiBtyzyos2LqG1LppcDmq2YbAXevkh0TfVL1wnsGbt+yzKKWoG3KLK63gaYjggMN+f5Y1iB933EUbh64OsCro9dPytDb6v6uj6SRHAg2TF7EKfB2xBBdBVkoi3SanQg2p+sAXM2IpQcG7t+XUm4rMBbHHiN/mr+buCx2PW3VNtNRsLhf4iEMr6C2MtLKfkvQ8wxWSTAlapfn9foj4lU3B7QS6gi9mLyHZqnI0LkFWRPnJ3A+pVmJXUNPiPfL+P12PXzhKhhJXLM63thl3FVPhzd48bjruXyweT5ZwKnxq7vD1MX+xE55j5I9vFKQb8TqSe2Gtlj0qYlwSZyzJ2R96t6u17kXanHNNULTLbDpF+RTFUt/Fjg28hYGyCaTh+JFs3S9k0HdrXD5N6KdjZCfABXU189Bhxuh8kLdfRvVKKqoV9I+f38AjhYhaprWsyoFGqUVuVVJAFXtRq8E1gjdv3Xmmz7CCSlfsm51gCObuWq1Aq8FYAnkQmjNGl0IJFXW2VVYVbnfAWyci6ZyjoQle7mgxlybgXeg0gUUbMkiCPhwoiGo+QjkBeWXaILEeQOQwbc8aqt/yApu2+vJThUokwvx5A9Uc9EctH8Bxloq8O4O4HjYte/0Aq8XZBBPU+I6EQGrnWyIm2swNsdUfUvp87xWsBrJrrOCrzNEU1VkfaoA5mAjiLbRNiDFM6cY35Q+X1eIVsIApgZu36mkKue1RXUvi8Ppgaxmsgxl0A0rv0i6FLg/kVXxF9h2w5g2SaySg+0bwaSumAFxNH3PmQM8xFhoeS4Pg7RcpyP5FPaJKfJx+0w2bCi/R8g70UlHqKBOQBZAC5Hvu/OB3aYLF7nuUxFIhwvRUowZNEBHKoS6FXvPwnozRKgxhIqQu9m+gubM4Ed7DC5f+h7NbYZrdFP6yJ1TLIG6FKK9KYyhcauf44VeJchqt5e4MlBSCd/Lf3rukxBitPtj2iLqvuVAgdYgXceEuEyARkU/zLQlX4dZJU0aJRKnx+j6t88Xohd/zgr8M4BdkRlFS6o1F2LDcnXPPQgfkerI+HgWXlpzrQCL0S0TT8E1iNbe9WO3J8rgK0rf8hwPJ6MhI1vZgXe1xsJC7cCbwFEoMkTPEAErPOpXXCz+vePKb4/mU62VuBtgGgMFkU5fVuBdxaiGRmKFdQa5IxrBrDep2+kwPbDINAshbyvX6Zcsb6Uj2Yy5bFsIUQY2ANJlnhhv8bKfDNyzLXtMHkWwA6TyyPHvAoZRwCeqcjtco3qx8FIpFSWCeiXdZzHvMBFiDm3B3mfipz7M/1xWuV3EjnmNxCBbTHEDBbaYTIYZV+aJetag9zzXyHO/ZoWMlqFmuXIH6TbkEmpadTKclDK1FuBtxSwItkTRjsikPUTair69iJDn5+km8aTLlXSrPPv7gCx63+ArAgHygfka4dSJDrjJ+RrYGYDW8Su/0cr8L6NqN3PJfs9Gg9sagXefCWnZSvwppAdSTUBMcPth2hU6mXvnHOp7G+IpDBfCzm3LAFoFpKyfg6x63cpAc6lv4DXgWgX+qA0kPdkHONYZIEw0KKi9dBOwTWZmnT3xK5fV1VhpVlZHXn2X2g2PFf5UzyEmFtrvQsGcv3OQaLOauWJeThyzBeA7eww+UwJMY8V7HMx4nt1SFVfJlFjPqg4j5Wpbc7qQTRm9dQnaxh1b85G3sFSkMLmwImRY25UylM0nKgMyHkRqwCrR475EeJk/Qs7TIrum6ZORnoEQx61UqTneeuPBBZEJpE8Fij4bbh4vol9UmpHOuXRizj8tjrk9lJEc5FFDzJg14oiaYM5VcEvoXjSaUMijGIr8A5HqtvmXY8pSMbORvgq+X5OKfCb2PUPVsU2n0HOr/r8O4E7Y9fPKqFwNGIm7UBW47Mo+1NcnbH98WRrwtqRIpz9fKMixzQix1xNVYC2MvZtlGcouCdGnblQlO/H24gT+e3A+5Fjnhs5phk55vKRY34/csw9lOaitM/CkWOuqRLhVbIl+RXrc7rJhoiQ8WDR+SDXdk2kpllNlBPwp/Qfg0zgtMgxdyzYfQvkmcsTaDoRc+oMJHfJVvVkbo4cc1LkmE7kmPdHjvlA5JgHqEKRRWyBRLC1U57H2hGft9vyaklFjjlBCWdDQQ/5daFKLII8H/eo8HnNABmtQs2TSLRT1gPTL0X6COPfFJcPGJSVzQD5A7VfzpRyaGpp21rZgfMwgD2swMuL9mqWRxHNRQfliWKW+v8uykn7VvKLgZYipUr8lOKJqlQp/MtIgi6vRv8ajQR7lXwhrYMKjZ4y/eyMqLxLvjufIL49mVFAKu/Rlog/1c+BnwFfj13/0BxT0qbkX49eJGP0HFTl39eAx4EbgH9Hjnl75JhNawXtMHmLHNMYIpjV1PipnCt3Ua5ePR8irB2ILJj+iZj0LkMqVh8WOebNSOj1g8BbkWPeEznmIqp0QUhjifVKGIhgWfm8ZjEBWDdyzJrRT5Fjjkd8q7KEhnbkPufxLfJNnQmS7PEYpL7WiqUkiDX6My/wN2TM3gLRtpwPvBM55vHKbFe5/SaRY/4JGZOy+mIgRTpXr9pvz8gx/4PK3RQ5ZqAKcg4aKurrDvKTn5YolXa5WEXCaQbAqDQ/xa6fKvX/o8iDXUqRngI/il1/xGpqYtfvUJlnf0T/VXYXMvmNNG5EzCxFq6eE8qRcEpbrmaSzzEElFfwZyETcEtRzcyjiE3Mi8HVE6HoLWFKFfl+DCB8T6CuQdQC/K/liqHQCR1P/wqAdMQHlbd+JZOtshOvIMAMpepDznIPSLp0KnGoF3vh6Mh8r4eUZ8ouMVlLkDzQeiYYBIHLMBSlHk1Xe/1KiyDzn03rYCzEfT6poezaSZfrsOvYvFYKtpp3ssPlzkOe/jbLwshkirD2OrMYb5W/KlPRi5JjfRByAv0X+OzUbMQtFNdpdlGJt5NcKfusiuy4byPk/b4dJowvK0xF3gsrrPVl9TgNOihzzV3aYnBw55smI0FQrFUQPFVGVkWMegQjvpfF2IvKMbBw55qp2mAxmGv8jEK3bPNTWAifIc9+yKNu5kdGqqSF2/X8jNuofAL9GVs3Lxq5flP1ypOAhCdG6kfogXyB1VvaMXf+54exYFson5EDytQJQzl1Tr7ahpNnJYxxShbulqEl6ScT5eT5EeFoJ8TW4HpUzA1lhdSMru8+RwfeIiqYWp/FFwSTy/aHG06BQE7v+/5Dw+BmUBYoZSH+3ysswrfZtVSmHSq4g/56+U5nVGHGIz6pLNBFYP3LMFZvthB0mTyL38FZEK/U+IsysUZnltoBNaOzejqO/RrINeUb2pnGfsk4keRkAdpi8aIfJ1oh2Ik9jMw7xGavFNIrH/SIn25uRdyKLXuR61yRyzHkjxzw8cswnkMVdnjnLRN6ZoyPH/BEibBb6TCkmohL9qarnlQJNiTbEuditp8/NojSHqyLjy7vkXz8oa2w0A2BUhnQPFlbgtSPOmnsjg9qNyOp8WuGOzR9vEWTw7QAeVyvpEYsVeFsjk/1Ayxh8BpyMOMg9RL6Jqjt2/WbU9rlYgTcPMvhnDR4zgB1i139IbTsFCYP9uFoIsAJvXiRCqJFMrikicGT5Tc0Efhq7/jkNtFfZl92R7MivIfmOhiyMuqIf7cATSBK40vXtmZjM7jr3H9eHX53x4beRFevjyISyfk5TM5BQ4HCQu5xJ5Jh/Q6KoWkE9dcw+p+yc/gKSt+XxjH7lJa9LkTxFS9fpw3IzUsW++r2bCZxhh0m/zMIV+/4WKV5ZafrpAC63w+TI7L367L84krpigYzzKOJd5JmpJWx2Aw8rIZDIMbdCxvH5crZ/2g6T9Rrox4BQ2Zfzyq50AbYdJiOx4OqoYVSanwYDVc33aWQVX3rgVgaOtAJvLRWB01Ji1/8YERJGC/ch+TPqymWRQwo8VEqYZwXey5QTcVVvd2/lF1bgrYmset4HHmhS27AH+Su9KUiG1IdATIXkmFRi1//CCrz7kJDtet+jmeSb8CYjWseGhRqVCfmK6u9Vvpg9EF+YZZF7dy5w/mBoamLX77QC75vIivr7wIT2nu67//DURd+Y2JvsT/ncd0Tub14kWi/FGoM+qNpJP0dyvnyO+M2cYYdJrqaqBpcg16koVL5e6tGGz49oZ64BjrXDJNOZ2Q6TRyLHvBCJXJqILC5K5RN2qEegUfwYcS5elPI5zkAS/VXnuanmQERwPQbxOXoLMYHWq2W8mPqEk2oWqrFPqWr531BRk4p6hLyJiD/YPIiQM5hCRYg41JfuX4lO4A9aoBk4o9b8NAicgpizKiXoduTFP284OjTSUIUfL6K5iKYSnfR11jyM/iaLFBEmTgDJvmwF3nOIk+75yMrrfZXpuC5U3aorkP7nCRYGMnjWy0EZfc+jC3EyLYp8W0RpXVrF6UihxBWQQXRJxE/h1sGoY6Y0NSWfpPmAqdu+/8/vtvX2Lkvfaz6O2g7W9xb8PofIMX+KZOP+GjLpLYw4wj6onGKb4SrgOfoKtLMQn4daTp/N0o4I1E+qSTYTO0yOQypjX4ksiE4BlrPDpO7cTaoez0pILq+7EN+rfZEMxUXmEewwSe0wCewwWdEOk3ntMFnVDpPf16khakcyqDdzX96nb/22SroQIfSbdphspOpMlXi84HidiDn4I2RM+S0QRY55fdE9GAiqb+siwS5diOvBTGRRsv9gHHNuQ5ufFFbgTUNMDVnMAubJyvQ7t2AF3kRk8NuYvquMXmQSqjVJlnxorgN+WBk9o4ST3yB+LikivBwRu/4/1eT7HFJWoVpd3oWsWm+pZSK0Au83SMK8Wirvp2LX/2aNbUptTkZMUFkr+l5kAuxFVpC/RSagd3K2BxEWe2jSDFXVty8jYbVZ5rsZSJXvRzJ+G8gxb0M0V3OOedlzIct35Na0K51vSeDpQd6179lh8ue8nUpEjrkQYnbJO8d9m01FHzlmG2KG/iEyLjyIPLs3owQ2ysL3W4jprxWanQ7gx6qQZEtQIcxpA5qcQSFyzEWRyLRGTcodyALiLGSRWSkQz0L8Z9bIO78ck88sJIJ2YfovcmYC19lhMqhFT5UpbmHgzUF2Vp6r0OanMkUDkoE8+GNaqFECxPpIPpUORFgohWX6iANl9QDQTX7odg9wE2IW+ADRktxfHQ4cu/4TwLpW4E0A0irfojWR3BhZ7U9SbV5gBd6Jsev/Jue8plCfQAOwuhV47XX6pKxE/sp9HDLhrglMK52Tyq57DNnPW5v6/MIKvDdj1/9jHX3IY3vyw/CnIH4RLRNqrMBbmiqBBmBSb6GVqxNx4twCyRD+LPAbO0z+pdLoJ3aYFGkFt6JcYLSaqUiES1NCjTpuoD5zUGHTeyJhy18g5oS/IJFJHiJ8z0/zfmdTVPtNCzWRY66CRGktgpiL1gBmR455G2LeervZtgfIJ4iwmSfUvIVct/kRU1APcn8D4PeIduM25NxmI/5sTwG7FQlsdpicFznmB5RLk3QjWd0XQd6TaiYD+0WOeexgZie2w+R9RAOlaSFaqCnzL2RAyuJj6kzaNVpRZo/7KJcImA34VuD9AlkhHUi22WYysuKZF5mQS/WZuoFjYtevO0Nu7PqzrMBrUxXBlwHeoLjgJZQjJ05RgkBWBMZyyABZD73I6qmegb+D4smrI6Nq/Knq32PIj+RoR7Q6f6yjD3m0kW9eNmgub0oRayJCf592n1ngK3ypaxptaaZ81QZcYofJr0tfRI75rcgxb0CybqeRY96POM5mhSqbFGsIm8mRVIgdJp2I1u23VT/dC9wbOeaGiFloIGZEA0Dl6/kS8H49K/nIMb+M5IophWVXCvETkNIGm6sw5iGbTJUpZ13kefSRZ7taqJ+NjLOPIM7uKyMpAG6oqN79JrCaioxbEvi3HSb/qacPdpjcCNyoTJKJHSZp5Jhvkv+OtAG3R445HXgJuNQOkzfrOmHNsKKFmjInIquBrGq4Px+iujXDye8Qh92SkFCarI9HBpMi/6v5EdPRT5DB6FXgvEZrNClH4HtUHyYiglFCHc5+yCB5MtlhpZ/SWJRSvXWBXkUEumUzfuskw3lXPUenWIF3ldo/z3ZflC+kHu4n/7pNZ2ACUxafkSFg3LTk2mz94UuYyazqB6gD0crM8VuJHHN7xLehUnjeCng+csyN7TD5W1XzD5IvuMxATEVDzbM0nkSxkg4kI+41lOsrjY8c80bgkDzhJnJME3gYWQzkjesmImwdBxw+gD7WTeSYByDh9KVn0UQ0Lhsi73cbZeF+bSR3VAJ83w6TG7LatMPkX6iQ7Qb7sjSyOFspcsyXqb1QLRUL3QI4NHLMfe0wqStzs2b40D41FViBdxCS86YXeQknII6V/lgWaqzAWxgxleRNsI8hiePyHGz/G7v+MgPswxTVh/mrfipd93omilmx62eegxV4TyGF/oqEs5lICH/dxVBVAcd76FsleyaSOXq9PDOW8sf5nHxh66PY9avT7TeEFXg3Ibl+KgX1bkTl/T4Sev0+4s90tXIEb/ZYpmqrX6K5ZWd8xHGv3s1SMz8lMcYxoTfpGp/2ngb8smQ2UGnt3wKWqt5fkSACzwGVUU0qGsilv7/Em8DXazm+DgaRY/4Y0W42mnNkFlIlfjoS5Vf5LHchKRDWzzK1qGrQN1Bfjbb37DD5coN9a5jIMb+DREVlLRSPRM7zSrLHnZnAMnaYtKTwaOSYOyNO7CbyznUjY0oji52ZwJJ2mHzaij5pBgcd/VRB7PqXIY5oOyNhgYvGrv/LsSzQKJaiOCnU/yFOklmVdTuQSXGg7E72CtNABpOunONX8nnBb/sgYcLVYb4lR95OJMPtr63A+4kVeKdYgbetmqxziV3/cWSFeT2SsTYCTqJAoFH7zUQyh2b5jHTRmgKeewEXIFqL0jV8CXnG10MivVZGUtRfNZCIKFVfajfkeegjHP1n6qIctNZ+7Lv2ARyy+t7Jjt885HQ7TM6ompyXojjzrgl8F9GmVnIYYs74DHmGuxDhZ708gSZyzI0ix7wjcsw3VK2hrbO2axY7TC5GKke/SXG0VILcm0T1+ypEi1KKVqtkEmIe35Bs1qB+R+WWR77lcDr5VexPQUxrRddnz1Z0InLMVZH3czJlIWYijQk0IAus77WiT5rBQ5ufqlCTzaBU6B7BvEtx1d3/Itl0V0F8bqYgL3gX4j/QSGXpPFYhvzp2OyI4zUCiIBalv0A+kwJBIHb9163As5FcMNsiq8Q/q7bbEHPNOohJCGQSmQ58aAXeRrHr5/ogqLIc+xSdXA6HIALRIvTNF/Iy+eUP6kY5J3tW4J2ECDATkPOr9qeZgggM6zCA2mOx6z9sBd6qiL/JxlTdo48nzcvHIjxmVVCuZ+EwGdg6csxlS74Udpj0AmdGjvlrJKHbjCLtTEUkTCn79bJI3aTz7TA5oY4+1IUdJtcr36CzkBDzLEwkr8rWwCw7THojxzyD/PdgClIb6dGM3z5F3sda2qFeRLM4qCjN20oFmyyG1CHLm4MmIzXTBtqH05C8SXlmyh7kOa1ngd/OwHJ0aYYALdSMQdTEshYy0N0Tu36hCj52/Q+twHsIsR1Xv/wdwK9j15+hEqtthggFs5DoqGdb1O0PUf4DGb91AK/Grv9bK/AuQpIkLkaDgkDs+p+pbfptZwXeOojpsXLCnwcZXG9FNBstJXb9j6zAWwlZke6GXNOrgdtamV1apSJ43wq8H5C3Mk7TyQvM7jw4csxX8pK/1Xms/1iBtwMSul6dxTVF7lVWwsl3EPNVln9SJbMR4auPg6gSbgrNApFjfgm591lC3eGRY15th8mr/fdsDuWMulGNzT62w6RSA9lF/nvQQ7628ibqq2s1DtgxcsxTVQr/QUGdeyfF2qOi+Wc6kgxwIOyK+A4VOYyPR57JNooXdqU+5ZU50YwQtFAzhlBZkf+MqKJT1ARmBd7usevXWp3th/jOLEHfcMorUM63yufiAVqsyVL9Poji5/Em1YePrcBbDTExbIUM0lORFdTaZK9i6+EIsiOCxgOrWoH31dj1X2uy7VyUiSormmYwmEzeNTaMcWt+9tYewG6RY94B/KDOOkn9iF1/uhV4WwB3IxNFG/IsfQ5sGbt+T+SYSyDJ37ZGHDYvR+UcoljbkCL1i3JReVm2ADZAOQyryJVdyNcItSHmuhPrOMVGmL/G79VJBm9BQsPzhJpMR1U7TD6NHPMHiLZygto/L2PzvIgAtFONvg2Ua1CZpRvcr6QF/sMAj/9TapvkpiOatOWQ+z8euWfVdclKebaaShGgGTq0o3CLUX4JmyGaks+APygNwVAc+37E5l694ugAVqsqKJi1/3hEC7MFMnFcH7v+y0X7NNnPpRAz0CqIOWQq5QKH1fQC21YKZVbg/QExl1QP2Cmy2p+JRL6co7Qhy6hjRHkJFK3AewFxzsxiGlJs9K66TjAHK/AWQ0Kfv0CS/A1Wdtq8438diTzpJzRM7unmmOheNvn4NSg7rK5aI09MreO1Ad8GlkbCdB+IXb9X5VF5nHKUG8gz+gxiLriY/OivacCidphk3kdV/fsviMZnqjqXXuBMZKI8jZww/KcWWPa1/02ccsg2H7z491Y5g0aOeQvyrGaZN2YDX7HD5N2qfS5EsgtX11e6wg6TyqKqWcdbBYlCXIXiqvA9wCQ7TAbtGVTJEZ9BfGdqCaol/7NeRPjdWkU5lSK7dkaKXy6IRL2dZ4fJf2scfwbFQk2KhJEvVWmyjBxzBUTYnB+5fr3IWL51vZo8JbRvhwhJ99th8u969tMMHC3UtBA1aT2EOD1ORAbUcUgG3ZZlCM059v8B/yQ7Qmk2cFkjUT2DhRV4pYgIk/I1aiPfebELWC52/ffU/isiRf/qKWzXiYRnL4UM4inivHhWtfO3FXg3IyvXrEmgE1hL+c5kndM8yGD7fpbQpCb3SxEzU7c6xkxgr9j1h9R/ywq8uxF/lznPyfjehMW6viB47krGl/PJzEDCalseFh055ouIv0X1Pe9AomKuQBzTv0N5UirlPtrDDpM/FbT9ZyQRXrV2oAMRaH5Ghs/KbMaBAbPHmUxOZs8yRBv5fTtMPlTtzotoM7+FOJxfCTxSK0tv5JjrIEJW9aQ+C7jPDpN+yd+UL8heiC/IUohPm4/kbKlrwFaCwGzy36teoH0wosNU4sSdkWK9pQXd8eRrbLqQ7M0LIsL0X5Q5sXQetyPPbOm+zVKfLewwyfUBixzzdUQDk8e7wJZ2mPR7r5W2bxNEOH4Dudc1owPVvfsFov1JKGdbvxXYzw6Tltdc0/RFm59ayx+QbJclG27p30uswHshdv0XBvHYKyMvepZQ04YMMMOKMjNVh3jWUk0nVdt/m/qytZa0ANUVsU9S+/+y6vuzkbo01ZNPD/BKlkBjBd6iwGWqTz1ArxV45yKRHUuqvseI5mEv1Z+SiWse4HZVLDVTWBokdkLqZ+01vjcxDNJJa/7vvxz72t2VAg3IBLIdLc71Ejnm/yETRdZkOwU42A6TyyPH3BuZGA9F/Kf+Cpxlh0muT0PkmIshWsasZ2oKcp9eRxL7zdmmFxhPL0YKbTJvTQC2BJ5Sq/YlEQ3XFOT5SJHreGvkmPvVyGb7TOSYhyCZrxPkXexBfDP2ruj7MogmYlVEe3mpHSZ5msOa2GGSRI75AtnFYkEis3aNHPMT4ME8jZya3HdHFgNLIvftVeCELOFS3d/HkGs1DyKIlkqfbJnTl8/tMMkzNe2OCBeVGpcJ6nODchrPu/5nIxq6am1Nj+rjFnmCivr+IfVphD0RTVm11nlHpOhqq82bmip0SHeLsALvq8DqZDulTURWoIPJB+RP9iniiAnMKe44VGGdlexGfVEulcxEBuASA1WXTwFOUHli5hC7/lPIKr6Lcnj7dGQ1t2N1I6p4418Rc91EyoP4sYiJ5GXE5PI2Et6bZVqboLYfMmLXnxm7/oHAYie8cscvb3rq0o4zXrqV+Wf3K2hdaRJoJQtQXBB1AZBJxQ6Tm1WBwq/aYbJvkUCjqCc1wWYJxkPdhskMcyKzDHllMl6GNiQqbVfEf2shygKvgdzvndTvhdhhEiCRPIch/jKbI8UXpwFEjrkD8rwcjvgYHQz8PXLM/Wq1XYPjyL6HvUiF7YuRc/sgcsxNqjdSAs1tSEmBryCLYBPRst0YOebBVdsbiBP4opTz5ZQE+U3Jf/fnjxyz2qm8xI/JNyEtTL7QBrLguJu+aQamI0LZTvVoXprgZ2T3tx04bABFVjV1oi9w67DJH6xN8ksw5GIFnoUMdN9GzAGXA9fk+IX8FYn+mEL/MboTuNAKvL0QFfwyQJcVeNcAXuz6g1bfpIrFaSwhWSdwYpXvyZ+RKKVma+uADHArIYUy5xC7/jnKX2dPZMB8CvhTTiTS99Q21UJspZ8IyOSRx3jEmbVhrMBbCNFi7IHc71uAc2PXrytZWez60yPnrMsRs0AWpeKjreZV8rVzCfDEANp+m+IIljfsMPmfFXg7L9w9/YvFZ04zV532Dnu9/XRejaqpiKZgBbIXgFOQVflNtTqmaggF1d9Hjjk//TOZl2qAXRk55r5I6YMr7TCZXus4Vce8T2m8LkaEjFJCUYP+z+kdkWOuWFUXalfKzvjVTEJC6a+qyHK8FiK8ZW1fVNKiG1kQPpzx24I5+5T68EzkmAkiTHl2mLweOeZSSDmSndRxn0eejQ7gTuDOajOQqiA+Bfh0gMJOUfTeJGTM+GAA7WtqoDU1reO/5AuJvYhdtm5UWPbLyMS1IhLGeh7wsKqY3QflI7Ij4oRa6XTXifhzrIUIRV+hXKDTAf6qtA5DwUuIcFaLXsRv4ejY9fvknold/w36J2BrFJMcLUTs+m/Hru/Hrn907Pp/KAit/i75+UQaoWGHVCvwvoT4Tx2HCNPLI5rAl5QTdl3YYfIBYlboqPqpA8llMhABI++Y05HnMev6d9PfLNhI2x8i5oIsob8DyRlD7Pqdn0yc518vzm/x6cSp9Bq5SstUfYoK2Q40b8mu5GswxiFBB+cC0yLHPKfRlb6qUv5lZPzYg7IJrJo2JPqskqMoFhJ7Ea1TiWXIL6JapBk2yR8XHiV/sThefSYi7+NzkWNugAgxeyGCXDtSpHcHxNH69kqBJnLMJSPH/BMy3rwDvB855o+U1qmQyDGNyDEXjRyzMmlkbkl6RKD8a+SYRfl7NANECzUtInb9fyJp3rNe6i7gnAabvBp5KStXtVOQ2ig/BIm0sgJvJSvwvqEqS/8DcYw7BbgLWRlupv5/Cv21JBOQEO69VSHJta3AW0c5tg4Gf0IGr1omqB7g9tj1L8n5fT8Gli/iY2Cgfiy1shvXw2zE16JRfomo+CtD0Cciq9qGnjM7TH6BJA58HhGI/w0cDexer1NqExyLVLfuQkx105EKzjvZYfLPAba9L5LVuaTVmK2Oc64dJnPy44xLe49cfObnXa9PWRSzN3dh3oksBPIm9l7kug2EL5FffqQSA1ngNBxwoEx5/0Le/zwBYQL9czF9vY4+VY4V/yZfg9pbcOwvyL+Ov6FYqCxRSu1wNZIfqVL4K5kL+7xrKlLuWcSXbgJynxdFhN88DWZp3y0RrePbQBw55kuRY26M+KsVmW2XBB6JHLPe7M+aBtHRTy3ECrzlkFDVqeozG5mgT41dv+4MsSoE+V/kD3avIiHRVyN2/wQZTH4NnJIR2bMtot3Iqxz8GvIyl3Jb9AJHxK4f5vTPRAaC9ZFJ6YbY9WtWsFV+PKUQ11oroS5g/qzEgVbgrYeoqhvNf1GKoNkmdv1HGty3ug/fQcwzA9HWvAKs0khot7qGneRX2Z4NTGll8r7BInLMhREN4gzgqcrw4sgxd0TyjCyPqOt/A/yuzgiUcYjZZDeU4GiHyQsVv28HXJRgLNYzbtyEbmM8k3p7jAlpn9tQMlV8D8m3sjP9r3knsIkdJk0noFT+NNdQX80mkPdi1WZChJXfzJ9yjpUCN9phsofadmGKtQ4g75Jlh8mcSvSRY/4DMe1Wa5Q6EW311ygLQr3I+Wxvh0muQ65KYHgD8q6lNF8BfTawmDIFEjnm8YjjbtY426m27adBihxzU+TZqN6vE3nufoo4N+e9ozOAn9hhcmUT56CpgfapaQHK92UH5CHeETEJbIhkyb06dv3CAUiZmnZGJul7kTwNs8kXahZGzAPVmpejkYHi1KrvDYq1I8vTX2t3saqa/RRwd8nvRoWtP4qo3edBVlEnWYF3euz6vyg4BogKfCvqrz0zL9kD61E0LtD0INFpv4hdPytNf6PcieTgWJfGCxeCXLdNm8xVU2QSGEc52d2IRk2G/ZJCRo75U+AEytd1PkQDtXnkmHvUoUHaDKk6Pw8iyO4dOeb5qs3NEOfYdpMUszdhIgmpTND/Rp7rD5HImUBlxv0BkrNkM+T9Ki0iDqwUaJSAcgLikPwesuK/pkZ/70QWBlOoX3O+leprLipfzU7Is3A3Er31GCKsZQk1vYjAU2Jh8pP3lbilUqBRbIdEOpVKf3SpNn6GXJvqY/4HGWNyscPk0cgxLSS5poVEUDajTU5Rc17kmCsijtt5Y+xs5N3OSrnwm5z92hEt6kaIhm9/sq/fVGQs1ELNIKA1NQPECrxTEN+GXmSg60G0NTuqOlJF+45DBt/dkUl6HDLovIQ4FmepKHsR269Ftqp3BlKIc86xVR6VD8l+EXvJH0xLae3bgONj1z9XlVPYgOxyCjsW5V2xAu98JLKjnsF7GrBw7Pr9PDitwHsTsd/Xy0zg5Nj1z2xgn5pYgTcBcRQ9BImOeRMx/02gfG961N8zkUGvpJreLXb9O5s87t/Jj/p4PXb95ZtpdySgShm8SfYqtwP4lh0mTxbsvyoySWZVhv4Nkvsmz6zynB0maxe0/TXERDMduNsOk46K336OmNUqj9uBZDN289pU+y6LLGZKSeqK3o8O4Cg7TC6r6tcPkcXUi8gz+G3Kz2EHYmbZFjn3h8geC7qBze0weSJyzMnIO1gkPBwAXFdV5qGUW2ZrJLP5J4gj9a3IuJFVs+00O0zq9qWKHPMlsutKpcg4txjZwsTryDU6G8lgPilnOxCT2A52mDxcdexJyJhYZGYbj2RSPo/sMbwbON0Ok9Ny2tAMAO1TMwCswNuJsjNdqQJsO6KlObeOJg5AHAUnU44OmIpMWK+RbZvtqtg+i16qsrHGrj8dOJn+DqGl5IB5GMiqbhJwuhV4+yGDetZA145oioqYt8bxSnQC52UJNIpGJPEUMV+0oup1H2LXnxW7/lmx6y8du/7U2PVXQfKMXIckHfsYWbGtiFybi5AV69LNCjSK48l+NjoRAXs0swP5zqaTqV25+adkC0TtiDN1URTiGmpCzsQOk1ftMAnsMLmlSqD5MhKqXS1ITUHKTqxZ1GFVnNNGTLqXUuxDYiIRgKVjfx/xR/kxIsgciWh925HJtTSmrIcUkPwrMvFnMRF4OHLMb9thMpOMaK0qzgVejhxz0arzSewwudMOk9PsMLlE9eEbZL/7k1E+gg1wGCIMVdOBLJry3o3DEe3VgZQLmhaRJTz3Ujz+lJ7dWwraT2nCN0pTH9r8VAcq2uQrwDux68cVP51AtiQ+GdjHCrwjY9evFiQqOSZn/0lIGOklSEKukvDRiThCno/4wGQxnrKT5Bxi1z/TCrz3ENPU0qrNa1R7tQq5gQySxyCrjKxJw0DMWEXcgwy4eX4oXcgLfxsSep7Hk8j9qIce4PDY9Zsu0lgPqgL4kcjg/T6SWO2eCv+mlhVKjF3/Hivw9gcuoHzveoAjY9e/tVXHGSYmkS/4jqN2LZ8NC/ZPKNZM9pIvUBXxXfInuknAiZFj3g78tZT6vxpl5io9/y8jC5usjMvn22HyHkjkDnAhfbUueWP6JMQccg6iEcpjPHCTSmR4sNp2+4y+gLzHE5EM0DuofXZDtJZ/A+5SflLzI+acvHEmL0dNJnaYPKT8os6mrLF5GjjMDpO/R44ZI9dlNeR6vg0cbofJnZFjPkXtZ6gTODSrFIcdJrMix/wLkuSx+pr0Ancoc+O0yDH3QcbYUoh+qZ7eUbVKPGiaRws1BViBtwAiUW+BTOYTrcB7Aklv/yFiO88jQezzfeotKVPQfogavGhiTpEB6FSkXlAH8Gzs+r1W4F2OpOLOUiG/k1fjKXb9a4Frldlkduz6qRV4k5BQz3qehSXJ92VJEe1SEbciIcSlIocluhHb+oXAfbVqVCFmhJ2oL2pkHLI6z02tX4lygt6WcgbgW4GbYtfvqthmMmCoYpRYgbc14q9TKiS4GmJXv8YKvB9XO263gtj1b1ClHVZDBtcXRoNzcB08SL6AMAPxQSniC/LDrNsQB/PN6C/YJMDtTUZ85RcKleN8Gwl9NiPHfBL4bmXOGRU+fAkiCE9W+8xA7muP+u4/yDtfmc5gv4zzKMKgdoFNkOv/HTtMbkCElSURIWWRjG3bgK0ix/wx8l6mqr/TgY9VRNDb5AuLKVX5oupBORavFjnmVKDXDpPOit+eAdaJHHMB5L58UnFfl67R9L+AI+0wqS40WsnhiBDVTlljniDnfExFP26NHPOfiHC4KhKVd3EdSSQ1A2DM+9SoSWoC0JURFTQBmdC/j7yItyM1kj5RUSZ/Q1YClRP5bCQnzQpIrpAVcg7dDSwWu/6cisLKofgZxAxTz2phocrJtKKdyYjfztcoq7x7EE3H5rHrP1OxrQGYeaYcpYV6HsnkmuetX+J15Nw3or8JqhPYPnb9wrTiytH4KiQ6oBu5tjcCPy4JCfWgTGGXIoNl0ep+JnBc7PoX1NHmROA+xBegpE2agWhe1kN8Fc5DHBYB/oGYH28ne7XZgRTjrDvSygq8+RBTxCf1RJSNRVSV8M3oK7TWVWQzcszDEcG52hSUIr5q30X8S+ahLIjMRiaktVQ170b7uybiPF+Pw3g3cI8dJjtW7L8z8k5kpfN/yg6TjXKOeyniG1IvHUjY/78oronUBRxnh8n5FceaSf74MAuZ1KsXGT3Ai3aYrKGcv4+n/znOQpxrr1S/vWOHyQxVM+skxKF2GpJA8OKB1qqKHPMRZPzKoguJ5qqZOypyTBtJk7Gt+uqPwMnKlKgZRsasUGMF3oJI9MGeyAT8PuJXcqXSUExGvPRXpPyidSGT2DeQlOt/JttUMh1ZJS1ItjPYLCQTbZ8U6lbg3YekC6+lFZkJBLHrH5y3ger/geozFZmMz1TJ6bACbxHEhr4HonF4Azghdv1+tXzUtTpEbbsk5dViJZ2I38ANyHWz6Fvb5eTY9X9V47wqj7kootr+b6Xg1wgqq+4uiBBwMNnq7S5g2dj136+jvVKERvXgPAspSrgh/SeubmTwzhJSU6TS+V51HLsNeZZcykU+XwX2iF2/lgZsTBE55kTEtOBSThZ3FxJtVDjhKEfOhxHtXOlezULu00Z2mPxDZZz9GRKpmCLauDPsMHmnX4P19/lB4JvUXhiAPJPL22ESq32fUPvmbWtn9S1yzAMQbW49aQVmIsnnfhI55taI5jLPCXgGEmb9sDqOgVzDonGrFBFWTSeyIHgJKcp5qGpritq+ZFofT9lP5mHKRVeNinZeQELo68lbk0nkmN9G6plVv6/diOlol2bb1owMxoRQo7QRNqIBeQVZvf8DUTVWalk6kIn/VCvw8nIUJEjo44OIJJ6nATgP8aG4CjGFlLQF05HopA0qyw+oCfhdamfonIloc7atFT2VhxV48yJapCXoO3B1AsfErn9xwb6l4oELUc4L0YGsRHeIXb9HRW1tieSp+QK4MXb9pieEWqiMx4sDHymn56xtTgOOoDxYlWoXnRi7fl0J6ZTPUZ7posgXI29AB3gwdv0t6jj21ZQdPCuP+Tlgx67fcObh0Y5KXb8E8HGpTlKd+01EFh0lgf8e4JyqEgAtRfX1QmRhMFsdN89RdBqS/+brSPRcUVbiacBWWdWoVQK3txEta5HT6yxEs7ttKVJJ+aT8kf7PbQ+q6GfJZBM55jxIxt1mSpNMA1yV2RhlErofMcc0GpbdAfzYDpMBOdkqrdHP1H/bkDH3X0jF7kH1vdMMPqNeqLECby2k4NqSyAs5HtEkbET26rkLGUReQLQxWXQjviwnkr3y6gHOiF3/56oPayODWTsygN5Rbe5RjqR/I39VNRNZydwH/HUgfhhW4B2B2N+z1OH9Qr4z9p+MhJl/BxEMrgYeiF1/MArA5aL8fc5GyjkkyL29Hfhh7PqfZ2y/FRJltCyi5TizQdNPF/U5TddLgjxnZ5BfQwor8L6MTCRZz9pM4LTY9ZsuHzBaKaWqH8TMxi1HCQAWIuBslrNZB+JHsja1TVZdwJIZ+WBKx1sVGTMWK2jjfMRRts91jBxzdaRm0jyIUGQgz+E2JWdktZ2JLF7y+lrS4mQJ/R3ABnaY/EO1tTTybtaj0crisSxzXOSYExAhMQFeqEzkmIXKe1MKWngUeHw0PWeafEa0UKM0MFshIX+LIcLKhaUIJJV590X6CwpFK+cvkFVcSL7X/Qwkz8ID5E80a8SuX3dEi5qgPyHfl+ax2PXzbL0NYQXec4hzcRbTgJ1q+b6MBKzAuwcRTqt9KyJgtSYT1xUd70Vg5SZ37yZfIJqBlNDYMEcY2wXJV5SXKbVlz0a9qOd1XyRiZhJiir1AOcgPKpFjLg+ciSRyG4dEux1rh0lhkrYabS6DmD7WA2LEP+PhBtv4CmLmXB0x587JVKwcVvdGggo+Q5zmT6H/+54imtyFMn6rpgv4YynLb0G/lkaS8eVpPjqBg+wwuVZtX6r9VvLX2wSpD/WKHSaZTruRY16AaL6qn/GSliNrvElUm3PC6JXp6wYajHiq4Hk7TNaMHHMFxGQ3HZkbTqMsmHUDP7LD5JYmjzEsKM3bTsii+yXg3lrCmaY/Izb6SQk0VyJ5XEov/+rAwVbgbRm7/tPIqjxrIqmlJk0RrUneSqoXcSY8CfHDqU6odUEjAg1A7PpdVuBdgORYyEoMdkoj7WVhBd7yyDktVLBZXdl81fVfDfF7eTl2/UFT3VuBty6iDl4LmRAuQFayG9LfPDgBSby3LXVGNDXAKYg5sfr+dCCmw+XJvn6PI+r5LdX/qwXhqWrfC5A6S9XUKvLZlM9Rs1iBNwU5p+Upv3s28CMr8NatlSF7IKhEdCVH3tLKfwPggcgxt7HDpOHyFpFjbkbZh2QC8v5vEznmFXaYHFFnG9shDu3jVRsbAXtFjnkCou14ErlWUyibkf+LmMBLPmqdyIT7KMX5dmarz18RQaIWP6I4FL0dqaj9eySfzU+RSKZZyPPuFZUpUByPCIRfpbyI7ECuaZ5A8wGi7a3kPZqfd7qAeyPHvAsRxEom4eoxYh7gqsgxP7fDJDcZ6EgicsytkNw2IOPHTOB/kWNuqp2PG2MkJ9/7Nn0FGhABZirwhwq/jkbtsm2I0+cp5CdpOquUWA15Ke9DbNcPA7vHrn98g8cscSKS4rsLWWF8oY53WOz6DzbZJqoY5Y2IH805iB9CHuOokZbcCryVkZXmo6q/r1mB92cVjt5SrMDbFfFf2gZZca2A1LC6jvzBbyryfLSU2PVvQVZ8pfszQ/39e2QFNYO+k0fJ3+iw2PW/gwz4eTb5icAuORXR/1LQrRnAbxs4jVZwJHIule/eJCQc+MrIMb8WOeb5kWPeEznmWUoQaRWnIve3emxqR4TChogcsw2ZLKZQ9q8rFTj8QeSY69fRxlREu9Be0cZ49X8fEZgWpny9Svl0lkbMwNcgpQpORKKOppG/uOhBwtY3sMNks6zaQxl8k9pm0/mRCCIfWaiYiDDgAo8rP6RcVD++gaQ6uBpxru4lP8XDbGDfjGiyFykO8c6jJCh+DQm2mIxc47y0Du2I2XfEo5I33kq5ZuB4RDCzgPujOiqGa8qMWE0NsqLIU8/Og9TlyHQaVfQiA0TlS9eJROl8ATxqBd73gcso10aaiLz4c14GJWw0LXBUovxsDrAC7+fISm8mcH+NBH31cAaiqq9lp+4EvBr+NAsijtLz0Xfg3RJxLNx8QD3te6yJiDaueqJvJ9/fCeTeFoZ/K01TSbPy73r9gWLX91UeoK0RAfjBCnPnN5BJYWvV7gPI9fyn2vdt5aRd1O/5q/seu363FXguMvlVhqd3ICbXPzO0lDKuVjNum/f+uW4KzxtybcYjE8zBkWPuVXIGHSDfIV/T+tXIMRfO8y/JYYuC9iYhhWGfgDkOxrsiAvYM5H48jkRJ5T0/JqLFylogTkGcfDet/DJyzD8hJvAs/7rZwM/sMHk594z68wW16zSZ6pjVY8RERPO5MxU5cFQU2VaIE/Izdpj8yw6TJHLMDxAn35Upnj8mIveyjwZIJRncCbmuk8ge4zuQhde66rzaEN+0w5EFQL3+OGtEjrk7otX5H3BtXvLDYeZAsp+fcYhGbWNkQa2pg5Es1BQ5vvUiK6PLkFTdWavf95HMtK76/T/ASbHrz3lxY9e/0Qq82xD19iTg6dj1P6unc1bgfRWJYJgHeXHvaWDifBfRgAwIlWdnF+Rlz7uXJaepN4Cfxq5/U41m90cEweoBciKwnhV4K8Wu38iAW8SPyHecnkj+RNKFrJwzsQJveySZ2QLI+U+3Au9QpYmpiXoGfp/x/StIGv8i3iC7Lg2ISj5zQo5d/1Yr8N5GQsrXVttdgBREHVQHbZXLaX5geuz6s8jx7Vm4ezqHvv7AeKPvs1ZaNFwbOeaX7TD5fIDdKZqYa03cWSxUsM84lFZTZcN9CplESlF/eyKmpW7yq2i3UVzWwMr47gFEY7E6fSfoTqSmVF3vl/Kl+QMiYNS6LjFyblkCwVQkE/DvlQPtrxEhp7QwNFTSwOORsa6WL1Ahdpi8qrR7e1M2ly+NLKReA35hh8ldSrBaDvifHSbvRY65AfkZzbMYh2g5p6rzODxyzPPtMPEG0v9BYDXyz8lEtKYPD1VnRjsjWah5HFkRZKk3JyIh2x8gkTGrURZsEuTB30tFvhxqBd64vIlBDeJ1O80qDcBZiCaptFr9AfC2FXgb1SsUDRSVh+YJxKms6D52IEn86s3tsCn5UQ4JkgyrVUJNLX+Gd5FcQJWDaAfwx9j1n83awQq8zSibCkpMAa6yAm9m7Pp3WoE3P+I0ug/liKrfVJXAaJbTkbTx1QN/J3BR0X2IXf85xMzVEEo7tDui3YqAW+pJB6CEmRMQc9NkoNcKvN8j/mabUjVRbvnhy0UzZ4poOa5otP9VPEI5oVk1b9thklW1vYi/k6+p6UK0kiB1jizK5uySiWpHis30nRRntv5H9Rd2mPRGjrkF4gztIs9gFyLE1uVbp7RKT1A2JRVRck7Oygg8Z5vIMbdE3oXK8ymNv+tn/FZEF7KozESFTl+sPnnbdNF3rHmffHNXNan6lBZN49XnkMgxH7HD5O462xkKXkc0dFmuFD3IvdPUyUj2qTmP7BVQF6IVeVtNEJshqalLttrrgLUqQ3lbvNL9LhKNVZkafR7E1FGrAFwr+S2iNq6VeKsdOFb5INXDR+RrSHoRR94BYwXe4hRr40AGPBeZGKYjq7jDkaicPH5FtlDWDpylzGt/Rybz5ZFSFT8GXlRh9wPlBsSvqRuZ8Gaqzx3ASVbgTbICbyMr8DZWEUYDwgq8LRHny3MQZ+uLgXetwCssoqj4LZJQcX7KRVn3RoSjfkLRYl1fzJ6Q5gZjTKb2/ayHouc5arQxpfV4Frkf1cwGLoscc2FkHMmaVKpLelRTq8BhpqOqHSaddpgcglz7xYEF7TD5WVG25Cp2QTRqWQJNdX8MxO8m79rOQPyO/kC+0DJJ9bPeceSviE9ey7DD5A3KeciKKN3rPJPgUa3sVzWRY7ZFjrlr5JjXRI7528gxN6/hF3MpIrxk0YX4dGrqZMRqamLXf8sKvG2R7I+lwX8CcC8y8Ja266aGxN9ijiVb/ToB+JYVeIvErt/oarIh1MS8FfU5SY9D1MaLIpFXtfgtMmBmnaOBXP9WMAHR/OSRAleopHP9siBnobRoaxRsYiOOqEvQd8VXqtl0GaKhyGt70u1PnN82T0/3KoiQ9WJ1bguVX+hEK/AuRgoBtiE5fl6zAu8gRMtX2mecFXjHFSVDLEIldLyNvveqNHHdZwXeEur9yNp3WcR8muVj8SVEa3Agcl1SYEKnOeH+FDYzsifHDsRRvWkix5xMfmZdEN+CZngIiaSrJAF2t8Pkw8gxV0QWUM3kKHqQYpNkoaCshJhmFgobkm8Sy5pAS2NFdRLJLkRYrCe3R73mvzuBnQcp78tu9I00SxEB/HVk4VJKnrob+SkSvjII/QLmJBd8HFkYlMyYuwOPRI65ox0m/YQXO0xeV7WzLkbuzUTkfepBcgblCTyaDEasUAMQu/6jVuAtgfi8LAQ8H7v+W8PbK5Yp+G0WosIeVKEGEVAaGYTbgR9YgfeL2PU/qrHtE0h0w76UJ8sedbwTgJOV+eZBxAzUbBHFd5BsuVlalRS4q8ksutXO4dXt7pHz+zjgm1bgzVtZ0Vs5M59Cmv7IgHn2WudAY6d3n+/a579P9Zikn0aOubcdJo9XN6bKMlxe0c5OSCLB6vM9ywq8T2PXv7GhsxT2JX/l3IY4auYJhFuSv+KdiuQtWQyJeJkEPPu9+NkeRBs6hb6TWy8S0XNXI53PoNbz3LBmK3LMjYDj6H+dUuR5vhs5p2bGwpR8/6kSRQ7vA+ET8k0WRRjIvZoXEcx/i6SuOILapqXS5Jp1zF5EO3PSYIZR22HyRuSY/4eYjrdCBMIrqUieFznmElQsfKtIkbw6g8VFSKHjyki7qchi6VBEo9oPO0zCyDEfQpy5l0ZMwNfpDMeNM6KFGgCVYK3h3BSDyOvkq9knIAPkYBPT+L3rRiKuCp1lVV2sg5GIm0ORye1ZZCA7k7If0Z7Ar6zA+2bs+h802BdUtfGjkKRzWXlhjum/V802UyvwbkFWRtVq+V4k23NR9Fav6ssXMEc7cxewHoYxOQVmtE3mxiXXmfRO+4Kc+ModU4F7Isdcww6TWqaRM8g3i52O5EBplBXIn4gmU7uKfN5KOgV6VLTeE3O+dX1U1eW7EbNJSbB5H9i6BSvKaYgpLa+S8vNNtHk02ddoPLBm5JjLqYmyJMjX6zMCMsnXKrBYt/9Z5JjzIjlk9kcmwn8ikVBZ5odrEV+oZoSa8cAUO0xmquN+WbVVNKaU/HLakQVmpeZnJrB5VimHwUBVOM/Vziun4geRyLesZIFnDka/VKmMncheNLUjpvPcki2qjMdpg9G3uYmR7FMzUvGRSbeabuDOoajRE7t+Kdy00dpQdTkLx66fxq5/d+z628Su/3VEwNmZ/n5ES5IRJVQvsevfgFRIjxE1+Cwk6d4mKtKoGY5DVm+V5zobmTAPR1aTeXyG+BSV2AhxjO4z0XWbbTyx0P/xVvtCIIPmsUUdUg65RWaIryiNUKO8Rv4zMBOJ+MvjLvInsQ5yosuUj8oyiMnlUCS8/autSBCmVtoe+fmjmskPlZcwEeQZKZkiDkf8X0o+UKUcRY9l7in0IH4oecJcQo1FRAk1IT6J1IJaCHmu1gZuixwzK2HjG4iZZzZl4bSU6qCW9jRFFislfPJNWSW+QJymV0N8QD5R390OrNusQKNyHt0YOebnkWN+GjnmZUrIarSdyZFjfjNyzLVUWYd9kKy8M5D7U0p8eJwdJkX3dCAsSLFJvchRW9MitFDTILHr3wH8BhnwShWqZyCOyvsPYVd+goSgdqq+dCCDWZ7gMp7m8+0cTbaPzXgkzDsrbLUulNllKUSr8OXY9deOXf9vA2gvRqLmLkSip95DfGVWVRXMf0b+pHlClVP5DuSEr/YaBk8vuCzINcjLTD1nc4pX9D3UnoiyuKpGm3/M+zF2/ZJzcfW1mIlo5u7P29cOk147TP5ih0loh8kTrfSdsMPkBkTA+ByZNGcggua+dWS9zeI18jVSE1CCnx0mXXaYfAfJan004n9mIRN5Vj6sbqTw7FnAp/Q35c0GHrLD5KU6+7kvIixWC7ftwIWqthEwp1zDm/T3q5uGmJF+SbGPTBt9/Xh2oVhLcxGwnB0mL9ph8qEdJofZYbKIHSbz2WGyUwPn2IfIMb+OPGu7IOHcC6ICAyLHXLLONozIMY9GnpG7Ef+p9xCfo7WRnEM/Q+7pUnaYXNhMX+ukKMgCRMuvGWRGvPlpJBK7/s+twLsSeRmnIjkEHh1IEcpGsALvu0h+nkURM8tHiB/MRcBNSP6LSu1CJ3DkAJL85ZkDQAZ3C9G2NIW6bu82u39Gex8gEQ79ohxi13/CCrzdEX+XeShHrxwfu361kFAKC81Y6RuVXxbavZVZ7HrEzl9tLugBbmoyQm89shcmncDWeU7CFZyAFBc8EbnHnyHC4K+GunhpJXaYXBE5Zki5QOE/B1AD5zeI/1C16W828Fy1hkklZ+vjc6Hyo9yGvG8JIng8DHzPDpMZkWOuh5gPV6bs6/ZH4IAG+rkfxflf1gf+oqJo7qRvJFLpUVwAGRd+rfr7Xfo/uz3AI3aYfKbOzaA4TDpBtBsDTRCaxUX0989qQ0ybpyHpOuagioVOAj6pEKR/iITBV97feZA8YN9SWpnB0sz0wQ6TWZFjXkh2KZwOJLu0ZpDRQk2TxK7/X2TAHFKswNsRsadXvjRfRjQ3NyI+I0ciYcrzIzb9n8euf88ADvsKIrhkqfEnUmzmGBCqYvjhyOA1H+JAd3Ls+o9VbLMSMimsiERy/DZ2/X+p35YHDqFchPDC2PXvUNqllZFB9MWc/DF/BA4iY7IZl/ay3qdvgAgQl9ZxKsch92YRygLnTGSVf3Qd+/dBRcDdRL5zbc36TEqYvIpijc+woKKCMosrNtjOY5Fjnoj4LRnI9ZqO+AHtVmcb/1TOqWsi/nT/KqX/jxxzPGIu+jGiKVkE+HcT+XSKBItSVl1UH5YiX8s+GRHmN0Tel/UojxUdqo/frzi3NHLMvyFajSzeGAyBRgko65A9poxHFoyO2vZrSDLN9ZFFyMeRYx6HjHenku+rdhq1tait5iTEpLkDct96kYXnr+0wqZX4VNMCtFAzilCOq1kRNCCD2WmqBtEZtLbuiY9EoFUftxu4u46IqqZQGZMfBlahLAhsBqyrygrcgkQ+7EX5Wd4W+IkVeH9EchZdg0wIbUi48G5W4J0Yu/7Z1A5BfhxZ5W1ccXwmJrPZ6OPX+FLXtOTdSfN//rOVv/voE7lNCLHrf2wF3qpImPSeyGB+PXB5VuXuOjiV4mig7yETwVyPHSZnR455E+JAviDiu3JPI9ofpRnoI2RFjrk3kk+rJHDMBn5ih8mTTXTzFvIdv9tUn0Ey7Nbq90TEnLUV8j44yLt7O3BNRj0pD/Gbyyq027DAXSdtFJvIxgNEjrkU8DQSrVUSgCwkyePiFGu31hl4NxtDCePfU5Xmt0CeiTvsMGk4mELTHEaaDonFRNMCrMBbDKn8m7c674hdv1YyvqL2V0QGuI2RFd0lwO9i159lBd7hiK2+l3Jq+BeBrSpDoFuJFXj7UVZRVzMN+DkSyZC1yi35qGRFh8wEvl5PtWklWJ2AOMUu2N7TPWuHd59v2/jj1/jzEqsZ935pldk948we4Aex619b+6wGjkqkOI3iRHVnxK7/06Hoz9xI5Jjb0z9zNciz9TSiNewGQuCcWuUjIsdcEDF7LUzfyL1OwLfD5DS13dpI/aNapQputMPke/Wci2r3O0g00fyIsNGJCGg3VG03AckcvS/y3t0MXF1n4c3KdgxEq5oVoZcC99thslXkmBchC4Gs9/gz5B3I03J9ZIdJKxJCakYR2lF4dDGb4uRXTYfUWoG3CeK0tyei3l4FcYJ80Aq8CbHrn4s4Mh6NON5tCXxzsAQaxffJH7wNRNjIG9BK2pksxiMOiTVR1dpPjl1/IWCBzvETe65fej3jh2s5xp1LrEbPOLMNWV1foXIqDQW1ign2IiZDzeDhk68x3QQxUy2FRMY9Fznm/EWNKR+XtRFn11mI8//HSGqDSl+M56hd5bqDBrP52mHyJySacW0kN9HiGQJNOxLifynwLeQ8zwReVrWzGjleijg1Zzntz0RC20FyLeW9x22ItjXrWnQztBneNSMEbX4aoagw4B8h/iRfQpyBL0Ve4rUydumhzsy7GccaR38/HRCBYnUkPPJ3set/yNCaNPJqUIGs5hZust02VCHDBikV+ctjH6RMw2AzAZn4isxPdYUSaxoncsw2xFSUR+XCYxJiLiktBnKxw+QdYPvIMacgGoiP7TDprdomjRxzO0RoySpbkCIC0TV1nEr18VOKheHjEYG68rmbgmiOL0L8YBo53h2RY+6JmPAWQ67bv4Ef2WFSMvUVLdTGIU7uv0fGipIGeyYi+P2ykf5oxgajRqixAu//kMHh36rK9YjBCrylEFPITojq+B7gxNj1X2uyPQPJf/Etyjb2ryAT5jRkJTaZ8oDWA/wPOLm5M2B1xKkwiylIwc7fNdn2QPgjkrE1y89gIvAhMrA3SgcSDt8oi5MvaE0ClrICrw2gOtOyFXirIfdvU0QwugvwYtfvl7RPVYDfGvGd+LNySq/kRYo1dtfHrt9V82yaJHLMccj5zhykVPgjnQTRmtZbXHEi8g4VCjUllGNuP+dcZbL5FqLBfBnxN9sIWfTMRMaD94EdVIK6TCLHXAspJ/IJcJcqHFkPB5EtSI8Hdoocc3U7TP5eZ1sA2GFye+SYf0KCHWbbYfJh1SbXIY7PWcf9DCnbshISKLEjIuwHwBWNmsQ0Y4MR71OjBIabEXNIKVzyIaQK9+fD2DUArMBbBonImZeykFhKgrVB7PovNNHmJojjXp7PxOfIgLY5ItDciDgJv9fosdTxNkacCPMEm1dj1y9amQ4KVuAtjKwcF6TvirQD0Ri9j6zGsiaXBIlymUpf4T1FBMClVRLDRvqzIxI6n5WorBMJS19W/f9p4IjY9Z+1Aq/kB9FOWRjpRXKwrF0SbKzAG4+ssHes6KuB5Nk5ojJlgBV4P6F/luIUCS9fJXb9llf2jRxzKnK9v4+8h5+o/58/0oUbJRBsi5g8lkGEgl/ZYVLLxzurrSmIk/e3aWxhuGFWSY06j2ki0W7fojwulISfPdR37wF/y7sXkWMuhAjTKyHPVY/6d/d6qlZHjtlFcSmL/wHL1vIfagTla/QCosmpNEN1AruMsGrbmhHAiPapUVWMn0TCGCcjk+4kZDK/V2k0hpszkH5VDm7jEA3H+U22uRfFjoCTgdti1583dv0FY9f/UbMCjeIf5A9WsximKrGx63+C2PcfR2zkHcik7SMh0uchwlh1NEiCDIRrIea6TsqJ3N4GNm5UoFHcodqpNkGliHCxPKKpM5Hw04eVQHM+/fNxjEMmokoV+YmID8Ek9Zms/j2AijBcgNj1z0NC9z9W5zcLeVfWGySBpg2JBDsQOVcTmWhOR3KjjHTOQhx7N0MEz+2A+yLH/FG9DUSOOTVyzAC55pvRuKb77Aa3r2RvJJqpcqEzBQknP8MOkz/ZYfJcDeHyNiQj8BTkHs6LCOi3RI65XB19qOWnNRFJrdAylK/RmkiNqmnIOPAIsOVgCTSRYy4VOeYlkWO+Hznmu5Fjnh055pcG41ia1jOiNTVW4O2DeOTnVQXeInb9p4e2V32xAq+T/HoxPcB8setnOcMVtXkd4rBbxEWx6x/SSLs1jnk2ol6uNq9MR7LxvtWqYzWD0trMD7xdnVPGCrw1keiklZEkgJcB95YSyCnTz1fVb09WaTyWRUwD/4cId78tqmWlzKD3UY5SKSVjyzNFPIEIZnkTYHfs+pOUD9Wn5GvL3oxdf9nqL9V+X0Yi3watREfkmLsgav2sd7EbyTg7oszCJSLHXBXRnGW9p13AknaYfFKjDQO5l6vTRGFNRQJMbcDcU3n859Wxs+hCSlXk1p2LHHMFRKOcdQ1mAxfbYXJ4jT5sj/hqFZnd7rDDZPuidkYyKhT7GUTwK2mGZiHa8TVG6jOuKTPSfWo2Jd8EU8o7MqxCDbWvYTPX+E+IU2qR9qTVeQ+OQQa3Q9W/45ECdnsPt0ADc7Q2mROPKqvglP5vBd4iwHFW4H0DCYG/IqsKthV4+yLO1yYyUG8LeFbg7RC7fmZJidj1X7cCbzkk8mN51X5Rdep1Kc7HUdLezEdxMcXMas+q4OtQFFHdlfx3sQcxi4zUaJN9yJ+IEyTz7hU12tgIMYE3K9CUaDZT86IFv3UjSf+KnoOVkPc6Lw9OXvK9Odhh8mdV+DMvU3IvosUazZyPaLAqrRgTEBP4GbRYE6VpPSPa/IQ4guUlmioVKRxuilJw/7vJkOfbEIEij17Et6NlxK6fxK5/HDJ4bgmsEbv+12LXH3BW1yyswFvSCrwVmyzkWNTuekjm4BORrJ4/Bp6xAu/oqu2WQgSayZQnvEnICu02K/ByI69Uwc+/xK5/OVIjqZa6818536eU63FNpzip2nBPFkWTcamcxEhlAfpXbS/RhkxitdiS2rlhavGEHSZ1FZXN4B/kX+OJ1K4r9D75zuW91C8Y/4Tsgr4gzsq/rbOdEUfkmBMR14aseXE8IthrRjgjXai5ivwCjSYy+Q83eVWFZyI+Dw2jzCvr0r+idMkB+ajY9QdldR67/ozY9Z8BIivwNrAC7xgr8A6yAm9hK/AmW4G3ihV4dRWby8IKvK9bgfd3JPHW08DHVuAd3wr/KOVo+yfET6C0Ih2v/j71/9k77zjLqfKNf2cys52O1IDUUKUJCFJFkC4iSBHQBBCBH0UENIIFqVGKjaICJlQpgigivYogSEcEg/RI77s7O7M7mfn98Zzs3LmT5N47bWd37/P5zEfZm5uce29yznve93mfxw79T1Uc7lF+/3+pnmuaEtfdFC8496OFIM9Ne7bztOmWugSVEqoxg8Hzs4YLVyNOUh7aUMffWMXd5JtSgjZH9SgAz6C2km8RelEgcMwg3w/iLuXdQzOQSnCtDd6DqISSd592opbsmnCitAMJ73XQ//uYjkjug+kqHHbErrVO7Fp/jl1rWuxaH8WudXEdJpntlHcV1tvt1sQcxJgOahIveBo9bJU7g8zx+H7gcFMKmGNIvOCfiMD3tBlXJ8oUfGUofkuJF7yXeMEmiOx6OarnR8BmiRecP9RxV8MO/WXt0D/GDv0f26G/JxLiuxlNpmejnd4HZhyxHfqPGAXiRq7xSZTZWhdlRRYwfyciz5ShYjuKJ55xyD8qwwoUl/cm0JiOzXHoHq1cMLKF7NuJF9yD3IKfQKWabvQ9blXVHXc88C/6gofMAf5eZFI4J/EXlHGqDrqmA+eOcRn4P6CsbrXmSRfqgqqnhH0d9Tmp96JA4360IZuF2o43c6L0sXoHXA0nSh9E3K+MLN+B5sIJwP6xa10Ru9b2sWv9PHatK2PXOsR0q2Xv70GZy+y9oKCkAyke192V5UTp9WjTdQW6J25HthyHj4UuuNi1NkaB6i4ou7YgCsQeLwtsTAt4mY/dw8M5ziZGBmOaKJzBDv2d0C5nJfpEmiahSSNFkvBz3AHVDv3MNfvN0XLsHg7YoX8MfV5R49F3alG+a+lFC8UaZcTaquv8CpGR8xRCO4AlhuAkjh36B6GOqKIywV8TL9jZHHsk6jzKO3YqsE/iBWVcmeprr4M6bD5v/ulu4DuJFzxeddwUoKeIPG6Iv9ujTFE3auO9dzTvJzv0l0aaKnuhLMytwEl33Xvmq0gL6ZtooXgVqd1eNBYWszLErmWj73I9+qQhbge+Vm8LsnFgdul/z2TZilb0TPwNON6J0n8Ox7hzxjAJZYC/T/+gPGv/z57d6eiZ2syJ0ucr3r8o6qTbHG1ULhxKsDUWYQw6N8h5qRtZOhxU8t4y+4sdnCitqdQcu9YyaBNjAbc6UfpynUNvYhgwVwQ1GezQv5/8TpIOYNfEC+4a/VGNHdihPxnt3N6vdxG0Q38LVDooU+8tQidwduIFdYmK2aH/PPleL6Ad5A6JFww6fW2IwXeSH6h0Aj9JvOAkc+zCiORbzafoQV1SKxkSbqNjaIXZZanKf29BrfrHIhG/Z1Ewfnuj1xhJGKuHxxEPJQs+UzSpb5kFabFrtVar3c4NiF1rRdQt9qITpQ3JIJgOqP1QyXlF9Ky10Bf8d6F7asMy8buhInatf1OuaJyhF33OomduTMH8NksAsROlHwzyHIuiYK0oY/uxE6VFHYbZOb6Cyr0LoN/2XeDQWi3k5v74CWq2SM17W1FG65C58XmZGzGmy0+VMK23G5DfTTQRLRbzJezQX9kO/VtQeeh14BU79Per8+3HU951U4YJqGOoXuRxAjK0ks9NagQPo9JfnrR6ilq9ATDCjduhNuqPzdimouzDNoMJaMx5ewoCmhARk9dD2catgRuMUehYwo9Rp0dlNs1CgeJs3sXcOkE7UfqSE6X3NxrQmPf2OlF6OeqCeg/ds5XZzPHIP+n/Gjlv7FprGs7Hv2LXui12rS+aBTLv2KXpE3ishRZg5di1HjAZnmFD7FptRrtoOM61auxaj6BS4K3A6+b7GEynWS337yLC+Gw4UXotCnw/jUrlK9SpieOixoSs4WCS+f/7Il2tJkYBc01QA3ySYtJwC8UZgHkaplTwMFqg29EOZTngt3boH1r2XoPVKC8z1UIj5aKLKA5cPkRCeYOGyU7tgLIg0+gT3fsQ2CXxgjeqjn8YZU32R7yY3YGVEy94YSjjyMFnkC9OdQZpEnCG0eAZK8hKTtVoATY0Ga75HWuiwC8PE6nTLBXA+Dj9E3E+1kLP8ZXAhQWBjUXjnWafBn7b4HtyEbvWWrFr3YYyn52xaz0Uu9YWQzjfwoj/sj79BVb3ZRD+Vcgjr0hLpoe+bsNSOFHa40Tpf5wo/W8DpdUfkJ8lngQcb+xFmhhhjHWdmkq8SDGxsxd4bhTHMpZwLNIPqX5gsgXz4mofoio8j/RWBhPY9AIb26H/HOKnXFqj7HUhquc79GWHetAE6Q0HbyTxgjfs0F8X2BTtqN8Ebq4W7Ks4fhaypBhJHEC5QONuzBlvrTyU7b57mAs7QGLXWgAZwx6Inou7gFOcKC1qta+FDSnXq6krw2BaiIuMZPdBZYu7q177HyqvrFjXSIVxwJ6xax3tROmgBRpj11oddTdNoW++2Bi4JXatnZ0ovWcQp/XQ56+evyYCu8SutaITpS/VezJj+Pkt1K1X/czNQIHHSOGTJa9NRuWssSBDMk9jrokcjanfA+R3IMxAJM35EV+ieKGxUPq0DGdTXBZKq/63Gi1oEVwNlSZKZeATL5iB7ANORkHq+6jz5IDEC+6oMc66YXRkHki84DeJF/ypKKAZRVSLeVWijcHxmUYK91KcCXidOa+X0xBi11oFeAkRnFdAnI2vAA/HrrXZIM63JVI5LypjzKJcjLES21G8mZhEjsidyRocTeOl2k7qL1sV4TQG2n2AxjpYyYEdKL7/Z6H5oiE4UXojsDeaY7pQhv8R4HNOlA4pG1wD75e8ltJYVruJQWKuCWoM9kGZhalo4u00fyckXjAoo7h5AGXcj8y0rhCJF9yNJqtO+sp7UxE35SiUXTkLTRJ/Qg9u3qI3GTjUDv0V7dBfwA797e3Q39b4d1VebzranX6IdrRrAZfZof+oHfp22VjnYtxCsU5KDwokxgpOpFgP5di5qasvdq11UYv8YvSf6zKOUFjEXSnBuZQHoZ3AT+s818IUz8EtiNcxAGbR3hOVWWehZ/zflAskjmfoKuQ7UDze1WPXWmQQ5/yI4iC6l+LnphYeRZ5kZyE/tY1HqiOtAueR/+x0IS2h0rm4ieHBXNX9BLO7Sz6PygsfAddUcyXmFhjy87eROd6HyHn694kX1H3z26H/QyTglpfyfhtYupq4WnCeFVEdexGkofKXvHHYoX+mGXPe5NaFUvtbowAp6wz5VuIFvzPvb0OBqU3/8mc36jpatZHPPzfAqCY/hxapyvJOJ3Bf4gXbz5GBFcAO/c0RqXlltLC8h37D6+bowBqACVaeRVnEInQA6zpRWkuNNzvnYihbVVaC85wojUrOMRHxuN4FlkLaRUWlyY+Q63VhBiB2rQWBWU6Uzohdy0W/W3WZPgX+4UTp5iXjronYtaZRLJcwC9gWtfuvA7wM/MKJ0tIMbOxaOyAdobzzTgOWcKK0rMEg75w+8CN077ajeelpYHsnSgej8F7vdccjovOn6bMUmYY2iFuMZEdcE32Y64KaeQVGzv82NAFlC910VLPesd6F3Q79RdDEuBT9J9sOYL/EC24YpiFn1/sFalnM2+Gm5q960u8A9kq84CY79HdHyrkL5Lx/KipF/ank+kugOvxawH+A380NQa0d+ksha4st0SQ7DtX9D2/U8HS0YNq725GJ6Fw1URgDx0coz6pMBTavtyQRu9biiNNSFtR0AFs6Ufpo1XvHoQzON9Bi24a4XIvQp21UjU7gDCdKT65zfFmX3Z4oUGpFi+rHwKZOlL4au5aFNh02yu7UcvauPP81yJMub0PzKjJ5HU8fmbkD+JUTpd+rMeZrURYoC2wynt2BTpQO8GyrMcbtkVBidZDUBfzZidK9GjlfozBk4C+gqkIbCtj+0szSjB6aQU0DsEO/ZTgmd9Pi+xL5xLLpaKG71A793RAXYA3Urn0B8NPECzorzjURtRJ+wxzXiropvm+UbIcVduhvjx7UPHPDTAAsDwmqjx+KsQYowBmJF5xQdc0FUflrazSp9qBJu9P8/30TL/hz/Z9izsEO/SVRS/criRc0SYMjhNi1NkcqyGWaJB8Dn2jEj6kOjZheJLi2Y9X7rkcLd2VWZibK/FRnLfu91YnSAdkmEwzsg0RJl0VlttOB+5DR79dReesW4ConSjti19oAfScZ0bcFZRF2rKfF3ThYP0KffkuGDhTI5DVydACbOFH6dMl5W4GvIq7Qkqh0dIYTpQ0r+MaudQ+wVcHLnYA9FLJ0E2MfzaCmBky563AkuLUM4pT8Ci2+gyKg2qG/HlIeLXI9/gfaxZ9G/53mDCSMtlXiBd1GxfYuNJlMoa+e+9XhztBkMN/HQ8Da9C95zTDjKONpdSKy92bkT4BdwImJF5xdcb3PIy4PFKe+ZwDLGyfvJkYJZmHdCJWpXkYljjExoRh+x+sUdyJ1A99xovRnDZ738yjDUqbt1OFE6ex71WSNHi14z3T0jBdtBl5wonSV2LWWR8/Mx+bvAvrLBGT2DMc6UfrrnHEvjH6j6iCvG5lhrlnPb2c6oM4EdjRjfgB1aB1D/nzWjbI1g/LBaxSxa72Oynt5+Aj4fHUWrYl5C3MbUXhO4HykErkseogXQ0JKNw3BhHFhygm+i6NdV3XqfCKqV+9muCm3Ir2MKRWvTwSuGCnSreHnfA64gt7eGa29PV2tvT2dE7q7LqcGKRktMJtQfN/1Ar/P/sMO/UVRQDOZcofkXqT0Whfs0F/QmHWuOxxGmvMjYtdaAYml3YVEDW8DYrObn+MwirSXUtwldBYikjZ63jtR91RZAFC92dmW4qAlr5uoEknsWi+izG6MyL5TkbZS5TORWcf8rICw+3Xy2/XbUKaoKLvRD06UPudE6a7mXO1OlG6BNnpFUgBtwCfqOXctxK61dOxaJxqfqxNi11oq57BXSk4xHmWMRwWxa1mxa20eu9YuRjSxiVHA3KRTM+owZplfZ+BubyJanLcC7mnwnJsiY7o8TgmIcPciaj3N29lNQUJdMyieEC1UjvpRI2OrF4kXTItd6/7O1ra9P26f2L3wzI7ecb3pAd/c4IBXnp+y5Iq0tJTdV5MQL2ER9L220ldDPz7xgso0+AHUp58zCbXrlsL4KgVI8XUm+p7et0N//8QL/lbHdZpAarKozLEM/VubVwLui11rBSdKu+bI4PrjSLSQ7Y2ygK1oM7GfE6V1+3pVw4nSm2LX+geaA6rvz1lUBOYGnRRvYrLgqOg+35yB7eNlqrjdqNvnkqp/34RiflEb2izdU3LefjBZnWzsD5nr5mVfpzVy3iJUeDK1onmjEzgxdq2vVP2WZ6HPXr0JmgXc40TpW0MdS53j3Zo+D6keYELsWtcCB4+RZ2OeRTNTU45dSl6bjNK/dcMO/Z8Cd6BJtui7n4ncscsW8zUR4bRodzTeHDMiiF1rO+C8CT3dU5bomrrAuN50QWDCqf/647IT01kzGOjkXI0FET/mauAx879b5biPb0F9Gi7TEKegFk4HDqNPuXQKsDxwsx36ZV0yTfTHLijbWL24tqLvdI9GTmaH/tp26F9th/47dui/Zof+KXbol/rz1AMnSmc6UeoioboDgF2BxYcS0FTgMFQ6qgxWZqJOsWpi742U69oUiWP2lryvCBb5ZaBXS64zC3VKDhb/QJ1m1RmqHpQpqw7yGoLpOssChGyDOcH897WmtJbhevqUy7PM8VSU6fraUMbRwHhXRdylJdHmdSE0J+9BhVVLEyODZqamHJVmdXkoDApNeejbqNa8BGrhXJj8zoleNEF+gAhzL6CMQhFWQgqpRRNeFyoNDBqmLOOg4O1ZI5yX4cfkBBufmDlt0lUP/fqj3Tc94rSe1tYfU/z9vJ54wT/RZy26/m5oEaoH3WjSK4Rxxz6S/OzXBFRSPLDO683vWI/iTOMUpLh7ZT0nskN/M1RGzbp1QJYV+9ihv+FwkKmdKH2TYVaNdqL0SUO8/QFyZJ6FPvNPnCh9u+rYN2PXOg3x8iozCB1Io+hzBZcpnHvKGPkoi1aNi9H9n7cRagEGTbQ3Kr7bo83J5mj+aUfz2JedKB1qd9++Ja/1IsL0r7OxAN+KXesi876FkDXCjaPYgXQc+VmricDesWsd70TpXCViOTehGdSU42a0u8/DdOCPeS+YgOAaYHv6Fv8lSq4zAwU/F2fdVXboX4hal/O4JK3ooclSwNXzW4p2K4OCKZFdgnhE3UCryTKdasa3TtF7F+juar/jb2dfss1Wx6+BdibVD/d0pGJcdv1x5vq1JPmnot3hDkbUrwxrmWPzghqL4oWliYF4Gy3IeVm0TuoUeTPPye8YeI9PQDyPoxmY9RgzcKL0eerc/TtReqrpnDoXEVkzy4kFUOPB/9H/+5xuXs/NxraYE1TuGsxEMA44JHatEys1WZwojWPXOgE1H4xDc38Xer73rDfwMC7YKwJvVHZMGS2d7YzTtgMkTpQOaWNVgeUpzthOJkek0InSfyEhyTmBzSleW7vQ/FmXB1UTjaNZfipB4gX/QZoH1Q/8DOBJim/MjZFWQb3y993AR1Xt4kejgOrDkvdlwUwm6tRh/vZJvGBQhDg79B3gduQHNQmViqagXeb3zWFlAlZtqMvgcCQ4l40tS0X/kdo+R1tTniFLkSy7CyyTeMEjNc4HGnNZEN9sr64f11A+d1xR53lWRMFLHibQgDHkXILN0fME+v7aUPv1gSg4uhN4DWVa9qEku5QCycRF6G5pqSblZHy6+40Y3Gw4UfpzJFp6MXrGf4a6nm6tNfDYtSbHrnUF6ii7E3ghdq07qwmwxgX91mEMaEBZ52kFr01l7Pn+lXVhtlFup9DEENHM1NSGi+rFx6IJqQtZB5xQotS7O+Utn9VoR4qXs2HOfbod+j9DD3TZInI4Uk59Hbgq8YIPGrh2NYrUiScB37FD/6ybWtsvenzh5b/b0TZu3Bofv8GynR9mx3QDdzpR+nEC2KH/aZSt2gkFNFcnXlBPO2VRaSPDQ4kXHJ39h9GxOQ4tDpOB+4GTqq71HDICzHNz78Ckr5uoDSdK341d6yCUDWxH80iKMmFHOVFa5JJcjYmUdwHWZQw5N8BkOA5j4GdqRc/W6k6Ublv1nocQ6bffPN0LdLSN5/h19uLShy6kbWAj1ngUMO5JVYBphAYPHcRHuBEFROPpy75uCTwQu9bqI0x+vRYFYNXoRffcWFO6vgDYgHxu0ztILLWJEUIzqKmBxAtSFFycgSafGXXYDljU73o9Ey3SRbuNTpRFKPJV+SDxgsvrvFY9+DzFXJ0e4JCdNz/66AnpLKuFXtKWVtb/8FV++O8bOyb2zPoYdXYBs7+7v1K/wV+Gf1BceppReT7DlXkIdT9lC8bOwDZ26H8p8YLbzVh67dDfHxG1K1WcO9AkEzY4xvkaTpReGbvWY4insRYKGs81af96EVMc1HSjNvE5DtPttRkKtv85yA6aTdGGKC9Qm4ic2k+r/EcnSt8x/lW3o04zumnh3fFT+O46X2HNqW/QbbUxPl87cArirNWbNSuE4Q59JmfsbUjiYg/q5FCVXGMF9Ay/5ERpv7ZsIxy4DbofJqC5YSZ6dr/gRGmtxoTRxjWoGWRb+gKbmej332usaDnNq2gGNXXClIbqdVn9C9oNFYnrTUe7jFYkyvXlsuvaof9L4HgGlrM6gF/UOaZ6UfYZxwFn0NIysbOtL+Z4dJFP9hyx/lefv/jRS7Z2ovTDei9kZPjXQx0jD2flt8QL/meH/h/QZFmZ8cpMTH9b8W+HI2Xmygk30+z4nR36y1ec9yE79NdF3+W2KFj8DXDJGHDynuvgROlziAsyKCReMMsO/e8jHahqXk0nVYv8nIAhwF6BguBeYHzsWlcChzpRWtRNlIdOyjc6uc+dE6X/BpaNXWstwPnh2ru7/1h0pZ1oaWlbaVpNrulwaTBtSfFGZwFUah9UUBO71pKIYLwxWvjHx671ILBPJeHaidInYtdaFmV9V0KCgTePtv1A7FrtKNs7zYnS1/KOcaK0J3atPYAvIS+sxdFm6tyi9zQxfGgGNSOD+1CwsjH9F+UZ6Oa+AAlSPZZ4QT0729NQOnObivPNQLXtM4ZpzBkuBE4hnw80i5yyWndrW+tLU5ZYbZutjp+UlHOAgNnWDiHanWb6IR/Zob9X4gUPmsMOQvVyjz6vpBhZIlTO5m7emAwWBj4FzPb2SbzgRVQGaGIMIPGC8+zQ70X3XEZgjYGDEy+I5+TYTCBxPQOfhX3QPXl4A6f7G8WCfdMRYboQhqPyzD9C/ylEap/y+CLLt7T1FFbvplHRSh271mT0vC2OVMnvbyBjMI1iHZqUQfLRjA/V31CGpp2+53hz4N7YtdZyonR2VtwEkYW+cCMJo559FLKtaQPaYteKkT/VgJK6Gff15q/6XK0oiJ9e+fkqXvuEea2IR9RECZo2CSMEO/QnIKLvIeiB7USdDyclXtDIDq/ynBuhGjvAn01b9LDCDv1JyKXboW8y70aT+NuoVp+Hj4CvZOWeGte4BmmdVAcj04C1Ei94teLYhRBf6L3EC17IOdeLJWP6GNgu8YKGPWSaKIeZfDdGO/XHnSgdkkWFkUBYCegYLMl9uBG71qWohJOXpegElm4kMxm71leACN33WRZlBip/bl2vB5WxR7kA2PCgF+9t3eN/j1kTerorszJdqJ16AydKu2LX2g1lm3rQXNSNdFu2q6eUZow8XyO/dNYBbOVEaT1k/erz7mrGVWRuu7cTpTfnvG9NVPJ8A3igOjCoOnYV4DtoQzgVcefCRvy+zHmOAU5lYIA7DVi/Hqd3Q9w+BW2qxtOXaT8V/SaHoaBpAbTRuwM4zInSV/PO10Q+mkHNCMOo2C4ATDUckzEPE9gcirooJiMp/DOA8yh2FJ4ObJZ4wZM1zm0Dz5M/QXYBv0q84PgGxnoufYFjNaYCS1QagDYxdMSu9TlUbpiMUUtFi/UR85IbcexaL6BAKw8fATs7Ufr3Bs+5GfBDpOXzEbJhOXcwvBA79Bcdn86a8Nf7f75Li865NHqGLgF8J0o/MkJwTzBwMZ4FPOZE6SZ1jjvrxqxuO7/SidJD8t9V85wB0ocqwilOlP6w4vjFgRuA9VEQ0IIyw190ovSJnPNvSh8PJ6tKZBy6beolN5tg5G36Otcq0Q1c4kTpwTXO0YKClE3pv5nrQKajjwIn0L8Mm6LS/JpNE8760Sw/jTBMIPPhnB5HI0i8oAM4x/zNhgkgNmEg/6EXdV49RW2sTzFhcjxq524EP0VqsW0MdA7+cTOgGV4YQ8O/MHCRPAAtlEeO+qBGDu9THNS0owUHmG2gmWkd3W28pwbABEHbD8fgEi9Qa/DBZ/8W+K1ZfFNz/n1i13oW+VTlBfztwKdi11q7HnK3E6W/iF3rabTwroE8lM5BpNjB4kPEo8lrCuiiQjrCBAU3A+vS//NMAe6JXWvFyu/cHH8FA3mNk8w5XOpX9y1zZW+jvt9zCwbSEbLx7IC4QtVzooUCqW9SrJfWRBWaQU0TjeBPqL3yK/Q5C89AE9AeVTo7RfiA8vb0hpQ2Ey941Q79zVF78br0lcpOQuW+JoYX3yV/EZoEHBy71g8aKcmMcZyLspN5QfwrTpQ+ZxbP76PFPitpjItd63Tg1FHudFkXuIk+blKP+d8iO5VutGDX1bHmROldKGs7XLiKYn+6XkQgzrARGmv1Z2kx/+bRfxO2FsWCp5NRJrreoGYG5XYV9WycdqXYlHc8xRYWE9B82wxq6kRTfK+JumGClgMRr+dqNMGdAqyaeMHTZe+twAMUd1hNYxB6MYkXPJ14wWdQF9S6wJKJF/yqziCricawBeVqqWuP4lhGGlcgc9nK+6gblTUz6X4XBXoT0K56QfP/ffPaqMBkim5HROAFUZA5hXxyb4ZWZC47R+BE6ctIMbqDvu+41/z3D6s6hdanuJtrEiIXV2IB+ryf8pBXSipCDBRxj2ZQW0wUFGAWzUc1XC8GeGo1UYJmpqaJhmAChUHv2BIv6LFDf2+kNVMpAz8dlTUG7dGTeMFbFE8+TQwPyoQd22q8PrfhLFR+qlxweoGH6Su1/oj8HfgklC0cLf2jr5M/nxctlr1I+fbBgtdHBU6UnmEcz49DzQn/Ac5yovSeqkPfpThI6Ubl70o8TbHWVTcNzF/G28pD5a8J9CUDOoFXUDavFv6I5A/y7pVZFHeXdSC+WhN1okkUbmKOwA79FZEVxFaIhHc+cGMdwoZNzEGYyf1X5E/OzwOrzQviYkYM7lnyuV/TEQ/iIZSdKgoceoCJjXbaDAbGwqDIILabvmxAGxr/TGDLaj6Naf3eF3Hn/gdETpS+NFLjrhexa01A80Rep1QHsFk1WTh2rZ+QH0hMRx1Lzzc4hrURIXtrc83fAT9zonRq2fvMe1sQyXlb+vPROoA/oCzbb6pe60KZwg2HwRR0vkEzqGlijiJ2reXQRLEn2gHd0tna9qOdtjhmGWA5tHN7qFlKGhsw6ro3o0UvI2F2oUVym8G09o5FxK51FBCQr4HUg3bnR6OSaZHH2wxg8mgEecYF/DjysxNTUdZoaWT++HfgskrDS3OOtZBr+Hj0285ExOPvOFE6x/lpsWvtiAKAdvPXg7IlZzlROoCbY2QHzkDk9ZkooHsbOKDRrrXhgHl2jge+hbRo3gTOBH5hBPu2Q+X89dB99TvEyyrz2muiCs2gpok5hti1PolaGRfCpM57oaeztb3lqPX37XhhypLZzfkacuJu6jWMAZjJeW/USr8walX9xbykp2F0Sc6gmJPyaydKD4td6wLEM6sOJrqQHsqoCD3GrrUyKrnkBWFTgSWdKJ1R8v5WpF2zHAMzTzOATYxv1ByF+ZxHIOLwK8B5TpQ+UOM9CyARzo+BZ8ZCJjF2rZaxMI55Ec2gpok5hti1LkfqrP06C3qAfy24LN9af3Y2PUUT2KrN8lQTowEj8PYIxUHCXk6U3hK71kKIl7I8fWWO6cCrwGdHsxMsdq1vIuPHrOOpEz07uzlRemeN926JOG155Z1uFKANSo9mrCJ2raVQOagXuL3SlqGJuRdNonATcxK7k9Mq2QqsOfUNJqQz6bTGYY75BLAdcGujF7FDvx3YD7VxLogEuX6WeMErpW9sYr6FE6X/jl3rL8gctbK81InMO28zx31kDB/3RvdYpo9y1XAaLdqhvybKNrwJ/C0vuHei9Dexa92DMmgrA48BFzpR+kYdl1iu5LU28t3t50oYfsuZiG+T8Y3Gxa51DnBiM4Myd6MZ1DQxJ1F6/1n9s4gTULt2Q0GNHfrjEAnv0/TtpFcBDrRDf5vEC3I5IHboT0YlhQ+bfJ65D2bh2gL4Gso+3AxcXVaCycF+qLvpSFSGSoFLgeOqPIk6kYrvJcMz+j7Yob8oIphuSF/3zzTjQD/A/sOJ0v8Axw7iUjHFEh+zgCcBYteaAuyPlMXfQRmcYbdrGWEcjjY41STwo5C9RD0t2k2MUTTLT03MMcSudTuaHAd0j7wycVG8jQ+q/KdpwBGJFzS0cNih/03gbPK7dWJg9cqgxQ79NZDo2hZoB5cAxydeMMCYruI9iyFLie1be3s+BC7qaWm9uVkqmzMw/JArkOBZJhI5DbWbb+JEaXX7b63ztSHu0Mej0clUCTv0H0ABeTVnZyqwSuIFw1IyMUHgU8DqDNxsdADroKDn7+g7nYyCvC4kfPmtuSHDYT7n/xBpOg+vOFG6wuiNqInhRjNT08ScxAnAPVR1j3S2tvHrlT9XfWwLOY63deAwipU8l0WT+LMAduivAPwD7eyzQGsl4DI79McnXvD76hPYob868MBn3ntx0kEv3Td+penv0N1ifemJhZd/9cFDzv/spr/9eI6Jm1XCGINuj3an987jpbevMVDBdQr67JegMmbdMH5WQzLsHAzs0F+P3t51aWkZ0NFk9aSTelpavwGcNhzXMlosOwJ3A0ui76oLBTL7OVH6QuxaTwGL0ZfRsdCzexDKoP51OMYywphAsdIwwCdj17KcKJ0rfPqaGIimovBcCDv0F7ZD/1d26H9kh35qh/5TdujvOqfH1ShM2noHJNPeBXROs8a9d+oau8x8aLGVslR7F9op7pt4QU09iBwsVPJad9XrJ9K3s6/EJOBndujnPS9Xbf32swv/6N9/Gr/K9HdoBcb1pmzwwcvLT+7uesaY8M1R2KF/OHI0vgi1Ij9nh/6lxhl7XsQx5AeybcDmsWstOcrjGSzWt3p7cn+jtNWylpnxQZEuzaDgRGkCrIZk+b+Pym5LO1F6Q+xaayCeTt4zMBm1Kc8N6DJ/RZjaDGjmbsyrk9o8C8P1eAhZAmTtpp8CrrJD/+jECy6aY4MbBJwo/Rsy1lsSsKakM994YPFV10QZllVRLf/8xAteHuQl7gNs8u/1ccAzFf+9S8FxoJ3+qkg3BwA79Fdp7e1xjnr+zpYJPf3FTtvopbe3Z0GkZfKDQY59yLBDf3tEiqzu4tkDkU6/M+qDGiJi11oGfZ6XCxagpUrePhNlIsa88nRLb88743rS9hmtA22HWnt6WPPjN1ao/nfzHH0FlcseBu6o5P+YY8ahOWMW8K8qflAPyrpUc9eWodifCPSMjTjs0G8BPoPKR88kXhA38n6jB3MJasOvbtfvBC4cloE2McfQDGrmPnhoAql+ICcB59ihf/nc6EztROnsRSZRoHHEMJ06QMJ+eTyBC6qyP2UcmBYGyrQvvvK0t9Nxvfnq7e29PS2oZX2OBTVI2DBPHG4ScLgd+j+cW+6X2LU2RNmm1dFvMSN2rROdKP1t1aHPUFxiGAe8PGKDHEYc/fwd91204pa5asXtvSlfev2xSZWlEtPS/XPEBRuP7vEkdq2ts+crdq3DkDliq/mbGrvWIU6U/qXGcP5DsWZPCjzR0IcbBOzQXxeZ6i6GntV2O/QfQma67zdwKh/YDJWWMwHJaYhj98PhG3ETcwLN8tPch/0pVjDtBT47imMZ80i84FnUlvs/RK78CO3IfouMCCtxFcXmcW8hyfJK/KcF2ntLvejKXxwFrFXyWi+jtMMeKmLXWg3xPdZFi+tkZN74s9i1Dq06/DS0oFdjBnB5IwqtsWtZsWsdHrtWHLvWB7FrPRi71k6D+xSN4YtvPDn1h8/+ecaEdCZtJhPY0tvD+HQWeySPssbUNz+qCGg2Qi7VE1AWqxUt2CsD15pjvob8rBZG0gZTUMbj6ti1qg0h+8GUpu4gv3TTBZwVu1ZL7FqfiV3rF7FrXRS71p6xaxU5hDcE0wV2D9IDmmLGPxHNdzc1ci7z+28EHIw8ma5HmZtNnCgtMtttYi5BM1Mz96HsN+slR/dlfkfiBffYob8c6iJZAHgc7cx2MkTfBLXN/gS18S5G/++5Azi0urU78YIPVrj4+CvSltYD867bAzNbzYIyB/EuxbyiduC9URzLUHAi+UJ4k4DTYte6yBB6caL0zti1voMW8G60wLcAdyKeSF0wnTLXIWJxtpHYBLg2dq3vO1H6s8F+mHrgRGkvrvXr3/0zPPyGZdYf/+yCS7NE11R2e/0J1v74fzOQX1qGY8n3qWoHNoxdaxWkkFyUtTsVeRqVYT8k0Pdp+jKXFgoOnkAk7C/TF1TtBbwRu9ZmTpQOlWjtoixb9SZhHLCOHfobJF7wWL0nM11sV5u/JuYhNIOauQ9XA2uSP8G3A4WS4XboL4x2OK8nXlDkeDtPwgQkj8DsjqU7UYAzAWVufo06ZtYHTkZlo3FILfaExAtyv9fuVuvwq+0N1zzg1X9sUsmr6YWeVmWFfj5Sn6lO/JL8xawbuDPxgrnFVfsLFAfs4xDf6dnsH5woPS92rSsRT2oScJ8TpbNfN23fW6MSxIvAPdXcE2AbJDlQ/d1NAk6PXesSJ0obKXsMBicu1fXxJoe+dO+nUIaiFykWP47u0wxrUZx5n4l0bhYtuc5nag3EZDi2jF1rfWBT1CL/FydKp8au5aKAppKgvQDKql0M7Fbr/DWwJcUZalCgVXdQ08S8i2ZQM/fhQkQ+XZKB2YQfJ14wIH1qHLEvRNor3UCnHfqnAj+f34Tl7NC3UECzNH27vixFfhOwQuIF30C6MzWReEEXsOmNRyzzDXvGBz+elM5cEkhb4EbgmEqu0BzCBaj89ln6+APTgffRDntuQVnHioUC035wovQD4LLqfzedPLcAi6BAoAd4P3atHZwofa7i0AMolgPoRgHTpXWNvgCxay2Ifof9zFiuAn6T2Ss4UTrDlIa2R+TuXoyrc1UQ9jwKbPLKne3m9bIsbt2ihE6UPo6CqkocS/53NQ7YPnatRYcYAL6JuDsDFch7e/jaKw98zjiM/8GUypqYT9EMauYyJF7woR36G6EMwJfQJPY28IPEC8Lq4+3Q/wTqglgUTZrj0I7nFFSWOGk0xj2GsCP9dWgq0Qp8HXETMnuF7noCv13Pff1C4MLYtSYCs7JSyJyC+d2/gbIR76Df+9Pot/8zcGVeADyGcRlyoc4jq75KneTf2LXGI27GJ+h/D0wB7old65NOlGYBVF57f4ZW8ss9dcO0+/8TkZqzLMRqwJGxa23oROmbMLsj6WbzV4SfocCnOpuRAs86Ufpo7Fp/Q/dDdUZnJjnBX4NYpuS1megz9gtq7NBfFnF+Xq2ju/EiFGROAliy8yM+8/6L0AtPLWRP2vvVh/dGtitnxK51shOlZwzyczQxl6MZ1MyFSLzgDWBvYwEwEfi4ZOE9HE3Y1RPZZOA7duifPUj9l7kVq1HcxTEJWM8O/S+hks1qwCw79K9BqsJvwuxsT0teCa9BGf4RgR366wH3oh36RLS73w24HNhnLs3OnQV8FS2e2e/XgzI0BzegZptxPqqDlRb0+++OsiWgbNuO9GW4KtGKiMtDwelIALKSTDsRBQBno+xNXXCi9G+xa52CbB2yzUtGjP+yOewwJAcxiT6F4k5Egj+ZoSFGfKM8tCGiPgB26C+CFJ8/hzJw4+zQfwzYO/GCXLHKxAsesUP/l/T2HnXU83dM2vGtp+mlhZbeXtp7e2iltzLIPDF2rUedKL1tiJ+pibkQze6nuRiJF8xMvOCjGovUlyjeUc4ENh72gY1tvEZ5R9IGaMJd3Rw3DvFrHrVDfzM79G/HCHjZoX+/HfpFE/kcgdHxuB5lozLeVQsKYvdHu/m5DqYc82mURXsd7fr/iDpW7m/gVOuQ70SN+fd1Kv77WkS0rtbCmQnc6ETp8w1ctx8MCXk/+gc0GdqBPWPXaoj070RpAKyNur9+icpaKztR+qp5PTavn4cyW8+bY9dzonSohPHTUVmzGjOAK50onQqz7887EFdpAsoWT0Scnr+b7GguEi/43jlPXnXhTm8+nY7vSZnQ08343pRWBkx/kxnY2djEfIJmpmbeRxkXoYXiFuZ5FTeRv5BkWJOBQU8b6oi6y7w3e30z4E479LcrIhLPAXyagaWVDJOR/s8tI3Hh2LUWRQvVGyPhA2Q4MieYv8HiDbTQ5hHtZ5jXM8xEAVS1g3UL8N8hjCE7R94YMlj0ac3UDSdKX6Ak6+JE6f+Ab5u/YYMTpTfGrnU60mTqQeNPgfvp33G2BeAw0MuqDZXIdweuKbrOeh8lX6G+Dk+n7sE3MU+hmamZx7HStLf/sM+rD808/rmb2eu1h1l4Zr/NVIq8juYnjKNcGbUoizOe/JbSScz5DqdKLMnAzEIllh3uC8autV7sWg+hgOAF4NXYtfYZ7usMEwb4d5W8vgPK3FQvou3AMUOxWzA8mWdLDnnVidIOUFYndq1NY9faP3atzUyWZ8zBidLTgRURafh7wGZOlG5fVZL9LMWZ4wUoaSs3masy7k4lXq7zuCbmMTQzNfMwYtfa4UL48awWq31cb0pnaxvuy3/nR2t9iX8uumKmvVK2wM+L+Bjtfou0W3ppXDBvfTv0pyReMG1IIxse/ItizlA34lQMG2LXWhX4G8oCZd+bDVxs1G6vGM7rDRVOlL5j2o8jFKyMQxmZFPh6lZ7KV8nn04C+y52AAeT8BnAiKnVWk3s7zGvErrUSIghXLuZvx661oykn1QVT9tkE2ByVia5LvGDYO/MMufnXJYd8jL7vvLVnFlVk4qpzp7FrfUS5nxvo851Z45gm5lE0MzXzKGLXWhi4rgUmjetNWwAm9HQzoaebk//1x57VP35j78QLCtO88yoSL0iBX5Cf1p9OTmtwnRgT5Fvjvp3xfqoxE9PZNYz4AfnE20nA2UYPZkzBidJrELfkF8hZ+ufA2k6UVgsllm36Whii0KUTpTcgeYapaLH/GIlCfteJ0t8bNd77gFVQcJX9rQDcZzq5asIO/QWBv6P74jS04L9sh/63q45rt0N/Vzv0j7RDf0dDiB9uXEfxutONyOxlOJ/i9vMe89r5TpT+eXDDa2Jux5ibcJoYNuxDwUI7vjftPP/xy6t5AvMTTkHKqDMw7uDmLwL+j4EBT7d5vShweWyMtUfvhxbDGfQtmB8hj5yGDADrwI4UL+5TkLjdmIMTpS86UfodJ0p3dqL0u06UVltggBbgouybhYKEoY7jIsSB+iLqUFvCidJzzcu7IrHM6nm6FQWNX6Y+/A4R4Cej0tkkVAI6xQ79zwPYob8B6lC6AvgpEvl81Q79NQf3yfJhskPHo2es8nmaDvwi8YLnct/Yh5ORiGbl79KJdGwCYAMnSuc6k9Ymhg8tvb1jYoPZxDDDkPa+V3LIT5wo9UdrPGMRZsLeHpUebky84CXz77ujlm4HpcSvQeKFN9G/zAKanLdNvODBivMug0oTbcBtiRfkLZgjDqOcvBFK6d+eeMGwk8Jj13qDYlfsGcDqWffN3AaTKXkMqRVXZkU6gN87UTqi4oWxa51MuRnq2U6UHld2DqNX9CrFPJY7EDn3NeQJVYlepIG1/HDfO3bob4Ec4tcAXgLOSbygTIdnNkz27wvIqDazsrglRxG6ifkQTU7NvIvn0G4mjxMwjXKS4nyBxAv+Dfw759//CPyxWnzPDv1NkV7Ktmgy/TtwXOIFD5vXW1B6/9sou9MCtNqhfzVwkCl9jRrMrrfWzneouAJ1t1R3s4DIrnNlQAPgROkso+Z7DuLXtKCA5izkEzbSeNtcL88eoJP+nVpFWBFlI4uCmtVRVjdvLci0e76IVIyHDYkX/A1xsRqGCV5uYYS6+JqYu9EMauZd/IGCrpweSHf/7BEbTA39k9Fu7Brg7JEgDs7NqCZRJ17wL2AHO/RbkfhedZByAHAU2tVX7uy/grqCThnB4c4p/AQt+IvT1yrfi7I0h8ypQQ0XnCj9CDgodq3D0AZhtjP2KOAqVAoqQj0k7IRi4jgoi7MOxYToKSib0kQTcwWa5ad5GLFrfRq4Fe2iJwIzemhJj1h/P55bcOlKVdEuxLn4dOIFTd+UQcIO/ecRqTMPHwKLj3a2ZjRgWpt/AOyLFtB7gR84UTpfGQwa24ODUNtyAvzWidInh3jOfZEhZBsKGrMJ+yngKCdK76t1Djv070T6MNX6TNNRIL4yCrjzsjnTgaMTL7h4UB+giSZGGc2gZh5H7FrjUPp4JeDFHTY/Zr+ZVtuuDCR3psC1iRfsO9pjnFdgh/4sirOfXcCyiRcMVbm1iTGI2LU2QkapbWgDkaJus9OdKD11iOd2gCuB9eh7brNs2PecKP1l2fvt0F8KlUo/gbRgsrFdCHwL2TK8RL4Y4HRgmcQLPh7KZ2iiidFCM6iZj2BaNDspXnhnAhPmUm+gOQ479N9E4nd5mAEsXItwadpv10eLyWOJFzTJj2McRhTuf+T/9h3A1k6U/nMI518TdfzkBR2dwAq13OANP+xLyJ7gI+CKxAueqnh9T+Q43oqybZ2oRXrPegm8cxJGkHAiMGMk1KybmHvQ5NTMX2ijvI2/3bw+z5VIRgm/QR1n1Wn+LuSKXRjQGJ7OGYh0OxPtyKfaof+1xAvuGMxgYtdaFjl1b4Bk/X/jROl/BnOuJkqxNcWWB+ORqaw3hPMXeUSBAo89kH5LIQw/7Frzl/f6H+zQfwj5Ra2ORBwvMua5Yxaxa00AfozMOicBH8WudTbq7mzOY/Mhmpma+Qx26P+bYuLfE4kXrD+a45lXYIf+BOBBRLqsDhxfAdYpS+HboX8qKgVMrnqpA9i0clddD2LX2g4ZPrahhXUW6sj6lhOlv23kXE2UI3at/VFQkWuU+Z8pS75/2Ke/9hjSfrky8YKG/Jxi1zofLdp56Eb8paCRc9aCyep+EzgGtez/Fzgt8YJh7YIaCkx25i5khlkZVHYANzhRWrfLeRPzDprie/MfMuGrasxglJxtY9daNnatn8eu9WrsWi/HrvWT2LWWGI1rjyD2R3omA5+p3t4FL3vowk8YlecBsEN/EvkBDSggacjAMXatScipezJ9nS/taOL/eexaKzZyviZq4mkKBAhntlg8tsgnF0UyAD8HnrBDf9EGz38PElHMQyfiywwbjDRB1nmVqRmvB0R26P94OK81RHwO2JCBWbJJwO6xazW7tuZDNIOa+QyJF9wEHNjS2/sOvb3T6e2dhtQ490+84LaRvr7xsnkK7TyXAz6JpOKfjF2rXrO6sYiDyA9KmJTOXOTd8VOeBt6KXeuvpixUidUoLvlZyK9nAGLX+kTsWt+JXeuK2LV+HLvW8ual3ShWP7aAA8s+SBONwXQ4/Ysco9S0pZU/LTM7+TkZ3e9nN3iJG4D3UFamEjOB/yAn7OHEZ5FSdPX9PBn4rhGXHAv4EgXPHFrbdhq9ofQhdq0FY9faN3atb8SutfqcGMP8jCanZj5D7FqfuQu+0wMLvzx5cdKW1v99cvp7h68dzhwtMuAvkHJpZUA9HumcnAF8fZTGMdwo4lTQQi+zWq3s9e2Ah2PXWsOJ0qwc9RHFnAmQzUE/xK61NXAjClImIt7O8bFrfQMRVou0ScYByxe81sTgsSsynlwNaJlujZvYCy0nrbUbb09YsPK4ccA+duh/I/GC6iAlF06UzoxdazOUPdkI/dbjUell/xEgxu5D8f2com7KMtPK0UItEv2ocyuMWer5KAC1gJbYte4CvlLlVt7ECKGZqZmPELvWemgi3KAV2lea/m77qtPeXmFcb3pd7Frbj8L1xyFbgrz7rg2J1M2tuIECM8xZLRarfzybb9mGXIZnB2/GRuEF8ifhDkRAno3YtSYCf0JlgWzxGW/+/0XAW+QbWmbne7TWh5mfYIf+2nbo72CH/gqDPYcTpW+jUsg2PfCtM1bfiT0++388tkjuKdsoVvgtOv/rTpRuiUi8uwArG9+qDwY75hJMonhtsGhw7COI61GXYB56kL/bqMEEnueh53AB9D1OBLZhbASB8wWaQc0YROxaq8auta0p1QwnAvJ3YBOBnw3ztfIwjoFuzpUYb8h/cyPORxNsv93j+HQmX0keYUrar/FpMgPNCA9A9hWVB05HfI3fVB37JYq/xxYkpvYO+SWtbtS6O9/DDv1V7NB/GvgHyoI8a4f+7YPgvADgRGmvE6UPrx6lFz6w+KovzGotTIS/Q/FiXOsarzhRer8Tpa8P5v114i8UG3mmDIOR5zDhb8ADDHTtng5c5UTpcJu31sL3KJ5f94pda1D3VRONoRnUjCEYAu2DwJPI5uCZ2LXuNYqtw4GtKV4MV4lda5Fhuk4unCidhkS+ivDI3KoxkXjB28AmiN/Q1drb0zm5u6v3ay8/yIEv51IeZlS9/wlgbRQcPQf8E3WebJV4QXUGaFmKd8vjgRXQ7vAFtDh1oBLW28DnnSj9sMGPN8/BDv3JiGC7JgoyF0Lf6ZbArYYsOxT8kHxC/nTgx2NcC+pGZJ9QLUEwA7gz8YJnRn9IA2Hmil0Rofl9889vIHXrETUbLcC6FM+vXWiz0cQIo8mpGSMwjsD3AzZ9qqQAmwL3xK611jC40NbSbairxj9EfAd51lSb9HVQ7io+5pF4wX+BrezQX9yZ+tZSv3ziyn+09fbkERmnAVHO+19FgcwxNS71HCp15fFwOoAnnSh9xZAUN0cliwS43YnS0fiN5wbsi4KZ6o3dOCR58BmUwRkUEi/4vR36ywEn0UcgHocyomO6pT7xgm479DcHLkBZwcyc9SL0/I4ZOFE6E33HJ8Wu1TqHnbrfQPN3HsajsnATI4ymTs0YQexaewAh+VoXUxHR7NYhXuMKYG/y208fdKL0s0M5fwPj+Cpqb52IJsuPgMOdKP3TaFx/tBC71sGIGF0ZwM0AHgM+50TpgG6ZOs9rIe2bpRm4KE8FPjlCXIt5BnboX4ba8PPQBXw38YJfDMN1FkJZs1bg7sQL3q/xljEFO/QXABYD3kq8oEl0LYGZ137LwI6sFHjIidLNRn9U8x+aQc0YQexa51C8Q+8FfuxE6ZA0ImLXWgEtqAvSF9j0oN3951BZI1MvvR641onSXPLrUGEW5jXRA/+cE6U9RldiK7Tw3+hE6ZhcAExL9m6oXHFnmWlh7FpfQDvJTwEfoPLSz5woLSLy1jsGB3kNLYQyADPRjnoXJ0ofGMq55wfYof8zpN6cF+B3od9qMvAicDryRWtOlk0UInatVuASYHe0kWlBWdlpwCZOlL4yB4c336AZ1IwRxK51IqrDj8t5uRPwnSgd8s7RBDY/Rg+eBdwGnAz8EglsTTGHTgNeBzYd6eAidq3xwDWo3bkXBVptwHecKP3VSF67UcSu9WOUgu9B31+KXKm/PFIBYMlYLPSdrYbKS38ZarA0v8AO/XVQeamwFb8C04FfJF5w4siOau6EHfpTUAZ4TcSZu3Juy0gNF0yjwxbIFmMh4BbgCidKB0UMb6JxNIOaMQLT6fQM+QTQTmAlJ0pHxIcldq0fAj4DJ/iZKFtTlKYfruv/BnX/VF+/A/iSE6VjotvClAgvYWB6eQYQOlH6f6M/qiYGCzv0TweOom9XnVKgDIyeQSfxgtdGaXhzBezQ3xhtjNrQc5GRo+cKI8wm5j00u5/GCJwofRFlTDro0yvpNf/9nZEKaAwOJ3/HOg7Y05jGjQhi11qA/IAGtNh8f6SuPQicQL6C6UTAM/YETcwlSLzgBFRG/AtqnY8pFnTrRaTZJgyM39ktKCORPReTzN8f7NCf261PmpgL0ex+GkNwovSM2LUeAL6NfISeBc4eBY5EWSt3LyIvj1Rp5ZOoO6SoDLDmCF13MFil5LUUEXdfGKWxNMHs0sck4N3ECxrufEm84E7ETcIO/QsoNnsdS6JzYwW7UbyGtABfA84aveE00UQzqBlzcKL0XsTR6AejVnkisD7SG/klEDlRWqtNux78l+LgoZM+DYiRwFsUS/qDfKnGCt5AJOs8tCNRtSZGAXbor4Rajj+Hsivv26F/YuIF4RBO+1dElM/rQOwG7hjCuedFrEDxZmQikhJooolRRTOomQsQu9b+SFU2a4FeCrUK7xq71peHQZvhZOB35GvHnJUFToYEt7IZwwvDoQnhROk7sWvdi9peq+/H6cA5Q73GMOJspDNSXYKaibq1Bng0NTH8sEN/KeBhlGHMSuhLA+faob/gEFqxyzgg/0m84PE6xrYacCqwA8py3gj8MPGCeTGD9wLik+UFgTOAf4/ucJpoosmpGfOIXWsyCmgyMmOGycDnkZfSkOBE6dXAaSgrMxV1PnUClyGTSWLX2gVpozwJPA68Zoizw4GvA/+jT5q9FwU0NyFi7ljBxchzqdIOYSrKdB0ypwY1H+Jo1KVXPX9NAk6xQ78s81eGnSkmCq9S67x26K+NlKC/bMa3ADKHfNQO/VVzjm+xQ39LO/Qvt0P/Njv0v2eH/uKDHPucwJ8ZqDqcoYex9ew2MZ+gGdSMfXyBYqXfKah1cMhwovR0pIZ5GHAEsKoTpYca/ZjPoZbr5dDCMRlYBrg0dq2dhuHab6JU9f8BV6PgYUdgnzmsENoPZiz7o2DyV0hh9WvAuk2xu1HF7hSXLHuBDQZ53m8xMFtZed7P1Xj/LxgYbLWi4OanlQcaG4YLUMnrq6g1/wfAf+3QX7fRgc8JJF4wE437ffo2JNPN35cSL3hvTo2tifkXzfLT2Mdkyk0gFxquCzlR+h6yMKjGTynuTjoTTcxDvXYnMloc02aLxm/mIfPXxJxBmRJzS43Xc2GCjM+UHNJGn4ZT3vvHId+ovGe1FdjFDv2WCgG/HVGAXFnKnIjIyNfbob9Kdqwd+oug8trriRd8WN8nGh0kXvC4HfrLAnsgvaRXgasTL5g6Z0fWxPyKZlAz9nE/+R4/0FeiGTEYHk3Zzne12LUmOlGaK6Eeu9YyyKjxbeRJ1BRGamKouAypNOcF2p2oPNoo1qG49AQKNsq8oFop33xUZ8WPIF8eoAVYAtjADv0XgAuRaeNMoN0O/euBQ8dS0GAMV/M2Q7Nhh/5ayNttK2Su+lvgNzlmrU00MSQ0g5oxDidKX45d6wbUPlk5iacoqIlqnSN2rSXQTmphNDH/DU2U+6N74A/ANSVqtN3kKx2D0vIDymOGC3QpsBOSnW8DXo9d6ytltgJNDA2xa41DXSkfm7LevIhfA99Eth6VZagO4LDECwbTEbg0CoiK7vOPEi9Iit6ceEGnHfpPI1XuPPy9ymZhmZKxpMCSqAy7hhlT9jn3AFa2Q3/TWrYNJvu0OfANFCjdDVw02mUhO/S3Rpuv8fQFjqcDX7VDf8vEC4ZVBduoRZ+IlH2nIk7iBU3vqvkDTU7N3IGvo+BlBtrldKLyxya1Om5i1zoMEXzPAk5B3Rgfod3ul4EvIj+iJ2PXGqBXYzIrfyTf4bsHuKXAmPFqFNBMoE+caxXg3ti15iYy5FyB2LVaYtfyUVv5o8DLsWs9aPy05ikkXvAxsBEKbj5AQfPfgZ0TL7hukKf9N8UBTQ8ixdbCt9EzWo0OBrpbP0QxV248sCjqNKwe03hgLbRgF8IENOejjq79UUPBDxFn51Nl761x3tXs0L/ADv1H7dC/wQ79z9cxjstQqboyEzYJZXDdwY6l4HqfBx4E9kSBqoPmvb8ZscAm5nE0bRLmIsSutSCwEvCOE6X/q+P4TZG2Rj1KtzOBq5wo/XrOeZZHC+VC9JXCZiFy4MZOlP636vhVUZdUXnlgBnCqISY3UQWzCGxMHz/hvnpE5Ywn1bH0L2n0oiB4TSdKXx+B4c5TsEP/JkQCryYhdwAbJ17wTB3n2BZpSK1s/uk/wBGJF9xXddxqyFy2+tnsRLYDzwHHk1/S6gV+nHhBocGtHfo7IXJ/dYmrF7ViO40adNqhvwvarIxDmddM8fw3iRccW/Ce9VBmuIiP9FjiBZ9uZBwl42tFz8yyOS93AMclXnDBcFyribGLZqZmLoITpR87UfpEPQGNwXHUZ9gHmqj2NuWL6uu+CqyLdn5vIEG8C1HXz3+rj0eLctEudCJaOJqogh36yyG5/juB81B24BWTTi9E7FpT0AJYvYC1oEzZ0cM/2nkSX0UZlA7zl8kb7F9PQAOQeMEdiResiRbWZRIvWKc6oDHH/QdlEz5CgedUFPDfhzIrHeRnR0EbilqllCMp5uwsTXGZLBcmy3ElCsIy2kKLucahdugXkaynUPw5IF/jZrBYl+LGiUmoDNfEPI4mp2bexlqUkxfzMIUcBWGz0/+W+StE7FoOsC/lrbFvNzimeR5ml3k34sNUpumnAPfYob984gXT8t4LbIgybXkB7HhgF+C7wzfaeROJF3wEbGWCyI1Raeuvg+FiJF7wbh3H3Gz8kbZD5aZ/Jl7wHIAd+teg3yxvju5BPLgylHF2uhFnpxHsRJ8nXTUmAAeT3xH4JMVlvVkoKzVcmEx5AFXYvdbEvINmUDNv4wVUU643sLGADwd7sdi1dgWuQiWqok6SDpTlaaI/tkVkzurvrQV9n/shwmMeOinPunaUvNZEFRIveAp4apSuNZOcDsbEC561Q/8i4ED6Z1ymA+cmXvBijVM/jKxP8ub48UA9pbSF0ObkLRR0FT3TrRQESYkXTLVD/xfkZ466GF5vqCcoD6BuGcZrNTFG0Qxq5m2cg1oo89LQeegFPoV2Vw3BOFRn6ekiTAeuRRmJJvpjPYoNE6egzEFRUPNPFNjkpfI7UBdNE2MUhnfiAosDdwFXJV7QgcqGDyCS8fLAS6h1egU79K9DmZGLC7qZzkHltOo5vhO4PfGC10rG46B77bMoK/QRImUXbY46yPGrq8CJKIPyLfO/bah54YDEC14ueV9DSLxgmh36P0PfWzW3rBPZnDQxj6MZ1MzDcKL0zti1zkZ8iza04++m+HefhQTIBtNyvTN91gHV6AUSpM1x41jRqoldy0bqtBOBe5wofXgODucttHPN0ySaiWwkZiN2rc2BHyENoQ+QfcNX6fMHA/EuYppy9WMWduifCRxOX7vzbsBpduh/NvGCl1Dm8ypz7PGoFbodPcM7ACfaob9d4gX97l2T6dkLbTRA2RQLdYntVzKeZVGwtCB92b8JiJ/3JgPb6HvR/VloJGqI7t+3Q/9KpFXjoG6zRkvj9eAHZjzHofmoHdmYfD3xgldG4HpNjDE0u5/mAxieywHAYmhC+Rz55You4EW0gEbAtU6UFnm7VF/jULQTKsrUXO9E6XB5RQ0ZsWv9CPDRpNyGArqH0QKzEwoO7gXuH40gzA79BRAJOy+rNgNYyyxyxK61L7JoqAxgOlCnzZsoMJ2KBM5+4UTp9JEdfRODgR36OyBuTPVvngJPJV6wQcWx66JW5Tze1NuIlDyAT2L8qr6AykcPJ17wbI0xnY02H3llnKnoGfksChwsc+3dTcmu7Lw7oSxtmzl3D8qenIJKUEeiTM7iwPPAKUNoz8+IzasBH2fPTRPzB5pBzRyEKdnsj0zvuoHLgaszEbzYtbZB2hLrAu8B5wLnFejC1HvNTVCbd62S1DS0m9q6SC246rwbAvcUnHc6cKITpb+oek8LYDlRWtQpNSKIXeuLaAdbPdZuFCR0ox1eB+pG+oITpUUk3WGDHfoZJymb+LvR4nF84gXnm7GPR1o0eaWmacBBTpReM9JjbWLosEP/VhRw5KED2MB0SWGH/q8RGTeP1zIV2DPxgiGTbu3Qfx7pSeXhY0Rqfhc1IbwJPFKHCGDGy8kj6s5A5dMN6b8h6gDOSLzg1IY+QBPzPZrlpzkEI0D3ECLYZYvrpsCxsWttBuyFTBOzB31h5KS9a+xaX3CidDCqqThR+o/YtSJUw8+u28vAVPAUxK85Hji5jvM+ErvWM4gbUrnLy9LTs0sgsWtNQKWTw4EFYtd6C/gJ8MtGDSxNO/OSwFsNBB4nkB98Zc9DtnBkXJbnYtc6GbhiJLMeiRfcaJye/w8Fsv8Fzku84F8Vh21NcRfKFOAgpE/SxNjHJ0tem4VKPf8x/70CxUTdrE17OFC2YWoFZhmScj+ish36K6B7b2VE2A0TL3jHvLwrxffseGATBmaGJqGS1W8TL2h2SzZRN5o6NXMOP0Ou2JWL6xSUMj2V/gFNhklokd11iNc+EgVNmchX0YQzEcnR14udUIo8Uz6ehgiBWzlR+iFA7FqtwK2IzLcgmpCXQp+5bmGs2LUmx671O5S1eAJ4J3atyAQ5tVC0E82DhRaXc4DnY9daroH3Noy77j3zo7vuPfP1u+49s+Oue89sveveM6vJw7V0h5ptq3MPnqSYhzYe8aEyPILKw3loQVnV4cClFGvgTCeHb2eH/gHm+t9Bcg4nAS/aob+VOeQTFPvXtVLcsdSNuHpNNFE3mkHNHEDsWu3AV8h/mMejNHNRSWYK4NU4f2vsWpvHrrWbUQPuBydKe50o/asTpdujdHKZqdzCZdeqOu97TpRuDayPrB22BVZyovTpisO2ReTW6sV5MvC12LVWrHUdU7a6FU2gE9B3MgHYG7jdvF6GesULq8f3CUbQRTx2rXVRG/4pyL7iIGQrEVQc9gDFi0AHIgw3MXfgTPKfvZnAXVVeU78mf07oRhyUR4ZpTOcDr5sxVKIDOKRa3doO/eVRp9RE+u7LieiZ/JPhtjxRMPZaaKH4Xh8V2KHfbof+0nbo1yti2sQcRrP8NGcwkfKAchLKchShkA9jSlfXokmlBxgfu9YtwH5OlHaYY/YAvo9SxW/VGOvT5j3jEf/nYDO+v6Jy0RvVb3Ci9D/0pc2rsWfJ+HvRzuzcGmPaHJVnqrMYE5CfzNaUt42fiRaJelvdM7QBm8autXTe5x4KTCB2A1JEzYIyC33XR8SudbMTpfc6Ufq2yVC59M/kZQanTQ2gOmA0WHZF2cJ/JF7w2CDOsQJ93JLHGrUdSLzgETv0D0P3Ykpfd+JTVHUoJV6Q2KH/ReB6dH+0oef7ZWCnRq9dMqaP7dDfCM0PX0dz1cPADxIvuD/nLQdSPJdNRJYR30Xt6I16TrUide1Rhx36bajsfhT6XVrs0L8aODLxgg/nxJiaqA/NoGbOYCpS7S1S9XwBKCpzTKfAXM9kZW5hYAliB6RvsXvsWiehdsdsQV8A1dHzWr07gB8ZDsw9KGDI3rcacGjsWps5Udpo6rsok1Jvi+e2FAckk1H2qSyouQLYEi0cWStt5tBcK3vZhTI2wxrUoI6lxcn/DiahkmGmBXIU0g45Ci1s49DC4zpR+sEwj2uegx36X6MvkGgDeuzQfxTYxZhl1nr/QsDvURdhF7p/3rJDf/fEC54ufXMVEi+41A79PwFfQlnRB6vbsyuOvcsO/SVR4L8kKgU9OFwBTcV1PkA+Yrl+TlVYiYFeWRnGocBof3Ou86j/Ge8A/px4QZ4Ny2jg98jwt3I+2B/YzA59J/GCUW1uaKJ+NIOaOQAnSntj1zoFkWOrF+cORGTdnoF2A90oIIoKTp3tKqoxAdghdq2N0K6pOsPRjgKbmfSlwy3gaCdKb41d61hgHfqXjMajSesS5JhcL65Hn6uI+3FzHefopK9DqRop5eW0zHn8kNi1LqgYy60oGDoQfT9Fk2872nUON5amWOK9hYog15DETzDk5RWAD5worZVxawIwWYgLGFj+3BiVFr9Ux2n+hMit4+l7liYD99mhv3LiBQNsRspg7Bnq0hJKvKALPUNjBY8De1As5ZCVj85Cc9eCBcd1oDknRYH6eShbNOow4oPVAU2GFVH5v5kRHaNoBjVzDuejhexY+urX7cAPnCi9Nnat65EGxFGoLNOO3G4PdKK0aDe5BcW7pi70MBYREy3gd0iyfSYSo8vk9Q8jn6DaAqwdu9ayDZhs3oZ2mJ+mf3A1HbmEv1DHOa5HvJM89FLbFwcAJ0ofR5Nyhj+ZQOc75KuxzgAucaJ0aj3nbxD/olzi/Z/V/+hEaSciejdRP75DvnLzeGB7O/SXSbyg0NHcDv1PoSC++jnL+B8e85dy7SVAoVt4BdrQs7Y+AwOg6ajL8lKkp/OWsY+YU/gq5Rnbo2kGNWMWzaBmDsFkC74fu9Y5iAOSAndlC2bVbnx54H0nSmuZ5JW1PraixbHMv6XVidIbcl4r2l1l71uYOsm3TpT2xK61HapXfxPtcN8Ffoo6wurBoig4y/ssrYjoOCg4UfoM8PXYte4HfoEyQq3m76+UGHrGrrUBmuC3Qtmiy4DTnSjNk7Gvvu7zsWv9A9iMgcHNLDOWJoaO9ShesLqAVSm/fzaiuFtwErANOUGNEcFrSbygNIs43DAE171RufVt4JJaAnyNIPGC942I4F/QxqfI6mMcysb8kb4sSPY9Xgr82pTRxoJQZK32+MVHZRRNDArN7qc5DCdK33ei9HonSv+UlwFworTTidK4joAGlFYvmhSmIxXaohLHVHKM9Qz+UXLNcZTrbQyAE6UznCg9HpFiJwFLOVF6dgMaNV+nODibgTqHhoo/oDJfK33ttb/JhBGrEbvW1iiTtjPiKX0C6c08GrvWInVec0/gMTT5T0dt8VOBvZwofX6wH6SJfni15LV2agfE71P8DPUg0vBs2KG/nh3696Dfc5od+o/aob9lnWMdEuzQXwnpyfwKZZCOBR61Q7+ezErdSLzgARQInEFx23k38J/EC/ZH2ZrvoVL4WokXHD7cvKAh4tYarw9bUNjE8KOZqZm3cDNajPegj7My0/zt6UTp07Fr3YmItpXlpJnAaxQQkBFprkgbpxeJ6P21+oXYtRYEuivKWP1gslVFk2AZFqY4ILcYolZL7FoLoHLPcvRlTdYFbohd62AnSn9fdXwLMo2sTquPRxo830aeNKVwovR91F21ASrPvQf81ZSZ5ijs0G9B38Fk4MnEC0ZcYXm4YT7D5YgPU/1bpcBziRfUCh5voZhv1Yk2Dtn11kaB7uSK92wA3GyH/k6JF5SZQA4HbkDO79mz0mb+jrVD/+7EC+4ZrgslXtBlh/6piJO2PAO/o1mIJ4NRSS7qjhwL+BMKQvOaEVKkw9PEGEUzqJmHYAjIHnA1CjSWBO5DrdfZDvUrqKX5IBSQWOghPqzEruBDih/yfiRWgNi1dkRidauY//47cGSVXs1QcCvKiOQFL71AXutpIzgEWIZ8ldPzYte6tuq7WhkFL3kYj3y3agY1GZwofQxlbMYE7NDfBnEnFkaT+jg79M8BflitWzJWYYf+nqi8uRj6XXvNXyuST5iGno1SJF7QaYf+V9EzNg7Nob0ou3ZR4gUPVhx+Ov0DmgyTUDlxvRpjbgE+jzJ+yyBhy18aRd9SmIBqZfKD/0mojHpPrfM0gsQLeozH07306UdlAfnhiRfU5H+Zz7wX2ggsi7IipydeUNbNOKxIvCC1Q/8LqJ18PH2/30xUJhvpYLSJIaDp/TTCiF1rFUT23RBpSpzrROkDc3RQQOxaE9FC/G4t4mvsWp9EhNS8enk3cLkTpZ45dhck01+ZCepFi8aGTpTGsWstgbJJC6CJuiHTSDP251HQVhmYdwJ/c6K0yE+n3vM/ibq98jAVeUH9o+L4tVCJrihD9KYTpYV1evN9/Jg+McEHgROcKH2w6D3mfZ9CweuqiHx9nhOlNRe8RmCIsf8gn9x5ZuIFw1rKGAnYof9lxG+q/gzdaOH6A/D7xAvq5nPYob86cAzi2PwPlXhuryyj2KHfSTFxfxbwCdP5lHf+FqTx4plxt6BFdRawW+IFpfotdujviDKsCxUc8lTiBeuWncOcZwrivh2IPsufgXOqhAGr3zMRBYgbou/m8sQL6uLc2aF/IXoOKjdQHcB3Ey+opV81rLBDfxn0fG2GJBx+nXjBfaM5hiYaRzOoGUHErrUzWuDbzV/mTHumE6UnzcGhNQwj4Lc1AyfpDuAzTpT+y5RhXkBtj9VI0XfxAMoUZfoqXShg2jazUqhzPDYypdzInGM8cB3wzaH6MxkPqzULXv4Y2NmJ0vsrjm9DIoaL5hzfjTqmDi641uIoIKmWku8AvuxEaW59P3atwxAhdRzKts1E3/G+TpQOm6qwHfpXoQUqb8c/DVgi8YKahqdzCiY4eIl83lcvcFPiBUO1HSm69gyKibOzgMWLdHEM7+av5GdHPwCWTLyg0KfJDv2VUUdd3vUz7s8rqJz26zx/JaPH8wzKErVUvHcasMlwEo7N9TZC2aO89vBOwE68oCbpvon5G02i8AjBZBOuQg9otli1mv8+PnatokzAqCN2rdVj1/Ji19ozdq0iUbt9gEfRYtuBMhbTga85UZoZLi5DceeAhQi8P0ET7SSUZZmMRP0ua2TMTpQmTpRuibIU2wG2E6X7D5Ph5B8o5vq0UiVJb0pRPvpeKtGLiMtnlFzr26gkUq25Mwn4TZ7lg7GSOAdlwzLC9Djz31caLtNwYUuK54kewBnGa40ElqRY5LIFCeiNFG6iWELhqRpCf9+kWPvFQmWpQiRe8ALK+OW1RreiZ3VTdN/+xw79tXKOuwSVgFqq3rsgderqNIgDKM5sdVOfhlAT8zmanJoCmJKAhUoHg0ln7UK5Wd3BqCw14jBeUzsi7suzSIOmJ3atSchS4XNmrD2AFbvWD9CEOhm4C7jTZFE2MyTWjdFu8S9VQUQt5/CMg1CN8cC2sWst40RpQ+3YTpQmQGEqfJA4F2nzLEr/LqsO4Id5xF0nSi+MXWsWCmAWNO97EjikhvbOVymeyBdHQVtc9e9fozzQ+DLFAo2NYirFgWo7ylyNZcykfPNW5ko9VJyAAu4pOWNY23QhnVTQ+bMU5crbi9Vx/b2A2xG3bRy6N/IMUiegrOfscpSxCSjrItzADv3FEy+opyuzXixMcVdjO02z1ibqQDNTU4XYtbaMXetfqPXzJeTMvOMgTrU4xc60FtopjThi19oEpZovQ2WfG9BnWgkJSH0OTWyTEcdlEipr/Ai1XF6P2pIXBpFYnSj9tROlV1dnRZwofRO1kOahG2UtiibqLkRsrBz7MrFrrWWyXsOK2LVWjF3rkNi1Dopdqx/J14nSd1BZ61a0KHahVt8jnSgt1NJxojRCO9s1gOWcKP2ME6UDXI2rUHSPQJ/oYjVsCoT6emDiNfaGvh36sR36f7ZDf4sa16+F35Dv2twLvJh4wUioKw8bjLpv0W8wC2VTR+raMdoA/C3n5fGoxfq7BW+/l2Jl7DbqIJKbgGMDRKo/kWKftxZgVTv0K93rP0W5pUErwx9k3Eqx512Kmh6aaKIUzaCmArFrfQa1Ra+FJp3xaKG9zgjGNYLHKM7UdDD0Dp2aMPoot6KMw4IoeFkASevfg3b0RQFDG5rUpiB+ycWxa7XErrWpKVOtUfC+wxhYhkmRV1FZ99M4jIZI7Fqrxq71IOLnPAi8E7vW6bFrFe3i6kbsWpYxhPw36ob5BfBS7FqnVJZ6nCh9xYnSnYFFUKBiO1H6u1rnd6K0x4nSV01gVA/+THG2oEgx+GEKJv/O1nbr0UU+6aAMzy7ALXbof6vOseThAvRdVf6ms8z1v1bPCYzT8WJm9z8ncCgab+XzOAtlGy+2Q3/I91U17NBf2Q79E1FGdjL5gn2Tge/ZoZ8XoP6G/PuiC/k91cVnSbygN/GC+xIvOIvyIGUm/bM/vdTOvB5ih/6q9YyjTvwB6QBVd2F2Ag8lXvD4wLc00UR/NInCFYhd6x6kBpuHfzlRWrfLrFkg/4m6aCp3271ogV+xEWLsYBC71reA08ivzXeYsdTrVN2FFEkXQYtDO+LY7F4tDBi71saoDLMFmqCuB55A3SJ5Gapu4EEnSreMXesTaCFfmP5BdwdwsROlQyrZxa71Q7Q7rv5OOlCp6IqKz/ADZDT5EbK1OL9IfK/Oa6+IWulXRN/dJShofBIFnZWLTgdwuBOlA7gLsWtNQSTPRSrfk9LCWxMW5ICNv0FvS7/1qxNYKfGCQZlw2qE/AXW/fIM+n6yzEi94ucb7JgIB+sxtaJG+APj+aMvg26G/BtIX2Z4+rtNi6N7rQJnJC7JSkB36k5EY4gqo0+76etWA7dD/EeKqtNLXPl4UUEwDPm2yOtXn2Qgp8C5ozjEOZXD2QqWi5ZDeSz+HcEOO3gZ1Ti2MyMB/RN/9zuRvZjuBpTMHahPovUdx9xT0GeH+IPGCYbGGMB1HlyO+TxcqjV0PfKOR7rQm5l80g5oKxK7VTXFNtxtYuBEiqulsuQEpaGZy++8DuzpR+tTQRlvX9S9F5Ls8zEQTbVn5oxLZjVI5Oc8CngI2KuMdxa71S7Qo5gVQmWP5Zk6U/s8EHT75GaROVNZpqI4fu9ZOSMF0VVQWLPqNYydKV4tdazfEMZhI3+ftQMHH1k6UNrwgG/2g8+lb6Gage2JH9PnPR62jPahM8F0nSgtLI7FrrY26YxYGWma1tI57feLC7d/91Fda3p4wgCfcCfiJF4ya1YJZWO9G5ZfK33IGcE/iBTuN1liqxmWjrqDqIHI68KPEC862Q39zRPJtRffsNPRbfSHxgkcogdE3uZ7GNgsrJF7wZt6Ldui3IrHAJVCmc4IZW9Zp1wr8FzmMJ+b4yxEfJmsFT9E9n3UJVqMD2SccXnXtfRA3q4jzVfn+rWp9N/XA2ElMQZ9zKeDlZsdTE42gWX7qj1p28rXSsf3gROm7TpRujvgZB6Fd4gqjEdAYvEx+9wNognuN4hJZNVoYuNtsB1ZHC1cuYtdaGe3w8yb5bpTRcSoMMXemuCTWhSb4uhG71gmIDL056oIpKzWsFLvWhSgNni0IGSahrNs+jVzfjGElpKY6gT4uTFYKvBF4wYnSz6HMwXLoHinlepiOsxWQ0vPhp66x63XehgfmBTSgRalsxz0S2AKpIlf/lhOBrezQ//QojyfDt+kfrGaYDPzIDv0lULC4IFpcW9DvtAhwm8k+leE46g9oepE6c25AAxK0S7zggcQLbkDB7n1IsXcB8zcZlcvvMgHNviigqRT9y+75yuCkC5G8O9HzcXTOta9CJeqnKfa7ys57ZNkHrQU79Be3Q/9KlBV9HWV2jwf2t0N/vaGcu4n5C83up/74ExKFq174eoH7BitX70TpvxEvARCvA+mSTB2mFuQi/A5NDEXYlT5diKzun5cm76E4AG5Fi9dDBa/vVnDO7L2LVmU+yr6PFgbydQoRu9YyqIRUpBVSjTaUsi8KfCaj4PTSesdgcHDJOdtQIPdHI4JYtwO48cq6F+BvoT8NcWgWyDl0GuImjSZ2onhxH48yVI+O3nBmY1eK3dB7UdBTdK+3o0X+ipLzr1LyWiW6UEDh1Xk8KGAZx8DnqQ11qH0eBSf1BFW9qG383rKyZOIFfwX+aof+3sBvyTe3taj/cw+AHfqT0PyxHH2Z48WREeeeQJcd+g8g0cG6n/8m5k80MzX94aPdS2XGJkWLwoCdTKMwRNvjgXdQl9B7sWtdF7tWkY7GkOBE6ctIEXMGfRmbGShw2M0EW6ugz/0X1CF1JZpsZ9KnBPwuxVmqbvN6Edopvs9aUHBXid9RHNj0kN9JUoTdKd9h5qEWaXQwHR8rU7yQtiMi8lBxI7qvqrONsxABu1SBdgSQUvzd91A7K9oP5tkZl6fb0yDKOFGtaGEtCgomU3vx/g/Fn3sWyno8i9SC10q84N8Fx+ZhE4rvv4nIdqHIrqMaMxFR2rVD/zU79KfZof8P47idh2cp3gR3U9xhVg/2Q1nUvFK4hTZdm6MSbRNNlKIZ1FTAidKXEP/lcuR3NBWVIjasEJgbCs5CZMVF0CQ0Hu0cHzbkz2GHE6Uhas/8GfospwIrO1F6t3n9YydKz3WidFcnSr/uROl+SAzvh8ApKNOyHcWLQQsKiIpwG8XdPS3AvrFr/d5o6YA8dR6nf0Ym89Y52InSRnRFJjO82chOyj9rER4jvy0atCDU9MSphcQLutHE/w9zrY/QeO8Dtp4DHk3XU9yS3I24ZjURu1Z77FonIdLqDNQJd6JRcR4MLqH4t5iGvr+ibMB0VNItw5kF558J3J14wTqJF6yZeMF36rUOqMD/KN5cWCigeZz6A/kzUSbTRs/KZ4Dr7ND/ZvWBiRc8hQKbvGB0JuoiHCy+Qu3s0gRgb6Ny3EQThWgShUcJRszvFfJLIdOB45wo/fXojqp+xK71I1TKmoiC4Vnmb28nSksX+ti1bkSp8SI+QgdqquUsAgAAgt1JREFUpf8LIh4/g1rDD0cB4D+BU2p5IeVc9zMoQ1Evx6EMPShQWMOJ0iK9j6JxLIHa06sD1x6URVnZlJIq39OCSjSH0WdM+isnSl+pdT079FdEfJsXEy+oefxgYTpVdkE77NuqHa7t0L/avF7ZadYBXJ14wYG1zm++gz+jTp7qc9zsROmegxjzAkgR+pP0cUyybqi9UJnuNfI7BqeiDqHZmURTOlkceCezi7BD30fdVC0oQzcN/c5bD0WszvhNlbVy/xMJet5ZMP5KTEefO28z1YHsL/plTO3QXxqJcdrou+tCc8HXEi+4rp7PkAc79G8GijJElfgY2DzxguEyxm1iHkQzqBklxK61J3Ax+TVpgLudKN1mFIfUMGLX+ixwBFowHwV+4UTpf+t43zjkWHwM5dnBaeb1fwM7NaD1UnTdFsQ52azGdWthJiIuft2J0kFlVWLX2gpxtrLup5ko+/D5ahNKM+7f0X8HO9P87VjpOzUaMOP5LMoq9na3tN7whS2+vRstLcegwCwjkV8HuCZrlLUFH4V4KkshAuhPUet0zcxRjaC0A3XMPWGutRRys94WlVV+i0qVawDvVeq6mN2+T59Z5IOo8+kf5vXtUaYJ8/p08zl3yQwNTcv3L1DpJEW/66XAMYkXzLBDfzn0+y2I/M7uGGq2zPg5/ZviUmYnEtNcBencpOi7q773O1CZbP2C83yMApUBHmIV7eIboLLzdTXsHgphdIt2RY0En6f4c2XoApZLvGBI80KdYxuHOgs/KPPYamLsoRnUDAMM8XdNNIk8V73rNsfshia9oqDmFidKB6NcXO8YP2HG+C7wbydKew2X5xhExutBrr6/dKJ02FoozYL4VaSeuh7lAmAZZgJPOlHar6vKuFJ/B2lYvIOcka/K+74r3jMFZUmWGMTwU3OdzzhR+mrOudtRp8nayMX3mjLtodi1JqBJfBm0476j4F7ZEXWk5C3mbwHLlH3m4UTsWpkz82Zoge+9dcm1Zp3jfKFtVmtbNf+oAzk4/2CYrn0qasXPC0hT4CQnSk+1Q39dlMkaR18mtBvda9NQJulVYG9TRqkJO/QXRQHLKqg8eGXmqG0W9r+joKAy89qJylfbFFgfDAl26C+M1MGLWqyzMu0ziNC8CeKsrWf+ewrajPwQ+D4KTvLwMXBw4gXXDtPQB8Bkfe4341uAci0fUFb4LtTOfgx6np8HTkm84PqS9zU6ronIn+4gdN+lKED+XuIFg9aoamL00AxqhojYtfZHfJUJ6KH8CDjMidI/Vx23AFqQ8kow04Bv1GrjHeT4JqBd215op9OGvJKORtyhBeibJDuRZsoGjZZYCq7dgrJTe9F4CagD2NyJ0sfNuTLH8/H0kXkzIcPvIK7EdqildiXkl/QTJ0rvMCKEp1Nc/spQqcWTORlvbrhW1Z9tNaTDMsX8dZj37etE6Z/NZ98alY+yCfw841VViti1/oyCnzxMRS7hjRCmB43Ytc5C2ZbZJM6vbXQQyaQ8Q3JAC+JiWbZmiNeuGdRss9Xxp6GgY1XKF8VeM7bVEi8Y0r1th/7nUKCXV7qZDmyXeMGIdJuZUs22lHPFuhB/p3CTZIf+EUgYMe+57ETaOUOeA0qu/zcUdOV9jt6K/21F9/zbKIjZkoGlyDMSLzh1GMaUaSt9hv7B6gyU9dthJILVJoYXzZbuISB2rS+jgKHyIZsMXBW71s4ZGRfAidKppvPpp1XHz0Ap5UHXpGvgErRATqDvQXUQf6WF/t0+E9DO6XS0UxkqNkJtmbXq+3loR6qpj5uMyGU552lBKeJfoZ3nYvRN0ssDn41d6xSkpPpdc87qe74HTeLj0UKZpcBbkbbLYbFrfRftanc1x/wRBYRL0rfgZtf9fexaq5vrufTp3WwEHBG7Vj3lo7JuuF7qMzMcMkyWa0DJ8M0JpVzNcUgY7u3BXNOk/VcAPrpLHV3fIn/h7UL38JoMdJLOQwv6jQ9DZP2hYPuCMYEC5+0Y5hZ6wwX6OQqUa3XojQe2tkN/ucQLXis45hJUghtP/2eiAwjLAho79BdEJaMDzFiuAc6vVyTPcL4+TXFAczMKuPZEm65b0WbrjwycAyYBJ9qh/9vECwZ1z1Ug01bKM/3cDD3DDw/xGk2MMJrdT4OE2YlXBygZJiJRuX5wovQ8JN72OJqU30IdCFtnXT2xa60cu9aRsWsdFbvWkHxVYtdaHpVHqjMULWhCyZsc2xmEwFwB9qd+jZi8cWxp/v9WlE/k41EQU73QTEKEzQWQQOBd6HufjnZ/FyMn5fPMv1fX9CcjUbGHULfOUWiRvR0tpHnPj4WCQpf+AmiZUup1dXhY3Udxt9k4dP+MBo4n5zMuNKumVMhHjV7IDv1W45X0LiqRvLLNlsed/fyUJR5mYDdSRhR+gj6rg3owAQUkQ0UXxaKVKcWCl4OCIQi/gDhAWUa4FrpQ9ioXiRdMRc/EbWi8HSiT9RN0nxeNZTHELzsFbTrWRs/QM3bo1ytNsALF31ELIg3fhbzFXkP8pr0o3hylFGc2G8GOlAer9ZCZm5jDaGZqBo8FUAdFETbM+0cnSm9EO9B+iF2rFfg1/W0NfhK71lXAQYPkUGyEJo9GA4sJsWu1lFkf1IkFKQ6cUzRRl5UNvhS71jco5iHViz2dKP05sL0x+VwESDLRv9i1fk7xd9SOOAlZ+aWl5FhQ8FLdrVOJCShYu7vgdVDm6VAGcic6gVvr6YAaJuQaVu7+v8e47JOfpWt2F/5sdAFXNcI9MBmIbyHOVX/rgpaWTb+5wdc+DB/53Xmf7Hj/YAxxEzgHLb4g/kgtGf9KfNDAsUW4DpU5837jzOtsWGCH/i5IiqGRzwi6X0tbxhMveB3Y2WReFgbeqIMUewoK6Cs3ABPM9X6JxEtr4UXKP0+r+VsYfc/roI1ImYhno99PHmahYDVv09FDsTRFE2MIzUzN4JGJ0xWhUVLZkYhQO6Hqby804Q8Gg+pKAB6vFdDErrVi7Fpr1NALuYVihdwuVJoqu84kFIA8TO3OiCKMo0Jl14nSD5wofbFKxXg8xc+CRf3+WKD7IusIKsLiZScwpOTtEfl4Kn2aM7cg8upoIXfXulfyCOt8lNDW0z2Lvt9vGuqo+Va9J7dDfwrKgp2ASn3V31krLS2TvI0O6kAZmQlOlC7mROlpTpR2A5iSxxXUpzQ9DZE+hwRDNr6KgSKR01HpZoA55WBgjESvpPEFOwWeS7zgP/UcnHjBx4kXvFpnl88B5D+LFrBrgeN49fVeQR1h9VxvEvAF5NeV60xvMBziktdTPG/Pok5tpSbmLOb7oMYolS5UIf5WdJwVu9a2sWt9NXattYxlwh3kp6G7UZ25EXyX/EVkEvCdQSqp3kNxmryT/Ae4A5EzcxG71mdj13oO7ZAfBt6KXevQgsOvR91D1ZNXJ/CAKR+U1eEzRWOfwQc1KfCJ2LXKeCh/oXzCbPR6f6F4cmxH6ftSOFH6ANID2RHZLGwMfHmEbTWqcQ85909bbw/B03+YNTGd9UVUwrsUZXU+nXUI1Yn/Q6WIsszXBKR+3VtiJPp/iG+R+RllAU7l2Kejhe/PDA8ORgHc8+Z6z5lxHDFM54f6yh0per4yUb4uxNO72A79RoLxelGLH1eLjJ9hH/TdTUXPeVkJcbz5+x8Dy1YdwE31BnDVsEN/UTv097RDf0+kI/ZH8sudV1bKAjQxdjHfdj+ZIOFwpKi5KJoArwWOqXaBNvosN6AHK+Oj/BNNapmORrbodqEU9wZOlBZ6qlSd36L8oU6BKY14T8WutTDaVe2MyiGt9KVVpyMy3s1I5TjLtnQC/+dEaW4rp3GGfoiBE1sH+t4G7IJN2/iliBeT8VauQR1iHUYt9jsMnAxnokX1bdSOOhiycYZM4XVfJ0oHaG+Y7/8VGrcr6EGffQr67noRwfp+RP6u7o7pQh5iX6jn5LFrLYdKUTuZc78DfN+J0qjBcQ4KpoX+Hwz87meYcZwzlPPbof8fRFqvhQcSL9isjvMti8q+HyNi6bFIX+ddTPt/4gU1TWlNd9ORqLz8CPCzxAuGrPrcKOzQPxCVdMo6BzvR83E06orqQYFzluHbMvGCAd17QxjTE4hLk4dXUddUXYuKMeD8PPqNNjP/P2+j3Q38GBH+L0A8wWy+/A1yoG+oNGQ6nU5Cc89MNK+3I4Lye4hPtjQKpH4C/HYOqHI3MQjMz0HN6WgiqJywZ6J25085UdphjlsGpdWrF6iZaIHfF9V990ATypXAzxoRjotdayEUCBVlY6YBC9bDcTHB2oHo4c8CsC4U0LyDeCznAtc6UdpjMlTrmLE/5URp4aQfu9a1aALNm3jeA5bM3m/0TVZHAdQLqKtqKeDVSi0X03J+O+KtZN/xDBRATqNxPk1lW3Y1ZgCrVjiCz0bsWo8iQbF60YHKJh+hsSfA5U6UvmnOtznKVE0wYxqH2kL3dKK0ZlnQZJaeQaWqyhp/B/CDoQYU9cKIBkbo90vR93oqcOZQOVd26L+KvJbKMB04MvGCcCjXqhd26P8EZVyyrrVu9Kx/NU+MbgjXGYcsSDZGQdcViRckRqX5e2g+GYfKckUl3pnoOb8QZU2rg88eNHetNVytyHbo74Q2f3kbm28mXnD5IM+7EX3mutXoADbNNIYMD2tR4K3ECwZlMmyH/sGom6w6YOwAjhjK/Wa6uw5B89+/UEBU1IXWxDBjvgxqzIKRUGxZcIwTpReaY09BQUvesbPMeTpQi+8FTpQ23PkRu9YxaDdQlC7+pROlNQ01Ddn4MsTNyUPhol7nON+luJ14OhIj+y/a5Xzf/LuFOhi8IpsDkynZGfFFFke7tsES/2ahRSAvqOkCznCi9Mc5Y3gYEauLzllJIOxBC/2hZQu7+Vxbos/0hBOlzxcdm/PeH6CgKe++mwYs4URpkYfRsMIEyqujBeeZwbrVV8MO/QtRl1jRoj0DBXabj4bwmR36n0adZ3kL63RkHTBkl2g79D+JsnkLIb5XFwp8T0MbrYXomwuKROl6UDYpy14cRP73OA2JAf5zqOOuGP8BKIPUasZnAScmXvBLO/THo5b2hYGHG+EX2aF/PeKSVevQ3Jh4wXB1ZGbXeg2Vd/PwcuIFKw7yvPuikqyFgtIutBnYO/GCwfjGNdEg5teg5stASHEW4E60WzoBcRrqWWBnoBbtDRtV5I1d60EkRJWHFHEpanIBYtc6CLUnF423EzjVidLTGhmfOffWiKhadu5VUED1IwbugKaj76Y0jW+6vb5C/XyvWkqk1XgNfY7QidIHY9daBfgm+p0d8gPLbGKyzF8XCmY/P9gAsRZi13oKGZHm4SPEM7l3JK49WjCy/0+QL2L3AZI7+HnmqTQK47kA6a/kdb9MBQ4aDpVdO/SfQvo61dfJMmHV936v+Ztq3vM2sHtF5uJvyMw0Dx+jzNoKwIooo/Nb0/k0lM/QjrJMFgpeOu3Q3xmRtjPbjDaUfflK4gXT7dBfCZX810fZ2/MSL3iy4pxtqBx0DNoIvA2cDZxdT9mwgbGPR8FS0RzTC4xrVEDSWHW8SD6vqANYpppzZof+hkj6ItPjuSHxgmGVBJjfML+2dNeqjS6OHsYJ1L+4TkTy96fHrvU22jlNRpyEHzlR+o+S95aRYKdT7HZcjWMpD8AmUKJdUYTYtb4OnF/j3DFKo/+AfA7AeBQk5rYJV+CzNEZgb5RAvRz6bb4au9ZDyHKhDQUzRRF+9eduA1YG/hq71nr1lmFM5uZLqDw4GRGKL3aiNK/NuGwSb6nx+lyBxAtesEN/a+Rz5aBSTzdwMgpmRnvHtSTFekgWKnkMCcbSYeWC6xRdO/u9v444Ho9WfTf/pliddwrSTcqENj8HHGeH/q6JF5TJCpTCcFj+nv23HfprIK5cdZbrc8ClduhHqGOsDc13WwH726H/vcQLfmHO2W3Gerod+q0jyGGZiTYmRaTmGQzu+TqA4vmoF23WLoLZnJ4LEX0hU0n/Cvrsnx0GIcH5FvNrUHMXxaWe6cBqDE40bhzqiqjUhtkO2Dx2rQFu1maRuwQJWBWhFXEx6sEyNV6fgVyw60bsWpNQ9qeMqNuFeAirlxzThoiMtfA+tXkWQ0UrCiqqvW8aCZCywGZDRBovheEu3Ywk2LPMxEaos22TalNLRK5ejfyJt5d5RNk08YJHgXWNAeQU4L9z0EDwXgaWPyrxyDBcYwXqFwusRAtwawGH5FdoQc2bzzPNlwzZvHS9HfpL1VPWMz5YeyNO3JOoHFT9Gx1L/uZsAiK670D/79VC93Zgh/5NiRf0M8YdSVJu4gW9duhfgsQMqzcsXagtfzAB9XIUrxuTEPE4w76oA6zyO1nAvP9SmkJ/g8Z82dJtiJo/YGDrXicqIQ0l/ddK/xu7Bd24FxvOSyW+DexOcaamAziuAe5ELcfsHhRENYJtqL1r6UWBT5FwVYZ62pHPZfgUWUe6W6GX8kCu8sBv9ioLVVlqmYR2/1HOWy5CrtZ5LaxHlrQ3z5VIvOC1xAuencOOyJfQx2+pxEzgKROADRUvMLjN5H+KSLGJF/wLlXVmUL9AnIVKrrNhh/540+LcWvFve6BS61nICDMCXrZDf5Wq8xVliqBct8lCvKphhR36q9qh/0U79DcwWZFq+KhUVDknTUNz6AmDvOwTFEtDTEP8sAzHkp/Rbge2skN/MAa8TTCfBjUATpSejSL159BD9yFamE+q8dYPKRaUK8NEBnbXFKmSggKJfZwo/U0D1zid4sBhFjJCbNSBux5Z9qystSOaAPMwAxHoaiEjHg4VHeZ6l9DX0j3c6KWGaiuAHfr7vDFhoZ+15GddLGDj2LUqd3E4UToVZXJ+i3gRKfAYsIcTpZcNeeRNDEDiBR8iYveLaBHKRA/vR0T24bjGv9Cc00i2pgOR78vOGyEj13rnJgtlXrBD/xN26P8e3WdvAG/ZoX+04Txdhu7bbJ5awLzv1qpgoUy+oo3igKedYsJuw7BDfzE79O9BGaVLEfH7WWM1MRuG27IByjDfinh2hyOtpcGKll6N5tnqoDjT26pUki+Tj5hJ/6xOEw1gviQKl8Fog8TkpxE7kF7CW4hjUh2QlJFWPwZ2cqL07+Y69WjTLNBoh0vsWj9GZLte+ngizyJ/qVyJ+Ni1lkU7l0zi/DogcKL0f2axfYn6yNL/RWnwO9D3lwUnM9BCsYkTpYUidyaT9T/MZJuDeknB05F/0HZIkfhlBu9BVYReNJEvV2ZhYYf+14Hzr3/g3EkLzyr8KXuBTZ0ofWiYx9jEIGAW60+jheXZ6tJI1bE7o66ltdF9dynww8QLCu0Y7NC30WK7POUB/AxEmD4y8YK6rBfs0J9Gua5NhmmoxPEE8DQKLCpL8p2oVL0e+ZnkacDOiRfcZ677RSRnUX3tXpRxXJAKZe8KTAeOS7zg13WMuRTmd3sE/RaVY+5FkhMrJl4wXCKbRWNYFwVIk1Eg141+wy9UCgSawGurgtN0AkubILuJBjHfZmqK4ERpZqBWXZrqQZPMRU6UXoIUgKeiYGUqIsneSHHppJUKI0Kj5/J+yVCm07jVAk6U/gh1IR2PApXPOFG6bklAswLa1XwTTeJLm///VOxaKxoBwUuoT4Z+iiFEb4gmuDdQoHMyNQIag6VQK+hgMAsJ6D2MWl23daJ0phOlb6GdWFEAWU9Unym2Zqn96WgXv3ONgMZC3RuTnp+yZNmFWhgeV/QmhgGJF/QmXvBI4gU31ghoPESOXRcFJwsifZKHjAVE0fkTlNksymqC5pT/A+x6AxqDekQCu9Gz8gCSUViCgRzDCai7qag03oI4ZRlupM86IrvVZ6DnZCc0F+Q9g20Mg8qzaZP/FeoYrB5z5tc24hYjppvLRvY230a6XivmKB6fQX5WvRO4dqwFNHbot9ihv64d+puV3dtjAfMrUbgWPPQwevSp4D4D7OdE6fsATpSeG7vWhag9sRsFLEua49roHzBOB07LBP0q8AsUeOSp6XYD3bFrdaDd3wmVonVlMG3G59X1SbXoLkz/HWM70so4C2VvDkc7naMo3gWmiICNaduu1eWUh7I2SyjP0nQCvhOlV1X+o3E63zznvSkqNR6GdpAWClynod9vvPnv8WjCPhm1Xi6LAqdL69AkWt28n78u9Sk2/ODlsmMPjl3rdSdKT6pxzibGAExb8M8ZmK0dh+4RDy2yuUi8ILVD/3aKdXragdsHQVj9GdLMykMvesZeBHYwhNm9KM/s9JD/TPagDCgwm3z7DdTS/Q0UKN0BXJR4wbt26H8eZYQWrjpPC3CzHfqfbrSFOoMd+icgjmRZmWsKyow0Us4fFEz7+S01jrnVDv2TkEFoisadom7Zw0Z6jI3AdCheirLeKdBuh/7PUEZyzKksN4OaHBgS5uGxa30P7ajedaL05ZzjutBNmOH12LU2RSTPDdEN0InEsS7NudQZqBtmKzQ5Zh4ole2jk1EL8Odj11o/JzDqh9i1Pokm1BVQCeayomDIlHu+SHF76Rdj12o1WaUTYtc6GaXav8nAibALcXoGDSdKPzQieJvReKu2hVpbq3EFehirJ+ZOtHtcHpGhV0BZpXvRTuscxK/4CKmyvu5Eqd/gmGZl131l8uLMbGllfG/hHNACHB+71q1FIoVNjCkU6UqBnuWvURLUGJyNdJ2q5+FO1OlUlskpwhJoU5SXYelCm6jzKoKlWk0AeQFNLyqp9NNJMue8m3wH+gnkl7DHIf2cXZHvUkOwQ39b4ERql5e7gTcbPf9IIvGCs+zQvxQ1i0wC7k284LE5PKx+sEN/LeAmBgbvx6Dv9KTRHlMtNIOaEpideENtnCZLsXnsWoujxf/byCPqWGMEeaATpY+bY2fFrrUL0kr5EnrAv8nACWk82v3tT4nLcOxaLuL6ZGqWewKnxq61nROleS3AlX5QecjE5nrMeDtj1zoOTWjfpa/b6R3g606UPlN0ogZwCPAgyp7UWx6dhZRu+7WrmwBv7YLzTAaOcqL0YmTTkL3HQfYXk+lLyR8HeLFrbeBEaSP6Ec+jsuTyr01chJlWO+O7SyuKE1DpbK4NaozA2mnIAqAVLXDfS7zgiTk5rhGARXnpsibZPfGC50ym5ErzT5lg3X3oWR8MykpGAK1V2Z/LkAt2EXpQMJSVcKahstIODe7St6P4+1oALewNBzWozF6PL9wspIc0pmD0aEY8ezQEnEB+MDoJ6R39ZLTEMetFk1MzctgX3RCLogVyAiLd3WdUbAEw7sMPOFH6HeA2ijk5kymZ6GLXWhkFNBPpm9Qmozr/TXku5E6UdlOuW/O0E6X9WkTNeE9FO8Lt0CTqAE/ntKw3DCdKn0XZq3rT7p2ICL1rzmuLUd7iunjOv52HvrPK72sC+rwD7BXKYBaPQ4COtNXidytszozW0n1EK8qOHRK71mBdyecYjOfNo0hEbCKaDLcH7jfePvMSHqJY62oG4trUROIFN6F7az/Eodkg8YIdhkBofZnie34WA7uUrik5HrSBWQllQ85BpZHlB+FY3U3xM93L4GUcqlvL887dAZxpOs+aaAxbURygp9QpaTGaaGZqRgBmQTqF/B3EBGTBkEcMrVVyKXv9EIp/z3Go0+HGnNeOB/7EQF5PaRupE6UzYtd6FknZfw3d+B2xa/0M8YeGong7DU1yRYqfGTLRv7BA1fe/FC88vcA/jVryCciR+V1EVs4LztpRqaCherepnW8HnPaXpdfdor2n2/Je/jsTerqLfszJaPH4qsmwzUndlkZxOn38pAwt6DOdi4LVUpjAeBuU6elFpP17h2qeORSYrpodEFdkccQduwDZgfyY/s95NypZ1r37NgJ4NX2BjDWBA0xPvODlgsMuQv5Refd9LwPngE+gDEaed1QHcFbiBW+ie7JsbJOQ9so30abgceCkCtXim5BfVB6mI5LxYPACCrry0IsEL4PEC+oVMO0HO/QXQ1ny18o62uZhlAXXbahRZkyh2dI9Aohdax2kbZHXwghqcTwCmT6uglrEf4U8px4hfzGfDnzHidLzC655HWLa52EGcKwTpRcUvHc3lKFY2PzTh8ARTpTeUHA+YtdqQ7vVteifnuwA/uBE6deL3lsLJqv0LuUO3b2o1XyVGqaSv0ITdl7QdgNaPOtpgQWY6UTpYI02M2PIfVEJsdY1pwOHO1Gax8Wa4zCfZX9UmlsW+O+2Wx67Xk9La9H3MwtYvEwDJHatiahTbX36vp/piLe285wQHDQBzeWIe5Z1fXSioHsrpHVyMsq29KLF+8jEC4bNE8yM4UgUQFloMXkZ8BIvGCADYIf+oSgIyew/OtGu+ouJF9xljlmQvtJTF/q+LfoyJj3AH8w1SjcohjT9d+RnVfmcdQDfSLzgSnPc6QxsNuhAc+UOg1HxNZyaGxj4PM0C7ku8oB4V87zzLoqCve3p4yjdgJzIx9xCPlKwQ/8Y5B2Wt0H/d+IFa43ykGqiWX4qQOxaE2PX2iF2rS8aV+963mPFrvUNpPNS1vY2EU0oG6CFe1W0i3mKPm2DSsxC5m5lC9wTFHtEpYjsmgsnSv+EJL43MH/LlQU0BjujXWP1IjYJ2MuUwwoRu9YGsWtdHrvWk7FrXR+71mzNBpOd+DnFbeRdKPDarY4d/LfR5NyJdhVZC/5xKAisN6ABBXGDhindXUkfibusFj0ZOHQo1wNlPmLX+mS1uN8w4EKUrVgHlfk+09bTUxbw1SOqeAoi2E+hzxRxCiKOnzjUAQ8Su6PAt/J5noA2LNciY9zlUFCzYOIFXx7OgMbgKJQFW9hcdyKwBnBntagcgNF8WR9lx/6EGhJWyQIag5vQgj0BdTq20VcG+iGwXuIFX6vTSPKrqAxRvXGYBFxggh7Qb3gomotmIi7eY+jZ/L4xhGwIiRfcYT5fFmhS8f+77dDf22S46oaRYrgXiYlOQHP0BHQvVIsOzuv4NWrAqJyLZ6E5dDAdriOOZqYmB4Zw+yv6ZPbHIb7K8UW6JCZt/kfg85QvlJ2Utx6CHsgetMvqRqnZ45wofbdkzEsj7Ym8BzgFFqujBbluxK4VUixvPgON93yzo/8CYssvj4Kv/yCBwMzIrde85ydOlJ5szm+hB2p/9B1kRMXnUIo9qrfF3ZzPRjYF01BG7BvAT6ld4srQAezgROmg0tg542lBrfJnlozhGSdKy3zBal3jq6gtf2G0gXkeOGSo3VWxa30akVn77d6+t/aXeXjRFeltyd0rle7qzPPzEcWbgfedKK1rczGcsEP/bmDrgpenAZtXOk2PwPXb0eK/UM7LKfD7xAsOaPCcub+fwTTg24kXXNjA+e4Dtih4+WPkKF4ZUGGH/mGo+6s6m7QfcFuj5FM79FdA89ER6HNlz9Q0NN8cjLzxXqrFB7JDfyc05+Zl2qcBOw22nDU3wg79Caij9hD0fN6GypIvzdGBFaDJqalC7Frbkm/g+E1UEjmj4K1fQFyAWgHNx/SpTRZhHEq7bwc8UCbwVoFWiol4XUjp99w6zlMvMuJf3q6ll75W0bPo3wK+GgMzhJk/lh+71tVOlP7HcHK+YRSSt0G7g1uKRARrwYnShArypilxlWUqs11fC9qVHDRcAY0ZT2/sWlei76fo+rcXvFYTsWvtg7Iplffx2sAdsWttWt0p1iAyZ+F+OPilv/HkwsvTOZAv3oE6AMswgfIAcxEjL1B3x43xMDoUtTEvi4KDn6MJuV5NlDIPnhRxUkYSDsX3qUV9JrHV2IRift4Uc866gxrK26lbql+3Q39VFNBU/t7ZMTcAs+zQ/yvwf/VmvRIveNkI8C1A/+6vKShr9U80p7bbof8sCrReKzjdthRTByahsuN8E9QYz7ELzN+YR7P8NBDVxL8Mk5GjclEq06V4l9mL1IPPNn/1eBtNALZqYBLfkmIF4kmIEzCcuIZin6lW1HG1AVpUJle9VoQ2qlKaTpQmTpRe6kTp7wcb0BTgNooNL2ei36wV7SLHAefGrrX8MF4f83kuJL/M1oWE1BqGyQKdRTFR/eTBnLcCGf+iH1ae/g7nPHlV9yc6P34VBb2zkBjllxIvqBWgZeqzRXizkYDG4AKUCVsO/ZZLIpG267MSgh36rRXlkTw8SLEa9QRgpDtqWim3KBlMO+1HFOvTpGjz1gj+WDKOBRj4nB1M+aauHdgFeMQO/UXqGYDJaO1Lfjt7q7neQuiZWA915BXN5dMo/s1nUZ+6ehNzCM2gZiDWKXmtHaUw81AU2YMW/2OcKP0+qmXXU/OrlOWvB501zluPQ3YjuBNxTKons+nAeSYz4lGfZ1SGdkZ+5wuA0dS5mYET1Cz6FIWziXcK6oq6bjDXil1rw9i1zold67exa33ZkKwzHIM6ZbJFfTryHvucE6WvDuZ6KCuxaMFrWXfRUHAbBV0Rq099c+bVD/1mD3P9JRIvWLuOgAbDjTqb/AWjA/hJIwM02YADGBjYTUJ8sKdNaWka0GGH/mt26B+Uw5c4i/x24xnA9aYzaERgSJoPUR4ALGiH/iFVztqL26F/rh36H9ih32mH/j126G9W8Z6bKO4K7EI8oUbwG4r5fACX26Ff+RlWKLl+BgsFId+scwyTqX+usZAgZ9FG7yqK595eBjkPNDE6aJafBqKsrt9G8W7yLygtmVd+ygS1cKL0mdi1bkelpbJ0e0pjYlS3Ufx7TgOiek5iFtwj0GK7JOqyOB0pE88Ompwo7YldayckwncEIou+ipjy2aS4OI05bk9jdNO6+yBy6uHou2tBJYo812ALWNtYY4xHHRtX1jDobEEdFHuhXX2rueb/Ytfa3InS90yZ7duxa52EOsk+AP5TbwuzucamqEzxKnAPWpjKvvehdhHdiHyLVqL/zrgT+IcTpY8MRgoXBS5rIgJ3tkj3Ar+ntjpvNXaleNPWir7rStjItmQ5KlRSjUDel80Ysu90HJLBHzG/LiPKdyq1OV+LoU6nrYD9TGbjMfTsZr/NVsDtdujvib7Py8jPUmb3xd/s0H8b/R4XJl5QurlKvOB9O/RvBfYmv6zVjua7m81/P4IyMbVE8yYizaOgxnGgBod6DW9Bm9BNyQ9QnkNE4S8w0O7mnMQLXqnzGk3MATQzNQPxa/JTqd3A3SXk1MsQX6Y6bdkB3FBls7AXcLF5LS/NOR242InS5+sdtBOl01HbZ/VOtwPt9mrqYJgF8lqkCLs8WrxXQyTpM3OuOdOJ0lOcKF3SidI2J0pXcqL0dxUL8t3UnyHKfJeurfP4IcOJ0lnG+mAxJNW+sBlD0cSYEeYOQFmFl2PXWqPkEgegSXkSfc/aAigYuLhqLB87UfqgE6XPNRDQrICEB29Fi/4NKLBZCpV98jALLdCDhhFt3BwtUl2Ic9QJXE2+CGK9502dKN0fLVDfQ1yYTzlRevAgSk8WjVttTAa+W13ySLzgVhQk7IkI5muYLqeRVFI9mfqUckHj3s0IHB6Nsp3VZZiJaLPxB3S/VwZLmT3LOHPNCej5Pw94oEZ5LsMiFH/fWekvw++obc+QYYrpRqoFm8aC9S7kZ9f/JMrUXYKIz5XrYw/wu8QLftjANZqYA2h2P1XBaGXcg3ZyWdalAwUsGxsX76L3LofarjdBD1g7WryOzdPYiF1rEipn7YwCkmXQohQAlwxGcCx2rW1QS+Y66KH9FXBBPSJusWttjnagedmmTmC1RkoisWtNQeJYi9N/gphpztdO3/f0X2QV8Qra1X0GZcWuMU7ho4LYta6lf6agDL3o8zl5v1XsWk8h1+A8dAHLZAapgxinhb6z5eiflcl8eXZDv+VE+j7LLMSXWN+4lw8ZsWstipzdX3OidEzod5hF8A/ofmoUHwMHJl4wR0sMduinNLbp7EEk6C9RLEaXdRE2kj3tAY5NvODnZQcZc8bvkk8a7gC2qPQ1skN/U7TRaqNcj6oTGXBumXjBgCCk4nyfQSXxeiUaOoHVq7MuduhvCfy14DwzgKXmJ52auRHN8lMVjFLuFmiH7aFF4Trgd3lZGqMe/DVEiF0QPVjfRQ/yy2XlCWNO+V+U9v7FMI3/Loxb9iCwF8Xp7l60UP4KZgd/+5i/HuRfc40x+czGMi12rc3Q97cKWlTHm/Hth4IdB3jVidJ/xa61BMow2GhS6QKC2LWOc6K0Xtfx2TBaOd8w134MZb9qLeZnAjtR3y65BWVFNkTdFdVYtuS9M9HudVBBDVK4XYyBC1QL2nGvhiwsfoSCxCxDc8ZwBTQAJigb7GcYKfyIcj+jWhjRnZ7hlyyPlIGLfotplC/21WhF92zZnD6Y+b4V6eT8vMZxv0GKwtWYBTxTbdSYeMGDRpdmB7SJyO2oQ0HSKii7s1vJ9R9GpfLVyQ/aMrfxHhTQ/KCgjORR/Ox3ow3okDKdTYwsmkFNDkxW5QrzVwgT0NxJfwXUFZC2ynZlAc0YxTjKeQjtALFrLYK6QrLgA1SOOD52rc2cKJ2avcmJ0v8C68autSbKRMUV2Z4PUVCX4RpgZfpIhNmu76cmq/UFc46HEYHzOSSQ9UU04VyDkdTPMffcCTmNf9EEfrlwovTh2LWOR8FbPTvlHhS85AU1McVuzu2Il1III/p4NBI3a0WluZ85UfomysQVBaBTgI2MWefetT7AvATT0fIt6i/dVGMcg98UlMKUNg5HpaXxQJsd+k8BByVe8HTV4b9Dlhz1kl+nAncwtGCuCAvXccybiIeyc9W/pxSItCVeMMsO/SeQH9VfUJY773cbB+xgh/5iRdmaxAt67dDfAZW8lzLvmYmC/B+gAH9N9Eyek3hBkVbTQhSX0SzKRVWbGANoBjVDg4vq/5UPYrv5uyJ2rVIJ/zGIv6AMSt6D24O4G6BsxooM1INwEPH2W9VvdqL030iZMhexa62EJp68roiJSB8o24GtgQLH11GXzRS0uz4AGYYeRZ+5Z+U5AG6IXWtJJ0rL+BDLoQmxTH8jQzvFas2no11ddSq7E5GMpw58ixC71lJIdXjRinEcDRwYu9ZGyFqjk/zfqgsYblXbuQVL0lh5pRpB4gUfDtNYqvEt9HxU3g8bAn+3Q3+dKj+nHyG9lBXpbxnRggLcynuzC1mGfJ3i7syh4OE6jtmffJFCC80X/bhWRizvSrQh7KJ28JZlxAtlDhIvSOzQXw11962DVNj/mHhBI52ft6DMZt5z1YIaBOYITFC8IfpsbwC31yJxz49oEoWHhkMp3hEuiXYGcxNuRjuZar2bDiR894zhcuxHvh7EeHI6QmLXWi92rRtj15oau9Z7sWudZxbtSqycc90M1TyAFhSQL0/f5JNJ6m+NUuFlC1thGrtC6beegGYW8LhxFh8AJ0pvpE/CvQMFSpnXzZE1zn06En6rHMd4RMj8JeKMFD2/vdTZ7TYP4gMGH9R0IZLosMOQbX/MwAA3E6frZx5reBsboc7CO1FZdioKzttQBmQ6ureuRwH9dtR331aiG33uIl2WmdSna3Qs+TyUdmBbO/QXz/7BDv0FkJ/XxvTZNEyg9thPskO/1L0+8YKexAvuSLzgnMQLLm8woAFl56cxkMg8A7h7EO7kwwI79JdEm5y7EVXh98CbduhvPifGM5bRDGqGhjzp8gzdNV4fczDtxVujHVQnepCnISXirIwxnnKNiclG8h6A2LU+i8zudkZBx6KI5/J47FqVHREv05imTREmITuEoslvPOW72XbKNYdAi8A0VP7avexAJ0pPQwHb8cgNfAsnSrczfKoy7EN+JtVCPIROxEPIgiXQPTcDOLKM0D4vwyxif2bwbeu5/CA79C079NewQ3+VQXr/rE0xV6edgWUbEi/oTLwgQropK6KyShbQ9yAi/cqJF3wV8U4a+cypOUcbfYJymdZMNs5O4IDECx6o43xlz9RMM3bs0F8WGflWu7nXi60H8Z66Ye6fTVDHaCf6jjtR6XfPkbx2Ecz9djO6hyabvwXRXHrzYDyz5mU0y09Dw90oW5D3PY4DquvkYx6mJHJg7FqHo1r6e1WdUzNQ6aNoEnupqv32twzMZrWjB9JHejg4Ufp87FpPovTqUO/LzGYib+fYRUkZzInSmbFrvUOxPP7HqDTwKHC/4e8sgYKWfdFG4S/A6VkbvxOlr6NyWF0w2aKyAK8FGOdE6Z9j11obcS/WQd5O5xdljuYjHI7KGkvRl8mrpWEyC7ipurPF+N4cicj/49Hv+5Yd+ocYM8V60Un5It5PvM4O/XXQfbY1+e3S7ebfM3+v93OOKUJP1Viy8u1bqIy0F7Aueo62tEP/scQL/jvgLH1jzcq1RRiHzCXvQV2NtbzvyjBYrlTdMATizezQXx5l3F9IvGBOkuE3RKX9vM1kG/JkGqpK+DyDZlAzNPyU/B11B1pcCjkTI4HYtRwkQf5JVAePnCgtbIMsgxOlncCbsWtNMQaG05DBYq/xYzqHgUFDSoWeTexay6AsRR7GoQn5mIp/+woS31sM7eRmokUk+6sXr5pzVKMHTf631Xj/T8nXCZkOnOxE6c+zfzBGoo+hIC3LDnnA3rFrbTKYAMN8x48Dny445JWMhO5E6UvIHLQJg8QL3rVD/1NoZ/1lFDCsAay3eNdUlpnxIW9NWJC3JvRLpL6DgkNgNuE4AP6PgQHmisCNduhvU0I4rca/UWmsqFV4topvRVtxZTt+HiaiIOQs9Nx0UjvLmJq/6kxm5r92DAqksnGuDXh26O+OvMg2RS3jLwEPoAX3TopLR1mW4zbU+j+UNWccalAYFSRe8CqaS+Y0imQhQN/7Z0ZrIHMDmuWnIcCJ0hh137yCFv2P0AT1a5SFGDXErnUEcsD+FtppnQy8FLvWoG742LXGxa51HZqI70bp2BdNi/aFFGc7jjPt3qBJqEw0rd/Ow1grOCgo+DkiVX6BxkTUMrHB5+njsMxAfIRXgG3qEHL7GUr5z0CTclaKu4qBRMWTUQBVuUi0ocVlKAai3yNfBLIDZQ2aKIEp3VxuRPK+uu6Hr/7gzCevTi97+EJO+dcfif55MT974vcsMnMa6B5dAHjcDv3VzSkuR5y5oozZBOA+O/SPrqcclXhBL3Ag+v0qy1BdwGuYTJ45V4iCinrm5xZz/hRtCmqVoN6juDQ7AfFyKgOvdhTsXIv4dreasd5i/vs69N3lZRG6UOn5PpRVGkpA0wFcVtICPy/jTcq9uubLUnMRmuJ7NWAW6F1QKvtJ4G/VHU2mXLAOqnM+5URpmTEfhnPyDeA4tHt5BRFKrxik4N6aSHo8r8X3XWBpowJb7/lsVDpbOOfl6YjTcQf5E/40xOmIzOd8jfxSVQpc60TpvjXGchOaaPMmzey76qLPgLLH/P8sy5KJdx0N3NWIMm3sWqvQx3W4ybSnVx/zMcW741nAIkbtuWHErrUHWkAmoc80C/i2E6UjQmadV2Huwyd7YPXWioW1mxbemrAgX9/4YHpaWqGvBLMNyr7VQ7rtQJon59QzFjv0P41sGDY37w2BMxMv+Mi8viranNRTZpkBnJx4wWwbATv0v4UyjXnPy0z6E3Srkfme5QVpvfQ9Yxl6zLFFQd1TiResa4f+5ai5YCj4BXBcA+7qQ4Yd+lNQU8FiaH590ASnowqTNXyTfD+3DmCzxAueGNVBjWE0y08liF3rC6jLBDRJdAOvxa61reFJALPN+J5s4NSXIuXPbEe0JsrurE++gFUtfJNi8u544KDYtaaj0ssdeerGVfgjxdoUE5AnTSakV40pqPUyMv5QxyLNjeqAawbqBimEIRJvQ/Fnm45KLxmXZQmUGq/kC0xA5biVnChthAORaezUEkUs4770mtfrDmpi11oY/Z57ocDvdFRK7EIB86hN6sMJw03ZA5WBEuCqelqnDbH0OPS8dKMMyi8TL2jEsX0bYIXWqvmujV4WmdXBZ9/7L/cv7oAW5wWR2Fy9we8k4DQ79M9LvKCoe282Ei94lHIriQnUZyEwCz3Pv6n69wtRhjPvmelBGeQ7c17LFuuiACUveKmVSVrVDv0NEQ+tp47ji9AJfDjKAc0eaJ5O0XeZArEd+l9IvKBRF/Mhwej57IbIwm3oHulGQeopzYCmP5rlpwLErrU8apVcwPxNQAv2qsDNJjszmPNuhDpmqmvrk4HDY9dacRCnXYniAHUSEpI7H7UBvhW71g4l43Mor+FaaJdZJkK1ZexamQNuVkevTrnv4UTpcyXnAIn7lS0UbYjDszmwGfpt8siYk9FCVRdi12qJXWti5W8cu9aysWutH7tWtcprWY3/f6h8V+91l0atuz9C+kcboaDmEkTAnlsDmnVQIPNr4ETkm/U/O/R3rPG+VVDG8HAkarkKWpSftEO/ETf3TSmQz5+UzuJTH/bTQJyESqCNeE1NQG32ubBDf7Id+gfboX+BHfon2KGfZ5ia4bk6r/0chkBqh/7ddujPskN/BiLm/x8KpLNnJ+uKO8ZwgL5q/jsrb05DQpi/Jb/kOVhMRIJ8Dw/xvBNQKXBUYIf+mvQJAWZz/2TEL5oj9hmJF9yP5rfTEd/qIuCzlVm6JoRmUFOMQ8kPFNoQ+XVDwzvZN3aty2LX+nXsWlvUEezsSXFau4UaLcIFeISq7okKWPS1KS+IMjDXmeAlDytQuy5fqxXTAn4fu9Z2KKvTTv9dnoX8qWrhFcozIePQZFNPgLl4rQNi1xofu9YZaIKfCrwbu9ZPY9e6Hykf34OCwt/ErpWN6wQGmohi/u34BsuJv0TZpsqs1iTUYXdKA+cZMzCWALfRJ5II+kyTgD/UaEc9H8kiVHJAJqBS8EkNDGMqBcHxrJZWprUNeBw/Sf0eQhlcO/QHdMyZgO41xMU6FN33z9uh//W8kxgxtR+Qf09VYiXUoXQXIvZmO/h9UHByMXABWgDPBz6deMGvzTVuQPeUj0jGR6ANxMkoA1SNbooDrVoB2CQkUno1DWQsc9CIZcRQ8S3yeUftwEZG4G/UkXjBm4kXnJJ4wc6JFxyWeEEj1YH5Bs2gphgbUryg9qK69DNoAtkfcWRuBq6u1GnJQdYWmodM0r9RXEj9rregh/PogtdeZHjKkj2IJ5TH82kDNjCclUI4UfoumpTzFqTq+n4ZeoH/xa5V2BligtG/ou9lQfRbLIpKH59FC8aC5n8PQGUQnCh9AAWiL6OFaBpSMj3EidK6d3XGcuOL5H/344Gvxa61TOxau8eutZ05fm5A5qOVF3i2IlL4ABg+w9bk/8bt6JmrF4XO7z0trdy55ACj9aKOvTLMRFyz2TDGmregjUQW0I1H99AFhj+Th/NR00EZUpT5qubetJprHI5afS9MvODoatG4xAveTbzgl4kXHJ94wSWJF3QkXvA28Dn6Nz50omC+aKNTzzO4hRnLQQzeJ2w05THWp3gOnIn8pZoYo2gGNcV4keJAoRelcD9J32TVinZ3O6EuhyLcgiaMPMykdrvxABh+z66odv0xfd06Rbuodqo8iUxp5QokXNZJY0FSHiYiu4GiLMpMit2EK3EgmtCm0WdG10lj5YEWZPD4Vuxa/1dwzFYoUK0OwvK4BBOBXYy1A06U3kbfznkjRMzu5xsWu9ZysWudHrvWbbFr/TZ2rQ2qzjkh5zqVmILuyQjxvN6OXetLJccPC+zQb6ul4loDK1PeQbRWyWtlv3HdyrlOlP4Plb36dR7NaG3nquU25vWJi+S9rdHycp779TYUewm1kVNSsUN/Y9RtuHSN67VRLnjXhgKeK+zQX9qce2079A+0Q393O/RzfcOM8eSKyKLhAGCNxAu2Q1IRHfRlcsqyN7lIvOBq9Jw808j7zHXryewOF16mWCixjfnXgmSuQJMoXIwL0EOd14UwA2mI5JHxJgPfRjXPPNyGvILWpv9kPwOJuT2W+64acKL0bkOszTq1uhHfJI/70ot8kwCIXWtfM97x9E3MvSjwGEdt4bI8WKiM84mC945DWhdZd8oXEC/mY+T2/Yr5XB/FrrUxsCUKPKahnfedqMZcL7Jywk9j13rZidKbql7fjcZKDt1oB/qiGWcv/c05ZyN2rc8Df0LP23gUMO4Xu9aVaJJfC3U3TEOtr0UYT/975orYtbZ0ovTRBsZdF+zQXxuVTD4HtNih/yhwbOIFf2vwVC+iTFteYNQJFOn4vIcyXssVvF6PH9FsOFF6TuxajyKRxNX/teAyi13yyc0WenTRFarvzTJC6yx0X+e9biEdF2A2H+gyiruY2qna8duhfxgqBxUZlVbiXYoFIisxDrjJWBMsg57lFP2mByRe8KfqN5gOn4eq/u0KO/QfQaWqtVBgsiva2JWhF7jHtJyTeMFHduifiebXss/ZSZ9O1dGJF9xacuxw45f0ZRgrkc2bpc+bHfoOfRned5C0wx8TL2goCGxicGi2dJcgdq1jgNPQYtSOdgzdKGV+CcVk2Q+cKM1rv8vOuwAi7+5FX1tkCBxnRO+GY+wtKGhYnoFBxXRgTydKbzFjeZP8ybcLPcCforaoVx4yXkD1ubuBfzpR+tnYtT6B0tuZj9NM9J2c7ETpGUUnjl3r68B5NM59AHjUidINq853Dqql1xu8fQwcWKvEZLg3b1GfZUYXWhzr3Wz0ADc4UbpHncfXBaPV8jD6PSq/jw5gl8QL7m7gXO1oZ5tH7O0AVkm84I2C9+5HviJ1B7Bj4gX31TuOnHOvgzy4JtEXyM9EgcsE8nljRS3PncAliRccas49Hj17S1IcIHUht+gTzHuWMu+pJwPVi4L8yxAHbrDoADZKvKBQYbsMduj/CQU2Rc9ML5prtky84PGK9+1KvtFrJV5EhOd7Ey8YQDI22cMvoczoW8AVRffRYGCH/kmos7Id/eaZz9YWZf5PduhvizYw4+h7jqcjlfF950RL+PyGZvmpHD9HXSi/BK5BKewVgKcofyDjspM6UTrViVIXkVfXAhZzovSI4QpozDV6EddjKn2dB9kkcyl9jtu7UlxqGodKMoMJaEDBy+/RZJDxYjIRvGwhvhJlXLIAcRya2L9vMhxFuBRxCgZTKsszGr2BxoiMbaiUWAs7U/9zNp6+EttHKHCaTnHnSCv6fYYbp5FPwJ5E7Rb3fjDE1y+gLrCs7Nph/vYuW4gSL7gCcZw+QPfNNOROvE9eQGP8meoKShMveAo925ej3fQbaEe9G8Udd9WE9wy99O+u2x3dz2W/e8aJybAXxSWPatxpumGOojahuAzjUFZ5sDiT8q6mO1EQ8HjVv39E7eCtK/GCWwoCmpVRiegilBE5BXjRDv2D6x14LSRecBIKmH6F5rBjgRVrBDRtSKBzEv03JpPRPLDTcI2viWI0y09VMCWc05D2yQSkP/M9J0pvrTjmTxSXZLpQx09NGFPDV4Y65pLzP27IuN9AZYS30M63UkBwYYrvg5aS1+pBC5rYfoy6MhZBLdB/daI0NSJ/m5NfxpuISgV5mhpZ0HZc7Fq/RB0gjZA789qs/4bUT7emtvbMDODwOkX1lqCx77AdBWz/BT6PgpwyJ96R0MzYkeIFeXU79BdpRCcm8YInjN7MV1AQ/yrw+7vuPTON7z3zKGB79JuESCCxt+K9F9mhfwnKFs4CnqlO49uhvxPwE3PuWXboX4+E2kq5D8bPyK3+dzv0z0eWCRnBOQua/7+9Mw+TnKr68NudmenZQUARDAiiYRVB9kVBBEQWRfD7WARNBOFT3BGIoiAqGBFEFhEQSZRVQHaUTVB2UVlkUYIsakT2baZ7Znom3d8f52a6ujpJrV3d033e56kHpqsqdSuV3HvuWX6nm/x7fjFyf2VzxCaUbwQWIwZdpQT/8tTfGf5YM/5r7dD/OFIiPyLbuQ6mIAt3UyRecKcd+keYzx9AjKSFyKZup7x+SRUhtjKDbxGS2zcCY7Rex3AvWHbeTrVD/4+JF7QlqTjxgkdpzOh7H8WaWrMR/anqsLfSZtSoqSB2rRWQcMtbGLo4NwauiF3Lc6L0UqNfsxnFN+WzTpRe18Lnb4VMDHc6UVpTzKsWTpS+iGgbnFDwkj9S/w6xiCIDbypwt+kY/cPKJ0x4bNeC92H+XlR2vhQnSv8Vu9ZNiOFWz/W8gJzmkqbf0keQ87FRwXszkcUvOFF6Zx2fBeLVa8ST1IUYFVk33uxz8+iltVYMRbTdRW523L/M/m2M7bsRw2GW+cw9gatj1zqwUvnZeHtyc83s0N8XKV/OQlTTENmEHezQ3yDxghebGOsRdujfhHhCVgceQIyGIq9YF8PVXp9HFuY847gfODrxguo54j7EE1VkDGWK0iciOj3fRiqK5iLn5jDE2JnByLBhGS0lvSZecKYd+pchnte5yKblzrwwix36KyM948qMtwHkHi3yCG6GlJ/nzb/TkOajh9T9BdpLWT4c5IdglTajRs1wvoBIYldb2zOBn5heSIdTflM2LMpnEmV/gCThLcqOEbvWZ50ovajR4zWCE6V/Mc0Tq0vYaymMVpLlBVVONAuAa7KE30pi15qChPM+RLlXpLAzcBWnIVVSta7n+YiRcXLek6ZD978oNmr6gDPyDJrYtTZE+jVtiZSt/gRZxO9BftMyscJKFjEyuTr7/5ShXI9exLs0Gi0TrkcWqbyF47EG1XyLuAS517LP6EKMm48C+yAu/1JMyfRpjMy5mYLkMH0ZCRk3TOIFNzM88fcYpBVK3r0/FdGKyriIYl2hAfJ/s5uQJNR3MHz+GUAMod8gidt/Rq6pdSrG8j7EO/R/yH23LxLuqOX56aVENLBejOF4Vs0XirFZliybIm0cDioJS65ZcowpNOexahd/oliSYyEFXmelvWhOzXCykFMePYhLuixuOwg8FrtWd+xaMxtQHf6GOfZ0ZDKeax4/i11ruzqP0Qq7ITdclsvRiyiW1hLhyxhEdrMLGNK2OB/IFRhDFpsPUd7fppcq704RRpm4Vq7Hi4jhs12N3KWbKc5T6Ea8C8OIXevDyELzP0jOVZaHdS3DPS61WIJcZ0XXjYVM+r9FWlHsPkoqw0cjBmD1brsPMfxbwpTCr0f+/NOI+vMGlN+v+zY6Njv032WH/oV26L9qh/7LduifYxSAzyb/flgI3JZ4wRPZHxIveBb5DguQ3xSGVH0PyfMemZDa9gyp72b3UR9yPeyIGD7XITlo1d87Uw6/Brk2yq7xAeT+ihgKmXWC5SnfxESJF2ybeMHjJa95kmLxzyU0Xi7eNhIv+Dfy++TlGfUjGx1llFFPzXDKjLxBRDyqbCFeiEwWbyCTziuxa50I/KiokaIRUTuC/IVvJqKc+gHz2uWRyqsdkFyKnwN3NdMEsxLTgHO32LVWQ/RcnnWi9LHYtU5AJud6FuXtkcTnNwNPOFH6Wslrv0rt8xg4UXpzyWuq+S6y4OaVic4HvuxEaaEIGyz1IG1bMLaFwO1OlP4t5z15pbuzzLE8hha2It5AdngPUzvH4WwnSqMar2mJxAueMHopJyGhsC4k3+jIxAvubcNHrIxM8kUlvWUqw5XU2jQ05DU1ZexZSCxbOF1gL8QT8gGkdcqKiFehBzE0RjRrTLzgZ3bo34tck+sii+3pJk8jl8QLngO2NaJ8GyL5b8uZsWTGwAconqe6kOaGt9mhvxNisMxgyAAaMOP4C3Bu4gUjDPR2YBJmtzRjvi/xgnnmqXuRBT/PazmP+jS6/oIkCa/DSOOmHzHsxpIDkXl5L4aqGV8A/qed1VlKMWrUDOdyZMHN200MUKyZkfEKUk2UTSJvRpJkNzTCdm8Af6wycGzK2w5sDBC71rpICep0ZNIdQDwDF5gwVct5ECb3pbKN/dFIaeU3KdejeNiJ0vmI8fBMHR9Vpq+RAls5UfpgHcdZihOl82PXOgLJOag0MBYiXqfLc984nO9T3GzwPoYqtiopSnQGmbz3Knke4Ankd3ze/LeWUbNGjefbgtkt72ESM7varLERU+xhGUC8fvXwMLJw5OWhLEJCXI1wBiPzUaYiHobjEy84wA79NZHf6M3Aw1XJvsMwCasN53cYo3J38kvLa228pplj/NkkTB/A0PfpRvpn/XQUDZq9EYVzKxuPHfonIfk+tyJl6+sw/J5YgsydV9Y6fuIFg+bc3I78LnMQQ6kL+GyZ0dgJEi9YCHzClOi/G9l8Pqil3J1DjZrh/BgJL63A8MmkD/GmfBnZpeWxmPwKhpmI9b5ndqzYtT7hRGkWX32d8kXvDfPfXyOJaJUT1Cxkl3g9EupoKyZ59i5kt9mDuKurvTYLkPPSCP9BEjDz6KVJSXQnSn8Su9a/EUNyXeTcnQ18v1Zn8ti1pjNU8ZLH1IJqpzmUJ9bOQnaguzDyd+4FTnai9CEzhteQCb7ovhxANIVKMeGSzZHd7+9Nom1TmMm4rROyE6Uvx651KZJjUe2tWQjU1aQv8YLUDv0vIYto5e+WIvfVj+sdkx36MxHxxzzvjoUYp9n5aEj4r0l2p9ybmcc0xBuSKRPvz/D5qMsc8xQ79C/Nq05qBTv0t2WoEWQlXwXeSLzgJDv0d0CMzW0YEmV8CPFk1HWdJl7wjB3670A2IBsjhsMlps3DuMB43Wreq0r7UaOmAidKXzBdtE9lqDLnX0hJ96Wxa6WIe7N6YV+MuBjfVnL4ORX/vSZ2rU2cKP27meDvQsS0qndlC4Cfxq61AfkieiA7yy/QZqMmdq1VkZ3TBsj3y0TUXsN4j5Ck2684UdqoCNoPkHyZPFG1M50obbpFgxOl15BTDmo6YB+KVJf9CzirSonXpnzxztO2AVngivIEFiIhgNORsMbKyO81iHzXGxmuPJ1bxlrBYiTBOhcj+hYhBnRmxA3YoX9A4gXjrZT0UCS0sjNiyGW9vA5xorRuoyHxgovs0J+HGELrmmNdhagfN7LITaX89y/beIwGb5Q8lxmalV6bXuDUxAuynlGfotgbtgTpMxa1OMZqjiM/pDgLONoO/VMTL3gJ2NEO/TUQGYZ/mtL6hki8YAkyP9X07iiTCzVqqjDVOnuaXJdpQG9FaOcXSIJrtovqQkIuLyI7pP3q/JhpiFpl1iPqIKSUeDZDk0IvEv/+MRLiKMvLKDOmGiZ2LQtR+V2T4dfIO5Ddx4pAWkunpaIiaGuGKoKuRoy3p5GS7Wxy7gduoY4eL7FrrYF4v96KJOheXpb8G7vWtkhybdbJOAX2j10rcKI0q1J5mfKFK1cPxonS5027g30ZbqQNIjvRnxhjeX3EM7E78tuej+ToVC6kmcFTxAlOlJbtrs9EqoemM3xBu9QO/S3bpd/RDpwoXQB8NHatdyHXxzzgBqPd1BCJF1wLXGvUi9NmQmVGvv9JipsVFhrudui/GTF6X0Kqw3J/QzO+HRCP658SL3iyZEjnIcnBefknfch8kc0LixDJhsqqvuUoDlVNoXlBzTI2pTiPaQ4SOn0CxNtCfaFqRWkINWoKMOGK/qq/DZg+Sdsgi+ocJPRzOTJZ7UF9pbtTkDLM7LhPm5yZQ5Bd9gJkUrvElBk/RrE3IKVGL5Im+BBiMFRfHxZSlbWLE6WFHgNYWhF0OUP9pFZHPBZnIZPwTOR7Wkhi3Vn15NHErvVFxNPTjRiHnwROil1rWydKR+z4YteaiuzcK38Xy3y+H7vW9U6U3u9E6auxa92CeA6qjZs+KkpfTVXbhsjC8VeklHYhYqQuMu9/GtjPidLnAIzm0IXmUcRHGPKKVTOAJGLnYof+iowMN2T0AEfRWGfrjuBE6ROYha5VsvCFHfrdyP24KWJMX15nqOVw5Jqt9jb0IRWKw7BDfzoS3twH+f2nAP+2Q/9/qw1IO/R3QcrUMwG/qXbo34KoI+dtDq4H/oAk4FfqFS0ADjW9mJZH7sdnjeeikpsRAzdvPupG5ADaTVlitgV8yITFhhn2mm+itBM1ahrE7KzvNI+lxK51I/AgUiVRT0O6YVofTpS+jCSqjuh35ETpf8zxd2GkcbMIqVJpJ5tSbJzNQXbWuUaNWfDXRBbv6vBStuBmf8/O0/7IglJK7FqbIuencuGebY53Xexa6+YkTO9EsQemBzFIsmTOg5Ed8AoMff/5yG99phnD1ogOSWUFzM8QOf+jkRDIy06UlrbKKBlPUdJ4N+U5Fusi10KeUWNR1ZV9omISNG9FwokzkHPyYzv0D0284Pyy9yZe8Bsj5ncqYtR3IYnyn0u84I85b/klskBXNhpdG7jDDn0nC3+ZXlq/ZuTvtxPi/f14zlgG7NDfE6me+yJi0D4AfC9L8k284DUkHJzHryjWjpnCcLHAlrFDfzlq5wCdhBjtmUdyX+AGO/T3yRpeNvnZ70SS7GcjhuAt2jxy8qJGTZswXpzjqZ0XAbJLaVSz4EAkfrw1smtPkYXuU06U/rXsjcbQeB+St9ML/NqJ0sKqDWR3u5B846wfyR/K+4wjEI/AbIpFqPKYg4SdjqrxuixhuZpuZBHbhOEiaFDeVNCioqLNidLnjMdsP2SXu7RPlvl910KSfqtzqg4y7/8iEg5rlt9RLCw2D9HAKOIlysNnDSvrLqNcgVT4ZOcim+POskP/IdPzqZDEC66xQ/9aJKSbljTbXJ3hlY4ZXci1fyhDAnxfJf9+6AH2tEP/bXktHYz35Wfm0SjLU67WfRRi/LWLzRnywBZRafxlYou7IB7Opd/RGKbvx4SkEy+YTwF26J8AfAW5l6ciBuBTduhv3yaRyHGB8T7OAnrVYCtHjZo2YbpdX0bthMJeRPOjLAwxAidK5wE7mtyMLRFPz29NbkLZuJZDXNHrIUbKYuCE2LVOqMgnqeZSioXvBqrHbno43UFr5cZfiV3rR06UPl/yGodiT0aKlJ1XGzV/pdioWUiVEWJyOn5uHtV8jfzFaSbwmdi1jqmhz1OKE6UPx671O6TnU6VBuQhJbh5m1BiNnC2B6bfCfTtsd8Q/kZyQvK7sbW2nYIf+DORcvDFewgfGI7IR+fdgD7L4ebWOY75PUuNlmyOLbp5nbAYSxszur60onmstxEvZSmPJPNZEru+8TUAXxblDzdJMY1mQhfobdui/2/z/24DtkHlqEJhih/7hiReM8DrZof9RxIip9tyug/QR27OJ8YwrjObPNxFP8CxgkR36ZwPfNOXjZe9dEcnL6kaaoI6b6rDRRI2a9vG/FO+MsuqofyAx+EubrfBxovRRGlPN/DmS/5FNbtl/j4pd634nSkdUxZjE1i8gbvgsJJJ1j/5mZesD0+LhVsp1bOrl0+SE3yp4GAmN5V23U8jJzTBtIB4lf7Fbggic1csHco6RsQh4D+L+boWPI1o7B2MmdcRD99lK9eDYtT6GVE5NMa+bdsLDl1/4jQ32XpWurh6GJvpexKit2XYgD7PYfAbJiboX+a2/i+SsDCI5JEckXnBFM8dvMw7Fon4Wch+0i7LqJJDE84xaXrK9ab9R82/K1XufskN/GrLoLY+I5DVchVTBPZS3QChjDaR3VeXmo9JQOdkO/X8mXvDbqvcdSb4w6DQkf2clU221LHMxUombecCmAp8DNrVD/wMFPba6EEPoG8jaA6IXdDoioDkuNiGjhbZJaB+rU6y8OxW4zInS7Z0ovbiVkuVGiF1rRaQFQt7kNouScI8TpeciIauLkVj+pcAOTpSeUvXSHYBVaKLnVRVTKe65lHEaQzdpJUuAx0vCcLsh+U69SI7MG0i4ZpcskbdOXi95zqrxfF04UbrIidIvITkUGwBvdqJ0v0oPUOxaWwEXIHkRc5GE5RlbvvL0fuf9OTwDMQzvQsr89wf2bsZlbYf+kUiO0WeRcNyx5t87IsbUVKQi7nw79Eeo6o4B/6Rc46ctCcmG2yhexHsZHjKq5ZUtTABvlsQLEkRGoKhq8nlko3UxknvzVzv0rzF6Pc183hJqh4/LKFuLMmX1at5R8p5+aouljmvMhqLSoMmYgYTai1roHID8FtOR0P4chtr8fH5UBjuOUE9N+3gcyXvIK5Wcz9j0JHk7xS5ykB4yhThRej+Sy1PGRtTOn8mqNvqRXWEei6ix6DhR+kjsWocg3pVB5Hv1IhN0kRJw1ql889i1NkZ2688DtzTRN+ksYH3yjdeXERGxYZjqq68g7uOVkMTT7wIXl6lAm7DiMwVPf5sCPZA1+l7+/K1/+OFbnCj9TvHXqI0d+u/J+ZzsOqpegDJBt0taSfhslcQLHrJD/xkkabp6jAup3R+skc9abAy5yxie4N2LNJ/8TcXLL0KunaL5tiy/DZDddxM77AMYrhBeyT45f9sJqbpsuGeW4RwkN27VnOdShjyPzbB+zt+eorilxjSKv/uywq4Ue4az5q+/z3nuWPLnqEwv6IyJ7K1Ro6Z9XEFx35GUxiXb20FCuQv6mTZ8xguIsVJk2AwgCbDrUGzQZK87t+R5AJwovSB2rd8iYZqVgPsxibx1vPcB6pfgH4bRU3kn4o2ZwtB5XYx8/09UGykmefpaxOOV7bbWQSb/9RAXcTNsTnnTy7fTulfiszSW7D0D+W5jKlOPTPR3IrkVs5HfZwlwXOIFrSRxj8BUS22OhEG2QozlMxBDZ3U79L+MeDJfQTw772fk/dhLhYKyHfqzkVDM7oihv9i8b7od+g8BX0+8oN4mlBsh5ej1atJMRxKX32oUcRvCtDD4FKJFNYOha3Qxpl0AUqI+iNzv9Xauh6pqUcOJiBesegFfBNwwAUJPA5TrVo3YQJjQU5kHawXkfBUmXy/rqFHTJpwoXRi71geR/IUe5KbOuvTuYnojdXpML5jE0x0ZuUDV3QXbiPFtYP75SFX47EpMuXMBryGhuVXJT/LtR27ezzhR+kw94zHl72fX89p2ELvWUcjuJwu5LEQm6gRRBT45TyMHSfjdhvxml4fHrnVGg+GvjDcoNhCn0oYwGJLnUNaTrJouKiZZkzjvIrlmKVJFdlGNDuk1MS0g1ka0Wf5W/XziBU+a/kz/g5z7F4BftpgvUojpNTSsG70d+lsgQpKZgCcMhT6XIHNDah4Rcm6wQ/+9SNiwyLO6MXCFHfpe4gWlOlGGavHMelgIfNIO/Z2RHKUngR8mXvCb8rcJiRfcYlohHM9QK4SLgW8nXvC8HfrrIobNAiTJd+OiY1WwgJxq0cQLrrZD/1QkHymrfppvxvzp6tcvg1yDqDTn0YdspIdhDMt5SFg6j5T8LuIThq7BwQnrhRoTjBLxR5Bd/dPAVUZ4bazGsxKihmojO7YlyIJ8NfA94LGyMEjsWvsiuSxZGGIB8CUnSi+ueM1HkIlrKsPdpXcgk9uvKc43WozsuI7tVK5RI5j8lVsYaZgMAH93ojTPLZ6991xkcs3zqvQiLSYaLteNXesbiJenOgQ1ANzjROm2jR6zGjv0v4tUexUtsNUkwOqJFwzGrrUy0j5iJYbOWy9yP2xtKvkaHc9cZFe+I0MCh08Ce1UaLKYn0LbI4nZjgbDdqGF2yk+Tnzjfi1zrg4gxf2XiBbF53xQkhFm0GFXyMrByrVCfEfy7lMbUg/uRha/y2uoFTkm84FsNHKcmpnopz9NSyXzEw7Nj4gW586gd+msxXKfmdxOl7NkO/fOQUGHl/NOHeP72KEgUPgnx9lXfu/3A+YkXHDxKwx0XqKemzRgl4no6QncEJ0pfil0rSzj7ILAF4pbeFclDeT52rf2dKB0hLha71m5I9VTlDTUbODd2rTeyyiknSq8xLRE+Z479JNIe4CFjFJVNvlnOiYPs6scbXyJ/Ye8G3h671kYlSsg9FIeJumm+n9CPkYqZtRlaEBYik13NkuU6OQv5XfIYZPj36gP+r2KCPQ1JHq/8frOQHK5jED2jRrkOCbtVVnatD9xtDJnFSPL07ojhPoCUAx+aeMEFTXxes2xMcdPbWcBOiRe8L+e5Xag/HLM80mDzshqvuxnJ86vuPF7EIPKbVXt1ZwGH26H/i3Z6vIynJUBEKwcQb0uKGIUvINdVBFyVo5hceZwnqbMJ6jLIwYhRdxRyT72E5IadWJIXcyxSqVk5P8xHNh5fG83BjgfUUzOJiF3rR4goWLXXYT7wHidKn6p4bRei8bIB+TzqROkG5rVL9VKA+5woXVruajwdN1F7wu4DtqmnVUI7MaG1rqKk4di1/oxUGuTxOiJ+eHXBe/dGJuW8774AeLcTpWX9fwoxXcUPQIT/ZiCu6p/U0PlpCDv0t0fCi93IBmgASWp9CPFG9iAema8nXnC7GVcPEh4rysd51YnShtRs7dDfGMmTyavMmY9M1Jsg5yOvxcGO7c6nKcIO/Q8insnlCl7yt8QLRjRHtUP/MBrTEuoD3pt4weM1xrM+sqvPKmGy3lp/RIzErIddFpKwyP/tFgPfSbzgew2MsS7s0F8FyYWaAdyaeMGIhHulsWRx02dsL6T60UIUpi8t8nZNJNRT0wBGyO4YJKQwC3gE0W2pK948lpixf5bi3kCHA4fFrrUa4iLfi/JE0fVMZU/mzVmqlxK71o+Bo01Y615k1zWT8rLNHmShfLCB7zQD+BiSO/AUcGW9ORvGs3QKUhbZFbvW3cDhOR2iH0a8T3n5JVORqrcirmGocWdlgmifGWtTBg1IDheSWF0zubpZEi/4vR36KyNevZURI/feGhNrrZLgZhopbgV0dQ8OYA0OsLh72LQ1G/gw0q+sSAjvG5RUx7WZhyhOzl9MsY7RE4jRWK/MxnSkiq7Uu5l4waN26K+G3CfrA88iRQuvIZ7bzwBvRrw6b6J4Jz+VYkNtKXbovx0xll4Hbsv6cdUY438pbumgGBqpWDLn/VfmMalQo6ZOYteaiQhMvYOhSWtj4LLYtT7vRGk4ZoOrj/dQ3BtoKqJWvDLSHHMF6ksS3ZuR4SmQBMB5wPedKB2MXWtXJK9neYoNpS4a0E2KXWtLhjpvz8S0nohd60NOlP6pxnvfjSRkzmLILb8tcFvsWh90ovTeipefgsS0qz0AS4CHnCj9e9HnOFG6OHat9yHu4n0Qo28xEp4pSgAcVyRe0I80BK2X18zjLQXPj0jurcWWLz85dY9nH5y62avP0DU4yL9nrsDZ79iOP664Fki4YjHF13YX9SWjtoXEC16yQ/9CZIdcfc30M7yTdiW3IOetXi9WN2Js1jOmReRXX95iHgDYob8jsvHJ8yzOI798OHvvDCT8tytDjYAH7NDfP0c0T1FGDRXfq59PIcl/1buwmcCpxu0+nplHuaFiAT6yG6u36uWXFOilIB2wpwE4Ufo4Uk3zffLF80Dc3yPUjfOIXWs2cANiJM1GruM5yE7zJmOAlvEDhhs0GTMRI2YpRtDvEDO+XsSYmY/srPeqNVYnSl93otQ1Y1sTWNGJ0m81oZGzTGC8c98ZHApzLMX87ZhGjhe71qrHP3LFsZu/8vSUKYMDWAyyRt/LHPvYNWz3wt9BjJmIcumCTsvDfw5JnF+IeCzmIR6SXYtyUkxi69aMbWXKrYjHs7/q74uB/yD3XBHnIh6z6Uiy81zk/rzcDv0R4TZFGS3UqKmfT1LsWh9EyhfHMw8iehlF2DSmTdKFeHiKEhBnUqGXYMTkjkN2htUT9wLgD7U8LBXsQ7HhNYWcrscZJldoJ4rHvVnsWmvFrnV87Fr3xK51H7LT3w5JnP0m0lNm/UbKsZ0oXehE6fMT1ZipZOf3ffW2i1bbvHtRt8V8axrzrWks7J7CeWts+/wO2x3R6K79yEGYY1XJdUwfWMIX/vG7we7BgZ8lXnA9cn3nJaT30kbRvXpIvKA/8YKDkE3Qvsj1tlqWd1TyvseRTcXXkMrB31EszJdS3uC0IUw5+TUM3bNLkNyohRiNnaJqKzv034IY+HkbnGk0lxiuKE2h4af6KTtXrShldgQTBjoACdlkyYGV9FAu9NQoUxAX/NKduRnDnkh2/ufNOPqQBMlGwjFrU5x4PBvJYWmFB5EdZ/abboaE1K4F9hvLEv1lgSXd1i9//o7tei5ZfQs2fC1hoKubh5a3WWhNWxkxnH9c77F6rWnurLQ/996au3jBohvuOOUcPn0iwCeQ8PAs8xhEDJobgfOb/S4mR2QO8ESjSZamgWCZdyPvPYuRENXJ5vPfz9A9mzGAfLdmxRuHYRLCr2e4YF4/stnY2mjxlLE+xeG/KUhOlKJ0hHG9EI8zLkdu3qLdyN2dHU7jOFF6R+xa7wf+RL6notH+TbUSGw+mKtxgSt6Pjl3rWxijph414CqeRoyhPM9ZLxVKybFrzUV+t9cQXZnB2LVuQlzled+3SOl0CpIvcAoSXlByMEmp6wNdvVOmc89K76x8eiYNGDV26M+9xJo2d1ZaHQ0xdHV1TRkcGARIvOApO/TfhQj+fRj5vSPgpmYk4U3F1S8Qvakl5m8/AE7opMR84gW3m1yXE5Hw1CBigBzZjvJqo6vzM0beS9OQ8NEnkETrMl6ifC1pW0XeaGHOwweRzdbbEAP5VFMurixDqFFTP+cgmiVTGX7e+oDjx0IxuEleRnZgZYJXKfXl1WS7syJjqChZFGPINHvOLqZYDXkQ+JUpM/8hUsLej/xmSexa+yOaD+9nZF7NQsSoKdKP6QHc2LWOXIZ+706zPJKDUSTaV7OCpoLt73iz07/Hsw/2TBscaffOt3pYfsmCpdVniRe8gSRhn9bAZ4zADv01kCqlan2XryPXxrdbOX6jJF5wjx36uyPn7tkyzZYmWJP8Xk0g1/sB1DZqHkFybt7FyLmgl+L2MS1hkpNXB15KvODlWq+vwalIVWvmxX4PcJAd+h9LvOCmFo+tdBDNqakTJ0pfRcIQ1yGLZD/wHCLR/f0xHFqjPEt5mOl+5DtmAmZ/Q4StspYPMOTaPxVJgixiVBrKmY7VezEyoRHgR0ax9hQkwXcGshjMQsJWv0dyBbZB8ntS5HveDnyL4q7GGYvJV4tVhH9QPK8MICX+9dJ18Wpb9PdN6SGtWisXdk/hnHe8P27Cy1cPmZJy9QI9CzjCDv2yDUFbsUN/DTv0b0KSnf8GvGCH/uHGs9AOplHcbTx7vhTjufpf5L6qzJebj8wlI+T8q7FDv9sO/eWMsnKt104xXrMXEa/zf+zQv8m00GgYO/S3ZUimIzuvUxED51d26DfSA00ZY9SoaQAnSv/jROnHkEVyVeBtTpSeXdZmYByyPsUT1QLAd6J0T8QYmOVE6XpOlH4d0Z44H8k3uQbYw/z9dHIqXRCjZzSNvbeSb4B8zeTtHEx+eKoH+LITpX91onRnTH8eJ0q3Q0TTak1gPchkquSQeMECJLyU155gIaKtUi9/eKVn9pRD3/tJfv/mtVnc1c0AEM9+C8euv+fCG1bZcFQ8AIjmTZG3bjHS6X3UsUN/RUTccAfkupyJVNEdR2PnsYz/UnzNL2F4t/FCjGCeg2yA7kBkAPYB9itrWWCMmSMQo+0F4A079H9m2mIUcQ4SJpqF5Dv1IAq6f7RDvxkdpM9R7LnuRlpzKMsIGn5qAiN81lJjvk5jwjHbIc0niybs+5wovRnAVOksNRqcKH2E/CZxxyEekN2QkFU2gUVIrL7tmAqm48k3WmYCJ1CcuDgNqUYBlobBsv9/2jQA3Zn8c7QEuN2J0k6XCC9rHMNQ/swiZGHoB9zEC/5S70ESL3jNDv0TXpw+9+vHr7fHzOMHB+kCBru6+hEv4IXNDtAO/R5EE+Zlo8VTSZ6RnmHVeL6dHIos2tWh4FnAV+3Q/2HiBU03LzXenuspDh8vQO6lujCJ0d8xj3o5A5HLqLyXDwS2sEN/k2rxPuON2Y+R9/YUZLN5IOUNdvPYvuS5qRS3vVDGIWrUdIjYtWxkEn3SidKONtmLXWsHRFlyGuUN8zZq9NhOlC4G/id2rfWRHW4KXONE6dNNDLVe3kRJvg4S2y/T+yhbCPZFmgDuzPDFZAGSEOnWN8TJi9mZf9U0xdwMMQLuqdWAsYDjkZDpcXR1rTIonpILkUTZho0LO/RnAichC2kXMGiH/rnAUYkXZBuVcxGPQ57R/BqirNwJ9qI4N6kfaU1yYwvHz/rA5RnwA0hbhFHpbg5LDRSPkd+xB8n12ZOR/a3eT3HO1iyk3ULdRo0d+sshispF9CCCpMoygho1o0zsWu9CwjbvwSSsxq51JvD1TmiWxK71TiRcVE8eQNOxYydKHwVqlX62i1oCZX3mkeeK7gXOLnqjSQDe1Zy3A5CFoxfZ0V5s9HaUOki84FWk71crxxgEzrNDP0QWskXNdmA2nokbgU0Zvih+BljPDv2dzedl3dXXZqjacQDxzrodrH4qKyHvIj+nrBHeR7FoYTeyORhNdqY4h2020nm72qhZSHlOYKMbxrcj80lR2GpJ4gWPNXhMZQxRo6aC2LVWR3JOngceaDVXJnatFZHSwDchk0Q2kX4O8Zgc2srx6+TL1GesDFLcl2Zc4UTpgti1bkE8Q9Wu+X7EiLwCMeZ6GLrOsyqon8eu9R1kN35O3u/sROk/6HCVi1KMMSRaNSi3QzwT1bv8GYiWymbAfYkXLLBDfxskb+MQZIG9Hfhe4gWd8tIAhMhmqGhDcleLx38HxWtAinilWsLkuKwLvJp4wRM5n1FGnsFzE8Vjno+EvRuhLKcIoLANijI+UaMGiF1rDuLS3gnZHVnAc7Fr7W1k8pvlEPIbOc4EPhm71jHt7KpcwNYU59BUsgA4epTH0k4OQyofskRBkO/wPHCsE6Uvx661GdL64f0MVUBlr10DETh7LxXGpQkTHgysh1SbnOtE6ahUcSkdZxeKDYQZ5vn7AExo60TzGCsuQAyrtRluiPUBn6vMBbJDfy0kr20QuD7xgqfKDmyH/kpICK6IfuCiJseNqWI6CZkDFwNT7dB/CvhERRfuGyg3UC6u/mPiBfPt0P8SUnlZGR7sQyrr6mq1UnG8F+3Qvw3RqKmeJ3splo5Qxilq1AhXIA0NpzM0eawF3B671lpOlDargbA7+WJ9IJPGVjTWLLAZahlN/cCTwKFOlN5fzwFNx+9DkaQ8C8lBOcOJ0pcKXt+N5Ad8HsmFuQs4uawZZC2cKH0mdq0NgC8gbRGWIB6as5wofd285m/Ap4xx83tG7shmAQfGrnWyE6Vx7Fp7II3/LMT4WQQcEbvW/k6UXtXsWMcj5tztjXzPm4HfL2NVfM3Qj4SR8jSYssaYdWN0Uo5CEqKXQ4zgYxIvuLbFcQKQeMFC4zE6EjEO5gAPmM+4zYyhG0nI34+hhN8T7dC/ADi0JFT3iRoff3eF8dEMpyFG0wyG5sD1gNvt0F838YJnEy943g79kxFvcqWxuQDJW8qtvEq84Fw79J9GEtLfjWhvnQ78tMm8rU8h4qlvQc7xgBnDZbSQjK6MDV2DgxN9Hisndq11kUSwPOOjD/iOE6U/aPLYNyAhkjzeAP7HidJRFXYyC/VF5KvkPgts4URp0sDxVgT+DKzM0DlbiHyfTau9GqZS6RJkF5lNXEuQBeZjo/39zRi+jywMeRIGixG5+Z8BCfnJoQuA1VowbscN5vc4B1nUpiILfC/wMLDzRBYVtEN/I8SgLvqN90YW85oVRXboTwXuRMq7q70oRyVecEbLA64DO/S/hlQgVn+nPuDoxAt+XPHaLZCQ6pbIhrao1cggcFziBU11kjdeoH+Tn8y7CDgl8YKvm9d2IX31jkG8p68BP0VCfR2rMDVaNB9DvHXzgPMTL6i3F50yjlBPjeivFFn3MxH9g6aMGuDniMhb0eTx+yaP2wjXIforezMkLrUIMSr2bMSgMXwP0eip9HpMRxbI05GKhUp2ZbhBA3LdTQEujl1r5Q4kTJc13uwyY9m35P2DSB+r0dJF6SQusquvNOJnI007TwUOGoMxdYTECx60Q/8KZPGqvB6XINfzr5AwyeXAZxMvKDPwPo7k31Uv3DOBH9ihH9V4f8sYg+BIiqUNjsK0pLBDfzfEo1rZ36mI+cDjNV5TxqYUSyr0IBu9r8PSXKlfmMeYYUJ5vzIPZRlGxffgVYoVNQcRQahmuRL4I/m6FrdRX0VSS5iQgocYNVcjbtaTgHUa6IpdyQHkJ9ZZSNVQdTXFoRR/z0w7Z7T5DcXaIv1IbN+muAv7TPP8ROBI8n+P6cB+sWsVnYOJwqeQc/AMQ8Y9yPU7BzkPHwdurKHa+0mKr+slSI7GaDONcg2Vtxr13W7gPPIb2VYziJyXK1sY13zK15ZST5gd+m+1Q38vO/R3sUO/qKRdUXJRT025zkMfLQjIOVG6JHatDyMJqZ9n+ISyC/CX2LU2znJARgtj2NxEi+W1hqIcoYzpDC9FXanG65dvaTQVxK71JmSxeTeSJxQ5UfpfhpfmVrIQySW5P3attRG3c15p5zw6V65eF7FrTUNKXj+BLMiXAJfUUXK+WslzA0hewTPtGON4xOSYnAmcaYf+hxHvRbUndTpSdbQ1xRVGtSoKS5Pz7dC3kJy7TyOVkNcC5yVe8FqN41bSj4QOi8qRX0+8YIkd+ptQbLCD/O4pcj8sAHZqtCN5Ffcgc0CRpELunGqSi89EcvUyY7PLDv3PJF6gHhSlLia9p8aJ0kVIaKGP4SWEvUji6Z0tfsQSxN1dvUPqAVYBvtji8TtNWTXYf5HcmkpuoVh9eRpSwdQypvv4vxAF1IOQGP2TsWsdjnim8q71+chvA5IsnqeBMYhMsNV6GWNG7FqzkSqds5CO1DsjobEHjWFXxr9KnuumNc/kssaOFIeGZyCh5yIup1gTpYcSeQSzeF+HVDd9BFG0/S4Q26G/ZvmQhzChm7PIL3VfwJAI3XTK+zs9h1Q+fhKwWy1bN8m6ByJzamVovw/xXF9a8NYTECN9OmLozUUMo/Ps0N+6lTEpk4dJb9QAOFF6PbAJogvxV+C3SIO2z7WhImQ9RKcmj+nIRLIs8Q3yQzl9wNE55+tMxCio/vsC4DonSssW2bowIZNrkQUq25FORxamH1AsMDYD+X0y43YHpFpsHmLgzDP/3mGcie4dB6zD8AV5FkNl6mX8gOK+TBc4UdqpFgDjgeqNTCWLKdfFOR+puqmumOoFzky8oKw/2EGIzEDl7zcTURy/oGzAORyDJO7PR+6xQfP/9yHXCUjFVJFXvh+4OPGCHyZecFV1W4JmSbzgBqS681LEkH4IqXLaJa/LuFF6Pox8j9IMpNmsotREw08GU158yCgcuuUuuOMJJ0pviF3rM0jPlqw0tgtphDliQnai9LnYtbZHPB0rIzu3HsQzcnCbhrUnxbkC3SXPpUge0KbAf5DSZhvxfKwFPA3cWE8is/GebIP81neNsnFwMPmG2jRg/9i1PuNEaVHy+y+R5HiPoYTtXqQ7+5fbP9Rxza+Aw8mfBweRBPtcjF7K5ojRvhtDisPfRzyDZXyR/MXbAt5rh/6qiRc8W3v4S8u+t0dyePY2474cuDVTPk68oM8O/RMQI6e6nH0a4j1pO8bjs3+dL1+T4oKNLmTTqSg1UaNm9HmUYqNmMeJhWKZwovSi2LUuRaocLODPxtNR9PoHTLuIDZEcm0faLDq4OsW5Pl3IRJ9n2MxlaDebKdZ+2InS3zby4bFrZWW12S53SuxaRzhR+tNGjlPnZ3VRnEMB8nvMQHbrIzCetMNi1zoN0Q7KdGruHm2dGqPrsjLwYuIFbe9/Zof+Ckh111ZIef65iRcU5kIlXvCIHfoRI5N+e4HTEy94puzzEi94HtjbeBnmIt+rHp2UsuTefuQeqcuoMeMYQH7Dm0te9jfEK5Wn0XO6HfpXNKnx0i5eoTwP6ZVODURZtpn0OjWdIHatzyHKlJW7s0EkvLGhE6X/HJOBtQkjrvcBxGh5Dri6k2GM2LX2QuTR8xb7BchEXq9HbABYs96wWOxaLuK1qq6E6QMOdKL0ijo/t25i13oCeGfB088Bq44nIT1TwXIy4h3KxO9+DRzWSpfpqs94L1JROAW5z5YgRuZ3Ei8ISt7XhZS4H4EYx08BQeIFhV6aNoz1N0ihQJ6hvQB4S7vLwe3Qv4mK7vRVzAN2Tbyg1fzBlrBD/07EIK1Oi+io9o+ybKOemg7gROmZsWstQjoOz0Um9T8Bh0wAg2Y14FZkBz4N2WmeY1pMtFRtFbuWg/TJ2gDZaf6kQIX4WmQxmM3IhWIJUsL7Q/NcUX5NRjciVrhtHePrAr5DfmnvTETTp+1GDXAsIqBX/bm9wHfHk0FjuArJIan0pn0cWN8O/U2abVCZYUqWr2N4B/ostPYtO/RvTrwgt9OyCdFcRAstAZrge4iUQZ5g3jmjpG9T5h0aoI1ViC3wKaTVwSyGrpX5yFxZ2IR2omGu500RleoHEi/IVWpX8tFE4Q7hROnPEdG6tYFVnCjd1onSZbr7q1nUb0Ti4VkPpjmIcXGF6aM07PWxa60au9bKNY47N3atqxEBsC8h+QL/B9wfu9aIxGonSheb17yA7DoXm/++DuzqROkZSBLtnyjv8JuxpfE+1WImUsFWxDrmHLUVJ0ovQipFMiXnN5AS2tMRNdZxgyknfh8jw4M9SN7SLm34mO0ormLqQdoYjBsSL7gb6Qw+n6HfbyGSd3Zkuz/PlI8/Q3HOynREVX1MSbzgSWR+PA64AynY8ICd25XAPN6xQ387RI35d8j1kNihf45RsFbqQD01HcSJ0gHkgp0obIXonuTF6acghsg3AWLX2g3pB7Mq0BW71j+Q6rLbK98Uu9YspJrjXTnHmwKcFbvWTU6UPlf5pBOljxiv0e6Ag1RcXJVVLTlR+nzsWvOpLT4GYuxPo7gUPWMR5UngfaPlNXGi9ITYtX6KGHPdwK1FvbfGmLxGgRlzkJL03B4/DfC2kucsxOgeVyRecJEd+lci52cmcFfiBf9p9+fYob8qUl6+Cvn36QLg14kX/Lfdn90MiRe8glToNavivsxih76DNOSs9sB+AjFIx5VxPl5Ro0ZphXUoNhJ6kA7YxK71IWTXUblbXx/4bexaH3Ci9L6Kvx8EvL3kM7uQioofVT9hPDZlSqj3I7k/tUJQLzFcQDAXI654OSKCV71w9zPK0u9OlL6KVLqMZ/qRCTnPsMkqhlrlUfIXbJDf8c+tHNwO/TchHqVpwG2JF7QsQwCQeMECJGw2mlyJeCnz5vpFSMn1oTnPKZ3na+TPTTMB1w79o43R1xAmp213RFjzAeDerDJuIqJGjdIKCcWeiiWIqi+IAZJXnTQTCBB9mAyX8qTe6ZSHfMr4KRLOKjNq+oHjGvCwfAUJr6zIUI5EH1Ii/s0mxzmRuBIpc85jIW3otZN4wQN26P8NUQGuntNSWgjJ2aH/VSQXbjGmT5gd+hcBh4xxtdBSTLLz1kip/ivAVYkXvG6H/rpIPlrePD8AXJd4gduxgU5QTHhvZyR5/5/Ab5sMl21H8Zq8CFFKLxR1LBhbtqHEHHsAeMIO/Q8lXjAhhTY1p2YSErvW8rFrbRO71not5nz8juKeSouRUNEcRoaSKnlf1b9rVSktQHYbDWOad34MybeZx3DhtcWIQXMGQ0qs9RzzBWTh+AYieHYvsuPa2HhSJjWJF/wTyfWpLuHuBa5MvKAlL0oFuyPJ5PMZEk6cB+xVqzS7CDv0P4Io/U5nKFdsOtL89NjWh9w6duiviOTD3IAYj2cA/7VDfz8kZ6loce02zystYAzHfyHG+YmIeOJ/TDVeo5TNF1NqPJ83tjWQQoU55jEDCW2tzzIoJVIvatRMImLXmhK71ulIO4PrkUX48di1mhK2MgJvuyEJuZlx048sKt9xovRRZKdcZjhVC9tl7QqKmEeJKFotnCi9GanUOgj4KiLcd6D599udKD280TwYJ0rfcKL0VCdKt3CidCsnSn/qRGnbdViWYY5CEmMfRoyOGDn3bVPTTrzgOcRTswsiqPdpYOXEC8p6u9XiWIo7YH/ZDv3xIJx5ObJIzUY8kLORxetcJORXlM80QGuduCc95ve/DfEcZ81Q5wBvBn5nh36jDYvPpLj1xgvI/dMIh5Hv+ZkKbGCH/oYNHm+ZQMNPk4vTkYVkunmAeFFui11rfSdKG05idqL0L7Frvd0cd19kYekGvh271r6ISvNdSElvnnGTxq71M+BEJ0qfQHaan0VuvOo8iVeA95UJ/dU55gWMo15OEx0Tv7/YPEb7c+6iuAllo6xT8pyFGMdjlvhvh/47gS3I9272AB9FDJcNGXkvLQROGdUBTnw+QnHn8ynIfPjzBo53EZIUvA1DycL95rFfE3kwm1Hs+U4RY7ilPl/jEfXUTBJi11oJyVfJ23lOo0AiP3atVWLXOid2rddj11oYu9bNsWttXvka02X8NWAjhjQmehAD51Ykp2Y++SWls8y47o9da0sTztkcCW1lN/Q8RHp+JSdK47q/tKK0xsslz1k0GA4YBdZmqJt1NRZy/+2JqBPPM39fhBg0RydeMCrtESYR61EsJTAbOf91Y3pi7YYkbt+BeGbOBN7d5G/1NOXVmXWrVi9LjJmnxuRyvAcRfXpI8w9GnfciE9r0nOd6kI7FwzB6Mg8gSbDZtfJBYOvYtfZwovRW87puRiomZ8xAdh+bAt9GclqqxzAFmQQuiF3rXU6UPg18KHatuebvz5lyeEXpJKcj12z1dT0A/J2x3xQmFM/hg8DTiRf8yw79tRCvzVZIZd+F7argmuT8Bwm754WZFiBJww1hDJsLzaNVzkQaM+fNy28ghtOEY0yMmti1tkJcbSthGhzGrnUe8KV6mgcqTTGP8kn4tZy/HYV0GK+8TrqQm+Ts2LUck3+yBsX9iLqBnZwo3QdptvhXJIs/j7cC6wKPgeSqIDefoowFpwIfQkI8lTvybqTS5Uk79LdJvGCsvId/RRbOdchvLXAqgKnEuZzxX/6/rHEZ5hwXcH6nBpJH4gV/skP/e0gV5jRkHu9Dksf3aFXJe7zS8Z1G7FrvAG5CFsLZiBT0dCQEcVqnxzOJ+CPFSWjzyZch35fimOzbGNKTWUT5tVTpIi9rxrikxvMTmti1umPX2jJ2rd1i1yoTlFM6QOIF/YhRcwojE9pnASswhrlZJsdiT8T7krVWWIJ4CU5OvKCh8l+lMRIveANp99HHUHHDIuT8f3I8lEwnXvB9YEvEa/Nr4FvAmokXNFVBuizQ8YaWsWudgSSP5mXlLwTe5kSpdmQdBWLX2gEp5cusdhBD5x6kO/WSqte/gGTy59GLlC0/YV77MFLaXE0/cLoTpV8zrzsX6fGS5yXsA94yGSuHYtfaEtlJz0XCGz3Ib/WpTBVZGRvs0P8dw7WUKukDNkm8IK8n2ahhh34Poub9KrKI7ofonDwPRGXdyZX2Yof+KsDByPz3d6Q7/ERSjl+mGIvw0w4UlxkuQpJNb+3YaCYRTpTeGrvWpkh/mfcjE+JPgPMLwn7XI+XOeWqtbzAkrgdSsnsLkkOTeW36gRcRgb2MExEPUPW11wv8eJIaNKsBNzMy6XB34JeIYrEydtglzy1GwqYdMWqM0NuxSGJ/FzKX3gl8OvGCRiptlDZhWkx8d6zHoQhjkej2WslzFqJ5oowSTpT+zYlSz4nStZwo3dSJ0rAkj+l7iLFR7c7rA75ambzrROm9iKrprYjB8wJSnr1xZU8iU720M5KZ38uQxs2pwDHt+I7LIF8gP8w3A9jdGD3K2HE/xVUk0+ms3stpiA5PJgbYA2wP3GeH/vIdHIeijEvGwlPzU0Q3IS9j/FVkAlHGAU6UPhm71tZIPHYrxLj5D/A1J0qvqHxt7FoHILkHPcgOMgXucKL0xZzj3h271lpISeQc4OHJ6KGpYHuKc5cWIZVr6s4eO36IVA9Vt/pYiEjit9QM0vTm+TiSQJ8AFydeMKI5qR36mWhkdZsPC7mPPk1OTzRFmUyMhVFzMSLUthVDhk0mUb//aHU1VprDqAJvZ9od9AAvV/9GsWt9DEk0riwdnA1cWFn6XXXcQaQR4YTGSBd8Egn5rYYYJwFwQcV5LEso7EZEB5UxIvGC++3Q94DzEGM9C8feQ4uqyHbob4Co0k5H7pkFwA/s0D8w8YJq5extECO3qOnhR1GjRpnkdDz8ZEIdHwY+h/TJiRHVxY2cKL2z0+NR6sOJ0nlOlL5UYHQWadTMpLiZ4WThTCRvKfNKrYd4K0+veM1ZFFem9dI+hVylSRIv+BXS5fggpCnqFokX7Jh4wfzydxZj8mNuRHSgsnyqGeZxvh361d3qa3U0L+rDpiiThjHRqTGGzS/NQ1mGiV1rNkOl3Xls2qmxjDdi11oPqfSqDlvMAj4du9bpTpQ+jiRkX43IrmeLWz/iwdxHhQfHB4kX9NLeEu4dEUM3T2bfQqpEj674223kJ+2DlHSHbRyboiyTjLUiprLs08/IROJKWurTtIzzcYor/aYAe8HSUNwBiPLyjYiK81nAhk6U3t6BcSpjwzrkK3yD5FitV/mHxAsWIB7uao9MH3LNXIGiTHK0oaXSEk6U9seudSOwKyON5MXApZ0f1bihh+Kd9RQqFjRj2FxjHsoExw79VRGl1zJ5ixE5Z4kX/NIO/X8jZd0bIflWPwHOMBL7ijKpUaNGaQdfQsq5ZzNUxbMIqWb7+lgNahxwM/BF8pve9SK6Psrk5Byk710RqXnNCBIvuA0JRSljhB36KyKe1TWBR4BLTHhSGWM0/KS0jBOlTyHlqD8B/gU8g1RhbOhEaUvlrss4f0AmvOoEz4XAQ4homjLJsEN/OWAnyptRHqBNJ8cndujvgcxzASKC+GMgsUN/0uYPjic63iZBUSYTJpH6DGAfZPfdDVwCfGGSa/OMKUba/jDgA4jq9dnADaaf0mh/9urA38ivGAToS7wgT8er45iFegfEEL9yssv/26H/VkRJPe+3ewVYxfQMU8YIDT8pyijiROl8wI1d6zBgZeB5NWbGFrNQ34rks2R5TTsCVxl9mNE2bP7LyAaZlTw8yp9fEzv0ZyL5XVsh5ylF9HNOSrzgW2M6uLHFozjCMRXYA2kcqYwRGn5SlA7gRGmvE6VPqUEzttih34WUZc9heOXRLKTj9UdGewyJFywGTiJfV6YP+PZoj6EOTkPE/mYyZPxNB75ih/7eYzmwMaasYq0HybFRxhA1ahRFmUxsAqxU8NwsJCTVCY5HREcXIr3S3sD0VEu84IYOjSEXO/RnA/uTv3jPYnIn/z+KqD7nsQj4RwfHouSgRo2iKJOJFZFQShErd2IQiRcMJF7wRUS48iDgQOAtiRec3YnPr8GqlJ+jtTo1kHFISH5z00HE2Lm+s8NRqtGcGkVRmsIO/W0R1du3ArcD5yReUNbHajzwMPm9k0B0le7u4Fgw5+vyTn5mHTxPsX4OwLOdGsh4I/GCF+3Q/xhwpfnTLGAe4qXZyYQWlTFEq58URWkIk5dyCvAZJETRjexSFwM7JF7wlzEcXk3s0L8USeisDq/0ARslXvBE50c1vrBD/zIkv6i6e3wv8PnEC6KOD2ocYYf+XOB/ARt4HLgi8YLJrJ4+blBPjaIojbIDcDDDy1qzRoxX2aG/eidKo1vABS4EdkHafIAYZPuqQbOUQ5Ck2LcjSdUp4o24DPjFGI5rXJB4wRvAuWM9DmUk6qlRlDqJXWsqkkj6JSTZ9O/Ad50onVStDezQvwKpFMprxDgP2CXxgo6GcZrBDv01kIarrwC3a5uB4Zgu4rsCH0YaZl6SeMH9YzsqRSlHjRpFqYPYtbqRJMD3M9xD0Qsc60TpyWMysDHADv37gM0Knn4dcBMvuKpzI1IURRG0+klR6mNnYFtGKonOAr4Xu9YKnR/SmHE3Q2GbaqYxDsTjFEWZnKhRoyj1cQD5jSlB1GE/3MGxjDWnka+Iuwi4I/GCJzs8HkVRFECNGkWplxklz3VRrDI64Ui84Cngo8BriGjcPKT66W6kIkRRFGVM0OonRamPq5EQVJ63xkJ6CU0aEi+4xQ79tyDdplcE/pJ4wWNjPCxFUSY5miisKHUQu9Z0RCJ9NYYLk/UBVzpResCYDExRFEVZioafFKUOnChdiHQsvh7JHelFylzPQHRPFEVRlDFGPTWK0iCxa80FVgD+60SpqogqiqKME9SoURRFURRlQqDhJ0VRFEVRJgRq1CiKoiiKMiFQo0ZRFEVRlAmBGjWKoiiKokwI1KhRFEVRFGVCoEaNoiiKoigTAjVqFEVRFEWZEKhRoyiKoijKhECNGkVRFEVRJgRq1CiKoiiKMiFQo0ZRFEVRlAmBGjWKoiiKokwI1KhRFEVRFGVCoEaNoiiKoigTAjVqFEVRFEWZEKhRoyiKoijKhECNGkVRFEVRJgRq1CiKoiiKMiFQo0ZRFEVRlAmBGjWKoiiKokwI1KhRFEVRFGVCoEaNoiiKoigTAjVqFEVRFEWZEKhRoyiKoijKhECNGkVRFEVRJgRTxnoAiqIoY4kd+jOBI4H/A5YDHgOOTbzgujEdmKIoDdM1ODg41mNQFEUZE+zQnwbcCWwAzKh4qg/4WuIFPx2TgSmK0hQaflIUZTLzcWBdhhs0ADOBk+zQn9X5ISmK0ixq1CiKMpn5JDC74LklwAc7OBZFUVpEjRpFUSYzPTWen9qRUSiK0hbUqFEUZTLza6C34LlpwB86OBZFUVpEjRpFUSYzEfAKEmqqpA/4SeIFL3V8RIqiNI0aNYqiTFoSL5gPbA5cCywCFgCvAt8Gjhi7kSmK0gxa0q0oigKYSqe5wAuJF6RjPR5FURpHjRpFURRFUSYEGn5SFEVRFGVCoEaNoiiKoigTAjVqFEVRFEWZEKhRoyiKoijKhECNGkVRFEVRJgRq1CiKoiiKMiFQo0ZRFEVRlAmBGjWKoiiKokwI1KhRFEVRFGVCoEaNoiiKoigTAjVqFEVRFEWZEKhRoyiKoijKhECNGkVRFEVRJgRq1CiKoiiKMiFQo0ZRFEVRlAmBGjWKoiiKokwI1KhRFEVRFGVCoEaNoiiKoigTAjVqFEVRFEWZEKhRoyiKoijKhECNGkVRFEVRJgRq1CiKoiiKMiFQo0ZRFEVRlAmBGjWKoiiKokwI1KhRFEVRFGVC8P+pZfebLjjgLQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_2\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "dense_8 (Dense) (None, 500) 1500 \n", + "_________________________________________________________________\n", + "dense_9 (Dense) (None, 100) 50100 \n", + "_________________________________________________________________\n", + "dense_10 (Dense) (None, 50) 5050 \n", + "_________________________________________________________________\n", + "dense_11 (Dense) (None, 2) 102 \n", + "=================================================================\n", + "Total params: 56,752\n", + "Trainable params: 56,752\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "None\n", + "Training for 120000 steps ...\n", + "Interval 1 (0 steps performed)\n", + " 1/60000 [..............................] - ETA: 3:01:42 - reward: 1.0000" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\sarah\\documents\\sarah\\neuro data design\\q-learning\\qlearning\\lib\\site-packages\\keras\\engine\\training.py:2470: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.\n", + " warnings.warn('`Model.state_updates` will be removed in a future version. '\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "60000/60000 [==============================] - 147s 2ms/step - reward: 0.1712 : 2:14 - reward: 0. - ETA: 1:55 - ETA: 1:47 - rewa - ETA: 1:44 - reward: 0. - ETA: 1:4 - ETA: 1:42 - reward: - ETA: 1:42 - reward: - ETA: 1:4 - ETA: 1: - ETA: 1:40 - reward: 0. - ETA: 1:39 - reward - ETA: 1:3 - ETA: 1:37 - reward: 0. - ETA: 1:37 - reward: - ETA: 1:37 - reward: 0. - ETA: - ETA: 1:35 - reward: 0. - ETA: 1:34 - re - ETA: 1:32 - reward: - E - ETA: 1:30 - ETA: 1:29 - rewar - ETA: 1:28 - rewa - ETA: 1:27 - reward: 0.032 - ETA: 1:27 - reward - ETA: 1:27 - re - ETA: 1:26 - reward: 0.0 - ETA - ETA: 1:25 - reward - ETA: 1:25 - reward: 0.03 - ETA: 1\n", + "24865 episodes - episode_reward: 0.413 [-1.000, 23.000] - loss: 0.269 - mae: 0.523 - mean_q: 0.976 - mean_eps: 0.505\n", + "\n", + "Interval 2 (60000 steps performed)\n", + "60000/60000 [==============================] - 361s 6ms/step - reward: 0.7375\n", + "done, took 507.879 seconds\n", + "Testing for 2 episodes ...\n", + "\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.97 0.97 0.97 326\n", + " 1 0.97 0.97 0.97 373\n", + "\n", + " accuracy 0.97 699\n", + " macro avg 0.97 0.97 0.97 699\n", + "weighted avg 0.97 0.97 0.97 699\n", + "\n", + "[[316 10]\n", + " [ 10 363]]\n", + "G-mean:0.9712558282176605, F_measure:0.9731903485254692\n", + "\n", + "\n", + "Episode 1: reward: 659.000, steps: 699\n", + "\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.97 0.97 0.97 326\n", + " 1 0.97 0.97 0.97 373\n", + "\n", + " accuracy 0.97 699\n", + " macro avg 0.97 0.97 0.97 699\n", + "weighted avg 0.97 0.97 0.97 699\n", + "\n", + "[[316 10]\n", + " [ 10 363]]\n", + "G-mean:0.9712558282176605, F_measure:0.9731903485254692\n", + "\n", + "\n", + "Episode 2: reward: 659.000, steps: 699\n", + "Testing for 2 episodes ...\n", + "\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.97 0.94 0.95 156\n", + " 1 0.94 0.97 0.95 143\n", + "\n", + " accuracy 0.95 299\n", + " macro avg 0.95 0.95 0.95 299\n", + "weighted avg 0.95 0.95 0.95 299\n", + "\n", + "[[147 9]\n", + " [ 5 138]]\n", + "G-mean:0.953603623576553, F_measure:0.9517241379310345\n", + "\n", + "\n", + "Episode 1: reward: 271.000, steps: 299\n", + "\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.97 0.94 0.95 156\n", + " 1 0.94 0.97 0.95 143\n", + "\n", + " accuracy 0.95 299\n", + " macro avg 0.95 0.95 0.95 299\n", + "weighted avg 0.95 0.95 0.95 299\n", + "\n", + "[[147 9]\n", + " [ 5 138]]\n", + "G-mean:0.953603623576553, F_measure:0.9517241379310345\n", + "\n", + "\n", + "Episode 2: reward: 271.000, steps: 299\n" + ] + } + ], + "source": [ + "x_xor, y_xor = get_xor_data()\n", + "x_train_xor, x_test_xor, y_train_xor, y_test_xor = divide_train_test(x_xor, y_xor, 0.7)\n", + "INPUT_SHAPE = x_train_xor.shape[1:]\n", + "run_training(x_train_xor, x_test_xor, y_train_xor, y_test_xor)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The XOR data was able to achieve a geometric mean score of .97 and .95 on the first and second test runs respectively. " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model: \"sequential_3\"\n", + "_________________________________________________________________\n", + "Layer (type) Output Shape Param # \n", + "=================================================================\n", + "dense_12 (Dense) (None, 500) 1500 \n", + "_________________________________________________________________\n", + "dense_13 (Dense) (None, 100) 50100 \n", + "_________________________________________________________________\n", + "dense_14 (Dense) (None, 50) 5050 \n", + "_________________________________________________________________\n", + "dense_15 (Dense) (None, 2) 102 \n", + "=================================================================\n", + "Total params: 56,752\n", + "Trainable params: 56,752\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "None\n", + "Training for 120000 steps ...\n", + "Interval 1 (0 steps performed)\n", + " 27/60000 [..............................] - ETA: 1:55 - reward: 0.2593 " + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\users\\sarah\\documents\\sarah\\neuro data design\\q-learning\\qlearning\\lib\\site-packages\\keras\\engine\\training.py:2470: UserWarning: `Model.state_updates` will be removed in a future version. This property should not be used in TensorFlow 2.0, as `updates` are applied automatically.\n", + " warnings.warn('`Model.state_updates` will be removed in a future version. '\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "60000/60000 [==============================] - 186s 3ms/step - reward: 0.0177\n", + "29468 episodes - episode_reward: 0.036 [-1.000, 23.000] - loss: 0.311 - mae: 0.599 - mean_q: 0.976 - mean_eps: 0.505\n", + "\n", + "Interval 2 (60000 steps performed)\n", + "60000/60000 [==============================] - 338s 6ms/step - reward: 0.7323\n", + "done, took 524.327 seconds\n", + "Testing for 2 episodes ...\n", + "\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.98 0.96 0.97 343\n", + " 1 0.96 0.98 0.97 356\n", + "\n", + " accuracy 0.97 699\n", + " macro avg 0.97 0.97 0.97 699\n", + "weighted avg 0.97 0.97 0.97 699\n", + "\n", + "[[330 13]\n", + " [ 8 348]]\n", + "G-mean:0.9697829243186653, F_measure:0.9707112970711296\n", + "\n", + "\n", + "Episode 1: reward: 657.000, steps: 699\n", + "\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.98 0.96 0.97 343\n", + " 1 0.96 0.98 0.97 356\n", + "\n", + " accuracy 0.97 699\n", + " macro avg 0.97 0.97 0.97 699\n", + "weighted avg 0.97 0.97 0.97 699\n", + "\n", + "[[330 13]\n", + " [ 8 348]]\n", + "G-mean:0.9697829243186653, F_measure:0.9707112970711296\n", + "\n", + "\n", + "Episode 2: reward: 657.000, steps: 699\n", + "Testing for 2 episodes ...\n", + "\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.96 0.97 0.96 153\n", + " 1 0.97 0.96 0.96 146\n", + "\n", + " accuracy 0.96 299\n", + " macro avg 0.96 0.96 0.96 299\n", + "weighted avg 0.96 0.96 0.96 299\n", + "\n", + "[[148 5]\n", + " [ 6 140]]\n", + "G-mean:0.9631029924060853, F_measure:0.9621993127147767\n", + "\n", + "\n", + "Episode 1: reward: 277.000, steps: 299\n", + "\n", + "\n", + " precision recall f1-score support\n", + "\n", + " 0 0.96 0.97 0.96 153\n", + " 1 0.97 0.96 0.96 146\n", + "\n", + " accuracy 0.96 299\n", + " macro avg 0.96 0.96 0.96 299\n", + "weighted avg 0.96 0.96 0.96 299\n", + "\n", + "[[148 5]\n", + " [ 6 140]]\n", + "G-mean:0.9631029924060853, F_measure:0.9621993127147767\n", + "\n", + "\n", + "Episode 2: reward: 277.000, steps: 299\n" + ] + } + ], + "source": [ + "x_xnor, y_xnor = get_xnor_data()\n", + "x_train_xnor, x_test_xnor, y_train_xnor, y_test_xnor = divide_train_test(\n", + " x_xnor, y_xnor, 0.7\n", + ")\n", + "INPUT_SHAPE = x_train_xnor.shape[1:]\n", + "run_training(x_train_xnor, x_test_xnor, y_train_xnor, y_test_xnor)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The XNOR data was able to achieve a geometric mean score of 0.96 on both runs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The model achieved more than 95% accuracy on both XOR and XNOR. This is far better than the chance accuracy for this problem of 50%. It seems to imply that q-learning would be a good approach for the XOR/XNOR dataset." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "qlearning", + "language": "python", + "name": "qlearning" + }, + "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.8.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}