diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..2f77e919 --- /dev/null +++ b/.gitattributes @@ -0,0 +1 @@ +*.ipynb linguist-documentation diff --git a/README.md b/README.md index 04c0760d..7c6e2bba 100644 --- a/README.md +++ b/README.md @@ -64,6 +64,10 @@ For a detailed list of existing KV cache compression methods, check [Awesome-KV- ## Evaluation +See the [speed_and_memory.ipynb](notebooks/speed_and_memory.ipynb) notebook on how to measure peak memory usage and total time gain. +drawing + + We provide a simple CLI to evaluate the performance of the different presses on several long-context datasets. _Average performance on the RULER dataset with 4k context length and Loogle Short Dependency QA task for 3 models and 7 presses_ diff --git a/evaluation/README.md b/evaluation/README.md index 7eb0b97c..c826381e 100644 --- a/evaluation/README.md +++ b/evaluation/README.md @@ -7,7 +7,7 @@ This directory contains a set of scripts to evaluate the performance of differen - [Infinitebench](infinite_bench/README.md) ([hf link](https://huggingface.co/datasets/MaxJeblick/InfiniteBench)) -Please refer to the README of each dataset for more information on how the huggingface dataset was generated. +Please refer to the README of each dataset for more information on how the Hugging Face dataset was generated. ## Usage @@ -99,7 +99,7 @@ $dataset ``` Where: -- `create_huggingface_dataset.py` is a script that generates the huggingface dataset from the original dataset. Each dataset is associated with a set of parquet files with the following structure: +- `create_huggingface_dataset.py` is a script that generates the Hugging Face dataset from the original dataset. Each dataset is associated with a set of parquet files with the following structure: - `context`: ... - `question`: ... - `answer_prefix`: ... diff --git a/evaluation/assets/peak_memory_consumption.png b/evaluation/assets/peak_memory_consumption.png new file mode 100644 index 00000000..d2838909 Binary files /dev/null and b/evaluation/assets/peak_memory_consumption.png differ diff --git a/evaluation/infinite_bench/README.md b/evaluation/infinite_bench/README.md index eea45e01..241ad613 100644 --- a/evaluation/infinite_bench/README.md +++ b/evaluation/infinite_bench/README.md @@ -2,6 +2,6 @@ [Infinitebench](https://github.com/OpenBMB/InfiniteBench) is composed of 12 major tasks. -## Create huggingface dataset +## Create Hugging Face dataset -The processed huggingface dataset for Infinitebench can be found [here](https://huggingface.co/datasets/MaxJeblick/InfiniteBench). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script. \ No newline at end of file +The processed Hugging Face dataset for Infinitebench can be found [here](https://huggingface.co/datasets/MaxJeblick/InfiniteBench). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script. \ No newline at end of file diff --git a/evaluation/loogle/README.md b/evaluation/loogle/README.md index e3165de9..658cfa62 100644 --- a/evaluation/loogle/README.md +++ b/evaluation/loogle/README.md @@ -2,6 +2,6 @@ [Loogle](https://github.com/bigai-nlco/LooGLE/tree/main) is composed of 7 major tasks to evaluate LLMs' ability to understand both short and long dependency content. -## Create huggingface dataset +## Create Hugging Face dataset -The huggingface dataset for Loogle can be found [here](https://huggingface.co/datasets/simonjegou/loogle). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script. \ No newline at end of file +The Hugging Face dataset for Loogle can be found [here](https://huggingface.co/datasets/simonjegou/loogle). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script. \ No newline at end of file diff --git a/evaluation/ruler/README.md b/evaluation/ruler/README.md index 4e34caa6..85eaf351 100644 --- a/evaluation/ruler/README.md +++ b/evaluation/ruler/README.md @@ -2,9 +2,9 @@ [RULER](https://arxiv.org/abs/2404.06654) generates synthetic examples to evaluate long-context language models with configurable sequence length (from 4k tokens to 128k tokens) and task complexity. It contains a set of 13 tasks grouped in 4 categories (needle in the haystack, question answering, multi-hop tracing and aggregation). -## Huggingface dataset +## Hugging Face dataset -The huggingface dataset for RULER can be found [here](https://huggingface.co/datasets/simonjegou/ruler). To reproduce this dataset, +The Hugging Face dataset for RULER can be found [here](https://huggingface.co/datasets/simonjegou/ruler). To reproduce this dataset, 1. Install the [RULER repository](https://github.com/hsiehjackson/RULER) and download the necessary data files (see 1. Download data in the README) 2. Copy paste the `generate.sh` from this repository to `$RULER/scripts`, set the `DATA_DIR` variable to your desired location of the RULER data files and run the script diff --git a/evaluation/ruler/generate.sh b/evaluation/ruler/generate.sh index aafa915a..d5488c93 100644 --- a/evaluation/ruler/generate.sh +++ b/evaluation/ruler/generate.sh @@ -1,4 +1,4 @@ -# The following script prepares the synthetic data benchmark for a given huggingface tokenizer and without template +# The following script prepares the synthetic data benchmark for a given Hugging Face tokenizer and without template # Before running this script, make sure you downloaded the data as explained in the README: # cd scripts/data/synthetic/json/ # python download_paulgraham_essay.py diff --git a/evaluation/zero_scrolls/README.md b/evaluation/zero_scrolls/README.md index af7b745a..73aba0ad 100644 --- a/evaluation/zero_scrolls/README.md +++ b/evaluation/zero_scrolls/README.md @@ -2,9 +2,9 @@ [Zero scrolls](https://www.zero.scrolls-benchmark.com/) includes ten natural language tasks across multiple domains, including summarization, question answering, aggregated sentiment classification and information reordering. -## Hugginface dataset +## Hugging Face dataset -The huggingface dataset for Zero Scrolls can be found [here](https://huggingface.co/datasets/simonjegou/zero_scroll). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script. +The Hugging Face dataset for Zero Scrolls can be found [here](https://huggingface.co/datasets/simonjegou/zero_scroll). To reproduce this dataset, simply run the `create_huggingface_dataset.py` script. ## Evaluation diff --git a/notebooks/speed_and_memory.ipynb b/notebooks/speed_and_memory.ipynb index 98f9be65..4c9210eb 100644 --- a/notebooks/speed_and_memory.ipynb +++ b/notebooks/speed_and_memory.ipynb @@ -4,7 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "In this notebook, we showcase the memory and speed improvement obtained using the KV press pipeline (tested using A100 with 80GB memory)." + "**In this notebook, we showcase the memory and speed improvement obtained using the KV press pipeline (tested using A100 with 80GB memory).**" ] }, { @@ -12,176 +12,441 @@ "execution_count": 1, "metadata": {}, "outputs": [], + "source": [ + "# Run these below to be able to use quantized cache \n", + "# See also: https://huggingface.co/blog/kv-cache-quantization#how-to-use-quantized-kv-cache-in-%F0%9F%A4%97-transformers\n", + "#!pip install git+https://github.com/huggingface/transformers.git --upgrade\n", + "#!pip install -U optimum-quanto" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], "source": [ "import warnings\n", - "warnings.filterwarnings(\"ignore\")\n", "from time import time\n", + "from tqdm import tqdm\n", "\n", + "import numpy as np\n", "import torch\n", - "from transformers import AutoModelForCausalLM\n", + "from transformers import AutoModelForCausalLM, pipeline\n", + "from transformers import QuantizedCacheConfig, QuantoQuantizedCache, DynamicCache, QuantizedCache\n", + "from transformers.utils.logging import disable_progress_bar\n", + "import transformers\n", "\n", - "from kvpress import ExpectedAttentionPress" + "from kvpress import KnormPress" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "warnings.filterwarnings(\"ignore\")\n", + "transformers.logging.set_verbosity_error()\n", + "disable_progress_bar()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "device = \"cuda:0\"\n", + "ckpt = \"meta-llama/Meta-Llama-3.1-8B-Instruct\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def get_size_of_cache(cache):\n", + " if isinstance(cache, QuantoQuantizedCache):\n", + " value_cache = cache._quantized_value_cache\n", + " key_cache = cache._quantized_key_cache\n", + " size_in_bytes = 0\n", + " for value in value_cache:\n", + " size_in_bytes += value._data.nelement() * value._data.element_size()\n", + " size_in_bytes += value._scale.nelement() * value._scale.element_size()\n", + " size_in_bytes += value._shift.nelement() * value._shift.element_size()\n", + "\n", + " for key in key_cache:\n", + " size_in_bytes += key._data.nelement() * key._data.element_size()\n", + " size_in_bytes += key._scale.nelement() * key._scale.element_size()\n", + " size_in_bytes += key._shift.nelement() * key._shift.element_size()\n", + " return size_in_bytes\n", + "\n", + " elif isinstance(cache, DynamicCache):\n", + " value_cache = cache.value_cache\n", + " key_cache = cache.key_cache\n", + " size_in_bytes = 0\n", + " for value in value_cache:\n", + " size_in_bytes += value.element_size() * value.nelement()\n", + " for key in key_cache:\n", + " size_in_bytes += key.element_size() * key.nelement()\n", + " return size_in_bytes\n", + " else:\n", + " raise NotimplementedError(f\"{type(cache)} is not supported yet.\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# The model is loaded each time inside the function to avoid potential GPU leakage\n", + "\n", + "def get_prefilling_stats(press, n_tokens, cache_implementation=\"dynamic\"):\n", + " torch.cuda.reset_peak_memory_stats()\n", + " torch.cuda.empty_cache()\n", + " idle_peak_memory = torch.cuda.max_memory_allocated()\n", + " model = AutoModelForCausalLM.from_pretrained(ckpt, torch_dtype=\"auto\", attn_implementation=\"flash_attention_2\").to(device)\n", + " initial_peak_memory = torch.cuda.max_memory_allocated()\n", + "\n", + " inputs =torch.arange(n_tokens).reshape([1, n_tokens]).to(device)\n", + " # Model warmup (for better prefilling time estimation)\n", + " with torch.no_grad():\n", + " model(inputs[:, :100])\n", + " torch.cuda.synchronize()\n", + " torch.cuda.empty_cache()\n", + "\n", + " # Compute cache size and prefilling time\n", + " start = time()\n", + " with torch.no_grad(), press(model):\n", + " if cache_implementation == \"dynamic\":\n", + " cache = DynamicCache()\n", + " elif cache_implementation == \"quantized\":\n", + " config = QuantizedCacheConfig(nbits=4)\n", + " cache = QuantoQuantizedCache(config)\n", + " else:\n", + " raise NotImplementedError(f\"Cache {cache_impl} not yet implemented\")\n", + " \n", + " model(inputs, num_logits_to_keep=1, past_key_values=cache)\n", + " cache_size = get_size_of_cache(cache)\n", + " del cache\n", + " \n", + " prefilling_time = time() - start\n", + " \n", + " peak_memory = torch.cuda.max_memory_allocated()\n", + " model.cpu()\n", + " torch.cuda.empty_cache()\n", + " torch.cuda.reset_peak_memory_stats()\n", + " return {\"Idle Peak memory\": idle_peak_memory / 1024**3,\n", + " \"Initial Peak memory\": initial_peak_memory / 1024**3,\n", + " \"Prefilling time\": prefilling_time, \n", + " \"Peak memory usage\": peak_memory / 1024**3,\n", + " \"Cache Size\": cache_size / 1024**3,\n", + " \"Peak memory w/o weights and KV cache (GB)\": (peak_memory - cache_size - initial_peak_memory) / 1024**3\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def get_generation_stats(press, n_tokens, max_new_tokens = 100, cache_implementation=\"dynamic\"):\n", + " torch.cuda.reset_peak_memory_stats()\n", + " torch.cuda.empty_cache()\n", + " idle_peak_memory = torch.cuda.max_memory_allocated()\n", + " model = AutoModelForCausalLM.from_pretrained(ckpt, torch_dtype=\"auto\", attn_implementation=\"flash_attention_2\").to(device)\n", + " # disable EosTokenCriteria stopping criteria\n", + " model.generation_config.eos_token_id = None\n", + " model.generation_config.stop_strings = None\n", + " \n", + " model.generation_config.do_sample = False\n", + " model.generation_config.temperature = None\n", + " model.generation_config.top_p = None\n", + "\n", + " initial_peak_memory = torch.cuda.max_memory_allocated()\n", + " \n", + " inputs =torch.arange(n_tokens).reshape([1, n_tokens]).to(device)\n", + "\n", + " start = time()\n", + " with press(model):\n", + " kwargs = dict()\n", + " if cache_implementation == \"quantized\":\n", + " kwargs = dict(cache_implementation=\"quantized\",\n", + " cache_config={\"backend\": \"quanto\", \"nbits\": 4})\n", + " \n", + " outputs = model.generate(inputs, max_new_tokens=max_new_tokens,\n", + " generation_config=model.generation_config,\n", + " pad_token_id=-1, **kwargs)\n", + " assert outputs.shape == (1, n_tokens + max_new_tokens), outputs.shape\n", + "\n", + " total_time = time() - start\n", + " peak_memory = torch.cuda.max_memory_allocated()\n", + "\n", + " model.cpu()\n", + " torch.cuda.empty_cache()\n", + " torch.cuda.reset_peak_memory_stats()\n", + " return {\"Idle Peak memory\": idle_peak_memory / 1024**3,\n", + " \"Initial Peak memory\": initial_peak_memory / 1024**3,\n", + " \"Total time\": total_time, \n", + " \"Peak memory usage\": peak_memory / 1024**3\n", + " }" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def combine_stats(prefilling_stats, generation_stats):\n", + " \"\"\"Combines prefilling and generation data, then plots.\"\"\"\n", + " combined_stats = {}\n", + " for compression_ratio in prefilling_stats:\n", + " combined_stats[compression_ratio] = dict()\n", + " combined_stats[compression_ratio]['Peak memory usage'] = generation_stats[compression_ratio]['Peak memory usage']\n", + " combined_stats[compression_ratio]['Prefilling time'] = prefilling_stats[compression_ratio]['Prefilling time']\n", + " combined_stats[compression_ratio]['Cache Size'] = prefilling_stats[compression_ratio]['Cache Size']\n", + " combined_stats[compression_ratio]['Total time'] = generation_stats[compression_ratio]['Total time']\n", + " combined_stats[compression_ratio]['Generation time'] = generation_stats[compression_ratio]['Total time'] - prefilling_stats[compression_ratio]['Prefilling time']\n", + " \n", + " return combined_stats" + ] + }, + { + "cell_type": "code", + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "You are attempting to use Flash Attention 2.0 with a model not initialized on GPU. Make sure to move the model to GPU after initializing it on CPU with `model.to('cuda')`.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "65d3b16c204e4537a79ef6f1397f5278", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Loading checkpoint shards: 0%| | 0/4 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" }, { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total time: 35.04s. Estimated generation time: 6.48s\n", - "Peak memory usage: 33.10 GB\n", - "\n", - "Compression ratio: 0.5\n", - "Total time: 36.27s. Estimated generation time: 7.71s\n", - "Peak memory usage: 37.00 GB\n", - "\n", - "Compression ratio: 0.25\n", - "Total time: 37.63s. Estimated generation time: 9.08s\n", - "Peak memory usage: 40.91 GB\n", - "\n", - "Compression ratio: 0.0\n", - "Total time: 37.92s. Estimated generation time: 9.36s\n", - "Peak memory usage: 44.82 GB\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "# Compute peak memory usage and generation time for different compression ratios\n", + "plot_compression_stats(stats, title_suffix=' (bfloat16)', max_peak_memory=45, max_cache_size=17.5)\n", + "plot_compression_stats(stats_quantized, title_suffix=' (4bit)', max_peak_memory=45, max_cache_size=17.5)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "from matplotlib.colors import LinearSegmentedColormap\n", "\n", - "def timer(press, max_new_tokens = 100):\n", - " start = time()\n", - " with press(model):\n", - " outputs = model.generate(inputs, max_new_tokens=max_new_tokens, do_sample=False, temperature=None, top_p=None, pad_token_id=-1)\n", - " assert outputs.shape == (1, n_tokens + max_new_tokens)\n", - " return time() - start\n", + "def plot_memory_vs_context_length(stats, stats_quantized, fontsize=13):\n", + " gree_color = np.array([118, 185, 0]) / 255\n", + " cmap = LinearSegmentedColormap.from_list(\"apple_green_to_black\", [gree_color / 4, gree_color])\n", + "\n", + " context_lengths = sorted(stats.keys())\n", + "\n", + " bf16_peak_mem = [stats[cl][0.0]['Peak memory usage'] for cl in context_lengths]\n", + " int4_peak_mem = [stats_quantized[cl][0.0]['Peak memory usage'] for cl in context_lengths]\n", + " bf16_compressed_peak_mem = [stats[cl][0.5]['Peak memory usage'] for cl in context_lengths]\n", + " int4_compressed_peak_mem = [stats_quantized[cl][0.5]['Peak memory usage'] for cl in context_lengths]\n", " \n", - "for compression_ratio in [0.75, 0.5, 0.25, 0.0]:\n", - " print(f\"\\nCompression ratio: {compression_ratio}\")\n", - " press = ExpectedAttentionPress(compression_ratio)\n", - " torch.cuda.reset_peak_memory_stats()\n", - " total_time = timer(press)\n", - " print(f\"Total time: {total_time:.2f}s. Estimated generation time: {total_time - prefilling_time:.2f}s\")\n", - " print(f\"Peak memory usage: {torch.cuda.max_memory_allocated() / 1024**3:.2f} GB\")" + " plt.figure(figsize=(8, 5))\n", + " \n", + " # Plot data with colormap\n", + " plt.plot(context_lengths, bf16_peak_mem, '-o', label='bfloat16 cache', color=cmap(1/4))\n", + " plt.plot(context_lengths, int4_peak_mem, '-o', label='int4 cache', color=cmap(2/4))\n", + " plt.plot(context_lengths, bf16_compressed_peak_mem, '-o', label='bfloat16 cache + 50% compression', color=cmap(3/4))\n", + " plt.plot(context_lengths, int4_compressed_peak_mem, '-o', label='int4 cache + 50% compression', color=cmap(4/4))\n", + " \n", + " plt.xlabel('Context Length (tokens)', fontsize=fontsize + 2)\n", + " plt.ylabel('Peak Memory Usage (GB)', fontsize=fontsize + 2)\n", + " plt.title('Peak Memory Usage vs. Context Length (Meta-Llama-3.1-8B-Instruct)', fontsize=fontsize + 2)\n", + " plt.legend(fontsize=fontsize)\n", + " plt.grid(True)\n", + " plt.xticks(fontsize=fontsize)\n", + " plt.yticks(fontsize=fontsize)\n", + " \n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAu0AAAHiCAYAAABcAPIvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1gTyf8H8HcIEHrvgjQBEWwoWFBALGBFERUQwX6eBRWx17P3rngWEMV6dsWGBdvZe0EUxLOhAlKkQzK/P/hlv8QkkCAS1Hk9D8+du7Ozs7Ob3c/uzs6wCCEEFEVRFEVRFEXVWnKyLgBFURRFURRFURWjQTtFURRFURRF1XI0aKcoiqIoiqKoWo4G7RRFURRFURRVy9GgnaIoiqIoiqJqORq0UxRFURRFUVQtR4N2iqIoiqIoiqrlaNBOURRFURRFUbUcDdopiqIoiqIoqpar1qCdxWIJ/MnJyUFLSwtt27bF1q1bIYvBVz08PMBisfD69evvzqv8tl2/fl1suv379zPpLCwsvnu9vyP+ftu+fbvYNPHx8bSOa6Fnz55hzJgxcHR0hKamJjgcDurUqYMePXpgx44dKC4ulnURfzr8Y93Dw0PWRfnhqvOcXd6OHTvAYrEQGxsrcn0sFguLFi0Su3xqairk5eWZtNVdvpowcODASs+r5f1O59ft27fD398f9vb20NHRgaKiIkxMTODn54dr165Jnd/du3exePFi+Pr6wtTUlDluvtf+/fvh6ekJbW1tKCgowNDQED4+PoiPjxdK+/r1a6G4jMViQVFREebm5ggODsbTp0+lLsP27dvBYrEwcODA796e301BQQGMjY3RpUuXKi3/Q560h4SEICQkBP3790eDBg1w7do1DBs2DIGBgT9idTKxa9cusfNiYmJqsCQUVTsQQjBz5kw0atQI69evx9evX9GuXTv4+vrC0tISp0+fRkhICOzt7Wu8bPyLlyyD3tpQhtrAwsKiWoIXaRQWFmLGjBlwdnZG165dxaar6Ly+Z88ecLncaisTPR5ql/Xr1+PgwYNQVlZGmzZt0LNnT+jr6+PgwYNo27YtNm3aJFV+8+bNw9SpU3H48GG8f/++Wso4fvx49OvXD1euXEHTpk2ZG4Jjx46hXbt22Lx5s8jlVFVVmbgsJCQE3t7e4HK52LlzJ5o1a4ZLly5VS/l+tDlz5kh10ykLlf2ulZWVMWnSJJw6dQoXLlyQOn/57yyfSN9WaFxcHLp06YK9e/eif//+6Nat249YbY1gs9lo0KAB9u3bh9WrV0NeXrAKMzIycPr0aTg5OeHevXsyKiVF1bxp06Zh8eLFMDQ0RGRkpNCThMzMTCxfvhzLli2TUQmp31VERATevn2LNWvWiE3TtGlT3L9/Hw8ePECTJk2E5sfExEBbWxtaWlpISUn5gaWlZGHDhg1o0KAB1NXVBaYfO3YMvr6+GD9+PPz8/KCnpydRfq1atUKjRo3g7OwMZ2dnWFhYoKioqMrle/ToEVavXg0tLS1cu3YNDRo0YObt3bsXgYGBCAsLQ2BgINTU1ASW1dPTE4rLiouLMXjwYOzatQtjxozBo0ePqlw2SjojRozA3LlzMXXqVNy8eVOqZWukTXvHjh0xYMAAAMCRI0dqYpU/VP/+/ZGeno4zZ84Izdu3bx9KSkoQFBQkg5JRlGzcunULS5YsgbKyMi5evCjy1Z+2tjYWLFiAixcvyqCE1O8sIiICOjo6FT4w6t+/PwDRT9sTEhJw//599OnTB4qKij+snJTstGjRQihgB4AePXrAw8MDhYWF+PfffyXOb/LkyZg7dy66d+8OIyOj7y7f5cuXAQD9+vUTCNgBwN/fHw0bNkReXh6ePXsmUX6KioqYO3cuAODx48fIysr67jJSklFWVkbv3r1x69Yt3L9/X6pla+xD1KZNmwIA3r59KzD95s2b6NOnD4yNjaGoqAhTU1MMHToUb968EcojKysL69atg5eXF8zNzcHhcKCrqwtvb2/ExcVJVZ7s7Gy4ubmBxWJhzJgxUrW3DwwMBIvFEtkMJiYmBmpqavDx8akwj4SEBAwcOBBmZmbgcDgwNDSEv7+/yPZl/PZjc+bMQXJyMvr27Qs9PT1oaGigc+fOzI+0tLQUCxcuhK2tLZSUlFCvXj1s2LBBbBmuX78OHx8f6Ovrg8PhwMLCAiNHjsSHDx8qLMOLFy/g7+8PQ0NDyMnJ4ciRI3B0dASLxUJiYqLIdb19+xZsNhuWlpY18m3DyZMn0bFjR9SpUwccDgcmJiZo06YN/vrrL4F0VT2mXr9+jcDAQOjr60NVVRXNmzfH3r17K301dvr0aXTt2pWpcysrK4SFhSEjI0Oi7fr8+TPk5eVhYmICHo8nMs3x48fBYrHg6+vLTCsuLsbGjRvh7OwMXV1dqKiowMLCAt26dcPevXslWndFVqxYAUIIQkNDK23+4urqKjTt2bNn6N+/P3MeqFOnDoKDg0UeT/z23QMHDsSXL1/w559/wtjYGBwOB46OjoiMjBRIP2fOHFhaWgIALl26JNC289s2mV++fMHUqVPRoEEDKCsrQ1NTE56enjhx4oRAuvfv30NXVxccDgcPHjwQKuOCBQvAYrHg7e0NQohUZagub9++xejRo2FtbQ0lJSUmaBUVeEhbp+UdOnQILVu2hIqKCvT09NCnTx8kJSUJvcrmr+O///4DIPiNkLh200eOHEHLli2hqqoKHR0dBAQE4N27d1LVw6VLl/Dy5Uv07t0bCgoKYtO1aNEC9erVw549e4R+Wzt37gSASh/GSHr8SHo8XLlyBaNHj0ajRo2gra0NZWVl1K9fH1OmTJFZkEUIwZ49e+Dv7w9bW1uoqqpCXV0dLi4u2Lhxo8jzUvlj4e7du+jcuTO0tLSgo6ODvn37Mvs0Ly8PkyZNgoWFBZSUlODo6IgDBw5USxm+B/+4keUNG4fDkSidrq6uxHkaGBgw/19aWip1mb5Vfj8/fvwYPXr0gLa2NlRVVeHu7i72pkeS67WFhQXz70GDBgn8Zvjt+SuLU/j5iGueV/48+C3+MdexY0fo6upCSUkJFhYW6Nu3L86fP89sv6TneX5zcXFNmsQi1QgAEZflggULCADSvXt3ZtqGDRuInJwckZOTIy1atCB9+vQhjRo1IgCIvr4+efbsmUAep06dIgCIhYUF6dixI+nXrx9p1aoVYbFYhMVikW3btgmt193dnQAgKSkpzLSPHz+SJk2aEABk1qxZUm0fm81m8lVRUSFfv35l5icnJxMAZMCAASQ1NZUAIObm5kL5HD58mHA4HAKANGnShPj5+ZEWLVoQFotFVFRUyKVLlwTSR0VFEQAkODiY6OjoEHt7e9KvXz/SsGFDpq5SU1OJj48P0dTUJD179iReXl5EUVGRACCbN28WKsPOnTsJm80mAIirqyvx9/cntra2BAAxNDQkCQkJIsvg7+9PNDQ0iKWlJenXrx/p1KkTOXHiBFm7di0BQMLDw0XW3Zw5cwgAMn/+fInqmr/foqKixKa5ePGiyDpev349s6/c3NxIQEAA6dixIzE1NRU6PqtyTL18+ZLo6+sTAKRevXrE39+fuLm5ERaLRcaOHUsAEHd3d6HlJk+eTAAQRUVF4urqSvz8/IiNjQ0BQKytrcnHjx8lqhtvb28CgJw7d07k/H79+hEA5ODBg8w0Pz8/AoCoq6uTLl26EH9/f9K2bVuiqakpsqzS4HK5RENDgwAgDx8+lHr5c+fOEWVlZQKANG3alPj7+zO/TzU1NXL58mWB9Pz97uPjQ2xtbYmJiQnp06cPadeuHXNMb9myhUl/+PBh0rt3b+bYDgkJYf7Kp0tMTCRmZmbM8eDj40M8PT2JiooKAUCWLVsmUI5//vmHACD29vYkPz+fmX7r1i0iLy9P9PT0yIcPH6Qqgzj8bZZ0X/37779EW1ubACB2dnbE19eXtG3blsjLyxM2m0327t37XXXKt3r1agKAyMnJEQ8PD+Lv708sLS2JtrY2CQ4OFvgNJyQkkJCQEKKqqkoACNTBhAkTmDz5v/2JEycSNptNPDw8iJ+fH7NvbGxsBOq7MuHh4QQA2bVrl8j5/PVduXKFzJ49mwAg58+fZ+bzeDxibm5OzM3NCY/HI3Z2dkLXFEKkO34kPR5atGhBlJSUiIuLC+nduzfp2rUrMTY2JgCIg4ODwPVHEiEhIZWeV8sTdX4tKCggAIiuri5p27Yt6devH+nQoQOznSEhIUL58Ot1xIgRhMPhkGbNmpG+ffuSevXqEQDE1taWZGVlEWdnZ2JgYED8/PyIh4cHcx4+ffr0d5ehqs6dO0cUFRWJtrY2yczMrHI+/Gt+Vb18+ZLIy8sTLS0t8vTpU4F5e/bsISwWS+j8kJKSIjYOIeR/v3t9fX2pysKPB76tZ/5+HjVqFFFRUSENGzYk/fr1I40bNyYAiJKSEnn8+LHAMpJerydMmMDk4+rqKvCb4ccrlcUphBBibm4udj/w6+Pb7SotLSV9+vRhrt/t2rUj/v7+xNXVlaioqBAfHx9CiHTn+YKCAqKgoEDMzMykqvsaCdp5PB5p1aoVAUCmT59OCCHk+vXrhM1mkzp16pA7d+4IpN+6dSsBQFq0aCEw/dWrV+T69etC+d+7d49oaWkRDQ0NoZPYt0F7SkoKqVevHmGxWGTt2rVSbx8/aN+yZQsBQKKjo5n5c+fOJQDImTNnxAbtKSkpRFVVlaipqZG4uDiBeadOnWJ2YlFRETOdfyACIFOmTCE8Ho8QUlavAwcOJABIgwYNiKOjI/n8+TOz3Llz50SW4c2bN0RZWZmw2Wxy9OhRZjqXyyXjxo0jAEjz5s0FlilfhtGjR5PS0lKB+VlZWURFRYXo6+sLlJ2fb926dQmbzSbv37+vqIoZ3xO0161bl7BYLHL79m2B6Twej1y8eFFgWlWOqfbt2zMXoPL1cPr0aaKgoCAyuNq/fz8BQBwdHcnLly8FyjRr1iwCgPTr10/stpa3c+dOAoAMHjxYaF5OTg5RVlYmmpqapLCwkNlGfj2lp6cLpC8oKCD//vuvROsV5+XLlwQA4XA4QsdFZXJzc4mhoSEBQNavXy8wb+XKlQQAMTU1JQUFBcx0/n7nn5z520lI2UkTAKlbt65AXvyLl7igt7S0lLkJXrp0KeFyuQLbZ2lpSdhsttAFh//7GzVqFLM9/Buxw4cPS1WGikgTtGdnZxNjY2PCZrNJTEyMwLzbt28TbW1toqamJnCuqEqdJicnE0VFRaKoqEguXLjATC8pKSGDBg1i8vv2N1zRRZOQ//32VVRUBI7NvLw80rp1awJA5M20OC1atCAAyIsXLypc35UrV5hjedCgQcz8y5cvEwBk6tSphBAiMmivyvEjyfFw8uRJkpWVJTCtsLCQDB8+nAAgf/31l8T1QEj1BO0lJSXk8OHDpLi4WGD658+fSfPmzQkAoQdP/GAOAImIiGCmFxcXkw4dOjDXME9PT5Kbm8vM58cCbm5u310GSUVGRpKQkBDSr18/Ji9NTU2hGwdpfW/QTggh69atI3JyckReXp60a9eO9OvXjzg5OREWi0V69OghdH4XF7RnZmaSU6dOMTdNK1eulKoclQXtAMiaNWsE5vFjiwEDBghMl+Z6zc9f3PFbWZxCSNWC9nnz5jHH6KtXrwTmZWVlkfj4eObf0pznmzVrRgAI5VmRHxq0l5aWkhcvXjAXNg6HQ5KSkgghhPj4+BAA5Pjx4yLz6tGjBwFA7t27J9G6p0+fTgCQY8eOCUwvH7Q/efKEmJiYEHl5eaGLmaTbxw/aMzMzCYfDIZ06dWLm29nZEWNjY1JaWio2aOc/iV23bp3IdYSGhhIA5NChQ8w0/oFoZWUldJJ6+PAhU++inrw2bdpU6ALDDxIDAgKE0hcWFhITExMCgFy9elWoDPr6+iQvL09k2QcPHkwAkP379wtM5z/N7tGjh8jlRPmeoF1ZWZloa2tLvC5xRB1T/Iu6lpaWyKdc/fv3F/mD5T8h+DboI6Ts5NSkSRPCZrNJWlpapeXKzc0lqqqqAoE5X3R0NAFAhgwZwky7efMmAUB69uxZad5VcePGDQKAGBkZSb1sZGQkAUBatWolcj7/pFb+98rf7xoaGkIXKUIIcXR0FDrmKzuR8gPT3r17i5x/6NAhAoCEhoYKTM/JySFWVlYEAImNjSVDhw4lAMjQoUOF8qipoH3VqlUEgMDT6/L4N0PlL9RVqVP+76P8scaXmZlJ1NTUvito5z/gKe/AgQMiL6oVUVZWJnJycszDDnHru3LlCiGEEBcXF6KhocHcKPIDZP7TTVFBe1WOn+85HvLz84m8vDxxcnKSarnqCNorEhcXRwCQsLAwgen8YKtNmzZCyxw9epQAZW9rEhMTBeaVlpYSPT09oqCgIHTtk7YMkhoyZAhzTQVAdHR0BN5aVlV1BO2EELJ3717mjQL/z9jYmKxbt07oGOcfY+L+DA0NyZ49e6QuQ2VBu6urq9Ay6enp3329ljRoryhOkTZoLyoqIlpaWgQAuXHjRqVllOZ3zY8Xysd7lfkhbdr5bXjk5eVha2uL7du3Q11dHXv27IG1tTV4PB7Onz8PFRUVeHl5icyjbdu2AMo+cCuPy+Xi7NmzmDNnDv744w8MHDgQAwcOZD5ue/nypcj8bty4ATc3N2RmZuLw4cPMR0dVpaWlha5du+L8+fP4+PEjbt++jcTERPj7+4PNZotd7uzZswAg0N64PHHbDZT1J/xtm0wrKysAZW3uRLWj5s9PTU1lpl25cgUARNYBh8NBnz59BNKV16FDB6ioqIgs+4gRIwAAW7ZsEZjO//fw4cNFLlfdmjVrhszMTAwZMkSiPmilOab4/fV6e3sLfaEPlH0k9K3Pnz/j4cOHsLGxgaOjo9B8FosFV1dXcLlc3L17t9LyqqqqwsfHB9nZ2UJ9TvM/oivf9rZ+/fpQVVVFbGwsli1bJvKbBVmp6FgE/rcdoo7FZs2aiWy/aWtrC0DwmK9MVX+X6urqiImJAZvNhr+/P7Zu3QobGxusXr1a4nVXt+85x0hTp/zfAv98UZ6WlhY6deokZckFiVpe2n2bm5uLgoICaGlpSdzNZFBQEHJycnD8+HEUFxfjn3/+QdOmTYU+/ivve+q8Mu/fv8emTZswbtw4DB48GAMHDsSff/4JRUVFsde7mvDgwQMsXboUo0aNwqBBgzBw4EBEREQAEH8dFrVP+dcoCwsLZv/ysdlsmJubo6SkBOnp6dVShsrwx5T5+vUr7ty5gw4dOqB37941dv0ShxCCcePGwd/fH8HBwXjx4gVyc3Nx8+ZN1KtXD2PGjMHo0aNFLvttl499+/aFk5MTPn36hKlTp+LOnTvVWlZR+1lXVxc6OjpCv11pr9eSqChOkdadO3eQlZWFxo0bo0WLFtWSJ5+Ojg4AIC0tTeJlfkiXjyEhIQAAOTk5aGhooGHDhvD19YW2tjYAID09Hbm5uQAq/7Cj/A/13bt36NatGx4+fCg2/devX0VOHzBgAEpLS7Fv375q63IyKCgIhw4dwt69e5kuwCr7UIk/IEedOnUqTCfqBCVqGX7gaGRkJPJmgT+/fFdT/KBN3Mdf/Omi+patW7eu2DI7OzvDyckJ586dQ0pKCiwtLfHp0yccP34cpqam8Pb2FrvstyS5wJL//6D127QbNmxAz549ERkZicjISBgaGsLd3R2+vr7w8/MTqCdpjyn+CcfMzExkWlH1w9/nL1++rHS7RO13Ufr374/du3dj165dTKDw6dMnnD9/HqampnBzc2PSamhoYMuWLRg+fDgmTZqESZMmwdbWFu3atcOAAQNEfhgqDX6Ql5mZCS6XW+FN67e+51g0NTUVuQy/Bwhpulfj76P+/ftXeEMvav+0atUKoaGhWLVqFYCyjxZVVVUlXnd1429LZftV1LZIU6dV+S1IQ1RZpN232dnZAstJwt/fH2FhYdi1axfk5eWRmZmJGTNmVLjM9xw/FVm5ciWmTJmCkpKSStOmp6cjPDxcaPrQoUPRpk0bqdZbkeLiYgwcOBB79uwRm0bcdbiia5i4a6Koa5i0Zbh69Sq2bt0qlGb58uViu3BUU1NDs2bNsG/fPhQWFmLLli3w8vJC7969xa7zeyxevBjPnz8XmMb/6BgAoqOjsWbNGvj4+DA3JgDg4uKC2NhY1K9fHxERERg5ciQcHBwE8hHV5SMAnDlzBt26dUPHjh2RnJzMBJHh4eFCx2qbNm0wdOhQibalovPIly9fBKZJc72W1Peee8rjd55ibW1dbXnyaWhoAIBUH5XXSD/t3+J/2a2mplbpD6D8wTd06FA8fPgQvXv3xqRJk2BnZwd1dXXIyclh8+bN+OOPP8T2TBIQEICdO3di1qxZcHNzq5YumLp06QItLS3s2LEDHz58gL29PZycnCpchr/t/BsbcUTd0cnJiX8xUtE8aVUUWCopKVW47IgRIzB8+HBs27YN8+fPR3R0NEpKSjB48GCpfnz8u+T8/Hyxafjzvg2QGjVqhGfPnuH06dM4efIk4uPjsX//fuzfvx+tWrVCfHw8c7P4PceUpPj73MjISOybJT5zc3OJ8uzUqRP09fURGxuL7OxsaGpqYu/eveByuQgICBA6HgICAtChQwccPXoUZ8+exaVLl/D333/j77//RlhYGFasWFG1jUPZkzINDQ3k5OTg6dOnaNSoUZXz+lZFx2J1HvP8feTt7Q1DQ0Ox6URd4PPz8wXeeNy9e7fan8hIg78tfn5+Fd481K9fX2haddbp96qOsmhqagIQH0SKoq+vj44dO+LUqVP4+vUr2Gw2AgICKlzme44fcW7cuIEJEyZAU1MTa9asgYeHB4yMjJheRExMTASeWubm5iI6OlooHw8Pj2oN2leuXIk9e/agYcOGWLp0KZycnJjROV+8eAE7Ozux58zquoZJW4akpCSRdTNnzhyJ9klQUBCOHTuGo0eP/rCg/fTp00KDHLm7uzNBO78HIz8/P6Fl1dXV4e3tjcjISFy9elUoaBfHy8sLPXv2xIEDB7Bjxw6MGzcOAHDgwAGml6fyJA3apdmX0lyvJVVZnCJOdfc6VBn+QwUtLS2Jl/khQXtl9PT0oKSkBDk5OURFRUn0VDUvLw9xcXEwNDTEvn37hALAV69eVbj83LlzYWJigiVLlsDT0xPx8fEC3R1VBb8pCb/5R2hoaKXLmJqaIjk5GStWrJCqa6bqZGJigsTERPz3338if9ySvg0QJTAwEOHh4YiKisKcOXOwdetWyMnJYciQIVLlw79Tr2i/8ueJuqtXUlJCz5490bNnTwDA06dPERgYiOvXr2Pr1q0YOXJklY4pY2NjAMJdl/KJms4vn7inHVUhLy+Pfv36MaP48QfJAMS/7dHX18fQoUMxdOhQEEJw5swZ9OvXDytXrsTgwYMlPtF/S05ODt7e3ti/fz92794tVdBuYmICACIvEMD3HYvS4O+joUOHSn1RHj9+PF68eAEfHx9cuHAB4eHh8PT0FBkU1wRTU1MkJiZiypQpaNas2Q9bj7GxMRITE/H27VuRTUfE/UZqkpqaGpSVlZGVlQUejydxMBEUFMSMWNixY0fmdy/O9xw/4hw+fBhAWfeh3z7kKSgowMePHwWmWVhY1Eh3uvxy7dmzR+icUdl1WFZl4Dd5rCp+YC9NMwZp8bstFIffLSb/RvRb/OmZmZlSrZffRWH55kT8825NkeR6XV34NwC5ublCTVxFnbP4bxKTk5OrrQx8/H2lr68v8TIyeawiLy8PDw8P5OTkMP1bViY7Oxs8Hg/GxsZCwVVJSQnzI67I4sWLER4ejoSEBHh6elbLD3DAgAHQ1dWFnp6eRO3kO3bsCAASlfdH4bevFPVqkd+Gs3w6aaiqqiIoKAgfPnzApEmT8PLlS3h5eUn9uorfvOPkyZNiL0THjh2TuJwODg4YNWoUAODJkycAqnZMtW7dGkDZa8W8vDyh+fv37xeaZmpqivr16+PZs2d48eJFpWWVFP942717N16+fInbt2/D0dFRoqCZ34c4f0j3721LGBYWBhaLhbVr1yIhIaHCtOX76q3oWATAjIVQlWOxPP6JWlxfxFX9XR47dgybN29GvXr1EBMTgzVr1qCgoAD9+/cXatJQWRmqS02dY/jNbw4ePCg0Lzs7m2nn/a2aqge+xo0bg8fjISkpSeJlevbsCVNTU+jq6koU7FWlziurB/4FXdRDiX/++adGAnRRKiqXqPPfr1AG/hPwH9FEQlL81gHi2p/zp4traigO/yZH1DdasiLqeg1Uz7mDfwMu6losamyWZs2aQUtLCw8fPpTomxRpysi/VooagVkcmb0LnT59OuTk5DBo0CCRd5i5ubmIjIxEQUEBgLJBADQ1NfHkyRPmAyig7CPCyZMnSxwMLVu2DGFhYXj69Cnat28vdRvDb7Vt2xbp6elIS0uTqGnDhAkToKysjPDwcBw6dEhoflFREQ4cOCD1ACLSGDJkCJSVlbF3716B1/o8Hg/Tpk3D+/fv0axZsyq3deZ/kMpv4zts2DCp8+jduzfq1KmDhIQEzJw5E1wuV2D+xo0bce7cOaipqQk8xc/Pz8fatWuF2ojxeDycPn0awP/unKtyTNnY2KB9+/bIzMzE5MmTBV6nxcXFiR2oaObMmeDxeOjdu7fIwXgyMjKEPuCtTMuWLWFtbY2LFy9i+fLlAER/0Hn//n0cOnQIxcXFAtO/fPnCDKFcvl3y4cOHUb9+fQQHB0tclhYtWmDSpEkoKCiAp6cnTp48KZQmOzsbs2fPRrt27Zhpffv2haGhIa5evSo0yMTatWtx584d1KlT57ufXurp6UFBQQHJyclCxxJQdrw1aNAAu3btwrx584TaTBNCcO3aNYHj5NOnTxg6dCjk5eWZQdUGDRqEXr164d69e5g5c6ZUZaguf/zxBwwMDLB06VJs3rxZ6JVvaWkpzpw5I3AxrIpBgwZBUVERO3bsYEZrBMp+PxMmTBDbJIX/dkXcQGzVjX/Dd/v2bYmXUVFRwdu3b5Gens4MglKRqhw/lR0P/I8yt23bJnAD+OzZM0yePFnibalu/HJt2rRJYDq/icXPWIaEhATs379f6BxJCMHevXuxdOlSsFgsoTceVTlXVhX/KfTKlSuFgsf169fjypUrUFdXl+oD8DNnzjCDDokaxfpHk+Z6DVTPucPd3R0AsGjRIoHf3Z49e0Q+POJwOBg/fjyAstjp27fC2dnZAs2aJD3PFxYW4vHjxzAzM2PedkhE4n5mJACIH1xJlIiICGbgDkdHR+Lr60v69etHWrRowXSPVH4wA/4ATWw2mxkIx8LCgigrK5NRo0YRAGT27NkC6xA1uBIh/+t6sVGjRiK7OBO3ffwuHytT0eBKR44cYbpsqlevHunevTsz2A1/4JH79+8z6fndGH27beXLJa5bLn4XX9/2d7pjxw4iJydHWCwWadOmDQkICGC6MqtocCVxZfgWvz9lIyMjUlJSItEy37p27RrT1VLdunWJn58f6devH1NODocj1FVSZmYmAUAUFBRIy5Ytib+/P/H19RUY9KT8/q7KMfXixQtmcCUbGxsSEBBA3N3diZycHBk9ejQBQDp27Ci0PdOmTWO6NnNyciJ9+vQhfn5+pGnTpoTNZhNNTU2p64jffScAwmKxyH///SeUht8dnaamJmnfvj3p378/6dq1K1FXVyeA4IBnhPxvX0vbFR2PxyPTp08ncnJyzDHZs2dPEhAQQNq2bcsM9mVjYyOwXPnBlZo1a0YCAgKYrkorGlxJXLd/4o757t27E6BsUJoBAwaQIUOGkMjISGb+ixcviKWlJQFADAwMSIcOHUhgYCDp1KkTMTAwIADIqlWrmPRdunQhgHBf2enp6cTY2JjIyckJ9RVdWRnE4W+zuro6adGihdi/u3fvEkLKxsHQ09MjAIiZmRnp3LkzCQwMJJ6ensxvqnw/8lWt0/KDK/EHHLGysiJaWlokKCiIAMKDGq1YsYI5z/j7+5MhQ4aQyZMnM/PFnbMJqVo3ifHx8QRiuuEsvz5+l4+VETe4krTHDyEVHw/p6enEyMiIACCWlpakb9++pEOHDkRBQYH06dOn0q4zReHvRysrK7HHUPmuYUVdWy5dusRct/m/V35/5vyBrL7dPxV11VfZPhV1PFSlDBXhH/+amprE09OTBAYGki5duhALCwvm+P523xFS8bnyxIkTAvXKYrEIAIFp/AF/JFFQUEDatGnDlMfV1ZX06dOHNGjQgLmG7dixQ2AZft2qqqoKDPTTt29f4uTkxFw7Ro4cKXE5ym+3uC4fxXXJ+O0xK+31+v3790RJSYmw2Wzi7e1NBg8eTIYMGUKeP38uUK6K4pSPHz8y129bW1vi5+dHGjduTNhsNhk/frzI7SopKSE9e/YkQNngSu3btycBAQGkTZs2AoMr8UlynuePozNixAixZRVFpkE7IYTcv3+fhISEEHNzc6KoqEi0tLSIg4MDGTx4MDlx4oRQv6PR0dGkadOmREVFhejq6hIfHx/y8OFDsTurogvAmDFjCFA2KmlGRoZE21cdQTshhCQlJZGRI0cSGxsboqSkRNTV1YmdnR3x9/cn+/fvFzm4UnUG7YSUBcXdu3cnurq6REFBgdStW5f8+eef5N27d0JppQ3aZ8yYQYD/DUhSVW/evCFjx44l9evXJ8rKyoTD4RArKysyZMgQoRFzCSn7cW3YsIH4+voSa2troqKiQrS0tEijRo3IX3/9JXI/S3tMEVI2YFFAQADR1dUlysrKpGnTpmTnzp3k6tWrBCgboEaUS5cukT59+hATExOioKBAdHV1SaNGjcjo0aOrNBhIYmIi87v7dgASvtTUVDJ//nzi6elJTE1NiaKiIjE0NCSurq4kMjJSqP/jqgbtfE+ePCGjRo0i9vb2RF1dnSgoKBATExPSvXt3EhMTI7K/5SdPnpCAgABiaGhIFBQUiLGxMQkKCmJOxuVVNcD89OkTGTBgADEyMmIu+N/mkZWVRebPn0+cnJyImpoaUVJSIhYWFsTLy4ts2LCB6Ud/w4YNBCjrX17UAB6nT58mLBaL1K1bV2BwHEnKIEr5wY8q+iu/zampqWTSpEnEwcGBqKioEBUVFWJtbU18fHzI9u3bBcYZqGqdElLWd7qLiwvT37Kvry9JTExk+qz/dlCakpISMmPGDGJtbc0MRlb+/FXdQTshhNja2hJtbW2hgd/Kr+97g3ZCJD9++Co7Ht6+fUsCAwNJnTp1iJKSErG3tyeLFy8mpaWl3xW0V/RXfl+Iu7Zcv36deHp6Em1tbaKurk5at25NDh48KHb/VHfQXpUyVOTz589k7ty5zDmSw+EQZWVlYmNjQwYPHszcDH+ronNl+YF+xP1J2l8+X1FREVmxYgVxcXEh6urqRF5enhgbGxM/Pz+RgwSK66edzWYTAwMD0rlz5yr1QV9dQXtVrtdnzpwhrq6uzDgQ5c9LksYpCQkJpFu3bkRdXZ2oqqoSNzc3cuHChQrPg1wul2zfvp24ubkRTU1NwuFwiIWFBenbt2+VrjX8cW3EHVvisAiRUcM46pdFCIG9vT1evHiBpKQkph/e38HixYsxdepULF68WKavsClKlrhcLho1aoSEhAR8+PChWnrr+h5r1qzBuHHjcODAgR/W+wdFUZQkCgoKYGJiAltbW6aJqqRqT/9e1C/jwIEDSExMRJcuXX7JgL2wsBDPnj0Tmn7x4kUsXLgQ8vLy8Pf3l0HJKKpmJScnC7VHLSoqwqRJk/Ds2TO0b99e5gE7UNbOv27duli8eLGsi0JR1G9u06ZNyMrKwqJFi6Relj5pp6rN0KFDkZWVhRMnTqC0tBQ3b978oV3OycrHjx9hbGwMOzs72NjYQElJCS9fvmQGaFq+fDkmTJgg41JS1I+3ePFizJ49G82aNYOZmRlycnLw8OFDpKamQk9PD1evXoWdnZ2siwkA2LFjB0JCQnD8+PFqG2CPoihKGgUFBbCyskLTpk1FdthQGRq0U9WGxWJBXl4eNjY2mDt3rshBIH4FBQUFmDVrFuLi4vD27Vvk5ORAS0sLzs7OGDNmDDp37izrIlJUjbh9+zZWrlyJGzduIC0tDaWlpahTpw68vLwwdepUsaOlUhRFUdKjQTtFURRFURRF1XK0TTtFURRFURRF1XI0aKcoiqIoiqKoWk5e1gWoTXg8Hj58+AB1dXWwWCxZF4eiKIqiKIr6BiEEX79+hYmJCeTkfp/nzzRoL+fDhw/0wymKoiiKoqifwNu3b2FqairrYtQYGrSXo66uDqDsINDQ0JBxaX4NJSUlOHv2LDp16gQFBQVZF+e3QetdNmi9ywatd9mg9S4btN6BnJwcmJmZMXHb74IG7eXwm8RoaGjQoL2alJSUQEVFBRoaGr/tyUUWaL3LBq132aD1Lhu03mWD1vv//G5NmX+fhkAURVEURVEU9ZOiQTtFURRFURRF1XI0aKcoiqIoiqKoWo4G7RRFURRFURRVy9GgnaIoiqIoiqJqOdp7zHcghIDL5aK0tFTWRam1SkpKIC8vj8LCQnC5XFkX57dB6102aL3LRk3Vu7y8PNhs9m/XYwVFUbUDDdqrgBCCrKwspKWl0QtzJQghMDIywtu3b+mFrgbRepcNWu+yUZP1zmazYWBgAE1NTbqPKYqqUT9F0J6fnw9HR0ekpKRg1KhRWL9+PTNvzpw5+Ouvv0Qut2zZMoSHh1d7eT5+/IisrCymP3d5eXl68haDx+MhNzcXampqv9VQw7JG6102aL3LRk3UOyEEpaWlyMnJQWpqKgoKCmBsbPxD1kVRFCXKTxG0z5o1C2lpaRWmWbVqFfT09ASmNWvWrNrLwuVykZ2dDX19faH1UcJ4PB6Ki4uhpKREg5gaROtdNmi9y0ZN1ru6ujo4HA7S09NhYGAANpv9Q9dHURTFV+uD9nv37mH16tVYunQpJkyYIDZdz549YWFh8cPLU1JSAkIIVFVVf/i6KIqiqNpHVVUVaWlpKCkpoUE79dvjcrl4kHAF6Zmp0NM2RhP7tvR38YPU6qCdy+Vi2LBh8Pb2hq+vb4VBOwDk5ORARUUF8vI/frNocxiKoqjfEz3/U1SZCzcOYcW2sfic8Y6ZZqBriglD1sCzpa8MS/ZrqtVB+6pVq/D8+XMcPHiw0rSNGjXC169fwWaz4eLigpkzZ6Jz584VLlNUVISioiLm3zk5OQDKnqaXlJSIXIb/pJ3H44HH40mxNb8nQgjzX1pfNYfWu2zQepeNmq53Ho8HQshv/6Sdf50Ud72kfozaUu/xNw9j2kp/AERg+ueM95i81A8Lw/bCo0WvH7JuWW+7rNTaoD0lJQWzZ8/GrFmzYGFhgdevX4tMp6WlheHDh6N169bQ1tZGYmIiVq9eja5duyIyMhIDBw4Uu45FixaJ/Ij17NmzUFFREbmMvLw8jIyMkJubi+Li4qps2m/p69evsi7Cb4nWu2zQepeNmqr34uJiFBQU4PLly7TLXwBxcXGyLsJvSZb1zuNxse7gSHwbsJcpm7Z40yjkpslDTq76b2zz8/OrPc+fAYvwH1HUMl5eXvjw4QPu3bsHBQUFvH79GpaWlkK9x4iSkZEBR0dHFBYW4u3bt1BTUxOZTtSTdjMzM6Snp0NDQ0PkMvw8LSwsoKSkVPUN/E0QQvD161eoq6vTV8o1iNa7bNB6l42arvfCwkK8fv0aZmZmv/V1oKSkBHFxcejYsSMUFBRkXZzfRm2o93tPL2H03I6Vpls/Kw5ODu7Vvv6cnBzo6ekhOztbbLz2K6qVT9pjYmIQFxeHy5cvV+mA1NXVxYgRIzBnzhz8+++/6NSpk8h0HA4HHA5HaLqCgoLY9XK5XLBYLMjJyf0WvUNs374dgwYNwsWLF+Hh4SHRMhs3bsTatWuRkpKC4uJiPHz4EAcPHsTcuXORkpJSIx8M/+74TQTk5eUREhKC7du3y7ZAvwl+vfPPEVTNqOl6l5OTA4vFqvBa8Tuh9SAbsqz3rK8V9+hXPt2PKOPverzVuqtKUVERwsLC0KVLFxgZGSEpKQlJSUn477//AADZ2dlISkpCVlZWhfnwA8P09PQfXGKqvIsXL2LUqFGoX78+Nm3ahOjoaOjq6tZoGR48eIA5c+aIbVK1aNEi9OnTB1ZWVmCxWBLdROzcuROurq7Q0NCAmpoaHB0dMW/evOotOEVRFEX9BLJyJIut9LTpWAbVqdY9aS8oKEBaWhpiY2MRGxsrND8mJgYxMTGVDpz08uVLAIChoeEPK+uP8jN3n8RvYxcZGQkdHR3weDzmA9+a8uDBA/z111/w8PAQGZBPmzYNOjo6cHJyqvTmDwAGDx6M6Oho9O7dG0FBQZCTk0NKSgpzI0lRFEVRv4MvWZ+xduckxF6MriQlC4a6pmhi37ZGyvW7qHVBu6qqKv755x+h6WlpaRg5ciS8vb0xZMgQNGrUCKWlpcjLy4OmpqZA2rdv3yIiIgK6urpo3bp1TRW9Wvzs3Sd9/PgRAKCjoyPjkoiXnJwMKysrAICjoyNyc3PFpt22bRuioqKwY8cODBgwoKaKSFEURVG1BpfLxcGzmxCxazpy87MBAM4N2+P24wv/n6L855Fl35WEDVn90zxw/FnUuuYxCgoK8PPzE/rjd99obW0NPz8/2NraIjc3FxYWFhg0aBCWLl2KLVu2IDw8HA0bNkR2djYiIiKgrKws4y2S3IUbhzB5qZ9AwA78r/ukCzcOyahkQGlpKebMmQNzc3NwOBw0atQIe/fuZea/fv0aLBYLUVFRAMralrJYLHh6elaY7+vXrzFgwAAYGhqCw+HA2toa06ZNE/oy/MOHD5gwYQKaNGkCbW1tKCkpoUGDBliyZAm4XC6Tbs6cORg0aBAAoF27dkw5yvcixA/YK0MIwaJFi+Dk5MQE7F+/fkVVvt2+f/8++vTpw2ynmZkZAgICkJyczKTZt28fevTogbp164LD4UBPTw89e/bEo0ePqpwn3/Xr1+Hu7g5VVVXo6upi6NChIm9WUlNT8eeff6Ju3bpQVFSEiYkJhg8fjs+fP0u9zRRFUdTP73HiDYRMcsayLaORm58NO8umiFx0HRv/Ooclkw7AQLeOQHpDXVMsmXTgp3jQ+LOpdU/apaGsrIzevXvj5s2bOHLkCHJzc6Gnp4cOHTpg0qRJcHFxqdHyEEJQWFS1boi4PC6Wbw2F+O6TWFixbSxcGnUAuwrdJylxVL6rV4XJkycjLy8PI0eOBABERUUhICAAhYWFGDhwIPT19bFz505s3rwZV65cwc6dOwEA+vr6YvP877//4OLiguzsbIwcORI2NjaIj4/HokWLcO3aNZw/f54ZKOvRo0c4dOgQevXqBWtra5SUlOD06dOYMmUKXr16hb///hsA4Ovri9TUVGzevBnTpk2Dvb09gLKbPWklJiYiOTkZo0ePxrx587B69Wp8+fIFGhoaCAgIwPLly8X2TFTeiRMn0Lt3b6iqqmLo0KGoV68ePn78iDNnzuDJkydM2davXw9dXV0MHz4cRkZGSE5OxubNm+Hq6op79+7BxsZG4jwtLS2ZtA8ePEC3bt0waNAgBAYGIj4+Htu2bYOcnBw2b97MpHvz5g1atWqF4uJiDBkyBNbW1khKSkJERAQuXryIO3fuCL3VoiiKon5Nmdlp2BAzFUfPbwMAqKtq4c/ABfDt9AfzBN2zpS/cnX1+2ia9P5ta2+WjLOTk5EBTU7PCLoQKCwuRkpICS0tLoa6+Cgrz4BZYeRAnC5d350JZSVXq5fi9x9StWxePHj1igrbs7GxmQKv3798zbzQGDhyI6Oho5mk0v037qlWrhHqP6d+/P3bv3o3Y2Fh06dKFWefEiROxfPlybN26FUOGDAFQ9q2DkpKS0I3HgAEDsHv3brx79w7GxsYCZZakxxt+8xhRH60ePXoUPXv2hL6+PoqLizFjxgxYWlrixIkT2L59Ozw8PHDhwoUKb4by8/Nhbm4OFouF+/fvo04dwScSPB6P6e0iLy8PqqqC+yghIQFNmjTBkCFDsHHjRonzBMqOZ21tbbBYLFy/fh0tWrRg0nTt2hVnz55FZmYmc+Ph4+OD69ev4969ezA1NWXS3rlzBy1btsSMGTMwZ86cCuvzd8c/3jU0NGjvMTWopuu9ouvA76SkpAQnT55Ely5dftvePGThR9c7l8vF0XNbsWHXVOTkZgIAurUbiDEDlkBHy6Da11cVksRrvyJ6VaEk8ueffwo8ZdXU1MSIESOQmZmJ+Ph4qfPj8Xg4duwYmjZtKhCwA8DUqVMhJyeHw4cPM9OUlZWZ4Li4uBhfvnxBeno6vLy8wOPxcOfOnaptWAX4A7WkpaXhwIEDCA8PR+/evREVFYWQkBDEx8fj9OnTFeZx5swZpKenY8KECULBNQCBAIMfsBNCkJOTg/T0dOjr68POzg43b96sUp4A0KpVK4GAHQA8PT1RWlrK3KxkZ2fjxIkT6NGjB5SUlJCens78WVhYoF69ejh79myF20pRFEX93J6+vI1BU1pi0d8jkJObCRvzRti64Cpmj4mqNQH77+ynbh5T2yhxVHB5t/iPGity/9lljJ3fpdJ0a2acRNMGblLnr8QRPcKrpPjNTMpr0KABAODVq1dS55eWlobc3Fw4ODgIzdPR0YGxsbFAvqWlpVi8eDF27NiBpKQkoXblmZmZUpehMvy3B3Xq1EGHDh0E5oWEhCA6Ohrx8fHM9xai8Hsxatq0aaXru3//PmbOnIn4+Hjk5eUJzCvf3EWaPAHRbfj53XBmZGQAKGsKxOPxsG3bNmzbtk3ifCiKoqifX9bXDETsmo7DcZtBCIGqigZGBMyDn/dIyLNpqFhb0D1RjVgsVpWaoABAi8adYKBris8Z7yG6XXtZ90ktGnf6LduKhYWFYd26dejXrx+mT58OAwMDKCgo4N69e5g8eTLTJKQ68ZuIGBkZCc3jN8WprpuFN2/ewM3NDRoaGpg5cybs7OygqqoKFouFcePGVdjDTWUqOl74Nz/8/wYFBSEkJERk2p/po26KoiiqcjweD8cvRGHdzsnI/lr2EKezexBCByyFng7tY722oUF7LcFmszFhyBpMXuqHsu6Salf3SQkJCfDx8RGY9uzZMwBVewKrr68PdXV1PH36VGheZmYmUlNT0aRJE2bazp074ebmJtBjDQAkJSUJLV9dw5g3bNgQSkpKeP/+vdC8d+/KevgxMKj4daGtrS2Aso9BxY3MCwCHDx9Gbm4ujh07hnbt2gnMy8jIEBi5V9I8pVGvXj2wWCwUFxcLvVWgKIqifj3Pk+9hyeaRePKyrPmllZkDJg/fCCcH6d/mUzWDtmmvRTxb+tba7pMiIiKQnZ3N/Ds7OxubNm2ClpYW3N3dpc5PTk4O3bt3x/3794XahS9evBg8Hg+9evViprHZbKEmMXl5eVi1apVQ3vwPK798+SJ1ucpTUVFB79698fHjR4H29UBZfQAQao//rU6dOkFPTw8rVqxAamqq0Hz+NvFvxr7dxi1btjB930ubpzR0dXXRpUsXHDp0CDdu3BCZZ1qaZMNWUxRFUbVXTm4mlmweheBJzfHk5U2oKKlh3MAV2LXiPg3Yazn6pL2Wqa3dJ+np6aFFixZMH+hRUVF48+YNtm7dChWVqrWXX7hwIeLi4tCzZ0+MHDkS9erVw+XLl7Fv3z64ubkJNNPw8/PD33//jX79+qFDhw749OkTIiMjmbbZ5Tk7O0NOTg4LFixAZmYmVFVVYWlpyXyMuXPnTmY007S0NBQXF2P+/PkAAHNzc4FBlBYuXIhz584hMDAQY8aMgYWFBU6ePInY2FgEBwdXOniXiooKtm3bBj8/Pzg6OjLdM6alpeHMmTMICwuDj48POnfuDBUVFQwYMACjR4+GtrY2rl27hpMnT8La2hqlpaVS5dm9e3ep90dERATatGkDNzc3BAcHo2nTpuDxeHj16hWOHj2K4OBg2nsMRVHUT4rH4yE2fgfW7ZiEzJyyhzBebQMwNmQ59HVMZFw6SiKEYmRnZxMAJDs7W2yagoIC8uzZM1JQUFCDJZOdqKgoAoDExcWRWbNmETMzM6KoqEgcHR3Jrl27hNKHhISQ8ocVl8slmZmZZNasWQQASUlJEUj/6tUrEhQURPT19YmCggKxtLQkU6dOJXl5eQLp8vLySHh4OKlbty7hcDikXr16ZNGiReTcuXMEAImKihJIv337dmJvb08UFBQIABISEsLMc3d3JyhrfyT05+7uLrRNKSkpJDAwkOjp6REFBQVSv359snz5csLlciWux5s3bxIfHx+iq6tLFBUViZmZGQkMDCTJyclMmkuXLhFXV1eipqZGNDU1SZcuXcjjx4+Ju7s7MTc3lypPfr1/u+18/P168eJFgelpaWkkPDyc2NjYEA6HQzQ1NYmjoyMJDQ0lT58+lXh7f1f8epfm2KC+X03X++92HRCnuLiYHDlyhBQXF8u6KL+VqtR74qsHZMhUV9K8F0jzXiB9xtiTW4/O/8BS/liSxGu/ItpPeznf2087JYz2Wy0btN5lg9a7bNB+2mWD9tMuG9LUe25eNjbtnYV/Tq0Hj8eDspIqhvaZhYBu46CgoFhDJa5+v2s/7bR5DEVRFEVR1C+EEIJTl3dhTXQ4vmR9AgB0aN0HYweugJGemYxLR1UVDdopiqIoiqJ+EUn/PcHSLaNw/9llAEBdE1tMHLoOLZtUT29jlOzQoJ2iKIqiKOonl5ufgy37/sK+2DXg8rjgKCpjSJ+Z6N8jDIoKnMozoGo9GrRTFEVRFEX9pAghiLu2D6uiwpCeWdYNsEeLXggbtArGBuYyLh1VnWjQTlEURVEU9RN69fYZlm0ZjTtPLgIATI2sET50HVydOsu4ZNSPQIN2iqIoiqKon0hxSQE27JqKvbFrwOWWgqOohIG+0zCg50RwFH/fHo1+dTRopyiKoiiK+gkQQnDh+gFEHBmDr/kZAIC2zbtjwpA1qGNoKePSUT8aDdopiqIoiqJqudfvE7F86xjcfBgHADAxsMSEIWvg5iz9CNjUz4kG7RRFURRFUbVUQWEeIg8sQMyx5SgtLYGiAgctGvTE3PDNUFP9fQYWomjQTlEURVEUVesQQhB/8whWRo7Dx/Q3AIDWTp0xLmQFHt17AY6isoxLSNU0GrRTFEVRFEXVIm9Tk7B8Wyj+vXcKAGCkVxcThqyBu4sPSktL8QgvZFxCShZo0E5RFEVRFFULFBYVYPuhRdhxeAlKSoshL6+AAT4TMdhvOpQ4KrIuHiVjcrIuAFW7xcfHg8ViYfv27bIuSq3k4eEBCwsLWReDoiiK+sldvn0c/cY2wLZ/5qGktBgtGnfE3tVPMLL/AhqwUwBo0E7VgIiICImD/oiICLBYLLBYLKSnp//YglEURVGUjL3/lILxC7tjwqIe+PD5NQx0TbFk4gGsm3UG5ia2si4eVYvQ5jG1EJfHxdOUK/iSkwodDWM4WLYFW44tk7K4ubmhoKAACgoKVc4jIiICVlZWGDx4cIXpPnz4gClTpkBNTQ25ublVXh9FURRF1XZFxYXYcWQpog8tQlFxIdhsefTvMQFD/GZARVlN1sWjaiEatNcy1x4fwuajY5Ge/Y6ZpqdpiuE+a+Da0LfGyyMnJwclpZoZXW3UqFGwtraGg4MDYmJiamSdFEVRFFXTrt07heVbx+Ddx2QAQPOGnpg0bD0sTe1lXDKqNqPNY2qRa48PYeEOP4GAHQDSs99j4Q4/XHt8qMbLJKpNe/lpUVFRcHBwAIfDgbm5OZYuXSqwPJvNxtu3b3Hp0iWm2QuLxcLr168F0h0+fBjHjh3Dpk2bwGZL/1bh48ePCA0NhZWVFTgcDgwMDNCxY0fExcUxaW7duoWBAwfC1tYWKioqUFdXh6urKw4fPlzlPPk+fPiAgIAAaGtrQ0VFBV5eXnjxQvjr/qKiIixcuBAODg5QUlKClpYWunfvjvv370u9zRRFUdTPJfXzf5i4uBfGze+Cdx+Toa9jggVhe7FxzjkasFOVok/aqxEhBEUl+VValsvj4u8joQCIqJwBsPD30bFoYtOhSk1lOAoqYLFYVSqbOJs2bcKnT58wZMgQaGlpISYmBpMnT4apqSkCAwMBANHR0QgLC4O+vj6mT5/OLKuvr8/8f05ODkaPHo0//vgDLi4u2Lhxo1TleP36NVxdXfHp0ycEBwejefPmyMvLw40bN3Du3Dl07NgRQNmNwfPnz9G3b1+Ym5sjIyMD0dHR8PX1xa5du5gyS5MnAOTl5cHNzQ0tW7bEwoULkZKSgjVr1sDHxwdPnjxhbkJKSkrg7e2Nf//9FwMGDMDo0aORnZ2NLVu2wNXVFZcvX0bz5s2l3xEURVFUrVZcUoRdR1dg24H5KCouAFuODf9u4zCs32yoKqvLunjUT4IG7dWoqCQfvaf/qHZoBBnZ79B3pmaVlj64IBdKiqrVWqI3b94gISEBmpplZRo8eDDMzc2xbt06JgAOCgrCjBkzYGhoiKCgIJH5TJ48GTweD4sWLapSOUaOHIkPHz7g9OnT8PLyEpjH4/GY/58xY4bQOkJDQ9G0aVPMnz9fIGiXNE8ASE9Px8SJEzFp0iRmmr6+PiZNmoRz584xy69fvx7x8fFCeY4cORKOjo4IDw9HfHx8leqAoiiKqp1uPDiLZVtG403qSwCAk4M7Jg5dj3rmjjIuGfWzoUE7VWWDBg1iAnYAUFFRQcuWLXH9+nWJ87h27Rr+/vtv7Nq1SyAvSX358gWnT5+Gt7e3UHANlLXJ51NV/d9NS35+PgoKCkAIgaenJzZt2oScnBxoaGhIlSf/36GhoQLTPD09AQAvX75k8oiJiUH9+vXRrFkzoZ5xOnbsiOjoaBQUFEBZmY5yR1EU9bP7mP4Wq6PCcP76AQCAjpYhxoWsgLdbYLW/+aZ+DzRor0YcBRUcXFC1Xk+evLqM2du6VJruryEn4WjlJnX+HIXq7+PVyspKaJquri4yMjIkWr64uBjDhw9Hhw4dEBAQUKUyJCUlgRCCpk2bVpr28+fPmDFjBo4ePYrPnz8Lzc/KyoKGhoZUeQKAiYmJ0Me6urq6ACBQFwkJCSgoKBBoGvSt9PR0mJmZSbReiqIoqvYpKSnG7uOrsPWfuSgsyoecnBz6dh6DP/z/gppq1d6WUxRAg/ZqxWKxqtwEpaltJ+hpmiI9+z1Et2tnQU/LFE1tO8ms+8dvVeWD0fI2bNiA58+fY8WKFUhKSmKmf/36FQCQkpKCnJwckTcH0iKEoFOnTkhISMDYsWPRvHlzaGpqgs1mIyoqCrt37xZq9iKpiuqBECLw/w0bNsTKlSvFpq8ooKcoiqJqt9uPL2Dp5lF4/f45AKBxfVdMGrYBtpaNZVwy6ldAg/Zagi3HxnCfNVi4ww8AC4KBe9lrtOE9VteagF0a4l4D/vfff+DxeOjcubPI+S4uLlBVVa2wz/Z69eqBxWLhwYMHFZbh0aNHePjwIWbNmoW//vpLYN7WrVurlKe0bGxskJaWBk9PT6EmNhRFUdTP63PGe6yJDsfZq3sBANoa+ggNWYYu7gPo+Z6qNvRIqkVcG/piWvAB6GnWEZiup2WKacEHZNJPe3VQVVXFly9fhKYPGjQI//zzj9Cfh4cHACAyMrLS/tp1dHTQuXNnnDp1CufOnROaz3/SzX8aXv7JNwA8efJEqMtHSfOUVnBwMD5+/Cj2SfunT5+qlC9FURQlG6WlJYg5ugJ9xtTH2at7/78pzGgc3PAC3dqF0ICdqlb0SXst49rQFy0dfGrNiKjVwdnZGTt37sTMmTNhb28POTk5dO/eHY0bN0bjxsKvDE+cOAEA6N69O/T09CrNf/369WjdujU6d+6MkJAQNGvWDAUFBbh58yYsLCywZMkS2Nvbw8HBAUuXLkV+fj7s7Ozw4sUL/P3332jYsCHu3r0rdZ7SGjt2LOLi4jBx4kRcuHABnp6e0NDQwJs3b3D+/HkoKSnh4sWLUudLURRF1by7Ty9h6eZRePX2KQCgoW1LTBq2AfWtnWRcMupXRYP2Wogtx0Yjaw9ZF6PazJgxA1+/fsWGDRuQlZUFQghSUlIEenP5HpaWlrhz5w7mzZuHkydPYseOHdDW1kbjxo0xfPhwAGVP2mNjYxEeHo7o6Gjk5eXB0dER0dHRePjwoVDQLkme0lJQUEBsbCw2btyInTt3Yvbs2QDKPmR1cXFBSEjI91UERVEU9cOlf0nFmh0TcfryLgCAloYexgxYgm7tBtIn69QPxSJVfdf/C8rJyYGmpiays7OhoaEhMk1hYSFSUlJgaWkp1GMIJYzH4zFdKdKTWc2h9S4btN5lo6brnV4HypSUlODkyZPo0qULFBQUZF2cH66UW4p/Tm3A33tnIS8/BywWC76d/sCfgQugqa5TY+X43epdFEnitV8RfdJOURRFURRVgQcJV7F08yi8/O8RAKBBPWdMHr4RDerRUaypmkODdoqiKIqiKBEysj5h3c7JiL0YDQDQVNPByKBF8Gk/5Lu7PaYoadGgnaIoiqIoqhwul4uDZzchYtd05OZnAwB8OgzF6KBF0NKovIMEivoRaNBOURRFURT1/x4lXsfSzaOQmHIfAFDfygmThm1AQ7uWMi4Z9burUtD+8eNHnD59GpcuXcKDBw+QlpaGrKwsaGlpQV9fH02aNIG7uzu8vb1hZGRU3WWmKIqiKIqqVpnZaVgfMwXHzkcCANRVtfBn4AL4dvqDNoWhagWpgvYzZ84gIiICJ0+eBJfLFRpkJj8/Hx8+fMDDhw+xY8cOsNlsdO3aFX/++Sc6depUrQWnKIqiKIr6XlwuF0fObcHGXdOQk5sJAOjWbiDGDFgCHS0DGZeOov5HoqD9zp07CA8Px5UrVwAAbdq0gYeHB1xcXFC/fn3o6OhAQ0MD2dnZyMzMREJCAm7duoWLFy/i2LFjOHbsGNzc3LB8+XI0a9bsh24QRVEURVGUJJ6+vI0lm0ciIfkOAMDGojEmD9uAxvauMi4ZRQmTKGh3cXGBoaEhFi5ciP79+8PU1FRkOh0dHejo6MDa2hrdunUDALx9+xYxMTFYu3YtXFxcwOVyq6/0FEVRFEVRUsr6moGIXdNxOG4zCCFQVdHAiIB58PMeCXk2/dyPqp0kOjJXrVqFP/74o0qDSJiZmWHq1KkYP348/v77b6mXpyiKoiiKqg48Hg/HzkdifcwUZH/NAAB0cR+AMcFLoadNv8GjajeJgvaxY8d+94qUlJSqJR+KoiiKoihpPU++hyWbR+LJy5sAAOu6jpg0bAOcHNxkXDKKkgx9B0RRFEVR1C8rJzcTEbtn4OCZCBBCoKKkhj8C5qJv59GQl1eQdfEoSmJy1Z1hRkYGCgoKqjtb5Ofnw8rKCiwWC6NHjxaan5iYiJ49e0JbWxuqqqpo27YtLly4UO3loCiKoiiq9uPxeDh+YTv8RtvhwOmNIITAq20ADqxPRGD38TRgp346UgXtR44cQVhYGEJDQxEREYHc3FwAACEEc+bMga6uLgwMDKCuro4OHTrg+fPn1VbQWbNmIS0tTeS85ORktG7dGtevX8ekSZOwbNky5ObmwsvLC+fOnau2MvyOtm/fDhaLhfj4eImX2bhxI+rXrw8OhwM2m403b97gr7/+AovFwuvXr39YWSlhbDYbAwcOlHUxKKraVOWcRP1+ElMeYNj0tpi7fhAyc9JgaWqPiL8uYP743dDXMZF18SiqSiQK2rlcLrp164bevXtjzZo1WL9+PUaPHo2GDRsiNTUVoaGhmDt3LjIzM0EIAY/Hw4ULF+Dh4YHPnz9/dyHv3buH1atX46+//hI5f+rUqcjKysKZM2cwdepUjBw5EleuXIGJiQlGjRol1J889eNcvHgRo0aNQv369bFp0yZER0dDV1e3Rsvw4MEDzJkzR+wNwqJFi9CnTx/mzY2FhUWlee7cuROurq7Q0NCAmpoaHB0dMW/evOotOCXSwIEDwWKxRP4dOHBAKH1RURFmzZoFS0tLcDgcWFtbY/78+SgpKRFIV1paimnTpsHU1BQ6Ojrw9/cX+WDg9u3bUFRUxI0bN37YNlIUVT1y87KxfNtYBE9shkeJ/0JZSRWhwUuxa8UDNG/YTtbFo6jvIlGbdv6ASsrKyvDz84OBgQFu376Ny5cvY9KkSdi3bx+6dOmCpUuXwtLSEq9evcLEiRNx+vRprFixAkuWLKlyAblcLoYNGwZvb2/4+vpiwoQJAvPz8vJw7NgxeHh4oEmTJsx0NTU1DB06FLNmzcLt27fh4uJS5TLUNB6PixepV5CVnwotFWPYGreFnNzPMRpbXFwcACAyMhI6Ojrg8XjIycmp0TI8ePAAf/31Fzw8PEQG5NOmTYOOjg6cnJyQlZVVaX6DBw9GdHQ0evfujaCgIMjJySElJQX//fdf9ReeEmvnzp1C00T9rvv164ejR49i8ODBaNWqFa5fv46ZM2ciKSkJ27dvZ9KtWrUKy5Ytw8SJE2FgYIDFixdj8ODBOH78OJOmtLQUw4YNw4gRI9CyJR3CvDYYMGAA/P39oaioKOuiULUIIQSnLsVgzY6J+JL1CQDQoXVfjBu4AoZ6oruppqifjURB+65du8Bms3HlyhU4OTkx08PCwrB69Wro6upi3759UFVVBQA4ODhg//79sLCwwMmTJ78raF+1ahWeP3+OgwcPipz/6NEjFBUVoVWrVkLz+BfZnylov/PqEHZfG4vMvHfMNG1VUwS6rkFzK18ZlkwyHz9+BFDWZ39tlZycDCsrKwCAo6Mj08xLlG3btiEqKgo7duzAgAEDaqqIv5SBAwciPj7+u5tGBQUFVZrm5MmTOHr0KMLCwrBixQoAwNChQ6GlpYWVK1di+PDhaN26NQDg0KFD6N+/PxYuXAgA0NTUxNChQ1FYWMh0b7t8+XJ8+fIFCxYs+K6y/0pKSkrA5XKr1AVwdWCz2XRIeUpA0n+PsXTLKNx/VjYAZF0TW0wauh4tmnSUcckoqnpJ1DwmISEBrVu3FgjYAWDMmDEAgObNmzMBO5+amhqcnZ2RkpJS5cKlpKRg9uzZmDVrltgmDB8+fAAA1KlTR2gef9r79+9FLltUVIScnByBP6DsolTRH78JUHX/3U4+gA1n/QQCdgDIzHuPDWf9cDv5wA9Zb2V/AFBcXIzZs2fD3NwcHA4HjRo1wu7du5k0r169AovFQlRUFAAwzRfatSt7HclvovRt3q9evUJQUBAMDQ2ZpgxTp05Fbm6uQLp3794hLCwMTZo0gba2NpSUlNCgQQMsXrwYJSUlTLrZs2dj0KBBAIB27dox5QgJCWHSWFhYCGybqHLxeDxwuVwsWrQITk5O6N+/P3g8HrKzs8HlcqWuw7t378LPz4/ZTjMzM/j7++Ply5dMmj179qB79+6oW7cuOBwO9PT04OPjgwcPHkidZ/kmYYQQXLt2De7u7lBVVYWuri6GDBmCnJwcoTzfv3+PESNGoG7dulBUVISJiQmGDRuGjx8/Vvn4EbfvpV2ey+UiKysLpaWlYtPu2rULABAaGiowPTQ0FEDZ03r+tIKCAmhrazP/1tLSAo/HQ35+Png8Hl68eIG5c+di/fr1UFVVlaqshBAUFhZiyZIlaNKkCVRUVKCpqYnmzZtj3bp1VfoNzJ49GywWC0+ePMHYsWNhbGwMFRUVtG/fHgkJCeDxeDhw4ACcnJygrKwMCwsLbNq0SaiM/N/D2bNn0bJlS6ioqMDIyAihoaFCxwR/nY8fP8b48eNhamoKJSUl/Pvvv0wdLliwAA4ODlBSUoKWlha6deuGu3fvCuRTWlqKVatWoVGjRlBXV4eGhgbs7OwwePBgFBUVMemuXr0Kb29vGBkZQUlJCXXq1EHnzp2Z9fF4PERGRoLFYuHChQsC9Z6RkYHRo0fDzMwMioqKMDMzw8iRI5GWliZQFv7y586dw7Jly2BtbQ0OhwNbW1tERUVJdVxWdq34Hf4kuWb+qL+s7Aws3zYOQROa4v6zK+AoKmOE/zzsWHoXTg4eMq+bX7Xea8vf70iiJ+05OTkwNzcXml63bl0AgJGR6AEJDA0Nv6snmREjRsDKygphYWFi0+Tn5wMAOByO0Dz+kyB+mm8tWrRIZDv5s2fPQkVFReQy8vLyMDIyQm5uLoqLiwXmEUJQzBW9rsrwCBe7roYCENX+ngBgYdfVsTDVcIEcS/qnTIpsFbBYLKmXKywsBABMmjQJ+fn5TEC8e/du9O/fH1lZWQgMDASHw2HasF+/fh2bNm0CABgYGAAAU1e5ubnMzdGbN2/Qvn175OTkYMiQIbCyssK1a9ewePFiXL58GUePHoW8fNkheuPGDRw8eBDdunVD//79UVpaivPnz2Pq1Kl4/vw5Vq9eDQDo2LEj/vvvP0RHRyMsLAy2trYAAEtLS5HNdPgBuKh5L168QHJyMoYNG4aZM2ciIiICmZmZUFdXR+/evTFv3jyoqalVWoenT59GSEgIVFRUMGDAAFhZWeHz5884f/48bt++DX19fQDA2rVroaOjg+DgYBgYGCAlJQXR0dFo27Yt4uPjYW1tLXWeQNk3Id27d0f//v3Rs2dPXL16FZGRkeByuUy9AWWjF3t5eaG4uBhBQUFMU7eoqChcuHABFy5cgKamZqXb+62SkhKxdSzp8gCgra2Nr1+/QlFREa1bt8b06dPRvHlzgbS3bt2CiYkJNDU1BdanqakJY2Nj3Lx5k5nu5OSEPXv2wMvLC7q6uliyZAns7OwgJyeHnJwcplmem5ub1GXPyMhA7969cfXqVXh6emLq1KngcDh49uwZ/vnnH+atjTS/gaKiIgBAcHAwVFVVMX78eKSnp2PDhg3w8vLCtGnTMGfOHAwePBj+/v6IiYnBn3/+CXNzc6E3kXfu3MHBgwcRHBwMPz8/XL16FevWrcPDhw9x+PBhyMnJCawzMDAQysrKGDlyJFgsFtTV1ZGRkQFfX1/cunUL/fr1w+DBg5GTk4MdO3agbdu2iI2NRdOmTQEAy5Ytw8KFC+Ht7Y3g4GCw2Wz8999/OH36NNLS0qCmpoaXL1/Cy8sLBgYGGD58OAwMDPD582fcuHEDN2/eRIMGDQD875yUn5/P7Jfs7Gx4eXkxN0CNGjXC48ePsWnTJpw/fx7nzp2Durq6wPJTp05FQUEBgoODweFwEBkZicGDB8PY2LjSplDFxcUoKCjA5cuXUVpaKtWx8SviN4usKYQQPE25gnN3opBbkAkAsKvbEp2ch0CTo49zcedrtDyyUtP1XpuIi+t+eUQCLBaLDBo0SOp5AwcOJHJycpKsQsjOnTsJi8UiV65cYaalpKQQAGTUqFHMtAMHDhAAZOPGjUJ5PH36lAAgU6dOFbmOwsJCkp2dzfy9ffuWACDp6emkuLhY5F9OTg55+vQpycvLI1wuV+AvvzCHDIxArfzLL8wRKq8kf9u2bSMASN26dcmXL1+Y6V++fCF169Yl2traJDc3l5keHBxMADD/Li0tJZmZmWTmzJkEAElOTmbmBQQEEADk+PHjAuucMGECAUA2b97MTMvNzSWlpaVC5evfvz+Rk5Mj7969Eyrz+fPnK90+BwcHYm5uLnLeoUOHCACir69PNDU1ydKlS8n+/ftJSEgIAUA8PDxElqn839evX4menh7R19cnb968EZpfUlLC/H9OjvA+evLkCVFUVCQjRoyQKk9+vQMgLBaL/PvvvwJpOnfuTOTl5Ul2djYzrXv37kRfX5/8999/Amlv3rxJ2Gw2mTVrVpWOoeDgYLF1LMnfpEmTyLhx48iOHTvIwYMHyezZs4mWlhZRUFAgZ86cEUirpqZGXFxcRObj7OxMjI2NmX+npqYSZ2dngrK7YmJsbEyuXLlCuFwu2bp1K9HW1iYfPnyQqqz8el+0aBEBQKZMmVLhPpfmNzBr1iwCgHTt2lXguFu9ejUBQNTV1cnr16+Z6R8/fiQcDof069dPIG/+9h48eFBg+pgxYwgAsmvXLqF1uru7k6KiIoH0K1asIADIyZMnBaZnZmYSMzMz4u7uzkxr2rQpsbe3r7Du+Ntx/fr1CtOJ+n1PmTKFACDr1q0TSLtu3ToCgEyfPl1o+SZNmpCCggJm+ps3b4iioqJQfYn6y8vLI0+fPiU5OTlirxW/w19eXh45cuQIycvLq7F1Jr56QIbP8CDNe4E07wXiM8KaXLp5TOZ18avXe237S09PJwBIdnZ2lWLMn1WtHFypqKgIYWFh6NKlC4yMjJCUlATgf81csrOzkZSUBD09PZiYmAjMK48/TVTTGaDs6byoJ/QKCgpQUBDdfyuXywWLxYKcnBzzNIrv23/XJqLKK+lyAPDnn39CW1ubma6trY0RI0Zg2rRpuHz5Mjp37gwAzNN8/nL8Jijlp8vJyYHH4+H48eNo2rQpunXrJrDOadOmYdWqVTh69CiGDRsGAALNr4qLi5mmA97e3ti1axfzNLn8uqXZZlHp8vLyAABpaWmIi4tDhw4dAAB9+vQBAERHR+Ps2bPMtosSFxeH9PR0LF68GGZmZhWul/8kkBCCr1+/ori4GIaGhrCzs8OtW7eYtJLkWb7pT6tWrYSetLZv3x6nTp3Cmzdv4OjoiOzsbMTGxmLQoEFQUVHBly9fmLRWVlaoV68e4uLixPbgxJefny/0BKS4uBg8Hk8gT6DsdybJk/tvv4nx9fVF//790aRJE4waNQovX74UWD+HwxG5P5WUlJCfn8/MMzIywo0bN5CYmIj8/Hymicfnz5+ZrmONjY1x8OBBLFiwAJ8/f4aHhwfzRkQUfr3v2bMH2tramD17ttjzhLS/Af5vaOzYsQJtut3cykZz7NGjh8AbUf6xk5SUJFQGOzs7+PoKfiMzdepUrFu3DkePHkVgYKDAOseNGyf04eeuXbtQv359ODs7C+3bjh07Ijo6GkVFRVBWVoampiaSk5Px77//ok2bNiLrTktLCwBw/PhxNGnSRGybeVG/76NHj0JPTw/Dhw8X2NYRI0Zg7ty5OHLkCObPny+w/MiRIwXWYWZmBltbW5H1JaoMLBarwmvF76Qm6iG/IBdb/5mL3cdXgcstBUdRCYN6T0eQTzg4irL5vkLWfufj73fdbomD9qSkJOzYsUOqefxgW1oFBQVIS0tDbGwsYmNjhebHxMQgJiYGy5Ytw4gRI8DhcHD9+nWhdPwu2r59hf6jKMqrYNMQ8R81ViQx9TJWnexSabrxXU7Czlj6IZcV5UU395GUvb290DT+6+pXr15JnV9aWhpyc3Ph4OAgNE9HRwfGxsYC+ZaWlmLx4sXYsWMHkpKShLrxzMzMlLoMlVFWVgZQdtPHD9j5QkJCEB0djfj4+AqDdn5AyW8mUJH79+9j5syZiI+PZ24Y+CwtLauUJwDmo9vy+N1wZmRkACgbnIzH42Hbtm3Ytm2bxPl8a+nSpWID+/JNdgDA3d29yn1t29jYoG/fvti+fTtevHjBNINSUVFhmnR8q7CwUKjZm5ycnNCxPXbsWDRq1AiDBw/GzZs30adPH6xduxYuLi4YPXo0goKCcPLkyQrL9/LlywoDT0D63wDft/uBfzNd/hgpP09UL0eifs/GxsbQ0tISuU5+/ZaXkJCAgoICof1aXnp6OszMzLBw4UL07NkTbdu2hYmJCTw8PNC1a1f4+fkxNwP8Jj0LFy7EqlWr0LJlS3h5ecHf319k88zyUlJS0KRJE6YpEZ+8vDxsbW1x7949oWXE/S5or1C1CyEE568fwKrI8fj8pexBnJtzD4QNXo06hsLHPEX9yiQO2q9du4Zr166JnHf16lWR8wghVWpHraqqin/++UdoelpaGkaOHAlvb28MGTIEjRo1gpqaGrp3745Dhw7h4cOHaNy4MYCyttNbt26FjY1NjfUcw2KxwFFQrTyhCI6mnaCtaorMvPcQ3a6dBR1VUziadvppun+sTmFhYVi3bh369euH6dOnw8DAAAoKCrh37x4mT54s8GS5upialnUTJuqbDWNjYwDVd7Pw5s0buLm5QUNDAzNnzoSdnR1UVVXBYrEwbty4Cnu4qUxFPW2Qch9OAmU9tISEhIhMy7+JqUhwcLDQk9Rly5bh4cOHiImJEZhe/s1NVfA/Tk9PT2eCShMTE7Efnr9//17sWze+kydP4siRI3j06BFYLBa2bduG1q1bM6MwL1y4EB07dkRqaipzDNQ0cftT3PRvb3CrQtQ3PoQQNGzYECtXrhS7HD+gb9WqFZKTk3HmzBlcvHgRFy9exO7duzF//nxcvXoVOjo64HA4iIuLw61bt3DmzBlcvnwZs2bNwpw5c7B792706tXru7ejvB9ZX1T1eP0+Ecu2jMatR2WDJJoYWiJ8yFq0bd6tkiUp6tckUdAu7iL+oygoKMDPz09oOr/LOGtra4H5ixYtwvnz59GpUyeMHz8eGhoa2LJlC96/f4/Y2Ngq3TjUNDk5NgJd12DDWT8ALAgG7mXlD3BdLbOAPSEhAT4+PgLTnj17BkCyJ7Df0tfXh7q6Op4+fSo0LzMzE6mpqQL97u/cuRNubm7Yu3evQFpRb3Oqa383bNgQSkpKIoPAd+/Kevjhf2grDj+YfPDgATp16iQ23eHDh5Gbm4tjx44xPe7wZWRkCDTjkjRPadSrVw8sFgvFxcVCbxWkYWVlJXQ8xMTEIDEx8bvyFYX/xsHQ0JCZ5uzsjF27duHt27cCTYfevn2LDx8+oEePHmLzy83NxZ9//omZM2fCxsYGQNl+Lp8P///fvn1bYdBua2uL58+fo6ioSGQTPED630B1SkhIEJqWmpqKrKwsiX/PNjY2SEtLg6enp0TN0NTU1NC7d2/07t0bQNnIyaNGjcK2bdswceJEJp2LiwvzoOXt27do2rQpZsyYUWHQbmVlhaSkJJSWlgo04yktLcWLFy+qdI6iZKegMA+RBxYg5thylJaWQFGBg5BeUxDcazKUOJU/PKCoX5VEDX6joqK+6+9Hq1evHq5du4aWLVti8eLFCA8Ph6qqKk6fPg0vL68fvv7q0tzKF6M6HYC2quDTQB1VU4zqdECm/bRHREQgOzub+Xd2djY2bdoELS0tuLu7S52fnJwcunfvjvv37+P06dMC8xYvXgwejydwkWaz2UJPwPLy8rBq1SqhvPk9unzbzlZaKioq6N27Nz5+/IjDhw8LzIuIiAAAdOlScZOmTp06QU9PDytWrEBqaqrQfP428Z/6fbuNW7ZsYfq+lzZPaejq6qJLly44dOiQyJE/CSEiRwv90fLy8pjePsq7f/8+/vnnH9jb2wv0qhMQEAAAAr3ilP93//79xa5rxowZ0NTUFAggTUxM8OTJE+bfjx8/ZqZXJDAwEJmZmUw76vL4+0fa30B1SkxMxJEjRwSm8b8d6Nmzp0R5BAcH4+PHj2KftH/69In5//T0dKH5/C6E+b9TUWlMTU2hr69f6W/Zx8cH6enp2Lp1q8D0LVu2IC0t7YfVI1W9CCG4eOMw+oY2wPZDi1BaWgJXpy7Yt+YphvvPoQE79durlR+iimNhYSE2ILG3t8fRo0druETVr7mVL5wsfGrdiKh6enpo0aIF0+VjVFQU3rx5g61bt4rtHrMyCxcuRFxcHHr27ImRI0eiXr16uHz5Mvbt2wc3NzeBNzx+fn74+++/0a9fP3To0AGfPn1CZGQk0za7PGdnZ8jJyWHBggXIzMyEqqoqLC0t0aJFCwBlT+357VbT0tJQXFzMBFfm5uYCgygtXLgQ586dQ2BgIMaMGcMMGBYbG4vg4GBmoB5xVFRUsG3bNvj5+cHR0RFDhw5FvXr1kJaWhjNnziAsLAw+Pj7o3Lkz033j6NGjoa2tjWvXruHkyZOwtrYW6FZOkjz5H+VKIyIiAm3atIGbmxuCg4PRtGlTph/xo0ePIjg4GHPmzJE63+/x8uVLdO7cGT179oSNjQ1UVVXx8OFDREZGgs1mY/PmzQLpu3btim7dumHlypXIzs5mRkTdtm0bgoKCxH4EeevWLWzcuBFXrlwR+MApKCgI27ZtQ3BwMJydnbF48WK0a9eOaTolTmhoKE6cOIH58+fj9u3b6NSpE5SUlPD06VMkJibi3Lmy1/3S/AaqU8OGDREUFIRhw4bBxsYGFy9exIEDB+Du7o5+/fpJlMfYsWMRFxeHiRMn4sKFC/D09ISGhgbevHmD8+fPQ0lJCRcvXgRQdn5u2bIlWrRoARMTE6SmpmLz5s1QVFSEv78/AGD+/Pk4e/YsunXrBktLSxBCcPz4cTx//hyTJk2qsCwTJ07E/v37MWbMGDx48ABNmzbF/fv3sW3bNtjZ2VW6PCV7bz68xPJtobh+v+wG1ljfHBOGrIGbc4+f4m05RdWImu6upjbLzs6utAuhgoIC8uzZM1JQUFCDJZOdqKgoAoDExcWRWbNmETMzM6KoqEgcHR3Jrl27hNLzu0Pk43cBx+86LiUlRSD9q1evSFBQENHX1ycKCgrE0tKSTJ06leTl5Qmky8vLI+Hh4aRu3bqEw+GQevXqkUWLFpFz584RACQqKkog/fbt24m9vT1RUFAgAEhISAgzz93dnen27ts/d3d3oW1KSUkhgYGBRE9PjygoKJD69euT5cuXEy6XK3E93rx5k/j4+BBdXV2iqKhIzMzMSGBgIElOTmbSXLp0ibi6uhI1NTWiqalJunTpQh4/fkzc3d2Jubm5VHny6/3bbefj79eLFy8KTE9LSyPh4eHExsaGcDgcoqmpSRwdHUloaCh5+vSpxNtbXkhIiMjySyI1NZUEBQUROzs7oq6uTuTl5YmZmRkJDg4mCQkJIpcpKCgg06dPJ+bm5kRRUZFYWlqSuXPnkuLiYpHpS0pKSKNGjUhoaKjI+du2bSP16tUjGhoapEePHuTDhw9iy8uvdy6XSwoKCsj8+fNJgwYNmLps3rw52bBhg8Aykv4GZs+eLfI3xO8Kd/bs2ULlEXXs8I+JuLg44uLiQpSUlIiBgQEZPXo0ycnJkWidfCUlJWTNmjWkefPmREVFhaioqJB69eqRwMBAcubMGSbdokWLSNu2bYm+vj5RVFQkpqamxM/Pj9y9e5dJc/HiRdK3b19ibm5OlJSUiLa2NnFxcSFbtmwhPB6PSSfq2OVyueTly5dkxIgRpE6dOkReXp7UqVOHjBw5kqSlpQmUWdyxL66+RPndrgPiFBcXkyNHjoj9bUmioDCPROyeSVr1USTNe4G06qNINu6aTgoK8ypf+DdVHfX+s5MkXvsVsQiR7F36ixcvkJ6eDisrK4EP8yIjI3H16lWRy3Tp0kVk2/TaKicnB5qamsjOzoaGhobINIWFhUhJSYGlpaXMhvH+mfAH1dHQ0KjVXWL+ami9y8bPUO/8EVG3b98u66JUm5qud3odKFNSUoKTJ0+iS5cuVeqC79KtY1gZORYfPr8GALRs0gnhQ9fB3ES4tyLqf7633n8FksRrvyKJmsd8/foVrVu3BpvNZtp08l25cgXR0dEilzt27Bi8vLyY/qcpiqIoivq9vfv4Cisix+LqnRMAAANdU0wYvBrtWvrSpjAUVQGJgvZ9+/bhy5cvWLNmjcjeMlgsFnbv3i0w7fbt21i5ciX27t3LDA5CURRFUdTvqai4EDuOLEX0oUUoKi4Emy2P/j0mYGifmVBWqlp3yRT1O5EoaI+NjQWHw8GQIUPEpvn24yVfX19s27YNsbGxNGinKIqiqN/YtbsnsWzrGLz/VDZ4V/OGnpg0bD0sTYUH+qIoSjSJgvYHDx6gefPmUvUSoqCggIYNG+LBgwdVLRtFURRVzST8jImiqsWHz6+xKnI84m8dAQDo65hg3MCV6OjalzaFoSgpSRS0f/r0CS1bthQ5z8HBAZ6eniLnmZiY4O7du1UvHUVRFEVRP53ikiLEHF2OyAMLUFRcADZbHgHdxmFo31lQVabfuVFUVUgUtLNYLHC5XJHzwsPDER4eLnLejxhanqIoiqKo2uvGg7NYtmU03qSWjVrs5OCOScM2wLqug4xLRlE/N4mCdgMDAyQnJ0udeVJSEvT19aVejqIoiqKon8vH9LdYFTkeF24cBADoahlh3MAV8GobQJvCUFQ1kKhDWxcXFzx8+JAZRVISKSkpePjwITMKJUVRFEVRv56S0mJEH1qCPmPq48KNg2DLsRHQbRwOrHsOb7dAGrBTVDWRKGjv27cveDwexowZI9FHTIQQjBkzBgCYIaopiqIoivq1pKQ+RPDEZlgfMwWFRfloYt8GO5ffQ9jgVVBT1ZR18SjqlyJR0N67d2+4uLggNjYW3bp1q7CpTHJyMrp27YpTp06hRYsW6NWrV7UVlqIoiqIo2fuc8R4zV/fHrrOz8d+HROhoGmDOmGhsnn8ZNhaNZF08ivolSdSmHQAOHz4MNzc3nDp1CnZ2dnByckLTpk2hp6cHAEhPT8f9+/dx79498Hg8WFtb49ChQz+s4BRFURRF1azS0hLsjV2LLfvmIL8wFyyWHHp3GoGRQQugrqol6+JR1C9N4qDd2NgY9+7dw8SJExEdHY07d+7gzp07TFs1frMZDoeDgQMHYsmSJdDQ0PgxpaYoiqIoqkbdfRKPJVtGIeXtMwCAg00LtLLrh8EDRkNBQUHGpaOoX5/EQTsAqKurY9OmTViwYAEuXryIhw8fIiMjAwCgq6uLxo0bo127dtDV1f0hhaVqXnx8PNq1a4eoqCgMHDhQ1sWpdTw8PPD69Wu8fv1a1kWhqGrx+vVrWFpaYvbs2ZgzZ46si0PVAulfUrFmx0ScvrwLAKCloYcxA5bAq01/nD59Wsalo6jfh0Rt2r+lq6sLPz8/zJs3Dxs3bsTGjRsxb948+Pn50YCdEhIREYHt27dLnJbFYoHFYiE9Pf3HFowCAGzfvp2p82//Ro8eLXKZHTt2oGnTplBWVoahoSGGDh2KtLQ0oXS7d+9G/fr1oaamhrZt2+L+/ftCaXJycmBmZoalS5dW+7ZRFFV1pdxS7DmxBn6h9XH68i6wWCz09hqBA+sS0aP9YMjJVSmEoCiqiqR60k7VDB7hIiXzCr4WpUKdYwxL7baQY7FlUhY3NzcUFBR816vPiIgIWFlZYfDgwRWm+/DhA6ZMmQI1NTXk5uZWeX1U1UybNg329vYC0+zs7ITSrVq1CmFhYXB3d8eaNWvw7t07rFy5EtevX8etW7egqqoKALh58yaCgoLQt29fjBs3Dtu2bUPXrl2RmJgIdfX/jYg4depU6OvrIyws7MduICURc3NzFBQUQF6eXh5+Zw8SrmLJ5pFI+u8xAKBBPWdMHr4RDeo1l3HJKOr3JdFZ+dSpU+jcufN3r+zkyZPo0qXLd+fzK3vy6RCOPR+L7KJ3zDRNjil61F8DR0PfGi+PnJwclJSUamRdo0aNgrW1NRwcHBATE1Mj6/wVbN++HYMGDUJKSgosLCyqnE/Hjh3h4eFRYZr09HTMmDEDzs7OOH/+PNjssptJZ2dn9OjRA2vWrMG0adMAAEeOHIGFhQX27NkDFosFLy8vWFlZ4caNG+jYsSMA4N9//8WWLVtw/fp1GiT+P0II8vLyoKamJpP1s1isGvvNU7VPRtYnrNsxCbHxOwAAmmo6GDVgMXzaD6FP1ilKxiT6BXbt2hWtWrXCsWPHwOVypVpBaWkpDh8+jBYtWqB79+5VKuTv4smnQ9j50E8gYAeA7KL32PnQD08+1XxvPPHx8WCxWALNW8pPi4qKgoODAzgcDszNzYWaOLDZbLx9+xaXLl0SaHbxbRvww4cP49ixY9i0aRMTCErj48ePCA0NhZWVFTgcDgwMDNCxY0fExcUxaW7duoWBAwfC1tYWKioqUFdXh6urKw4fPlzlPPk+fPiAgIAAaGtrQ0VFBV5eXnjx4oVQuqKiIixcuBAODg5QUlKClpYWunfvLrLZiCx8/foVxcXFYucfOXIE+fn5GDNmjMB+6t69O6ysrARutgoKCqClpcV8rK6jowMAyMvLAwAUFxdj2LBhCA0NRbNmzapU3oMHD8LDwwNaWlpQUVGBnZ0dQkNDBbYhLy8PU6dOhbW1NTgcDoyMjBAcHCw0WFz543rjxo2ws7ODkpISGjZsiBMnTgAAHj9+DG9vb2hoaEBXVxehoaEoKSkRyKdbt26wsrLCq1ev4OPjA01NTWhoaKBXr1549eqV2HVu2LABDRo0gJKSEpYvX86k2bdvH9q0aQN1dXWoqKigRYsWOHDggFBdxMbGwt3dHXp6elBWVkbdunXh6+srcBy+ffsWgwcPhrm5OXNMt27dGtHR0Uya169fg8ViCbVnLy0txZIlS5gy6urqolevXnj8+LFAuvLLnzhxAs7OzlBSUoKxsTEmTpyI0tLSinYpJSOl3FLsP7kefqPtmIC9Z8dhOLA+Eb06DqMBO0XVAhI92tq+fTtmzpyJXr16QUdHB35+fnB3d4ezszOsra2F0iclJeH27duIj4/HwYMHkZmZCTMzM4nbNf+sCCEo4eZXaVke4eLo81AAogavIgBYOPZ8LOrpdKhSUxkFtkq1j0q3adMmfPr0CUOGDIGWlhZiYmIwefJkmJqaIjAwEAAQHR2NsLAw6OvrY/r06cyy+vr6zP/n5ORg9OjR+OOPP+Di4oKNGzdKVY7Xr1/D1dUVnz59QnBwMJo3b468vDzcuHED586dY57qHj58GM+fP0ffvn1hbm6OjIwMREdHw9fXF7t27WLKLE2eQFlQ6ObmhpYtW2LhwoVISUnBmjVr4OPjgydPnjDBbUlJCby9vfHvv/9iwIABGD16NLKzs7Flyxa4urri8uXLaN5cdq+ee/Toga9fv4LFYqFhw4aYOHEigoKCBNLcvn0bANCqVSuh5Vu2bIk9e/YgNzcXampqaNWqFdauXYudO3fCzc0Ny5cvh6KiIhOgL168GAUFBZg7d26Vyjt9+nQsXLgQDRo0wPjx42FsbIzk5GQcPHgQc+fOhaKiIkpKSuDl5YVr167Bz88PEyZMwMuXLxEREYGzZ8/izp07MDU1Fch3w4YNyMzMxNChQ6GkpIS1a9eiV69e+OeffzBs2DAEBASgZ8+eOHv2LNatWwcDAwPMmDFDII+8vDx4eHigRYsWWLRoEV6+fImNGzfixo0buH//PoyMjATSr169GhkZGRg2bBiMjIxgZmYGAJgxYwYWLFgAb29vzJs3D3Jycjh8+DD69OmD9evXY9SoUQCAS5cuoUePHnB0dMTUqVOhpaWFDx8+4Ny5c0hKSoKtrS1KS0vRsWNHvH//HiNHjoStrS2ys7Px6NEjXLlyBSEhIRXWd//+/bF//3507NgRf/75Jz5+/IgNGzagVatWuHLlCpo2bSqQ/uTJk9i4cSNGjBiBwYMH4+jRo1i+fDm0tbWZtzFU7fAo8TqWbB6JFykPAAD1rZwwefhGONrSEc0pqlYhEiosLCQrV64kNjY2hMViETk5OSInJ0fk5eWJnp4esbS0JHp6ekReXp6Zx2KxiJ2dHVmzZg0pLCyUdFUyk52dTQCQ7OxssWkKCgrIs2fPSEFBgdC8opJcMukMauVfUUlulerk4sWLBACJiooSmmZsbEyysrKY6Xl5eURPT4+0bNmSmcblcomZmRlxd3cXu44RI0YQIyMjJq+QkBACgKSlpUlUxs6dOxMA5PTp00LzuFwu8/+5ucJ1kJeXR2xtbYm9vX2V8nR3dycAyJIlSwTSLF26VGj5lStXiswzOzu70jqqSFRUFAFAUlJSBMqYmZkpUFZx9u3bRwIDA8nWrVvJsWPHyJo1a4itrS0BQObMmSOQtlu3bgQAyc/PF8pn4sSJBABJTEwkhBDC4/GYfQmAcDgcEhERQQghJCEhgXA4HHLmzJkqbfPNmzcJANKuXTuh3yKPxyM8Ho8QQsjmzZsJADJx4kSBNCdOnCAASFBQEDONf1ybmJgIHNcPHz4kAAiLxSIHDx4UyMfJyYkYGRkx/+ZyucTV1ZUAIGPHjhVIe+jQIQKA/PHHH0Lr1NbWJp8+fRJIf/fuXQKATJ06VWj7fXx8iLq6OsnJySGEEDJ+/HgCQCiP8vjb8e2x+q2UlBQCgMyePZuZdvbsWQKA9O3bl6lbQgh58OABYbPZpE2bNkLLq6ioCByTPB6PODg4CNRXdZHmeK8OFV0HfiZfsj6TuesHk+a9QJr3AmkXpEX+ObWRlJaWSrR8cXExOXLkCCkuLv7BJaXKo/UuWbz2K5L4fReHw8H48ePx4sULxMfHY8KECXBxcYGioiIyMjLw+vVrZGRkQFFRES1atEB4eDji4+Px/PlzhIaGgsPhfN/dBVXrDBo0CJqa/xumWkVFBS1btsTLly8lzuPatWv4+++/sXLlSoG8JPXlyxecPn0a3t7e8PLyEppf/pUu/wNJAMjPz0dGRgby8/Ph6emJhIQE5OTkSJ0n/9+hoaEC0zw9PQFAoC5iYmJQv359NGvWDOnp6cxfcXExOnbsiKtXr6KgoKDC7S0pKRFYNj09nfloNzMzU2A6vzvWyvTt2xe7du3CkCFD0L17d4SGhuLRo0dwdHTE/PnzBZoy5eeXvUkS9Xvmt4Pmp+E3+3jz5g2uX7+ODx8+YMSIESCEYPjw4ejTpw86deqEx48fo0OHDjA2Noanp6dQcwtRdu0q63pu0aJFQu2v+U2wgLK3K3Jycpg6dapAmq5du6JJkyY4evQoeDyewLyBAwcKHIuNGjWChoYGTExM4Osr+F1JmzZt8PHjR5EfTk+ZMkXg37169YKdnR2OHDkilDY4OBgGBgZC28hisRASEiK0z/lvRa5fvw4ATHkPHjwotvkJP83Fixfx+fNnkWnE4Tchmz59usAbu8aNG6N79+64evWqUO9BPXv2FPjGgsVioV27dmLri6o5XC4XB89sgt8YOxw7HwkA6O45CAfWJcLP+88qNVGkKOrHq9KXX25ubnBzc2P+nZeXh+zsbGhqagoERr8bBbYK5nlW7WKUknkZkfcr/0h3cNOTsNR2qzTdtxTYKlUpVoWsrKyEpunq6kocLBYXF2P48OHo0KEDAgICqlSGpKQkEEKEXs2L8vnzZ8yYMQNHjx4VGbRkZWVBQ0NDqjwBwMTERChw5Hd9Wr4uEhISUFBQINA06Fvp6elM0whRrl27hnbt2omc5+TkJDRN2m9Q+DgcDsLDwzFw4ECcPXsWw4cPB1B2YwaUtc1XVlYWWKawsFAgDZ+ZmZnANm3evBkJCQk4dOgQvn79ig4dOqBbt25YunQpNm7ciA4dOiApKUmgh5lvvXz5EiwWC40bN65wO1JSUmBiYgJtbW2heQ4ODnjw4AHS09MFAmZRx7W2trbI/cLPNyMjQ+DDUS0tLaEmMABgb2+PI0eOIC8vT+BcaWtrK5Q2ISEBhBDUr19f7PZ9+vQJADB69GgcPXoUI0eOxOTJk9GmTRt4e3sjICCAOd7Mzc0xffp0LFq0CMbGxmjSpAnat2+PPn36wNnZWew6gLJ6lJOTE+pdCCirxyNHjiAlJUXg2BZ3fgCE64uqOU9f3saSzSORkHwHAGBj0RiTh29E4/qtZVwyiqIqUy3dNaiqqv7WwTofi8WConzV6sFGrxM0OabILnoP0e3aWdDkmMJGr5PMun/81vc+jdmwYQOeP3+OFStWICkpiZn+9etXAGWBQk5OjsiLv7QIIejUqRMSEhIwduxYNG/eHJqammCz2YiKisLu3buFnrhKqqJ6IIQI/H/Dhg2xcuVKsekrCuiBsieb334Ie/bsWSxbtgwxMTEwNDQEAPB4POaJd1Xxn5KW7y/fxMQEAPD+/XvUq1dPIP379+/BYrGYNKKkpqZi8uTJWLduHfT09LB7925kZWVh3bp1UFFRYdrAnzhxotIbufJP1KuTuP0p6X6uim9vdPh5slgsnDp1Suy6HRwcAJQFw7dv38aVK1cQFxeHy5cvY/z48Zg9ezZOnjzJfIMwf/58DB48GLGxsbhy5Qq2bt2KZcuWYdKkSViyZMl3bcO3fmR9UdLL+pqBjTHTcOTcFhBCoKqigT8D5qO395+QZ9Oem6iq4/G4eJF6BVn5qdBSMYatcVvIydWOOOVXQ3+ptYQci40e9ddg50M/ACwIBu5lgUmP+qtrTcAuDXGB1X///Qcejye2O1EXFxeoqqpW+Cq9Xr16YLFYePDgQYVlePToER4+fIhZs2bhr7/+Epi3devWKuUpLRsbG6SlpcHT07PKPTFoa2ujQ4cOAtPevSvrbcjV1ZUJtHk8HtPcp6r4TXv4NwJAWdeOmzdvxvXr14WC9hs3bsDOzq7CJ6ijR4+Gi4sLBgwYwJRdR0eHCVpVVFSgo6ODt2/fVlg2W1tbnDp1Cg8fPoSLi4vYdFZWVjh9+jSysrKgpaUlMO/Zs2fQ0NCAnp5eheuqiqysLHz8+FHoaXtCQgIMDAwkeshhY2OD06dPo27duiKfcH+LzWbDw8OD6bbz0aNHaNasGebPn4/Y2FgmnZWVFcaMGYMxY8agsLAQXl5eWLp0KSZMmCDURKf8MjweDwkJCWjUqJHAvGfPyoa0t7S0rLSMVM3j8Xg4dj4S62OmIPtr2Zu/Lu4DMCZ4KfS0hd8GUZQ07rw6hN3XxiIz73+93mmrmiLQdQ2aW9V8N9W/OtqHUy3iaOiLAY0PQJNTR2C6JscUAxofkEk/7dVBVVUVX758EZo+aNAg/PPPP0J//KAjMjKy0v7adXR00LlzZ5w6dQrnzp0Tms9/osd/6vftE74nT54IdfkoaZ7SCg4OxsePH8U+aec3dahpopozZWdnY8mSJVBUVBRo1+/j4wNlZWWsX79eoOnN8ePH8erVK/Tv31/seo4cOYLTp0/j77//ZqaZmJggLS2N2fZPnz4hLS2twqf1AJiefqZNmyayi0r+PurZsyd4PB4WL14sMP/UqVO4f/8+evTo8cO6svt2nYcPH0ZiYiJ69uwp0fL8G5tp06aJbOZU/ngRNXpw/fr1oayszPz2srOzhbqnVFJSYm4IMjMzxZaFX+ZFixYJHP9PnjzBsWPH0KZNm0rfElE1LyH5LoZMbY0FEcOQ/TUD1nUd8fe8S/hr7A4asFPf7c6rQ9hw1k8gYAeAzLz32HDWD3de1Xw31b86+qS9lnE09EUDA59aMyJqdXB2dsbOnTsxc+ZM2NvbQ05ODt27d0fjxo1Ftknm94ndvXt3iZ6Crl+/Hq1bt0bnzp0REhKCZs2aoaCgADdv3oSFhQWWLFkCe3t7ODg4YOnSpcjPz4ednR1evHiBv//+Gw0bNsTdu3elzlNaY8eORVxcHCZOnIgLFy7A09MTGhoaePPmDc6fPw8lJSVcvHhR6ny/V8OGDeHu7o6GDRvCwMAAr1+/RmRkJFJTU7FixQqBLhH19fUxb948hIeHM98ivH//HitWrED9+vUxbtw4kevgd+v5119/CTyR7dq1K9OH+YABAxATEwNNTU107dq1wjK7uLhg8uTJWLJkCZycnNCvXz8YGRkhJSUFBw4cwK1bt6ClpYWBAwciOjoaS5YswevXr+Hm5oakpCRs3LgRhoaGWLhwYbXU4bf09PRw6NAhfPjwAR4eHkyXj4aGhkL9n4vj7OyMOXPmYM6cOWjSpAn69OkDExMTpKam4u7duzh58iRzwzJs2DC8e/cOnTp1YkY03bdvH75+/Yrg4GAAZR+gDh8+HL1792beiNy9exdbt25FixYtRI5+y9exY0f07dsXe/fuRWZmJrp168Z0+cjvFpOqPXJyMxGxewYOnokoawqjrI7h/n+hb+fRkJev+ujWFMXH43Gx+9pYVNRN9Z5r4+Bk4UObylQjGrTXQnIsNqx1PGRdjGozY8YMfP36FRs2bEBWVhYIIUhJSam27yAsLS1x584dzJs3DydPnsSOHTugra2Nxo0bMx9QstlsxMbGIjw8HNHR0cjLy4OjoyOio6Px8OFDoaBdkjylpaCggNjYWGzcuBE7d+7E7NmzAZQ9bXZxcam0n+wfJSAgAPHx8Th79ixycnKgqakJFxcXREVFiew9Z8KECdDV1cWqVasQGhoKDQ0N9O3bF4sXLxbbNGbKlCkwNDTE+PHjBaZra2vj1KlTGDNmDCZOnAh7e3vExsaK/HD0W4sXL0bjxo2xfv16LF26FDweD2ZmZujSpQvT3EZBQQFnzpzB/PnzsW/fPhw6dAhaWlro06cP5s+fX+FHv99DVVUVFy5cwPjx4zFlyhQQQuDt7Y0VK1bA2NhY4nxmz56N5s2bY+3atVi9ejXy8vJgYGAAR0dHgUB5wIAB2L59O6Kjo5GWlgYNDQ00aNAABw4cQO/evQGUfQ/h6+uL+Ph47Nq1C1wuF3Xr1sW0adMwYcKESsuya9cuODk5Yfv27ZgwYQJUVVXh7u6OefPmoWHDhtJXElXteDweTlyMxrqdk5CVU/b2xattIMaGLIO+TsVvryhKGi9Srwg9YRdE8CXvLV6kXkH9Oh41VaxfHovQL4IY/IAlOzsbGhoaItMUFhYiJSUFlpaWdKhvCfDbVmtoaNAR9WoQrXfZ4PF4cHNzw7t374RG/aV+nJo+3mvjdSAx5QGWbh6FR4n/AgAsTe0xadgGNG8ourep6lBSUoKTJ0+iS5cuUFCgT/BrSm2o98sJ2xB1aWil6f5ovxstbarWO1xFJInXfkX0STtFURRF/aRy87Kxac9M/HN6A3g8HpSVVDGs7xz4dw2FgoKirItH/WLSclJw7vFaXHz2d+WJAWipSP5mkaocDdopiqIo6idDCMGpSzFYs2MivmSVfZTcoXVfjBu4AoZ6ppUsTVHSSfp4HWcercTdlEMgpKx7ZDmWPHhE9GBuAAs6qqawNW5bc4X8DXx30P7lyxfcvXsX6enpMDc3R+vWdIAGiqIoivpRkv57jKVbRuH+sysAAPM6dpg4dD1aNO5QyZIUJTkurxT3Ug7jzKOVSP50g5nuYNoJXo3DUFSciw1xff5/qnA31QGuq+lHqNWsykF7Wloaxo4diwMHDjDdkYWEhDBB+9atWzFp0iSmOzCKoqjfwYkTJ36rNpZUzcnNz8GWfXOwL3YtuDwulDgqGNJnJgK7j4eiAkfWxaN+EQXFObicsA1xj9cgI/c/AIC8nCJa2QahU6PxMNVxZNKOYh0Q6qddR9UUAa6raT/tP0CVgvYvX76gdevWSE5ORpMmTeDq6ooNGzYIpPH19cWff/6JAwcO0KCdoiiKoqqIEIKzV/di9fYJSM9MBQC0a+mLsEGrYKRfV8alo34V6V//w7nHa3EpYQsKS8pGJldT0oOnw0h4OoyEpoqh0DLNrXzhZOFDR0StIVUK2hcsWIDk5GTMmjWL6XP426BdR0cHjRo1wqVLl767kBRFURT1O3r19hmWbRmNO0/KxnAwM66H8CHr0NrJW8Ylo34VyZ9u4syjlbjz6gDTXt1E2x6dGo5HK9sgKMorV7i8nBybdutYQ6oUtB85cgS2traVDhJibW2N+Pj4qqyi1qM9ZVIURf2eauL8n1+Qi63/zMXu46vA5ZaCo6iEQb2nI8gnHBzF2tHNJPXz4vG4uPf6CM48XImkT/8y0xvU6QCvxmFwNPOCHIt2F1zbVClof//+PXx8fCpNx2KxkJOTU5VV1FoKCgpgsVjIy8uDsnLFd58URVHUrycvLw8sFuuH9JFNCMG5f//B6qgwfP7yHgDg5twDE4asgYmBRbWvj/q9FBR/xZXnkTj3eA3SvqYAKGuv3tKmPzo1Ggcz3UYyLiFVkSoF7RoaGkhNTa00XXJyMvT19auyilqLzWZDU1MTaWlpKCoqgoaGBuTl5cFisWRdtFqJx+OhuLgYhYWFdJCfGkTrXTZovctGTdQ7IQSlpaXIyclBTk4OtLS0wGZXb7vd1+8TsWzLaNx6dA4AYGJoifAha9G2ebdqXQ/1+8n4+gZxT9bicsIWFBSXPUxVU9It117dSMYlpCRRpaDd2dkZFy5cYEaEE+Xhw4d48OAB/Pz8vquAtZGRkRGUlZXx+fPnX+5NQnUjhKCgoADKysr0xqYG0XqXDVrvslGT9c5ms2FsbAxNTc1qy7OgMA+RBxYg5thylJaWQFGBg5BeUxDcazKUOPSNLlV1rz7dYtqr80hZT3/GWvXRqdF4tLYdUGl7dap2qVLQPmbMGJw6dQq9evXCnj17YG9vLzA/KSkJAwYMACEEo0ePrpaC1iYsFgtaWlrQ1NQEl8tFaam4wQWokpISXL58GW5ubnSY6xpE6102aL3LRk3Vu7y8PNhsdrXdGBBCcPHmYayMHIdP6W8BAK5OXRA+dC1MjayrZR3U76esvfpRnH20Ei8/XmOmN6jTHp0ahaFhXW/aXv0nVaWg3dvbG5MmTcLSpUvh6OgIGxsbsFgsnDlzBo0bN8azZ8/A5XIxffr0X7q7RxaLBXl5ecjL04FlxWGz2SgtLYWSkhINYmoQrXfZoPUuGz9jvb/58BLLt4Xi+v3TAABjfXNMGLIGbs496FsaqkoKir/iamIU4h6tZtqrs+UU0LJeIDo1Go+6eo1lXELqe1U52ly8eDGaNWuGBQsW4NGjRwCA1NRUpKamon79+pg5cyYCAgKqraAURVEU9bMrLMpH1MFF2HlkKUpKi6Egr4gBPSdhUO+pUOKoyLp41E8oI/ctzj9eh/iEzSgozgYAqHJ00M7hT7R3GAUtVWMZl5CqLt/1iLhPnz7o06cP0tLS8Pr1a/B4PJiamqJOnTrVVT6KoiiK+iVcunUMKyPH4sPn1wCAlk06IXzoOpib2Mq2YNRP6XXaXZx/tha3k/cz7dWNNG3/v716MDgK9CbwV1Mt7Tr09fV/uV5iKIqiKKo6vPv4Cisix+LqnRMAAANdU0wYvBrtWvrSpjCUVHg8Lu6/PoorGbNx5NgzZnp9k3bwahyGRnW70PbqvzDaGJuiKIqifoCi4kLsOLwE2w8tQnFJEeTlFdC/xwQM8ZsBZSVVWReP+okUluTiauJ2xD1ajc85yQAAOZY8WtoEoFOj8TDXayrjElI1oUpBu6enp0TpFBUVoauriyZNmsDf3x9mZmZVWR1FURRF/VSu3T2JZVvH4P2nVwAA50btMWnoeliY1pdxyaifyZfcdzj3ZB0uPduM/OIsAICKojZMFdpjaPfl0Ncyl20BqRpVpaA9Pj4eQFnvKeKGcy4/b8+ePZgxYwaWLFmCcePGVamgFEVRFFXbffj8Gisjx+HSraMAAH0dE4wftAodWvehTWEoib1Ou4szD1fi9qv94PLKupU21LRBp0bj4WIZgPNxl6ClaiLjUlI1rUoNn1JSUjB27FjIy8ujf//+OHbsGB48eIAHDx7g+PHjCAoKgry8PMaMGYOrV69i4cKFUFJSwoQJE3D27NlK809MTET//v1hb28PTU1NqKiooH79+ggLCxMaiXXOnDlgsVgi/5YvX16VzaMoiqIoqRSXFCHywAL0DW2AS7eOgs2WR5BPOP5Z9xwdXfvSgJ2qFI/Hxb2Uo1h81B1/HWyOG0m7weWVor6JB8Z6H8NC/+fwdPgTHAXatOp3VaUn7Tdu3MC6detw6tQpdOzYUWBeo0aN0LVrVwwYMABdunRBy5YtMWXKFLRo0QLt27fHunXr0KlTpwrzf/fuHVJTU9GrVy+YmppCXl4ejx8/xubNm7F37148ePAABgYGAsusWrUKenp6AtOaNWtWlc2jKIqiKIldv38Gy7eOwZvUlwAAJwd3TBq2AdZ1HWRcMupnUFSSh6uJ23H20Wp8zkn6P/buMzCqamvA8DvpvVcIEDohhRa61BSwAQKxUIMIV0WlKV78rgXLVbkaQAQVEEIR0dAFJAUQ6SS0FEJvAdJ7z5Tz/ZhwMAISQpJJ2c+/7H1mzprDJKw5s/baAOjrGdCj9YsE+szE3bGrjiMU6ooqJe1fffUV/fr1uydh/6uAgACeeOIJvv76a1566SUGDRpEp06dOH78+EOf38/PDz8/v3vG+/fvz/PPP09oaChz5sypMDdixAjc3d0f+bUIgiAIQlWkZCSxYOVM9h7dBIC9jQszgr9mSL+XxJ114aGyC24RlfAt+8/+QGFpNgBmRjYM9HwVf883sLUQ7bOFiqqUtCcmJjJ8+PCHHtekSRO2bdsm/9y2bVvOnj37D4/4Zy1aaBdcZGdn33c+Ly8PMzMzsUOpIAiCUGOUyjLW/7aAFWEfU1JahL6ePi88/RZTXvgICzMrXYcn1HHX0k8SEbuA45c3yPXqTlZtCPSZQd/2EzExtNBxhEJdVaXs1szMjJiYGCRJeuDdBEmSiImJwczsbnP/kpISrKwq/wetpKSEgoICSkpKOHv2LO+++y4ATz311D3H+vj4kJ+fj76+Pj169OD999/nySef/MfnLy0tpbS0VP45Ly8PAKVSiVKprHScwoPduY7ietYucd11Q1x33ajN6x4Tt5evVr7FjdsXAOjUoS+zX15EmxY+tRZDXSHe75WnkTTEJe0iMn4RF5L3y+NtXfoR4DUdn2ZPo6enDzz8eorr3nhfu0J6UPuXfzBmzBh++eUXXnvtNebPn18hMQcoLi7m3XffZcmSJbz00kusW7cOAA8PD0xNTTl58mSlzvPtt9/y5ptvyj+7u7vz6aefMnbsWHls4cKFJCYm0qdPH2xtbTl//jwLFy4kOTmZlStXEhwc/MDn/+ijj5g3b9494+vXr7/nNQmCIAiNV15hJlExKzl77RAA5ibW+PkG491qoCiFER5IpSkhqXgflwp/o1B9GwAF+jQ16Utr82HYGrXRcYT1U1FREWPGjCE3N/eRbgbXd1VK2q9fv0737t3JzMzExsaGoUOHyj3Yk5KSCA8PJzs7G0dHR44dO0aLFi1ITEzE09OTd955hy+//LJS57l58ybnzp2joKCAU6dOsX37doKDg5k+ffo/Pi4zMxMvLy9KSkpISkrCwuL+XzXd7057s2bNyMjIaFRvgpqkVCqJjIwkICAAQ0NDXYfTaIjrrhviuutGTV53lUrJr78vZuXGTykqKUBPocfIIa8x5fkPsTS3qdZz1Tfi/f5gOYW32Zf4HX+eW05haRYApkbW9G//CoM6vo6dRdX3rRHXXZuvOTg4NLqkvUrlMS1atODIkSP861//Yu/evfz888/3HOPn58d3330n16G3atWK5ORkrK2tK30eNzc33NzcAO1C01GjRtG9e3eKioqYO3fuAx9nb2/Pq6++ykcffcThw4cf2K3G2NgYY2Pje8YNDQ0b7S9CTRHXVDfEddcNcd11o7qv+4n4P/hy+TSuJmnXYnm37827U5fSvmXnajtHQyDe73fdyDhNeGwIxy5tQK3RlnA4WbUmwHs6T3SYVK316o35ujfW113lFZutW7cmKiqKy5cvc+jQIbl/uqurK3369KFNm4pf+RgbG+Ps7PxYwfr4+NClSxeWLl36j0k7IHeSycjIeKxzCoIgCI1LRlYyi9a8w+4/fwLAxsqBN8fP55lBE9HTq9L2JkIDppE0xN7YRfiZEM7d3iePt3PtxxCfWXRu8axcry4Ij+Ox26y0bt2a1q1bV0cslVJcXExWVtZDj7t4Udsv93E/KAiCIAiNg0qt4tdd37JswwcUFuejUCgYGfgqr435FGtLO12HJ9QxpcoiDl9YQ0TsAlJytQuT9RT6dG/9PIE+M2nl1F3HEQoNTZ3sjZiSkoKLi8s94/v27SM+Pp6BAwcCoFKpKCwsvKfkJikpie+++w57e3v69OlTGyELgiAI9djpxIN8uex1Ll2PA8CzbQ/mTFlCxza+Oo5MqGtyCpPZk7CEfQnfVahXH+gxFT/vN7F/jHp1Qfgnj5W0FxUVsW/fPi5evEh+fj73W9OqUCh4//33H+l5X3vtNZKTkxk8eDAtWrSgpKSEEydOsGHDBiwtLfn6668BKCgooGXLlowYMQIPDw+5e8yKFSsoKCjg559/xtTU9HFeoiAIgtCAZeaksnjNHHb+sQYAaws7po3/guF+k0UpjFDBjYwzRMQu4Oil9XK9uqNlSwJ8ZvBE+0mYGlnqOEKhoaty0h4aGsrMmTPl3ubAPX3b7/z8qEn7Sy+9xJo1a1i7di3p6ekoFApatGjBv/71L9555x2aN28OgKmpKaNGjeLYsWNs3bqVgoICHBwc8Pf3Z86cOfTo0aOqL08QBEFowFRqFZvDv+e79f+hoCgXhULBcP9XmDbuc2ws7XUdnlBHaCQNcTd2ExEbwtlbe+Txti59CfSZRVf34aJeXag1VUrao6KimDx5MtbW1rz33nvs27ePI0eO8MMPP3D58mW2bNnCxYsXeeONN+jWrdsjP//zzz/P888//9DjjI2NWbFiRVVegiAIgtBIxZ4/wpfLXufC1dMAeLTuxpwpS/Bq11O3gQl1RpmqmMMX1hIRu4DknHOAtl7dt9VoAn1m0tpZvFeE2lelpP3rr79GoVCwb98+OnXqxKRJkzhy5AhTpkwB4NNPP2XOnDksW7aMqVOnVmvAgiAIglAV2bnpfLvu32zfsxIAS3MbXh/7X54LmIq+vrhbKkBuUQp7E5ayN+E7Ckq03edMjazo7zEFf683cbBsoeMIhcasSkl7dHQ0vXr1olOnTvd/UgMDvvrqK7Zu3cqHH37Ipk2bHitIQRAEQagqtVrNlshlLP3pPfILcwAY5vcyb4z7AltrR90GJ9QJSZmx2nr1i+tRacoAcLB0J8B7Ov06vIypUePZwEeou6qUtBcUFMh15YC8QVF+fj6WltqFGHp6evTs2ZM9e/bc9zkEQRAEoaYlXDzOl8teJ/HyCQDatezMnClL6NRBdBZr7DSShvikcMLPhHD2VpQ83sa5D0M6zaKL+3D09epkkz2hkarSu9HFxaVCr3RXV1cALly4UKGGPSsri+Li4scMURAEQRAeTU5+JkvWzWVb1AokScLCzJrXxnzKyCGvYqAvErHGrExVzJEL64iIW8Dt7EQAFAo9fFuNZojPTFo799JxhIJwf1X6y9WhQwd58yKAPn36IEkS8+fPZ8OGDSgUCg4fPszevXsfWEIjCIIgCNVNo9Gwbc+PLFn7b3ILtDeXnh44gTcnzMfeRmy215jlFqWW16svlevVTQwtGXCnXt3KXbcB1lNqjZqEqwfIykvGzsoVz5b90BcddWpElZL2p59+munTp3P8+HF69OiBn58fPj4+bNy4kaZNm+Lq6kp8fDwajYYZM2ZUc8iCIAiCcK9zV07y9cq3SLh4HIDWzb14d+pSunTsp+PIBF26mRVPROwCjlxYJ9er21u0IMB7Ov09Jot69cdwKG4zy7ZNJyP3pjzmYO3G1OGL6Os9UoeRNUxVStonTJhAu3btcHbW3rXQ09Nj586dTJ48maioKFJSUrC2tmbOnDmMGzeuWgMWBEEQhL/KK8jm96Pfc3JNOJIkYW5qydQXP+b5J6dhYGCo6/AEHZAkifibEYSfCSHhZoQ83sqpJ0M7zaZry+dEvfpjOhS3mf+uGQ1U3FgzI/cW/10zmvcmbBSJezWr0jvW2tqaIUOGVBhr2rQpu3fvpqioiNzcXJycnEQLLUEQBKHGaDQaduxbzeI1c8jJ15Y7DOk3hhkTv8LBzlXH0Qm6oFSVcOTiT0TELuBWdgKgrVfv1nIkQ3xm0calt44jbBjUGjXLtk3n7wm7lgQoWLZ9Br08h4tSmWpU7R8zzczMMDMzq+6nFQRBEATZ+aunmb9sGrHnDwPgYN2Mj6avpGdnfx1HJuhCXnEaexO+Y2/8EvJL0gEwMbSgf4dX8Pd+C0erljqOsGGJv/JnhZKYe0lk5CSRcPUAPq0H1lZYDV61Ju0qlYoVK1YQHx9Ps2bNmDp1Kra2ttV5CkEQBKERyy/M4YefPyBs9xI0Gg2mJuZMHv0+loo2dPUcoOvwhFp2KyuBiNiFHL64FpW6FAB7i+b4e79F/w6vYGZsreMIG5asvGT2nVzHtgOLKn28UH2qlLR//PHHzJs3j3379tG/f39A+zXlwIEDOXLkCJIkoVAoWL58OTExMdjY2FRnzIIgCEIjI0kSv+9fx6I175CVkwqAf5/nmRH8NXbWzuzatUvHEQq1RZIkEm5GEhG7gLik3fJ4K6ceDPGZTbdWI0W9ejVSqko5dvY3omJCOXF+NxqNutKPtbMSZWrVqUrv6sjISNzc3OSEHWDjxo0cPnwYHx8fpk2bxu+//87WrVtZsmQJ//d//1dtAQuCIAiNy6XrcXy57HVOJx4EoEXT9rzzyrf07KQthVEqlboMT6glSlUJRy6t19arZ8UDd+rVnyPQZxZtnHujUCh0HGXDIEkSl26dJCp6FX+cWk9BcbY859GiD4N9J7Ah8mMy85K5f127AgcbNzxbis5N1alKSfuVK1fw9vauMLZ582YUCgU///wzHh4evPLKK7i7u7Nx40aRtAuCIAiPrKAoj+W/fMQvO79BrVFjYmzGK0EfMObZmRgaGuk6PKGW5BWnsy/hO/YmLCGvOA3Q1qv36zAZf++3cLJqpeMIG47s/FT2nVxHVEwo11Pi5XF766b4dZuAX7eJuDm1B8Da3LG8e4yCiom79oPT1GELxSLUalalpD0zMxMHB4cKY/v376dt27Z4eHgAoFAo6N69O/v27Xv8KAVBEIRGQ5Ikwg/8zMLQ2WTmpAAwuNcoZk4KwcWxuY6jE2rL7exEImIXcPjCWpTqEgBszd0I8J7OAI9XMDO20W2ADYRSVcbxxB1ExYQSc26XXP5iaGBMb6/nCPCdRKe2fvck4H29R/LehI339mm3cWPqsIWi3WMNqFLS7uDgwK1bt+Sfz549S2pqKsOHD69wnJGREWVlZY8XoSAIgtBoXEk6y/zl0zgR/wcAzVzb8PbkxfTpOlS3gQm1QpIkzt7aQ/iZEOKSfpfH3R19GdppNt1ajsJAX/Tef1ySJHHl9mmiYkL54+RP5BVlynMdmvfC3zeYfp1fwMLU5h+fp6/3SHp5Dhc7otaSKiXtHh4e7N+/n1OnTtGlSxdCQkJQKBQ89dRTFY67du0arq5iEYIgCILwzwqL81nx68f8vGMharUKYyMTJo36P8aPeAcjQ2NdhyfUMKW6lGMXfyY8NoSbWXEAKFDQpeUIhvjMoq1LX1GvXg1yCtLYd/In9sSEcjU5Vh63s3JlcLcJ+PsG08ypwyM9p76evmjrWEuqlLTPnDmTPXv20L17d2xsbMjOzqZly5YMHXr3Tkhubi4nTpxg2LBh1RasIAiC0LBIkkTU4TAWrppFWpb2G9wBPYYz6+WFNHFy121wQo3LL85g39nv2RP/LXnF2q5Axgbm9OvwMgHe03Gybq3jCOs/paqMmHO7iIoJJTpxJ2qNCigvf/EcgZ9vMF3a+qOvLzru1HVV+hd66qmnWLx4MfPnzycjI4O+ffuyZMkSjIzuLgxas2YNSqUSPz+/agtWEARBaDiu3TzH/1a8yfHYKACaOrfi7cnf8ITv0zqOTKhpydnniIhbyKHzq/9Sr94Uf6+3GNBxCubGYo+Xx3Xl9hmiYkLZd3IdeYUZ8ni7Zj3w9w2mf+cXsTQT17k+qfLHqmnTpjFt2rQHzr/yyitMmDABCwuLqp5CEARBaICKSwr5ceOn/LT9a1QqJUaGxgSPnMv4EXMwMTbVdXhCDZEkicTb+4g4E8KZGzvlcXfHbgzxmY1vq9GiXv0x5RZm8MfJn4iKCeXK7dPyuK2lC4O7jsfPdyItXDx1F6DwWGrsuxBTU1NMTcUfX0EQBEFLkiT2HdtCyMoZpGYkAdC361O8/co3uLmIMoiGSqUu49ilDYTHhpCUeQYor1d3H86QTrNo6/KEqFd/DCq1kphzv5eXv+xApdbuW2Cgb0RPz2EE+E6ia7tAUf7SAIh/QUEQBKHG3bh9kf+teJOjp8MBcHVswezJ39C/+7MiYWugCkoy2ZfwPXsTlpBTpN3O3sjATK5Xd7Zuo+MI67drKXHsP/0T+06uI6cgTR5v6+Yrl79YmdvrMEKhulUqaW/V6uEbFygUCszNzeWdUl9++WWcnJweO0BBEASh/iopLWLVps9Zu3U+SlUZhgZGjB8xh0mj5mJibKbr8IQakJxznsjYhRy6sJoyVTEANmZN8Pd+iwEeU7AwsdNxhPVXXmEme2LWsvXUYpYdvCKP21g4MajrePx9J+Lu6v0PzyDUZ5VK2q9du1bpJ4yPjyc8PJwvvviCNWvWiO4xgiAIjZAkSfwZ/RshK6dzO+0aAL06D+GdVxbTvElb3QYnVDtJkjh3+w/CY0M4c32HPN7coQtDfWbTvXUQBvpiF9uqUKtVnDi/m6iYUI6d3f6X8hdDeng8S0D3SXRtP0SsB2gEKpW0V2ZXU0mSKCoq4sqVK2zbto09e/bw4osvcurUKdq3b//YgQqCIAj1w82UK3z941scPKFdbOjs0IxZLy9kUM/nRClMA6ORlBy5uI49Cd9wI/M0oK1X7+T+LEN8ZtHetb/4N6+i6ykJRMWEsvfEWnIKUuXxVk264GLSjVdf+hh7G7EXTmNSqaR9wIABj/Skb7zxBkuXLuWNN94gJCSEH374oUrBCYIgCPVHSWkxa7fOJ3Tz55QpSzEwMGTssNlMHv0fTE3MdR2eUI0KSrLYG7+UiLQQSlKyATAyMOWJ9pMI8J6Oi007HUdYP+UXZbH/9Aaioldx8WaMPG5t7sigruPw9w3GzdGDXbt2YWXuoMNIBV2osYWor7/+OosXL2bv3r01dQpBEAShjjgYs5OvfnyLW6naOtsePv6888pi3N0ebXdFoW5LyblAZNwiDp4PpUxVBIC1mSv+Xm8ysONULEzEwsdHpVarOHkhgqiYUI4mbEOlLgNAX8+AHh7P4OcbTHePp+TyF6VSqctwBR2q0e4xnTt3Ztu2bTV5CkEQBEGHbqddI2TlDPYf1/6td7RrwsxJC/DvEyTKIhoISZI4n/yntl792m9ISAA0s+uEo3ogrzz3mfgmpQpupCaWb360lqy8ZHm8pWsnArpPYmCXMVhbOOowQqGuqdGkXa1Wo6enV5OnEARBEHSgTFnKum1fsXLjZ5SWFaOvb8CYZ2cyOeh9zE0tdR2eUA1U6jKiL4cRHhvC9YyT8njnFs8S6DOT1o59+f3338UC00eQX5TNgTO/EBm9igtJx+VxK3MHBnUZi59vMK2bdtZdgEKdVmNJu0aj4fjx47Ro0aKmTiEIgiDowJFT4fxvxRskJV8CoJvXQN555VtaNxc7LTYEhaXZ/HF2GXviF5NdeAvQ1qv3bRdMgM90XG20zSVEmUblqDVqTl2IZE9MKEcStqJUlQKgp6dP9w5PE9B9Er4dnsLQQHz4Ef5ZjSXtH374IUlJSUyfPr2mTiEIgiDUopT0G4Ssmsm+o5sBcLB1ZUbw1wQ+8aIohWkAUnMvERm3iAPnVv6lXt2lvF79X6Je/RElpZ1jT8xq9p5YQ2bebXnc3cUb//LyF1tLZx1GKNQ3lUra16xZU6knu9PycdeuXSQmJmJjY8Ps2bMfK0BBEARBt5TKMn76LYQfwz6hpLQIfT19Xnj6Laa88BEWZla6Dk94DJIkcSH5ABGxCzh1bdvdenV7H4b4zKZHmxcw1DfWcZT1R2FxLn+e+YWo6FWcu3FUHrc0s2Ngl7H4+wbTummXBvUhVyOpuZp9gPzSZCyNXWlp2w89hb6uw2qQKpW0BwcHP9IbTJIkmjZtyq+//krTpk2rHJwgCIKgW8dj9zB/+TSu3zoPQJeO/ZgzZQltWohdF+szlVpJ9JUwImJDuJZ+Qh7v1PxpAjvNwqPJoAaVWNYktUZN7KW9REav4kj8FspUJYC2/MW3/ZP4+wbTo+MzGBo0vA8/8amb2X5uOrmlN+Uxa2M3hnVYhJfzSB1G1jBVKmnv3//hmyMoFArMzMxwc3Ojf//+jBo1CmPjhvcGFQRBaAzSMm+xYNUsog7/CoCdtRPTJ37FkwPGiWSuHisszWb/2eVExS8mu1CbaBnqm9C3/UQCvWfgaitadFbWrfQLRJWXv2Tk3k1aWzh7lpe/jMXOykWHEdas+NTNrD0zGsq/nbkjt/QWa8+MZnynjSJxr2aVStr/+OOPGg5DEARBqAtUKiU/71jE8l8/orikED09PYKGTuNfL32MpbmNrsMTqigt97Jcr16qKgTAytQZP683GNTxVSxNxUY9lVFUkseBM78SFRPK2WuH5HELU1sGdhmDv28wbdy6NfgPthpJzfZz0/l7wq4lAQq2n5tBR6fholSmGtVoy0dBEASh/jgR/wdfLp/G1aSzAHi37827U5fSvmVn3QYmVIkkSVxMOUR4bAinrm6V69Xd7LwZ4jOLnm1fEvXqlaDRaDhzaS9RMaEcid9MqbIYAD2FHl3bD8XfN5hensMaZPnLg1zNPlChJOZeErmlSVzNPkBru4G1FVaDJ5J2QRCERi4jK5mFq98m/MB6AGysHHhz/HyeGTRR7LVRD6nUSk5c3UT4mRCupkfL497NnmRIp1l0bOrX4O8EV4fbGZfYE7OaPSdWk56TJI83c/IgoPskBnUdh52Vqw4j1I1SVQHxqVsqdWx+afLDDxIqTSTtgiAIjZRKreLXXd+ybMMHFBbno1AoGBn4Kq+P/QwrC1tdhyc8oqLSHPYnriAq/huyCrRJpoG+MX3bTSDAewZN7TrqOMK6r6gkn4OxYUTFrCLh6kF53NzUhgGdX8LfN5h2zbo3ug89paoCEtN3EJcaxvmM31Fqiiv1OEvjxvehpiaJpF0QBKEROnX2APOXT+PS9TgAPNv24N2pS/Fo3U3HkQmPKi3vClFx33Dg3I+UKAsAsDJ1YrDnNAZ5voaVqaOOI6zbNBoNcVf2ExW9ikNxmyhVanvU6yn06NIukIDuk+jZcRhGhiY6jrR2larySUzfQWx5oq7SlMhzdiatKFSmU6rOf8CjFVgbu9HStl/tBNtIiKRdEAShEcnMSWXxmjns/EO7/4a1hR3Txn/BcL/JohSmHpEkiUupR4iIDeHE1S1IkgaApnZeDPGZRa82L2Fo0LiSzEeVnHlFLn9Jy74uj7s5tse/vPzFwbpxta0uVeVzNv238jvquysk6vZmbfBxDsLbOYgmlp1JSNtS3j0GKi5I1X4LMazDQrEItZqJpF0QBKERUKlVbNr9Hd/9/B8Ki/JQKBSM8J/C6+P+i42l2OmyvlBrVJy4spnw2BCupB2Tx72bDWWIzyw6uvk3utKNR1FcWsDB2I3siQkl7sp+edzcxJr+nV/E3zeY9s17NqprWKLKIzH9N2JTwriQuRuVplSeczBri7dzED7OQbhadqpwXbycRzK+08YH9GlfKNo91gCRtAuCIDRwZ84dZv7yaVy4ehoAj9bdeHfqUjzb9tBtYEKlFZXmcuDcj0TGLSKz4AagrVfv03Y8gT4zaGrnqeMI6y6NRkPC1QNERq/iUNxGSsq0LS8VCgVd2gbg5xtMb68RGBua6jjS2lOszCUxfTuxqWFcyAhHLZXJc45m7fF20SbqLhbe//gBxst5JB2dhosdUWuJSNoFQRAaqOzcdBavfZff9q4CwMrCltfH/pcR/lPQ1xf/qdYH6XlXiYr7hj/P/UiJUls/bGniyGCvaQz2fA0rUycdR1h3pWRdZW/MGqJOrCY166o83sShLQHdJzG463gcbNx0GGHtKlbmcDZ9O3EpYVzIjKiYqJt3kEtfXCy8HumbBj2FvmjrWEuqlLS3bt2aKVOmEBwcjItLw93tSxAEoT5Sq9VsiVzG0p/eI78wB4Bhfi/zxrgvsLUWixLrg0spRwiPDeHE1c1yvXoT244M8ZlF77ZjRb36A5SUFXIodhNRMaHEXt4nj5saW8rlLx4tejea8pdiZQ5n07YRmxrGxcwI1JJSnnMy95BLX5wtPBvNNanPqpS0X7t2jf/7v//jgw8+4JlnnmHq1KkMGTJE/IMLgiDoWMLF43y57HUSL58AoF3Lzrw7dSk+7XvrODLhYdQaFSevbiE8NoTLqUflcU+3QIZ0moWXW6D4f/Y+JEki4epBomJWcTA2jOJSbQcdhUJBpzZ++PsG09vrOUyMzHQcae0oUmZzNm0bcalhXMyM/Fui3lF7R90lCBcLUVJV31Qpab9+/To//vgjK1euZOvWrWzbtg03NzcmT57Myy+/jJtb4/m6SRAEoS7Iyc9kybq5bItagSRJWJhZ89qYTxk55FUM9EUlZF1WXJbHn4l36tW1XUwM9Izo3W4cgT4zcbPz0nGEdVNa9g25+0ty5mV5vIlDG/x8gxncdTxOts11GGHtKVJmkVCeqF/KjKqQqDube8o16s4Wold/fValv+Rubm58+OGHfPDBB4SHh7N8+XJ27NjBRx99xCeffMLQoUOZMmUKzzzzjGghJgiCUIM0Gg3b9vzIkrX/JrcgC4CnB03kzfFfYm/jrOPohH+SkX+dqLhv2J+4XK5XtzBxYLDn6wz2fB1rM/Hv93clZUUcjttcXv6yF0nStho0NbagX6cX8PcNpqN730bxjUSRMpPzqTu1iXrWHjSSSp5zsfDG2zkIb+fROFt46DBKoTo91u0XhULB0KFDGTp0KGlpaYSGhrJixQp27tzJrl27cHFx4eWXX2by5Mm4u7tXU8iCIAgCQOLlE3y57HUSLh4HoE0Lb+ZMWUKXjmJDk7rscuoxwmNDiLmy8S/16h4Ees+kd7txGBk0ni4mlSFJEonXDhMVE8qfZ36huPTuhj6d2gzG3zeYPt4jMTEy12GUtaOwLJPY5I2cNfqeo4fiKyTqrhY+8h11R/P2OoxSqCnV9p2pk5MTc+bMYfbs2cyZM4cFCxaQnJzMZ599xueff87TTz/NvHnz6Ny580Of6/z583z88cecPHmS27dvo1Qqad68OU899RTvvPMOrq6u9xz/7rvvsn//fsrKyujatSvz5s1j8ODB1fXyBEEQ6ozc/Cy+W/8fNkd8jyRJmJtaMvXFj3n+qTdEKUwdpdGoOXltK+FnQriUelge79jUX1uv3mwIegrxzfRfpecksefEGvbEhHI745I87mzXEn/fYPy6TcDZzl13AdaSwrIM4tO2EJcaxuWsvWgkNegDErhadpK7vjiat9N1qEINq7a/7nfq3FetWsXt27cB6NOnD4MHD+bXX3/lt99+4/fff+eXX37hueee+8fnunnzJsnJyTz33HO4ublhYGBAXFwcy5YtY8OGDZw+fRonJ22bq8uXL9OnTx8MDAyYM2cO1tbWLF++nCFDhvD777/j7+9fXS9REAShxqnVak4nHiAjOxkHW1c6e/ST2zNqNBp27Atl8dp3ycnLAGBo/7FMn/A/HOxc/+lpBR0pLsvnwLmVRMUtIj1f23bQQM+IXm3HEugzg2b2PjqOsG4pKSviaMJWoqJDOX0pSi5/MTEyp1+n58vLX55o8KW3BWXpJKRtITYljCvZ+7SJejlXi04YZnsx8on3cLUWNeqNyWMl7SqVim3btrF8+XKioqLQaDRYWVnx2muv8eqrr+LlpV088/HHHxMWFsaECRP44IMPHpq0+/n54efnd894//79ef755wkNDWXOnDkAzJ07l5ycHE6cOCHfxZ8wYQKenp5MmzaNc+fONYraNkEQ6r+9Rzfz9Y/TScu8u7ugk70bsycvoqlzK75c9jpx548A0LJZR96dsoRuXgN1FK3wTzLzbxAZ/w1/Ji6nuCwPAAsT+7/Uq4t2yXdIksS560eJjFnFgTO/UFSSJ895tx6Iv28wfb1HYWpsocMoa15BaRrxaZuJTQ3jStYfSGjkuSaWXeSuL9aGLdi1axcOZm11GK2gC1VK2i9evMiKFStYvXo16enpSJJE165defXVVxkzZgxmZve2VQoKCuLXX39l+/btVQ62RYsWAGRnZwNQWFjI9u3bGThwYIWyGwsLC1555RU++OADoqOj6dFD7PonCELdtvfoZt6dPxqQKoynZd7i3fmjUCgUSJKEmYkFU174iBeffgsDA0PdBCs80JXU43K9+p27o642HQj0mUnvtuMwNmwcbQcrIyP3FntPrCEqJpRb6RfkcWdbd/x9gxnsOwEXu5Y6jLDm5ZemEp+2mbiUMK5k76+QqDe16lZe+jIae7PW8rhSqbzfUwmNQJWS9vbttQsczMzMmDRpEq+++iq+vr4PfZy1tfUjvdlKSkooKCigpKSEs2fP8u677wLw1FNPARAbG0tpaSm9e9/bf7hXr14A/5i0l5aWUlpaKv+cl6f9dK9UKsUvRTW5cx3F9axd4rrrRlWvu1qj5usVb/H3hF1LOyZJEoN7jWb6xP/haNcUSRL/vnfo+v2u0ag5fWM7kfGLuPyXevUOTQYT4DUdT7e79eoN6d+sKte9VFnM8bPb2XtyLWcuRaEpX4hrbGhGH+9RDO46AU/3fnL5S0O6Xnfkl6ZwNmMr8WmbuJZzoGKibtkNL8dReDqNxM60lTz+1+ug6/d7XdBYX3uVknZPT09effVVxo8fj5WVVaUft2LFClasWPFIx7/55pvyz+7u7qxbt45+/bSdEe7Uzjdt2vSex94Zu3Xr1gOf//PPP2fevHn3jEdERNz32wKh6iIjI3UdQqMkrrtuPOp1v5YSR1rWg/9W3dHEuhPRR88AZ6oYWcNW2+93paaYG8V7uFz4G0XqVAAUGOBm2o825sOwllqSFCeRFLe7VuOqbQ+77pIkkV5wkfOpe7mc/idl6iJ5ztXKk3bOg2lp3wcjA1OSzhWSdK7hXa8yssnUP0Km/iHy9M6C4u4HdAtNW+zVfbBX98Gk2Jn8NDiacA4494/P2Zj/vhcVFT38oAaoSkn7p59+ipGR0SMl7FUxYsQIOnToQEFBAadOnWL79u1kZGTI83f+0YyNje95rImJSYVj7mfu3LnMmjVL/jkvL49mzZoRGBhY46+tsVAqlURGRhIQEIChofgqv7aI664bVb3uEYfyIPzhx7Vp34LAvk89RoQNU22/37MKkth7dgkHzv9IcVkuAObGdgzoMJWBHV/DxqxxLAp+2HXPyrvNH6d+Yu/JNdxMPy+PO9o0Z1CXcQzqOh5X+9b3PK6hyC9NJiF9C/Fpm7ieexDpL9+kuVl2x8tpFJ6OI7E1dX+k5xV/3+9WRjQ2VUraR44cSWBgIE8++WR1x1OBm5ubvLvqiBEjGDVqFN27d6eoqIi5c+fKd8P/WuJyR0lJCcA/3jE3Nja+b8JvaGjYaH8Raoq4prohrrtuPOp1d7av3C7SLg7NxL/nP6jp9/vVtBjCY0OIvvyrXK/uYt2OQJ+Z9Gk3odHWq//1upcpSzh2djtRMaGcPB/+l/IXU/p6j8a/ezDerQY22O4vuSW3iE/dRGxqGNdzDlVI1Jtb9yrf8GgUtqYtHvtcjfnve2N93VVK2h0dHbG1ta3uWB7Kx8eHLl26sHTpUubOnUuTJk2A+5fA3Bm7X+mMIAhCXXH5RgLLfvnoIUcpcLZ3o7OH2DSptmk0ak5f/43w2BAuJB+Qxzs0GcSQTrPwaf5Uo++vLkkSF5KiiYoOZf/pnykozpbnPFs+gZ9vMP18gjAzaZjfYOeW3CIudSNxqWFcyzlUYa65dW98XILwchqFrWlzHUUoNBRVStoHDhzI8ePHkSSp1tspFhcXk5Wl3arb29sbY2Njjhw5cs9xR48eBajUAllBEITaVlicz/Jf5rFh5yLUahUGBkaoVGWAgooLUrV/Y2dNXij3axdqXomygIPnQ4mMXUha3mUA9PUM6NnmJQJ9ZtLCoYuOI9S97PwUztzcwu+L5pKUliiPO1i74ec7Eb9uE2nq2DDbEuaU3JQT9es5hyvMtbDpI99RtzFppqMIhYaoSkn7J598Qvfu3Zk5cyZffPGFXD9eXVJSUnBxubeH7b59+4iPj2fgwIGAtrXjs88+y+bNmzlz5gydOnUCoKCggBUrVtC2bVvR7lEQhDpFkiQiD/3KwtBZpGdpF9MP7DGCmS8v4NyVk/f0aXe2d2PW5IUM7jVSVyE3KlkFN4mKX8z+s8soKssBwNzYloEdX8XPcxq2Fo3721ulqpRjZ38jKiaUE+d3o9Foy4SMDEzo4z0Kf99gfNoMQl+v4X3AzClJIi51I7EpYdzIrXiz0N2mL97OQXg5j8LGpHLlboLwqKqUtP/888889dRTLF68mA0bNuDv70/z5s3vm7wrFAref//9R3r+1157jeTkZAYPHkyLFi0oKSnhxIkTbNiwAUtLS77++mv52M8//5w9e/YQGBjIzJkzsbKyYvny5dy6dYudO3eKjZUEQagzrt5MZP7yN4iJ2wuAm0tr3p78DX27aReXNnFyZ0D34Q/cEVWoOdfSTxB+JoToK7+i1qgAcLZuS6DPTPq2m4CxobmOI9QdSZK4dOskUTGh7D+1nvyiLHnO2bIDo/ynM7DLS5ibWuswypqRXXxdm6inhpGUe0weV6CghU1ffMoTdWuTxv1hTqgdVUraP/roI3mjj7S0NNavX//AY6uStL/00kusWbOGtWvXkp6ejkKhoEWLFvzrX//inXfeoXnzu3Vhbdq04dChQ/z73//miy++oKysjK5du7J79278/f2r8vIEQRCqVVFxAT+GfcJPv4WgVqswNjIheOR7jB/xDsZGFW926Ovri11Oa4m2Xn0HEbEhnE/+Ux7v0GQgQ3xm4dPi6UZdr56dn8q+k+uIignlekq8PG5v3RS/bhMY0GkMZ6IvE9j9qQa1MDCr+Jq29CUljKS84/K4AgXutv20ibrTSKxMmugwSqExqlLSvmrVquqOo4Lnn3+e559/vtLHe3h4sG3bthqMSBAE4dFJksTeI5sIWTVTLnnp5/sss15eiJtLq4c8WqgppcpCDp4PJSJ2IWl5lwBtvXqP1i8S6DMTd8euOo5Qd5SqMo4n7iAqJpSYc7vk8hdDA2N6ez1HgO8kOrX1Q19PH6VSyRku6zji6pFVdFW+o34zL1oeV6CgpW3/8tKXkVgZN452nkLdVKWkfeLEidUdhyAIQoNy7dZ5vlrxJsfOaDdAaeLcktkvL6J/92d1HFnjlV1wi6iEb9l/9gcKS7UdTsyMbBjo+Sr+nm802np1SZK4cvs0UTGh/HHyJ/KKMuW5Ds174e8bTL/OL2BhaqO7IGtAVtFVYlPDiEsN42ZejDyuQI+Wtv3LS19GYml87xo7QdCFKiXtgiAIwv2VKUv4/uf/sH7HAlQqJUaGxkx47l0mPvdvTIxNdR1eo3Qt/SQRsQs4fnmDXK/uZNWGQJ8Z9G0/ERNDCx1HqBs5BWn8cWo9UdGruJocK4/bWbkyuNsE/H2DaebUQYcRVr/MoivEpYYRmxrGrbwT8rgCPVrZDsDbRVv6YmnsrMMoBeH+HjtpP3LkCAcOHKjQF71fv3707t37sYMTBEGoLyRJYv/xrXy/7U3yCtMB6NP1Sd6e/A3NXNvoOLrGRyNpiL2+k/DYEM7d/kMeb+/an0CfWXRu8Qx6DbDDycOo1EqiE3cSFRNKdOJO+UOMoYExvT1H4OcbTJe2/ujrN5x7ehlFl4hL0Sbqt/NPyeMK9GhtN0hb+uL0HBbGTjqMUhAersq/lRcuXGD8+PHExGi/UpIkbV/hO91afH19WbduHW3bNswerYIgCHfcuH2Rr358iyOndgPg4tiCtycvon/3YaKDVS0rVRZy6MIaImIXkJp7EdDWq3dv9TyBPjNp6dQ49+64cvuMXP6SW/6hEqBdsx74+wbTv/OLWJrV/qaJNSWj8KJc+nI7/7Q8rqfQp5XtIHxcgvB0eg4LI0fdBSkIj6hKSXtycjIDBgwgNTWVJk2aEBQUhLu7OwqFgmvXrhEWFkZ0dDQDBw4kJiYGV1excEMQhIanpLSIVZs+Z+3W+ShVZRgaGNHDYzifvLMcS4uG1/6uLitWZ7El5n3+PLecwlJtS0JTI2sGdvwXfl5vYG/R+Da5yS3MYP+p9URGr+LK7dPyuK2lC4O7jse/ezDNnTvqLsBqll54QS59Sc4/I4/rKfRpbTcYb+cgPJ1GiERdqLeqlLR/+umnpKamMnPmTD7//HOMjIwqzH/55ZfMnTuXkJAQ/vvf/7J48eJqCVYQBKGu2H98OyErp3M77RoAvToHMmNiCPGnL2FibKbb4BqRGxmn+f30VxxL+wUp7U69emsCvKfzRIdJja5eXaVWEnPu9/Lylx2o1EoADPSN6Ok5jADfSXRtF9hgyl/SC89r76inhJFccLcuX5uo++FTnqibGznoMEpBqB5V+q3dtWsX7du3r7DJ0V8ZGhryv//9j507d7Jjxw6RtAuC0GDcTLnC1yunczBmBwDODs2Y9fJCBvV8DpVKRfzpSzqOsOHTSBpib+wi/EwI527vk8fbOj/B0M6z6dzi2UZXr34tOY6omFD2nVxHTkGaPN7WzVcuf7Eyt9dhhNUntSCRuPLSl5SCu/3j9RQGtLHzk++omxs1jNcrCHdUuTxm1KhR/3iMQqGga9eubNq0qUqBCYIg1CUlpcWs3Tqf0M2fU6YsxcDAkLHDZjN59H8wNWm8u2XWplJlEYfL69VTci8A2juqvi1HY5rry9hnpjeoTX4eJq8wU9v9JSaUy7dOyuM2Fk4M6joef9+JuLt66zDC6pNacFa+o55amCCP6ykMaGsfUJ6oD8fM0E6HUQpCzapS0m5lZUVSUtJDj0tKSsLKyqoqpxAEQagzDsbs5Ksf3+JW6hUAevj4884ri3F3a1jt8OqqnMJk9iQsYV/CdxXr1T2m4uf9JlbGLuzatUvHUdYOtVrFifO7iYoJ5djZ7X8pfzGkh8ezBHSfRNf2QzDQr/8fXlIKEuSuL2mFZ+VxfYWhnKh3dBqOmWHDWUArCP+kSkl779692bFjBzt37uTpp5++7zG7du3i0KFDPPus2EhEEIT66XbaNUJWzmD/ce2Oy052TZn58gL8eo8WXWFqwY2MM0TELuDopfWoNdrk1NGyJQE+M3ii/SRMjSwBUCqVugyzVlxPSSAqJpS9J9aSU5Aqj7du2hV/32AGdHkJa/P6XbctSRKpBQly15e0wkR5TpuoB+LjHISH0zCRqAuNUpWS9n//+9/s2rWL5557jhdeeIExY8bg7u4OwPXr1/n555/ZsGEDenp6/Pvf/67OeAVBEGpcaVkJ67Z9xapNn1FaVoK+vgFjnp3JK0EfYGbauBY21jaNpCHuxm4iYkM4e2uPPN7WpS+BPrPo6j680dSr5xdlsf/0BvbEhHIhKVoetzZ3ZFDXcfj7BtOyiY8OI3x8kiSRUhAvd31JLzwnz+krjGhnH4i3SxAdHYdhamiju0AFoQ6o8p32VatW8a9//YuffvqJ9evXV5iXJAlTU1N++OEHevXqVS2BCoIg1IbDJ3fz1Y9vkpSsXVDq6zWId6Z8S6tmDac1Xl1Upirm8IW1RMQuIDlHm7jpKfTxbTWaQJ+ZtHbuqeMIa4dareLkhQiiYkI5mrANlboM0Paa7+HxDP7dJ+Hb4cl6Xf4iSRLJBbHEpYQRl7qR9KLz8py+woj2DkPxdg7Cw/FZTA1F61RBuKPKPZ/GjRvHwIEDWb58OQcPHuT27dsANGnShH79+jF58mSaNWt8fXEFQaifUtJvELJqJvuObgbAwdaVGcFfE/jEi6IUpgblFqWwN2EpexO+o6AkAwBTIyv6e0zB3+tNHCxb6DjC2nEjNbG8+8tasvKS5fGWrp0I6D6JgV3GYG1Rf/uLS5JEcv4ZufQlo+iiPGegZ0w7+6H4uGgTdRMDsRZOEO7nsRq1urm5MW/evOqKRRAEodaVKUv5aXsIP4Z9QmlZMfp6+rzw9HSmvPAhFmYieagpSZmx2nr1i+tRabR3kx0s3Qnwnk6/Di9jatTwr31+UTYHzvxCZPQqLiQdl8etzB0Y1GUsfr7BtG7aWXcBPiZJkridf1oufcksutsO1UDPmPYOT5bfUX9GJOqCUAkNY3cFQRCEKjh2OpL5K97gxm1t+8AuHfszZ8oS2rTw0nFkDZNG0hCfFE74mRDO3oqSx9s492FIp1l0cR+Ovl7D/m9JrVFz+mIUUdGrOJKwFaWqFAA9PX26d3iagO6T8O3wFIYGRg95prpJm6ifktszZhZflucM9Exo7/CkdjGp4zMYG1jqMFJBqH8e+6/jjRs3SE5OprS09IHH9O/f/3FPIwiCUG1SM26yMHQWUYfDALCzcWb6xK94sv9YUQpTA8pUxRy5sI6IuAXcztZ2BFEo9PBtNZohPjNp7dzw1z7dTDtf3v1lDZl5t+Vxdxdv/MvLX2wtnXUYYdVJksTN3Jjy0peNZBVfkecM9Ezo4PCUfEfd2EAs5BaEqqpy0v7jjz/y2Wefcf369Yceq1arq3oaQRCEaqNUlvHzjoWsCPuY4pJC9PT0eP7JN/nXi/OwMBcL3qpbblFqeb36Urle3cTQkgF36tWt3HUbYA0rLM7lzzO/EBUTyrnrR+RxSzM7BnYZi79vMK2bdqmXHxQlSeJmXgzXDEIJOTqT7JKr8pyhnikdHJ/G2zmIDg5PiURdEKpJlZL2pUuX8uabbyJJEl26dKFVq1ZYWIhfSkEQ6q7ouL3MXzaNa7e0nUk6dejLnClLaNeyk44ja3huZsUTEbuAIxfWyfXq9hYtCPCeTn+PyQ26Xl2tURN7aS+R0as4Er+FMlUJoC1/8W3/JP7dJ9HD42kMDYx1HOmj0ybq0cSWd33JLrkGhkAJGOqZ0cHxaXzKE3UjA7FLsCBUtyol7QsWLMDIyIidO3cyePDg6o5JEASh2qRl3mLR6reJOLgBAFsrR96a+D+eGjAePT09HUfXcEiSRPzNCMLPhJBwM0Ieb+XUk6GdZtO15XMNul79VvoFomJWs/fEGjJyb8rjLZw9y8tfxmJn5aLDCKtGkiSSco8TmxpGfOpGskvufrtuqGeGVVkXAjq9gafzsyJRF4QaVqW/oDdv3mTQoEEiYRcEoc5SqZRs2PkNy3/5iKKSAvT09Bg95HVeHfMJluY2ug6vwVCqSjhy8SciYhdwKzsB0Nard2s5kiE+s2jj0lvHEdacopI8Dpz5laiYUM5eOySPW5jaMrDLGPx9g2nj1q3elb9IksSN3GPEldeo55TckOeM9M3p4PgMPs5BtLL2Jyr8D7ycnsLQoP72jReE+qJKSXvz5s0xNTWt7lgEQRCqxYn4P/hy+TSuJp0FwLtdL96dupT2rbroOLKGI684jb0J37E3fgn5JekAmBha0L/DK/h7v4WjVUsdR1gzNBoNZy7tJSomlCPxmylVFgOgp9Cja/uh+PsG08tzWL0rf9FIGm7kHtVueJS2idySJHnOSN+Cjo7P4u08mvYOT2Kor/3/X6lU6ipcQWiUqpS0T5w4ka+++oqsrCzs7OyqOyZBEIQqychKZtGad9j9508A2Fg58Ob4L3lmULAohakmt7ISiIhdyOGLa1GptV3D7C2a4+/9Fv07vIKZccNc0Hs74xJ7Ylaz58Rq0nPuJrTNnDwI6D6JQV3HYWflqsMIH51G0nAj50h56csmckvvlvVoE/Vh+LgE0c5+iJyoC4KgO1VK2t99912OHz/OoEGDWLRoEQMGDKh3X/8JgtBwqNQqft31Lcs2fEBhcT4KhYKRga/y2phPsbYUNxYelyRJJNyMJCJ2AXFJu+XxVk49GOIzm26tRjbIevWiknwOxoYRFRNKwtUD8ri5qQ0DOr+Ev28w7Zp1r1f//2kkDddzDpeXvmwir/SWPGesb0lHp2F4O99J1E10GKkgCH9Xpb+y+vr6/PDDD/j5+eHn54ehoSEuLi73vZOlUCi4fPnyfZ5FEATh8Z06e4D5y6dx6XocAJ5tezBnyhI6tvHVcWT1n1JVwpFL67X16lnxwJ169ecI9JlFG+fe9SphrQyNRkPclf1ERa/iUNwmSpVFgLb8pUu7QAK6T6Jnx2EYGdafhFabqB+S76jnld7tE29sYKW9o+4cRFv7QJGoC0IdVqWkPTExkUGDBpGeno4kSZSVlXHjxo2HP1AQBKGaZOaksnjNHHb+sQYAaws7po3/guF+k0UpzGPKK05nX8J37E1YQl5xGqCtV+/XYTL+3m/hZNVKxxFWv+TMK3L5S1r23Q4pbo7t8S8vf3GwbqrDCB+NRlJzLfugNlFP20x+abI8Z2xghafjcO0ddYdADPTqV/29IDRWVUraZ8+eTVpaGsHBwcycOZNWrVphbi5aPQmCUPNUahWbw7/nu/X/oaAoF4VCwQj/Kbw+7r/YWNrrOrx67XZ2IhGxCzh8YS1Ktba/uK25GwHe0xng8Qpmxja6DbCaFZcWcDB2I3tiQom7sl8eNzexpn/nF/H3DaZ985715tsEjaTmavYB4lLDiE/dTH5ZijxnYmCNp9MIvJ1H09Y+QCTqglAPVSlpP3ToED4+PqxcubK64xEEQXigM+cOM3/5NC5cPQ2AR+tuvDt1KZ5te+g2sHpMkiTO3tpD+JkQ4pJ+l8fdHX0Z2mk23VqOwkC/4bTz02g0JFw9QGT0Kg7FbaSkrBDQlnJ2aRuAn28wvb1GYGxYPxZeahP1P4lN0d5RLyhLledMDWzo6DQCH+cg2tj7Y6BnpMNIBUF4XFVK2o2MjOjYsWN1xyIIgnBfWTlpfLvu3/y2dxUAVha2vD72v4zwn4K+vr6Oo6uflOpSjl38mfDYEG5madcDKFDQpeUIhvjMoq1L33pzh7kyUrOusSdmNVEnVpOadVUeb+LQloDukxjcdTwONm46jLDy1BoVV7P/1N5RT9tMQVmaPGdqYFt+Rz2INvZ+IlEXhAakSkn7oEGDiI2Nre5YBEEQKlCr1WyJXMbSn94jvzAHgOF+k5k27nNsrR11G1w9lV+cwb6z37Mn/lvyirV3ZY0NzOnX4WUCvKfjZN1axxFWn5KyQg7FbiIqJpTYy/vkcVNjS7n8xaNF/VhMq03U95cvJt1MoTJdnjMztJPvqLe2GywSdUFooKqUtH/xxRf06NGD//znP8ybN0/c6RIEodrFXzjGl8te59yVkwC0b9mFOVOX4NO+4e6wWZOSs88REbeQQ+dX/6VevSn+Xm8xoOMUzI1tdRxh9ZAkiYSrB4mKCeVg7K8UlxYA2vKXTm388PcNprfXc5gYmek40odTa1Rczt5HXOpGElI3U6jMkOfMDO3xdHoOb+fRtLEbjL5ewylhEgTh/qqUtK9bt45nnnmGzz//nF9++YWBAwfStGnTB7Z8fP/99x87UEEQGoecvAy+XTeXbVErALAws+a1sZ8xKvBVcYPgEUmSROLtfUScCeHMjZ3yuLtjN4b4zMa31egGU69eUJLOL3s/449T60jOvNtmuIlDG/x8gxncdTxOts11GGHlqDVKLmftIzY1jIS0LRQpM+U5M0N7vJxG4u0SRGvbgSJRF4RGpkpJ+0cffYRCoUCSJC5fvvyPfdhF0i4IQmWo1Wq27fmRpevmkluQBcAzg4J5c/yX2Nk46Ti6+kWlLuPYpQ2Ex4aQlHkGKK9Xdx/OkE6zaOvyRL0oCXmYkrIiDsdtJjJ6VXn5iwSAqbEF/Tq9gL9vMB3d635tvlqj5FLWXuLkRD1LnjM3dMDTeSQ+zkG0sh3YIDexEgShcqr0279q1arqjkMQhEYs4WI085dP4+ylaADatvBhztQldPZ4QseR1S8FJZnsS/ievQlLyCnS9uU2MjCT69WdrdvoOMLHJ0kSidcOExUTyp9nfqG4NF+e8241iMAek+jjPRITo7rdhlibqO8hNjWMs2lb/5aoO+JVnqi3tB0gEnVBEIAqJu0TJ06s7jgEQWiEcvIz+e6n/2NL5DIkScLczIpXX/qE0UNfx0BfJCqVlZxznsjYhRy6sJoyVTEANmZN8Pd+iwEeU7AwsdNxhI8vPSeJPSfWsCcmlNsZl+RxZ7uWDO4yHnKb8sLISRga1t2SEZWmjEuZUdoa9bStFKuy5TkLIydt6YtzEC1t+4tEXRCEe4i/CoIg1DqNRsNve1exeO275OZra3afHDCOt8bPx8HOVcfR1Q+SJHHu9h+Ex4Zw5voOeby5QxeG+syme+sgDPTrdxeRUmUxR+K3EBUdyulLUUiStvzFxMicfp2eLy9/eQK1Ws2uXbt0HO39qTRlXMyMJC41jLNp2yhW5chzFkbOeDmNxMdFm6jrKcSaDUEQHuyxknaVSsXOnTs5fvw4GRkZ9OzZk5dffhmA27dvk5GRQceOHTEwEJ8NBEHQOnf5JF8ue534i8cAaNXMk3enLqWrZ38dR1Y3aDRqLiQfIKcoGRszV9q59kNP724yp1KXcfzyL4SfCeFG5mlAW6/eyf1ZhvjMor1r/zpfw/1PJEni3PWj5eUvGygqyZPnvFsPxN83mL7eozA1tpDH1Wq1LkJ9IJWmlIuZkcSmhHE2fRslqlx5ztLIBS/nUfg4B+Fu+4RI1AVBqLQqZ9MHDx5k3LhxJCUlIUkSCoUCpVIpJ+1Hjhzh+eefJywsjJEjR1ZbwIIg1E95Bdl8t/4/bAr/DkmSMDOx4F8vfczzT76BgUHdLWmoTTFXNrP+0HSyC2/KY7bmbozpu4gOTQbyx9kf2BO/+C/16qY80X4SAd7TcbFpp6uwq0VG7i32nlhDVEwot9IvyOPOtu74+wYz2HcCLnYtdRjhP1NpSrmQEaG9o56+vWKibuyKt9MovJ2DcLftKxJ1QRCqpEpJ+9mzZxk6dChKpZI333yTJ554gueff77CMc8++yxmZmZs2rRJJO2C0IhpNBp2/rGGxWvmkJ2n3RBmSL+XmD7xKxztmug4uroj5spmlkSM5k4HlDuyC2+xJGIUBnpGqDRlANiYueLn9SYDO07FwsReB9FWj1JlMUcTtmnLXy5GopE0ABgbmvGETxD+3YPxatn/vu2E6wKluoSLmRHaxaTp2ylV3f1WwMq4iXxHvYVNX/QUdfM1CIJQf1Qpaf/kk08oKSlh165dBAYG3vcYIyMjunbtyqlTpx4rQEEQ6q/zV08zf9k0Ys8fBqClmwdzpizB13uQjiOrWzQaNesPTefvCbuWdkylKaOZXSeGdp5Nj9Yv1Nt6dUmSOJ90nD3Roew//TOFJXfvSHu16l9e/jIaMxNLHUb5YEp1CRcydxOXupGzadspVd/tXmNl3BRvZ+0d9RY2fUSiLghCtapS0r5v3z569OjxwIT9jqZNm3LmzJkqBSYIQv2VX5jDDz9/QNjuJWg0GkxNzJny/Ee8+PRbGBrWz2SzJl1IPlChJOZBXuq7AI+m9fMDT2bubfaeXEtUTCg3087J4442zfHznYh/t4m4OrTWYYQPplQXcz5jd3npy2+UqQvkOWtjN7ydR+PtEkRz614iURcEocZUKWnPycmhWbNmDz2usLAQpVJZlVMIglAPSZLE7/vXsWjNO2TlpALg3+d5ZgR/jbODm46jq7tSci9W6rjcopQajqR6lSlLOHZ2O1ExoZw8H/6X8hdT+nqPxr97MN6tBtbJ8hdtov47salhJKbvqJiomzTD23k0Ps5BNLPuKRJ1QRBqRZWSdicnJy5duvTQ4xITEyuV3AuCUP9duh7Hl8te53TiQQBaNG3PO698S89O/jqOrO5KyblIZNwi/kxcUanjbczqfjtMSZK4eDOGqPLyl4Liu73IPVs+gZ9vMP18gjAzsdJhlPdXpi6SE/Vz6TsoUxfKczYmzbV31J2DaGbdQyTqgiDUuiol7YMHD2bt2rXs27ePQYPu/1Xtli1buHTpEtOmTXusAAVBqNsKivJYtuFDft21GLVGjYmxGa8EfcCYZ2eKUpj7kCSJC8kHCI8N4fS17UjlNev6eoaoNQ/6ZlKBnbkb7Vz71V6gjygrL4V9J9exJyaU66kJ8riDtRt+vhPx6zaRpo5tdRjh/ZWpCjmXsYu41I0kpu9AqSmS52xNWuAl31HvUa9baQqCUP9VKWn/97//zS+//MKIESP44osveO655+S57OxstmzZwttvv425uTmzZs2qtmAFQag7JEki/MDPLAydTWaOtmxjcK9RzJwUgotjcx1HV/eo1EqiL/9KeGwI1zNOyuOdmj9NYKdZFJVksyQyqHz0rwtStYniS30XVujXXhcoVaUcO/sbUTGhnDi/G41G2y/dyMCEPt6j8PcNxqfNIPTrWNxlqkISM3YSlxrGufRdf0vU3bWlLy5BuFl1F4m6IAh1RpWS9g4dOvDzzz8zfvx43njjDd544w0UCgWrV69m9erVAJiYmPDzzz/TsmXd7asrCELVXL6RwPzl0ziZsB+A5q5tefuVxfTuMkTHkdU9haXZ/HF2GXviF5NdeAsAQ30TnmgfTID3dFxtO8jHTlNsvKdPu525Gy/1XYhvq7rROleSJC7dOklUTCj7T60nvyhLnvNo0Qf/7sH083kec1NrHUZ5r1JVAecydhKbEsb5jF0oNcXynJ1pS7ydg/BxDqKpVTeRqAuCUCdVeXOlESNGEB8fz4IFC4iMjOTatWtoNBrc3NwICAhg9uzZtG5dNzsBCIJQNYXF+Sz/ZR4bdi5CrVZhbGTK5NH/Yezw2RgZGus6vDolNfcSkXGLOHBuJWUq7Z1cazMX/DzfYGDHf2Fp6nDPY3xbjaSr+/B/3BFVV7LzU9l3ch1RMaFcT4mXx+2tm+LXbQL+vsE0daxbGzyVqgpITN9BXGoY5zN+/1ui3gof5yC8XYJoatlVJOqCINR5VU7aAVq0aMHChQurKZS7Lly4wLp164iIiODy5cuUlJTQunVrgoKCmDFjBubm5vKxH330EfPmzbvv8/zvf//j7bffrvb4BKGxkSSJyEO/sjB0FulZtwEY2GMEM19eQBMnd90GV4dIkkRGaQJLo1Zy5vpvcr16M3sfAn1m0bPNixjq//OHGz09fTo0HVgL0T6cUlXG8cQdRMWEEnNul1z+YmhgTG+v5wjwnUSntn51qvylVJVPYvoOYssTdZWmRJ6zN22Nt4v2jnoTyy4iURcEoV55rKS9pqxcuZIlS5YwbNgwxo4di6GhIfv27eM///kPv/76K0ePHsXU1LTCYxYsWICDQ8U7V926davNsAWhQbp28xzzV7xBdOweANxcWvP25G/o2+0pHUdWd6jUSqKvhBF+5muuZ52E8ooRn+ZPMcRnFh5NB9erBPHyrVNExYTyx8mfyCvKlMc7NO+Fv28w/Tq/gIWpje4C/JsSVR7p+vv5KW4lF7PCUWlK5Tl7szbaO+rOQTSx7Fyv/h0EQRD+qk4m7aNHj2bu3LlYW9+tiXz11Vdp27Ytn332GT/++CNvvPFGhceMGDECd3f3Wo5UEBquouICftz4Ket/C0GlUmJsZELwyPcYP+IdjI1MdB1enVBYms3+s8uJiv9GrlfXw4gnOkxkaKdZFerV67qcgjT+OLWeqOhQribf3RTPzsqVweXlL82c6s7rKVHlcTZtO3GpYVzIDEdlVAoZ2jkHs3Zy6YurhY9I1AVBaBAqlbS3atWqyidQKBRcvnz5kR7j6+t73/EXXniBzz77jPj4+PvO5+XlYWZmhoFBnfwsIgj1giRJ7D2yiZBVM0nL1C6I7Of7LLNeXoibS9X/FjQkabmX5Xr1UpW2l7eVqTODPF6j7FYrnuv7IoaGhjqO8uFUaiXRiTuJigklOnEnao0KKC9/8RyBn28wXdr6o69fN/6mFitzSUzfTmxqGBcywlFLZfKcqaYpPVtOoHOTF3Gx8BaJuiAIDU6l/hJfu3YNhUKBJEkPP/hvqvMP582b2gTC2dn5njkfHx/y8/PR19enR48evP/++zz55JPVdm5BaAyu377AVyve5OjpCACaOLdk9suL6N/9WR1HpnuSJHEx5SDhZ0I4dW1bxXp175n0bPsSaPTYlbxLx5E+3JXbZ+Tyl9zCdHm8XbMe+PsG07/zi1ia2eowwruKlTmcTd9OXEoYFzIjKiTqjuYd8HEOwsN+BCf+vIF/q6frxYclQRCEqnik2yfdunVj3LhxDB8+/J6a8pqmVqv55JNPMDAwYMyYMfK4jY0NU6dOpU+fPtja2nL+/HkWLlzI008/zcqVKwkODn7gc5aWllJaerf2MS8vDwClUolS+aBNToRHcec6iutZux71uheXFLJ66xes3x6CSq3EyNCYccPeZvyIORgbmTbqfz+VRsnJq5uIjF/E9YwT8riX25MEeE+ng+sg7c0JTd1+v+cVZvDnmQ3sObG6QvmLraULAzqPwa/rBJo5d5THdfkaipXZJGb8RkL6Zi5lRaKW7sbiaNYBL6dReDmOwsncE4VCgVKpREFSnbzuDVldfr83ZOK6N97XrpAqcfv8119/5aeffmL37t2oVCosLCwYOXIk48aNY/Dg2llg9eabb/Ltt9/y3//+l7lz5/7jsZmZmXh5eVFSUkJSUhIWFhb3Pe5BnWfWr1+PmZlZtcQtCHWZJEmcv3GMiOgfySu/49q6aVeG9JiCnZWrjqPTrTJNAdeLIrlSuINijXYxph5GNDcbSGuzZ7E0bKbjCB9Oo1FxI/skF9L2ciMrBo2kLX/RUxjQwq4H7Z0H42bbBT2F7ru/qCggU/8YmfqHyNWLRVKo5DlTTTPs1X1wUPfFTBIbdwlCY1dUVMSYMWPIzc3FyspK1+HUmkol7XdkZWWxYcMG1q1bx9GjR1EoFLi6uvLSSy8xduxYOnfuXCNBvv/++3z66adMnTqVH374oVKPmTdvHh999BHh4eEEBgbe95j73Wlv1qwZGRkZjepNUJOUSiWRkZEEBASIr61rUWWu+82USyxYNYsjp3cD4OLYghkTv6af77ONuh44Le8yexO+5dCFULle3dLEiUEdX2NAh6lYmjo+8LF15f1+LSWOvSfXsv/UenIL0+TxNk27MbjrBJ7o9DxWZvY6i++OImUWiRnbiU/bxOXsPfKHCgBnc088HUfh5TQSJ/OO//Asdee6NzbiuuuGuO7afM3BwaHRJe2PVB5jZ2fH66+/zuuvv87Vq1dZt24d69ev5+uvvyYkJAQPDw/Gjx/PmDFjaNaseu5CffTRR3z66adMmjSJ77//vtKPu9NJJiMj44HHGBsbY2x8b89kQ0PDRvuLUFPENdWN+133ktIiQjd/wZotX6JUlWFoYMT4Ee8wadR7mBg3zm+YtPXqhwiPDeHU1a1yvbqbnTeBPjPp1eYlDA0q3zFHF+/3vMJM9p/+maiYUC7dvFvGY2PhxKCu4/H3nYi7q3etxnQ/hWWZJKRtJS41jEtZFRN1Fwtv7c6kLkE4mT96pxrxd0Y3xHXXjcZ83Rvr665yS4CWLVvy/vvv8/777xMdHc1PP/3EL7/8wnvvvceCBQtISUl57ODulK9MnDiRFStWPNLdv4sXLwL3X7QqCI3V/uPbCVk5ndtp1wDo1TmQt19ZTIsmdWsny9qiUis5cXUT4WdCuJoeLY97N3uSIZ1m0bGpX53+1kGtVnHiQjhR0as4dnY7KrW2ztNA35AeHs8S0H0SXdsPwUBft//BFZZlkJC2ldjUMC5n7UEjqeU5VwsfecMjR/P2OoxSEAShbquWPl4tWrSgVatWNGnShNTUVDQazWM/58cff8y8efMYP348K1euRE9P755jVCoVhYWFFfq5AyQlJfHdd99hb29Pnz59HjsWQajvbqZc4euV0zkYswMAJ3s3Zr+8kEG9RtbppLSmFJXmsD9xOVHxi8kqSALAQN+Yvu0mEOA9g6Z2/1yOUZPUGjUJVw+QlZeMnZUrni373bPj6PWUBKJiQtl7Yi05BanyeOumXfH3DWZAl5ewNnf4+1PXqoKydPmO+uWsvRUTdctO8oZHjuaN8wOjIAjCo6py0l5UVMTmzZv56aef2LNnD2q1Gmtra6ZMmcL48eMfK6glS5bw4Ycf0rx5c/z9/Vm/fn2FeWdnZwICAigoKKBly5aMGDECDw8PuXvMihUrKCgo4Oeff671LjeCUJeUlhUTuvm/hG7+nDJlKQYGhowdNpvJo/+DqYm5rsOrdWl5V4iMXcSBcz/+pb+6E35ebzCw46tY/UO9em04FLeZZdumk5F7Ux5zsHZj6vBF+LQeyP7TG9gTE8qFpLvfClibOzKo6zj8fYNp2cRHF2HLCsrSiU/dTFxqGFey/6iQqDex7KwtfXEOwsG8rQ6jFARBqJ8eKWnXaDSEh4ezbt06tm/fTlFREUZGRgwbNoxx48bx1FNPYWRk9NhBRUdr/0O6ceMGEydOvGd+wIABBAQEYGpqyqhRozh27Bhbt26loKAABwcH/P39mTNnDj169HjsWAShvrp4M4aVb8/iduoVALr7+DHnlW9xd6s7u1rWBkmSuJRymPDYEE5e3SLXqze182KIz6xHrlevKYfiNvPfNaOBir0BMnJv8t81o9DTM0BTvvmRvp4BPTyewb/7JHw7PKnT8peC0jTi0zYTmxrGlaw/kLj7TWtTy654uwTh7TwaB7M2OotREAShIahU0n7s2DG5Zj09PR2FQkH//v0ZN24co0ePvqc85XGFhoYSGhr60OOMjY1ZsWJFtZ5bEOq722nX+GrFWxyI+Q0AR7smzJy0AP8+QY2qFOZOvXpE7AKupB2Xx72bDWWIzyw6uvnXmeuh1qhZtm06f0/Y/0qjUeHu4kNgj5cZ2GUM1ha6+1YgvzSV+LTNxKWEcSV7f8VE3apbeenLaOzNWussRkEQhIamUkl77969USgUeHt78/bbbzNmzBiaNm1a07EJgvAISstKWLftK1Zt+ozSshL0FPq89Mx0prz4EeamlroOr9Zo69VXEBX/TZ2rV3+QhKsHKpTEPMi/RmjLZHQhvzSF+FTtHfWr2X9WSNTdrHzxlhP1VjqJTxAEoaF7pPKYs2fP8n//93/83//9X6Ufo1AoKvRCFwSh+h0+uZuvfnyTpORLAHTtOIDubUczccy/Gk1rrLS8K0TFfcOBcz9SoiwAtPXqgz2nMcjzVaxMnXQc4b3UGjWnL0axPvLeTd7uJysvuYYjqiivNJn41E3EpoZxLfuAXFoE4GbVXb6jbmfWslbjEgRBaIwqnbRLkoRKpXr4gYIg1JqU9BuErJrJvqObAXCwdWVG8NcM6jmK33//XcfR1TxJkriUeoSI2BBOXN2CJGnv/ja19SSw0yx6txlTJ+rV/+5m2nn2nFjNnhNryMy9VenH1cYutXklt4lL20RcShjXcg5WSNSbWfeUE3Vb0xY1HosgCIJwV6WS9upo4SgIQvUpU5by0/YQfgz7hNKyYvT19Hnh6elMeeFDLMysUCqVug6xRqk1KmKubCIiNqTO16vfUVicy59nfiEqJpRz14/I45Zmdgzo/BIHY8PIKUjn/nXtChxs3PBs2a9GYsstuSXfUb+ec6hCot7cupdc+mJr2rxGzi8IgiA8XLX0aRcEofYcOx3J/BVvcOP2BQC6dOzPnClLaNPCS8eR1byi0lz+PLeCqLhvyCy4AWjr1fu0HU+gzwya2nnqOMKK1Bo1sZf2EhUTyuG4zZSpSgDQ09PHt/2T+PsG06PjMxgaGOPTZnB59xgFFRN37YePqcMW3tOv/XHklNwkPnUTcalhXMs5VGGuuXVvfFyC8HIaJRJ1QRCEOkIk7YJQT6Rm3GRh6CyiDocBYGfjzPSJX/Fk/7F17q5ydUvPu0pU3Df8eW6FXK9uaeLIYK9pDPZ8rc7Vq9/OuMj+M+vZe2IN6TlJ8nhz5474+05iUNex95S69PUeyXsTNt7bp93GjanDFtLXe+Rjx5VTkkRceaJ+PedwhbkWNn3K76iPwsak2WOfSxAEQaheImkXhDpOqSxjw85FLP91HsUlhejp6fH8k2/yrxfnYWFeve1W65IH1as3se3IEJ9Z9G47tk7VqxeV5PHHqQ1sj13IsoOJ8ri5qQ0DO48hoPsk2rh1+8cPWH29R9LLc/hDd0R9FNnFN4hL3Uhcahg3co9WmHO36Yu3cxBezqOwMXGr8jkEQRCEmieSdkGow6Lj9vK/5W9w9aY2CezUoS9zpiyhXctOOo6s5qg1Kk5c2Ux4bAhX0o7J417NhjDEZxaebgF15psFjUZD3JU/iIxexeG4TZQqiwHQU+jRtf0Q/H0n0bPjsxgZVv7Dhb6e/mO3dcwuvk5c6kZiU8NIyr17DRUocLd5Am+XILycRmJtIlr3CoIg1BciaReEOigt8xaLVr9NxMENANhaOfLWxP/x1IDx6Onp6Ti6mlFUmsuBcz8SGbeoQr1677bjCPSZgZtd3anZT864TNSJ1eyJWU16zg153M2xPU3Me/Lqix/jbF+73VWyiq9p76inhJGUd3dxrgIF7rb98HHWJupWJk1qNS5BEASheoikXRDqEJVKyS+7FrNsw4cUlRSgp6fH6CGv8+qYT7A0t9F1eDXibr36j5Qo84HyenXP1xnk+RrWZs46jlCruLSAg7FhRMWEEn/lT3nc3MSaAZ1fwq97MK1cuvD7779jZ1X1xFgjqbmafYD80mQsjV1padsPPcX9y2Oyiq7Kd9Rv5kXL4woUtLTtX176MhIr45pvFSkIgiDULJG0C0IdcSJhP/OXTeNKUgIA3u168e7UpbRv1UXHkdWMSylHCI8N4cTVzXW2Xl2j0RB/9U+iokM5FLeRkrJCQLtpXJe2gfh3D6aX53CMDU0BHrvVZnzqZrafm05u6d2FqNbGbgzrsAgvZ+1C1MyiK8SlhhGbGsatvBPycQr0aGnbX3tH3XkklsYujxWLIAiCULfUeNKek5ODjY1NTZ9GEOqtjKxkFq15h91//gSAjZUDb47/kmcGBTe4Uhi1RsXJq1sIjw3hcurdRZGeboEM6TQLL7fAOlGvnpJ1lb0xa4g6sZrUrKvyeFPHdvj7BjO463gcbKp34WZ86mbWnhnN3/u055beYu2Z0XR2HUN6QSK38k/Kcwr0aGU3EB/nIDydnsPSuG58KyEIgiBUvyol7dOnT2fRokUPPS4rK4uAgABOnDjx0GMFobFRqVWE/b6EHzZ8QGFRHgqFgpGBr/LamE+xtrTTdXjV6m69+jdkFlwHwEDPiN7txhHoM7NO1KuXlBVyKHYTUTGhxF7eJ4+bmVjRr9MLBPhOokOLXjXyoUIjqdl+bjr331hJO3Y6WfuhToEere0GaUtfnJ7DwrhutbsUBEEQakaVkvbFixdjb2/PBx988MBjsrKyGDx4MHFxcVUOThAaqtOJB/ly2etcuq79/ejYpjvvTl1Kxza+Oo6semXkXSMy/hv+TFwh16tbmDgw2PN1Bnu+rvN6dUmSSLh6kKiYVRyMDaO4VNsDXqFQ0LmNf3n5ywhMjMxqNI6r2QcqlMQ8SL8WsxjY8t9YGDnWaDyCIAhC3VOlpP2JJ55g3rx5ODg48Prrr98zn5mZiZ+fH7Gxsbz11luPHaQgNBSZOaksXjOHnX+sAcDawo5p479guN/kBlUKczn1KOFnQoi5uukv9eoeBJbXqxsZmOo0vrTsG+yJWc2eE6tJzrwsjzdxaINfefmLk23t7ASaXnieI0lLK3Wsm5WvSNgFQRAaqSol7Tt27GDAgAG89dZb2NnZ8eKLL8pzGRkZDB48mPj4eGbMmEFISEi1BSsI9ZVKrWJz+Pd8t/4/FBTlolAoGO7/CtPG/hcbKwddh1ct7tarL+By6hF53NMtQNtfvVkgegrdfTApKSvicNzm8vKXvUiStuzE1NiCfp1ewN83mI7ufWulpj6t8ByxKWHEpYaRUlD5byMtRRcYQRCERqtKSbuVlRXh4eH07duXiRMnYm1tzZNPPklqaip+fn6cPXuW2bNn87///a+64xWEeufMucPMXz6NC1dPA+DRuhtzpizBq11P3QZWTYrL8vgz8U5/9Yr16gHeM2hm762z2CRJIvHaYaJiQvnzzC8Ul+bLc53aDMbfN5g+3iMxMTKv8VhSCxKJS72TqMfL43oKA1rb+nEz7zjFqhzuX9euwNrYjZa2/Wo8TkEQBKFuqnL3GCcnJyIjI+nbty9BQUGEhobywQcfcO7cOd555x2+/PLL6oxTEOqdrJw0vl33b37buwoAKwtbXh/7X0b4T0Ffv+rb0tcVGfnXiYr7hv2Jy+tcvXp6ThJ7T6wlKiaU2xkX5XFnu5b4+wbj120CznbuNR5HSkECcSna9oxphWflcX2FIW3s/fF2DsLTaThmhnZ/6R6joGLirr3zP6zDwgf2axcEQRAavsdq+eju7k5ERAT9+/fnhRdeQJIk3n33XT7//PPqik8Q6iy1Ws3pxANkZCfjYOtKZ49+6Ovro1ar2RK5jKU/vUd+YQ4Aw/xe5o1xX2BrXf/rkS+nHiU8dgExVzZWrFf3nknvduN0Vq9eqizmSPxWoqJXcfpSlFz+YmJkzhM+QQR0n0RH9ydqdO2AJEkUKq6z5+o8EtI3k1aYKM/pKwxpax+Ij3MQHk7DMDO0rfBYL+eRjO+08QF92hfKfdoFQRCExqlSSfuNGzceOGdpacnSpUsZP348Y8aM4bXXXrvn+ObNa2dBlyDUlr1HN/P1j9NJy7ybXDnZuxH05DT2HA7j3BVtL+12LTvz7tSl+LTvratQq4W2Xn1reX/1u/XqHZv6a/urNxuik3p1SZI4d/1oefnLBopK8uQ579YD8fcNpq/3KEyNLWo0hpSCOO3OpCm/km5yHq5p5/QVRrSzD8TbJYiOjsMwNbT5x+fych5JR6fhld4RVRAEQWg8KpW0u7u7P3RxliRJrF27lrVr11YYVygUqFSqqkcoCHXM3qObeXf+vZvgpGXeZMm6uQBYmFnz2tjPGBX4ar0uhSkuy+PAuZVExi0iI/8aoK1X79V2LIE+M2hm76OTuDJyb7H3xFr2xIRyM/28PO5k20K7+VG3Cbjat6qx80uSRHJBrFz6klF0QZ5TSAa0dxhCJ9cX8HAchqmh9SM9t55Cn9Z2A6s5YkEQBKG+q1TS3r9//zqxS6Eg6JparebrHx+0CY6WibEZv3xzFie7JrUXWDXLyL9OVPxi/kxcTnGZ9u61hYn9X+rVXWo9pjJlCUcTthEVE8qpCxFoyktzjA3NeMJnNH6+wXi3GlBj5S+SJJGcf4bY8sWkGUV3a+UN9IxpZz+Ujg7PceOkIcN8gjA0NKyROARBEITGqVJJ+x9//FHDYQhC/XA68UCFkpj7KSktIun2hXqZtF9OPUZ4bAgnrmxCI6kBcLXpQKDPTPq0G1/r9eqSJHEhKZqo6FXsP7OBwuIcec6zZT/8fYN5wicIMxPLGjv/7fxT5Yn6RjKLLslzBnrGtHd4Em/nIDwcn8HEwAqlUsltdtVILIIgCELj9lgLUQWhscnITq7W4+oCjUbNyWtbCT8TwqXUw/K4LuvVs/KS5e4vSWl3F3M62jTHz3cift0m0MShTY2cW5IkbuWfJC6lPFEvvrv5koGeCR0cnipP1J/G2KBmPiwIgiAIwt+JpF0QKkmj0cgLTB/Gwbbub4JTXJbPgXMriYpbRHr+VQD09Qzp3XYsgT4za71eXakq5WjCdqJiQjl5fvdfyl9M6eM9Cn/fYHxaD6qR8hdJkriVd0K+o55VfEWeM9Qzpb3DU/i4BNHB4WmMDWpuUasgCIIgPMhjJe1FRUXs27ePixcvkp+fL7dY+yuFQsH777//OKcRBJ07f+UUXy57nbgLRx9ypAJnezc6e9TdTXAy828QGf/NPfXqgzq+xmDP17Exr70PHJIkcenmCaJiQvnj1HoKirPluY7ufeXyF3PTR1vMWdlz38yLLt+ZdCPZJdfkOUM9Uzo4Po23cxAdHJ4SibogCIKgc1VO2kNDQ5k5cyZ5eXdbrEmSVGHB6p2fRdIu1Ff5hTl8v/59NoYvRaPRYGZiweDeo9ixb035EfdugjNr8sI62THmSupxwmNDiLmyUa5Xd7FpzxCfWfRuOw5jQ7NaiyUrL4U/Tv1EVEwo11Pu7g7qYO3G4G4T8PedSFPHdtV+XkmSSMo9TmxqGPGpG8kuuS7PGeqZ4eH4DN7Oo+ng8BRGBjW/S6ogCIIgVFaVkvaoqCgmT56MtbU17733Hvv27ePIkSP88MMPXL58mS1btnDx4kXeeOMNunXrVt0xC0KNkySJnX+sYfGaOWTlpgEQ+MSLzAj+Gke7JvTrPuyePu3O9m7MmryQwb3qziY4Go2amCu/EREbwsWUQ/J4x6Z+BPrMwrv50FqrV1eqyjieuIOomFBizu1Co9F+cDAyMKG313P4+wbTqa0f+nrV+4FHI2lIyj1GXOpG4lI3klNydx8JI31zOjg+g49zEO0dnsRIv/Y+uAiCIAjCo6hS0v7111+jUCjYt28fnTp1YtKkSRw5coQpU6YA8OmnnzJnzhyWLVvG1KlTqzVgQahpF6/FMn/5NE4nHgTAvWkH5kxdQnfvwfIxg3uNZED34ffdEbUuKCnL53LhDv6zcSYZf6lX79VmDIE+M2nu0KlW4pAkiSu3TxMZvYr9p9aTV5Qpz3Vo3gv/7pPo1+l5LExtqvW8GknDjdyj8mLSv+4waqRvQUfHZ/F2Hk07h6EiURcEQRDqhSol7dHR0fTq1YtOne7/H7+BgQFfffUVW7du5cMPP2TTpk2PFaQg1IaCwlx+2PAhYb9/i1qjxsTYjCnPf8hLz8zA0NDonuP19fXp5jWw9gP9B5n5N4iKX8z+xOUUl+UC2nr1gR1fxc9zWq3Vq+cUpLHv5E/siQnlanKsPG5v1YTB3Sbg5zuRZk4dqvWcGknDjZwj8mLSvNJb8pw2UR+Gj0sQ7eyHYKhfu60rBUEQBOFxVSlpLygooHnz5vLPxsbGAOTn52NpqW2BpqenR8+ePdmzZ081hCkINUeSJHb/uZ5Fq98mMycFAL/eo5kxKQQXh2Y6jq5yrqQeJyJuAdGXw+R6dQv9pgzv9R79OgTXSr26Sq0kOnEnUTGhRCfuRK3R7oRsaGBMb88R+PkG06VdQLWWv2gkDddzDpXXqG8ir/S2PGesb0lHp2F4O99J1E2q7byCIAiCUNuqlLS7uLiQlZUl/+zqqr17d+HChQo17FlZWRQXFz9miIJQcy7fSGD+8mmcTNgPQHPXtrwz5Vt6dQ7UcWQPp+2vvu2eenWPpoPx6/gWSXEaBnR4psZ35rxy+4y2+8vJn8gtTJfH2zXrgb9vMP07v4ilmW21nU8jqbmWfYi41DDi0jaRX3q3J76xgRWejsPxdh5NW/tAkagLgiAIDUaVkvYOHTpw8eLdLbz79OmDJEnMnz+fDRs2oFAoOHz4MHv37n1gCY0g6FJhcT7Lf5nHhp2LUKtVGBuZMnn0fxg7fDZGhsa6Du8fFZflc/D8KiLjFpGep+0nrq9nSM82LzHEZybNHTqjVCq5GV9zO3PmFmaw/9R6IqNXceX2aXnc1tKFwV3H4989mObOHavtfNpE/aB8Rz2/LEWeMzGwpqPjcHxcgmhrH4CBXt3+9xMEQRCEqqhS0v70008zffp0jh8/To8ePfDz88PHx4eNGzfStGlTXF1diY+PR6PRMGPGjGoOWRCqTpIkIg/9ysLQWaRnaUspBvZ8jlmTFuDq1ELH0f2zzIIk9sQt5o/EZXK9urmxHYM8X6uVenWVWsmJ87uJjF5FdOIOVGolAAb6RvT0HEaA7yS6tgtEX7969mzTSGquZv9JbEoY8WmbKShLledMDWzo6DQcb+cg2tr7i0RdEARBaPCq9L/rhAkTaNeuHc7OzoC2fn3nzp1MnjyZqKgoUlJSsLa2Zs6cOYwbN65aAxaEqrp28xzzV7xBdKx2nYWbS2vefmUxfbs+qePI/tmVtGgiYhcQffnXu/3VrdsR6DOTPu0m1Hi9+rWUeKKiV7Hv5DpyCtLk8TZu3QjwnUT/zi9iZW5fLedSa1Rczf6TuNQ7ifrd85ka2OLpNAJv59G0sffHQO/excGCIAiC0FBVKWm3trZmyJAhFcaaNm3K7t27KSoqIjc3FycnpzrT/k5o3IpLClkR9gnrfwtBpVJibGRC8Mj3GD/iHYyN6mbNs0aj5tT17YSfCeFiykF5vEOTQQzpNAuf5k/VaH/1vMJM9p/+maiYUC7dPCGP21g4MajrePx9J+Lu6l0t51JrVFzJ/oO41I3Ep26mUHm3Lt7M0I6OTiPwcQ6itd1gkagLgiAIjVb1fI/9F2ZmZpiZib7Hgu5JksS+o5sJWTWT1IwkAJ7wfYbZLy/CzaWVjqO7vxJlAQfPrSIibuED69Vrilqt4sSFcKJiQjmWsB2VugwAA31Deng8i3/3YLq1H4qB/uMvbFVrVFzO3kdcShgJaVsoVGbIc2aG9ng6Pae9o243GH29ml1IKwiCIAj1wWMn7WfOnOH48eNkZGTg6enJsGHDACgtLaW0tBQrK6vHDlIQHtX12xf4asWbHD0dAUATJ3dmT/6G/t2f1XFk95dZkMSe+G/54+wPFevVO77KYK9p2Jo3qbFz30g9S1R0KHtPriU7/+4Cz9ZNu+DvG8yALmOwNnd47POoNUouZ+0jNlWbqBcp7260ZGZoj5fTSLxdgmhtO1Ak6oIgCILwN1VO2s+fP8+kSZM4duyYPDZx4kQ5aV+/fj2vvPIKO3fuZOjQoY8fqSBUQklpEas2/Ze1W/+HUlWGoYERE557l+CRczExrnsb6lxNiyE8NqRCvbqzdVsCfWbSt90EjA3Na+S8+UXZ/Hl6A1Exq7iQFC2PW5k7MKjrOPx9g2nV5PE7P6k1Si5l7SEudWN5on63Vay5oQOeziPxcQ6ile1A9PWq/Ys/QRAEQWgwqvS/ZFJSEv379yc9PZ1hw4bRr18/3nnnnQrHPP/887z++uts2rRJJO1CjZMkif3HtxGycgbJ6dcB6N1lKO+8sphmrm10HF1FGo2a09d/Izw2hAvJB+TxDk0GMcRnJj4tnq6RenW1Rs2pC5FExaziaMI2lKpSAPT1DOju8TT+vpPw7fAkhgaPVzeu0pRxKXMPcalhJKRtpViVLc9ZGDlp76g7j6al7QCRqAuCIAhCJVXpf8yPP/6YjIwMVqxYwcsvvwxwT9Jubm5O586dK9yJF4SacDPlMl+teItDJ7V9yV0cmjN78iIG9BiOQqHQcXR3lSgLOHg+lMjYhaTlXQa0CXPPNi8R6DOTFg5dauS8SWnniIoJZd+JtWTm3d0xtKWrD/7dJzGwyxhsLJwe6xzaRD2K2NQwzqZtpViVI89pE/VR+LgE0dK2P3oKsUBdEARBEB5VlZL23bt34+PjIyfsD+Lu7k5ERESVAhOEhykpLWbNli9ZveULypSlGBgYMn74O0wa9R6mJjVTVlIVWQU3iYpfzP6zyygqywHA3NiWgR1fxc9zGrYWTav9nAXFOZxNDmf/d59zPunuB2crM3sGdh1bXv7S+bE+1Kg0pVzMjCQudSNn07b9LVF3xtt5FN7OQbS07ScSdUEQBEF4TFVK2tPS0ujbt+9Dj1MqlRQVFVXlFILwjw7E7OCrH9/idupVAHp2CuDtVxbj3rR9rcWg0ai5kHyAnKJkbMxcaefaDz29u8nptfQThJ8JIfrKr6g1KqBm69XVGjVnLu4hKiaUI/FbKFOVAKCnp49vh6fw9w2mh8czj1X+otKUciEjgrjUMM6mb6dElSvPWRq54OU8Ch/nINxtnxCJuiAIgiBUoyol7fb29ty4ceOhx124cAFX15rdpVFoXG6lXiVk5Qz+jN4OgJNdU2a9vJDBvUfVailMzJXNrD80nezCm/KYrbkbL/VZgL6eIRGxIZxP/lOe69BkIEN8ZtVIvfqt9AtExaxm74k1ZOT+JR6z5gwfMA3/7hOxtXSu8vMr1SVcyAzX3lFP306pKk+eszJuIifqLWz6iERdEARBEGpIlZL2vn37snXrVk6fPk3nzp3ve8z+/fuJj48nODj4McITBK3SshLWbv0foZv/S2lZCfr6Box9dhaTg97HzNSiVmOJubKZJRGjAanCeHbhTZZGBsk/6+sZ0KP1iwT6zMTdsWu1xlBUkseBM78SGb2KxOuH5XELU1sGdhnDwC7jOX86maf7PY2h4aO3T9Qm6ruJTQkjMf03StX58pyVcVO59EWbqNfcJk+CIAiCIGhVKWl/++232bJlC8OHD+f7778nMDCwwvzevXsJDg7GwMCAGTNmVEecQiN2+ORuvvrxTZKSLwHg6zWIOVOX0NLNo9Zj0WjUrD80nb8n7H+lQMGTnefg7/VmtdarazQazlzaW17+splSZTEAego9urYfSkD3SfTs+CyGBsYolUounNn1SM+vVBdzPmN3eenLb5SpC+Q5a2M3vJ1H4+0SRHPrXiJRFwRBEIRaVqWkvWfPnnzzzTdMnz6dZ555BjMzMxQKBZs2bWLLli3k5eWhUChYunQpPj4+1R2z0EikpN8gZNVM9h3dDICDrSszJ4UQ0PcFnXWFuZB8oEJJzP1ISHg3G1ptCfvtjEvsiVnNnhOrSc9JksebOXkQ0H0Sg7qOw86qamVoZeoizmf8TlzqRhLTd1RM1E2a4e08Gh/nIJpZ9xSJuiAIgiDoUJWbJL/++ut07dqVL774gr179yJJEvn5+ZiYmDBkyBD+7//+r1KLVe/nwoULrFu3joiICC5fvkxJSQmtW7cmKCiIGTNmYG5ecQHf+fPneffdd9m/fz9lZWV07dqVefPmMXjw4Kq+PEGHlMoyfvothB/DPqGktAh9PX1eeHo6U174EAsz3e2wq5E0nL6+o1LH5hQlP9a5ikryORgbRlRMKAlX7/ZyNze1YUDnl/D3DaZds+5V+vBSpi7iXPou4lLDOJexkzJ1oTxnY9Jce0fdOYhm1j1Eoi4IgiAIdcRj7WzSq1cvtm7diiRJZGRkoNFocHBwQF//8RajrVy5kiVLljBs2DDGjh2LoaEh+/bt4z//+Q+//vorR48exdRUu7vl5cuX6dOnDwYGBsyZMwdra2uWL1/OkCFD+P333/H393+sWITadexMFP9b8QbXb50HoEvH/syZsoQ2Lbx0FlOpspBD51cTEbeQ1NyLlXqMjdmj3/nWaDTEXdnPnphQDsZupFSp7bykp9CjS7tA/H2D6eU5HCNDk0d+7jJVIecydhGbGsa59J0oNXe7OtmatMDbOQgflyDcrKr2QUAQBEEQhJr1SEn7rl272Lp1K0lJSRgbG+Pj48OkSZNo2bIljo6O1RbU6NGjmTt3LtbW1vLYq6++Stu2bfnss8/48ccfeeONNwCYO3cuOTk5nDhxQl4UO2HCBDw9PZk2bRrnzp0TSUg9kJpxk4Whs4g6HAaAnY0z0yd+xZP9x+rs3y+78DZ74r/lj7PfU1iq3dXT1NAaCQ0lygLuX9euwM7cjXau/Sp9nuTMK+w9sYY9MatJzb4mj7s5tsfPN5jB3cbjYP3opTZqiolL/ZWzmVvLE/Viec7WxB0flyC8nYNws/IVvyOCIAiCUMdVOmkfO3YsGzZsALRbxgP89ttvfPXVV2zYsIFhw4ZVW1C+vr73HX/hhRf47LPPiI+PB6CwsJDt27czcODACl1sLCwseOWVV/jggw+Ijo6mR48e1RabUL2UyjI27FzE8l/nUVxSiJ6eHkFPvsGrL36Mhbn1w5+gBlzPOEVE7AKOXdqAWqMEwMmqNQE+M3iifTDxSRHl3WMUVEzctYnvS30XVujXfj/FpQUcjN3InphQ4q7sl8fNTKzo3+lFArpPon3zno+cTJeqCkhM38GZlF84Z7KLY2fL5Dk701b4OAfh7TyaplbdRKIuCIIgCPVIpZL2H3/8kZ9//hkDAwPGjx9Ply5dyM/PZ8eOHRw5coQJEyZw/fr1CnfGa8LNm9oFgM7O2p7TsbGxlJaW0rt373uO7dWrF4BI2uuwmLh9zF8+jas3EwHwad+Hd6cupV3LTrUei0bSEHtjF+FnQjh3e5883s61H0N8ZtG5xbNyIu7baiTTAjfe06fdztyNl/ouxLfVyPufQ6Mh4eoBomJCORgbRkmZtpZcoVDQuY0//t0n0dtrBMaGpo8Ue6kqqULC+wAAQGxJREFUn8T0HcSmhnE+43dUGu2mSijAzrQ1Pi5B+DgH0cSyi0jUBUEQBKGeqlTSvnr1avT09Pj999/x8/OTx+fOncukSZNYs2YNmzdvZtKkSTUWqFqt5pNPPsHAwIAxY8YAcPv2bQCaNr23dODO2K1btx74nKWlpZSWlso/5+VpN41RKpUolcpqi70xu3Md/3o907Nu8+26d4k89AsANlaOTBv7OU/2H4eenl6tXvtSVRFHL64jKmGRXK+up9DHt+Vo/L2m4+6o/dZHrdagVmvkx3Vq9iwdRw8h6sz3pOVexsm6Nf6dXsXQwOie+FOzr/HHyXXsPbWO1Kwr8ngT+zYM6jaBgZ3H4mjTTB6vzOsvUeVxLmMHCembuJgVgUpz931sb9oGD/sR5F1qwoi+UzEy0u6AqlKpqnCFhEdxv/e7UPPEddcNcd11Q1z3xvvaK5W0x8XF0atXrwoJ+x3vvfceq1evJi4urtqD+6sZM2Zw5MgR/vvf/9K+vXar+qIi7WI6Y2Pje443MTGpcMz9fP7558ybN++e8YiICMzMzKojbKFcZGQkao2KmMRd7D/zM2XKYhQKPbq1G8qALmNQFFmwe/fuWounRJ3FlaLfuVq4G6Wk3TjIQGGGu1kgrcyfxqzYkbPRaZzl/r3Or2Yc4fCVFRSWZcpj6377nD6tXqGlQ2+U6hKuZh7hQupebufe/d0w1DeltcMTtHMejLNlBxRFCqIPxwEP//1RUUi2fjQZ+ofJ0TuFpLj7R8tE0wQHdV/s1X0wK3ZHk6XAAoiKiqraBRIeS2RkpK5DaJTEddcNcd11ozFf93/K7RqySiXteXl5tG7d+r5zd8bv3KWuCe+//z7ffvstU6dOZe7cufL4ncT6r3fL7ygpKalwzP3MnTuXWbNmyT/n5eXRrFkzAgMDsbLSXWvBhkSpVBIZGYlTMzMWrZnF5Rva9QiebXrw9uTFtG/VpVbjSco8Q1TCNxy/fLde3cGyFf6eb9Kn7QRMjCwf+hxH4rew7OB8/r4QtbAsi8hzX+LdahAXb0ZTUqbtea5QKPBuNYjBXcfT2/M5jI0q/4GwWJnDucwdJKRt4mJWJGrpbo26g1k7vBxH4eU0Cmdz7wqlL3eue0BAQJV2RBWqRlx33RDXXTfEddcNcd1rNuesyyqVtEuS9MA2jnp62j7OGo3mvvOP66OPPuLTTz9l0qRJfP/99xXmmjRpAty/BObO2P1KZ+4wNja+7116Q0PDRvuLUN2yclLZdmAhcVf+AMDa0p43xn3BML+X5fdOTdNIGuJu7CYiNoSzt/bI421dnmBIp1l0aTHsoQtH71Br1Py4czb37xyjHYu7oq2Jd7Frhb9vMH6+E3CybVHpeIuVOZxN20ZsahgXMyNQS3fvqDuadyhfTBqEi4XXQ2vUxXtZN8R11w1x3XVDXHfdaMzXvbG+7sfq017TPvroI+bNm8fEiRNZsWLFPQmKt7c3xsbGHDly5J7HHj16FHhwJxqhZqnUKjbt/o7v1v+HwmLtDrnPBUzltbGfYWNpXysxlKmKOXxhLRGxC0jOOQdo69W7tw4i0HsmrZwffYFywtUDZOT+846oAFOHLWLYE29WeuFnkTKbs2nbiEsN42JmZIVE3cm8ozZRdwnCxcLzkWMWBEEQBKH+q3TSvnr1alavXn3fOYVC8cB5hUJRpQVwH3/8MfPmzWP8+PGsXLnyvndlLSwsePbZZ9m8eTNnzpyhUydt15GCggJWrFhB27ZtRecYHThz7jDzl0/jwtXTALjat+GTWWvo5HFvl5+akFuUwp74Jew7+x0FJdqac1MjKwZ4TMXf603sLZtX6XklSSLu8v6HHwhYWzg+NGEvUmaRkLaVuNSNXMqMqpCoO5t74l3e9cXZomOV4hUEQRAEoeGodNJ+pzf7o6rK45YsWcKHH35I8+bN8ff3Z/369RXmnZ2dCQgIALSLSffs2UNgYCAzZ87EysqK5cuXc+vWLXbu3Cla3NWirJw0vl33b37buwoAKwtbXn3xUwxKXejYpua/8UjKjCUidgFHL65HpdHWfjtYuhPgPYN+HV7GtBL16veTkXOTvSfXEhUTyq30C5V6jJ3V/XdELSzLLE/Uw7iUtQeNdPcDrYuFN97lfdSdLTyqFKsgCIIgCA1TpZL2mqpXf5Do6GgAbty4wcSJE++ZHzBggJy0t2nThkOHDvHvf/+bL774grKyMrp27cru3bvx9/ev1bgbK7VazZbIZSz96T3yC3MAGO43mWnjPsfCzIZdu+7fgaU6aCQN8UnhhJ8J4eytu51S2jj30daruw9HX+/Rq8BKlcUcTdhGVHQopy9GopG0vwNGBqYoFApKldqV6+a2YGAMqlIozAZQ4GDjhmfLuzuiFpZlkJC2ldjUMC5n7UEjqeU5Vwsf+Y66o3n7ql0EQRAEQRAavDpZ0x4aGkpoaGilj/fw8GDbtm01F5DwQPEXjvHlstc5d+UkAO1bdmHO1CX4tNeWwtRUL9UyVTFHLqwjIm4Bt7O1mzMpFHr4thrNEJ+ZtHbu9cjPKUkS528cIyomlD9Pb6CwJFee82rVH3/fYPp6j+bUxUi+3T0Kl/ZgZPKXmEog5bzE1KELKVZlkZC2hdiUMK5k76uYqFt2kheTOpq3q/pFEARBEASh0aiTSbtQ9+XkZbDkp/fYFrUCSZKwMLPmtbGfMSrw1Qd2GqoOuUWp7E1Yyt6EpRSUZABgYmjJAI8p+Hu9iYOV+yM/Z2bubbn85WbaOXncybYFft0m4tdtAq4Od1ueWjtB807w98ovQ2Pt+PH8j9ix/2yFRL2JZZfyRH00DuZtHzlGQRAEQRAaN5G0C49Eo9GwNWoFS9fNJbcgC4CnB03kzfFfYm/jXGPnvZkVT0TsAo5cWCfXq9tbtCDAezr9PSZjavRoffXLlCUcO7udqJhQTp4Pl8tfjA1N6es9Gv/uwXi3GnjPAmiNpGb7uekA/H25xJ2fUwq0GyU1teyKt0t5om7W5lFfsiAIgiAIgkwk7UIFarWa04kHyMhOxsHWlc4e/eQ752cvxTB/+TQSLh4HoG0LH+ZMXUJnjydqJBZJkoi/GUH4mRASbkbI462cejK002y6tnzukerVJUni4s0YoqJD2X/6ZwqKs+U5z5ZP4OcbTD+fIMxMHvwB4Gr2AXJLH97y8UWvdXRpMrbSsQmCIAiCIPwTkbQLsr1HN/P1j9NJy7yblDrZu/HamE+Jv3CUzRE/IEkS5qaW/OulTwh6choG+tX/FlKqSjhy8SfCY0O4nX0W0Nard2s5kiE+s2jj8mitI7PyUth3ch17YkK5npogjztYu+HnOxG/bhNp6vjPJSt5pcnEp27mSNKSSp1ToaidjaMEQRAEQWgcRNIuANqE/d35o/n7Tp9pmTeZtzhY/vnJAeN4a/x8HOzu39LwceQVp7E34Tv2xi8hvyQdABNDC/p3eAV/77dwtGpZ6edSqko5dvY3omJCOXF+NxqNtr7cyMCEPt4j8fedhE+bQej/w06oeSW3iUvbRFxKGNdyDiLddxfU+7M0rv7rIwiCIAhC4yWSdgG1Ws3XP07n7wn7X+nrG7D4g3C6ew+u9vPfykogInYhhy+uRaUuBcDOopm2Xr3DK5gZW1fqeSRJ4tKtk0TFhLL/1Hryi7LkuQ4tehPQfRL9fJ7H3PTBz5dbcov41E3EpoZxPedQhUS9uXUvvJxGceB6CPllKdz/eimwNnajpW2/+8wJgiAIgiBUjUjaBU4nHqhQEnM/arUKvWos+ZAkiYSbkUTELiAuabc83tKxO0M6zca31ahK16tn56fyx8mfiIoJ5VpKnDxub90Uv24T8Os2ETenB/dAzym5SVzqRuJSw7iec7jCXHPr3vi4BOHlNApbU+1OqvZmrVh7ZjSgoGLirl2JOqzDQvQUNddBRxAEQRCExkck7QIZ2cnVetw/UapKOHJpPRGxC7iVFQ+AAgVdWz5XXq/ep1K72CpVZUQn7iQqJpSYc7tQa7Q7ixoaGNPb6zn8fYPp3Nb/geUvOSVJxKVuJDYljBu5RyrMudv0xds5CC/nUdiYuN3zWC/nkYzvtJHt56ZXWJRqbezGsA4L8XIeWenrIQiCIAiCUBkiaRcoLSuu1HEOtlWv084vTufAmRXsTVhCXnEaAMYG5vTrMJkA77dwsm79kGfQunzrNFExq/jj5E/kFWXK4+2b98TfN5h+nV7A0sz2vo/NLr6uTdRTw0jKPSaPK1DQwqYvPuWJurVJ04fG4eU8ko5Ow7mafYD80mQsjV1padtP3GEXBEEQBKFGiKS9ESsszmfZho/YsGPhQ45U4GzvRmePR6/TTs5J5FTOEnb+cgClugQAW3M3ArzfYoDHFMyMbR76HLkF6ew79RNR0aFcTT4jj9tZuTK4vPylubPHfR+bVXxNW/qSEkZS3vG/vCIF7rb9tIm600isTJo88mvTU+jT2m7gIz9OEARBEAThUYmkvRGSJInIQ7+wMHQ26Vm3AfBq15P4C3eS2nvrtGdNXljpnU4lSeLsrT2EnwkhLul3edzd0ZchPrPwbTUaA33Df3wOlVpJdOIu9sSEcjxxh1z+YqBvRG+vEfj7BtOlbQD692k5mVV0ldjUMOJSw7iZF/OXV6KgpW3/8tKXkViJDi+CIAiCINQTImlvZK7eTGT+8jeIidsLgJtLa9555Vv6dB163z7tzvZuzJq8kMG9Hl6nrVSXcuziz4THhnAzS7sgVIECF+OejPP/Lx5uAx9ar371dixRMaHsO7mO3MJ0ebxds+74+QYzoPOLWJrZ3fO4zKIrxKWGEZsaxq28E/K4Aj1a2Q7A2yUIL6fnsDR2eejrEARBEARBqGtE0t5IFJcUsiLsE9b/FoJKpcTYyITgke8xfsQ7GBuZADC410gGdB/+wB1RHyS/OIN9Z79nT/y35BWnAnfq1V9moMdrxBy8QFuXJx6YsOcWZrD/1M9ExYRy+dZJedzGwpnB3cbj5zsRdxevex6XUXSJuBRton47/5Q8rkCPVnYD8XEOwtPpOSyNnR/5egmCIAiCINQlImlv4CRJYt+xLYSsnEFqRhIAT/g+w9uTv6Gp872bFenr69PNa2Clnjs5+xwRcQs5dH71X+rVm+Lv9RYDOk7B3NgWpVIJXLjnsWq1ihPndxMZvYrjib+hUisBMNA3pGfHYfj7BtOt/dB7yl8yCi/KpS+380/L43oKfVrZDsLHJQhPxxFYGDtV6jUIgiAIgiDUByJpb8Bu3L7I/1a8ydHT4QA0cXJn9uRv6N/92Qc+RqNRcyH5ADlFydiYudLu/9u787ioyrYP4L+ZgVkYRvYdRFBQ2UTFFQxQMZdEJck0jdRs08olNe3NJTWrx9RKXh/3hZ4e0+x90vTR3PdMcd9BxYVFQUH2da73D5qj4wzIKDKDXN/Ph09639c5c51rCC/OnHMfly4QP7JsIhHhYtoe/HF6Pk7f3CKMe9q3wcutJqCdd2y116unZJzDzmOVl7/k5N8Rxpu6tUFUu+EIDx6MRko7rW0yCy5XNuoZG5Cef0YYr7wRtCsCnWLh79gfllKHmheHMcYYY6we4ab9BVRcUoTVv87F2v/7GmXlpTA3k+LNAZPxVsynkMssqtzu+LVf8dOhj5Fd8PCadhulO4aEfodgz1dwNHkdtp+Zj1v3KldwEUGE4CbReDloPHxdulR5+UtxWR62HlmMPScTkHT74Y2h1paOiGwzFN3axsHLNUhrm7sFl3Amo/KMekb+wwcmiUVmaGbbDYFOA+Hv2B9Kqf1T1YgxxhhjrD7hpv0Fs//YZny74iOk3U0BAHQMfhkT3/4BjV19qt3u+LVfEf/HQGivHANkF6Qi/o9XYSG1RmFpDgBAamaBsObDERX4MZyt9e+3oqIcJ678gT/+Wok/z/8GNVWu/iIRm6G9X190D3kLIS16aZ2Vv5N/QTijfqfgvDBe2ah3R5BzLPwc+kEptdN5PcYYY4yxFxk37S+I1DvX8e2Kj3Hg+GYAgKOdOyaMWIjIjjFPXLFFra7AT4c+xuMNe6XKscLSHFgpXBAV9BHCW74DS7nuCi4AcPPOBew8vgZ7TiTgfu7DJ6h6ubRCVLvhiGg9BFaWDy9jycg/L9xMerfggjAuEZnDxy4KAU4D4e/YDxbm+l+PMcYYY6wh4Ka9nispLUbCf/6B1b9+iZLSYkgkZngjegLejv0cCrmyRvu4kn5A65KYqozqugb+HlE643mF2dh/ah12Hl+NK7cePsCokdIeL7UaDGmhF958bQzMzc1BREjPO4uzdzbg7J1fcLfgohBf2aj3QJBTLFo6RsPCXP+TTRljjDHGGhpu2uuxIye34x/Lx+BWejIAICSwKyaNWgQvd/1PB63KvfxbNYrLK84S/lyhrsDJKzuw6/hqHDn/H5SVlwAAxGIJ2rXog6h2wxHSojdAImzZugUZ+Wdw4d5/cDZjAzILLwv7kYik8LV/GYFOA+HnEA2FubVBuTPGGGOMNQTctNdDGZk3MX/VOOz581cAgL2NC8YNn4+o0EFPvBTmUQUl2dh7YSm2nZ5Xo3hrCxfcvnsZO4+vxu7EtbiXmybMNXEORPe/L3+xUTn9fUb9NE6lr8NJWQKOHHsYKxFJ0dy+JwKdYtHSoS8U5lY1zpkxxhhjrCHipr0eKSsrxb82z8eKDbNQXFIIiViCQX0+wqhBM2Bp0ajG+7n74Cp2nP0OBy6tREl5wd+jIhAR9PX8RIBUosTS/5uCyzf+FMZVFraIaP0Guoe8haZurQEAaXmncDTpO5y5swH3Cis/AYAYMBPL0Ny+FwKdBqKlQ1/IzWqeL2OMMcZYQ8dNez1x7OxufLN0NFJSLwEAWvt1waRR8WjmGVij7YkIyRmHse3Mtzh5/T+gv28wdbcNRFTQOKzY9AlEqvsgglbjTn/fm5qVVoDUgj8hFksQ0rwXuoe8hfZ+r8BMIkVq3glsS56KsxkbcK/oqrCtmVgOX9uXUZbWFK93+wyWCr6ZlDHGGGPsaXDTbuLu3kvFd2s+wR8H1wEAbK0c8XHcPPQKH1qjS2Eq1OU4fm0j/jgzH9fuPrxJNNCjF15uNR5+bt1w9to+ZGXeh6wQsLQH5JaAWAKoK4DiPCD/HlBSAPTq+B6GRE2HjcoJqbmJ2HFtGs7e+QX3i64J+zUXK9DcvvffZ9T7QExybL21FTIzVe0XhzHGGGOsgeCm3USVl5fh560/YOm66SgszodYLMbAlz/Ae0NmQaW0fuL2hSUPcODSCuw4+x3u5d8EAJhJZOjsMww9gsbCzdZfiM24V9l0y5SAXWNAKn+4n9JioKy4sml393DFnxnzcfb0L7hfdF2IMRcr0MKhDwKdYtHCvjdkZpbCXFlZ2TNWgjHGGGOMcdNuJBUVFTh18QCystNhb+OC4JZdIJFIAAAnzu/HN8tG4+rNcwCAQN+OmDQqHi2atnnifrPybmDH2e+w/+JyFJflAQBUcgd0DRiNrv7vo5HCEQCgVqtx5uoe7Dy+GgdPr0cjR8AjSHd/5rLK8fJS4EjONCDn73GxBVo6vIJAp4FoYd8bUrOaLS/JGGOMMcYMx027Eez+81d8u+Jj3L33cG10Rzt3vPP6TJw4txdb9yUAAKxUdvhw2Nfo23U4xGJxtfu8eucotp+Zj+PXfgGRGgDgatMSPYLGo5PPG5CaKQAA6VlXsTNxDXYdX4PMnJvC9t7NK//7+BU3mr+by/5u1B37IsgpFs3te0EqsXiWMjDGGGOMsRripr2O7f7zV0z+ZiAef/ro3Xu3MTt+JABAJBJhQNQ7eP+NObBW2VW5L7W6AidSfsP2098i+c5hYdzPrTtebjUeAR4vQywSo6gkHztOrsLO46tx7tp+IU4pt0J48GC09AvE9lujn5j7sOCNaG7f08AjZowxxhhjz4qb9jpUUVGBb1d8jMcb9keZScyxdPY+BDbvVGVMUWkeDl5ehR1nFiIzr/LaconYHJ183kCPoHHwsAuCWq3GuWv7sfPYahw6+wuKSyuXdhSJRGjtE4VuIXFw83DFpXubsD/t8xrlX1SWXfODZYwxxhhjtYab9jp06uIBrUti9CmvKENpWYneufv5t7Hz3A/Ye2EJikofAACUMltE+r+Pbv6jYa10wZ37Kfjpj5nYmbgGd+4/vFnU1d4H3UPi0MI3ADcL9+HwnU/x4ETNnoSqoZK5GBTPGGOMMcZqBzftdSgrO/2p4lIyE7H99Hwcu7YeFepyAICzlS96BI1DZ983QUQ4dGYjdh5fjTNX9wjbKWQqdAkehFb+7ZAnuoizd/6JExcf/tIglVjCzyEaAU4x2HTpY+SWpEH/pwAiWMnc4WXTxeBjZowxxhhjz46b9jpkb6N9plppA5jJgPISoCBbO05Napy+8Tu2n56Py+n7hLkWrhF4OWg8Ahv3xsWUw1j8fx/i4Jn1KCrJB1B5+UtQs64IaRUGseoeLmT+B/+9tVzYXtOoBzm/Bl+7l2EuqVzfUQQREk4PBCCCduNeeSdqdIuFEIsktVoPxhhjjDFWM9y016Hgll3gaOeOYsltOLfQXQ894xKgULshm85j6rp3cOdBEgBAIjZDu6aD8HLQOFiYOWB34losWjcO6fcePn3Uxc4bndp2g8pRjeSc7Tj6YBdQeQVNlY36owKcYjCs1S/YdOljPCh5eDbeSuaO6BYLEeAU83yKwhhjjDHGnoib9jokkUgQ++pg7L3+D505cxng0Qowl9zDvw6NAQBYSK0R4fcuwpqPxKXrf2HZ/32K08m7QFR5JlwhU6J960g4uCuQXnwEV0qWAXcq9yeTqODnGI1Ap9gqG/XHBTjFwM+xH65nH0BeSTpUMhd42XThM+yMMcYYY0bGTXsdUqsrcCbz3zproQMP10MvVxfDXuWFHkFj4aDww/5T6/HRlhAUFucKsYF+beDhbY8cnMe9kt9x7+8z6k/TqD9OLJKgqW3EUxwdY4wxxhh7Xrhpr0NX0g8gu+DhpSfmckAsAdQVQFnxwzivRpHY8N94pGZeEcbc3J3h07IJis1vIL/sBG7+vcBMbTTqjDHGGGPMtHHTXodyCitXhZFZAJb2gOSR6leUA/lZQEkhsPPESpTkA1Z2MjT38waUWSisyEAWMoAybtQZY4wxxhoabtrrkErhCJkF0MhJd04sqRzPvw/Y2tpBaaNGCWWjEBeBCm7UGWOMMcYaMm7a61BJUQUs7Sr//Ph17SIRQASo7ADgHkroYaMe5PQafOx6cKPOGGOMMdZAcdNeh67fPwCJedXzmkbezjwAr/jP4UadMcYYY4wB4Ka9TpnLahbXwqY//Byjn28yjDHGGGOs3hAbO4GGpKV7RK3GMcYYY4yxhoGb9jrU1C4CcrEd/n42kg4iQC62Q1O7iDrNizHGGGOMmTZu2uuQWCRBbOBS4abTRxFVXtMeG7iUn0DKGGOMMca0cNNexwKcYjCs1UZYyd21xq3l7hjWaiMCnGKMlBljjDHGGDNVfCOqEQQ4xcDPsR+uZx9AXkk6VDIXeNl04TPsjDHGGGNML27ajUQskqCpbYSx02CMMcYYY/WAyV4eM3fuXMTGxsLb2xsikQhNmjSpMvatt96CSCTS+/XLL7/UXdKMMcYYY4w9ByZ7pn3q1KmwtbVFmzZtkJOTU6NtEhISdMbat29fy5kxxhhjjDFWt0y2ab969Sq8vb0BAAEBAcjPz3/iNkOHDn3eaTHGGGOMMVbnTPbyGE3DbggiQm5uLtRq9XPIiDHGGGOMMeMw2TPtT8PKygp5eXmQSqV46aWXMHv2bHTo0KHK+JKSEpSUlAh/z83NBQCUlZWhrKzsuefbEGjqyPWsW1x34+C6GwfX3Ti47sbBdW+4xy4iqur5nKZDc3lMSkqK3vlPP/0UpaWlaNu2LZRKJU6fPo2FCxeioKAAW7duRffu3fVuN2PGDMycOVNn/KeffoKFhUVtHgJjjDHGGKsFhYWFGDJkCB48eIBGjRoZO50680I07fokJSUhODgYrq6uSEpK0huj70y7h4cHsrKyGtQ3wfNUVlaGHTt2ICoqCubm5sZOp8HguhsH1904uO7GwXU3Dq57Zb9mb2/f4Jr2F+rymEf5+Pjgtddew+rVq3HlyhX4+vrqxMhkMshkMp1xc3PzBvs/wvPCNTUOrrtxcN2Ng+tuHFx342jIdW+ox22yN6LWBs3a7llZWcZNhDHGGGOMsWfwQjftmstinJycjJwJY4wxxhhjT6/eXx5TUFAAiUQCuVyuNX7y5Els2LABLVu2RNOmTWu0L83l/ZpVZNizKysrQ2FhIXJzcxvsx1nGwHU3Dq67cXDdjYPrbhxc94d9Wj24LbNWmWzTnpCQgBs3bgAAMjMzUVpaitmzZwMAPD09MWzYMACVZ9N79eqF/v37w8fHR1g9ZuXKlZBIJFi6dGmNXzMvLw8A4OHhUctHwxhjjDHGalNeXh6srKyMnUadMdnVYyIiIrBv3z69c+Hh4di7dy8AICMjAxMnTsSxY8eQlpaGoqIiuLi4IDIyElOmTEGLFi1q/JpqtRppaWlQqVQQiUS1cRgNnmZFnlu3bjWoO7yNjetuHFx34+C6GwfX3Ti47pVn2PPy8uDq6gqx+IW+0luLyTbt7MWQm5sLKyurBrcsk7Fx3Y2D624cXHfj4LobB9e94Wo4v54wxhhjjDFWT3HTzhhjjDHGmInjpp09VzKZDNOnT9f7ECv2/HDdjYPrbhxcd+PguhsH173h4mvaGWOMMcYYM3F8pp0xxhhjjDETx007Y4wxxhhjJo6bdsYYY4wxxkwcN+2MMcYYY4yZOG7aG6grV65g2rRp6NixIxwcHKBSqRAcHIw5c+agoKBAJ/7y5cvo378/bGxsoFQq0aVLF+zevVvvvh88eIAPP/wQbm5ukMvl8Pf3x+LFi6Hvnme1Wo0FCxagRYsWkMvl8PDwwIQJE/TmAABbt25F586doVQqYWtri9jYWFy/fv3ZimFEhYWF8Pb2hkgkwpgxY3Tmue616/79+/jkk0/QrFkzyOVyODg4IDIyEgcOHNCKO3r0KLp37w6VSoVGjRqhZ8+eOHXqlN59pqWl4c0334SDgwMUCgVCQkKwYcMGvbElJSWYNm0avLy8IJPJ0LRpU8yePRtlZWV649euXYvWrVtDoVDAyckJb7/9NjIzM5+pBnUtPz8fX375JQIDA6FSqWBvb4/OnTtj9erVOt+bXHfDzZ07F7GxscLPkSZNmlQbXx9rbEjOdaWmdS8uLsayZcvQr18/NGnSBAqFAt7e3hg8eDAuXryodxtTqaUh7z+rI8QapMmTJ5OlpSUNGTKEvv/+e1q8eDG99tprBICCgoKosLBQiE1OTiZbW1tydHSkL7/8kuLj4yk4OJjMzMxox44dWvstKSmhdu3akZmZGY0bN46WLl1KAwYMIAA0ffp0nTw++ugjAkADBgygpUuX0rhx48jMzIwiIyOpoqJCK3bjxo0kEokoODiY4uPj6csvvyRHR0dycXGh1NTU51Kn523ChAlkaWlJAGj06NFac1z32pWSkkJNmjQhe3t7mjx5Mq1YsYLmz59Pb731Fv373/8W4o4cOUIymYy8vb1p/vz5NH/+fPL29iZLS0s6c+aM1j7v3btHXl5epFQq6fPPP6clS5ZQeHg4AaCVK1fq5NCvXz8CQCNGjKBly5bRiBEjCADFxcXpxM6fP58AUHh4OC1ZsoQ+//xzUiqV5OfnR/n5+bVen+ehoqKCwsLCSCwW0/Dhw2nJkiW0YMECat++PQGgSZMmCbFc96cDgGxtbal79+5kY2NDnp6eVcbWxxobknNdqmndL168SAAoLCyMvvjiC1q+fDlNnTqVbGxsSCqV0u7du3W2MYVaGvr+s7rBTXsDdezYMcrJydEZ/+yzzwgA/fDDD8JYbGwsicViOnnypDCWl5dHjRs3Jl9fX1Kr1cJ4fHw8AaDvv/9ea78xMTFkbm5OKSkpwti5c+dIJBJRTEyMVuz3339PAOhf//qXMFZaWkqurq7UuHFjysvLE8ZPnjxJYrGYRo0aZXgRjCwxMZEkEgl9++23ept2rnvtCgsLI3d3d0pLS6s2rl27dqRSqej27dvC2O3bt0mlUlFUVJRW7MSJEwkAbdq0SRgrLy+ndu3aka2trVbNtmzZQgBo/PjxWvsYP348AaBDhw4JY5mZmWRhYUHt2rWj8vJyYXzTpk0EgObMmWPYwRvJ4cOHCQCNHTtWa7ykpIS8vLzIyspKGOO6P52rV68Kf/b396+2aa+PNTYk57pU07pnZWVp/QzXOH/+PEmlUmrbtq3WuKnU0pD3n9UdbtqZljNnzhAAevfdd4mIKD8/n2QyGXXt2lUn9osvviAAdPToUWEsNDSULCwsqKioSCt2//79BIC+/vprYUzzC8L+/fu1YouKisjCwoJ69eoljO3YsYMA0BdffKGTR9euXalRo0ZUWlr6dAdtBOXl5dSmTRvq06cPXb9+Xadp57rXrn379mn9UlNaWkoFBQU6cUlJScIZrseNGDGCRCIRpaenC2Nubm7UtGlTndi1a9cSAPr555+FsTfeeIMA0M2bN7Vib968SQDo/fffF8aWLVtGAGjt2rU6+/b29qaWLVvW4KiNb9u2bQSAvvnmG525du3akaurKxFx3WtLdc1jfayxoTkby5N+WapKmzZtSCaTaY2ZSi0Nef9Z3eFr2pmW27dvAwCcnJwAAGfOnEFJSQk6deqkE9uxY0cAwLFjxwBUXid94sQJtG7dGnK5XCu2ffv2EIlEQqxmO7FYjPbt22vFyuVyBAcH68QCqDKP3NxcXLlyxeDjNZYFCxbg0qVLWLRokd55rnvt2rp1KwCgcePG6Nu3LxQKBZRKJXx9ffHjjz8KcU86XiJCYmIiACA9PR2pqanC+/F47KP70/zZzc0NHh4eWrEeHh5wdXU1qO6XLl1Cfn5+zQ7eiNq3bw9ra2t888032LBhA27evIlLly5hypQpSExMxIwZMwBw3etCfayxITnXN2q1Gunp6cK/tRqmUEtD339Wd7hpZ4KKigrMmjULZmZmGDJkCIDKG1EAwM3NTSdeM5aamgoAyM7ORlFRkd5YmUwGe3t7IVazb3t7e72PYnZzc0NWVhZKS0sNzsPUXb9+HdOnT8e0adOqvHmJ6167Ll++DAAYNWoU7t+/jzVr1mDlypWQSqUYNmwYVq1aBcCw4zW0NmlpaXpjNfGPx1a3byISYkyZjY0NNm3aBFtbW7z22mvw9PREy5YtER8fj40bN2LUqFEAuO51oT7W+EX5+aPPP//5T6SnpyMuLk5r3BRq+SLXvb4zM3YCzHSMHTsWR44cwZdffonmzZsDqFzdBIDeBk9zVlcTU12sJl4To4mvLlYTI5VKDcrD1L333nvw9vbG+PHjq4zhuteuvLw8AIBKpcKePXsglUoBAP3794e3tzemTp2KuLi4Wqu7vto8qe6Pxxqyb1NmaWmJgIAAREdHo3Pnzrh//z7i4+MxZMgQ/Pbbb4iKiuK614H6WOMX9f04fPgwxo8fj1atWmHq1Klac6ZQyxe17i8CPtPOAACff/45Fi1ahHfeeQdTpkwRxi0sLABULkH1uOLiYq2Y6mI18ZoYTXx1sTXd9+OxpuzHH3/Ejh07sHjxYpibm1cZx3WvXQqFAgAwePBgoWEHKs8ER0dHIyMjA5cvX661uuurzZPq/nisIfs2VWfPnkXnzp0RFRWFf/zjHxgwYABGjhyJgwcPwtnZGaNGjUJFRQXXvQ7Uxxq/iO9HYmIi+vTpA1dXV2zZskXnkkZTqOWLWPcXBTftDDNmzMDs2bMxfPhw/POf/9Sac3V1BaD/ozDNmObjMhsbGygUCr2xJSUlyMrK0vq4zdXVFVlZWXp/MKSmpsLe3l5osAzJw1SVlJRg/Pjx6N27N5ydnZGcnIzk5GTcuHEDQOU668nJycjJyeG61zJ3d3cAgLOzs86ci4sLgMrLjAw5XkNr4+rqWuVHyqmpqTqx1e1bJBIJMaZswYIFKC4uRmxsrNa4hYUF+vTpgxs3biAlJYXrXgfqY41flJ8/GidOnEBUVBSsrKywZ88evbmbQi1ftLq/SLhpb+BmzJiBmTNnIi4uDsuXL4dIJNKaDwwMhEwmw5EjR3S2/fPPPwEAISEhAACxWIw2bdrg5MmTOg3hX3/9BSISYgGgXbt2UKvV+Ouvv7Rii4uLcerUKZ1YAFXm0ahRI/j6+hpy6HWuqKgImZmZ2LJlC3x8fISviIgIAJVn4X18fLB8+XKuey3T3HSrudH6UZoxR0fHJx6vSCRC27ZtAVQ2+25ubsL78XgsAJ1apqam4tatW1qxt27dQlpamkF1b968OSwtLas5YtOg+Qe+oqJCZ668vFz4L9f9+auPNTYkZ1N34sQJ4aFGe/bsgaenp944U6iloe8/q0NGWrWGmYCZM2cSABo2bJjOA3UeNXDgQBKLxXTq1ClhTLNeuI+Pj9Z64YsWLapyvXAzMzO6fv26MHbmzJlq1wtPSEgQxkpLS8nFxUVnvfBTp06RWCymkSNHGnz8da20tJQ2bNig8/W///u/BIB69uxJGzZsoMuXLxMR17023b9/n1QqFbm5uWkdR1paGimVSvL19RXGQkJCSKVSaT04KjU1lVQqFXXr1k1rv5988kmVaxlbW1tTbm6uMP77779Xu/7ygQMHhLG7d++SQqGg9u3b611/edasWc9QjbozduxYnSVHiYiys7PJxcWFbGxshOPjuj+7Jy09WB9rbEjOxvKkup84cYJsbW3Jw8NDa313fUylloa8/6zucNPeQGmavMaNG9OaNWsoISFB6+uPP/4QYpOSksjGxoYcHR1p7ty5wpM5JRIJbdu2TWu/JSUl1LZtWzIzM6Px48fTsmXLhCdz/s///I9OHmPGjBGezLls2TIaP348mZmZUXh4uM4vEuvXr9d6MufcuXPJ0dGRnJyctB4WUd/oW6ediOte25YsWUIAyN/fn7799luaO3cuNW7cmMzNzWn79u1C3KFDh0gqlZK3tzctWLCAFixYQN7e3qRUKrV+gSKqfHCKp6cnWVpa0rRp02jJkiUUERFBAGj58uU6ObzyyisEgEaOHEnLly+nkSNHEgAaOnSoTuy8efMIAEVERNCSJUto2rRppFQqqUWLFvXmwSYpKSlka2tLIpGIhg4dSosXL6Y5c+ZQkyZNCADFx8cLsVz3p7N27VqaNWsWzZo1ixwdHcna2lr4++Prd9fHGhuSc12qad1TUlLIzs6ORCIRzZgxQ+ff2oSEBJ0nl5pCLQ19/1nd4Ka9gYqLiyMAVX6Fh4drxV+4cIGio6PJysqKFAoFhYaG0o4dO/TuOzs7m0aPHk0uLi4klUqpZcuW9MMPP2idGdYoLy+nefPmka+vL0mlUnJ1daVx48ZV+Y/j5s2bqUOHDqRQKMja2ppeffVVSk5OfuZ6GFNVTTsR1722bdy4kTp06EAWFhZkaWlJUVFRdPDgQZ24w4cPU9euXUmpVJKlpSX16NGDEhMT9e7z9u3bNHToULKzsyOZTEatW7emdevW6Y0tKiqizz77jDw9PUkqlZKXlxd98cUXVT6gatWqVRQUFEQymYwcHBxo+PDhdOfOnacvgBEkJyfTm2++SW5ubmRmZkYqlYq6dOlCGzdu1InluhtO82j5mvwcJ6qfNTYk57pS07rv2bOn2n9rAWh9EkpkOrU05P1ndUNERPSUV9YwxhhjjDHG6gDfiMoYY4wxxpiJ46adMcYYY4wxE8dNO2OMMcYYYyaOm3bGGGOMMcZMHDftjDHGGGOMmThu2hljjDHGGDNx3LQzxhhjjDFm4rhpZ4wxxhhjzMRx084YY4wxxpiJ46adsQasoKAA8+fPR2RkJJycnCCVSmFjY4NOnTph2rRpuHnzprFTrJeaNGkCkUiElJQUY6fyXK1evRoikQgzZsyo1f3m5OTAzs4OsbGxtbpffd566y2IRCLs3bv3ub/W87Bw4UKIRCL89ddfxk6FMfaccdPOWAN1+PBhNGvWDBMmTMBff/2FgIAADBw4EJ07d8bVq1cxa9Ys+Pr6YufOnXWeW0REhNGbXlPIwdhmzJgBkUiE1atX1+nrzpkzB9nZ2Zg+fbpJ5GPK3n33XTg5OeGTTz4xdiqMseeMm3bGGqBTp06hW7duyMjIwOTJk3H37l3s2rULP/30E7Zs2YKMjAxs3LgR7u7uuH37trHTZQ1Ieno6fvjhB/Tt2xcBAQHGTsfkKRQKjB07FgcOHMB///tfY6fDGHuOuGlnrIEhIgwbNgzFxcWYMWMGvvrqKyiVSq0YsViMmJgYJCYmIiQkxEiZsoZo5cqVKCkpwZtvvmnsVOqNN954AyKRCIsXLzZ2Koyx54ibdsYamG3btuHcuXNwd3fHZ599Vm2slZWVztnOwsJCzJo1CwEBAVAoFLCyssJLL72EdevW6d2H5vpuAFi+fDmCgoKgUCjg7OyMd999Fzk5OUJsSkoKRCIR9u3bBwDw8vKCSCQSvh5FRPj3v/+Nrl27wsbGBnK5HC1btsSMGTNQWFioFTto0CCIRCJMmjRJJ78rV67A0tISlpaWSEpKMiiH2lJeXo7FixejU6dOaNSoERQKBYKDg7Fw4UKUl5frxBtS00elpKRgyJAhcHBwgFKpREhICNatWyccc0REhNZrzJw5EwAwfPhwrRrou/775s2bwr4VCgVCQkKwefNmg+pARFixYgVUKhX69Omjc8w1zSchIQFhYWFo1KgRLCwsEBQUhLlz56K4uLjGuZSWliI2NhYikQgxMTEoKSkR5o4ePYrY2Fi4uLhAKpXC3d0db7/9tt57QB69pOfs2bOIjo6GjY0NlEolwsPDcfjwYb2vv3XrVkRFRcHNzQ0ymQyurq4ICwsTavAoDw8PhIWFYevWrUhLS6vxMTLG6hlijDUoo0ePJgA0btw4g7fNzc2ltm3bEgBycHCggQMHUq9evUgmkxEA+uijj3S28fT0JAA0ceJEkkql1KNHDxowYAA5OjoSAOrSpQup1WoiIsrMzKS4uDhycnIiAPTqq69SXFyc8KVRUVFBgwcPJgBkaWlJERERNGDAAPLw8CAA1L59eyosLBTi79+/T+7u7iQWi2n37t3CeGlpKYWEhBAAWrZsmUE5VEdzzNevX39ibGFhIUVGRhIAsrW1paioKOrbt69Qn+joaKqoqHjqmmokJSWRg4MDAaBmzZrR66+/Ti+99BKJRCL6+OOPCQCFh4cL8RMmTKBWrVoRAAoNDdWqwcWLF4mIaNWqVQSA4uLiyNHRkZo2bUqDBg2iTp06EQASi8W0ffv2GtWMiOjcuXMEgKKionTmapIPEdE777xDAEgul1Pv3r1p4MCBZG9vTwCoU6dOVFBQoLXfuLg4AkB79uwRxvLy8qh79+4EgEaMGEHl5eXCXHx8PInFYhKLxdShQweKjY2loKAg4f+JCxcuaO1/+vTpBIBGjx5NFhYWFBgYSIMGDRKORS6X09mzZ7W2WbRoEQEgiURCL730Eg0ePJiioqLI3d2dqvpn+/PPPycAtGLFihrXmzFWv3DTzlgDExoaSgAoISHB4G3HjBlDACgyMpJyc3OF8YsXLwoN4+bNm7W20TSYzs7OdOnSJWE8MzOTmjVrRgBo165dWtuEh4dX2/R+8803BIAiIiIoPT1dGC8pKaGRI0cSAJo8ebLWNrt37yaxWEzu7u50//59IiKaOnUqAaD+/fvrvMaTcqiOIU37Bx98QABo0KBBlJOTI4zn5uZS7969CQAtXrxY7/4NqWm3bt0IAL333ntaTei2bdvI3Nxcp2knethwrlq1Sm/umqYdAE2YMEHrl4sFCxYIv0DU1OLFiwkATZ06Ve/8k/L55ZdfCAC5urrSlStXhPGcnBwKCwsT8nzU4017VlYWtW/fXvil6FFHjhwhiURCbm5udPz4ca255cuXEwDq0KGD3pwB0Hfffac1N3bsWAJAw4YN0xpv3LgxiUQiOnbsmNa4Wq3W+uXiUZs3byYA9Oabb+qdZ4zVf9y0M9bAtGjRggDQtm3bDNouPz+fFAoFicVirTObGt9//z0BoO7du2uNaxpMzZnsR82bN48A0PTp07XGq2uYy8rKyN7enpRKJWVkZOjMFxYWkrOzM9nY2OicoZ44cSIBoNdee432799PYrGYXFxcKDMzU2c/ddG037lzh8zNzcnDw0PrkwGN9PR0kkqlFBQUpHf/Na1pUlISASBra2vKy8vT2eaNN954pqbdy8uLSkpKtObKysrIxsaGzM3Ndeaq8v777xMAWrNmjd75J+Xz0ksvEQBasmSJztzp06dJJBKRpaUlFRUVCeOPNu23b98mPz8/AkBz587V2Ue/fv30/mKqER0dTQDoxIkTOjmHhobqxGdlZREA8vT01BpXKBRkY2Oj9zWqonmPH/9eYYy9OPiadsZYjSQmJqKoqAht2rRBixYtdOaHDRsGADh06BDUarXOfI8ePXTGfH19AVSuGFJTJ06cQFZWFjp37gwnJyedeYVCgbZt2yI7OxtJSUlac7Nnz0ZwcDDWr1+PV155BUSEVatWwd7evsavX5v27t2LsrIy9OzZEwqFQmfe2dkZPj4+OHv2LIqKinTma1rTQ4cOAQB69uwJS0tLnW0GDRr01McAVC6PKZVKtcbMzMzg5eWFsrIy3Lt3r0b7uXv3LgDAxsbG4BzKysrw559/Aqi8MfNxQUFBCAoKQn5+Pk6dOqUzn5SUhNDQUFy6dAlLly7Fp59+qjWvVquxa9cuWFhY4OWXX9abQ5cuXQBA75rp+t4rOzs72Nra6nz/a75/R44cifPnz+s/4MfY2toCADIzM2sUzxirf7hpZ6yBsbOzA2D4P+6aG9yaNGmid97a2hpWVlYoKipCdna2zry7u7vOmEqlAgCtm/yeRLNu+o4dO7RuRnz0a8uWLQCArKwsrW2lUinWrFkDAMjNzcV7771XZQNWFzTHsmzZsiqP5fz58yAi3L9/X2f7mtZU0xR6eHjozaNx48bPdBz68qgql+o8ePBAaztD3Lt3D6WlpbC3t9dZDUlD872bmpqqM/fBBx/gxo0bmDt3LkaNGqUzn5WVhfz8fBQWFkIqlep9ryZOnCjEPq66GpWWlmqNxcfHw8vLCytXrkRAQACcnZ0xaNAg/Pzzz6ioqNC7n0aNGgFAlTchM8bqPzNjJ8AYq1vBwcE4dOgQTpw4gaFDh9bqvqtbXUUsrp1zBJqz+M2aNUNoaGi1sZpfUB71888/C38+deoUKioqIJFIaiU3Q2mOJTg4GK1atao2ViaT6YzVVk2fVW3lYWVlBQDIy8urlf09rrrvz0GDBuGnn37CggULEB0drfNpkua9srS0xKuvvlrt6/j7++uMGVKjoKAgXLhwAdu2bcPWrVuxd+9erF+/HuvXr0enTp2wd+9enU82NL/wWFtb1/h1GGP1CzftjDUwffr0QXx8PDZs2IBvvvkGZmY1+zHg6uoKALhx44be+QcPHiAnJwcKheKpLm+oKc0ZyxYtWhj8ZMyDBw/i66+/hrOzMwICArBz507MmTMH06ZNew6ZPpnmWMLCwvDDDz88t9dxcXEBANy6dUvvfFXjdc3R0REA9H6q8CR2dnaQSqXIyspCQUGB3rPtmk823NzcdObefvtthIaG4oMPPkDXrl2xd+9e4VIjALC3t4dcLodYLMaqVaue2/KfGnK5HP3790f//v0BAOfPn8eQIUNw5MgRLF++HB988IFWvObTLQcHh+eaF2PMeEzjNA1jrM707NkT/v7+uH37NubMmVNtbG5urnBNbdu2baFQKJCYmKhzrTgA/PjjjwCA0NDQZz7zqjmLqG+N8nbt2sHKygr79u0zqLnLzc3FsGHDUFFRgVWrVuHHH3+Eg4MDZs2ahaNHjxqUQ22JjIyERCLB77//jrKysuf2Op07dwYAbN++HQUFBTrz69ev17tdXdTgUZpPGy5fvmxwPubm5ujYsSMA6H1mwLlz53D69GlYWloiODhY7/7ff/99LFq0COnp6YiMjERycrIwZ2ZmhoiICOTm5mLXrl0GHVdt8Pf3x+jRowFUHsvjLl68CABVHhtjrP7jpp2xBkYkEuHHH3+EXC7HjBkzMGXKFJ1GjoiwadMmhISE4NixYwAApVKJESNGQK1WY/To0VrbXLlyBbNnzwYAfPTRR8+co+asvr7mTSaTYdKkScjLy0NMTAyuXbumE5OamoqEhAStsTFjxiAlJQVjxoxBz5494eTkhOXLl6O8vBxDhw7VqUF1OdQWNzc3jBgxAikpKRg8eDDu3LmjE5OcnIyNGzc+0+v4+PigW7duyM7OxuTJk7VuFN6xY0eVD8aqixo8SnMjp+Z7ztB8PvzwQwCVDzR69PsiLy8PY8aMARHh3XffhVwurzKH0aNH47vvvkNaWhoiIyNx9epVYe6zzz6DWCzG8OHD9T5gKj8/HytXrtR703BNFRYW4vvvv9e5Nl2tVmPbtm0A9N+boLn5NTw8/KlfmzFm4oy7eA1jzFgOHjwoPEDIwsKCunXrRkOGDKE+ffoI43K5nHbu3Cls8+jDlRwdHSk2NpZ69+5Ncrn8iQ9X0mfPnj3Cw3ketXHjRgJAjRo1ooEDB9LIkSNp5MiRwnxFRQUNGzaMAJBUKqUOHTrQ66+/TjExMeTv708ikYhatWolxK9fv54AkJ+fn87SiqNGjSIAWvuvSQ7V0RxzcHAwdejQQe/XF198QUSVS1RGRUURAFIqlRQaGkqDBw+m6OhoYc31fv36PXNNr1y5IjxcycfHhwYPHkzh4eEkFouF9fcff6hRamoqyeVykkgk1LNnTxoxYgSNHDlSWBtes+Tj40t2ahi6bKZarSYvLy9SqVRayzLWNB+ihw9XUigU1KdPH4qNjRWOu2PHjjV6uBLRw3XmPTw86Nq1a8L44sWLSSKREAAKCAigmJgYGjRoEHXo0EF4yFh2drYQ/6RlKh9/L7OzswkAmZubU8eOHYXva82Dw5o0aUJZWVk6+wkLCyOJREKpqanVlZgxVo9x085YA5aXl0fz5s2j8PBwcnBwIDMzM7K2tqYOHTrQ9OnT6datWzrb5Ofn08yZM8nPz49kMhmpVCoKCwujn376Se9rPE2DSVTZNGleA38/nOZxv/32G/Xp04ccHR3J3NycHB0dqW3btjRp0iRKTEwkIqLbt2+TjY0NSaVSOnnypN7j8fHxIQD066+/GpxDdcdc3dejx1xeXk5r1qyhrl27kq2tLZmbm5Orqyt16tSJZs6cSZcvX9a7f32qq+m1a9do8ODBZGdnRwqFglq3bk0JCQl08OBBAkCvv/66zjbbt2+n0NBQsrS0FHLXNLi13bQTEc2ZM4cA0Pr16/XOV5ePxtq1a6lz585kaWlJcrmc/P39ac6cOXrXwq+qaSd6uOa9p6en1jGcPHmS4uLiyNPTk6RSKVlbW5O/vz+NGDGCfv/9d62n0RratJeVlVF8fDzFxMRQ06ZNycLCgqytrSkoKIhmzpxJ9+7d09nHjRs3SCQSUd++ffW+BmPsxSAiIqqlk/aMMcbqoa+++gpTpkzBV199hcmTJxs1l4yMDHh5eaF79+7YvHmzUXOpL+bOnYupU6di69at6NWrl7HTYYw9J9y0M8ZYA1BcXIxr167Bz89Pa3zPnj3o168fioqKkJycDE9PTyNl+NCkSZMwb948nD59GoGBgcZOx6QVFRXB29sbPj4+2L9/v7HTYYw9R9y0M8ZYA5CRkQEXFxc0b94cPj4+kMvlSEpKwunTpwEA8+bNw4QJE4ycZaWcnBw0bdoUkZGR+OWXX4ydjklbuHAhxo0bh6NHj6J9+/bGTocx9hxx084YYw1AUVERpk2bhh07duDWrVvIzc2FtbU12rVrhw8//JAvq2CMMRPHTTtjjDHGGGMmjtdpZ4wxxhhjzMRx084YY4wxxpiJ46adMcYYY4wxE8dNO2OMMcYYYyaOm3bGGGOMMcZMHDftjDHGGGOMmThu2hljjDHGGDNx3LQzxhhjjDFm4v4fwLGVC+KKKToAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_memory_vs_context_length(stats, stats_quantized)" ] } ], "metadata": { "kernelspec": { - "display_name": ".venv", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -195,9 +460,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.12" + "version": "3.10.15" } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 }