{ "cells": [ { "cell_type": "markdown", "id": "baed30d2-7634-4d91-973b-74a90d9abb58", "metadata": {}, "source": [ "### How To: Train a BPNet model using the Python API\n", "\n", "There are two ways one can train a BPNet model using bpnet-lite: (1) using the Python API, as we will discuss here, and (2) using the command-line tools. Each approach has trade-offs, with the Python API likely being more familiar to those who are developers and easier to integrate into other code-bases, and the command-line tool being easier for those who are just looking to train a model as fast as possible. Because bpnet-lite aims to be as light-weight and low-level as possible, the Python API provides a great deal of flexibility to make changes to the standard pipeline.\n", "\n", "Here, we will focus on a BPNet model trained to predict CTCF binding in HepG2. Specifically, this is ENCODE Accession ENCSR000BIE. Just in case it is not clear, we use a lot of ENCODE data in these tutorials because it is well organized and easy, but there is no requirement that the data be from the ENCODE Portal. All you need are bigWigs with the signals as well as peaks and negatives (which can be calculated from the peaks using `bpnet negatives`).\n", "\n", "#### Loading the Data\n", "\n", "The first step is to provide filenames for where your data are. Unlike the command-line tool, the Python API does not handle the preprocessing of data, so you will need to provide bigWigs with your signal as well as peak and negative files and the genome you want to use. The peaks and negatives can be either bed or bed.gz and can actually be hosted remotely if necessary." ] }, { "cell_type": "code", "execution_count": 1, "id": "1bcfb436-9362-4060-bca1-56bd9ad1d308", "metadata": {}, "outputs": [], "source": [ "seq = \"/home/jmschrei/common/hg38.fa\"\n", "controls = ['ctcf-bpnet/ctcf-hepg2-control.+.bw', 'ctcf-bpnet/ctcf-hepg2-control.-.bw']\n", "signals = ['ctcf-bpnet/ctcf-hepg2.+.bw', 'ctcf-bpnet/ctcf-hepg2.-.bw']\n", "\n", "peaks = 'ctcf-bpnet/ENCFF199YFA.bed.gz'\n", "negatives = 'ctcf-bpnet/ctcf-hepg2.negatives.bed'" ] }, { "cell_type": "markdown", "id": "dd6933b6-770d-455f-8956-92984b42ec92", "metadata": {}, "source": [ "Next, we wrap the training data in a generator that will be used to train the model. This generator starts off by loading all of the peaks and negatives into memory with padding on either side equal to the maximum jitter. This includes both the sequence, which will be input to the model, the signal, which is being predicted, and the control tracks, which are optional inputs to the model. During training, slices of these padded sequences are taken to simulate the process of jittering the sequences while still allowing pre-loaded of the sequences into memory so we do not need to load from disk. We will also specify which chromosomes to use for training: this allows us to pass the same peak and negative file into each of the data loaders and have them subsequently filter out examples not on the training chromosomes." ] }, { "cell_type": "code", "execution_count": 2, "id": "e7ef9bde-5e52-4b1a-96e4-2c9ea44e369b", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Loading Loci: 100%|█████████████████████████████████████████████████████████████| 43391/43391 [00:04<00:00, 8938.63it/s]\n", "Loading Loci: 100%|████████████████████████████████████████████████████████████| 42358/42358 [00:04<00:00, 10178.07it/s]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Filtered Peaks: 197\n", "Filtered Negatives: 0\n" ] } ], "source": [ "from bpnetlite.io import PeakGenerator\n", "\n", "training_chroms = [\n", " \"chr2\", \"chr4\", \"chr5\", \"chr7\", \"chr9\", \"chr10\", \"chr11\", \"chr12\", \n", " \"chr13\", \"chr14\", \"chr15\", \"chr16\", \"chr17\", \"chr18\", \"chr19\",\n", " \"chr21\", \"chr22\", \"chrX\", \"chrY\"\n", "]\n", "\n", "training_data = PeakGenerator(\n", " peaks=peaks,\n", " negatives=negatives,\n", " sequences=seq,\n", " signals=signals,\n", " controls=controls,\n", " chroms=training_chroms,\n", " negative_ratio=0.33,\n", " random_state=0,\n", " batch_size=64,\n", " verbose=True\n", ")" ] }, { "cell_type": "markdown", "id": "6411dbd1-a3e9-4d01-a437-8819352a5461", "metadata": {}, "source": [ "Looks like a few examples got filtered. This happens when the extracted example falls off the side of the chromosomes, fall within the blacklist regions (not provided here, but can be provided), or have to many N characters in them.\n", "\n", "Next, we will load up the validation data. Because we do not need padding and do not need to sample batches for training, we can use the default extract loci function. " ] }, { "cell_type": "code", "execution_count": 3, "id": "0a6a487a-e2f0-44a4-af15-2eb6b41d3150", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Loading Loci: 100%|██████████████████████████████████████████████████████████████| 4780/4780 [00:00<00:00, 10051.56it/s]\n" ] }, { "data": { "text/plain": [ "(torch.Size([4780, 4, 2114]),\n", " torch.Size([4780, 2, 2114]),\n", " torch.Size([4780, 2, 1000]))" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from tangermeme.io import extract_loci\n", "\n", "validation_chroms = ['chr8', 'chr20']\n", "\n", "X_valid, y_valid, X_ctl_valid = extract_loci(\n", " sequences=seq,\n", " signals=signals,\n", " in_signals=controls,\n", " loci=peaks,\n", " chroms=validation_chroms,\n", " max_jitter=0,\n", " verbose=True\n", ")\n", "\n", "X_valid.shape, X_ctl_valid.shape, y_valid.shape" ] }, { "cell_type": "markdown", "id": "e6ec7bd9-6250-4d94-ba65-a6c8ae8ddafa", "metadata": {}, "source": [ "#### BPNet Model and Training\n", "\n", "Next, we can define the BPNet model architecture parameters. There are many you can modify, including the number of filters and the number of layers, but the most important ones are the number of outputs and the number of control tracks. Because we are predicting stranded outputs here, and because we have control tracks, we will set both to 2, but they do not need to be set to the same value. A note, though, is that BPNet only predicts a single log count value regardless of the number of output tracks. This is the normal behavior when predicting chromatin accessibility or transcription factor binding, but may result in odd consequences if you start making predictions for a bunch of different tracks.\n", "\n", "An important consideration when training BPNet models is setting `count_loss_weight`, which is a weight on the count loss. In the command-line API, this is automatically calculated for you, but it must be manually set when you use the Python API. It is calculated as the sum of the number of reads in an example, averaged across examples and strands. The pipeline uses the following code to determine it:\n", "\n", "```python\n", "\tif parameters['count_loss_weight'] is None:\n", "\t\tpeak_read_count = training_data.dataset.peak_signals.sum(axis=-1)\n", "\t\tcount_loss_weight = peak_read_count.mean(axis=(0, 1)).item()\n", "\t\tparameters['count_loss_weight'] = count_loss_weight\n", "```\n", "\n", "Here, we are using the value derived from the official repository so that we can have a fair comparison later on." ] }, { "cell_type": "code", "execution_count": 4, "id": "ed0fdf63-5e2e-4231-8ed2-92af8ed09167", "metadata": {}, "outputs": [], "source": [ "from bpnetlite.bpnet import BPNet\n", "\n", "model = BPNet(\n", " n_outputs=2,\n", " n_control_tracks=2,\n", " count_loss_weight=124.035,\n", " name='ctcf-bpnet/model',\n", " verbose=True\n", ").cuda()" ] }, { "cell_type": "markdown", "id": "dc1f25fc-60c1-47c5-9473-fb55ed0eb82c", "metadata": {}, "source": [ "Now, we have to specify the optimizer. Vanilla Adam with a learning rate of 0.001 is the default." ] }, { "cell_type": "code", "execution_count": 5, "id": "5a8bd1c7-1070-48f1-bbd7-cc27c7daf128", "metadata": {}, "outputs": [], "source": [ "import torch\n", "\n", "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)" ] }, { "cell_type": "markdown", "id": "09f31569-443a-41df-93dc-a8f369cd0dc3", "metadata": {}, "source": [ "BPNet also uses a scheduler that cuts the learning rate in half when a specified number of epochs have been reached without improving the loss. Note that this plays with the early stopping that is built into the `fit` function, which will usually terminate the training procedure before reaching the threshold and minimum learning rates set here." ] }, { "cell_type": "code", "execution_count": 6, "id": "8165455c-d513-4789-88bd-aa57b346b873", "metadata": {}, "outputs": [], "source": [ "scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, factor=0.5,\n", "\tpatience=5, threshold=0.0001, min_lr=0.0001)" ] }, { "cell_type": "markdown", "id": "73a07e0d-4ee2-467d-9a43-5384ccf67ec1", "metadata": {}, "source": [ "Then, we can train the model using the `fit` function. Here, we pass in a few training specific hyperparameters as well as the training and validation data." ] }, { "cell_type": "code", "execution_count": 7, "id": "e9c8fc47-d354-4ec6-9ae8-5ac4d1c5e581", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Warning: BPNet and ChromBPNet models trained using bpnet-lite may underperform those trained using the official repositories. See the GitHub README for further documentation.\n", "Epoch\tIteration\tTraining Time\tValidation Time\tTraining MNLL\tTraining Count MSE\tValidation MNLL\tValidation Profile Pearson\tValidation Count Pearson\tValidation Count MSE\tSaved?\n", "0\t898\t6.6875\t0.3842\t381.8342\t0.5251\t407.2075\t0.41983423\t0.59712267\t0.4542\tTrue\n", "1\t1796\t6.1871\t0.1942\t350.2059\t0.3744\t393.9158\t0.43557942\t0.71063036\t0.3375\tTrue\n", "2\t2694\t6.2182\t0.1949\t411.1587\t0.3707\t391.1888\t0.44186798\t0.7465077\t0.2894\tTrue\n", "3\t3592\t6.161\t0.1953\t373.5336\t0.3177\t390.0112\t0.4454455\t0.76701236\t0.2678\tTrue\n", "4\t4490\t6.1695\t0.1964\t307.6154\t0.2309\t388.776\t0.44791612\t0.7800946\t0.2423\tTrue\n", "5\t5388\t6.1677\t0.1968\t332.8315\t0.224\t389.8837\t0.4490773\t0.78811306\t0.2493\tFalse\n", "6\t6286\t6.2306\t0.2099\t322.2471\t0.1584\t387.48\t0.44984755\t0.7793525\t0.3057\tFalse\n", "7\t7184\t6.0064\t0.1968\t346.826\t0.3733\t386.7539\t0.45105067\t0.7895414\t0.2312\tTrue\n", "8\t8082\t5.9378\t0.2005\t336.1071\t0.2456\t386.9609\t0.45094076\t0.79110396\t0.2436\tFalse\n", "9\t8980\t5.9679\t0.218\t365.19\t0.3085\t386.4074\t0.45112094\t0.7961907\t0.2457\tFalse\n", "10\t9878\t6.0746\t0.201\t381.6792\t0.2964\t387.5968\t0.45169595\t0.80174756\t0.2299\tFalse\n", "11\t10776\t5.9657\t0.209\t399.4953\t0.3386\t386.7601\t0.4526868\t0.79971445\t0.2585\tFalse\n", "12\t11674\t5.967\t0.232\t315.4037\t0.2407\t387.1695\t0.45198223\t0.8061229\t0.2258\tTrue\n", "13\t12572\t5.9638\t0.2013\t338.3375\t0.2065\t385.9676\t0.45231536\t0.8021382\t0.2279\tTrue\n", "14\t13470\t5.9533\t0.2008\t345.3364\t0.2405\t385.7491\t0.45258027\t0.80415\t0.2123\tTrue\n", "15\t14368\t5.9497\t0.2008\t312.7818\t0.1463\t386.3974\t0.45249468\t0.79889864\t0.2428\tFalse\n", "16\t15266\t5.9485\t0.2009\t309.6071\t0.2257\t386.8736\t0.45289117\t0.8106955\t0.2307\tFalse\n", "17\t16164\t6.0055\t0.1993\t412.3003\t0.1695\t385.9764\t0.45309043\t0.8117003\t0.2029\tTrue\n", "18\t17062\t5.9617\t0.1963\t384.7162\t0.2055\t386.1438\t0.45205492\t0.80845743\t0.263\tFalse\n", "19\t17960\t5.956\t0.1965\t356.8955\t0.1953\t385.979\t0.45251903\t0.8099449\t0.2131\tFalse\n", "20\t18858\t5.957\t0.1962\t374.5444\t0.2541\t386.2297\t0.45311397\t0.8115832\t0.2191\tFalse\n", "21\t19756\t5.9579\t0.1961\t303.9682\t0.2139\t385.4861\t0.45325646\t0.81220305\t0.2099\tFalse\n", "22\t20654\t5.957\t0.1965\t364.9231\t0.241\t385.7539\t0.4534836\t0.81158155\t0.2145\tFalse\n" ] } ], "source": [ "model.fit(\n", " training_data, optimizer, scheduler,\n", " X_valid=X_valid, \n", " X_ctl_valid=X_ctl_valid, \n", " y_valid=y_valid, \n", " max_epochs=50,\n", " batch_size=128,\n", " early_stopping=5,\n", " device='cuda'\n", ")" ] }, { "cell_type": "markdown", "id": "4fa9ca74-9342-4102-97af-b6d4c6ffdfa8", "metadata": {}, "source": [ "Running this function will print a log to the screen containing some important statistics about training, and save this same log to disk under .log where is specified when you create the BPNet object." ] }, { "cell_type": "markdown", "id": "ae0b7887-e8bb-4964-8206-600ffd8bae17", "metadata": {}, "source": [ "#### Comparison to Official BPNet\n", "\n", "We can now compare the performance of this model to the official TensorFlow model to ensure that they are of comparable performance. First, we will load the model from the tarball uploaded to the ENCODE Portal for this experiment. See the tutorial on loading models for more details on what we are doing here." ] }, { "cell_type": "code", "execution_count": 8, "id": "a004abf4-967f-4168-a0d7-e4cb19feae52", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "BasePairNet(\n", " (iconv): Conv1d(4, 64, kernel_size=(21,), stride=(1,), padding=(10,))\n", " (irelu): ReLU()\n", " (rconvs): ModuleList(\n", " (0): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(2,), dilation=(2,))\n", " (1): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(4,), dilation=(4,))\n", " (2): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(8,), dilation=(8,))\n", " (3): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(16,), dilation=(16,))\n", " (4): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(32,), dilation=(32,))\n", " (5): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(64,), dilation=(64,))\n", " (6): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(128,), dilation=(128,))\n", " (7): Conv1d(64, 64, kernel_size=(3,), stride=(1,), padding=(256,), dilation=(256,))\n", " )\n", " (rrelus): ModuleList(\n", " (0-7): 8 x ReLU()\n", " )\n", " (fconv): Conv1d(66, 2, kernel_size=(75,), stride=(1,), padding=(37,))\n", " (linear): Linear(in_features=65, out_features=1, bias=True)\n", ")" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import tarfile\n", "\n", "from io import BytesIO\n", "from bpnetlite.bpnet import BasePairNet\n", "\n", "with tarfile.open(\"ctcf-bpnet/ENCFF328YVP.tar.gz\", \"r:gz\") as tar:\n", " model_tar = tar.extractfile(\"./fold_0/model.fold_0.ENCSR000BIE.h5\").read()\n", "\n", "official_bpnet = BasePairNet.from_bpnet(\n", " BytesIO(model_tar)\n", ")\n", "\n", "official_bpnet" ] }, { "cell_type": "markdown", "id": "006c3468-2b5c-431b-9da3-cdad3b2a25d6", "metadata": {}, "source": [ "Now, we can make predictions for both models on the validation data, making sure to pass in the control tracks for both." ] }, { "cell_type": "code", "execution_count": 9, "id": "d95ca33f-e437-401b-96bb-5f4d342fad53", "metadata": {}, "outputs": [], "source": [ "from tangermeme.predict import predict\n", "\n", "new_y_logits, new_y_logcounts = predict(model, X_valid, args=(X_ctl_valid,))\n", "official_y_logits, official_y_logcounts = predict(official_bpnet, X_valid, args=(X_ctl_valid,))" ] }, { "cell_type": "markdown", "id": "ba4a8d13-943f-47db-863a-31b828891c7d", "metadata": {}, "source": [ "Then, we can use the built-in performance measures to fairly compare the performance of the two models." ] }, { "cell_type": "code", "execution_count": 10, "id": "2eb8256a-7244-40d6-8699-cdbd42a2b701", "metadata": {}, "outputs": [], "source": [ "from bpnetlite.performance import calculate_performance_measures\n", "\n", "lite_perfs = calculate_performance_measures(new_y_logits, y_valid, new_y_logcounts)\n", "off_perfs = calculate_performance_measures(official_y_logits, y_valid, official_y_logcounts)" ] }, { "cell_type": "markdown", "id": "4483c795-3e38-4fce-bea1-819dcc9047e9", "metadata": {}, "source": [ "We can start off by looking at the log count Pearson." ] }, { "cell_type": "code", "execution_count": 11, "id": "3e855b45-ffe0-4705-8775-dba3a5fa687e", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(tensor([0.8116]), tensor([0.8123]))" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "lite_perfs['count_pearson'], off_perfs['count_pearson']" ] }, { "cell_type": "markdown", "id": "e57b713a-10d9-4348-a4f2-6b7c31db431a", "metadata": {}, "source": [ "Looks like the two are of similar performance.\n", "\n", "Next, we can look at the profile Pearson." ] }, { "cell_type": "code", "execution_count": 12, "id": "16c3b87a-5ffd-4c10-8a6c-18c8ab0f5a39", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(0.45348364, 0.4504725)" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy\n", "\n", "numpy.nan_to_num(lite_perfs['profile_pearson']).mean(), numpy.nan_to_num(off_perfs['profile_pearson']).mean()" ] }, { "cell_type": "markdown", "id": "263eb69e-ef45-4264-9428-7d461703bc4c", "metadata": {}, "source": [ "Again, it looks like they are of similar performance.\n", "\n", "As a more visual comparison of the two, we can take a look at what the predictions from the two models are at a locus of interest." ] }, { "cell_type": "code", "execution_count": 13, "id": "98d9f33a-a644-42b1-b7c9-dbe2501d30fe", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAw0AAAHqCAYAAABGP6LzAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd8E+Ufxz+XpLuFLihQQGbLaEsLAiIospThYAiCAoJsxYGggigqgoCoyBBBUUCWKAjI8KcgiIJs2VD2Xt17Jbn7/ZEmuUvuLpfRJjTf9+vVV5PnnnvuuXsud8/3+S6G4zgOBEEQBEEQBEEQEqjc3QGCIAiCIAiCIDwbEhoIgiAIgiAIgpCFhAaCIAiCIAiCIGQhoYEgCIIgCIIgCFlIaCAIgiAIgiAIQhYSGgiCIAiCIAiCkIWEBoIgCIIgCIIgZCGhgSAIgiAIgiAIWUhoIAiCIAiCIAhCFhIaCILwCn755RfExsYiNjYWBw4csNrOcRy6dOmC2NhYDBo0yA09LBuM533z5k3ZevPnzzddH7E/W/u7G6Xn6W42b96MZcuWOdXGoEGDFN2jgwYNEoxhfHw8unfvjoULF6KkpMSpPjiK8T4jCOL+Q+PuDhAEQZQnQUFBWLduHVq3bi0oP3jwIK5fv46goCA39cwzWLJkCUJCQqzKq1at6obeKOexxx7D2rVrPb6fW7ZswYULFzBkyJByOV6tWrXw2WefAQAyMjLw888/Y+7cubhz5w4+/vjjcukDQRAVAxIaCILwKrp3747Nmzfjgw8+QHBwsKl83bp1SEpKQl5enht7536aNm2K8PBwd3dDMUVFRfDz80N4ePh91e/ywt/fH4mJiabvjz76KHr06IENGzbgvffeg5+fn/s6RxDEfQWZJxEE4VX06NEDgGHF10hubi7++OMP9OnTR3SfBQsWoG/fvmjVqhWaN2+OXr164eeffwbHcYJ6HTt2xKhRo7B9+3Y89dRTiI+PR6dOnfDDDz8I6h04cACxsbHYtGkTZsyYgbZt2yIhIQEDBw7EmTNnrI5/8uRJjB49Gq1atUJ8fDx69uyJbdu2WdU7duwY+vfvj/j4eLRr1w6ff/45dDqd3ddIjm+++QaNGjXCzp07BeUTJ05Es2bNcO7cuTI7R6MJ0p49ezBp0iQ89NBDaNasGUpKSkTNkwYNGoQnn3wSR48eRf/+/ZGQkICOHTti/fr1AIC//voLvXr1QrNmzfDUU0/h77//turX1atXMX78eLRp0wZxcXHo1q0bVq1aJahjPNctW7Zgzpw5aNeuHZo3b44hQ4bg8uXLgv789ddfuHXrlsBsyIjS+8wZNBoNGjVqBK1Wi5ycHFM5x3FYtWoVnnnmGSQkJKBly5Z47bXXcOPGDcH+e/fuxZgxY/Doo48iPj4eXbp0wZQpU5CRkWF1rL/++gvPPPMM4uLi0LFjR3z33Xeiffrtt9/Qt29ftGjRAs2aNUOnTp0wadIkl50zQRCugTQNBEF4FcHBwXjiiSewfv169O/fH4BBgFCpVOjWrRuWL19utc+tW7fw3HPPoUaNGgAMk/Np06bh3r17GDt2rKDu2bNn8cknn2Ds2LGIjIzE5s2bMX36dGi1WgwbNkxQd86cOWjSpAmmTZuG3NxcLFiwAIMGDcLGjRtRq1YtAMD+/fsxfPhwNGvWDB9++CFCQkKwbds2jBs3DkVFRejduzcA4OLFixgyZAiio6Mxc+ZM+Pv7Y/Xq1QLhSAksy1oJGgzDQK1WAwBGjBiBw4cPY+LEidiwYQOio6Oxfv16bNiwAdOmTbOyV3flORp599138dhjj+HTTz9FYWEhNBrpV1lqaiomTZqE4cOHo1q1ali5ciXeffdd3LlzB7///jtGjx6N4OBgLFy4EK+88gp27NiBqKgo0zXt378/qlevjnfeeQdVqlTBnj17MG3aNGRmZlqN/RdffIHmzZtj+vTpyMvLw2effYYxY8Zg27ZtUKvV+OCDD/D+++/jxo0bWLBggVVf7bnPnOHmzZuoVKmSQDMzZcoUbNiwAYMGDcKECROQnZ2Nr776Cv3798emTZsQGRkJALh+/TqSkpLQt29fhISE4NatW1i6dCmef/55bN68GT4+PgCAffv24eWXX0ZiYiLmzJkDvV6PJUuWID09XdCXo0ePYty4cejevTvGjh0LPz8/3L59G/v373fZ+RIE4SI4giAIL2D9+vVcTEwMd+LECW7//v1cTEwMd/78eY7jOK5Pnz7cxIkTOY7juB49enADBw6UbEev13NarZZbsGAB16pVK45lWdO2Dh06cLGxsdzZs2cF+wwdOpRr3rw5V1BQwHEcZzp+r169BPvfvHmTa9q0KTd58mRTWdeuXbmePXtyWq1W0OaoUaO4tm3bcnq9nuM4jnvjjTe4hIQELjU11VRHp9NxXbt25WJiYrgbN27IXp958+ZxMTExon+dO3cW1M3IyOAeffRR7tlnn+VOnz7NNWvWjJswYYKgTlmco3EM3377bav+G7fxz3PgwIFcTEwMd/LkSVNZZmYm17hxYy4hIYG7e/euqfzs2bNcTEwM98MPP5jKXnrpJe7RRx/lcnNzBceaOnUqFx8fz2VlZQnOdcSIEYJ627Zt42JiYrijR4+aykaOHMl16NDBqv+WyN1nAwcOlL1H+fV69OjBabVaTqvVcikpKdzcuXO5mJgYbs2aNaZ6R48e5WJiYrjvv/9esP+dO3e4hIQE7tNPPxVtn2VZTqvVcrdu3eJiYmK4HTt2mLb17duXa9euHVdUVGQqy83N5Vq1asXFxMSYyr777jsuJiaGy8nJsXk+BEG4F9I0EAThdbRq1Qq1a9fG+vXr0atXL5w8eRITJ06UrL9v3z4sXrwYJ0+etPJ5SE9PN63CAkDDhg3RqFEjQZ0nn3wSe/fuxenTp/Hggw8KyhmGMX2Pjo5GUlKSKbrTtWvXcPnyZbzzzjsAINAAPProo9i1axeuXLmC+vXr48CBA2jTpo2gL2q1Gt27dxdd1ZZi2bJlAl8PAFZ272FhYZgzZw4GDRqE/v37Izo6Gh999JFoe648RyOPP/644vOpUqUK4uLiTN9DQ0MRHh6OmjVrmjQKAFCvXj0AwO3btwEAxcXF2L9/PwYMGAB/f3+rfq1cuRLHjh1D+/btTeUdO3YUHNuodbl9+7bAr0AKe+4zpVy4cAFNmzYVlI0aNcqkZQOAXbt2gWEYPP3004LzjIyMRKNGjXDw4EFBP+bOnYvdu3cjJSUFLMuatl26dAmdOnVCQUEBTp48ieeff15w7wQHB6NDhw7YsGGDqSw+Ph4A8MYbb6BPnz5o0aKFYFwIgvAcSGggCMLrYBgGvXv3xooVK1BcXIw6deoIJvN8Tpw4gWHDhqFVq1b4+OOPUa1aNfj4+GDHjh1YtGgRioqKBPXFJnbGsqysLEV1k5OTAQBpaWkAgFmzZmHWrFmi/cvMzDS1LXdspcTGxipyKG7WrBkaNGiA5ORkDBgwAIGBgaL1XHmORqpUqWKzf0ZCQ0Otynx9fVG5cmWrMsAgLACG66nT6bBixQqsWLFCUb8sj2Vs0/IeEcPe+0wptWvXxhdffAGO43D79m18/fXXWLx4MWJjY03+Penp6eA4Dg8//LBoG0YzMpZl8dJLLyElJQUvv/wyYmJiEBAQAI7j0K9fP9O1y8nJAcuyiu7Hli1b4quvvsKKFSvwzjvvoKSkBA0bNsTo0aPx5JNPOnTOBEGUDSQ0EAThlfTu3Rvz5s3Djz/+iHHjxknW27p1KzQaDRYvXixYNd2xY4dofeMkWKzMclIpVddYLywsDIBhZbhLly6ix6tbt66pbblju5p58+bh/PnzaNq0KebNm4cOHTqYJpe2ju/oORrhay7KikqVKkGtVuOZZ57B888/L1qnZs2aLjuevfeZUvz8/Eyr+QkJCWjdujWefPJJfPLJJ3jssccQFBSEsLAwMAyDVatWmQQdPsay8+fPIzk5GTNnzkSvXr1M269duyaoX6lSJTAMo/h+7Ny5Mzp37oySkhIcO3YMixcvxvjx401aKYIgPAOKnkQQhFcSFRWFYcOGoUOHDujZs6dkPaMTsEplflwWFRXh119/Fa1/4cIF0yq6kS1btiAoKMjKTGTLli2CyDi3bt3C0aNH0apVKwAGk5k6deogOTkZ8fHxon9GU6LWrVtj3759gkmZXq8XjbLkLHv37sU333yDMWPGYOnSpQgJCcEbb7whmjDMledYngQEBKB169Y4c+aMKTGa5Z9R4LEHX19fUa2BvfeZo4SFhWH8+PFIS0vDypUrARhyXHAch3v37omep9HMyiisWQoWP/74o+B7YGAgEhIS8Mcff5i0DwCQl5eHXbt2SfbN19cXrVq1wltvvQUAolG2CIJwH6RpIAjCa5kwYYLNOu3bt8fSpUsxfvx4PPfcc8jKysJ3330nuiILGJKgjRkzBmPHjkWVKlXw66+/Yu/evZgwYQICAgIEdTMyMvDKK6+gX79+yM3Nxfz58+Hr64tRo0aZ6nz00UcYMWIEhg0bhl69eiEqKgrZ2dm4dOkSTp8+jXnz5gEAxowZg507d+LFF1/EK6+8An9/f6xatQqFhYV2XZPTp0+LJndr0KABgoODkZKSgrfeegstW7bE2LFjoVKpMGfOHAwcOBCzZ8/G5MmTy+wcy5vJkyfj+eefxwsvvIABAwYgOjoa+fn5uH79Onbu3GkVSlcJMTEx+OOPP7B69WrExcWBYRjEx8fbfZ85Q8+ePbF06VJ8//33eOGFF9CiRQs899xzePfdd3Hq1Cm0bNkSAQEBSE1NxZEjRxATE4Pnn38e9erVQ+3atfH555+D4zhUrlwZu3btwt69e62O8frrr2P48OEYOnQoXnrpJej1enz77bcICAgQmOnNnTsXd+/eRZs2bVCtWjXk5OTghx9+gI+Pj0mwJAjCMyChgSAIQoY2bdrgk08+wbfffovRo0cjKioK/fr1Q3h4uNUEGQAaN26M3r17Y/78+bh69SqqVq2KSZMmiWYAHjduHE6ePIlJkyYhLy8PCQkJ+OKLL1C7dm1TnYceegg///wzFi1ahE8++QQ5OTkIDQ1F/fr10a1bN1O9mJgYLF26FLNmzcI777yDypUr4+mnn8YTTzyB999/X/H5Dh8+XLR86dKlaN26NcaPHw+GYfD555+bVsUTExMxbtw4fPrpp2jdujU6d+5cJudY3jRo0AC//PILFi5ciC+//BIZGRkICQnBAw88IHCAtofBgwfjwoULmDNnDnJzc8FxHM6dO2f3feYMKpUKEyZMwMiRI7Fs2TKMHTsWU6dORbNmzbB27VqsWbMGLMuiatWqaN68ORISEgAAPj4+WLRoEaZPn44pU6ZAo9GgTZs2WLZsGR577DHBMdq2bYuvvvoKX375Jd544w1UqVIFAwYMQHFxscAxv1mzZjh16hQ+++wzZGRkoFKlSoiLi8OyZcvQsGFDl543QRDOwXCcC7PGEARBeDEdO3ZEw4YNsXjxYtl6Bw4cwODBgzF37lx07dq1nHpXvnjDORIEQXgT5NNAEARBEARBEIQsJDQQBEEQBEEQBCELmScRBEEQBEEQBCELaRoIgiAIgiAIgpCFhAaCIAiCIAiCIGQhoYEgCIIgCIIgCFlIaCAIgiAIgiAIQhYSGhxk8eLF6NOnD5KSktCmTRu8/PLLuHz5sru7pQiWZXHixAmwLOvurhBlDI2190Bj7T3QWHsPNNbew/0w1iQ0OMjBgwfxwgsv4KeffsLSpUuh1+sxbNgwFBQUuLtrNuE4DlqtFhQ4q+JDY+090Fh7DzTW3gONtfdwP4y1xt0duF/57rvvBN9nzJiBNm3a4PTp02jZsqWbekUQBEEQBEEQroc0DS4iNzcXAFC5cmU394QgpGFZz13BcAal5+XO81d0bGfU0hxn+FPWGcXNWvVbZF/LOvzvHnnPOXOdpfblX3+OA7RFjh/DnrEkCIIoJ0jT4AI4jsOMGTPQokULxMTEKN6PZVm3qKH0er3gP1Fx4Y/13ewiPPXVv+jXIhpvPRHr5p65js/+OI+1h29i8ysPo1plf8l6V9Pz8eyi/RjycB2M7VC/HHsIbD5xB+9vOo2vBiSibYNI8Uqp56Ba3h3cw6+De/g1u4/BrH4WjdNuQB+3B4CvdMXzv0O1cSTYZ74GYrvLtnnwSgZGrvwPU55sjN5J0WB2TQfz33Kww3cClWsCADILStB93l50jYvCB082wR9n7uGtdSfxZb8EBPiqMXrVUXz0VBM8k1jD7nMqC5jTG8BsHQf22aVAvQ727fvHZDCnfwE78m8gqIp5A8dC9f3jgMYf7ODNUP34HHDxT3CdPwTX5lW7+6ha1RvITzdcZ5Xaajs9w70HGmvvwZ1jrVZbP2fEoIzQLuCjjz7C7t27sXr1alSrVk3xfidOnIBWqy3DnhGEmcVHsvHH5UIAwPq+yu9TT6fPz3cBAI/XC8CoFtKavn+uF+LLA9loEumDjztElFf3AJj7yABYJ3HtG+57C5XSjgAAjjy10+5jtNjcEQBw5tFvUFi5gc16So4zcMM9FOoMr4j1fauZ9k2r3R3Xmk0AAKw7k4c1p/NMdYznCgD+GgZFvP09AXvOX2rfOw0G4HbjEaZy34K7iP/zeQDA0W5bkfRbDwBAQaUGONv+G/s6yHFosaUTAODMo9+isHL5CrgEQXgfLVq0UFSPNA1O8vHHH2Pnzp1YuXKlXQIDAMTFxblN03Dy5EnEx8crli6J+xP+WEdeSwYu3wAAJCYmurdjruTn/wEAIiIikZjYVLLaVdwGDpxAQFBQ+Z9/aR8ZRvraq05XAtIMn+3uH8cBmw0fGzZsCFWNZtJ1N5s/2joOs2k7AL25bum+4RERCCvdd2/mJeD0BXOd0nMFALVKJdzfE7Dj/KX2japaFVX5+2ZeBf40fExIiAd+M3wOCPB3YCxZYIvhY2xsDFAt3qoKPcO9Bxpr7+F+GGsSGhyE4zh8/PHH2L59O1asWIFatWrZ3YZK5V6XErVa7bE3JuFa1Go1GIYRfK9wMIzseXEwnD/Luff8JY/NM0Oxu3+sWZ2tUin/Xduqx1/T4NdVMQxQ+l2tVonWMdVTeCx34GifVAxM528uKG0T5ovGQP6eFEVv3l+tYoTHsYCe4d4DjbX34MljTUKDg3z00UfYsmULFi5ciKCgIKSmpgIAQkJC4O8vbVdNEETZYEtrpy91YNV7omMuADBOLCJwZRPXm1WgCeULBpbIbLq/sbze/OvE6lzXdhmNK0EQhCOQ0OAga9asAQAMGjRIUD5jxgz07t3bHV0iCK/G1gRXzxr/e6jQACdm2GVk5qikWTnBgKmoUoPlheFP7vXO+qnx2iahgSAID4KEBgc5d+6cu7tAEAQPWxNcfWkFjxUaPFDTwEGJpsGxbfc1VkIDX9PgpNAg0DQ41xRBEIQroTwNBEFUCGzJAno9mSfZi5JLJWeeJLftvsbKPMmFmgYyTyIIwkPxKqFh48aNKCkpsSovKSnBxo0by79DBEG4DJs+DZzxv6cKDc5MsMvmnJT4NMhRUWUGWaFB4NPgwPXjyDyJIAjPxKuEhkmTJpkyN/PJz8/HpEmT3NAjgiBcha3pmec7Qjvj01BG5klOahoqrk+DnKaBtzDFOpCkiTQNBEF4KF4lNHAcJ/oSu3fvHkJCQtzQI4IgXMV97wjtgeZJSvBKnwZLEVVK08A5KTSQUwNBEB6EVzhC9+zZEwzDgGEYvPjii9BozKet1+tx8+ZNPPLII27sIUEQzmJLFjAKFWyFFBrcd05S2gQVY8hTUCGx0jTwhAM9T2hwRNNA0ZMIgvBQvEJo6Ny5MwDg7NmzaNeuHYKCgkzbfHx8EB0djccff9xd3SMIwgXY0jToSp0adJ4qNDgVctXzNA0Mw1RcTYPl9eYLBwLzJAdyNpBPA0EQHopXCA1jx44FAERHR6N79+7w8/Nzc48IgnA5CkOuOuvcW2Y45dNgzzkxcNrshX88Xr/5WhwVU5F9GiyuH19oEJgnOTDpF/g0eOi9ShCEV+IVQoORXr16ATBES8rIyADLCh/oNWrUcEe3CIJwAbaEAeOEtkL6NNgjBDAqx2ztJeBrE/iRqQwmoS47jGchZ57Ez9PgkCM0aRoIgvBMvEpouHr1Kt59910cPXpUUG50kD579qybekYQhLPYNE9iPdw8yWWO0DbOj2Gc96/lSQP86El8gYxBRc7TYKlp4GkX+HkaHDJP4jtVu064IwiCcBavEhomTpwIjUaDRYsWoWrVqhVXdU4QXogtSw6Pd4R2lU+DzdVpFzz3OKFwYIQvuKkqsqbBUuoS+DTwhAZnoye5UCNEEAThLF4lNCQnJ2P9+vWoX7++u7tCEISLsZkRukJrGvjnZEvT4NpI23xtgs7Cp6HiahpkHKFZJzUN/PFzaH+CIIiywavyNNSvXx+ZmZnu7gZBEGWAzYzQrKc7QrvIPMmWpsEVQgNPGODLBXwtjtf6NAhCrjrpCE3mSQRBeBBeJTRMmDABn332GQ4cOIDMzEzk5eUJ/giCuH+xnRHa0x2hy8k8yRUzeQuHZyM6gdDgEkMoz0Q2ehKZJxEEUTHxKvOkoUOHAgCGDBkiKCdHaIK4/1HqCM1y0tnh3YqroifZ0qS42DyJr+ERhlxlvMg8yZWO0HzzJBIaCILwHLxKaPjhhx/c3QWCIMoImxmheRX0LAeN2sMmtOWmaXCteRL/sgtDrnqRTwMnkafBoZCrZJ5EEIRn4lVCQ6tWrdzdBYIgygibPg287XqO87yHH38yz3H2CRH2JARz8USef92NWbcBip5kqKZ3cixJaCAIwnPwuPdmWXLo0CHZ7S1btiynnhAE4WpszZX1FpoGj4MvNLB6QG3H49mehGAuNk/iX0phyFUv0jRI+TQY6zJqO9qm6EkEQXgmXiU0DBo0yKqMb9dMPg0Ecf9iy6fhvhIaOD3sejzbE3LVxe7J/EPrKXqSUNMAGAQKlR1CA8ingSAIz8SrhAZLTYNWq8XZs2cxd+5cjBs3zk29IgjCFdjUNHAeLjTwJ/OsDoCf8l3L26eBBytxXSkjNH+brx1t830aSNNAEITn4FVCQ0hIiFVZ27Zt4evrixkzZuCXX35xQ68IgnAFNjUNeg8XGgQJD+xcYS5voYF3rTkLXxEjFdqnQTbkqsVE316/BLuyexMEQZQfXpWnQYrw8HBcuXLF3d0gCMIJbOZpkJjcegxW5kn2YE/IVdfO5Pnyl9ARGp4X1tYZ5PxGOBmfBrsFQDJPIgjCM/EqTUNycrJVWUpKCr799lvExsa6oUcEQbgKpRmhLT97DJaO0PbgzpCr/DwNFknfVBVIZpAVGqSiJ1luU3QcMk8iCMIz8SqhoWfPnmAYxmpykZiYiOnTp7upVwRBuAJbcoDHCw3OrDDbZdLi2ozQ/Eupr8gZoQXXtbzMk0jTQBCE5+BVQsOff/4p+K5SqRAeHg4/PzscDgmC8Ehs+TTwt7OeaCruzGTRnuhJ5eQIXfEyQis0T3JW00DRkwiC8FC8SmiIjo52dxcIgigjbCkP+Pb2Os+UGswf7TVLsSu5m2vNk/hYahr4QgPLclDdz/ZKctocm9GTHDwOCQ0EQXgQXiU0AMDBgwfx/fff49KlS2AYBvXq1cPw4cPx4IMPurtrBEHYicDU0I6M0La0Em7BmcmiXT4N9jUtfjzxa2mpaeAfS89xULnbYMmZcZcTzGSTu5F5EkEQFQOvip60adMmDB06FP7+/hg0aBBeeOEF+Pv7Y8iQIdi8ebO7u0cQ5YYtp+H7BYEbgI1TYlm+psEDz9+pFWZ7oieVXUZoPWepaeBt84Rr7szKfbk5QvP3JUdogiA8B6/SNCxatAhvvfUWhgwZYip78cUXsXTpUixcuBBPPfWU+zpHEOUIywHq+9hSxIhgfmVjsqy7nxyhnfFpKKvoSfxjCKInmYt1MsndPOKaO7NyL6fNcWnIVTJPIgjCM/EqTcONGzfQoUMHq/KOHTvi5s2bbugRQbgHjzTPcQD+edg6pfvKEbq8oifZcx9ImILxr6swT4MwuZtH5MZwStMgc10FmgaKnkQQRMXEq4SG6tWrY9++fVbl+/btQ/Xq1d3QI4JwD54wf3MFrB1+Ch7vCO1MfH5HoyfZk3FYoi7f1K1EZ65jGT2Jn5HbbThl7iNnnsRr10rTYO8xKXoSQRCeiVeZJw0dOhTTpk3D2bNnkZSUBIZhcOTIEWzYsAGTJ092d/cIotyoKJoGO/yg7RIw3IMz5kkOJndjdYBKbbN5g2+CbfOkEr1erAoAD9E0lId5kkuTu5HQQBCE5+BVQsPzzz+PKlWq4Pvvv8f//vc/AEC9evUwZ84cdO7c2c29I4jywxPmb65AIDTYWGEXJncrqx45gWCyaGcHefsyNoUG3mxe4aRUxTCS0YP4rgpanTAjNB/WE3wanNEwyUmorIyWiMyTCIKoIHiV0AAAXbp0QZcuXdzdDYIod/hzOFsT7PsFe3wa9Kz7zZMsJ9ICBKGgnDBpsSd6ksJJqZXQwIM/BsV6vnmShb+DRwgNFteVZQGVQitd2ehJcnkanHBqp+hJBEF4EF7h05CdnY0VK1YgLy/Paltubq7kNoKoSNgTnvR+wR6TI0GeBjdpGmRD3TqVEdrB5G5KJ6WMdLtyPg386+yR0ZPsuc4UPYkgCC/HK4SGlStX4tChQwgODrbaFhISgsOHD2PFihVu6BlBuAfPtOm3H4H7732gaZDFmRVmR6MnyVwH1iJ8qqQjNO8zX2gwbPOwMLdWmgY7rrOcozplhCYIwgvwCqHhjz/+wIABAyS39+/fH7///ns59oggyh+BeZIHzpkdQTC/sqVpYJVrJcoKefMkZ0Ku2pGngY/MhJavmVFqnsQXGliOk0z85jYsr6s911lOEyTICE0+DQRBVEy8Qmi4fv06HnjgAcntDzzwAK5fv25Xm4cOHcLo0aPRrl07xMbGYseOHc52kyDKFHuchu8XBD4NNup6giN0uZgn2boSCo/Dv14qxvIYZgSO0LwLy3HC8/UIR2g5syLbO5s/Wmpo+O0669NAIVcJgvBQvEJoUKvVSElJkdyekpIClVJnuFIKCgoQGxuLKVOmONs9gih3PGH+5grsyQgtFBo8UdXixGTRLk2DsuOwlpoGRSFXhZoGqWzRbsPKrMhBTYNd5knkCE0QRMXAK6InNW7cGDt27EBiYqLo9u3bt6Nx48Z2tdm+fXu0b9/eBb0jiPKnovg02JPlmW8e4y5NQ5mZJ8klHpM9jvSklD/JZywdoQVRq8TNkzhOOD6e4dNQHuZJFkIDmScRBFFB8AqhYeDAgXjzzTdRrVo1DBgwAGq1IZmRXq/H6tWrsXz5cnz22Wdu7qUbKcwErh8AGnQG1LxbQlsIXP4LqPso4BtkLk9JBkrygZotHDqcnuWw+3wKEmuFITzIV7ixKAe4theo3xHQ+Nnd9t6LaagTGYTo0ADR7TlFWhy6koFHGlaBr8ZBRZteB1zcAdRuDQSEKd8v4wqQcwuo005R9f2X01GjcgBqRwSKbs8r1mH/pXS0axgJANhzIQ0PN4jA5dR8qBgGTWpUEtTnT9luZxUi+U6uaV8+JToW/1xIRcu64ajk7yPYlplfgqM3MvFowyrQqFUAq0fWyW04omsANiAc7RpE4kJKLk7eygYDBu1jq5jG4nJqHjLyS/BgnXCrYx66moHIYD/UjQzC8RtZuJiSh9rZh1CrQRyq1W4IALiUmoesghKoVSqcvp2NuhFBgontraxC/O/UXWhUDO7lFqFuRBAebmA+P/6k9Wp6PlYfuI7QQB8k1KyMy6n5qBEagFs3b4C58x/09Toh5M5e5IXUR4meQ1TRFQQ17oyCrHsIuncYQSotUhCGqvFdUK2yP1CcB/bsZpxKB+oGFiE3sjluqGui9QOVgIt/oovqMLRQIxshwI2DuJdyF/lpN1G7dh2cu3INdWrWQFDmVfPYHt+AZFUCHqxXFTi3FYWqYBzLCkCLGr44iQaILLmFB3xzcVLdFBo1gweKS2C8S3L3LUWITwDOpOlQLTQYNzILUTsqHIdVCeA4oF1RCYwhIfKOrkfwY29gz+UsZBWW4PEm1aBnOfxx5q5AAMgp0uG3k7fQzXiPnNmGX6okIyioEn4/fRcPq07hKlsNqw+Yf1Pp+SU4d6/Y9P3nwzdw/uJ51C44C7VaBb1ej6zQpgjOSsaNyi3wSEQerqflIjO0CUruJqNK5lEU+YZDW/kBVNam46amJmIaNkJBXjYKzu1CeP0HEZx+Av6+PsjKL4SqMANpTDiah2vhH9MBf94LhP76AWgCKyMptBA3UrMQz10AP5Vd/sHlCKoUbro/DuvqoWkEg+AqtYGUswAYoEoscOVvIOuaecf0i8C534D8VIDVQZd6wfwyzb0jvLkv/GEu0/gDfpUAtY9BOMhPNZT5BAA1WwIh1QzHKoW9uheqEz8BjZ4EfEtH+PJuoHKpua22ALjwj0G4qN4MuHcaeKAt4C/87Rt/t+1jqkJtyNSHlJwi3DqxC4mNY8BE1Ad0xcClnaL78zn59yZUqdsU1Wo1EJQfu5GFIF81GkaFSO5r4s4JABwQXh+4+g9Qr0Ppue0C6jwC+FkHLXEpt48ZkhpWi5euk30TSLsA1O8gsv9RQOUDVIsrsy5KkZFfgmMWY+kVFOcCV/cY5gYcK5ib3M4qxOXUfNH3maNcSctHWl4xWoq8r8T492IainR6RAb7IaFmqMv64WkwnKyRbcVhzpw5WLx4MYKCglCrVi0wDIPr16+joKAAw4YNw4QJExxuOzY2Fl999ZXdCeJYlpW3cS4j9Ho9Tp48ifj4eKjVaqgWtwOTcgZsh/fAtXvTVI/59RWojq8BF/sk2H4/mMrVH5e+ZN88BwRVsfv4y/69io+3JqNWWAD+miDU1qh+eBrMtT1gH3oZXJdpdrV74EoGnl9yEABwaXpX0TrPLt6Po9ezMPrRunjriVi7+w4AzJ4voNo1DVyVxmBH71W8n+m6Df8LqJ4gW/fUrWw8s3AfAOlzGbrsMP6+kIaBrWujSKvHuv9uoV2DCOy5mA4AOPvR41AznGms3//1LNYeviloY+WwlmhTL0JQ9unv57D47ytoXjsUP496SLCt85y/cSWtAJO6xWJ4u7pgDnwN1R+TcZWNwmMlc9C5UVXsuZSGIq1hwtnigVD8NNLQRv3JhoSKf775COpEmIXQy6l56PLlHgDAiSmdkTB1B9qoTmON73TD9Xo/Q7C/Pewa/yhqhxsmW/EfbUdBifzK7QG/lxHFZOE3fUt0Ux8SbBtS8hZm+yxGFSbHVNa2aC7+nj4IzF8zoPpntqk8hwtAQvF3ONhmP6oenWd3vwHgN31LNOs0ADX+elNQ3rxoEf7zHw0A6FQ8G5e4aIypfg7vZH4k295zxe/jANcYf/qOR32VeWJ7+4kleHiT4RrN7BWHjIISfPr7eav9I5CNI/5jTN836NtinPYVPKQ6gx99Db/VOkWrZftw0W8gNIy1JuRffRM8rD4DAGhS9D3+9XsVoUy+Vb06Ravxrc/n6KI+InucoqCaaJ8+EQf8x8rW8yQ4lQ/YFzdDvdT69852/ABc29eBG/uhXtYdAHDkqZ1IvLQA6jO/CNt5oC3YwZsFZR0+343rGYV4r0cjDH24DgCgx5Tv8T8fw3tP/34GmN8nQXVwMbi67cEO3CDax9N7NyNh54umfYyk5RWj9YxdAKSfVyZ0RVDPqGHoa932YK7sBps0GGBUUP23DFyDLmAHrJVvwxlK8qCeVRsAoH/3LqD2Fa1mel4P2mQQZIwU50D9aR3DtsmpijKqO4Pl+/qxz3bjRmYh3u/RCENKx9IbUK3qA+byLrAPDge0+Ya5SaMnwfb9wfRu+OGllmhbP8JGS8owtrlj3COoGxkkW/fglQwMKJ17AMDR9zqhUoCPzB7iWI51eaL0eF6haQCAcePGoVOnTvj1119x/fp1cByHBx98EE899RQSEuQncGXFqVOnoNVqbVcsI06ePAkAaJFieFkXH16FM8EdTdtbHF8DAGDObcGxY8cMhRwHo37h/KFdKAiNsfu46w4YJrU3MgvN7RqPec0weWSP/IDjVZ61q91fz5hzbVi2a+To9SwAwI8Hr6FLVKFd7RtpcmgFAgAwqWcljyOG8brdPPgr0h6QNyH541KB6bPUMf6+kAYAWHPwOvSlsqdRYACAI0ePIcDHsPJ78uRJpKdnW7Wxed9ZBOQIV/V+PGDw//nvepbVsa+kGfq17sBlPBicjdhDqxEMoI7qHgBgR7LQd+hWWq5VG9sPnETLGv6m7//eKDJ93v/fcQBAKybZVGbPNbZk39FTyIgwTAp0OtumHlFMFgBYCQwA0FZ1WiAwAEAEk4Njx46h9rWz4IvPlRjDveV7yvHJTzf1IfyTHIcaFuXVGfNkrTFzHZe4aFy4lweIz31MPKg6hwP6xmAsHKWvnT8OoA0A4MSFq8gpFr83VRb79VLvxTjtK2jJGytbiAkMAEwCAwBURr6owGDElsAAAP75N1GbEfdjy6zWFufTSpBZqgRpHe0HhmMReu9fm+2KkRfaGHvSg9HV4p7ZzTZDfHQomFITI7/82wjMvSzZDsNqcfvARtQS2ZZ65RRuBh1D1MUNqMkrtxQYAIC5ttfqN3M9w3A/rj9wCUmBWQCABpxZc3Ls2DEkHllu2P/KbsnfXMZ/WwX7GLmYoRUtF0Ndko1EY1+v7AYAqI6aF6WYi9ud+s3bwqcwBcY3/omjh8FqxDW5xuf1vQO/4E6WWXvim38LRv3E8aNHwEkIHa7G+L6+kWkey8TSsfQGWlw2CKX4bzlUpSaATPIWwb2yef8ZBOUq0HTZwR8HTqJ1tL9snV/PCvN87Tl8HDVCHJ9eG8e6PGnRQpnliNcIDQCQkJDgNgFBjLi4OI/QNKB0Ucrf30/o98FbrDKVs3pgi+FjTExDoAavvkICD+4H0rKE7VocU61SSfqgSPFPxkXg9EXxdo38bFg90Gg0drdvRLXPDyh9RtjVRum51apVEzVt7Hem+Drw3xn5Y5SeCxhGNElBXHwCAn0Y01iHXT4DXLklqBNVLQqJiQ0FZeptO4HiEvFjlx4zICAQiYmJUB0NBDKlz0Pj62tuo3TfunXrIbFxVVOdW+o7wP4sAEDjxk2ALbvBMObzsdzfHurXb4jEOgYTMu6X32E7xpI0lpNtAFCDRWJiIpgboYBIADYfjRpwYl0gLLQScNeylJ8/wfBZBdtOGua6hv/3uFBEMVmoEmFemasaVQ2aghLggvXJiJ2/ody1SB3HVe1UGrYBC1ccw+7zBqH70oiugL4E+KSaQ8cJeHwyRv+gwmpMEwg/B7imaDd8gbk/B78Bfp8o21Z0jerAGevyKpERiExMBJP/F3DWdp+kfreBQUGmbcz6XwT1Vb8xgu9iHPgvEMiyrsPcyAL+NCxYJCQ0g0rObKYgHbAR4dzRZ7Mism8CpcEOE+LjDOZiYpQ+r6tVi0IUvz8ZlYCdho/NEuIAH3Ghw1VYva9LxzIoOLhsr5OnUToelndWYmKi6ZpERVWzep85TGmbderUQWJT+WfDnsxLwKkLpu+NGze2qZ0Qw52aBqV4ldDgadgbscnVqNVqwY3JgJG8UU3lnNlxUq1SAQ7c2AzvZy91PLm+SLbLy3Rre1/72+fvq/w41qgY29eNUdlzLhJtMCqo1SpTG5zI9M5QR9g+v5bk+DDGbfJTRj3LWbWhUgmPyf8dcCIB3Zx5eLK8cS6L6D1q6A3tizofO388FZQ5wtoz0TbW1Rof/zxnWxaMZGQtV03m3Y1a4ytwSFer1QDj+GqxWu0DQA/W4rfAwuK3pbb9ulUx4u8EFac3PDPkHOkFfbLvuWpZJre/WB0Vv77K/NwRRYE5T5lOmPjPVgY2n8VWz2v+/uAcegc6gj3v64qM5S9AcB8yrr8mlu8r0ToWv0sl+8hhOdaeBAkNDpKfny/I7XDz5k2cPXsWlStXRo0algYF9wlKXkj8KCEKX2COHMaR5Ut7uuNg112ws7L97ToXiXLLZFpiEZPEjqNsfBhFlcUi5ljuwZ+IGPvMca5Zv2ZN7XE2M0bbQkzoUhsn0iJRblTgRPexB5WoMMILd1r62dJ0SAzLulpODTAAx/tNsywnGVlK6hieKkqIXXs9VFAzjPUWicm6IlQaGIQGYRt6SwFYpeB1K/V7Mt5fTj57BAkeLa+CkrYl6vBL9SwHH7n5jrsjQvHPQUnoZctzFlxEN56LF/lAC5C7T519N4s3aruG1S1ScQeHhAYHOXXqFAYPHmz6PmPGDABAr169MHPmTHd1q+xx9wOfUIzVhN0Nszv+pF0JUmE5HU0MZmyvrMJ9qow2+iKhO9UKTIZswSjM7myXpqHU9EtnfPzz+q7nOMlrrcQEyhVomLJ7xrBQQXQ+yzDQQQWNI+dYuvJsOQm3FhqcWDm8j5K82Qzn7O5zcTakrSCPhifmeyGIsoOEBgdp3bo1zp075+5ulD+UbOi+wXKi7I7cDEaTIKVzdqnJvaOmRcb2yiqxmMZoPiTyu1ArNC2Sg+GU/d6UaBpMbcIoNBgmsRyv73qWk7xW5bV45uuME4gNLLUB1tscmAQypddRxDxJrJ5DuHuibQc2f2vufofwj+9IXyj5XoXHWV/TipIHSQyvyAhNuBBaWblvsDZPckMf7Fzp10ncX44+hPUmoaVsTt6kTRBZsSw7TYP1udgjNJjMk4xr7nxNA8tJXiumnDQNvii7iZjV6r9gm4OT+lKzI0ufBp1le0rMk6Qoaw2vC5/rNrWC7tZW88/VEWGM3393nwtRJjirmXZUM34/UOE1DT179lRsX7Zhg3hsaoKH4IFJAoQnY/ngcsdjjLVz0s5PKMbH0Ye4UXAqK02DyWRHZNLlGqHBelLiI6rBsEdoMPRLStMgda3tEUycwVVCg5jJFisjGMhpIWQpNTsSc4QWq+cQZa1pcHLyy7/SNn+r7taaODvpF2T/JqGhImK54Fbe+3syFV5o4CdcKy4uxurVq9GgQQNTqLLjx4/jwoULeP75593Uw/sMgWqXhAbFOPEQ4TjOIccqy4myO82TlE7apYQGZ82Tymrlp+zNk6zbEDPfcUzTIOLT4BFCg2vMk1SMdX/lNA2OCw2G62hpnmStaXBGaChjMxgn2+ffMx4vNAjeYY4IDU6aNxEej7OaBp2ehIb7lrFjzRlBJ0+ejEGDBuGNN94Q1Jk3bx7u3LkDr0fJpJJ1XjVbgYVwaQTXTUGkG77ZLFcaGlCqrkS55YNPzE7T4bEw7ijRgI+agVZvNnXh98VyD45XUiIRusdjHaFloicZgtw6d1wx8yRfxjxRcSRPg3EEdJxR0yB0hJa6VuWVp4F/fs7gI6Kx0DNGp2VrrCb5SmEUOkIr8WmQ+kGWuXmS3qkHM39BwuYqq7tNeuzVFFieD2nb3Us5TCCEz0D7j0c+DRWE//3vf+jZs6dV+dNPP40//vij/Dt0P0KrLI7hxLWSsvO3hbXQ4HAX7ManNE67zs5Je1lpGspKaHCHI7TYSrw9E3eVhSM0v+96vYwj9H2maRBrx7YjtAOYzJOE+99X5klOPsv5K6s2V1nd/d5w9h0mEDroHVgRcVrTUIF9GrxKaPD398eRI0esyo8cOQI/Pz839MjDUGICwznpRKbwMM7ijkzbsvBXp+zM02BLZpDM06DAPMnhsbCRp8FXU7r6yhnGQqBpsOgHP2q+VkrT4KQjdFnZmJp9GsQdoZ3N0yCmaeCvoJtyLzC2BUurPA1ijtCctCN0eeVpENMQONaO9ZgYnZ3FRsV58yTLY7kwT4PYs9aVq9wc69SDmX/PVLiQq5bXhXwa3Es5TCDIEVqaCm+exOfFF1/Ehx9+iNOnT6NZs2YADD4N69evxyuvvOLm3nkAFcg8yZZJT7njhHmSrQmv1FbLl7fYc6yszJN8eRlhLSPyWPfL/L1YRNPA6vVOO0KXlabBHD3Jut8qhnWBeZL1b8wP1uZJSo5jWdeYp4HjZ4SW8WlQYp7EgBXN6m0Pfi4SGuQ0DWJnomfUjklAEiFXy9w8yUmhQTCeDpgncSxrylxvl0/D/WCexF+pkTVPIqGh3LEYj7JYINQL3lcO7E9CQ8Vg5MiRqFmzJn744Qds2bIFAFCvXj3MmDED3bt3d3Pv7hOcdSIrJ3QsC7Uz5gCuxgk1tt5BpypLFak7zJOM/eD3Rc5BW8w8SafTOi40lLV5EiNtnqRxgXmS2G/MlzFPho2aDmfMkxhe33VOOkJrwELrpNDAPz9L7An76ifSTlmaJ1kKVdaaBieui8j9JSZQ2oPAD8aB55Ner4NG5Wv4XNEcoeWuLZnoehRl8WzXy7yv7N2/ouFVQgMAdO/enQQEKRSZJzmvmi0P8ySPC+xk56og/xrZ0jQoNU8SW5EpK/MkP415gsRaZBm27Bf/u1ZEQGL1OuhZxzpaHo7QHMeBKSPzJLHfGN98x6jpUOIIbewLY2GepNQRWuoYnII69iBnnmRPGFsx8ySjYCA2KnKRlcCopH/DKnGTJ6u8Dy42T1KaLVwKwbXk9HY/DPR6HTQ+IkKDx5snKdAU8Psoa57kaS8aL8BiPMrC9JR/PztialSRQ656lU8D4QJcYJ5UHnjcj1Zw3Wy/aPjPKUcnvHJmQGWNr0ZoniR4CHPSQkOJTsQOXa9zeDzFoje5EjVYQ9sivwVXhCgVD7nKExoYo9Cg/FgmoYEzhlw1348sy0leayVTSvlJvbI+yuVpsEdosNehWl5okNFalm6zFJhcmhFa7Jnh5PNXzfeDcWAiz+qFwqbpc0UwT5LrI5kneRRlIbfx23Tk3UGahgqCXq/HsmXL8Ntvv+HOnTvQaoUvlYMHD7qpZ/cR90nkCEdNesoMO8269DyHYEcfQJZRTMrzilgKDQLzJL2M0CDiCK3T6aBnHZtwGY9VVkKkGnroWA4aSfMkJ48r0i5/Mqw2mScpP46VeRKnzDxJiWmQnEmW0gm/3GS/LIUGWfMklQZgJdor1SBYjoHOEUdoqQUFF5snsSwnvJYOPMt1OvP1sM88yd3RkxS8w+T6eJ+8A70FR6MLKm2ThAYhXqVpWLBgAZYuXYpu3bohNzcXQ4YMQZcuXcAwjCCfg9eiZGLlAvOk8ljw9jhNg52rU/x5tSc7Qks5ofnY4Qitt+HTwOl1TmtbylLTwHKc6HKXCqzzN7stTYMdQoNlTgediHmSnCO0lDaDEdSRfoErFxpcpWmwboez+M/HypyIj5x/lGKfBgWCr75EvNw4RjyhwhnzJD1nITRw9t+rAk3D/eTTYK95kuV1oehJ7sXyvVYWmgZ78o7A+hapyEKDV2kaNm/ejGnTpuGxxx7DggUL8OSTT6J27dqIjY3F8ePH3d29+wMPdoTm/9DLYvXBKex0ntPzVzpc5gjt+gcZJ2G1r2YYqBiDoKJnOWEcdxmfBqPQwPCy+TrjCG1vngh7MWoapByhnT6qDUdoYy4IJeZJxjrG8TJlhNYr1TTYLtfICg3KnhdyjtD25L7wEUkSJ2diJatpUGSeZCmkW5onKVij00kJDaXnwvKFBsefv3qWE15LRxyheX29r4QGJc9iuT6SI7RHoZOLdOVwm/Y5QltWqchCg1dpGtLS0hATEwMACAoKQm5uLgCgQ4cO+Ouvv9zYMw9BiSOcC3waysoRmu+w5Gkyg6BDSsyT+DaVDjpCWzpwiTXjsJ+DaRDFj65WMdAYwzFaxP637JfQPEm4Gg4YVsI9IXqS2KRZDdZwPqIZoV2Rp8F1mgajDbvRzMjkCM0PuSrrCC1RzrON9yRNg1zoVrsdoRVoGiyvj0OO0FKaBuMYuSgbsd7KPEmhIzTvmCzroKbB3X4AShyZ5bQR5NPgXmQcoV01V7fXEdryHe1xlg4uxKuEhqioKKSmpgIAateujb179wIATp48CV9fX3d2zTO4z82T9HaqFMsVO180AvWojYeW1FYlyd0cnkzbME9SqxhThElLR2i56ElGTQN/QuOUI3Rp20qEI1s2+2ITVjVKz03kt1Ae5knGSboyTYOwrnGSzFlM/qSulZRgwr8ucpN6pZGV5IQGe6Izifk0iJknGe8RvZw2we3mSdZJBJ01TxJcS05hnga+07yUI3RFi55k2V+KnuReZMyTXPXet9cRWm4hrKLhVeZJXbp0wb59+9CsWTMMHjwY48ePx7p163D79m0MGTLE3d27P/Bg1SxfjXi/O0LzzXmcNc0xHdaVQkMpUs9olYqBunRFyMoRWlbTYLg2/Mknq9NBzzh3DSydr8WwtYotFgpUDb2k0KBRkKXZFmKhXPmTYQ2E2gM5NBamTCbzJIs8DVLqeKkJO98kSc3oJaVYOdMlPnIOzErbkGpHVMPAcVCBcdo8yabQoCR6kq5YvNxknsRL7OeMeZKeE15Lhc9yhucM7rh50n3mCG1ZhxyhPQpnnZZd0abcO62i4VVCw4QJE0yfu3btimrVquHo0aOoXbs2OnXq5MaeeQiKzJMsVqecPAzHcWBcZK8kyAXgaZoGO53n7AlhKGmeZJU5U+Q4jj7cRMeMM/VGo2KgVpmFBqWO0Fqd4bNAaNDroFc5qGkwOkIruB9sCw3iJkh6Ttw8SVVG5klieRqUHMWkaSgVwKRCrkqp46WOoVKoaVBqWiSbp8EOQUxsvIzwz0XPcvBRK4ieZGObpVBV9uZJyp6/YtpAK0dolrXfPEkiwtv9ZZ6kIOSqpUbHjeZJjuQMqHBY3KfOhkcVw15HaLkw4hUNrxIaLElMTERiYqK7u+E5uME8Sc9y0KhdIzToy+Dh4TLsNU+SyWtg1bREuXVyN5E6dghXgheW0TyJd3QVOLCl0zEVYxYaLO3kLaOqsgJNg7V5EsvqwDroUmyPT4Mt0xcxB10Vw0pqGgzn4Kx5knWffBkx8yTbk2nL/phWwnn3o56TztMgZQLlcvMkEQdme9swtCOtsRCYJxkFS9noSbb9HayTuzmQEdpW9CQHzJPE7n2Wdcw8iS/EsrxVdrlFAZGD2zxOmaLIPEnGB82N0ZM8bjHMHcgsOrnqvW/vXEKJKXBFwat8GgBg48aN6N+/P9q1a4dbt24BAJYtW4YdO3a4uWduwt6b28XRkxxJ0S6FvgzUlDZRev3sVGnbG71BDFf7NIi9sPhF/Bj9Bk2D4fFiGZFHbzFp4J+f2aeBNznR65y+BkrO05bpi5i5i8ZkniRuuuQsjI08DRpGefQkNVhBPT3jY3UMy0hXfFQSq/z885QTGuRyOPCRN09Sfk2V5mkwRdhyUNPAlUZFsnaEdiBPg6R5kpjQoOxaiP12dCxnuncM7So0s+ELCrw8DYLoaLZMAd1t0qPkHSZrnuQ+E12PWwzzAMrivW+veZJlHVfOazwNrxIaVq9ejZkzZ6J9+/bIzc0FW3pjVKpUCcuXL3dz79yEvc50Ls4I7UqJvCxWHGyi9PrZuTpljyO0FFaaBgV17GnPEoGZioqBWtIRWrgfX9NQLOIIzer1Dq+wGY+r5D6zqWkQ9WngJDNCq8E6rWgQW032E3GEVpqtmREIDaUr6wodoeXaFftsiZTQYYlc1CP7HKGl8zTwMTnLO+jToOeM2jVL8yQHfBrKIHqS1GKB4FoqXQCSiJ5kl6bhvjNPkoueVL5aExIarLEn0qBS7DV5slqgq8Dj5FVCw8qVKzFt2jSMGTMGKp6qOC4uDufPn3djz9yIvSslLl5lca2mwQ1CgwMrdOXlCO1yTYNIXSlNg6UjtGJNg5h5kl7rdK4KJY7Qtlax/URWrmUdocEKzLccgZ+t2YgzjtBCTUPpyjcnFBrsdYQWahqkr2H5O0Iry9Ng0jQ4GD1J6npZCSFKoieVgSO0WP/0rKOO0BKaBns0ox6labi/HKEr8gq2o+hckNNItk0HHKEr8jh5ldBw8+ZNNG7c2Krc19cXhYWFbuiRB8B/ANrpCOeoeRL/MK6UyAUTU1FTmjL4ISteoSu7kKtSo2Z5DcSasRnOVcohrHQQ+XvzJ5UaFQO1WkJokHWEdq2mwXgdXaFpkHWElgi56rwjtHWffJwIuco/R7ZUaGAshAap36S0TwPH++y8T4OsI7STQoMRsTjsjjpCG++tMnWEdsKnQWw8rUOuKnOEZlyRp8HtIVcVBPOQC6vqRp+GiryCrRg5R2hXaRrsdYT2ouhJXiU01KxZE2fPnrUq//vvv9GgQQM39MgDEExmFdzoLjBPsnSEtuv4MthyXiqTH7LSa2Bv9KQycYQWnzzIwW9CzBEaEhNGFWPWNLAWzrWKHKEZ/uRE5/DL0uzTYLuurQmpqCM0WFnzJCVJ1+QQmxjyHYXVdggNludnFhp4q2oyjtCSeRp4Y+WK6Ell6QhtPAOxSYG8eZL0NuM9ZtMRWklGaFeZJ0ksOhiLWVYkuZudjtD8/B72BG4ob5MeKxSZJ8kIFm6MniT4bVbceak8MotOrhKq+O8LR5K7VWRHaK+KnjRs2DBMnToVJSWGB/OJEyewZcsWfPPNN5g2bZqbe+cmnDJPcuyBKel74OTLxJZDVJmoDBWbJ7nfEdqRkKt6ljNFQRLrB8e75oJ4/SqDiRJgMA1yxhGac4EjtE5BxBZbeRUccYR29t1h2zzJcJ2UZoTmT7r1jAbghMfQs5ykil9a06DUPKl8HaHFNBbGib2Y46589CR16d7SixHWmgZXmieJaBrknr8ca/KhENPy6VhOeC0t71+OE9U8CKInSZknkSN0maEXvBfcLHx5CPz3iave8fa26U2O0F4lNPTp0wd6vR6zZ89GYWEhxo8fj6ioKLz77rvo0aOHu7vnHvgPHkXmSc6rZiXzKTip6uW/q0TDDJaJeZLCB7czIVdFfQnMZZLmSS7waWAlVnFM48Y7F6EjtAoaY54GO0KuakV9GvQOj50rHaHFzJNMmgaJkKvlZp6kIPmdZfQkVqUB9BaaBtYBTYPAEVq6H64wT3LWEdqImOOuzehJjEr0t2sWGix+b45ET9JLCExiQoOcAMXqTUKK2EqslSM0p7dIoGMWOvgIQ6466AjtdvMkJSFXZd5zbswILRQAy/XQ7kXENNZIWThCOx1ylYSGikO/fv3Qr18/ZGRkgOM4REREAADu3buHqKgoN/fODdgbCcIF5knSmgbnXia2VOQuM0/iHOiznS8aW5GgBJdN6pAKfBpsveB1EgKe6aHK8ieMFpoGo3kSKz+p4Ldr1DTwJzQcq3PcGdy4suqCjNBiK+BqcKWTJ+v2DWY7zt1zKpGJoa9ocjfb95SluRQn4tPAWvif8JESGlQCszTpiFGKzZNc5tMgbZ4kZoMvKzQwammhQcRUDwB0DkVPktA02G2eJOFvwPPxkTVP4gkdwnZ5v0u9lE+DdLcs+yYJyyrLa+EITkdPUuATUUaI+eJ4BYJ5h8X7owyuid4eIRjWwooSc9j7Fa/yaeATHh6OiIgIpKam4uOPP0aXLl3c3SX3oFTVajKGdT5yhGRkICdVvTobKkWXCQ2OqKft3EeohhYztbL9VLLcT8ynwdZkWtAPwbiVHp93Lmpe3HeNSmVK2qdjWaE5iEXf+ccwhlzlmzqJmSepFC7gW2oa+PtZtmErr4KYrb2G0UOvEx9Peya4UohFyPHj2erbkxFabRE9yejToOIdwzKnBh8p8yT+WMmZDym9Hn4ySdkEuQVsIOcbISY02HSElvBJkNI0OOQIrZNyhBaJniS3Ym+Re8PUvN5snmQlNEjsz0cgYOrFj2FpfijXN0nKcjKu5B0mZ8LkMeZJ3iQ0KPstu808yeI9avM3cB/jFUJDTk4Oxo8fj4ceegjt2rXDDz/8AJZlMXfuXHTu3BnHjh3DJ5984u5uugelDrrG1RVXmCdJraI7a55kw3lJzCHQIRy5BnaaJ9lyhFbyTFLi02BrFUVKe2Nqm3cujjpC8/tpdIQWRPlh9Vbj6atR9uiydITm72fZhq1JrVjIVYN5kvh4qsEqjnAjhVrUp0HMEdp+TQOrKk3uxo+II5sRWirkqosdoWU0DUoTttlqR3A/KjJPUkmab0oLDQ74NEhpGkTNk2Sup0RkI1M0MUuhQc7ZlwdfwOQkBBPb0ZPs1Gi7mgqSEdqrNA0y70z+89dTHKErcuZurzBP+uKLL3D48GH06tUL//zzD2bMmIF//vkHxcXF+Pbbb9GqVSt3d9F9KHVsZnWGl54LHKF1Ui8Yp4UG5ZoGp8KvOqJtsXMfV2galPg0iLXNL5JyyDa1zVpPYAHnHaE1NhyhfdUqFGmVXwPjMfn7WbbhaEZovkMoHzX0gkmWI6hZ67b5/VDbmRFaYJ5UuvLN17Bo9ZykQC2lzVDsCK1QSyAnGMglflPWjrW5mvGzlrOV3M1JoUGJz5iUIzS4Ujs/viO0zLWQEBpMeUtYTqAZlHX25SGMnlSGeRrKcgWfHKHvP2SuM8vTzpEjdNnjFULD7t27MWPGDDz88MN4/vnn0aVLF9SpUweTJ092d9fcj1L7TJGVLkdVyJKO0PaGf7XAliO02OqiQwiugcIHtzMhV8Um9o5oGhTUsTq2DUdo/iq1UGgwO0KzTjpCc6y1I7SvRg0omECahQbOaj/LNhx1hGb14uNpmKQ792LXcNYTXx9RnwbbWDlCi4Rc1coY44r5NDBglWeEdoEjtNw2S0Q1DUZZV8wRWk5oUGCeZDnWstGYpJByhAYMz0feM1I2uRvfp0HkNywacpWPxANGIDTw7hWXZ4QuN/MkR3waHHj+uwjhs7lcD+1eZN6ZrMR96Ax2axq8yBHaK8yTUlJSUL9+fQBArVq14Ofnh759+7q5Vx6C1APU8qUh5ojn6pCrTqp97XGEdsq/wWnzJOcdofnbpbQm1o7QYloFMYFEQrsgmHwYP4ibJ/EdofU2HaHNn5U6QvspNE8yTwgN333V5um1ZRuOOkJzEqtgKrBOaxrEhAZHHaFVFkIDjD4NPGHIeP2l9rdEbZEwTk7jUf7mSWKO0OaEg0ZMYXk5GdFLpZYUGoz3mOXerFx7UkiZJwGG3xpf0yCV08FY19ikyG9Yb+kIzVk480uaJwnNBkWPYWuYlTwz3W6eJBc9SUbYKmNc9g673xAsbgpvMFbCTM4Z7F1gtHqnVWAlkFcIDSzLwsfHx/RdpVIhICDAjT3yIKRUrZYPU5MjnvOO0HoljtAOtG2PI7RTD5dydoQWzznBX10Rb8PaEVqkjogjNH8/gQAh4szMj/EvMFORdYS2fMBajxs/ZwKntxYafNTKJmTG9kzmSTxBwbINW47QYnkc1NCDlXCE1oAVjX5kD2J98mGsBTUl5kka6E3CBQsVuFIbe/7kUU6tLnYMNViXO0L7yJgxyTk3WyI2XhyEmif+Z61sngZpTYPxmlnlaXDkESNrcqQTbGdETNfE2hGcq5wjtIJnlFDTUIaO0GU5Ga8gjtBeJTTIzE34z1+XmSfplT0TTXW8yBHaK8yTOI7DxIkT4evrCwAoKSnBhx9+aCU4LFiwwB3dcy9Sqy5SqyvlFXLVgbYFC0BlKjQ40E8nzJPEVjoU+RIqiJ4kqpGRGB+hI7SxUQnzJIYxh1zlOEkzJ8tjGBFqGvRWddzhCC2GGqykpkENVrAyWxaYNQ2272c1w5pWwzkwJsdcpectdgw1WEOY1VLkTJBcEU3KHvMkMYxnIHaP6zmVtJ0X44AjtKsndZxe8HtTiTjJC+qK9MMUclVUaLD9jBL8LjkpoUG6W4YdFdwHbjdPUugk7saM0N4lNMiYJ/Gev64LucpvX4F5EjlCVyx69eol+P7000+7qSceiJRJklWGUDHzJMcmAQJ7Qankbg6sNNnObWCH3a0cnMXLVtE+9r1oJCNMGcuUxI62coS2XQeQMU8SESAYGfMkYyZpPSsvsIlNMix9GizPV6nQYIoWU/rfRy0jNNjICC2GGix0ErMklQt8GmyhskPToOKZEvGFBqW+BlJCg6ujJ8lhj3mSKKWnwH90mXJ5cIy00KBSSwoNxrbErg/LcqaAAE7joHmSmLBvldyN1UKJeZLAj4Kfp8Eecw6PMk+SuCcVJ3crX6FB0h+woiPzzuRY8fvQGVg7FxitF8Jc0g2PxCuEhhkzZri7C56LlKpW0jzJedWswBxFINLzj8nB3gQ/klGZRLY7pcZ0JIKUnWZdkrksjGUKbB8sz1FpwjudiHBgWdc0UZYIuSrICM2ystdeTJXLN8vhWJ3V+fqqld0Xprj0pf8Fmga1KzQNehRLOK9qGD3UZbwSaTQHUqJp0PB8GjhGBaY0epKcSREfcfMkvWB/uQhJtsy/lGBP9CQ5+OZ9JvMkBx2h5aLY6FgOvi4VGpSaJ5mvtVh+FT3LwZ8/HpYCiJSmQVHIVVeYJ5VX9CQl5kly0ZPKV2iw9Y6rsMhFT5Iwk3MGe6+zkndaRcErfBoIGRSbJ+mtyx01T1ISPcmB9m2twljmaXBYlem0eZJrHaElD2lRR2wXy3bkTIfEInfwVx75K/VWjtAyTupi8o+l6YSzmgbj/r5ymgaHhAYOkDAT4a/slxX2mCepLEKuGjMUO6tpcLUjtBy+MonflGAyT+JrGoyO0EoyQotgShwocn6uiuYCwCp6kkpOaJCInmQ2xbIwT7JMKqfAPEnS2dqmeZKCZ6bbzZNknvFuzAht7wp4hUHmnSnlW+PU4cgRWhISGpxk1apV6NixI+Lj49G7d28cPnzY3V2yD6kVFSnnL1c4Qks9+BTGCpfClibByizG0Re6BzhCK1nJcCQjtPWKiYSmwegILTBP4k1oGIZnnmS/psEyI7S1I7RCTYOsI7Sl0GD/BEAtkxHaB/pyExoUO0IzpeZaUJm0eLbyUxgpL0doOeQiKymB4YT3g+EzB47joGNtRE+SsF0y/obEro9L47W7whHa9HuwEBosozZJRQQrr4zQ5AgtCmkaRDaVhabBhqZfrr5hn4orNZDQ4ATbtm3DjBkzMGbMGGzcuBEtWrTAiBEjcPv2bXd3TTlSqy5SqyvlFXLVgfYFq9lKhAZHHzDlnBFaXGti+5CW10DsdG2FZZXqh8mOW8I8SaPiCw3OOUKDs3aEVhxy1cIRmr+fvSFXxVCDlbwHlJr9OINRu6NEOFEJzJMYMKUZoZWet0o0epSlpsHzHaE5q7whHFgO8nkVZEKu6k2aBmXmfw7D6gUrrkrNk0RDrrKc0IfH0sROKuSqRBZp+0KuKnl4lZdPg8RxPNSnwWsdoZX6NLjMEdq+66xEe15RIKHBCZYuXYo+ffqgb9++qF+/PiZPnoxq1aphzZo17u6acgQ/Rs78QFdknuTYJEDgb+1C8yR7HKHFvitCKn+Fzf3se9HYdIRWEtHBUtOgYFIjp40Rm3zwhQb+hELNFxo4ec2J2BzCVY7QpmgxRvMkmehJjmgF1GAF8eoFfXTWaVcBxj4rTe5mNjGy3xFatE3GjuRuDjiaW+LsNeXAmIQEI8bkg1YZnPnImScZBWhG5Jnjyomdg+ZJrIiwb+UIbZmJWoFPg5Sz9f2V3E3invTQ6Ele6wgt8870BEdob0ruxnBSmaEIWUpKSpCYmIi5c+eiS5cupvJp06YhOTkZK1eutNkGy7KSibnKkgOrpqLS1f9BpVYjmM1Dbf0107azPk0AMPDhStBAd8FUfllTH8WMP6rpbyOMzQQA5DLBuKl5wO7j5xabVwsDfNQmh9kArgB1dFdM2877xEJvh69+fonONBnw06isHF31LIcCrfkBE+yrkQqIIgOHxtozpm/X1Q8gXxVsc69IfSqqsCkAgELGH1c19WXrF5ToBXb4lqvieo5DQYn8C8tHxcDPRw1Wr4dKrUZ+sc5KbFAxQJCv+RpzHJBXYh6fQB+1afKvYzkU8q5fiJ8GjbWnTd8vsNHIhOFa1AkPRF6xDmn5JfDTqMBxQIkx2zPDINDXvKrLP1cjCcxl+Jfar99mopCCcNP+ABAR5Iv0fJnoMabzYxDkq0axjkWJnhXsZ9lGBHJQX3XHZpt88jk/3FLVQAx3xWpbKlcZVZhsu9qzlzzOH2e4B1CXuWvzWEWcD85zNZGguoJCVRAm1liKuTf7AQAOsrE2j1UFWairuicoO8HWRQxz0zRW19kquItwxfvbi7PX9BJbHW9V+w5Hb2SZfHzqRQYhNNAHSbdW4X2fVaL7/RbwFB4s3o8qbKrVti6VfsWFlDzs9XsV0Uy6qbxO0Wo0q1lZYAa37l43x/uuaYiauuvwg2GCn8FURjgnfi2uauqikAkEIP671epZ1NVfRQhTCADIVIWZnusAcEVTD0WMdS6jeiXn4cf7XWZrIgEAhVq9yXTGR6WCv4+0AFZDdxOVJfpt6/iuIFp3A5W4HABANlMZtzU1reqEs+mI0t8FABTDF5d9Gorun6UKxR11dJn00wgHmJ7hepGx9Ab8uULU1V0W3XaOqYdsvUFravk+cxTj+wKwfl+JwZ97AAZNe4CP/RnhizSVkN18LB5u/zjUagcyyjuB0uN5xx1XBmRmZkKv1yMiIkJQHhkZidRU6xeLGKdOnYJWW/arkZbUvLwWtXEHYouC/Akxn3q6S1ZlIVyeYNKoGP77RF/6J0KM9px97TIwL7myED0/wbFdYI5aW39Nsv9SBHBFtq8b/1w4QHSBVcliu3E/Vqa+Zdty48PfZrFfQ9Ut85csoCqAeiqYx0FqX/65ilCDu4cauCfcvxCor1RPajyWymI/e9qQIIgpFhUYAJS5wAAAwUwRWjHC38lxth6aqaxfsP6MFgmMoa+FvpHQ6jnkcgEIYQrRSmXnb62UBJXw3GurUlEbyp5/jiB3TVfqOmGg5k/Z/VfqO+O/61mCsstp+QCAKFWk5H7Hc4LwH7pgss9qQfkptg4upOQBAJbrHse7PkIt8/Gbwv7m+fkjmCkyb5cYKzHq8xZxAEgKDAAEiy8AxH97vN8cX2AAIDlB4+9Tg7uHGlqeECjzbLAXyeO7mMpcNipr5X+nfiiRfF6HslkIZbPKoGci2HqOeimx3OWyuSb2tCn2DnOkH1rgt1sdcPJkdQd2do4WLVooqkdCg5MwFkvVHMdZlUkRFxfnFk3D3YhN+G33JkRWiYSKUYFjVCgKrI6A/FtWdQuCaiEw/yb4Mbx1PsFgVT7wLc60qq+UiCBfZBZqRdR4DAqCokuPaT+hgT7IL9ZDK2FYyzBARJAf0vKKRbcrpTAoGv4Fd8DYYaKlV/tD5xMCvyJlk6rKAT4o1OpRopM+RpVgP6SWnovxc5CfBlypJoLlWKSlppnGOizQF7lFWoBhEOKnRmaB+JMtMtgP6fnFVhGXVAwQFuSHdN7104bURFUuDRpwSM0rRoi/D+pXCYSOBc7dzTWNhb+PCj5qteH4FlTy90GxTo9iHYsQfx9EVfLDXS4MBdlpYEsKBfsDQP0qgbiRUYhCrR4+ahWiQwNQpNUjq1ALjgMeiAjAjYxCgSbB30eFmKohSMsvQVpeMWKiQpBdWII7WUUI8fdBoVYHXx8/VKtVF/euX4AuqDr8tVkI8FEhXxOKwvTr0Gh8UBJYDfm+EQjVpaM4/XrpCiuDzMjmqKVKw01VNCKyTyEYhcgu1KIgqCZUrA7VQjRIyc4HwBgSTVaJRdGdswir2RhZt85BU5yFwqBaAFgEqPQIK76FnEItssOawKckD9F+BbiXr0cEk4cixh95nB/CuSzTWFcODcfJq6mo06IzdmRloaY6Ezn5hQgP8kVqXglqqAx1OQC1EtrjU78qOHZiIwIykhER7IdgXzWuZRQAAOpVCUJWgRZVQ/yg5zhkFWgR6KNGjpZBsX8VsIwGMT6pSM8vQbGOhT64Gh4ILEZRQT5Sc4tROdAHV9MLEBbgg2A/DQpK9AgL8kFgQCCulwRDDzV8VCx8ClKgDq2F0KJbOJXJIDTQD+qiTNSqHgXUaA6knUNubg4ytL6o7V+IS3fS4aNRo3a9Rrhy6RyKAqJQwqkQ4KtB49AYZGvP42BeFVROP4qaQRyiqtdETl4+zmUCEUE+aKlpiJalZkY1QgNwL6fY7LTIJeBycRvcK2ChLsk1j0XBbTSr0goco8HezKeQH1IfwbmGRZTcSg2wUBMEFcOgRuWHcDG1H1LzdQitUR8LC/yt7vN9JTsRmHfdZCaWW6khUnUFCCi8C7+iNDCsFsUBVQEAIdFNkHf3AvL9qiIs/aipjaKAqtAUZyHj7k1EVolEUfADUHE6+BWloTAgCoH5twALnaKKAcIChZo1jYpBQFh1ZGVnQa0zjHtBUE3R/fkERdZGYU6q6XdpJNhfAx3LociGBhQAtL6VADDwKckpPeaN0uNbv2/KAq1vKAAWPiU5knVYtS9KfMPgX2itHVOyv6uwfIarVAzCAnwUaVorFozkvaJRqxDsp0aWxPvMEfw0KvhqxN9XYoQG+oDjDJq9/GLHViR9gsIQGVAd8fHx5a5pUAqZJzmIK8yT3IVer8exY8eQmJjosTcm4RporL0HGmvvgcbae6Cx9h7uh7EmR2gH8fX1RdOmTbF3715B+b///oukpCQ39YogCIIgCIIgXA+ZJznB0KFD8fbbbyMuLg5JSUlYu3Yt7ty5g/79+7u7awRBEARBEAThMsg8yUlWrVqF7777DikpKYiJicGkSZPQsmVLd3eLIAiCIAiCIFwGCQ0EQRAEQRAEQchCPg0EQRAEQRAEQchCQgNBEARBEARBELKQ0EAQBEEQBEEQhCwkNBAEQRAEQRAEIQsJDQRBEARBEARByEJCA0EQBEEQBEEQspDQQBAEQRAEQRCELCQ0EARBEARBEAQhCwkNBEEQBEEQBEHIQkKDF7Jq1Sp07NgR8fHx6N27Nw4fPuzuLhF2sHjxYvTp0wdJSUlo06YNXn75ZVy+fFlQh+M4zJ8/H+3atUNCQgIGDRqECxcuCOqUlJTg448/RuvWrZGYmIjRo0fj7t275XkqhB0sXrwYsbGxmD59uqmMxrlice/ePUyYMAGtW7dGs2bN8Mwzz+DUqVOm7TTeFQOdToc5c+agY8eOSEhIQKdOnbBgwQKwLGuqQ2N9f3Lo0CGMHj0a7dq1Q2xsLHbs2CHY7qpxzc7OxltvvYUWLVqgRYsWeOutt5CTk1Pm50dCg5exbds2zJgxA2PGjMHGjRvRokULjBgxArdv33Z31wiFHDx4EC+88AJ++uknLF26FHq9HsOGDUNBQYGpzrfffoulS5diypQpWLduHSIjIzF06FDk5eWZ6kyfPh3bt2/HnDlzsHr1ahQUFGDUqFHQ6/XuOC1ChhMnTmDt2rWIjY0VlNM4Vxyys7MxYMAA+Pj44Ntvv8XWrVsxceJEVKpUyVSHxrti8O233+LHH3/ElClTsG3bNrz11lv47rvvsGLFCkEdGuv7j4KCAsTGxmLKlCmi2101ruPHj0dycjKWLFmCJUuWIDk5GW+//XaZnx84wqt49tlnuSlTpgjKunbtyn322Wdu6hHhLOnp6VxMTAx38OBBjuM4jmVZrm3bttzixYtNdYqLi7kWLVpwa9as4TiO43JycrimTZtyW7duNdW5e/cu16hRI+7vv/8u3xMgZMnLy+Mef/xxbu/evdzAgQO5adOmcRxH41zRmD17NjdgwADJ7TTeFYeRI0dykyZNEpSNHTuWmzBhAsdxNNYVhZiYGG779u2m764a14sXL3IxMTHcsWPHTHWOHj3KxcTEcJcuXSrTcyJNgxdRUlKC06dPo127doLytm3b4ujRo27qFeEsubm5AIDKlSsDAG7evInU1FTBOPv6+qJly5amcT516hS0Wi3atm1rqhMVFYWGDRvSveBhTJ06Fe3bt8fDDz8sKKdxrljs3LkTcXFxeO2119CmTRv07NkTP/30k2k7jXfFoUWLFti/fz+uXLkCAEhOTsaRI0fQvn17ADTWFRVXjevRo0cREhKCZs2ameokJiYiJCSkzMdeU6atEx5FZmYm9Ho9IiIiBOWRkZFITU11U68IZ+A4DjNmzECLFi0QExMDAKaxFBtnoxlaWloafHx8TIIGv05aWlo59JxQwtatW3HmzBmsW7fOahuNc8Xixo0bWLNmDYYOHYrRo0fjxIkTmDZtGnx9fdGzZ08a7wrEiBEjkJubi27dukGtVkOv12PcuHF48sknAdBvu6LiqnFNS0uzasPYblmPPQkNXgjDMILvHMdZlRH3B1OnTsX58+exevVqq21i42wLJXWI8uHOnTuYPn06vv/+e/j5+UnWo3GuGHAch7i4OLz55psAgCZNmuDixYtYs2YNevbsaapH433/s23bNvz666/4/PPP0aBBA5w9exYzZsxA1apV0atXL1M9GuuKSVmNa3nM5cg8yYsICwuDWq22kkTT09MRGRnppl4RjvLxxx9j586dWL58OapVq2Yqr1KlCgDIjnNkZCS0Wi2ys7Ml6xDu5fTp00hPT0fv3r3RpEkTNGnSBAcPHsSKFSvQpEkT0zjROFcMqlSpgvr16wvK6tWrZ1qBpN91xeHTTz/FyJEj0aNHD8TGxqJnz5548cUXsXjxYgA01hUVV41rZGQk0tPTrdrPyMgQ1UC4EhIavAhfX180bdoUe/fuFZT/+++/SEpKclOvCHvhOA5Tp07FH3/8geXLl6NWrVqC7TVr1kSVKlUE41xSUoJDhw6ZxjkuLg4+Pj6COikpKbhw4QLdCx7CQw89hM2bN2Pjxo2mv7i4ODz11FPYuHEjatWqReNcgWjevLnJxt3I1atXER0dDYB+1xWJoqIiqxVhtVptWk2msa6YuGpck5KSkJubixMnTpjqHD9+HLm5uWU+9mSe5GUMHToUb7/9NuLi4pCUlIS1a9fizp076N+/v7u7Rijko48+wpYtW7Bw4UIEBQWZ7CRDQkLg7+8PhmEwePBgLF68GHXq1MEDDzyAxYsXw9/f32QzGxISgj59+mDWrFkICwtD5cqVMWvWLMTExFg53BLuITg42OSnYiQwMBChoaGmchrnisOLL76IAQMGYNGiRejWrRtOnDiBn376CVOnTgUA+l1XIDp06IBFixahRo0aJvOkpUuXok+fPgBorO9n8vPzcf36ddP3mzdv4uzZs6hcuTJq1KjhknGtX78+HnnkEbz33num58P777+PDh06oF69emV6fgxHBnBex6pVq/Ddd98hJSUFMTExmDRpElq2bOnubhEKsYzVb2TGjBno3bs3AIM2YsGCBVi7di2ys7PRrFkzTJkyRTAJLS4uxqeffootW7agqKgIbdq0wQcffIDq1auXy3kQ9jNo0CA0atQIkydPBkDjXNHYtWsXvvjiC1y9ehU1a9bE0KFD0a9fP9N2Gu+KQV5eHubOnYsdO3YgPT0dVatWRY8ePfDKK6/A19cXAI31/cqBAwcwePBgq/JevXph5syZLhvXrKwsTJs2DTt37gQAdOzYEVOmTBHkdSkLSGggCIIgCIIgCEIW8mkgCIIgCIIgCEIWEhoIgiAIgiAIgpCFhAaCIAiCIAiCIGQhoYEgCIIgCIIgCFlIaCAIgiAIgiAIQhYSGgiCIAiCIAiCkIWEBoIgCIIgCIIgZCGhgSAIgiAIgiAIWUhoIAiCIAiCIAhCFhIaCIIgCIIgCIKQhYQGgiAIgiAIgiBkIaGBIAiCIAiCIAhZSGggCIIgCIIgCEIWEhoIgiAIgiAIgpCFhAaCIAiCIAiCIGQhoYEgCIIgCIIgCFlIaCAIgiAIgiAIQhYSGgiCuK+ZP38+YmNjkZGR4e6uyPLff/9h/vz5yMnJUbzPxIkT0bFjR0FZx44dMXHiRNP3e/fuYf78+Th79qzL+goAhYWFmD9/Pg4cOODSdo0cOHAAsbGxZda+LSyvoxSxsbGCv8TERHTr1g0LFixAQUGBoO7EiRMFdePi4vDEE09g3rx5KC4uNtUz3rNt2rRBXl6eaN9GjRrl0HmtWrUKv/zyi0P7ugOxe1wpgwYNwqBBg1zcI4IgpNC4uwMEQRDewNGjR7FgwQL06tULlSpVcridBQsWIDg42PQ9JSUFCxYsQHR0NBo3buyKrgIwCA0LFizA2LFj0bp1a5e1a6Rp06ZYu3YtGjRo4PK2Xc0TTzyBl156CQBQUFCAgwcP4quvvsK5c+cwf/58QV1/f38sX74cAJCdnY2tW7fiq6++wuXLl/Hll18K6mZkZGDJkiV44403XNbXNWvWICwsDL1793ZZmwRBEAAJDQRBEPcVTZo0cXcXRCksLERAQIDi+sHBwUhMTCy7DrmQyMhIQV8ffvhh3L59G5s3b0ZxcTH8/PxM21QqlaBu+/btcevWLfz222+YNGkSoqKiTNseeeQRLF++HC+88AKqVKlSHqdCEAThMGSeRBBEheDu3bsYO3YsmjdvjhYtWmDChAlWJktGs4/t27fjqaeeQnx8PDp16oQffvhBUM9oOrNlyxbMmTMH7dq1Q/PmzTFkyBBcvnzZ6tj//vsvXnzxRTRv3hzNmjVD//79sW/fPtP2+fPn49NPPwUAdOrUyWS+4ohpDt+s5sCBA3j22WcBAJMmTTK1y1/9PnnyJEaPHo1WrVohPj4ePXv2xLZt22SPcfPmTbRp0waAQbNhbNd4XKN5zenTp/Haa6+hZcuW6NKli+l448aNQ8eOHZGQkICOHTvizTffxK1btwTHEDNPmjhxIpKSknDt2jWMGDECSUlJaN++PWbOnImSkhLB/iUlJVi4cCG6du2KuLg4PPTQQ5g0aZLVmGu1Wnz66ado27YtmjVrhgEDBuDEiROKr7cUISEhYBgGKpXt12izZs0AwOoavPHGG9DpdFbaCjGUnG/Hjh1x4cIFHDx40DRmtkx/YmNjMXXqVKxfvx5PPPEEEhIS0Lt3bxw7dgwcx2HJkiXo2LEjkpKSMHjwYFy7ds2qjXXr1uHpp59GfHw8WrVqhVdeeQWXLl2yqvfLL7/giSeeQFxcHLp164aNGzc6fK4EQZQ/pGkgCKJCMHbsWHTt2hX9+/fHxYsXMXfuXFy6dAk//fQTfHx8TPXOnj2LTz75BGPHjkVkZCQ2b96M6dOnQ6vVYtiwYYI2v/jiCzRv3hzTp09HXl4ePvvsM4wZMwbbtm2DWq0GAGzatAnvvPMOOnXqhFmzZkGj0WDt2rUYNmwYvvvuO7Rp0wZ9+/ZFdnY2VqxYgQULFphWlZ01zWnatClmzJiBSZMmYcyYMXjssccAANWqVQMA7N+/H8OHD0ezZs3w4YcfIiQkBNu2bcO4ceNQVFQkacJStWpVLFmyBMOHD8ezzz6Lvn37AgDCw8MF9V599VV0794d/fv3N9n337p1C3Xr1kWPHj1QuXJlpKamYs2aNXj22WexdetWqzYs0Wq1GDNmDJ599lm89NJLOHToEBYuXIjg4GCMHTsWAMCyLF5++WUcOXIEw4YNQ/PmzXHr1i3Mnz8fJ06cwPr16+Hv7w8AeP/997Fx40a89NJLaNu2LS5cuICxY8ciPz9f8XXmOA46nQ6A2Txpw4YN6N69u+DekuL69eui169GjRp4/vnnsXLlSgwdOhR169YV3V/p+S5YsACvvfYaQkJC8MEHHwAAfH19bfbvr7/+wpkzZzBhwgQwDIPZs2dj1KhR6NmzJ27cuIEpU6YgNzcXM2fOxKuvvopNmzaBYRgAwOLFi/HFF1/gySefxPjx45GZmYkFCxbgueeew7p161CnTh0ABoFh0qRJ6NSpEyZOnIjc3FwsWLAAJSUlAsHLnrElCKKc4QiCIO5j5s2bx8XExHCffPKJoPzXX3/lYmJiuE2bNpnKOnTowMXGxnJnz54V1B06dCjXvHlzrqCggOM4jtu/fz8XExPDjRgxQlBv27ZtXExMDHf06FGO4ziuoKCAa9WqFTdq1ChBPb1ezz399NPcs88+aypbsmQJFxMTw924cUPxub3zzjtchw4dBGUdOnTg3nnnHdP3EydOcDExMdz69eut9u/atSvXs2dPTqvVCspHjRrFtW3bltPr9ZLHTk9P52JiYrh58+ZZbTNe87lz59o8B51Ox+Xn53OJiYnc8uXLTeXGa7x//37B+cbExHDbtm0TtDFixAjuiSeeMH3fsmULFxMTw/3++++CesZrsWrVKo7jOO7ixYuy9wb/OkoRExMj+jd8+HAuPz9fUPedd97hEhMTOa1Wy2m1Wi49PZ1bvnw5Fxsby/Xp08dUz3j90tPTuYyMDK5Fixbcq6++atreoUMHbuTIkXafL8dxXI8ePbiBAwfaPC/++bVt21ZwLtu3b+diYmK4Z555hmNZ1lS+bNkyLiYmhktOTuY4juOys7O5hIQEq9/J7du3ubi4OO7NN9/kOM7we2jXrh3Xq1cvQXs3b97kmjZtKrjH7TnXgQMH2nWuBEE4B5knEQRRIXjqqacE37t16waNRmNlAtSwYUM0atRIUPbkk08iLy8Pp0+fFpRbmnbExsYCAG7fvg3A4NyclZWFXr16QafTmf5YlsUjjzyCkydPWkXYsYRlWcG+er1e+UnLcO3aNVy+fNl0XfjHePTRR5GamoorV644dYzHH3/cqiw/Px+zZ89Gly5d0KRJEzRp0gRJSUkoKCgQNVmxhGEY0etuvOYAsGvXLlSqVAkdOnQQnFfjxo1RpUoVHDx4EABMYy91byilW7duWLduHdatW4dVq1bhvffew6lTpzB8+HArs6mCggI0bdoUTZs2RZs2bfDJJ5/g0UcfxVdffSXadlhYGEaMGIHff/8dx48fF62j9HwdpXXr1ggMDDR9r1+/PgDg0UcfNWkU+OX8+7+oqAi9evUStFe9enU89NBD2L9/PwDgypUrSElJwZNPPiloLzo6GklJSeV6rgRBOA6ZJxEEUSGwdCTVaDQIDQ1FVlaWoDwyMtJqX2OZZd3Q0FDBd6OpR1FREQAgLS0NAPDaa69J9is7O1swIbPkq6++woIFC0zfo6OjsXPnTsn6SjH2bdasWZg1a5ZonczMTKeOUbVqVauy8ePHY//+/Xj55ZcRHx+PoKAgMAyDkSNHCsKOShEQECBwLAYM152/b3p6OnJychAXFyfahvG8jOMpdW8oJTw8HPHx8abvDz74IMLDw/Hmm2/il19+Qf/+/U3b/P39sXLlSlO/o6OjBdGuxHjxxRexcuVKzJ4927QvH6Xn6yiVK1cWfDeaXEmVG8dC6voChnvj33//FfRP6rfH9/Uo63MlCMJxSGggCKJCkJqaKohMo9PpkJWVZTU5NE6mxcrsmUgChlViwGA3b3R2tSQiIkK2jX79+pl8EQBlNuj29G3UqFEmJ2VLpGzoHSU3Nxd//fUXxo4di5EjR5rKS0pKkJ2d7bLjhIWFITQ0FEuWLBHdHhQUBMA8nlL3hjMYtU7JycmCcpVKJRAwlODv749XX30V77//Pv766y+r7UrPt7zhX19LUlJSTPeg8b/cb8+Ip54rQRAkNBAEUUHYvHmzYHXyt99+g06nQ6tWrQT1Lly4gOTkZIGJ0pYtWxAUFISmTZvadczmzZujUqVKuHjxIgYOHChb1ygMWK62R0VFCSa09mKp/TBSr1491KlTB8nJyXjzzTdd1q4cDMOA4zgrwefnn392mdkVADz22GPYunUrWJaVFNYAmPJLSN0bzmBMpmdLKFRKnz59sGzZMnz++edgWVawTen5AoZxs2fMnCEpKQn+/v749ddf0a1bN1P53bt3sX//fjzxxBMADMJplSpVsGXLFgwdOtRkonTr1i0cPXpUoLGy51wJgihfSGggCKJCsH37dqjValOEnLlz56JRo0aCyQxgMJsYM2YMxo4diypVquDXX3/F3r17MWHCBLvyDACGVc/33nsPEydORHZ2Np544glEREQgIyMDycnJyMjIwEcffQQAiImJAQAsX74cvXr1gkajQd26dW2artiidu3a8Pf3x+bNm1G/fn0EBgaiatWqiIqKwkcffYQRI0Zg2LBh6NWrF6KiopCdnY1Lly7h9OnTmDdvnmS7wcHBiI6Oxp9//ok2bdqgcuXKCAsLQ82aNWX3admyJb777juEhYUhOjoaBw8exLp165xKaGdJjx49sHnzZowcORKDBg1CQkICfHx8cPfuXRw4cACdOnVCly5dUL9+fTz99NNYvnw5NBoNHn74YVy4cAHfffedXdc9LS0Nx44dA2AQ+s6ePYuvv/4alSpVclkSNbVajTfffBOvvPIKALMmw57zBQz32datW7Ft2zbUrFkTfn5+grZcSaVKlfDyyy/jiy++wNtvv40ePXogKysLX331Ffz8/EzRrlQqFV5//XW89957eOWVV9CvXz/k5ORgwYIFViZL9pwrQRDlCwkNBEFUCObPn4/58+djzZo1Jmfad99912rVu3Hjxujduzfmz5+Pq1evomrVqpg0aRKGDBni0HGfeeYZ1KhRA0uWLMEHH3yA/Px8hIeHo3HjxgIH0datW2PUqFHYsGEDfv75Z7Asix9++MHpbMsBAQH45JNPsGDBAgwbNgxarRZjx47Fq6++ioceegg///wzFi1ahE8++QQ5OTkIDQ1F/fr1rYQpMaZPn45PP/0UY8aMQUlJCXr16oWZM2fK7vP5559j+vTpmD17NnQ6HZo3b46lS5di1KhRTp0nH7Vaja+//ho//PADNm3ahG+++QZqtRrVqlVDy5YtTQKa8RwiIyOxYcMGrFixAo0bN8b8+fPt0r78/vvv+P333wEY7PqrVauGjh07YsyYMYiOjnbZeXXu3BlJSUk4evSooNye83311VeRmpqK9957D/n5+S7zkZFi1KhRCA8Px4oVK7Bt2zb4+/ujVatWePPNN03hVgGYwvYuWbIEY8eORXR0NEaNGoVDhw4JnJvtOVeCIMoXhuM4zt2dIAiCKA86duyIhg0bYvHixe7uCkEQBEHcV1DIVYIgCIIgCIIgZCGhgSAIgiAIgiAIWcg8iSAIgiAIgiAIWUjTQBAEQRAEQRCELCQ0EARBEARBEAQhCwkNBEEQBEEQBEHIQkIDQRAEQRAEQRCykNDghbAsixMnToBlWXd3hShjaKy9Bxpr74HG2nugsfYe7oexJqHBC+E4DlqtFhQ4q+JDY+090Fh7DzTW3gONtfdwP4w1CQ0EQRAEQRAEQchCQgNBEAThMHeyC3Hoaoa7u0EQBEGUMSQ0EARBEA7TZsZO9F20D8duZLm7KwRBEEQZQkIDQRAE4TSHSdtAEARRoSGhgSAIgvBusm4AumJ394IgCMKjIaGBIAiCcBoVw7i7C45x6z/gyzhgSWd394QgCMKjIaGBIAiCcBrVfSoz4Pgaw/+7J9zbD4IgCA+HhAaCIAjCaVT3q9TA6t3dA4IgiPsCEhoIgiAIh9Cz5iREjooMWQUlOH8v1zUdcgRW59z+pzcAO6cBHpyQiSAIwhVo3N0BgiAI4v5Eq2dNnxkHfRqeWrAHNzIK8fsbjyK2WoiruqYcZzUNPw8x/K/TDqj3mLO9IQiC8FhI00AQBEE4RAlPaHDUEfpGRiEAYOuJ2y7pk91wEkLDiZ+BZU8CeanK2slPc12fCIIgPBASGgiCIAiHKNHxNQ3276/jCR1p+SWu6JL9SJkn/TIcuPoPsHOqsnYYep0SBFGxoaccQRAE4RB88yQda79Nf3ah1vQ5NddNeRJs+TQUZklv4/sxkNBAEEQFh55yBEEQhEPwNQ18rYFSMgvM2oUbGQUu6ZPd2PJpkFOh8AUOldo1/SEIgvBQSGggCIIgHIKvadA7oGnILDBrGvKKnYxi5Cg2HaFlhAZ+FmnSNBAEUcFx21Pul19+QWFhobsOTxAEQThJMU/ToNU7IDTw/BgKS9yUL4GvLWBFtCVymgY9zw+DhAaCICo4bnvKffHFF2jbti3effdd/Pfff+7qBkEQBOEgfEHBEfOkLJ6moVDrCUKDVrqeGHxNA+VpIAiiguM2oWH37t2YPXs2cnJyMHjwYHTt2hXffPMNUlMVhrcjCIIg3Arfp0Frh3kSVzrBTudrGrR6U3m5whca9CJCg5wGQc8TGuwVOAiCIO4z3CY0qNVqdOrUCQsWLMDu3bvx3HPPYfPmzejQoQNGjx6NHTt2gBVTFRMEQRAegdCnQdnz+s+z99By+p/450Iqzt3NMZVzHFCkdcMzn+/ToBcL+8ozTyrIAO4cN3/X8eoX5wJaMrklCKLi4hFGmBEREWjevDmSkpLAMAzOnz+PSZMmoXPnzjhw4IC7u0cQBEGIwE/uplPo0zBs+WGk5RVj0HcHceR6pmBbQYkbnKH5GgKx8Kt8n4YFLYHFjwI3Dhq+8zUNm14BPo8V94sgCIKoAGiUVkxOTlbcaKNGjRTVS0tLw6ZNm/DLL7/gxo0b6Ny5MxYvXoyHH34YRUVF+PLLLzFx4kTs2rVL8bEJgiCI8qFEgSN0TpEW6XklqBsZZLXNmA3aSEGJHhGu7aJt+NoBo3mSwEyKr2kozfp87jegViuhpgEAirIBXRHgG1gmXSUIgnAnioWGnj17gmEYcBwHxkbqz7Nnz9psb/To0dizZw/q1KmDvn37omfPnggNDTVt9/f3x9ChQ7Fs2TKlXSQIgiAUwrIcnl+yH5UDfLB40IPQsxzUKvvSOguTu4mvsLebuRM5RTrsePNRNKgaYrU9xE8DjZpBZoHWPc7QuiLzZ6N5Et+3QTZ6kkhCOn0xABIaCIKoeCgWGv7880/T57Nnz2LWrFkYNmwYEhMTAQDHjh3D0qVL8dZbbylqLzw8HCtWrEBSUpJknapVqwqOSxAEQbiGG5kF2H85AwCwYv81zNh2FktefBAP149U3IYguRvL4fDVDPx1LhWvdWoIX43B+jWnyGDy8/f5NEG0JCNBfhqoVQahocAdYVe1PKFh0SNAr0VAvfa8CiJCg1GQ0IkIDbPqAOPPAyFRruwlQRCE21EsNERHR5s+v/7663jvvffQvr35wdqoUSNUr14dc+fORefOnW2216pVKzRt2tSqvKSkBNu2bTNpNvjHJQiCIFyDireC/v7GUwCAl1f9h2NTHlfcBl/TsPrAdaw+cB0AEBbki2Ht6grqqlUMnl20z6qNID+1SXvtllwNOp55UkkusPYFoPOH5jLjdRKL7CTqOA3gwCKg8wfCsty7wF8zgQdfAqonONVlgiAId+CQI/T58+dRs2ZNq/KaNWvi4sWLitqYNGkScnNzrcrz8/MxadIkR7pFEARBOIHSiKfbz9zD93uuCDQNfK6k5VmVSVk+BftpEOirBgAUaoWOyBuO3sSu5BRlnXIUvqbByI4PzZ+N0ZV0IvXENA1S5X9/BhxZCix+xO4uEgRBeAKKNQ186tevj4ULF+KTTz6Bn58fAIOGYOHChahfv76iNqR8I+7du4eQEGu7V4IgCMI1cBznlP/AiB8Oy25XMQxKdKzAR0LKFy7YX2OKvMQ3T7qalo9xaw3hTS990t1ufwsABt8EtY98HZ2NMKlGbUJJgbnMKF1JaRrEBIzCDPNnbRHg4y9/XIIgCA/DIaHho48+wujRo9G+fXtTpKTk5GQwDIPFixfL7ms0O2IYBi+++CI0GnMX9Ho9bt68iUceoZUYgiCIsmLw9wfxz4W0Mmv/h33X8Nupu9j2mvlZrpIQGoJ8NSYzJ77QcJmnrUjPK0bVSnZOsnd9AuydBwzfAVSLE6+j14qHWbWsAwDafHOZUZNgj6Yh9AHz5zvHgdqt5Y9LEAThYTgkNCQkJODPP//Er7/+isuXL4PjOHTv3h1PPvkkAgPlo0YY/R3Onj2Ldu3aISjIHIbPx8cH0dHRePxx5Ta1BEEQhH1ICQxKMjLz/RjkSM0tFpgWzdgmHlUv2E+D4lIzJ75Pw8Er5hwOd7KL7Bcads8y/P/tHWDoVvE6SpKxiWkajAKEWPQksfJ/5wN7vjB/L7Y2zSUIgvB0HBIaACAgIADPPfec3fuNHTsWgMGxunv37ibzJoIgCMLzscesKafIHC0pt1h8RT/ITwMftUFoyC2tf+ByOhbtvmSqcye7EM1qhTrQWwAF6dLbxMyILDEJDTxNg1GAsMzTYNqeb9A2aErfb3+8Z/9xCYIgPAyHM0Jv3LgRAwYMQLt27XDr1i0AwLJly7Bjxw5F+/fq1YsEBoIgCA/lwOV0jP/pONLyhKvm+RKTfzHyFNQN8tMgNMjgd5BZGpL1238uC+qMXvkf/nfqrvXOd44DS7oA/3wu7cVdIGOGpUjTIGKepC0VGqQ0Dee2AQselNYokNBAEMR9iENCw+rVqzFz5kw8+uijyMnJAVua1KdSpUpYvny55H6tWrVCRobBGaxly5Zo1aqV5J89rFq1Ch07dkR8fDx69+6Nw4flnfQOHjyI3r17Iz4+Hp06dcKaNWus6vz+++/o3r074uLi0L17d2zfvl2wff78+YiNjRX8tW3b1q5+EwRBlDdKTJAA4JXVR7H+v5t4adkhAEB2oRY3MgrQZsZOxcfKLbItNAT7qREW6AsA+G7PFaw+cF3UfGr0yiPWOx//Ebh5EPhzKpByRvwA9moamr8o/M6WCg188ySj1kHKERoAsq4DF/6QP662CLiwXTyCE0EQhIfhkHnSypUrMW3aNHTu3BnffPONqTwuLg6zZs2S3G/SpEkIDg42fbaVWVoJ27Ztw4wZM/DBBx+gefPm+PHHHzFixAhs3boVNWrUsKp/48YNjBw5En379sXs2bPx33//4aOPPkJ4eDieeOIJAMDRo0cxbtw4vP766+jcuTN27NiBN954A6tXr0azZs1MbTVs2BBLly41fVer1U6fD0EQRFmiZ5UJDUYNw4mb2WBZDg9O2w6tXmFM1lIy82Um1aUE+WkQ4GN+dr674aTp86sdG2D+Tpkw3qnnzJ+LssXrcBI+GCUF4pqGkGrC70bBQEzTIGWeZOTSTiCuj3W5UWjY8gZwfA3QZizwxHT5tgiCINyMQ0LDzZs30bhxY6tyX19fFBZKq3t79epl+ty7d29HDm3F0qVL0adPH/Tt2xcAMHnyZOzZswdr1qzB+PHjrer/+OOPqF69OiZPngzAED725MmT+P77701Cw/Lly/Hwww9j1KhRpjoHDx7E8uXL8cUXZmc2tVqNKlWquOQ8CIIgygOdjNCQU6RDnYlb8WyLmnggIhDX0g2T47S8YrsFBgBIyZUw3+ER7KdBiL91WFR/HxUigyVMWNcPB9IvGhKmGbHH5OfOceDbTkDNB0U6ZJHJWa8FMq4Af/EWxIxahxLrfBQCsm6IlxujKx0v1XIf/JaEBoIgPB6HhIaaNWvi7NmzVtma//77bzRo0EByv7w8Gw9YHkaNhBwlJSU4ffo0Ro4cKShv27Ytjh49KrrPsWPHrMyIHnnkEaxfvx5arRY+Pj44duwYhgwZYlXH0vTq2rVraNeuHXx9fdGsWTO8+eabqFWrloKzM8CyrGJTAVei1+sF/4mKC42196B0rItKbJsMrTtyE9Uqm6MV3czIl6ktTUqu7Yl83YhA0YhM/ho1/H2E2mi9Xg9wHNQnf7aqry8uAHjnrtL4gykVJCyviWrLm2BYLXDdOkO1Pqgq+DpjTlcCrHsJTJpZq8Fp88Hq9WCKsmVtfDltAVi9HpY6aLakEJxOayrnqsWDteM3Sr9r74HG2ntw51grtZRxSGgYNmwYpk6dipISg2r2xIkT2LJlC7755htMmzZNcr8HH3zQpkmSMenb2bPi4fn4ZGZmQq/XIyIiQlAeGRmJ1NRU0X3S0tIQGRkpKIuIiIBOp0NmZiaqVq2KtLQ0qzYjIiIEbSYkJGDWrFmoU6cO0tPT8fXXX6N///7YsmULwsLCbPYdAE6dOgWtVmu7Yhlx8uRJ25WICgGNtfdgOdYleg6f/puJxCg/PBkThNxiZSFTs/LNWoJ9x5Md6svdTHlhQ80A2tQruJtnLcgUaXVIvX1TUHbs2DGodAVIEmnr2sVkZBZWN31vBrXpBXfsv8OAyvy6i8u4AakwHOdvZ4OvRy8pzINfhtBESp+bhuPHjqHevRuQe9oX5mTg7LFjaGFRfvfmVaT/+xviS79nMOG4euyYTEvi0O/ae6Cx9h7cMdYtWlg+pcRxSGjo06cP9Ho9Zs+ejcLCQowfPx5RUVF499130aNHD8n9fvjhB0cOZxNLQUQq27RcfctyW222b99esD0xMRFdunTBxo0bMXToUEX9jouLc5um4eTJk4iPjyc/jAoOjbX3IDXWPx2+iaN37+Ho3RK8168tUnOLgV9TZFoyUKQzP5v8wqsByLK7Tzkl8s+3RtUqoVWLJEOf/tgl2KbngKax9aHZdwBBKEI2gpHYMBqq5U+KtlWnZjU80CzR9F21MxDQGYSWxCYNAf/K5m3bpM8lpvkjwB7zd18NA65yTTDZZgFGo81BYnwTqE6Jv2fY1qOhOrAIARoGiYmJwGbh9mqRoYh6wGzaGhYWitDERCiFftfeA42193A/jLXDeRr69euHfv36ISMjAxzHWa3Mi2FvVCRbhIWFQa1WIy1NGGkjPT3dSptgREwLkZGRAY1Gg9DQUFMdyzYzMjIk2wSAwMBAxMTE4OrVq4r7r1I5HPHWJajVao+9MQnXQmPtPViOdQnPF0GtVoOF/QEo7mbb9k1whOqhAVCr1YgIsU7cptVzCPH3xWbfyWisuoE2RfOhWj8UTPoF0bZU+mJArQZYPaBSA7zzVOuLAHW44Ut+mnWoVLWfqUwdUlWwidFrgbC6QPZNoHoicO80wGqhLkyXDKmqatYfOLAIjK5Q9Hen0pcIHLdVrM7Qdzuh37X3QGPtPXjyWDs0ax08eDBycnIAAOHh4SaBIS8vD4MHD5bcLzk52RSeNTk5WfZPCb6+vmjatCn27t0rKP/333+RlCSmwDZoBP79919B2Z49exAXFwcfHx9THcs29+zZI9kmYPCvuHTpEjlGEwThUfhpzI/5Yp0eOgccmu/klE1I0NBAwzPXR63CllfbCbaFB/ki0FeDxiqDM3En9X9AxlXpxnRFBoflL+OB9SPMoVIBs+PypV3A3GbW+8Y8DjzzFdD7W8AnAOi73BDRCDA4QhuFjPbvAMGlQkXePaA4R7wvPoGG/9oCgxBj1ddCoDDD/F0udCtBEISH4JCm4eDBg6K2+MXFxThyRCSWdik9e/bE3r17ERERgZ49e4JhGFHzHKU+DQAwdOhQvP3224iLi0NSUhLWrl2LO3fuoH///gCAzz//HPfu3cOnn34KAOjfvz9WrVqFGTNmoF+/fjh69CjWr1+Pzz//3NTm4MGDMXDgQHzzzTfo1KkT/vzzT+zbtw+rV6821Zk1axY6dOiA6tWrIyMjA19//TXy8vIEEaIIgiDcjVplXnHPLtSiRMTp2BZ3shQkQXOA0ABz1KS46MqCbd8MaoEgP/NqGwcGnMZfWk+iKwJ+fAHIuQWc/Anwq2TeZgyXuqKn+L6aACBpoPl7056GyEr7Fhgm/sbQqho/Q3SlnFtAzh2gSEJo0JRqTrSF4mFddcVAAU9oYJUnzCMIgnAXdgkNfA3AxYsXBWY+LMvin3/+QVRUlNiuAIA///wT4eHhps+uoHv37sjMzMTChQuRkpKCmJgYfPPNN6bITqmpqbhz546pfq1atfDNN99gxowZWLVqFapWrYrJkyebwq0CQPPmzfHFF1/gyy+/xLx581CrVi3MmTNHkKPh7t27ePPNN5GVlYWwsDAkJibip59+soooRRAE4U6KdWYhIbtAC70DflR3sg2ahkr+GuQoSNimlCA/8VfQW0/E4sE64YJs1BwYcDoZM6mUZCDltPk7v25JgXTGaADwsTaPgn+o4T+rBQozDZ81fkBAafnaFwBGQllv1DToiiSEhiLSNBAEcd9hl9Bg1A4wDIMXX3zRaru/vz/ee+89yf35E2pXTq5feOEFvPDCC6LbZs6caVXWqlUrbNiwQbbNrl27omvXrpLb58yZY18nCYIg3ECR1mwek1mgRaCv/bayRqGhTmQQTtw02+K/0Lo2wgJ9sWCXTAI2GfiaBABY8HwSfj99Dy+1rWvY7mPRV7lcDCd/En7n+y0s7Qp0tHg3+QSZNRCVRN5HvkGAyscgNOSV5oNQ+wGRsYakbYB04jifAPPnoizr7ZaaBr37ougRBEEoxS6h4c8//wTHcejcuTN+/vlnk9YAAHx8fBAREWGX88bly5excuVKXLp0CQzDoF69ehg4cCDq1atnT7cIgiAICdLyzKvYWQUl8FFLBRsFAn3VKCjRS37316jxXo/GmLb1LKY+0xSD29QBAIeFhkBf4SvoyYQaeDKhhvl4avOxOQCMMyvyOy3Cgff6GvhrpsFHofVo6/oMAwSGG3wXjOZDGl+g3TjgwNfyx+ILDUYtBR+thU8DmScRBHEfYJcjdHR0NGrWrInk5GTEx8cjOjra9Fe1alW7BIb//e9/eOqpp3D69Gk0atQIsbGxOHPmDJ566in89ttvdp8IQRAEIeSvcylYtPuS6XtWoVYyI3SLB8JwZmpXtGtgjhL3eqeGgjp+PioMf6QeDr/X2SQwAMCrHQ1JPQc+VNtcV2P9epn9bILgu6WmwRLG0hxJzjzJXuo8Ary8Dxi8yWxyZEmARRYGtR8QEgU0flq+bZUaUPsaPvM1CkZ0xUJhgsyTCIK4D3DIEXrx4sWIiIjAs88+Kyhft24dMjIyrDI0izF79myMHDkSr7/+uqB83rx5+Oyzz9CtWzdHukYQBEEAuJiSh9fWHBWUZRWUQKsPEK1v9C/IKTKbynRqXBUzfjP7svmoDYJAZLBQWzH+8VgMa1cXZ27nYOX+6wCAxtUr4diNLABA1RA/PN+6tml/0zF9bbyCeEKCChxUrAsn15YCgZI6mlJBILS2dV1LfAIMwkChmNBQJIzuROZJBEHcBzgUcnXt2rWiJkQNGzbEjz/+qKiNtLQ09OzZ06r86aeftsqRQBAEQSjn6PVMdP5it5XTcmEJKxlyNajU1+FWptlxt4pF/gStTOSl0EBf+PK0C93iqpk+75/UCW90jkFEsK+pLMRPg4cbSOe+QVEOcNmc8O1jzVLztgadpfeT4qm5wJBths8+QQbzI1uIaRoAIPQB2/sanaHFzJN0RYCW559BQgNBEPcBDmkaUlNTRfMRhIeHWyVOk6JVq1Y4fPgwHnhA+PA9cuQIHnzwQUe6RRAEQQDYdOy2aHmJXg8dKz7xN2oaCnmO05X8ha+IYq18uFYNT5PwWGxVxNesjCBfDVSlYV/bNYjEiEfqomFUCJ5uVgP+lo7OfL7tAKSbfSVUDE/Y8Qvhfa4knS+BT4shhv+j9xjCpirBStNQKkTxNQ0xXYFWI4DVzwl9E4x+DScsHLQBQ1I4DU9bw5LQQBCE5+OQ0FC9enX8999/qFWrlqD8yJEjqFq1qsRewjCrHTt2xGeffYbTp0+bQpkeP34c//vf//Dqq6860i2CIAgCQCVe/gM+JToWWglNgzGq0tz+SXhz7TF81q8ZGIvV+GKdSKIyHnxNRL0qQYitFiLYzjAMJvdoYrP/yL0nEBis8Akyfw4IUyY0GKkWr7yuEvOkwEiD5iOkOpB9w1xuDMd655h1uzm3AH9eXgryaSAI4j7AIaHh2WefxSeffAKdToeHHnoIALBv3z7Mnj0bL730kuR+r7zyilXZ6tWrBUnTAGDq1KkYMGCAI10jCILweoq14pP7Yp20eZLR36BLkyic+PBxk8DQKykaG47eMu0vR1KtUHRtWg1Na1Sy8l+wi+v/ym/XmM2cEBAKZF2Trx/RwLF+WJohmcyTeAtmGoloVFJCj9rPEA62yBy61pSx2pK8VODYKiDxeXMmaoIgCDfhkNAwYsQIZGdn46OPPjJlhvbz88Pw4cMxatQoyf34yeEIgiAIJ9AWGSasIrb5/DCrfEp0rKR5koaXOZqvYfiiXzPFQoNGrcKiQS1sdt0mUpmWjfDDxoo5NGv8zTkdOkw2TLodIdriXNSlGhy+eZQxeZtl8rjWY4AjS4F+K4DwusCCUrPb6s2AmweFdQvSgK3jgR6fC8s3jDTkhEjeAgzf4dg5EARBuAiHhAaGYfDWW2/h5ZdfxqVLl+Dv7486derA19fX9s4EQRCEc2RcBhY+DCS9YD3RBJCeLx6aVM48SaUSdwzmCxBSGgyXU5Ivu1nLaGAywAoUcaYOCAdyS/062r/teD+qxQm/izlPm8yMLK5r1xmGhHJ+wUKn56gm1kIDABxaYj2WxiRyNw/Z1W2CIIiywCGhwUhQUBASEhJsV5SgoKAAhw4dwu3bt00aCyODBw92pmsEQRAVl79mArpC4NASnE6agqY1Kgs2Z+SLaxqK9Sx0EhGQNBJCA5+6VYJs1nEJNoSGIzfz8VDpZy4wAlY9Vzn1ajOj8QMYNcCJCEu9FgP/rQAeGW/4HhBm8FUwwjAGgQEAfPyBt68Y/Bz+nSd9PG2hMDGc1LEJgiDcgOIn69ixYzFz5kwEBwdj7NixsnUXLFhgs70zZ85g5MiRKCwsRGFhISpXrozMzEwEBAQgPDychAaCIAgpePbwPebtwcXp3QQT53QL86RK/hrkFOkMmgaJ5G5qGaFh0ytt8f3eK3i7ayOnuq2YklzZzdeztSah4UpxCKwCgKtdJDQAQFCkISu0Jc36G/6M9FkC/DICeGySeDuB4Yb//pXFtwNAxhWDJgIAdCUkMBAE4VEo9lQLCQkRfJb7U8KMGTPQoUMHHDx4EH5+fvjpp5+wa9cuNG3aFO+88479Z0IQBOEt8J1oAat8DDmFQs1tq7qGCavBEVpc06CWyVvQrFYo5vZPQnSoeGI4l2ND03Apw3y+V1DDuoKrNA2AuPmTGFUbG8K5NuohX88/VHrbhpEGwSEvBVjYWrgtV0RwIQiCKEcUP1lnzJgh+tlRzp49i48++ghqtRpqtRolJSWoVasW3nrrLbzzzjt4/PHHnT4GQRAVG47jcCk1Hw9EBDoXred+w0JoyCooQWV/w4Se4zjklwiFiEr+Bg+AEp1eMnpSYu1Q1/fTUWz5NPBeXfqw+sKNI3YCm+S14XYRFOG6tgB5TcPdk8B3jwP5Kdbb1g4Ehm93bV8IgiDswIXLMXYeWKMxOdhFRETg9u3bqF+/PoKDg3Hnzh13dYsgiPuIX4/fxus/HsMTTaOweFAFSgp57jcgNRlo+4a48y1PaPCBDlmFWjwAg9BQrGNhaYEUUpqkrUTHYtc5w4S0R3x1PN+6NqqG+OFCSh4eaWidsNNtFMubJwXA7Oid6mPWNKREtkbV6Bbu0TQoJSDU/NkYfpWPmMAAiDtPEwRBlCOKn6w9e/a0SvQjxYYNG2zWadKkCU6dOoW6deuidevWmDdvHjIzM7Fp0ybExMQo7RZBEF7Md3uuAAB+P13BTDfWlNrK12gO1GtvvZ23Eh+EQmTzzJEKSvRQQw89zNmWQ0o1DUdvZJkigwb7adC2gWFC3DBKmVlpuWFD0xDOmIWKyZsv4IXSRM06Y0ANVwoNDToBp39xXXt88yS/EKBAPNIVQRCEp6FYn9+5c2d06tQJnTp1Qrt27XD9+nX4+vqiVatWaNWqFfz8/HD9+nW0a9dOUXvjxo1DlSqGla033ngDoaGh+PDDD5GRkYGPP/7YsbMhCMKr8PdR2650v6Hn+SOknRevozOH8AxmipBdoIWe5fDfnWLkHfsF5/0Go4/qb1Mdo6aBn0rgfIr8ar5bsSk0SORxYEvNslwpNDR7HnjyS2DMPte0xzdP8rNTWOMPIMfZlwmbIAjCSeyKnmRk8uTJGDRoEN544w1BnXnz5ik2LYqPjzd9Dg8Px7fffqu0KwRBVGAup+bh4y1nMLZjA7R4IFy2boUUGvLTzJ+3TQDqtgeq8LSvep1QaEAhsgpKsO7ITUzfk4muvh9AreLwue8ibChqBxYqk6aBT0qOh65wX90ja4rzo+4x/KR/DL3Ue7FdL0y+xrClApfa+nwdRqUCHhzquvb45kmMnX44+anA2kFgGnRGnfP7od6yAxjzLxDV1HX9IwiCkMAhz8H//e9/6Nmzp1X5008/jT/++MOuttLT03H48GEcPnwYGRkZjnSHIIgKxMur/sOuc6l4bvF+m3VZifChHkHyVmBJF+D0BkP4TKVY2rTvnWv6+Mfpuxi/6l/B5m7qA8jLy8NvpSZaDGO+JvUYQ4KzSgHW60MfPe2hE80No6U36dtikm44/uNi0LLoK4zSjhNsZ0yaBg8WJv14mgYLh3ab7PkSuLEfql3TEHGrNEP0voUu6xpBEIQcDulw/f39ceTIEdSpU0dQfuTIEfj5+SlqIy8vDx999BG2bdsGvd4Qi1qtVqNbt2744IMPFIduJQii4lBQokPyXYPZjM6GQPDVrovYc9G8Ks+ynGRWY7fw4/OG/z8fBBJfAHryJndF2cCPLwBxvYEHXxLul5cq/B5kdsQdueIIopAB+Js3v67ZgKsnr+BMtS/ghxJUR7p5Vxg0Epaahs1j2yG+pkwUH3fC8nITNHwcqNMO2D4FAMCAA1e61pWKMKtdTZoGlQs1Da5GxVurK0iTridGxmX59giCIMoQh542L774Ij788ENMnToVmzZtwqZNmzB16lRMnToVQ4YMUdTG5MmTceLECSxatMikaVi0aBFOnTqF9957z5FuEQThoWQXaLHqwDXkFwtDgfJzBly4l4vEj4QhJd9edxyvrP4PHGctQMz+/Zzg+1e7LiK7QGtVj+M4LPzrInaccaOz9LFVwu975wFX/wG2jLOua5lIjBVesyCmCJbUyTuGKHUuajEpUPM0DQGMQcNh9GkwYvndowitbf7c+1ug7eumrwWc/KKUSdOg9i2LnrmO6on21Q8oFZByRcx/Xem/QRAEIYNDQsPIkSMxa9YsnDlzBtOnT8f06dNx5swZzJgxAyNHjlTUxu7duzF9+nQ88sgjCA4ORnBwMB555BFMmzYNu3fvdqRbBEF4KAt3X8TkDafQ/xuzydGqA9fQ5IPfseeCYbX109/PocQi8dhPh29i64k7uJVVaPMYn28/jzd/OmZVvudiGj793zkM/+GwcydhDyJCjgCxDMMFGcDW8cCZjcKminORW2QWhgJhLTQAQB3dJVSG0IHYvzQ0aSULIaFSgAevxBdmGv4/Pd9k/5/x3Gb8qm+Debreorss13UBAPwSVqq1eWI6EBAOdJpS1r11jH4/ANWbGYSiwb8CCf2t60TFmT+HlIaVzb1rXY/xYFMsgiAqFA4vUXTv3h3du3d3+MChoaGiJkjBwcGoVKmSw+0SBOF5GFf5T97KxpW0fGw5fhufbzdEBhr43QFcndkDeRZZjflYJiQT0zwAwJ/J1jHuL6bkOdptxzFOfKXgR0i6vBvYOc3a+bc0hv/hc9cw6NAO/Pb6owCAIIg7MKenpaASoxeUBcCoaRAKCR6taSgoNa+KNjs5B9Rvi9e0r0ru8oFuCBboeiIwPxqZ287i6I0sfDz4OGKre+i7JOwBYJQ5uhUCI4ATPwrrVIoG7p0yfK4cDaScBvJEhAZP9t8gCKJC4bAxZE5ODn7++Wd88cUXyMrKAgCcPn0a9+4pMwEYM2YMZs6ciZQU80s+NTUVs2fPxssvv+xotwiC8ECiwwJNn3st3GsSGPjkFUsLDUdvZOJejnmFPT3ftmNxiY4Fx3ECYYRlOWQVlFiZSbmcrOvC774WCyT8hF4/PC0eLSiiAQAgPycTRVoWJ/74Ac+qdyNQxDwJAHIz06w0DSMeqoYfekYg5JrZ7EutYjw3e3ZBhtnOP9CciTnAV42H68tlZmaQijBcSy/A4r8v4+CVDDy72EUhUssDnwDrssrR5s/h9a23GyHzJIIgygmHnjbJyckYOnQoQkJCcOvWLfTt2xehoaHYvn07bt++jU8//VR0P8sEcVevXkXHjh1RvXp1AMCdO3fg4+ODjIwM9O8voq4lCOK+JC3XPEnOEvE72Jl8T1ZoGLf2OADg6sweAIBbmdLmSgt2XkDfB2uh8xe78WRCdYEpzuiVR/DHmXuoEuKHQ5M7230eirE0Pwq0CB2rJJpSRH0g5TSCmULUYu7hmfMT8YwP8Km2n2j1AH0u9Iy/oKx5dT9g6xMAgDaqydjHNoWfxkMFBgBY0dP8OUB4zV7r1BD/XkqHUnKLdJ7nHC8FP+GbkUhemN3wetL7Kky6ShAE4SwOCQ0zZ85Er1698PbbbyMpKclU/uijj2LChAmS+3XuXIYvaYIgPJb0fPmcAC8tU+ZvoGc5qFWMrI/DZ3+cR16xHrlFOqw5eAPPtzY71v5RaiaVmluM/GIdgvzKaJW2uDRxGqMCOBbQWwgJlt/FiDCsLj+oOo8ffaeZiturTwAAbnKRqMmYo+80U12C1vKRvvVN08cHmXPYh6aIZu8Auz8Fmg8GQqrZcVJlTH46cOe4+btG6Mz8UL0ITH2mKXYlp2DXOWGEqXqRQbicZp0Q7kZmAR6ICCqT7rqUoAig7zLg5yHmsoTngBsHgKpN5IUGfRlrzQiCIEpx6I158uRJTJ061ao8KioKqampInsY4CeIIwjCO+A4Dul5duQpkCE9vxhVQ/xlNQ0AsGj3JdPnzcdui9ZJyyt2vdBw7zRwYTugKV3xj4wBUpMNUW+2TwHavmHQOigRGngmKdGMeYW9tSoZAHCCrYfqNWpAfc8gRDyhti14BaEQ2zVvALtgSBDnSY7Cl3eZPz8kbqI6uE0dDG5TB30X/YtDV81+I/1a1sLM35Kt6t/LKb4/hAYAaNoLWD/cHC0rIMwgSABA+iXJ3aDj/RbSLgDpF4HYbmXWTYIgvBeH9NR+fn7Iy7N2Lrxy5QrCw+UzuFpy6tQpbNq0Cb/++ivOnDnjSHcIgvBgcgp1NnMuKKX1J39ixf5riqIpGcmVMHs6cTMbkzecRJ+v/8Wu5BTsOCNvIqWIrx8GdnwA7PrE8D04yrxt71zgj9Jw0iXWq+JWlPo0SFHABEI1ajdON1MWorpGaABimJvmgnw7cwS4Cl2JeHSp20cN/1uNBLrOkG1i7cg2eKWDWagKlYgGlZIr7v/hsRhzdlRpJDQ74t9HluTcBrJuGK7pggeBNf2BW/+VbT8JgvBKHFpm69SpE7766it8+eWXprLbt2/j888/x+OPP66ojfT0dIwbNw4HDx5EpUqVwHEccnNz0bp1a8yZM8du4YMgCPex/N+rqB0eiA6NqlptS81z3cSN44D3N55C58YykyiFvLrmqOnz0GWHAABNa1TCplfaQuOso3BxaabfkOrC8hsHDP9tRVcCoK9cG3JxcQo0oWBUKgSFVrHalsUFIZQRCiY94qvhVnIJkGU8gGu0P3ZRlAPMSwJqtgSeL40WlHPHYCaVctbwvWoTm82oVAzCAs3mS6GBEkJDjtksLrtQi2//voyeSTXQoKqHJg/tOhOoFi8MtwoAvkEAGAAiwtaFP4CvWgH9eblA0i4A0c3LsqcEQXghDr0Z33nnHWRkZODhhx9GcXExBg0ahMcffxxBQUEYN04kWZEIH3/8MfLy8rB161YcPHgQhw4dwpYtW5CXl4dp06bZboAgCI/g3N1cfPDraQxddgisiEbhRoZyrYCRepHyJiX2aBrs4fTtHFwRsY13mBAL4cYnwCD55EubcaJWayBpIObsz4KOk35E/x70DACgUlik1ba7nPWiSyV/DSa04WWBVqLtcDXnfjNERzr/m+H7iZ+BLxoBu2cBKaWa5qimipoK9DWveVUOMAsQm15pi5fa1gUA3ONpGqZtOYMFuy6i/zcHnDyJMkSlNviaWE74GcZs8iaGtgA4uMT8vSi7bPpHEIRX45CmITg4GGvWrMG+fftw5swZsCyLpk2b4uGHH1bcxj///IOlS5eifn2zirlBgwb44IMP8NJLLznSLYIg3EB2oTka0rWMAtS1mPBfzygAALSpF4F9l21Hv/lzfHv8efYePtlmbaNuJPlujoO9tU2mSHQnhwm0CBOacQXISwGKJfqv0gDD/gDHcVgwaRtWYyH+8x9tVe1vfTxusoYswZWrRAu27dM3wUmuLhqpbgh30pcYTFmMaMtG8JKFtbi22983/P+LZ45UpZGipoL8zHqYyjzzpPAgX1StZMgcfSerCH+evYeH6kVg+1mDE3xanrxTvsfC2Fjj4zuRiyUPJAiCcBK7hQadToeEhARs3LgRbdq0QZs2bRw6MMuy8PGxVilrNBqwLCuyB0EQngg/58GZ2zmIDg3A3otpeLBOGEL8fXAt3SA0xEVXwoDWtfEazyzIV62yygJdv0owjl7Pkj2mrYTLzpChIAeEKDqRyaifhRlMSR7weYx1vVI4GIxQjNcsA+JmNFpocDfbsIqurt7MVH6AbYSbz6xFnztLgCMWO+35EuB4yd8ubgcWPgw8t8IUqcnllBQAyVuBBp0MDuAsz2ekMMsgQPGpXBvwV5aQLYinaYgM8cUTTaPAckDNsABElQoNvx6/jV+P38aYx+qXfW6OssZWaNUcnr8KPwmcXguoPTgDOEEQ9w12mydpNBrUqFHD6Yn9Qw89hOnTpwuSwd27dw8zZsxwWBAhCML16FkOH/56Gt/vuSK6PafIvHr8zT+XMW7tMQxddghDlh7C0euZ+H6vYb/a4YEI4UUralA1GFOeErdfjwj2FS3nExetbHIZbBEh6fRHT2BAq1qm7+0aGMx7gnwNK9eZBfJCw9/nU3HiZpbhy+1j5hXewizryn4K+hhW1/RRX2redeaOURMhPlHUQW2qC5UK7+uHQ8upMVfXGz3iqiHCV2+9EydSlnLaENXpp8HA4e9t9xUA7p4C1jwP3FMQuGLnx8Avw4H1wwzf+ULDrAes+xQkl8BNiC8v34S/jxqLBz2Ibwc/CIZhUDVEaMrz9V+XoOVlFZfKKO7Z2JGPIbf0vXpyHfBxJHB6Y5n0iCAI78Ihn4YxY8bg888/N2WCdoQpU6YgPz8fnTp1QufOndGlSxd06tQJ+fn5eP/99x1ulyAI1/L3hVQs+/cqpm45g2wR050cnnnS8RtZ2HryDgDgyLVM9Fr4r2lbiwfCBSFOlw5piYEPPSB6zOa1w9CkuvyEu3ntMNPnygE+eKF1bSx/qRV6xFfHjjfbm7b5qIWTrSA/DT7pFY8vn0vE7288ivkDkvDb64+ge7zBaXnSLyfx2pqjeGnZIazYf81wDc6n4ok5f+O3k3cw+PuDeHrBXuiKC4Bv2gOLHzWsqIs5N1tqGkQoZs39M85ljVqEhJqVcSX8EQDAv/om0KoMk+F9quaYP8CcI2ebb1fEFi/HIcTBz0dtn5Nz8hbgzCZgi4Q/GmsxsV/+FHBuK7Cqr3VdjjPkgDi5zvD90HeG/5d2Gv6LJbWr2dL8OUB5AAwNL2mbZcK6qiF+svu61ATNEzGaJxmFNX7+B4IgCAdxyKdhxYoVuHbtGh555BHUqFEDgYGBgu0bNmyw2Ub16tWx4f/s3Xd4FMUbwPHvtfReCQk1IaGEEAi9ShORIlVRBMSCWH8iFhQLKgg2VMQC9gKKgqAURZpKEUKvCYTQ0nuvV/b3xyZXcpeQhNDn8zx5cjc7W+42udt3Z96Z1avZuXMnZ86cQZIkQkJC6pQXIQjC5bf9lGlozn/jMhjRobHF8vzSi3f7mDEolLaN3TiWZErQdLKrfmwgd0cNG/7Xh9S8UrrP32KzTutGpqDij//1obGHIwD9Qi1HE7I1EpJCoWBUR1MugKezHV7OptaN3w/Lff+3xqbzd2w6W2LlbjSPLDMNZRl/IYGwiseZX46npMvjmNovKujK5D76GbFILv4oKi/m7FyhXJ4ALiYHIqscYlq+HDR0buZFXPNPmLF8NbFSEz4fHkgfuzheaT8Bpdr08f3hhI68/WcsU9pWlPV8AqKXWr1uAHzCIPOk7WWSZNkNJn4b/Hg3DH0LQofIidwl2fIy8+4wlVKPwrZ58uNWgy374Z/9V+6eVZWLP0xYDtvmy6MH1ZL5ebWrco793KyThl3s1cYhddPySy3O93WhLjM/F6aBeW8A0T1JEIQGUK+g4VJndjbPi+jVqxe9evW6pO0JgnD5RJ8zJS/vO5fN0PBGKBUKlBV3es1bGqozvIN8F19ldne4NhOrNXJ34OupXVi+5wKbTlgmd7Zt7MYdkY0p1eoJcLe+SLwjsjG/HUrmiQEhuDloeG7lERaZ3Z2vyqNiCM/7VH+SLznxq6EvAFtjU+mqOIkCeFuzhO/0g/lSP4y484nGoMEnbQf//pZHExUQGAVJFQkFjdrDA39BXiJ/fPsWt/MbAO/bPYSrq4pbM77hOe3D/GX/PADnpEZ89esRfoxOqHj99ihU9hyS5DkbWrXuAO7drJqIe7fyoUfLHhw6dKjixTSF6Tvhsyqfra2GwIDZcuuILcXZll2Evh8l/177ZLXvmwXzUXsWNLVc9u0I6yFoQQ6sWg+Tf+qgdYDcimOnUqKockHt5mD5tzWyQ2PeHNOe8Z/9R0xKPqn5pbS5SEvWtaeOQUPcRtNzjZPtegl75WT0IfPkv1tBEIQa1CloKCkp4e2332bz5s3odDp69OjBSy+9VOc5FRoqL0IQhMvLYJA4nW66O3w+u5ghH/yLi72aNY/1QqFQWOQ0VKdFxay8QZ6OxrKqXUqq0z/Mj94hPrSa/YfVNj+cUH0Q8M64DjzUpyVtA9xQKhXc3j7Aoh98VV7OGkIUiczRfAdARrkH2w0RvKtZwljVdmO9l5XL2GToTEKS5Z3qvqqj8gNnX5h5Uh5W1UvOVyhTu5CdX2j8xF2W2YpM3JmLfPyjy17jCfVq5ukmEh9tGvXI383BokWmMsG3Vhw9rMvajwcHd+vySoWpdcorsKDXwaFlNdcpSLEu82tTr925OWjY/9IguTtWFeZBRI+W3sZg0d/NnpgUSM+/ziZ9A4uYQX/PSlIO/ElQ7BeWdfzamoau/XGCqbw0V54jw6CDr2+H1rfLs4F/N1IervW70fDChcv+EgRBuL7VKadh0aJFrF69mltuuYVhw4axa9cu5syZU68dN0RehCAIl1diTgmlWlNw//fJDOIzijicmGfsF55fcvHuSZWtEq4OGnY835/o2QONF3bmCc1LJtm+26lRKWnmLd8tDfV3YXBbf9yrmdCrkp1aSXigu3HfNQUMAIEeTnRXxhiff9PpDH/N6Mtw5X9WdbfazSQny8YFMIBvmDxZWaP2xqLsonL+MnQG4JQhkEwsL9wPSq24X/sc8ZLl8KmN3BzoGezNzMGhfDO1i9Ud9Ro5W0/6Ruvbq7/rDFBgNupOXlLt97X/W3jDGw7/WPt1AKLug77P1G0dM94u9laJ7lW18DUNAexfkSCdll9GbnE5u+Kv0qzY9WJ27oMHkNbqHvR3LoO7fjCVu1t1kDPJvQA7FkJGDGx/Ty7TyqN0GScjFARBqEGdWho2bdrEvHnzGDZMbkYeOXIkd999N3q9HpWqprlLrTVEXoQgCPXz8bbTbIlJ44spXWrs2x2XLve7VysV6KpM3JaSV4KXs52xpWHhnR0Y0aEx7/51EjcHDe9stN1vPsjT8n/9l4d7kpxXQjMvpxpnYt74VF/KtIaLBgv11TrAlVylaUQgVfZpQv1dKVWqQLIMjNQKA01zo23fdrExo3FWYTn/GiK4u3w2xw3Na31MwX4uKBQKnhjYqtbrmA7SXs4R+HOW/PzO7+SZhaUaWni3L5SHRwW4YB0sWVBWfH2U5Na++1JVIz6s33q1sHRSFD/vS+SZW8OMZf7ulUFDKaM+3sm5rGK+u78rmYVlvL/5FF9M7kJYo2t0tujmveWkdUfTAACEDQWl2R9hZRBgS0EKpBy5fMcnCMINr05BQ2pqKp07dzY+j4iIQKVSkZ6eTkCAjb6qNbjUvAhBEOqv8oJ+6tfRvDKiHVHNPG3Wi6vomnRLmC+bYyzH1E/JLeXLHWfZHiffrW3s4YhGpeSFoW0s9nGxvuOOdiqCfV0ueswOGhUONrqiNBQfZRGDlaZEZzLjQK/FQbI9Gdi9yr9sb8g3jAV/xHLgfA7fPdCV3WeyKt4LBf8ZajfbMchDwPq41KE7ki3dH4F2o+Vk48pWippaGs7vkIfrdPWHcztq3rZSI4+KdOD7muuN+hTWPFK3424At7ZrxK3tGlmUVXbvWrbH1BVn28l0vt55DoDnVh7mt8d7X7FjrJMRi8AnFCInWpabtz4FdYFz27EpPxmy4k3Ps880/DEKgnBDq1PQoNfrrSZkU6lU6HS1nzSnofIiBEGoH/Mx6g8n5jH2013sf2kQ3jYuUOPS5KAhIsjDKmh48Lt9xseBHo50bW75P7z8wW4s2hrH3FHhDXn4Defsv7BzEYz4ANyD4PRm7BVa4g0BtFCmoSwvkMe4r2K5bgD3qLcan2dIbgwqe5fH1WvwVeSSetKZz/6JA2BLTDqPLT9gtY2aqJQKbgn15cVh9evrb8XV8sIZpY3Ay7wvfHa8nPdwYk3N29WVwPeja67TbxZE3nNVggZbbAVhjmaBaFLuNZzr4OwNg16VH+urDIM7fQccXw29Z0B6DJz6w3r9glTL0asWVZ8PJAiCYEudggZJkpg1axZ2dqbuDOXl5cyZMwdHR1OC4+LFi6vdRmVexIgRI7C3t2fdunXMmTOHRYsW1ePwBUGoqwIbM+Om5JXaDBpOV3RPauXnwsan+jLkg39tbvPNMe2NuQOVeob40DPE+qL7qqk6nOi3I+Tfm16FcV/KLQuAumUfFAUHIOu0zc38qB9AUfDtPHRe7ou/Td+RPFyYp7tXrrAxzlj3p711Sy59e1wEd3auoV/65dLqVnDxgzN/Q/ZZKM6S551wbwJ5CRddvVpR98m/79sAuxbJ3aUWRTbAAddPiJ91i9bec9nGx0VlOgwGyepv+ZrXqL0ph2b0p/BOiGkivaAukLhXHiK3LL/6bVT9/xAEQaiiTonQo0ePxtvbG1dXV+PPyJEj8fPzsyirSWVexBtvvMFLL73E0qVL2bJlC/qqd04EQbgsMgusu9uYz4K891w2hxJy0eoNxu5Jrfxdqu3r7eNibzU3wjXnxO/wVnOI2yQ/N++acWylPBlZRZDQLDQCRUBktZtS+7bEpd0Q4/OmyvRq61Z23bJlQpcmfHVfZ6b1bWksG9spqObX0VDuWw9D3zE97/KgaWbqnLNwtqKLS+htMOozCB9nqqsxJRZXK3wcPBYNbhXdVpv3gntWGEeTulqCfV14dkiYRdnec6ZJ+Uq0erIvMiP4Nc/REzrea3re8hb5d9qJmvNZSkUytCAINatTS8P8+fMveYcNmRchCELdZRZaXxRlVZSdTi9k/Gf/oVEpeP+uSIrL9fi42NHCp/qcgwf7XN0LwVr5eZL8e9k4mJ0G62daLl/1ADSKkB97Bct3aY+tNC23c0UKvZUDvqNY0nEg3i72HDw8kY5JyzgR/ADD1AHGmbCrcrZT0amZJ9vjMpk5OJSl28/Q3NuZBWPl/R1KMF2sqa7UHe7mveUfn1ZywrRHE9MF/Zl/5C4uIF/stxsNkXeb3g9tETh5y60RIHdtCh4A/5m1MDt6yKNIXYMe7NOi2iR9kGfjvuRckqvNfHbykEHw7zuQtK/6+gA/T4a7f5KD571fQP8Xrbu2CYJwU6vX5G6XoiHyIgRBqJv953PwcrHHXq0iKdd6hJWNx1PZdz6bY0ly9wWtXuLx5QcBGNY+wHgxu3RSFF/vPMfoToFcyCqmbWM3bm3rf+VeSH2YJ38C/DVbTuCtKrViZBnvEPnu7PldEFeR7NyyH4pxX2E+IGzHBz+Gojnc7+LHFIPEkwNb8dSKQ8Sk5NO6kSuxqXLXrpm3hnFfz+acSMmnTYAb93Zvhr3G1Mhb08zYl11wf9Njn1D5d2K0/NvJG1r0My2ftBqWjYc+M6HjJHl0pewzcj96tb0cPPz2qFy3wz3V7zN8LBxbZZ3Qe4XYq1W8PS6CLTFpbDwuTxjo5WxHgLsDx5PzSS8oBWqYy+K6YBZ8NukGwQMh3vbM6kZn/4H938CW1+V8laJMuHv5ZT1KQRCuL1c8aGiIvAhBEGq2eGscW2PT+XJyFGdztTzzy54a6/9xLNVmuY+LPdNvCTY+tzUizTXt1EZYfqdl2V6zCbH8wyHzFOgrWl+Cush33xUKmPgL7P4UYtfL3XeqUijkPADkFoKwRq58d39XTqTkczI1nzc3xAIwPCIApVJBeKB8IepZZYjbPq18WPAHaFRXuT+5v1nCur07PLQVnMyS24MHwPPnwM5Ffu0eVXIvOk6E9uPkoT09m1e/nxGLoN0YeXtXyZ2dm9A/zM8YNIT4ueBqr+Z4cj5p+bZHy7qu9J8tB8G9npLPVZvhFw8aADa+YHp8YddlOzxBEK5PVzxoGD3aerSNkSNHXunDEITrVqlWz7e7zjGiQ2MaezhaLdfqDbz71ykAXlsXw5pDWfXe1/29mxPgbr2P68aJ32te3uVBuQtG5ey5w9+3TAbt/oj8U0u+rvb0c/XFYDanhZ+bQ43rtGvszm+P9SLAveZ6l527WT5Fo/a2L/ztLzKHgdq+5oABwN5Fvoi9ynxd7Xnx9ta899cp7urchH3n5S49r689QSN3B/qH+V3lI7wEvqHw5EHT8+Z9qq87/APY+yWkHbUsL8mBvxfILUsqG3OjGPRygOgaYHtELkEQbjhXPGhoiLwIQbiZvf3nSb7aeZb5f8Ti7qhh8T0d6R3ig84g8dYfsbg5mr7g1xxKrnY7qx/tyfub4/j3VAYAsW/cRmJOCUGejsxadYS953IYd6UScy8HSYKM2JrrOHpCqyHy0KA+rSxmcb4Ut4T58v5dHWgfWLtuLh2aeDTIfi+JQgGth8sTiPV79mofzRUxrW8w9/dqgVqlJDGnBJCToad+vZeY128jNb8UJzsV/m4OJOeWMHf9CcZ2CmJgm2u8S15VPq1MI2FFTZUv9P9+U14WORFa9IWPOlmv9/d8OPmHPLpW/xctA+o1j8CRFeDaGCb8AIG2Z3MXBOHGccWDBkG4WWQUlLHhaAqjOgbi7njxWYy//+8cJ1LyeeOO8BpnRt4UY+pKlFeiZdKX0UQ18yTE14UV+6yHx/RyUJJdaho1paWvMxO7NaNjU0++mNyZr3ee5dZ2jXDQqIxDUn4w4Toewz1hL/z++MUDhjYjIOx2eUbd/i/UXLeOFAoFoztehwHXqE8gbzb4W89qfaOq/F9r29hyEsI2r/wJgIu9mh8e7MbmE2lsOJrKhqOprH28N+2DrrO8h+nbYf+3chcytaPcstD5AVDbgXcwDHxFzmeoKuWQ/JOwG0KHQo+KvJXTm+XfBclw+Kfqg4akA/IcIK2HywnyVZ34HYozofP9DfAiBUG4nETQIAgNYM+ZLJzt1cZ+66VaPbe8s42icj25xVr+N6iVzfVS80p54Nu9jOjQmAV/yBe5hxLyGNDalyk9mrP6YBJ3dWmCWqXkp+gLnM8qJiG7xGo7+8/nsP98jlU5wIOd3DhX7sLP+xIBeHd8Bzo1lWeAtlMrebhfsM31GoxBD9oSuVvK5ZJ7Qe5rr9fClzXMNv+/I/LMuE5e1+zoPleVg7v8cxMa0NoPTycNOcVai/LCMh1vro9BbzYp4vQf9vProz3xN+t6tvdcNnct+Y9XR7RjSs/mDXJMf59MR5LAXqOkczMv7NR1GiXdkqMn9H7K9PyuHyyX95kJXi3hl/tsr3/2X/ln4wvytsxHaIpeKg/PGzLQVFZeBN+PkYMNgONr4N6VcgvghmegrBC6TjONbNa8L/iEyAnY/30Mp/6Evs/IifOCIFwTRNAgCHWw50wWsakFjI0KwsVe/vc5lVbAXUt3Y6dScmTOrThoVKw/kkJRuTz3yPubT9E+yI0Brf1ZczCJj7bG8U7FhfuirXEcT87neLJp0qWYlHxiUvL5eJs86s/8P2IJ9XfhVFqh9QHVYEBrP9oGuNLNp4gQez/WHk7htvBGdAjyaJg3o7Z+f0IeLee+DRBUzd3I05vh9//B4NdA4yi3ABxbJQ/jGTpUvkAZ/BqgkLtIJB+UL1y2vAZZZ+RhIvVl8qg+VY37ClbeL48G5NlM/hGEKlRKBWse68XBC7nMXR9DZqEpITrabAI4gKTcEt776yRvj+tAqVbP0n/PsHCTnEf06u/H6RXiTYifZf7HydQCVEoFBkli95ks7ugQiLuThviMQrIKy+nawnJG9TUHk3hqxSHj8w5B7ix/qDv2aiX3f7OPrNw8VrU3oFLVnE+Qll/KrFVH0KiUvDmmPT4u9mj1BjRmrZllOj12KiWKdqPluRw8moNfG9j0Cuz93HqjJTZuUPwwBl5MkScIdG0kj65VGTCAnIidmyDPA1I5GMGRn8wO9KgcNPwwBlIOy2UrK1ofVHZw5Ge5dTB8nNw6eCmKs2Hbm3Lrhn9bKCuAnHMN1j1REG5UCkkyu30i3BT0ej2HDh0iMjLyol841zpJklA08CymkiSx8Xgam06k8fStoQRWJBtvj8tg0pfycJRdmnuy8M5I/N0ceG3tcZbtkWf+fW98Bw5cyDE+N/fGHe14+bfjxuc9g73ZFV//JGU7tZJynQEvZzt8XOwsgoqXhrXhwT4tLc61Uqms3XtlqJhosTbJjZV19VrQ2EjkLUiF9yru6Pu1hUGvyV/MKYdgx/tycBA2FD7uarle+zvh6M/W21PZy8FBbdm5wAuJcvcIJx9wvc76otfBjfR/fbVlFZZxLDmf48l5vP2naU6HiCB3Hu8fwrTv9+Nir2b5Q90Y9+l/lOstJ03TqBRM7xfMI7cEk1usZf2RFOZtiLGoE+LnwldTujD6k51kFZXj7qghr0TLkHb+zBvdniHv/0tWkeWcKi8Na4OLvZpZv8pJy0GejpTpDAR5OpKQXcLSyVF0bOJBWn4Z72w8yfjOQXy0NY6dp+XPmedva41aqeDNP2L4/v5u9G7lw+4zWUz9ei/jooIY0aExG46m0L+1H8VlOnq28EARu5bkTYtI8YgiwL6c1hfMhmENjIKk/Q3zpjfpDgrlxUdt6jpNvugH6PM0/PmCHKB0my4P/5txEqKXyPOQtOwPa/8nzynywCZ5Ars10+UWEwC3IHj6OKy4F2LWyqNOOXnLk0AOmSd32zIX/bmc49FpMrQbJR9HzjnIPS+XD33bugtWXhKsfVL+7BrxIbjUbSJM8X/dgAx6OWerSfdr8rvgejjXN0TQsGzZMr788ksyMjJo1aoVL774osUEclVFR0ezYMEC4uLi8PPz48EHH+Tuu++2qLNx40Y+/PBDLly4QNOmTZkxYwaDBw++pP1eK67mH+aBCzkEuDsQfTabZXsu0D/Mj4f7tkRpY1Kr5JxiLpw+RooqgDsig8gsLONsZhGdmnmSW6xlV3wmT/98mMV3d2Ro+wBKyvW899dJopp5cmu7RhYTZW2NTUOhUNDKzwVXew0r9l3ATqVkUFt/isr0bI5JY3xUEMeT83lv00njfAUAHZt6EOrnajNfoCF5OmkoLtfj5qjB1V5NRmEZ0/sFW0xENaVHM54eHGa84e6kURn7ZO+Iy+RoUh5tAlzpF+qLQqFAr9MR9/ePtOo5HJWT3CWJfV/LX3LdpssX0ge/l5MkW/aDQ8tg6zz5y9XZBzyayiPidHnINOJNQZrcAhC3CTJi5C96lZ38hejsC0Gd5e4KOeflD2hbdyWvhH6zoMNdcpeLm8D18IVzPfrtUBLrjqQQEejOvd2b4eGkoe8722x2E7zaHDRKQvxcLD6/quPtbMfaJ3rTc4GNOUtq0M/5At/qZ8lP7lsP3wyrz6FeFpLKHkU1NxUkZz8URdazt5d6huKQc8qq3OAdirJZd7iwBwa+QlKphsa/3YWCiksmz+ZywGBmuWYMfqPeZFDuL5C0j8KO03E8/BWqY7/IFTTOMHSBPOGeW2PTMZTriEnMICz7H5w63CG3tlao9v86Lwl+nsR5ZRDRbWczvod1d0tJkkjJKyXA3cF4w0iSJEq1BhxrOT+MJEnsO5+DwSDRraW3aYFeK08amHMeWg2Wc2VqoNeWoTq/A5r2ADsnuTBxv/z90/cZSIiGoyth0Kty11G91vaoXWUF8oz1rv7g4CF/vicfkOfj2f4ejP4MGlfk5KXHypNS+rWVk/n/ng//LSa3yUA8HvjVcrs55+Vj0ZXJN7cutTWrHq6Hz/DrPmjYsGEDzz33HK+++iqdOnXip59+YuXKlaxfv57GjRtb1U9ISGDEiBGMHz+eCRMmcODAAV577TXee+89hgwZAsDBgweZOHEi//vf/xg0aBCbN29m0aJFLF++nA4dOtRrv9eSwpJyDh05TI/OnVAqleQUazmenEfvEB8UCgUFpVo0KiV2KiVKhfyhkVpQhpezHZIEDmolFGUibX+XDHUAdJ+Ol6OGc6mZnDx1kpXnHcgp1vL8ba2JKthC4qnDuPZ7nOyzB/h17VrOS/6MVu1ktb4Xfxq60tLXmRAfZ5r7ulBcWkrq0b9pXX6cZoo0xqv/Za52IkebTiImJZ/8Uh0adDRTpNJJGcc2fSQSSp4OTuKP0nC2J5nu+GlUCpo7lNDSIZ9NWT5IQHdlDDmSK3FSIHps/1MqMNBPeZj9hjAKcDKWSSgABX1DfY0jDgE0V6SgcAuiQK8yzrbsRCkzuzryxxkdxVkJ+CryKArsRW6ZPOtykCKdTMmdiaotuCmKad+uPb1bB6IKH4VCZYdSqUCr06PRl/D9/nS2r/+ewQ4nGRfpj8LJC1z8ofUwuRvA8dVy031GrHyRb9AbP2ylkhwUqUeQ3Jug6PO0PG/BqT/r/kfj7Au3LYCjv9Rv/ZBBpsTJ2nJvIrd2mH8xj1gEARFyjsS6GbaTnTXO8MDGm66rwfXwhXOjeH/TKT7cEgeAq72ayT2bGbsTAozpGMjuM1kk55XaXH/xPR2NkydWR62UWyt+O5zEkwNa8ezKI/U+3vaB7hxNyrt4xVrqrIhFo9CT7dsdp4wDeFDILPWPhCkTLeqVSRq2GSJ5WXsfT6jXMFm9yWpbpw2NcVMU46fIrXGf8f0/Zf/endxZ+EON9a4XWUGDKcs8g17tjE9BLI4K+bujSOFMTq+XMKQcxTHjCPqmPUnUexPplo9K0nGy+b14+QXit/4+Y4vJYt0ddLxvIS19nEg5sg2FSk2L3F0U7f+Z3dpgclTeuDSNpEfJP9jln2Ne0R3EePZHqVDQqaknt7dvxL5NP3Je702MvglTO3lwT89WFKXGkbLsETKKJR7VPsmcCX0ZXv4nym3zUJRYtpIXebTGmWJo1gudZ0v0CfvJ9+mEb+Pm5B5ei8eZtQDkKT0obDqAwJAI2DynxvdIsndD4eAO5UVITj4o/NvCiTUXf3OHfyB/38Suq7ZKbORLtL79USjKgIPL4N+3jct2N7qH9ne+jLOrl3xjzNlP/h7SllCw6wvsFTr2hr9CeOs2JB/6i9buWorUnqhb9sZOpaSgTIeDRklCZgGNDamo/FqhqQhCqt4glSSJtPwy/N3sMRgM1/xn+HUfNIwfP562bdvy2muvGcuGDh3KoEGDmDlzplX9d955h61bt/LHH38Yy1555RVOnjzJihUrAHjqqacoLCzkiy9Mk0A98MADuLu7s3Dhwnrt91ry6rvvE5K3k0aaEoq1BpQYCFRkkiF5kKoORKUtpIfyBMHKFABKsWO7vj37Da0IUGQx2m4vbobci+6nUHLARWH7S7PSJqkLXlIuYYoEEiQ/WihScFBorert0rflnNSIUuyYqNqCvY06+ZITiZIvBhTsM4TSTRlLG6V1NyGQv8zWGbqTJnnip8glVJGAI+V4KgrwUch36ZIlL/7VRxChPEtjRSZ6O1d0Dt74+fqT4dAMz5wjlOSk4VaaiKRxxtC8L3H5SpwD29LkzM/y3Xxz7k1AZYchLwmlvob3xcFdvvjX6+QPrCut+6PQKEIeVSUvCTa9bLveHZ/IMwon7DElTyqUcp9oAEcv8GoBEXfJXQpyzsK/78pBTtMe0OUBiFkHiXvl4OeWF6B5L3mfSKZ5A3Tl8vCOvmHQ7znr4ygrkEeDUanlu01OXnK+w01GBA1XTl6JlgV/xBLm78KErk1x0KjYeTqT3GItzbydCA90p1SrJz6jkKIyPUcS5TwJNwc1747vwK3tGvHmhhiW7T7PrKGtuadbMzILy7jv673EpOTj6qBm8T2d6Bdq6sry76kMfjuUjINGyZ1RgTzyfTTJBXrev6sDwb4u2KtVvPfXSTyd7Fh5IBG9QeLurk1wd7TjiQEhvLTmGKsPJtl8Pe0au6HVG2gT4EaovysLN53CXq2kRKtHkuT8qJJyPU52KtIKSm22ZAQp0nlG/TO/6PsRoMhmjb4XOrO0STU6BioPsM8Qxj2qLTym/o3FulF8rh+GCgMPqDYwU7OSF7UPkCD5okbPEOVe+qiOslnfidd0U5CATzUfcptqLwDf6QYzTzeRh1XreET9u/HC+6nyR9luaI+bopjxqn8oR81g5X7aKc/zue523tTdgx+5zNd8wQDVIQA+0Y3kguTHFn1HnlSvZpJavslRLNnjpJBbL5Ikbx4pf4p+ysPM1KwEYI2+J77k0Utl6npa1RLdMNwpYoL679r9gdWgXFJRggPuiiJjWZmkJgMPghSZtd7OcUMzog2tsUNHO+U5IpXxaCUVp6VAwhQJlCJPQln52oskew4ZQmp8ndebUqUT9oYSU+uRmWIcMKgdcdHVvqU8QfJltxSOnVRGiCKJJooM3BTFpEkelGFHIv6kuLSlqZOW80Vq9CpHmpeeoEV5HH6KXE41v4fC1vfQoUvPa/Yz/LoOGsrLy4mMjOTDDz+06Do0d+5cYmNj+eEH6zsSEydOpE2bNrz00kvGsk2bNvHUU09x6NAhNBoNt9xyC/fddx/33Xefsc4333zDt99+y7Zt2+q132tJ1rwwvLW2ZwAWrhKVndwca+PDCwCFSh6ZJOUIFNo4d0oNGCoCKf/2crJv6lEM7ccTpw8i9Pi7KPIq7gK2HSX3BU45LCcp27vBA3/B6S3yRX7Y7ZbjsScfgn1fyX2Fk/bLrQ6jP5O7M1U6tRHsnOVtnd4M7UbL27JFkiy3LzQIETTcGA4l5BLg7mAxMlNVer2e//YdwK1xCBFNrAPkvBItkiTh4WQ5+/jp9ELOZxUR5OlEfqkWTycNpVoD7Rq7WeQ7lesMKBWg1UtW3VgKy3Qs232eLTHp5JVoGdzWn3FRQTjZqziZWsDfJzPQGyT83OxZuT+RMq2Bx/qHcCqtgG92ncOpYnvF5XocNEqCfV1o6evC+awiTiZmUIYGkI8lzN+Vk2kFFvsPcrcnSJnJkF5d2X8hl8zCMjoEeXA4MRe34guoi1I5rGpPiJ8LZTo9B87n0jfUh97BXjQrO8kre9QU6KBjEw+KyvScPneObFwBBXYqJZFNPWiiKaDb+c/4sbwvp+3b8PKgQII8HfnpQDopRRKuDhpGxL/KAOVBhpYtIF3py8SWxdzPb6ReOIUKA59qpvCYchXRJYF8aXcvaqmcXuU78CKfFzU/Gl/PCmkQocpkOkonavX3USlR8uGp8kd5WL2OwaoDVstzJWdcKEGtMNhYu/ZyJWc0SgXOkiln7hvdrWjQ01SRxo/6ATym/o3DhmDK0BCkyKSbMgY3RTG5kjPnJH8SJT/aK85wXGrONkMkb6i/RomBL/TDyJOc6a86RLLkTbyhMQ+r1+KmsOz697p2Eo6U0VSRzm2qaH7UD+SQIRgHypmk3lQRZBoYrpIT7/MkJ1IlLzToaKlM5bChJXsNcvetY4YWDFQdoLsyBl+F3Pp23NCM85I/p6QgiiV77lT9Q4iy+jmOLqctzZ/llkkvXLOf4df16Ek5OTno9Xq8vb0tyn18fMjIyLC5TmZmJj4+PhZl3t7e6HQ6cnJy8PPzIzMz02qb3t7exm3WZ7+2GAwGrkbM5jJ+CYe2fk/Lgv24FZ1Fq7AjW+lFvFdfvJ00eJQm4J/2L3ulNsQ0v5dAVzXdtHtRlOaSmlvISYcOxHoNQOMeQM/Sf7ArTqXQoTHN9Am4OKhxcfemPOYPjjh2oaD9fbhQRP7hdaha9KFloD9e7q44OzqiOL4KRdxG0GuROk6GrDhwa4wU1JVynR673DPg6IEi9Yg8E236CdBrySsqQ51/Aee2g9Ge2orOIOEw6AUoTEcRuxZF0j6koK5oCzJQahxR9nkKYtaTe/4wLhHDUUdOgMS9KGLXy99NCiXkpyCFjwOPZijO/Qtpx0FXiiLtGGgckTpOkvs6quzAoENxbjvknEPqMxOpcScUf7+J4vRmebl/W6SAjvL2sk7Lx9O0B4rCNCQHdxQGvfyaHT0heIDc3adxRyjNR3FhJ6Qele+eh96G5NpIPmmBUXJSL8gX3SmHQKFAkbgPKXysfGddVwrlxXIinkJuCtXr9RQePYr24d2odMVynkIlv3AIHiQHK+5B4B0qlxuqfMn4t4dh75v2XXlxodeb6gSbDXPq1856uXDZ6Sveb714369r7RvLoy7VdB71ej2OaiWt/Z1t1nOxM/3/m2vh7UgLb+sZ3g1V/udVFf/idirrbTiqFTzYuzkP9m5utZ2eLb3o2dI0CtTDfSxvHLx0e1iNgzFo9QZKtXpcHUx92SVJ4sCFXNwdNTT1crIYdnZyj6ojoVUZUMFKc7b1k79zK49jx+mW5JVo6dvKp8p+B9A1pwQvZzucK0bK69a6uXG5TrcagC+zSmjl51KxvdEoc+UL3vcc1NipH6Y0IZe/g9xx0KjIKR6M3iChV7xGVn4RKQYPxlUM012YEsvRfdtp56smsdkYtOmnOJ2Yjot/U/TFBSi9W6JCR3eHBM4kJHJI3YF7XFyICJ6OPmMPuf9+RqlBieegmWS5hpGUV0ZLXxdcdNmoEvdy/OgBYv2G0tTfh26a06hKcyHlAPrcZBIdw/DrMgaHnFPk5uWxq6wFfvnHycWJLgPvxMHJjqKEg8TvWU96qZp2fafTrrE7P+1L5KEmHiQVPMrRkxl4OGk4W65DE+aHziCRXVROfEYh3s529IwKonF2MfMbu3Ey7j5OppfipPaklYcje1IK2BWfRUsfZxK6v0N6QSnx6YUcT8pFZzAQ7OdO/zBfzmQW8WVGAdtPZxPo6YhareJb/Xiyi8rpF+rL5znncFWVs7c4gOJyHdlFWvaclZPmP7irA12bexKVX4afqz2bj52nOPEw2xINHC/1pbm3E20D3Li7axNKDXrWRP+BlJ9MlncUroXnKPIOR6e0w6f4DCGBPuTsX8PO8hDs7DR0UMQT4FCOwqCjScomMv26U+ASjI+mlON59mg1zvg2akrT1E2UJBxEhUSxcxOK9QrO2bUixC6HZmmbOGbfkfKmfa7KZ3htg5TruqUhLS2Nvn378tNPP9Gxo2kyqk8//ZTffvuNP/+07ns9ZMgQxowZw8MPP2ws279/P/fccw87duzA19eX8PBwFixYwPDhw411fv/9d2bPns3Ro0frtV9bjhw5glZr3c1GEARBEARBEK6EqKjazeh+Xbc0eHp6olKpyMy07MeXlZVl1ZpQyVZrQHZ2Nmq1Gg8PD2OdqtvMzs42brM++7UlPDz8qrQ06PV6jh49Svv27a/ZJjChYYhzffMQ5/rmIc71zUOc65vH9XCur+ugwc7Ojnbt2rFz506L3IJdu3YxcOBAm+tERkaybds2i7IdO3YQHh6ORqMx1tm5c6dFTsOOHTuMrQr12a8tyqswpJc5lUp1zf5hCg1LnOubhzjXNw9xrm8e4lzfPK7lc311r1obwNSpU1m5ciUrV64kPj6eN998k5SUFCZMmADAe++9x3PPmUZcmTBhAsnJycyfP5/4+HhWrlzJqlWruP/++411Jk+ezM6dO1m6dCnx8fEsXbqU//77jylTptR6v4IgCIIgCIJwo7iucxoqVU6ylp6eTmhoKC+88AJdunQBYNasWSQlJfH9998b60dHRzN//nzj5G4PPfSQ1eRuf/75Jx988AGJiYk0adKEGTNmcOutt9Z6v4IgCIIgCIJwo7ghggZBEARBEARBEC6f6757kiAIgiAIgiAIl5cIGgRBEARBEARBqJEIGgRBEARBEARBqJEIGgRBEARBEARBqJEIGgRBEARBEARBqJEIGgRBEARBEARBqJEIGgRBEARBEARBqJEIGgRBEARBEARBqJEIGm5Cy5YtY8CAAbRv354xY8awb9++q31IQh0sWbKEsWPH0rFjR3r06MGjjz7KmTNnLOpIksRHH31E7969iYiIYNKkScTFxVnUKS8v54033qBbt25ERkYyffp0UlNTr+RLEepgyZIlhIWFMW/ePGOZOM83lrS0NJ555hm6detGhw4duOOOOzh27JhxuTjfNwadTsf777/PgAEDiIiIYODAgSxevBiDwWCsI8719Wnv3r1Mnz6d3r17ExYWxubNmy2WN9R5zcvL49lnnyUqKoqoqCieffZZ8vPzL/vrE0HDTWbDhg3Mnz+fRx55hDVr1hAVFcVDDz1EcnLy1T40oZaio6OZOHEiP//8M19//TV6vZ4HHniA4uJiY53PP/+cr7/+mldeeYWVK1fi4+PD1KlTKSwsNNaZN28emzZt4v3332f58uUUFxfz8MMPo9frr8bLEmpw5MgRVqxYQVhYmEW5OM83jry8PO6++240Gg2ff/4569evZ9asWbi5uRnriPN9Y/j888/56aefeOWVV9iwYQPPPvssX375Jd9//71FHXGurz/FxcWEhYXxyiuv2FzeUOd15syZxMbG8sUXX/DFF18QGxvLc889d9lfH5JwUxk3bpz0yiuvWJTddttt0rvvvnuVjki4VFlZWVJoaKgUHR0tSZIkGQwGqVevXtKSJUuMdcrKyqSoqCjpxx9/lCRJkvLz86V27dpJ69evN9ZJTU2VWrduLf37779X9gUINSosLJRuvfVWaefOndK9994rzZ07V5IkcZ5vNO+884509913V7tcnO8bx7Rp06QXXnjBouzxxx+XnnnmGUmSxLm+UYSGhkqbNm0yPm+o83r69GkpNDRUOnTokLHOwYMHpdDQUCk+Pv6yvibR0nATKS8v5/jx4/Tu3duivFevXhw8ePAqHZVwqQoKCgBwd3cHIDExkYyMDIvzbGdnR5cuXYzn+dixY2i1Wnr16mWs4+/vT6tWrcTfwjXm9ddfp1+/fvTs2dOiXJznG8vWrVsJDw/nySefpEePHowaNYqff/7ZuFyc7xtHVFQUu3fv5uzZswDExsayf/9++vXrB4hzfaNqqPN68OBBXF1d6dChg7FOZGQkrq6ul/3cqy/r1oVrSk5ODnq9Hm9vb4tyHx8fMjIyrtJRCZdCkiTmz59PVFQUoaGhAMZzaes8V3ZDy8zMRKPRGAMN8zqZmZlX4MiF2li/fj0nTpxg5cqVVsvEeb6xJCQk8OOPPzJ16lSmT5/OkSNHmDt3LnZ2dowaNUqc7xvIQw89REFBAUOHDkWlUqHX65kxYwbDhw8HxP/2jaqhzmtmZqbVNiq3e7nPvQgabkIKhcLiuSRJVmXC9eH111/n1KlTLF++3GqZrfN8MbWpI1wZKSkpzJs3j6+++gp7e/tq64nzfGOQJInw8HCefvppANq2bcvp06f58ccfGTVqlLGeON/Xvw0bNvD777/z3nvvERISQkxMDPPnz8fPz4/Ro0cb64lzfWO6XOf1SlzLie5JNxFPT09UKpVVJJqVlYWPj89VOiqhvt544w22bt3Kt99+S6NGjYzlvr6+ADWeZx8fH7RaLXl5edXWEa6u48ePk5WVxZgxY2jbti1t27YlOjqa77//nrZt2xrPkzjPNwZfX1+Cg4Mtylq2bGm8Ayn+r28cb7/9NtOmTWPYsGGEhYUxatQopkyZwpIlSwBxrm9UDXVefXx8yMrKstp+dna2zRaIhiSChpuInZ0d7dq1Y+fOnRblu3btomPHjlfpqIS6kiSJ119/nb/++otvv/2WJk2aWCwPCgrC19fX4jyXl5ezd+9e43kODw9Ho9FY1ElPTycuLk78LVwjunfvztq1a1mzZo3xJzw8nBEjRrBmzRqaNGkizvMNpFOnTsY+7pXOnTtHYGAgIP6vbySlpaVWd4RVKpXxbrI41zemhjqvHTt2pKCggCNHjhjrHD58mIKCgst+7kX3pJvM1KlTee655wgPD6djx46sWLGClJQUJkyYcLUPTail1157jXXr1vHJJ5/g7Oxs7Cfp6uqKg4MDCoWCyZMns2TJEpo3b06zZs1YsmQJDg4Oxj6zrq6ujB07lrfeegtPT0/c3d156623CA0NtUq4Fa4OFxcXY55KJScnJzw8PIzl4jzfOKZMmcLdd9/NZ599xtChQzly5Ag///wzr7/+OoD4v76B9O/fn88++4zGjRsbuyd9/fXXjB07FhDn+npWVFTEhQsXjM8TExOJiYnB3d2dxo0bN8h5DQ4Opk+fPrz00kvGz4eXX36Z/v3707Jly8v6+hSS6AB301m2bBlffvkl6enphIaG8sILL9ClS5erfVhCLVUdq7/S/PnzGTNmDCC3RixevJgVK1aQl5dHhw4deOWVVywuQsvKynj77bdZt24dpaWl9OjRg1dffZWAgIAr8jqEups0aRKtW7dm9uzZgDjPN5pt27axcOFCzp07R1BQEFOnTuXOO+80Lhfn+8ZQWFjIhx9+yObNm8nKysLPz49hw4bx2GOPYWdnB4hzfb3as2cPkydPtiofPXo0CxYsaLDzmpuby9y5c9m6dSsAAwYM4JVXXrGY1+VyEEGDIAiCIAiCIAg1EjkNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIgiAIgiDUSAQNgiAIV8GhQ4d48skn6d27N+Hh4fTq1Ysnn3ySgwcP2qy/YcMGhg0bRkREBGFhYcTExADw/fffM3jwYMLDwwkLCyM/P59Zs2YxYMCAOh/TpEmTmDRpUr1eT23XnTRpEmFhYcafdu3aMWDAAF588UWSkpIs6v76668Wddu2bUvfvn154YUXSEtLM9bbs2ePsY6t92/WrFl07NixXq/rn3/+4aOPPqp1/VmzZhEWFkbHjh0pKiqyWp6UlETr1q0JCwur03YvpvI92LNnT53XrXyfExMTG+x4BEG48aiv9gEIgiDcbL7//nvefPNNIiIieOaZZwgMDCQ5OZnly5dzzz33MHv2bO69915j/ezsbJ577jl69+7Nq6++ip2dHc2bNycmJoa5c+cyfvx4Ro0ahVqtxtnZmUcffZTJkyfX+bheffXVhnyZ1WrSpAnvvvsuAFqtllOnTvHxxx+za9cu/vjjDxwdHS3qz58/n5YtW1JaWsq+fftYsmQJ0dHRrF27FicnJ4u677zzDsuXL2+wY/3nn39YtmwZTzzxRK3X0Wg06PV6NmzYwPjx4y2W/frrrzg7O1NYWNhgxygIgnAliKBBEAThCtq/fz9vvvkm/fr1Y/HixajVpo/hYcOG8fjjjzNv3jzatGlDVFQUAGfPnkWr1TJy5Ei6du1qrB8XFwfAnXfeSUREhLG8adOm9Tq2kJCQeq1XVw4ODkRGRhqfd+nSBXt7e2bPns3+/fvp3bu3Rf1WrVrRvn17ALp3745er+eTTz5h8+bNjBw50livT58+bN++na1bt9arpaWhaDQa+vfvz6pVqyyCBkmSWL16Nbfffjs///zzVTs+QRCE+hDdkwRBEK6gpUuXolAomDNnjkXAAKBWq3n11VdRKBR8/vnngNzd5Z577gFgxowZhIWFGbsCPfvsswCMHz+esLAwZs2aZVyn6kWzwWDg+++/54477iAiIoLOnTtz5513smXLFmMdW12MFi9ezPjx4+natSudOnVi9OjR/PLLL0iS1KDvi6urq/E9uJjKgCM5OdmifMyYMYSEhLBw4UL0ev1Ft7NhwwbuuusuIiMj6dixIw888AAnTpwwLp81axbLli0DsOgmVZtuPGPHjuXgwYOcOXPGWLZr1y6SkpIYM2aMzXVOnTrFI488QpcuXWjfvj133HEHq1evtqoXHx/PAw88QIcOHejWrRuvvPKKza5QlfucMmUKnTp1okOHDkyYMIH//vvvoscvCIJQlWhpEARBuEL0ej179uwhPDycRo0a2awTEBBAu3bt2L17N3q9nkcffZT27dvz+uuv8/TTT9OtWzdcXFwAWLduHZ9++qmx+46Xl1e1+541axa///4748aN48knn0Sj0XDixAmrPIKqkpKSuOuuu2jcuDEg52LMnTuXtLQ0Hn/88Xq+E6DT6QC5e1JcXBwff/wxTZo0oVOnThdd9/z58wBWr1epVPL000/z6KOPsnr1asaNG1ftNj777DM++OADxowZwyOPPIJWq+XLL79k4sSJ/PLLL4SEhPDoo49SXFzMxo0bWbFihXFdPz+/ix5jz549CQwMZNWqVcbgbuXKlXTp0oVmzZpZ1T9z5gwTJkzA29ub2bNn4+npye+//86sWbPIzMzkoYceAiAzM5NJkyYZA0xvb2/Wrl3LG2+8YbXN3377jeeff56BAwfy1ltvoVarWbFiBQ888ABffvklPXr0uOjrEARBqCSCBkEQhCskJyeHkpISgoKCaqwXFBTEkSNHyM3NpWnTpsZuQ82aNbPo1lPZDcm8+44t+/bt47fffmP69OnMmDHDWN63b9+LHvP8+fONjw0GA127dkWSJL777jsee+wxFArFRbdRVVxcHO3atbMoa968OUuWLMHOzs6qvsFgQKfTUVZWxt69e/n0009xdna22QVp4MCBREVF8dFHHzFixAjs7e2t6qSkpPDRRx9x77338tJLLxnLe/bsyZAhQ1i8eDEffPABTZs2xcfHB8Difa8NhULB6NGjWbFiBTNmzKCwsJDNmzfz+uuv26y/ePFitFot3333HQEBAQD069eP/Px8Pv74YyZMmICrqyvffPMN2dnZrFmzhtatWxvr3X///RYtLyUlJbz55pvccsstfPzxx8byfv36MXr0aBYuXMgvv/xSp9ckCMLNTXRPEgRBuMZUdv2pzwW5Lf/++y8AEydOrPO6//33H/fddx9RUVG0adOGdu3asWjRInJzc8nKyqrX8TRt2pSVK1eycuVKVqxYwXvvvYeDgwP33Xcf586ds6p/55130q5dOzp16sTDDz+Mj48Pn3/+ufGCvqpnnnmG1NRUvv32W5vLd+zYgU6n44477kCn0xl/7O3t6dKlC9HR0fV6XVWNGTOGzMxM/v33X9auXYtGo+G2226zWXf37t306NHDGDBUGj16NCUlJcZRofbs2UOrVq2MAUOl4cOHWzw/ePAgubm5jB492uI1GgwG+vTpw9GjRykuLm6Q1ykIws1BtDQIgiBcIZ6enjg6Ol60T3xSUhKOjo64u7s3yH6zs7NRqVT4+vrWab0jR47wwAMP0LVrV9544w0aNWqERqNh8+bNfPbZZ5SWltbreOzt7S1aRiIjI+natSt9+/Zl0aJFLFy40KL+W2+9RXBwMGq1Gm9v74t2D+rUqRODBg3i888/56677rJanpmZCVBt9yWlsmHupwUGBtKjRw9WrVpFUlISw4YNw9HRkZKSEqu6ubm5Ns9P5WvNzc01/rbVUlU1gKp8jU8++WS1x5eXl2c1+pQgCEJ1RNAgCIJwhahUKrp168b27dtJTU21mdeQmprK8ePH6du3LyqVqkH26+XlhV6vJyMjo1b98SutX78etVrNkiVLLLr5bN68uUGOy5yfnx+enp7ExsZaLQsODq6x+5UtTz/9NCNGjOCzzz6zWubp6QnAokWLjLkal8vYsWN59tlnMRgMzJkzp9p6Hh4eZGRkWJWnp6cDpmP28PAwBgTmqpZV1n/55Zfp0KGDzX16e3vX6jUIgiCA6J4kCIJwRU2bNg1JkpgzZ47VCD96vZ45c+YgSRLTpk1rsH1W5i78+OOPdVpPoVCgUqks7ryXlpby+++/N9ixVUpNTSUnJ6fBLmSDg4MZO3YsP/zwg9UoS71790atVnPhwgXat29v86dSZY5FfVtVBg8ezODBgxk7dmyNeRE9evRg9+7dFpPWgZzM7OjoaFy3W7duxMXFWQVX69ats3jeqVMn3NzcOH36dLWv0Vb+iCAIQnVES4MgCMIVFBUVxYsvvsibb77JPffcw8SJE2ncuLFxcrfDhw/z4osv1moUodrq3Lkzd9xxB59++ilZWVnccsst2NnZceLECRwdHaudyblfv358/fXXzJw5k7vuuovc3Fy+/PLLS77YLC0t5dChQ4AcKCUmJvLFF18AMGXKlEvatrnHH3+ctWvXsmfPHotuOEFBQTz55JN88MEHJCQk0LdvX9zc3MjMzOTo0aM4Ojoau/WEhoYC8Pnnn9O3b1+USiVhYWG1fg/s7e1ZtGjRRes99thjbNu2jcmTJ/PYY4/h7u7O2rVr+fvvv3n22WeNQ9JOmTKFVatWMW3aNJ566inj6EnmQ7sCODs789JLLzFr1izy8vIYMmQI3t7eZGdnExsbS3Z2Nq+99lqtXoMgCAKIoEEQBOGKmzRpEu3bt+err77irbfeIjc3F3d3d6Kioli+fDkdO3Zs8H0uWLCAtm3bsmrVKn799VccHBwICQnh4YcfrnadHj168Oabb/L5558zffp0/P39ufPOO/Hy8mL27Nn1PpaEhARjroFSqcTHx4fWrVvz8ssvW0xed6n8/f2ZMmWKzS5KDz/8MMHBwXz33XesX7+e8vJyfH19CQ8P5+677zbWGz58OAcOHGD58uV8/PHHSJLEli1bLjoCVl21bNmSn376iYULF/L6669TWlpKcHAw8+fPt5jXwdfXlx9++IF58+YxZ84cHB0dGTRoEC+//DKPPvqoxTbvuOMOGjduzBdffMGrr75KUVERXl5etGnThtGjRzfo8QuCcONTSA09Q48gCIIgCIIgCDcUkdMgCIIgCIIgCEKNRNAgCIIgCIIgCEKNRNAgCIIgCIIgCEKNRNAgCIIgCIIgCEKNRNAgCIIgCIIgCEKNRNAgCIIgCIIgCEKNRNAgCIIgCIIgCEKNRNAgCIIgCIIgCEKNRNBwEzIYDBw5cgSDwXC1D0W4zMS5vnmIc33zEOf65iHO9c3jejjXImi4CUmShFarRUwGfuMT5/rmIc71zUOc65uHONc3j+vhXIugQRAEQRAEQRCEGomgQRAEQRDq68jP8NfLcA3fHRQEQWgI6qt9AIIgCIJw3fr1Ifl3y1sgZOBVPRRBEITLSbQ0CIIgCMKlKsm52kcgCIJwWYmgQRAEQRAulVI03AuCcGMTQYMgCIIgXCql6mofgSAIwmUlggZBEARBqA+D3vRYtDQIgnCDE0GDIAiCINSHXmt6rBAtDYIg3NhE0CAIgiAI9aEvMz1Wiq9TQRBubOJTThAEQRDqQ7Q0CIJwExFBgyAIgiDUh77c9FgyXL3jEARBuAJuiKBh2bJlDBgwgPbt2zNmzBj27dtXY/3o6GjGjBlD+/btGThwID/++KPF8ri4OJ544gkGDBhAWFgY33zzTYPsVxAEQbiBiKBBEISbyHUfNGzYsIH58+fzyCOPsGbNGqKionjooYdITk62WT8hIYFp06YRFRXFmjVrmD59OvPmzWPjxo3GOiUlJQQFBTFz5kx8fX0bZL+CIAjCDUZnFjSYj6QkCIJwA7rug4avv/6asWPHMn78eIKDg5k9ezaNGjWyaj2o9NNPPxEQEMDs2bMJDg5m/PjxjBkzhq+++spYJyIigueff55hw4ZhZ2fXIPsVBEEQbjAWLQ0iaBAE4cZ2XQ8sXV5ezvHjx5k2bZpFea9evTh48KDNdQ4dOkSvXr0syvr06cOqVavQarVoNJrLsl9bDAYDkiTVun5D0ev1Fr+FG5c41zeP6/VcS5KEQQKVUnG1D6XutKVUpj/rdVq4Qu/99XquhboT5/rmcTXPtUpVu4EcrlrQ8OuvvzJ06FAcHR3rvY2cnBz0ej3e3t4W5T4+PmRkZNhcJzMzEx8fH4syb29vdDodOTk5+Pn5XZb92nLs2DG0Wu3FK14mR48evWr7Fq4sca5vHtfbuf4oOpdDaeV8MMQHV7vrq/HbOfs4rSsenzsbT27ZoSu6/+vtXAv1J871zeNqnOuoqKha1btqQcPChQuZO3cut912G+PGjaNTp0713pZCYXmHSpIkq7KL1bdV3tD7rSo8PPyqtTQcPXqU9u3b1zq6FK5P4lzfPK7WuS4o1ZJZWE4LH+d6rf/3L38CEFPmybSuLRry0C6/cwWwU37YomkTpPDIK7Jb8X998xDn+uZxPZzrqxY0/PPPP/z999+sXr2ayZMnExQUxJgxYxg9enS1ycdVeXp6olKpyMzMtCjPysqyak2oZKs1IDs7G7VajYeHx2Xbry3KqzwZkEqlumb/MIWGJc71zeNKn+t+724hr0TL5qf7EuLnWu/tFJfrr7+/UUlnfKhUAFf4+MX/9c1DnOubx7V8rq/aVatKpWLgwIEsXryYf/75h7vuuou1a9fSv39/pk+fzubNmzEYah7Czs7Ojnbt2rFz506L8l27dtGxY0eb60RGRrJr1y6Lsh07dhAeHl6rfIb67lcQBOFGlFcid7HcFZ91SdspLNNdvNK1xnxyNzF6kiAIN7hrogOpt7c3nTp1omPHjigUCk6dOsULL7zAoEGD2LNnT43rTp06lZUrV7Jy5Uri4+N58803SUlJYcKECQC89957PPfcc8b6EyZMIDk5mfnz5xMfH8/KlStZtWoV999/v7FOeXk5MTExxMTEUF5eTlpaGjExMZw/f77W+xUEQbjRmXevdLa7tIbrwtLrMGjQlZkei9GTBEG4wdX6Uz42NrbWG23duvXFKyEnJf/222/8+uuvJCQkMGjQIJYsWULPnj0pLS3lgw8+YNasWWzbtq3abdx+++3k5OTwySefkJ6eTmhoKEuXLiUwMBCAjIwMUlJSjPWbNGnC0qVLmT9/PsuWLcPPz4/Zs2czZMgQY5309HRGjRplfP7VV1/x1Vdf0bVrV77//vta7VcQBOFGV1RuulB2tq97c7pOb2pNLiq/DoMG0dIgCMJNpNZBw6hRo1AoFLVK9o2Jibno9qZPn86OHTto3rw548ePZ9SoURY5BQ4ODkydOrXa2ZjNTZw4kYkTJ9pctmDBAquyrl27snr16mq3FxQUxMmTJy9pv4IgCDe6yq5JAKp65GiV6UxBQ8H12NIg5mkQBOEmUuugYcuWLcbHMTExvPXWWzzwwANERkYC8vwHX3/9Nc8++2yttufl5cX3339fYw6An5+fxX4FQRCEa0dusemi2bzVoLbMg4ai6zKnwax7kmhpEAThBlfroMG8283//vc/XnrpJfr162csa926NQEBAXz44YcMGjTootvr2rUr7dq1syovLy9nw4YNxpYN0d1HEATh2mTe0jBvQwy7z2Tx2h3htV6/TGe60M6/LlsazLonSXUPmgRBEK4n9UqEPnXqFEFBQVblQUFBnD59ulbbeOGFFygoKLAqLyoq4oUXXqjPYQmCIAhXUL5Z0JCYU8K3/50nKbek1uuXaU0X2lVbKlLzSvn9cHK9WjDqLCseyovrvp559yTR0iAIwg2uXkFDcHAwn3zyCWVlpqbZ8vJyPvnkE4KDg2u1jepyI9LS0nB1rf9Y34IgCMKVkVtsPaO9Xl/7CStLzVoatFXWG7ZoO0/+eJDl0Rfqf4C1kbgPPuoEX1y8hdyKyGkQBOEmUq8x8l577TWmT59Ov379jCMlxcbGolAoWLJkSY3rVnY7UigUTJkyBbXadAh6vZ7ExET69OlTn8MSBEEQriDz7kmVLjJOhgXzlgZtlRaFrCL5gvzvkxlM7tG8XsdXK4d/lH+nH6/7ujrR0iAIws2jXkFDREQEW7Zs4ffff+fMmTNIksTtt9/O8OHDcXJyqnHdynyHmJgYevfujbOzs3GZRqMhMDCQW2+9tT6HJQiCIFxBJVrrC2W9ofYtDeaJ0Lpq1rNXX+bphLSl9V9XL+ZpEATh5lHv2XgcHR2566676rze448/DsiJ1bfffjv29vb1PQRBEAThKsgoKCO/VEu5zjrfoGqLQU3ME6G1ZtsymAUQDpq6z/9QJ7pLCBrMAw5DLV53SS4UpIJf7eYyEgRBuJbU+xbOmjVruPvuu+nduzdJSUkAfPPNN2zevLlW648ePVoEDIIgCNehLvM2M/C9fzifbZ08XDU3oSbm3ZPKzYKNHLOhXDWqOvR3qo9LChrMXn9tWhoWd4ZPukHqsfrvUxAE4SqpV0vD8uXLWbRoEVOmTOHTTz/FUHGHxc3NjW+//bbaIVe7du3Kn3/+iZeXF126dKlxkrjo6Oj6HJogCIJwhWw8lmpVVreWBtvdkzILTUFDifYyj550KUGD+bq1yWkoypB/n9sBjWo/NK0gCMK1oF5Bww8//MDcuXMZNGgQS5cuNZaHh4fz1ltvVbveCy+8gIuLi/HxxWaWFgRBEK4t5l2HbOUh6GrTTadCqVlOhN4gYTBIKJUKMgtNuQIFpdbJ1g3qUnIa6tLSUJJreuziV/99CoIgXCX1ChoSExNp06aNVbmdnR0lJdWP0T169Gjj4zFjxtRn14IgCMJVZD5Mqi3luuq7J5Vq9WQUlNHESx4wo6xKToTWYMBeqSIt33QhX3C5J31rsJyGiwQNuWZDxyrrnU4oCIJw1dTrkysoKIiYmBir2Zr//fdfQkJCql2vsLCw1vuobJEQBEEQrh0l5TVfHNtqaahsQRj/2X8cTcpj1SM9iWrmaZEIDXI+hL0azmeZ7uBf9paGhuqeJOlh/7dwaiOM+xI0jpZ1zYMG8/kdBEEQrhP1ChoeeOABXn/9dcrL5Q++I0eOsG7dOpYuXcrcuXOrXa9z584X7ZJUOelbTExMfQ5NEARBuIxsDbNqrmpOw/Mrj7BiXwLdWnhxNCkPgF8PJFYEDZZ1K2d/vpBtHjRc5pYGrVnruEEPyorRmmLXw6HlMPIjcPKqZl2z7kl6Hax9Un689wvo+YRl3bxEs7oiaBAE4fpTr6Bh7Nix6PV63nnnHUpKSpg5cyb+/v68+OKLDBs2rNr1vvvuu3ofqCAIgnD1lV40aLDsnrRiXwIAe85mG8sMklwnyyx3AUwjKJ3PKjKWXdHuSXqtKWj46R75t3sTGLrA9rrm3ZP2fGp6XJnwbFHX9JrQlVkvFwRBuMbVu2PlnXfeyZ133kl2djaSJOHt7X3Rdbp27Vrf3QmCIAjXgJLymhOdazN6UmUPpuPJ+RblOr2cDH0203SBXVimQ2+QUCkv08AZFkFDOWgcLJcXpVe/rtZ6yFl5Oza6VJnPHm1ruSAIwjWuXvM0TJ48mfx8+cPey8vLGDAUFhYyefLkateLjY01Ds8aGxtb448gCIJw7blYIvTWmHT6vr2NnaczLUZaMmeQJCRJ4lhFd6VKWr2BfedzyCnWYmc2E3Rh2WVsbTC/gLd1Ma+qYT6h6vIhbHU/Mp89Wi9aGgRBuP7Uq6UhOjoardb6w7WsrIz9+/dXu96oUaPYuXMn3t7ejBo1CoVCgSRZf6mInAZBEIRr08USoX89KE/2OenLPRx+9VabdfQGiaTcEvJLdWhUCuxUSorK9RSW6fhh93kAhkcEsO5wCuV6AwWlWtwdNQ37QipVbWmoSlXDfrXVjBZoM2jQ1rxcEAThGlenoMG8BeD06dNkZJj6bRoMBrZv346/v3+162/ZsgUvLy/jY0EQBOH6crFE6EoGqfoWgl8PJuHqIH/9NPd2JqdYS1G5nseXHzR2TWrh7Yyrg5qsovLLl9eg11lewFc+Nh8+VWVX/frVBg22uieZtS7oRNAgCML1p05BQ2XrgEKhYMqUKVbLHRwceOmll6pd33yI1qrDtQqCIAjXvoslQpvbdTqr2mXf/ie3KIT4uXAoIRfAIpfB0U51+YOGqjkJlRf7ZWa5FtUFDQZD9d2MbAUNFsGJ6J4kCML1p05Bw5YtW5AkiUGDBvHLL78YWw0ANBoN3t7eqFSqWm/vzJkz/PDDD8THx6NQKGjZsiX33nsvLVu2rMthCYIgCFfIxbonmZv5y+GL1gnxc7FKiAZwslPj6iB3DWqQuRoy4+DXh6DPM5B8QB4CddBrlnUqL+xLzY7HUBGw5F4AhRLcg+TnuuonMrXdPUkkQguCcH2rU9BQ2TrQEInKf/75JzNnziQ8PJzIyEgADh8+zIgRI3j33XcZOnToJe9DEARBaFi17Z5UW828ndGorEdGcrRTGrswZRSUGefwqbcNz0DyQVgx0VQWPNCyjjFoMEvQ1pVA5mn4uAs4+cDTJ+Q8B20Nk8JdtHuSaGkQBOH6U69E6CVLluDt7c24ceMsyleuXEl2djbTpk276Dbeeecdpk2bxv/+9z+L8kWLFomgQRAE4SqTJInpP+zHw9GOt8ZFGMtLtfIIeD4u9mQWXvrFr7ujBo3KeiA/R43aGDTM+vUo+87n8O74DvXfUXG2ddmFXZbP9VqQJMugQVsKuz4EySAPv5qXCF4tqh9uFWrR0iByGgRBuP7Ua8jVFStW2OxC1KpVK3766adabSMzM5NRo0ZZlY8cOZLMzMz6HJYgCILQQM5mFrHxeBor9iVYJDRXtjR4OlU/qtBfM/ry7f21m5fHxV5tO2iwUxm7JwGs3J9oVadO7F2ty/Z/Y/k8Pwnebwc/3m0q0xZDkdl3Up48WR3lhdXvSwQNgiDcgOoVNGRkZODr62tV7uXlZTGiUk26du3Kvn37rMr3799P586d63NYgiAIwiXIKSo3DoOdV2LqYpOaZ+q/X1IuBxCeTtWPKtTI3YFuLbyqXW7O1UGN2kb3JKeKROgGo3G8eJ3t78mBQ3mBqUxXatmdKLciaCiuPsnbZvck85GWRNAgCMJ1qF6fyAEBARw4cIAmTZpYlO/fvx8/P79q1zMfZnXAgAG8++67HD9+nA4d5Cbnw4cP8+eff/LEE0/U57AEQRCEetp9JosJS3dzX8/mzBnZjsxC04Vtcm4pIX7ynfrsIvmC2Me1+qDB2U6NSqkgIsidI4l51daDGloaNCrcHBpwbobyoovXST1iXaYtBfNcitwL8m9b3Z0qJeyGf9+Bvs/Kz3d9BOe2m5aLnAZBEK5D9Qoaxo0bx5tvvolOp6N79+4A/Pfff7zzzjvcf//91a732GOPWZUtX76c5cuXW5S9/vrr3H333VZ1BUEQhIaTmleKSqnA19Wet/+UB7j4Zte5iqDBdGG743QmfUPl1uWMinJfl+pnSlYp5YvsZQ92o/2cv2o8BhcHdTWJ0CqaejnV7QXVpKaWgZpoiy0neMs8WbvtbZ0LYcPAvy38VWUoctHSIAjCdaheQcNDDz1EXl4er732mnFmaHt7ex588EEefvjhatdriFGXBEEQhEtXqtUzaOE/FJbpODn3NtRV7vZnFpiChqX/nmFit6Y083Y2lgd6mrr7dGvhxZ6z1nfeXR00PDkghEVbT1d7HDW1NLTyd6nz66pWTS0DNdGVyknQlY6vhhb9oCBVfq5QWi43l3teDhqqqho0lBWCnbOpRUOvhWO/QvPe4C7mNBIE4dpQr6BBoVDw7LPP8uijjxIfH4+DgwPNmzfHzq6GmTMFQRCEa0ZOcbkxwXne+hiiq1z0ZxVZXtg+/P1+dAaJ0+lyAnCPlj4MjwjA29mOOSPbMfTD7cSmFmClhmFSNSoF9molaqV10OBkpyLY1zJo0BskYytGnRgMUFIlaPBtAxkxF19XWwJU2ee6p0yPnf2gMNX2ujnnbZebzwidGQeLO0PEXTBmqVz232LYPAecvOG5Mxc/RkEQhCvgkrLMnJ2diYiIuHjFahQXF7N3716Sk5ONLRaVJk+efCmHJgiCINSgTGu6O/7df5YXt8XlOmM3pEpVAwIfVzsW39PJ+LymxOjquNirUSgU2KmtAwEHjQoHjeVkoWU6PU52tfzaStwHJ9bALS9UDKVapTWgtOZcCyNtCSgrjqNZbzi/w3K5s2/1QUN2vO1cCvOWht2fyL+PrDAFDacqunTVt0uVIAjCZVDroOHxxx9nwYIFuLi48Pjjj9dYd/HixRfd3okTJ5g2bRolJSWUlJTg7u5OTk4Ojo6OeHl51SloWLZsGV9++SUZGRm0atWKF198scYRmKKjo1mwYAFxcXH4+fnx4IMPWuVQbNy4kQ8//JALFy7QtGlTZsyYweDBg43LP/roI6vX6ePjw86dO2t93IIgCFdLqa76SdoyC8rJLZYvbB00SuPcDOa8nS1zGsr11XTRqSLU34VTaXJrRWUAUPk7xM/F2JJhr5ZbH/58qg+3fSAnEZdpDdQ6NvmiYuI2hQo6V+TaqR3k7kYgBw2NO8mzQ9dEVwKqip12nmodNDh6VL9uzjlTNyZzerOATGXjBSnqNbChIAjCZVXrTyZXV1eLxzX91Mb8+fPp378/0dHR2Nvb8/PPP7Nt2zbatWvH888/X+sXsGHDBubPn88jjzzCmjVriIqK4qGHHiI5Odlm/YSEBKZNm0ZUVBRr1qxh+vTpzJs3j40bNxrrHDx4kBkzZnDHHXfw22+/cccdd/DUU09x+PBhi221atWKHTt2GH/Wrl1b6+MWBEG4mmwFApX+OpFKfoncdSnEzzqvwE6lxE5t+fXRubkngM2kZnMejqaL5MpeSQ/2acF9PZtzV2fTiHyVsz+3buSGuqJLUpmudoGJhaT9UJYvP3Zwh9bD5cddHoC7f4SeT8pdgwCa9YIBL1uuX5pvGoLVJxRGfWq5PKiGIcJL86sJGrSQcRI2zoY4G4nilzLztSAIwmVS65aG+fPn23xcXzExMbz22muoVCpUKhXl5eU0adKEZ599lueff55bb721Vtv5+uuvGTt2LOPHjwdg9uzZ7Nixgx9//JGZM2da1f/pp58ICAhg9uzZAAQHB3P06FG++uorhgwZAsC3335Lz549jUndwcHBREdH8+2337Jw4ULjtlQqlc35KgRBEK51pdrqWxrmro+hkZsDACG+LhxLyrdYHuRlPefBUwND8XWxZ1Ab/xr3az73gr1a7vbTupEbc0a2Y+dp2xN7OmhUFJbpajzmaunLTV2R7N1g9BI4twNa3gIaB7j1Dfkivv9s8GwmL7MgQUmO/FBtD407mhb1m1VzonJ5kXUuBUBJLvzxPJzZVmVXkhwwiKBBEIRr0FVrA1Wr1cY7Sd7e3saWARcXF1JSUmq1jfLyco4fP07v3r0tynv16sXBgwdtrnPo0CF69eplUdanTx+OHTtmzKs4dOiQ1Tb79Oljtc3z58/Tu3dvBgwYwIwZM0hISKjVcQuCIFxtF7sAT82Xu/FUTUYGeGFoG6syRzsVD/ZpSXMf5xq36+tqj6+r3LVpWp+WFst6Bnvz7JAwlk6Ksiiv7Kpk1dKw7U3Y+2WN+0NXZgoaHNzB3gXCbpMDhkoqjRwwAHi1tN6GeT03syChWU/It92qDcgtFLZyGgpTLedtqKQtln+L7kmCIFyDat3SMGrUKONF/sWsXr36onXatm3LsWPHaNGiBd26dWPRokXk5OTw22+/ERoaWqv95OTkoNfr8fb2tij38fGpdmbqzMxMfHx8LMq8vb3R6XTk5OTg5+dHZmam1Ta9vb0tthkREcFbb71F8+bNycrK4tNPP2XChAmsW7cOT0/PWh2/wWAwzr56Jen1eovfwo1LnOubR13PdXHFyElV3dutKT/suWB8HtnE3fh4co+mjO0YSHige633YzBYXui3DXBlfFQgGQVlDG7rb7Wd6X1bWL0Oe42y4pi1pvKMk6j+eUuu23Gy5YW2ZKAyhVrSlSIV56IEJAc3DBc7bidf07pBXVEkRhsX6RVq0DijDIiEwjQMjTuBtgSVzQ2BVF6EVFZocXdO8m+PIu0oGKzff31xLqgcUCqUxvGabL3P4v/65iHO9c3jap5rlaq6TzFLtQ4aBg0aZHxcVlbG8uXLCQkJITIyEpBnc46Li+Oee+6p1fZmzJhBUZF8B+app57i+eefZ86cOTRr1qzO3Z+qBjOSJNUY4NiqX7X8Ytvs16+fxfLIyEgGDx7MmjVrmDp1aq2O27x142o4evToVdu3cGWJc33zqM25/i+xlJ+OF1qVvz3IG1+nUn4wK1PlXOCRKDf+Pl9ClFsxuoyzHLJ9T8am1CqjLtkXpUFWNr7AoUO1a1VGJ39OHos5iSFTzolwyomhsr0jc9nDJLZ71NitR6ktpLITkS4vhZwjf+EH5JRInD106KK7c+z7OSpdIe7pe2iEKWg4FhOHzj4DOr2NQjIgHT8Fkg9uXd+kVfSLxnoZzUbge34tUkk+yedOEWS27Wy1H5a3pExiDkdT5tKUkIJCKkO1QwcPVttdSfxf3zzEub55XI1zHRUVdfFK1HH0pEqzZ89m0qRJPPXUUxZ1Fi1aVOuuRe3btzc+9vLy4vPPP6/toRh5enqiUqnIzLTsB5uVlWXVmlDJVitEdnY2arUaDw8PY52q28zOzq52mwBOTk6EhoZy7ty5Wh9/eHj4VWtpOHr0KO3bt691dClcn8S5vnlUPdcGg4SymjkNxv7yp1VZRKA7Y/t3AcB/2zbSKiZx6xoVSbfOCp6p53HtyT8DMacAGNkhgDG3RFR7XNVx276T5MICmjRvSWSris/hs/lQkX7gf3YVPr3ulSddA8hNgIqXqCnPw+/cGgA8GjU13uiqWUWdvIGw6CdjaXiHTuDgZqN+R6QTi1BUDL3qNW4hvLcWpaGMxt6Wg4N4BjSHJNt7bdMiEAIjUcZ6QHrFkYS3Bo1lDon4v755iHN987geznW95mn4888/WbVqlVX5yJEjGTt2bJ1aCrKysjh79iwALVu2xMvLq9br2tnZ0a5dO3bu3GkxHOquXbsYOHCgzXUiIyPZts0y+WzHjh2Eh4ej0WiMdXbu3Ml9991nUadjx45Up7y8nPj4+FpHawBKGxMaXUmVSejCjU+c65uHSqUiJb+M4R/tYEKXpswa2tpieXU3KtwcNca/EU9nO2PQoFZf0nQ+TO7Zgq2xGQxu68/D/YLrtY3K+Rq0BrNm9HLLFgxVWT5ULtPamGQOUDp6mOrUhlcz8G0NGbHyPuwcq1/frDVAZRZYKKvkPCgdq+++qtIWyds362qlMpSDyvbM2OL/+uYhzvXN41o+1/W6anVwcGD//v1W5fv378fe3t7GGtYKCwt59tln6du3L/feey/33nsvffr04ZlnnqGgwPYHvi1Tp05l5cqVrFy5kvj4eN58801SUlKYMGECAO+99x7PPfecsf6ECRNITk5m/vz5xMfHs3LlSlatWsX9999vrDN58mR27tzJ0qVLiY+PZ+nSpfz3339MmTLFWOett94iOjqahIQEDh8+zJNPPklhYSGjR4+u9bELgiBcDp/8HU9usZbP/omnVKvngW/28vVO+eZMcbnt/rLmoxp5u9R9orbquNirWflIz3oHDGBKhLZI3q46OZv5fAfVTdzm4G67vCZqs+80W3MqGJm1npivc3i5/LtRBExcVU1LRYXKoWHNJ3+zlUgtCIJwFdTrFtKUKVOYM2cOx48fp0OHDoCc07Bq1Soee+yxWm1j9uzZxMbG8tlnnxnv4B88eJB58+bx0ksv8eGHH9ZqO7fffjs5OTl88sknpKenExoaytKlSwkMlEe4yMjIsOgy1aRJE5YuXcr8+fNZtmwZfn5+zJ492zjcKkCnTp1YuHAhH3zwAYsWLfHG53AAAD0LSURBVKJJkya8//77xtcKkJqaytNPP01ubi6enp5ERkby888/G/crCIJwLfjrRBpbYtPZEpvO1F4tKCi1nQBtHjSEN3Zn5+lrZzbiypaGwjId07/fj4NGyRv+mVh0/CkvAm0pLL+z+pmU/drVfecqswCgtq3DtnIQ2o+DVoMg52z165VV3DDTlprKKkdUEgRBuMrqFTRMmzaNoKAgvvvuO9atWwfIXYvmz5/P7bffXqtt/PPPP3zxxRcWMzf36dOHuXPn8uCDD9bpeCZOnMjEiRNtLluwYIFVWdeuXS86wtNtt93GbbfdVu3y999/v07HKAiCcKWozXIGzNMHsgrLKCi1PfhC5YU5wJMDW5GSV8rwiIDLdox1UdnScDghlz+Py3kDd7dKoJt5pfJCeaK0s//Y3si0vyEgsu47V9eu9Rx7F6ipkVzjVPHbeo4Lo8qgQSeCBkEQrj317qx6++231zpAsMXDw8Pm7NEuLi64udXQfCsIwg1h84k03v3rJO/fFUmbAPE/35CUZne6dXpTDkNceqHVTM6VVGbRhbO9mkV3V5/DdaU52skBTVq+6WJaUZprWam8qObuQ43r+XpqGzSM/RJ+mWI9o3Qlu4q8hJqChtKK7knmQUO5CBoEQbg21DsTNz8/n19++YWFCxeSm5sLwPHjx0lLS6vV+o888ggLFiwgPT3dWJaRkcE777zDo48+Wt/DEgThOvHgd/uITS3gseUHrvah3HDMA4DcYlP/+Lj0wmq7J9mprt0JxTyd5GDgQrbpAlpVbjlLNTFr4eD3Db9zVS2DhoAIePIghI+xvdyuYtK7yhYHgKpJ0X+/Ced3gbbEVCZaGgRBuEbUq6UhNjaWqVOn4urqSlJSEuPHj8fDw4NNmzaRnJzM22+/bXO9qhPEnTt3jgEDBhAQIDeBp6SkoNFoyM7ONiYyC4JwY8suKr94JaFOzLsnVY6CBJBdWI6nk8b2Oqq6DYN62WlL5Lvy2xdy/9mNLOcRzmcV40su96i24FEqj1uajzNuFEHC7stzHLVtaaiq9wzYYdaN1c5G9ySXRlCSY7ne10PB1axb2LJxMHEltBqMIAjC1VSvoGHBggWMHj2a5557zmIY0r59+/LMM9WP5m0+QZwgCAKA3nDl5yq50Zm/p2l5pq4uxVpdtS0N6qs8BLSF9FhY0hc6T4U9n9EUGKGMZJWhL4vtFtFNGQsVsdA5gx8RyirJxU4+0P9FWP/0pR9LfYOGQXOg11PwVjP5eeUp0Tib6rgFQEaM9brm3ZNADhzmVDMilCAIwhVSr6Dh6NGjvP7661bl/v7+VhOnmTOfIE4QBAHgKsxveMMrMRuaNNUsD6C0XE9hNUGD5lpqadj5AejLYM9nxiJHhRwldFPGWlQ9KwUQQZWgYewXENy/YYKGGodZvQhHD7PtVLTwmLc0eDSzvZ621Ha5IAjCVVSvoMHe3p7CwkKr8rNnz9ZpcjaAY8eOER8fj0KhICQkhLZt29bnkARBuE4ZLjFqKNXqLUb+EaoPGkq0eqvRk7q39OJUWiF3d216xY7voqqZT8Eb67vtZ6VG1hWdfRvuWJr3gQPf1n/94R9A6lF5O2AZNLg1tr1O1ZYGQRCEa0C9goaBAwfy8ccf88EHHxjLkpOTee+997j11ltrtY2srCxmzJhBdHQ0bm5uSJJEQUEB3bp14/33369z8CEIwvWpatBwOCGXp38+xAtD2zCorX+N6+4/n8NdS/5jxuBQHusfcjkP87piPglaer4pp6FEayAxp8Si7o8PdUdvkFBfS4nQNmZNnqv5mluV+6zKLxj8rNd39mm4Y2k/Dgw6CIyq3/qdp1o+N0+EdvGH296C3R9D7gWzSqL5TRCEa0+9viWef/55srOz6dmzJ2VlZUyaNIlbb70VZ2dnZsyYUattvPHGGxQWFrJ+/Xqio6PZu3cv69ato7CwkLlz59bnsARBuEadTi/gqZ8OcjrduoWyakrDQ9/tIz6jiAe/s75ArGr26qPoDBLvbDzZUId6QyjVGoyPC8tM3ZFKyvXEpJomE5gzoi0KheLaChgAlLZbjvqqjlqVFeBkXdGxAW86KRQQeTf4hjbM9sxbGpx9oPt0uPO7i69XZv2/IwiCcCXVq6XBxcWFH3/8kf/++48TJ05gMBho164dPXv2rPU2tm/fztdff01wcLCxLCQkhFdffZX777+/PoclCMI1avoPBzidXsies9n898JAi2VSlZaGdLPRfi5GYWvmXYGScr3N8oJSLfEVgdv25/rTxMvGBfe14CJ9+hMlH4IUmQAUYmPeA3VFHoJ/e0g7CvbX0Dwg5i0Nld2w7KznLLKy5hG46zIMKSsIglBLdQ4adDodERERrFmzhh49etCjR4967dhgMKDRWA/9p1arMRgMNtYQBOF6VdnCkFIxko95oGA+0k/VkZR+ir5AqVbPfb1a2NzuNR8y6LVwdCUEDwDXmrtaAXDyDzj6CwxbaJlEW0fmOQ3mjiXlUa434GynItCjhknGrjZtSY2Lnyp/lPc1n/KNfgiZku38B0C+yP7nLej5RAMf4CVQmX3v+baRf2scLr5ezO+X53gEQRBqqc5t0mq1msaNG1/yhX337t2ZN2+exWRwaWlpzJ8/v96BiCAI16aqsxCX6UyfH5VxwpmMQiJf+8ui3qxfjzJn7QnSC2zfeb7mGxpWT4c102GL9WhzNv04AY6tgj1L6ryrvBItn+zLY++5bIucBnNFFS0QEUEeKJXX8JunqzloOCIF06f8Q77U306mVEMrglcLGP0Z+Ldr4AO8BAoFPHkIHt0Nzt5ymXsQRE68+LpmwbZjXjyK3R+D3vZoWIIgCA2tXh1ZH3nkEd577z3jTND18corr1BUVMTAgQMZNGgQgwcPZuDAgRQVFfHyyy/Xe7uCIFx73BxMjZqSJFl1n5EkiZd/O0ZBme0LoOrmFjAPGqp2czJ3NrPIYmbkKyIrHo6tlB8f+uHi9c1vxJTXvf/6h1tOs+VsCRM+j7YKGm4JsxxNqGNTjzpv/4q6SEvDhxO7GR/n4nK5j6bhebUAvzaWZXd8DArzXA4bQV1ZgTyHRXEWbf99COWml+XhaXPOXcaDFQRBkNUrp+H777/n/Pnz9OnTh8aNG+PkZNkvdvXq1RfdRkBAAKtXr2bnzp2cOXMGSZIICQmpU16EIAjXBxd7NZmF8kV7TrHWqvtMiVZPTEqBrVUByC/RVrusUqnWgKOddQLthaxi+r/7N55OGg6+UrvR3S5JyhH44zkoSDGV+baxridJ8NM9cneV8d9C7nnTMmcfSDshD8lZy25KF7KLjY+rvr9BnpZdkSKCaujScy3QFte4eGj7AGYODuW9TaeQqt77uqsWAdq1SKEAexcorRhWNmQgBHQA7xD443koy4cTv8Hvj6Ns1tu03tY35J+nY6ofwlUQBKEB1CtouNSZnc3zInr16kWvXr0uaXuCIFzbzC9ik3JKOJSQY7H8653nyC6qviUg10bQkFtczrGkfOPzvBKtzaBh+2l5wsmc4osHHg1iSR/rsowY2PQKdH/MlNtQlAEnN8iPC9Pgo06m+vHb5PrBA2HSr9bbK0yHokzwN81r42Jv+jjPKrR8L4M8LW/sNPVy5pp2kZYGgGY+1q/hmNSSLw4HsSDkOp27w87VFDTYu8HAV+THO96Xg4b1MwFQnN9hvW7iPmg78godqCAIN6M6BQ0lJSW8/fbbbN68GZ1OR48ePXjppZfqPKdCQ+VFCIJwbdh8Ig0/N3sigjxsLs8zu+h/96+T/HPKcub4iw2ZeiI5n05NPHF3kpNIdXoDYz7ZZVHn4IUcbgtvhEKhoEyn58Vfj9EvzNdi+NGl/8YzoLUfIX61GK2mPhKiq1+280PIOAX3/CQ/z08yLcuMA8ns8/DMNvl3/BZKynRkFZdbXvgv7ixfXD5xALzlEegczS6SdRYJ5RLN3Cw/6q/pJGiwDhqePAQr74fkA8aiPiHWczE4SKWsOZTMiA6NGdimFonn1xonL8hPlB/bm3W7cvGHzFPyLNmCIAhXSZ1yGhYtWsTq1au55ZZbGDZsGLt27WLOnDn12nFD5EUIgnD1JeWW8OB3+xi5eCcJ2cWk51smLZfp9BYX7lUDhtp4Z+NJJn21x/h8//kczmQWWdR5ZNkBvth+FoCf9yaw6kAiT/54kGKzPIk3N8Ty0ppjdd5/rVVNeHbytnwetxFKcuQZgpfeYipPOVztJh/+dC2939rGuYwCMFS02FTcjV79y7fM3xADQGG56XU+ofqVj+0/QYmB9zSfcesfvfElVz4kOxVujvVqZL5yzLsnBUaBZ3O5z793CIxeCoCnsx3Rswdy+JVbSfWTu+v8oJdbwT/edpqiavJjrmmBZq1N5sPEBnS4+LqGK9SSJgjCTatO3xybNm1i3rx5DBs2DICRI0dy9913o9frUanq1hTcEHkRgiBcfYlmfen7vC3fIV/+UDd6Bst3gvNqyEdo5OZAar71yEgKhcVAMQAcScyjTKfHXq0yDt1a1bwNMZRq9RbdodKqjLy0+0w2X+04y/29bQ/jekmyz1o+D4iE5INQki0/lwzwdkvLVgWoMWiQ0mOBCByWjQRVPvmTNlJ5OZmQeJ4l587wYJ+WxryPtopzzNTICdifKm5jrGo7lMME1VY+0o/B28Xu2prfQpKsh8GqbGmYuEoerlahkLtiPbHfopqfqzxU6aF+H/P4D6s4IMkTsB24kMudS/5j3RO9r63XejFNusH+b+TH9matYR3uhv8W17xuZbcmQRCEy6ROQUNqaiqdO3c2Po+IiEClUpGenk5AQECddnypeRGCIFwbbOUi7Dqdxb5zOUQ28SCnhlGLurTwYu3hZKvyjk08OHAh16o8JbeU5j7OZNQwAdx7m05ZPD+RnG9V5/V1J5jYvSn26lrc7JAk2PWRfNHq7Aex66DLQ+DiKw+PigJaD4OYtaauJZV8W0P6iSrbs9Et8+jP1e6+pSKFQ4TQKFfumhO/ez0dK5Y1Qs4N6TJvs7H+SNV/xsd3hTtDnPxYiRyFtfS5yqMNlebJE5ypNBC3GVZOleelCOoMv9wHPR43tTQ4uIPy4g3iHm4e7JNaW5QdT87nZFoBrRtdQxO7XUzIYHBpBAYdtBpsKq/NkLE552HjbOh8v7HLmiAIQkOqU9Cg1+utJmRTqVTodLVvBm6ovAhBEK6cyjv8tmTZCBoWbzttfOxkIzm50i2hvjaDBmU1d4cTcopp7uNsnLfhwd4tUCkVLPn3TLX7sBV8AHR47S+iZw/CzcF6kkkLpzbCpophoN2bQF4C7PtKHvFo5UVmr3fxhe6PmtavC4UKJD0BiiwaV8x+DPD39n/oWHHId6r/ob/qIPO19/CroS8AQYp0Y91J7RyMQcPwCH9KXFsyOdwRNs+BrtOu/Gg7RVnwXig07gQP/AXLxsrlG1+A8LGQcgh+fdBUX1O73AtPJzub5f+czKB1Ize+332eRVvi+GZqF9o1voZHjnLxhZmxcqBqHizVprVk5wfy76Mr4Zmac4QEQRDqo05BgyRJzJo1Czs70wd0eXk5c+bMwdHR9OG+eHH1zaiVeREjRozA3t6edevWMWfOHBYtWlSPwxcE4XJ7fe0JlkefZ8GYCEZ1DLRaXjlSz7ioIPqH+fHY8gMWy4vL9XRu5kn7IHe+3nnOWD6ojT9jOgUy8xfrrjkKBfz4UHfu/ny3RfnZzCJ6h/iw83QWAH5u9jja1a9/fqnWwNrDyUzs1sxywenNsOxOGPUpdLgLLpju3JOXIP8uyoAfxla/cRd/eUSksNvBJxQ8m8HPk+t2gEGdIWEPD6j+4JQhyFg8Q7PKopqvIp+Fdp/RQpeKN/kEmQUYZMUbH7byceTFgW1gYVs5CTs3AcZ9WbdjulRxf8l30ROjTe8lyF1x8hKt69s5WZfZ4OlsO/D751QG46KCeLkij2X5ngvMG92+zod9RSkUlzZrYWGq/FtXBt/dAY0i4Pa3G+bYBEG4qdXp23b06NFWZSNH1m2It4bMixAE4fL7ZV8CpVoDT604xLCIADQqy+4i2UVyVyF/N3siq5k07LH+IWyKSbMoe3l4m2r7m4/tFESPYG/Ozr+dAxdy+XlvAiv2JbBw0ykuZBVzIkXucuTn6oBWX7dR2Hxc7IxzRlTObZBTVI6DNhfH3x6Es//IFVdPk4OG7CqtGEFdIHFv9bMWt7oVRi6GonTwDZPL2t4BPZ+EXbW/OSI17oQiYQ8ahZ6Fdp9dtP4T6jXWhdmmoIHSfPlOf+WoTckHTfkEBkOtugFdMvOuWWnHzY7zjOl97nw/lBfJLS0ezWu1WVcHDbOGtub3Q8nGvw2Aveey+WH3BeNz85nIrztqB9DJLWz6e1cTfzqO0N3P2a67ejr4tZUD3gv/wZB5cncwQRCES1CnoGH+/PmXvMOGzIsQBOHyM7+uP5KYy+qDSTjbq3lhqDxhWWZF9yRvZ3sCPRx57rYw3v7TsntE71Y+5BSXs3yP6QLOy1lusVz1SA++3nkOO7WSqT1bUFCqpXtL74p9K4hq5omfqz07TmeSlFvCFzvOWmyjQ5AH851jq53nYVL3ZpTrDKzYl8B9PZtz8EKOMWhY8s8Z1h1OISm3hEmqv3hD84/FuseT82iXHmO5wVZDwDUAYn633pnGSW6hcPYxzcdQKXRInYKGLM8OWA8qWkdmLQ2UZMPhH03Ps+NhQVMYuQg2PAstb4GxX1iuf+YfuYtQk66XeiSyMrMJ/FY9aKOCAm55AVz86rzp6f2CmdS9GaM/2UmX5l7sOJ3J+axi3t9synFZuT+R1o1cebBPy3oc/FU25nP4eRIMmgMt+qE/n1J9XfPzDHJAVhnACoIg1NMVH3evIfIiBEG4Msp0evJLTf+bK/cn8WO0fOH/6C0huDmoOZ8lD33q7WJnLJ/eN5jB7/9DfEYR4YFuaFRK7ogMpESrZ/bqYwT7OhsnI4tq5kVUs5pzmpp4ObFkUhT3fR1tvOBvG+BG5+aeONmp2TVrAHYqJXpJ4pEfDpCUW8IdkY1p7u3MrW39KdcbuD0igO4tvUjMKWHC0t1kFpTgQSFJufI+minSrPY7a9l2fi9LxLw95J19WvY6TmNpn054JP0t5wZ4h0D0Uuj3vBww2NK4o+3yakSXNeX2i1Wa9jf89jikVTOMrHkrSXE2HP3FcnlZvpx8DPKygEjo+bj8vDAdvqtoSX7qGHg0qdPx21Ro9h6XF1ovH76wXgFDJWd7NX/N6AfAF9vPMHd9jFWduetjmNitmc2JAK9pbUfCs2fkuRwMBsodbLxPni0g56x1eUas7aBBVw5J++RRm5TX2fshCMIVd8WDhobIixAE4cpIz7ccpagyYAA4nV7I6+tOcCwpH7VSQaemnsZlSqWCjyd24usd55h5qzwMpkqpYGK3ZozpGIRSSZ2HwgwPdGffS4PJLS7HXq2yuOirnP1XiYIvpnS2Wtch9zz94peA3+ME+wQR/eJA3n/pQZ7WrGRq+bOMuX0ojhtTrdb7svAxFArLbkh/Z7pxXMrnBbe+fDp5hmnBsPdqfgF21czCPHElLBsHgEHlQJbOjiTJhy2pzqj1Udyq2m97vcYd5Z/eM2DVA5bL2t8pj8hkfmGeHQ+5F6jRX7OhwwQ58Ekyy0357VE5T+PWufIcE789DqM/g+D+NW+vUuI+cAuUR56qzqQ1td9eLdzfSx5S11bgsDkmjREdTEngJ5Lz+WnvBZ4ZEnbxxPirydk074fOwQv91D9RFaXD8TVwYg2M+BC2vQkJlrlAnN4sd5GTJNjzmfx307S7PNP032/KXedufeOKvhRBEK4/VzxoaIi8CEEQLs38P2LYdCKNKT2a4+aoZnTHIJv10msY2nTsp6YZmaf3C6aJl2XSautGbrw1LsJqvUu9w+tRzUg51ZIkWH6XPKPuns9AZY/ioa08XTGXwdd278Dmd6DisHbo2xGmTMBXkY+fIte4mXTJg2TJm1OSfMd9c0waucXldTue+/8iefu3LDntjmOHURSXlDMzsDvuIz9CWj+TN11e4Pu0ZmhRIx1KYpU0k3OqewDYpW9LT5XZ8K1jK5KYWw8HnzDIlLuEGXo8gTJqivUwrpUBg2dzyDlX/TFmnpKDBrPZlzn7r/xboYIjFTNa//4EzKho4TjzD3i1AI+mltsqzYPlE+CC5ezdFu76AbyC5SFtG5BSqeDBPi2Z0LUpxWU6Xv7tGBuPyy0dT/x4kBY+zoQHyiMpDf9oOwYJCst0LLwzskGP47IK6goqFbQZCaXvg6MH+LSChW0s6x34Tg4uU4/Bn7Pksjl5csAAcrc5ETQIgnARVzxoaIi8CEEQLs2Sf+RuK6/+LiejKhUKRnZobHX3/+OKoVM7NvXgYDVDl7o7anhmyDXaX1pbAj/eLV8IV9KXwZe32qxeKml4UvsELooSNtk9i73C1DWra9knlpvWSxy4kEPbAHf+99NBOjf35Nkhratu0kiSJE7ZteXlwklEl2TDbnmUo9i8fQzv0Jc3ir5AW2T2kVwxuV1iv/c4sHUl83iAPVTkAfSeYRqLX+MA0/5Gf2E3x9Ilwrv0Bo29PGqT+euu1P8ly2FNAZp0l0cqit8KWafleQGO2Jg7ojJgAPm9XTcDMuPg3HbQOMOLSfKoSLs/A/dAOWG8poDhf0fkkaUuIxd7NS72apZM6sz+8znGYHf4Rzto3ciVr+7rgqHivY4+m31Zj+WyUSjkgAHkYXR7PG6aDM4rWG5lOrtd7nJWqTgb7FyhvCLPRFsq/y0JgiBU44oHDYIgXF22Eob/99Mh/vfTIYa082dS9+Ys3X6GyCYebI2VLzI6BHkwd1Q4wxbtsFp3QOv690G/7PZ9DWe2WZdriyyf+4ejbd6PL3K7cZdnGBuOpvBH+x8ZtXs8APEG0yAN7QPdaerlxPqjKdz/zT5j+Z6z2Uzt1QIfF3tOJOeTnFvCoLb+ZBWWkZhTws/7Eli2x7p7UPS5bKLPZWPr47hDkDtB/YeRGzqetW72cOFb+WK+1/8sK9o5QYt+6PIOgbJiO32fk0eAsnMB/3D54j1yIkSMl5O0z/9nutPcsh+U5JqChnVPy33j3QJNoy1VVZwpz1dh/p6+5mG7rrkWfeWWi6FvX/aAoaqoZp48MSCEj7bKwXBsagEvrj5qXF51FvLrVtRUOVG/55NyHsm/78CW1yD0NlOdt1vIgV6lYyuh471QXiy3MjXrdWlDvwqCcMMRQYMg3OAMksRbf56kibczgR4OFJXpq6278XiasQvHv6cyABjSzp+Xh7dFpbS+gOje0ouXhrWxKr/qdn4Ih3+yno3ZlvBxMGYpGqWKihRgnr9NbjFY4RZN5sZ3+Me+H+se7k253kCYvys/7D7P+qPWo9d0nrvZ4vmGJ/sw85fDxJgNA1oXX0zpIh9iRTca2o2Sf2ojYjwEdpKH2tQ4Q+xaiJggL2vRF5r3kS8oFQro8wwc+FZetvND+bdCCXd+J/eH3/0plObW6zXg0gjCx8DuT2DUZ3LORH6SHJBcBU8PDiUmJZ/NMXJA/PfJDOOypNwS9p/PIaqZJ+U6Aw9+t49ADwfmj7HuZndN8wmBpyqCocR9ctBQnAWHllnWMw+ef3sMts6Tg868C3D7u9D1oSt3zIIgXPMUknTD3FsRakmv13Po0CEiIyPF3Bg3qITsYs5kFtE72Ivv/9rDnH9yaqz//QNdmb36mHHeAnNbZ/ajpa8LAJtPpPHd7vO8MrwtaqWC5j7VJPdeKboy+fawxgFOb4GCFDlYOLfddv3mfaBxJOz6CJQaePQ/uQ/4RUiSZNF161hSHsM/kltdPJw03N+rBQs32egKVEc/TevOp3/H88+pDAI9HNk5a0Ct173k/+v8FFjU0TT/RMQEGLNEfqwrh7m+8uPmfeTJ2E5uuPg27d3g4X/lLjOZp+QWj2vk7rV5VyVPJw1+rg6cTJO76jzUpwV9Wvky+atoAKJfHIi9WsXibXGM79yEFj7OFvOVlOn0qJVKm4H15VDnc/3P27Btnu1lTj7yyFjJBy3LlWp4OVOepbs4C0IGWS436OWZxQ166PuMPKpTbRgMcguYJMnDyNqaH0RbAnu/lP9Wuj1iXUdXLi+7CeaeEN/XN4/r4VyLlgZBuA7ll2pxtVfbHIFIb5AY/9l/pOaX8sMDXTiSZnv+gnFRQRgkiVm3tcbPzYF/n+vPt7vOsf5oCm0D3Pgx+gID2/gZAwaAQW39GdTW3+b2alReJE9OVTmsoyTBuR1yUq75UJ56rXz32912YjYgJ/SWFcoXNSsmyt1qAqPg1B+26986V75r7t0KQityGXo9JffprkXAANYjPYUHuvPH//rg6qDG1V6Ds72KHacziT6bTai/C9lFWjILrZPI+7TyYXucnMvw9rgIFv51Cn83ewyS3GrTvaU3LX2c+eTveKb1vcJzCbgFwMiP5KFXg7pY3mVW28HUP+HUn3JLgUEndzGSDBBxJ2SfNU2KV0mphsf3gmsj+Xmja2sm5sgmHozpGEhGYRmvDG+Lv7sDQz/YTlJuCZ9vP8vn201Dl/4bl8nBCzks23OBz7efRaGAD+6K5I7IQM5kFDJs0Q6Gtm9U6yTqUq0egyThVM/ZzOuiVKvnV2kIdzouQV2SKQd9E3+Rcx4koNVgsnT2eH3bF4Xe7LPCoIP5TUw5D4Nek+fraBQhX9SnHDbNO5J+Qp6HJOo++f/K0dM0m/e2Nyk5soZN7mMZfM8zOGYcMg392/NxuXWjNA+mrAW1Pez9AjY8YzqOs9vlUaFA/t/PT5TXUShh2jbQl0P8Nnk0KDfTiFhy/QS525WuHPo9VzGRoR5QyH+7qor3vzhbDo5a9BNDzwpCDW6IloZly5bx5ZdfkpGRQatWrXjxxRctJpCrKjo6mgULFhAXF4efnx8PPvggd999t0WdjRs38uGHH3LhwgWaNm3KjBkzGDx48CXt91pxPUSz15WyQiSNEygUxotLSZL4csdZNhxN4bWR4bQPkruXJOeWsOlEGuM7B+Fkp+ZCVjHTf9jPXV2a0NjDkRPJ+dwW3ggHjZKYlHze/vMkbQLcmDOyHXvOZtEnxJc1Ow/y3paz9OsQSp9WPvx7KoPhEQE4aFTMXx9Dcn4pBWZzK9hye6gzH0zui51KYX3nV5LAoEdKjEZyb4bSw0Y3Er229nf5drwPm1+Tv9Sn/iHvb9dH8NdL4NtGvttfli93ozjys5xs22emfKe7KF0eQlJfLo/ck3sBCpJrt9+Wt8izC7e9o3b1G0Bli8SptAJu/3A7IX4u/PBgNzwcNRxJyiMi0J33N58i0MOJe7o1vfgG6+CK/1/rygFJvtAD2DoX8hLl99yzBWiLr3jOwqVKzSvlwy2n+P1QMkXl1XfjAznB+t/n+rN462m+2ikHGEqFnDdxW3gAfVv5cCG7mBY+zmQUlNGtpTc5ReU8/P1+os9l4+Niz+an+zLn9+McT87H09mOQA9H3h4XgUalJL2glC93nCU1rxQXezWD2vrTP0zOH9JqdRw5cpigkDYolEp+O5jMf2eymDsqnMYepqHLpYp5S/48nkor+1x+6JtDbvNh/Hi8mN4hPvQJ9WHF3gRe/f04E1qreLR5Ok22PVHv9y/BtQNBhcfQqRzhzu9QbXoRZUYsALmSM5tbv8a4k8/YXFcb2BVNUnS99w0gDX0bReht8pwpmXEQt9G0MGSQfOPg4A+mQKj1cHnm7H/flp83ioBmPSE9BsJul+c5idsoD6ccMgiiP4cjK6DjJGjaQ+5md/AHiNsETp5w76+mAQqKMsHJW57QcMf7oLKD4AEQEAEqe8vWk9wLcnc9GwFLtf/XBj3kJ3MmKYUi9zDjd8wVZzDIn+n1bUEUCfhG18O12XUfNGzYsIHnnnuOV199lU6dOvHTTz+xcuVK1q9fT+PGja3qJyQkMGLECMaPH8+ECRM4cOAAr732Gu+99x5DhgwB4ODBg0ycOJH//e9/DBo0iM2bN7No0SKWL19Ohw4d6rXfa4nFHyaS6W6LJFn+42tL5bsvPqGWTc+SJCfKpcdQ5tYM+4B2crJlSTYFybFoWvTGwU4t372J3yrfZQ4ZBEd/wXBuJ4q2Iyk8up4dToNwibyD7o3VaEqyjHckdYkH0KvskUrzKTr2B+cChtCpiTulrs05W+JEcx8ntCXFOJxczSmdH2GdB2FXnAKujUnIK0etKyKpWEX7IHfsVUrOp2YSm60nItANp7IMdNkXoHEkKYUGfOy1qHPOkhC7l7Am/pTnJFNy9HfU2adZ4Xw3EW3a4tGyExHlh9HrytmS6siv5+wIDGrOEy5bcDizEfvkvfyr6sbbLs8xqnEup4qc0J3+m9tV0fgqcnCmDHVAOCnN72DDjr24UUQ3dRzdlDGUGxSs1fdEhR5/RQ5/GyIplBwpwgE7dPgpcthvCKWxIotRqh0MVpmGwfxEN5L/DG0ZqtxDf9VhAhTyyC+pkif7DKHEGYLQKHQEK5LxdlJxwKUfkp0L07yPojpWZWSc5n2g/Xh51uA9S+RuPpUc3OU+7z0eg2O/mkbecQ2Q7/YBtB0FkffIk0g1ai9/YafHyHcrt78r/wY50dLZD3YsvMS/4ot44oDpy/sqSc8vxd1Jg736ynz4Xw9fONeLrMIy3v7zJHvOZnEuy9Rlr4mXI8/f1pr3/jrF2cwi7FRKyvWGWm3TQaOkVFu7up/dG8WiLXGcqJIL42qvpm1jNw4m5CIZDFTdnEqpYGh4IwrL5P+3glId+8+buibW5hhaKpIpR81dqr95Qr2mVscryHLtAjAEROKRtgdlaTYGe3eUZXlW9bQqR6QO91BcpkWRGYd72n8AHFeE4tC8Mw5BEWTn5qGJ24DWyZ8cu0CcQ/viZKfivEskUn4SQw49gTJbTuh/XTeFYQ+9hr1ST+rpw9i7+9IuaxOGwyvY7dAL5/YjcFbpCdAl4pR5lHWGHqS7haOToEtTD/p5pJOWW0S+UzMCvZxxL0mUPz+PraJ8x8ecKXUmput8buvRCcf0Q7DzffQoURp0KE6up8i5Kbq+s3BP243hQjQljv44uXmjD70dtVpDaUY8508eRqEvo8ClJY173kVA0UlY8wiSQgmNI1Ek7sWgcSa991z8O96GwqCDoyvlVi0XP/BqCSU58vPc8/L3j29r+bvl0HJ0ZYWocs8i9XkOpdoOzu+Ur11K89BKUFRShqNSh+HknyQ4tqHFkMfReAbK+V7xW5CyTlOanUxJuZaTHn3p0mcoao0GCjPk7nkKhbxPO2ckyYDWoMBOXyQfU3oMZSWFSG1H4WCnMY6oIAFlOgNKJOyK0+ShrNX28k03pRokiezcHOJyISLIAzsV1/xn+HUfNIwfP562bdvy2muvGcuGDh3KoEGDmDlzplX9d955h61bt/LHH6auDK+88gonT55kxYoVADz11FMUFhbyxRdfGOs88MADuLu7s3Dhwnrt91qyZ+UHuJ5aRdvyIxblOtScsw8jVdWIZrqz+GmTsZdKAUhX+lJg74+HLhMnQyGOehuzuVbQSioKccRTUX2dSjGGpoQqE+Tg5RLpUKFGvjt4zuCPQmGa5TfOEIinogAfhfwlXCLZoUOFa5WJu4SaKKABzlOtOHjYTrwNGQxD5oFHM/nunb4MXBtDyEC5bP/X0Lw3+F2DydmXmQgaLo+zmUX8F58FwKiOjXGyU/PX8VSmfW856V77QHeOJuXh5iB3G8wr0TbYMdiplZTrahdw2PLoLcFsjU0nNrWgxnoKheUIUs6U0EEZT6LkSwdFPAcMrZin+YpbVIfZrg9njb43HZTxtFCkkI0bd6jkHJFSSYMSA3YK+fN4lb4PfZVH8FXksUkfxVFDC+M8KW9r72Sm+hdUCnnHr2sn8Y8hAgfKeUezlLbK85RJGkaWv0Gy5MMT6tVMU68HYIu+I2/pJjBMtZv/qVcbj/u8wY89hjbESE3JkDxopzxHF+VJOitP8Zu+J6WSHcHKZHIkF+ONmHTJAxV6jhuak4cztyn3ckHyI1hpPeCBuWzJFS9Fze8ryCOwNVekGl9nfZVIdjgqLLuc6iQlMVJTWisS0ChqbiEzX0ePEh0qnBVlxrIyNDgryjCgRInBov4hqRXtFWewVzTc3/bVpkeFCuv3LEfhjgoDbpLtc1smqS2G5Ab5PSpROKJCTzka8iRH/JGDdgeFlhzcOKtpRTvdcQpxRI0edykfnaSkUOFMqksbsjv+j263DL1mP8Ov65yG8vJyjh8/zrRp0yzKe/XqxcGDB22uc+jQIXr16mVR1qdPH1atWoVWq0Wj0XDo0CHuu+8+qzrffvttvfdri8Fg4GrEbIHHPyVIsp79Vo2OkLLjhHDcapmfIQO/EtMoI8WSPU4K2xN/aRR6PJEDhjhDIFrUtFWet1m3jVIeglIvKWr8MLX1QWl9/KZ//ObKNItlrZTysJEGSYFSIV10W9VJkzzxVhSgRkeB5MgS3XB8FHmMU+/ABeskYnM5Cnc8pTyS1UFoNBp8S0x9pgtcQ8h1aUlg2jaUBvkDucTeB5WTF6q8c2TghYtKi1qpQNdxCg4pe1EWpaPMlJv+8z3b4dhmCMrMWBSNwlEk7YeEPUiNOpBq35JGhhQU53eg0JUi+YfLd23yElEkH0BCAa2HwfldoC1GirgLyouQou5HkR2PYvs7kJ8s3/mpILXsj9T2DiQHT1CqUe5cKO+zcrmdC4ryQiTf1kitRyC1G43i+K8oTm2UJyFrOQBDzydQ5JxDcg+S8xJUGhRZcUjBg4wX/Yqjv4AkIbUfb9383fc56zc56n75t752X5w3En3Fa9bfhK/9cmrq6UDTzqYuenq9noGtffl5Wjf+OpGGl7Md46KC8HY2TfJnMEjklmgp1xk4npxPsVbP8eR8OgS506mpB74u9mw8kYaDWvn/9u49OKr67uP4++wtm8vmxuYiEEDADYRwCZEigvKAz2ipMuXS6cDTApN2oLQ6ztgKI2ObThEatVXbKeMQUHkcRhGe+JSRy2OFoR1LqIQiEkApEK65kMsm2WSTbHb3nN/zR2B1CWxBAyGb72uGGfZ3fnsu+9nN2e+e3zmHvCHJ1LV24kyI4W+n6ik5XMnRSg8ZiXaenzWKkekJDEmNZfMnFyk5XEVcjJlpI1L59EwVhjWeOXmD0Oi6MV3Z+UZsZhNHKz0kxFiYkZ3G2EFJTHc5eXrmCMrON2HSYOKQFE5Ue/jgsxqyUmOZN3EQp2q9ZKXE0tQeYOuhSzw5YwQpcTbO1HlpbPczcUgyNrOJj08/xmMfncJmMTE6M5GkkQPIG5WO0v00/+tD/q99NDUdZu5JMNHs8XDgYjsj7xlAzJAkNuwqpdqcysxR6WxVM/mbdyiaLZY9ztn4a06wzv0t6tt1fAEDh93Cf7s201hdQV1jEx7HUAbGWtkb+xQp97+Iz6+zo7yG6poW3jIN50DmMuyBZnyNVdTH3UtGcjzHq1to9QXZaUwhNdbCpGQPVWTS0B6gtsVHnNWMCvhReoAOYuj6YaTrT83gRAt1bQaWQDvjHF7+y7KP8hYH/xt8kEcsR6k2UuhQNg4rF0O1WkabqpjvOEZ8ezV2OjlhDCVJa6NN2fkffTqfKhcx+EmijVetrzPF9Dn7jbGUWSZS77fyhOkTHjYfQ1caZ9VA0rVmkrQ2PjFGk6p5MSmdQSY3sVf2uxeNNFYHF7PIvp/pxkHGaufD3reR9tEAFs3AgkEMwWvaup5jwqBeJXLQGE22Vsl9piru17puIFlu3MsePZ9sUyWzTAcxa4pK5WSPns9BYzQTTGeYZjpOptZIo3KQqTWRqHXtH5tVPMnal1ft6lA2mkggBe8N98sHjVE48aBjoh07nxtDSNeamWg6TRyd2LUAlcrJYK0h7HnnjAx8xKChaCGOoDKH3yATMKPjVg4OGGMwMGFG5yHTMVLofoToq64WDEFlwqIZodfPQde2xeEj+ZpiMoUWUgJd+8kYfGGvezKtJHvL2HnxBLp+/fsI3U43W6T06SMNtbW1PPzww2zZsoWJEyeG2tevX8+f//xn/vKXv3R7zmOPPcbcuXNZvnx5qO3TTz9l4cKF/P3vfyc9PZ3c3FyKioqYPXt2qM+OHTtYtWoVx48f/1rLvZ7y8nICgTtfsTdfPov73BEG+KtJUO00KAedtlRqY0eQxWVSA7VcUgNwm9KpjM/hfr0cZ7CGhk4LraYE6lUqFy1DiLVaGNN+kIRgI5djhhNPGxazleHOOEwmE4c7MnFrqYBCtTXgtziw2OzEWRTxVo3JsdUkdVZx3p/IBXsOdu8l/JqVgDKjGQEGpTpoJpFUi4/yJitOzcP9jibONAZoMew40zLI9HzG2Y54qmzDuNfWwvCWg9QbiWQ6U6h2t9CEA2tKFrnWKi50OojLuA/MZlRzFTF6C7VGMh32DLLiFW6/CaddEexsp9bTwSgqMDpaaTMnUuGYRJpdI95uJcZkYPU10GFJImCyETQgwRQgtr0aUARi0zEF2gjEpnUN37k67EsZXf9M4bW6pbOZoM3RNWYfsF4pzgKxaZGDVAqrrwFlshK0JX45VOgr06/9oq3pfpTJGmo3d3owqQABuxNN92PSO9Bt3cfGakEfVn8zhtketq7hy9NBQUzHZTrjBqIZgbBlhRjBbq+BEEL0NEMpDAWGouv8ra/oDCos5iuncCmwmLqOo1726iTHmIi3mQhcueuf9cpVsdwdOs0+g2HJFvxBhbvDwK8rhiVbCBpdy9ANhaaB16+wWzSqW4Ok2E3YrSZaOg1SY02YNY3LrX68AY2RqVbaAwaxFg0V9GNGR7fEogF+HWIsXcvWDYVF+bF7L1HnM1FrzSLBppERZ8LReBTVdIGGmCEkpN9LTMs5jppGEx9jJVNrQvnb6PD58Pn91NhHMt7hJc5XQ8DuJNDZwdGONIYPiMXZ9i+afHBMz8LfUkulSmfCwHiGJVtJaDtPR81J3H4z1alTyEyKxRdUKAVxqgN30EZQacSYNeJtJmpag/iCilONAYYkWZg5LBaPr2v7a6oucOKyl7NaFunxZuKtXa91eryZMQlteKtPcs6jc8HIQDkyGJJsZ2iSBXeHTnWrTmVLkIDRteyMBDO6AWPTbXi8bfg6fVzqsBFvMzMgPoZGnwFK8cBgO0l2EzUtAfydHdR3KFSnl06/n3pSyEi0MyLFyoBYMyYVwH3hGEppmJKzCMYkoqERDPhJ8Ndhj4sn0OnjQjAVZ4INv2Ei3vCSaripawug6zoJVhMp5nZajVjqgnZ89nSGtx4i0FxDBzYsiZm0ag68cVmMT/HTfukozUYsmTkPYzFfsy+/A/Lz82+qX1Tsua+9ssm1l0e8mf7Xtt/MPG91udfKzc3tlSMNuj6WY8eGM3bs2BtWl5PDHs2IMLf/vOGUmz0l/MtrxDxwwz5frbtzw6b8BxPDHs8P/e/aASrhI9wn3dzKXXH3n95+fbquc+zYsYhZi+ggWfcfknX/cTXrCePHXcl6MtndenXtBb+8FtwMXLewjC/vQvIt4EZ74rxbmGNkeXl5fCdij0d6bFlf2wOT/32fW/ZwhGnf6ROf6z5dNKSkpGA2m2loCD8k5Xa7cTqd132O0+mkvr4+rK2xsRGLxUJycnKoz7XzbGxsDM3z6yz3ekzXuz71HWQ2m+/aN6boWZJ1/yFZ9x+Sdf8hWfcfd3PWvfut9Ruy2WyMGTOG0tLSsPYDBw6Ql3f9qnjChAkcOHAgrG3//v3k5uZitVpDfa6d5/79+0Pz/DrLFUIIIYQQoq/q00UDQEFBASUlJZSUlFBRUcFvf/tbampqWLBgAQCvvPIKK1d+ecLkggULqK6upqioiIqKCkpKSnj//ff50Y9+FOqzePFiSktL2bBhAxUVFWzYsIF//OMfLFmy5KaXezczm83k5+fftZWs6DmSdf8hWfcfknX/IVn3H30h6z59IvRVV2+yVldXh8vlYtWqVUya1DVm/bnnnqOqqorNmzeH+peVlVFUVBS6udvSpUu73dztww8/5A9/+AOVlZVkZWXxzDPP8Oijj970coUQQgghhIgWUVE0CCGEEEIIIW6fPj88SQghhBBCCHF7SdEghBBCCCGEiEiKBiGEEEIIIUREUjQIIYQQQgghIpKiQQghhBBCCBGRFA1CCCGEEEKIiKRoEEIIIYQQQkQkRYMQQgghhBAiIika+qF33nmHmTNnMnbsWObNm8c///nP3l4lcQuKi4uZP38+eXl5TJkyhZ/97GecPXs2rI9Sij/96U9MmzaNcePGsWjRIk6fPh3Wx+/388ILLzB58mQmTJjA8uXLuXz58p3cFHELiouLyc7OZu3ataE2yTm61NbW8uyzzzJ58mTGjx/Pd7/7XY4fPx6aLnlHh2AwyGuvvcbMmTMZN24cjzzyCOvWrcMwjFAfybpvOnToEMuXL2fatGlkZ2ezd+/esOk9lavH42HFihXk5+eTn5/PihUraGlpue3bJ0VDP7N7926Kior46U9/yvbt28nPz2fp0qVUV1f39qqJm1RWVsYPfvADtm3bxqZNm9B1nR//+Me0t7eH+mzcuJFNmzZRWFhISUkJTqeTgoICvF5vqM/atWvZs2cPr732Gu+++y7t7e385Cc/Qdf13tgsEUF5eTlbt24lOzs7rF1yjh4ej4eFCxditVrZuHEju3bt4rnnniMxMTHUR/KODhs3buS9996jsLCQ3bt3s2LFCt588002b94c1key7nva29vJzs6msLDwutN7Ktdf/OIXnDx5kjfeeIM33niDkydPsnLlytu+fSjRr3zve99ThYWFYW3f/va31e9///teWiPxTbndbuVyuVRZWZlSSinDMNTUqVNVcXFxqE9nZ6fKz89XW7ZsUUop1dLSosaMGaN27doV6nP58mU1atQo9fHHH9/ZDRAReb1e9eijj6rS0lL1wx/+UK1Zs0YpJTlHm9/97ndq4cKFN5wueUePZcuWqVWrVoW1PfXUU+rZZ59VSknW0cLlcqk9e/aEHvdUrmfOnFEul0t99tlnoT5HjhxRLpdLVVRU3NZtkiMN/Yjf7+fEiRNMmzYtrH3q1KkcOXKkl9ZKfFOtra0AJCUlAVBZWUl9fX1YzjabjUmTJoVyPn78OIFAgKlTp4b6ZGRkcN9998l74S6zevVqpk+fzoMPPhjWLjlHl3379pGbm8vTTz/NlClTmDNnDtu2bQtNl7yjR35+Pp988gnnzp0D4OTJkxw+fJjp06cDknW06qlcjxw5gsPhYPz48aE+EyZMwOFw3PbsLbd17uKu0tTUhK7rDBgwIKzd6XRSX1/fS2slvgmlFEVFReTn5+NyuQBCWV4v56vD0BoaGrBaraFC46t9Ghoa7sCai5uxa9cuPv/8c0pKSrpNk5yjy6VLl9iyZQsFBQUsX76c8vJy1qxZg81mY86cOZJ3FFm6dCmtra3MmjULs9mMrus888wzPPHEE4B8tqNVT+Xa0NDQbR5X53u7s5eioR/SNC3ssVKqW5voG1avXs2pU6d49913u027Xs7/zs30EXdGTU0Na9eu5a233iImJuaG/STn6KCUIjc3l5///OcA5OTkcObMGbZs2cKcOXNC/STvvm/37t188MEHvPLKK4wcOZIvvviCoqIi0tPTmTt3bqifZB2dbleud+K7nAxP6kdSUlIwm83dKlG3243T6eyltRJf1wsvvMC+fft4++23yczMDLWnpaUBRMzZ6XQSCATweDw37CN614kTJ3C73cybN4+cnBxycnIoKytj8+bN5OTkhHKSnKNDWloaI0aMCGsbPnx46BdI+VxHj5dffplly5bx+OOPk52dzZw5c1iyZAnFxcWAZB2teipXp9OJ2+3uNv/GxsbrHoHoSVI09CM2m40xY8ZQWloa1n7gwAHy8vJ6aa3ErVJKsXr1aj766CPefvttsrKywqYPHjyYtLS0sJz9fj+HDh0K5Zybm4vVag3rU1dXx+nTp+W9cJd44IEH2LFjB9u3bw/9y83NZfbs2Wzfvp2srCzJOYpMnDgxNMb9qvPnzzNo0CBAPtfRxOfzdftF2Gw2h35NlqyjU0/lmpeXR2trK+Xl5aE+R48epbW19bZnL8OT+pmCggJWrlxJbm4ueXl5bN26lZqaGhYsWNDbqyZu0m9+8xt27tzJ66+/Tnx8fGicpMPhwG63o2kaixcvpri4mGHDhjF06FCKi4ux2+2hMbMOh4P58+fz0ksvkZKSQlJSEi+99BIul6vbCbeidyQkJITOU7kqLi6O5OTkULvkHD2WLFnCwoULWb9+PbNmzaK8vJxt27axevVqAPlcR5EZM2awfv16Bg4cGBqetGnTJubPnw9I1n1ZW1sbFy9eDD2urKzkiy++ICkpiYEDB/ZIriNGjOChhx7il7/8Zejvw69+9StmzJjB8OHDb+v2aUoGwPU777zzDm+++SZ1dXW4XC5WrVrFpEmTenu1xE269lr9VxUVFTFv3jyg62jEunXr2Lp1Kx6Ph/Hjx1NYWBj2JbSzs5OXX36ZnTt34vP5mDJlCr/+9a+555577sh2iFu3aNEiRo0axfPPPw9IztHmr3/9K6+++irnz59n8ODBFBQU8P3vfz80XfKODl6vlz/+8Y/s3bsXt9tNeno6jz/+OE8++SQ2mw2QrPuqgwcPsnjx4m7tc+fO5cUXX+yxXJubm1mzZg379u0DYObMmRQWFobd1+V2kKJBCCGEEEIIEZGc0yCEEEIIIYSISIoGIYQQQgghRERSNAghhBBCCCEikqJBCCGEEEIIEZEUDUIIIYQQQoiIpGgQQgghhBBCRCRFgxBCCCGEECIiKRqEEEIIIYQQEUnRIIQQQgghhIhIigYhhBBCCCFERFI0CCGEEEIIISKSokEIIYQQQggR0f8DzI5eTYmWy/sAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "from matplotlib import pyplot as plt\n", "import seaborn; seaborn.set_style('whitegrid')\n", "\n", "plt.figure(figsize=(8, 5))\n", "plt.subplot(311)\n", "plt.title(\"Mapped Experimental Reads\")\n", "plt.plot(y_valid[1793].T)\n", "plt.ylabel(\"Read Count\")\n", "seaborn.despine(bottom=True, left=True)\n", "\n", "plt.subplot(312)\n", "plt.title(\"bpnet-lite trained BPNet model\")\n", "plt.plot(torch.softmax(new_y_logits[1793], dim=-1).T)\n", "plt.ylabel(\"Predicted\\nProbability\")\n", "seaborn.despine(bottom=True, left=True)\n", "\n", "plt.subplot(313)\n", "plt.title(\"Official BPNet Model\")\n", "plt.ylabel(\"Predicted\\nProbability\")\n", "plt.plot(torch.softmax(official_y_logits[1793], dim=-1).T)\n", "seaborn.despine(bottom=True, left=True)\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "9ada2c52-28d8-4794-9fb0-543fa197422d", "metadata": {}, "source": [ "Ut sems like the predicctions are pretty similar for both of them, with both models getting the positioning of the primary peak as well as the much weaker peak to the left.\n", "\n", "Finally, we can look at the attributions for the models at this locus." ] }, { "cell_type": "code", "execution_count": 14, "id": "e117fd20-a234-4859-994a-091292ee6faa", "metadata": {}, "outputs": [], "source": [ "from tangermeme.deep_lift_shap import deep_lift_shap\n", "\n", "from bpnetlite.bpnet import ControlWrapper\n", "from bpnetlite.bpnet import CountWrapper\n", "\n", "X_attr0 = deep_lift_shap(CountWrapper(ControlWrapper(model)), X_valid[1793:1794])\n", "X_attr1 = deep_lift_shap(CountWrapper(ControlWrapper(official_bpnet)), X_valid[1793:1794])" ] }, { "cell_type": "code", "execution_count": 15, "id": "3332042d-a373-466a-9c0f-44771f0c9d76", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from tangermeme.plot import plot_logo\n", "\n", "plt.figure(figsize=(10, 3))\n", "plt.subplot(211)\n", "plt.title(\"DeepLIFT/SHAP of bpnet-lite trained model\")\n", "plt.ylabel(\"Attribution\")\n", "plot_logo(X_attr0[0, :, 1000:1100])\n", "plt.grid(False)\n", "\n", "plt.subplot(212)\n", "plt.title(\"DeepLIFT/SHAP of official model\")\n", "plt.ylabel(\"Attribution\")\n", "plot_logo(X_attr1[0, :, 1000:1100])\n", "plt.grid(False)\n", "\n", "\n", "\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "20ceaf48-b27c-4eb1-89b2-6454b5bd8b37", "metadata": {}, "source": [ "Looks like they are quite similar -- perhaps even more similar than the predictions, with the two G's to the left of the motif both being highlighted amidst negative attribution characters on either side.\n", "\n", "All together, it looks like bpnet-lite produces models using the Python API whose performance is comparable with the official models and attributions/predictions quite similar." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.13.5" } }, "nbformat": 4, "nbformat_minor": 5 }