From 35384d9fd83316120cdce468610135bb9604cf84 Mon Sep 17 00:00:00 2001 From: coomdev Date: Thu, 10 Aug 2023 21:50:19 +0200 Subject: [PATCH] Use Yukariin's better model --- model_gen/captcha_75_25.h5 | 4 +- model_gen/captcha_ocr.ipynb | 1725 ++++++++++++++++++----------------- model_gen/penis.py | 47 + src/group1-shard1of1.bin | 4 +- src/model.json | 2 +- 5 files changed, 915 insertions(+), 867 deletions(-) create mode 100644 model_gen/penis.py diff --git a/model_gen/captcha_75_25.h5 b/model_gen/captcha_75_25.h5 index 28e66ba..edb802d 100644 --- a/model_gen/captcha_75_25.h5 +++ b/model_gen/captcha_75_25.h5 @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:38fe538eaa6f78c6d64cfa7af477d6f6680265c3faa97386f921131e436e215a -size 47170376 +oid sha256:61e6c4d5689ecaf2056fa81f7e02163371dbdace2dba0527069fe21cb5bf98c5 +size 791405 diff --git a/model_gen/captcha_ocr.ipynb b/model_gen/captcha_ocr.ipynb index 27b77cc..1cbd36d 100644 --- a/model_gen/captcha_ocr.ipynb +++ b/model_gen/captcha_ocr.ipynb @@ -1,886 +1,887 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "id": "mjAScbd2vl9P" - }, - "source": [ - "# OCR model for reading Captchas\n", - "\n", - "**Author:** [A_K_Nain](https://twitter.com/A_K_Nain)
\n", - "**Date created:** 2020/06/14
\n", - "**Last modified:** 2020/06/26
\n", - "**Description:** How to implement an OCR model using CNNs, RNNs and CTC loss." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "wWvlZPBJvl9U" - }, - "source": [ - "## Introduction\n", - "\n", - "This example demonstrates a simple OCR model built with the Functional API. Apart from\n", - "combining CNN and RNN, it also illustrates how you can instantiate a new layer\n", - "and use it as an \"Endpoint layer\" for implementing CTC loss. For a detailed\n", - "guide to layer subclassing, please check out\n", - "[this page](https://keras.io/guides/making_new_layers_and_models_via_subclassing/)\n", - "in the developer guides." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "Yq0Pe4Zuvl9U" - }, - "source": [ - "## Setup" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "id": "5q-xCl8Qvl9V" - }, - "outputs": [ + "cells": [ { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-08-08 08:50:40.669196: I tensorflow/core/platform/cpu_feature_guard.cc:182] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", - "To enable the following instructions: SSE3 SSE4.1 SSE4.2 AVX AVX2 FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n" - ] - } - ], - "source": [ - "import os\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "import sys\n", - "\n", - "from pathlib import Path\n", - "from collections import Counter\n", - "\n", - "import tensorflow as tf\n", - "from tensorflow import keras\n", - "from tensorflow.keras import layers\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "id": "mjAScbd2vl9P" + }, + "source": [ + "# OCR model for reading Captchas\n", + "\n", + "**Author:** [A_K_Nain](https://twitter.com/A_K_Nain)
\n", + "**Date created:** 2020/06/14
\n", + "**Last modified:** 2020/06/26
\n", + "**Description:** How to implement an OCR model using CNNs, RNNs and CTC loss." + ] + }, { - "data": { - "text/plain": [ - "True" + "cell_type": "markdown", + "metadata": { + "id": "wWvlZPBJvl9U" + }, + "source": [ + "## Introduction\n", + "\n", + "This example demonstrates a simple OCR model built with the Functional API. Apart from\n", + "combining CNN and RNN, it also illustrates how you can instantiate a new layer\n", + "and use it as an \"Endpoint layer\" for implementing CTC loss. For a detailed\n", + "guide to layer subclassing, please check out\n", + "[this page](https://keras.io/guides/making_new_layers_and_models_via_subclassing/)\n", + "in the developer guides." ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "tf.executing_eagerly()\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "sSm7N--8vl9W" - }, - "source": [ - "## Load the data: [Captcha Images](https://www.kaggle.com/fournierp/captcha-version-2-images)\n", - "Let's download the data." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "id": "g3EVJfHBvl9X" - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Number of images found: 10056\n", - "Number of labels found: 10056\n", - "Number of unique characters: 22\n", - "Characters present: [' ', '0', '2', '4', '5', '8', 'A', 'D', 'G', 'H', 'J', 'K', 'M', 'N', 'P', 'R', 'S', 'T', 'V', 'W', 'X', 'Y']\n" - ] - } - ], - "source": [ - "substitutions = {\n", - " 'B': '8',\n", - " 'F': 'P',\n", - " 'U': 'V',\n", - " '6': 'G',\n", - " 'Z': '2',\n", - " 'O': '0'\n", - "}\n", - "\n", - "def apply_substitutions(input_string):\n", - " output_string = \"\"\n", - " for char in input_string:\n", - " if char in substitutions:\n", - " output_string += substitutions[char]\n", - " else:\n", - " output_string += char\n", - " \n", - " return output_string\n", - " \n", - "data_dir = Path(\"./captcha_images_v2/\")\n", - "vdata_dir = Path(\"./validation/\")\n", - "cdir = Path(\"./cache/\")\n", - "\n", - "# Get list of all the images\n", - "images = sorted(list(map(str, list(data_dir.glob(\"*.png\")))))\n", - "labels = [apply_substitutions(img.split(os.path.sep)[-1].split(\".png\")[0]) for img in images]\n", - "\n", - "images_v = sorted(list(map(str, list(vdata_dir.glob(\"*.png\")))))\n", - "labels_v = [img.split(os.path.sep)[-1].split(\".png\")[0] for img in images_v]\n", - "\n", - "# Maximum length of any captcha in the dataset\n", - "max_length = max([len(label) for label in labels])\n", - "labels = [x + ' ' * (max_length - len(x)) for x in labels]\n", - "labels_v = [x + ' ' * (max_length - len(x)) for x in labels_v]\n", - "\n", - "characters = set(char for label in labels for char in label)\n", - "characters = sorted(list(characters))\n", - "\n", - "print(\"Number of images found: \", len(images))\n", - "print(\"Number of labels found: \", len(labels))\n", - "print(\"Number of unique characters: \", len(characters))\n", - "print(\"Characters present: \", characters)\n", - "\n", - "# Batch size for training and validation\n", - "batch_size = 4\n", - "\n", - "# Desired image dimensions\n", - "img_width = 300\n", - "img_height = 80\n", - "\n", - "# Factor by which the image is going to be downsampled\n", - "# by the convolutional blocks. We will be using two\n", - "# convolution blocks and each block will have\n", - "# a pooling layer which downsample the features by a factor of 2.\n", - "# Hence total downsampling factor would be 4.\n", - "downsample_factor = 4\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "gqn-NjRovl9Y" - }, - "source": [ - "## Preprocessing" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "id": "MjQltH0Mvl9Y" - }, - "outputs": [ + "cell_type": "markdown", + "metadata": { + "id": "Yq0Pe4Zuvl9U" + }, + "source": [ + "## Setup" + ] + }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-08-08 08:57:18.156048: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-08 08:57:18.442949: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-08 08:57:18.443125: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-08 08:57:18.446150: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-08 08:57:18.446487: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-08 08:57:18.446778: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-08 08:57:18.532929: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-08 08:57:18.533550: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-08 08:57:18.533758: I tensorflow/compiler/xla/stream_executor/cuda/cuda_gpu_executor.cc:995] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero. See more at https://github.com/torvalds/linux/blob/v6.0/Documentation/ABI/testing/sysfs-bus-pci#L344-L355\n", - "2023-08-08 08:57:18.533855: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1639] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 2216 MB memory: -> device: 0, name: NVIDIA GeForce GTX 1650, pci bus id: 0000:01:00.0, compute capability: 7.5\n", - "2023-08-08 08:57:18.534141: I tensorflow/core/common_runtime/process_util.cc:146] Creating new thread pool with default inter op setting: 2. Tune using inter_op_parallelism_threads for best performance.\n" - ] - } - ], - "source": [ - "from skimage.morphology import opening, square, label\n", - "from skimage.measure import regionprops\n", - "from skimage.io import imread, imsave\n", - "from skimage import img_as_ubyte\n", - "\n", - "def crop_and_fill(image, crop_size, fill_value):\n", - " # Create a new image with the desired crop size and fill color\n", - " cropped_image = np.full(crop_size, fill_value, dtype=image.dtype) \n", - " original_size = image.shape\n", - " cropped_image[0:original_size[0], 0:original_size[1]] = image\n", - "\n", - " return cropped_image.reshape(cropped_image.shape[0], cropped_image.shape[1], 1)\n", - " \n", - "# Mapping characters to integers\n", - "char_to_num = layers.StringLookup(\n", - " vocabulary=list(characters), mask_token=None,\n", - ")\n", - "\n", - "# Mapping integers back to original characters\n", - "num_to_char = layers.StringLookup(\n", - " vocabulary=char_to_num.get_vocabulary(), mask_token=None, invert=True\n", - ")\n", - "\n", - "def filter_image(img, kernel_size=3, num_components=8, min_height_ratio=0.25, max_height_ratio=1):\n", - " # Binarize the image\n", - " binary_image = img < 0.5 # Pixels with a value less than 0.5 will be True (1)\n", - "\n", - " # Label connected components in the image\n", - " label_image = label(binary_image)\n", - "\n", - " # Get properties of the labeled regions\n", - " properties = regionprops(label_image)\n", - "\n", - " # Sort the regions by area (in descending order)\n", - " properties.sort(key=lambda x: x.area, reverse=True)\n", - "\n", - " # Create an empty image to store the result\n", - " filtered_image = np.zeros_like(label_image, dtype=bool)\n", - "\n", - " # Keep only the largest components that satisfy the height constraints\n", - " for prop in properties[:num_components]:\n", - " minr, minc, maxr, maxc = prop.bbox\n", - " height = maxr - minr\n", - " if height > max_height_ratio * img.shape[0] or height < min_height_ratio * img.shape[0]:\n", - " continue\n", - " filtered_image[label_image == prop.label] = 1\n", - "\n", - " return filtered_image == 0\n", - "\n", - "\n", - "def read_and_process(imgpath, cdir):\n", - " img = imread(imgpath, as_gray=True);\n", - " img = np.hstack([img, np.ones((img_height, img_width - img.shape[1]))]).astype(\"float32\")\n", - " img = filter_image(img)\n", - " output_path = os.path.join(cdir, Path(imgpath).stem + \".png\")\n", - " imsave(output_path, np.clip(img_as_ubyte(img), 0, 238))\n", - " return tf.convert_to_tensor((1 - img).astype(\"float32\").reshape((80, 300, 1)));\n", - "\n", - "def load_data(images, labels, cache):\n", - " os.makedirs(cache, exist_ok=True)\n", - " # 1. Get the total size of the dataset\n", - " size = len(images)\n", - " # 2. Make an indices array and shuffle it, if required\n", - " indices = np.arange(size)\n", - " np.random.shuffle(indices)\n", - " # 3. Get the size of training samples\n", - " train_samples = int(size)\n", - " # 4. Split data into training and validation sets\n", - " x_train, y_train = images[indices], labels[indices]\n", - " x_train = [read_and_process(x, cache) for x in x_train]\n", - " return x_train, y_train\n", - "\n", - "\n", - "# Splitting data into training and validation sets\n", - "rx_train, ry_train = load_data(np.array(images), np.array(labels), Path(\"sdir\"))\n", - "\n", - "def pad_image(image, target_height, target_width, pad_value):\n", - " # Compute the padding sizes\n", - " height, width = tf.shape(image)[0], tf.shape(image)[1]\n", - " pad_height = target_height - height\n", - " pad_width = target_width - width\n", - "\n", - " # Check if padding is needed\n", - " if pad_height < 0:\n", - " pad_height = 0;\n", - " \n", - " if pad_width < 0:\n", - " pad_width = 0;\n", - "\n", - " # Pad the image\n", - " padded_image = tf.pad(image, [[pad_height // 2, pad_height - pad_height // 2], \n", - " [pad_width // 2, pad_width - pad_width // 2], \n", - " [0, 0]], constant_values=pad_value)\n", - " return padded_image\n", - "\n", - "def encode_single_sample(img, label):\n", - " img = tf.image.convert_image_dtype(img, tf.float32)\n", - " # 4. Resize to the desired size\n", - " #img = tf.image.resize_with_pad(img, img_height, img_width)\n", - " # 5. Transpose the image because we want the time\n", - " # dimension to correspond to the width of the image.\n", - " img = tf.transpose(img, perm=[1, 0, 2])\n", - " # 6. Map the characters in label to numbers\n", - " label = char_to_num(tf.strings.unicode_split(label, input_encoding=\"UTF-8\"))\n", - " # 7. Return a dict as our model is expecting two inputs\n", - " return {\"image\": img, \"label\": label}\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "fnwhurZ-vl9Z" - }, - "source": [ - "## Create `Dataset` objects" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "5q-xCl8Qvl9V" + }, + "outputs": [], + "source": [ + "import os\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import sys\n", + "\n", + "from pathlib import Path\n", + "from collections import Counter\n", + "\n", + "import tensorflow as tf\n", + "from tensorflow import keras\n", + "from tensorflow.keras import layers\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "2514\n", - "7542\n" - ] - } - ], - "source": [ - "split_index = int(len(rx_train) * 0.75)\n", - "\n", - "# Move the first 75% of x_valid to x_train\n", - "x_train = rx_train[:split_index];\n", - "# Move the first 75% of y_valid to y_train\n", - "y_train = ry_train[:split_index];\n", - "\n", - "# Keep only the last 25% of x_valid\n", - "x_valid = rx_train[split_index:]\n", - "# Keep only the last 25% of y_valid\n", - "y_valid = ry_train[split_index:]\n", - "\n", - "print(len(x_valid))\n", - "print(len(x_train))" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "id": "k2MZdcpXvl9Z" - }, - "outputs": [], - "source": [ - "train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n", - "train_dataset = (\n", - " train_dataset.map(\n", - " encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE\n", - " )\n", - " .batch(batch_size)\n", - " .prefetch(buffer_size=tf.data.AUTOTUNE)\n", - ")\n", - "\n", - "validation_dataset = tf.data.Dataset.from_tensor_slices((x_valid, y_valid))\n", - "validation_dataset = (\n", - " validation_dataset.map(\n", - " encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE\n", - " )\n", - " .batch(batch_size)\n", - " .prefetch(buffer_size=tf.data.AUTOTUNE)\n", - ")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "NI0NRV5Ivl9Z" - }, - "source": [ - "## Visualize the data" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "id": "7GT5RSNgvl9Z" - }, - "outputs": [ + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "KIc-3qB0L5OE", + "outputId": "5162487a-c946-4569-aa2a-b6dd3944e85a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 2 + } + ], + "source": [ + "tf.executing_eagerly()\n" + ] + }, { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0oAAAGtCAYAAAAoBIT+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACHbUlEQVR4nO3deVwV9fc/8Ne9wAUUQUVFUASXhNRygRTc0DSXSs0003LNPqktbvUpSdPUUktzzSUT11JTcf1mJSWo5a5o5QKmomQggrKIAgLn94e/Ox/u3AuXy3rJ1/PxeD8eMPc9M+fOnXNnzszcGY2ICIiIiIiIiEihLe8AiIiIiIiIrA0LJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUrcezYMfTt2xf16tWDvb093NzcEBgYiHfffRe3bt2CTqfDwIED8x0/NTUVlSpVQu/evU2+vmrVKmg0Gjg5OSnDrl69iipVqqBfv34mx9m4cSM0Gg2++uorAMDw4cMNxgeATp06QaPRoEePHkbjx8TEQKPRYN68eWbfP5Ep27Ztg0ajwXfffWf0WvPmzaHRaPDTTz8ZvdawYUNotVrY2tri3XffNTntWbNmQaPR4Mcff0ROTg7mz5+PHj16oG7duqhUqRIef/xxTJo0CcnJyco4ixYtUsbJz9dffw2NRoPt27cD+F+O6JuDgwOaNGmCTz75BFlZWQbjMmfIEmvXroVGo8HJkycNhv/6668YNGiQsj2pXLkymjZtinfffRcXL15U+r399tvQaDSIj483GP/27dvQarWws7PD3bt3DV77+++/odFoMHHiRAD/W2c1Gg0+/vhjk3G+9tprSh8ARdqm5fdeExMT4e/vDycnJ4SFhRWwtOhRpV93NBoNIiIijF4XETRq1AgajQadOnXC1q1bodFosGTJEpPTe+ONN2Bvb4+zZ89Co9Fg0qRJ+c770qVL0Gg0GDt2rMHwF198ERqNBm+//bbJ8SIiIpSY165da7LP008/DY1GA29vb2VYVFQUKlWqhFdeecWo/507d1CnTh20adMGOTk5+cZMKkLl7v/+7/9Eq9XK008/LZs2bZKIiAjZtGmTvPvuu1KnTh0REenXr5/Y29vL7du3TU7jq6++EgCyc+dOo9f+/vtvcXFxEQ8PD6lcubLBaytXrhQA8u233xoMj4uLk+rVq0v37t2VYcOGDTMaPygoSAAIAPnll18MXrt69aoAkLlz5xZ+YRDlcevWLdFoNDJq1CiD4UlJSaLRaKRy5crywQcfGLwWGxsrAGTixIny4YcfilarlUOHDhn0+eOPP0Sn0ynTTUtLkypVqsgbb7whW7dulfDwcPniiy+kWrVq0qRJE7l3756IiCQmJoq9vb289NJL+cYcGBgoNWvWlKysLBF5mCMNGjSQI0eOyJEjR2T37t3Su3dvASD/+c9/DMZlzpAl1qxZIwDkxIkTyrDJkycLAAkMDJSvvvpK9u/fL/v27ZN58+bJE088IQAkOztbRES2bdsmAGTTpk0G092+fbvY2dmJnZ2d/PDDDwavrV+/XgDI7t27ReR/62yVKlXEy8tLcnJyDPqnpaWJk5OTODs7S95dDku3aabea2xsrPj6+kq1atXkyJEjli4+ekTo150qVarI4MGDjV4PDw9XXg8KChIRkVdeeUUqVaokly5dMuj7008/CQCZPXu2iIj4+fmJu7u7klNqwcHBAkDOnDmjDLt586bY2dkJAKlatarcv3+/wJjat29v9PqVK1dEo9GIs7OzeHl5Gby2YMECASDbtm0zGD5w4EBxcHCQCxcumIyVTGOhZAU6duwoDRs2lAcPHhi9pt/o7N27VwDIkiVLTE6jTZs24ubmZnIazz//vPTq1ctkoSMi0rNnT6levbr8888/yrDevXtLtWrV5O+//1aG5VcoNW7cWBo0aCB+fn6Sm5urvMadPioJTzzxhPj4+BgM0+/IjR07Vlq3bm3wmn5Hbs+ePZKZmSnNmzeXhg0bSnp6uoiIPHjwQPz8/KRBgwaSlpYmIiLZ2dmSmJhoNO+tW7cKANmwYYMybMCAAaLT6Uz2v3DhggCQd999VxkWFBQkTZs2Nej34MEDeeyxx0Sn0xlsJJkzZAl18bBx40YBIKNHjzb4LtbLzc2VL7/8UtmpS0xMNHkgYuzYsdK2bVsJDAyU999/3+C11157TbRarSQnJ4vI/9bZ119/XQDIvn37DPqvWrVKHB0dZfDgwQaFkqXbNPV7jY6Olnr16om7u7v8/vvvhV5m9OjRrzuvv/66ODo6SkpKisHrgwcPlsDAQGnatKlSKN2+fVs8PDykXbt2yn5YSkqKeHp6SmBgoJJDy5YtU7Y3atnZ2VKnTh3x8/MzGD537lwBIM8995zJA9Ui/yuU9HkVHR1t8PqUKVOkbt260rNnT6NCKTc3Vzp27Cg1a9aUmzdviojIli1bBIB88cUXhV9wJCIivPTOCiQlJaFGjRqwtbU1ek2rffgRde/eHXXr1sWaNWuM+ly4cAHHjh3D0KFDjabxzTff4MCBA1i2bFm+8w8JCQHw8HQyAGzYsAG7d+/Gl19+iTp16piN387ODp9++ilOnTpl8hIpouLo3LkzoqKiEBcXpwyLiIjAU089hWeffRanTp1CWlqawWs2Njbo0KEDdDod1q9fj9jYWHzwwQcAgNmzZyMyMhJr165VLiW1sbGBq6ur0bxbt24NAIiNjVWGjRw5EllZWdi4caNRf31+vvbaawW+J1tbW7Ro0QJZWVkGl/YRFccnn3yCGjVqYMGCBcplbnlpNBq89dZbsLGxAQC4urriiSeeMLocKSIiAp06dUJQUBDCw8ONXmvVqhVcXFwMhvv4+KBt27ZYvXq1wfDVq1fjxRdfNOpf1G0aAJw5cwbt27eHra0tfv31VzzxxBP5LxSi/2/QoEEAgE2bNinDUlJSEBoaavSdXa1aNYSEhOC3337DggULAAATJkxAUlIS1q1bp+TQK6+8AkdHR5Pr8b59+3Djxg2jaa9evRpubm5Yt24dHB0djXImr2eeeQaenp4GfXJzc7Fu3ToMGzZM2UfMS6PRYM2aNbh37x5Gjx6N+Ph4jBkzBh06dMD48ePNLCVSY6FkBQIDA3Hs2DGMHTsWx44dw4MHD4z6aLVaDB8+HKdPn8bZs2cNXstv5ywhIQHjx4/HnDlzULdu3Xzn7+7ujqVLl+L//u//MHv2bIwbNw79+vUzeY1rfl5++WX4+flhypQpJuMnKqrOnTsDgMHOXHh4OIKCgtCuXTtoNBocOnTI4LW8O3JPPvkkpk+fjqVLl2LRokWYOXMmJk6ciA4dOpid9/79+wEATZs2VYZ17doVXl5eRhu3nJwcbNiwAQEBAWjSpInZaV+9ehVVq1ZFzZo1zfYlMueff/7B+fPn8cwzz8DBwaHQ46kPRCQlJeGPP/5AUFAQgoKCcPr0aaSmpgJ4eMDgypUrSk6qjRw5Ejt37sSdO3cAPPy9xOHDhzFy5EijvkXZpgEPf3/VqVMn1KpVC7/++isaNGhQ6PdKjzZnZ2f079/f4Lt706ZN0Gq1ePnll4369+jRA6NGjcKUKVOwYMECrF69Gp9//jkee+wxpY+Liwv69euHPXv24NatWwbjr1mzBg4ODgb7UocPH8aFCxcwdOhQuLq6ol+/fti/fz+uXr1qMmZ9nqxfv175XdG+ffvw999/Y8SIEfm+1wYNGmDu3LnYsWMH2rdvj4yMDKxZs8ZkYUUF4xKzAnPmzEH79u2xZMkSBAQEoHLlymjXrh3mzJlj8ENa/Q9i8yZ5dnY2NmzYgHbt2sHX19dgum+++SZ8fHwwZswYszEMHDgQAwYMwIcffgidTocVK1ZY9B40Gg0+++wzXL58Wbn5A1FJCAoKglarVQqlpKQk/PnnnwgKCoKTkxNatWqlHPWOjY3F1atXjXbk/vvf/yIgIADjx49H48aN8cknn5id740bNzBp0iT4+/vj+eefV4brN1xnzpxBZGSkMvyHH35AXFycyZ1C4GGuZmdnIz4+HtOmTcPJkycxZ84c5cgkUXHoz3p6eXkZvZaTk6Osf9nZ2RAR5TX1gYgDBw7AxsYGbdu2Rbt27QBAORChz7P8CqUBAwbA1tZWOdsaEhKC+vXro1OnTib7W7pNAx4e1QceHsRwd3c3vTCI8vHaa6/h+PHjOHfuHICHZ3deeuklVKlSxWT/efPmwcPDAxMnTkTXrl3x5ptvGvUZOXIkHjx4gG+++UYZdvv2bezevRv9+vVD1apVleH6K3j0BwFGjhwJETF5RkpvxIgRiIuLU24itHr1agQFBaFhw4YFvtfRo0fD19cXly9fxvTp0832J9NYKFkBV1dXHDp0CCdOnMCcOXPQp08fREdHIzg4GE888QQSExMBAPXr10fnzp3x7bffKnfL+uGHHxAfH2905C00NBR79uxR7sBVGDNmzAAAjB07FjVq1LD4fXTp0gXdunXDjBkzDC6FIiqOatWqoXnz5kY7cvqduLyXB+W3I2djY4Np06YBAD788EPY29sXOM/bt2/j2WefhYjgu+++MzoKN2LECGi1WoMdvDVr1qBy5comj0yeO3cOdnZ2sLOzg7u7O2bMmIHg4GCMGjXKgiVBVDSurq7K+mdnZ4fQ0FDlNfWBiIiICOUuclWqVDE4EBEREQFbW1u0b9/e5HycnJzw0ksvYfXq1cjOzsb69esxYsSIfLdBlmzT9Hr37o2UlBSMHz+ed+4ii+kLjNWrV+OPP/7AiRMnCrxU2snJCe+//z4AYPr06SbXZf008xY73377LTIzMw2mfffuXWzZsgVt27ZVDgLox127di1yc3NNxqA/2LB69WokJSVh165dZi/vBoAff/wRFy9ehFarxc8//2y2P5nGQsmK+Pv744MPPsDWrVvxzz//YMKECYiJicHnn3+u9Bk5ciSSkpKwe/duAA93zpycnDBgwAClz927d/HWW2/hnXfegYeHB5KTk5GcnKxsiJKTk5Genm40f/3Oo06nK/J7+Oyzz5CYmMjbG1OJ6ty5M6Kjo/HPP/8gPDwcfn5+yu+LgoKCEBkZiZSUFISHh+e7I1fY9fvOnTt45plncOPGDYSFhZm8tMfLywtdunTBxo0bkZmZicTERPzf//1fvkcmGzZsiBMnTuD48ePYunUrmjdvjtmzZ2Pz5s1FWRxERjw9PQEA165dM3otIiICJ06cMHmlQNWqVdGiRQuDgw1BQUHK60FBQUoRFR4eDn9//3yPvgMPt1GnT5/Gp59+ilu3bmH48OEFxl2YbVpeH330EaZOnYqNGzdi8ODBLJbIIhqNBiNGjMA333yDFStWoHHjxmYvwza37dBoNHjttdfwxx9/KLevX7NmjXIgQO+7777D3bt3MWDAAGW/LCUlBQMGDEBsbGyBt7cfOXIk9uzZg/nz58PR0RH9+/cvMObk5GS8/vrreOqpp/DVV1/hxx9/VM5mkWVYKFkpOzs75Qj4n3/+qQx/8cUXUa1aNaxevRq3bt3C//3f/+Hll182eL5RYmIibt68iS+++ALVqlVT2qZNm5Ceno5q1arh1VdfLZW4W7RogUGDBmH+/Pm4efNmqcyDHj15Lw+KiIgw2JHTF0UHDx5UbvKgft5XYd25cwddu3bF1atXERYWhieffDLfviNHjsTt27exa9cufPPNN8jKysr3sjsHBwf4+/vjqaeeQv/+/fHLL7/Azc0N48ePN3pODVFReHh4oGnTpggLC0NGRobBay1atIC/vz98fHxMjtu5c2dcunQJv//+O86dO2dUKEVGRuL3339HTExMvpfd6bVr1w4+Pj6YMWOG8kP0ghRmm6Y2ffp0TJs2DZs3b8Yrr7yC7OzsAudBlNfw4cORmJiIFStWFPg7H0unaWNjg9WrV+Ps2bOIjIxULi3V0xcq48ePN9g3mz17tsHrprz44ouoVKkS5syZg4EDB8LR0bHAeN555x3cvn0b69atw+uvv45nn30WEydOxN9//10C7/bRwkLJCuS9m1deFy5cAPBwA6in/2Hgvn378Nlnn+HBgwdGp2Br166N8PBwo9a9e3c4ODggPDy8UL/RKCr9gzSnT59eavOgR0vHjh1hY2ODbdu24dy5cwa/eXBxcUGLFi2wbt26Qu3I5UdfJF25cgX79u1Dy5YtC+z/wgsvwNXVFatXr8aaNWvQuHHjfC9JUnN1dcWcOXNw8+bNfB9qSGSpyZMnIzExERMnTjT4HZI5+pyZPn06tFqtwXqs/1v/fV6Y/JoyZQp69eqV78Oe8yrMNs2Ujz/+GNOnT8eWLVtYLJFF6tSpg//+97/o1asXhg0bViLT9PDwQI8ePbBp0yYsXboUWq3WYNoXLlzAkSNH0K9fP5P7Z126dMGuXbuQlJRkcvqOjo6YOnUqevXqZfZ35/qDdzNnzsTjjz8OAFi5ciW0Wi3+85//lMj7faSU793JSeThc2J69uwpy5Ytk/3798vPP/8s8+bNE3d3d3FycjJ6RsTp06cFgGg0GvH19S30fPJ7jpKeuWe4DBs2TJycnAyGmXpGjIjIuHHjlAfR8pkwVBKeeuop0Wg0YmNjY/QcjAkTJohGoxEAEhYWZnJ8/XMptm7davTavXv3lOkvWrRIeTisvv31118mpzl27FhlvnPmzDHZJ78cycnJkSeeeEKqV6+uvB99Ds6bN6/AZUEk8r/nw5w8eVIZpn/gbNu2bWXlypUSHh4uv/zyi6xdu1a6dOkiAOTHH380mE5qaqrY2NiIRqORp556ymg+LVu2FI1GI3Z2dsrzyPQK++yvt956S/Lb5SjMNs3UA2dFRGbOnCkApH///iafI0iU37qjlvc5SkUZf/v27cp63KNHD4PX3n33XQEgx44dMznu7t27BYAsXLhQRAreXuX13HPPGTxH6datW+Lm5iZt27Y1eviz/n2sWrWqwGmSIZ5RsgJTpkxBtWrVsGDBAvTu3Rs9e/bE4sWL0bVrVxw/ftzoGREtW7ZEy5YtISKFOvJWUu7du2f2R/B6U6ZMgbOzcylHRI+Szp07Q0TQsmVLo3UrKCgIIgKdToe2bdtaPO2bN2/ixIkTEBGMGzcOgYGBBm3mzJkmx9PfscjGxgZDhw61aJ5arRZz5szB7du3sXDhQgAPcwxAofOMHm2m1pdPPvkEBw8ehKenJ2bMmIFu3bqhV69e+Pzzz9G4cWOcPHkS3bt3N5hOlSpV4OfnBxExuOxOT59frVu3RqVKlUr8fRRnmzZlyhR8+umn2LZtG15++WU+noLKzfPPPw83Nzej9fjBgwfYsGEDWrRooTybT+3ZZ59F3bp1i/07ojfffBNpaWlYu3at0U2Ihg8frlyCl/fZgFQwjYgF5+fpkda8eXPY29vj+PHj5R0K0b/Sjh078OKLL+L777/Hs88+W97hkJUbN24cvvzySyQnJxd4gwUiIioa40deE+WRmZmJo0eP4ocffsDvv/+uHPkmopJz+fJlnDlzBh9++CFq166Np59+urxDIit26tQpnDhxAqtXr0bv3r1ZJBERlRKeUaICxcTEoGHDhvDw8MCIESPw8ccf88nORCVs+PDh2LJlC9q0aYMFCxagRYsW5R0SWbH69esjJSVFuUzb1dW1vEMiIvpXYqFERERERESkwlMDREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUqkwtwfXaDTlHQJRgazhvijME7J2zBMi85gnROaVRZ7wjBIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUWCgRERERERGpsFAiIiIiIiJSYaFERERERESkwkKJiIiIiIhIhYUSERERERGRCgslIiIiIiIiFRZKRESF5O7uDhsbm/IOg6hCql69Ovz8/FC1atXyDoWIqFBYKBGR1atduzbq1KkDBweHcpm/TqdDnTp1MHXqVHzzzTdo3rw5dDpducRCVJHUqFEDderUwdChQzFp0iS89957qFKlSnmHVaKcnZ3LOwT6Fxg0aBC8vLyg1XLX3Jo8Ep+GnZ2dwf+2trblFMmjqX379qhZs6bZflqtFo6OjuW2M0zm2dvbo3bt2pg0aRIqV65cotPOm5f29vZwdHRE//79MXPmTJw6dQp//fUX5s+fj169euHjjz9GjRo1SnT+Bfn444/x119/4T//+Q8GDhyI48eP46uvvoK/v79B3BqNhusvlZiKvj75+Pjgt99+w19//YWQkBB4enriu+++Q2JiosXvS6PRWNXZXI1Gg549e2L69OlYvHgxd26p2Fq3bo0VK1bA29vb5IE4nU6H7t27G+3TUimTCgJAkdvSpUtl6NCh0rRpU9FoNPKf//xHhg4dKo0aNSrWdNnMt65du8qtW7fk559/lpo1a5rs06ZNGxk6dKh89tlncuPGDTl58qTY29uXe+yWNmtQGu/LwcFBBg0aJEOHDpUjR47IzZs3JS0tLd/PsyjNzc1NNm/eLMOHD5dhw4bJmTNn5I8//pDly5dLSEiIDBw4UBITEyU7O1vS0tIkNzdXfH19y+yz3bt3r6xbt04uXLhgsLzv3LkjGzZskPbt2wsA6devn5w/f16qVq1a7uujtTZrUN7LoKDWpk0b8ff3FwDy5JNPyoULF2TEiBHSvn17cXNzk6FDh5bpul9Qc3V1lf79+4uNjY3BcJ1OJwMHDpQFCxYYLPdz587JtWvX5OLFizJ9+nRxdHQs9LxeffVVefXVV8v9PetbvXr15M6dOyIikpGRIUFBQSU6fWtQ3su4MM3T01Pc3NzKPY6SaB4eHvLLL79IfHy8BAcHCwCxs7OTl19+WYYOHSq7du2Szz77THQ6XYnOt3v37ibzuCK0MsmDMplLCSjOgjx+/LiIiMTGxsrp06dlz549MmHCBBk0aJDMmjVLqlWrJg0bNiz3D/zf2Hx9feXHH3+Ub7/9Vp5//nnp1KmTdO/eXQ4ePCinT5+W06dPy61bt+T69euyaNEiGTx4sEyZMkU6duxY4l8Gpd2sQWm8r5o1a0paWprBfEqyUHruueckOjpaREQuXbokM2bMkBYtWhjtDOrzWC80NFSqVatWJp9tnTp1BIAsWrTIIIapU6fKBx98IIcOHZJt27bJxo0bpVWrVhVyg1NWzRqU9zIoqC1ZskQSEhLk9OnT8vnnnysxJyUlKXmi35Zt2LBBOnXqJLVr1y6z+Bo3biydOnWSgQMHytGjRyUrK0uOHz8ubdq0EQDSrFkzWbJkiWRnZxst9w0bNkjPnj3l5ZdftmiePj4+EhMTI3/99Zf07t273D+j9evXyx9//GHw2eiLW+ZJ2bYXXnhBoqOjJTw8XJ555hnp1KmTODk5lXtc3t7eRdoOtG3bVmbOnCmVKlWSefPmydmzZ5VcOnPmTKnEevDgQcnKypLIyEhlv2zEiBHlvgwL08okD8pkLiWgOAtSvYOll5mZKRs2bJC5c+dKz549y/0DL+lWs2bNEj3qX9RmY2MjmzdvlqioKImKipKkpCSjz+KLL74QAOLv7y/vv/++pKeny759+2T+/PlSuXLlcn8PhWnWoLTWo9IolGrXri2NGzeW999/X0REbt26VeDOhj6Pc3Jy5NatW3Lw4EFp166dNGzYUDQaTal+to6OjtKuXTuJjo6WS5cuKety3759BXhYSI0bN07++OMP2bp1q7Ro0aLCFfpl1axBeS+DgtqSJUvyjfvatWuSlpYm27dvl759+8qhQ4ckJiZGIiMjZezYsdK4cWNxcHAo1fiWLl0qIiJxcXGyfPlySU1NFRGRdevWiaOjo/zyyy/5xr97925p3LixNG7c2OxBDjs7O2nUqJHSf9y4cTJ16tRSOQhRu3ZtadKkiWzYsEF2796tFH35tWPHjonIw4J14MCBZvszT0qvvfDCC0ZxHzhwQFasWCFardaof7Vq1cTW1rbE4/Dw8JBvv/1Wdu/eLbNnz5YlS5aIs7Nzocb19vZWzq5OnjxZ9u3bJ7t375a4uDiD95WSkiKDBw+WRo0aleh7OHjwoNEyjIqKMrn89M3R0VG8vb3L/fMvC9aRjYVQnAX5888/y+3btyUjI8NousePH5caNWqU2Ifm6ekpM2fOlJo1a0qlSpXKZcWxs7OTKVOmyKlTpyQ4OFg++OADcXFxKbeCQ6vVSvv27UWr1Yqtra3R5Rgi/yuUatWqJYsWLTI4Gjlw4MAKcSmeNbBkHalWrZq4uLiY7VuvXj2jQunWrVtFyht7e3upVq2aDBw4UFavXi3Z2dly//59uX37tly6dElatGhhcjydTienTp2SxMREGTNmjPj7+8vgwYMlJydH0tLSZMmSJUU+gleYNmLECBkzZoz89NNPsmrVKlm6dKksXbpUOnXqZNDvv//9r+Tm5kp2drZMmjTJ4vnoP5dq1apJrVq1ZPbs2RXmyN6/MU9Ksmm12kLlW0GFkr+/vzz//PPy+uuvi729vWi1WnFzc5N33nlHtmzZIrdu3ZJvv/1W2rZtK1WrVjU4gODk5CS9e/cucOenME1fKImIxMfHy+LFiyUtLU0uXLggoaGhBS733NxcSUtLk6tXr+ab6/rm7e0t9+/fl5ycHMnIyJDo6GgJCgoSV1dXmTFjRonspLVu3VoWL14s586dk5ycHCXO9evXG10WqNFoxNXVVWbOnCnx8fEiIrJ///5SO3thDcojT0w1jUYjNWvWlFmzZiln9/Vt0KBBJmM/c+aM0fbAzc1N9u/fL+PHjy/xbcXMmTOVeb/33nty8+bNQhVKNjY2Su4sXrxYjh49avA+tm/fLu+884688847EhUVJbm5uXLv3j2pV69eseKtVKmSVKtWTdq2bStHjhyRd955R3bs2CG5ubkiYr5Qat++vdy+fVtmzpwpffr0kbfffrtUClBryBPryMZCKM6CdHJyEhcXFxkwYID8/PPPBtPNysoSLy+vEvvQ/Pz8JDc3V5KTk+XAgQMybtw4GTZsWLE3Tpa814CAANmwYYOIiAwfPly6du0q69evlyNHjhh9yZR1q1u3rnIEMq+5c+cqfb799luD19LS0mT16tUmiyUbG5syW7bWkLDmFBSfjY2NODo6yqhRo2Tp0qWSnJwsUVFRBf5OQKPRyOLFi43mM23aNIvP4nTu3Fk2bdokycnJkpGRIePHj5d58+bJiBEjxMXFRapUqWI0TqVKleStt96SVatWSWZmpqxZs0b5vHv27GkQU0pKisydO1dGjBhR4uuE/ii9+tK7mzdvGvw2YcKECfLbb7/J/fv3Ze/evWJjY5PvctJoNGJjYyM1a9aUsWPHyttvvy2DBw+WpKQkuX79usycOVPmz58vDRo0KPd1+1HKk9JqPj4+cv36dXnvvfekWrVqYmNjY3JnraBCqVWrVvlO397eXqpWrSoLFiyQtLQ0uXHjhsGVErVq1ZKbN2/K1KlTpU6dOkU+C5u3UBJ5mAOLFi0yOpiSm5trUHzoDR8+XFq3bm12Pt7e3pKeni6rVq2S+fPny7Rp0+TQoUOSnJwsOTk50rZt20LFq9VqlWWd93tBq9VKZGSkyeWclJQk7dq1M5hOrVq15J9//lF2JG/fvi1z584ttQOQ1qA8vyc0Go1otVrx8PCQqVOnSlJSkuTk5Ejz5s2VPjY2NgaXQOZl6vLOwYMHS2Zmpvzxxx/i6ekp7du3Fzs7O5PztrGxkaCgIHnuuedk3Lhx0rlz5wLj/fTTT5V5v/vuu5KQkFDoQikqKsoo/k2bNsnChQulU6dO0qxZM3nnnXfk4sWLIiKSnZ0tr776apG3c3369JF9+/ZJcnKypKeny4kTJwR4eLZNfxAgISFBJkyYkO9v7zp27CgiIrNnz5Z//vlHsrKypGPHjmW+npQF68jGQiiphVq1alW5dOmSMt2SLpQaNmwosbGxBrFnZWXJsGHDSnVl8fDwkI4dO4qnp6fExcUpZ2SuXr0qn376qaSnp4uIlMuKnLfVq1dPMjMzDZZPenq69OjRQ+mjLpREHm6U1D+Qt7e3l0OHDslPP/0kffr0KfffmVmD/GIbMWKEREdHy+XLlw12XuLi4goslGbNmiVhYWFG87H0bEnNmjXl9OnTcuXKFWWH6uzZs2bPFHbp0kVZX/r27WuwU6IulPRiYmJMbvyK0zp16iR9+vSRuXPnSlZWlsH8Dh48qJwpsLOzk3r16klSUpKkp6dLdHS09O/f3+Q0X375ZYmOjpbNmzdLTEyMZGVlSffu3WXx4sVy7dq1f+2le9agPN63TqeTDz74QHbs2CFbtmyR6OhoOX78uPTr10/69Omj7FQVtVDSNwcHBxk/frz4+PhI69atJSAgQABIUFCQclVFbGysTJ06tUg3NFIXSiIPiyX9wRcRkd9//13ee+896dOnj9y6dcugb2F/y+Pt7S0ZGRly+fJluXHjhtE8C1soffHFFxIdHS3R0dHyww8/SJ8+faRPnz7SrFkzGTFihMnlfOnSJZNnI/Tb0atXrxZ6/swTy5v+ANnRo0fl+vXrBjGpC6W8+3N5BQcHGx0MsLGxkVGjRkl4eLj89NNPcvDgQdm0aZPB1T8tWrSQRYsWSXR0tNy5c0fS0tIkPT29wBuoODo6ynfffafMu7CFkq+vrzg4OJgslPLmSdWqVWXChAkyd+5cuXbtmog8PIC8efPmIi3fvXv3GsxLXyg5OjrKP//8Y/DaokWLlPFatWql5E9wcLDExMTIggULJCcnR86fP1/ss1zWmifWkY2FUJIL1t/fX3bs2CEiD496rVixQvz8/Erkh+GNGzdWKvK8xo0bVyoriYuLi+zdu1fOnTsnqampcvToUcnNzZXExEQ5efKkbNu2TYKDg+XUqVOSkZFRrEKpUqVKsmvXLunZs6f4+fmJq6urxdMwVSiJ/O/SO8B0ofTgwQOZPXu2+Pn5KZc6ODg4GBSlZ8+eNXlW4t+UsObkF9vJkydN9jdXKE2ZMkX27NljNF5+hVKzZs3yPcLq6+srAwYMUDZ8sbGxJn9PodVqZcOGDRIREaHkUlJSkjRp0kTpo9FoTMYlUjqF0unTp0VE5Pz587JmzRqDy3hnzJih9PPw8JARI0YY/A4vv0vn3njjDTl37pwEBATIypUrJTc3Vy5fviwiwkKplJX3MujXr59RTCdPnpSIiAiTRYFeYQqlvG306NGSlJQkERERRr93EBH5448/LL5Do7pQysrKkmPHjknr1q3l3XffleTkZImMjFS+p8PDww36W1IoqQ9K5FXYQsXU9kRE5Pr16zJmzBiTr+UtlF566SWJiIiQAwcOyMmTJ+XkyZOydevWEr1kn3li3N577z0ljtjYWOVMXt5CSavVGq1fetHR0SbP2NrZ2cmBAweUfpcvX5bw8HDlDOKqVauMpmXuN7menp4G+zXvvvuuzJkzx+zlfZ9//rls3bpV/vnnH6MzsvnlSePGjaVr165y8+ZNOXPmTKHzV6vVSvPmzWXTpk1GvxPXF0r29vby448/yr1795TXNm3aJH5+fuLn5ydjxowxyMkJEyZIo0aNJCgoSIKCgsrlbq9l4ZF8oNDJkycxYsQIaLVadO7cGa+//jpGjRqF7du3Y8CAAcjJySnytKtUqQI3NzeLxmncuDHefPNNfPHFF0hNTUVKSkqhx83KykJYWJjBPffXrVuHyMhIHD16FB4eHpgzZw4uXryIxx57zKK41GxtbdG+fXv07t0bAHDkyBFERUXhvffeQ1JSUpGne/fuXezYscPsvCdNmoRJkybh66+/xhtvvGHUx9vbm88XKGGffPIJvv7663xft7e3R40aNdC3b18EBgaid+/e6NGjB3777Tejvh06dMDSpUsL9Rk99dRT8PHxwfXr1/Haa68hOjoa58+fN+jTsGFDk+OmpKRARMzOwxKTJ0+Gq6srhgwZgoCAAGzatAmvvPIKbG1tYWtriyVLluDOnTv48ccfUbdu3UJNc//+/diyZQuSk5Px2muvQaPRoEGDBiUaN1Ucjo6OWLhwIYYNGwYPD48SmebPP/+MOnXqYPjw4SYfiloS35kPHjzA8uXLcerUKUyYMAGLFi3CuXPnkJmZqfRJTk7G3bt3ATzcZjk7OyM1NbVI87t79y4cHR2LFTMAVKtWDcOHDzf5mq2tLZydnVGpUiXMnj0bDRs2xK1bt/Dkk08iPj6+2POm/Lm6usLW1hZ9+/ZVhs2cOROurq4IDg426Jubm4uhQ4ciKCgILi4umDlzJqpVq4asrCysXr0aubm5RtPXarUG37MNGjRAgwYN8OGHH+K5557LNy5nZ2fcunXL5GsuLi7QaDQGw65evWp2X/Kbb75Bly5d8Msvv6By5cqYN2+e8tqMGTOwcOFC/PHHH4iPj1e2adHR0YiJiUFGRgaaN2+OXbt2ITo6GhMnTkRaWhpcXV1x//593Lt3z2BeL7/8MlavXl3g88syMzPRo0cPPPfcc2jSpAk+++wzDBw4EAMHDjTqGxUVBTs7O1y5cgV//fVXge+zontkn5CWnJyMoUOH4qWXXkJMTAwAoEuXLsoOkamHfZWWWrVqYezYsYiOjsaPP/6I6dOnF3qHqVKlSggODsbHH3+Mjz/+GBMnTsSFCxdw9OhRAA+T+9VXX8Urr7xS4k9DDwwMxCuvvFLsB49mZWXh999/z/d1EUFGRoby/1NPPQUbGxuICHJycvDgwYNizf9Rpl92NjY2aNSoEaZPn47g4OBC74hMmzYNf/31FxYuXIhXXnkFTk5OGDFiBHx9fY36PvnkkwY7ZTk5OUYFjZOTEz744APlYbJHjhzBN998Y7Lwys+cOXOQnZ1dYJ/+/ftjypQpqFGjhtEGzpT9+/cDAKpWrQpfX1/UqFEDv/32GzZu3IgDBw5g6NChmDJlCvbv348uXboUavn99ddfSE5OLtR7on+XqKgoZbujFx8fj2+++QYXL14ssfn89ddfmDZtGh577DGMGjWqVL4rc3JyUK9ePTg4OGD16tUYNWoUrl+/rsxr48aN+Oqrr7Bx40Zs3LgRL774Ir766qsiPTw2JSUFQ4YMwddff21yJ9gSGzZswDfffGP0OQCAl5cXtm7dij///FPZFtesWRNjxowp1jypYA0bNkRoaCjGjx8Pf39/ZXj//v3x4YcfwsnJyWichIQEbN68GatXr1YO6t28eRM//vijRQ8B1mg0qFWrFnx8fHDkyBGD15ycnLBx40ZMnToV3t7eBq+5u7tj7dq1RTrgEBUVhcDAQLzzzjsYPXo0ACAjIwMnT57E0aNHMXfuXFy8eBFz5szB9OnT4evrCwcHB7Rr1w4uLi4AgI4dO2LgwIGoWrUq3n77bRw6dAhDhgyBvb09unXrpry3li1b5lskabVag3z8/vvvsWvXrgIPOIaHh6N169aF2n5WdI/kGSW9lJQU/PTTTxg9ejSGDBmCjh074uOPP8abb76JqKgohISE4OjRo4iOji7WfNLS0sxu/PRPYA8ICEBAQAB+/fVXXLlyxey0s7KysHPnTgwaNAhOTk7Q6XQYPHgwjh07hqpVq8LJyQnR0dHKjqufnx8OHjxYrPdT1q5evYru3bsjJCQEHTt2RNOmTfHFF18gMjIShw8fRpUqVfD888+Xd5gV0rx583D//n288MILWLVqFVxdXZGWloaVK1fi/v37Zsc/ffq00Zdvbm6uyZ0PvdjYWISHh2PTpk0GR50B4IMPPsDkyZOh0Whw+/Zt3Lx50+QXcUFfzuaKpBo1auC9995D69at8fbbb2PBggW4ePEidu3aZbJ/w4YNsXnzZjzxxBOwt7cHADzzzDP45ptvsHbtWpw4cQKpqalwdnaGvb09goKCAAC7du1C69atC4yFHk2enp5YuXIlZs2aZfTa2bNnkZWVVWIH63Jzc5GRkYF9+/YhMzOzVM66Hz16FOnp6YiNjcVPP/1kcFCuW7dueO6555SDB19++SXGjRtXpCs39uzZg7179+LixYtIS0srVswPHjzAkiVL8OKLLxrt/Go0GnTp0sVoHFvbR3qXqdTY2tqiWbNmqFWrFlxdXVG9enWD9f+ZZ54xOZ5Go8Hnn38OR0dHdO7cGYmJiQAe5tf+/fuxdetWhISE4Pjx44WKo1atWggMDDTa9p0+fRo5OTmoUqUK4uLiDF5LTEzE33//DT8/P0veMoCH+29nz55FYGAg9u/fj4MHD+Kvv/7Cn3/+iT179iA5ORl+fn4ICgpCmzZt8NZbbyEpKQkXL15UCiUAqFy5Mk6cOKGcjZs6dSrat2+PRo0aoXbt2qhatarJq3D0PDw88MQTT+DMmTOFivvKlStYuHAh7ty5U6wrsCoKZj0eXp7w888/w9vbG7Vr18bkyZPh5OSEBQsWID09HTdv3sScOXMQExODU6dOFTitiRMnGg2Lj4/Hzz//XCqxp6Wl4Y033sCiRYvw2GOP4f3338fw4cMRFxeHKlWqoEqVKrh06ZJSKL3yyitYsGCB0XRsbW3Rpk0bnD59GjY2NnjyySdx9OjRYh+1K4rLly9DRJSd4Tp16sDf3x8DBgzA8ePHUa9ePYwbN85oPK1Wi/r16+P27dtlHXKFpb/8xdHREa6urgCAmJiYQh95NnX5TI0aNQzOAAIPz3zWrVsXubm5GDJkCA4cOGA0XrNmzXDlyhVcuHABSUlJeOONN0weYGjYsCEGDhyI+vXrFypGU+O3adMGAODm5oY5c+bg9u3b6N27t8kzVw0bNoSbmxt2796N3NxcvPzyy7C3t8crr7yCXbt2ITc3F0eOHEGPHj1QpUoV5OTk4Pr160hISEDHjh1x586dIsVJ/16VKlVCr169EBoaihdffNGg8F+zZg2OHz+O5s2bY9y4cUXaASssGxsb1K9fP99LikzZvn076tatq1yC7eDggKCgIERERODixYsYNmyYQf8aNWoYnGFdt24dEhISihTvwIEDcefOHbRt2xZjx47FjRs3ijSdoqpXrx46deqE+vXr4/r164iIiICnp2eBB4bof5o3b45Ro0bhqaeewqxZszBkyBDs3LkTvXv3hoigdu3aFk1PRDB16lSMHz8effv2xe3btzFy5EjMmDED1apVwxtvvIG+ffvi77//xvLly3Hu3DlERkYaTefo0aO4efMmgIf7EeozV1u2bMGqVauQnp5udHDvwYMHRoXVlStXcOjQIbPx29jY4Pz589i6dSs6deoEOzs7jBgxAt9++y327NmDxYsXA3iYQ3Xr1sWYMWPQpEkTowPDGo3G4CcfHh4eGDx4MAAgICDAaL6XL182uHQ9JSUFcXFx0Gq1CAgIwL179+Du7m4y5tzcXISFheGff/4p9sGKioKFUh4xMTGIiYlBr169AAB9+vTB2rVr4enpiW3btiE5ORm9evXCr7/+mu806tSpUyKxvPPOOwCAsLCwQvU/d+4czp07h59++glPP/00PDw8MH78eDRp0qRQ42s0GvTo0QMdOnTAY489hldffRW//PILcnJysGDBAty4cQNOTk4Wnco2Zfjw4WaPaK5cuRLvv/++cvTe3t4eNWvWxK1bt5Qd53r16hmNZ2trCw8PD7PFLBVs3bp1SgGk0+kMjlwBD8/YFLTzr88BV1dXuLq6YuLEiWjcuLFyxO/q1asICAhA3bp1ERoaChHBggULMGjQIFStWhXTp0/HL7/8ku9ZWBcXF4wcObLAa60tlZCQYHS5hd6+ffvQo0cPnD9/HosWLVKGOzo6onr16njw4AEGDBiAMWPGYNmyZUhPT0f//v1ha2tb6Gu3ExMTDQ4O0L9fYGAgjhw5gtDQUPTt21cpVnJycvD777/j999/x/nz53Hy5EkAwKlTp/D333+XaAwODg544YUX8j3iXrVqVcybNw+1atXCpUuXEBMTgyZNmihFEgDY2dlh6NChWLhwocmCa8uWLWjVqpXJ30hZytbWVtk2lrbc3FxcvXoV9vb2yu8OBw8erOyAnjx5Erdu3UKNGjXQq1cv3Lx5EzVq1EBSUlKJ/0ayItP/JuiDDz7ACy+8oFxWvX37dgAPLw99/PHH0ahRI+h0Ovz555/IycnB5cuXUa9ePbP7CykpKZg+fbry/5o1a5Cdna2cra1ZsyZq1qyJlStXIjMzE+Hh4ahRowbu37+P+Ph41K9fHwEBAbhz5w569eqV73ewJb/DzsjIUM5uFcTJyQmrV69G1apVC+yXmJiIxMREjBo1Cvb29lixYkW+v68raBo//PADtm7dCgcHB3z33XfKe/Xx8cHTTz+NnTt3Ytu2bdDpdMjOzja5v5eQkIA7d+7Ax8dH+W761yuTW0aUAJTTnVe++uorgzhGjhxZ4JPPIyIijGLP7+4r+vbFF18Y9D937pz07NlTtm3bJvPnzxcPDw+L49ZoNFKvXj2ZPn263L9/X5m2/rkv6ocR6sdp0KCBREdHG8STk5OjNJGHd6C7ffu2JCcnS2ZmpjRr1kyqVasm3t7esnDhQlm8eLGMGTPGZFybN282Wj5JSUkGt9GsW7eu0cOB33nnHeXOLW5ubsqT0dWWLFlSbuuKNTAVl06nkzNnzpjsP3z4cAEMH9r30UcfSbVq1aR169by7bffKncb0ouJiVFu692tWzejaeofQnns2DGDW5Fv2bJFOnbsKL6+vnL16lVJTU2V/v37S6dOnSQhIUFERJKTk6V69epml3Xr1q3ln3/+kZSUFIN5X7lyxewtj9u0aWMU84ULF/J9JoX+oZQLFy40WO+ys7Nl0KBBSj/9cyUyMzPl9ddft+gZF7Vq1TK461FsbGy53sHxUcyTorZGjRrJ3LlzZfr06eLm5qY8MLhatWr5biv0d73LycmRjz76SC5evChPPvmkUb+AgAC5ffu23L9/X3Jzc2XTpk0ybdq0Au9UCUAqV65sEEe1atXEw8NDpkyZotzCW+ThHevMPdC4R48eyrqZlJRk8rk106ZNy3f8zZs3Kw+lFSn8Xe+cnZ1lwoQJEhsbK7dv35YHDx4YzFN917v8lkl+d71bsWKFaLVaGTt2rMnXd+7cKZUrV5YePXrIhQsX5J133pEJEybI7du3Dfr98ccf4uPjI+PGjZNffvmlxB5Aaw2K+x5cXV1l6dKlym3VTVFvX06cOCFt27aVKlWqyJUrV4z6573rXX4tv0dHiIjcv39f0tLS5NChQ1KtWjV59913JS0tTfbu3Ssff/yxUf+kpCSzz/3atGmT0v/BgwfyzDPPFGr5uLi4GN2OW0Rkw4YNJvvb2NiIq6uryf1MtYyMDLl9+7byqJi8t0vfunWrUf9BgwaZvD14RESELFmyRPke+vzzz+XGjRuyefNmadOmTYl+l1prnlhHNhZCeX0IL730kixevFj5ckxPT5fQ0FDp1q2byf6mVuCLFy8WWCgdP37coP/evXtFq9VKnTp15PPPP5cBAwYUOX6tVmt0u8v09HSJi4uT2rVrmxwnv9tt5ubmSnZ2tvzwww/i4uIijRo1kvT0dElJSZHk5GSDB8n++OOP+X6hqL8Y9+zZY7BDYapQGjt2rMF01qxZYzJGFkrGcQ0YMED5sszr1q1bygbg1VdfVYbfv39fkpOTjW5Xqpf39tvPPPOMJCQkyKJFi2Tx4sVGhUteb731lgAPb886a9YsOXTokPKMCr3k5GSTt+nXPzDy+eefl3Hjxsn69evl+++/l8aNG8vvv/+ujH/48GGzn1NAQIBRbOfOncu3sBkyZIh8++238tFHH8mKFSuUcc6ePWtwC+/27dsr6/b9+/elcePGymu2trbSvn37fB9AW7NmTYPlnZubKxMmTCi3dflRzJOiNltbWxkwYICsWbNGkpOTDdrGjRtN7sDrC6WUlBSZPHmy9O/f32gb4e3tLT/++KNMmzZNZs2aJQsXLpSEhATJycmR0aNHFxjTunXr5M6dO0bxJCcnG33/rly5Ull/9THoH7hpY2Mj06ZNMxpH7aOPPso3lvDwcElISJAvvvhCkpOTxc/Pz6Ll6+zsLC4uLvLLL78YzHPhwoUyYsQIsbW1lWbNmsnevXtNPpw5v0LpyJEjUr16dWnVqpXJ12/evCnVqlUTW1tb5aCFTqeTq1evKg8DPXXqlIiIpKamyoMHDyQhIYGFUp7WoEEDowK3INeuXZMWLVooeaV/XEJe5golX19fo4O9ec2dO1fat2+v7FM4OzvLL7/8Im+88Ybs27fPqL+5x024ubnJ/v37ZdmyZbJw4UKZO3duoZ9PptFopFu3brJw4UK5du2aso+VX36PGjVKQkNDTT5iJa979+7JoEGDxMXFRY4ePSrZ2dnywQcfKNNp1aqV0cOg169fL++9956yDc/JyZHs7GxZsGCB2NraiouLi3zxxRfy2WefKd8Hf/zxh9lboJd2KwvWkY2FUNyF6e/vrzwoS/8APkua/myJ/rk9f/zxh8kzPZ9++qn89NNPBiuhuSN2pgqlklyR3nnnHYMvq1OnTsmWLVvyfW5UfoXS7NmzpVGjRsr7zvsAPrX8CqX58+fLBx98IJmZmZKQkCA7d+40eHo8YLpQ2rNnj8EOR6NGjWTr1q3KhkqPhZJxXIMHDzbZ98qVK9KnTx/p16+f8sRvcw4ePCgrV64UW1tbAR4+W0v/kDkbGxv56quvDJ5RkZe+UAIePq/B19fX4GyniGGh1LZtW2nUqJG88MILcuLECYmOjpb9+/fLzp075YMPPlDWw379+ikbjsIUSjt37jSKraAHQlepUkU5g1avXj3ZvHmzpKWlyeXLlw0esFe3bl3ZvHmz5ObmSk5OjsEDCp955hm5ceOGHD16VJo1a2Y0D3WhJPLwCGB5rcuPYp4Ut/n6+hp9H+b3/BX1c5RSUlKMHmhZuXJlWb16tezfv19q1aolAJTvu+XLlxe489asWTPZvXu32R0qkf8VSrt27ZLIyEh56aWXJCAgQI4ePSpnz5412j6ZUlChNHPmTFm/fr24u7uLt7e32YdM59emTZsmO3fulHPnzinzffDggYwdO1a2bdsmIiLLli0Te3t76dmzp7K9z+/7SP8gzfwKpZSUFJNnt/O+h2HDhsnOnTvl8OHDIiIslFTN0kLpp59+UsYtaqHUqVMng7Omaps2bTI4MKvVapVnQhalUHrmmWfk448/ls2bN4uTk5M4OjoaPMC2sK1169byxhtvyMaNG/N9RqW/v7/ExMSYXY5518MxY8ZIo0aNDPb3fH19jQoltVGjRkmjRo0Mvr98fX0Nzjjlfd6Ym5tbqT9brLzyxDqysRCKuzDbt28vsbGxsnz5ctm1a5dERETImDFjpFWrVhY92FF/ijUuLk569eolLi4uRn10Op2sXr1aib13794FTrO0C6Xq1asbHOl/9dVXC+yfX6GkPsJdUKG0atUqg75Vq1YVPz8/WbdunXz66aeSmZkpffv2NTn/WrVqGX0ZzJ492+SRCzc3N4OdfBZKxnHlVyjldfv2bdm6dasEBQWZvDwyNjZWXnjhBbNPGgcefuGbkrdQAiB16tQxKpSys7Plt99+k4iICLlz547s3LlTZs6cKb1795agoCCTX8R+fn5y+PBhuXLliqSkpEhERIRMmDBBKebU7bfffjOKTV2sm2v+/v6yefNmef7555VhLi4uUrduXVmwYIFkZWWJr6+vODo6ip+fn/j7+8vXX38tKSkpsmnTJqN1mYVS2SqN9xUcHGy081HYQknE9A6gk5OTUiT5+fnJzZs3JSMjQ06ePCkHDhyQZcuWGRVYzZo1k3fffVcOHjxYqJ1UfaH0ww8/iMjD4sPb21v69Okjo0ePltmzZ5udRkGFUkk3T09PCQoKUi4BnDx5snTv3l0iIiLE29tbmjVrZvJseGJiogwaNEj69+8vJ06ckPfee0+Ahzt/iYmJRv3zK5RMtYCAADl58qRMmDChxI6wW4Pivof8CqXc3FzZsGGDBAUFSXh4uOTk5MiZM2cMrtTJr1DSr68FNfUB1LyuXbum5JS6FbZQcnFxkb1790pERISyb7V48eJ8tzkl2UJCQsx+buYK9sIUSr169TIaT6fTyaBBg2Tr1q1y8eJFuX79urRu3Vr8/f3ll19+kTFjxuRb5JVWKwuPzM0cfv31V/Ts2ROXLl2Cq6srnn76aTg5OWHLli2IiIiAvb09vv32W5w9exY3b940e7e32rVrY/fu3QgPD8eNGzfw66+/YtWqVcjJyUFWVhbOnz+P3NxcaLVaTJgwATqdTvnhelnSP7gt7w/fvb29MWjQIBw8eBAJCQml8myNlJQUtGrVCuPHjwfw8EfDgYGBSE5Oxv79+zFy5EiEh4ebHDchIQHr16/HRx99pAwbNWoUPvvsM6Pnzty8edPgzitdu3aFu7u70S08KX/Z2dkYPnw4du/eDQDKzUz0kpOTsWzZMuzcubNQ08vKysL9+/cteihkVlaWciesevXqYf78+Vi1ahUOHz5s9jb5p06dQtu2beHr64t9+/YhKCgIsbGxsLGxQXZ2NmxtbaHT6aDRaIzuxldUJ0+eNHoIX0pKClJSUvDRRx+hT58+eO2116DT6Yzu0NimTRtotdpH4raqj5Jq1aohPj4ebm5uZp8RZOrGBrVq1YKDg4PBOnr37l3lQa2nTp3CzJkzlTuy9unTB82bN8fWrVtx+PBhHD16FPv27UPNmjUNHlxZVPrb5X/66adGr929exfJycmoVasWduzYgV9++aXY8yus2NhYxMbG4vLly6hatSqys7Oxfv161KpVC6tXr0adOnUM7lp2584dpKenY9u2bdi0aRMAYNu2bcrrFy9exPfff4+hQ4cazEej0cDZ2blQd1E9evSowXN/qGDZ2dmYMmUKrl27ho8++gh169bFzp07C/X9nN+DxvXatWtndLt3vdzcXCxdutTkXRebN2+OZs2aITk5GVqtVslRV1dXrF27Fj///DPWrFmjDOvQoQOcnJyQmJiIu3fvwsHBAba2tmYfT1Fcd+7cUR5HUZKWL1+Ow4cPw8/PD/379zf5WWRlZSEqKgoXL16Et7c3fHx8cOzYMeX1mjVrYt++fRbd+KJCKJNyrASglKpRe3t7adGihUydOlWOHTsmN2/elM8//1yGDx8ujo6ORkeH8v5oL6+MjAxp2LCh0s/BwUEmTJggq1atkpycHLl165ZUrVpVed3Ozk4cHBzE1tZWTp48aTCtvXv3ik6nE0dHx2Ifoahevbp0797d4IzS999/r/yY0dSRFVNnlHJzc41+J1SrVi1JTEyUU6dOydSpU+XcuXPy4MEDuX//vmRnZ8v9+/dl+/btMmXKFHFzcxMHB4dCX3bx0UcfSVZWljL/27dvGyy/vO3EiRNKP/UlT2XZrIGpuMydUcrIyBBPT0+l/+zZs+XevXuyePFiWbp0qezatUu6du1a6OWg0Whky5YtRvNRn1Hy8PCQhIQEmTt3rowYMUIcHByUZup3POZa3759lTNUP//8s/Tt21d0Op34+vrKjh075Pvvv5eFCxfK9evXDeLKycmRHj16lOh3yrRp0+TGjRsmj9pduXLF6Ahl3jNKubm5cu/ePfnvf/9bLuvxo5onxW22trZSqVIlGT9+vHKJdlpamtEl2ra2thIVFWUU071792TOnDkFrvtardbgt3RarVYcHBykb9++MnXqVLl27Zrs3bvXomUREhIiOp1Oxo8fLyL/O6Okn8enn35qFGffvn2lRYsWcu3aNUlJSSmXdVWn04mDg4O4uLjIzZs3lfiysrLk3r17cu/ePcnJyZHdu3dLly5dCrx8at26dSaXzcKFC5knxWj5nVHKysoSLy8vs/lk6ozSL7/8UuB4I0aMyPf9pKWlyaxZs0xeGdGoUSOZOnWqtG7d2mifSeRhnjRp0kSmT58uR48eVYZ37txZunfvbtGVScVpdnZ20qlTJ5k6daqsXLnS5DamKGeU9DcmsrGxEQcHhwJvRuTk5GR01i4qKsrgd7n/pjyxjmwshLJY4Po7ty1dulT27NkjN27ckKVLl8rgwYOVlS6/Qik7O9vkD/h0Op389NNPkp6eLp07d1aG63fYQkJCDAoCkYc/Ej9w4ID8888/smHDBqlcuXKx3lf16tUNrtkdOnSoDBw40GDnWN/q1q0rFy5cMHp/MTExRpcZarVaqV27tlLAvP322zJw4EDx8PCQDRs2yIYNG4p0rS7w8Hchzz//vKxbt0656xELJfNMxWVpoeTs7Czu7u5ia2srdevWld69e1t8BzZTefL1118b7Kzo1x9L7g5XUHNwcJCAgAAJDQ2VnJwcSU9Pl4iICAkODi7w/R86dKjIv5sw1ZydnSUmJkY++ugjk/MzVyidOnVK3N3dS+y3DtbWrEFpv8fFixeLyMOid/fu3TJ06FClYLKxsTF5IGHBggUmL9OzpNWqVUtmzpwp27dvN9oRun//vsGNT/TUeWKuUNLfpbRVq1by6aeflvu6am9vLz/88IPs3r1b1q1bJ3379hV3d3dxd3eXJUuWyJ49e/LdduibulDav3+/rFu3ToYMGcI8KUYrTqGUX54UVCjZ2trKzJkzJSkpKd/3lJGRIXXr1i1w3p06dZLVq1fLunXrlJ8BpKenG003Jiam0DduKI1mZ2cne/bsMXqPxSmUCpNvW7dulVWrVsm6detk48aNkpGRIXv27PnX5ol1ZGMhlPXCr1KlikyaNEl27twpYWFhcvLkSTl9+rTRrUH18iuUgIc3MBB5uPKePn1aPv74Y6OES0xMlIEDB8qePXtk2bJlsmLFCgkPD5d9+/blez1tYZuNjY20aNFCtm7dKsnJyXLs2LF8j34EBAQohUdubq4sWbJEdu/eLX/99ZdFZ7eqVKlSYrc3btCggTz55JP5XvvNQul/TMU1ePBguXPnjoSHhytHukVEzpw5I+Hh4TJp0qQCj7YWpZkqlJKSkkz+pq+km/o3gnklJCRISkqKfP311+Ln5yejRo2SefPmlej8tVqtPPnkk/L666+bvONWXFycdO3aVYKDg+X06dNy+vRp2bp1q/z8888SHh4u3bt3L5f191HPk5JslStXlhYtWkiLFi1kzJgxEh4eLhs3bpTTp0/LwoULDb6z9Apz22NLcqBFixby1ltvSXh4uNy+fVvWrFkjdevWlRYtWsj27dvzXTbZ2dkGZ5A//fRTOX78uNy4cUNEjB/nUN7N0dFRIiMjZdeuXUa/KapUqVK+Ny3K2yZNmiTh4eEyd+5cadGiRZl8Tz0KeVKcQgkw/C1fTk6OHDp0SIKCggocx83NTUaPHi2bNm2SQ4cOGcz/1q1bEhAQYNH2Tl2spaeny5gxY6RFixYGBxTKq+lvZJJXYQqlzMxMOXjwoCxatEhatGhRqDwBHl4xkvcsuX57Z+qOk/+WPLGObCyE8vgA+vTpI9OmTRM7Ozvp0qWLvPXWWxIVFaUUOUuWLJGoqCi5c+dOgYVS5cqV5eWXXzb5A9OIiAjlVpY//vhjkc/AFLa1bdtWnnnmmQKP4ru4uEivXr2UO6LNmDFDzpw5UyY/VCxKGzNmjLI8WSgZx1W3bl3lmSMLFiyQQ4cOSb9+/Ur1DjV5C6X09HSJioqSGTNmlNk65OvrK59++qlERUXJe++9J+vWrZO4uDh57rnnpF27dtK1a9cSO5NVUHN2dpZly5ZJv3795PPPP5f79+9LVFSUREVFybp166RXr17Sq1cvg7vn/dubNSiP960/S/7CCy/I4cOHJSoqSi5fvix9+/aVXr16lWrxERAQIN26dVMONpm6Rf7y5cvl0qVLkpOTI//8849069ZNqlSpopxRSk9Pl7S0NKsslM6dOydhYWHFPqhoTc0aFPc95Fco5eTk5PusxbytX79+cv/+fTl27Jj07t3b7Jl/nU4nP//8s9y7d086d+4s9vb28u2338ro0aPl+++/l7/++kuaNWtm0XbIz89PevXqJUuWLJGYmBjZs2dPkS4NL61WlELJyclJunfvbrX7dJa0smAd2VgI5fUhqBNCq9VKQECAvP3221KzZk3RarXSqVMneeuttwo8CuXs7CxXrlyRtLQ0Wbx4sQQHB8vNmzdl5cqV8vPPP0tKSoq8++675b7SmXr/Wq1W2rdvb1VfDnmbh4eHTJs2TbkmXf8A3LI+KmgNzMU4depUeffdd81eilLctmrVKrl586YEBwdL3759RavVlvn6o1939X+3aNGiXHbw9O+7UaNG0r9/f+V3JtaaT6XdrEF5LwP9OtCuXbsyKdjVrXbt2vLRRx9JYmKi8kyUHj16SOXKlWXMmDESGxsrOTk58sMPPyhnv2JjYyUmJsbqCiUA0rRp02JftmhtzRoU9z0UdEapMGdjGjZsKAMGDCh0jjg4OMj58+fl7bffFuDhfld0dLQ0atRItFqtrFu3Tnbv3l2knzM0adJE2ecr73Ujb1u/fr3R8i3J29RbeysL1pGNhVDeH0ZJNGdnZ2ndurU0atRINBqNuLi4SKVKlcTJyUm8vb2lY8eO5R5jRW1arVaWLl0qubm5sm3bNklOTpaoqKhSP0OXt1kDczHa29uXyQ56pUqVxMXF5ZEtBtjyb9agvJeBNTSNRiM1a9aUWbNmSUJCgsElnwX9rtEaC6V/Y7MGxX0Pxb30rijN2dnZ4DJ9Z2dnpbgZNGiQxY+CsPbWpEkTo2WclpYmEyZMKPTldBW5lYVH5vbg1iA1NRXHjx9X/k9JSVH+vnv3LmJiYsohqn+H3NxcnD17FtnZ2Wjfvj0iIiKQnJzMWzCrZGZmlsl87t27VybzIaKiERHcunULH374IVasWIHExETltfv375djZERFl5qamu//+tvD/5vcu3fP4LEzaWlp2LNnD+rVq4fPPvsMs2bN4r5lMbFQogrP19cXlStXhpeXF0QEI0aMwA8//FDeYRERVQjXr18v7xDoEWJra4vRo0cjODi4vEP5V9AfKJ49ezYuX76MkydPom7dukhMTCyxZwc+ylgoUYXWokUL/PDDD6hduzZSUlJw8+ZNREdHl3dYREQV1okTJ/Dhhx9i3LhxcHNzK+9w6F9Go9HA1dW1vMP4V0hMTMTQoUOxa9cugytG/v7773KM6t9FW94BEBWVg4MD7O3tlf9nzZqFxo0b48qVK+UYFRFRxXb9+nXMmTMHTz75JKZPn47ExER8+eWX+PPPP5GdnV3e4VEFlZWVhR07duCjjz7i2aQScvfuXWzZsqXMLqt/FPGMElU41atXxyuvvIL//ve/cHZ2xq+//orbt2/j7NmzPM1MRFQCRAQJCQmYPn06li9fjqSkJDg7O2Py5MnlHRpVMCKC3bt3Y/78+Th58iR/w0oVikby/grMimk0mvIOgayAq6sr+vXrh6+++goAsHfvXrz00ktW8cVrDanEPCFrxzyp2Nzd3XHz5k3k5uaWdyj/av+GPHF3d8fKlSsxZ84cnDp1igcyqcSVRZ7wjBJVGFqtFqtWrcILL7yAnJwcXLlyBefOnbOKIomI6FEQFxdX3iFQBREXF4devXqVdxhExcIzSlRh2NjY4MKFC3B0dMSpU6fw6quvGt0aszxZQxzME7J2zBMi85gnROaVRZ5UmEKJiIiIiIiorPCud0RERERERCoslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUWCgRERERERGpsFAiIiIiIiJSYaFERERERESkwkKJiIiIiIhIhYUSERERERGRCgslIiIiIiIiFRZKREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUmGhREREREREpMJCiYiIiIiISIWFEhERERERkQoLJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZGKxYXSwYMH0atXL3h4eECj0WDnzp1mxzlw4AD8/Pzg4OCABg0aYMWKFUWJlajCYJ4Qmcc8ITKPeUJUfiwulNLT09G8eXN8+eWXhep/9epVPPvss+jQoQMiIyPx4YcfYuzYsQgNDbU4WKKKgnlCZB7zhMg85glR+dGIiBR5ZI0GO3bswAsvvJBvnw8++AC7d+/GhQsXlGGjR4/G2bNnceTIkaLOmqjCYJ4Qmcc8ITKPeUJUtmxLewZHjhxBt27dDIZ1794dISEhePDgAezs7IzGyczMRGZmpvJ/bm4ubt++DVdXV2g0mtIOmcgiIoK0tDR4eHhAqy3az/6YJ/RvxzwhKpzi5grzhB4FJbFNKYxSL5Ti4+Ph5uZmMMzNzQ3Z2dlITEyEu7u70TizZ8/G9OnTSzs0ohIVGxuLunXrFmlc5gk9KpgnRIVT1FxhntCjpDjblMIo9UIJgNHRCP3VfvkdpQgODsbEiROV/1NSUlCvXj3ExsbC2dm59AIlKoLU1FR4enqiSpUqxZoO84T+zZgnRIVTErnCPKF/u5LapphT6oVS7dq1ER8fbzAsISEBtra2cHV1NTmOvb097O3tjYY7OzszYclqFefyBOYJPSqYJ0SFU9RcYZ7Qo6S0Lw0t9ecoBQYGIiwszGDYvn374O/vb/I6WaJHEfOEyDzmCZF5zBOikmNxoXT37l2cOXMGZ86cAfDwNpRnzpzB9evXATw8fTt06FCl/+jRo3Ht2jVMnDgRFy5cwOrVqxESEoL33nuvZN4BkRVinhCZxzwhMo95QlSOxELh4eECwKgNGzZMRESGDRsmQUFBBuNERERIy5YtRafTibe3tyxfvtyieaakpAgASUlJsTRcolJnav1knhAZYp4QFY56HWWeEBkrq3W0WM9RKiupqalwcXFBSkoKr5Ulq2Mt66e1xEFkirWsn9YSB1F+rGEdtYYYiApSVutoqf9GiYiIiIiIqKJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUWCgRERERERGpsFAiIiIiIiJSYaFERERERESkwkKJiIiIiIhIhYUSERERERGRCgslIiIiIiIiFRZKREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUmGhREREREREpMJCiYiIiIiISIWFEhERERERkQoLJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUilQoLVu2DPXr14eDgwP8/Pxw6NChfPtGRERAo9EYtYsXLxY5aKKKgHlCZB7zhMg85glR+bC4UPruu+8wfvx4TJ48GZGRkejQoQN69uyJ69evFzheVFQU4uLilPbYY48VOWgia8c8ITKPeUJkHvOEqPxYXCjNnz8fI0eOxOuvv47HH38cCxcuhKenJ5YvX17geLVq1ULt2rWVZmNjU+Sgiawd84TIPOYJkXnME6LyY1GhlJWVhVOnTqFbt24Gw7t164bDhw8XOG7Lli3h7u6OLl26IDw8vMC+mZmZSE1NNWhEFQXzhMg85gmRecwTovJlUaGUmJiInJwcuLm5GQx3c3NDfHy8yXHc3d2xcuVKhIaGYvv27fDx8UGXLl1w8ODBfOcze/ZsuLi4KM3T09OSMInKFfOEyDzmCZF5zBOi8mVblJE0Go3B/yJiNEzPx8cHPj4+yv+BgYGIjY3FvHnz0LFjR5PjBAcHY+LEicr/qampTFqqcJgnROYxT4jMY54QlQ+LzijVqFEDNjY2RkcxEhISjI52FCQgIACXLl3K93V7e3s4OzsbNKKKgnlCZB7zhMg85glR+bKoUNLpdPDz80NYWJjB8LCwMLRt27bQ04mMjIS7u7slsyaqMJgnROYxT4jMY54QlS+LL72bOHEihgwZAn9/fwQGBmLlypW4fv06Ro8eDeDh6dsbN25g/fr1AICFCxfC29sbTZs2RVZWFr755huEhoYiNDS0ZN8JkRVhnhCZxzwhMo95QlR+LC6UXn75ZSQlJWHGjBmIi4tDs2bNsHfvXnh5eQEA4uLiDO7tn5WVhffeew83btyAo6MjmjZtiu+//x7PPvtsyb0LIivDPCEyj3lCZB7zhKj8aEREyjsIc1JTU+Hi4oKUlBReN0tWx1rWT2uJg8gUa1k/rSUOovxYwzpqDTEQFaSs1lGLHzhLRERERET0b8dCiYiIiIiISIWFEhERERERkQoLJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUWCgRERERERGpsFAiIiIiIiJSYaFERERERESkwkKJiIiIiIhIhYUSERERERGRCgslIiIiIiIiFRZKREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUmGhREREREREpMJCiYiIiIiISIWFEhERERERkQoLJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREakUqVBatmwZ6tevDwcHB/j5+eHQoUMF9j9w4AD8/Pzg4OCABg0aYMWKFUUKlqgiYZ4Qmcc8ITKPeUJUPiwulL777juMHz8ekydPRmRkJDp06ICePXvi+vXrJvtfvXoVzz77LDp06IDIyEh8+OGHGDt2LEJDQ4sdPJG1Yp4Qmcc8ITKPeUJUfjQiIpaM0KZNG7Rq1QrLly9Xhj3++ON44YUXMHv2bKP+H3zwAXbv3o0LFy4ow0aPHo2zZ8/iyJEjJueRmZmJzMxM5f+UlBTUq1cPsbGxcHZ2tiRcolKXmpoKT09PJCcnw8XFBQDzhEiNeUJUOOpcYZ4QGTO1TSkVYoHMzEyxsbGR7du3GwwfO3asdOzY0eQ4HTp0kLFjxxoM2759u9ja2kpWVpbJcaZNmyYA2NgqVLt8+TLzhI3NTGOesLEVrl2+fJl5wsZmpum3KaXFFhZITExETk4O3NzcDIa7ubkhPj7e5Djx8fEm+2dnZyMxMRHu7u5G4wQHB2PixInK/8nJyfDy8sL169dLt2osJn11a+1HYBhnydIfeatevToA5ok5FeVzZZwli3limYryuVaUOIGKE2veXGGeFKyifKZAxYm1osSp3qaUFosKJT2NRmPwv4gYDTPX39RwPXt7e9jb2xsNd3FxseoPTc/Z2ZlxlqCKEqdWa/iTP+ZJwSrK58o4SxbzxDIV5XOtKHECFSfWvLnCPClYRflMgYoTa0WJU71NKfHpW9K5Ro0asLGxMTqKkZCQYHT0Qq927dom+9va2sLV1dXCcImsH/OEyDzmCZF5zBOi8mVRoaTT6eDn54ewsDCD4WFhYWjbtq3JcQIDA43679u3D/7+/rCzs7MwXCLrxzwhMo95QmQe84SonFn6o6bNmzeLnZ2dhISEyPnz52X8+PFSuXJliYmJERGRSZMmyZAhQ5T+V65ckUqVKsmECRPk/PnzEhISInZ2drJt27ZCzzMjI0OmTZsmGRkZloZbphhnyarIcTJP8sc4S1ZFjpN5kj/GWfIqSqzqOJkn+asocYpUnFgZpyGLCyURkaVLl4qXl5fodDpp1aqVHDhwQHlt2LBhEhQUZNA/IiJCWrZsKTqdTry9vWX58uXFCpqoImCeEJnHPCEyj3lCVD4sfo4SERERERHRv13p3iqCiIiIiIioAmKhREREREREpMJCiYiIiIiISIWFEhERERERkUq5FErLli1D/fr14eDgAD8/Pxw6dKjA/gcOHICfnx8cHBzQoEEDrFixwqhPaGgomjRpAnt7ezRp0gQ7duwo0zi3b9+OZ555BjVr1oSzszMCAwPx008/GfRZu3YtNBqNUcvIyCizOCMiIkzGcPHiRYN+pbE8LY11+PDhJmNt2rSp0qekl+nBgwfRq1cveHh4QKPRYOfOnWbHKa31s6LkiaWxMldKNs7yyBOAuVIUzBPmCfPEPOYJ86Q888SIpbfJO3DggDz//PPi7u4uAGTHjh1mx4mIiJBWrVqJvb291KpVS7RarXz99ddy/vx5GTdunFSuXFmuXbtmclz98wDGjRsn58+fl6+//troeQCHDx8WGxsbmTVrlly4cEFmzZoltra2cvToUUvfnkL/3ILCxjlu3Dj57LPP5Pjx4xIdHS3BwcFiZ2cnp0+fVvqsWbNGnJ2dJS4uzqAVh6VxhoeHCwCJiooyiCE7O1vpUxrLsyixJicnG8QYGxsr1atXl2nTpil9SnqZ7t27VyZPniyhoaGFWr/zWz9nzJhhkCdardbs8qyIeSLCXCnv757yyBORkskVGxsb8fPzU/Jk9uzZZpdn3jypX7++jBw50qLlxW1KycbJPCkY88QyzBPmSXH2vUpj/bS4UCrum/H29hatVmvwZnx9fWXSpEkmx3///ffF19fXYNioUaMkICBA+X/AgAHSo0cPgz7du3eXgQMHWvju/qd169YyevRog2EFxWlKkyZNZPr06cr/a9asERcXlyLHZIqlceqT9c6dO/lOszSWZ1FiVduxY4doNBrlIXsipbNM9Qqzfue3fvr4+BjkScuWLQ36qJdnRc0TEeaKtX33lHWeiBQ9V3r27Cl16tRR8qRdu3YFLk9TG0eNRiPdunUzGMcac4V5Yl3Lk3nCPCkO5olLkWMypzj7XqWxflp86V3Pnj3xySef4MUXXyxU/xUrVqBevXpYuHAhGjZsiNjYWHTt2hXz5s1T+nTr1g2HDx82Of6RI0fQrVs3g2Hdu3fHyZMn8eDBgwL75DdNc7KysnDq1CmjaRYUp1pubi7S0tJQvXp1g+F3796Fl5cX6tati+effx6RkZFFirG4cbZs2RLu7u7o0qULwsPDDV4r6eVZ3Fj1QkJC0LVrV3h5eRkML8llaqn8ltXly5cxbdo0JU9atGhh1Cfv+66IeQIwV6zxu8ca8wQwvaz+85//4ObNm+jVqxcA4OLFiwUuz7x58vjjj2Po0KEAgJiYGINxrC1XmCfWtzyZJ8yTomKeWGeelNb6aVu8UM3LG2hiYiJycnLQqVMnTJ06FQ8ePICdnR3c3NwQHx+vjJOZmYnMzEwAwI0bN9CxY0dcuXIFrq6u0Gg0cHJyQnZ2Nq5evYratWsjLi4OVapUQWpqqjKNKlWqIC4uzmBYYcXFxSEnJwdOTk4G47u4uODGjRuFmuaiRYtw9+5d9OzZU+nv6emJ5cuXo0mTJkhLS8Py5cvRtm1bHD58GA0bNiyTOKtUqYJFixahRYsWyMrKwubNm/H0009j7969aNeunTLdklyeRY01r/j4eOzduxchISEGfUt6mardu3evwNhu3LiBoKAg/P333/Dw8IBWq4Wbmxuys7ORmJgId3d3AEDVqlUNxlOv8xUxTwDmirV995RXngCFy5XAwEDk5uZCq314jC5vrgBAcnIy3NzcDMbLu96rN3yJiYkQEVy+fFnJE/U4efMEAGJjY/HUU08hJSUFGo0GALhNKUaczBPLFHebAjBPCsI8KV6ceVXkPHF3d0d8fHyBeVJoFp1/UkEhTo899thj8umnn4qIyI0bNwSAfPXVVwJA/vnnHxER+eSTT8THx0cZZ9q0aQKAja1CtdjYWBER+fXXXwWAcs0uAJkwYYJBXnzzzTdib2/PPGF75Jo+T9S5AkBsbGxk48aN+eZK3jzJmyvA//JEnSvME7aK2kxtUwDmCRtb3pbfvpednV2BeVJYpX5GCYByNKJGjRqwsbFRjorohyckJBhUfcHBwZg4cSIAoEePHvDx8cHatWsRGxsLZ2fnsgiZqNBSU1Ph6emJKlWqAHi4Ptva2sLV1VXpk5ycbDCOep0HmCf076bOE8A4V6pWrWp0tE+93uvzAXiYK1qtFrm5uQbD846TN08AoEuXLjh58iTzhKyWuW0K84TIfJ7Url3bbJ4URqkXSnkD1el08PPzw8GDBw3eTFhYGPr06aOMY29vD3t7ewBAhw4dlNsEOjs7M2HJauk3QPv27YO/v79yeQMAnD171qDvvn370LZtW+V/5gk9KvLuqKlzxdfXF2FhYZgwYYJBH32uqDd8Op0ODRo0UC451cubK3nzBADatWuHkydPMk/I6uW3TWGeEP1PfnkSGBhYYJ4UmkXnn1SAwt2Z4vHHH1f+37x5s2i1WmnQoIGcP39exo8fL5UrV1buqDFp0iQZMmSI0v/KlSvi6OgoACQlJaU44RKVipSUFAEgx48fl5CQEKNbVAIPbw8+Z84cuXDhgsyZM8foFpXME/q30+fJm2++KefPnzfKFeB/tz3OL1fUeSIi0rVrV9FoNBISElKoXDl79izzhKxaQdsU5gnRQ+b2vX777bcC86SwLC6U0tLSJDIyUiIjIwWAzJ8/XyIjI5V7spvagatUqZJMmDBB2Tja2NhIjRo1RKfTSatWreTAgQNK/2HDhklQUJDBPL///nsmLFktfbLa2dmJt7e3LF++3ChPhg0bJl5eXmJrayu+vr7St29f5gk9UvR58uSTT4pOpxNvb29ZsGCB0fbk888/lwYNGoidnZ1Ur17dYD03lSd2dnby+uuvi5eXV6FyRR8H84SslXqbwjwhMmZq30tt69at4uPjI3Z2duLr6yuhoaEWz8fiQkl/L3h1GzZsmIiY3oGLiIiQli1bKhtHU2+mIExYsmam1k/mCZEh5glR4ajXUeYJkbGyWkc1IiKWXaxX9lJTU+Hi4oKUlBReK0tWx1rWT2uJg8gUa1k/rSUOovxYwzpqDTEQFaSs1lGLHzhLRERERET0b8dCiYiIiIiISIWFEhERERERkQoLJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUWCgRERERERGpsFAiIiIiIiJSYaFERERERESkwkKJiIiIiIhIhYUSERERERGRCgslIiIiIiIiFRZKREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUmGhREREREREpMJCiYiIiIiISIWFEhERERERkQoLJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREakUqVBatmwZ6tevDwcHB/j5+eHQoUP59o2IiIBGozFqFy9eLHLQRBUB84TIPOYJkXnME6LyYXGh9N1332H8+PGYPHkyIiMj0aFDB/Ts2RPXr18vcLyoqCjExcUp7bHHHity0ETWjnlCZB7zhMg85glR+bG4UJo/fz5GjhyJ119/HY8//jgWLlwIT09PLF++vMDxatWqhdq1ayvNxsamyEETWTvmCZF5zBMi85gnROXHokIpKysLp06dQrdu3QyGd+vWDYcPHy5w3JYtW8Ld3R1dunRBeHh4gX0zMzORmppq0IgqCuYJkXnMEyLzmCdE5cuiQikxMRE5OTlwc3MzGO7m5ob4+HiT47i7u2PlypUIDQ3F9u3b4ePjgy5duuDgwYP5zmf27NlwcXFRmqenpyVhEpUr5gmRecwTIvOYJ0Tly7YoI2k0GoP/RcRomJ6Pjw98fHyU/wMDAxEbG4t58+ahY8eOJscJDg7GxIkTlf9TU1OZtFThME+IzGOeEJnHPCEqHxadUapRowZsbGyMjmIkJCQYHe0oSEBAAC5dupTv6/b29nB2djZoRBUF84TIPOYJkXnME6LyZVGhpNPp4Ofnh7CwMIPhYWFhaNu2baGnExkZCXd3d0tmTVRhME+IzGOeEJnHPCEqXxZfejdx4kQMGTIE/v7+CAwMxMqVK3H9+nWMHj0awMPTtzdu3MD69esBAAsXLoS3tzeaNm2KrKwsfPPNNwgNDUVoaGjJvhMiK8I8ITKPeUJkHvOEqPxYXCi9/PLLSEpKwowZMxAXF4dmzZph79698PLyAgDExcUZ3Ns/KysL7733Hm7cuAFHR0c0bdoU33//PZ599tmSexdEVoZ5QmQe84TIPOYJUfnRiIiUdxDmpKamwsXFBSkpKbxulqyOtayf1hIHkSnWsn5aSxxE+bGGddQaYiAqSFmtoxY/cJaIiIiIiOjfjoUSERERERGRCgslIiIiIiIiFRZKREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUmGhREREREREpMJCiYiIiIiISIWFEhERERERkQoLJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUWCgRERERERGpsFAiIiIiIiJSYaFERERERESkwkKJiIiIiIhIhYUSERERERGRCgslIiIiIiIiFRZKREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUilSobRs2TLUr18fDg4O8PPzw6FDhwrsf+DAAfj5+cHBwQENGjTAihUrihQsUUXCPCEyj3lCZB7zhKh8WFwofffddxg/fjwmT56MyMhIdOjQAT179sT169dN9r969SqeffZZdOjQAZGRkfjwww8xduxYhIaGFjt4ImvFPCEyj3lCZB7zhKgciYVat24to0ePNhjm6+srkyZNMtn//fffF19fX4Nho0aNkoCAgELPMyUlRQBISkqKpeESlTpT6yfzhMgQ84SocNTrKPOEyFhZraO2lhRVWVlZOHXqFCZNmmQwvFu3bjh8+LDJcY4cOYJu3boZDOvevTtCQkLw4MED2NnZGY2TmZmJzMxM5f+UlBQAQGpqqiXhEpUJ/XopIgCYJ0SmME+ICidvrjBPiExTb1NKi0WFUmJiInJycuDm5mYw3M3NDfHx8SbHiY+PN9k/OzsbiYmJcHd3Nxpn9uzZmD59utFwT09PS8IlKlNJSUlwcXFhnhAVgHlCVDhJSUlwcHBgnhAVQL9NKS0WFUp6Go3G4H8RMRpmrr+p4XrBwcGYOHGi8n9ycjK8vLxw/fr1Ul0YxZWamgpPT0/ExsbC2dm5vMPJF+MsWSkpKahXrx6qV69uMJx5YlpF+VwZZ8linlimonyuFSVOoOLEmjdX7t27B4B5kp+K8pkCFSfWihJnftuUkmZRoVSjRg3Y2NgYHcVISEgwOnqhV7t2bZP9bW1t4erqanIce3t72NvbGw13cXGx6g9Nz9nZmXGWoIoSp1b78N4ozJPCqSifK+MsWcwTy1SUz7WixAlUnFi1Wi3zpJAqymcKVJxYK0qc+m1KqU3fks46nQ5+fn4ICwszGB4WFoa2bduaHCcwMNCo/759++Dv72/yOlmiio55QmQe84TIPOYJUTmz9O4PmzdvFjs7OwkJCZHz58/L+PHjpXLlyhITEyMiIpMmTZIhQ4Yo/a9cuSKVKlWSCRMmyPnz5yUkJETs7Oxk27ZthZ5nRbn7CuMsWRU5TuZJ/hhnyarIcTJP8sc4S15FiVUdJ/MkfxUlTpGKEyvjNGRxoSQisnTpUvHy8hKdTietWrWSAwcOKK8NGzZMgoKCDPpHRERIy5YtRafTibe3tyxfvtyi+WVkZMi0adMkIyOjKOGWGcZZsip6nMwT0xhnyarocTJPTGOcJa+ixGoqTuaJaRUlTpGKEyvjNKQRKeX76hEREREREVUwpfsLKCIiIiIiogqIhRIREREREZEKCyUiIiIiIiIVFkpEREREREQq5VIoLVu2DPXr14eDgwP8/Pxw6NChAvsfOHAAfn5+cHBwQIMGDbBixQqjPqGhoWjSpAns7e3RpEkT7Nixo0zj3L59O5555hnUrFkTzs7OCAwMxE8//WTQZ+3atdBoNEYtIyOjzOKMiIgwGcPFixcN+pXG8rQ01uHDh5uMtWnTpkqfkl6mBw8eRK9eveDh4QGNRoOdO3eaHae01s+KkieWxspcKdk4yyNPAOZKUTBPmCfME/OYJ8yT8swTI6V6Tz0T9M8D+Prrr+X8+fMybtw4qVy5sly7ds1kf/3zAMaNGyfnz5+Xr7/+2uh5AIcPHxYbGxuZNWuWXLhwQWbNmiW2trZy9OjRMotz3Lhx8tlnn8nx48clOjpagoODxc7OTk6fPq30WbNmjTg7O0tcXJxBKw5L4wwPDxcAEhUVZRBDdna20qc0lmdRYk1OTjaIMTY2VqpXry7Tpk1T+pT0Mt27d69MnjxZQkNDBYDs2LGjwP6ltX5WlDwpSqzMlZKNszzyRIS5YinmCfOEeWIe84R5Up55YorFhdKBAwfk+eefF3d390K9GZGH9/Nv1aqV2Nvbi729vXTo0MHgdV9fX5k0aZLJcd9//33x9fU1GDZq1CgJCAhQ/h8wYID06NHDoE/37t1l4MCBhXxXxlq3bi2jR48udJymNGnSRKZPn678v2bNGnFxcSlyTKZYGqc+We/cuZPvNEtjeRYlVrUdO3aIRqNRHrInUjrLVK8w63d+62eTJk0M8qRly5YGfUwtz4qYJyLMFWv77inrPBEpeq706tVLqlatquRJu3btzC7PvHlSv3598fb2tmh5cZtSMOaJS5FjMod5Yh7zxLqWZ0XKk9JaPy2+9C49PR3NmzfHl19+Waj+V69exbPPPosOHTrg2LFjyMrKwpEjRxAaGqr06datGw4fPmxy/CNHjqBbt24Gw7p3746TJ0/iwYMHBfbJb5rmZGVl4dSpU0bTLChOtdzcXKSlpaF69eoGw+/evQsvLy/UrVsXzz//PCIjI4sUY3HjbNmyJdzd3dGlSxeEh4cbvFbSy7O4seqFhISga9eu8PLyMhheksvUUvktq4sXL6JZs2ZKnrRo0cKoT973XRHzBGCuWON3jzXmCWB6WTVv3hwpKSlYuHAhAODixYsFLs+8eRIZGYn3338fMTExqFKlisE41pYrzBPrW57ME+ZJUTFPrDNPSmv9tLhQ6tmzJz755BO8+OKLheq/YsUK1KtXDwsXLkTNmjUhInjuuecwb948pY+bmxvi4+NNjh8fHw83NzeDYW5ubsjOzkZiYmKBffKbpjmJiYnIyckp1jS/+OILpKenY8CAAcowX19frF27Frt378amTZvg4OCAdu3a4dKlS2UWp7u7O1auXInQ0FBs374dPj4+6NKlCw4ePKj0KenlWdRY84qLi8MPP/yA119/3WB4SS9TS+W3rHJzczF27FglT6pWrWrUJ+/7roh5AjBXrO27x1rzBDC9rHr27AkRQYcOHQAAycnJBb73vHny+OOPo3fv3gCAvXv35jtOYeLgNqXocTJPShbzhHlS2GmWRpx5VbQ8Ka3107Z4oZpnqqILCAjARx99hAcPHsDOzg4iAo1Go7yemZmJzMxMAEBOTg7u37+PK1euwNXVFRqNBnfv3gXwsKJNTU2FiOD+/ftITU1VppGeng4ABsMKKy0tDQBw7949g/Hv37+P3Nxcs9PcunUrpk2bpqxA+v5NmjRBkyZNlH6rVq1Chw4d8MUXX+Dzzz8vkzjd3d3x8ssvK//PmTMHV65cwezZs5WzHiW9PIsaa14rVqyAs7Mznn76aYO+Jb1M1dTxquXk5CAjIwN///03PDw8oNVq8fDMMQzWaTX1Ol8R8wRgrljbd0955YmpmNVycnKQmpqK3NxcaLUPj9GZyhV13uRd703lCfDwCLs+T9Tj5M0TAHjw4AFu376NlJQUpQ+3KUWPk3limZLapjBPjDFPih9nXv/2PCk0iy7UU0EhriN87LHH5NNPPxURkczMTOWHVQDkn3/+ERGRsWPHSseOHZVxpk2bJgDY2CpUi42NFRGR7du3i62trWRlZSl5MmLECIO8mD9/vtSrV495wvbINX2eqHMFgLi6usr8+fPzzZW8eaLPFa1WK8D/8kSdK8wTtoraTG1TAOYJG1velt++l6enZ4F5UlilfkYJ+F9Fp9Pp4Ofnh+PHjxsMDwsLQ58+fZT+wcHBmDhxIgBg6tSp2LNnD65cuYLY2Fg4OzuXRchEhZaamgpPT0/l+u99+/bB399fOWoHAGfPnjUYZ9++fWjbtq3BMOYJ/Zup8wQwzhVfX1+EhYVhwoQJBn3y5kreo4E6nQ4+Pj64cOGCwfC8uZI3TwDg/fffx1dffcU8IatlbpvCPCEynyeBgYFm86RQLCqrVADzZ5Q6dOggY8eOVf7fvHmz2NjYiI2NjZw9e1bGjx8vlStXVu6oMWnSJBkyZIjS/8qVK+Lo6CgAJCUlpTjhEpWKlJQUASDHjx+XkJAQo1tUAhCtVitz5syRCxcuyJw5c4xuUck8oX87fZ68+eabcv78eaNcASCzZ88WGxubfHNFnSciIhMnThQA8tVXX8n58+fN5srZs2eZJ2TVCtqmME+IHjK37/Xbb78VmCeFVeqF0vvvvy+PP/64wbD27duLTqcTnU4nrVq1kgMHDiivDRs2TIKCggz6f//990xYslr6ZLWzsxNvb29Zvny5wesA5L///a/4+PiInZ2d+Pr6SmhoqEEf5gn92+nz5MknnxSdTmeUK/rtydatW/PNFVN5Mnr0aKlfv754eXkVKlf0cTBPyFoVtE1hnhA9ZG7fS0QKzJPCsrhQSktLk8jISImMjBQAMn/+fImMjFQeXmXqSHelSpVkwoQJJo8iFgYTlqyZqfWTeUJkiHlCVDjqdZR5QmSsrNZRiwsl/UOz1G3YsGEiYvpId0REhLRs2dLkUcTCYMKSNTO1fjJPiAwxT4gKR72OMk+IjJXVOqoR+f/307NiqampcHFxQUpKCn9USFbHWtZPa4mDyBRrWT+tJQ6i/FjDOmoNMRAVpKzWUYsfOEtERERERPRvx0KJiIiIiIhIhYUSERERERGRCgslIiIiIiIiFRZKREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUmGhREREREREpMJCiYiIiIiISIWFEhERERERkQoLJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUWCgRERERERGpsFAiIiIiIiJSYaFERERERESkwkKJiIiIiIhIhYUSERERERGRCgslIiIiIiIiFRZKREREREREKiyUiIiIiIiIVFgoERERERERqRSpUFq2bBnq168PBwcH+Pn54dChQ/n2jYiIgEajMWoXL14sctBEFQHzhMg85gmRecwTovJhcaH03XffYfz48Zg8eTIiIyPRoUMH9OzZE9evXy9wvKioKMTFxSntscceK3LQRNaOeUJkHvOEyDzmCVH50YiIWDJCmzZt0KpVKyxfvlwZ9vjjj+OFF17A7NmzjfpHRESgc+fOuHPnDqpWrVqoeWRmZiIzM1P5PzU1FZ6enkhJSYGzs7Ml4RKVutTUVLi4uBisn8wTIkPME6LCUecK84TImKltSmmw6IxSVlYWTp06hW7duhkM79atGw4fPlzguC1btoS7uzu6dOmC8PDwAvvOnj0bLi4uSvP09LQkTKJyxTwhMo95QmQe84SofFlUKCUmJiInJwdubm4Gw93c3BAfH29yHHd3d6xcuRKhoaHYvn07fHx80KVLFxw8eDDf+QQHByMlJUVpsbGxloRJVK6YJ0TmMU+IzGOeEJUv26KMpNFoDP4XEaNhej4+PvDx8VH+DwwMRGxsLObNm4eOHTuaHMfe3h729vZFCY3IajBPiMxjnhCZxzwhKh8WnVGqUaMGbGxsjI5iJCQkGB3tKEhAQAAuXbpkyayJKgzmCZF5zBMi85gnROXLokJJp9PBz88PYWFhBsPDwsLQtm3bQk8nMjIS7u7ulsyaqMJgnhCZxzwhMo95QlS+LL70buLEiRgyZAj8/f0RGBiIlStX4vr16xg9ejSAh9e53rhxA+vXrwcALFy4EN7e3mjatCmysrLwzTffIDQ0FKGhoSX7ToisCPOEyDzmCZF5zBOi8mNxofTyyy8jKSkJM2bMQFxcHJo1a4a9e/fCy8sLABAXF2dwb/+srCy89957uHHjBhwdHdG0aVN8//33ePbZZ0vuXRBZGeYJkXnMEyLzmCdE5cfi5yiVh7K6VzpRUVjL+mktcRCZYi3rp7XEQZQfa1hHrSEGooJY5XOUiIiIiIiIHgUslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUWCgRERERERGpsFAiIiIiIiJSYaFERERERESkwkKJiIiIiIhIhYUSERERERGRCgslIiIiIiIiFRZKREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUmGhREREREREpMJCiYiIiIiISIWFEhERERERkQoLJSIiIiIiIhUWSkRERERERCoslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEilSIXSsmXLUL9+fTg4OMDPzw+HDh0qsP+BAwfg5+cHBwcHNGjQACtWrChSsEQVCfOEyDzmCZF5zBOi8mFxofTdd99h/PjxmDx5MiIjI9GhQwf07NkT169fN9n/6tWrePbZZ9GhQwdERkbiww8/xNixYxEaGlrs4ImsFfOEyDzmCZF5zBOiciQWat26tYwePdpgmK+vr0yaNMlk//fff198fX0Nho0aNUoCAgIKPc+UlBQBICkpKZaGS1TqTK2fzBMiQ8wTosJRr6PMEyJjZbWO2lpSVGVlZeHUqVOYNGmSwfBu3brh8OHDJsc5cuQIunXrZjCse/fuCAkJwYMHD2BnZ2c0TmZmJjIzM5X/U1JSAACpqamWhEtUJvTrpYgAYJ4QmcI8ISqcvLnCPCEyTb1NKS0WFUqJiYnIycmBm5ubwXA3NzfEx8ebHCc+Pt5k/+zsbCQmJsLd3d1onNmzZ2P69OlGwz09PS0Jl6hMJSUlwcXFhXlCVADmCVHhJCUlwcHBgXlCVAD9NqW0WFQo6Wk0GoP/RcRomLn+pobrBQcHY+LEicr/ycnJ8PLywvXr10t1YRRXamoqPD09ERsbC2dn5/IOJ1+Ms2SlpKSgXr16qF69usFw5olpFeVzZZwli3limYryuVaUOIGKE2veXLl37x4A5kl+KspnClScWCtKnPltU0qaRYVSjRo1YGNjY3QUIyEhwejohV7t2rVN9re1tYWrq6vJcezt7WFvb2803MXFxao/ND1nZ2fGWYIqSpxa7cN7ozBPCqeifK6Ms2QxTyxTUT7XihInUHFi1Wq1zJNCqiifKVBxYq0oceq3KaU2fUs663Q6+Pn5ISwszGB4WFgY2rZta3KcwMBAo/779u2Dv7+/yetkiSo65gmRecwTIvOYJ0TlzNK7P2zevFns7OwkJCREzp8/L+PHj5fKlStLTEyMiIhMmjRJhgwZovS/cuWKVKpUSSZMmCDnz5+XkJAQsbOzk23bthV6nhXl7iuMs2RV5DiZJ/ljnCWrIsfJPMkf4yx5FSVWdZzMk/xVlDhFKk6sjNOQxYWSiMjSpUvFy8tLdDqdtGrVSg4cOKC8NmzYMAkKCjLoHxERIS1bthSdTife3t6yfPlyi+aXkZEh06ZNk4yMjKKEW2YYZ8mq6HEyT0xjnCWrosfJPDGNcZa8ihKrqTiZJ6ZVlDhFKk6sjNOQRqSU76tHRERERERUwZTuL6CIiIiIiIgqIBZKREREREREKiyUiIiIiIiIVFgoERERERERqbBQIiIiIiIiUimXQmnZsmWoX78+HBwc4Ofnh0OHDhXY/8CBA/Dz84ODgwMaNGiAFStWGPUJDQ1FkyZNYG9vjyZNmmDHjh1lGuf27dvxzDPPoGbNmnB2dkZgYCB++ukngz5r166FRqMxahkZGWUWZ0REhMkYLl68aNCvNJanpbEOHz7cZKxNmzZV+pT0Mj148CB69eoFDw8PaDQa7Ny50+w4pbV+VpQ8sTRW5krJxlkeeQIwV4qCecI8YZ6YxzxhnpRnnhgp1ZuPm6B/cNrXX38t58+fl3HjxknlypXl2rVrJvvrH5w2btw4OX/+vHz99ddGD047fPiw2NjYyKxZs+TChQsya9YssbW1laNHj5ZZnOPGjZPPPvtMjh8/LtHR0RIcHCx2dnZy+vRppc+aNWvE2dlZ4uLiDFpxWBpneHi4AJCoqCiDGLKzs5U+pbE8ixJrcnKyQYyxsbFSvXp1mTZtmtKnpJfp3r17ZfLkyRIaGioAZMeOHQX2L631s6LkSVFiZa6UbJzlkScizBVLMU+YJ8wT85gnzJPyzBNTyrxQat26tYwePdpgmK+vr0yaNMlk//fff198fX0Nho0aNUoCAgKU/wcMGCA9evQw6NO9e3cZOHBgmcVpSpMmTWT69OnK/2vWrBEXF5cix2SKpXHqk/XOnTv5TrM0lmdRYlXbsWOHaDQa5WnkIqWzTPUKk6yltX5WlDwpSqymMFeKHqdaWeeJCHOlMJgn1rU8mSfMk+JgnrgUOSZzyjNPTCnTS++ysrJw6tQpdOvWzWB4t27dcPjwYZPjHDlyxKh/9+7dcfLkSTx48KDAPvlNszTiVMvNzUVaWhqqV69uMPzu3bvw8vJC3bp18fzzzyMyMrJIMRY3zpYtW8Ld3R1dunRBeHi4wWslvTyLG6teSEgIunbtCi8vL4PhJblMLVUa62dFyZOixqrGXCmZOPWsMU+ARztXmCfWtzyZJ8yTomKe/DvzJD9lWiglJiYiJycHbm5uBsPd3NwQHx9vcpz4+HiT/bOzs5GYmFhgn/ymWRpxqn3xxRdIT0/HgAEDlGG+vr5Yu3Ytdu/ejU2bNsHBwQHt2rXDpUuXyixOd3d3rFy5EqGhodi+fTt8fHzQpUsXHDx4UOlT0suzqLHmFRcXhx9++AGvv/66wfCSXqaWKo31s6LkSVFjVWOuFC/OvKw1T4BHO1eYJ9a1PJkn5sdhnpRsnMyTklWW66dt8UItGo1GY/C/iBgNM9dfPdzSaZZGnHqbNm3Cxx9/jF27dqFWrVrK8ICAAAQEBCj/t2vXDq1atcKSJUuwePHiMonTx8cHPj4+yv+BgYGIjY3FvHnz0LFjxyJNs7RizWvt2rWoWrUqXnjhBYPhpbVMLVFa62dFyZPiTJe5Uvw487LmPAGYK8yTwk2zNOLMi3lSuHGYJyUXJ/Ok5JXV+lmmZ5Rq1KgBGxsbo2ouISHBqOrTq127tsn+tra2cHV1LbBPftMsjTj1vvvuO4wcORJbtmxB165dC+yr1Wrx1FNPFbkKL06ceQUEBBjEUNLLs7ixighWr16NIUOGQKfTFdi3uMvUUqWxflaUPClqrHrMlZKN05rzBHi0c4V5Yj3Lk3lSuHGYJ6UTZ17Mk6Iry/WzTAslnU4HPz8/hIWFGQwPCwtD27ZtTY4TGBho1H/fvn3w9/eHnZ1dgX3ym2ZpxAk8PJoxfPhwbNy4Ec8995zZ+YgIzpw5A3d39zKNUy0yMtIghpJensWN9cCBA/jrr78wcuRIs/Mp7jK1VGmsnxUlT4oaK8BcKY04rTlPgEc7V5gn1rE8AeZJXswT5kl+HsU8yZdFt34oAfpbFYaEhMj58+dl/PjxUrlyZeWOGpMmTZIhQ4Yo/fW3AJwwYYKcP39eQkJCjG4B+Ntvv4mNjY3MmTNHLly4IHPmzCmxWyoWNs6NGzeKra2tLF261OB2icnJyUqfjz/+WH788Ue5fPmyREZGyogRI8TW1laOHTtWZnEuWLBAduzYIdHR0fLnn3/KpEmTBICEhoYqfUpjeRYlVr3BgwdLmzZtTE6zpJdpWlqaREZGSmRkpACQ+fPnS2RkpHIrzbJaPytKnhQlVuZKycapV5Z5IsJcsRTzhHnCPDGPecI8Kc88MaXMCyURkaVLl4qXl5fodDpp1aqVHDhwQHlt2LBhEhQUZNA/IiJCWrZsKTqdTry9vWX58uVG09y6dav4+PiInZ2d+Pr6Gqx8ZRFnUFCQADBqw4YNU/qMHz9e6tWrJzqdTmrWrCndunWTw4cPl2mcn332mTRs2FAcHBykWrVq0r59e/n++++Nplkay9PSWEUe3tPf0dFRVq5caXJ6Jb1M9bfwzO9zLMv1s6LkiaWxMldKNk6Rss8TEeZKUTBPmCfME/OYJ8yT8swTNY3I///1ExEREREREQEo498oERERERERVQQslIiIiIiIiFRYKBEREREREamwUCIiIiIiIlJhoURERERERKTCQomIiIiIiEiFhRIREREREZEKCyUiIiIiIiIVFkpEREREREQqLJSIiIiIiIhUWCgRERERERGp/D/lDay58W9l5wAAAABJRU5ErkJggg==", - "text/plain": [ - "
" + "cell_type": "markdown", + "metadata": { + "id": "sSm7N--8vl9W" + }, + "source": [ + "## Load the data: [Captcha Images](https://www.kaggle.com/fournierp/captcha-version-2-images)\n", + "Let's download the data." ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "_, ax = plt.subplots(4, 4, figsize=(10, 5))\n", - "for batch in train_dataset.take(1):\n", - " images2 = batch[\"image\"]\n", - " labels2 = batch[\"label\"]\n", - " for i in range(batch_size):\n", - " img = (images2[i] * 255).numpy().astype(\"uint8\")\n", - " label = tf.strings.reduce_join(num_to_char(labels2[i])).numpy().decode(\"utf-8\")\n", - " ax[i // 4, i % 4].imshow(img[:, :, 0].T, cmap=\"gray\", vmin=0, vmax=255)\n", - " ax[i // 4, i % 4].set_title(label)\n", - " ax[i // 4, i % 4].axis(\"off\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "5pgP4jIIvl9a" - }, - "source": [ - "## Model" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "id": "ddaZyWUFvl9a", - "scrolled": true - }, - "outputs": [ + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"ocr_model_v1\"\n", - "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", - "==================================================================================================\n", - " image (InputLayer) [(None, 300, 80, 1)] 0 [] \n", - " \n", - " conv_2d1 (Conv2D) (None, 300, 80, 60) 600 ['image[0][0]'] \n", - " \n", - " pool5 (MaxPooling2D) (None, 150, 40, 60) 0 ['conv_2d1[0][0]'] \n", - " \n", - " reshape (Reshape) (None, 75, 4800) 0 ['pool5[0][0]'] \n", - " \n", - " bidirectional (Bidirection (None, 75, 200) 3920800 ['reshape[0][0]'] \n", - " al) \n", - " \n", - " label (InputLayer) [(None, None)] 0 [] \n", - " \n", - " dense2 (Dense) (None, 75, 24) 4824 ['bidirectional[0][0]'] \n", - " \n", - " ctc_loss (CTCLayer) (None, 75, 24) 0 ['label[0][0]', \n", - " 'dense2[0][0]'] \n", - " \n", - "==================================================================================================\n", - "Total params: 3926224 (14.98 MB)\n", - "Trainable params: 3926224 (14.98 MB)\n", - "Non-trainable params: 0 (0.00 Byte)\n", - "__________________________________________________________________________________________________\n" - ] - } - ], - "source": [ - "\n", - "class CTCLayer(layers.Layer):\n", - " def __init__(self, name=None):\n", - " super().__init__(name=name)\n", - " self.loss_fn = keras.backend.ctc_batch_cost\n", - "\n", - " def call(self, y_true, y_pred):\n", - " # Compute the training-time loss value and add it\n", - " # to the layer using `self.add_loss()`.\n", - " batch_len = tf.cast(tf.shape(y_true)[0], dtype=\"int64\")\n", - " input_length = tf.cast(tf.shape(y_pred)[1], dtype=\"int64\")\n", - " label_length = tf.cast(tf.shape(y_true)[1], dtype=\"int64\")\n", - "\n", - " input_length = input_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\")\n", - " label_length = label_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\")\n", - "\n", - " loss = self.loss_fn(y_true, y_pred, input_length, label_length)\n", - " self.add_loss(loss)\n", - "\n", - " # At test time, just return the computed predictions\n", - " return y_pred\n", - "\n", - "\n", - "def build_model():\n", - " # Inputs to the model\n", - " input_img = layers.Input(\n", - " shape=(img_width, img_height, 1), name=\"image\", dtype=\"float32\"\n", - " )\n", - " labels = layers.Input(name=\"label\", shape=(None,), dtype=\"float32\")\n", - "\n", - "\n", - " # First conv block\n", - " x = layers.Conv2D(40, (3, 3), activation=\"relu\", kernel_initializer=\"GlorotUniform\", padding=\"same\",use_bias=True, name=\"conv_2d\")(input_img) \n", - " x = layers.MaxPooling2D((2, 2), name=\"pool3\")(x)\n", - " x = layers.Conv2D(60, (3, 3), activation=\"relu\", kernel_initializer=\"GlorotUniform\", padding=\"same\",use_bias=True, name=\"conv_2d1\")(input_img) \n", - " x = layers.MaxPooling2D((2, 2), name=\"pool5\")(x)\n", - "\n", - " # Reshape layer to prepare for the RNN layers\n", - " new_shape = ((img_width // 4), (img_height // 4) * 60 * 4)\n", - " #new_shape = (36, 256)\n", - " x = layers.Reshape(target_shape=new_shape, name=\"reshape\")(x)\n", - "\n", - "\n", - " # RNN layers\n", - " x = layers.Bidirectional(layers.LSTM(100, recurrent_activation=\"sigmoid\", activation=\"tanh\",kernel_initializer=\"GlorotUniform\", recurrent_initializer=\"Orthogonal\", return_sequences=True, dropout=0.3), merge_mode=\"concat\")(x)\n", - " \n", - " # Output layer\n", - " x = layers.Dense(len(char_to_num.get_vocabulary()) + 1, activation=\"softmax\", name=\"dense2\")(x)\n", - "\n", - "\n", - " # Add CTC layer for calculating CTC loss at each step\n", - " output = CTCLayer(name=\"ctc_loss\")(labels, x)\n", - "\n", - " # Define the model\n", - " model = keras.models.Model(\n", - " inputs=[input_img, labels], outputs=output, name=\"ocr_model_v1\"\n", - " )\n", - " # Optimizer\n", - " opt = keras.optimizers.Adam(learning_rate=0.0075)\n", - " # Compile the model and return\n", - " model.compile(optimizer=opt)\n", - " return model\n", - "\n", - "\n", - "# Get the model\n", - "model = build_model()\n", - "model.summary()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "PCAmf-fzvl9a" - }, - "source": [ - "## Training" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "id": "M-R6QGjuvl9a" - }, - "outputs": [ + "cell_type": "code", + "execution_count": 47, + "metadata": { + "id": "g3EVJfHBvl9X", + "outputId": "63444ebd-1935-47ff-c031-0060c94fe3fc", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Number of images found: 10610\n", + "Number of labels found: 10610\n", + "Number of unique characters: 22\n", + "Characters present: [' ', '0', '2', '4', '5', '8', 'A', 'D', 'G', 'H', 'J', 'K', 'M', 'N', 'P', 'R', 'S', 'T', 'V', 'W', 'X', 'Y']\n" + ] + } + ], + "source": [ + "substitutions = {\n", + " 'B': '8',\n", + " 'F': 'P',\n", + " 'U': 'V',\n", + " '6': 'G',\n", + " 'Z': '2',\n", + " 'O': '0'\n", + "}\n", + "\n", + "def apply_substitutions(input_string):\n", + " output_string = \"\"\n", + " for char in input_string:\n", + " if char in substitutions:\n", + " output_string += substitutions[char]\n", + " else:\n", + " output_string += char\n", + "\n", + " return output_string\n", + "\n", + "data_dir = Path(\"./images_10k/\")\n", + "\n", + "# Get list of all the images\n", + "images = sorted(list(map(str, list(data_dir.glob(\"*.png\")))))\n", + "labels = [apply_substitutions(img.split(os.path.sep)[-1].split(\".png\")[0]) for img in images]\n", + "\n", + "# Maximum length of any captcha in the dataset\n", + "max_length = max([len(label) for label in labels])\n", + "labels = [x + ' ' * (max_length - len(x)) for x in labels]\n", + "\n", + "characters = set(char for label in labels for char in label)\n", + "characters = sorted(list(characters))\n", + "\n", + "print(\"Number of images found: \", len(images))\n", + "print(\"Number of labels found: \", len(labels))\n", + "print(\"Number of unique characters: \", len(characters))\n", + "print(\"Characters present: \", characters)\n", + "\n", + "# Batch size for training and validation\n", + "batch_size = 16\n", + "\n", + "# Desired image dimensions\n", + "img_width = 300\n", + "img_height = 80\n", + "\n", + "# Factor by which the image is going to be downsampled\n", + "# by the convolutional blocks. We will be using two\n", + "# convolution blocks and each block will have\n", + "# a pooling layer which downsample the features by a factor of 2.\n", + "# Hence total downsampling factor would be 4.\n", + "downsample_factor = 4\n", + "\n", + "\n" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/100\n" - ] + "cell_type": "markdown", + "metadata": { + "id": "gqn-NjRovl9Y" + }, + "source": [ + "## Preprocessing" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-08-08 09:00:00.538999: I tensorflow/compiler/xla/stream_executor/cuda/cuda_dnn.cc:432] Loaded cuDNN version 8902\n", - "2023-08-08 09:00:01.417354: I tensorflow/compiler/xla/service/service.cc:168] XLA service 0x7f9eb707a6f0 initialized for platform CUDA (this does not guarantee that XLA will be used). Devices:\n", - "2023-08-08 09:00:01.417398: I tensorflow/compiler/xla/service/service.cc:176] StreamExecutor device (0): NVIDIA GeForce GTX 1650, Compute Capability 7.5\n", - "2023-08-08 09:00:01.480666: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:255] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.\n", - "2023-08-08 09:00:01.881648: I ./tensorflow/compiler/jit/device_compiler.h:186] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n" - ] + "cell_type": "code", + "source": [ + "!rm -rf sdir" + ], + "metadata": { + "id": "8bVogUbzY6Fi" + }, + "execution_count": 48, + "outputs": [] }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "1886/1886 [==============================] - 66s 32ms/step - loss: 10.4818 - val_loss: 3.5385\n", - "Epoch 2/100\n", - "1886/1886 [==============================] - 59s 31ms/step - loss: 2.9341 - val_loss: 2.3414\n", - "Epoch 3/100\n", - "1886/1886 [==============================] - 57s 30ms/step - loss: 2.1140 - val_loss: 1.9919\n", - "Epoch 4/100\n", - "1886/1886 [==============================] - 58s 31ms/step - loss: 1.7638 - val_loss: 1.7001\n", - "Epoch 5/100\n", - "1886/1886 [==============================] - 68s 36ms/step - loss: 1.5672 - val_loss: 1.7731\n", - "Epoch 6/100\n", - "1886/1886 [==============================] - 69s 37ms/step - loss: 1.5323 - val_loss: 1.9233\n", - "Epoch 7/100\n", - "1886/1886 [==============================] - 67s 36ms/step - loss: 1.4012 - val_loss: 1.6993\n", - "Epoch 8/100\n", - "1886/1886 [==============================] - 72s 38ms/step - loss: 1.4151 - val_loss: 2.1529\n", - "Epoch 9/100\n", - "1886/1886 [==============================] - 67s 35ms/step - loss: 1.3961 - val_loss: 1.6122\n", - "Epoch 10/100\n", - "1886/1886 [==============================] - 63s 34ms/step - loss: 1.3398 - val_loss: 1.7357\n", - "Epoch 11/100\n", - "1886/1886 [==============================] - 66s 35ms/step - loss: 1.2908 - val_loss: 1.6795\n", - "Epoch 12/100\n", - "1886/1886 [==============================] - 65s 34ms/step - loss: 1.2644 - val_loss: 1.5135\n", - "Epoch 13/100\n", - "1886/1886 [==============================] - 67s 36ms/step - loss: 1.2279 - val_loss: 1.6908\n", - "Epoch 14/100\n", - "1886/1886 [==============================] - 68s 36ms/step - loss: 1.2833 - val_loss: 1.6330\n", - "Epoch 15/100\n", - "1886/1886 [==============================] - 64s 34ms/step - loss: 1.3665 - val_loss: 1.7188\n", - "Epoch 16/100\n", - "1886/1886 [==============================] - 59s 31ms/step - loss: 1.2802 - val_loss: 1.4348\n", - "Epoch 17/100\n", - "1886/1886 [==============================] - 66s 35ms/step - loss: 1.2824 - val_loss: 1.5345\n", - "Epoch 18/100\n", - "1886/1886 [==============================] - 57s 30ms/step - loss: 1.2963 - val_loss: 1.4366\n", - "Epoch 19/100\n", - "1886/1886 [==============================] - 61s 32ms/step - loss: 1.2542 - val_loss: 1.4457\n", - "Epoch 20/100\n", - "1886/1886 [==============================] - 61s 33ms/step - loss: 1.2377 - val_loss: 1.4475\n", - "Epoch 21/100\n", - "1886/1886 [==============================] - 58s 31ms/step - loss: 1.2494 - val_loss: 1.5095\n", - "Epoch 22/100\n", - "1886/1886 [==============================] - 58s 31ms/step - loss: 1.2469 - val_loss: 1.5823\n", - "Epoch 23/100\n", - "1886/1886 [==============================] - 63s 33ms/step - loss: 1.2601 - val_loss: 1.5059\n", - "Epoch 24/100\n", - "1886/1886 [==============================] - 68s 36ms/step - loss: 1.3095 - val_loss: 1.5356\n", - "Epoch 25/100\n", - "1886/1886 [==============================] - 67s 35ms/step - loss: 1.6499 - val_loss: 1.7413\n", - "Epoch 26/100\n", - "1886/1886 [==============================] - 68s 36ms/step - loss: 1.4921 - val_loss: 1.7528\n" - ] - } - ], - "source": [ - "epochs = 100\n", - "early_stopping_patience = 10\n", - "# Add early stopping\n", - "early_stopping = keras.callbacks.EarlyStopping(\n", - " monitor=\"val_loss\", patience=early_stopping_patience, restore_best_weights=True\n", - ")\n", - "\n", - "# Train the model\n", - "history = model.fit(\n", - " train_dataset,\n", - " validation_data=validation_dataset,\n", - " epochs=epochs,\n", - " callbacks=[early_stopping],\n", - ")\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "id": "1EpbnVEEvl9a" - }, - "source": [ - "## Inference\n", - "\n", - "You can use the trained model hosted on [Hugging Face Hub](https://huggingface.co/keras-io/ocr-for-captcha)\n", - "and try the demo on [Hugging Face Spaces](https://huggingface.co/spaces/keras-io/ocr-for-captcha)." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "id": "8_xv3ktTvl9b" - }, - "outputs": [ + "cell_type": "code", + "execution_count": 49, + "metadata": { + "id": "MjQltH0Mvl9Y" + }, + "outputs": [], + "source": [ + "from skimage.morphology import opening, square, label\n", + "from skimage.measure import regionprops\n", + "from skimage.io import imread, imsave\n", + "from skimage import img_as_ubyte\n", + "\n", + "# Mapping characters to integers\n", + "char_to_num = layers.StringLookup(\n", + " vocabulary=list(characters), mask_token=None,\n", + ")\n", + "\n", + "# Mapping integers back to original characters\n", + "num_to_char = layers.StringLookup(\n", + " vocabulary=char_to_num.get_vocabulary(), mask_token=None, invert=True\n", + ")\n", + "\n", + "def filter_image(img, kernel_size=3, num_components=8, min_height_ratio=0.25, max_height_ratio=1):\n", + " # Binarize the image\n", + " binary_image = img < 0.5 # Pixels with a value less than 0.5 will be True (1)\n", + "\n", + " # Label connected components in the image\n", + " label_image = label(binary_image)\n", + "\n", + " # Get properties of the labeled regions\n", + " properties = regionprops(label_image)\n", + "\n", + " # Sort the regions by area (in descending order)\n", + " properties.sort(key=lambda x: x.area, reverse=True)\n", + "\n", + " # Create an empty image to store the result\n", + " filtered_image = np.zeros_like(label_image, dtype=bool)\n", + "\n", + " # Keep only the largest components that satisfy the height constraints\n", + " for prop in properties[:num_components]:\n", + " minr, minc, maxr, maxc = prop.bbox\n", + " height = maxr - minr\n", + " if height > max_height_ratio * img.shape[0] or height < min_height_ratio * img.shape[0]:\n", + " continue\n", + " filtered_image[label_image == prop.label] = 1\n", + "\n", + " return filtered_image == 0\n", + "\n", + "\n", + "def read_and_process(imgpath, cdir):\n", + " img = imread(imgpath, as_gray=True);\n", + " img = np.hstack([img, np.ones((img_height, img_width - img.shape[1]))]).astype(\"float32\")\n", + " img = filter_image(img)\n", + " output_path = os.path.join(cdir, Path(imgpath).stem + \".png\")\n", + " imsave(output_path, np.clip(img_as_ubyte(img), 0, 238))\n", + " return tf.convert_to_tensor((1 - img).astype(\"float32\").reshape((80, 300, 1)));\n", + "\n", + "def load_data(images, labels, cache, shuffle=True):\n", + " os.makedirs(cache, exist_ok=True)\n", + " # 1. Get the total size of the dataset\n", + " size = len(images)\n", + " # 2. Make an indices array and shuffle it, if required\n", + " indices = np.arange(size)\n", + " if shuffle:\n", + " np.random.shuffle(indices)\n", + " # 3. Get the size of training samples\n", + " train_samples = int(size)\n", + " # 4. Split data into training and validation sets\n", + " x_train, y_train = images[indices], labels[indices]\n", + " x_train = [read_and_process(x, cache) for x in x_train]\n", + " return x_train, y_train\n", + "\n", + "\n", + "# Splitting data into training and validation sets\n", + "rx_train, ry_train = load_data(np.array(images), np.array(labels), Path(\"sdir\"))\n", + "\n", + "\n", + "def encode_single_sample(img, label):\n", + " img = tf.image.convert_image_dtype(img, tf.float32)\n", + " # 4. Resize to the desired size\n", + " #img = tf.image.resize_with_pad(img, img_height, img_width)\n", + " # 5. Transpose the image because we want the time\n", + " # dimension to correspond to the width of the image.\n", + " img = tf.transpose(img, perm=[1, 0, 2])\n", + " # 6. Map the characters in label to numbers\n", + " label = char_to_num(tf.strings.unicode_split(label, input_encoding=\"UTF-8\"))\n", + " # 7. Return a dict as our model is expecting two inputs\n", + " return {\"image\": img, \"label\": label}\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fnwhurZ-vl9Z" + }, + "source": [ + "## Create `Dataset` objects" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"model\"\n", - "_________________________________________________________________\n", - " Layer (type) Output Shape Param # \n", - "=================================================================\n", - " image (InputLayer) [(None, 300, 80, 1)] 0 \n", - " \n", - " conv_2d1 (Conv2D) (None, 300, 80, 60) 600 \n", - " \n", - " pool5 (MaxPooling2D) (None, 150, 40, 60) 0 \n", - " \n", - " reshape (Reshape) (None, 75, 4800) 0 \n", - " \n", - " bidirectional (Bidirection (None, 75, 200) 3920800 \n", - " al) \n", - " \n", - " dense2 (Dense) (None, 75, 24) 4824 \n", - " \n", - "=================================================================\n", - "Total params: 3926224 (14.98 MB)\n", - "Trainable params: 3926224 (14.98 MB)\n", - "Non-trainable params: 0 (0.00 Byte)\n", - "_________________________________________________________________\n", - "1/1 [==============================] - 1s 696ms/step\n", - "HSXVW \n", - "28P0VK\n", - "VMTPM \n", - "HKYJA2\n", - "['HSXVW ', 'HSXVW ']\n", - "['28P0VK', '28P0VK']\n", - "['VMTPM ', 'VMTPM ']\n", - "['HKYJA2', 'HKYJA2']\n", - "1/1 [==============================] - 0s 32ms/step\n", - "YPDVAK\n", - "Y0S4RR\n", - "H4DRJ \n", - "NJTNKP\n", - "['YPDVAK', 'YPDVAK']\n", - "['0S4RR ', 'Y0S4RR']\n", - "['H4DR ', 'H4DRJ ']\n", - "['NJTNKP', 'NJTNKP']\n", - "1/1 [==============================] - 0s 53ms/step\n", - "088S4 \n", - "PVSSSY\n", - "SVK4WA\n", - "ASJKKX\n", - "['088S4 ', '088S4 ']\n", - "['PSSY ', 'PVSSSY']\n", - "['SVK4WA', 'SVK4WA']\n", - "['ASJKKX', 'ASJKKX']\n", - "1/1 [==============================] - 0s 47ms/step\n", - "0RW8HW\n", - "0ANDKK\n", - "R204S0\n", - "4VNHNX\n", - "['0RW8HW', '0RW8HW']\n", - "['0ANDKK', '0ANDKK']\n", - "['R204S0', 'R204S0']\n", - "['VNHNX ', '4VNHNX']\n" - ] + "cell_type": "code", + "execution_count": 64, + "metadata": { + "id": "IEec36ZDL5OH", + "outputId": "e79ca0b6-4bce-4830-c863-d7167cd2f666", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "2653\n", + "7957\n" + ] + } + ], + "source": [ + "split_index = int(len(rx_train) * 0.75)\n", + "\n", + "# Move the first 75% of x_valid to x_train\n", + "x_train = rx_train[:split_index];\n", + "# Move the first 75% of y_valid to y_train\n", + "y_train = ry_train[:split_index];\n", + "\n", + "# Keep only the last 25% of x_valid\n", + "x_valid = rx_train[split_index:]\n", + "# Keep only the last 25% of y_valid\n", + "y_valid = ry_train[split_index:]\n", + "\n", + "print(len(x_valid))\n", + "print(len(x_train))" + ] }, { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "cell_type": "code", + "execution_count": 65, + "metadata": { + "id": "k2MZdcpXvl9Z" + }, + "outputs": [], + "source": [ + "train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))\n", + "train_dataset = (\n", + " train_dataset.map(\n", + " encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE\n", + " )\n", + " .batch(batch_size)\n", + " .prefetch(buffer_size=tf.data.AUTOTUNE)\n", + ")\n", + "\n", + "validation_dataset = tf.data.Dataset.from_tensor_slices((x_valid, y_valid))\n", + "validation_dataset = (\n", + " validation_dataset.map(\n", + " encode_single_sample, num_parallel_calls=tf.data.AUTOTUNE\n", + " )\n", + " .batch(batch_size)\n", + " .prefetch(buffer_size=tf.data.AUTOTUNE)\n", + ")" ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from sklearn.metrics import pairwise_distances\n", - "\n", - "# Get the prediction model by extracting layers till the output layer\n", - "prediction_model = keras.models.Model(\n", - " model.get_layer(name=\"image\").input, model.get_layer(name=\"dense2\").output\n", - ")\n", - "prediction_model.summary()\n", - "\n", - "# A utility function to decode the output of the network\n", - "def decode_batch_predictions(pred):\n", - " input_len = np.ones(pred.shape[0]) * pred.shape[1]\n", - " # Use greedy search. For complex tasks, you can use beam search\n", - " results = keras.backend.ctc_decode(pred, input_length=input_len, greedy=True)[0][0][\n", - " :, :max_length\n", - " ]\n", - " # Iterate over the results and get back the text\n", - " output_text = []\n", - " for res in results:\n", - " res = tf.strings.reduce_join(num_to_char(res)).numpy().decode(\"utf-8\")\n", - " output_text.append(res)\n", - " return output_text\n", - "\n", - "def lev(s1, s2):\n", - " m, n = len(s1), len(s2)\n", - " dp = np.zeros((m + 1, n + 1), dtype=int)\n", - "\n", - " for i in range(m + 1):\n", - " for j in range(n + 1):\n", - " if i == 0:\n", - " dp[i][j] = j\n", - " elif j == 0:\n", - " dp[i][j] = i\n", - " elif s1[i - 1] == s2[j - 1]:\n", - " dp[i][j] = dp[i - 1][j - 1]\n", - " else:\n", - " dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])\n", - "\n", - " return dp[m][n]\n", - "# Let's check results on some validation samples\n", - "j = 0\n", - "_, ax = plt.subplots(4, 4, figsize=(15, 5))\n", - "\n", - "for batch in validation_dataset.take(4):\n", - " batch_images = batch[\"image\"]\n", - " batch_labels = batch[\"label\"]\n", - "\n", - " preds = prediction_model.predict(batch_images)\n", - " pred_texts = decode_batch_predictions(preds)\n", - "\n", - " orig_texts = []\n", - " for label in batch_labels:\n", - " print(tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\"))\n", - " label = tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\")\n", - " orig_texts.append(label)\n", - "\n", - " for i in range(len(pred_texts)):\n", - " img = (batch_images[i, :, :, 0] * 255).numpy().astype(np.uint8)\n", - " img = img.T\n", - " pred = pred_texts[i].replace('[UNK]', '')\n", - " comp = orig_texts[i];\n", - " if len(comp) == 5:\n", - " comp += ' '\n", - " if len(pred) == 5:\n", - " pred += ' '\n", - " dist = lev(pred, comp)\n", - " print([pred, comp])\n", - " title = f\"P: {pred} T: {comp} ({dist})\"\n", - " ax[j // 4,i % 4].imshow(img, cmap=\"gray\")\n", - " ax[j // 4, i % 4].set_title(title, color=('green' if comp in pred else 'red'))\n", - " ax[j // 4, i % 4].axis(\"off\")\n", - " j += 1\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NI0NRV5Ivl9Z" + }, + "source": [ + "## Visualize the data" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": { + "id": "7GT5RSNgvl9Z", + "outputId": "67525f74-36e2-4ca5-9246-6990c7c5a368", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 405 + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "_, ax = plt.subplots(4, 4, figsize=(10, 5))\n", + "for batch in train_dataset.take(1):\n", + " images2 = batch[\"image\"]\n", + " labels2 = batch[\"label\"]\n", + " for i in range(batch_size):\n", + " img = (images2[i] * 255).numpy().astype(\"uint8\")\n", + " label = tf.strings.reduce_join(num_to_char(labels2[i])).numpy().decode(\"utf-8\")\n", + " ax[i // 4, i % 4].imshow(img[:, :, 0].T, cmap=\"gray\", vmin=0, vmax=255)\n", + " ax[i // 4, i % 4].set_title(label)\n", + " ax[i // 4, i % 4].axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5pgP4jIIvl9a" + }, + "source": [ + "## Model" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": { + "id": "ddaZyWUFvl9a", + "scrolled": true, + "outputId": "8b407d1a-15bd-4cee-89cb-fb06eb723fda", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"ocr_model_v1\"\n", + "__________________________________________________________________________________________________\n", + " Layer (type) Output Shape Param # Connected to \n", + "==================================================================================================\n", + " image (InputLayer) [(None, 300, 80, 1) 0 [] \n", + " ] \n", + " \n", + " Conv1 (Conv2D) (None, 300, 80, 32) 320 ['image[0][0]'] \n", + " \n", + " pool1 (MaxPooling2D) (None, 150, 40, 32) 0 ['Conv1[0][0]'] \n", + " \n", + " Conv2 (Conv2D) (None, 150, 40, 64) 18496 ['pool1[0][0]'] \n", + " \n", + " pool2 (MaxPooling2D) (None, 75, 20, 64) 0 ['Conv2[0][0]'] \n", + " \n", + " reshape (Reshape) (None, 75, 1280) 0 ['pool2[0][0]'] \n", + " \n", + " dense1 (Dense) (None, 75, 64) 81984 ['reshape[0][0]'] \n", + " \n", + " dropout_9 (Dropout) (None, 75, 64) 0 ['dense1[0][0]'] \n", + " \n", + " bidirectional_19 (Bidirectiona (None, 75, 256) 197632 ['dropout_9[0][0]'] \n", + " l) \n", + " \n", + " bidirectional_20 (Bidirectiona (None, 75, 128) 164352 ['bidirectional_19[0][0]'] \n", + " l) \n", + " \n", + " label (InputLayer) [(None, None)] 0 [] \n", + " \n", + " dense2 (Dense) (None, 75, 24) 3096 ['bidirectional_20[0][0]'] \n", + " \n", + " ctc_loss (CTCLayer) (None, 75, 24) 0 ['label[0][0]', \n", + " 'dense2[0][0]'] \n", + " \n", + "==================================================================================================\n", + "Total params: 465,880\n", + "Trainable params: 465,880\n", + "Non-trainable params: 0\n", + "__________________________________________________________________________________________________\n" + ] + } + ], + "source": [ + "\n", + "class CTCLayer(layers.Layer):\n", + " def __init__(self, name=None):\n", + " super().__init__(name=name)\n", + " self.loss_fn = keras.backend.ctc_batch_cost\n", + "\n", + " def call(self, y_true, y_pred):\n", + " # Compute the training-time loss value and add it\n", + " # to the layer using `self.add_loss()`.\n", + " batch_len = tf.cast(tf.shape(y_true)[0], dtype=\"int64\")\n", + " input_length = tf.cast(tf.shape(y_pred)[1], dtype=\"int64\")\n", + " label_length = tf.cast(tf.shape(y_true)[1], dtype=\"int64\")\n", + "\n", + " input_length = input_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\")\n", + " label_length = label_length * tf.ones(shape=(batch_len, 1), dtype=\"int64\")\n", + "\n", + " loss = self.loss_fn(y_true, y_pred, input_length, label_length)\n", + " self.add_loss(loss)\n", + "\n", + " # At test time, just return the computed predictions\n", + " return y_pred\n", + "\n", + "\n", + "def build_model():\n", + " # Inputs to the model\n", + " input_img = layers.Input(\n", + " shape=(img_width, img_height, 1), name=\"image\", dtype=\"float32\"\n", + " )\n", + " labels = layers.Input(name=\"label\", shape=(None,), dtype=\"float32\")\n", + "\n", + " # First conv block\n", + " x = layers.Conv2D(32, (3, 3), activation=\"relu\", kernel_initializer=\"he_normal\", padding=\"same\", name=\"Conv1\")(input_img)\n", + " x = layers.MaxPooling2D((2, 2), name=\"pool1\")(x)\n", + "\n", + " # Second conv block\n", + " x = layers.Conv2D(64, (3, 3), activation=\"relu\", kernel_initializer=\"he_normal\", padding=\"same\", name=\"Conv2\")(x)\n", + " x = layers.MaxPooling2D((2, 2), name=\"pool2\")(x)\n", + "\n", + " # We have used two max pool with pool size and strides 2.\n", + " # Hence, downsampled feature maps are 4x smaller. The number of\n", + " # filters in the last layer is 64. Reshape accordingly before\n", + " # passing the output to the RNN part of the model\n", + " new_shape = ((img_width // 4), (img_height // 4) * 64)\n", + " x = layers.Reshape(target_shape=new_shape, name=\"reshape\")(x)\n", + " x = layers.Dense(64, activation=\"relu\", name=\"dense1\")(x)\n", + " x = layers.Dropout(0.2)(x)\n", + "\n", + " # RNNs\n", + " x = layers.Bidirectional(layers.LSTM(128, return_sequences=True, dropout=0.25))(x)\n", + " x = layers.Bidirectional(layers.LSTM(64, return_sequences=True, dropout=0.25))(x)\n", + "\n", + " # Output layer\n", + " x = layers.Dense(len(char_to_num.get_vocabulary()) + 1, activation=\"softmax\", name=\"dense2\")(x)\n", + "\n", + " # Add CTC layer for calculating CTC loss at each step\n", + " output = CTCLayer(name=\"ctc_loss\")(labels, x)\n", + "\n", + " # Define the model\n", + " model = keras.models.Model(\n", + " inputs=[input_img, labels], outputs=output, name=\"ocr_model_v1\"\n", + " )\n", + " # Optimizer\n", + " opt = keras.optimizers.Adam()\n", + " # Compile the model and return\n", + " model.compile(optimizer=opt)\n", + " return model\n", + "\n", + "\n", + "# Get the model\n", + "model = build_model()\n", + "model.summary()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PCAmf-fzvl9a" + }, + "source": [ + "## Training" + ] + }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "INFO:tensorflow:Assets written to: captcha_75_25.tf/assets\n" - ] + "cell_type": "code", + "execution_count": 77, + "metadata": { + "id": "M-R6QGjuvl9a", + "outputId": "1430d686-b65f-470e-ee40-749311d07dcc", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 1/100\n", + "498/498 [==============================] - 35s 51ms/step - loss: 20.7945 - val_loss: 19.4729\n", + "Epoch 2/100\n", + "498/498 [==============================] - 23s 45ms/step - loss: 16.1562 - val_loss: 5.6912\n", + "Epoch 3/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 3.3449 - val_loss: 1.3842\n", + "Epoch 4/100\n", + "498/498 [==============================] - 22s 43ms/step - loss: 1.5384 - val_loss: 0.9462\n", + "Epoch 5/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 1.1034 - val_loss: 0.7941\n", + "Epoch 6/100\n", + "498/498 [==============================] - 23s 45ms/step - loss: 0.8891 - val_loss: 0.6393\n", + "Epoch 7/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.7451 - val_loss: 0.5670\n", + "Epoch 8/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.6231 - val_loss: 0.5043\n", + "Epoch 9/100\n", + "498/498 [==============================] - 22s 44ms/step - loss: 0.5347 - val_loss: 0.4431\n", + "Epoch 10/100\n", + "498/498 [==============================] - 29s 58ms/step - loss: 0.4694 - val_loss: 0.4051\n", + "Epoch 11/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.4273 - val_loss: 0.3923\n", + "Epoch 12/100\n", + "498/498 [==============================] - 22s 43ms/step - loss: 0.3658 - val_loss: 0.3645\n", + "Epoch 13/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.3459 - val_loss: 0.3111\n", + "Epoch 14/100\n", + "498/498 [==============================] - 23s 46ms/step - loss: 0.3083 - val_loss: 0.4242\n", + "Epoch 15/100\n", + "498/498 [==============================] - 24s 47ms/step - loss: 0.2930 - val_loss: 0.3382\n", + "Epoch 16/100\n", + "498/498 [==============================] - 22s 44ms/step - loss: 0.2523 - val_loss: 0.3169\n", + "Epoch 17/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.2442 - val_loss: 0.3462\n", + "Epoch 18/100\n", + "498/498 [==============================] - 21s 43ms/step - loss: 0.2535 - val_loss: 0.4511\n", + "Epoch 19/100\n", + "498/498 [==============================] - 23s 46ms/step - loss: 0.2347 - val_loss: 0.3736\n", + "Epoch 20/100\n", + "498/498 [==============================] - 22s 44ms/step - loss: 0.2096 - val_loss: 0.3644\n", + "Epoch 21/100\n", + "498/498 [==============================] - 23s 47ms/step - loss: 0.2080 - val_loss: 0.4305\n", + "Epoch 22/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.1874 - val_loss: 0.3905\n", + "Epoch 23/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.1835 - val_loss: 0.2836\n", + "Epoch 24/100\n", + "498/498 [==============================] - 22s 44ms/step - loss: 0.1564 - val_loss: 0.3313\n", + "Epoch 25/100\n", + "498/498 [==============================] - 21s 43ms/step - loss: 0.1750 - val_loss: 0.3248\n", + "Epoch 26/100\n", + "498/498 [==============================] - 22s 44ms/step - loss: 0.1797 - val_loss: 0.2985\n", + "Epoch 27/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.1588 - val_loss: 0.3010\n", + "Epoch 28/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.1469 - val_loss: 0.3371\n", + "Epoch 29/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.1814 - val_loss: 0.3944\n", + "Epoch 30/100\n", + "498/498 [==============================] - 21s 43ms/step - loss: 0.1236 - val_loss: 0.3072\n", + "Epoch 31/100\n", + "498/498 [==============================] - 22s 44ms/step - loss: 0.1224 - val_loss: 0.3949\n", + "Epoch 32/100\n", + "498/498 [==============================] - 22s 45ms/step - loss: 0.1378 - val_loss: 0.4653\n", + "Epoch 33/100\n", + "498/498 [==============================] - 21s 43ms/step - loss: 0.1348 - val_loss: 0.3056\n" + ] + } + ], + "source": [ + "epochs = 100\n", + "early_stopping_patience = 10\n", + "# Add early stopping\n", + "early_stopping = keras.callbacks.EarlyStopping(\n", + " monitor=\"val_loss\", patience=early_stopping_patience, restore_best_weights=True\n", + ")\n", + "\n", + "# Train the model\n", + "history = model.fit(\n", + " train_dataset,\n", + " validation_data=validation_dataset,\n", + " epochs=epochs,\n", + " callbacks=[early_stopping],\n", + ")" + ] }, { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:tensorflow:Assets written to: captcha_75_25.tf/assets\n" - ] + "cell_type": "markdown", + "metadata": { + "id": "1EpbnVEEvl9a" + }, + "source": [ + "## Inference\n", + "\n", + "You can use the trained model hosted on [Hugging Face Hub](https://huggingface.co/keras-io/ocr-for-captcha)\n", + "and try the demo on [Hugging Face Spaces](https://huggingface.co/spaces/keras-io/ocr-for-captcha)." + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": { + "id": "8_xv3ktTvl9b", + "outputId": "19ac5608-fbb5-4603-ede8-1a1f15ec6234", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Model: \"model_6\"\n", + "_________________________________________________________________\n", + " Layer (type) Output Shape Param # \n", + "=================================================================\n", + " image (InputLayer) [(None, 300, 80, 1)] 0 \n", + " \n", + " Conv1 (Conv2D) (None, 300, 80, 32) 320 \n", + " \n", + " pool1 (MaxPooling2D) (None, 150, 40, 32) 0 \n", + " \n", + " Conv2 (Conv2D) (None, 150, 40, 64) 18496 \n", + " \n", + " pool2 (MaxPooling2D) (None, 75, 20, 64) 0 \n", + " \n", + " reshape (Reshape) (None, 75, 1280) 0 \n", + " \n", + " dense1 (Dense) (None, 75, 64) 81984 \n", + " \n", + " dropout_9 (Dropout) (None, 75, 64) 0 \n", + " \n", + " bidirectional_19 (Bidirecti (None, 75, 256) 197632 \n", + " onal) \n", + " \n", + " bidirectional_20 (Bidirecti (None, 75, 128) 164352 \n", + " onal) \n", + " \n", + " dense2 (Dense) (None, 75, 24) 3096 \n", + " \n", + "=================================================================\n", + "Total params: 465,880\n", + "Trainable params: 465,880\n", + "Non-trainable params: 0\n", + "_________________________________________________________________\n", + "1/1 [==============================] - 1s 1s/step\n", + "['JSMYJY', 'JSMYJY']\n", + "['JNKSK ', 'JNKSK ']\n", + "['RHMMVG', 'RHMMVG']\n", + "['NNXY0 ', 'NNXY0 ']\n", + "['YPMTNN', 'YPMTNN']\n", + "['WDKJTX', 'WDKJTX']\n", + "['JYRGNS', 'JYRGNS']\n", + "['PSDD0 ', 'PSDD0 ']\n", + "['KKPPV ', 'KKPPV ']\n", + "['AW2GPD', 'AW2GPD']\n", + "['D0VSJ ', 'D0VSJ ']\n", + "['ST2VWP', 'ST2VWP']\n", + "['4VHHN ', '4VHHN ']\n", + "['TWTNSK', 'TWTNSK']\n", + "['JXYARA', 'JXYARA']\n", + "['8KNRGD', '8KNRGD']\n", + "1/1 [==============================] - 0s 33ms/step\n", + "['PGYYXT', 'PGYYXT']\n" + ] + }, + { + "output_type": "error", + "ename": "IndexError", + "evalue": "ignored", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 66\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mpred\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcomp\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 67\u001b[0m \u001b[0mtitle\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34mf\"P: {pred} T: {comp} ({dist})\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 68\u001b[0;31m \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m \u001b[0;34m//\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mimg\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m\"gray\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 69\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m \u001b[0;34m//\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mset_title\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcolor\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'green'\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mcomp\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpred\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0;34m'red'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 70\u001b[0m \u001b[0max\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mj\u001b[0m \u001b[0;34m//\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mi\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"off\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mIndexError\u001b[0m: index 4 is out of bounds for axis 0 with size 4" + ] + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ4AAAGbCAYAAACF5lr+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOydd1gUydPHv0sGyQhIRuUUFRUVc+TMGc9wRhQzeqY7L3ieijkH9Mw5nxEVc8CMAUURAxhARSRKzqneP3h3fgy7ywbARezP89Sj9HSo6Zmt6anprhYQEYHBYDAYDAaDwWAwGAwGg8EoY1SUrQCDwWAwGAwGg8FgMBgMBqNywhxPDAaDwWAwGAwGg8FgMBiMcoE5nhgMBoPBYDAYDAaDwWAwGOUCczwxGAwGg8FgMBgMBoPBYDDKBeZ4YjAYDAaDwWAwGAwGg8FglAvM8cRgMBgMBoPBYDAYDAaDwSgXmOOJwWAwGAwGg8FgMBgMBoNRLjDHE4PBYDAYDAaDwWAwGAwGo1xgjicGg8FgMBgMBoPBYDAYDEa5wBxPDEYp6HGwB8adGadQ2RY7WuCPK3+UsUYMBoMhG8x+MRgMxv94GPkQGgs18CHpg9xlL769CN0luohLjysHzRgMRmUnLScNZivNcPDZQbnLfsn4gipLquD8m/PloFnZ8U06nvY83QPBfAEnWou0UGtDLfxy/hfEpMUoVOeN9zcgmC/A8ZfHeenBMcEYcHQA7NbZQWuRFqzWWKHz/s7Y8GADL5/9OnsI5gvQaV8nsfVvf7yd0/fR50fIzc9F/c31UXN9TWTmZorkf5/0HjqLdTDw2EDeOStStjgd9nTg9Z8k8brhJUvXcXU6bXLipeXk58D7vjcabW0E/aX6MFxmiHqb6mG873iExIdw+Ypezzsf74jUTUSwWWsDwXwBeh3qBQD47/l/EMwXYOujrWL18TzrCfWF6giKDgJQeH0ULSuJux/v4vK7y/izzZ+89AIqwIq7K1Dduzq0FmmhweYGOBx8WKT8n63/xMaAjYhOiy6xHUbl4mvZL2E7Wou0EJkSKVJG3G+26O+kKPuD9kN1gSq6HeiGrLwsAIUPyHnX58FpkxOqLKkCkxUmcN7ijGkXpuFz6meurNcNLwjmCxCfEc+rMyI5AjXX14TxcmMERgXKfK5fy34JbfqU81NE8pfU348+P+LlTc5KRrPtzaC1SAsX317k0u98vIPuB7vDao0VtBZpwXatLXof7o1DwYd45QXzBfjl/C8iOiy5vQSC+QKMPj0aBVQg87kKYfar8lKeNkYoqgtUYbbSDAOODsCruFci+UedGgXdJboS6yt+X79Pes/VvejWIrFlhp0cBsF8gUi9Qpvww4YfxJa78u4KV7fwN9vncB/oLNZBanaqRB2HnRwGjYUa+JLxhUvLzsvGhgcb0GZXGxgtN4LGQg1YrrZEn8N9cDj4MPIL8iXWJ7SF0qTDng4S65BWp/pCddivs8fUC1ORlJUkkl+SjQdKtmvyjM+ECMuNPTNWbHuzr83m8sRnxCM3PxdVV1RFm11tJJ6vsL3GWxvz0mPTY/HX1b9Qf3N96C7RhdYiLTisd4DHaQ+xektitt9sDKk/BHaGdrz0V3Gv0O1AN+gu0YXxcmOM8Bkh4mDq5tANDsYOWHpnqcztMcqO8rZ7jz8/Fjkuzs4J7VHvw71F8gvt3Cr/VVzaP37/QDBfgBvvb4jkF76v/PvwX9yLuAeV+SqYdXWWWF2X31kOwXwBzr0+x6XJct/KQvG+lST26+zlrlPeMao847LhJ4dDa5EWXn95LZJ/2Z1lEMwX4Ozrswq9F/pH+KPNrjbQWayDaquqYeqFqUjLSZP5/MXhfd8bepp6GOw0mJeelJWE8b7jYbrSFFWWVIHrXleRcbOJjgnGNhqLOdfnlEqH8kZN2QqUhgUdFqC6UXVk5WXhzsc72PxoM86/OY/nk55DR12n1PX7R/jDda8rbA1sMa7xOFTTrYaI5Ajcj7wP7wfemNKcf+NrqWnh+vvriE6LRjXdarxjB4MPQktNi3tpU1dVx7Ze29B6V2ssvLUQSzou4eX/5fwv0FDVwPpu60X0Kk1ZAJjddjbGNv7fQCAgMgDrH67H323+Rh3TOlx6A/MGMvSSZPof7Y8Lby5gSP0hGNd4HHLzcxESH4Kzb86ilU0rOFZ15OXXUtPCoeBDaGPLH3Tc/HATn1I+QVNVk0sb7DQYe4P24q9rf8HN0Q3muubcsYeRD7EtcBt+a/kbGlZrKKJXacoWZaX/SnSs0REOxg689NnXZmPZ3WUY13gcmlo2xenQ0xh6cigEAgHPmPR17At9TX1sCtiEBa4LSmyLUfkob/slJDs/G8vuLMOGHhukZxbDwWcHMer0KHSq0QmnBp+ClpoWcvNz0W53O4TEh2Bkw5GY0mwK0nLS8CLuBQ49P4R+dfrBUs9SYp2RKZFw3euKhMwEXB1xFY0tGkvMW5yvZb+EbA/cjlltZ5V4PpJIyU5BlwNd8CzmGXx+9kE3h24AgGMvjuHn4z/DuZozpjWfBiMtI4QnhePWh1vYHrgdQ+sPLbHeZXeWYbbfbIxsOBI7+uyAikD+b0jMflV+ysPGTG02FU2tmiI3PxfPYp5hy+MtuPH+Bp5Pei4y7lEELTUtHH5+GP+0+4eXnp6TjtMhp6GlpiWx3NuEt3gY+RDNrJrxjhUffwHAsPrD4PvaFz4hPnBv6C5SX0ZuBk6HnEY3h24w0TEBAMSlx6H7we54HPUYXWt2xT9t/4GxtjGi06JxNfwqhp4circJbzGnvfiB/091fuL93tJy0uB5zhP9HPvhpzo/cenmVczFFS+RzT03Q1dDF+k56bgWfg0bHm5AYFQg7oyW3elSEvKMz4qXO/HqBDb13AQNVQ3escPPD4uMiwfWHYitj7fiQ9IHEecPANz6cAufUj5hRosZXNrDyIfoeagnUrNTMdhpMCY2mQhNNU2EJ4bjVOgp7Hm6BzdH3UQ7u3YlnuPT6Ke4GnYV/qP9eemfUj6h3Z52MNA0wJKOS5CWk4ZV/qsQHBOMh+Me8s5rQpMJmHllJuZ3mA89Tb0S22OUD+U1tvK66QXfIb4y5z/7+iwef36MJpZNSsz3T7t/8N/z/zDx7EQ883zG3U9JWUmYcWkGmlo2xaSmk6AiUMGEJhOw+t5qDG8wHPXM6nF1fEj6gAW3FmBg3YHoWasnAPnuW2m0s2uH/f3289LGnhmLZlbNML7JeC5NV0PyxwZJKDJGlXVctqbrGpx/cx4Tz06E30g/Lj08MRwLbi5A/zr90atWocNcnvfCp9FP0XFfR9SpWgdruq7Bp5RPWOW/Cm8S3uDCsAvynD5Hbn4uvB94Y0aLGVBVUeXSC6gAPQ/1RFB0EH5v9Tuq6lTFpkeb0GFPBzwe/xg/mPzvg8tEl4lY/3A9/ML98GP1HxXSo9yhb5DdT3YTvEABkQG89F8v/krwAh16dkjuOq+HXyd4gY69OMal9TjYg0xXmFJiZqJI/pi0GN7fdmvtqOPejqS/VJ/W3VvHOxaRHEEq81Wo/5H+Inp7nvUk9QXq9DzmOZd2/MVxghdo08NNJZ6zrGWlcezFMYIX6Hr4dZnLFKf97vZUb2M97u+Hnx4SvECLby0WyZuXn0fx6fHc38Jz++nIT1R1RVXKzc/l5R93Zhw12dqE7NbaUc+DPbn08MRw0lmsQ0OOD+HV7bzFmezX2VN6TjqXXpqy4ohJiyG1BWq04/EOXvqn5E+kvkCdJp+bzKUVFBRQ211tyXqNNeXl5/Hy/3LuF7Jba0cFBQUltseoPHwt+yVsx3mLM2ku1KTIlEhemeK/WSLR38nh4MOkOl+VOu3rRJm5mVz60edHCV6gg88OiuiSmZtJyVnJ3N/zrs8jeIHi0uOIiCgyJZJ+WP8DGS4zFOkDRSgP+0VU2Bf1NtYjtQVqNOX8FN6xkvpbeE4pWSnUYkcL0lioQWdDz/LK191Yl+ptrEfZedkiuhR/tsALPHuy4s4KghfI3ced8gvyFTpfZr8qN1/LxhARbQ7YTPACLb+znJc+0mckVVlcRWJ9xe/r8MRwbhwAL9DTqKe8/AefHST1BerU+1BvkXqFv9/aG2rT9AvTeccyczNJf6k+N/4S6p+Rk0F6S/So6/6uYvU79OwQwQv0X/B/XFrX/V1JZb4KnXh5QmyZgMgAOhB0QOI5FycuPY7gBZp3fZ7MZYpT3L4K+fnYzwQv0INPD3jpxW18UUqya/KOz4gKr7Hbf26kMl+FTr06xTt29+Ndghe46yLU//aH2wQv0NLbS8XqOP7MeFKZr8I9zxIyEshilQVVW1WNXsW9EslfUFBAh54dooefHoqtryhTz08l27W2IvbM86wnaS/Spg9JH7i0K++uELxAWx9t5eWNSYsh1fmqtDNwp9T2GGVLedo95y3OBC/Q48+PecfF2bn2u9uT7VpbMlpmRL0P9eYdE9q5lXdX8tIvv71M8AJ5Xffi0ib4TiDV+ar0JOoJl5aUmUQWqyyo9c7WvPu096HeZLDUgD6nfObS5LlvFaHK4io00mekwuUVHaPKMy4jItr2aBvBC7TnyR4urduBbqS/VJ8+JX/i0uR5L+x+oDtZrLLgjXW3P95O8AJdentJgd4gOvnyJMEL9PbLW176kedHRM4rNi2WDJcZ8nQV4rTJiUacHKGQDl+Db3KpnSSE3r3wpHAu7V3CO7xLeKdQfe8S3qGeWT0YahmKHDOrYiaSpqWmhZ/q/IRDz/lLJQ4HH4aRlhG61uwqUmZpx6WoqlMVE89NBBEhLScN0y9NR0vrlpjoMrFE/UpTVhaSs5IREh+C5Kxkucu+Syzs89Y2rUWOqaqocl8QizLEaQi+ZHzBlXdXuLSc/Bwcf3lc7AwAe0N7eLX3wuHnh7ky6x+sx9Pop9jcc3OJXzZKUxYAzr0+h7yCPHSqwV9aeTr0NHILcjGp6SQuTSAQwNPFE59SPuHep3u8/J1rdsaH5A94Gv20xPYYlZ+ytl9C/m7zN/IpH8vuLJOr3NEXRzH85HB0sO+AM4PP8GYalPT71lLTgr6mvtg6o1Kj4LrXFbHpsbg8/DJcLF3k0kkeSmO/hNgb2sO9gTu2B27nLR+URlpOGrod7IbAqECcGHSC+wIp5F3COzS1air2i6O4Z4uQNffW4I+rf2B4g+HY3Xe3QjOdAGa/vlfKw8a0tW3L1VMWtLRuieqG1UWWnB4MPohuDt1grG0ssewQpyE48uIIb+mpb6gvMnIzMKjeIF5ebXVt/FTnJ1wLv4bY9FiRug49PwQ9DT30qd0HAHAv4h4uvbuE8Y3H82YnFcXF0gXDGgyT+VwlIZwdHpUapXAdZX1d5B2fCbHSs0I7u3Yi4+KDzw6ivll9OJnxl9K0tmkNe0N7kesPFPbL8VfH4Wrvys102PJoC6LSorCu6zqRWfRAof0aUn8Imlo1lXqOp0JP4cfqP0IgEPDST7w6gV61esHWwJZL61SjE2qZ1MLRF0d5ec2qmKGBeQOcDj0ttT3G16Es7N6UZlNgpGUk8xJ+PQ09zGgxA76vfWUKJdC5ZmcMrT8US+8sxesvr3Ev4h62Pd6Gac2nwbmaM5fPQMsA3t28cTfiLnYE7gAA+Lzyge9rXyzrtAwWehZcXnnu27IkJD4EH5M/ypxf3jGqvOOysY3HorVNa8y8MhNfMr7gv+f/4eLbi1jkughW+la8emV5L0zJTsGVsCsY3mA4b6zr3tAduhq6CvftqdBTsDe0R03jmrz04y+Pw7yKOe+5Y1rFFIPqDsLp0NPIzsvm5e9cozN8X/uCiBTSo7ypVI4n4cuQifb/nBod93VEx30dFarPztAOjz8/xvPY5zKXGeo0FA8jH/IM2qHnhzCg7gCoq6qL5DfQMsD67utx5+Md7AjcgTl+cxCTFoNtvbeJPPzKsqws+IT4oM7GOvAJ8ZG7rJ1B4RTpg8EHkVeQJ1MZe0N7tLRpicPP/xdP5MKbC0jOThZZ7ypkRssZaGjeEJ7nPPE24S3m3piLwU6DuSUtJVGasv4R/jDRNhGZCv4k6gmqqFdBnap1eOnCqf9Pop7w0ptYFE7BvRtxV2qbjMpNWdsvIdWNqsvtPDnx8gSGnRyGdnbt4DvEF9rq2rzjwt/3vqB9Mj/cYtJi8OO+HxGdFo1Lwy/J9CJQGkpjv4oyu91s5BXkyTwoSs9JR/eD3REQGYBjA49x07iLYmdoh2th1/Ap5ZPMenjf98Zvl3/D0PpDsafvHoWdTgCzX98r5WFj3ie9BwAYaRuJPR6fES9WSmKI0xD89+I/zrbEZ8Tj8rvLUpegDq0/FFFpUbxYKYeeH0LH6h3FOnSH1R+GvII8kReFhMwEXHp7Cf3q9ONsn+/rwiU2wxsML1GHsiAyNRJ1NtbBrGviY7nIQknXJbcgV+w1KclJr8j4TMhQp6HwDfXl4p/kFeTh2MtjYq+nQCDAUKehCI4NxovYF7xjF99eREJmAobV/59zz/e1L7TVtCU6A2UlMiUSH5M/onG1xiLpsemxYj+SNLNqhifRT0TSm1g0gX+Ev0g6QzmUhd3T19SXy5EEANNaTJPLWbWmyxroqOtgwtkJmHB2Aqz1rTHfdb5IvoH1BqLnDz3x59U/EZYYhmkXp6GVTStMaDKBy6PIfVtW1NlYB+4+osuXJaHIGFWecZlAIMDWXluRnJUMz3OemHFpBlwsXTC52WSRvLK8FwbHBCOvIE+kbzVUNeBczVnhvvWP8BcbduJJ9BM0tmgsMuZrZtUMGbkZIvGrmlg0QVJWEl7E8e1nReGbdjwlZyUjPiMen1I+4cjzI1hwcwG01bTFDvQVYWbLmcjIzYDzFme02tkKf175E5ffXUZufq7EMj9W/xHVdKtxD+dXca/wNPppiQOmAXUHoFetXvj9yu/Y8HADZraaKfIVqDzKlictrFugvV17bA/cDus11hh6Yig2BWyS6gUf6jQUp0JOcUHTDwYfRHu79hLX8aqpqGFb720ITwpH8x3NoaaihnVd18mkY2nKhnwJgb2hvUh6VFoUzHXNRRx/wq8QxY2qlb4VNFQ18DLupUztMioP5W2/iiJ8SC+/s1xq3ifRTzD4xGC0sW2Ds0PPijidAMDN0Q21TWpj7o25qO5dHR6nPbDryS6xMweE9DzUE59TP+PS8Etobt28VOfzNalhVAMjGozA9sDtMs1AGHlqJB58eoBjA49xsyWK82frPxGRUhhc/ce9P2Lu9bm48/GOxCDhZ1+fxfRL0zHEaQj2ue3jrf9XBGa/vg/Kw8akZqciPiMeUalRuPT2EqZfmg4BBOhfp79I3vTcdJiuNBUrJTG0/lB8TP7IOTSPvjgKLTUtib8nIT+Y/AAXSxdutkxSVhLOvzkvcfz1Y/UfYaFrITK75tiLY8gtyOU5OIQbohQfX2XlZfGcN+ICen8NEjITEJ8Rjw9JH7D7yW5sDNgIUx1TsXGNLr+7LPaauB1xK7ENecdnQgbUHYB8ysepkFNc+/EZ8RjiNERsfuGssYPB/J2dDj0/BC01LfSv+797LSQ+BLWr1hb5sCu8T4WSnpNeoo7C61vdqDovPSqt0OZb6FqIlLHQtUBCZoLIjIMaRjUQnxFf4vOQUX6U19hqavOpMNIywvybos4gcehr6mN6i+kyO6vMdc2xrNMy3Hh/A8GxwdjQfYPEmEkbe2xETn4Omm5viui0aGzttZX33FbkvlUm8oxRAfnHZfXM6mFmq5k49vIY4tLjsLXXVrEf72R5L5TWt/LMjheSV5CHdwnvUN2wusixqNQo8W1JGJfVMKoBABV2XPZNO5467e8E05WmsFlrg8EnBkNXQxc+P/vwps69n/4e76e/V6j+zjU7496Ye+hTuw+CYoKwwn8Fuh7oCqs1VjgTekZsGVUVVQyqO4hzPB0MPggbfRtu2rMkhEbExsAGc9rJF5G+NGVLYpTzKNA8wijnUXKXFQgEuDT8Eha5LoKRthEOPz+Myecnw26dHX4+/rPEwdmgeoOQmZeJs6/PIjU7FWdfn5X6lbOZVTNMbDIRCZkJWNpxKS8onDQULfsl44vYL4mZeZlig2wKlyll5onuQmikZST1CzCj8lHe9qsowof0tsBtUh/SCZkJyCvIg7W+NbTVRJ1OQOEylQdjH+D3Vr8DKNydZMyZMbBYbYEp56eIHdDEpMdAV0NX7AO0PCiN/SrOP+3+kfnrWkx6DLTUtGBjYCMxz+hGo3Fx2EV0sO+AOx/vYOGthWi7uy1+2PCD2C/lMemFO/JUN6xeaqcTwOzX90J52JjRZ0bDdKUpLNdYotvBbkjOSsb+fvvFzmDUUtPClRFXxEpJ1DOrhwbm/9tN8VDwIfSt3VemwMBDnYbi5KuT3DIwVYEq+jn2E5tXVUUVg50G496ne9wMIaDQwWFexRwdq/9vRkRKdgoA0eC5Wx5t4TlvStqRTVbsDe1B8wh73PbIXKb2v7VhutIU9t72GH1mNByMHXBh2AWxfdbcqrnYa7Kq8yoxNf8PRcZnQOGsq24O3bhx8aHgQ2hl00ps8HAAqGtaF42qNcJ/z//j0tJz0nEm9Ax61erFW96Skp0i9uV8hM8I3nX58+qfInmK8iWzcOdCIy2+XRQ62TTVZLeLQtvK7KJyKK+xlYGWAaa3mI4zoWdEZv9KQrh5iKzOqqo6VQEAOuo6IoH8i2JnaId57echITMBv7b8VcQhrsh9W1bQPMKNUTfkKiPPGFWIPOMy4H99a6lnWeIEDWnvhdL6Vtxu89JIyEwAgUTsD/D/47JKZH++acfTxh4bcWXEFVwfeR0vJ71E2LQwdHUQjaNUGppaNcXJn08i8c9EPBz7ELPazEJqTioGHB0g0Zs4tP5QvIx7iaDoIBwKPoTBToOlLn2zNbCFWRUz1DOtJ3aGQXmVLU801TQxu91svJr8Cp9//YzD/Q+jhXULHH1xVOz24EDhutVONTrh0PNDOPnqJPIpHwPqDpDalnDQq0jMGEXLiltipK2mjex80Zdu4a4t4l7kCVQmSyMZ3xZfw34VRdaHdMfqHeHp4okDzw5g+sXpEvMZaBlgRecVhQO4ae+xs89O1DapjX8D/sXCWwtF8h/odwAJmQnovL/zN/clWJ5B0dZeW6GhqoFuB7ohND5UYr6uDl1xafglJP2VhFujbmFy08n4kPQBvQ71EumfkQ1Honet3lhyZwnW3ltbJufE7FflpzxszNx2c3FlxBX4/Fy4G1xydrLEZZ+qAlV0qtFJrEhjqNNQHHt5DG8T3sI/wl8mBwdQuGttcnYyLry5gIPBB9GrVq8SdxcTzmoSznr6lPIJtz/cxmCnwTwnr7CO4ttl96/Tn3PclNVOmopwYtAJXBlxBYd+OoQW1i0Qmx4rcTxYVaeq2GsibfctRcdnQOH1vPLuCj4mf8SpkFNSr+ew+sMQnhTOOeJPhZxCRm4GbxYaUHhdxG1hvsB1gUxOzuIQ+HZR2IfiPqZIsotC2yoAs4vKoDzHVtOaT4OhliG8bnrJlF8eZ1VqdiqmXpiK2ia1kZOfI9VZWtK7iyL3rbKR15Ekz7gsIjkC827Mg5OZEyJSIrDi7ooS85emb0vzHl7c/gD/Py6rRPbnm3Y8NbNqhk41OqGDfQfUMa1TqpgX0tBQ1UBTq6ZY0nEJNvfcjNyCXBx7cUxs3ubWzVHTqCamX5qO8KRwmQdMlRkLPQsMdhqMW6Nu4QfjH3D0xVGJsZ+GOg3FhTcXsOXxFnR36C42uLuyMdExQWJWoki6ha4FotOiRV7qhEZR3JT0pKwkVNWuWj6KMiosX9N+AYUP6eENhsv0kP63x78Y7DQY6x+ulyk+gZ2hHUY3Go27o+/CUMtQZIkEALS3b4+jA44iPCkcXQ90LVXQb2Uwu+3/TwW/W/JU8LqmdXF+2Hlk5mWi8/7OiEiOKDG/jroO2tq1xb89/sU/7f5BYlYiLrzhb8erpqKGowOPor1de/x2+TfsfrK7VOfC7Nf3QXnYmPrm9dGpRie4Obphr9te9KndB+N8x0m9z+VlSP0hiM+IxzjfcTDRMUGXml1kKmehZ4EO9h2w+t5q3PpwS+r4q4llEzhWdeRm4xwOPgwCiTg4HE0KA1cXj/lpY2DDOW7Efa3+WrSza4dONTphSP0huDLiCrTVtTHs5DCJy3cVRdHxWZ/afaCppomRp0YiOz9bJNh7cYbUHwIVgQrnEDz0/BCMtIzQ44cevHyOVR0RGh8qEgKjgXkDmZ2cwP/i/yRm8u2icIaucHlNUaLSomCsbSwyG0FoW4UzLBhfl/IcWxloGWB6c/lnPRlqGUqd9TTbbzai06JxqP8hzGgxA7ue7MLdj4rFT1TkvlU28oxRhcg6LvvlQuFkhwvDLmBg3YFYfHsxwhLDFNJTWt9KW3osDmNtYwggELE/QOEzTWxbEsZlFd3+fNOOJ2Uh9ICKuxGEDHEaghvvb6BO1Tq8HQm+d9RV1dHAvAEX3FIc/er0g4pABfc/3a+wTjtHE0eEJ4aLpDtXc0ZGbgZexb/ipT+IfMAdL0pkSiRy8nNQx5QfzJfBKA/+afuPTA9pFYEK9rntQ3eH7ph/cz7WP1gvU/1G2kaoaVRT4qChd+3e2NVnF4Kig9DrcC+FpiQri5rGNTG8wXBsfbxV6qComVUznPr5FGLTY9F5f2fEpcfJ1EZJzxYtNS2cGXIGjSwaYZzvOPi8UjxoOrNfjLJiWcdlyMrLwuLbi8u0XlsDW7S2bY0b729gYN2BUFNRk7nsUKehuP3xNvQ19UUcFeIYVn8Ynsc+x7OYZzj0/BB+MP5BZOmgMD6MOKd6RUNXQxfz2s/D0+inZb57laLjM211bbg5uuHG+xvoXKOz1JciSz1LuNq74tjLY4hJi8GVd1cwoO4AkZ1Ae/3QC5l5maXeREK4I17Rnc+Awjh2pjqmePT5kUiZh5EPxY7vwxPDUVWnKkyrlBzLjPFtMr3FdJkcSUKEzqrToaclOqsefX6EjQEb8UuzX9DYojHmtZ8HGwMbTDw3UeYNmoqiyH1bEZB1jCpElnGZzysfnAk9g4WuC2Gtb4113dZBQ1UDk8+LBheXBSczJ6ipqIn0bU5+Dp5GP4WzubPcdaqpqKGmcU0R+wMUjrsCowJFPiI8iHwAHXUd1DKpxUsXju0q6ris0jueSrNV8PXw62KXI5x/cx4AUNuktsSyYxuPxbz287C6y2qF2q4IlGY78jdf3ogNJJ6UlYR7n+7BSMsIpjriH8q6GrrY3HMzvNp7oXet3nK3/TVoadMSiVmJIh7zvo59oa6ijk0Bm7g0IsKWR1tgpWeFVjatePkfRz0GAJF0BgMo/VbnxSn6kI5Oiy4xr7qqOo4POo7WNq0x/eJ07A/azx0Lig4S6zj+kPQBL+NeonZVybZxRMMRWNdtHe58vIP+R/uXuFlDaSiN/ZLEP23/QW5+Llb4lzxNGwA61uiIw/0P423CW3Q72I2LEQMA18KuiS0j7dmir6mPi8MuwsHYAUNODJFYjzSY/WIIKa2NqWlcE/3r9seep3uk2hR5WeS6CPPaz8OUZlPkKjeg7gDMaz8Pm3psEnFUiEM4u2nu9bl4Gv1UZLYTALS2bY3ONTpj2+NtOB1yWmw94pZJKEJufi5C4kNk/uovjmH1h8Fa31rmFzhZKc34bGbLmZjXfp7MsUiH1R+G2PRYTDg7QSTYuxDPpp4wr2KOGZdmiOzuBIhfUiwOK30r2OjbiH1R71+nP86+Psub1Xct7Bpef3mNgXUHiuR/HPUYLa1bytQuQzmUxu4VdSQ9jX4qUxmhs2rBrQUix/IL8jHh7ARY6FpgoWthmIIqGlWwofsGPI99rvDyennv27IiJD5E6kZSkpBnjCqkpHFZanYqpl6cikbVGnHPEUs9Syx0XYiLby9KXLlUEgZaBuhUoxMOPDuA1OxULn1/0H6k5aRhYD3F+raldUux9mdAnQGISY/ByVcnubT4jHgce3kMvWv1Fpm59jjqMQw0DVDPtJ5CepQ3sn9C+kYRbpepSIDeKRemICM3A/0c+8GxqiNy8nPg/8kfR54fgb2hPTwaeUgsa2doB68OXgpqXTHwCfGBx2kP7O67W+4AvUExQRh6Yii6/9AdbW3bwljbGJEpkdgbtBefUz9jXdd1JQbJHek8spTaly89f+gJNRU1XA27ivFNxnPp1vrWmN5iOlb6r0Rufi6aWjXFqZBTuP3xNg7+dFDknK+8uwJbA1s0qtboa58C4xugNPZLErPbzsb+oP0I/RIq9cGko66Dc0PPof2e9hh9ZjQMtAzQp3YfXAm7gnk35qFP7T5oYdUCuhq6CEsMw66nu5Cdnw2v9l4l1ju1+VQkZCZg/s35cD/ljoM/HSzzpYalsV+SEA6K9gbtlSl/vzr9sL33dow+Mxp9DvfBxeEXoaWmhb7/9UV1o+roXas3ahrVRHpuOq6GXYXva180tWyK3rUlv9CZVjHFlRFX0HpXa7gdccM192toZtVMrvNg9oshpCxszO+tfsfRF0ex7v46LOskW3wOWWhv3x7t7dvLXc5Ay0Cu8Vd1o+poZdMKp0MLHUrCXdWKc+CnA+h2oBvcjrihu0N3bnlddFo0roZfxa0Pt9Ddobvc+hYnMjUSdTbWwciGI+UKMF4UdVV1TGs+Db9f+R0X317kbQdeWhQdnzWs1hANqzWUOX//uv0x6fwknA49DRt9G7E79BlrG8PnZx/0PtwbDbc0xGCnwWhq2RTqKuqISInAsZeFL5a2BrZS2+tbuy98QnxAxI9b93fbv3Hs5TG47nXFtObTkJaThpX+K1HfrD48nPnvAbHpsXgW8wyTmyo2m4LxdSit3ZvWYhrW3l+LoJggVFGvIjW/gZYBpjWfJnaW1PoH6xEYFYgTg07w4tH1qd0HfWr3wfyb8/Gz088y3cNFkee+LUvqbKyD9nbt5Q4wLkSeMSpQ8rjsH79/8Dn1M04OOskbv0xuOhl7g/Zi+qXp6ObQrcQ4gOJY/ONitNrZCu33tMf4JuPxKeUTVt9bjS41uyhsa/vW7ov9z/bj9ZfXvFlMA+oOQIsHLeBx2gMv416iqk5VbArYhPyCfMzvIHo/XQm7gt61e1fY2JuVfsaTrAi/iqgK/ndjruqyCq72rjj/9jx+vfwrfr38Kx5GPsSkppPwYOyDrxp7SJx+FQkC8X7U7ezaYaHrQiRnJWPNvTWYcHYC1t5fCztDOxwfeBzTWkxTqn6lxVzXHD1+6CF2GvuyTsuw5McluPTuEiafn4z3Se9xoN8BkWnpBVSAE69OwL2Be4U1EIxvA3nsg4OxA4Y3GC5z3QZaBrg0/BLsDe3x8/GfceP9DfSv0x8zW87E+6T3WHJnCSaem4jtgdvRxKIJro64in51xO8iVRSvDl6Y0mwK/nv+HyafU+4gXR778E+7f+Sywx6NPLCq8yrc/HATA48NRF5BHnb02QEnMyccfXEUUy5MwZ9X/8S7xHeY3XY2rrlfk7qsyMbABpdHXIaWmha6H+yOF7EvZNYHYPaLUba4WLqgg30HbH60+ZuL3SZEOJummVUzOBg7iM1jVsUM/mP8sa7rOiRlJWH+zfkYf3Y81j9cDx11HRz86SB8h/h+TbVLZHyT8TDQNJA5WG9FQ19Tn5tVNcRpiEQ709KmJZ5Peo4pzabgYeRDzLw8E1MuTMHB4INoZtUMt0bdwh+t/5Da3uhGoxGZGom7Efy4OjYGNrg56iZqGtfEX9f+wgr/FejxQw9cGXFFZLbByVcnoammKTWGFePbxlDLENNbTJerzPQW02GgacBL+5TyCXNvzEWvWr3wU52fRMps6L4BQOFECHmR576tSMg7RgXEj8sef36MjQEbMcllksjSaVUVVWzpuQXRadH4x+8fuXVsbNEYV92vQltdGzMuzcC2x9swptEYHB94XO66hPSu3RtVdaqKjMtUVVRxfuh5/FzvZ6x/sB6/X/kdVXWqwm+kn8jqgpD4EDyPfY5RDUcprEd5IyBZ56FWcs6EnkHf//ri6oir6Fijo/QCX5n1D9Zj2sVpeDvlLWoa11S2OiI03toYVTSq4LbHbWWrIhbj5cboWasn9vfbLz2zjNz+cBsd9nZAyOQQ/GDyg9zlT4WcwtATQ/Fu6jtY6H2dLeYZlZOKbr8qOhXdfpUHzH4xGAwGn477OsJSz1LhsWKjrY3Qwa4D1nYrm91HGQzG98PCmwux++luvJnyRqHJEtMvTsetD7fwePzjCvtBkM14+n8CIgMAFO5IVBEJ+ByAKupVYGdop2xVREjLSUNIfAjqVq2Yffcu4R0SsxLLXL+2dm3RpWYXqdtySmL53eX4pdkv7KWNUWoquv2qyFR0+1VeMPvFYDAYfJb8uARHnh/Bh6QPcpe9+PYi3nx5g1ltZ5WDZgwGo7Izo+UMpOWk4b/n/8ld9kvGF+wI3IFFPy6qsE4ngM14wuV3l3Hz/U2svrca7eza4fKIy8pWiceJlydw4/0NbAzYiLGNx2Jb723KVokjJi0GPiE+2P9sP/wj/HHH4w5a27ZWtlocYYlhOP/mPDY/2oy3CW8RMjkE1Y2qK1stBqPMqOj2qyJT0e0Xg8FgMBgMBoNRWaj0wcWlsfTOUgRGBaJP7T74t8e/ylZHhJlXZiI1OxVjGo3B2q4Va+ruq/hX+OX8L3AwdsA+t30V7qXt1odb+PXSr6hnVg+nB59mTidGpaOi26+KTEW3XwwGg8FgMBgMRmXhu5/xxGAwGAwGg8FgMBgMBoPBKB9YjCcGg8FgMBgMBoPBYDAYDEa5wBxPDAaDwWAwGAwGg8FgMBiMcoE5nhgMBoPBYDAYDAaDwWAwGOWCzMHFK/LWfAwGo+ypLOHfmO1iML4vKovtApj9YjC+NyqL/WK2q2T09PSQl5eHzMxMWFhYICoqStkqMRilQhbb9d3vasdgMBgMBoPBYDAYDEZ5Y2JiguXLl+Pz58+4efMm9u/fD0tLS2WrxWCUOzLvasc81wzG9wX76sZgML5FKovtApj9YjC+NyqL/WK2S5SxY8dCT08Pjo6OGD9+PJeekJAAExMTJWrGYJQeNuOJwWAwGAwGg8FgMBiMr0yLFi3g6ekJABgwYAB0dHRE8kyfPv0ra8VgKAfmeGIwGAwGg8FgMBgMBqMMuHHjBnR1dWFiYgJ7e3veMX9/fwQGBuLTp0+4evUqAgMDlaMkg/GVYY4nBoPBYDAYDAaDwWAwFEBLSwtjxozBokWLAACGhoYAgPz8fGRlZQEAGjVqhOjoaOTm5iIvLw8FBQXIzc1VlsoMxleHOZ4YDAaDwWAwGAwGg8GQE3Nzc0RHR/PSiAihoaHw9fXFH3/8oSTNGIyKBXM8MRgMBoPBYDAYDAaDISfdu3cXSTt+/DgGDRqkBG0YjIoL29WOwWCIhe2swmAwvkUqi+0CmP1iML43Kov9+l5sl0AgQFZWFqKiorBr1y4AwIQJE1C3bl0kJycrWTsG4+shi+1S+Qp6MBgMBoPBYDAYDAaDUen4+PEjHj9+jEaNGonduY7BYLAZTwwGQwLsq1vlok+fPjA1NcXOnTuVrQqDUa5UFtsFMPvFYHxvVBb79b3YLuGMp/z8fKSlpcHU1BRAYXBxNuOJ8T0hi+1iMZ4YDAajElKlShVoaGigSpUqePv2LVRVVQEA8fHxOHPmTKUZ3DIYDAaDwWAoE21tbWhraytbDQajQsNmPDEYDLFUFsfE92S71NTU4OzsDACYO3cuevfuzR378uULwsLCAAA9e/ZEXFycMlRkMMqdymK7gO/LfjEYjMpjvyqz7TI0NISDgwMAQEVFBXfv3oWamppIHjbjifE9wWY8MRgMxndC//79YW1tjXXr1vHS8/LysH//fty/fx/btm1TjnIMBoPBYDAYlQB7e3ts376d+9DHYDBkg814YjAYYmFf3b4NunXrhu7du2PkyJEwMDAQOf7rr79i7dq1StCMwVAOlcV2AZXffjEYDD6VxX5VdtvVvHlzbN++HadPn8asWbO4cAZC2IwnxveGLLaLOZ4YDIZY2OCn4tO6dWscOHAA9vb2Yo97enpi+/btyM/P/7qKMRhKpLLYLqBy2y8GgyFKZbFf34PtcnJyQlhYGBITE6GhocE7xhxPjO8NttSOwWAwKjFVq1aV6HQCgEePHjGnE4PBYDAYDEYZ8/z5c7EOtoKCAiVow2BUfJjjicFgMBgMBoPBYDAYDAXIyclBbGwsAKB3795sthODIQbmeGIwGAwGg8FgVAisra2Rn5+PqKgoZasiFWtraxQUFODz58/KVoXB+OZo0qQJnj17htzcXGWrojBEBD8/P7x69Qq//vqrstUBADRu3BhGRkbIzMyEv7+/stVhMDiY44nBKMaIESNQtWpVAEBwcDCuXr2qZI0YDOns2bMH7u7uUFFRUbYqDAaDITdTp06Fqqoq2rZtC19fX+zevVvZKpWIpaUl1q1bh7y8PDx48EBsnh07diA1NfUra8ZgVHxcXV2xc+dO7Nq1C+np6QCAu3fv4uHDh0rWTH66d++ubBVgamqK4cOHAwAmTZoEBwcHhIeHo0aNGkrWjMH4H8zxxJAZfX19bNiwgZeWlZWFCRMmKEmj8iE5ORk7duyAhoYG3r59y30tyM3NxdixY5WsHYMhnsWLF+PatWuoU6cO/v77b6XpYWtri65du2L79u1K04HBYHwbuLm5oV+/fgCA4cOHc45zX19fZaolE3l5eUhPT4e7uzt+/vlnsXlOnDjBHE8MhhgGDRqE6tWrY+HChVza06dP4eHhgadPnypPsW+MBQsWwMzMDFu2bMGaNWuUrQ6DUTIkIwCYfOdibm4ucl+kpqaSg4MDPXr0iBNTU1Ol61paadeunci5FhQUcOc4duxYpetY3lJZUHY/lqf07duXO08HBwe6d+8ehYaGcmkuLi5fVZ8qVarQy5cvKT4+nvutmJiYKL2fmHxfUplQdl+Wp7Rv354+f/7MnWv37t25/3t4eChdP1nE09OzxOv39OlTUlVVlavODh068MZURaV3797lch7e3t5kaWmp9P5kUnnsl7Tz3Lx5s9hyvXr1Ulrfjxgxgrp166b0e0BWWbBgAWVkZFB+fj75+PjQvHnzeH0ZFhamdB2ZfD8ik10oKwPCpPKLOMcTEdH9+/dp4sSJlJeXR3379iWBQCC2vKamJgEgVVVV0tLS4kSYXpHEyMioxN9DZmbmN/VwUkQqC8rux/KUoo6nlJQUkXP/2o4nANSmTRvKycmh3Nxc6tmzJwkEAtLS0iINDY2v0r6wPS0tLVJRUeHSW7duTYmJiTRy5MgysT0V0W4xKZTKhLL7sjxFaL+ys7PJ2dmZBAIBdevWjTIzM8nd3V3p+ski0hxPRESJiYmUmJhIXl5eYutYsWIFJSYmUkxMDGlra9OgQYMk1pWenk4NGzYss7GTiooKeXl5UW5uLiUmJlKVKlW4Y+rq6ryx2siRI7lziY2NJR0dHbG2lknppLIg7TwlOZ5SU1Ppy5cvpKamJrZc0We8lpaWwv2spqYmUsfMmTMpPT2dGjduzP3GVFVV5XYeKyrC31ibNm1kyr9z504qKCggIqInT56QhoYGrV+/njIzMykzM5Nevnyp9PtZ1mvx9OnTrzZOZFI+IgssGAij1DRv3hw9evTAqlWrEBMTg8LnDR97e3uEhYUBAMaOHYvMzExOXr58CUdHR07U1dW/9inIjZaWFqpXr/5N6MqofDg4OMDR0RHW1tZcmp6ensL1WVpaonbt2mK3BZaXgIAATJs2DWPGjMGzZ89Qr149ZGRk4Pjx46WuWxZsbW3x5s0bZGZmYsKECZxdqVGjBgwNDbFnzx7O9gQFBfFsj5qa7KvPw8LCWOwEBqMM+PXXX/HixQsQEW7evAl7e3vs27dP2WqVGYaGhjA0NIS1tbVYO62trQ1DQ0OYmZkhIyMDR44ckViXjo4OVFVVER0djaCgIFhYWJRKty5duuCXX36BmpoaDA0Ncf78ee7Yrl27eGO1PXv2cOdiamqK9PR07tikSZN4ttTc3LxUejG+X3R1dWFkZCRxPNKwYUPefdmmTRuFnsVTpkxBXFwc0tPTUa9ePTg6OsLMzAw6Ojp4/PgxMjMz8ejRI/z111+YNGlSaU9LKlpaWrCzs4OhoSFu376NZs2aSS0zZswYBAUFAQA0NTVhYmKCqVOnQltbG9ra2qhbt255q10mEBF0dHTg4+OjbFUY5QyL8fT/ODo6Ijk5We5dVHR0dNCoUSPcvXuXS+vbty9UVFQQHh7+3axT7t27N27evIn79++LHGvevDmOHz8OPT099OvXD40aNeIdr1GjBl69esX9Xb16dbx//768VS41mzZtwqVLlziHmjS6deuGixcvlrNWjO+B27dvw9/fH5aWliXmc3V1hY2NjdT6fv/9d7Rs2RIDBgzAiRMnSqWbhYUFatSoAX9/f5w/fx5OTk6lqk8eevbsidzcXEyZMgU+Pj7YtGlTiflr167Nsz3jxo3Dly9fAACvX7/GixcvJJbV1NTEuXPnUKdOnbJRnsH4TujevTsuXLjA/f3vv/8CKHR0/PbbbzAzM8PUqVOVpZ5chIWF4f3797C3t5ead8yYMUhNTcW8efO4F+br16/L3WbHjh2hrq6O2rVr48iRI1i7di13TN4Xt4sXL2LKlClYu3YtzMzM8O+//3Ixt2JiYpCcnAwDAwOxZdPS0nD58mUAhc+apUuXQldXl6t327ZtvPwRERF49OiRXPoxGNK4desWtm7dCk9PT7nKrV27Fjo6OmjcuDFWrlwpNkC4k5MTFi1aVG72qHnz5tw4ztTUFG5ubtyxP//8E/3795e5LktLS/Tv35+zpyVhYmICGxubCvOOWlBQgNWrV2P8+PGoV68eN/YSvk8DwJMnT76Jd0NGyXx3jidnZ2fuoVqU9u3bIzo6GpMmTUJCQoJMdamoqGDx4sXo1asXDh06xKX//fffiI6OhqenZ4X5UZclDx48gKamJpydnXnpXbt2xYkTJ0QMg42NDTQ1NaGnp4f169dXyj6Rhe3bt2P37t0gIty6dQvXrl1TtkqMb5Tly5dj3bp16Nu3L06dOiUx34oVK+Sqd9u2bZzjqVevXggKCkJERIRcdWRlZeGHH37AzJkz5SpXGrp3744WLVpg5syZyMrKwoYNG3Dz5k20b9++xHIxMTE859SaNWu4GQl37tyBn58fdywiIgI7duwonxNgML5xZsyYAUNDQ7x7967E2UoeHh5Yt24d1q1bh9q1a3Pp//77LxwcHDB9+nSRTUxKS9WqVTFlyhSR9LCwMOzdu7dUdX/58gWJiYkyOZ4AYPr06dDS0kJKSgqGDx+OHTt2oHnz5nK1WdSut23bFm3btgVQ+PK2ePFihIaG4uDBgzLXd/jwYQwfPhw9evTA0aNHuXQfHx+sXbsWf//9NzQ0NHhlCgoKMHv2bKxfv55Lmzx5MkxMTGBnZ4fRo0ejW7duvDLPnz/HyZMnsW/fPrx7906uc2Z8XwgEAvz6669Yvnw5L33WrFkiv7W8vDxMnjxZpA4dHR38+eefCAgIwNmzZ8W2s3jxYgCAtbW13GMdRTEwMMCvv/4KABgwYAA3K+nBgwcYO3Ystm7diqCgILE2S4i9vT08PDwAANWqVQMAhIeHy+R0AgonW6xbtw7nz5/Htm3bEBkZWZpTKjWqqqrYtGkTVFRUsGXLFm7s9ffff3Mz0c+ePYvAwEDk5uZi0aJFylSXURrKaq3u15bly5eTrq6u3OU8PDxo+/bt9OLFC7HnefnyZYnriouLQCCgsWPH8spPmTKF3NzcqH379krvo7IWYYwnb29v2r17t9j+69ixo9iyHTt2pPj4eGrXrh1NmDChxHvN3t5e6eeqrq5Ov//+u9TfRY0aNWSus2fPntxa7NDQUPLx8SEfHx/at2+f0s9XnFQWlN2P5SlFYzzJQ35+PvXr14/c3NzIzc2N7t69S0REbm5uXN2bN2+mmzdv0pEjR+TSydnZWWybUVFRNGTIkHLphw0bNvDa+vz5M82bN48ePnxYYj8kJyfT9OnTuXq6devG9cn+/ft5eRMSErjfrI+PD/388888e/fPP/+QmZmZ0u8JJpXHdhHJZ78sLS3pjz/++Kp9PXz4cPLx8aGMjAwiKhxDlZS/TZs2FB8fX2JspPXr15epjrVr1xbbTmxsbKmDmMsS46ms+e233yg9PV3i8XPnzsl9HufOnRNbV8OGDSk1NZWIiK5du8bZxz59+kisy8TEhMsnlKlTp3J1dunSRan2oSTZt28f+fj40MyZM5WmQ2WhpHPs3LkzhYeHl1g+KyuLfHx8eL/RgQMHiuTLycmhatWq8Z7PVlZWpKGhQX/99Rdt3rxZap9bW1uXqMuUKVNKfV29vLzIx8eHLl26JLaN+/fvEwBq2LAhGRsbi61DIBDQ8ePH6fbt2yLlnzx5IrMurVu35so1b978q97fWlpavGvl4+NDZmZmlJ+fL7H/L168SG5ubhQSEsIFUhdK48aNlfZbZcIXWfgmHU8LFy6kzMxMevv2LYWGhtK6detkLuvh4UFTpkwha2tr+vz5M9WuXZs3cOjcubPUOv744w8KDQ2l0NBQCgsLo5s3b1KtWrWoVq1alTowWmkcTwA4h9K34HgCQM2aNZP6u5DH8XTjxg3q2LGjSB35+fkUGhoqMfCosqSyoOx+LE8ROp48PT05G1SrVi1auHBhiX2Sm5vLCwZrYWFBtWrV4m0MsHnzZho8eDA5ODjIpZOmpib9+eefYttduHBhmffBgAEDKDExUaSt+Ph4GjFiBNWuXZtycnIk9sX+/fvF1mtsbMzr0+IDXuHzRyipqakUFhZGt2/fVvp98b1LZUKe865Vqxalpqby7svQ0FDau3dvmfXtsWPHeHUnJCTw9JXmeAIKxwIODg4Sz1mS40k49nr58qXMwaw1NTXp2rVrPMeHEH9//1LvwqsMx9OHDx9KfEkrS8fThw8fuJfU3bt3K9xPGhoanC3V0dFRuo0oLgsWLKDQ0FCuX48ePao0XSoLJZ3juHHjZK5n7dq1XDkVFRWxH9yKO7EcHR3JyMiITp06VeIHoe3bt9OrV6/I3t6+RB3KwvF05cqVEtsQOp5KkmvXrkksL6vjycjIiD5+/MiVK8nxVK1aNdq5c2eZ3t+6uroiuoeFhZXYN1u2bCEAZGNjIzLei4iIoNDQUDb2qgAiC9+k40lNTY00NTUpLCyMEhISKDk5mbKysnhy6dIl0tbWpipVqpCRkREZGhoS8D/HEwDOSaSiokKzZs0qcUc2Q0NDat26NWVlZVFeXh6lpKRwu3qoq6srrS+MjIzIyMiIZsyYQVlZWeW6i5WpqSmlpKQo7HgSSlk7noR9YGRkxLsWampqNGPGDPL09FRoR4rGjRtTQkICZWVlSdRVHk97UFAQOTs7c18Pi5OXl0dTp079artnSJPKgrL7sTxFRUWFNDU1RV7CpkyZUmKfFHc8FZfhw4dTeno65eTkUFJSEhkYGMil18iRI8W2W5aOJwMDA8rKyqLc3FxeGwkJCZxER0dTamoqNW7cWOyuf0SSHU/FRSAQkKamJidfvnyh/Px8SkhIoMzMTEpNTaWEhAR68eKF0u+L0oqqqioZGRmRt7c3ZWVlUUREhMRnY0WUyoQ8512rVi2xdRQUFPDGR7a2trznpqRZ3gYGBrx8RXdQkoQsjicAJTqe8vLyRMZ0wrGX8HjVqlXJyMiItLW1ReoeM2YMr1xBQQGdPHmSlixZwnNCX716tdT3moeHB2VnZ0u9jrm5udyssPKmLB1PRERxcXHUsWNH2rBhQ5n8PnV1dendu3fc9Vm9erVSP9qOGzeOu7cSExPp/v37Sh3XVxak9bmsbN68mXd/qKmpiXUkFyU7O5v77W/dupXbAVJbW5uCgoK43RuPHj1KCQkJlJGRIXGMQET0559/yrwapqg4OjpSfHw8JSQk8OyEn58fGRkZkYmJCYWGhhJRoZ3esWMHbd26lbp06SL2mVutWjWRMY+Q+Ph4mSZimJiY8M5V2FdFpV+/fvT27VuKioqi48ePl/k97uLiIvW6JyUlkb29PSUkJNDq1au5sm/fvqUHDx7QkCFDePmjoqJIT09Pab9bJpXY8VRcJG09u3LlSjp48CARFW7P6eLiQgsXLqRVq1bJtEzPzMyMXFxcyMXFRcRZ0KlTJ6Wes4ODAzVr1kxkwNO8eXNydnYmJycnMjY2pmrVqpVpu40bN6YZM2bQ3Llz6eHDh/Tw4UMKDg7m2v/ajid1dXXeQPj333/nrlnRB9uoUaMUduj88ccflJqaSoGBgfTs2TOergUFBTIPUNTU1Ojt27fUs2dPieceHh5OTk5OSr23hFJZUHY/KkNK63gCQH/++Sc9fPiQcnNz6f3791SzZk2Z2/8ajidDQ0Ou3g8fPtDDhw/FfvE6efIkXbx4kRo3bkwfPnwQ0UlWx1NxuXLlCvdV3NPTk1q1aqX0614WoqKiQsOGDeP1kYWFhdL1kkcqE/KctyTHk5CwsDB6+PAhPX78mJfu6enJPTddXFzIysqKgMLZTcLna2xsLMXGxpZYf05OjszOiZIcT/KwdOlSkbrHjx8vNu/mzZtp165d3LipLBxPAGjHjh1S+2X9+vU0YsQIevjwoUQH1NOnT0vXGVT4EinPKgAjIyNycXHhlltLIjAwsMx+n+vXrxcZu86ePVusE/FryMSJE4mI6OXLl6Svr68UHYpKZaGkc5TkeIqIiKCHDx+KfPAdMWIE1a1bl9TV1Wn48OFy67J48WJycXGhNm3aUEZGBi1evJjTRUVFhU6fPk2dO3cusY42bdoodD27detGw4cP5814SkpKooULF9LVq1cltmdiYsL7jbq4uFBkZKRIvuDgYLp+/bpcOhVdaieJvLy8cvsQ3qBBA6ntDxo0iJydnSXWIW7Z5cOHD8nFxYXrOyZfV2ThuwkufurUKUyaNAk//PAD1NXVYWlpidevX4vNq6WlhSFDhqBTp04YOnQoAODAgQPIzc0FADRt2vSr6S2Ohg0bYteuXWjcuLHY435+fkhPT8fZs2dRtWpVnD9/HkSEvXv3gohK1XZgYCACAwPRpk0bbNy4EV++fEGDBg247Ty7du0KW1tbAMCnT59w5cqVUrUnjYKCApw4cQIDBgwAIDmY8u7du1GlShVkZGQgLCwMN2/elLmNFStWQFVVFRs2bICuri4OHToEV1dXhfTV09ODo6MjAgMDxV6/mzdvIiYmRqG6GYyy5ObNm4iNjcX69ethaGiICRMmcDvAlZU9MTMzQ8+ePQEAvr6+iI+Pl7nszz//zP1/5cqVEoNq/vTTT9z/x4wZg82bN8PBwYFLc3Bw4O2iIiudO3fm/r9582a5ylZkdHR0cODAAV7aoEGD4O3trSSNGGXFvHnzsH//fmhpafGC6s+ZMwcWFhbc376+vpgyZQoGDhyIvXv3olu3bpg5cybatm2LcePGSaw/JiamxIC4QlRUVOTarUkeqlatilatWok9NnHiRKxbtw67du3ChAkTyqV9ccTExHC7Yu3fvx8LFy7EX3/9xQXNBYDz589j5MiRiI2NhUAgwJMnT1C1alWZdiUtyufPnzF9+nSZ83fq1IkXUFwSJiYmaNOmDe7cuSOXPuKYOnUqcnJyYGxsDACoX78+Fi1aBIFAgMjISMTFxUkMBl3WmJqacvfL6NGjkZKS8lXaZYhn69atWLRoEVasWIHffvsNKioqePnyJSwtLbFo0SKsW7cOa9askbvev//+G3///TcA4OXLl5g9ezaAwue4tbU1Tp06ha5du5bpuQgR7mZdrVo1LoB5cHAwNDU10bFjR4nlhg4dirS0NLi4uGDSpEkS8x0/fhxv374tW6UVxNbWFsbGxiVuIqWmpsbbvU8SR44cwebNm0XOfciQIcjKykJ4eDh2794NABg4cCB0dXXRtGlTBAQEYPjw4XJtsMD4isjknqKKPWtAlhlPwmmVRZfaSRJhLCMhq1at4k3zbNOmDdnY2CjtfP/55x+J1+nIkSOUlZVFUVFRtGfPHi597ty5ZbJUwsHBgby9venly5d0+PBh8vb25vq4OO/fvydvb29ydnamWbNmkbe3N3l7e5Ofn1+J95q8S+1q1KhBwcHBNHXqVJo6dSrFxMSUWH9oaCini3AJpjzSr18/Xn0bNmwgb29v6tevX4nl1NTUKD8/n3x9fWn27NkS9WvRooXSf1PA9/HVrbJKaWY82dnZkbe3N292X0JCAm8pRn5+PqmpqVGtWrXI29tbZImvtBlPs2fPJm9vbzp27Bh3TNYAl+7u7uTt7c2bbv7LL7/I3DedO3emiIgInl63b9+mWrVqKf26VQRZs2aNXPdLRZTKhDznLW3G04gRI8SW69evH/f83Lp1KxER9e/fn4DCQLADBw4kALRt27YS609NTSVPT88SdZw6darIZgClISAggHuee3t705EjR6SW2b17N82ZM6fMZjx17NiRpk6dSjNnzpS5X4rPoj927BgZGBhw8fnmzp1LvXr1ori4OLn6Izw8XC7dxc0aKKnfyuP32qRJEwoMDOTaiY6O5q6npDiac+bM4V13b29vsra2lqvdVatW0dGjR7l2jxw5UiHiT1UWSjpHcTOenj59yo0l5s6dy8XbWrt2Le3bt6/M9Pry5Qt3z7x//17mcorOeJIkf/31V5mdU3Jyslxtl9eMJzc3N7p//77Ib7Po+5G4GE+S2LhxI3l7e9OgQYO48vHx8fTq1Steu6NGjaI5c+Zw5YYNG6b03/H3KLLwXTiexowZww2aZXE8Xb9+nVePonGTevXqVeLOH9KkS5cu3OBPTU2Nrl27Rn5+flKDsBEVTr00MzOjw4cP0x9//MGtby6tGBoa8gaNGRkZ5OrqSosXL5aoy8CBA+nly5dij/Xt25dcXV15oqWlJZdOWlpavOVpwvXSxcnMzCRXV1de4GVFHIjFHU9CIiIiyM/Pj/z8/MQOXoSOp/j4eFqwYAHdvHlTpI7Vq1dXiKnewPcx+KmsoqjjSU9Pjx49eiRTv16/fp2ePHlCRETDhw8nAKSjo0N+fn4Sf+/v378nPz8/sUtNpDmeXFxcyM/PT6xjWR7Hk7Cu7t278+p48uQJ+fn50aFDh5R+/b629OvXj7NdwlgnQn777Tfq0KGD0nWURyoT8py3trY2zZs3T2JdkhxPRaVXr15EVDiG8PPzIx8fH+6YNMdTbGwsNWzYUKTOWrVqcfdXUlJSWXaPwvj6+pa4jEMemTlzJvn5+dGlS5e4cczhw4d57V26dIlXprj9ISIyNTUlbW1tcnV1JXt7e1q4cKHccaG+RccTAJH+EhIYGEh+fn4iAfJbtGjB+/iwbNkyuXe6zszMFGmvrJyRzH5Jtl2Ojo4UEhIikj82NpYbSxR9zylrx5OilLXjydbWlm7cuFEmulUkx5M4ir4fiXv3EceoUaO4JbnC4OJAoeMpPT2d5s6dy2vb0tKSK/vixQu5wkMwKRuRhUrheBo4cKDYgJcrVqygQ4cO8ZwS4hxPqqqqpKqqSrt27RK7flboeHJ0dKTIyEixX/QEAoHIjKLx48fTxIkTFT4vDw8PSkpKosjISLF6iaNXr16UlJREwcHBBID09fXLzOkklClTptC0adPoyZMn3CwBbW1tsrS0FGtQEhISqF27dmK3/y2PdbiSHE/p6ek8XS0tLRVav6ylpcWVDwsLE7u7zOfPnykyMpI2bNhA8+bNo3bt2pGmpiaXNzU1lUaMGEFv3rzhlUtMTKwwW4NWFpTdj8oQRR1PxsbGCvVxQkICRUZG0ufPnxUqTyTd8dSlSxde/uTkZO53KJzRKo8IBAKu/KZNm7h6xb24qaioVNgZP2WhV/FArc+ePeP6pqyfH19DKhPynnv//v0l1iXJ8XTkyBGysLAgVVVV6tOnD69Mfn4+RUZG0rJly6TGMoqIiCDgf2Oqq1evUmRkJC82VH5+vohzUxnk5+fTf//9Vyb3m6GhIQUGBlJBQQE3Xps1axbZ2tqSra0tNWvWjC5cuMArU9T+7Ny5k9zc3ER+y8bGxlK3nC+OvI6nn3/+Wea6leF4EpKbm8v1bdeuXUlVVZUaN25Mt2/fJktLS7njQ6mqqnKOp4KCAu4doiLE2KwsSDq/5s2bi81/7tw5Lji0ubk5WVpa0sCBA2nt2rW0f/9+Xt6i10wS+fn5Je7+KC9l7Xjy9PSk1NRUysvLo/j4eLK0tKQ//vhDbr26dOnC2V5Z5Ws7noqSnp5OnTp1kprP0dGRLCwsqFevXpSamkru7u6kqqpKNWvWpLy8PEpNTaXIyEjq1KkTqaqqko2NDa98bGwsZzPWrVv3TW2Q8q2KLFQKxxMAWrZsGU/fK1eu0O+//05ERJ07d+ZuOA8PD5o7dy5ZW1uTiooKOTg4SDVOQseTk5MTERUaPGEQbWtra7K2tqYlS5bQgAEDeDrJ4niytrYWu51v3bp1KT4+XtbLw9G8eXNKSEjgHE/lIcK+FPcjNjMzo+joaBG98vPzycXFhSIiInhiZGRU5vpJcjylpqaWeVsqKipkbm5eYtBV4QOy+D02YcIEun37tkh+ttSubFF2PypDvrbjqSwoyfGkqqoqEvA6MTGxzPpLIBBw2xTfu3ePgMLZX9bW1qSurk6pqal09+5dpV/X4tKsWTPy8/OTe9fB4lLU8RQaGlphnWyySmVC3nMvyfE0ffp0bjMMdXV1bvxy9+5dys/Pp+zsbInPMmkveUSFH1yGDBkidkyVmppKERER1KJFC9LW1papvvKmLGe33L9/n1e38Jmfn59PERERJW7pXtIL0du3b+U6J3kcT46OjnJdh+KOJ1VVVe4esra2VmjXL6EUdzylpqZSamoqxcbGcuNF4ZhY2LfR0dFka2vLtS/LRi9Cux4aGspdm6VLl9Ly5cspOzubXr9+zexXGSHp/CQ5niTtnjZ9+nSRvCdOnCjRER4VFUXa2trUpk2bMjufsnY8CQQC7qOW8JkraWOEknB2duZ+i8bGxjK17eLiQomJiSXWm5+fL/fyVVkdT8U/JIrD1dWVrK2tyczMjDw9PbnffXp6OtnZ2ZGnpycR8W1tSUybNo1MTU2/+fFNRRZZqLDBxatWrQp9fX2EhYXJlJ+KBbmlQqcaAODy5cvQ1dVFeno6AGD+/Pno06cPOnXqBKAw0KUkXr16hZSUFLRp0wafPn3C8+fP4eTkhMaNG0NVVRUXLlzgyg8aNAgAZArA2LBhQ5iZmeHChQu4ceMGPDw8UKtWLQDAjRs38PLlS/z222/4+++/YWpqCiMjI5n64Wsg7NfifQ4Ahw4dgrm5uUi6iooKLl68iKpVq5a7fpIo6TorSkFBAWJiYjBo0CBcv35dbB6BQMD7V8iWLVtQp04drF69GpqamrC2tkbt2rXLXEcG41vF2dkZJiYmMDU15QJeP3/+HDExMUhLSyuzdoTPi/z8fPz+++8wMTHBihUrMHr0aIwePRoaGhowMjKCo6MjQkJCyqzd0tCuXTtcv34dKioq2LZtG6ZOnSr3xgQaGhpo27Ytz+40bdoUBQUFZa0uowKwdu1a3LhxA0+fPkW9evVw4cIFvHjxApmZmcjJycHx48dx5MgR+Pr6ipQt/vwSh4WFBQ4dOsRLu3HjBvLz83HhwgWsXr0aQOF9V16kpKQgICCA+7tdu3ZQV1cXyZeTk4P379/DwcGhXALzCgQCrs+sra1x/vx5DB48WGxb4sZSQvz9/VGjRg2Z+p+I4O/vL7eeimJmZoZz586hQYMGAAAPDw8ueDJQOH7+/PmzQnUfOXIEz549g5+fH54/fw6gcGzt5eUFAGjVqhXMzc3x4cMHrkyjRo1KDGoMFAY2X7RoEQDg9OnTvCDH2traXNBpRsWm6KYh4ujQoQMyMzORkJCAa9euoU6dOrC0tERBQQGuX78Oc3NzODk5fSVtxVP0PbU0NG/eHLa2tjh9+jT27t2LUaNGoXHjxjAwMJD4XvLo0SO4u7tjy5YtsLS0FJtHRUUF9+7dk3uDA2no6Ojg0qVLUvP5+fkBKLQjly5d4myqjo4O3r9/z+UramtLQiAQ4NixY9i4cSMiIyPltpWMsqFCOp709fWxdOlSREdHY86cOWVe/40bNzBmzBikpKTg999/LzFvUFAQevbsib///ht16tTB06dP4eTkJHb3tJ49e8La2hp//vknqlWrJnLcyMgIo0aNAgCMGzcOderUAVC4C8CGDRvQt29fHDhwAHfu3EF+fj6Awt0XnJycKpTjSVG0tbUxePBg/Pfff8pWpcz59OkTbty4gQ4dOshdVrirV6tWrTBgwABERUWVsXYMhmxkZWXhv//+w+DBg6Xm3blzJ8aMGVMuetSqVQs9e/bE+PHj4ejoCAD48OEDTp48iX379kl9uVCEEydO4Pnz5zh16hROnjyJ0aNHAwB27doFAKhTpw527dqFY8eOcWUSEhKwd+/eMtdFFn788UdusDVo0CD4+PjIbFv79OmDmjVrQk9PD/Pnzy9PNRkVlLi4OPz66684fPgwgMKd7RYtWsQ9j0rD48ePcevWLQDAX3/9hZycnFLXWZQdO3YgNTUV1atX5zkOsrKyMG/ePKxbt45Li4+Ph4mJiUgdX758wbJly1CvXr2vsiNUkyZNMG7cOPz5559ylRs5ciR+/vlnmZx1+fn5GDFihKIqyk1GRgb+++8/pKeno2XLltwOU0KOHDmCBw8e8NJu376NR48eyVT/+vXreX/fuXOH+2A8e/ZsmJiYwMbGhtvVWB727t2LsWPH8tKEOw8yKhaBgYF49eoV984kDy9fvkSnTp0waNAgtGjRArm5uVixYgUmTpyIvn37Kn2X8rJgy5YtImmrV69G27ZtMWHCBOzcuVNsOV9fX+jo6KB58+ZcWu3atdGjRw9ePjs7O9jY2JTJjpaKUKdOHYWufXHat28Pa2trdOrUCR8/fmSOJ2Uh07wo+nrLVVRVVen48eNERBQUFER79+4lCwsLqeWWLl3K0/fy5cvcDiOzZ8/mpgAXjfGkoaEh8zTj3NxcOnPmjEx5v3z5QkDhlMn79+/T3r17ae/eveTj4yO1rK+vL5df3DIsaTRv3pxGjhxZrkvtSpKrV6/StGnTyN3dnVavXi2in3AZS3mKtBhP5SGOjo708OFDqdcnLi6O3N3dyd3dnR4+fEiOjo5KuU6ySGVB2f2oDCnNrnaSpsELWbNmDY0YMYKsrKy4tK1bt9KHDx9KdZ2KLrWzt7cnX19f3vHiwXnLQwQCAY0YMYL7jbq7u5cYXy8pKYkmT56slGusqqrKi5UzePBgWrx4MW8HVnHSr18/kV39Ll++zJ2vLMtVKrpUJuQ995KW2hEVjjGKBmotLtbW1nTixAmFdE1ISCB3d3dq0qRJiTrKM/YqzvLly7nNO7p168Y7Jhx7FRVJIQs+f/5cpvdc8aV2knSXt16BQMAF2JWGvLtPOjo6ylSvkOJL7XR1dcnV1ZUaNGhA7u7uNHLkSF7Ab3E8fvyY9u7dS7t37+bpWnyp3Zs3b2jv3r1SdxutVq0aZ7ukLTNq2LAht3seG3uVP5LOT96ldkBhTCJ3d3exAeHF4ePjI/FZVrduXQoPD6fg4GAiIpo5c6ZMsaDKeqmdOFFkqV1R9uzZQ0BhTMykpCQKCwuTq/3iY6/09HS6cuUKBQcHyxQGxMbGhk6dOlWqc5CFz58/88ZpRXf/vHDhAvn7+4uUOXjwILm7u8u9gRUT2UUWKoTjqWfPnvTo0SN69OgRPXjwgBfc8vfff5cpuGlJjqcXL15wgQeLOp6uXr3K5d+6dSs1adKEPn78KGuXSCQvL48ePXpU6hcxRWjevDndvHlTqY6nwMBAsrKyEgmcTVR5HU8dOnSQ6foUfQjUqFGjQhvAyoKy+1EZIq/jadmyZdy21dIcTz179iSgMEZMkyZNqEmTJmRsbEyOjo7cBgK+vr506NAhua7Tq1evSE9Pj2rWrEmPHj0SiRX3NRxP4qRu3brk6uoqUe+jR49+dZ02bNhAjx8/5ukRFhZGmZmZUrcDX7BgAa/co0ePFNrdsyJLZULec5fmeCIqjN0hHHM9evRIZOfef/75R2LZkSNHUnJystg6Zd0lrjSOp06dOnH1SHI89evXjx49ekQNGjT4ao4nR0dHSklJKVH3snA8eXl5cXZ38ODBvPq/puPJ19dXbGwqZ2dnTr/Tp0+XWN/jx4+5ezAhIUHkuCI71UkSS0tL3piUOZ7KH0nnp4jjSSjSfmNFkTS+1tLS4u7RJk2akIaGBjVu3JiLGSSJb8nxBICioqIoOzub1qxZI5cOxWMmCwkLC+M9N+bMmSO2/Pz580t1DuI4ceIE74PIq1eveG06OTlxz4OYmBj68uWLSB3Tp09X+m+7sossVAjH04gRI2jWrFl069YtIiLeoCY1NZUSEhLI0NCwxC+5JTmeiIjb9aio48nU1JSCg4PJ0NCQM1DPnj0jMzMz6tatG23YsIHbSSEzM5OysrJE+qWgoIAyMzMpMzOzTHdPKEp2djZlZmZSSEgIGRoakqGhochsACFfI7h4SSJ05okbmBIxx5O8Xx+UKZUFZfejMkQex9Mvv/xCmZmZlJKSQmFhYTI7nsTJu3fvyNDQkHR0dGjt2rVyX6ukpCSJA0tlOZ6AwqDrQjtffEeuEydOkJqaGmloaJCWlhZpaWlJnXWkiDg7O1NiYiIlJiaWOKugJMeTiooKLVmyhJf/4sWLSr9fy1oqE/KeuyyOp+KkpqZy91ZiYiI3qyArK0tkhkFqaqpYp1F+fr7MOyCV1vEk/BippqbGjYkMDQ3JwMCAnJ2dKSkpiYiI4uPjJbZT1o4nAGKdJ0VZvXq13LtEFXc8paenc9fp/v37ZGFhwUm1atVkrldLS0viOO3mzZtkaGhI+/fvp4KCAm7su3v3blqyZAlFR0dTUlISFxxZUlBxHR0d7tq0aNFCruu8b98+qlKlSpkFAra3tyeiwmff8OHDK3SA4cqCuHMzNDSk1NRUkbxv3ryRujvtjRs35Gpf1g+7mpqapKWlRd27dy/x2Voejid1dXVu3NCqVSvKyMggIuJ+88J3VKEYGxvzdMzJyeHZuOzsbM4+CNPPnDkjl05aWlp0/vx5bswjacZl0bbEPT+ESBo7SaN58+ZcXVu2bCFtbW2uH4S7HxYVS0vLEutjjqfyF1ko+2jLCqKvr8+tYdfX1+fSdXV1YWRkhMTERIlB0hQlLi4O9evXR1JSErKysgAADRo0QGxsLC5evIgpU6bg48ePCAkJgZmZGRo0aICQkBCeXL9+Hdra2rC2tsbly5fLVD8h3bp1g7a2NhwdHZGUlISkpCSJMRPs7OygqqpaLnrIQ9FrKA/W1tZiA4FWdDIyMhAbGys1n7q6Oqytrb+CRozKhoGBARwdHaGtrV2m9f7777/w9fWFnp4ejI2NYWdnV2L+koLg16xZE0lJScjIyFBIFwMDA+jp6UnNZ29vD0dHR6m6lhUJCQnQ1taGtrY2duzYwTv2008/YeXKlbhy5QoyMzORmZmJ8+fPl2n7DRo0wJMnT2BoaAhDQ0OoqckXnlEgEKB27dqYPHkyZs2aBQAICwvDnTt30K1btzLVlVGxef/+PUJCQnjBWXV1dbl7y9DQEFpaWgAKN0GxsbFBZmYmF7heV1e3VAGpAcDBwUHhsjY2NggLC4ODgwPy8vK4MVFSUhKSk5Px9OlTjB8/HklJSejTpw8SEhJKpWtZ8uuvv3Kb0CiKjo4Od52aN2+Oz58/c/Lp0yfUrVtXpjEGESE+Pl7ssdzcXCQlJeGPP/5AaGgounbtCqDQPltZWeGPP/6AiYkJ1NTUMGHCBHh7e0NXV1eknoyMDO7apKamynWe2tra2L59O4YMGQJHR0fY29vLVb4oDg4OqFmzJgBgxYoVOHDgANtAQUkIBAKx90pBQQG3AZQ4LCwsYGpqWi46nT9/HpmZmZgxYwb+/vvvcmlDEgcPHuTGDXfv3oW2tjZiYmLQvHlz3Lx5k3tHFUpiYiLvHXTAgAEICgri6tPQ0ODsg6J2OisrCz169ODGPL179xabr2hb4p4fABATE8PVs2LFCk5v4fMnLi4OISEhCA0NFam/qM0wNDSEpqamwvaEUXGoEMHFP378iLlz55ZqMCIr79+/5/0opDF79mxul4vU1FSJAc7GjRtXbgN4kmPXgyNHjpSLDl+LrVu34uzZs4iOjubSHj16xNsppSISHh6Os2fPcgGJJWFtbY3NmzdLNOSM75t+/fpJPNapUydMmjQJbdu2LfMgjw8ePEC3bt1gYGAg1YZs2bIFBQUF0NTURF5ensR8z549Q1xcXJkNFs3Nzbn+WbduHWxtbREQEIBmzZqhYcOGqFGjBs6dO1fmgYyL8+TJEyQkJMDY2JhLmz59Ovf/rKws3L59u0zbvHnzpkLlnJ2dUb16dWhoaHCBx1++fImQkBBMmjRJ7l3wGBWfyMhIhISEcEH5i9OvXz88ffoUzs7OePLkSYl1denSBfv378e+ffsgEAgwfvz4MtHx+vXrCr8UCYP9+/v7o1+/frh7965InqNHj8LQ0BBfvnwplZ4VASLChQsX0LdvX6l5VVVV8eLFCwQGBsLd3R0vXryQmDc3Nxfe3t7w9vaWmGfQoEGwsLDAjRs3APzv+eTu7g51dXVoaGhg06ZNAIC0tDQsXLiwzHYbFQYMHzJkCAoKCrBp0yZMmTJF7nratGmDM2fOcBv0FBQUoHnz5nj58iV7ef1GcHBwwI4dO1C3bt1yqb9Tp044cuQInj9/XuL7VocOHRAQEIDs7Oxy0UPI6dOn8fHjRyxfvlzkGBGhfv36vLR27drByclJ7g9SXwMtLS20a9cOt27dwt9//8059uzs7HDs2DEcOXIEq1evhpqaGrKzs3m7j3fu3BmXLl1C37598fPPP+P69evYunWrsk6FUUZUiLv05s2b8PX1xYwZM8q9rbKcNaWiooI5c+ZARUUFrVu3LlVd9+7dw8WLFwEUOrvKc7vhio5wICPEx8cHwcHB3N9PnjzBqVOnxJYdPHiw2B1sypt69epJdToxGCWhoqKCY8eOffUZi23atIG+vj6ysrKgpqaGAwcOYNy4cRLzHzhwAK9fv5b6xXj37t1wd3dXaKdHcTRs2BAnT57kpVlZWWH+/Pno3r07mjZtCjMzM8TFxcHR0RHm5ua4efMmpk2bBmNjY4SHh2PPnj2l1mPr1q3IyclBjRo18M8//4gcT0hI4O0U5+npCUNDQyxdurTUbcvLuHHjMGnSJO7vV69ewdPTk9txjFH5uH//Po4fPy723pSVW7du4dq1azAyMkJaWhr27dsn1sGjTDQ0NGBraytRr23btn1ljQp3klq0aFGZ1zthwgSxjqeYmBjcuXMHenp6uHv3LmbOnAk9PT3o6enBzMysRMeThoaGWKdTamoqt1Ont7c3srKyYG5uDgsLC0ycOJHLV3zmp62tLTQ1NUvlePr3338RFxcHa2trjBs3DmfPnkWDBg1w4MAB7gOwPHTt2hWbN2/m7QrdoUMH9O/fH9evX8esWbPw22+/ISAgAGfPnsXYsWO5GSiMioOJiQkMDQ3LrX4i4mYizpw5U2K+hQsXYtu2bTKtbigN48ePh7q6Ot68eYMLFy5IzT9z5kxMmDBB7EyyxMREHDp0qFT6vH37FleuXEHnzp1lyn/9+nXOWQ0A1atXFxlzfPjwAaNHjxars5B169bxdihlVBJkXWuJcl4XuGbNGqk63L17V2J5WWM8laWoqalRVFQUubm5cbGgFCEoKIicnJy4eoXrn/38/MjNzY2qVq0q0ra0XWeUHeNJEtJiPJ07d05qfxXfWaWolLRzYEWI8URUGHhZGddGXqksKLsfZRUVFRWZ1sDLEmdAnhhPf/31F5fu5uZGRkZGtGnTJollS4rxVFyuX78u83US8uHDB3JzcyM3NzduByJZMTU1JQsLC3rw4AG9evWKfHx8yN3dnXJzcykuLo58fHw4kRaEu7jUqlWLJk6cyLtev/zyC929e5fc3Ny4YN+RkZG8ck+fPqXk5ORS3Rv9+vWTuQ+KntfGjRt5x06cOKH0+/xrSGVCkfNfuHChxPqEAcANDAxo3bp1YvMsXLiQV1+rVq2k6ilPjKeYmBiF+2PevHkUGxtL3bp1k6mtrxVcHCiMaSSNIUOGyF2vubm52LqSk5Np9erV5ODgQEDhRj0FBQUUHR1Nw4cP59VRq1YtzvbVrl2btLS0xNaZmZlJ8+fPF9HBwMCAs8tFZcmSJXTkyBGpu0/r6emJ3em4KPXq1SMAZGRkRG5ubmRvb09t2rRROGaetPYuXrxIISEh1LBhQ/L09KSEhATy8fFh9quMEHdu6urq3L1z8eJFLm9oaGiJfdK4cWN69+6dXO0rsnlP0fdGcZiZmZXptT569KhIG1u2bCE3Nze57vuicbN27tzJ9XHnzp3LRM8//vhDRM+rV6+KfWebO3eu3PULBALq27evxPfpixcvkr29fYl1lBTj6dq1a1SzZk2l/7Yru8hChZjxVBasXr0arVu3Rtu2bb9am3l5eWjZsiXev38vcVq7LMTFxeH58+fc340aNYKKigqSk5PZUggGg/HVuHTpEjIzM/H06VOJebZt24bmzZvj06dPZd5+VlYW2rVrhw8fPmDmzJmoXbs2CgoKUK9ePRQUFGDs2LH4/fffJZa/f/8+VFRUuHggjo6O+P3331FQUICqVavCzc2NyyvPtHRDQ0OsWrUKV69exeDBg/Hff/+hoKAA27Ztw4kTJxAVFcXNEjM3N0doaCh2796NZcuWKdQPxZE1fmCvXr2QmZmJBg0a4NixYzA3Ny+T9hmVh9OnT6Nu3bpITk7GnDlzuBnGd+7cKdWy2I4dOyI/P7+s1JTI3bt3sXfvXl6MKnkhojKbiVmUzMxMifHvWrduzS0TLCv09fVhZmaGt2/fAgD++usvCAQCmJubw9vbG3PmzEGPHj3w7t07GBsbc/avSZMmEpcLpaSkYPv27SLpycnJOHXqFGbNmoVRo0Zx6Q8ePMCkSZOkLmtMTU3Fo0ePZDqvxMREblZ7aa7zsmXLuKU5VlZW8PPz4x3v2rUrsrKycPToUZibm8PAwAB9+/bF+fPn0aNHD4XbZUgmNzeXu7b+/v7cTCZpS+QDAwORnJxcLjpdv34dlpaWuHv3Ll69elUubRSnXbt2aNq0qUj6kSNH8Oeff8p9rsL3RgCIjY1FUlJSWagpkeDgYAwbNgwFBQW4cOECmjRpUqr6iAiPHj2Cn58fjh49itq1a+P8+fNcbLYWLVrg0qVLAIDmzZvDxMQE58+fx7p167B582YAKHH59sePH/Hu3btS6cgoI2RyT1H5zxpQU1MjTU1NTnr16kUJCQmUk5PD6fDgwQOJX6lnzZrF23Xua8x4KirCWQNJSUlkaGhImpqaNHnyZJn69urVq3K3V1FnPKmrq5OmpiY5ODhQQkICTxITE6XOeDpy5IjU3QEr4owngUBAv/32m0zXm814+rooux9llaIznjIzM2nIkCF0+/ZtkfMp6xlPqqqqnN0Vlpe2pW9mZqbEnYyKinDGU0JCgtidbIoj/I327duXl//x48fceQntSXh4OGlqatKECRN4dQh3tBJSs2ZNsra2FrFH4nZFESf6+vpUs2ZNysnJoVWrVkmc1VH8y19eXh5lZWVRQUEBpaSkkL6+vsL3RnR0tNS+IyKKjY0lR0dHibvQsBlP3x6KnH9JM56ISOy9HxUVxR0X3rsuLi4EyDbjyc7OTmb9QkNDKSEhgQ4dOsTZnmrVqvHGe5Lo1KmTXH0hbsZTfn6+TParLEVFRYU0NTUV3k3N1dVVxIYREe3fv5/Lo6OjQ3FxcTzbmZ2dTVlZWRJtwvHjx0lTU5OOHTtGCQkJ9OLFixL1UFNTI19fX27HrKysLEpMTKSsrCzKysqiiIgIMjIyIiMjI9LQ0CB9fX0SCAQEgIYMGVLitRXOeCov0dTUpHnz5hFR4XOieH8mJCRQZGRkuexKKo9UFsqyT3bu3Cn3TpiyznjS1tam2NhYiouLo5iYGO5eeP/+Pe+9tOgYSVExMDAgIyMjGjhwIOXl5Ym872zdulWp954kKTrjKTk5mbcSx8TEhGdnFZnxJJS+fftSXl4e9e/fn+7duydyTXv37k06Ojrc+35ubi5ne4rauNTUVN4uoyW9NzIpO5GFCrOrXV5eHrKzszk5e/YsjI2NcebMGS5Ps2bNsH//fri4uKBKlSq88kuXLi0xfpOzs3O56K2hoQEXFxdYWVkBAFq1aoWkpCRkZ2cjNze3XNqsyOTm5iI7Oxtv376FsbExT+zt7aV+Tfj555/x4cMHhdt/8+YNt0Ph14SI8OnTJwQEBCi8oxeDIeT48eO4dOkSJk6cWC7xJp49e8b9Pz8/n7O7siJrDLqQkBDcu3cPJiYmGDp0qMz1nz59GrNmzUJKSgqePHnCfRncsGEDZ0+qV6+O7Oxs7ktpSEgI7ty5gwYNGiAgIACfP3/m6vv06ZOIPUpPT4eLiwtq1KhRoi7bt2/Hq1evcODAAcycOVPmWR2qqqrQ1NSEQCCAnp4eL+aBvGhqasqU78cff8Tjx4+lXh8HBwe4uLjAxcWFm6Fhb28PFxcXXnBPxvdD0VmOwns3ICBArs1YZKV27dowNjbG0KFDOdtz+/ZtqTvafvr0CSkpKWWuz9egoKAA2dnZCu+mdv36dZ79srKyQkBAAMLDw7k8GRkZMDU15e2cp6GhAU1NTRGb8OTJEzx//pzTa+DAgTA2Nka9evVK1CMvLw+9e/fG5cuXkZ2djX///Rdr1qyBpqYmNDU1ERMTA39/fyQkJGDOnDnYuXMn2rZtK5OtdXJyKlf7k52djY8fPyIgIADOzs4izwRhv5b3BhUM+YmIiMCjR49k+v28e/dOrveAzMxMmJmZwdTUFObm5rx3lqLvpaUNKl67dm28efMGCQkJOHr0KFRVVb/J562+vj5u3rwJe3t72Nra4tq1a7zYulZWVgrH5MrJyeH6pWXLlrhz5w4CAgK498IzZ87A1dWVGxOpqalxtqeojZs4cSKMjY1x8+ZNETvJUDIyuadIebMGJk+eTLt27aJDhw7x9Fm4cCF5eHiQh4cHdejQgQDQhQsXuOPFZzwlJSWRiYkJeXh4kKOjo9x6qKmpkYeHB7Vr144AUNeuXcnDw4PXxvXr18nS0pIrI23WgJDymPEUERHB9Y+VlZXSvaCySufOnWnz5s0Sv2x8+fKFxowZU2IdoaGhYsumpqZ+lXOYN28e7dq1i5Pg4GCeHkFBQdS4cWOl97U0qSwoux9lleIxnrZu3UoREREi5yNtxpO5uTkdPHhQpNy7d++4e9LIyEhi+apVq9KePXtK7NOjR4/KHM9FKL1795Z6rYrPSpwxYwYZGxuXWG+bNm1o165dXJwTobi5udGuXbskxmTQ1dUlosK4c0JbOXLkSLF5N2zYQB4eHtSiRQuJekiLTxcYGKjwvbFlyxapfUdE5OTkRImJieTr6yv2+OPHj8nDw4OePHnCpb169Yo8PDzo9u3bdPr0ad5XYhcXF6mxWyqiVCYUOX9FZjypq6uLnW2spaVV5jOexMmbN2+ktiFLLKHiUlFmPH1NcXJy4mLOERXOStq1axf5+/tzaSYmJmRhYUGenp4KtaGqqkrLli0joNC2f/jwgU6cOEFqamrk4ODAPWvs7e1ltl8+Pj5Kn21UEaSyUB59s2nTJjp9+rTENp8+fUpNmjShV69eKRTjqTzlypUrUvvsW5jxJOTWrVsS4/r26dNHoXacnJxo165d3GzbESNGkIeHB82aNYv3XnXy5EmRNtPT07m4YcOGDVN6n32PIgsV3vEkFC0tLZo6dSpP0tPTiYjo9evX5O3tTe/fv+f0Fed4cnFxISKiGzduyB1krEqVKkREFBISQt7e3vTx40ciKlxCItSn+IuPMh1PQs6cOVPqAeHXlD59+pCBgQH98ssvtGHDBpHzkeXlTdmOp+LSpk0b7h6ZP38+EYkGb62IUllQdj/KKkUdT9euXaNHjx6JPZ/jx4+Tt7e3RDl+/LjYckWXZEgSHR0dOnLkiNQ+lRbkUZwo4ngqT1FXV6epU6fSvn37uPYLCgpo/fr1XF8KAzGbmJgQUeES5latWomtr0+fPvTlyxeJ5xYbG0tDhgyhfv36kbe3t8xL/YD/PX8eP37M2ZLExERe/Xv27KGVK1fSxIkTydzcnA4fPiy1v4vj7OxMmpqa3PkHBgZSx44dlf7bkFcqE4qcf2V1PBF9u0vtvra4uLjQ1KlTKTo6miZPnkxA4Uud0H6U9Ut5z549ydDQUOwxNTU1kfF7cftFVP5L7b4VqSyUR99oamqKTEQQEhwczH0cGjFihNwfx8pbSnI8paen09SpU8nV1VXpeoqTJk2a8JzZ0lDU8VRc4uPjRfpFTU2NVq5cydmSFy9eUEFBAY0bN45sbGxo6tSpVLt2baX32fcoMtkFWW8iZZ+MOGnTpg25urpy8uDBA07foo6nMWPGUJs2bTjHE5FscVKKiriv2QMHDizxC7iyHE9ZWVnk4eFBfn5+ZGtrq/TrpKiI212rNI6nr/lSK0m0tLTI1dVVoRf3ry2VBWX3ozzSoUMHcnV1pZo1a1LdunXl3sWFiOjZs2c8u+jq6kpjxoyh6Oho8vPzK3G2nZqaGnl6ekpt4+7du6We8TRo0CCRepXxGzU3N+f6qVOnTrzZlsHBweTn58fF2jpz5gxvVmtxCQsLK7HfoqKiKCIigqZPn17il33hCyJQ+IVXuKtVTEwM/fzzz7RixQpeTEMiosGDB1NwcDD5+vqSo6MjhYSESL2OxQkICKCbN2/y0pjjSbkocv6KOJ4EAgFnf3bu3MnlNTc3l+mFoyI6njZs2EC5ubkidQwZMoSLO1TZpVmzZgrHlSpPadGiBWd3t27dSkTM8SSUykJ59I2qqiqNGzeOiIg2btzIG+cU3R28Ikpxx9OhQ4c43eV9J1WGSHL4iaOsHE/dunUjPz8/mjFjBpempaVF6enp5OfnR8OGDaMGDRpQhw4dvhubXpFFJrugTANS1mJiYkKWlpZkaWlJJiYm9Ntvv1FeXh5njNTV1WnGjBmUl5dHsbGxZGZmRqqqqtS9e3feTS0UVVVVWrNmDUVGRlJubi7l5eVRQUEBLV68mGxtbaW+eMnieIqOjiYTExO5z7W44ykvL49+++03srS0JAsLC1JTUytxOc23IsLrJZwJkpOTQ5GRkRQZGUmtW7cmVVVVEZHkeCooKKArV64o/Zy+FaksKLsfSyNmZmaUkpJCgYGBnG2TJkWDPgpFTU2NJk+eTHl5eVIdCerq6mKnVQvJz89XaMZAr169qKCggPLz86lNmzakoqJCffv25Tl60tPTlf6SVLQvT58+zdmf/Px8Sk9P5+yPULZu3co9C6Q5ngoKCmjOnDklOp3CwsIoNjaWNmzYQKtXr6acnBxe4Ofk5GQRpxNRoeMpKCiIatSoQerq6tzzT/gMtLS0pLFjx/Kuo7jgpkKOHTtGmzdvrrBfYEuSyoQi579gwYIS65Q2205PT4/72FZSYHvh/TVs2LBSzy6QxfG0cOFCuQL8Vq1aVayNrGgzIb530dXVJUtLy0o/C01WqSyUV/+oq6uTpaVluW8aVdZS9B3V0tKyVBuOKEOMjIzo1atXMl37snI8mZiYUF5eHqWmppK7uzsBhY4n4Tvh7Nmzld4vTP4nMtkFZRuQ8hSBQCD2JcbY2JgePHjAvUAVFBSQl5cXAaBq1aqRtbU19evXj/Lz8+nLly8UERFBhoaGpKKiQiNGjKDExER6//49VatWrcT2ZXE8ff78WaFzO3HiBPf13MfHR+kva+V9DVVUVCgkJIQiIiI4ycjI4K5hUZFERXip/ZaksqDsfiytqKiolNmXHFnv/+K2Kzc3l/vdderUiW7fvq3QS8KcOXNowoQJXFlNTU36559/eG09e/ZM6X0uFKH9UVNTIzc3NyIqXF4t7Ash+fn5NGLECHrw4AF9/vxZ4r24Z88eqdfy7du3dPLkSRo5cqRMOwESEaWkpNCoUaNEHFpC2yn8u1u3bpzu9vb2pKKiQq6uriL1vXjxgkxMTL7ZL4iVCUXv2z179vCelxEREVx4AlmWeUpasktU6EC9du2ayP1VGinueCr6OxPKhAkTlH5vMWFS3lJZUHY/Mil7uXLlCkVERFBMTEyJ197Dw6PMHMnCd+8PHz5wM/Zr1apFERERNGXKFKX3CZP/iSyooRJDhY417m89PT00a9YMv/zyC5o1awagcDcDf39/AEDHjh2xZ88eWFtbAyjcQWXs2LG4dOkS2rdvDzU1NRgZGWHChAk4evRomeioqakJZ2dn3o4ysvDs2TNMmzYNnz59KhM9KipFr6GjoyPv2OrVq9GwYUNeWoMGDWBqasr9/enTJ4SGhgIovNaK7ijDYCiLsrxnZa0rMjISnz59grW1NW7duoWwsDB4eHhwx69evapQ+0SELVu2IDs7G4cPH8bEiROxcOFCnn4PHz5UqO7yQGh/dHV1MXv2bADArFmzsHXrVmhoaODcuXMQCAQAgLVr12LatGlIT0/H3LlzYWJigjdv3gAA2rRpg6CgIJFnkjgcHBy4/7dr1w6jR4/GnTt30KZNG4llNm/ejK5duyIgIAAvXrzg0otf74sXL8LGxoaXlpCQgGvXrgEo3DlWT08Ptra2GDduHJYtWyatixgVECLCqFGjRNL//PNPdO7cGXl5eaWq/8qVK+jatWup6iiOv78/b0fblStX4tKlS2XaBoPBYDAUp3PnzgAKd+jbuHEj75iOjg5atmwJANi1axdu3bqFd+/elbrNgoIC7N+/H/v37+fSXr9+LTKWYXwjfE+e66IxnoiItmzZQrNmzSIA5OXlRWfOnOEFPFy/fj1XNikpiYhkC9ArFFlmPKWmpiq8qwgTUfHw8KA1a9Zw0r9/f6Xr9K1KZUHZ/fityoABA2jNmjWko6NTZnUWnd0kDLRPRHTlyhVas2YNLV++XOnnLUns7OxozZo1EuP6jRs3jpKSkmj16tX0119/8aaaz5s3j6ysrGjhwoU0Y8YMsra2lqnNn3/+mdasWUNVq1Yt8R5fvnw5HT58uNQxUn777Tdas2YNzZw5U+n9XRqpTCij/5o1a0ZBQUESdaoMy/iZMKmoUllQdj8y+bpiamrKe/8SF/aBSeUWmezC92RATExMaMeOHdw5Fd1mu2HDhmRjY0P9+vWjvLw8Cg0NpWbNmnHHR40aRURl73hSdKkdEyblLZUFZfcjk/9JUcdTSkoKubu7k7u7u8iOoN+q9OvXj6ytrSkqKoqGDBkiclz4HGnfvr1c9ero6Ei8v589e0Zz5syh8PBwFpz3/6UyoYz+a9CgAQUEBEjUiTmemDApP6ksKLsfmTBh8nVFFgT/bxykIlxO8K1jYmICe3t7AEBQUJDYKeedOnXC3Llz0a5dOy5NRUUFjRo1wpcvX/D+/XuZ2ho/fjy2bt1aYp6oqChYWlrKrD+D8bWQ0TRUeCqL7aoMVKtWDVZWVgCAvLw8BAUFKVmjskddXR0NGjRATEyMyFJo4fMnNDQUaWlpMtepo6OD9PR0sccuXboEPz8/LF++HE5OTryldt8rlcV2AcqzXzVq1ICfnx8MDAzQqVMnAMA///wDNzc3GBsbIzExUSl6MRiVncpiv9jYi8H4vpDFdlXqGE/i+PLlC758+SLxuEAgwPLly9G+fXteekFBAR4/flze6jEYDEalJTo6GtHR0cpWo1zJzc2V+KyQ9vyRFyJCbm4uVFVVy6xOBgMAwsLCUL9+faioqCA5ORkAMHToUGhqanJ/MxgMBoPBYMjKd+d4kgYRoUmTJuXezqdPn5CWloa4uLhyb4vBYDAYlY9Pnz7h33//xcWLF5WtCqMSkpqayvs7MzMTmZmZStKGwWAwGAzGtwxzPH1F0tLScPnyZQDA4sWLERgYqGSNGAwGg8FgMBgMBoPBYDDKD+Z4+kosX74cERERIttPMhgMBoPBYDAYDAaDwWBUVr674OJfE3t7ezg7OwMAzp8/j5ycHOUqxGDIAQtwyWBUDMQFFy8oKMCoUaPg6emJ6Oho7Nu3D9euXRNZHvU9UllsF8DsF4PxvVFZ7BezXQzG94Ustos5nhgMhljY4IfBqBiIczzl5+ejSpUqsLOzQ0JCAuLj45WkXcWjstgugNkvBuN7o7LYL2a7GIzvC1lsl8pX0IPBYDAYDEYpyM/PR1paGgCgd+/eqFKlCrKzs/H69WvmdGIwGAwGg8FgVGiY44nBYDAYjApMQUEBzp49i2XLlgEAqlevXmm+ijMYDAaDwWAwKj9sqR2DwRBLZXmxZbaLURmwsrLCwYMH0b59ewCAra0tIiIilKxVxaSy2C6A2S8G43ujstgvZrsYjO8LWWwX29WOwWAwGIwKTmRkJMaPH49Nmzbh9evXSExMVLZKDAaDwWAwGAyGTLAZTwwGQyzsqxuDUfGoWbMmEhMTkZCQoGxVKiyVxXYBzH4xGN8blcV+MdvFYHxfsF3tGAyGwrDBD4PB+BapLLYLYPaLwfjeqCz2i9kuBuP7okwdTwwGg8FgMBgMBoPBYDAYDIY8sF3tGAwGg8FgMBgMBoPBYDAY5QJzPDEYDAaDwWAwGAwGg8FgMMoF5nhiMBgMBoPBYDAYDAaDwWCUC8zxxGAwGAwGg8FgMBgMBoPBKBeY44nBYDAYDAaDwWAwGAwGg1EuMMcTg8FgMBgMBoPBYDAYDAajXGCOJwaDwWAwGAwGg8FgMBgMRrnAHE8MBoPBYDAYDAaDwWAwGIxygTmeGAwGg8FgMBgMBoPBYDAY5QJzPDEYSqLHwR4Yd2acQmVb7GiBP678UcYaMRgMhnjSctJgttIMB58dlLvsl4wvqLKkCs6/OV8OmjEYDMb/WHF3BRz/dUQBFchd9q+rf6H5jubloBWDwWCUzMPIh9BYqIEPSR/kLnvx7UXoLtFFXHpcOWhWdgiIiJTR8J6ne+Bx2oP7W1NVE7YGtuhSswvmtJsDc11zueqbeHYidj3ZhcAJgXAyc+IdyyvIQ+OtjZGSnYIXk14gLiMO1b2rc8dVBCqw0rNCE8smmNd+HpyrOXPHBPMFAIAxjcZgR58dIu3OvjYbS+4sAQDE/R6H57HP4brXVSadaR5x/aCpqol3U9/BSt+Kl6fDng6Iz4jH80nPuTT7dfb4kPwBvzT9BRt6bODlv/H+Blz3uuLYwGMYUHeA2HY77OmAmx9uStVvXvt58OrgVWKe8MRw1NtUD30d++Jw/8Mix488P4LBJwbj3+7/YnKzyRh1ahT2Bu3ljutp6KG6UXW4N3DHL81+gaaaJgDA64YX5t+cDwEE+DD9A2wMbHj1pmSnwHyVObLysjC56WT82+Nfuc9L3n5U5FpJ4u7Hu2i/pz1CfgmBg7EDl15ABVjlvwqbH21GVGoUapnUwqw2szCk/hBeeZ9XPhjuMxzvpr5DNd1qUttjlB9lbcseRj5E8x3NsabLGsxoOYN3rO9/fXEm9Ax29dkFj0YevGPtdrfDu8R3iPw1EgD/dy6AALoaurDQs0Azq2Zwb+COzjU7i7Rtv84eTmZOODv0LC99f9B+jDo9Cp1rdMapwaegpaYFwXyBQr+9QfUGwXmLM4Y1GIbdfXfzjidlJaHOxjqwNbDFvTH3oCIQ/TYi/N1KY3ff3RjlPEpqvrob60JdVR1BE4N46T6vfPDT0Z/Qzq4dbo7in9uuJ7sw5swYXBp+CV1qdhF7DxhrG6O+eX30/KEnPJw9oKepx6tDaOPifo9DVZ2qXHpEcgQ67O2AxMxEXHW/isYWjTHq1Cgcf3kcaX+nibQlCTsDO4RPC0e7Pe0QEh+CkMkhMNEx4eWZeHYidj7ZiYBxAbznnjgW31qMXU934fUvr6GqosqlJ2Ul4Y8rf8AnxAcZuRloZtUMq7usRmOLxrzy0y5Mw52IO3g8/rFU3RnKoaxtGSD6LO1+sDvuf7qPkMkhIvUlZyXDcaMj9/u/9eEWbzylIlCBibYJ2tm1w0LXhahjWkdsm7c/3MaGhxtwN+Iu4tLjoK2uDceqjuj5Q09MaDKB167QdvWq1Qu+Q3x59bxPeo/q3tWxsvNKzGw1k5c+/+Z83PpwC5EpkTDUMkQtk1pwtXfFfNf5YnUS1iUL4dPCYW9oLzVfcf1KMw4WQABDLUM0t26Oue3moqVNS7FtPot5hrX31+LG+xuISo2CmooaHIwd0KVmF0x0mYgaRjW4vMLxXn2z+giaGASBQMCrq+gzREhcehwW3VqES+8u4UPyB+hp6MHe0B6u9q6Y034OdDV0S+yTlOwUVPeujlWdV4k8I8+EnoHXDS+8jHsJsypm8HD2wJz2c6CmosbliU6Lhv06exwdeBR9avcpsS1GxaI87ZcQNRU12OjboI1tG3h18OLd77Leu8Xfg6qoV4FZFTM0tmiMIU5D0K9OP5GxjyLjOQDwj/DHH1f+QGBUIPQ19TGo3iAs6bhE6u+oOMLxijTa27XHjVE3FKpTW00b9ob2+KnOT/ij9R/Q19TnjgXHBGP+zfkI+ByAmLQYmOiYoK5pXfSp1QdTmk/h8hUdHwoggL6mPmwMbNDSuiXGNBqD5taiTmXhez4AqApUoa+pj+pG1dHGpg0muExAXdO6YvXfGbgTq+6tQnhiOGwMbDC12VSeLorQeX9nWOpZYq/bXl76q7hXmHFpBu58vAMNVQ30rNUTa7qsgWkVU14+5y3O+LH6j1jTdU2p9ChP1KRnKV8WdFiA6kbVkZWXhTsf72Dzo804/+Y8nk96Dh11HZnrWdZpGU6HnsbEsxNx2+M27wG39t5aBMcG49zQc6iiUQVxGYXewCFOQ9Djhx7IL8jHq/hX2PxoMy68uYD7Y+/zBuFaalo48eoENvXcBA1VDV67h58fhpaaFrLysgAAdarWwf5++3l5Zl2bBV0NXcxuO1ui/tn52Vh2Z5mIA6Qktgdux6y2s2CpZylzGQCY3XY2xjYey/0dEBmA9Q/X4+82f/MGcg3MG0itq7pRdcxrPw9/XfsLHs4e6FKzC3csJTsFMy7NQHOr5vBs6smla6pqck68pKwknHh1AjOvzETA5wD8N+A/Xv2aapo4/Pww/mjNn91z8tXJMjsveftRkWtVnJX+K9GxRkee0wkodGQuu7sM4xqPQ1PLpjgdehpDTw6FQCDAYKfBXL6+jn2hr6mPTQGbsMB1gcJ6MMqOsrJljS0aQ0ddB3ci7og4nvwj/KGmooa7EXd5g+qc/BwEfA5A71q9efmt9a2xtONSAEB6TjreJrzFyZCTOPDsAAbVG4QD/Q5AXVW9RH0OPjuIUadHoVONTpzTqTjy/PbqmtbF761+x5I7SzCq4Si0t2/PHf/r6l+IS4/DhWEXxDqdAGBdt3VIy0nj/j7/5jwOPz+MtV3X8hw4rWxalXheQtrYtsHOJzuRnJUMAy0DLv1uxF2oqaghIDIAufm5vH66+/EuVAWqaGnNfzkT3gO5+bmITovGjQ83MP3idKy5twZnhpyRalMjUyLhutcVCZkJuDriqojzBgDa2bUTecaMPTMWzayaYXyT8VyaroYuBAIBtvbaCuctzph5ZSbP0Xcv4h62Pd6GX1v+KtXplJufC+8H3pjRYgbP6VRABeh5qCeCooPwe6vfUVWnKjY92oQOezrg8fjH+MHkBy7vRJeJWP9wPfzC/fBj9R9LbI+hXMrKloljU49NcNrshBmXZuBQ/0O8Y39f+xvxGfG4OOwi7/c/tdlUNLVqitz8XDyLeYYtj7fgxvsbeD7puciHl7nX52LhrYWoYVQDoxqOQg2jGsjKy8LjqMdYfW819gbtxbup70T0Ovv6LB5/fowmlk1K1P9twls03d4U2mraGN1oNOwN7RGVGoXA6EAsv7tcouPJVMdU5He7+t5qfEr5hLVd14rkVYTSjoNff3mNTY82wXWvKwLGBaC+eX1e/dsfb4fnOU9U1amKYfWHwbGqI/IK8vA89jn2Be3DuvvrkDk7k2cjACA4NhgnX51E/7r9S9Q/ITMBLttdkJKdgtHOo+FY1RFfMr/gWcwzbH60GZ5NPaW+MO96sgt5BXkiH+suvLkAt//c0MG+AzZ034Dg2GAsur0Isemx2NxrM5evmm419HXsi1X+q5jj6RulPOxXURsUGBWIbYHbcO7NOQR7BsNSz1Lue7foe1BmbiY+JH+A72tfDDg2AB3sO+D04NM8xwsg/3juafRTdNzXEXWq1sGarmvwKeUTVvmvwpuEN7gw7IJc5/9TnZ947ytpOWnwPOeJfo798FOdn7h08yryO/c299wMXQ1dpOWk4fK7y1h8ezH8wv1wd/RdCAQC+Ef4w3WvK2wNbDGu8ThU062GiOQI3I+8D+8H3iLOHudqzvit5W8AgNTsVLyKf4VjL49he+B2zGgxQ6xTpnONznBv6A4iQnJ2MoKig7A3aC82PdqE5Z2W49eWv/Lyb320FRPPTUT/Ov3xa4tfcfvjbUy9OBUZuRn4s82fcvcBUHi9roZdhf9of176p5RPaLenHQw0DbCk4xKk5aRhlf8qBMcE4+G4hzy/xIQmEzDzykzM7zBf5GNnhYGUxO4nuwleoIDIAF76rxd/JXiBDj07JHedR54fIXiBtj7ayqV9SPpAVRZXoUHHBnFp4YnhBC/QyrsreeXPhJwheIHGnxnPpcEL5PafG6nMV6FTr07x8t/9eJfgBep/pD/BCxSXHidWr3ob61H73e3FHhP2g/MWZ9JcqEmRKZG84+13t6d6G+vx0uzW2lG9jfVIbYEaTTk/hXfsevh1ghfo2ItjYtsTx7EXxwheoOvh12UuU5Tc/Fyqv6k+1fSuSRk5GVz6L+d+IbUFahQUHcSljfQZSVUWV+GVzy/IJ5dtLgQvcOc/7/o8ghfopyM/kfMWZ5E2O+/rzPX75HOTFToveftRkWsljpi0GFJboEY7Hu/gpX9K/kTqC9R551NQUEBtd7Ul6zXWlJefx8v/y7lfyG6tHRUUFEhtk1F+lIctc93jSuYrzXlpIXEhBC/Q0BNDqfaG2rxj/h/9CV4g7/veXJqk+zEvP48mnZ1E8AL9cfkP3jG7tXbU82BP7u/DwYdJdb4qddrXiTJzM3l5S/Pby8zNpJreNan2htqUnZfNnYPAS0C/XvxVbBlJrLy7kuAFCk8Ml6uckL1P9xK8QOdfn+elt9jRgoaeGErwAt2LuMc7VmtDLWq0pRH3t6R7gIjoWtg10l6kTXZr7Xj2UWjjhM+NyJRI+mH9D2S4zFCkHnF2syhVFlehkT4jJR7/++rfBC/QjfAbRESUk5dDTpucyHatLaVlp0ksJ+Tky5MEL9DbL2956cJnblE7GZsWS4bLDGnI8SEi9ThtcqIRJ0dIbY+hHMrDlol7li6/s5zgBbr09hKX9vDTQ1KZr8KzSZLGM5sDNhO8QMvvLOel/xf8H8ELNOjYIM6uFCUpM4nmXZ/HS2u/uz3ZrrUlo2VG1PtQb94xcWPFSWcnkdoCNXqf+F6k/pi0mBJ6QpSeB3uS3Vo7ucpI06+04+ALby4QvECeZz156Xc/3iXV+arUbnc7SslKEdElMzeT/rn2D2+cMtJnJGkv0qZaG2pRg80NRMYqxZ8hK+6sIHiB7n68K1J/clayyDNIHA02N6DhJ4eLpNfdWJcabm5Iufm5XNrsa7NJ4CWgV3GveHmPvzhOAi8BvUt4J7U9RsXha9kvIqL199cTvEBLbi0hIvnu3ZKe50tvL+VsWFEUGc91P9CdLFZZUHJWMpe2/fF2EdurCHHpcQQviNhTeSg+BhLy05GfCF4g/4/+RETU42APMl1hSomZiSJ1FLe5xcewQjJyMsjtPzeCF2jTw028Y5LGsvHp8dRyR0uCF+jc63O8ukyWm4i0M+zEMKqyuAolZCSUfOISmHp+KtmutRWxk55nPUl7kTZ9SPrApV15d0XEzhMV9ofqfFXaGbhTIR2+BhUuxpPwS2h4UjiX9i7hHd4liH6hKs6geoPQ44ce+OvqX4hNjwUATLkwBeqq6vDu5q1Q2wBgpWeFdnbtcOg5/+vcwWcHUd+svsiUZkX4u83fyKd8LLuzTKb89ob2cG/gju2B2/E59XOp2xdHclYyQuJDkJyVXGI+NRU1bOu9DeFJ4Vh0axEA4PHnx9j0aBN+a/mb1K/8KgIVdLDrAKBw6nhRhjoNxdPopwiJD+HSotOi4Rfuh6H1h8p/UsVQpB/lvVbFOff6HPIK8tCpRide+unQ08gtyMWkppO4NIFAAE8XT3xK+YR7n+7x8neu2Rkfkj/gafRThfRglC+lsWVtbNsgJj0GbxPecml3I+5CX1Mf4xuPR+iXUMRnxPOOCctJQ1VFFeu7r0dd07r4N+Bfib/voy+OYvjJ4ehg3wFnBp8RO9NJUbTUtLC552aEfgnF0ttLkZufi/Fnx8PGwKbMZvDFZ8QjJD4EGbkZJeYT9pmwDwEgKy8LgVGB+MnxJ9QwqoG7H/93LC49Dq+/vJapr4HC+2BOuzn4kPwBB54dEJsnKjUKrntdEZsei8vDL8PF0kWmumVlTvs5qGlUExPOTkBOfg5W31uN57HP8W/3f1FFo4rU8qdCT8He0B41jWvy0o+/PA7zKua8L56mVUwxqO4gnA49jey8bF7+zjU6w/e1L0g5K/wZClIaWyaOX1v+igbmDTDp3CRk5WUhvyAfE89NhJ2BHeZ1mCe1fFvbtpwORZl7Yy6q6lTFzj47RWanA4CBloHY8AF6GnqY0WIGfF/7IjAqsMS23yW+g7W+NewM7USOmVUxk6q7LHxM/sgb88hDacfBXN8m8vt2/s35EAgEOPjTQbFf0rXUtLDwx4Uis51UBCr4p+0/eBbzDD4hPiW2/S7xHVQFqmhh3ULkmL6mvtRnUHhiOJ7FPEOn6vyx1cu4l3gZ9xLjm4znLaub1HQSCITjL4/z8gvHZqdDTpfYHuPboKztl7g6S3vvCvmrzV/oUrMLjr04htdfXkvNL2k8l5KdgithVzC8wXDezCn3hu7Q1dDF0RdHZdJHXnLzcxESH4Ko1CiF6/jRvljfJrxDPbN6MNQyFMkrq83VVtfG/n77YaxtjMW3F8s0BjHRMcF/A/6DmooaFt9ezKVff38dXzK/8N7VAGBy08lIz03HuTfnZNKpOKdCT+HH6j+KLEk+8eoEetXqBVsDWy6tU41OqGVSS+Q6mlUxQwPzBjgdWnFtV4VzPAkfdiba/4tF0XFfR3Tc11Gm8pt6bEJOfg5mXJqB0yGncSb0DJZ1XCZTHByu7WJxMIBCB4hvqC+3xCOvIA/HXh4rE+cHAC7OkTwOkNntZiOvIE9hB4g0fEJ8UGdjHamDBQBoYd0Cni6eWOm/EsExwZhwdgLsDe0xr730QSQg/roDhctKrPWtcSj4f06/I8+PQFdDFz1/6CnH2UhG3n5U5FoVxT/CHybaJiID1ydRT1BFvQrqVOXHrWhm1Yw7XpQmFoVLAoq+MDMqDqWxZUKnxp2Pd7i0ux/vooV1CzS3bg51FXX4R/xvOu7diLvQ09BDQ/OGMummqqKKIU5DkJGbwWtDyImXJzDs5DC0s2sH3yG+0FbXlqleeehcszOGOA3B0jtL8cv5X/A89jk2dN8gkyNEFv59+C/qbKyDh5EPS8xXw6gGLPUsef0QEBmAnPwctLJphVY2rXi/MWG/y+p4AoARDUcAAC6HXRY5FpMWgx/3/YjotGhcGn4JTa2aylyvrGipaWFTz00I/RKKSecmYcHNBejn2A+9a/eWXhiF5yxu2d+T6CdobNFYZFlkM6tmyMjNEBk4N7FogqSsJLyIe6H4yTC+OqUdlxVHTUUN23oVfqxaeHMh/n34LwKjArG552aZlsIIP1AZaRtxaa+/vMbrL6/hVttN7vglADCtxTQYaRnB64ZXifnsDOwQkRwBv3A/uduQFXcfd9TZKD5+lSyUZhzM9a3W//o2IzcDfuF+6GDfAdb61nLrM7T+UPxg/AMW3FxQ4gufnYEd8ikf+4P2S8xTEkLbXNxWCcdOxR36lnqWsNa3xpNo/tjKQMsANY1rsrFVJaGs7Ze4Okt77xZlRIMRIBCuvLsiU35x47ngmGDkFeSJ3PMaqhpwruYscs+XFZGpkaizsQ5mXZulcB0ifWtoh8efH+N5rPT4uSWhq6GLfo79EJkaiZdxL2UqY2tgi/Z27XH/032kZKcAkGxPmlg2gYpAReRdTRYiUyLxMfkjGldrLJIemx4r9mNkM6tmYq9jE4smvPeDiobSHU/JWcmIz4jHp5RPOPL8CBbcXABtNW30qtVLofrsDO0wv8N8HAo+hNFnRqO1TWte3IuiZORmID4jHjFpMbj5/iZGnRoFABhYd6BI3gF1ByCf8nEq5BQA4PK7y4jPiMcQpyEieRVF6ABZfme5TPlrGNXAiAYjsD1we6m8y2XFko5LYFrFFB32dsDjqMfY1GOTxBfW+Ix4xGfE413COyy9vRSnQk6hgXkD1K5am5dPIBBgcL3BOPz8f4HLDwYfxE91fuICkZcWRfpR3mtVlJAvIWIDh0alRcFc11zE222hZwEAIk4uK30raKhqyGxAGeVLWdqyltYtoSpQ5TueIu6itU1raP0fe+cd1lTy9fFvSIDQQUCkIyCiYsWKlbWvlVXXjm1ta19dXVfXtayuFXvvBWyr2LtYsVdEpQgWOtKRnmTeP3hzf1ySQAIJAZzP85zngblzZ87Mvfdk7rkzZ3h8NLVsKtUpVfxrc0mIZ2oW/7L9Mv4lhpwagnZ27XBh2AWVOJ3ErO++Hrqautj1Yhf6u/ZXW0yNtrZt8STmCQqEBQAK+7q2cW1YGljCw4bteBL3uyKOJxtDGxhpG0n9wtrLrxdiM2NxdcRVqYEvlUU3p24Y6jYUe1/uBU+Dh009N8l1nkAkQERKBGobSwZGjsuMg6W+pUS6LJslDsRKbVblRtnjMmm0smmFX5v/ijUP1mDhrYUY6jYU3Z27S82bmZeJpOwkxGXG4eqHq5h5dSY44GBAvf/FDBLPECo+A50Qwow3xCIQCSTqMNQ2xMzWM0ud9TS91XRocbXQ+VBnNN3ZFDOvzMTZkLOlzqysSMo6Dr7/5T4TnLno5jQfUj5AIBLAzVxydn9KTgqrb/OF+RJ5uBpcLOywEK8TXjNjaGmMbToW5rrmGH12NOptrYfJFybj6Jujpc66FyO+B2qbsG1V3LfCcZ1UW6VvKfUDoqOJI7VTVRRV2K+iNuhS+CXMuDKj0Ab9f9yy8t67RZE1NlPknLLc8+pCbEM+pX3Crue7sO3pNljoWaC9feHsyzlt5iC7IBtNdjSBx14PzLs+D9cirjHjNUUoa9+KiIhxysd9iwOXw5WYbaXF1YKpjilivynet2W1XSk5KRIzyx1NHJGUncTMeK1sqD24eJfD7Cmx9kb28P3Jl7Vj2KeZnxQqc2brmTgUdAjBicHY2XunxIu8mL9v/42/b/9vRo6htiFWdVnFWjYgxkTHBD2ce+Bo8FGMaDQCfm/84GHrIXW6dVkRO0B2vdiFP9r9wQzeS2Jhh4U4HHQYK++vxMaepU+jVoTRTUbLtSuUGENtQ2zovgE///czBjcYLHMQmVWQBfM17OCZHrYeEoE3xQxrOAxrH67F05inMNExwdPYp1jReYXcesmDov1YlmslJjk7WWJHPADIEeRAmyvpTBNP0c0R5EgcM+GbsJZcUdSHMm2ZgbYBGlk0YpwcSdlJCE0OZQJmt7VtyzhDwpLD8DX7q0KOEADMrIDMvExWekpOCgQiAWwMbaDDU53TCQB0NXWhq6mL1NxUdHPsVvoJCrC40+JSd+UU086uHU6+O4nncc/R2qY1AqMC/9fXdm2RmJWI8ORw1DGtwzilFN3UQV9LH5n5mRLpCVkJqKFTQ+rAQtmIg6/XN68v98yFlJwUEBDWDAgxOYIcqR8AZNks8QwVarMqN6oYl0ljeefl+O/9f8guyJYIsF2UsefGsv4XB+ouOjtQ/DW6+Gyn9Lx0ifHG0/FPpX5BntFqBjY82oAld5bg7BDpSxUa1GyAV5NeYdndZbgQdgGv4l9h4+ON0NfSh083H4x3H19yo+VA3l2hSqKs42B9LX2s67aO5XiS1bcA4LjREel5/3u5lrWj8vCGw/HP3X+w9O5S9HftL1UfC30LvJ70GkvvLIV/iD92PN+BHc93QIurhYXtF2Jhh4Uy2wEAyTnJ4GnwJPTMKSi0Q7Jslbh9RTHhm5Rp5gJF/ajCfkmzQQf7H2TsSHnv3aLIGpspck5p97z4uLJxMHYA+VuxpfR1t7AnHDQwb4CD/Q8ys1+7OnXFw3EP8e/9f3E14ioeRj/E6gerYa5rjj199yj0wVJZfSttKTdQ9r5NzkkGAIlxVmnXEZAchxUdZylr+bcyUbvjaeuPW+Fi6gKeBg8Wehaoa1ZX5m5G8sLV4KJprabMulBZTGg2AYMaDIIGRwPGfGM0MG9Q4iyaYW7DMNJ/JL6kf8GZkDNY3XV1ufSURnkdIOpGPBAsKUYJn8dnti3W5mqjtkntEl+Cmlo2hauZK/ze+MGYb4xa+rWUvitSWfqxPE4/adPNdXg6yBPmSaSLd0yU5gQgIHL/mFFUi7JtWTu7dtj8ZDOSspPwIOoBK36Ah60Htj3dhjxBHhN/SFHHk3jZcPF4HZ1rd4adkR22P9uOGvwaSndoF2VBwALEf4tHPbN6+Pv23xjiNoS1fKaiYOI8fQlEK+tWeBD1AP94Fsarc6vpBkNtQwRGBcLWyBbP455jcIPBCtfxLf+b1EHAEa8jGOE/Al0Pd8X9sfdVNlB4FvsMW59uhVtNNzyOeYwjQUcwotEIuc8nkGGzBPLbLLHd44DarMqMKsZl0jDUNkRd07pIyk4qcavzRR0Wob19e3zL/wb/EH8cCz4moY+BVqEdK7rjJVD40nB9ZOGSlWsR17DmwRqZ9RjxjTCz9Uz8fftvvIx7KdMWuZi64LDXYQhFQrz7+g4Xwi5g9YPVmHBhAmqb1JaI36gOFB0H5wpyEfAxAJseb4JQJGTlkdW3AHB2SGFsytfxrzHn+pwS9VnYYSFGnRmFMyFn4FXPS2o+SwNLbO+9Hdt6bUN4SjiufriKVYGrsOj2IlgaWLJ2T5UX8axdWbZK2qxeOraquqjCfoltEJfDhZmuGeqZ12PFCwOUd+/KGpspck5Z7nl1cernUzDUNoSmhiZsDG0kYkkChe+WpwefRr4wH6/jX8M/xB/rH63HwBMD8WrSK9Q3ry9XXcrqW2kzO4Hy923xcVZp1xGoeuMstS+1a2ndEl0cu6CTQyfUM6+nksGNLOqY1kEXxy74ofYPaGbZrNSlW33r9oU2TxujzoxCnjAPPzf4Wek6OZo4YkSjEdj1Ypf8y77a//+yr0DFl32pAy6Hiy6OXdDFsQva27eX68v7MLdhOP72OPyC/TC4wWCV3CeK9mNZrhVQGEMsNTdVIt1S3xLx3+IlnFLisqXNsEjLTYOZjplEOqXiUbYtK+oMCfwSiIYWDZkvLx62HsgT5uFp7FPc/3IfPA2e1KCWJSFeL190i1wxW37cgiFuQ7DpyaZSY56UFbEjZFrLaTg28BhSc1Mx70bZtqEtL40tGsNAywD3o+4jJCkEKTkpzIwnDY4GWlm3wv0v95nYT4o6+aIzopGely61rzs6dMSJgSfwMe0juh/pXqap+aUhFAkx4fwEWBlYIXBsoXNt9rXZSMtNK/XcGjo1wAEHqTlSbJaBJTMVvCiybJbY7olnXlEqJ+ocl0mjoUVDdHHsgv6u/XGw/0H0rdsX48+PR1R6FJPH1cwVACTigPA0eMx4Q56XkxmtZsCYb4wld5aUmperwUVDi4aY334+/AcXxsL0feOrSNPUjngc3NulN3y6+2BW61n44+YfeBb7jMnjXMMZPA0egr9Kxljp6NARXRy7wN3KvdS6hjccDucazlh6t+RYT0BhmAUXUxdMazUNd8fchQZHo9S+NdUxhUAkkJjNIJ5NKtVWfYuTOrZKzUmldqqKogr7JbZBnrU90dCioYTTqShluXeLUtLYTN5zynLPq4sO9h3QxbELOjp0lOp0KooWVwstrFtgRecV2N5rOwpEBTj59qTcdZW1b7kcLhNuwFLfEkIilFjKli/MR3JOMqz0Fe9bcTyr4uOs0q5jDZ0aEr6Lyj7OUrvjqSqho6mD/q79cfvTbXR17Kqyi7qw/UKFHCBONZwwotEI7Hy+s1LEelIFwxoOQ9y3OIQlhyktoHtxytKPil4rAHA1dcXH1I8S6U1qNUF2QTbeJ71npT+OecwcL0pMRgzyhfmoZ172IKSUykvRAOPi+E5irAysYG9kX+iUigpE01pN5QrKK0YoEsLvjR90NXWlOlE0OBo41P8Qejr3xJI7S7DpsXzxgBSpX+wIWeq5FI0sGmFGqxnY82IPHkY9LL0AJcPVKJxNFvglEPe/3IehtiEaWjRkjosDjCuye2BRxAFHuztJX37cp24f7Ou7D6/jX6P30d5Knwa/6fEmvIx/ic09N8NQ2xA7eu9AcnYy/rhR+uxOngYPTjWcJHZ7BQpt0ou4FxARESv9ccxj6GrqwsXUhZUutnvUZlHKw8rOK5EryGXtNFTXrC7q1KiDM6FnkJWfVeayjfhGmNlqJs6GnlVoqZV4lndVH4Mt6LAABloGWBiwkEnT09JDJ4dOuPPpDmIyYspcNleDi4XtF+JV/CuFdl1yNHGECd+k1L4VOx+L2yrx2KmoMw0ojEEXnRGNJhZNJMr6mPZRYqMXCkVR5L13i3I46DA44KCrY1e58ksbz7nVdANPgydxz+cL8/Eq/pXUe76qwdhcKU4ZaYhnzNoa2sr9bH9J/4I7n++gjW0bZsaTLHvyLPYZREQk8a4mD7Jsl7WhNcx1zSXqAoAnMU+k1vUx9SPMdM1grmcucawyUCUcT+Xd9lKZzGkzB393/Bt/dfhLZXUUdYDEf4uX65yF7ReiQFiA1Q+Ut/wvPTcdIUkhKvkCryhONZywofsG/Nv5X2aXN1WgaD+W5Vq1sW2D1NxURKZGstL7ufaDpoYmtj3dxqQRQrDj2Q5YG1gzMzDEPI97DgAS6ZTKiyK2zMrACrWNa+Pmx5t4FvtM4jp72HrgTOgZhCaHKuQIEYqEmH55Ot4nvcf0ltNZW+0WRZOrif9+/g9tbdti5pWZStmtRYzYEbKpxybmx3xJpyWwMbTBpIuTpAb/VZSk7CSEJIXIHfS3nV07fM3+iv2v9qOVdSvWV1IPWw+EJoXibOhZmOqYKvRCEvAxAMvuLkNt49oY3mi4zHwjG4/Ehh4bcP/LfQw4MaBMgTOlEZUehUW3F6Fv3b7o79ofQOHAaXqr6dj9YjceRz8utYw2Nm2kDnwG1huIhKwEnH5/mklLyk7CyXcn0celj8SXuOdxz2GkbYQG5rKX/lCqBuoclznVcMKA+gNw4NUB1u/u4k6LkZSdhPHnx0t9fuTZQhsojI9kzDfG0rtLJY7d+3xPatmXwi8BAOqa1pU4pihf0r8wwWYrGmO+MSa6T8TViKt4Ff+KSV/UYRGERIgR/iOkLrmTt29HNBoB5xrOUmeUPY5+LNVp+CTmCZJzkiU2nylOG9s2ACRfCBvUbABXM1fser6LtYxw+9Pt4IAjEZMqPTcdESkRdGxVjVG2/SrvvStm5f2VuBZxDYPdBqOOaZ1S88sazxnxjdDFsQuOBB1hzQA8/PowvuV/w6AGkptoKYMCYQFCkkKU6oC/9fGWVPuiiM3NKcjBSP+RSMlJwYL2C+RaRpuSk4Khp4ZCKBJiQfsFTPoPtX9ADZ0a2P5sOyv/9meFu7L2clF8x3VrQ2vYGtpKHWcNqDcAF8IusGb43oy8ibDkMKmboT2Pe442Nm0U1qGiUHuMJ3kQb3mpjGCW5aVxrcZoXEu+LcvLw4L2C3D49WGEJofKNUgXO0AOvj6oNB38Q/wx5uwY7O+3X6Eg46piRusZKq+jLP2o6LXqVacXeBo83Ii8wdppxsbQBjNbz8SaB2tQICxAC+sWOBNyBve+3IPvT74SO5Zdj7gOOyM7NK3VVP4GUtSKorasnV07HA4qdPgUnfEEFDpDxLs9ynI8peel40jQEQCFuxd9SPmA0+9PIyI1AkPchmDZD8tKrF9XUxcXh11ExwMdMfbcWBjxjcq985zYEdLHpQ8rzoeelh429tiIn078hI2PNmK2x+xy1bPlyRYsubMEt0bdQieHTqXmF/fhw+iHWNxxMetYa5vW4HA4eBT9CH1c+sgctFwOv4yQpBAIRAIkfEtAwKcAXI+4Dntje5wbeo4JBimL6a2mIyUnBUvuLIH3GW/4/uRb7mUC0y5PAyEEm3tuZqUv6bQEJ96ewKSLk/Bs/LMSd0TsV7cfDgcdRlhyGGsW08D6A9H6cWuMOTsG776+g5muGbY93QahSIglnSRfLK9HXkefurL7j1J1UPe47HeP33Hi7QlseLQBK7usBFA4Mzo4MRj/3v8XT2KeYIjbENQ2ro2sgiwEJwbjaPBRGGgZSA2UXxQjvhFmtJoh1TmyKnAVnsc9x0+uP6GRRSMAwIu4FzgUdAg1dGpgZuuZ5W6bt7837ny+o3CQXmUxo/UMbHi8ASvvr8SxgccAAO3t22NLzy2Ydnka6myug+ENh8PVzBX5wnyEJYfB940vtLhaqKVfq8SyuRpcLGi/gNk9ryiHgw7D940vvFy94G7pDi2uFt4nvce+l/vA5/HxZ7s/Syzb0cQRbjXdcCPyBsY2ZQeDXtN1Dfoe7YtuR7phSIMhCE4MxpanW/BLs18kZmDeiLwBAoJ+dfvJ012UKoiy7Zei965AJGDGZrmCXHxO+4xzYecQlBAETwdP7Oq9S6IORcdzy39YDo+9Huh4oCMmuE9AdEY01j1ch25O3dDDuYdS2l2cmMwY1NtaD6Maj8KB/geUUua0y9OQXZANL1cvxuY8iH6A48HH4WDsgDFN2bYkJjOG6adv+d/w7us7nHx3EvHf4jG7zWxMbD5Roo6w5DAcCToCQggy8jLwOuE1Tr47iW/53+DT3YfVXzqaOljmuQxTLk3BoJOD0N2pO+59uYcjQUew/IflqKFTo0zt7Fe3H/xD/EEIO77cn+3/xMl3J+F50BMzWs3At/xvWPNgDRrWbIgxTdhtT8xKRFBCEKa0mFImHSqCKuF4+h5xruGssANkYYeFOBJ0BEIiLD0zRSaK9qOi18pC3wI/1vkRJ96ekNjieGWXlTDhm2Dn85048PoA6tSogyNeRySWF4qICKfen8K4puPoS1w1Rux4sjawlthBs6gjSpbjKTojGiP9RwIoDLJrqW+JNrZtsL3XdnR1km8atxHfCFdHXEW7/e0w+L/BuDz8MjradwRQGK9NUcSOkC0/bpE45lXPC71demPxncX4ucHPsDWyVbj8stLapjV4GjwIRAKJL92G2oZwq+mGoISgEmeXLbq9CEBhHIIaOjXQsGZDbOixAWOajJE7mOXiTouRkpOCzU82w1jbGNt7bwcBKdExJIszIWdwNvQs1nZdCzsjO9YxA20DbOyxEQNPDsSmx5swq80smeX0qdsHZrpmOPH2BBZ2+N8SHK4GF5eGXcLv13/HpsebkCPIQQurFjjQ/4DEF96QpBAEJwZjQ/cNCreDUnURf6kui60oieZWzdHJoRO2P9uO+e3mw4hvBABY0XkFujt1x5anW7Dv5T4kZSdBR1MHLqYumN1mNiY1n1SqcwQonPW04dEG1o5tQOFLgN8bP9z5fAe+b3yRXZANSwNLDHEbgr86/CWxHbYqUVXfWhlYYVjDYTj8+jAiUiKYuCuTW0xGG9s2WP9oPfMip6mhCacaThjVeBQmN59caowWoHDW0z93/5HY0nyi+0Toauri5sebOBt6Fhl5GTDXNUc3p26Y324+mlqW/pFtbJOxWHR7EXIKclhBfnu79Mbpwaex5M4STLs8DeZ65viz3Z9Y1HGRRBkn351EO7t2crWFQgEUv3fzhHnM2ExXUxc19WrC3dIdizosglc9L6kfnBQdzzWzbIYb3jcw78Y8zLo6CwZaBhjXdBz+7fyvCnpAdaztthYn357EpQ+XsOvFLuQL82FnZIdfW/yKhR0WwphvzMr/Kv4VRvqPBAccGGgbwNbQFn1c+uCXZr/IXDFzPfI6rkdehwZHA4bahqhtXBujGo/CBPcJUmMD/triV2hqaGLdw3U4F3oOtoa2WN99PWa0KvsEibFNx2LL0y0IjApkjTNtjWxxZ/Qd/HbtN/xx8w9ocbXQq04vrOu2TmJW+en3p6HN01ZJDGplwSHyzo+lUChK497ne+h0sBNCpoTINZ22OGdCzmDYqWGImB4BSwPVb8NOoRQlIy8DRiuNsLD9wlJnTVHKz0/Hf8LT2KeImhVVemYVsezOMux/tR/h08LL5ASbeWUm7n6+i+cTnlNn+XfEudBz6HesH26MvIHOjp3VrU61IighCI13NMaePnswrtk4datTKUjPTYfjJkes7rK6TH0S/y0etTfWxrEBx9DPlc54olAoFUfnQ51hZWCFw15lC23RdGdTdLLvhPU91itZM+VRJWI8USjVjfb27dHNqRtWB5YtJteqwFWY2nIqdTpR1MLTmKcAIPcWtpSyIyIivIh7ofa+ntVmFr7lf8Ox4GMKn5ucnYw9L/bgnx/+oU6n7wxqK1QH7VtJjPhGmOsxF2serJHY9EAeNjzagIY1G1KnE4VCqXBW/LACx4OP43PaZ4XPvfLhCsKTwzG//XwVaKY86IwnCoVCochFUEIQbkTegM9DH+QKchE5I1JmcHJK+cjKz8LR4KM4E3IGF8MvwvcnX5Xt6EmhKJtrEddw59MdrHu4Dh3sO+DayGvqVqna8DDqIW59uoXVgatRS78W3k15p5Qt4ykUCoVCUSU0xhOFQqFQ5OL0+9NYeX8lmls1x/ru66nTSYV8zf6KiRcmwtbQFmu6rqFOJ0qV4t/7/+JF3Av0rdtXajw3StnZ+XwnTr47ifZ27bG552bqdKJQKBRKlYDOeKJQKBQKhUKhUCgUCoVCoagE+pmEQqFQKBQKhUKhUCgUCoWiEqjjiUKhUCgUCoVCoVAoFAqFohKo44lCoVAoFAqFQqFQKBQKhaISqOOJQqFQKBQKhUKhUCgUCoWiEuTe1Y7D4ahSD6VTo0YNNG3aFMHBwXBwcMDt27fB5/OZ4+3bt8f9+/fVqCGFUrmpLvsOVDXbRaFQykd1sV0AtV8UyvdGdbFf1HZRKN8X8tguuR1PVQ13d3dcu3YNR44cQefOnRmnU3BwMK5fv47Y2Fg1a6hcGjVqhM6dOwMAtm3bhry8PDVrRKFQKBQKhUKhUCgUCuV7h0PkdK1XFc81h8PB3r17YWNjg65du7KOffr0CcOHD8eDBw/UpJ1y6Nu3LwYMGMBKq1u3Llq1agWgcLZXamqqOlSjVCPoVzcKhVIVqS62C6D2i0L53qgu9ovaLgrl+0Ie21XtHE8aGhrIz88Hl8tl0oYMGYIPHz4gKysLISEhatSubOzYsQPNmzdn/re0tISVlZXM/NTxRFEGdPBDoVCqItXFdgHUflEo3xvVxX5R20WhfF98N0vtvLy84OzsjM2bN+Pp06fgcrkQiUQQiUTg8Xh4+/YtgoOD1a2mTIrGnrp+/Trc3NxYx/X19cHj/e9SCQQCiEQiaGgUxoa/e/cu+vXrxxxPT09XscYUCoVCoVAoFAqFQqFQKKVTLRxPmpqaWL16NVavXg2g0DFz6NAh3L9/H3PnzkV+fr6aNZSNpaVlifGmEhMT8eHDB1bajh074OTkhIkTJ+LFixfo2LGjqtWkUCgUCoVCoVAoFAqFQlGYauF4io6OxunTp9G2bVtYWFggPj4e48aNAwDs379fzdqVjfT0dNy8eRP79u3DxYsXZeabPXt2BWpFoVAoFAqFQqFQKBQKhSI/1SrG09ChQ7F9+3ZkZmbC1taWdWz27NlYt26dmjSTjawZT69evULTpk3VoBGFUgiNM0ChUKoi1cV2AdR+USjfG9XFflHbRaF8X3w3MZ7EODs7Q0tLC2ZmZvD39wcArFu3DgMHDsTEiRPRrl07AMCePXtKnEVUUezYsQP29vbqVoNCoVAoFAqFQqFQKBQKRSVoqFsBZdKmTRv8+OOP6N69O/r374/+/fvD1tYW69evh0gkQv/+/SEQCBAYGKhuVQEAXbp0wapVq9StBoVCoVAoFAqFQqFQKBSKSqhWM5769euHgoIC2NjYMGn6+vrIyMhA06ZNsXPnTgwdOhQCgUCNWv6P+vXrw9TUVN1qUCgUCoVCoVAoFAqFQqGohGo146mgoEAibdeuXUhJScGTJ0/g6elZaZxOAJCfn4+CggKEhoaqWxUKhUKhUCgUCoVCoVAoFKVTrRxPYrKysrB//348e/ZM3aqUSlJSEvr3748nT56oWxUKhUKhUCgUCoVCoVAoFKVSLR1PqampGDt2LCZOnIjnz5+rW51SCQkJwcSJE6uEo4xCoVAoFAqFQqFQKBQKRV6qpeNJzIsXL5hlbPr6+ggICMDvv/+uZq2k4+zsDFtbW3WrQaFQKBQKhUKhUCgUCoWiNKpVcHFpiEQiCIVCcLlceHp64uPHj+pWSYIOHTpg7969MDQ0VLcqFAqFQqFQKBQKhUKhUChKo1rPeAIAb29vaGlpITw8XN2qSKVmzZo4efIky+lECEF8fLwataq8aGpqwsTERG3183g8uhMhhUKhUCgUCoVCoVAoclLtHU+EEIhEIrRo0QIAYGVlhc6dO8PY2Fi9iv0/iYmJ6N69O8LDwxEcHIybN2/i/Pnz6Nmzp7pVUwtNmjSBjo4OPD090aRJE9YxLpeLcePG4dixY2pblujo6IgzZ86gc+fO6Ny5M3R0dNSiB4VCoVAoFAqFQqm81KpVC3Z2dupWQy4sLCxgb2+vbjUo1RgOIYTIlZHDUbUuKoXP52PFihVwc3ND165d0b59e9y/f1/dajF07NgR3759qxLB0FXJxYsXMX36dISEhODjx4/Yvn07c0x8DQHgzJkzmDZtGqKjo0ssr3HjxhAIBHj79q1S9HNxcWHihgHAP//8g6ioKFy6dAnOzs64ffu2UuqpDMhpGio9Vd12USgUxagutgug9otC+d6oLvarqtsuLS0tTJkyBcHBwbh+/brC52tqamLq1Klo1qwZXr9+jbVr16pAS+VhamqK9evXw8TEBFOnTsXnz5/VrRKliiGX7SJyAqBaiLOzM/H29iY1a9ZUuy5UJKVz585k586dRCQSlXpPXrlyhezdu5dwOBypZbm4uJBHjx6RwMBA4ujoqBT9XFxcJPSIi4sjnTp1Iu/evSNt27ZVex8qS6oL6u5HKt+PrF27lmzYsEHtenzvUp1Qd19SoVIRMnnyZGJtba12PSqDVBfU3Y/yCofDIfv27SMHDx4kgwcPZtKNjIwIIYSEh4eTgwcPMrJ69Wq5ytXT0yNRUVHE29ubNGjQQO3tLEnWr19PjI2NybZt28jx48eJlZWV2nWiUvVEHr6bGU8UNsuXL0f37t0BAO/evYO3t7eaNfofkZGRqF27tlx5CSF4+fKlVC+rvr4+6tatCwAICQlBy5YtkZmZWS7dis94AoD4+HgMHToUt27dwujRo3Hw4MFy1VFZkNM0VHqo7aJUFJGRkbCxsUFQUBB8fX2xfv16dav0XVJdbBdA7ZeqGTp0KNLS0nD58mV1q/Ld4u3tjQ0bNiAuLg6JiYnw9PRUt0pqpbrYr6piuzQ0NJCfnw8ul4uEhARmJQWXy5UI+QEAeXl5CA4OZv4nhKBNmzYQCAQS5fbu3RuLFi1i0oRCIdq0aQORSKSaxpSRpKQkfPr0CTVq1MDOnTuxatUqdatEqYLIZbuqm+eaSqFwOBzC5/MZefPmDUlNTWUkPz+fubYCgYBs27aNrFu3jqSmppL4+Hi16X348GGSlZUl720pk9zcXCIUCkl+fj7Jz88nnp6eMmdGKSKNGjWSqEs844kQQrKyskjz5s0Jn89X+z1QXqkuqLsfqahOits5dT53J06cIEKhkLnvcnNzSWpqKnFzc1N7P31vUp1Qd19WJ+HxeITP5xNdXV3y9etXkpqaSrKzs8mIESPUrlt5ZNmyZSQ1NZU4ODhI2MPKNhYRXwM+n0+cnJxIamoqycnJYe53kUjEGqt27NiR8Pl8oq2trXbdK0qqCwBIly5dyLJly5hrXqtWLZKamlqpZgZraGgQgUAgV5vS09OJiYkJGTJkCMnJyWEkLi6Odd+2atWK8Pl8oqenR6ZMmUIIISQvL4+4urqqvb3SJCUlhWljTk4OSU1NJc7OzqznTlNTk/D5fPLu3Tu160ulcoo88ECp8ujo6MDe3h5xcXEwNjaGjo4OnJ2dcf78eSZPREQEs1OeqakpNDU1mWNcLheTJ09m/s/LywOHw1HLV5eRI0di1KhRyMvLA4/HQ2pqKhISElC7dm1oa2vLXU7t2rWxevVqXLp0Cfn5+bh165bCuvD5fDg4ODD/a2lp4fXr1yWeo6uri6dPnyIzM5O1UyGl8uDg4AA+n4+cnBy6hr0K4OTkBKDQhhWnQYMGuH79OmrVqgWgcPZmgwYNKlQ/MXp6etDQ+N9+Hdra2tDW1gaXy1WLPhQKhc3ff/+NhQsXqluNciP+DRNjbW0NY2NjfPz4UWr+Jk2aIC8vj/n/06dPyM3NVbmeYpydncHjFb5uzJkzB+PGjZOZlxTb1XnHjh2oU6cOoqKimE13oqOj8e3bN9UqTVEKPB4PCxculHjudHV11aRR+ahTpw5SU1Nx7NgxHDt2jEk3NTVlxQ0+cOAAXFxcWGOCSZMmASgc00gbz1QW+Hw++Hw+wsPDER8fz8xAXLNmDXr37o20tDT1Kkip0lDHUxVCV1eXWR73+PFjxMbGAgCaNWuG+/fvY/v27ejSpQvq1KmDjIwMnD59mjl34sSJSEpKAgDMnTu3xGmUXC4X3bp1w9WrV1XYmpLJycnB9evXce7cORw8eBBr167FzJkz5X6Ja9WqFUaOHFkuHRo1aoTHjx+X6dzSphjXrVsX9evXx40bN8q9/I+iGOfPn4ebmxvCw8Mxb948Jv3ixYvIz89Xo2aFTmR3d/cSNz7o0KEDatSogTNnzlScYmrk999/h56eHsueAYBAIMD58+cxbNgw7N69G9HR0ejbt6+atAQePHiA3NxceHl5VZklBhQKperx66+/YtasWYwzRwwhBGfOnAEhBC4uLnBzcwMA/Pvvv6ydkv/880+sW7dO5b93zZo1g729PYYNG4aBAwfKdU56ejrq1avHStu/fz8MDQ2xf/9+tG7dGitXrsQ///yDrKwsVahNqQBq164NLy8vAJVj7CUvPXv2lBpOIzk5WeK+PXToEPT09Jj/V65ciZo1a+Lz58+sj9qVmVq1auH9+/estEuXLqlJG0p1gDqeqhA1a9ZkXr5OnDiBkJAQAICtrS0AYPLkydi9ezeOHDmCr1+/snaEUwQejwc/Pz9s2bIFAQEBuHPnjnIaICeEEPz111/YuHEjkzZnzhxMnDgR+vr6rLxr1qyBlpYWevToAT8/PwDAtGnTmNhORZk/fz7zlfDatWsIDAxUms6fPn3C5cuXmcGdlpYWJk+eLPMaDBw4EP/88w+2bduGL1++0PXUaqBOnTosZ8bKlSsxf/58tenD4XDwzz//oH///jhy5AgAYNu2bUhISGDl++eff+Dh4YHly5czaUePHmXsQXVj0qRJMDQ0xMyZM9GuXTt07doVAJCbm4vVq1cDAA4fPoz9+/cjIyMDAODq6oqhQ4fCz89PIiabqli+fDk4HA5WrVqF33//vULqpFAo8lG/fn107NhR3WqUCT09PcydOxePHj3C5cuXERERAaFQKOF4EgqFGDhwIEQiEdq1a4ft27fj9u3b+PPPPzFr1iwmn6amZoXMxJwyZQrGjh2L1atXY8uWLZg6dWqZyhkzZgyAQrv+888/AygcY1HHU9WlS5cu6NKlCwBg7dq1yM7Oxrt373D8+HE1a1Yyu3btwqFDh+RaEVI8du6IESPg6OiI9PR0ValXIXz+/BkTJkzArl271K0KpSqiyFpdKuoVBweHEq/R5s2biYmJSanlzJ07V97LTt6/f0/8/f1JrVq11N7+zMxMCf1q1apFdHV1SatWrZh8ISEh5OzZs8Tf358lReNazZ07t9T6WrZsKVcfxcXFEQBk+vTprPS0tDQyY8YMqWUvWLCAyZeUlETq1q1L/P39Sbdu3dTez2KpLhRv15s3b6Tmy8nJqfA+btu2LXN/njlzhrWbo4+PDzE0NJQ45+7duxK6P3r0iPj7+5P9+/er/b5RpciyXa9fvyb+/v5Mf/Xv319t/WJlZcXSrXHjxmrvt+9NqhPq7suqIHPmzCH+/v5ES0tLZp6BAwdK7d9z584RW1tbtbehJLGwsCCEEBIREUH8/f1Jamoqqw379+8n/fv3J3379mWd17x5c2JgYKA2vffu3UsIKYwjun//frJu3bpS7/eUlBS197e6pboAgPTo0aPEPPPnzyc///wzIYSQmJgYZjxkYWFRoX0+ZswYll4zZswgubm5Evrm5eUpJV5sZZOiMZ5ksW7dOtK/f38mfqX4WpUWt6pBgwbE39+feHp6qr2dVFQrctkFuXIROvhRt/B4PBIRESHz+vj6+pLNmzdLfcnZs2cPsbS0JABIu3btyNevX+W97AzOzs5q7wNZjqfi+UJDQ0ttz9evX0loaCh5//494XK5Uusrr+OJEEIyMjJIaGgoad26Navs4o6n1q1bE0IImTBhgtr7WSzVheLtKq/jyd/fn+jp6TH/z58/n4SGhhJzc3O5zj958iQJDQ0loaGhJDY2VqbecXFxpG7duhLnS3M8iREIBMTX11ft946qpDSn+YcPH0hoaCiJiYmR6JfQ0FCyYMECletY3PHUpEmTEvN7enqS0NBQ0rVrV7X3b3WR6oS6+7KyipWVFWNHxWMDHR0dmfllOZ58fHzU3pbSROx4ksXs2bPVrqM0ETueCCl8Yd+9ezfZvXs3kxYXF0dcXFyIi4sLuXjxIiGEkNTUVLXrrW6pLlhaWpKoqKgS87Rt25ZwOBzi7OxMpk6dyqRHRkYyz/f8+fNV3uc8Ho+5F11cXIiWlhZp0qSJhL7fs+MpNjaWuLi4kNjYWDJgwAAm/cuXL8y1Cg0NJVOmTGHKNTMzY+6B0aNHq72dVFQr8vC/qGeUSo2JiQlq164t83j//v0xduxY3LhxA0ZGRgCAQYMGISUlBf369WOmVevq6sLMzEzh+oODg2FhYQEDA4OyNaCSYWZmBhcXF7i6uqp0iZKBgQFcXFxw9+5dWFpaqqweSsVhb2+P5ORk5ObmIjc3F8uWLcP06dPx9etXVj59fX2YmJjAxMQE3bp1Y/IPGDAALi4ucHFxKfGeqFWrFszNzZkyJk+ejNzcXLRr107mOVwul1l6+z0xa9Ys8Pl8NGvWDGZmZtDR0WEFz+VyuXBxccGSJUuQm5uLjh07wsbGBjdu3FC5btevXy/RxvD5fJibm+Pw4cOIjY1FXFwc7ty5U2WDr1K+H/r27YvU1FTGtoll/fr1jN0SS9FYJyXB4/EwZ84cTJ48WepyMAMDA3z8+BEfP35k7Ki+vj7S09OrxTb0Rfus6CYwssjPz1dqoHAOhyNx7ZSBlpYWxo4di5iYGFy4cAEikQgFBQUICwtDWFgYMjIykJGRASMjIzx8+JDav2qApqYmbGxsSs1HCMGHDx+wbds2JrB1gwYNYGxsDHNzc8yfP5+xLaoa3wgEAuZeDAsLQ35+PiIjI5GamsoKZK+lpYWcnBycOXOGFeC/ouHxeNDR0WH+NzExYTY00tXVhYmJCSwsLJCdnY1Tp04x+cTvh2Vh2bJliIyMhIODA06fPs0ES7e1tWVssYuLC2xsbGBiYgIul4uIiAi8evUKfD4fhw4dKnPdspg3bx769euHx48fw9TUVOnlU1SAXO4pQr+6VbTo6uqS5s2bM9NN4+LiSrw+W7duJQsWLCANGjQgAIiOjg6ZNGkS8fb2ZpXbrVs3eS+5VJ4/f07s7OwqvD8aNGhAsrOzJfQp64ynosTHx5PmzZsTGxsbVjllmfEUGRlJnjx5Qp4/fy6RTzzrDGDPeLpz5w4zzZfOeFI+xdsla8bTo0eP5OqXFy9eSJzr6elJOBwOad68OSMBAQGqbppU7t69q/Z7RxViaGhINm3aJLXNU6dOlcg/YcIEiSUpRcnOzmaulTKXEpubm5OQkBCmnuHDhxMNDQ1WHldXV6KpqUm0tbVZ90zz5s0ZG71582a193lVleqEuvuyNJkyZQp58uQJefLkCXn16pXMdpw9e5Z1n7u5uUmU1bx5czJhwgTmHG9vb4kZydevX5dafv369UvUszLPeLKzsyPNmzcnbdu2Zek2e/Zs0rx5c9K9e3eZ/Xr48GGl6ODs7EyaN29OevbsKVFHx44dmeumyBKoojOeijJt2jRy7do18vnzZwKA1KpVi2zfvp04OjqSu3fvkrdv35I9e/ao/bqoS6oLdnZ2peZp27Ztqf0xZMgQ8uTJE5KVlUUyMjIq/HoUX4YnZvHixWq7Rzp37kz8/PyIqakpAQpXhLx8+ZKYmpqSo0ePsvS8e/cu8/x++vSJaGtrS5Qnz4yniIgI4uTkVGq/iPHy8mLer5o3b07MzMxU0hcXL14kTk5O5NOnTwQonCEq7hcqFSvyQB1PlVTEUzz9/PzImDFjSHp6eonXZ+vWrazzGzRoQB4/fkzGjBlDrK2tmfTijqfjx4/LewswbNy4scL7Q9aAVhmOJzGrVq1iyvj555/L5HgaNWoUAUC0tbXJmTNnWPlmzZpFBg4cSAC248na2pr5mzqelE/xdslyPE2ePFmufpHmeFq9ejX55ZdfWDGaCCHk1KlTZN++fWTfvn3kwYMHKmlfccrjeNLW1iZjxowhHh4ear//iktJTnNpjifxM7lv3z6JgVhxjh07RsaMGUN0dXWVoqurqyt58uQJU/64ceNYx2/fvk1mzpxZ4tJB6ngqu1Qn1N2XioiJiQnZt28fefr0aantSkhIIGPGjGFJZmYmuXTpEpPn3LlzEsvnlOl4io2NJUOGDFFLX2lpaTHtvnHjRpnvj/I4noyMjBgdgoKC5Kpv5syZrDJsbW1lLieW5XgihJA5c+aQNWvWEGtra3LixAmyfft2YmxsTLS0tMjSpUuZD3I1a9ZU+31d0VJdUJbjSSwvXryoVI6nM2fOkDFjxpDRo0dLfFwqj7Ru3brU+97V1ZU8fvyY7Nq1i4wZM4bk5uaSly9fklGjRpXa50UdT23btiVjxowhWVlZpZ43dOhQlg7t2rUj7969K/U8Qgh5+/atQte6NCluu+bOnUu2b99OxowZQ44dO0aGDx+u9uf4exR5oLvaVVJiYmIwY8YM/PTTT9i3b1+ZytDU1ISBgQF4PB44HA58fHyYLTwPHTqErl274rfffmN2Cfne6dy5M5o0aYIePXpgwYIFuHjxYpnLysvLw99//41+/foxaT4+PsjIyED79u3RokULZahMUZDRo0fDyspK6jEfH59Sd4IcMWKE1Knj0nYx27dvH+bMmYPU1FQAhbuztWnTBkDhDouGhoYq20WvQ4cOGDBgAIDCqcjyLsXQ09PDvn37EBwcjEmTJil150d1sGnTJixcuBD29vb48OEDgoKC8NNPP0nkGzx4MAYPHoy2bdsiKysL7969w86dO8tcb0hICCZMmIAOHTrg999/x7Zt29CoUSM8evQIR48eBQCsX7++zOVTKJWR1NRUjB07Fs2aNcOuXbvg7u7OOn7q1CncvXsXXC4XPj4+EmOb7OxsBAUFITs7G/n5+Zg5cyZycnKUrufSpUuRnJyMqKgo+Pv7K738kvD29oa7uzu0tbUxceJEAIX9MmPGDKZfKgpLS0uFx5deXl6ssA+Ojo54+fIlXr16pVA5RXe609bWxqRJk6Cvr4/Zs2fjr7/+AlD4O/bff/8hNjYWiYmJrJ1cKZSK4vHjx5gxYwamT58OJycnJr1fv37MGN/d3R0ikYh1niJjLzEeHh7YsWMHQkJCMHr0aGRnZ7OOczgcrFu3DlwuF3l5eRg/fjzGjx+P3Nxc+Pn5Yfjw4aXWsXbtWkbXH374AW5ubnLp5u3tjdatWyMnJwd//PEH7t+/j8mTJ2Pfvn1wdHQs8dyCggIUFBTIVU9prFixAjY2Nhg5ciST9u+//8LR0RGfPn0CAJw/fx5AoZ3R1tZmjb0oakYu9xSpWl/dqpM4OzsTT0/PUqdBFp/xpKenR6ZOnUoCAgJIQEAAuXXrloT3OTMzkzXbRl6Kz3hydHQkAQEB5Oeff2bSLCwsyL///qu0fqiIGU9F+0URpM14AkAaN24s1/l0xpNqKdqmkmb4yRNc/NChQ3LXO2DAANa5VlZWxNPTk3h6ehIej0fq16+vjOZJcPfuXTJt2jSyevVq4unpKTN4vjQp+uU9NDSUBAQEkCtXrqj9XgTKNuMJAAkPDyfdunUjTZo0ITY2NsTT05OEhYWV2IfJyckkICCAdOzYUam2Ky4ujgQEBEhdAvjXX38RT09PZvdNOuOp7FKdUHdfllV8fX0l2hIWFkbc3NyIv78/iYqKYuxhURE/p7KWv5ZlxpOtrS0z03X+/PmEz+crvb1bt24l+vr6Uo+Zm5szY7GEhARCCCGZmZlMm8Wz0rW1tSVmzZZGeWY8ubq6Kng3Smfp0qVk6dKlTLgCNzc3EhAQUOLmGYQQkpiYSH755ReybNkyEhAQQMaMGUO0tLTI5MmTJfJmZ2eTgIAAMnLkSLXf26qW6kJ1mfEkliZNmhBPT08yYsQIudp/9+5dEhAQIHdwdFdXV9Yy/Zs3bzLHxowZw7zLSbMR6enpUoOhF2XRokWlBnuXh+Ibody7d6/Uc06dOlXukAazZs0iAQEBpKCggHz+/Jl4enqSw4cPM3WcO3eOzJ49m5w4cYJs3LiRBAQEEIFAQAgh1X7H58oi8kAdT0oSDodDuFyuQi95pQmXyyUcDodoaGiQ+Ph4mdfm6dOnpEaNGoTL5ZLz58+TmJgYEhMTI+GsEggERCAQEJFIRIRCISGElMnxlJmZSWJiYkiTJk0Il8tljF16ejqJiYkhVlZWxNHRkeTm5pKYmBjSu3dvcuvWLfLmzRumTYr2RdGXN5FIxBje8jqehEIh0xfbt28n586dU7g/hEIhiYmJIWlpaSzHk6amJpk6dSpj+GRBHU+qpWibSnI8ieOjlSTlcTwVl/r16zPPpEAgIPn5+cTOzo4MHTq0XO3Ny8sjaWlpJDU1tcQd1cT2qujzKC2OGiGFcciUfX9Jq78k6dq1q8yXspIcT9KmrJubm5OMjIxS+zIlJYWxp+fPny+T/Sop7k1R+vfvT4BCB6WVlRUxMjJSuw2oqlKdUHdfKiqdOnUif/31F/Hz85Panq9fvxKhUEjCw8PLtDxFXseTeEymq6vLGj/16tVLqe319vYmUVFRJCcnhxgbGxPgf7bN19eXsR9iOz958mRiZWXFivkoFmU4nhTp0/I6nj5//kxsbW2JkZEROXPmDElISCAxMTFy75z85csXoq2tTebOnUtGjRpFeDweAQrHTmI7aGVlRRITE5n+W7hwodrvcVVLdaG6OZ7EwuVyWfenlZUVady4MfN+VZysrCwyceLEUsvV1NSUWH4vth/i8UpBQQETBmT37t3k9OnThJDC3SDd3d1L7GsvLy9iaWlZqoNKFmLbVXQMtHTpUpKdnU2ys7OJtbU1GTdunNRzi743KtrfzZo1IzExMSQrK4sIhULSoEEDZly3bNkyQkjhe5jYnhgaGhITExPW8mHqeKoYkQfqeFKSzJs3j3FiODs7l3tdepMmTYhQKCR///23XN7kog4UMdnZ2SQqKopERUWRT58+EU1NTaKhoUEmT55M+vfvT968eSO340lacHOxA6t4vcXTBg0axKwDFgqF5NChQ8TGxoZoaWnJ3R/il7f8/Hzi4+NDFi9eTHJzc6U6nm7fvi1Xm75+/UpsbGyIvb09057yUtTxJBYNDQ1y7NgxiX4SQx1PqoXL5TJBDUtyPInz6OjoEBsbG6lfxZXpeBLfG0UFKHSwKIu4uDji6upKbGxsSI0aNZh6bW1tSUFBAREKhWTz5s3ExsaG2NjYkJycHKnlhISEKPXesrS0JNnZ2UQoFJIDBw7IZQ/4fD5ZsWKFVP1KcjzJktLi5klDKBSSCRMmkJo1a7Ji5xkaGsqcRaGo44lK+aU6oe6+VERq1apFEhISSHp6ulwxQ06fPq1wHaU5nrS0tIiNjQ05ePCgxFgkPT2deHp6KrXN3t7eZMqUKcTe3p7Y2NiQzp07s+oVCoXE0dGR2NvbE3t7+xLjyJXX8cTj8UhkZCRjz8ViZWUltT5FHE/5+fnMeFIsX758Ibt37ybTp08nX758YdITExPlKvPLly8EQKnOfC6Xy/Sfra0tsbGxUepH3som1QV5HE9eXl4lznAsKpXF8SRLNDQ0pMZL8vf3J4aGhiWea21tTWxsbMi8efNK7C8nJydSs2ZN5vkTP3dWVlYkNjaWZGVlyVy1MX78eBIeHi7zXaQ0isd4Ej+7GhoahMvlEhsbG/LLL7+UWIZIJCq1L4pL69atmfOLOyrnzp1LcnJyiJOTk4TT3dLSkrkWJ06ckDkjlYryRB5ojKdy0LZtWyYGCofDgYaGBgAgPDwcISEhmDp1KkJCQhATE1Om8jU0NLB48WK58wLA06dPkZGRAQC4deuW1DXx4jg2y5Ytk1uX9u3bY/PmzahZsyaaNWsGoLDNHA5Hpi6y9Bw5ciRGjhyJNm3agMfj4f79+3Lr8fnzZ+zZswcCgQBeXl5o27Yta6tQAOjUqRNyc3Ohra1dYlnDhw9HdHQ0sz2rtLYoA5FIhCFDhqBDhw6wtLRUSR0U2fz888+YNWsW5s+fDwsLi1Lz//jjj/jvv/+wcOFCPHr0CAEBASrbprt4TABl06dPHzx69AhGRka4efMm/v33XwDAsWPHwOMVmv+pU6di6tSpEueGhoaiVq1a5dp+Vxa3b99mtgIeNWoURo0ahWnTpiE4OBi3b9+WyK+trY0ZM2ZIjYkVGxuLqKgopesojdjYWBgaGuLWrVtwdnZGr169EB8fj8GDByM7OxtPnjyR+34hhCAgIAAAWDFTKJSqSnx8PH788Ue4u7ujY8eOGDZsWIn5SxorSMPZ2Rk1atSQeqxNmzaIiIjA+PHjsXnzZtax7OxsPHz4EPv378etW7cUqrMkjIyMEBMTg9mzZ2PLli1S8zx69AgREREACscvY8aMUaoORWnbti0cHBwk7GFGRobU2HZ2dnYllhccHIyEhAQAQFxcHA4cOCAz75gxY5i/GzZsqFAMu9LsJY/HY2K3iHFyckJkZKTcdVAqJ6dPnwYAREdHY/To0QCA169fIykpSY1alQ2RSITr16/j3r176N69O5Pev39/rFmzBidOnIBIJJL6/IeHhzNjopIQCoVITExk3luK0r59ewwYMACWlpaYOXMma4wBAMuXL4e5ubnEeeL3Rj09PbRu3Vpm3W5ubujcuTMAID09Hc+ePQMhBM2aNYO5uTkuX76Mr1+/4ubNm2jcuDHMzMwkylD0PcvT05MVg0ooFLKOr169GkZGRsjKyoJIJIKJiQlMTU2hra2Ns2fPQldXFwAwaNAgPHjwABs2bGDONTMzQ+PGjREUFISvX78qpBelHMjr6UQl8KRVJvHy8iIpKSlk1qxZZNasWeT8+fNS+23SpEllKt/a2ppcuXJF3stDXr9+TXx8fIidnZ3cdbx584YsXrxYrvLFW2g6OTlJxIsqjaIznsTcuHGDzJs3jyQlJcmla9FZA0+ePCF37twhhBR+hZP2tSw3N7dUvbp160YAEGNjY3L69Gny9OnTcsWHIkT6jCexyIp3QGc8qZY9e/bIlU8842nAgAFMmkgkIpqamkyfKHvGkzRR5ownHx8fmbOYSmPSpElk+vTpxMfHh/zxxx9Kvbfmz58vdQlqVlaW1Pw2NjYy9dy7d2+ZdCjLjKcdO3aQHTt2sNJevXpFrl+/Tvz9/cm6deuIoaEh87vg6uoqc8aTQCAgY8aMIUBh/Kr58+cTExMTtT/31UGqE+ruy7KKtBhPxTlz5oxCZa5Zs4YQUmiXN2zYQPz9/VnlyZrBrewZm2Jp27ZtqW20t7cnO3fuJJ8+fSK9e/cusbziM57Onj1LfHx8yM6dO2WWX3TG099//y2xk9zBgwfJ9u3bS9VTVtliWzZ37lzi4+NDfHx8lBInhpD/zXgqTXg8HvHx8WGNsx0dHdV+j6tKqgvyzHiSxu7du8msWbMkxsOVfcYTULjTm6ydkwkpXConbTmsrDAHxVm6dGmpy2n79+9PfHx8SGpqKuv96NSpU1LLXL9+PdHX1yerVq2SS4ddu3aRL1++MLYhMjKSOebv70+AwphUaWlpUs+fM2dOqf3Yq1cvMmvWLFJQUMA6t3Xr1jLP0dPTI9u2bSPr1q1jxX4SU3xHzr59+xJCCNm3bx+ZOXNmtZ5FWVEiD9TxVEbp2rUrE0MpKCiInDhxQmq/ldXxBBQ6eby9vcn79+9LvDZhYWGkVatWCpdfknEsjtjxBBQG0VYEaY6niRMnkgcPHsgV0BkA6dOnj1RnkjIcT0BhXJVmzZqVuu16aZTkeBoyZIjUafTU8aRa9PT0yNq1a8n58+fJ48ePZearjo4nWQiFQjJnzhxW2vz585mgrrdu3SIuLi4qua+mTZtGDh48SKZNmyah1/jx46WeowrH0+jRoxXuN2mOJzE9e/ZkbImYe/fulbgxREREBKNPp06dFJ6CTkW6VCfU3ZdlFXkcT1++fCEHDx4kzZo1k6tMd3d34u3tTUaOHEk4HA7p0aMHq7zK6Hiys7Mjurq6pEuXLqWWV9TxdPr0aWJra0uAws1aZFE8xpOenh7x9vZmZNu2bURfX58sXbq0VF1lMWHCBJbTTN5wBqUhr+NJLHZ2duTMmTOEEOp4qgqU5ng6cOAAc59KW2KWnZ1NDh48yEhycnKldzwBIB4eHsTb21uqM6m8jiehUMjEQitNYmJiyNq1a5n/ZTmeCCHk5MmTctU/f/58YmZmRiIjI4m3tzez9LmgoICMGjWKdOrUianPy8uLeHt7S4RIKCgoYK5pjx49pOpe/J06ICCAeHt7E3Nzc4m8s2bNIgcPHmTa8PbtWzJ37lzy+fNnVhmyHE9iDh8+TBYsWKD2+6cqizxQx5OccvnyZYm0Jk2akKioKOLs7Ez++OMPqf1WHseTWEqaYZSamkrq1q1bpnLfvHlDevbsKdf1V6bj6dSpU8THx4dkZmbK7XgCIHXdsrIcT2JRpeMJKAySN2PGDCb/wIEDydOnT5n/qeNJ+QCFMXisra3livH0PTieCgoKCJ/PJ+7u7sTd3Z1cv36d1K9fn3C5XOLu7q7QzElFxdHRkXz69IncuXOHjBkzhqWXrBk/qnA86evry91faWlpTL8o4ngqjaKOJyrKk+qEuvuyrOLg4EDCw8NLbNvt27eJu7t7mQLp16pVi1X+oEGDyJMnTyTqyMvLI7169SKrVq1SehvldTzJW17RXUUXLVrEpBd3PI0YMYKx3Q4ODjLLW7lyJenduzfhcDisOCmKUjw2itjxFBUVRWbNmkV2796t8Ex4QgrHb8+ePSPPnj2TOh6TJmIH2ps3b8izZ8/Ijh071H6vK1uqC6U5nsTvR1paWsyH8G3btpG7d+/KPKcqOJ7EEhcXxzynRceO58+fl8irCseTu7s7+fDhA/N/SY4neXFzcyNcLpe4uroSoDBeqLu7e4lBwzt27CizvKioKPLs2TMJh1Jxx1NJz/nFixclyh0+fLjEbHNxXaampgSQdDwRUvixUN33TVUWeaAxnuSkdevWSE1NxenTpzFlyhTk5+fj1atXaNCgAb59+wZNTU2l1zl06FBs27YN+vr6MvMIBAKEhoaWuY6goCCFzxEKhUwMpaysLGat8aJFizB58mQAAJ/PZ/JraWmx1vV+/foVurq60NfXR25ubpl1F8Pn85GTk1PucgBg3LhxTBsAYOTIkdi0aVOp5+Xm5jIxc0rixYsXCAoKgpmZGRYuXIjg4GDW+mWKasjIyGBin1EKKSgowJs3b5Cfn49+/fohNzcXIpEIz58/V2m9kZGRyMvLQ/v27SEQCDB37lz8+++/EAqFKoulVV4EAgHTL7NmzcIff/wBPp+PyMhI8Hg8aGpqQltbm2X3KJSqCo/Hg0gkYmLQaWhogMvloqCgQO4yPn36VOrvckZGBl6/fg2BQKCwjomJiWjRogWAwjFGSkoKDh48KJFPJBLhypUrUmPHKQNxzBEul1tiPi0tLeTn5zP/i23F0KFD4ePjAwBMPD2RSMTqa0IIa6y0detW5tqcOHECEydOlFrn0qVLkZubq3S72rt3b7x69Qru7u7Izs4Gl8vF0aNHAYClp6amZon9wuPx0LBhQ2hpacmM3SWGw+FAW1ubGWeJx02ZmZnlbQ5FzYjfD0xMTJCTk8P8ptasWROvX78GUPq9VBmpW7cuM+4Ux0oDCuOIpqamMv936tRJJTFmnz9/zsTkBYD8/HwQQspVF5/Ph1AoREhICAAgKiqqxBibtra2uHDhgszjNjY2sLGxYb1D83g8ua918bz5+fnQ0tLCrl270LVrV1y9epV5hxbXFRkZCZFIJNc7G0X5KBbZ8TuGw+HA2NgYY8eORU5ODkaNGsUYFQ8PD0ybNk3pdWppacHY2FhlD8fHjx/LFNx469at0NHRwenTpxEWFoa0tDSkpaXht99+g46ODvT19REeHs7kP3LkCFxdXQEUDkpyc3NhbGyslDZoamri7NmzSikLKAxCKm5PWloasrOzkZCQUOIAOj4+Hjo6Opg9e7ZcdQgEApkOt1q1atGXV0q5yMnJQUhICCPSnnEOhwNPT0+cOXMGQOF9r+pA50WJjIxEaGgonJ2d0bRpU2zfvh2DBg2S6Rx0cnKSmp6bm4vY2FhVqipBTk4O0tLSEB8fD11dXfTt2xchISE4fPgwsrKyULduXYlzwsLCEBISgvj4+ArVlUKRl6LP2B9//IGpU6eibt264PF4GDx4MA4dOqT0jQb69OmDBQsWlOlckUjE/E7Pnz8fnp6eMoOVC4VCZGVllUdVCbhcLuzs7HDixAn4+/uXmLdjx444f/4887+DgwNSUlKQk5ODffv2wdjYmBkThYaGYtu2bcxGEEChk01HR4eRDx8+MOdYWlrKdNqoyq5/+/YNzs7OSE9PR0FBAXJzcxEdHY2QkBAYGRkxekpzBBYlOjoanTt3RkhICPT19aGlpSWRx87ODlwuF/b29ggPD5e6wQSlapOXl4eGDRsiLS0NeXl5yMrKQlpaGsLCwph7ae3atQgJCUFYWJi61ZUb8XjG0NCQ9YxqaGgwz6+xsTFevXol97ifw+HA1dVVanDxknQACp3cRd/NysLTp0+ZgN2lweFw8OHDhxInT4hxdHSEpqYmXF1dsXr1aqmbIRQtt27dunB1dcWWLVuYQO6xsbHo2LEjQkJCIBAIpNr8L1++QE9PD8bGxnLpRVEBcs2LIlV3ureyRFqQNKFQSAYOHEi8vLykBjIjpHxL7Tp16lTqVPWvX7+Wq13GxsZyXf+iS+3kEQcHB6nlPHz4kEycOJH5v7IttSsunTt3Jt27dyf37t2TWU5cXBwxNzcne/fuLXWpnVgWLFhACCHE1dWVFfz5xYsXKouto6hUF4q2qaSldiNHjiRA1V9qd/fuXVZ5fn5+UvNlZWWpfT27q6srefnyJdm2bRvZuXMn0dPTk8jD5XKlBiInpHCjgbLWrchSO3k2QZA23VuMeKmKp6cny6bHx8cTLy8vZit4KsqR6kRF9VlUVBQznilqM8zNzcnt27dJZGQkE6dIvKy0NAkKCiq1fYsXL1aK/m/fvpVaviJjDEXEzMxMZpuioqLIqVOnyKlTp0jNmjXJiRMnyObNm4mXlxfx8vKSiD0iRhyYtzR5/vw567yDBw8SLy8vwufzZZ6jzKV28krxQOfFKRrj6ejRo2TmzJmkT58+TFqTJk3I+/fvibe3NwFAWrVqJRHz9NatWxX2jFSUVBfkXWpX3WX48OFK79ugoCDSqFEjhXUp7wZK169fJ9ra2nLVxeFwSEZGBrMZVEkIBAImxqg0ii614/P5EscvX75Mdu/eTQAQZ2dncvfuXTJ79myJ5YUdO3Yke/bskbl5F11qVz6RBzrPrBxoaGjg5MmTSi939uzZ8PX1hYmJCS5cuICZM2fKzLtu3Tql10/5Hzdv3kSvXr2kbjvs5+eHsLAw/PLLL2jQoAHGjh2Lu3fvlqu+HTt2VKkvOtWJffv2wdnZGfXq1WPSOBwOfvvtN6xatapCdDA0NIS3t7dSyxw/fjyGDh0qkf7161csX75cqXUpSnZ2NmJjYzF58mTs3btXYqvcykJ57Oz27duZJTa3bt3C1KlTsWPHDjg4OMDCwgKnT5/G3bt3MXHiRGb6OoVS0fB4PKnjmZkzZyIyMhL6+vpo37492rdvj9zcXFy+fFkNWlZOzp07x1qizOFwmNlXU6ZMwfv37+Ho6MhsHS+LCRMmlKl+b29veHt7w9rausJngCqL//77D9u2bYOhoSFWr14NoHBJkqurKzOL9PHjx5g8eTJ27NghdWYphaIKmjRpAi8vLwCFKxaWLVum9DrWrVsn96oJAGjYsCFGjx6N3377Tem6lMSsWbOQl5cnV15CCBYtWoSXL1+WutSZy+Vi27ZtZdLpyJEjmDZtGtLS0gAUzqQV/1bZ2NhIzJ765Zdf4OjoiIiICImy7OzssGTJEvj7++PVq1dl0odSMtTxpGSmT5+OtLQ0HDp0qEzn+/j4YPLkyejVqxecnZ1ZMQGksX79+jLVow4yMzOxb98+TJkypUznjxs3DsePH5crb0ZGBtavX48VK1bIzPP333/jxYsXSEpKKrGsH3/8Uarj6dixYzh//jwePXqE4OBgeHl5qTw+DkV18Hg8LFq0SCJ9yZIlaN26NQDA3d1d6fWOGDECAwYMAADo6Ogw04aLEhERgTlz5gAAli9fjvr168tdfm5uLjNoGjVqFPr37w8AqFmzJvz9/XHq1CkcOXKknK0oG9++fUN0dDSAwufbxMSE6YvKRHns7M6dO1l23MrKSmKKd4cOHeDq6kodT5RKx59//sn8LbZ/pS0tq2jmzJkj99ITVWBra8ta0mZjY4PmzZsrXM7BgweZl7qjR4/ixIkTUvPNnj2bWZrXsWPHEj9OVhVOnTqFlJQUGBkZoU6dOozzCQCaNm2KzZs3Y9q0abC0tMTWrVsRHR2tkg+/FEpRnJycsG/fPjRt2hRA4RLfonGTAODXX39FXFxcuepZv369Qo4nMTNmzECnTp0wdOhQpcTMLY2NGzfixx9/lNv5tH///hJjPImZMGECdu7cWab4U35+fozTqTibNm3Cb7/9xsTRKw07OzssWrQIffr0wefPn5GXl4chQ4YorBOlBOSaF0XoUjtpS+3E3Llzh6xdu5YQQkj9+vWJhoYGGThwICGEkISEhBKj/ReV1atXy7VErCjyTnmUJRW51C4pKUliurci0+A1NDSIi4sLS5ydnWXW365du1LbJd6uuCTZunWr1HOLTglXVGQttaO72imfom0qaamdsiltqZ2zszMJDQ0lKSkpMsvo06cPcXFxYe2MVNKOL4Swl9qdOnWKhIaGknPnzhGgcHmIi4sLcXV1JUKhkBBCSEpKCgkNDSWhoaHltidlESMjI+Z5Tk1NJefPnye9evUi48ePJ4D6l9r17NlTrunX1tbWpG7duqSgoIB1fuPGjVn5zM3NyePHjyXq6d+/v9qf+eoi1YmK6rO4uDi5dWrevLlcZdrb25e6W5MyltoV3wGpKOpYaleUjh07EhcXF4kdPEuj6K52JUnRZTwRERGMLZ81axYrX2VfaldU+Hw+a5yXnJxM8vLySGhoKElOTiYxMTEkJCSEdOjQgQQEBFTYM1JRUl2oDkvttLW1WfdiUlKSRDs+fvzIPHehoaESYz95ltrp6+uTQYMGydWviYmJZNSoUcTHx4ccPnyY9OvXj2hoaLDqPHToELNTc1Ep71I7QgjR1dVllenn58e0ffPmzUz69evXSUREhFxl2tvbM2NSaaSlpZEhQ4YQABK7l0ZFRREbGxumXhMTE3Lu3DlCCCHp6emkWbNmTN6OHTsSAMTJyUkuvbKystR+D1YlkQfqeJJTSnI8Xb58mXC5XKKtrc3EG+JwOGTcuHFkwoQJUmMQSRMej0fu3r1LUlJSSHp6ulzXxcLCotxta9WqFUlJSSEpKSkSL01ilOF4ioyMJN26dWOlqWpQCBQOtLKyskrsP+p4ki3VhaJt2rt3L0lJSSGpqalS84aFhRFtbW1GXr58WeZ6S3M8cTicUgckiYmJJCQkhDRr1oykp6eT2NhYkpeXV+I5Dx48ICYmJsTExITRv6CggBkQGBgYkI8fP0o918rKijlXHU4obW1t4ubmRnbu3EkWLVpEMjMzZTrj09LSiJaWVpnr4nA4pHPnziX2ZWZmJmnZsiWJiYkhBgYGcrehS5cuJDs7m2RmZhI3NzeJPJqamkRfX591H1LHk/KkOlFRfaaI4yk1NVXucqXFZizKypUrWXH0yiIlOZ7i4uJU0l/yOJ769OlDOBwOadCgAcnPzyc5OTkkJSWFJCcny4yDKUZex5OGhgZZvnw5M4YTS0ZGBsnNzWWktN+Nkqhox1NxEf8ee3l5Me2rW7cuAVDue6cySnWhOjieZN2LRYXP55P4+Hjm3kxISGDGLrm5uRLvVeJ8RZ3yOjo6pFWrVnL37dWrV8nkyZPJkCFDyJMnT8jXr1+JoaEho+etW7dIZmYmMTU1JYMHD2Z0EYlErHKysrJISkoKY4/y8vJYdkRMUdsldjxpaWmRbdu2EZFIRFJTU8mzZ89I3759SWpqKhkyZAiJjIwkIpGIpKSklPouZmVlRVxcXErMU1BQwBoP5ufnk5SUFKkxB4vGXX78+DHx9vYmKSkppG3btkRTU5PEx8dLlP/161fWdb158yaJiopS+z1XlUQeqONJTpHleMrLyyMbNmxQen0uLi4kMjKy1Oty/fp1pda7a9cu8uzZM4l6lOF4sra2lkhTpeMJAJkyZUqJ/adOx9OHDx9Inz59WANC6nhSPtLaZmhoSN69eyeRNzQ0lJWPw+GQ/Pz8MtVbmuOJz+eT+fPnl1iG2Gnh6upKFi5cSACQnTt3kidPnpAnT57I3HwgISGByfP8+XMSHh5OmjdvTmrVqkU2b94sV5sqw6Bw48aN5OnTp4xOcXFxTLtu3rxZrrLlmfE0aNAg5j55+PChQuUPHTqU9OjRo8Q81tbWzDWkjiflSXWiovpMEcdTdna23OWW5ngihJB+/fqVS/eSHE+enp4q6a+ijqePHz+SJ0+eSMzM7N69O9HQ0CDPnz8n6enpZNq0acz5pc02Fzue3NzcSPPmzYmrq6tC+hX/bcnMzGRspzzXpCjKdjyFhoaSJ0+ekPPnz6vFPlR2qS5YWFiUOMOmMowxVCUHDx5knrcnT54w9rWgoICZnTRq1CjmuLa2tkKOpxs3bjB1HT58mDx//py8fPmSSdu+fXup47yEhATG9vL5fPLkyROybNkypgwNDQ3y8OFD8uTJE7J8+XJSo0YNVhv79u1LEhISCCGFmzU1b96cNG/enOzevZupIzk5mTRv3pysW7euRF2srKxKdcYXJScnh6xYsUJm/4sdTwKBgBw+fFjiuHjsFRMTw3wATExMVPt9U9VFHmiMp3ISFxenkvX1YWFhWLJkCQ4cOCAzz+nTpzF48GCl1jthwgTweDzs2rULQOHa+iZNmpSprOjoaCQmJqJZs2bw9/fHwIEDlahpxXP06FHWGuqoqKhylffHH39g9erVUrcQpqiWjIwMjBkzBo8ePaqwOuvWrQsPDw/mfysrK/zzzz8S+WJjY3H16lUAYNath4SEMHknTpzI5G3SpAmmT58OABg4cCAMDAwAAMePH2fStbW1cfz4cRw/fhxTpkzBtGnT0K9fP9y8eROEEACAp6cnHBwclNtgJTBjxgxwOBzs3r0bGhoauHz5cpWJ63H06NFS82RkZODSpUuYPn06OnfuDBMTE+Tk5ODYsWMVoCGFUv25dOkSdHR0VFrH7du3cffuXWzZskViq3GRSIQuXbpg7Nix2Lx5s9xlNm3aFGPGjMHKlSthaGiIxYsXKxQDLigoCJ8+fYKDgwPy8vKwcuVKZjOJBQsWwMnJCcbGxkz8P1UiEAhw+PBh5v9169bh7du3Kq+Xol4SEhIwYMAAJgC2l5cXE5usujNq1CjW/z///DN69OgBkUjEjLsOHjyIgwcPKlx2Tk4OM0YEgJEjR4LP5+OPP/5g0iZPnoyCggJMmzZNZjlv375lnsPc3Fy0bNmSdVwkEqFNmzYAgJ49e6JOnTp4/PgxRowYAU1NTQDAmzdv0LlzZ5Y+RalRowaePn2qcBtLQigUwsfHBwsWLCg1b1ZWFkaOHCmRHhMTg0GDBsHBwQE2NjZwd3dHjx49lKonRQbyehdRCTxp6hRZM54+ffqksjpHjRpV4jU5ePAg4fF4Km13q1atyPTp04mRkZFC5zk4OJCLFy8yX93q16/PWlImpirMeOrUqROZPn060dHRUZpezZs3J87OzmTkyJGsabh0xpPykdU+CwsLMn36dDJ9+nRmdqGqZjw5ODiQgICAUs9JTU0t88wXb29vpj3idexiMTU1Jd27d2f+Hz16NGsJcM+ePcn06dNZba3OXyOB0mc8Xbt2jSxfvpwkJycTQhSf8SSPODo6StSbnZ1NNm7cSAYOHKj2PqqqUp2oqD4bN24cWbJkiVw6VaUZT7///rtK+kuepXZFbW5xKTrj6b///iPTp0+X2Vfx8fFl0rFnz54kPj6eTJkyRepxV1fXUttASPlnPGVmZlbYfVwdpLpQvF3Dhw8n06dPZ2a/VPcxhqIi74yn2NjYUsuaOnUq2bx5c4nl3Lt3jzRo0EAu3Tp37kw2btxINm7cWOpM/bKwZ88esn//frnylvbe6OnpSUJCQgghhTGe5O3/MWPGqP0eqOoiD9TxJKdUtOPJ2dlZ6lKg4pw9e1btfSNN+Hw+adSoUbVwPKlaOnbsSKZOnUoIoY4nVSBPW5s1a0Y8PT1Jq1atWOm+vr4Sa+Ll5c2bN8z95eHhIdc56l5PXjTmQGhoqNyDkqooXC6X/PLLLzKvxYoVK1gvtBXleBJTNEgnFcWkOlGR/SbvUofK5HgaOnQoSUxMZMp69+4d8fT0ZERVH+fK63ji8XiMjtbW1gQAqx1FKavjCQBp2bKlROBhsajS8dSvXz8SGxtLCCFEKBSSffv2Vei9XJWluiCrfYaGhsTT05NYWVmpva8rk5TF8TR//nwSEBDALFvt1q0bCQgIkBnHlJDC+Jienp7ExcVFbt3mzp3LnG9kZEQ8PT3J6tWry3uLKMzUqVMlPqyKxdTUlAQEBLBCUCjieKJSfpEH6niSUyra8dSkSROJugQCgYSUZ0BSETJ//nwyceJEcu/ePan9p2rH0+TJk4lAICA9e/YkVlZWEsLlctXeR0BhkD4rKyuJ3SLUKdWF8vRBaGgoad68ucRz5+LiIhEoXxriAKiyHE8ikYgps2XLlkrZLKA8Uvwl8evXryQmJobcuXNH5stLVZZGjRpJvS43b94kCxYsYDniHj58SDgcjtybRcgjXC6XjB49Wqpzkzqeyi7ViYrsNy6XS7y9vYlIJCJCoZB06NCBuLm5SegkEonIrVu3CJfLLfV5qFu3bqltLI/j6Y8//iBCoZB06tSJWFlZEXNzc5X2j1gsLCxKbVdJjidpUtzxJBQKiUAgIDExMSppjyodT9OmTWPOz8zMJDVr1qzQe7kqS3VB3f1Y1URTU5Pl4JGGSCQi7u7u5NixYwQo3MHtzZs3pKCggBWvqCTs7e0V1m3OnDlEIBAQT09PxuaPGTOGNS4uaVe6ogiFQiIUClnj39zcXNK6detSy2jdurVU/TgcDomKimL1U9euXYmlpaXar+v3JPJAYzyVk7i4OJWVnZ2djZSUFACAmZkZDAwMIBKJVFafqkhJSYGpqala6t6xYwd27txZ6fstPz8fsbGx6laDUox69epBJBJJxOESiUQSsTykYWlpiaysLNSsWZNJS0xMRH5+PgDgwoULmDJlClOmurG3t8f79++ZtpmZmQEojEd19OhRpceUq6zk5uZCJBKxYsNoa2tj7ty5AID169cz17A8CIVCHDhwAMbGxpg9ezYAwMbGptzlUihlQSgU4tChQzAxMcGHDx9w9+5dmJiYIDo6mslTs2ZNaGlpoVOnTsjPz8eqVauwbds2ibJSUlKQnZ2N+Pj4Uus1MzMDj8eDQCBQSF8+nw8jIyNMnToVgYGBKCgoUOh8RejSpQtOnDgBIyMjAFDp73VOTg6Sk5Pxyy+/4Pr16yqrR1U0b94cixcvRmpqKrKystCwYUMmXiGFQpFOQUFBqc8JIQRfv35lxmYcDgcA0LZtWzx+/LjUOuLi4sr03rpu3Tr4+Piwxqn79+9nYlRZWVnBwcGBiW1pZmYGPp8vtSwzMzNYWVlh4sSJrBjJIpEIffv2xYULF0rVp1atWqzfFg6Hg1q1ajH/z5o1C7dv31bpbwKlbFDHk5wIhUI8fvwYrVq1YtIEAgHatm2rkvoyMzOxZMkSnDlzBra2tvD19YVQKGSC0lUFTE1NwePxYGFhAT09PbXoQApn9amlbkrVR/wjW1an0K1bt1BQUIC7d+/i5s2bAICpU6cqFCS2IklJSUHHjh3Rs2dPuLi4YNKkScyxWrVqwcHBAZ8+fVKfghVAbm4uoqOj4ezszEpv2rQpmjZtCqDwo8COHTuUNqjZsGEDNmzYAAC4fPkyNDU1ERYWppSyKRRF2bhxI/N3amoqbG1tmf83b96MevXqMf+3bNkSLVu2RNu2bVkvGv/++y9u3rwJfX39Uuvbs2cP7ty5gw8fPsitI5/Px6xZs5iAuvn5+di/f7/KHPg3btzAtGnTsH79eoSHh2PQoEGIiYlRah13796FsbEx7t+/j8WLFyu1bEVITU3FixcvmP8VdQg+e/YMY8aMQX5+Pq5cuaJs9SiU75YHDx6wNqnZuHEj3NzcZDqdcnNzERgYyPw/evToMn00k/UuVadOHdjY2ODUqVNITExkfiuWLl0KDw8P/PDDD0hPT8fz588BFP5eCIVCvH37ltkApyil2e8WLVrAxMQE69atQ/369Zl0Dw8PxgkHAL/88gsuXLiAiIgIhdtKUS3U8SQnAoEAd+/eZTmeVElERARWr16N9evXY+bMmVXSa9uyZUvo6OigYcOGsLOzU7c6FEqFcuHCBYSHhyMrKwt//fWXutWRm5CQEISEhGDgwIHo168fLC0tAQAdOnTAiBEjpO7EV1VJSkrC+vXr0aFDB7i7uwMA4uPjcebMGVy6dEnmeW3btsXevXtVYpd79uyp9DIpFGUha5ekv/76CyYmJsz/fD4fx44dY77MF0UkEmHTpk2sFxlFZ8To6OiwdmHq0KEDDh06pNKZo76+vtDS0sKFCxdU8kFL3Tv/7tu3D+np6QgPD8f27dvLVda5c+eUpBWFQhEzevRohISE4OPHj+jYsSOuXLmCr1+/AgDMzc0xYsQIJu+uXbvw5csXZjdLZdOgQQPs2LED7dq1w86dO/H582fm2KJFiwAAW7duRffu3XHx4kVcvXoV3bt3L9ds8U2bNgEA8/HWw8MDrVq1wsKFC8HlchEVFYX//vsPvr6+1OlUWZFrQR6ha3XFMZ4ePHhAvL29ibe3N0lMTFR53JPmzZuT9+/fE6FQSNauXav2flBErK2tSZMmTUrccUbVMZ6olF2qC6rqH2lx2Agh5OXLl8Tb25vY2dmp/RqWV3r27MnYO29vb9KoUSO166QKcXd3J97e3iQpKYlMmjSJ3LhxQ+K6fvjwgezfv5/s379fpXFkqJRfqhPq7svySJ8+fVj249q1a4SQwhgfq1evLnf5VlZW5MSJE2Tz5s0K77xbXilvcPHKIEZGRqzrU9bd66goV6oL6u7HqigTJkwosU+dnJyYnbDfvXtHPDw8CFC4odPmzZtZzzOfz1eprs7OzqXWZWFhQd6/f0+8vb2Jk5NTqWX27NmT1d6ZM2dK7Ye0tDRy8OBBEhQUxEq/ceOG2q/h9yxy2QW5chFqQFq3bk3Cw8OJg4MDk+bm5lYhdbu4uJBWrVqRDx8+qL0fyiKOjo7E3d2d5OXlSdxX1PFUeaW6oKr+ETue1q1bR9zd3UmrVq1IVFSUXD+uVCqnfPr0ifD5fDJ9+nSJ++jhw4fEzMyMmJmZqV1PKiVLdULdfalMsbW1Je7u7sTd3V1pO2bWqlWLmJiYVHhbqoPjiUrllOqCuvuxKkpJjqcZM2aQq1evstJGjBhBABANDQ3i6uqqdv2LC4/HU2j3PLHjad68ecTd3Z2Ym5uXeI9t3bqV2bwqMTGRODs7q73N37PIZRfkykWoAQFADAwM1Fq/oaGh2vugPGJkZESMjY3JrFmzmPuKOp4qr1QXVNU/XC6XGBsbE21tbSatqj+j37vUqFGDREVFkWPHjhFjY2NSs2ZNEhQURHJycsjt27fVrh8V+aQ6oe6+pCJdZDmeRCIRycnJITk5OaRr165q15NK1ZPqgrr7sSqKlpYW2bt3r0RfFhQUkB49epC3b98SGxsbYmxsTIyNjYmmpqbadVam8Hg8VrtMTU0JIYQcOnSImJqaEmNjYxITE0OCgoKY8beenh55//49qVGjhtr1/95FHmiMJwXIzMxUa/0ZGRlqrb+8pKeng8/nw9DQUN2qUCjlRigUSsQlqerP6PdOSkoKK5Dy+vXr4eXlRWMFUCiUEvn8+TNycnLw4cMH9OnTR93qUCiUKkh+fj4TAyk8PBxCoRBAYRDxK1eu4Nq1a4iKikLnzp2RkpJS7XaLFAgErDYJhUJ8/vwZffr0wcWLF3H8+HFYW1uzzsnLy2NteEGp3FDHE6VCsbOzQ79+/Zj/SwrgS6FQKOpk1qxZ6laBQqFUUpKTk3Hnzh0AwLx58xTalY9CoVCk8fLlS5w+fRqjR4+WOuHBwMAAy5cvx/nz53HgwIGKV7ACSUtLQ7du3eDp6Ynjx4+rWx2KEuD8/3TI0jMW2aaQQikP7u7u2LFjB169eoXp06cjJydH3SpRpCCnaaj0UNtFoXxfVBfbBVD7VVnR1dXF4MGDsX//fnWrQqlmVBf7RW2X8uFwOJg+fTo2btyoblUoFAnksV3U8URRC40bN0ZUVBRSUlLUrQpFBnTwQ6FQqiLVxXYB1H5RKN8b1cV+UdtFoXxfUMcThUIpM3TwQ6FQqiLVxXYB1H5RKN8b1cV+UdtFoXxfyGO7NCpADwqFQqFQKBQKhUKhUCgUyncIdTxRKBQKhUKhUCgUCoVCoVBUAnU8USgUCoVCoVAoFAqFQqFQVAJ1PFEoFAqFQqFQKBQKhUKhUFQCdTxRKBQKhUKhUCgUCoVCoVBUAnU8USgUCoVCoVAoFAqFQqFQVAKHVJd9OykUCoVCoVAoFAqFQqFQKJUKOuOJQqFQKBQKhUKhUCgUCoWiEqjjiUKhUCgUCoVCoVAoFAqFohKo44lCoVAoFAqFQqFQKBQKhaISqOOJQqFQKBQKhUKhUCgUCoWiEqjjiUKhUCgUCoVCoVAoFAqFohKo44lCoVAoFAqFQqFQKBQKhaISqOOJQqFQKBQKhUKhUCgUCoWiEqjjiUKhUCgUCoVCoVAoFAqFohKo44lCoVAoFAqFQqFQKBQKhaISqOOJQqFQKBQKhUKhUCgUCoWiEqjjiUJRIk9inkBrmRY+p31W+NwrH65Af4U+vmZ9VYFmFAqFohpWB66G6xZXiIhI4XP/uPEHWu1ppQKtKBRKdeVH3x8x/tz4Mp3bek9rzL0+V8kaUSgUimqpDnavyjieDrw6AM4SDiP8f/hw2eyCqZemIuFbQpnKvP3pNjhLOPjv3X+s9HxhPnr79YbGEg3se7mPVf+z2GesvOm56Wi5uyX4//Bx5cMVAMDi24tZuuou10X9rfWxMGAhMvIyFGrT9MvTwVnCwYeUDzLbseDmAnCWcBCUECR324vWW5Lc/nRboTKnXpoqkb7i3gpwlnAw9uxYiIgIn9I+gbOEg7UP1rLyEUIw8fxEcJZwsPj2YgD/u0Zi0VymCceNjvD290ZkaiRzrrhMsXCXcmG33g5ex73wKv4VAOD0+9PgLOFgz4s9MttwPeI6OEs42PR4k9ztLsqCgAUY2nAo7I3tWenvv75HjyM9oL9CHzVW1cBI/5ESDqYezj3gXMMZ/97/t0x1U1SHKuxPUS6FXwJnCQdW66wkXt5/9P0RJqtMQAhhpb+MewnOEg7sN7DvNQAI+BgAzhIOdj3fBQAISQrB3Otz0WRHExj8awDLdZbo5ddLwp4V5d7ne/j55M+w9rGG1jItGK00Qqs9rbD0zlKJNnc60InVPzVW1UCL3S2w7+U+VntGnxnNyqe/Qh+OGx0x8MRAnHp3qlTHRfHnvCT5lPapxLKk8f7re+b6puWmsY79evFXaCzRQEpOCis9JScFGks0oP2PNnIFuaxjkamR4Czh4M+bfwIAotKjsOT2ErTc3RImq0xgttoMnQ50wo3IGzJ1CkoIwpizY1B7Y23w/+FDf4U+muxogrnX57JsICDZv4b/GqLxjsZY92Ad8gR5TD5pv1F26+3Q52gf7H+5n5W3NDLyMrAqcBXmtZ0HDQ57SHEu9Bya7WwG/j982K23w9+3/oZAJGDlmdl6Jl7Hv8a50HNy10mpeFQ5BhOL9j/asFhrgU4HOmHFvRUyP8LkCfIw7/o8WK2zgs5yHbTa0wrXI64zx1/EvQBnCQcLAxbKrDs8ORycJRz8dvU3Ju3+l/vo6dsT1j7WzD3b52gf+L3xY50ra6yjSFtLkrKWWZ37ryiBXwJxLeIa5rWbx0oXERFWB65mbGWj7Y1w9M1RifPntZ2HrU+3Iv5bfJl1oKgHVY3FPqV9wpizY+C0yQn8f/iotbYWOuzvgL9v/S21XlnisMEBAHAz8ibGnh0Ll80u0F2uC8eNjvjl3C+Iy4xj6lT0OVsduBqcJRy8jHvJykMIgckqE3CWcPAx9SPrWK4gF9r/aGPYqWFMWlF9NZZowGqdFbod7lbi+54q7BdA+720fi9KdbF7PLXWXgaWdlqK2ia1kSvIxf0v97H92XZcCr+E4F+DoaupW+7yC4QFGHhiIC6FX8LuPrsxtulYmXkz8jLQ7Ug3BCUEwX+wP3o492Ad395rO/S19PEt/xuuRVzD8nvLEfAxAIFjA8Hh/O/hLKlNwxsOx+Ynm+H3xg+LOi6SqsfR4KNoWLMhGlk0krudh70Os/4/9PoQrkdel0ivZ1ZP7jKlsfL+SiwIWIBRjUdhT989Ei8mYggh+PXir9j1Yhf+6vAXFndazDo+veV0tLBugQJhAV7EvcCuF7twMfwi3kx+AysDDRX9nQABAABJREFUKybfULeh+LHOjxCKhHif9B7bn23H5fDLePTLI/Sq0wtG2kbwe+OHX5r9IlUPv2A/cDlcDHEbonBbX8W/wo3IG3gw9gErPTojGh0OdICRthFWdF6Bb/nfsPbBWrxJeIMn459Ai6vF5J3oPhFzrs/Bkk5LYKBtoLAOFNWiKvvj+8YXDsYO+JT2CQEfA9DFsQtzrJ1dO1z+cBnBicFoaNGQSQ+MCgRPg4cv6V8QnRENG0Ob/x37EsicCwB7XuzB3pd7MaDeAPza4lek56Zj5/OdaL2nNa6MuMKqDwAW3VqEZXeXwdHEEaMbj4ajiSNyBbl4Hvcc6x6uw8HXBxExPYJ1jo2hDf7tXOg0/Zr1FYeCDmHcuXEISw7Dyi4rmXzaXG3s6Vvo/M0pyMHn9M84H3YeA08ORCeHTjg75CwMtQ2l9pO5rrmEjVr3cB2iM6Kxvvt6ibyKciToCGrp10JqTir+e/cfy060s2uH7c+2I/BLIPrU7cOkP4h6AA2OBgqEBXgW+4zpc0DyOpwNPYtVgavQ37U/RjUeBYFIgENBh9D1cFfs67sPY5qOYemz+/luTL44GWa6ZhjecDhczVwhEAkQnBiMQ68PYcOjDchZkAOuBpc5p2j/puWm4dT7U5hzfQ6exj7FsYHHWOWLf6PyBHmIyYzB1YirGHtuLDY83oALQy/A1si21D7b93IfBCIBhjYcykq/HH4Z/Y/1RyeHTtjcczPeJL7BP/f+QWJWIrb33s7kq6VfC/1c+2Htg7XoW7dvqfVR1IsqbKD4910oEuJr9lc8iHqAv2//DZ+HPjgx6AR+qP0DK//os6Px37v/MLPVTNQxrYMDrw7gR78fcWvULbSza4dmls3gauaKo8FH8c8P/0itU+wMGdFoBADg5NuTGPzfYDSp1QQzWs2ACd8EH9M+4u7nu9j9YjeGNRwmtRx5qWdWT8J2zb85H/pa+ljQfkG5yv4e+q8oax6sQWfHznCu4cxKX3BzAVYGrsT4ZuPRwqoFzoaexbDTw8DhcFhjun6u/WCobYhtT7dhqedSpelFqTiUaYc+pHxAi90toMPTwdimY+Fg7IC4zDi8iH+BVYGrsMRzCTrYd5B4fn859wtaWrfEBPcJTJq+lj4AYN6NeUjJScGg+oNQx7QOIlMjseXJFlwIu4BXk16hln4thZ8z8Yet+1/uo6llUybP269vkZabBp4GD4FRgahtUps59jTmKfKF+axxCQB0dewK78beIITgY9pHbHu6DT8c/AEXh11Ezzo9JfRQhf2i/V56vxel2tg9UkXY/3I/wWKQpzFPWem/XfmNYDGIX5CfwmXe+niLYDHIybcnCSGE5AvySf9j/QlnMYfserarxPozcjNI6z2tidYyLXIh9AIr79+3/iZYDPI16ysr/afjPxEsBnnw5YFCbXLe5Exct7hKbcODLw8IFoOsvLdS4fYXZcrFKQSLy3c7YDHIlItTmP9X319NsBjE29+bCEVCJv1j6keCxSBrAtdI1L/g5gJWmcWvkZhNjzYRLAZZcXeFzDIJIeRcyDmCxSATzk0ghBAy7uw4orFEg8RkxEjon1OQQ4z+NSI9jvQoU/unX5pO7NbbEZFIxEqffGEy0flHh3xO+8ykXY+4TrAYZOeznay8Cd8SCHcJl+x9sbdMOlBUgyrsj5hved+I3nI9sunRJtJ0R1My+sxo1vE7n+4QLAbZ9mQbK33If0NI36N9if4KfXL0zVHWsW6HuxHTVabMvfgs5hnJzMtk5UnKSiLmq81J271tWenH3hwjWAzy88mfSZ4gT0LftJw08vetv1lpHfd3JA22NmClZeVnERsfG6K3XI/kC/IJIYSM8h9F9JbrSe2Hf+/9y9SrCL18exH79fYKnSMNkUhEHDY4kN+u/Ea8jnmRTgc6sY5/TvtMsBhk7rW5rPQ/rv9Bmu5oSly3uJJ/7/3LOjbh3ASisUSDpOakEkIICU4IlvhdyC3IJa5bXImNjw0rPfBLIOEu4ZIO+zuQjNwMCX1zCnLIwpsLiUAoYNKk9a9QJCTNdzUnWAzG7sn6jSKEkCOvjxCNJRqk1e5W0rpJgkbbG5ERp0dIpNffWp803t6YFAgLmLQFNxcQzmIOef/1PSvvf2//I5zFHBKREiFXnZSKpyLGYEV5FfeK1FxTkxivNCaxGbFM+uPoxxK/9TkFOcRpoxNps6cNk7bszjKCxSAPox5Krbvu5rqscVX9rfVJg60NpNq8hG8JrP+Lj3XKSoOtDUjH/R3LfP732H8J3xIIbymP7Hm+h5UenR5NNJdqssoViUSk/b72xMbHhmUnCSFk6sWpxH69vcR4jVK5UYUd+vXCr4S3lEc+pX6SOFb83i2K3nI9Msp/lNRjdz7dYb33iNOKv+co8pzlCfII/x++xBhpx9MdxHSVKel+uDuZeH4i69iKuysIFoO8jn/NpEl7/oLigwgWg3Q73E1me4tTXvtF+13+fq9Odq/KLLWThfhLzse0/01zi0iJQERKhKxTpCIQCTDk1BCcDTmL7b22Y7y77DWU3/K/oYdvD7yIe4FTP59CL5de8unqIKmr1HzF2jS84XCEJIXgRdwLibx+b/zAAUfia7OyiMuMQ0hSCAqEBQqd5/PQB3NvzMWIRiOwv99+mTOdAGDG5RnY+nQr5rebL9P7XBxp112efCMajYCIiHAs+JhE3othF5Gel47hDYfLpUNxzoSewQ+1f2DNZgOAU+9PobdLb9gZ2TFpXRy7wMXUBSfenmDlralXE40sGuFs6Nky6UCpWJRhf/xD/JEjyMGgBoMwxG0ITr8/zVqy1dK6JbS4WgiMCmSdF/glEB3sOqCldUtmZg1QOO32UfQjeNh6MPeiu5U780VIjKmuKdrbt8f7pPes9EW3F8FM1wx7++5lzcYTY8Q3kpiRKA1dTV20tmmNrIIsfM0uPW7ZH+3+QDenbjj59iTCksNKzV8aX9K/ICQpRO78gVGB+JT2CUPchmCI2xDc/XwX0RnRzHE7IzvYGtpKXoeoQLS1bQsPGw+pxxqYN4Ax3xgA0KBmA5jpmrHyaPO08aPzj4jOiEZmXiaTvuTOEnA4HPj+5Ct19iOfx8eyH5axZjtJQ4OjgU72nQBAruWHwxsNxy9Nf8HjmMes5TfS+Jj6EUEJQehSmz1j7t3Xd3j39R0muE8AT+N/E6t/bfErCIjE8nbxjLuzIdTuVTWUNQYrTuNajbGh+wak5aZhy5MtTPp/7/4Dl8Nlfe3m8/gY13QcHkY/RFR6FAAwv+PFl3kBwPPY5whNDmX91kekRKCFdQupNq+mXs1ytUVRaP/J5mLYRQhEAolZumdDz6JAVIBfW/zKpHE4HExuPhnRGdF4GP2Qlb+rU1d8Tv/MhGKgVG3KY4ciUiNgY2gjESIDKPu928G+g8R7Twf7DqihU4M15lLkOdPiaqGFVQvWeA8oHGe0sW2DtrZtpY5BjPnGcKvpVqK+DS0awkzXTGLJWFmg/a78fq9Odq/KO54iUgtvblMdUyat86HO6Hyos9xlCEQCDD01FP7v/bH1x62Y2HyizLxZ+Vno6dsTT2Oe4uSgk+jt0rtcusqTT9YDIhQJceLdCbS3b89yaiiT+Tfno97WeojJjJH7nI2PNmL2tdkY1nAYDvQ7UKLTadaVWdj0ZBPmtZ2HFZ1XyF2Hwn2pW5ivg30H2BjaSDU2fsF+0NXURX/X/nLrISYmIwZf0r+gWa1mEumJWYlobtVc4pyW1i3xMv6lRLq7pTseRD2QSKdUPpRhf3zf+MLTwRO19GthiNsQZOZl4nzoeeY4n8eHu6U77n+5z6RFpUchKiMKHrYeEg6PNwlvkJGXITHFVxrx3+JZjpCw5DCEJYehf93+Eo6qshCZGgkuh8s4XkpjZKORICClOjzkwdvfG/W2yr9U2DfIF04mTmhh3QJ9XPpAV1NXYp18O7t2eBb7jImBlC/Mx9PYp4XXwdYDD6IeMLG4UnNS8e7rO/muQ1Y8dDV1mSUC2QXZCPgYgE4OnVhLKMuKvPZSzMjGIwEA1yKulZhPbKeaWbLtnjgWQnG7Z2VgBRtDGwm7Z8Q3glMNJ4nBG6XyowwbKIuB9QdCh6eDa5H/uw9fxr+Ei6mLxHLcltYtAYAZUNc2qQ0PWw+ceHsCQpGQlVf8+190+Ze9sT1uRt5kOZvVBe0/2TyIegBTHVOJl9WXcS+hp6knER5C3K7i8VncLd0BgNqcakJ57JC9kT2i0qMQ8DFAZfoBhZMWvuV/g5nO/8Zcij5n7ezaISYzhvURKTAqEB42hWOQt4lvmfiUhBA8iHqANjZtSnwPAwrHK6k5qcy7Unmg/a78fq9Odq/KOZ7Sc9ORlJ2E6IxoHA8+jqV3lkKHp6OQA6g4f9z4A/+9+w9bftyCyS0ml5h31JlReBz9GCcHnSw1HkVKTgqSspPwKe0Tdj3fhW1Pt8FCzwLt7dsr1KY6pnXQwqoFjr89zgq+eyPyBhKzEss8Q0cVXAi7gJlXZ2Ko21Ac6n+oxK/xW55swYbHG/C7x++sGDDSyMzLRFJ2EuIy43Ap/BJmXJkBDjgYUH8AK192QTaSspOQ8C0Bdz7dwegzowEAg+oPAlD49X+o21A8j3vOmlWRkZeBS+GX0K9uvzK9cItnVhRd4wsAcd8KA9pZ6ltKnGOpb4mUnBSJQL6OJo5Iyk5CYlaiwnpQVIuy7U9iViJuRN5g1mHbGdmhjW0b+L7xZeVrZ9cOn9M/Iyaj0AEcGBVY6JCycoeHrQeCEoKY2TJiB1VpDo97n+/hYdRDDG4wmEkT38fFv9IQQpCUncSS4kGihUTIHAtJCsGMyzPwIu4Ffqzzo9wxF8T1igeRFUWBsAAn351kroOOpg761u0r9TrkCfPwNPYpgMIglbmCXLS1awsPWw+k5KQwX9UeRD0AASn1OnxI+YDT709jQL0BjL38kPIBApEAbuaSX8vEvytiyRfmS+QRH4tIicC/9/7FmZAzaGTRCHXN6srVH/Jeh7LavdjMWIl0RxNHvPv6Ti79KOpDFWMwWWhyNeFi6sL6eh6XGQdLAyn31f+nFb23hjccjoSsBNz8eJNJExERjr89jjY2beBo4sikz2s7D1EZUXDa5IQfDv6ARbcW4f6X+2XaqbGyUB37LyQ5BA7GDhLpcd/iYKFvITHjXFq7AMDa0BpaXC1qc6ooyrRD01tNhxZXC50PdUbTnU0x88pMnA05i+yCbKXqvOHRBuQL8zHYbTArXZHnTDyeEI/z4r/FIzI1Em3t2qKVTStocDSYD0Lvvr5Dam6q1DFIriAXSdlJ+Jr1FU9inmDQyUEQEiHzrlQR0H6Xv9+rk92rcsHFuxxmTzOzN7KH70++sDa0ZtI+zfykUJkJWQngafBQ27i2XHn5PL5cQVfrbmEP8huYN8DB/gclXsLkadOIRiMw48oM3P18F50cOgEonKGjxdVSqaE40P8ADvQ/IHf+hKzCXSVqG9cudQmIOK+LqUup5Y49xw7ybq5rjoP9D0p8Uf/79t/4+/bfzP+G2oZY1WUVfqr3E5M2otEIrHmwBn5v/JglQ6fenUKuILfMTrzknGQAgAnfhJWeU5ADoHA5TXH4PH5hHkEO67iJTmEZSdlJFT7Fn1IyyrY/x4KPQYOjgQH1/udAHeo2FLOvzUZqTipzL7Sza4c1D9bg3pd7GOI2BIFfAuFu6Q4trhba2LZhltd1derKOKWkzbITk5iViGGnh6G2SW3Mbfu/7VXFu24Wd76m56XDfA07WPfT8U9ZdYQkhbDycMBBrzq9sK/fPrn7Q1xv0SVnZeX26Nty57384TKSc5Ix1O1/S5aHug1Fn6N98DbxLRrUbACAPfhoZ9cOgV8CYW1gDTsjOxBCUEOnBgK/BKK+eX3mi1JJjqfsgmwMOjkIOjwdlvNd1nUAAMeNjkjPS2f+PznoJAbWH8j8n1WQJXGtPGw9JAJ0lgRzHfJLvg7JOcngafAk9CzN7hXd3VWMCd9E4uscpfKhijFYSehr6bPuwxxBDrS5Jf+eihncYDBmXpkJvzd+6ObUDQBw59MdxGTGYH67+azzxzYdC2sDa/g88sGtj7dw69MtZoOFw16H4WHrobQ2lQbtP9kkZyez7rWytEuMCd8ESdlJStGLUrEo0w41qNkArya9wrK7ywqDUMe/wsbHG6GvpQ+fbj4lhl6Rl7uf72LJnSX4ucHPEsH+FXnOPGw9oMHRwP0v9zGi0QgEfgmEpoYmWli1gI6mDhpZNELgl0D8WOfHEscge1/uxd6Xe5n/+Tw+fmv9G2a2nlnuttJ+V36/Vye7V+UcT1t/3AoXUxfwNHiw0LNAXbO6pU5lK43VXVZjw+MNGHhyIK6NuIa2dm1l5t3Zeyd+u/obehzpgXtj7pX4BfnUz6dgqG0ITQ1N2BjawKmGU5nbNMRtCH67+hv83vihk0Mn5Apy4f/eHz2dezIvp5WBUY1HITYzFivur4CZrhlmtZklM++8tvNwKfwSJl6YCGO+MevlqTiLOixCe/v24HK4MNM1Qz3zeqzYIWImNJuAQQ0GQYOjAWO+MRqYN5B4+Wlk0QhuNd1wNPgo43jyC/aDma4Zujt3L1vD/x8C9pb3Opo6ACB1e3JxHB8dng67jP9fqsOBYtuSUlSPsu3PkaAjaGndEsk5yYzzsmmtpsgX5uPku5NMHI62tm3BAQeBXwILHU9Rgejq2BUAYMw3ZhwdYsdTCyvpsTaAwuXCvf16IzMvE/fH3mc5DQy0CmMJfcv/xjpHX0sf10cWLn+7FnENax6skSjXwdgBu/vsBgcc8Hl81DGto7DjVFxvRe/oeCToCGob14Y2TxsfUj4AAJxMnKCrqQvfN77MMmC3mm4w5hszA4vAqEDm94LD4aCNTRsERgVivPt4BEYFwtbQVuYyaKFIiCH/DcG7r+9wefhl1u6csq4DAJwdUrim/3X8a8y5PkfiOJ/Hx/mhhUs1tbnaqG1SW+Hlesx10CrbdSjN7omPF4WASHy1o1Q+VDEGK4lv+d9Y96EOTwd5Qvl+T011TdHduTv8Q/yxQ7ADfB4ffm/8wNPg4ecGP0uU0d25O7o7d0d2QTaexz7H8bfHsePZDvT2642QqSFV8kNQdew/8RipKIq0iymH2pwqi7LtkIupCw57HYZQJMS7r+9wIewCVj9YjQkXJqC2SW2J2DqKEJIUAq/jXnCr6YY9ffZIHFfkORO/1xQdgzS1bMr8pnrYerCOaXG1mGVXRelXtx+mtpwKDjgw0DZAA/MG0NPSK3Mbywrtd/n7vbrYvSrneGpp3bLEL/llwdLAEtdHXke7fe3Qy68X7oy+g8a1GkvNW9+8Pi4Nv4TOhzqj6+GuCBwbKHP2Uwf7DhKBZKUhT5tq6tVEV6euOPX+FLb+uBXnQ88jMz+zUi2zAwCeBg8nBp1AjyM9MPvabBjzjSW2CBejr6WPy8Mvo8OBDhh+ejgMtQ0Zr3NxGlo0lMsA1TGtI1e+EQ1H4I+bf+BZ7DPYGNrg1sdbmOg+UaozSx7E68pTc1JZ6eKlJuKlJ0WJ+xaHGjo1JBxjqbmFZchz71AqFmXan/DkcGbJVp3NdSSO+77xZRxPprqmcDVzxf2o+/iW/w1BCUH4u+P/ZvZ52Hrg/pf7iM6Ixpf0LzLtQr4wHz+d+AlBCUG4OuKqxJI6VzNXAEBwYjArnafBY54rWTE89DT1yjVIKFpv8e1iVUlGXgbOh51HriBX6nXwe+OH5T8sB4fDgQZHA21s2jCxnAKjAvFnuz+ZvB62Htj3cl9h7KeYpyXGixt/fjwuhF2A70++El/inGs4g6fBQ/DXYInzOjp0BACZtorL4VbYdTDVMYVAJEBmXibLWVjU7hX/fYz7Fid1QJaak0ptXhVAFWMwWRQICxCWHMayU5YGlsyS46LEZRb+xhZ14AKFv/UXwi7gQtgF9K3bF6fen0I3p24w1zOXKEOMrqYu2tu3R3v79jDTNcOSO0twOfwyRjUZpaSWVQzVsf9MdU2ZMVJRLPUtcevTLRDCfqmS1S4ASMtNY8V9oVQdVGWHuBpcNLRoiIYWDdHGtg08D3rC941vmX9To9Kj0O1wNxhpG+HSsEsyP6op8py1s2uHHc92IC03jYkzJEY8BikQFuD+l/twt3RnZr8UxcbQptzjBGVC+71kqpPdq3IxnlSFo4kjro64Cg2OBrof6Y7w5HCZeVtat8SZwWeQmJWIroe74mtW6Ts2KYPhDYcjJScFlz9chl+wHwy1DdGnbp8KqVsR+Dw+zg09h6aWTTH+/Hj4v/eXmddU1xTXRlyDpb4lfjr+Ex5GPZSZV5kMbTgUHHDg98YPx4OPQ0iEGN6o7E488Qt78V32rA2tYa5rjmexzyTOeRLzBE1qNZFI/5j6EWa6ZiUO7ChVH983vtDU0MSxAcdwctBJlsxoNQP3Pt/Dl/QvTP52du3wJuENrkVcg5AIWUsXPGw98DjmMW5/us3kLY6IiODt742bkTfhN8CPcWAUpa5ZXdSpUQdnQs8gKz9L+Y0uhcNBh8EBh5nNVRGIdxHc3mu7xHX4x/MffE7/zArE2M6uHVJyUnAu9BwSsxJZM2Q9bD0QkRqBS+GXkCPIkbnM7vdrv2P/q/1Y33291B1J9bT00MmhU+G0bykviarm8OvCZXndnUqeASrL7ontWnG7F5sZi+iMaDSxaCJR1se0jxIBMinfN/+9+w85ghzWfdjEognCksMklms+jnlceLzYb2rfun1hoGUAvzd+uBx+Gam5qQp9sBO/3Er7eFTZqY7952rqKnUHqCa1miC7IFtil1ZZ7YrJiEG+MB/1zKnNoUiHuXczy3bvJmcno9uRbsgT5uHqiKtSY6uJUeQ5a2fXDgQENyJv4GXcS4kxSI4gBxfDLyIyNVKuzU0qG7TfJalOdq9aOp7KuhVtQ4uGuDjsIr7lf0PXw11LHPB3duyMowOO4kPKB/Tw7SE1ZoWy6e/aH7qautj2dBsuh1/GT/V+kupRVSZxmXEISQpBgbBAofMMtQ1xZfgVONdwxtBTQ3Ez8qbMvNaG1rg+8jr0tPTQy68X3iS8Ka/apWJnZIf29u1x/O1xHHlTuMymPDEIrA2tYWtoK9XBNKDeAFwIu8BsUwwANyNvIiw5TGp8rudxz9HGpk2ZdaGoF3ntj+8bX7S3b4/BboMxsP5Alvzu8TsAsHZVa2fXDkIixNoHa1GnRh2WY9LD1gPf8r9h29Nt0OBoSL2Xp12ahuNvj2Nbr22smGfFWdxpMZKykzD+/Hipz7206b7KYOX9lbgWcQ2D3QajjqnkzCNF+ZL+hQl+XRJHgo7A0cQRk5pPkrgOczzmQF9LH75B/wsyLh5QrApcBV1NXdYPe0vrluBp8LA6cDUrb1HWBK7B2odr8We7PzGj9QyZei3qsAhCIsQI/xFSl9yp6jr4vfHDnpd70MamDTo7lrwzTRvbQjtV3O41qNkArmau2PV8F2vHmO1Pt4MDjsSy6vTcdESkRFRoHB2K6ijrGKwor+NfY+bVmTDhm2BKyylM+sD6AyEkQux6votJyxPkYf+r/Whl3Upihp2Opg686nnhUvglbH+2HXqaeuhXt59EfbLGKJfCLwEA6prKF5hfGdD+k00b2zZIzU1FZGokK72faz9oamhi29NtTBohBDue7YC1gbWEbXke9xwAqM2pxsj7HN37fE/qWKc8925WfhZ+9PsRMRkxuDTsUqljGnmfM+B/4wqfhz4oEBWw7mEHYwdY6luWOAZRNbTfld/v1cnuVbmldvIg3saxLAEa29i2wenBp9HnaB90PdwV98bck7nNoVc9L+zusxtjz41F36N9cWXEFZU6gvS19NHftT+z1WNFLLObf3M+Dr4+iI8zPkqNqF8S5nrmuD7yOtrua4v+x/vjpvdNqUssgMIlcldHXEWnA53Q/Uh33B97n7WjgCoY0XAEJlyYgNjMWCxov6Dc5fWr2w/+If4SUx7/bP8nTr47Cc+DnpjRaga+5X/Dmgdr0LBmQ4xpwl6GmJiViKCEIExpMaV48ZQqgjz253H0Y3xI+YCpLaZKPW5taI1mls3g+8YX89rNA/C/H7KH0Q8xusloVn4XUxeY6ZrhYfRDNKzZEMZ8Y9bxDY82YNuzbWhj0wa6mro4EnSEddzL1YtZZz6s4TAEJwbj3/v/4knMEwxxG4LaxrWRVZCF4MRgHA0+CgMtA4lA+vIiEAmY+nMFufic9hnnws4hKCEIng6e2NV7VyklyIe3vzfufL4D8rdsB01sZixufbqF6S2nSz2uzdNGd6fuOPnuJDb13ARNriZaWreEFlcLD6MfopNDJ9aSN11NXTS2aIyH0Q9hzDeWWMro/94fc2/MRZ0adVDPvJ7Edejq2BUW+hYAgPb27bGl5xZMuzwNdTbXwfCGw+Fq5op8YT7CksPg+8YXWlwt1NKvVdYuwn/v/oO+lj7yhfmIyYjB1YirCIwKRGOLxjg56GSp5zuaOMKtphtuRN7A2KbsDSDWdF2Dvkf7otuRbhjSYAiCE4Ox5ekW/NLsF4mvbTcib4CAyBzwUaoWio7B7n2+h1xBLoQiIZJzkhEYFYhzoedgpG0E/8H+rHu8lU0rDKo/CPNvzkdiViKcazjj4OuD+JT2CXv77pVa/oiGI3Do9SFcjbiK4Q2HS42p0e9YP9Q2qY0+Ln3gZOKErIIs3Ii8gfNh59HCqkWFzi6n/SebXnV6gafBw43IG8xSdKBwCcvM1jOx5sEaFAgL0MK6Bc6EnMG9L/fg+5OvxGY31yOuw87IDk1rNVWKXpTKh7zP0arAVXge9xw/uf6ERhaNABTuWHso6BBq6NQoU8Dt4aeH40nME4xtMhbvk96zZqSI3+WKI89zBhR+OLc1tMXD6IdwMHaQWE7lYeuBU+9PgQMO2trKjlmsKmi/K7/fq5Pdq5aOp/LSzakbDnsdxtBTQ9HTtyduesuerTOm6Rik5KRgzvU5GHRyEPwHy15WpgyGNxwOvzd+sNS3lIgLUhmxNbLFtZHX0H5/e/T07Ym7o+/KfKib1GqCC8MuoNvhbuhyqAvuj72vUt0G1h+IaZenIU+YpxQn3timY7Hl6RYERgWyvN22Rra4M/oOfrv2G/64+Qe0uFroVacX1nVbJxHf6fT709DmaUsN3EmpPvi+KZxBU9JgvI9LHyy+sxhBCUFoZNEIjiaOsDKwQmxmLGttuRgPWw+cCz0n9UvLq/hXAAqdVg+jJZezfpzxkfVcrui8At2dumPL0y3Y93IfkrKToKOpAxdTF8xuMxuTmk8qs8MjT5iHkf4jARQ6amrq1YS7pTsWdVgEr3peKg1UXJxjwccgIqJSr8Op96dw+cNl9K3bF3weH+6W7ngY/VDqdWhr25aZtVi8La8TXgMAwlPCmT4oyq1RtxjHEwBMbjEZbWzbYP2j9Tj57iTiv8VDU0MTTjWcMKrxKExuPlnmphXyMPniZACFy6PNdM3QpFYT7Ou7D8MaDpO6I500xjYZi0W3FyGnIIcVNLy3S2+cHnwaS+4swbTL02CuZ44/2/2JRR0XSZRx8t1JtLNrV662UKoum55sAgBoamjCmG+Meub1sKTTEoxvNl7qkvNDXofwV8BfOBx0GKk5qWhk0QgXhl5AB/sOUsv/ofYPsNS3RNy3OJm/9Xv67sHZ0LM48fYEYjNjQUDgaOKIBe0XYF7beYyDWTzTkMspedfeiuR76j8LfQv8WOdHnHh7gvUCBgAru6yECd8EO5/vxIHXB1CnRh0c8TqCYQ2HsfKJiAin3p/CuKbjaHBxCv5s/yf83vjhzuc78H3ji+yCbFgaWGKI2xD81eEv1DYpfcfz4ojHXPte7cO+V+ydfe2N7KU6QOR5zsS0s2uHo8FHpc5caWvbFqfen4KrmavMiROVAdrv8lOd7B6HqGq+PoXyHdL5UGdYGVgptHV5UZrubIpO9p2wvsd6JWtGoVAoyic9Nx2OmxyxustqjGs2TuHz47/Fo/bG2jg24Bj6udIZT5TKTUZeBoxWGmFh+4VY9sMydatT5VBG/937fA+dDnZCyJSQMi3LPhNyBsNODUPE9IgS479QKBRKZaG62L1qGeOJQlEXK35YgePBx/E57bPC5175cAXhyeGY336+CjSjUCgU5WPEN8Jcj7lY82ANRESk8PkbHm1Aw5oNqdOJUiV4GlO4E2l98/pq1qRqooz+a2/fHt2cujHxVBRlVeAqTG05lTqdKBRKlaG62D0644lCoVAoFAqFQpFBUEIQbkTegM9DH+QKchE5IxKG2obqVqvKQPuPQqFQKHTGE4VCoVAoFAqFIoPT70/jz5t/wsHYAZeHX6ZOEwWh/UehUCgUOuOJQqFQKBQKhUKhUCgUCoWiEuiMJwqFQqFQKBQKhUKhUCgUikqgjicKhUKhUCgUCoVCoVAoFIpKoI4nCoVCoVAoFAqFQqFQKBSKSuDJm5HD4ahSDwqFUsmoLuHfqO2qWvB4PNSqVQvz58/Hr7/+CgCIjo6Gra2tmjWjVBWqi+0CqP2iUL43qov9oraLQvm+kMd2ye14olAoFApFlXTs2BHOzs7Ys2cPk3b//n1ER0erUSsKhUKhUCgUCoVSHuTe1Y56rimU7wv61Y1S0aSkpMDExIT539/fH2PHjkVaWpr6lKJUOaqL7QKo/aJQvjeqi/2itotC+b6Qx3bRGE8UCoVCqZTs3LmTOp0oFAqFQqFQKJQqDnU8USgUCkXtHDhwAIaGhsz/mzdvxsOHD9WoEYVCoVAoFAqFQlEG1PFEqbKcP38eiYmJ0NXVBZ/PB49HQ5ZRKFUJPp+PSZMmITU1FQcOHMCXL19gYmICExMT/P7778jIyFC3ihQKhUKhUCgUCqWc0Dd1SpXFwMAA5ubmyMrKAgBs27YNmzdvBiEEYWFh1WadPIVSHTEzM8PXr1+Z/2vWrAlnZ2eIRCI1akWhUCgUCoVCoVCUDQ0uTqmy3L59Gx07dpR6bMiQIcjPz8fHjx/x6tWrilWsmlBdHHfUdlVOvL29cfDgQVZajRo1kJqaqiaNKNWF6mK7AGq/KJTvjepiv6jtolC+L+SxXXTGE6VacuzYMQDA06dPcfnyZezatQsxMTFq1opCoQwePBj169fHggULWOm7d+9GTk6OmrSiUCgUCoVCoVAoqoI6nijVmhYtWqBFixa4ePEidTxRKGpm0KBBWL9+PSwtLQEAISEhmD9/PgDgzp07yM3NVad6FAqFQqFQKBQKRQVQxxOlyjJixAi8fPkSZmZmcuV/9uwZDAwMmP/HjRuH+/fvq0o9CoVSjJs3byI4OBiWlpZITU1Ft27dEBUVpW61KBQKhUKhUCgUigqhjidKlSU6OhoCgaDEPDt37sSMGTNw5swZ1K5dGzwej9myPSAgACKRCDH/x955RkWRfG38mSHnJAaCYEZljYiKEVFXXQOukVVRdE2roq55dde0xjVhTmvOCcOaESMGxIgSVBRBBCUKkpm57wfe6T/DBGZgYBDrd849Z6a6uvpWdfft6ttVt2Ji4OTkBABIT09HTk5OqevOYHxvaGlpYfLkyXBzcwMACAQCzumkr68PHR0dpKSkgM/nw9jYGJmZmWwEFIPBYDAYDAaDUQHgq1sBBqMkPHv2TO723NxcZGdno3v37rCwsEDTpk3x8OFDPHz4EJmZmdDR0UHNmjWRlJSEpKQkzJgxA05OTuDzJW+Nxo0bl1Y1GIwKS5MmTeDk5ISJEyfir7/+4u4tTU1NODk5wcnJCYcOHUJSUhI6duyIAQMGICkpCZMnT1az5gwGg8FgMBgMBkMVsBFPjG+avXv3Ii0tDf3791co/9u3b+Hs7AwAmDZtGn744Qd4enpyq2/8/fff+PvvvzFu3Djk5OTg1atXCAgIQPfu3bFv3z5YWlqWWl0YjIpGt27dcPToUW6UYUFMTU3x8OFDsTR/f/+yUo3BYDAYDAaDwWCUEczxxPimWbFiBTp16iTmeFq6dClmzpwJTU35l/fq1avB4/Hw6NEj8Hg8uLm5oXfv3gCArVu3AgBevHgBf39/9O/fH2ZmZvDx8cHTp0+xe/fu0qsUg1FB0NPTA4/HQ2JiIhYtWgQgP7Zao0aN8Pvvv8POzk7qyKYnT57Az8+vrNVlMBgMBoPBYDAYpQCPiEihjP8/IoTBKE98/PgR9+7dw+PHj/H3338DAB48eABnZ2fweDxs3LgRkyZNUqis6tWro1atWgCAixcvQkdHRyLPhw8f0L17d7x48UJ1lSinKGgayj3MdqmXNm3aQCAQ4P79+wAAR0dHWFpa4saNG3BxceEC/P/222+IjIzE5s2b8dNPPyEkJESdajO+YSqK7QKY/WIwvjcqiv1itovB+L5QxHYxxxPjmyY2NhaWlpY4duwYYmJiMH36dLHtyjieClKtWjXweDx4eHhgxYoVAICcnBzUqFEDnz59Uonu5R3W+WGUNi4uLhg9ejTmzp2L+Ph45OXlwdLSEp8/f1a3aoxvmIpiuwBmvxiM742KYr+Y7WIwvi8UsV1sqh3jm0JLSwtVqlTh/mtoaEBDQwOVKlVCWFgYMjMzoaenV+LjxMbGAsifjrd27VouXSgUlrhsBoORz927d3Hv3j2xhxVzOjEYDAaDwWAwGBULtqod45uiYcOGiI6O5iQsLAzXrl1DlSpVUKdOHezZswcZGRkqPaZQKOSEwWColorydZfBYDAYDAaDwWBIh414YnxTxMfH48qVK+jatStOnDiBkSNHIi0tDQ0bNsSoUaMQHx+PTZs24ffff4eGhoa61WUwGIxSw9DQEKNHjwYAnD9/Hq9evVKzRgwGg8FgMBjS0dLSwsSJE8XShEIh1q9fzz5Efgcwx5OamDp1Kvbv34+EhAR1q/JNERMTg8OHD6Nr164wMjICn58/aO/ly5f4/fff0bFjRzx58gTe3t7M8cRgMCo0ZmZmWLNmDQDA3d0dkZGRGD16NHJyctSsGYPBYDAYDIY4W7ZswahRo8TSiAjNmzcXczzNmTMHHz9+LGv1KhQ8Hg+rVq3CtGnT1K0KBwsurgbGjx+PZcuWITo6GtnZ2QCAgwcPisUSUiUbNmxAy5Yt0bp1awgEglI5RlliYWGBDRs24MaNG9i1axfy8vLEtp88eRIrV65EXl4ePn/+jOjoaDVp+m1TUb48MNv17XD9+nV8/vwZgwYNUrcq3wS2traIiooSS3vy5AmCg4Nx6tQpaGlp4cSJE2Wiy5w5c3Du3LlyseJnRbFdALNfDMb3RkWxX8x2MaTh4uKCgICAIvPVr18fYWFhZaBRxeXcuXNo0qQJbG1ty+R4CtkuUhAATFQkurq6dPnyZSIiysrKIiKiNWvWqPw4ffv2peTkZMrNzaW8vDzS0NBQe91LKo0aNaLk5GTKysqitLQ0qly5skQeIyMjAkB8Pp90dXVJQ0ODtLW11a77tyYVBXW3Y3kVHo9Hurq6pKmpSVpaWqSrq8uJlpaWWnSKiYkhExMTTq+yagORqPucKCu2trZSr/kHDx7QiBEjKDExkRITEykuLo709PS4evL5fJUcX1Te2LFjKTs7m9LS0qhatWpqb5eKhLrbUp2io6Ojdh2YMClrqSioux2ZKCei53lp970MDQ0Vun4cHByKfYzCfdpvuZ9XXDl+/DgJBAISCoXk6+tbJsdUBBZcXA0YGhpCR0cHb968Qc2aNREWFlYqKzllZWVBKBRCU7PizKjk8/kwNTWFjo4ODA0Nual2BbGwsICDgwP69OmDyMhIzJ49G0FBQXBycoKDgwOsrKzUoDmDUb6oXr06MjMzsXnzZpw9exaZmZmcbNy4US068Xg8tG/fHpmZmSodGqyhoQEHBwcJ6d27t1i9vxXbYGtrW6Rd37NnDywsLHDhwgUkJyfjxYsXXD3Hjh3LtYGsL2HGxsZS28zBwQFGRkYA8mPuPXnyBAsXLoS2tjYMDQ1x+fJlldeX8X1hZmYGBwcHnDhxgrvWKiomJiYwNTVVtxoMBuM7plGjRsjMzMTnz58xYsQIdatTYnbt2oXMzEw8e/YMT548EZNWrVqhZs2aMDQ05Po02tra6lZZJWhra3N1qlKlCvh8Png8HqpUqQJLS0t1qweAxXgqc6ytrbFu3Tp06NABv/32G1q2bIk//vgDANC3b1/4+/vjy5cvEvvxeDy4u7sjNjYW9+/fV+hYwcHBuHXrFtzd3cHj8dC9e3f8999/Kq1PWZOSkoJTp05x/7OysgAA1apVQ6tWrQAAGzduhJWVFcLCwrBu3TqMGzcOdnZ2ePjwIQDg8OHD+OWXXyTKrlu3LjIyMvDhw4cyqAmDUbbY2trCyckJAHDx4kUuXRScWp00a9YMdnZ2MDIywtmzZ5Xa187ODs2aNZObx9TUFLt27SqyrB49eiAxMZH7HxgYiJiYGKX0KW0cHR1x4MABbNq0SSEnz7BhwwAAVlZW2LBhAwCgc+fOWLlyJQwNDfHixQv89ddfAPKnOqakpAAAevfujf3790stc9WqVbh//z5ycnLwxx9/oFu3bhgzZgxu3LiBXr16qaCWjO8RUV/lp59+wqhRo9CiRQt07NgRGRkZuHbtmrrVUyl9+vQBn89H586dERoaqjZnP4PB+P6wsLBA+/btAQA3btzAjRs3AADPnj3DrVu31KiZaggKCoK+vj6OHTsmEfPy4sWLyM7Oxu7duzF79mwAgLe3N96+fYvz58+rQ90S07FjR5iZmaF69epYt26dxPbWrVtj1qxZmD59etkrVwjmeCpjjIyMULlyZQDA5s2bJbY3bdoUT58+lUjX1NTEyZMn8d9//6F3795yjzFt2jTs378f69atg7u7O4B8x1WdOnVKrH9ZYWRkxN0gJ0+exPPnzwEAkZGR6NevH5dvxowZMDQ0RL169cTiwmRkZODu3bv4+eefsXv3bvz666+wsbGRe0x3d3c4Ozvjt99+K5URaAxGWWBnZ4eRI0fC19dXzJa0b98eBw4cAACsXbtW6mhBEU5OTli4cCEAYPny5cjMzCw1fZ2cnLB9+3Y0bdpU6X1FzhRZzo7Dhw8jLCwMhoaGYunbtm1DfHw85s2bJ5a+Y8cOsf8DBw7E8ePHFdJlyJAhOH/+POe4KQ0cHR2xbds2NG7cGNu2bcPff/+N/fv3c84lIN8Zf+HCBfTu3VvMiffx40f069cPrq6u+PjxI27cuAEzMzPUqFGDc+Zv374d3t7eXOxBWRTsvBT8EPD27VvMmDFD6j6pqalYvXp1serNKBn29vbw8vLCqVOn8OzZM3WrI8HgwYNRv359zJ07V2xRkLFjxyIuLg59+vRBo0aN0LVrV7Rp0warVq1CWlqaGjUuHm3atEHXrl0B5MdE09LSAgBMmjRJnWoxGIzviD///BM1atSAl5cXzp49i8aNG0NPTw8A0LZtW/Tt2xcrVqxQs5Yl48OHD3jx4gX27dsndTRTcnIy7OzsuP916tSBmZkZnJ2dERgY+E04oGxsbLgPxyNHjpT7jvv27dvyMxqdzdUte3FwcKCgoCAaN24c5eXlibVzkyZNpO6jpaVFQqGQzp49W2T58fHxdO3aNSIi2rdvH7m7u1OfPn2Ix+Opve6KyNatW+nixYtcmwQFBZG9vT0BoJo1a9KkSZPIy8uLfH19uRhZgYGB5O7uzkn37t2pbdu2RETk5eVFDx484MqLjo4mX19f8vX1pUqVKhEAatKkCQUHBxMRUcOGDdXeBuVBKgpl0VaLFi2i48ePl4t7THTdP378mHx9fcnc3Jx8fX0pKChIZhv9888/5O7uTtnZ2RLbSntu+Pjx46XqNGvWLLn77dy5k5ycnMT2yc3Npb59+3J2oGrVqgSAqlSpQsHBwVy6qakpaWho0JQpU+ReOwMGDChSfxcXF/L19aW4uDi6dOlSqcbSs7GxoVOnThERkUAgoO7du9OPP/4opnNSUhI5OzvTzp07ZV6r9+7do1OnTpGGhgZ17NhRbH9jY2MCQEOHDpXbNkREAwcO5NpUFLdQFpmZmZzdbd++faleUxUJVbSHq6srERE9evSIfH19SU9Pr1TbXxkZNGgQffz4kYiI+vfvT+7u7rRjxw6u/qdPn+ae969fvyYiImtra7XrrYxYWFiQr68v18cozMSJE9WuI5PyIxUFdbejstK4cWPuGWVnZ6d2fVQpAwYM4OomEAi4czRq1Ci6f/8+9//27du0ePFi7l1UZLtEUr169RLrIi/G06NHj7g+hSheb3Fk//79cq/NiIgIqlq1Kh06dIiWLVtGhoaGZGlpSUREGzZsUFm7a2lpcW03cOBAlZ5Tc3Nz2rp1KxERzZw5kwYOHCizvp8/f6YRI0aU+nWmkF1QKBd9ewakvMu5c+fo3bt3Eu0sy/HE4/HIzc1NIcdTUlISERGdP3+ezMzM1F5XZaVmzZqUm5tLd+/epbp161LdunXp0qVLFB4eTu/fv6fdu3eTpaUlt61u3bpkZWUlUY7oBTwuLo569uxJX758kWjvt2/fUnh4OEVHRxMR0dSpU1kg8v+XikJZtJXI0fvq1Svatm2bWs+b6LoXYW1tLbd9tm3bRoaGhgSAateuTf379xfbnpmZWar6Kup4atu2LYWHh3OSm5tL586dozlz5nD7ZGVlSXX+aWhokI2NjUR6o0aN5LaNIo6nAQMGcPkFAkGpB+asVKkS3b59m3PeFMfxNG7cOKpduzYBkHA8vXnzhsLDwyk2NlZu2xCRWKDObdu2FZlfxJAhQ0q1jSoSqmgPkeNJxOvXryk8PJxWrlxZqudBEVmwYAEREXXp0oVLmzRpEhER9e3bl758+UKXL1+m6dOnc/p/S44nPp9Pr169knuOi3I8WVhYUHh4OM2dO1ft9WFS+lJRUHc7KirXr18Xew8gIoqMjCxXDnpFxMHBgZYvX87919LSorCwMAoPD6eEhASp50jkeMrIyKC6detS1apVafny5RQdHU3h4eH09u1bsfyRkZFcH2zp0qXF0pPH44m9vxUUDw8PrvxatWoVuy0UcTwB+c4bUf9XVY6nAQMGcHUQfSwhIvrzzz9LVO748eMpPDycatasyaWZmJhQ3bp1SVdXl/T09OTWedWqVaV+DSoCczyVUMzMzLiLVp6YmpqSiYkJAaD58+eLeZyJ8l+YkpKSyNHRkUxNTQkAaWtrk5mZGV27do2ysrIoOzubBAIBZWVlUUJCgtjFB4D09fXJzMyMUlJSiIjo1KlT30QEfz6fT2ZmZpzw+XzS0dGhrl27UlZWFmVlZZFQKOTa6tChQ7RixQpq1aqV3HILvoBnZ2dTkyZNuLaRRU5ODjVo0KDYdTEwMKgQqwcC33fnR09Pj1vZjcfjcdemyClpZGREWVlZtH//fjIzM6Nbt25xxxPdo1lZWeTk5MTdz2UlhR1P0kYx5eXlkb6+Puno6Eg4SrS0tGjGjBlc3szMTM52qVpatWpFubm5Us+byPHE5/MpLS2NcnJyJPI8fvyYxowZw418jIuLk3oc0TnU19eX21YFWbFihdTV30R2VuTU79OnD2VmZlJaWhrnzCltKbjqoLKOJyMjIzp37hw1adKEzMzMqHv37pSeni6zHeRRXMdTbm4uZWVl0adPn0qlfSoSqmiPwo4nEQVtlYODQ6nd54XF1NSUzMzMyMPDgxv1XfDe0dDQIB0dHeLxeJSSkkJCoZCOHDlCq1evptzc3G/K8aShoSExsr0g2dnZ9Ouvv8oto169ekSUb7eHDRum9jqVRPT09MjMzIwiIiIoIyODPn78yBxqhaSioO52FImOjg73zLaysqLMzEzO7mVlZVFycjIlJSWRr68v6ejocKJuvZWVDh060OHDh2nDhg1c3eSRlZVFQ4cOJW1tbbH6zp8/n5KSkoqU+Ph4SklJoaysLKpdu7bC78MGBgZi7d+7d2+KjIykrKwssX5eSVa1U9TxJO1aKdwnFo0CL0revn1Lrq6uMvu0qampYh9Y5InITpqZmVHjxo25ldyTkpJk9jOrVasmt87M8VSORVNTk5ycnKQOKbSwsCAnJydycnKiVq1akUAgoIsXLxZZZkJCAkVGRlKtWrVo8eLFEu27Zs0aLm90dDTp6+tzXwIL8/HjR3J1deXyGxoakpOTE50+fVosX2JiInl6eqq9PaWJnZ0dOTk5kZaWltiIASIie3t7cnJykjkSgohoypQpRZ7D0aNHi+2Tnp5Ojo6ORV7rxZ1qV6VKFTp37hwNHTqUu0YKi7rbXRmpKChbbzMzM/r3339p6tSp5OTkRN27d+fKmj9/Pjk5OUmMEhGRnZ1NgYGB3Jez4OBg+vz5c5meN3nOFBG5ublSnSoAqGHDhhKjMSMjI8nJyYmqVaumUl3btGkjU8eCjqdHjx7Rly9fKDAwUELmzZtH06dPp8DAQJkjPKtUqUJEREeOHCEnJyfS19eXOtz72bNnlJWVRYGBgTR+/HgCQI6OjmL3sGiqW3Z2Npe2aNEicnFxUct9KsvxdPr0aapcubJE/rFjx1JycjIR5Tvat2zZQt7e3kVeM9Io6HiaM2eO2Hl58+ZNkfunpKQw21UEqmgPWY6nwsTExHDXdGmNlnZwcOBGZYt4/fo12draSs1f8GPR9OnT6erVqxXK8fTvv/+K5dfR0RGzN87OzpSbm0upqakUGBhIPXv2VEs99PX1ycnJiapUqaL0vnw+n6vPvn37iIjo6dOndO7cObWfn/IoFQV1tmHB5/by5cs5nQQCAQUHB1NiYiL3rBJNyf+WxcDAgAIDAyVGKEkjKCiIAgMDaebMmSU+rqjvJXK2XL9+Xcx+SRuBLm+qXUHU4XgqLPr6+hQRESEx0EOapKam0suXL2Uec+vWrUV+iNbT0yMnJyc6ePAgt5/ovULUJ5UliYmJcuvMHE/lUFxdXcnLy4smT55MRETr16/ntg0ZMoS8vLykftVV1PFERPTw4UM6e/Yst++xY8fo48ePNHjwYGrbti15eXnRp0+fqEmTJlLPQ1RUFPXt21es7MIvb3l5ebRr1y4aN26c2ttUJH379iUvLy9Orl+/TkT5U9sKM2vWLIkRYYUpyvFkZGRE58+fF9snOzubJkyYQDdu3JBbdnEdT507dxYbVlmYvLw8habulBepKChS1+7du5OXlxf17duXmjdvTk+fPi3Wsd6+fUsAqFevXrRr1y6qVq0arV69ukzPW0kdT0D+l7Ndu3bRrl27xL6azZs3TyJvw4YNufta2WlmijiegHxn4LRp04rdJiLHE1F+DAM7OzsaNWoUlxYYGMjZzILTjzp27MjFn5HHyZMnuTYYNGhQmZ5vWY4novwYf15eXhIfILy9vSk1NZV7xqnC8VRYnJyc6NmzZ3L3Z46nolFFeyjqeEpLS6OrV68SUf50Ay8vL/Lw8FDpuZk9ezZlZmYSEdH79+9p165dUkMMiPpDGRkZnH5Hjx6lNWvWlFkIgW7dunH3tZubW7HKUNTx1L17d9LX16fZs2eLbT9x4gTt2rWryJh3pS2iPumhQ4cUflFv06YNeXl50bhx44go//koinM1derUchETsTxKRUFd7efq6ioxVTwgIIB27dpFW7dupQYNGtDRo0fVfp6LK3p6emLvUwVl586dRZ6X0hjN5ePjw/UZnzx5wh1r9OjR5OXlRS1btuTyfkuOJwMDAyLKt3tF5V29ejXX95KFj4+PROyqtm3bkrm5OQ0ZMoT++usvsfxHjhxReEq8LMdTeno67dq1q0z6porAHE/I94z7+PhQREQEV983b95Qhw4duDzypmgV5XiaMmUK19EqiEAgIFNTU86RJLpRZs2aRYcOHRLLm5eXR5MnT6ZevXpJlF+tWjU6duwYlzc9PV2t7Tl//nyysLAgHx8fTgrfEEePHiVvb2/y9vamJUuWKHoZcty8eVPqDVxQrKys6Pjx42L7JSYm0pIlS8jPz09m2SUJLr5nzx65eoscE9+CVBQUqevt27eJiCg5OZl8fHwoMDBQbpkzZ86klStXElH+lFZvb2/68uVLuTi/qnA8FZQJEyZw+xV0PBkbG5OPj4/YNENFhlkXFEUdTyUVfX19Wr9+PRERXblyhXx8fMSmIIqcWtHR0bR+/XrObsmLzZKbm0ve3t60e/dusfS0tDTy8fEhd3d3GjZsWKmPzijseJo5cyYdOXJELC0vL0/MHjds2JA8PT25a6A0HE9A/lRKb29vmjJlitSPCdnZ2eTj46Ny50ZFQhXtoajj6e3bt2Rvb0/e3t6c872or6zKire3N+dMOn36tMT2WrVqkY+Pj8wvx6dOnSqzKYF9+/al1NRUrm26d++udBkLFy4UCxVQGJHjqX///uTj4yO2bceOHWVW16Kk4MfQgn1jaVKzZk2JcxgbG0tz5szhFrkQCoW0aNEitderPEpFQV3td+LECTE9bt++LdavNzc3pzlz5lDnzp3Vfq6VkTFjxpCPj49CziVZLF68uNTDgbRs2ZK8vb1p8uTJnNP96dOn5OzsTED5dTwZGhpyfSRRKBdlHE8AinQ8ERE3eqp27drk4+NDc+fOpZUrV0oNi6HMLIPC79lbt24lb29v8vLyKrNrVBGY4wn5MTpEDB06lFxdXSW+wJXE8RQQECB1v8KBaEU3irRgwDk5OTK/Djk6OlJ4eDiXt7QdT3379qUff/xRIn3cuHHk7+9PWVlZdO/ePTH9R4wYQa6urpwUDAbu4OCg6GUoQeEvb4sWLaJr165xMVAKvjSLEMWIkgVzPOVLRUGRujZr1kxq8HmhUEhdunSRGJlnZGREhoaGtGzZMpo6dSoB+U6UouKOlbaYmZnR48ePi2wToVBI169fFwtEKUsKjtB8+/Yt+fv7k7+/v1S7Vl4dT0D+KK6CZGRkcPZINM0nJiamyLYTIQq6bmlpKbWTExUVRXFxcRQYGFiqU0oKO56KCiZPRPT8+XPy9/enEydOEFB6jqdRo0aRv78/Xb9+Xe7Ld2xsLHddXb58ucQjISoSqrhGlHE8ifZxdHSkqKgoOnPmDJc2bdo08vf3L/ZqQxMnThTrS0lzPCniOC/LqXYFR04sXrxY6f3fv38vty4Fp9p9/vxZbFvv3r3LrJ5FiaGhIbm6utKJEyeoQ4cOdOTIEYn7dO/eveTv7y/1GZSWlkbr16/nnOICgYDatm2r9nqVR6koqKPthg4dKnEfxcTE0E8//SSWb+DAgRQREUH+/v7Fmj5altK+fXvy9/eXGSBcGerWrVumuvft25c7tmhVtfLqeBIFFyciCg0N5fojrq6uCsf+LcrxNHfuXNLV1SUzMzNuZNjw4cNl9tuL43i6ceMGubq6krm5eZlfq4pQIRxPPB6PNDQ0JLy4ojQNDQ169eoVxcTEUExMDI0aNYpLr1WrFneyvLy8ZHqCVel4WrlyJVlZWZGNjQ0FBgZyX5337t1LeXl5ZGVlJfU4MTExtHv3bgLy58xraGjQ27dvKT4+noRCIdexFwqFdPXq1VJp6zZt2lBKSgrXVqGhoVy7pqWliel79epVWrZsGY0fP17mFBx9fX2Ki4tT9DIUo3///mKjNng8HhfnytbWlmJiYig5OZmEQiH16tWLcyxkZGTQnDlzuOl+hWGOp3ypKCha36pVq1Lbtm0pLy9P7F7S0tIibW1tsrKyoqNHj1JeXh734qWnp0cGBgZqP1ciKTilTBGysrK4+zc6OpoLjl/whUKZzk55cjzNmDGDq1tMTAzFx8eLlS+tA6aI42nWrFlkZWVF0dHR3H6LFy+mvLw8atWqFVlZWZGVlRUtWLCA8vLyKC8vr9SmlAHyHU9z5szh9BFd2wWn/QgEAoqJiRF7vgkEArF7QBoCgYBcXV2LdBAZGxuTlZUV2draUmRkJA0aNKjIsrOzs5njqQCquEa0tbVp/vz5RR6r8PMpLCyMBAIBnTlzhoYPH84Fof/48SPFxMTQ1q1bFfp63qhRI6l9hIKOJz6fT1WqVJG4TwsjEAhK3fHE4/Fo0aJFFBMTQwKBgN6/f09WVlbFcrgV5XjatWsXaWhoSCxzTqS840nUL1R0NGtxxNTUlM6dO0d5eXlcn3Tq1KkUExMjM6iuiEOHDpGxsTH5+/t/czEvy1IqCqpqD9H72uXLlyksLEzimn/y5An3nBeNUCzM6NGjxfYbMGAALVmyhKysrMrVgkA8Ho94PB7x+XwKDg6mmJiYImP3KENZOp5EYQ1EJCcnU5MmTcjExEQhXcvC8SS6tm7duiV1Jd/09HSlbKqTk5Pc/o1o1lLVqlWJiGjnzp20bds2qYvnCAQChRxPPB6Pzp07R0KhkF69eqWyqeh8Pp9u3bpFNjY25Ovrq1C/TBEqhOOpZ8+elJKSQgKBgFq1akU2Njbk4eFBAoGAk4IIhUKp2/r06SPzGMVxPBkYGJCNjQ03tJgo3+nh7e3NXSxv376lgwcPcv/5fD63gklhRLGbgPyhpCLds7OzaenSpfTPP/9QdnY2vXnzplQ6HlWqVBF7IZcXh+nevXvE4/Fo4sSJ9P79e5lR+At/mVAG0XDvqlWrkq6uLjf1iSj/hs3OzqYlS5bQqlWr6P3792LGQCgU0tChQ+nRo0cS5TLHk+IG5FtA2Xrz+XxuAQChUCi2yIDoHlX3uZF3jyrCx48fKTo6mqKjoyWcDgKBgPbv3082Njakra39TTqe3N3d5T78iUjqSiWKOJ7Gjh3LXSfyrgtRmig4uo2NTanEpunQoYPYOSzoeCo8TUqkz+7du7nzX9gGN2jQgPh8Pnl6espsA9GyvsqsmipqHz6fLxY4szDM8SSOqq6TKVOmFHmsws+n69evc/eErPspKSmJOnbsKPfYTk5OUvcVOZ4sLCwoIiKC61OkpaVx12fh43bt2lXl95C5uTnZ2NiQtbU1aWlp0ZQpU8SO+/79e7KxsVF4daOCUpTjiYhk9qWUiZtnaWlJHz9+JIFAUCojLLW0tMjGxoZ27NghpmNGRgZFRUWJxeKShWi6CovtJF8qCiVpg6pVq5KNjQ0NHDhQ7F0tNTVVLJ+8sBkFKex4Kq/X4ejRo2ns2LF08uRJysvL4+xgdHS0WMiWrKwsio6OVnpF2qKmyapSXr9+zS20I0L07piTk1OkQ63gIlrKSlGOp8jISPLy8pLqIyiMQCDg3tMVPYeyEDmemjRpQllZWbR69WqJkDAi5K2Ax+fzycbGhmxsbMTqGhISUqJzpqmpyZV78eJFrv5ZWVm0cOHCIvdXhArheALyh/QXfkF6//49+fn5SXxlk8bbt2/lrkp07tw5mfsWdjy1bduWjI2Nac2aNVyemzdvkp+fH/31119F1kWWvgU7hSdPnuTSg4ODqV69egSANmzYoPTLn6Ki6EvtjRs3FDbop06dkpiWpyhTp06lH3/8kWJiYujPP/8U25aTk0Nr164lIH8qn7GxMbeSU0Hs7e0lAn8yx1O+VBSKU/cRI0ZwX94TExPJzc2tzIcol+Y9WnDEwODBg8nPz4/8/PwkHsCi2FWKUp4cT9KIiori6qqvry+xnyKOp7Vr1yodd8XY2JiIiC5fvkxubm7k5uZG2traKjvvM2fO5PST53iSJo0bN+baxM/Pj86ePUtA/pSFolDG8VRQ5HUKmeNJHFVdI8VxPImuXdG1Ie3+2LlzJ7m5uRUZaF4aIsfTwoULOcdFcnIyTZgwgdu38Ec/VcZlMTMzIzc3Ny6genp6Oo0dO1Zm+5TGVLuiqFWrFmlra0t9BhkaGnL2pOBUjfPnzxOQP13Szc1NJR9LCi94IxQKyc/Pj4vT5OvrW2RdFI2T8r1LRUHZeleuXJm7nqUt6vHgwQPu+SSSa9euKaSLNMeTLGnYsCGnR1mOzBO9N65bt47c3NwoPj6eWrVqxbXL/fv3KSAggPz8/LiA00U5WKRRGsHFpcmePXtkTv1/9uwZubm5FWkfS6OPIU0XPz8/sXilhSlsu3R0dKQuigFAbOGawvTq1Yt4PB7l5OTQ9evX5YY5kLaghcimF5zCKOLmzZsSq6QqKs2bNyc3NzepHxwLvk+rwnZpooLw77//on///ujWrRsAICoqChMnTsS5c+fw/Plz/PDDD2L5jx8/jp49e0JPTw8A8OrVK3z69Elm+deuXUPPnj0V0uX06dPYv38/pkyZAgA4evQoRo4ciYyMjCL3HTJkCLS0tKRuMzExwdSpUwEAderU4dIdHR3h7e2NCRMmYNKkSQrpWJr88ssvICKF8v78889wcHBAaGio0sdZs2YN93vRokXc77179yIqKgp//fUXGjdujG3btuHevXvQ0dGRKMPLywu7d+/Gr7/+qvTxGRWXPXv2QFNTEw0bNoS3tzf8/Pxw69YtnD59GgcPHsTnz5/F8vfr1w+XLl1Cenq6mjQuPkeOHMGRI0cAACtWrICWlhYaNWoENzc3+Pj4lLh8Pp8Pb29v8Hg8PHjwAHfv3i1xmbIYO3Ys9PX1oauri/v376NVq1YAgIyMDGzbto07hyVhypQpOHr0KO7fv6/0vl27dkXXrl0BANWqVUNcXFyJdDE0NMTo0aPRrl07AMD+/fsxYsQIpcp49uwZOnfuXCI9GBWX1NRU7voYOHAgfHx8ULVqVW77qFGjMGrUKCxevBhRUVHYuXOn0scICgpCeno69PT0EBwcjE2bNqlMf3k0a9YMfn5+3H99fX1s3bq1TI6tKCNHjkR2djYWLlyI9evXY/LkyfDw8EDVqlVhZWWF6dOnS+xTo0YNTJ06FcOHD0fjxo2hp6eHrKwsAICbmxsaNWqEvLw8bNiwQWE94uPjceXKFXTt2hUnTpxAZGQkZsyYobJ6Mr5fxo0bBz09PTRq1Eji+RUdHY0TJ04AAFavXo2YmJhiHaNz584wNDTk/oeFheHixYsAAB6PB29vb/D5fADA0KFD0axZMwD5tqlFixbFOqaymJqacn2vqlWrwtDQEGfOnMHFixdRp04d3L17F3///TeSkpJKdBxvb2+8f/8ex44dU5Hm/6NWrVro3bs3AGDy5MnQ1dWVmffatWuYNGkSNm7ciCtXrmDkyJHg8XhieSZNmoS8vDwAwNWrV/HixQuV6PnlyxfcvHkTvXv3xqNHjzBt2jSMGzeO60sVJDExkbtWgPzrZc6cORg0aBC2b98OANi3bx8SExOLPG6fPn1w584dpKen4/79+3B1dVVIX3t7e/Tt25ez6SKeP3+Oa9euwcPDA3379lX62mjYsCG6du2KCRMmoFatWmLbzp07hzdv3uDr16/466+/lCpXLgq5p6h8j3hydnamvXv3in2Nu3LlCrf9+fPnlJGRQZ6enpxUrlyZPDw8uPy+vr5cgFljY2OaM2eO2DHkTbWLiYmhAQMG0IQJE7g4TQW5cOEC7d27V6FAvgWXoVSGTZs2lXo7KzqaomDgcEWkcHDxadOmceep8Op+hcnLy6Phw4eTp6cnNwqs4FfBevXqcWVJG5IqFApp+/bt9M8//3BpbMRTvlQUStIGoi8TBSn8lcPDw4NiY2MVXmK6PNyjRcVIqV27Nnl6etLr16+VauvCI55mz54t9uWp8IgBVY54mjt3LjcU3dfXlxYuXMiVFRcXRw4ODrR37165AW0VGfG0e/dusrS0VEo3Y2NjioyMFJumoorrxdbWlp4/f05Hjx4lonzb5eHhwdk80UjY4khpjXjq1q0bvX37VmaZbMSTOKqyDUWNeJo6dapCS0x3795d5qjs9PR0mjFjhsQ+skY8RUVF0d69eykqKopLu3Xrlti+pTniyc3NTaFz8PnzZ/L09JT5hVuWTJ8+XaER94ri4+NDv/76q9IxX/bv30979+6lvXv3cgvRiKYMKyO1atUiT09PqcGY2Ygn1UlFQV4dO3TowF2TWVlZYvutWbOGe4YVNbVW0RFPhXn37h13/H379smcSpyQkMDl27t3b7Gm2yojY8aMoT179pClpSXFxsZy7zeNGjWSmr84I56mTJlCt2/fVom+Q4cO5dpmxYoVYqPNT506xfVNCvPs2TOujC5dupCxsXGRU95k2aypU6fS3r17ad26dQq3S0REBPXu3Zv7Ly3Gnojg4GCx4/F4PJo8eTK3ffPmzWRqasptlzfiiSh/FKuXlxddvnxZbj43Nzdat24d7d27V+I6T0tLI09PT2rZsiUB+c9lZUbR6+np0d69eyViUH/69Im790Q+EVXbrm/a8eTv709BQUFSO7EFHU8NGjSQ2mHg8Xjk7u5ON27coGrVqtGqVasoKCiInj17RmlpaWIdKHmOJ6L8VXmSkpKkbvPy8qKUlBSJoHjS5HtzPF27do2Cg4O5fb29vcVunsKriRVkzJgx1KxZMy5vtWrVqHnz5jKHkUqbakeU3/ktGKCXOZ7ypaJQkjaQ5ngKCQnhpmn99NNP9OnTJyLKf5AWHgZe1qLIPTp+/Hhu1ceipF69ekXavoIUdjwVDuBfmo6n27dvc/smJyfT/Pnz6ebNmyQUCqlr167cC1dkZKTMoJXKxHhSRgICAigjI4PWr19PzZs3p+bNmyscu0WeaGlpUe3atWnmzJk0Z86cYg9LlyZFOZ769etXLAfRtGnT5JbLHE/iqOJcOjk5ScTaKMzz588pKyuryCH1e/bskfi4VpCCfS8gfzpYaGioQnVNTEyUmE5WHhxPxX1uX7p0SaHyFcXHx4d2797N/X/16hU1b968WC+fDx48UFk7AszxpEqpKEir2+3btykoKEhiilVkZCT3bFRmKrvohTwmJobbv7jOKEWoXLlyqZ77SpUqUaVKlQjIn1ZVVH57e3sKCwtTqg4GBgYl+ihVUDZs2MCVm5WVRW/evJF53AULFnDPgoKOJ5E0a9aMO4fNmzeXeLeX1feqXbs2xcTEUE5ODgUFBVFQUJCYcz4sLIyaN28uNpChsONJHoUdT0B+32vixIm0d+9eMjMzo6NHj3L9r6IcTzVr1uSCi8vj1atXEu8fM2fOpObNm1Pjxo2Ldb4WL15MQUFBUn0NXbp0UeiaK6nt+qYdTyJHj0AgoMzMTMrMzKS0tDSysLBQeKWp2rVrU05ODiUnJ1NaWhpXzvXr10lPT4/Lp8zLV2FcXFzIxMREbEUUbW1tqZ3r4jqetm3bRrq6uqSrq0uRkZF0//590tXVpcWLF1P37t1L3JHn8XhFrjZDlB+gXd6xRDrq6urS1atXJb4ydO/enYB8Y5qcnCw3YKWyQUZlOZ6EQiGdO3eO5s+fT3l5eczx9P9SUSjpdZ+amkqZmZliK/akpKRQcnIy7dmzhzZs2EACgYDS0tLEvnqUtfB4vCJfLomUe3G7dOlSkUG6C1JWjicdHR0xW7J69WruZVgoFNKpU6dIV1eXDAwMyNTUlHg8HvXs2ZOI8h1vslaxUcTxlJGRQU5OTvTy5UtKTk6m5ORk+vz5s8xAmAXtXEZGhlKxJhSVmTNnUnp6eolWgSksRTmeinusohxPshaiUEYqEqo4l5qamjRnzhyFjldUYGpDQ0OKjY2lzMxMqSvx+Pn5iTlVFVnBaMiQIWRqaioxmsDf35/S0tKoVatWXN+sJAFnC0rVqlUVHo0kEAi4Fwtl4iUV5XgSCoW0a9cuMjU1JVNTUy6AcGZmJi1atIhMTU3FXr58fHxo+/bt1L59ezI1NSUjIyPS0NCgdevWEVH+i19mZiadO3eOFi1aJPfYmZmZKrVBzPGkOqko8Hg87hm9d+9eiT54Tk4Ode3albuWi9NWhoaGErbDwMCAnj9/TlWqVOHuLVNTU7GFngq+N2ZmZlJERAT16dOnyJUZq1evTg0aNOCe/cnJyVSzZk21Xi/KvjcqG+Op8Ega0YrhycnJlJ2dLfdYnz9/pu7du1NmZiYNGzaMjIyMFD7fxsbGYgHVMzIyKDk5maysrMT6f6L3Xlk8fvyYBg4cKGbvX758qbDjSSAQ0O7du7nnmr6+PiUkJFBaWhplZWVRcnIy5eXlkbm5OQFFO55q166t0Ps0kbhNNzU1Vfijsei86erqkr29Pfn6+tLEiRO5Z7bout+9ezd3f6gi2L4ifNMxnl69egUTExNcvHgRv//+u9y8devWBZ/PR0pKikRcDS0tLZiamsLd3R1nzpwR21a1alWkpKSUWNcvX74AAIyMjGBtbY2tW7di8eLFiImJQXp6OqKjo0tU/pgxYzBmzBjuv52dHTIzMwEAHz58gLOzM2JjY2FgYAB9fX3Ex8crfQxjY+Mi83z9+pWL72RgYABbW1tum6mpKe7du1dkGXw+H69fv0ZOTg7S0tK4OFyFuXz5skripPB4PPTs2ROfPn3C7t27kZ2dXaLyGBUHIuKue09PT8yZMwc1atSAiYkJAGD48OH4/fffsX//fsyYMUMltqIkujZp0gR37tzh0uzt7eXOsS+KpKQkCIVCaGhoKJS/du3aePr0abGPpwhWVla4ceOGWJw7EUSEK1eu4Oeff5bYlpaWBiDfDmlqakIgEBTr+Hp6etDU1ESzZs0QEhICS0tLzJ49G69fv4aDgwNyc3MRERHB5e/SpQsePXoEfX19+Pr6YseOHcU6blHo6+srfJ7KM6LzxFAdeXl5iImJQWpqqkLPcXl8/foV1apVAwB0794da9asgY2NDRc/xc3NDdu2bcM///wDAHJjZxYsU5rtNDIyAgDcv39fZj+guPB4PLGYL/Lg8/kYOHAg3Nzc4OHhgatXr6pEh6CgIIwcOZL7X7C/JOL169dcnyQuLg7Lli0DkK9/vXr10KtXL3h4eCAsLAwdOnTg4g/OmTNHJToyGMWlY8eO8Pf3l7l96dKluH37NveuUhy+fv0qkZaeno5GjRpJpEdERMDAwAAAZL43/vHHH1i5ciWA/HdMoVAIU1NTLq7d+/fvJfYRxYaqKFhaWiIjIwPp6emwsbHB4cOHMXr0aG67mZmZTHv89etXfPjwgXsmCIVCXLx4sVj2OzU1Vey/np4e9PT0iozzlZycDA0NDSQlJSErKwvv3r3DsWPHUKtWLfz555+IjIyEo6MjOnbsiISEBFSqVElueXw+HyNGjEBoaChWrlyJ8+fPw8LCgtsuih98+fLlIuOBffjwAba2tjA1NZWb7/Pnz0hKSkL79u2L9b5eqVIlnDp1iotZde/ePdja2kJLSwuRkZFo0KBBie67kvBNO55EgWOlUblyZbRp04b7f/jwYejo6GDXrl0YNWoU2rdvDwsLC1hZWckso1atWti+fTsuXbokM+C3InTo0AFVqlQBALi4uKBHjx4wNzfnglpeu3ZNqeCuYWFhCAkJQdeuXRXqOO3Zs4drq6ZNm0JHRwezZs0qRk2Kpl27dlzHtlmzZpg3b57MvDdu3OACoVlbW6Nly5ZwcXHB7du34evri5cvXyI1NVUsiHhpMmrUKHh4eODNmzdlcjzGt8W+ffuwb98+PH78GE2bNhXbpmxA59IiMTER9evX5/6vXLmSCxhoa2urdJDMX375BV27dhV7yMrj5s2bnFOuKNzd3dGwYUOl9Klbty7+/fdfCafTs2fPEBERgdzcXAwePFjqvgkJCTh16hScnJxgbW2Nt2/fKnXswmRnZ+Onn37Crl278PnzZ5w5cwbNmjXDx48fYW1tLZa3efPmJTpWUYSHh+PDhw+legzGt82+ffvQuXNnDBs2TGVlXrx4ERcvXsTcuXPxxx9/QF9fH0B+QGyRQ6XgB7HCxMbG4t69e4iNjZXY1rx5c5iZmalM1+JCRPD19QUAnDhxQmVOp9zcXFy/fr3IfD/++KPUdAMDA4SGhiI6OhqjR4/G2bNnVaIXg6EqZs6cKXf7/PnzkZubi3/++Qc5OTmlrs+gQYOKzPPq1SucOnUKQH7/Jzs7G15eXti1a1dpq1dumDZtGnJzc/H48WNYWlqibdu2Ci8A5efnh759+2L27Nlo0aJFiT/Gnj59GlWrVoWdnR2ePHmCjh07wtzcXO4+d+7cgampKc6cOYO3b99yOixbtgx6enpYs2YNiAjXr1/H+vXrxRankkZqair8/PwQHh4OID9QfXZ2tsSHvg4dOgAAIiMj8fbtW9SsWVNse0hICLZt24bDhw9DU1O++2X58uVYu3at3Dzy+P3338UCpbdu3RqtW7cGkB/gXF1OJ+AbdzwVZujQodwLSc2aNTF06FCJPM2aNcPChQsxYsQIVK9eXWZZdnZ22LhxIzp16oROnTqVSK+lS5eK/b9+/Tq0tLTEVoYRsWXLFmzYsAHa2tpSywoPD8dvv/2G69evIzw8HDY2NlixYgWA/ItJtBJDQQo7f0Te/NJg/vz5MrdlZmZi+fLl3P9du3ZhyJAh0NfXh1AoRMuWLTFv3jwYGRlh8ODBEAqF3Cp+ZUX//v3h7+8vsWoZg/EtUrDj5+joiJ9//lmtjtUOHTpg4cKFAIC5c+cWOUJn2LBhqF27NvffxcUFbdu2lci3c+dObNy4UW5ZL1++RL9+/eTmWbVqFTfKQsTEiRNhaWkpc5/WrVtzHVV1cebMGWhqajK7xVALS5YswejRo2FnZyexTbTqT2GSkpIwdepUHD16VCzdzs4OI0eORO/evVGrVi2pIxrKkry8PPTv31/hlXqL4sSJEwgODkZWVlaJ+mI5OTmYP38+goODy43TacOGDfjtt98qxMhLRskZO3as1BFCBalRo0a5ul7OnDkjMfOlovH7779zIydlIW/QQEEuXLiABw8eQFNTE3/++SeXXvBdrySMHDkSGzduhJGREV68eAFnZ2epjqd169ZBIBBg2rRp6NWrF4D8gRDZ2dnw9vbmnPzFWZ0tKiqqyL7jxo0bkZubCyB/MMmlS5fw22+/ieU5cuQIOnfuzA1E+V6pMI6noUOHYvXq1ahcuTKA/C/gffv2BZB/QYo6RE2aNEGTJk3E9g0MDMSyZcsQGBjIpYmGCyrKqVOnsH//fgDA0aNHZTqOAHDLJxIRBgwYIDZVbPv27Vi9erXM/V+9esXdQBMmTICWlha3zGP16tXRrFkzZGdnY/DgwWjbti2mTZumcB1Kg5MnT+LAgQMA8kcIFFySEgBmzJghMZoiJCREZZ08ZenXrx/mz5/PXuAYMvn9999x4cIFbujwyJEj0b59e4wcORLJyclq1k42L168UNlStMWlXbt2UperLcydO3dw8uRJbNy4UeyLv6+vL2fXgfypfd26dcOFCxcU1mHSpEno1KkThgwZgoyMDLFtjo6OEp2awlMVt27dilevXsks39zcnBshsXbtWty6dUth3UrCyZMny+Q4iuLi4iJ1ufWCjkTG90tSUpKE0wnIH5lZ8OXg119/VdkxPTw8MHDgQIwfP16mQ6wwmpqa8PX1xYMHD4p8WZPH06dPsXDhQgQFBalkdGJOTk6RX+rlUXCKnypYtmwZQkJC8PDhQ+zbt0+lZTMqJtu2bcMff/yh1tEX3yOKOJ7kMXjwYG767/Pnz/H27Vvw+Xw8fvwYHz9+VJWaAIBDhw7B3d0dgPyR4z4+PoiLixMLNbF27VrMmDEDJ06cKJEOdnZ2mDp1qtwRSFu3buUcT9K4f/8+NDQ0lJ51UCFRKBIUlc/g4gVl2bJlnK6xsbFiy4U/f/5coj4eHh5Ut25dqlu3rsxV2ExNTenEiRPUt29fSk1Nldk2N2/e5FYhAPIDlovKrlu3Lj1+/Fjmvrdv36ZWrVpReHg4J/KC+cpbNatKlSpUt25dLjirkZER1a1bl27duiVWxooVK5RuXx6PV2QQORFt27bl6m5hYSG33ISEBCIiunDhAm3evJl+/fVX0tTUpCpVqlB4eDh9/vxZ7rGUWZK8Vq1aYuel4CpYBSlJVH/ROWjSpInUsllw8bKnNNqmcePGFBISQjNnzuSOEx4erpLgfOVNCt838uTjx49i+xYOLl4UTk5OVLduXe6+tra2Fit/zpw5Yrby/fv39O+//ypUD2dnZwoPD6cvX74QkfRVVRQJLv7p0ydulVRtbW2qW7cubd68WWre2NhYCg8Pp0ePHqn9PCorRQUXf/fuHYWHh9ORI0ek7j9gwAClzr0IaUu1KysVCVWe03379hV5vKKCi8sSecFdpfH69Wvq3LkzhYeHk5ubG1dO27ZtuTx9+/ZVKph3UbJ48WIiIqkrIReFsiuWTp8+ndLT04lIsk9aFlI4mPzTp0/FbKkq2xUAbdq0iWrWrCl3BUMWXFwxqShUr15d5rajR48qtXqdOsXLy0tuPVWxIEZJRNng4kUtDLJ8+XK5+4tWdS4LcXJyEjv2wIEDpfY9pa0SXL169SL75H/++adCbVbQdmloaEis7FpwUaoBAwZILEh28uTJIhd8EHHmzBkyMzMrUbstXbpUZvmNGjUqtfOlCN+048nU1JTMzMxoxIgRYhdBdHQ0l2fTpk2UkJBAkZGRpKOjw4miL4iamprE4/Hkrmp38eJFuWUEBAQQUX5k/KSkJLEo/WFhYeTu7q7oaSjWcu1aWloUFRVFRES5ubn0+fNncnd3V6oMRR1P3bp1U6pc0fnQ0tIiTU1N4vP53Opc0px9eXl5tGXLFlqxYgXl5uYq5XiS1i7SVgHLzs6muLg4MjY2Jm1tbTIzM1Nq6XNjY2OZKxYwx1PZUxptY2RkRLm5ufTp0yfKysoiovx7q6QPi/Ik+vr6dPv2bcrKylJYUlNTyczMjMaOHUtZWVmcE11k++StUvnlyxexjujixYslype24owsx5Oenh6dOXOGmjVrRmZmZmRiYiK2olpaWhqZmZnRr7/+ypUvFAo5W5+ZmUlJSUkkEAgkjpmQkCB2rjU1NalSpUpkbW1NOTk5lJSURElJSWI2U3SMmTNnkpmZWbl3UhbleGrfvj29fPmSW/Fm5cqV1LFjRzIzMyMzM7MiO+uyiI6OLnHbVCRUeU7V7XhKT0/n7mGhUMitsNOnTx8yMTGhunXrcmlpaWmcg1dVoqGhQTo6OqSnp1fk6lUi7OzsuD5KUeWL+qReXl4y+6SlLWZmZmRoaCjheMrJySnWR0dFxdfXt8g+InM8KSYVBXmOp+3bt6u9nRUVec+ytLS0CrOqnYaGBnl4eBS52qeswRqlJS4uLrRu3Tql3t0VFUUdTwKBgKZOncq1U2HHk4uLC9nb20vtp7569Yr69+8vsY8s9u/fX+J6lWfH0zcbit/BwQHv379HUlISdu/eLTZHuOCqShMmTEClSpVgb2+P7OxsTkjBqVx5eXklnvYVGhqKvLw8vH79Gubm5li1ahUAQCgUomvXrty0DCB/OoxQKJRZlqmpqUTg2qLIzc3F06dP8fDhQ2zZsgWVK1fG6dOni1UXRY6lDKLzkZubi7y8PAiFQhARbG1t0alTJ4nV/t68eYMVK1Zg48aNeP78eYl1lXZutbW1UaVKFdy7dw/jx4/H5cuXJYIgW1tbw8nJSaoEBgaiUqVKyMzMxMOHD/Hw4UOJ1RkY3zYCgQBHjhxBlSpVMHv2bKSlpUFTUxMvXrzggld/60yaNAlNmjRBSEgIXr16BR0dnSLFyMgISUlJ2Lp1K3R0dMDj8QDkr8bUtWtX7N27V+bxunbtyq3+CeSvNlq4fFkBGatXry5xH65fvx69e/fGo0ePkJSUBH9/f2hoaCAhIQEAYGhoiKSkJCxfvhzJycmIjIxEYGAgPDw88PDhQ/z+++8wNzfHiRMnJOxEz549xaZV5uXlYe/evfjw4QPi4+Nhbm4Oc3NzrFixgptGIKrDihUrkJSUhK5duxbvxJQTbt68iebNm3NBYTdv3owNGzYgKSkJSUlJSgVjTUhI4FY/c3JyUttUa0bx+hiKkJCQAC8vL25lWx6Pxy3aUqdOHQQHB+Ply5dcX+WXX35R+QqZAoGA63MoSsE+SkEaN27M/ba3t4eTkxOioqK4a1/UJ3327Fmpr/QpQkNDA/7+/rh8+TJsbGy49EePHuHAgQOltqiMCHkhJhiMb5XExEQu/AYRcf36hw8fomfPniVeqKSsKRxuRoSdnR0aNGiATZs2yd3/5cuXpaCVbO7evYspU6Yo9e6uavh8vtxFxgICAvDu3TuJfioRITw8HDVr1ixXsczUyTcb42nPnj3c6mmRkZFc3CMiElv2sTzw66+/IiMjgwuS+fjxY+zevRsAJAKWDRs2DBMnTsSoUaOkltWuXTuMGzdOLIibIvTu3bsYmquXoKAgjB49Gps3b+ZWB6hXrx7279+PzMxMqYHUleXYsWMSMV369u0LU1NTNGjQAD/88AOcnZ0l9mvRogXWr18vdfljEa9eveL2nTFjBurXr8+99DK+bTIyMrjVodatWwctLS00bNgQw4cPx8OHD3Hu3Dn4+vri1KlTYs6Ub4kVK1aAz+dj/fr1MDIywtKlS9GsWTOxF66iuHTpEj5//gxPT088fPhQap6wsDDcu3evWEvGAvkvrbt27YKbm5vMPPv27YNAIEB0dDRmz54ttuLp/fv38eXLF1hZWSE1NRWbNm0SW41k0KBB6N27t0SsJ0X466+/0Lt3b6ltdv78eQwePLjE8QfUyaBBg7B3717Uq1cP27Ztg6Ojo1L75+bm4sCBA7h9+zaysrLQpUsXFu9DzbRt27ZYfYwTJ07g999/55zNhTl79iyOHTuGiRMn4siRI9DS0uL6P927d4efnx9SU1MxZcqUklZBKvb29lx8TWXioQ0ePBgfPnyQuE/9/Pzg6emJixcvYt68eRJ9tkePHuH58+eYPn06t3pvaeHk5ISYmBi0b98ehw4dwsqVK+Hi4oIbN27g3bt3GDt2rNIfBRkMRj4hISF4/vw5OnfujNzcXLRs2fKb/jgydOhQPHjwQCL97du3+PPPP9G/f398+PBBzHn9vSNyKnl5eYHP58t8zhXm4MGDCAkJ4RYBY0DBcVFU/qbaDRw4kLy9vcnb25u6d+9e6scryVQ7WcLn87khedevXydvb2+ytLQkY2Njuedi8eLFZd7eik61KxirQRXi6upKYWFhMo9Xkql2smTIkCHccP/g4GBq27YteXt7k4GBAZene/fuRcaJePr0aZmfJ1VKRaGs2ovP59OkSZPI29ubzp8/T0RE9erVU/t5VKWIYqQoSseOHYnP59PChQspODiYaxcioqlTp5K3tzd17NhR6rGKijMgjTlz5nDPhYKiSDwTPz8/+vPPP2nEiBES2wpOjyYiOnbsGPn4+NCcOXO4PL179yZvb28aNWqU2L5Pnz6VqW9ERITaz6kscXBw4Npv6tSpUmMPZmZmko+PD/n7+yt9roiIUlJSSkX3ioSq2qRDhw40d+5cqdPLC1OcPgafz5c7lUA0JbZfv36kp6dHtWvXpufPn5O3t3eZTFWpXbs2Xb58mYiI9uzZI3UKrSy+fPlCo0eP5sqaO3cu5eXl0cePH8nHx4eCg4PF8j9+/JiaN29e6nWysrIiHx8fevToEZ06dYrS0tIoMTGRu2/LMvaMr69vke3IptopJhWFijDVztbWlvz8/Di9s7Ozy900eVVNtSsoffr0IW9vb/rrr78k9s/KyqJp06apvd6qEGdnZ6lxoAsTHh5OQUFBUrft2bOHYmNjpW6zsbEhovyYot7e3hLPCmlU9Kl236zjqayltBxPsbGx5OrqSrVr16Y5c+aQv7+/RDDwwlR0xxOPx6OrV6+Sv78/vX79Wu7xSsPxBIALCkqUb3CGDx9O586dI39/f/L396d3795J1Wf58uXk6upK8fHx5OTkpPbrtiRSUVBH29nZ2ZGrq2uZBmEsCymO4wkA6erqkqOjI9curq6uRXbeRI4ngUBAnTt35vaTJ4rEYZElTZo0oTNnznD3eEEHUocOHcjV1ZXWrFkjVr/Q0NAiy/1WHU8FhcfjUceOHSXau0+fPkrfj0ePHiVXV1eKiIigrl27loq+FQlVtYmNjQ1VrVqVnJyc6KeffpJ7zKL6GDo6Otx94uHhQYDijieR6OnplWghj+KIvb09ubq6kpubm8LxNgYNGkRCoZASEhLIy8uLAFDLli3FYnP+888/FBISwv0/fPhwqdfl3LlzFBgYyB1z2rRp5OrqSq1atVL5sY4dO1ZkHuZ4Up1UFGQ5nkJCQsrVRzk+ny92bc6dO5ezbw8fPuT0njx5MnXo0EHt+haW0nA8iURHR0fsmS/64J6amsq1UVnbcVWLIrarMJ8/f+bapHLlyuTs7MzFexXh7e1NFy5coKioKK6NHB0d5S5i8+bNmyKDvysizPFUAaQ0HE8BAQGUnZ3NGTwzMzN69uxZkV/ivnz5onQQ75JKWTqe+Hw+ZWVlUV5eHuXl5cld5a+0HE+pqalix46Pj6dmzZrJrfuuXbu4UVGlpVdZSkVB3e1YkUQZx9OCBQuU6uAUFmNjY7KysiqzQJaHDh0SexldunSpRJ6xY8eK1TE0NJQbTcXn8+nevXsSK9g9evRIZht9K44nWcLn87lzVFA6dOjA2e/CsnLlSgJAlpaWEs5HPp9PGhoanEybNo1iYmLI3t5eKb0qEqVx3ng8Hneutm7dKnbdCwQCWrJkCXduzMzMKCYmhmJiYmjo0KGkoaFBhoaGXP4vX75w2+Wh6OqTpSU8Ho80NDS460zR4OJxcXHcb5FDjs/nk5aWFtna2pKNjQ0ZGRnRgwcPuHwHDx4slTr8+uuvXFvn5uZSXl4enThxgqysrEpkawuKhoYGt8iLhoYGXbp0iRISEorcT97LW0ZGBtna2laoxTdKUyoKhR1PnTt3Jmtra7K0tCyVdiv47Cgqr+j61tDQoAcPHlBeXh7FxMRQdHQ0paWlUV5eHqWmplL16tU5UdU9pmqxtLSUGxBc9OwdNWpUiftTlStXJisrK+revTtXblxcHEVHR9Pt27cVbv/yIF26dKHo6GiJEe1FkZeXJ7UdCw5YEAqF1L59e4qPj6esrCzatm0bAaDdu3fL/eihqpky0hxPeXl5NGHCBKUWy1JWFIE5nhSU0hrxJHrAF0wzNTWVey4q+oingm3D5/Pp4MGDRJS/MkxhKa0HmOjYBVd4cHJy4oZTfvnyhdPh48ePRJT/BaBfv35qv1ZVJRUFdbdjRRJFHU/p6en0/v37Uvn6XlrC4/G4jmd0dDTNmjVLIs+QIUO47aIPBGfPniUbGxtuOH5MTIzYPnw+X2an8Ft3PMmTgja8oMgb6Xb9+nUSCASciBz/yk4ZqkiUxXXP5/Pp0aNHdPfuXerduzcJhUIaPXo02djYUKNGjThdhEIhd24KI2uqgQh1O5769etHAoGAPD09SUtLS2HHU0F8fHzIxsaGXr9+TQKBgB48eEBz5swhgUDAvXz5+fmVylScDh06UGpqKmd/TExMiryfinPPZmdn061bt2jhwoUkEAioSZMmCk1VluV4+vTpE0VHR9P169fJ3NxcrdfAtyIVBSsrK7EVnmNiYkhXV7dU2qxVq1Zizw5pI6oqV65MNjY2ZGNjQ+PGjROzZaL7at68edyz6tWrV1yexMREcnZ2Vvu1IUsK9zE+f/5M0dHRFBAQwNVH1ccs+Fx/+vQpRUVF0adPn0ggEJCXlxfZ2NiU+Qp4ysqUKVMoOjpaqedBXl6eVOeayPGUlpZGw4cPpxMnTtCbN29IQ0ODs9Nnz56VW7YqHU/x8fHcdX348OFSuQYKiyIwx5OCIsvxlJmZKfXLeHGkYcOG5ObmRr1795Y4jlAoJD8/P/Lz85Mag6S0pawdTzo6OuTm5kZubm7cC52hoaFazv2mTZuIKH854oEDB9Lz58/pzz//5LabmZmRn58fjR8/Xu3XqSqloqDudqxIUtDxdPv2bYm2vn79Ovn5+dHMmTPVrmtx5ODBgwq/yJ06dYr8/Pwk4gMkJCRILAP/PTqeiiM3b96UaKNnz56RtbW1UuVUJMr6HLRq1YrraxT8giuPJ0+eUNWqVaWePxHqdjy1b9+e/Pz8KCEhgYYNG0ZXrlzh6unn51fkEuKyEDmbVDE9Qp40atSoVPsYTZo0oS5dukh8jW/cuLFC+0tzPIWEhNCwYcNIR0eHBg8eLBYTj4lsqSgAICcnJ3r9+jUFBwcrPXJVUdHS0pJwhterV4+0tLS49wg3NzcKDQ3ltn/69Im7969cuSL1pdzAwIACAwMpJiaG3N3d1X5dyBOR/fr48SP5+fkpfN+qWtq0acO1a0ZGBiUlJYmdAyMjI7W3VUGxt7cnNzc3hWIfipDleDp37hz5+fnR1KlTZR6vrBxPXl5eagn3ogjf7Kp26uT27dsICgoCACQnJ2Px4sUqKbdJkyZYu3YtLC0tJbYJhUIcPnwY//77r0qOVd6ZNWsWFi5cyP0/cOAAt2x3WePv788tv1yrVi388ssvsLKy4rYnJyejc+fOatGNwShL7t69i7Vr14KI8Pfff2PHjh3o168fLl26hNDQUMyZM0eppcrLG0OGDFE4788//wwgf1n14cOHAwBGjRoFCwsLHDt2DFu2bOHysmXGlePLly/YtWsXAGDXrl2IiYlRs0bfD/fv3+eeZ7Nnz4adnR3GjRsnd5/AwEBkZGTA398f7du3Lws1lebWrVvo3Lkzfv31VzRp0gTdunWDUCjktj958gRNmjRBfHw8Dhw4wKWPHTsW+vr6Mss9e/YsJkyYUKq6A8Dz58/x/PlzlZZpbm7O2a7Ro0ejfv36xSqnZcuWqFWrFvf/48ePOHr0KI4ePYrWrVtj0qRJ4PP5WLZsmUr0Znw7BAUFYcyYMUhOTkZkZGSpHy8wMBABAQFITk7GtGnTJK65LVu2ICsrC0+fPsW+ffvklpWeno5+/frBxcUFp0+fLkWtS87GjRuho6ODhw8f4vDhw2rTIyAggHt+zJkzB5aWlhg3bhz69+8PAFizZg0+fPggYWfVxbBhw7Bo0SKl9uHz+Rg1ahS2b98ult6rV69i63HgwAHEx8fj48ePxS6jILt371ZJOaWCoh4+lAPPpDpl8ODB5OnpSZ6entSwYcNSO07Pnj25OCK3b9/mjunl5UVv3rxRW/3LesTTpEmTiCh/GqOnpyeLDaAGqSioux0rslStWpU8PT3LZFWqb0H69u1Lnp6etGLFCoWuzbS0NNq7dy/17dtX7bqrQ/T09Gjv3r2ciOLplPRZV5FQ9znS0dHh+iE3btyQqefJkyfF4jFu2bJF7Cuyukc8FSU9e/YkT09P6tmzJ5c2e/ZsufE/Xr16RS1btlS77sWRTZs20enTp4u8/uSNnKhcuTLt3buXC248a9Ys8vT0lIhB2r9/f7XX91uSikJZtRePx6Nhw4aRp6cnzZ8/nxvpIe3e3bt3r9rP7/cmVapU4Z4hooWZkpKSaOzYsWrX7c8//1T6up46dWqxw6oUHPEUGhrKtUtFmYaskF1QtKHVXZnvSfh8PjVv3lxsWCqPx1PrygFl7XiysrIiovzhsN27d1f7OfkepaKg7nZk8v2JkZERNW/enJo3b07h4eFyr8+bN2+W+zgIpSV3796V2ibM8fQ/1H2OCkr16tWpefPm1KZNmyL19vDwoAYNGlDz5s1p6NChlJCQQIMGDVJ7HRSVadOmUWpqKuXm5pKTkxNNnTpVrH6tWrUqVytzKSO7du1SeFU/aY6nbdu2UVBQELc0+I4dO6h58+blNvjytyYVBXW03bx58ygiIoKCgoKkLkyUkZGh9vP7PYuDgwPXNyqtqZfKSLVq1ej69etElO8ME+nWvHlzzr6J8PHxoebNmxd79eRx48ZRSkoKCYVCatmyJdWtW1ft9Ve1KGQXyrMBYVJ+RBHHU25uLrd8urLC5/NpwYIF9OnTJ/r48SN9+vSJKzc5OblUR5kxkS4VBXW3I5PvW4yMjMjU1JRMTU1p7NixlJmZyX2JfffuHbcS5vcohePqZGdnU2ZmJgUHB5eo3IqEus+RLDE1NSVPT0/uehYKhfTx40caNGgQ5ebmijmZNDQ0yNTU9JtyTKxcuZKLG5OcnExfvnyhZcuWkampKb1+/ZoiIiJIW1tb7XoWR2Q5fKXRsmVL0tXVJScnJ0pOTqbPnz9TWloapaamkpmZGZmampZawOjvVSoKZdVeOjo6pKurS7q6urRgwQIJPf7991/uGWxiYqL288ukfImBgYHUa8PQ0JC7bkaMGCE3dpMioqury5Wn7jqXlihkF8qbAWFSPkWW4+nVq1cUGhpKoaGh5OXlVezyu3XrRqGhodS+fXsC8odwR0VFUVJSEvXq1Uvt9f8epaKg7nZkwkSa3L59m65cuaJ2PdQl9vb2lJGRIXaviux/SaUioe7zpKj4+/tTTk4OhYaG0owZM9Sujypk7969lJubS2FhYbR582Yu/eLFixQaGkoHDx5Uu47FEWUcTyKysrK4qSHq1r+iS0WhNNvI2NiYHBwcyMHBgT5//iz1+OHh4RQaGkrz589X+zllwuR7EEXg/b9xKBIej6dINkYFhcfjISsrC6mpqbh16xaXPmzYMGRkZJTKMR0dHdG8eXPs3bu3VMpnyEdB01DuYbaLwVA/urq66N69O/d/7dq1sLOz4/4/f/4cHh4eCAkJKfGxKortAr4d+8Xj8bB582aMHz9e3aqolG3btmHcuHEV6pq6e/cuWrdurVDea9eu4cuXL3j79i1mzJhRypoxgIpjv0rTdg0bNkwiOHhcXBzu3r2LVq1awcrKCnp6esjKyio1HRgMhjiK2C62qh1DIYgIixYtwocPH8rMEfTixQu8ePGiTI7FYDAYjNLDwsICp06dEkvLzs7G0qVLAQCXLl1SidOJoR6IqMI5nYD8Ve2+R+7du4dLly5h27Zt+PTpk7rVYTAwbtw4VKtWDbGxsUhPT5fYHhQUhH79+mHAgAGoX78+8vLy1KAlg8GQB3M8MRRmyZIl6laBwWAwGBWEIUOG4OTJk+pWg8H4Lvnw4QMmTZoEAPjzzz/RtGlTDBgwAAKBAG/evGEf/hjlijFjxqBp06b48uULIiIiAAB//fUXQkNDcezYMS7f8ePH1aUig8EoAjbVjsFgSIUN92YwGCVlx44daN++PbS0tFCjRg2xbYaGhlK/XJeUimK7AGa/GKrH1tYWenp6yMnJQWRkJADA2toaenp6ePPmjXqVY1QY+6Vq2/Xo0SM0a9ZMLK1Tp064fv06ateujYyMDHz8+FGlx2QwGIrDptoxGAwGg8FQGzY2Nqhbty73PysrC5mZmQAqzgsWg/EtER0dLZEWExOjBk0YDMVp3bo1eDweHB0dcePGDRgaGsLY2Bg8Ho85TBmMbwS+uhVgMBgMBoNRscnNzcXDhw8xe/ZsmJubw9zcvNQWpmAwGAxGxSInJwfZ2dl49OgRfvvtNwDA6dOn0a1bNzg5OaF27dpq1pDBYBQFG/HEYDAYDAZDpdjb28PV1RXW1tYAgE+fPsHZ2VnNWjEYDAbjWyciIgK7d+9Gt27dcOHCBQDAf//9h169eqlZMwaDIQ8W44nBYEilokyDYbaLwSg7li5dCgMDA9SpUwfdu3fn0j98+ABbW9sy0aGi2C6A2S8G43ujotivsrBd165dQ6dOnQAAkZGROHv2LHbt2oVnz56V+rEZDIY4itgu5nhiMBhSYZ0fBoOhLImJiTA3N5dIFzmeBg4ciHHjxgEAevTogaysLJXrUFFsF8DsF4PxvVFR7FdZO55EvHjxAvHx8ejWrRtycnJKXQcGg5EPczwxGIxiwzo/DAZDWWQ5noRCIeLi4riAsABb1U4RmP1iML4vKor9KgvbZWFhgZCQEFSuXFlim56eXql82GAwGNJRqeOJwWAwGAwGg8FgMBgMBoPBUAa2qh2DwWAwGAwGg8FgMBgMBqNUYI4nBoPBYDAYDAaDwWAwGAxGqcAcTwwGg8FgMBgMBoPBYDAYjFKBOZ4YDAaDwWAwGAwGg8FgMBilAnM8MRgMBoPBYDAYDAaDwWAwSgXmeGIwGAwGg8FgMBgMBoPBYJQKzPHEYDAYDAaDwWAwGAwGg8EoFZjjicFgMBgMBoPBYDAYDAaDUSowxxODwWAwGAwGg8FgMBgMBqNUYI4nBqMMCIwJhPZibbxPea/0vpfeXILhUkPEp8eXgmYMBoNRPHoc7IHRZ0cXa99WO1th5tWZKtaIwWB8jzBbxGAwvge+5nxF5X8q4+Dzg0rvm5iRCIOlBrjw+kIpaKYY5c7xtOfpHvAW8jjR/VsXdTfUxcQLE/Hp6yeVHOPg84PgLeTBcKkhl/Y5/TM0F2li6KmhMvdLy06D3hI9/Hz0ZzFdgz4GSc3fcU9HOG52FEuzX2ePnod6Ss1/I/IGeAt5OBFygksTHUP3b13EpMYodAxFKNjG8uRG5A2lywaAiKQI6P6tK9E+jbY0QvW11UFEMvdts6sNqqyqgjxhHiJTIsFbyMOqu6uk5l1wYwF4C3lIyEjg0kacHiF2bgvDW8jDxAsTuf+iY/AW8nAy5KRCx1CWuf5z4fGDB+xM7cTSQ+ND0e1ANxguNYT5CnMM8x0m4WDqVrsbapvXxrI7y4p9fIbqULWNsl9nr9C9+O/jf2G8zBh9jvSRKGPtvbXgLeRh+OnhEtv+uv4XeAt5eJX4SuH7PjIlkrNHvIU8PPr4SKJcafeZkITY92wfWu5sCfMV5jBaZoS6G+rC09cT9z/c5/JJs3UAkCPIQc9DPcFfyMeuJ7uktlfHPR0VqsOCGwuKbPvC51KW2K+zx8qAleAt5OFJ7BOxMogIZivMwFvIw7vkd2LbsvKyoPO3Dn45+QtGnB6h0LFGnB4hVs9eh3tJ6C3LLkamRMLrjBdqra8F3b91UXVVVbTf3R7zr8+XaENpz41rb69Bf4k+mm1rhqTMJLltFxAVgCsRVzCr7SyxdCEJsTJgJWr41IDu37potKURDgcflth/VptZ2PRwE+K+xsk9DkN9lEZ/TNq9P/TUUOj+rYtXia8k8i+/sxy8hTz89+o/HHlxBLyFPGwL2ia17PH/jYfWYi08i3vGpYXGh3K6p2SlSN2vsE3RW6KHRlsaYd39dRCSUGZdnHc4g7eQhy0PtyhUd1XaroJlFryXQ+JDoL1YG15nvCTypmSloNrqami5syWy87Lxw5YfUGt9LWTmZkrkjUyJhP4SfQw4PkAsfeDxgeAt5GHW1VkS+wAQe27wFvKgsUgDlf+pjP7H+iM0PlRmPS68vgDeQh6sVlvJbXNpMFtU8Smtd8PYtFiMOTcGNXxqQG+JHmqtr4XfL/+OxIxEsXzKPDNFfbpJFyZJ5Jf3nicSzUWasF5jjRGnR0h97xNxLvwceh3uhSqrqkB7sTbMV5ij/e72WH13NVKzU8XyFuxn8hfyYbrcFD9s+QFjzo3Bgw8PimwnZfpKyvA68TUGnxgMmzU20F+iD4eNDlh0cxEycjMk9Jf27rz/2X5oLNJAtwPdkJWXBeB/77er766WWY+C76WidzyRaC3Wgv06e3hf9Jb5zBD1dbvs74JKKytBa7EWKv9TGV33d8X2R9uRnZctlr/w+TVfYY7m25tj8sXJCIkPUarNfO77wEjHCIMdB4ulp2SlYMy5MbD8xxIGSw3gutcVj2Mfi+Wx0LfAr01/xZ/X/1TqmKpEU21HLoJFHRehhlkNZOVl4U7UHWwJ2oILry/gxW8voK+lX+xyv+Z8xUy/mTDQMhBLr2xQGV1qdcGZ8DPIyM2QeoxToaeQlZeFoY1kO6dKi2xBNpbfWY4NPTaopLz9ffeL/d/3bB+uvr0qkV6/Uv1ilT/18lRo8jWRLRC/+Yb8MASzr83G7ajbaG/XXmK/yJRI3Iu+h4nOE6HJL/vLc9GtRfi5/s/g8XgqK/Np3FP4vfXD3ZF3xdI/pH5A+z3tYaJjgqVuS/E15ytW3V2F4E/BCBwdCG0NbS7v2OZjMf3qdCzsuBBGOkYq041RfFRlo9Z1W4evOV+5/xdeX8DhF4ex9se1qKRfiUt3sXVBK5tWuBt9V6KMgOgAaPI1ERAVIHVbZYPKsDaylri/V99bjQ+pH7D2x7Vi6Zb6lohMieT+L7i5AOc8zhVZF++L3tj0cBP61OuDIT8MgSZfE+EJ4bj45iJqmtVEK5tWMvfNFeSi/7H+uPD6Anb02oGRTUdKzTe33Vz82uxX7v/DmIdYH7gef7T9A/Ut/2evGlVpVKS+7e3aS7TJr2d/hbO1M8Y0H8OlGWoborJBZQDAnag7aFqtKbftZfxLpGSl5Ld/dABqmNUQ0y1HkIO21duiadWm6FyzM7ftXfI7/HXjL4xpNgbt7Npx6bXMaonp89+r//Do4yM0t2outy5vkt6gxY4W0NPUw8imI2Fvao/YtFg8jnuMFQErsNB1odz9/d/5o9fhXqhXqR78PP1grmcuN/8/d/+BW0031DavLZY+99pcLA9YjtHNRqOFVQucCT+DX079Ah6PJ9ZR6uPQB8Y6xtj8cDMWuS6SeyyGeimt/piINT+uwYXXFzDuv3HwH+7Ppb9LfodFNxehX/1+6Fk3/6Vj77O9mH1tNtwd3FHFsAqXNzAmENsfb8e01tPQuGpjLv3A8wOoalgVyZnJOBFyQsx2FMTG2AbL3PI/7iRkJOBQ8CFMvTwV8enxWOK2RCL/68TXePjxIexN7XEw+CDGtxhfZD1Vabtk0cCyAWa4zMDSO0sxovEIdLDvwG2b7Tcb8enxuDjkInQ0dbC953a02dUGi28txlK3pWLlTLwwEdoa2ljfbT2XlpqdinOvzsHe1B6HXxzG8s7LZfaVvJ290cK6BXIFuXj+6Tm2PtqKG5E38OK3F6hqWFUi/8Hgg7A3tUdkSiT83/mL2cqiYLbo+0GVtuhrzle0/rc10nPT8ZvTb7A1scWzuGfYGLgR1yOv49GYR+DzZI/PKOqZuePxDsxpNwdWRlZK1+3+h/vY83QP7kTdwYvfXkBXU5fLJyQhRp0dhT1P9+CHyj9wuqdlp+Heh3uYd30eLry5gGue18TKb1K1Caa1ngYgfyBFaEIojoccx47HOzC11VSs+XGNTN2U6SspSvSXaDjvdIaJjgkmOk+EuZ457n24h/k35uNR7COcGXxG7v4Hnx/EiDMj0LlmZ5wefFqsjYB8uzC+xXiFr4stP22BobYh0nPSce3dNWwI3IDHsY9xZ+QdsXyZuZnoe7QvLkdchoutC6a7TEcVgypIykzCzfc38dv53/DgwwP82+dfsf261OwCz8aeICJ8yf6CZ3HPsPfZXmwO2owVnVfg99a/F6ljriAXPg98MLXVVGjwNbh0IQnx06Gf8CzuGWa4zEAl/UrYHLQZHfd0xKMxj1DHog6Xd5zTOKwPXA//d/7oVKOTQm2jUqicsfvJbsIC0MOYh2Lpv1/6nbAAdOj5oRKVP+vqLKq3oR4NOTmEDJYYiG3b/2w/YQHocPBhqft23d+VTJaZUFZullxdRXTY3YEabmoolma31o5+OviT1PzX310nLAAdf3mcSxMdo8nWJqSzWIdiUmOKPEZxmHB+AmGBai6HS68vkfZibZp3bZ5E+0SlRBFvAY/Gnhsrdd+lt5YSFoDuR98nIqJ3ye8IC0D/BPwjNf/86/MJC0Dx6fFc2nDf4RLntiBYAJpwfgL3X3SMJlubEBaAToacLPIYyuB9wZuqr61OQqFQLH38f+NJ7289ep/ynku7GnGVsAC0LWibWN5PXz+RxkIN+vfxv8XSgaE6SttG/RPwD2EB6F3yO4ltC28sJCwAhXwOEUuvuqoq/XLyF8ICUGxaLJeeK8glgyUG1PdIX6nH+ungT2S31k7qNpE9Et0Xjz4+Ette+D6LS4sj3gIejT47WqIsoVBIn75+kihbZOty8nLI/Yg78RbwaHvQdqn6yOL4y+OEBaDr764rtZ8sDJYY0HDf4RLp2XnZpPu3Lg08PlAsfevDrWSxwoJ+3P+jhF0T2bNncc8kynsY85CwALT7yW6penTY3YGqr61OZsvNqNehXmLbpNnF3/77jTQXaVJkcqREWQXbXlR2wefGjXc3SH+JPjXe0pgS0hOk6lO4PM1FmrTz0U6x9A9fPpDWIi0x+yoUCqndrnZks8aG8gR5Yvknnp9IdmvtJGwjo3xQGrZOWj+HiGh70HbCAtCeJ3u4tG4HupHxMmP68OUDl/Yu+R3pL9EnjxMeXFqeII+abG1C9uvsKT0nnUsXCoVkv86efr/0O/U90pc67ukoVSdp/ajM3EyyW2tHRkuNJK5bIqK//P+iyv9UppMhJ4m3gCfVXheFKmyXLN1r+dSiehvqUXZeNhER3Y26S7wFPPr90u9iecf/N560FmnRi08vuLQTL08QFoA2B24Wy7vr8S7SWqRF/m/9CQtAN97dkNBH1vnd8nALYQFoxZ0VEvt8zf5KBksMaP399dR0a1MacXqEwvVntuj7oDRs0cHnBwkLQP+F/yeW/pf/X4QFoMcfH3Npyjwz7dbaUcNNDUlzkSZNujBJbJu897zCdZt1dRZhAejoi6Ni6ctuLyMsAE29NFXq9fox9SMtv71cQidp754ZORnkfsRd6v1eFLL6Soqy5NYSwgKI2R4iIk9fT8ICUFJGEpdWWP/DwYdJY6EGdd7XmTJzM8X2L9hvXX13tdg2aW0t6x1v0PFBhAWgBx8eiKWPPTeWsAC07t46qfV6lfCKNgVuktCpoC0SkZCeQK13tiYsAJ1/dV5qeQU5FXKKsAD0JvGNWPrRF0clrqvPXz+T6XJTsWelCMfNjjTs1LAij1calLupdrIQeeXepfxvKkNEUgQikiIULuN14musvb8Wa35cI3U0TV+HvjDQMsCh4EMS2z6nf8a1t9fQv0F/6GjqFKMGJeOPtn9AQAIsv7O8TI8bmxaLsIQw5ApyFcqfK8jF5EuTMbnlZNQyryWx3dbEFu3t2uNEyAmpZR56cQi1zGqhpU3LEuuuLIMbDkZdi7pYdHOR3KmAynI6/DQ61egk8WXwZOhJ9KzbE9VNqnNpnWt2Rl2Lujj28phY3soGldGoSiOcCZf/BYChPlRho4qibfW2APJHMYl4m/wWcV/jMLHFROhq6oqNenoa9xTpuencfsVhkvMkmOmaFTn9413KOxAIbWzbSGzj8XjciKHC5AnzMPjkYJwJO4MtP23B6ObFi9NRmC9ZXxCWEIYvWV9UUp62hjZaWLWQGFUWEB2A1rat0ca2jdh5EW0z1TWFY2Xlp0MDgJG2Eaa2mopzr85JDJkuTERyBGyMbSSm8wKQ2fYAcPv9bfx06CfUNq8NP08/WOhbFKnX+VfnkSfMkxiVcCb8DHKFufitxW9cGo/Hw3in8fiQ+gH3PtwTy9+lVhe8//IeT+OeFnlMRvmhNGzdr81+RRvbNph+dToSMxJx5MURXHpzCX+7/g1rY2sun72pPRZ0WIDDLw7jasRVAMD6B+vxNO4ptvy0RezrdkB0ACJTIjHYcTAGOw7Grfe38CH1g0L66GrqooV1C6TlpOFz+meJ7YdeHEL/+v3Rs25PmOiaSO03FpeS2i5dTV1s+WkLwhPDsez2MuQKcjHmvzGwNbGVGNGzzG0ZKulXwrjz40BE+JrzFVMuT0Frm9YY5zROLO/B4IPoUqsLXGu4on6l+jgYrHiMkXbV80d1SrtGfMN8kZmXiQENB2Cw42BudoEiMFv0fVMSWySajlZw5CQAVDOqBgDQ09KTup8iz0x7U3t4NvLEjsc78DHto2KVKYS0eyYjNwMrAlagoWVD/NPlH6kjDqsZVZOYdioLPS097O+7H+Z65lhye4lK3n3CEsIQ9SWqyHwy29+wGvg8vtisj4Ice3kMQ08NRUf7jjg7+KzESCcAaGPbBp1qdMLKgJVSpxIrgrT2j/4SjZ2Pd6Jb7W6Y3Gqy1P3qWNQRszvysNC3wJH+R6DJ18SS25IjawtzOvw07E3tJd6vT4ScQBWDKvi5/s9cmqWBJQY2GIgz4Wckpv51qdkF516dU+m7rqJ8M46niOT8E2+h978b3G2fG9z2uSlcxpTLU+Bq74oedXpI3W6gbYA+Dn1wOeKyRHyLoy+OQkACDPlhiMR+X7K+ICEjQUJyhdKdNbnCXKn55XUyapjVKLERKw5zrs1B/U31EZMme55xQdbdX4fkrGTMaz9PZp4hPwxBYmYiLkdcFksP/hSMF59fSG3jjNwMqW1WeB5wQaTllxenSYOvgXnt5uHZp2fwDfNVoLZFE5Mag6gvUWhWtZlE+uf0z3CycpLYx9naGU/inkikN6/WXOo0K0b5QBU2qiha2bSCJl8Td6L+N/Q3ICoABloGaGHdAk5WTmLOD5GTpCSOJ2MdY4WcH3Ym+Q6P4yHH5d6XBckT5sHjpAd8Q32xqccmjHUaW2w9C+Mb5ov6m+qr7F4G8tsxJi1GbBpiQHQAXGxc4GLrgpefX3IxAYgId6PvorVNa7nD9YticqvJCjn+7EzsEP0lGv7v/OXmK0hAVAB6HOqBGmY1cM3zmtjUTnncjb4LCz0LCSfXk9gnMNAykJii7WztzG0vSPNq+dMHCzvsGOWb0rB1PB4P23puw5esLxh/fjymXp4KJysnTHCeIJF3auupaFylMcafH483SW/w142/MNhxMLrV7iaW7+Dzg6hlVgstrFugV91e0NfSlxrjRxaRKZHggQdTXVOx9AcfHuBN0ht4/OABbQ1t/Ozws1JOmKJQhe3qUqsLPBw9sOzOMky8MBEvPr/Ahu4bYKAtHmbCRNcE67uvx52oO9j5eCf+9P8Tn75+wvZe28Veaj+mfcT1yOvwcPQAAHg4euBEyAnkCHIU0kdkM830zCS2HQw+CFd7V1Q1rIrBjoORlp2Gc+FFT+0GmC363imJLWpv1x58Hh+TL03G/Q/38SH1Ay68voAlt5fA3cEdDpUcJPZR5pk5t/1c5Anzij1gQNo9cyfqDlKyUuDh6CE21aokGGoboq9DX8SkxSgdb0ga9TfVh6evZ5H5Otp3BACMOjsKT+OeIvpLNI6+OIotQVvg7ewtYasA4GTISQw5NQTt7drjnMc5mc5BAFjQYQE+pX/CliDFYvAVRlr7X3xzEQISYOgPqgu5U92kOjrYdcD9D/clYnMV5m70XTSr1kwi/UncEzSr1kyir+ls7YyM3AyJ+InNqzVHSlYKXsa/LHkFlKTcOp5EzpwPqR9w9MVRLLq5CHqaetw8f2U5/+o8rkRckTuHFch3iuQIciSC3h56cQjWRtZi8+VFdN7fGZb/WEqILCfBlYgrUvO7H3WXq5vIiK24s0J+ZdVE3Nc4LL61GItdF8NYx1hmvv4N+kNHQ0fiC6Ho/5BGko6n+TfmS22zf+7+I/UY6bnpUvNb/mMptw6//PAL6pjXUdmop7CEMAAQi/sCALFfYwHke/YLU82wGpIykyQ81DXNaiIhI0Hq11dG2aNqG6UI+lr6aFq1qbjjKToAztbO0ORrwsXGRWzbneg70NfSl/qgUgbvlt4w0zXDwpuy4wRVM6oGz8aeOP/6PGzW2ODnoz9j9d3V3D0gjdl+s3Ei5AQ29tioUIwUdSNy4InaOO5rHN4mv0Wb6m3Q0qYl+Dw+Z/dD4kOQnJVcIqcfkO/4m9JqSpGOP++W3tDW0IbbPjc03dYUUy5NwZmwMzKdgLFfY9H9YHfYmdjB39NfYacTAIQlhsHe1F5qmVUMq0h8hRV9QS780cTa2BraGtoq6ewySo+ysnUNKzfEdJfpOB5yHPHp8djWc5tUp60mXxPbe23Hu5R3aLmzJTT5mlj34zqxPLmCXBwPOc7F8tHT0kPver1lOogEJOA+ToUnhGPm1ZkI+hiEHnV6SLzcHHh+ALbGttzozsGOgxESH1LuRsus/XEt9LX0sf3xdrg7uKN3vd5S8/VvkD9ya8bVGdgQuAHTXaZLjNI8HHwYOho66FMvf3GLwY6DkZyVLHN1pLTsNCRkJCA2LRaX31zGlMtTwAMP/er3E8v3Of0z/N76ceepukl1tLZtrbAjj9mi7wtV2qIGlg2wved2hMSHoPW/rWG71hY/HfoJbjXccHzAcYn8yj4za5rVxLBGw7Dj8Q7EpsUqVbeTISex8OZC6GjoiNVN1J8qfH8KhAKJj+zKvMOIyhM58sqCbrW7YbHrYlyNuIqm25qi+rrqGHxyMCY5T8Labmsl8j+Je4LBJwejbfW2+O+X/+Q6nQCgnV07uNq74p+7/yg06ikpMwkJGQl4n/Ieu5/sxqaHm2CpbykWj1hW++cIcsTavnBw+qJwrOwIIQnFPmoWJk+Yh4ikCNQwrSGxLTYtVvr7pAx7V9OsJgCoxd6V2+DinfeLD5u1M7HDwZ8Pig25jpwSqVBZOYIcTL08FeOaj0MDywZy83at1RWW+pY4FHyIC5j2Lvkd7n+4j+mtp0vtBG3qsQl1LepKpE+7Mg0CoUAivaV1S/zd6W+J9GdxzzD96nSZuomM2PbH2zG77WzugipN9rjvwR73PQrlneU3CzXNasoM3inCTM8MPer0wNnws0jPSYeBtgGICEdeHoGTlZPUthzTbAwGNBwgkb7v2T7sf75fIl1XU1dmMOQu+7vI1E2Dr4F57edh+OnhOB12Gn3r95Vbl6JIzMw3Pma64l/5REZQ2rRN0bDRzLxMse0ir3tCRoLcqTOMskGVNkoZ2lZvi7X31yLuaxyqGlZFQHQA9zLQpnobrLm/hlsgISAqAC2tW5Y4UL+JrgmmtJqC+Tfm40nsE7Hg2gXZ3Wc3nK2csevpLviG+cI3zBfTr05HpxqdsM99n1jbAMCn9E/Q5GtKfZCWlBFNRmBEkxEqLdPF1gV8Hh93ou5gaKOhCIgKgBZfCy2sWkBPSw+NqjTK/yJapwf35bykjicAmNxyMtbdX4eFNxfKDLjZsHJDPB33FItvLcZ/r/7D07in8HngA0NtQ6zpukZiCmN6TjqyBdmoYlhF7ocCaSRmJEqcS+D/bZaGfJtWGDNdsxKtGMoofcrS1ole5qyMrOROUXW2dsa45uOwOWgztvy0RWK6xsU3F5GYmciN0AHyR+n0OtwLLz+/RMPKDcXyhyWESXyY6l2vN/7tLR4gNk+Yh6Mvj2J44+GcU6NTjU6obJC/vHWTqk2UrnNhVGW79LX0oa+lj+SsZHSt2VVu3k09NsFhowNsTWzxZ3vJFY8OBh/ET3V/4hY3qWNRB82rNcfB4INwd3CXyD/yrPjiEJb6ltjfdz9aWLcQSz/y4gj4PL6YQ8rD0QPTrkxDcmay1BFSBWG26PtC1bbI2tgaztbO6FG7B+xM7XD7/W2sD1yPSvqVsKqr+KqxxXlmzms/D/uf78fyO8vh091Hbt7CdbM3tceBnw/AxtiGSxONiCkcxDv4czCabhPvl8XPiFf4g5KovLTsNIXyy4PmK+7wsje1R3u79uhXvx8s9C1w/tV5LL29FFUNq2Ki80SxvEmZScgT5sHG2AZ6mvKdTiIWdFyADns6YGvQVkxtPVVu3nob64n9/6HyD9jdZ7fY9G1Z7X/h9QX0Pfq/90UDLQN8/eMrFEWR9k/KTAKBJN4nAcn3RRGy7F3B98myptw6nkTOHE2+JqoYVEG9SvWKPV1h7b21SMhIKHJVHyD/S9qghoOwOWgzYlJjYG1sLXckDpDfAZI2ZUrWQ6ySfiWpK3Yo8nKojBErS+5/uI/9z/bjmuc1hc7TkB+GwDfMN3+VkR9+wd3ou4hMicTklrLnzEprs4KjOwqiwdNQalWUwrotvrUYi24tktqhKg4EcUMs8tQXHtUEgIttUNiwir5e8KC6FfcYxUeVNkoZRI6ngKgAuNV0w8vPL7Gy80oA+Y6RPGEeAmMCYWdih9ivsUU6ghVlcsvJWHt/LRbcXCDT+cHn8THBeQImOE9AYkYiAqIDsDVoKy6+uYjBJwfjttdtsfwrO6/Eugfr0P94f1wZegVtqkvGhypPmOqaoqFlQ86pFBAdgKbVmnL3s4uti9g2bQ1tbmpHSSjs+JP1MlbXoi72990PgVCAkPgQ/PfqP6y8uxJj/huDGmY1xGxibfPa8GzsiVl+s+Bx0gPHBxxXaui+tK+pepp6EiuZArJtGpBvG1W5iihD9ZSVrYv+Eo35N+bDsbIjXnx+gZUBK+VO229h3QIIgtT+14HnB1DDtAZ0NHXwJukNgPwVI/W19HEw+KDEKm72pvbY0WsHhCRERFIEltxegvj0eIn4IVciriA+Ix7O1s5cuQDgau+Kwy8OY0WXFWXyHFCEuf5zEfc1DvUr1cf8G/Mx2HGwTNtR3aQ6KhtURkPLhhIjCULjQ/Ek7gk8G3uK1bmjfUdsergJqdmpEi/if7X/C+3s2uFrzlf4hvlyDqbCHHh+AM7WzkjMTOQ+1DWt2hQ5ghwcDzkutmKWLJgt+n5QpS0KiApAz0M9cf/X+5wNcXdwh7GOMRbeXIiRTUeKDVYozjOz8IABRer2JesLdj3dhVvvb0k4T4208x2/BVdCFul2dVh+zDtZH+TlISqvLFfNPvLiCMacG4NXk15xzrWf6/8MIYT5bezoIRY/y62GG6qbVMeWoC0w1zVX6B24vV17uNq7YuXdlRIx6wpzcuBJGOsYIz49HusD1+Nd8jsJWyir/dvYtuHa/5+7/0hdYVoeyrR/4fdJ4P/t3TfyPlk+no5ScLZ2RueandHRviPqW9YvtmH5kvUFf9/+G6ObjUZqdioiUyIRmRKJrzlfQSBEpkRKTF0a2mgohCTE4Rf5sQAOvziMBpYNVPIlq6TUNKuJoY2GYvvj7QoN3SwrZl6diXZ27VDDrAbXxiKnW2xarESguZ51e8JE538BOQ8FH4IGT0NsiVt1IYr19DTuaYmDeYvmnSdnJouli4ZEiqbcFST2ayzM9cwlvNfJWfllKDMlhlF6qMpGKUvB6V73ovMDpLa2bQ0g/9qoY14Hd6LucE5ZVYy4Af7f+dFyCs6Gn5WIjyENC30L9K7XGxeGXEAHuw64E3UH71Pei+WpZlQNV4ddhYmOCbcUbHmnbfW2XCwnUXwnES62LgiMCUSuIBd3ou6gebXmUgNfFofJLSfDVNdU7nRHERp8DfxQ5QfMaTcHvoPy48RIm7oys81MzHSZCd8wX4w+N1rhofkW+hacPSpINcNqiPsaJ1GO6FklbVnplKwUVNJjNq08U1a2buLF/C/cF4dcxIAGA7Dk9hK8TX6rdDmp2ak49+oc3qW8Q50NdThpsLkBMnIzcCj4kMQ1aqBlgM41O6Nrra4Y32I8Lgy5gMCYQPxx7Q+xfKL7aOCJgWJlH315FDFpMbgZebOYtVctQR+DsOnhJkxynoQj/Y8gOSsZs/wUCzhcmAPPDwAApl6eKlbn1fdWIysvCydDTkrs80OVH9C5Zme4O7hjr/te9K7XG6PPjUb0l2guz+vE13j48SHuRN0RK7ft7vxnliLT7Zgt+r5QpS3a9mgbqhhWkXBc967XGwSSGi6lOM/Mue3+P0xKgPwwKaK69WvQD2cHn4VjZUf8cuoXMSeHKO7Ui88vxPY11DZE55qd0blmZ24alTKIyqttXlvpfYvL5oeb0bRaU7ERXQDQu25vZORmSI11u7HHRgx2HIz1geuLjHspYn6H+Yj7Godtj7bJzdferj061+wMjx88cHXYVehp6WHIqSEQkpDLI6v9LQ0sufaXNuWtKF58fgENnobc0f/meubggSfxPgnk96Wlvk/KsHfqfJ8st44nVZGclYyvOV+x8u5K1PCpwcnJ0JPIyM1ADZ8aGHNO/ItKS5uWqGVWC4eCD+FZ3DO8jH8pNeC1upjXbp5CRqwsifoShVvvb4m18YyrMwAAvY/0RqMtjcTy62jqoH+D/rgScQWfvn7C8ZDj6FSjE6oaVlWH+hIMbTQUtc1rY+HNhSWK9SQyUgVX3ADyh/da6lsi6GOQxD6BMYFSnZzvkt+hkn4lWBrIj1PFqNhUNqic71yKvoOA6AA0sGwgFvxWNOomIDoAGjwNtLZprbJjT2k1RWHnR0FEHTtpD8aaZjVxeehl8Hl8/HjgR7xOfK0SXUuLttXbgkDwe+uHJ7FPxEZpudi6IDMvE+dfn8fb5Lcqc/oB/3P8nQk/o5DjTwTX9jI+VKzosgK/Nv0Vu5/uxvQrsqd6F8TBwgHvkt9JpDep2gQZuRkITQgVS38Q84DbXpCY1BjkCHJQ31I8ADDj+8M31Bdnw89iseti2BjbYF23ddDW0MaEC5LBxYtCtCralp+24PiA42Lyt+vfeP/lfZFBpBtVaYShjYZi26Nt3Iez9Jx0nAk7g0ENB0mUe3zAcVQzrKbSIOPFRSAUYMy5MbAyssIi10VoVKURJrecjJ2Pd3IfKxSFiHDoxSG42rtKrXOjKo0UqvNyt+XIyssSW7npYPBBaPG1cKTfEYlyJ7ecjNvvbxe5OhazRYzi8in9k9RwKKKFofKEeVL3U/aZWcu8FmdLFB0woMHXwDK3ZfiY9hEbAzdy6e3s2sFExwRHXh4Rc4iUBNGoRFtjW4lg/KVJcdqfz+Njn/s+dK/dHQtvLsT6B+uLPE4H+w7oaN8RKwJWKLzCnaG2IeZ3mI+ncU/FVhnvXqc7NHgaKrXzUV+icPP9TbS2bS13xJMmXxO1zGtJvE8C+fbscexjiWviQcwD6GvpS4SwEdlMddi7b9rxpMiSmZUNKsN3kK+EuNq7QldTF76DfDGn7RyJ/Yb8MARP4p5g/o354IGHX374pbSqoTQFjVjc17hSPVZsWizCEsKQK5C+Qp+I7b22S7TxJOdJAIBVXVbh4M+SN+mQH4YgV5iLsf+NRXxGfLly7hUc9XT21dlil2NtbA1bY1upDqZ+9fvhv1f/iX0BvPb2Gl4lvsKABpLxrB7FPlKpE4FR+pR0iXFZtK3eFk/jnuJKxBW42LqIbXOxdcG96Hu4HXUbjao0UunQ6YLOj8KBdOO+xkkNVJgjyMG1d/lTcGV9Tfuhyg84/8t5fM35ii77uyAmVbFVNOVR0iXJZSFyJq25twa5wlyx9rc3tUc1w2pYGbBSLK+qEDn+Ft1aJLHt9vvbUu20KPhvPYt6EttEbOu1Df0b9Mea+2vw9y3J+IOFaW3bGslZyRKjUfo49IEWXwubH27m0ogIW4O2wtrIWuJafRT7CAAk0hnfHiWxdWnZafC+5I2mVZty/QYrIyssdl2MS28u4fhLyUC/8jjw/ABqmtXEOKdx6N+gv5hMd5kOQ21DHHxe9IvDzDYzkSvIxZp7+YvS+Ib5Ij03HRNaTJAoVxSg+2ToSalTHpShpLZr/YP1eBL3BOu7refs/8KOC2FjbINx58fJfKGWRkB0ACJTIuHVxEtqnQc1HITrkdeLXG25lnkt9GvQD3ue7uH6rQeDD6KdXTsMchwkUe4Ml/wPl0WtQshsEaMwitqiuuZ18Sn9E25E3hBLF11zTatKj2UJKP/MnNduHnIFuVh5d2WReUV0tO8IZ2tnrLu/jpsypa+lj5ltZuLF5xeY7Tdb6odxZT6WZ+ZmYpjvMCRlJmFuu7kqmWoalhBWpMMYyA8N8CTuicSKa4dfHAafx0ejKo2k7qeloYUTA0+gjW0bTLk0BfufFT2tcEGHBYj7Goftj7crVgnkv6PaGNuIDfKoblIdI5uOxMU3F8UcggWRNhVOFkmZSfA46QGBUIC57eYWmb+1TWup75P96/fHp/RPOBV6iktLyEjA8ZDj6FW3l8QMmkexj2CiY4KGlg0LF1XqfNOOJ0WWzNTX0oe7g7uEVDepDg2eBtwd3NHSpqXEfkMb5S+VeCb8DFxsXaSumqFO5rabi1xBLsITw0v1OHOuzUH9TfURkyb/RbBrra4SbSxaSauDfQf8VPcniX062HeAjbENzoSfgZ6mHn6u/3Op1KG4DGk0BLXMapV4pZo+9frA/52/xMPgj3Z/QF9LH657XbHhwQYsu70MA44PwA+Vf4BXEy+xvJ/TP+P5p+dcEGnGt0FJlxiXRdvqbZEnzMPDjw+5lZVEuNi64Ev2F4TEh6jc8QEAk1tNhomOCZ59Ep8W9yH1Axw3O6Lzvs5YdnsZdj/ZjRV3VsB5hzOexj2Ft7O33GG9rW1b49SgU4j9Gosu+7sovSpIYVSxJLk0qptUh62xLe59uAd7U3uJIcwuti649+EeeOBJnJuSYqJrgsktJ0u1SSsCVqD6uuqYcH4CtgVtw7agbRh7biyGnx4Ocz1zTGk1RWa5fB4fB38+iC41u+DP63+KvaxJ46c6P0GTrwm/t35i6TbGNpjSago2PdyEsefGYufjneh1uBduR93Gyi4rJeJhXI24iuom1eV28BnfBiWxdfP85+Fj2kds67lN7BqZ0GICmlVrhimXpygc9PZj2kdcj7yO3nWlr+Cmo6mDH2v9iOMhx4v8oNbAsgF61OmBnY93IjEjEQeDD8JCz0Kmc6J3vd5IyUrB+dfnFdJVFiWxXdFfovHXjb/Qq24vscVRDLQN4NPNB88/PYfPfcXjgx58fhAaPA2pfTggv85CEuLIiyNFljXDZQayBdlYd38dHnx4gDdJb2SeJ2tjazSr1qzIkQXMFjEKo6gtmug8EQZaBuh1uBf+uPYHtgVtwy8nf8G6B+vQpWYXqe+GIpR9ZooGDCj7PjHDZQY+pX/Cnqd7uLTZbWdjaKOh+OfuP2i6rSkW31yM3U92Y829NRh6aiiWByxHZYPKEtP8Y9JicOD5ARx4fgBbg7bC+6I3aq6vidNhpzGt9TSMdRqrlG6yqL+pPjx9PRWqm0AoQLvd7bD45mJsfrgZPQ72wOmw0xjZZKTU6bAi9LX0cf6X82hUpRFGnh2Js+HyBwh0sO+ADnYdlGp/LQ0trr916c0lLn1dt3XoXLMzJl2chLa72mLFnRXY/WQ3/gn4B+5H3HHg+QFUN6kuUd6rxFc48PwA9j/bj02BmzDm3BjUWl8LgTGBWPPjGnSr3a1InfrU64Po1GgJZ13/Bv3RyqYVvM54YdHNRdj8cDM67ukIgVCAhR0lZyhcfXsVver1UktMu2/a8VSa1LGogxZW+atvlKeROCJqm9fmnGPfKnwen1txple9XmUa1E4RNPmacgObKsrIpiMRkxYjMbTf1sQWN0fcRC3zWph9bTZW3l2JHnV64OqwqxLe6VOhp6CjqYOBDQeWWB/Gt09Bh1Lhl6CGlg25qXel4Xgy1TWV6sSoZ1EP67qtgyZfE5uDNmPsf2Ox5PYS6GvpY0evHVjz45oiy+5aqyv2992P8MRwdD/YXSUrrJQGonaV9gIqcjY5VHIQC4ypKqa0mgITHROJ9D/a/YF+9fvhVtQtzPKbhUkXJ+FSxCUMdhyMh6MfooaZ/JUDtTW04TvIF61sWmHSxUlc/D1pVDGsgh51eogNQRexvPNyLO20FJcjLmPChQmITInEgb4HJEYNC0mIk6En4dnIkwX0/Y4QfYDR4OW/+D/6+AibHm7Cb06/Sax4psHXwNaftiLuaxzm+Sv2LD7yIn8KSq96vWTm6VW3FxIzE3HxzcUiy5vhMgPpuen48/qf8Hvrhx51esgMKOxWww36WvpcTKSygEBi+ky6OAlEhI09JL/G963fFz3r9sSCmwvERlrLIleQi+Mhx+Fi6wJzPXOpeRwrO6KGaQ2F6uxk5YSO9h2xJWgLtj7aCgBFnqfgz8F4/um5zDzMFjGKS71K9fBozCN0q90NB54fwKSLk3A3+i6mt56O04NPF7m/Ms9MIH9xKJHdU5Sf6/+MWma1sOruKm5aGp/Hx/6+++E7yBfWxtbYELgBY/4bg8W3FuP9l/dY0mkJXk18JbHy2tO4pxjmOwyevvkB0v3f+aNX3V548OsDiRX8yoL2du1xd9RdNK/WHJuDNmPKpSmISI7Akk5LsKXnliL3N9E1weWhl2Fvao9BJwZJjFwrzIKOC5TWcUzzMTDRMcHyO8u5NH0tfVwacgm7++yGjqYOt4DLyrsr8TXnKzb32IzHYx9LlHX17VUM8x2GEWdGYN71eQj6GIThjYfj2bhncj8MFqRXvV6opF9Jwt5p8DVw4ZcLGNRwENY/WI8ZV2egkn4l+A/3R71K4qPdwxLC8OLzC4xoPELp9lAFPCpJABsGg6EQbvvcYGVkhf19lVtpQkTTbU3R0a4j1nZbq2LNGAwGQ3luv7+Njns7ImxCGOpY1FF6/9Nhp/HLyV8Q4R2BakbKB+NkfJucDT+LPkf6wG+YH9xqqn406PdGs23NYKBtILFi6PcEs0UMBuN7YfHNxdj9dDdeT3qt1ErEIqZcmoJb72/h0ZhHbMQTg1FRWdppKY6+OCqxqpciXHpzCa8TX2NOO8lYZAwGg6EO2tm1Q9daXbl4VsqyImAFJjpPZC963xkPYx4CgNgy5Yzi8TXnK8ISwtCg0vfdlswWMRiM74Wprafia85XhaY3FyYxIxE7H+/E353+VtvoTjbiicFgMBgMBoNRalyJuIKbkTex+t5qtLdrjyvDrqhbpW+WT18/wTfMF/uf78fd6Lu443VHbHVNBoPBYDDKI5rqVoDBYDAYDAaDUXFZdmcZHsc+Ru96vaXGH2IoTmhCKCZemIja5rWxz30fczoxGAwG45uAjXhiMBgMBoPBYDAYDAaDwWCUCizGE4PBYDAYDAaDwWAwGAwGo1RgjicGg8FgMBgMBoPBYDAYDEapwBxPDAaDwWAwGAwGg8FgMBiMUoE5nhgMBoPBYDAYDAaDwWAwGKWCwqva8Xi80tSDwWCUMyrKugPMdjEY3xcVxXYBzH6VNra2tqhbty4A4MaNGxAIBGrWiPG9U1HsF7NdDHXTsWNHaGho4Mcff8SMGTMAALm5udDR0akw91l5QpE2VdjxxPg2GDx4MHx9fZGdna1uVRgMBoPBYDDKHd7e3tDQ0ECHDh3Qp08fAICRkRG+fv2qZs0YDAaDURxsbW3Rv39/7v/y5cuhra3N/T9x4gQiIyOZ00mN8EjB1mee62+D+/fv4927d8jJyQEAHDt2DOfPn1ezVoxvkYpimJntYjC+LyqK7QKY/VIlffv2hbu7O3g8HoYOHSrRtszxxCgPVBT7xWwXo6xYtWoVLC0tUa1aNXTp0kVs2/v37/HXX38BAC5fvoxPnz6pQ8XvAjbi6Ttl8ODB3O9OnTrh06dPEAqFaN26tdRh5A0aNEC/fv2wePHislSTwWAwGAwGo9TQ1tbG3bt3AQDW1taoWrWq2PZDhw5hzZo1AICMjIwy14/BYDAYytO5c2csX74cAPDDDz+IjWwS0a5dOyQkJCAsLKys1WPIgI14qmAYGhrCyMgIb9++5dK0tbXB5/ORkpLCpf3222/w9fUFADg6OuLWrVtISUmBu7s7AgMDy1ptRjmEfXVjMBjfIhXFdgHMfimLrq4uAGDFihXw9PQEj8eDiYkJACAvLw95eXkQCoWws7NDXl4esrOzkZmZqU6VGQwxKor9YraLoSo0NDSgpaUFAAgJCYGZmRm0tbWhr68PAMjOzgYR4fbt2xg4cCA2bNiArVu3IiAgQJ1qf3coYruY4+k7YMeOHWjbti20tLRQq1YtsW1paWkYOXIkBg8ejHnz5uH9+/esE8YAwDo/DAbj26Si2C6A2S9FsLKygrGxMUxMTHD//n2xbUSEV69egYjg4+ODrVu3qklLBkMxKor9YraLUVLq1q0LPp+PQYMGYcGCBWLb0tLSEBMTAwDo0qULPnz4oAYNGQVhjieGGBYWFti+fTv3v3PnzjA2NhbLM2/ePISEhCA9PR1XrlwpaxUZ5QjW+WEwGN8iFcV2Acx+yUJfXx8//vgjAGDGjBlo3bq12PanT5/i7du3yMnJgYeHhzpUZDCKRUWxX8x2MYpDvXr10KBBA/D5fBw+fJgb6STiv//+Q05ODu7evYvVq1erSUuGNJjjiSGXcePGoXLlyrC2tsaYMWPEtiUlJWHjxo3w9/fHzZs31aQhQ52wzg+DwfgWqSi2C2D2qzCenp6oUaMG9u7di3fv3olty8zMxIEDB9CsWTOMHTsWjx49UpOWDEbxqSj2i9kuhjKYmppi6tSpaNu2LTp16iQ1z86dO+Ht7c1m5pRTmOOJoRCmpqbo2LEjRo8ejR49eohtmz9/PhYtWqQmzRjqhHV+GAzGt0hFsV0As18AYGdnh3Xr1gEA2rRpAzMzM9SpU4dzPK1atQoBAQHIzs7G/fv3YWdnh6dPn6pPYQajBFQU+8VsF0MZ7O3tJT4mFKZ169YS06kZ5Qe2qh1DIVJSUnD69Gm4ubmpWxUGg8FgMBgMAICenh5u3rwJOzs7sfT9+/dj9OjRaNGiBRYuXIivX79y25KTk8taTQaDwWAwGEXAHE8MjqlTp6JZs2ZwcXFRtyoMBoPBYDC+c/h8voTTCQDatm2LlJQU9O3bF3l5eWrQjMFgMBgMhjLw1a0Ao/wgWmaYwWAwGAwGozxjYWGBqlWrqlsNBoPBYDAYCsAcTwy5NG3aFLa2tupWg8FgMBgMBoOjdevWmDBhgrrVYDAYDAaDoQDM8cSQi7u7O5o2bapuNRgMBoPBYDAYDAaDwWB8gzDHE4PBYDAYDAaDwWAwGIwyJy4uDnPmzFG3GoxShjmeGAwGg8FgMBgMBoPBYJQ5OTk5ePbsGYhIZp5z587BzMysDLViqBrmeGIwGAwGg8FgfNNUq1ZN3SowGAwGQ0lsbW0RERGBFy9eYNWqVTLzVapUCXw+c118y2iqWwFG+aFevXowNTVVtxoMhlrg8/lwdXUFAERERCAyMlKp/du0aYOAgIBS0IzBYDAYRREYGIiGDRuiRYsWAICgoCB8+fJFzVoxGAyGcjg5OcHIyAjXr19XtyqlTpMmTeDn5wcLCwtERUUBAIKDg1GjRg0YGhpy+cLCwhATE4Pc3Fx1qcpQAczxVI5p0KABtLW18fTp01I/VsOGDbF161Y4OjqW+rEYjPKItrY2/Pz8AAAXL17E1atXuW1RUVE4efKk1P06dOiAZs2aYe7cuahcuTKEQmGZ6MtgMBiM/6Gnp4fx48ejS5cucHNzw/r16/HmzRts2LBB3aoxGAwlMTAwwJgxY8TSNm7cWGEdD1WrVoWHhwcAwNvbG1WrVoWenp6atSp9WrduDR0dHQBAZGQkfH19sXfvXnTr1g3z5s3Djh07AADHjh3D/fv31akqQwXwSN5kyoIZebzS1oVRiOHDh2PChAkIDQ1FXl4efv31V7lzX0tC7dq1sWXLFty/fx+RkZH4+++/MWvWLPz888/YtWsXzp49WyrHlUeDBg3QuHFjHD58uMyPzUCpXWtljaK2S1dXF5mZmVK3xcXF4cqVK9z/zMxMjBs3DgCwZs0a5OTk4MWLFzhw4EDJFWYwGCWiotgugPW9DAwM8PXrV6nbgoODMWLECDx+/BgAkJGRgfT0dOzYsQMtW7ZEp06dkJWV9V28vDEqDhXFfpXUdlWtWhWxsbFiacbGxkhLSytRueURAwMDHDt2DD169ODSvifbNWjQIGzYsAEeHh64du0al96/f3+cOHFCjZoxlEER28UcT+WY4cOHY8+ePQDyT+aTJ0/ETmq/fv3w/v17lR3P1tYWycnJSE9PR4MGDfDy5UtUq1YNGRkZZTpcncfj4f79+zAzM8O5c+cwbdq0Mju2iNu3b0NPTw+nT5/G33//XebHLw98b50feY6nwgiFQjx58gRA/n2TkpICFxcXJCYmFltPRvklICAAOjo6OHnyJJYtW6ZudRhFUFFsF8D6XtIcTwKBAK1atUJKSgrevHnDpWdkZEBPTw/bt2+HUCjEuHHjFHp5W7RoEQ4ePIjw8PBSqQODoQwVxX6p2vE0dOhQHD58uEKOKn/w4AGcnZ3F0r4nxxMAODo64sWLF+pWg1ECFLJdpCAAmJSxDB8+XO45SU1NpTdv3qhdT1WKtrY26evrU1paGmVmZtLy5ctL9Xg6Ojqkq6tL3bt3p+TkZE5E7Ny5U+1toi6pKChzLWRkZFBmZiYnQqGwyPJzc3NJIBDQly9fxK6hfv36ka6uLidaWlplev42bNhAycnJFBMTI6bHmTNnyN7eXu3X17ckmZmZRES0Y8cOrh3fvn1LycnJtG/fPtLU1FS7jkz+JxUJdbelusXAwICEQiFlZmbSnDlzyNTUlExNTaXmNTExIVNTUxozZgxNmjSJbt++TRkZGTLL5vP55O3tTTk5OdSqVSvS1dVVSjc+n8/ZAx6Pp/a2+l5FQ0ODOw9RUVFiz+EuXbqoXT9lpaJQ3Ppra2uTrq4u2dvbExHRli1byNTUlDQ0NNR+blQlItuxb98+sXcOEdnZ2ZSUlKR2PZkwUUYUsgulbUCYiIuRkRFZWFgolLcoxxMRUXx8vNrrVBKpXbs2OTg4cHLz5k0SCARl9iIXFRUlt32PHz/O6VaRHnqKSEWhJG1w9epVCg0NlXudLFu2jI4dO0ahoaEUEREhM9/hw4fJwcFB6Zeb4squXbtk6pKbm0t8Pl/t19i3Ik+fPqXIyEiZ7bl27VpycHAgLS0tqlevHtna2nL72tvbk4ODA3P2laFUJNTdluoWPT09OnPmjNL7bdmyhVxcXCg6OlpmnlatWtGnT5+4tk5LS5N6n2ppaYn1U7S1tQkANWvWjOLi4ig29v/aO++wKK7v/793YakCioCIIGgI8DEEiRDsCsESYgNLLLEnajQqYkk0MdZEE6NGJUaj2GOXWLAXbIkVrFGKigqiKAIiopTdPb8/+O18GbbDLoub+3qe8zzszC3n3pm53Dlz7zlPyM/Pz2B95OjoSD4+PuTt7W3w62UIGT9+vMpnqH79+gbXURsxFirb/ri4OF45v/76q8GviS7F1NSURowYwWujRCKhpKQkTvz9/Q2upzYiEAjI29ubfHx8eO+4smNOTk4G15GJ/kUTmHPxaqRWrVqYMWMGGjRogIkTJyIrK4t3PjAwEHfu3PnPRGEJDg7Gvn37YGNjwzteU5bR5uXlQSgU4sCBA8jIyED37t3x8uVLrcpwc3NDYGAggDKH1UVFRfpQlaEnOnbsCAAICQlBfHy8wjRTp07FrFmzsHXrVtjY2KBHjx7cuU6dOnFROfr164d+/fph2rRpSElJQUFBAefMvLoRCoXo2bMnJBIJgLJoUJmZmQbRRZcIhUJ06NCB549LF/j7+6NFixY4f/68wvMTJkzAhAkTMGbMGERHR+PUqVPo0KEDAGDPnj1o2rQp7t+/z20bPnv2LJ4/f65THRkMY+TNmze8MVUb2rdvj1OnTqFXr1549OgRLl68yDt/4cIFfP755xg2bBgAwNTUFPHx8fj000+RkJDApWvQoAGSkpK43+PHj8ejR48AAEuWLMHly5dx48aNSumoC8LCwrBw4UJcuHABPXr0MJqtWopo0qQJvL29cfToURQWFmqUp0uXLtw2+JSUFNy+fVufKjJ0RFFREQ4ePGjQZ0sfNGjQAKtWreId27JlCwYNGmQgjSqHu7s7mjVrBqAsOM+2bdsAANu3b8f27dshFAqxbds2mJqaYtmyZYiMjDSkuowaAjM8VROmpqaYP38+xo4dyx0bM2YMXrx4AQBo0aIFVq1ahfPnz+PBgwfV4kdk9OjRqF27tkF8lnTt2hUrVqyQMzoBZfvCZ86cCalUinPnzuHIkSPVrh8A3LlzB7169UJYWBhu3bqltdEJKJv4btq0CQDw66+/Ij09HUuWLNGxpgxDM2vWLPz6668YOnQoL4LSjRs3uJeADz/8EF27duWet+zsbKxYsQLHjh3D33//rXOd9uzZg86dO8PFxUXunFAoxM6dO7nfu3bt4ibjjx494qKI1HRcXFwwatQo7rdQKMTo0aMxduxYbhKkCywtLTFixAiF5/7991+uL52cnCAQCNC4cWN07tyZN3Y1atQIf/31FwBgw4YNePjwIXJzc7F06VKd6clgMP6Pd955B2PGjEFUVBQEAoGc4QkA9u/fD5FIBH9/f5ibm6N79+4YO3Yshg4dqrTcZcuWcX8nJCTo3NCtLVlZWXj16hXu3r2LWbNmITU1FZs3bzaoTkFBQSgpKdF5VOZ+/frh+++/R3R0NPLy8gAAzZs3V5mn/P+zv//+G/Hx8YiOjmbG/xrOixcv0KtXL7XpJk+ezHuX2L59e401LgqFQkyYMEHueMXofTUZCwsLTJs2DR988AG6desmd75v377o27evATR7O4mIiIC/vz/mzZuH4uJi+Pn5wcrKymgj+DHDUzUhlUqRnJzM/b537x6io6O51RCenp7w9fXF+++/jz59+lSLTmPGjIG3tzfPod20adN4euqLrl27wtXVVeE5gUCA6dOnAyiLGKYvw9PMmTPh4OCgNt2hQ4d0Ul9UVBRev36N9u3bY9euXQafGDJ0x4wZM7Bw4UKcPn2ac6j59ddf4/Xr11wEllu3bmHNmjUAAHNzc2zbtg0zZszAmzdv9GJ42rdvH16+fIkDBw7AyspKZdrevXtzf+fl5eGTTz7BypUrDWb0VUVUVBRiY2OxYMECODs7o3379nJp+vbtq1PDk5WVFYYPH67wXFJSEubMmcP9vnr1Kvz9/bF8+XLcvHkTHh4ecnmGDBkCoMwZspWVFXNYzmDogXfffRcxMTGYOHEiBgwYwB0XCATYuXMnbt26hZkzZ6Jnz54YOHBgpeoIDAzEBx98wEXWMwSdOnVCo0aNEBUVBQB4+vQpBAIBnJ2d0bp1awBAamoqvvnmm2rT6cMPP8Tnn38uFwBn48aN2L17d5XLHzdunMLjAwYM4AUJmT17Nvz8/Ljfbdq0QZs2bbB161ZmeKpBuLi4YPny5QDK7h11BAcHw8bGBnFxcUhOTsa+ffu4udeNGzf0Znhav3497OzscPHiRfz0009a5Z01axb8/f0rvYJTV+zYsQMikQiHDh2SW3mliqioKLRr1w6mpqbo2rUrTpw4gYiICACASCTCjh079KWy0VG7dm2sW7cOABAQEAA3Nzc0a9YMYrEYbm5u2Lx5M2d4cnJywh9//GE874363qvL5P9EJBLRuHHjiIgoMzOTSktLFfZ1rVq1CNC/j6ebN2/KlZeenk4pKSmUkpJCy5cv11tfrFy5UqP7btGiRUrL2LRpE926davSTj2PHDmitN6mTZtSw4YNq9zOgQMHKiw/JyeH62dzc3OD35uKxFioaj84OjpSRkaGyjpCQkLk8tWvX5/S0tK4NC9evOCu+Z07d7jjU6dO1et1fOedd8jLy4u8vLwoJiZG4357+vQpp+/hw4cNfj/KZMuWLeTr60sFBQUK9b5//z65uLjotM66desSUZmfrq1bt/LqKygooC+//JKX3tLSkry8vGjv3r1q+7ky/muYqBZjwtB9+baKk5MTJSYmklQqpfj4eBo2bBiNHj2agDLHvqWlpfT69WtKSUmhly9f8vp8/fr1vLIaN26s8hp9/vnnBmtn9+7dKTc3V06nnJwc3hh5/vz5atXrq6++UthX2dnZ3P+VU6dOqSxj5syZXFqZ5OTkqLwWtra2vDJcXV2pSZMmcoFCfHx8DH6PKhNjQZs2e3t7c/lGjRpFXl5e1LhxY6XpbWxsaMGCBZSSkkKpqam8ejMzM7n7Zdu2bVW6Fr6+vrz7TywW04MHDzSeY3h7e3N5CwsLFfZTWFiYXoMThISEcDqkpqZyz4Im73jOzs5cXtk42bRpU/Ly8qJ69epx6czNzVUG41m6dKnBn6uaIsePH1fpD5aIKCoqitavX08pKSnce8TcuXMNrrs60QRmeKpmsbCwoCVLlqjsa0Mansqze/dupXmtra2pTp06VKdOHbl/9KrExMSEIiMjSSwWK61XIpGQjY0N1a9fn5ycnLh63N3dqaioiBOpVEolJSV6MTwVFRXR2bNnq3y9lRmeypOZmWnw+1KRGAtV7QdnZ2e1dSgyPAGg5ORktXlLS0upV69eVKdOHb1fU1NTUzI3Nydra2u1E/jySKVS7rnr06cP1alTR2lkKX3Lli1bqLi4mPz9/Sk/P19O19TUVL3Ua25uTqampmRqakoXLlzg6ispKaGoqCil/X39+nWVfcsMT7oXY8LQffk2i0gkIjs7O8rLy6Nt27bR3LlzqaioiPz9/RV++PP09KSQkBC5FzJ/f3+V10id4Uk2hykvsnNmZmZUp04drQKq2Nra0rNnz6ioqEjpB8yKSKVSWr16NVe/Pl90W7VqpVSv169fU25uLuXm5lJOTg5lZ2fz5nUNGjTgdFyzZo1GbSsqKuLKtLGxkdPHwcGBJBIJL09xcTE3z7OysjL4vVpejAVN25uRkUHFxcVcvq5du2qUb/HixXJ1zp8/n8zNzenSpUuUm5tLL1684O6t0NBQle8spqam3L139epVKioq4ukl486dOxrpZ21trTC/RCKhXbt2kbm5OZmbm+v1WWzYsKFCwzQR0Zo1a7hACUDZ+5ms/YcOHaKioiJ68uQJ5ebm0ty5c2nNmjUkFospOTlZrh5tDU+yusoH2xEKhUrHybdZ7OzsqEePHrx3V3XIomWXhxmemGgl/v7+FBgYSFOnTlXb19VpeLp27ZrSsk+ePMmz6gcGBpKPjw/Vq1ePF3Xi+vXrGtVnampKw4YNU9smqVRK3bt3V5uOiPRmeCIiunjxYpWvuyaGpxcvXlBgYCC5u7sb/D4tL8ZCVftB34YnIqKUlBS6cOFCtUaak33JqizZ2dkUGBhIgYGBKiN1CgQCLp1MqhLZb8uWLURElJeXR4GBgXJ6paenk6enp1777ty5c1x9x48fVxk1SdUYS8QMT/oQY8LQfWkM4u3tTSdOnKA5c+bQixcvlPZ1YmIibdq0iZdXJBKpfVFQZXgSCoWUmJgol6ddu3YUGBhIc+fOJSKiNm3aaNyejRs3yn28S05OpkuXLtGlS5fkVoBU5Pbt22RnZ8eV16BBA97vqkqbNm2U1v3111/z0rZo0YLT+9KlS3IvW5qgbjXFwYMHVX4AWLFihcHv0fJiLGja3uzsbF4+TQxPdevW5eYC5an4cu7n58fdW7IVgGlpafTOO+/IPedjx47VqF3aGJ4UsW/fvmq9n7p166a0LXPnzqXAwEASiUTUt29f3rkrV67IzUm3bt2qcP6mreHJz8+PiIiWLFnCzQsVvfe1adOGO+/o6Ki0jX5+ftS0aVODP7sycXd3p8DAQGrdujU9ePCARowYQZmZmZrcXiqvlaHbpU40gfl40iNeXl7c/vply5Zx/pxqCrt378bixYuxceNGhQ7iGjdujBEjRiA9PR1AWRtiYmLg5OSErl27al2fubk5evbsqTadQCDA3r17ecf27dvHRSUpjywq19uMnZ0dLl++jJMnT+LLL79EamqqoVViVCOJiYkYOnQo/v3332qtNysrC5GRkZX2Yebg4IDLly8DKHPeOnXqVOTm5sLe3p7nw8DExASrVq3i/C8AwLfffstF9UxKSqqUE0UzMzO0bNkSf//9N9q0acMdd3Nzwy+//ML5HtAHBw4cwN27dzFo0CCEhobit99+Q2RkJBfpisFg1Cw++ugj5OfnIyYmBqNGjVI4H2vfvj1evXql03qlUik6dOiAbdu2wcXFBdbW1mjUqBFOnz7NS/fJJ5+gcePG2Lhxo9oyd+7cid69e8PS0hJpaWk4ffo0FixYwPnnDAsLw8GDB5Xmj42N5c3Fevbsibt37+L777/XefvVceHCBZ6f0ZUrV6JBgwaVmmMq45NPPoGDgwMWLFjAHevZsyfs7Ox0VgejcoSFhcHCwgIvX75EbGwsACAjI0Ntvk8++QT9+/dXm+7GjRvc/TV9+nR4eXlh0KBBmDdvHs8Bdr169XiBYapKt27d0KBBA7njW7duxWeffaZ1ef7+/vjggw8AlPmG3L59e5V1BMr6ZPr06XB1dZXzixkeHi4XZVyTPldEkyZNMGzYMLl3ucjISKXR7nbv3o0xY8ZwdW7cuBGnTp3izt+/f5/7vWfPHtSpUwcTJ07EzZs3eVFJqxMHBwd069YNgwYNQkhICLZu3Yr4+Hh4eXlh9erVGD58ONzc3AyiW02BGZ70SHBwMP744w9Dq6GUwsJCEBFev36t8PyVK1cgFAqxdu1aAGUOK/fs2cN78LWtb8SIEVwUp6CgIIWOd8tz8uRJ7NmzB66urjA3N5c7L5FIjCZ0cEhICFasWMEzQFy9ehXr1683nFIMvbNr1y6tjU5z585FcXExfvjhBz1ppR0jRoxArVq1kJ2dDUdHR7WTk3nz5nF///7775UyPFlZWWH69OlYtWoViAht27bVuozK8uOPP8LCwoILf9yzZ0/ExMQYxPDk4+MDLy8v7Nu3r9rrZjAqg6HGr4iICHTt2hU9e/bkGZ7+/PNPBAcH663evLw8jBgxAm5ubvjqq6/QqFEjuTTTpk1DcXExDh8+jO+++w5AmUFf9r/B09OTc6jdr18/WFpaAgDOnTunNPABAMyfPx9ZWVnw8PDgnI/LgrdUZOnSpdVueKrIl19+iaCgIJ0angDg+fPnXD8NGzYM4eHh3LnWrVujVatWOHfunE7rZCinRYsW6N+/P/r06YNatWohNTVV5X2sC3744QdYWlpi0KBB+OCDD7B06VKsWLFCJwGVbGxseONZv379ULt2bTmjypo1azR+Z5k3bx6sra0BAC1btuScrr969QqtWrXi0i1YsACZmZnc74iICNy8eRN3797VqJ7Fixdj6tSpcsdnzZqFjIwMzJw5U6NyFDFx4kQ0atQI48aN4wzwz5490yiw07fffosHDx4gKysLUVFRGDx4MAYPHsydv3PnDvfhdPny5bCyssLatWtx9epVjBgxAomJiZXWW1umTp2K+vXro169eujbty927tyJyMhIrF69GjY2NlizZg0cHBywYsUKFBYWwtbWFnPnzuWVMXPmTMyePbvadDYYmi7xQg1YwvW2yciRIyu1nK46t9r9888/SsvevXs3zZ49m4jKtr9FRETQlStX5NIVFBTQtGnTNK7XxcWFXFxceNtVlJGenk7x8fFKHQlru9XOw8OD4uPjKT4+Xq2Pm+raaleeRYsW0e3bt4mI6MGDB/Tee+8Z7P41FqraD2ZmZhQVFaWyjpCQENq2bZvcvajJVrvKOBcPDg6mwsJC7l5u3bp1pdr28ccfa9SH6enpFBISQiEhITz/RrqgvD8Vc3Nzrk39+vVTqHPF5fVr1qyh6Oho3jFV/ul0Jfv27ePVef36dXJ2dpZLp4+tdgsWLCBHR0dydHSka9eu0cOHD7l+q6nBCqpTjAlD96U+RFfjl6ZS3nHx9evXqVevXrytagMHDqTAwEAyMTGRyysQCCg4OJi+++47pddIG+fiirYHySgqKiIvLy/u940bN7g+UjT3IiK5rYEAyN7enhuvZf6LWrRoofZe8/Dw0El/a7PVTpEEBQWp1bU82jgu/uyzz+jZs2dyZSQnJ3N9HR8fTzNmzDDY82EsKGufj4+P3NwoJSVFqz4aNGiQwjrVbUeytLTkpb9+/TrFx8erfBeqiKKtdidPnpRLFxYWVul7IDo6mucnbc2aNUrnXv7+/ly+Tp06UUZGBl29epXzkaRqqx0RUfPmzRX6gZJIJBpvAa641e67776jkJAQEggE1L59e806tgI+Pj5ka2tLCQkJRES0ePFiblyr+H58/vx5+ueffygxMZFCQkJ4js/1KX379lX4jioLZCG752R6161blwQCAZ06dYqIiGJjY7lztWvXVtkfxrLVjhme9CBCoZACAgIoLy9P0+7lUZOci8sMT6WlpeTh4cE7L5FISCwWk1gspo0bN2pdvyaGJ3W8efOG97IfExNDnp6eZGJiwsmiRYsoMzOTMjMz6enTp2rLlEgkFBAQoJMoMNoanvLy8igsLIyePHmi0m/MqFGjuDY1aNCADh8+TCYmJjp1Umgs6KIvOnTooLKOp0+fklgspn/++YeXTx+Gp9jYWLp//z5vcp+Tk0MZGRla+07S1PBU3pmkvb09ubi4kL+/P/f8a+IsURkFBQXcvfz48WMiKjN0T5kyhaer7HmuGFWusLCQoqKieJOy6jA8ycaS8j5JsrKyuLbMnDmTBAKBTgxPQqGQ52vhyJEjlJWVRVlZWXLlKXKu+18TY8LQfakvad26NTd+PHv2jDIyMigzM5P++usv7lmvSvnz58+nzMxMcnBwoCZNmvD69PHjxzz/cAMHDlRbnoWFBffRrKIPJU0NTwKBQG78Ko/M8CTrF2VBWGRzr5s3b2rsgFed4Ukikby1hqeCggLq27cvd9+o8pVYq1YtuY8GitixY4fBng1jQdX1rXiPl5aWcv87O3XqpPZaWlpakouLC505c4b3nMydO1fl9be0tKyUH7HylJ8PCYVCMjU1VehE3NXVlY4fP16peXlFQ9j06dPJ0dGR3N3d5Rz3P3v2jOu7vLw8kkql1Lt3b64fLC0t6ZdfflHYlsmTJ9ORI0cUzuECAwM1GtNMTEzoxo0bXL5FixaRpaUll0ZTw1NGRgY3xrq4uJCpqSkJhULq3r07SaVSGjVqFFemqakpL+39+/dJLBZTYWEhTZ8+Xa/Pp0gkovT0dMrMzFQY4IaIb3iqKGfPnqXAwEA6e/Ysz7derVq1VPYPMzwxUSjOzs5UWFio8CF+8uSJ2n7Oysoia2trAvRveDp27BhlZGRQRkaGQmt3ecOTt7c3vXnzhne+S5cu5O7uTu7u7uTg4MAr28TERO4YULZ6xNXVlVxdXRU63NSW8s7PbW1t6fDhwySRSHgiQyqVcu3NyMigoqIihWV27NiRBAKBTow42hqeZHoSlf1zc3V1VfgiOWnSJC69rI0SiYRmzJhBrq6uOnFSbSzo4plWZ1gJDQ2lCxcuyEUmqmh4ys3NlZugaGt4OnPmDJWUlFCrVq3o+fPnvLIeP36sVVnKDE8FBQW8Z+XkyZMK88sMIkuXLqWSkpJKXB3F7Nu3j9zc3LixIjAwUO55Lo9UKqVevXpxxnR9GJ5kY5dsfPb09KQ7d+7Q6NGjiahsLC4/AZZKpdS/f3+1hqejR4/youw0aNCAXF1deVEDc3JyKCkpieuP06dPKy3v+fPnOm/72ybGhKH7Up8iGz+EQiGdPXuWa7PsWQ8LC+PueWX/C5XJvHnzqLi4WOG4IZVKKTAwkFv5oonhqaLe5ecPU6ZMIVdXV7VzhilTpqi81kVFRSQQCLg+cXJyogcPHsilCwwMlDNGqxN1hqcuXbro7LpWt+GJqOyayq71zZs3efeNq6srbzWqQCBQuEKlPMzwVHU0ffazs7N570flr+Xx48dVliMQCMjc3Jx7xpcuXUpxcXHk7e2tNI+vr2+l21RSUkLu7u7cfXXo0CGl85KMjAwiokp9mN+9ezev3F9++YWOHTumkdFs9uzZvPnT0KFDFc5hCwoKaPTo0UpXUzZs2FBpn8vKXrt2rZxOL168oI4dO3LpNTU83b9/X66u2rVr0+7du2nQoEH02WefaXQ/6TNKIACFY3JFVBme7ty5QyKRSE5PVYanAwcO6L1d1TV2McOTjuXWrVu8fktOTqbjx4/TgQMHyM3NjWcVVkT5JZP6Njw1b96cQkNDKTQ0lBYuXChXtszwdP36derTp4/KsL0Vl3t7eHjQxYsXufJlMm7cOLVt0oY+ffpQq1atCCgz8ihaQn379m06fvw4xcXF8XRUFdWuU6dOOrkfKmN4qoiibYzlDU+K6NWrV5V1Nxaq2g+6jGq3ePFiSkpK4h2LiYnhosKZm5vzxgBFcubMGSIqm9SMHj2a0tLSuLKysrK0apsyw1NcXBzvuW3RooXasq5evarlldE9rq6uJJVKdW54EolE3Ngl++q2Z88ert67d+9SUFAQbdq0iTfBmz9/Pt29e1et3ps2baLQ0FDq0KEDZ8Dbu3cv1//KthorIjc3V6dtfxvFmDB0X1annDhxQmVf/PHHHxQaGqrxdlJV22dycnLo888/p9TUVK0NTwAUfrgKDw/nnllFUWq//vprle0rKSmhDh06cGUoWxXerFkzrXQtP34poyrbgiqKIQxP6njy5Anvf1qHDh0UrlKRwQxPVUfT9m7dupW3HbY8J06cUJjH2dmZQkNDqU6dOiQSieSMH0OHDqV27dopzFtxBaQ+uHTpEtWtW5cuXLigcDusJlLxw6KuWb58OcXExCg9X9Hw5OvrS6GhodSjRw+F6QsLC+n48eM0aNAgXr6qGJ5qoqSnp6ttiyrD04YNG+Q+UgOqDU8V319rqmgCcy6uJ7KysrB161bs2rWL57Bw0KBBGDJkiNJ82dnZ1aEeACAmJga+vr4q05w/fx47duzA3r17YWqq2e0iEAgwbNgwBAUF4fjx47pQVSk7duxAWloaOnbsCEdHR2RlZcHR0RHR0dEQi8UAgO3bt+PixYtalbtt2zbY29vrQ2U5ioqKsGLFCjRt2hQfffSRTsrcsmULLCwsjMbxurEgc+5aHm9vbzg6OiInJweOjo7Yvn07Vq5ciYMHDyIlJUVpWa6urujcuTM2btxYJeePiujatSvPuWtKSgp8fHx0Woc+GD58ODZs2ICAgAC0aNGiUk7LFWFra4tly5bxjvXr1w9v3rwBAKxbtw6XLl3C4MGDUVhYiFGjRgEoi0Rja2urtvyBAwdi4MCBvGPdu3dH9+7d1eZ9+PAh/vrrLwDA4MGDsWbNGo3axGDUNAYMGMBFu1TEyJEjMXLkSMyePRv5+fnc8bi4ONy9excWFhYYPXo0bty4AalUChcXF17+c+fO4eLFixAIBBg/fjz69++PFStWoHPnzjhy5IhW869ly5bB1NSU93979+7d3Pn9+/cjPj4eUqkUy5Yt0+h/sUgkwrFjxzTWQR1dunSBl5cXrKysakwgirZt26K0tBSrV6/WmSPza9eu4eTJk7xj//vf//Dxxx9zv52dnfU+H2VUjv79+8PLy0vhuYYNGyIqKgqHDh3iOQHv2LEjNm7ciBUrViAtLY0XNRco+5/86tUrzJgxAwBw7Nixao0cPGbMGOTk5CAiIgJjxozh5n7a3PdisRgbNmxQ+c5YWR4/foycnBx06tRJZbpatWphxIgRAMA5ZVeERCLBDz/8gPnz5+tc17eBTZs24fnz53B2dlYbXEcf1/NtghmedMhXX33Fhc98+PAhJk6cyDtfv3593rFJkybh+fPnaNKkCb755hsA/GhPjRs35v6eOHEiFi1aJDe46pvDhw8jMjISTk5OKtO1bt0aGzZsAFBmeJJFe6rIvXv3MGfOHADA999/D09Pzyrr6OTkhDFjxuDGjRtYuHAhgLIoNRXDgNZUCgsLMXHiRHh5eaFFixaYMWMG3nnnHe58nz59uJf+3NxchcYLxtvLgQMHkJycDIFAgEWLFsHLywuLFy9GREQEBgwYoDJSWrNmzXDt2jVcuXIFzZo1q0atq05BQQHGjh3LO2Zubo5Vq1ZVusyZM2di1apVOHnyJDp16qQzwxPwf2OXrMwlS5bIpSEizJkzhzM81apVS2ODvabs2LEDBw4cwK+//gp7e3uIRCJcuHABO3bswKlTp3DgwAGd1sdg1DQqGtp79OiBAQMGoKioCIsXL8adO3dARLyouZcvX+aMUgCQlpaGb7/9FufPn0fjxo2xdu1a9OnTB0VFRRrp8PXXXwMo+3CwatUqtGvXjndeZrwnIgQEBICI1H7o04SYmBg8ePBA4bklS5agTp063O/27dvD3d29ynVqg42NDReVTxGyfmndujUKCwu547///rvWHwhlnDlzRm6+3bhxY7Rp04b77ejoyM0PGTWPrKws3gv5woUL4ejoCE9PTyxevBjPnz9XGH1u9OjRSsusVasWFi9eDKDsI/qdO3cAALVr19at8ih7R5PVBZSNUbm5uQD492KrVq14kcSjo6ORkJCgsEyBQKAXXYGy8e/Jkydo3ry50jSLFy8GEaF3795qyxOLxfjpp590qeJbxc8//4zIyEjY2dkZWpWaj0broui/tdxbG3F2dqaEhARKSEjg/CTl5+eTj4+PXNqKS0llUZAqOqqsyKhRo0gkElH37t3lzunbuTgA2rt3r6a3iUK++eYbCggIoICAAG7f9bRp07TaPqKMTp06UUBAAL3zzjtatX38+PFKncIR6W67iiZb7Sr6ZDl//rzCdFKplNuGVa9ePTp48KDSMouLi6u8H9hY0MUzropFixYp9T2izrn40aNHOd8TQqFQzpmsr6+vXJmyrXYyZs2axW370tVWu4qUd6apTLTZahcREUFNmzbl8k6fPp0SEhLo3Llz3FihqcyZM4dXdmpqKoWHh+ssKtHOnTvp2rVrcsEGgoKCKC0tjQICAnj+Q1xcXJT2oSbtqejIfvDgwdy5adOmcVtVfH19KSwsjM6dO0cNGjTQSVuNRYwJQ/dldUq9evU06pOwsDAKCAjgbR+7desW1a9fX2H6Bw8eUOPGjXl1ydI+ffqURo8eTcnJyVxgF21F1XYVZbx8+VJpZC5VPHjwgHx8fOjUqVPc3FMmVfGzp6utdo6OjpWqPy0tjWtHxe3o6tAkqp2ZmRlvnL1//77KMtlWu6pTlT4o70KAiOS2byl7dmJiYrhrHBoaqlK/6OhoraLZKUMqlZKVlRUFBATQggULtMrbp08fAsBFb0tISOBcZajbard582aure3atdO4zry8PPr000/p4cOHWumqCpl/uuDgYEpISOBtc/wvbLW7desWb7unqq12yoRttWOoZPfu3QgODoZQKOS2UpSWlqJFixZITk7mLQOXYWFhwfvt5+eHlJQUua0Ysi9uO3bsQGRkJF69egWxWMx9qStP3bp1ceTIEfTo0QMAUFxcrJPtVUSEkpISrfKIxWJO3N3duRVHhYWFKC0t5aV1d3dHrVq1qqznjRs3VC7NV0aDBg002gJTkxAIBLzl5NbW1gbUhiHj0aNHKCgokDsuEonUrlDMy8ur1P1bnm+++QYjRoyAt7c372t3TebWrVtITU3lfru4uOC9994DESEuLg579+5V+SUTAO7evYtatWrBxsaGd/ydd97BZ599hmHDhulE1+HDh8PNzQ03btxAXl4eoqKisH79ely6dAlNmzaVu/ZExI3hUVFR2Lt3LwCgSZMmGDFiBL766iuYmJjg5s2bCleSVrxnkpOTkZiYCKBsvBMKhQCAf//9F7du3cKZM2d4KwcYDGPnxo0byMzMxPXr17Fp0ybuuFAoRElJCczMzHjpi4qKkJaWxjsmm+M4OTmhqKgI+fn5uH37Nho2bKg3vcViMQQCAUxMTCCRSLBlyxbeqoyKc0RFuLu749KlS3LjHlA2/yu/YmvkyJGIi4sDAHz44Yc4evSojlqinJycHHTv3h2xsbEQiUS8cxKJBN9//z3atWuHzp0788a6Ro0aoVGjRpWqUygUcn2qjJKSEm4cBYCmTZvi6dOnSvvcxMQEpqamnMsGRvXi7+8PoVCIdu3a4a+//tL4OgwcOBB79+5FXFwcBAIBNydauHAhhg8fjpKSEpibmwMAMjMzMXXqVCQlJcHNzU1j3YgIxcXF3G8zMzPUr1+fe75kz6Amz/P69euxatUqCAQCbrWMo6Mjd/7evXto1aoV9z5mZWWFhw8fwtTUFE+fPuXuaRsbG67eGTNmoHPnzggNDVVY56tXr5Cdna12rCsuLkZmZiYCAgIQGRmJWbNmKU1rbm6O3NxcmJqaolatWtxKLTc3N+zfv19tP7ztNGnSpMplWFhYoLi4mLs/ZRCR3Dv0W41G5in6b311UyeOjo4KnT7KLNflpV69euTj40NNmzbVqJ/v37/PRU2qKK6urpSUlETZ2dlK8zdv3lzjdqha8ZSamsql02TFU35+Pg0bNkzjumfNmkVJSUlKwwVrSuvWrSt1DX/++WeV5RpyxdO2bdsoKSmJkpKSKDMzs1L9wlY8/R9VvYbqVjxFRUUpzLdr1y61uh08eJDs7e0JqPyKJxleXl5Ko88pE0OtePLy8qrydREKhdS7d2+ldehqxRPAHyvLh/Q1MzMjHx8fzjl8Rdm0aZOcXvPmzaOLFy9yvwsKCrjnXZGz26CgIJ21478ixoSh+7I6RdMVT6pW+Pn5+VFSUhLl5eVx6ZWNXy1atKCkpCTKz8+niIgIOnv2bKX01mTFU0FBAU2ePJkWLlxISUlJdOnSJblyFAVHUUZqaio3buTk5BARKXWmbGJiQn379lVZXlVXPDVo0IDMzMzI0dGREhISKCoqil68eMGrY8uWLVx6dQ56X7x4QUlJSfT69WuN+mPIkCFa61wxUnNFFAV2qQ4xFnTRF82bN1d4HVStFlQWXGf79u1Ur149bjWVLKKwJlHKZNy5c4cOHz7MK/fw4cOUlJTEcyLu4eFBL1++JKKy9yPZs6oqSJOML7/8kgBw84TDhw9T3bp1ydXVlYuUR1QWrEZV3z158oRKSkq4ugsKCujevXsar0Aq71y8fGCElJQUtX3WvXt3EggEdPv2bY3qIlK84knb3SzVIVV1Ll5R6tevTz4+PvT06VMKCwujx48fExFReno6JSUlqY3sWJNEE5jhSUMxMTGhiIgIioiI4EUzkpGcnMxFfurRoweXVlXkNEWoi2gFgHr37k2xsbEUGxtLcXFxvPyKDE+tW7fm9ClvqFFmeJJIJLR+/XquPZoYns6cOUOenp5a92tVozbs3bu3UgaWmmx4Ki8tWrRQu11LEXv27Kmy7sZCVftBneFp3bp15OjoKJdv8uTJCreTnjx5krclYtOmTRQREUG9e/eWi8yijeHpq6++0iq8NmA4w9PYsWO11rWi9O/fX2UdujQ81a1blyt35cqVZG9vT0KhkMaPH09ERN99953CfIoMTxXZu3cvlz46OlruHmCGJ+3FmDB0XyoTGxsbnd+bujA8yWTkyJEUGxtLe/bsoaSkJJVpx48fTy9evKj0VrvRo0dzrhaUceTIEbXlaGJ4SkhIoNjYWLKysuLyLVy4kM6cOUM7duxQOB8qP34poyqGJx8fH7p48SKNHTuWu4aHDh2iBQsW8PpFE8NTSUkJxcbGci9uZ8+eVav73bt3KTg4WGu9meFJv+izjypjeJKJLKqdbO6ljcHXyclJI/0WLFjAvadFRkZyx8sbjpQhMzxZWFhwx7Zs2UKJiYm8dOoMTzExMfT7779zv2NjY8nb21thRE5FKDM8WVlZUWBgoMq83bt3J0DzMZ1IseHp2bNnFBERodG7cXWJrgxPjo6OFBERQSdPnuT1waRJkyg2Nlbh/L+miyawrXZq6NGjB5o1awaRSIRp06YpTZednY2wsDCEhYXh22+/rZRD2b/++kujbTe7du3Crl27AAAODg5qI7F4eHhg+fLlsLOzQ1paGv78808AUOowvLS0FPPmzcPPP/+MiIgIjXRv27YtevTogUWLFmmUXsaiRYt4DtW1ZdSoUUYdue3ChQsYPXo0Vq1apZUjdplzY0bVefXqFefMtmfPnmjatCnvvLOzM6ytreWew4ULF+LNmzdYsmQJbzy4d+8eWrRowW1DUBTRrDJER0dj9erVWm+R1RUrVqxAdHS03DYXRch0Lb9cXRtGjx6NpUuXVipvZXj9+jVmzpyJDz/8EKNGjYJIJEJWVha+/fZbndYzbtw4jBgxQm6pNYNR03Bzc8O6deu4uYhUKsWcOXOq5f9xVFQUpkyZorKuVatWYdWqVTA1NeWiMilj2bJlGDZsGCZPnoyVK1eiZcuWvAh16sjMzERhYWGltjr7+/tz8yxNts//9ttvWL9+Pe/YkSNH8Ntvvyl1Oq5PvL29sWLFCgQFBSEoKIgLjPLxxx9jx44duHPnDoKCguTy/frrrwoD5rx69Qq9evXSSocDBw7g1KlTlW4D47+JruZeipAFH1BEfn4+Fi9ejLZt26JDhw7c8UePHmH16tW4fPmyXB5FkdJatmwJPz8/hW5YAOCLL77g/d6+fTsGDBhQ6YAnu3btws2bNzXa9jVgwAAEBARU2SWIjY0N/vrrLyQmJvICp2RnZ+O3336rUtmGRBZEavDgwbzjHh4eGDJkCEaOHFmtURirFU0tkagBljRDyNq1azXtIoWsXLmSwsPDKTw8nL766iuVaQcOHKi1fg4ODrwyTp06Rbt376bdu3fTpEmTuHTqnMgdP36cwsPD6fbt2zRs2DA6duwY51y8efPm9OTJE7VtLV+fJvLTTz9V2hGljPJOfbWRt2XFk0wOHTqkVb/Uq1evyrobC7ocD5o1a0bh4eHUv39/SktLoyVLlijdaieTbt260dSpUyuluzYrnqRSKZmZmWnVHl2ueAKgVcAAc3PzSl8HdYERiHS74kkmHh4eFB4ezluF+M8///C2Dtrb23NjsCZfN8uveALkv+SeOnWKtm3bpvO2GLMYE4buS2UiWzVQnj179tDMmTMrXaa5uTlNmzZNbZ+UlpZWecVkRbl69SqVlpbSmjVraNKkSdS1a1eN82qy1U7Ziqdhw4ZpdT8MHTpU67bpc8WTs7MzbdmyhSvniy++4P6+cuUKffHFF9z/hfIrngQCAfXo0YPCw8Npw4YNXJ6Kcy9NVjxp4lxckbAVT/pFn32kixVPlUHTFU/KpHPnztSpUycCwM0Lx40bR+Hh4dS+fXte2vIrnpSh7XtjSkqKxm0tv+LJ09OTXF1dud/qVjxVBkUrnpQ9owUFBdw8q1mzZtX6fOpixdOQIUNU5lf3XlFTRROY4UmNVMbw5OvrS15eXuTl5UV2dnZcWT4+Pirz6cLwVJ6XL19SSkoKpaSkqN1XvGbNGgJAbm5uZGpqSp6enuTi4sLVc/fuXbXt1sbwNHv2bHrz5g3du3dPbbmq0KXhafXq1dx109W+YkMZnpKTk5mPp/+PPsYFoVBIDRs2JBsbG6pdu7ba9BYWFuTl5UXbt2/XSvcHDx7wtlQAzPAEgNzd3dX6/tCH4Ukmbm5u5OvrS0Rl42z5SYaJiQl5eXnR/PnzNeqHioYnWX4vLy/auXMnEZVdW9lY/sUXX+itXcYixoSh+1KZKHt5Kyws5O5VWRRbbaRNmzZq+0RfhicioqtXr9KQIUN422PUiSaGJ1m/dOnShZfX1taWe95lvppUUdMMT0CZsf3o0aPUqVMncnJy4pX78OFDat26NRHxDU/lpfw2HolEQikpKTR37lwCysZaddsY8/LyKDw8XGu9meFJv+izj95Ww1N5qVOnDnl5eSmdt9Ukw1NFKW946t+/P3l5eVGnTp0q1acyFBmePD09ycvLi2bMmKE0X0ZGBvc/Z/369Xp/PtUZnnbs2MF7968oAoFApQuVPXv2UJ06dfTeDn2IJrCtdmoYOXIkmjZtimbNmsmdy8/Ph1QqRXx8PC5cuIB58+bh9evXuHv3Li+yCFDmrf7atWs61+/58+dc5ISFCxdi9OjRMDExAVC2RFFR5BOgbDlz+eWSsqhIGRkZAMoiRumTuXPnYt68ebC0tEReXl6lyujUqVOVIoK9evUKTZs2RWZmJoCyiCs1MYKJpaUlRCIRd78BZfeTpaWl0jyVjQ7D0AypVIr09HSN0xcVFSE1NRWPHz+GRCLhntHyfPjhh3j+/DmuXLkCoGzbhbu7O3JzcwEAW7duxcSJEyu9TNqYePjwodotPTNmzMCVK1f0ElElIyMDGRkZcHFxQbdu3bB8+XL8+uuvkEqlcHd3x5MnT/Ds2bNKlS2VStG4cWN8/PHH6N+/Pzw8PBAYGAgvLy8AgL29vS6bwmDoFCsrK+5evXHjBogI169fx0cffaQ2+qKXlxfi4+OrQ0058vPz8eLFCzRt2hSdOnXCyJEjNco3cuRIDB06VG06MzMz7NixA4cOHeIdf/nyJV6+fAkAKqOyybC2tlYbwa26yc3NRZcuXSAWi+Hg4MA717BhQ+zfvx/t27fHoEGD5PIGBwdj+vTp3G+hUAgvLy/Ur18fQNlYm5mZCRcXF7kx38nJCdevX0dMTAz27duntd4vXryAs7Oz1vkYhmfz5s147733uOf0bYnoW568vLxKv/8YmsTERO7ds6SkBETEvZ9URCwWo6CgANbW1igqKuLmwJpEFpe9i/7444/4+eefAZRFRS4/D6pXrx7nusLT0xP9+vXjznl6eqKwsBAlJSXVFv335cuXXGR7Ozs77m9LS0tYWFjg/Pnz8Pb2lsvn5OSEly9f1th3UV0hNLQCNR1XV1fuBf/Nmze4fPkyJ++++y7s7e3Ru3dvLFy4EAsXLoS/v7+c0UmGvvx2FBcXo7i4GOPGjUNCQoLc+dTUVLnjP/30Exo0aAB7e3vY29tj/PjxetFNGWKxWC70r7ZUxZfNo0eP0KFDB6SlpXH9p48HPScnB5cvX+YmlpVh6NChsLW1xf/+9z/ueo0YMQI5OTk61JRRHURFRWHjxo28sM4yVq1ahfT0dO4aL1iwAG/evIG5uTnMzc0xdOhQ5ObmomXLlgbQ/O3DxMQEQqH+/sVZWFjg8ePH+OOPP2Bqaor09HTcunULz549w4kTJ+Du7l6pcjt06IBDhw6hQYMG8Pf3h5WVFe+8q6srAgMDERgYqItmMBiV4vXr17h3757KNGZmZjA3N0dQUBCWLVumMq2fnx9u3brFvUCoQplPk6oQHBwMV1dXJCQkoGXLlmr9QskwMTFR+CGhIvHx8fj+++/lXs4cHBy451mTjwqTJk3Cu+++q5FumvLo0SPu5aiylJaWgojg7+8vd6527dpYt24d5s+fL3fu1KlT+OGHH1SW/f7776OoqIibq8kkIyMD9vb2+Prrr5W+9KrC19dX6zyMmoFUKsXUqVNhb28PJycnvXzYNzRSqRQ3b940tBoKISLuOVT2EfDmzZu4fPky1qxZA3t7e/z4449o3rw57O3tERAQgLS0NI3rk0gkXH2enp7cPNne3h6///47944rFAq5ObO5uTkyMjKQm5uLbdu2oV69ejppuzbcvn0bQUFBCAwMRHR0NHJzcxUanQDo9V20RqHRuiiqucu99Sk+Pj509uxZ2rdvH61du5bmzJlT6bL0sWRSkUyfPl0uJHfnzp1JIBBQTEwMrV27lhNNIsPIRNdb7bTpF2VU3A9dk2XKlCm0fv16he3QZKudIlEVMau4uJhttfv/GPraKxIzMzNau3YtL5qFu7u7XLobN25o3M7/0lY7Teq6cuWKXiOhlB+7EhMTKSoqimxsbHj+TojKttLJntU7d+7Q2rVreT7zKm6127hxI3fu7NmztHbtWoXPukQioX79+hn8Xq6JYkwYui9VyaeffqpxO2Tb+ZXJTz/9JBfRURkTJkyo8v83ZWJvb09Tp06ljh07apR+9OjRGulcE3w8JScn8+aAMtHGn5U6URYxKy8vj0aNGqUwT/mtdjJiYmL0fv+q24LIttpVjersMw8PD67e6OholVudKrvV7uDBg2RjY1Ot7fL29lapk6G22ikST09PevjwITeuqNuW+Nlnn/Hqe/78ucbjbkURCoVqXcpMmDBBJ9dE3Va78mNXVlYWxcbGqu3rvXv3koWFRbXeW/oQTWB7NlRgbm6OnTt3Ytu2bZXeNlHd/PDDD8jOzuatrkpOTgYRyUU40DXh4eGIi4tDamqqxnlkEfQ++eQTrFu3DgAwc+ZMo9tO8ssvv0AoFCIxMRECgQAdO3ZE165dDa0Ww0CUlJRg+PDh8PT0xCeffAIA3Ja66iQpKQmRkZEAgGnTpr3V2w6WLVvGW4Fx4cIFvX4FLS0t5frO3t4ekZGReP/99/HNN9+gf//+OHnyJPbs2YMtW7agpKQEwcHBGDNmDI4dO4ZevXqhYcOGWLx4sVy5o0aNQl5eHpo1a4ZRo0bh9u3bMDU1xeXLlxEQEMBFQREKhViwYAG2bdumtzYyGNXF1KlTkZ+fr1GU219++QXLli3TSwS9hg0bYvDgwahfvz7u37+v1u3A2bNnceHCBbRo0aJS9V28eJEbR3788UfUqlWrUuWoorCwEJGRkbh58yZOnjyp8/I14dGjR/jjjz8Unjtx4gTXBwsXLtRo1ZsukPULAPTt2xetWrWqlnoZuic3NxeRkZHo3Lkzxo4dCzs7O+Tl5eH+/ftYsmSJTuqYN28eCgoKdFKWrhg0aBBOnjzJuQxRBxFh4sSJcHd35+59XfH8+XOMGTOGF31OG+rWrYvVq1dj7969AMr6++nTp7pUsdqZNm0azp07h549e/KOFxQUYMOGDfDz80NsbCy2bt1apR1AbxUamaeoZn91exukulY86Us0WfFERBQaGqp12VZWVvTee+8RAJo/f75ah48y3qYVTxXF3d2dQkJC6OHDh2zFk54x9LWuiuh7xVN5CQoKopCQEIVf8Gviiqd27dpRSEgIJ6q+cOpbPDw86MKFC9S/f38yNzenkJAQ8vT05M7b2trSlStXeHkEAgEFBwcrjFxoZ2fHi5QnEycnJ9q2bRvXh+np6Qa/R2uiGBOG7ktV4uTkJLfCTxmPHz+miIgIleWJRCKKjIxUW5Y+nIvLxN/fn44cOUIhISEaBY4AylYlhISEUFhYmFKdla14Ki/Pnj1T2/akpCTe2FLTRNmKp5s3b2qUv7CwkLtfunfvXm16y65hSEgIDR06lE6dOqVwFXJ1iLFgiL6Tza1DQkKouLiY8vPzKT4+nuLj48nHx4eAyq94atOmTbW3x8rKijfPUSS1atXSuLzmzZuTQCDgHP6rQtsVT9pKvXr1KCQkhBITExXWf+HCBbVz2mHDhlF8fDydPHmSpFKpyvYYYsWTSCSi8+fP885/9tln1Lp1a6pdu3aNHssrI5rADE/VJIoMTxKJhMRiMZ0+fZpcXFzI0tLS4HoqE2dnZyopKVF7n1TG8FReDhw4IFemVColsVhMYrGYrl27Ri4uLuTi4lKll+yaIk5OTpWOzMcMT5ph6GtcFZFFWtKEqhqeZCISicjV1ZW7vyQSCd26dUujvNoYntzc3GjPnj1kYmJCJiYmBu/rqkrdunWVtsPW1pYuX76sk3rKR+QUi8W0efNmo+lDXYkxYei+VCe2trbc/+TAwEASi8UKXwC2bt1K1tbWasszVFQ7mYhEIo0NThVFIBBwfREdHc3NW8RiMR06dEhpHtnzq8zwVL4csVhMT548qfYtP5qKr68vT1cZMsOTunmJzPBERPTixQvKzMyktLS0am2DqampQaNKGQuGvhdlz+I333zDPTcZGRn09OlTIiKVhgrZ+5nsf6yxvHPIpKLh6fXr19SwYUNyc3Ojhg0bUsOGDattTlG3bl1q2LAhlZSUyG23Vrf9zMbGho4dO8Yba5RRXYanNWvWkImJCe3evZsyMzNJLBZTXFwcdz8a81xNE5jhqZrEwsKCSkpKKCMjgxN3d3cSCoV681WgSxEIBHK+oxRRVcPThg0bSCwWk0Qi4fopIiKChELhW9NX1SXM8KQZhr5OVRGhUEgpKSmUkZGhNqS0rgxPAKh///5UUFBAT58+pbp162r8kqeN4Uk2wZBIJPT8+XO9+mOqCaKrsWvatGmUkZHBm2hJJBKSSCQUGhrKxkgYz9hF9PaNX0KhUKHPHnU+nmRiaMOTrkQgEHDzFlVzl08//ZTy8/O58bC0tJQ3TywpKSELCwteWTW97eX1jIuLo4yMDDp9+jS5urrS8uXLVfpxKW94klHdhidDi7Fg6H6USfln8ebNm5SRkUE5OTk0bdo0OnToEBGVGXfLP3dNmjQx6vcORSueZPMImbi5uVWrTkKhkLp06cLTydPTU62vKIFAQKampjXGx5OsL58+fUp3794lExMTo7yHFIkmMB9P1YRUKsWff/6J4cOHG1oVnfPq1StcvHgRAKocaW3IkCEQCoUQiUS8kJgMxn8RqVTKRcD4+OOPMXnyZAQEBMDOzo4LO964cWM0atRIp/Vu3boVTk5OOHbsmE6jJz548IDnh6l27dqoV68eRo4caZRRacpDOvJHM3/+fMyfPx9btmyBm5sb2rRpw0XvO378OKytrfH69Wud1MVgaItUKsWDBw/w9OlTXhQhFxcXuLq64tGjRwbUrvqgsg+7atPt2LEDTk5OCA8PB1DmC2no0KHc+fXr10MsFlcqapuhKK9rt27dAADvvfceEhIS8O+//2rtzzAoKEin+jH+W5R/Ft9//30AQPv27VG/fn3Y2NhAJBIhOzsb/fv3N6SaBkc2j7h79y4ePnyI4uLiaq1fKpUiOzsbJ06cAAA0b94cd+7cQVJSEsaNG8elO3PmDEpLS7nfRFRjxseXL1/i8uXLAIAJEybg33//NbBGNQ8BaTgbFggE+taFUYMRCAQoKiqCmZkZAODo0aO4desWAODx48dYuHChIdX7T7Jp0yYMHDhQ4bmSkhJYWFhU6WVXVy/KhsbYxq6xY8fC3d0dU6ZMAQB07twZnTt3BgBMmTIFEonEYLotWrQIEydO5H7v2rULGRkZ3O9jx47h0KFD3G8PDw8EBAQgNja2WvU0Ftzc3JCens47xgxPxjN2AW/v+DVw4EA0a9YMY8eO5ZxF7969G2fPnsXKlSvx5s0bhfkaN26MNWvWIDg4WGnZYrEY5ubmNeZlg6EeZ2dndOzYEZs2bVKZ7ueff4abmxvPCODo6Ijnz5/rW8Uag7GMX2/r2PVfoHXr1vj777+532KxGNHR0QCAuLg4gwUhKM/t27dx/PhxiMVi+Pn5ITQ0FAAwffp0uTnOunXrkJ2dDVNT+fU0z549w+bNm7Fnzx6cOXOmynqlp6fDzc2Nd2zTpk14/vw50tPTdebM/m1Ek7GLGZ4YGjNw4EDOIv7PP//wVi4wqh9meNIMNnZVHyKRiPfCcPToUWRlZRlQI+PGysoKs2fPxuTJk7ljzPBkPGMX8PaPX/3794dIJEK7du3w+eefAyhb5VNUVITExEQsW7ZMLs+4ceMUHpfBDE/GjYODAxftFQDatm0LMzMzJCQkcC/HxoyxjF9v+9hlzMgMT2vXrsXp06dRWlqKrVu3GlotHj169MD+/fshkUjg5eXFRQ41MzPD6tWreWl3796N8PBwhfdcbm4u9u/fj82bN+Po0aNV1qu84engwYPYvn079u3bhxcvXlS57LcdZnhiMIwYDw8PHD16FO+++67cOWZ4+j/Y2MUwZmxtbXljwNWrV//zL+TGMnYBxjN+1a1bFx4eHgDKVj7WqVMH+fn5uHv3LoCya9ayZUuIxWJmeGLwCAwMxK5du/DRRx8hLS3N0OroHWMZv4xl7DJGrK2t4ePjg4cPH751qwkFAgGaNWvG/V6yZAnatGmjNl9UVJROViPdv38fffr0AREhKysLmZmZVS7TWGCGJwbDyLGxsYGJiQn8/Pxw5MgRAGVfAyQSCWxtbVFUVFTpstnkh8FgvI0Yy9gFGNf4JRKJYGJiAjs7O2719KRJkzBp0iQA4L4Ym5ubw9LSUmk5EokEdnZ2aNeuHVq2bIlZs2YxI5SRY2Njg4KCAkOrUS0Yy/hlTGMXo+ZibW3Nbedu27YtduzYwZ2zsLDg/taV4cnW1hYvX76scjnGiCZjF3MuzmC8xcgmYmfOnOEm6ps2bUJgYCD27t3L+f5hMBgMBqO6qF+/Puzs7HjHvvvuO6Xbw4GyYAOqyM7OhrW1NaysrPDq1SvueG5uLn7//XeUlJRUSWdGzeW/YnRiMBjaUVhYyP0dFxfH+2iRmJgIKysrANA6qIEymNGparAVTwwGQyHsqxuDwXgbMZaxC3g7xq/WrVvDycmJdywqKgpt27ZVmzcpKQlJSUncbwcHB7Rr105h2ilTpsDKygpNmzaFlZUVPv74YwDAxYsX0bt37/9MxDyGcWMs49fbMHYxGAzdwVY8MRgMBoPBYDD0xvTp0zkjkDKuXr2KPXv2yB0/ffo0Tp8+zf1u06YNzp49q7ScOXPmAADs7Ozw22+/wcPDA6NGjWJGJwaDwWAwajjM8MRgMBeeRIMAAAJCSURBVBgMBoPBqBI5OTn44osvFJ578OABrl27Vumyz5w5wzNc5efnY9KkSXBwcMDt27crXS6DwWAwGIzqgRmeGAwGg8FgMBiV4osvvoC1tTVKSkrw4MEDvdSRnp7ORcCT8ezZMzx79kwv9TEYDAaDwdAtzPDEYDAYDAaDwagUugonXdEZOYPBYDAYDONBaGgFGAwGg8FgMBj/Xfz8/PDvv/8aWg0Gg8FgMBh6ghmeGAwGg8FgMBgGISQkBMeOHYOtrS26dOmiMI2npyd8fX2rWTMGg8FgMBi6ghmeGAwGg8FgMBgGwdraGkKhELa2tpg6darCNCKRCGZmZtWsGYPBYDAYDF3BDE8MBoPBYDAYDIOwf/9+dOvWDdnZ2ZgwYYLCNElJSbhy5Ur1KsZgMBgMBkNnCIiINEooEOhbFwaDUYPQcGio8bCxi8H4b2EsYxfw3xq/fH19cfLkSTg4OHDH/ve//+Hly5d48+YN8vLyDKgdg1E9GMv49V8auxgMhmZjl8aGJwaDwWAwGAwGg8FgMBgMBkMb2FY7BoPBYDAYDAaDwWAwGAyGXmCGJwaDwWAwGAwGg8FgMBgMhl5ghicGg8FgMBgMBoPBYDAYDIZeYIYnBoPBYDAYDAaDwWAwGAyGXmCGJwaDwWAwGAwGg8FgMBgMhl5ghicGg8FgMBgMBoPBYDAYDIZeYIYnBoPBYDAYDAaDwWAwGAyGXmCGJwaDwWAwGAwGg8FgMBgMhl5ghicGg8FgMBgMBoPBYDAYDIZe+H/8uz+5WyPkPAAAAABJRU5ErkJggg==\n" + }, + "metadata": {} + } + ], + "source": [ + "from sklearn.metrics import pairwise_distances\n", + "\n", + "# Get the prediction model by extracting layers till the output layer\n", + "prediction_model = keras.models.Model(\n", + " model.get_layer(name=\"image\").input, model.get_layer(name=\"dense2\").output\n", + ")\n", + "prediction_model.summary()\n", + "\n", + "# A utility function to decode the output of the network\n", + "def decode_batch_predictions(pred):\n", + " input_len = np.ones(pred.shape[0]) * pred.shape[1]\n", + " # Use greedy search. For complex tasks, you can use beam search\n", + " results = keras.backend.ctc_decode(pred, input_length=input_len, greedy=True)[0][0][\n", + " :, :max_length\n", + " ]\n", + " # Iterate over the results and get back the text\n", + " output_text = []\n", + " for res in results:\n", + " res = tf.strings.reduce_join(num_to_char(res)).numpy().decode(\"utf-8\")\n", + " output_text.append(res)\n", + " return output_text\n", + "\n", + "def lev(s1, s2):\n", + " m, n = len(s1), len(s2)\n", + " dp = np.zeros((m + 1, n + 1), dtype=int)\n", + "\n", + " for i in range(m + 1):\n", + " for j in range(n + 1):\n", + " if i == 0:\n", + " dp[i][j] = j\n", + " elif j == 0:\n", + " dp[i][j] = i\n", + " elif s1[i - 1] == s2[j - 1]:\n", + " dp[i][j] = dp[i - 1][j - 1]\n", + " else:\n", + " dp[i][j] = 1 + min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1])\n", + "\n", + " return dp[m][n]\n", + "# Let's check results on some validation samples\n", + "j = 0\n", + "_, ax = plt.subplots(4, 4, figsize=(15, 5))\n", + "\n", + "for batch in validation_dataset.take(4):\n", + " batch_images = batch[\"image\"]\n", + " batch_labels = batch[\"label\"]\n", + "\n", + " preds = prediction_model.predict(batch_images)\n", + " pred_texts = decode_batch_predictions(preds)\n", + "\n", + " orig_texts = []\n", + " for label in batch_labels:\n", + " #print(tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\"))\n", + " label = tf.strings.reduce_join(num_to_char(label)).numpy().decode(\"utf-8\")\n", + " orig_texts.append(label)\n", + "\n", + " for i in range(len(pred_texts)):\n", + " img = (batch_images[i, :, :, 0] * 255).numpy().astype(np.uint8)\n", + " img = img.T\n", + " pred = pred_texts[i].replace('[UNK]', '')\n", + " comp = orig_texts[i];\n", + " if len(comp) == 5:\n", + " comp += ' '\n", + " if len(pred) == 5:\n", + " pred += ' '\n", + " dist = lev(pred, comp)\n", + " print([pred, comp])\n", + " title = f\"P: {pred} T: {comp} ({dist})\"\n", + " ax[j // 4, i % 4].imshow(img, cmap=\"gray\")\n", + " ax[j // 4, i % 4].set_title(title, color=('green' if comp in pred else 'red'))\n", + " ax[j // 4, i % 4].axis(\"off\")\n", + " j += 1\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": { + "id": "0T6jO2OrL5OK", + "outputId": "1a302d59-669e-4549-ac50-edc8d17494d6", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stderr", + "text": [ + "WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, lstm_cell_58_layer_call_fn, lstm_cell_58_layer_call_and_return_conditional_losses, lstm_cell_59_layer_call_fn while saving (showing 5 of 10). These functions will not be directly callable after loading.\n" + ] + } + ], + "source": [ + "model.save('captcha_75_25.h5')\n", + "model.save('captcha_75_25.keras')\n", + "model.save('captcha_75_25.tf')" + ] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" } - ], - "source": [ - "model.save('captcha_75_25.h5')\n", - "model.save('captcha_75_25.keras')\n", - "model.save('captcha_75_25.tf')\n" - ] - } - ], - "metadata": { - "accelerator": "GPU", - "colab": { - "name": "captcha_ocr", - "provenance": [], - "toc_visible": true - }, - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.3" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file diff --git a/model_gen/penis.py b/model_gen/penis.py new file mode 100644 index 0000000..cbd54be --- /dev/null +++ b/model_gen/penis.py @@ -0,0 +1,47 @@ +import os +import numpy as np +import matplotlib.pyplot as plt +import sys + +from pathlib import Path +from collections import Counter + +import tensorflow as tf +from tensorflow import keras +from tensorflow.keras import layers + +class CTCLayer(layers.Layer): + def __init__(self, name=None): + super().__init__(name=name) + self.loss_fn = keras.backend.ctc_batch_cost + + def call(self, y_true, y_pred): + # Compute the training-time loss value and add it + # to the layer using `self.add_loss()`. + batch_len = tf.cast(tf.shape(y_true)[0], dtype="int64") + input_length = tf.cast(tf.shape(y_pred)[1], dtype="int64") + label_length = tf.cast(tf.shape(y_true)[1], dtype="int64") + + input_length = input_length * tf.ones(shape=(batch_len, 1), dtype="int64") + label_length = label_length * tf.ones(shape=(batch_len, 1), dtype="int64") + + loss = self.loss_fn(y_true, y_pred, input_length, label_length) + self.add_loss(loss) + + # At test time, just return the computed predictions + return y_pred + + +print("loading"); +model = tf.keras.saving.load_model("captcha_75_25.tf", custom_objects={'CTCLayer': CTCLayer}); + +print("extracting"); +pmodel = keras.models.Model( + model.get_layer(name="image").input, model.get_layer(name="dense2").output +) +print("saving"); + +tf.keras.saving.save_model(pmodel, "pcaptcha_75_25.keras") +tf.keras.saving.save_model(pmodel, "pcaptcha_75_25.h5") + +print("done"); diff --git a/src/group1-shard1of1.bin b/src/group1-shard1of1.bin index d353a3a..ca5b217 100644 --- a/src/group1-shard1of1.bin +++ b/src/group1-shard1of1.bin @@ -1,3 +1,3 @@ version https://git-lfs.github.com/spec/v1 -oid sha256:b3d1959699ed9381dc680dcb6676e90670c6841c2b97fcf696ff6c2db261e1f5 -size 15704896 +oid sha256:f673767adc061648864cf142f2854df49c04ba0f717da152130cb007627e150d +size 1863520 diff --git a/src/model.json b/src/model.json index 7f6e0c1..ed12918 100644 --- a/src/model.json +++ b/src/model.json @@ -1 +1 @@ -{"format": "layers-model", "generatedBy": "keras v2.13.1", "convertedBy": "TensorFlow.js Converter v4.10.0", "modelTopology": {"keras_version": "2.13.1", "backend": "tensorflow", "model_config": {"class_name": "Functional", "config": {"name": "model", "trainable": true, "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": [null, 300, 80, 1], "dtype": "float32", "sparse": false, "ragged": false, "name": "image"}, "name": "image", "inbound_nodes": []}, {"class_name": "Conv2D", "config": {"name": "conv_2d1", "trainable": true, "dtype": "float32", "filters": 60, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "conv_2d1", "inbound_nodes": [[["image", 0, 0, {}]]]}, {"class_name": "MaxPooling2D", "config": {"name": "pool5", "trainable": true, "dtype": "float32", "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "name": "pool5", "inbound_nodes": [[["conv_2d1", 0, 0, {}]]]}, {"class_name": "Reshape", "config": {"name": "reshape", "trainable": true, "dtype": "float32", "target_shape": [75, 4800]}, "name": "reshape", "inbound_nodes": [[["pool5", 0, 0, {}]]]}, {"class_name": "Bidirectional", "config": {"name": "bidirectional", "trainable": true, "dtype": "float32", "layer": {"module": "keras.layers", "class_name": "LSTM", "config": {"name": "lstm", "trainable": true, "dtype": "float32", "return_sequences": true, "return_state": false, "go_backwards": false, "stateful": false, "unroll": false, "time_major": false, "units": 100, "activation": "tanh", "recurrent_activation": "sigmoid", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "recurrent_initializer": {"module": "keras.initializers", "class_name": "Orthogonal", "config": {"gain": 1.0, "seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "unit_forget_bias": true, "kernel_regularizer": null, "recurrent_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "recurrent_constraint": null, "bias_constraint": null, "dropout": 0.3, "recurrent_dropout": 0.0, "implementation": 2}, "registered_name": null}, "merge_mode": "concat"}, "name": "bidirectional", "inbound_nodes": [[["reshape", 0, 0, {}]]]}, {"class_name": "Dense", "config": {"name": "dense2", "trainable": true, "dtype": "float32", "units": 24, "activation": "softmax", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "dense2", "inbound_nodes": [[["bidirectional", 0, 0, {}]]]}], "input_layers": [["image", 0, 0]], "output_layers": [["dense2", 0, 0]]}}}, "weightsManifest": [{"paths": ["group1-shard1of1.bin"], "weights": [{"name": "bidirectional/forward_lstm/lstm_cell/kernel", "shape": [4800, 400], "dtype": "float32"}, {"name": "bidirectional/forward_lstm/lstm_cell/recurrent_kernel", "shape": [100, 400], "dtype": "float32"}, {"name": "bidirectional/forward_lstm/lstm_cell/bias", "shape": [400], "dtype": "float32"}, {"name": "bidirectional/backward_lstm/lstm_cell/kernel", "shape": [4800, 400], "dtype": "float32"}, {"name": "bidirectional/backward_lstm/lstm_cell/recurrent_kernel", "shape": [100, 400], "dtype": "float32"}, {"name": "bidirectional/backward_lstm/lstm_cell/bias", "shape": [400], "dtype": "float32"}, {"name": "conv_2d1/kernel", "shape": [3, 3, 1, 60], "dtype": "float32"}, {"name": "conv_2d1/bias", "shape": [60], "dtype": "float32"}, {"name": "dense2/kernel", "shape": [200, 24], "dtype": "float32"}, {"name": "dense2/bias", "shape": [24], "dtype": "float32"}]}]} \ No newline at end of file +{"format": "layers-model", "generatedBy": "keras v2.13.1", "convertedBy": "TensorFlow.js Converter v4.10.0", "modelTopology": {"keras_version": "2.13.1", "backend": "tensorflow", "model_config": {"class_name": "Functional", "config": {"name": "model", "trainable": true, "layers": [{"class_name": "InputLayer", "config": {"batch_input_shape": [null, 300, 80, 1], "dtype": "float32", "sparse": false, "ragged": false, "name": "image"}, "name": "image", "inbound_nodes": []}, {"class_name": "Conv2D", "config": {"name": "Conv1", "trainable": true, "dtype": "float32", "filters": 32, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "Conv1", "inbound_nodes": [[["image", 0, 0, {}]]]}, {"class_name": "MaxPooling2D", "config": {"name": "pool1", "trainable": true, "dtype": "float32", "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "name": "pool1", "inbound_nodes": [[["Conv1", 0, 0, {}]]]}, {"class_name": "Conv2D", "config": {"name": "Conv2", "trainable": true, "dtype": "float32", "filters": 64, "kernel_size": [3, 3], "strides": [1, 1], "padding": "same", "data_format": "channels_last", "dilation_rate": [1, 1], "groups": 1, "activation": "relu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "HeNormal", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "Conv2", "inbound_nodes": [[["pool1", 0, 0, {}]]]}, {"class_name": "MaxPooling2D", "config": {"name": "pool2", "trainable": true, "dtype": "float32", "pool_size": [2, 2], "padding": "valid", "strides": [2, 2], "data_format": "channels_last"}, "name": "pool2", "inbound_nodes": [[["Conv2", 0, 0, {}]]]}, {"class_name": "Reshape", "config": {"name": "reshape", "trainable": true, "dtype": "float32", "target_shape": [75, 1280]}, "name": "reshape", "inbound_nodes": [[["pool2", 0, 0, {}]]]}, {"class_name": "Dense", "config": {"name": "dense1", "trainable": true, "dtype": "float32", "units": 64, "activation": "relu", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "dense1", "inbound_nodes": [[["reshape", 0, 0, {}]]]}, {"class_name": "Dropout", "config": {"name": "dropout_9", "trainable": true, "dtype": "float32", "rate": 0.2, "noise_shape": null, "seed": null}, "name": "dropout_9", "inbound_nodes": [[["dense1", 0, 0, {}]]]}, {"class_name": "Bidirectional", "config": {"name": "bidirectional_19", "trainable": true, "dtype": "float32", "layer": {"module": "keras.layers", "class_name": "LSTM", "config": {"name": "lstm_19", "trainable": true, "dtype": "float32", "return_sequences": true, "return_state": false, "go_backwards": false, "stateful": false, "unroll": false, "time_major": false, "units": 128, "activation": "tanh", "recurrent_activation": "sigmoid", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "recurrent_initializer": {"module": "keras.initializers", "class_name": "Orthogonal", "config": {"gain": 1.0, "seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "unit_forget_bias": true, "kernel_regularizer": null, "recurrent_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "recurrent_constraint": null, "bias_constraint": null, "dropout": 0.25, "recurrent_dropout": 0.0, "implementation": 2}, "registered_name": null}, "merge_mode": "concat"}, "name": "bidirectional_19", "inbound_nodes": [[["dropout_9", 0, 0, {}]]]}, {"class_name": "Bidirectional", "config": {"name": "bidirectional_20", "trainable": true, "dtype": "float32", "layer": {"module": "keras.layers", "class_name": "LSTM", "config": {"name": "lstm_20", "trainable": true, "dtype": "float32", "return_sequences": true, "return_state": false, "go_backwards": false, "stateful": false, "unroll": false, "time_major": false, "units": 64, "activation": "tanh", "recurrent_activation": "sigmoid", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "recurrent_initializer": {"module": "keras.initializers", "class_name": "Orthogonal", "config": {"gain": 1.0, "seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "unit_forget_bias": true, "kernel_regularizer": null, "recurrent_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "recurrent_constraint": null, "bias_constraint": null, "dropout": 0.25, "recurrent_dropout": 0.0, "implementation": 2}, "registered_name": null}, "merge_mode": "concat"}, "name": "bidirectional_20", "inbound_nodes": [[["bidirectional_19", 0, 0, {}]]]}, {"class_name": "Dense", "config": {"name": "dense2", "trainable": true, "dtype": "float32", "units": 24, "activation": "softmax", "use_bias": true, "kernel_initializer": {"module": "keras.initializers", "class_name": "GlorotUniform", "config": {"seed": null}, "registered_name": null}, "bias_initializer": {"module": "keras.initializers", "class_name": "Zeros", "config": {}, "registered_name": null}, "kernel_regularizer": null, "bias_regularizer": null, "activity_regularizer": null, "kernel_constraint": null, "bias_constraint": null}, "name": "dense2", "inbound_nodes": [[["bidirectional_20", 0, 0, {}]]]}], "input_layers": [["image", 0, 0]], "output_layers": [["dense2", 0, 0]]}}}, "weightsManifest": [{"paths": ["group1-shard1of1.bin"], "weights": [{"name": "Conv1/kernel", "shape": [3, 3, 1, 32], "dtype": "float32"}, {"name": "Conv1/bias", "shape": [32], "dtype": "float32"}, {"name": "Conv2/kernel", "shape": [3, 3, 32, 64], "dtype": "float32"}, {"name": "Conv2/bias", "shape": [64], "dtype": "float32"}, {"name": "bidirectional_19/forward_lstm_19/lstm_cell_58/kernel", "shape": [64, 512], "dtype": "float32"}, {"name": "bidirectional_19/forward_lstm_19/lstm_cell_58/recurrent_kernel", "shape": [128, 512], "dtype": "float32"}, {"name": "bidirectional_19/forward_lstm_19/lstm_cell_58/bias", "shape": [512], "dtype": "float32"}, {"name": "bidirectional_19/backward_lstm_19/lstm_cell_59/kernel", "shape": [64, 512], "dtype": "float32"}, {"name": "bidirectional_19/backward_lstm_19/lstm_cell_59/recurrent_kernel", "shape": [128, 512], "dtype": "float32"}, {"name": "bidirectional_19/backward_lstm_19/lstm_cell_59/bias", "shape": [512], "dtype": "float32"}, {"name": "bidirectional_20/forward_lstm_20/lstm_cell_61/kernel", "shape": [256, 256], "dtype": "float32"}, {"name": "bidirectional_20/forward_lstm_20/lstm_cell_61/recurrent_kernel", "shape": [64, 256], "dtype": "float32"}, {"name": "bidirectional_20/forward_lstm_20/lstm_cell_61/bias", "shape": [256], "dtype": "float32"}, {"name": "bidirectional_20/backward_lstm_20/lstm_cell_62/kernel", "shape": [256, 256], "dtype": "float32"}, {"name": "bidirectional_20/backward_lstm_20/lstm_cell_62/recurrent_kernel", "shape": [64, 256], "dtype": "float32"}, {"name": "bidirectional_20/backward_lstm_20/lstm_cell_62/bias", "shape": [256], "dtype": "float32"}, {"name": "dense1/kernel", "shape": [1280, 64], "dtype": "float32"}, {"name": "dense1/bias", "shape": [64], "dtype": "float32"}, {"name": "dense2/kernel", "shape": [128, 24], "dtype": "float32"}, {"name": "dense2/bias", "shape": [24], "dtype": "float32"}]}]} \ No newline at end of file