{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from biom import Table, load_table\n",
    "from biom.util import biom_open\n",
    "from unifrac import faith_pd\n",
    "from skbio import TreeNode\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "from scipy import stats\n",
    "import numpy as np\n",
    "from statsmodels.stats import multitest\n",
    "import os\n",
    "from sklearn.utils import resample\n",
    "import matplotlib\n",
    "%matplotlib inline\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import multiprocessing\n",
    "from multiprocessing import Pool\n",
    "from itertools import repeat\n",
    "N_WORKERS = multiprocessing.cpu_count()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_biom(data):\n",
    "    table_path = data['table_biom_path']\n",
    "    table_biom = load_table(table_path)\n",
    "    return table_biom\n",
    "\n",
    "\n",
    "def filter_max_frequency(table, threshold=1):\n",
    "    maxes = table.max('observation')\n",
    "    above_threshold = (maxes > threshold)\n",
    "    ids_to_keep = table.ids('observation')[above_threshold]\n",
    "    filtered_table = table.filter(ids_to_keep, inplace=False, axis='observation')\n",
    "    return filtered_table\n",
    "\n",
    "\n",
    "def calculate_faiths_pd(data):\n",
    "    table_biom_path = data['table_biom_path']\n",
    "    tree_path = data['tree_path']\n",
    "    faith_series = pd.DataFrame(faith_pd(table_biom_path, tree_path))\n",
    "    faith_series.index.name = '#SampleID'\n",
    "    return faith_series"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_path = 'data/wol/astral.cons.nid.e5p50.nwk'\n",
    "wol_tree_path = 'data/wol/wol-tree.nwk'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "wol_metadata = pd.read_csv('data/wol/wolMetadata.tsv', sep='\\t', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = 'finrisk'\n",
    "target = 'BL_AGE'\n",
    "finrisk_data = {\n",
    "    'table_biom_path': f'data/{dataset}/anonymized-{dataset}-MG-{target}-filtered_rarefied_table.biom',\n",
    "    'tree_path': wol_tree_path,\n",
    "}\n",
    "finrisk_metadata_path = 'data/finrisk/anonymized.age-only.finrisk.metadata.txt'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "finrisk_16S_data = {\n",
    "    'table_biom_path': f'data/{dataset}/anonymized-{dataset}-16S-{target}-filtered_rarefied_table.biom',\n",
    "    'tree_path': 'data/finrisk/insertion_tree.relabelled.tre',\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "finrisk_faith_pd = calculate_faiths_pd(finrisk_data)\n",
    "finrisk_metadata = pd.read_csv(finrisk_metadata_path, sep='\\t').set_index('#SampleID')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "finrisk_table = load_biom(finrisk_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "finrisk_16S_table = load_biom(finrisk_16S_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "finrisk_wol_ids = finrisk_table.ids('observation')\n",
    "keep_ids = finrisk_wol_ids[wol_metadata.loc[finrisk_wol_ids]['superkingdom'] == 'Bacteria']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "924 x 6424 <class 'biom.table.Table'> with 924847 nonzero entries (15% dense)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "finrisk_table.filter(keep_ids, 'observation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_observed_otus(data):\n",
    "    table_biom = load_biom(data)\n",
    "    observed_otus = pd.DataFrame(\n",
    "        (table_biom.matrix_data > 0).sum(0).reshape(-1, 1),\n",
    "        columns=['observed_otus'],\n",
    "        index=pd.Series(\n",
    "            table_biom.ids('sample'),\n",
    "            name='#SampleID',\n",
    "        ),\n",
    "    )\n",
    "    return observed_otus"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "observed_otus = calculate_observed_otus(finrisk_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_finrisk = finrisk_faith_pd.join(finrisk_metadata).join(observed_otus)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "faith_pd_16S = calculate_faiths_pd(finrisk_16S_data)\n",
    "observed_otus_16S = calculate_observed_otus(finrisk_16S_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_finrisk_16S = faith_pd_16S.join(observed_otus_16S).join(finrisk_metadata)\n",
    "all_finrisk_16S = all_finrisk_16S.loc[all_finrisk.index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets = {\n",
    "    '16S': all_finrisk_16S,\n",
    "    'shotgun': all_finrisk,\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def is_old(x):\n",
    "    return x >= 60\n",
    "def is_young(x):\n",
    "    return x <= 35"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check out this source on the bootstrap\n",
    "# https://wormlabcaltech.github.io/mprsq/stats_tutorial/nonparametric_bootstrapping.html\n",
    "# (the code below is liberally copy pasted)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def non_parametric_bootstrap(x, f, nsim=10000, **kwargs):\n",
    "    \"\"\"\n",
    "    \n",
    "    Params:\n",
    "    x, y - data (numpy arrays)\n",
    "    f - test function to calculate\n",
    "    nsim - number of simulations to run\n",
    "    \"\"\"\n",
    "    statistic = np.zeros(nsim)\n",
    "    for i in range(nsim):\n",
    "        # simulate x\n",
    "        indices = np.random.randint(0, len(x), len(x))\n",
    "        X = x[indices]\n",
    "        X += np.random.normal(0, 0.05, len(x))\n",
    "        \n",
    "        statistic[i] = f(X, **kwargs)\n",
    "    \n",
    "    return statistic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_mean_and_confidence_intervals(btstrp):\n",
    "    btstrp = np.sort(btstrp)\n",
    "    mean = btstrp.mean()\n",
    "    message = \"Mean = {0:.2g}; CI = [{1:.2g}, {2:.2g}]\"\n",
    "    five = int(np.floor(0.05*len(btstrp)))\n",
    "    ninetyfive = int(np.floor(0.95*len(btstrp)))\n",
    "    print(message.format(mean, btstrp[five], btstrp[ninetyfive]))\n",
    "\n",
    "def difference_of_means(x, y):\n",
    "    \"\"\"Calculate the difference in the means of two datasets x and y. Returns a scalar equal to mean(y) - mean(x)\"\"\"\n",
    "    return np.mean(y) - np.mean(x)\n",
    "\n",
    "def test_null(x, y, statistic, iters=1000):\n",
    "    \"\"\"\n",
    "    Given two datasets, test a null hypothesis using a permutation test for a given statistic.\n",
    "    \n",
    "    Params:\n",
    "    x, y -- ndarrays, the data\n",
    "    statistic -- a function of x and y\n",
    "    iters -- number of times to bootstrap\n",
    "    \n",
    "    Ouput:\n",
    "    a numpy array containing the bootstrapped statistic\n",
    "    \"\"\"\n",
    "    def permute(x, y):\n",
    "        \"\"\"Given two datasets, return randomly shuffled versions of them\"\"\"\n",
    "        # concatenate the data\n",
    "        new = np.concatenate([x, y])\n",
    "        # shuffle the data\n",
    "        np.random.shuffle(new)\n",
    "        # return the permuted data sets:\n",
    "        return new[:len(x)], new[len(x):]\n",
    "\n",
    "    # do the bootstrap\n",
    "    return np.array([statistic(*permute(x, y)) for _ in range(iters)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def power_estimate(dataset, subsample_size, n_power_iter=100, n_hypothesis_iter=10**5, alpha=0.05, map_=map):\n",
    "    alpha_metric = 'faith_pd'\n",
    "    \n",
    "    def f(x):\n",
    "        dataset, subsample_size, alpha_metric, n_hypothesis_iter = x\n",
    "        subsampled_dataset = dataset.sample(subsample_size)\n",
    "        old_df = subsampled_dataset[subsampled_dataset.AgeCategory == 'Old']\n",
    "        young_df = subsampled_dataset[subsampled_dataset.AgeCategory == 'Young']\n",
    "        old_alpha = old_df[alpha_metric]\n",
    "        young_alpha = young_df[alpha_metric]\n",
    "        diff = test_null(old_alpha, young_alpha, difference_of_means, iters=n_hypothesis_iter)\n",
    "        pvalue = len(diff[diff < young_alpha.mean() - old_alpha.mean()])/len(diff)\n",
    "        return pvalue\n",
    "        \n",
    "    params = (dataset, subsample_size, alpha_metric, n_hypothesis_iter)\n",
    "    domain = repeat(params, n_power_iter)\n",
    "    with Pool(N_WORKERS) as pool:\n",
    "        pvalues = pool.map(f, domain)\n",
    "        \n",
    "    pvalues = np.array(pvalues)\n",
    "    power = (pvalues <= alpha).mean()\n",
    "    return power, pvalues\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import partial\n",
    "import random\n",
    "import itertools\n",
    "\n",
    "def power_estimate(dataset, subsample_size, alpha_metric, seed,  n_hypothesis_iter=10**5, alpha=0.05):\n",
    "    subsampled_dataset = dataset.sample(subsample_size, random_state=seed)\n",
    "    old_df = subsampled_dataset[subsampled_dataset.AgeCategory == 'Old']\n",
    "    young_df = subsampled_dataset[subsampled_dataset.AgeCategory == 'Young']\n",
    "    old_alpha = old_df[alpha_metric]\n",
    "    young_alpha = young_df[alpha_metric]\n",
    "    # set seed here before numpy does random things\n",
    "    np.random.seed(seed + 724)\n",
    "    diff = test_null(old_alpha, young_alpha, difference_of_means, iters=n_hypothesis_iter)\n",
    "    pvalue = len(diff[diff < young_alpha.mean() - old_alpha.mean()])/len(diff)\n",
    "    return pvalue        \n",
    "\n",
    "\n",
    "def calc_power(pvalues):\n",
    "    pvalues = np.array(pvalues)\n",
    "    power = (pvalues <= alpha).mean()\n",
    "    power, pvalues\n",
    "    return power\n",
    "\n",
    "data_type = '16S'\n",
    "alpha_metric = 'faith_pd'\n",
    "\n",
    "data_types = ['16S', 'shotgun']\n",
    "alpha_metrics = ['faith_pd', 'observed_otus']\n",
    "subsample_sizes = list(range(100, 1001, 100))\n",
    "\n",
    "info = (data_types, alpha_metrics, subsample_sizes)\n",
    "\n",
    "entries = []\n",
    "for i, (data_type, alpha_metric, subsample_size) in enumerate(itertools.product(*info)):\n",
    "\n",
    "    dataset = datasets[data_type]\n",
    "    dataset['AgeCategory'] = None\n",
    "    dataset.loc[is_old(dataset.BL_AGE), 'AgeCategory'] = 'Old'\n",
    "    dataset.loc[is_young(dataset.BL_AGE), 'AgeCategory'] = 'Young'\n",
    "    n_power_iter = 1000\n",
    "    n_hypothesis_iter = 1000\n",
    "    alpha = 0.05\n",
    "\n",
    "    power_partial = partial(power_estimate, \n",
    "                            dataset,\n",
    "                            subsample_size,\n",
    "                            alpha_metric,\n",
    "                            n_hypothesis_iter=n_hypothesis_iter,\n",
    "                            alpha=alpha,\n",
    "                            )\n",
    "\n",
    "    with Pool(N_WORKERS) as pool:\n",
    "        pvalues = pool.map(power_partial, range(n_power_iter))\n",
    "\n",
    "    power = calc_power(pvalues)\n",
    "    entries.extend([{'idx': i, 'pvalue': pvalue, 'data_type': data_type, 'metric': alpha_metric,\n",
    "                     'sample_size': subsample_size, 'power': power} for pvalue in pvalues])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "import pandas as pd\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "FULL_SHOTGUN_V_16S = 'results/2.01-power-calculation-all-v-all-1000--1000-v2.json'\n",
    "with open(FULL_SHOTGUN_V_16S, 'w') as fp:\n",
    "    json.dump(entries, fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "FULL_SHOTGUN_V_16S = 'results/2.01-power-calculation-all-v-all-1000--1000-v2.json'\n",
    "\n",
    "with open(FULL_SHOTGUN_V_16S) as fp:\n",
    "    entries = json.load(fp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "power_df = pd.DataFrame(entries)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = 0.05\n",
    "power_df['reject_null'] = power_df['pvalue'] < alpha"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "findfont: Font family ['normal'] not found. Falling back to DejaVu Sans.\n",
      "findfont: Font family ['normal'] not found. Falling back to DejaVu Sans.\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA4cAAAFYCAYAAADgGolFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8vihELAAAACXBIWXMAAAsTAAALEwEAmpwYAADDeElEQVR4nOzdd5xcZb348c9zzvTZXlJ20xsJSSBB9CqioldBrw0blis2VBQU7Pqzci33KlZQsF0FBduVYkFFFEEFQUQpCUkgvewmm63T58w553l+f5zZzezubEs2/ft+veaV2ZkzzzmzO5mZ73m+z/erjDEIIYQQQgghhDi5WUf7AIQQQgghhBBCHH0SHAohhBBCCCGEkOBQCCGEEEIIIYQEh0IIIYQQQgghkOBQCCGEEEIIIQQSHAohhBBCCCGEQIJDcRgopd6klDIVl5xSaodS6lal1AVKqYN63Sml1iilrlBKNU3TcV4x4jjHurxpOvZ3LFFK/bdS6g6lVO9Ez1Ep1a6U+r5Sap9SylFKbVdK/c+IbWYqpa5WSj2hlCoopXqUUv9USl2llIoe9ickxATkfenYppRaUPHc3l7l/qRSKlO+/7MHMf75Sqn3Tc/RnniUUtcrpXYc7eMQQhx9oaN9AOKE9ipgDxAF5gEvBH4CvF0p9WJjTGGK460BPgXcCPRNw/H9L3B7xc8vBD7OgeMetHUa9nWseTfwMHAb8IaxNlJKLQDuBbYDlwFdwAJgScU2dcDfAQ18EdgENBH8vf6T4G/mTPcTEOIgyfvSsS0DXAh8Z8TtrwAOpTHz+cBzga8cwhgnss8AVx3tgxBCHH0SHIrD6WFjzJaKn29QSv0c+DlwJUGActQYY/ZQ8WVLKbW8fHXkcZ+I6o0xWim1hHGCQ+BbQAfwbGOMW77tzyO2eSUwH1hjjHmk4vablVKfnLYjFmJ6yPvSse0W4A1KqYXGmO0Vt78BuBl401E5qhOcMeZEPdkghJgiSSsVR5Qx5mbgl8DblFKJwduVUv+llPqXUipVTkn8k1LqqRX3vwm4rvzj5or0owXl+9+llLpPKdWnlBpQSt2vlHrhoRyrUuoD5TTK1hG3K6XUNqXUT8o/D6ZDXaKU+opSar9SKq+Uum3w+EY8/m1KqUeUUsXyc/3edKWkTZYxRk+0jVJqMXAe8PWKwLCawWPfV2U/xhhzKGf7hTjs5H3p2HhfKrsH2Aa8vuLY5gDPBn5Y7QFKqYVKqR8ppbrLv5uHlVIvq7j/euCNQHvF32hH+b6YUuqrSqn1SqmsCtLnf10RlFfu57lKqYfKv6MtSqm3VkvHVEollFJfUEEKfqn878dUReqyUuqc8nG8RCn1jfLvvFspdaNSqmHEeHXlbTrLz+9xpdR7lVKqynjnK6W+XX7N9Zefm62UerJS6h4VpFM/ppQ6b8Q+qj2PpFLq80qpreX97lNK3ayUmlm+f5ZS6gcVx7W3/PqaUe3vJIQ4PkhwKI6G3xKkdJ1ZcVs78FWC1J83AfuBvyilTivf/xtgcJ3Jq4CnlS97y7ctIEjHehXwauBB4Dal1AsO4Ti/T5Aq+eYRt58LLAS+PeL2/wcsLW9/KfAk4A6lVHhwA6XU54FrgT8CLwE+CDwf+J1Syh7vYJRSllIqNImLGm+cKXh6+d+CUuoP5Q//fqXUD5VSzRXbPVD+96dKqfOUUslp2r8QR5K8Lx0770s3EqSWDno9wWzq3VX2P5cgrf104L3l4/8XQebCS8qbfYbg79vNgb/RYPAYBWoJ/o4vBN4JxID7lVKzKvZzKsHfOwu8BvgocDnwnBHHEwJ+D7yVIE3zBQSvgU8QpN2PdBVBuuzrgE8TpM8OpXeWA8rfEPz9vgy8mCDt+CvA56qM9zUgR/B6+wbwnvJtPyR47bycIP35FqVUS5XHD+43AvyBYDnB9cCLgHeVH9tY3uwGgt/lB4HnlbfdAyQQQhy/jDFykcu0Xgi+RBlgyRj3n1e+/9Vj3G8TpDw/Dlw12XErtrPKj78D+OWhHDfBh+IWQFXcdguwqeLnBeXHbQCsitufXr79oortfOCTI/Y7uN35Exzf9eXtJrq8aQrPeclYjwE+Ur4vDVxD8CXo7UAvwZfcyuf6SaBU3t4r338F0HC0X49ykYsx8r5Ucfsx+b5UcbxvBRaVrz+1fN9jwOfK1w3w2YrHfY8g6GseMd4fCFJxK49zzyR+3zZBcJMB3ltx+4/L+0lU3DYbKAI7Km67sHyMzxwx7sfK75Ezyj+fU97uByO2+0Z5TFX++UXVfn8EAacDtIwY7/sjtvtX+fazK247rXzbG0f8fiqfx1vK27xknN9VFrjscP2flYtc5HJ0LjJzKI6GwTPIQ+mG5XSdu5RSvQTBhQssA06Z1IBKPamcztJV8fjnTfbx47gWWAz8e3k/swnO3I48Ow9wk6lI1zTG3EtwFvVp5ZueR/AF8UeVZ9QJznqngWdOcCxXAE+exOXXU36W1Q2+P9xtjLnUGPMnY8x3gEsIZh+G0pKMMZ8mKO7xVoKzyc0ERTrWD6YgCXGMk/elY+R9yRizjaAQ1oVKqTOBUxkjpZRghvO3QGrE8f8eOF0FBbPGpYJqtX9XSg0Q/J1yQA3D/05PBX5rjMlXHOde4G9Vjmcn8LcRx3MHEC6PU+k3I35eRzCbOfi++UyCmeKfjNjuRiDCgb/joN+N+HkTkDPG3DPiNoC5jO1cYJ8x5lfjbPMP4INKqcuVUqunMWtFCHEUSUEacTQMfiDtBVBKnUHw4f574KLy7T7BmdHYRIOV04ruJDhD/m5gF8EH/GeAFYdyoMaYB5RSDwLvIEi5emt57B9U2bxrjNvay9cH12GMVVSieYzbB+1ieLXCsfiT2GYyesv//mHE7XeU/11LxRcRY8w+grP43wNQSl1KcBb8g8AHpumYhDhc5H2puqP1vvRD4L8JZvIeMMY8PsZ2MwiK1YxVWKuZIMitSin1YuBnBL+7/wJ6CIKx3zL87zybIK14pC6Cmc7K45lPcCJgrOOpNLLC7WBl58F9NwF9xpiRFZ/3VdxfqX/EzyVgoPIGY0ypHMeN9zpuJihGNp5XE5wE/BBB6upepdS3CGZ2J1zXLoQ4NklwKI6GFxKkzfyz/PMrCL7YvNxUFD5RSjUy4kNtDM8H6oELTFDpb/Dx07Xu4ZvAt5VS7QRfwn5ujKlWsr7aDNlMgpYRcCDYOpfRH+CV94/l+wRFFSbyZoIUoUP1WPnfsQrKjPvhb4y5Rin1GYKz/kIc6+R96dh6X/o/grV3byNYyzaWXuCvwBfGuL9zgv28BthijHnT4A3l9Zgjg669HAikK438/fYStP65YIz97ZjgeEbqA5qUUhFjTKni9sH1kBP9fQ5WD7BqvA2MMfsJ1rFeqpQ6heB18F8E6bffPEzHJYQ4zCQ4FEeUUurlBAUDrqpIz0kQnFWuTOd6DkGaYmUp88Ezp/ERww5+2ar8AreMYM3MZM5oT+QnwJcI1pzMI2jvUM0rlVJXDJ4xVUo9HZgD3Fe+/w8EAdU8Y8zI2bjJuIJgJm4i2yfeZFLuJzg7/fwR+31++d9/QFCxDugxxniVDy6nutVzoDiHEMckeV869t6XjDEDSqn/IchQ+Ok4m95OkFr5mBm/R6XD6L8RBH8nb8RtFxLMWFa6H/gPpVRi8DVSfo97OsPf424nOLGQNcZs4tD9mSD74lXAjypu/0+CWcH7p2Ef1dwBvEYFvT8nTAkuz+x+VCn1DiYIKoUQxzYJDsXhtKZcDS1C8OXlRQQfcH8gqKA36HaCimrXK6WuI1jT8wlGp7RsKP97qVLqBwRfuh4lSKvygB8qpb5MkP7zXwTpToe8rtYYU1BBKfT3AuuMMSPXmAyqBX6hlPo20Ar8D7CZ8loZY8xWpdQXgG+Uz7L+mWCmYi7Bup//NcbcNc5x7GDqZ52rUko9q3yMg2efz1RKZcv7uan8r6eU+gjB3+VbBAUvlhBUyLsb+FP5sa8HLiv/7e4H8gR/w/cTfHm5ZjqOWYhpIu9Lx+j7UpWxPz2JzT5JUDH5L0qpb5SPpZEgQFlkjHlLebsNBDNw7yQomFU0xqwj+Dufr5T6KnAbwXrqyxg9O/xZgp6uv1dKfYlgXeAnCNJKK7MofkQwS3pn+e/+CMFrbTHBCYjzK9ctTsLvCNp7fEsF7UseA/6DYLb4f4wxPVMYaypuJJi1/Uk5SP87wWvpPMoppASv8R8RrGF0gZcS/O7vqDKeEOJ4cbQr4sjlxLtwoLre4KVAsED/VoIvYarKY95NcGa5QDAj9VyCAOTuEdt9iuDL2eAZ/QXl2y8g+IAqEnx4voYR1demcNyjqg4SnJk2wKVV7ltQvu8SgvLi3QQB0m+AhVW2v5AgiMoRVHvbSHDmfc4R/BvdPeJvNHQZ43jXE5x53wt8HaipuH8FQbn/hwhSnNzydjcBZxzt16Nc5GKMvC8d6+9LFcf71gm2G1attHzbHIK1oB0EJ6T2EgT7r6/YJkkw29pfHmNH+XaLIPDrLP9+/kwwW7kDuH7Efp5HkI7rEPRivLj8+nloxHYxghnVTeVt+8qvnyuAUHmbc8rH8dwx/t4LKm6rK/8t9paf3xMEJwUqq9WONd71VKnSOvL3WO11SVCU54sE/08Gf683EaTXRgkKID1Wfr2ky8/xdUf7/7pc5CKXQ7sMlkoWQoxDKfU5gp5WbcaY9Ij7FhB8gXybMeZ/j8LhCSFOQvK+dHQppWoICvn8xhhz0dE+HiGEmA6SVirEOJRSawnKmV8OfGfkFzAhhDjS5H3p6FBKfZ2gdUUn0Ebw+2+komm9EEIc7yQ4FGJ8txJUo/s9QeqYEEIcbfK+dHTECKqiziRIs3yAII3z0aN6VEIIMY0krVQIIYQQQgghxKFXTBNCCCGEEEIIcfyT4FAIIYQQQgghxMm75vD5z3++uf3224/2YQghxKFSR2On8h4qhDhBHJX3UCGOVSftzGFPz+HqGyuEECc+eQ8VQgghTjwnbXAohBBCCCGEEOIACQ6FEEIIIYQQQkhwKIQQQgghhBBCgkMhhBBCCCGEEByF4FAp1aqUukop9XellKOUMuXLu6Ywhq2Ueq9Sap1SqqCU6ldK/U4pddbhPHYhhBBCCCGEOFEdjVYW7cBlhzjGDcBrK36OAc8HnquUeqkx5reHOL4QQgghhBBCnFSORlrpAPBV4DXAt6b6YKXUizkQGP4JmA08C8gRBLv/q5SKTMuRCiGEEEIIIcRJ4ogHh8aYHcaY9xljfgZ0HcQQb6q4/iljzD5jzF+An5Vvmw2cd4iHKYQQQgghhBAnleOxIM2TK64/Nsb1ym2EEEIIIYQQQkzgaKw5PFQzK66nxrg+4wgdixBCHBJjNKVSL1qXsKwIkUgzSh2P5+2EEEIIcbw7HoPDsagJN1Dq7cDbAebNm3fYD0gIIYzxyxeNMT6gh65r7VMqdbFu/SUUix3EYu2ctvrb1NScckwGiPIeKoQQQpzYjsfgsAuYW77eAPSVr9dVbLO/2gONMd8BvgNw5plnmsN0fEKI40y12bvg9iCog8HgbvB68LPWLsa4aO3h+1lct49SaQDXG8B1U/heCs/L4Pk5fC+D52fxvBy+n8Hzcqxc+RU2b/4sxWIHAMViB4+uu5gzn3Qz0Wjr0fuFjEHeQ4UQQogT2/EYHP6DA8HhqcA95esrR2wjhBDDVAZ0xnho42G0R6nUM2z2btWqb+AUu3GcPbheBr8iqPO9HJ6XxRu87mfxvCzGlMbcr6VihFQSW8WxTZyImY2tY8QibUOB4aBisQPtFSF6uH8bQgghhBDDHfHgUAW5Uk3lHxMVdyWVUi0AxpgepdQ5wF3l+35gjHlT+fr1wMvL1/9LKfU6YDnw6vJte4HfH45jF0Icm4wxBwI+7WFMCa1dfL+I7+fR2kHrYhAYYvC9NEWni1Kpi9aWc9mw8QPDZu/Wr38XS5d+nCc2f3rEnhS2lSRk12CrBGFVR0zNxA7FsHUU28SwSRBSCSwnhBrwYH8R05/D7x3A9KXRvSl0Tw8mlSP8tySxWPuwADEWa0eZYy+lVAghhBAnvqMxczgP2F7l9s+XLzDO+kFjzK+VUj8h6HX4HGBfxd0e8DYz3il8IcRxJQj2vHL6ZhAA+n4BXxeDgM8voHUJYwAVZDoarXHdAVy3l1KpB6e0n5LTRdHZh+PsRWtnaPzWlnOrzt7Fwm3MC78eW0cImQS2SmATAyyMrzFFB79vAN2fxu9LYXpT6N4udHeKUk8Kky0MfyK2jd3aiN3STPSMRditLdDnsnLelTy260NDs5Yr511JyI0f5t+qEEIIIcRox2NaKcAbCFJH3wIsBYrAfcBnjDF/O5oHJoSYmqAwi4PWLp6fw2gXAM8L1vAZNBhAKRRgMChsQOF5aRxnP05pP06hE8fZGwSApa5haZ6KEBGriYhqIqGeRNhqIErwc8Q0VJ29s/wQ0Y44ui+N19OJ25NC96TQ3Sl0TxoKzvAnEgkTam0h3NpKaMmphGbMINw6g9CMmYRaW7EbGlDWgRlB43kYxyVGC6vin0HNiGMyBaLuTOz6hsP3CxdCCCGEGMMRDw6NMTuYRGVRY8zdY21njPGAr5YvQohjnDEGrUvlINDB87L4fg7Py6BNCduuwbbCrFv/rqEZtNWrriGkGnHyOykWOig6+yg6e3GcfTjufkp+DwZvaB8KmwhNRGgiqZ5E1GoiTBNRq4Ww3Yiyw2BZYFmYbB6/vx+/rw/aqs/eqa0pclf84MD48TihGa1EZ8wjtLKV0IwZhFpbhy5WXR1KDX/LMp6HcV2M6+IP9A+7X0UiWKEkRKPEk8vA97EaYthNTcOCSCGEEEKII+V4nTkUQhyDggAwCAJ9vzBUpdP38+UZv0EhLCuMZcUIWTXYdpKHH3nTsHV/69ZfytKlH2fdE5cNPUoRIkIzUauZ2tAyInYz0dBMInYLEasBHA/dn8LvT6P70uj+NG7fLpy+FLo/je7PYAay4PlDYzaf9h/0f+KrrHzvJ7Dm1aN7U/R/4KvM/tQVzPjQh7Bbg0DQTiarPmfjuhjPQ2cy4HvD7lORCFayBqulGSuZxIpEUNEoKhJB2fY0/uaFEEIIIQ6dBIdCiCkJ0kAHA8BiUMnTDyp4Gu2jVDkLFIVSISwrQijUgFIKY3yKxU7yhZ3k89spZLeTL+xg9WnfqL7uLzKbOYkLCJsmwrkEVr+P6c8MBX66by+6/3Hy/WmyfSnMyFRPgFgEu6keu7GRyIq5hJqaCTW1Empqwm5qItTUhN/dw943HghCw+1tWMkkiac8BWMMeB66UMCUSuD7FTkNChWLYsUTWC3N2DU1QeA3eJEAUAghhBDHEQkOhRCjDKaBGlPC1w6+N9jKIYvvFw9sqMBSYZQKE7KTqNCBYMh1B8jlt1LI76RQ2EG+sINCYTfGuOUtLKI0k1DtWCZSdd1fyE1g3nMnTiqLY0a01bMtVEMNVmMNqq2R8Mr55YCvlUjLDMKNMwg3z8JO1Ez4XNuvvpqOyy7D7egk3N5G+9euwu3pweRyDAaAdjKJNaMVK5EIAr/BGUBJARVCCCHECUKCQyEEEKSEel4Gx9lPqdSLwQcUGINSNpYVBIGRSGLE41yKxd3k8zvLAeAO8vmdeN7A0DYhu56Y3UazegpRWonZbcTic7GsMO6GbUTmJFg55/M8tucjB9b9zfk8qtclvHYpqjGJ1ZhENdZhNSaxm1oI17cStuqwrRiWiqAIj1rzV8n4/tD6P+N5gAmmOAGrpoa53/te8PhQCCseR4VCB2YAJQAUQgghxElAgkMhTmK+X8R1UzilfXhuCstOEgk3Eou3o7DK6aPBTKExhpLbQ2EoCNxJPr+jPNunAVAqQjw+l/r6M4jbbUS8JiKZOCEdA0Ko2jgohb9zL8V7/ojzt0fQ/WnqrllD5tZbWHnhgXV/mSt/ROQD76LubRcE6xKtOBaRIBBUo9M1jdZo14XB4K8y/dMYVDiCSiawGxuwEgmswZm/SAQVHj+wFEIIIYQ4GUhwKMRJxBiD7+dx3QEcZx+elwXAtuNEIrMwpjRUGCYWa2flyq/R0/0nevv+TKGwA9/PD40VicwgkVhAY+NTScTnE4vNI+rX46cy+L29oDXYIVQijrIs/O5+in94AOfeh/H3dIFtEVqzmNjTn0OhJUvzOy6m8/L3HkjtvPpqlBemJrLkwPF7HsYtoT0vCACNARW0NzRKYSfiWPV1QfGXeDwI+mT9nxBCCCHEpEhwKMQJzhiN52UplXpxnH1o4wAWITtBJNI0tJ1SikfXXTKsYuhjj72HZUs/SW/f3TQ1PZNEfAHx+Hzi8XmEQslgti6Xwx8YwN/dR0n3QiiMSiSDgDCTp/in+4OAcNMuAOxlc0i85UUknvZUInUzsVQUW0WxYgnmXXcdRgd9Db1UCtPXN+y5BNU/k6hE4kD1z3AEKxIGmf0TQgghhDgkEhwKcQLS2sP3MzhOD46zH2M8lLKw7SQh60CBlmKxg76+e+jrv5cVyz9ftWJoIrmYFcv/Z+i2wYCw1L8Lv68fjIZQGOIJsHx8p4D7wDpK9z6G9/BW8HzsthnUvvp8ks94BtGZc0alhRrfx+vaD54bBH21tYSbm7HmtA+v/ilr/4QQQgghDhsJDoU4QWjt4HoZnOI+Sm4fGINlhQmFksOCMcfpCgLCvnvIF7YDUFOzAsuKVq0YqrAwvo/O5/H7+vD7BzDax4QUJm6BBUaX8DduxfvbJkp/fwyTL2I11FN73vOpeeYziSxaVHVWTxeL6HwOZdmE22YTnjkTa4x+gkIIIYQQ4vCS4FCI45jvF8rrB7tw3RQAlhUlHKpHqQOzbE6pm/6+e+nru5dcfjMAyeQy5s55C01NZxGJtGBZMVavupZ16y8ZWnO4euU1FPfsxNm7Gd+4mLCFFY+gLBtbJaAjQ+meRyjc8wB+bx8qFiPxb/9GzTOeQWz16qrr/Izvo7PZYJawro7YihWEGhtRIXk7EkIIIYQ4muTbmBDHkaCgTLaioEwOpRSWFSccbhw2O1cq9dHXfy99ffeQyz0OQCKxmDlz3khT41lEozOHje3rIpZnsWbV9zFojOOQ27IRr5AinGwgEqonZCUxvTkK9z5A5q/34O7cCZZFfM0akhe+gcSZZ2LFYlWPXTsOOpdFWRahtjbCM2Zi18gsoRBCiENjSiV0qYRdM35fWyHExCQ4FOIYZ4w/rKCMMS4oC9tKEIk0D9vWdQfo7/8bfX33ksluAAzx+ALa2/+TpsazicVmHxhXa0yxiJ/Po1Np3PR+7GQ9NY2nElIxsJPU1q5ERTQmXyB37/2k//pXio89BsYQWbqUposuInnWWdj19dWPXWt0NovxXOxEgtjy5cEsYTh8OH9lQgghTlDGGIzjoPN5vIEB/N5eTKEItkXyaU+TtelCHCIJDoU4Bhnjl/sPdlNyujH4KGxsO4ll1Q7b1vPS9PffT1/fPaQz6wFNLDaHtrZX09R4NvH4nGBMz0Nns/i5HH46jcnl0NrHU3lUOESidQlxM4OOt18+1E6i7StfIfXLXzHw85+D6xKaNYuGV72K5DOeQXj27CpHHtCOg8nnAEVo9qxgLWFNjVQTFUIIMSVGa0yhEHx29ffj9/VjPBcDqFAYu7EBe+ZMjOfh9fYSam6WAFGIQyDBoRDHEGM0jtNDPr8VrR0sK0ooVDOquqfnZekf+HsQEKYfATTRaBuzZ7+Cpqazicfmgeuii0Xcvo4gGHSc8j5AR8EkNJYVpsY6hbDdSKSmhV1vfjNuRycAbkcnne97HzM/9jH8/v6gsMySJWMGeINVTI1bworHiSxdSripCRWJHNbfmRBCiBPHUAG0bBa/tw9/oD/om6sURKJY8ThWKDhJqmJRjOMMfXaF29uYc821RJctlQBRiIMkwaEQxwBjNKVSL/n8NsAup38awELrEloX8f08/QMPlAPChzHGIxKZwaxZ5wcBoZqNcRz87jTF9GPlJvEERWEiEahJ4Js8Bk1ENRANzcAmib+vi9wjf8I693lDgeEgt6OTyKJFNF900ZjHrkslTC4LQGjGDMKzZ2PV1sosoRBCiAmZUikIBjMZvN5edCaDMYACKxbHqqsfM9CzIhF2XXzxsJOaey69hAU/+xmhlpYj+CyEOHFIcCjEURQEhX3kC9vwvTyRSCtgeOjhNwxVDF218io6997K3r3/hzEu4XAzM1pfQGPyyURNG6TT+JszOCYdDBoKoSJRrHgCYwzaFNHkUESI2+3YhTCl9Y+TeuSPFB55BL+7G4DEk88k3N42LEAMt7dV/VA2xgSzhCUHKxYjsmQJoeZmLJklFEIIMY6ghVEef2AAr7cPU8gHd1g2KhbDamgc9+SicV2czZspPPooDa94RdWTmqZUOpxPQYgTmgSHQhwFxhhct498fhuel8W2a4lEmgmFanjo4QuHeg0Wix2sf+xyli29Aq/QTX14LdFiE/QVML0aT+1BhSOoRHJYEKeNh6dTGCCs67C3O7iPPEbfoz+htHUraI1KJIivWkXs/POJn3464TlzaL/6ajouu2woPaf96qvRFR+yxnXR2QwYCM1oDWYJ6+pkllAIIcQoxhhMPh8Uj+nvx+/rK3+mKFQohIrFsJuaxx9Da0o7d1J89FGK69ZR3LgxWCZhWdQ9/7zqJzXlRKUQB02CQyGOoCAo7K8ICpNEIgdSX7QuDWtCD0GAGA+3MyNzFqAgalA1tVgjAjJjDL4p4BsHtT8H67tx120hs34DplAAyyK6ZAn1r3gF8dNPJ7pkybDegqbooGJR5l13HUYblKXQpRK6EJzlpVhERSNEFi0i1NKCFY0e1t+VEEKI44vxfXShgJ/Nont78QYGgvWCAOEIVixOqKZ23DEA3K4uio8+SmHdOorr16PTQWZMeM4cap7zHOKrVxNduZJQc9Ook5pzrrkWu6npMD5LIU5sEhwKcQQYY/C8AXK57Xh+elQbilKphz0dN9LW9mpisfZhAWIs1g4arNq6qmNr4+Jl+/E27ECv68RdtxV/f5Aqare2kjz7bOKnn05s1aoJe0CZooNfLBeucV10LovRmlBTM+FlS7Hrx177IYQQ4uSji0X8dBq/uxuvvx+jTbBeMBrDqqkN1r1PwE+lKK5fT6E8O+jt3w+A3dREfO1a4qedRmzVKkLNw2cZh53U9Dys2lqpVirEIZLgUIjDKAgKU+Ry2/C8NLadIBI+8OHm+0X27buVfV23YowhqReyavlVrN90+dCaw9Wnfp3Svr3DxtWeS2nLVkrrtuCv24G/pQOMQcVixFatIv7ilxBfs4bQrFlTSvkcrBKHW0KFw0TmzyfU2jpmY3shhBAnl8H+tX4qhbuvC10soAAVjY1bPKaSLhQobtxIcd06CuvW4e7YATC03KHuxS8mdtpphNvaJvwMGzyp6ff3kTzrLAkMhThEEhwKcZi4bop8fhuumwqCwoqZQmM0vb13s6fjRly3j/rwGmZ4zyTqzIaUzxmrbsQogzKKUu9+/EIKv6sX59FNlB59HG/DTsg7oBSRxYupefnLg1TRZcuGpYpOhnYcdCEPWmOFw4RaWwk1N8ssoRBCCCCoSq0zGbzuHrzeHoyvUZaFSiQINU6cwmk8D2fLliAYfPRRnM2bwfMgFCK2fDnJ176W+GmnEVm0aFIzjcPGdl10Po9BBe0uhBCHRIJDIaZZEBRux3X7RwWFAJnMY+za/T3y+W0kQvOYq15Kwl6CVRPHjtcTzkXoeOuBnk2zv/AF+v/31xTuvhcAu6WJ5NPOInH6WmKrV2PXTrx+o5LRGl0oYJwioLBrkkQXLMBuaMBKJqW4jBBCnOSCitR5/NQA3v7uoL0EJqiEXSVVVMWiWJEIRgdBo++UKJUrihbXraP42GOYYjE4obloEXUvehHx004jesopU16/bozBFIuYYiHImIlGCc+eRai1VU5oCjENJDgUYpq4bpp8YQduqRfLig8rNANQLO5lz54f0D9wP2GrkXb1chqsNVg1BwKyeLyNjre8c1jPpr0f/jCzPvtpMgsXkjj9TMLt7VMO4AbPrOJ7oCxCLc2EWhdh1dZKYRkhhBAY18XPZvF6e/G7u9GuC5aFFU+MW+BlqBF9ud9guL2N2Z/7HH0/+AHFRx4hNHs2Nc96FrHVq4mtXDnlE5pwYMmDcUsopbAaGgjPnUOorg4Vj8tJTSGmkQSHQhwiz8uQyw8GhdFRQaHnZdm79ya69t+GwmaG9WxarLOwaxpRqqL9RH8aYxeq9mwKz55DwwvPn/QxGWMw5dlBYwxWPE5kTjt2Y2MwOzjFtB0hhBAnlsHPCS+Twdu/Hz0wgDEGFY5gJZKEJvicMK5LceNGosuWsffDHxp+UvNjH6P9a1/D6+kl1Np6UMc35pKHmhpUOHxQYwohJibBoRAHyfMy5As7KTndWFZsVPqoMT7d3b+no/OneF6GBrWGmdazidQMbyxvSi6F395D/pd3kfjSl8doRD/xWVHjecHsoOeCsrAbGwnNn49dV4sVj0/fExdCCHFcMr6Pzmbx+vrw9u8fahavYvEJm89D0GKi8NBDFB56iOL69RjHYd4NP6x6UtOqrSOkJp/maXwfXSxiSg4YZMmDEEeJBIdCTJHnZSkUduE4+7GsCOFw86gPrVTqX+zafR3F4m6S1kLmWa8hWbN02IydMYbSA+vJ/ei36O5+Qmcuw034Ezair3y8KZ9ZVeWzvaFZMwk1NmLX1k65MI0QQogTz7BWE339YDTYIaxEAis5fnsj7TgUH3uMwsMPU3j4YbzOIAgMzZxJzbOfHVTFbm096JOaulTC5PPltYqKUEsrodaWYMmDNLIX4qiQb49CTJLn5SgUduM4+7CsMOFw06igsFDYza7d15FO/4uIamauuoC6+BnYIz7kvJ2d5H54G+6GbVhzWqn72NuoX3MOtoqioqMb0ZvB3oND6y5clAKrro5o+5Jg3UUiIWdWhRDiJGe0Rudy+AMDeF1d+PkCShEUk5mgCrUxBq+zk8LDD5N/6CGcDRswpRIqEiG2ciV1z38+8bVrh7VJMp43tZOaI5c8zJsbzA7W1EhBGSGOARIcCjEB38+Tz+/GcfaiVPWg0HVTdHb+lP3dv8ciykx1Ls3xZxKKJoZtp9NZ8v93B8U//QOVjJF484toPPdlhMP1Q9tUNqKHynUXBitkE2ppIdTSEqy7kDOrQgghCGYIvf37cffsQXv+gVYT4xSTgXLPwfXrg9nBhx4aakAfbm+n9nnPI752LdEVK8YsXjasEX21k5qy5EGI44oEh0KMwfcL5Au7cYp7UcquGhRq7dK1/zfs7fw/fF2kiScxI/o8IonhRWmM51G4/W8UbrkTU3KJnvcUGl55AbH6ucOK0gyNWyphclmMATsRJzp//oF1F3JmVQghRJmfyeB2duJ27QdLYdfUEhpnWYExBnf37gNrBzdtAs9DxWLEVq2i7qUvJb5mDeGZMyd9DJUnNau2mpg1k1BTUzA7KEsehDimyf9QIUbQukSh0EGhsBtlWYTDoxfpG2PoH7iPPbt/gFPqooalzAq/gHhy/rBtjTG4D20ie8Nv0Pt6CJ2+iLo3vJaaeaux1Oj/fkZrdGoAFQoRXXYKdkO9tJoQQggxjPF9/IEBSrt24afTqEiU0OzZ2NEDvQYrZ+90Lkdh3bogIHz4YfzeXgDC8+ZR98IXEl+7ltgppxx0FVDj+0H/3FJpaMlDeE67LHkQ4jgkwaEQZcb4FIv7yBe2g9GEw3UoNbqUdy63hV27vk82t4EorcwPvYG6mtNHffh5e7rI3XAb7qObsWY3UffhN1N/5r9jq1jV/fu5HMYpEpkzh8jcuVKqWwghxDC6VApSR3fvRpdcrESCUHPLgV6D7zjQa7D9q18l+8ADZH7zW5zHHwetUYkE8dNOI37BBUExmebmiXc6hsH+ucb3UbYVtJqQJQ9CHPckOBQnPWMMpVIPudwWtC4RCtVhWaP/a5RKfezZ80N6+/6MTYI260U01TwDyx4exOlsnvxNf6T4h/shFiF+4fNpfMEriEQaq+/fddHpFFZDA9GVK7FrkofleQohhDg++dkc7t5OvH37ALBqagnV1g3db0UiQ03oIWgl0fHe9zLzI/+PtONQf/75wdrBpUsPOq1zVLpoZf9cKSYjxAlDgkNxUnPdAXK5LXhellCohlAoKOttWTEsKwJojFHs3/87duy4GmN8WtRZzKg5b2jbQcb3Kf7x7+Rv+gMmVyTy72tpvOB1xBrnVV1XaLRGp1Mo2ya6YgWh1lZJvRFCCAEEnxF+KkVp9250Xz9EIlj1DaOCsKCKdaFqr8HI4kW0XXnlwR/DULqog1IqSBedO4dQXR1WIjHxAEKI444Eh+Kk5HlZcvntuKUebDs5rIG9ZcXQ2uGRRy+iWOwgFmtnxfLPM6P2P6j3lxONzBg1XunRJ8j98Db8jv3YK+dT/8YLqFl4Bpaqnhqqczl0sUhk7hwic+ZICo4QQggATKmE29uLu2sXplhExRPYLS2jt3Ndsn/5C6lbb2XWxz5WvdfgQcwSDqaL4ntg24SaWwi1tgT9c+WzSogTngSH4qTi+0XyhV04xU4sK0okMvoD17IiQ4EhQLHYwcZNH+H05d+lsHPT8PH2dpO98Te4/9qEmtlA7fsupP7fnkfIrn5G1bgufiqFXV9PYuWp2DXjNyAWQghxctC5HG5XVznAM1g1tVWb1GvHIXvnnaR+9Sv8nh4iixbh5XOT7jVYdd+D6aJaB9VF29sIDaaL2qPX3gshTlwSHIqTwmAF0mJxNyiralsKAMfpKhem6Rh2e7HYgbIPpPLofJHCLXdSuP1vELaJv/a5NL7oVYQj1ccNUkjTYCliK5YTmjFDUkiFEOIkZ4xBp1KU9uzB6+1DhUNYdXVVAzKdz5P5/e9J3XYbOpUiunw5zW9/O/G1a1FKoaJj9xoctV+tD6SLGrBqawkvXizVRYUQEhyKE5sxPo7TRS6/HYxPKFS9Aqnn5di77ya6un7NqlXfIBZrHxYgxmLtGF9jtMa56x/k/u8OTCZH+Fmn0/Ca15BoXlR1XAg+0HUhT3jOHKJz50pajhBCnOSM5+H19lHatRNdKKCiMeym6icX/UyG9G9/S+a3v0XncsROO42GV76S2KmnDh+zotdg1X1WpotaNqHmJkIzFmPV1mLJ55IQokyCQ3FCCiqQ9pLLbUabEiG7Fssavf7PGJ/u7j/Q0fkTPC9Fg1qD6ciw+tSvs27Du4fWHK4+9evk7/8nA1/9X/yde7FPmUPd/7uY2iVPHnNd4YEU0joSK87Arq093E9bCCHEMUwXCkHq6J4OjPaxkjWEmqq3k/D6+0nfdhuZ3/8eUywSf/KTaXjFK4guWTL5/TkOOp9DGYOKRAjPnkWouVnSRYUQY5LgUJxwXDdFLrcVz0sRCtUSsqqv60ulHmL37usoFHeRDC9mnnoVyZplKGNj+l3OWHUjRhmUVqR+/mv6v/QNVHMdNZe9hoanv4CQXb3lhDEGPzWAUlaQQtraKiW+hRDiJGWMQafTuB0duD09YFnYtdVTRwG87m5Sv/wlmTvvBN8nedZZ1L/sZUTmz5/U/nQuhyk5GAN2TZLookXY9Q1YSUkXFUJMTIJDccLwvCz5wg5KTje2nahabAagUNjN7j3Xk0r9k0h4BnMjr6POX4pVX4dSCjteTzgXoeOtbx5a2D/7c5/Df8+bSD7pKURiY7ec0IUCJpcjPKedyLx5kqojhBAnKeP7eH19uLt24WdzqGgUu7F66iiA29lJ6tZbyf7lL6AUNc96FvXnn0949uxJ7c/PZqFYxGpuJrp4UZAuGo1O51MSQpwEJDgUxz3fdygUdlIsdmJZkTGDQtdN09n5U/Z3345txWirfzn16eXY8Vqs5IEP0Hi8jY63vHNYM+G9H/sY8667Dj+dqTq28bwghbS2htgZa7Hr6qpuJ4QQ4sSmSyW8ri7c3bvRno+VSBBqrp46ClDasYOBW24hf//9qFCI2nPPpf6lLyVUpX1FNYNBod3aQmTVSqmCLYQ4JBIciuOW1i7FYieFws5yBdLGqs3mtXbZv/+3dO79Gb5fpLXp32lxz8LKglVXOyzl0/g+JutUbSZstBk1dpAulAIgesoywjNmSAqpEEKchHQ+T2nfPryODlAKq6aW0Dh9Bp0nnmDgllsoPPggKhaj7iUvof5FL8JuaJhwX8YYdC4nQaEQYtpJcCiOO0EF0v3k8tvGrUBqjGFg4O/s3nM9jrOPurozaKt7GaF9PoRCWHXDexH6vQNkvv4T4u/6QPVmwtbwVCBdKKBzWcJtbUQWLJAUUiGEOAn5mUywnnD/flQohFXfMOZJQmMMxcceI3XLLRQffRSrpoaGV7+a2he8YFLBnQSFQojDTYJDcdwYrECaz2/F18UxK5AC5PLb2L37+2Qy64nF5rJ00cdIpFvxOvtQyRrUiLO5zoOPkf3WzzG+ptDfMW4zYeN5+OkUdjJJ4owzJIVUCCFOMoP9CZ1du9D9/RAZfz2hMYbCQw+RuvlmnMcfx2pooPHCC6k991yseHxy+5OgUAhxBEhwKI4Lrpsin9+G66WwrRoi4aaq25VKfXR03EhP712EQrXMn3cxzfGzKO3YjecPYNXVD/vwNq5H9ke/xvn937EXttP63vcRa5tftZmwLhTRmTRoTXTpUsIzZ0oKqRBCnESM1kGRmR078PN5rFgcu/nA2kAVi2JFIhitUZaFX3TI/fnPpG65hdL27dgtLTRddBE1z3nOpIrFSFAohDjSJDgUxzTfd8jlt5QrkMaJhKsv6vd9h66uX7B3360Y4zFr5kuZNfMV0JOh9MRWSCawE8PTSL3O/aS//iP0ji6S//FcWi68CBUOZiJHNhMOUkhzhGfPJrJgvlSAE0KIk4jxPNyeHtwdO9ClElYiOao/oYpFMY7DrosvPlDp+r//m8wf/4guFmm+5BJqnvnMUZkrVfdnDDqbBceRoFAIcUQdleBQKdUEfBJ4GTAL6AVuBz5ljNk9icevAj4OPAOYAZSAzcBPgK8YY9zDdOjiCPL9IunMo2i/RDhcPV3HGE1v31/Ys+cGXLeXxsanMaf9DURpxNm2A1MsourrRhWqyf/5fvLX/QYVDtP6oQ+SfMq/VT2GoRTSeILE2jXY9fWH5bkKIYQ49gxWHi3t2gVaB0VmamqrbmtFIkOBIZQrXX/0o7RffTXG8yfVdH5UUDh/lQSFQogj6ogHh0qpeuBeYHnFzbOBNwPPV0o9zRizc5zHLwLuByo7kIeA08uXFcCbpvmwxRHm+3lSqUcACIerB2SZzEZ27/k+udxmEolFLF70PmpqV+L19FDYvQkVDmPVDl8P6BdyZK+7Ffev64muOIXW97xvzBLjfiYDnkd08WLCs2ZN6oNdCCHE8U8XCrh79waBngKrpnbcGT9dLIJlVa10bSVrgoBvHBIUCiGOFUdj5vCTHAgMrwS+APwncDVBkPhl4JXjPP4CDgSGvwNeBywD/gzEgNcrpd5ljBn/nVgcszwvRyr9CApFKDT6w9Fxuti954f0999LONzEwgWX0dx8Dng+pa3b8AcGsGprhwVzxmic7VvJf+NW9L5+6l/1Khpe+cqqAZ8xBj3Qj1VTS2z5KZMqFiCEEOL452ezuHv24O7vRoVsrLq6cU8M+rkcmdtvJ/2b39D2uc9NqtJ1JQkKhRDHmiMaHKogL/CN5R/zwCeMMSXg60qp9wCLgJcqpRqNMf1jDONXXP+VMWYAeEAp9QRwGmAD0lPgOOV5WVLpR7BUiHC4CcuKABqwcN00ezp+SFfXr1FK0Tb71cya9TJsO4aXSuHuDCacR/aI8nSB4h1/o/jju7Brapn5qU8RX7Wq6v6N5+EP9BOeM4fowoUyWyiEECe46pVHG8esPArgp1Kkf/Mb0rffjsnniZ9xBtqyxq10PWqfEhQKIY5BR3rmcCEwmMO3pRwYDnqMIDgMAWuBP40xxk+B/wc0Ai9RSv2UYObwlPL9fzfG9E33gYvDz/MypNIPY6ko4XAjWjs88uhFFIsdxGLtrFjxBfL5bTQ1PZ057a8nEmnB+D6lPXvwurpQyRqs8IHWFsb4lDL7KX73DtwHNxI/4wxaLr10zHWDulBAF/LEVqwgPHPmkXraQgghjoKhyqM7d+LncljR2LDKo9V4vb2kf/UrMn/8I6ZUIvHUp1L/spcRXbQIoGqla1NR3EyCQiHEse5IB4eV37hTI+6r/HnGWAMYY3Yrpf4N+DXwAqByhvHXwMWHepDiyHPdNOn0w1hWHNuOYVmRocAQoFjsYOPGD3P6ad9F6+Ccgs7ncXbsgFIpaDpcPstrjME3OdzHd1K45jb0QJrGN76Ruhe+cMzWE346hbIsEmvXYtdWLzYghBDi+DdUeXTnTrTjVK08OpLb1UXqF78ge9ddoDXJZzyD+pe/nEh7+/CxR1S6HrpdgkIhxHHiWGplMXb+RuVGSs0CfsmBmcJKCwnWM+4d47FvB94OMG/evIM7SjHtXHeAVOpRbDuBbQ+2iNBDgeGgYrEDy4ri+w5edzduRwcqGhtWdEYbB8/P4v16Hfmb7iDU2srMz32O6JIlVfdttMYf6CfU1ER02TKsiGQkCzEWeQ8Vx7OqlUeT4wdopd27Sd16K7l77gHLovY5z6HupS+ddHbJUFBYcrBbJCgUQhz7jnRw2FVxvWHEfZVlJfePM8aHCSqSAnyz/PNM4DfAKuA2pdRSY0znyAcaY74DfAfgzDPPNFM6cnFYOE4vmcx6QqEklnWgd6DrpYnF2ocFiLFYO2hwtmxFZ7NB9bjyTKAxPp7OQqqE863f4azbQPLpT6f54ouxRvQ3HGRcFz+VIrJgPpF586ShvRATkPdQcTwaVnkUg1VbN2GvQWfbNlI330z+gQdQkQh1L3whdS9+MaGmpkntU4JCIcTx6kgHh9sJeho2A0uUUpGKdYcry/96wEPjjLGi4vr1xpgMkFFK3UGw9jABnAXcNK1HLqad4/SUA8PacuGZQHf3HfT1/41TV3yJDRs/MLTmcPXKayg88RimWMSuO3AuwdM5NB72+hSpa2/EFIs0v/Od1DznOWMWFPBzOXBLxFavIjxGKwshhBDHLz+bxe3owO3aj7KtCSuPAhQ3biR1880UHn4YlUhQ//KXU/fCFw77zJnMfnGKEhQKIY5LRzQ4NMYYpdQPgPcBceAzSqnPA68nKEYD8EtjTL9S6hzgrvJtPzDGvKl8vTLX8E1KqY0EaxTPrbh9rEqn4hjhON3lwLAeyzpQRKa7+w527LyW+vonYds1rF1zA8ZoKLkUtmxG6+LQTKA2JTyTI6zr8G+6j/5f3kZ43jxa3/teInPnVt3vUJuKRILY6jPGnFUUQghxfDKeR2nXLtzduydVedQYQ/HRRxm4+WacDRuw6upoeN3rqDvvPKxkcszHjaTzeXQ+T6ilmciqlRIUCiGOS0djzeGngf8gWBv4ofJl0D7g/RM8/mrgtQTB5TvLl0oPA3+ZjgMVh0exuI9sduO4geGSxR8GfEqZLpytW8H3UckaVCiEMRrPZFAqRKyvgYGrv09p82Zqzz2Xxje+ESsarbpf4/vogX5Cs2YTXbxowrQiIYQQxxc/m8XZuAldLGA1No27XMBoTeHBBxm45RZKW7ZgNzXR+KY3Ufvc52LFYpPepy4W0bksdn09iVPWjFkRWwghjgdH/NuxMSallHo68CngfILG973A7cAnjTG7J3j8I0qpswjaWZxNMGvoATsIqpX+jzHGPWxPQBySYrGDTOYJwuEGLOvAy29/9+/ZufObQ4GhZUWCaqSbN0M4ghUPZvh8XUDjELVnox/YTve3vgxA6/veR/Kss8bcr3YcdDZDdOlSwrNnj3sWWQghxPHFaI3b2YmzbRtWPIHdOPbaQOP75O67j9Qtt+Du2kVoxgyaL76YmnPOQVW0Q5qIdhx0JoNdkyR+2mnYDQ3y2SKEOO4dlamTch/Cy8uXsba5mzEqmBpjHgZefTiOTRw+hcIecrnNRCKNKHVg3cfwwPAjWFYYncsFgWE0hhWJoI2HZ7KEVC01ei6p7/2M7B/+QGTpUlrf855xK8f5mTQKSKyRM7pCCHGi0YUCxSeewE+lsOsbxlxXaFyX7F/+QurWW/H27SM8Zw4tl11G8ulPn3At4shx/EwaKxoltvJUQs3NUtBMCHHCkLw6cdgZYygUdpHPbyUcbpo4MMxmcbZsgVgMFQrj6gwKSNoLoDPP/q/+F+7u3dSdfz6Nr3nNmOmhg20q7PoGYstPGTPdVAghxPHHGIO3fz/OE5shFBrqVahiUaxIBKM1yrLwsjkyt91G6le/wu/pIbJoEa0f+ACJpzxlSkGd8Tx0Jo0KhYmdcgqhlpYpBZVCCHE8kOBQHFbGGPL5HeTz24lEmlHqwAdxtcDQz2RwtmxFxcuBoRkgarUSs9vI/+kv9H3/+6hYjJkf/zjxNWvG3q/r4qcGiMybR2T+fPkAF0KIE4gulXC2bMHbvz+YLSyng6pYFOM47Lr4YtyOTsLtbcz+3OfI//OfhFpaaH7724mvXTul9E/j++h0CiybyKJFhGfOlDXrQogTlry7icMmCAy3USjsnFRg6KXTlLZuRcUTwQdvLExT8ulYOoTXtZ/cffcRPeUUWi67jFBj45j71fk8xikSW7mScGvrkXiqQgghjhCvvx9n0yaMMYRahr/HW5HIUGAI4HZ0svdjH2PONddiPG9K+zFa46dTKAOR+fMJz5qFikQmfqAQQhzHJDgUh4UxmlxuC8ViJ+Fwy7CztFUDw1SK0rZtWIlkUJE0EqJGz6PjLe8YOvvb9sUvompqoVQac79+agAViRBfewZ2zeRLkAshhDi2Gc/D2bkTd/cerNpa7CpLBYzrDgWGg9yOTlQshslmJ7cfY9DpNMb3icxpJ9zeLssShBAnDVlBLaadMZpsdjOFYkd5jWG1wPDMA4HhwAClrVuHAkNXp6itWUrn5e8Zdva384MfxI6N3abC6+3BbmwMCs9IYCiEECcMP5Mh/9BDeHv3Yjc3Vw3Wsn/9K6WdOwm3tw27PdzehrImTiM1xuBnMvh9fYRaW0g++UyiixZJYCiEOKnIzKGYVsb4ZLNP4DhdRMLN4wSGHw4Cw74+Stu3Y9XUlgPDNGGrEVU0Vc/+Gm1G7TMoJ54mungx4TlzpJS4EEKcIIzWuHv24GzfjpVIYjeMXlKg83l6//d/yf3lL9S++MW0f+1rdLznPUNZJ+1XX40eJ+MEQOdy6EKBUGsLkfkL5ASjEOKkJcGhmDZae2Rzj1NyeohEmofdVy0wdHt7cXfswKqtQ9k2rk4TUrWof3bhLogTbm8bFiBWO/vrZzKgNfHTTx93HaIQQojji87nKT7+BH4mjd3QWLWwWPHxx+m56iq8nh4aLriA+le8AhWPM++66zDaoCyFLpUwRaf6PgoFdD6H3dhEYsVy7Lq6w/20hBDimCbBoZgWWntkMhvwvAEikeHNh6sGhj09uDt3YdXVoyyrHBgmUf/spvtrV1H7ghfQftVVdFx+edWzv8YY9EA/Vk0tsRXLsWKxo/G0hRBCTDNjDG5XF6XNmyESHWpRMWwb3yd1yy0M/PznhFpamPXpTxNbvjy4r+jgjxEMDtKOg8lmsOrqSJx+OlZ9vWSdCCEEEhyKaaC1SybzGJ6XJhwePnu3f//t7Nz1reGB4f79uLt3VwSGWWyVRD3YTc/Xria6dCmNF1yAisWqnv01noc/0E94zhyiCxdKmwohhDhBaMfB2bwFr6cHu6GhassIr7ub7quuwtm0ieTZZ9P8trdhJSeXBqpLJXQmg5WIE121ilBTkwSFQghRQYJDcUi0LgWBoZ+bXGDY1YW7Z89QYOjpHLaKoB7ooufqbxBdtoyZH/sYVjxe9eyvLhTQhQKxFSsIz5x5JJ+qEEKIw8jt7cXZ9DgoCLW0VN0md++99Hz722AMLZddRs0znzmpsY3r4mfSWJEIsRXLgwb2ltTkE0KIkSQ4FAdNa4d0ej2+LhAO1Q+7b2RgqKww7r59uB0dwwJDS4VRf99P79evJXrKKcz86Eex4vGq+/PTKZRtkzhjLXZNzZF4ikIIIQ4z47o427fj7t2LVVuHVaWXoC4U6Pv+98nedRfRZctoufzySZ0gHGpgb9tEly4lPGOGZJsIIcQ4JDgUB8X3HTKZR/F1aVKBodfZGXzw19ejVBAYKmWj7ttH7zXfIrp8OTP/3/+rGhgarfEH+gk1NRNdtrTqFwchhBDHHz+Vovj445hSCbupuWqKp7N5M91XXYW3fz/1r3wlDa98ZdV000pGa3Q6DRgiCxYEDezD4cP0LMTRZIyP52XwvByxWJukCQtxiCQ4FFPm+0XSmUcx2iUcGl7ZrWpg2NGBu29fRWCYDwLDv+2j95pvE1u5khkf+UjVojLGdfFTKSIL5hOZN0/SgIQQ4gRgfJ/S7t2Udu7EStZUbVFhfJ/UL3/JwM9+ht3YyKwrriB26qkTjh20N8oQmTuH8Ny5ckLxBKR1Cc/L4DjdlErdGDQYQyw2C5CZYSEOhQSHYkp8v0A6/QjGGEKjAsPfsXPXt4cHhnv24Hbtx6pvQCmFbwqgQN3TSd83v0ts1aogMKzSZNi4Ln46RWzVSsJjrD8RQghxfNG5HMXHH0fnghYS1U76eT09dF99Nc6GDSTOOovmiy/GnkTRGT+dQilF/PTTpL3RCcb3i7huCqe0D89NAaBUmFCoDqUsSqW+o3yEQpwYJDgUk+Z5OVLpR1AoQqHha/4GA8OG+iezePGHUCqEu3s3XnfPUIlw3xQxRqPu2Ufft/6X2OrVzPjwh8cPDFdKYCiEECcCYwzu3r04W7ZiRaPYjU1Vt8vddx+93/42xvNovvRSas45Z8JUQeP7+P39hFpaZPnBCcIYg+/ncd0BHGcfnpcFwLbjhEINkj4qxGEiwaGYFM/Lkko/gqVC2HZi2H1VA8Ndu/H6erHq6sqBoYMxHurPnfR/5/vE1qxhxgc/WD0w9LwgMDz1VAkMhRDiBKCLRZzNm/F6+7Abqze018UifdddR/bOO4ksWULr5ZcTnj174rHzeXSxSHTZUsKzZ0vQcBwzRuN5WUqlXhxnH9o4gEXITozqoSyEODwkOBQTCgLDh7BUFNseXjBmVGCIjbtzJ15f/1BgqI2DNiXU3R30f/d64mvX0vrBD1Y9szvYwzC2YgXh1tYj9RSFEEIcJm53N84TT4CyxmxR4WzdGhSd2buX+pe9jIZXv3riojPGoAf6seJxEmecgV0zuV6H4tiitYfvZ3CcHhxnf3AiWVnYdpKQNXFlcsuKYVkRbDtBqdRLJNKCUlKfQIiDJcGhGNdgH8PJBoalnTvRqRR2fVDBVJsSvnFQf9rDwPd+SPyMM5jxwQ9WrRo3LDCUHoZCCHFcM66Ls2077r692HX11d/3tSb9q1/R/9OfYtfVMfNTnyK+atWEY+tSCZ1OE5k7h8j8+RMGkuLYorWD62Vwil2U3F4wBssKEQolUWryBWUsK4bWDo88ehHFYgexWDunrf4ONTXLJEAU4iDJu6kYkzGGbG4z2pQIhxqG3bd//2/Zues7BwJDY1HasQOdSWPVBoVqtCnhmQLWnbsZ+P6NxM88kxnvf3/1Lwi+L4GhEEKcIHQuR3HDRrTjjNmiwuvtpecb36C4bh2Jpz41KDpTWzvh2H46KEYSO2014SZJNTxe+H4hKCjj7MN1U6AUlooQDtUfdCBnWZGhwBCgWOzg0XVv58wn3Uw0KtlHQhwMCQ7FmIrFDkpON5FI87DbqwaG27ejs9mKwNDFMwXUH3YycP2PiT/5ycx43/vGDgz7+4kuXy6BoRBCHOfc3l6cDRtRkQh2Q0PVbXIPPEDvtddiXJfmd76Tmuc8Z3JFZwb6CTW3EF26pOqadXHsCArK5MoFZfbi+XkUYFlxwuHGQ1ob6nlZBgYeoLn5WUOB4aBisQNtSod49EKcvCQ4FFW57gC53GbC4eGlwEcFhlrhbN+OyVUGhh6+ycHvt5P64c9IPOUptL73veMEhn1Ely0jMmvWEXluQgghpp/RmtKuXZR27MSur55Gqh2HvuuvJ/uHPxBZtCgoOtPePuHYulBAF/JElywh3CaNzo9VQUP6AwVljHFBWdhWgkj40GZ5PS9D/8AD9PfdG/RaNh51dauJxdqHBYixWDuWkmq1QhwsCQ7FKEGT+8cIhWqH5f5XDQy3bcMUCsMDQ53F3L6V9I0/J/HUp9L6nvdUXQ8yFBguXUqkre2IPT8hhBDTy5RKFJ/YjNfbg91UvXehs20bPVddhdvRQd1LX0rja15TNYAcNu5g0ZnYYNGZiQuUiCMrqDCaxnG6cZwuDD4KG9tOYlkTpwmPx3XTDAz8nb7+v5HJPIoxPtHITGbOeBGNTU8nGp3D6lXXsm79JcPWHI7MeBJCTJ4Eh2IYY3yy2Y3l1I/oUBUw389RV7+WttmvZfbslweB4dZtmGIBq6Z26LGezmB+u4XMj28m8bSn0Xr55eMHhkuWEJnEWWMhhBDHJj+bo7hxA6ZUItQcVCNVsShWJILRGqUs0nfdRfeXvoRdW8vMT36S+GmnTThuUHQmRXjuXKJSdOaYEgSEGUqlborFLgwelgoRCtVMqaBMNa47QP/A3+nv+xvpzDpAE43OYubM82lqfBqJxOKhmWNjHCwrxto1N2CMRyhUK9VKhThE8k4rhsnnd+C6aSKRpqpVwFavugZlwhS2rMOUSsMCQ1enMbc9TuanvyD59KfTctllVXtZDQWGixcTmTPnSD9FIYQQ08Tt7sbZuAkVj2PXNwBBYGgch10XX4zb0Um4vY3Zn/0s9a94BXXnnYddVzfhuH4mDdoQW72acLPMAh0LDvQg7KFYThlVTL3CaDWu209///3lGcLHCALCNmbPejlNTWcRjy8cM5VY6yJaFymV+mhuPlsCQyEOkQSHYojjdFMo7CJcXhdQrQrYuvWXcvop38G4LlYySO8xxsc1afSvN5L92a9Inn02Le9+d/XAUOsgMFy0iMjcuUfuyQkhhJg2RmtKO3ZQ2rULu75hWHqoFYkMBYYAbkcnez/+ceZddx1+OjP+uL6PPzBAqKmR6LJlUnTmKAuKymTLPQj3orWLUva0zBCWSn30D9xHf9/fyGQ3AIZYbA5ts19JY+NZxOPzZW2pEEeBBIcCAM/Lkc1uJFRRUtoYr2oVMGwLK5Esb6ODwPAX68n+/Dckn/lMWi69dOLAcN68w/+khBBCTDtdKlHc9Dh+f3/QpmLE+kKj9VBgOMjt6MRoM/64Q0VnFkvRmaNoMCAslXopFjvLAaGFbdcQCh3aGsJSqYe+/vvo7/8b2ewmwBCPzaOt7dU0NZ5FPC7fDYQ42iQ4FGjtksluKK8xDJdv83DdjqpVwCh/wBujKekB9K3ryN38O5LnnEPLO985dmDY10tkwQLCMmMohBDHJT+Tobj+MYzRhKqke+piEZ3NEG5vGxYghtvbUFb1YG+w6IyKxaTozFEy2HZiMCA0pgRY2HZyUgHhYH0C0ICF1iW0LgJBVlJ//3309d9LLvc4APH4AtrbXlOeIZTvBEIcSyQ4PMkZY8jltqD9wrC2FR2dPyKf386qlVex/rHLD6w5PPXrlPbtPRAY3vIouVtup+bZz6b5He8YMzDU/X1E5s8nMl/SRIQQ4njkdnVRfPxxrEQSOxYbdb/X3c3+L3wBq76eti9+ic4PfmBozWH71VejS6N7zxnXxU+nCLe3E12wQIrOHGGel8N1+ygWO/F1AaVsbCuJZU0+QK9en+Ab9PX/g337biKXewKARHwh7e3/SVPjWcGJ5mmgtYfvZwFNOFwHyHpDIQ6VvAuf5IrFThxnL+Fwy9BtAwMPsm/frbS2nItlJTl9+XfBUqANpX178fIDlPQA/k0Pkf/FH6j593+n+eKLq5YuN8bg9/URmTePyIIFEhgKIcRxxvg+zvbtuHv2YDc0Vg3gihs3sv+LX8R4Hq2vex1WXS3zrrsOow3KUuhSCVN0hj3Gz2RA+8RWriTc0jJqTHF4+H6eUqmPotOJ7+VRVhAQRsKJgxqven2Cd7F06ccxxmdO+xtobHwasdjsaTl+YzS+n0ObEkpFiMXmEI22YNs18h1DiGkgweFJzHXTZHNPEAk3Db2hlko9bN9xFfH4AubNu4jSvt24nR3YdfVAEOyVdD/+/z1I/ld/ouZ5z6P5bW8bOzDs7SUyby6RhRIYCiHE8UYXixQ3bUJnMtjNLVXfxzN33knvd79LqLWVGR/5CJH2dkzRwR8RDA4aLDpjNzYSW7YUq8ospJhevl+gVOrDcTrxvBwoi5CdPOR+gI7TDcqqWp8gmVjMylO/fEjjDwrSXvNo4wCKaHQmsehMQqE6qU4qxDST4PAk5fsO6cx6QvaBimPG+Gzd9mW0dlm8+IPgaNzOjop2FeXA8Gf/IP/ru6g97zyaLrpo/MBw7hwiC8cuQS2EEOLY5KdSFB57DJSF3dg06n7j+/Rdfz2Z3/2O2Omn0/re9064XnCo6MziRUHRmSqfH2J6+H4B1+2nWNyL52XKRWUShxwQlkq99PX/jb6+e8jlHmf16m9WrU+g1KF/xfT9Ir6fByASaSIWW0ooVI9lyddXIQ4X+d91EjJGD1UJs+0DZ2w7On5MNruRRQvfSyw8C+fxJ1DR2NCHt6sH8H58P4Xf/oXa5z8/CAyrBH2DqaThOe1EFi2SwFAIIY4jxhjcvXtxNm/Gqqmt2k7Cz2To/spXKK5bR92LX0zj619fdc155Zg6NYCKRkmsXYtde2hVL0V1xmgcZ385IEyhlIVlHXpA6LoDQwFhNrsRMEFRmfbXE7JrWb3qWtatv6RizeG1aD16jelkaO3i+VkwmlCojpqa5UQiDViWtDUR4kiQ4PAklM/vxPUGiIQPnAlOpR5i776baWl5Ls3Nz8Lt6MCUHMIz5hKPt4EGv6ef7o7bqX3BC2h6y1vGDgz7+wi3zSYqgaEQQhxXjOfhbN2Gt29vsL6wSsBX2r2b/V/4Al5PD82XXELtc54z/piui58aINzWRnThwmE9EcX08f082ezjuF4qWEN4yAFhmv6B++jru2eoMX0sNpe2ttfQ1HQ28YqiMpYVZe2aGwADqGHVSifDGB/Py2CMj2XFSCYWEYk0YdsHtw5SCHHwJDg8yThOD/n8DiKRA4FhqdTHtu1fIx6fx7y5b8PPZHD3dRGZNY+Y10THW945VHGu7corUXX14IxeSzIUGM6aRXTxYkkXEkKI44guFChu3IjO57Gamque3Ms/+CDdV12FikaZdcUVxJYvH3dMP5MB3yO2apUUnTlMjDE4The53BMoFSYSPvig0POy9A/cT1/fPaTTjwKaWLSNttmvDALCMfoQal2cUjAYHPdgYRkXRYhYrJ1otFUKywhxlElweBIJzipuIByubHTvs23bl9G6yOJFn8UyNsUdO1HJBPFE+1BgCEET484PfYh5112HXyU49PvKgeGSJRIYCiHEccTr76e4YQPYIeyGxlH3G2NI/+IX9P/4x0QWLmTGhz5EaJxgb7B3oVVXR+yUU6TozGGitUMut5VicR/hcMNQr+Kp8P08/QN/p6/vXtLphzHGIxqZyaxZL6O56enE49NXN8AYg9YFfF0EFNHITGIxKSwjxLFEgsOThNYemcwGlAoP+/Do6PwpmexjLFxwObH4XNwdOzC+h51IoLQa1sQYggDRaDNqfK+vl/DMGUSXSmAohBDHC2MM7p4OnK1bsGrrqq4v1I5D7ze/Se6ee0icdRYtl15adbuhMX0/yCKZMydIIx1nLaI4eK7bTzqzEdBEo61TeqzvFxgY+Ad9/feSSv0LY1wikRZmzHghTU1nk0wsmdbZO9938P0cEBSWSSYXlwvLSIqxEMeaSQeHSqkI8E7gTmPM+sN3SGK6BY3ut+L7BcLhhqHbU+lH2Lv3Jlqa/52WlmfjDQzg9fZi1Qfb+H6RcHvbsAAx3N6GsoZ/YPj9fYRnzCC6dKkEhkIIcZwwrouzdSvuvi7sxqaqQZzX28v+K6+ktG0bDa99LfUvf/m4QYMuldDpFNGlS4NqpJIeOO2M8cnnd1Ao7CIUqp10oRbfd0il/klf/z2kUg+idYlwuIkZrefR2HQ2Ncll0zp7N7ywTC01NcsIh5uwbSksI8SxbNLBoTGmpJT6PHDeYTwecRg4zj6KxQ4ikQMpQKVSH9u2fYVYbA7z5r0NUyrh7tiBVVOLUgrXy9L7ne8z+3OfY+/HPja05rD96qvRpQMVyPz+Puzm5iAwlLPDQghxXNC5HMUNG9GOM2Z6qPPEE+y/8kp0sciMD32IxJOfPP6Y+Tym5BA/7XRCTaNTU8Wh87ws2ewmPC9HONw0LJizrBiWFQE0YKF1Cc9Lk0o9RF//PQwM/AOti4RC9bQ0/ztNTWdTU7NiWgPCoLBMtlxYJkIivqDcoF4KywhxvJhqWulGYBHwl8NwLOIw8LwM2ewThMONQ2dwjfHZtv2raF1gyeLPYFlRnO1bwQ6hQiG0cXF+/3eKv/oDNWc8lXnXXYfRBmUpdKmEKTc29vv7sBubiJ1yigSGQghxnHB7e3E2bERFItgNDVW3yd59Nz3f/jahpiZmf+pTRObOHXdMP51ChcMk1q7FSiYPw1Gf3IwxFIud5HJbsO3YsKJyEASGWjs88uhFQ+0kTj31y2zb9lUGBv6ObdfS3PQMmprOprZ21VB/4+k6Nt/Po3URpULEYm1SWEaI49hUg8NPAlcppf5pjFl3OA5ITB+tHdLpddh2fFjD2M7O/yOTWceCBe8mHp+H292NTmew6+uDHkkdOyn+7G7iT3oSsZUr8dOZUWMPBYYrlktgKIQQxwGjNaXduylt34FdX1+1pYTxffpvvJH0r39NbNUqWt///nF7Eg5WqQ41NgYnCiORw/kUTkq+75DNPYFb6iUcbqga2FlWZCgwBCgWO9iw4f2cuuJKstnHqa09bdobx2vt4Pt5jBlsUL+sXPBOvhMcKUqpK4BPVdz0DWPMu0dscw1wScVN/2WMuWKK+zkHOKf84/XGmB1TfPxgsYo/G2POGW9bcfRN9Z3iw0AN8JBSagewl6CpzSBjjHnWNB2bOARBo/vNGDQhOz50ezr9KJ17/4/m5mfT0vwcdKGIu2cPVvnD3/VSON+6AysWo/kd76h61s/v78NuaCC2XGYMhRDieGBKJYpPbMbr7cFuaqq6PtzP5ej56lcpPPxw0M/2jW9Ehcb+mjBYeCYydy6RhQtlzflh4Dg9ZHObAGvcvoXalIYCw0HFYgfR6Cxse/pmcofSRvGw7QTJ5BLC4WZZR3jseINS6iPGmByAUioJvH4axj2HA0Ho3cCOaRhTHKOmGhz6wIbDcSBiehUKu3FK3UQr1hm67gDbtn+VWKyd+fPeDsZQ2rkDFYmiLAvfFHB/9Q+8rbtoff/7CTWOXjPiD/QHgeGKFeN+aRBCCHFs8LM5ihs3YEolQs3V1xe6HR10feELeF1dNF98MbXPe964Y2rHQWczRJctI9LWdjgO+6SmtUs+v51isYNQqK68lnA0Ywz7u39Lff2TiMXahwWIsVg7cOhpnaPTRmcTjc6QtNFjUx3wOuC75Z//s3zbUaGUihljisYYeaEcR6b07V6mgo8PjtNLPr+NSPhAcBf0M/wqnpdj2dJPYdtx3M5OTLGIVVuHMT7utl0Ubv0zybPPJvm0p40a1x8YwKqtk8BQCCGOE253N87GTah4HLtciXqkwsMPs/8rX0GFQsz61KeInXrquGPqXA7juSROP33MNYvi4HlehkxmA1o7hMPNYwZgrpti+46vk0o9yOxZKVavuoZ16y8dWnO4etW1aF2q+tjJ0LqE7+cwxpTTRpeOmdYqjgk7gfnAOzgQHL6j/O8OYMHIByilnkqQFXgW0AR0A3cAVwymjpYzBedXPOyuitfks40xd1emjQJfA64ATgX+G7hirLRSpdSS8v6fB8wG8sAm4DPGmN9O5cmL6SPf8E8wvl8gm9tQbih74A18796bSGceYcH8S0kkFqCzWby9+1D1dRhjKDl9FL91O3Z9PU1vfevocVMDWLU1xE+VwFAIIY51xvcp7dhBafdu7PqG6usLjSF9223033AD4blzmfmRjxBqHb9fnp8aQEUiQeGZhFSgnE7GaAqFPeTyWwnZScLhsSu+plIPsW37Vfh+jnlz38qMGS/EsmKsXXMDwWofhdYltC5O8Rh8PC+HMS52KEEisZhIpBnbjh3akxNHwg+AjwBnKKWeQjBtvBZwgesJArYhSqkLgB8DldH+bOCNwIuVUmcZYx6f4jGcBtwMTJhjXg5M/0CwXG1QBHgq8BRAgsOjZMrf8pVS7cD7gWcCzcCLjTHrlVLvAe4zxvx9eg9RTJYxPpnMRhShYSko6cx6Ojp/RlPTs2hpeS7G83B27IBkAqUsXJ3Bu/kfeHv2MvPjH8euqRk2rp/JYCWSxE89teoXDCGEEMcOXSxS3LgJnc1gN7dUnXnSpRK93/kOubvvJvHUpwaN7ePxKqMFhgrPNDUTW7ZUCs9MM98vkM1uwvVSRMKNY87Oae2yp+MGurp+RSw2l1OWXUEisaB8X3HKwSAEf1utC/i6iMIqp43OlLTR4083QWD2WoK+5IN/vJuBrsoNlVIJ4JsEgeG/CFJRtxPMIP6eYBbxi8BLjDELRhS+ebYx5u4xjqERuIFgNjBf/nks3+NAYPgt4LNAFngaIItYj6IpBYdKqZXAXwnWHt5HcEZi8BNiPkGk/7pJjNNEUPn0ZcAsoBe4HfiUMWb3JI+lDfh/wAuBdoIX4XbgRmPMVyb/rE4cudxWPC8zrMS16w6wbduXiUVnsWB+UGCm1NEJno8VT6CNg//4Hgq/+Su1555LfM2aYWMa1wXfC6qSSmAohBDHNK+/n+KGjWBZ2I1NY27T/cUv4jzxBA0XXED9K185bjEZ43n4qYGg8MyCBVJ4ZhoZY3CcbnK5TSgVIhIeu+hMobCbrdu+TKGwgxmt/8HcuW/Esg7+O7TWLr6fxRhDONJAMrmYUKhh2quaiiPqmwTB4atH3DYyV/zpBAEgwBkEqZwjjb/wuLoU8A5jTL7i51HK6aSDx7QVuNQYo8s/334Q+xXTaKrvAF8m6HV4HlAEKpPZ/wZ8YaIBlFL1wL3A8oqbZwNvBp6vlHqaMWbnBGOcTjAVXZn/EiEIVvPASRccFov7KBT3EAkfKDZgjGbb9q/heVmWrfgkth3HGxjA6+nGqm/AGI2XG6Dwrd8SmjGDxgsvHDWunxogduqpWDFJKRFCiGOV0Rq3o4PS1m2o2lqsaPWgwdmyJWhsn8vR+oEPkHzqU8cdd6jwzCmnEJk163Ac+klL6xK53DaKTifhUAOWVf0ErDGG7u7fs3vP97GsGEuXfJSGhqcc1D4r00YtK0YisYhIpEXSRk8Qxpi/KqUeA1aWb9pgjPmLUmpkcDhjEsPFlFLJwcqnk/R4RWA4npkjHqPH3FIccVMNDs8GXmuMyarROQ9dBLOAE/kkBwLDKwkCyv8EriYIEr8MvHKsByulQsD/EQSGJeB9wE0EQeEKDvyHOGkEje4fJxxqHJYCsnffzaTTDzN//jtJJBZiSiXcnTuxamqDGUSdwv3pA/jdPcz69KdHpRT56RShGTMmXIMihBDi6DnQpqIXu7FxzBZD2Xvuoffaa7Hq6pj9uc8RWbBg3HH9XA48j8SaNdj19YfhyE9erjtAJrMBg08kXD31N9guzY6d32Bg4AHq6tawcMFlw7KDJsv3C/i6AChi0SBtNBSqlbTRE9O3gK+Xr39zjG32V1z/rjHm7SM3UEopY8xgIRkz8v4xFCa5XWWa6ylKKUsCxGPHVIPD8f5wLUzwolDBu9Abyz/mgU8YY0rA18trFhcBL1VKNRpj+scY5nxgWfn6lcaYayrue6B8OWloXSKT2TCq0X0m8xgdHT+hqekZtLaciwFKu3eDZaFCITydxTyyj8Kd91L30pcSW7Fi2LjGdcFAdPFi+fAQQohjlJ/NUtywAeO6hJqHpySqWBQrEsFojd/bR/auu4gsXsyMD3xgwmDPTw1gRaPETls77lpEMTXG+OTzuygUdmDbtYTG6Q+YTj9Szv7JMHfOm5k588UoNfmUXq1dPD8LGMKhehKJhYTDjZI2euL7IfCc8vUbxtjmb0A/wZrANyql7gZ+DcQIvmOfT5CRd3l5+96Kx56mlPrLoQRzxpgtSqkNBKmli4GrlVL/DWQIlqjVGGN+ebDji0Mz1XeIBwjSP39d5b4LCNJFx7OQoIgNwJZyYDjoMYLgMESQHvqnMcb494rrTUqpR4GlBC/cm4CPG2OyExzHCcEYQza3GW1KhEMNQ7e7bpqt275CNDqTBfPfiVIKt6cHP5XCrm9AGxedzZP77i8Iz5tHw6tfPWpcPzVAbOXKMVOThBBCHD3GGNyuLpwnnsCKJ0a1qVCxKMZx2HXxxbgdnYTb22i78kpUMgmeP/a4WuMP9BNqbia2bJmsNZ9Gnpcjm92E52UJh5vGDPS0duno+BH7un5JLNbO0qWfIJlYNKl9BD0Js2jtYlkRkolF5WqjEuCfLIwxaeDlE2yTU0pdCtxIEAT+qMpmP6i4fn/F9auAq5RSHGL/wrcSLBFLApeWL4P+C5Dg8CiZanD4GeCPSqk7CMrfGuC5SqnLCYrLPHOCx1fmGI9cpFr583i50PMqrl9Scb2d4AzHU5RSzzDGjP3pd4IoFHZTcrqJRA6cLTZGs3371/C8FCtWXIltJzDFIt7uPeV+hhrPZHF/eA86nWHm//so1oiqczqdIjxrFqGW6s2ShRBCHD3G83C2bcPduzdoU1GlvZAViQwFhgBuRyedH/oQ8667Dj+dGXNcf6CfyPz5RObPl8Iz0yQoOrOPbHYzlhUeNy20UOxg27Yvk89vo7X1PObOeQv2OLOLlbR2cb0BotGZxGNzyi2tJPNHVGeM+Um5h+H7CZaNNRPMJu4E7qQiYDTGPKiUuozge/Y84JDPGhlj7lNKrSFov/FcoI0DfQ5PqizAY82UgkNjzJ+VUucTNLj8fvnmzxM01zz/ENtYTPYdrPIFuYvgBZUFbiOouPQ04KXALaN2oNTbgbcDzJs3b+TdxxXXHSCf3zqqD9K+fb8glf4X8+ddTDKxCKN10LYiHEZZFq5OwQN7Kdz7AA2veQ3RRcPPRupSCZQismiRfKgIIYY5kd5Dj1c6n6e4aRM6n8duGrtBui4UhwLDQW5HJ0ZXXzqkHQedyxJbsYLwzJlVtxFTp7VDNreZkrOfUGjslE5jDD09f2TX7v9FqQhLFn+ExsbxiwVV8rw0xvjU1qwiGm2Vz++ThDHmCkb0Lxxju28RrEUceft9jFPnY8S2X+fAWsaR9437ghvrfmPMFoIZRHEMmfJpQWPMb4wxSwlyks8GVhhjFhljfjeJh1cuQG0YcV9dxfX9jK2n4vrNxpjNxpi9BDnWg86o9kBjzHeMMWcaY85sPY6LrPh+kXTmsfJi8gOFBzKZjezpuJHGxrNobX0+AF5XF7pQwIrH8U0BNeCR/d4tRJYsof5lLxs2rjEGnU4RPeWUUbOJQghxoryHHq/c3l7y//oX2vWwGxqrBgBGa/p/9jPcXbsIt7cNuy/c3oayRj/Gz2YxTpHEmjUSGE4jx+mlf+BBXHeASKR1zMDQ8zJs3XYlO3ZeQzK5jFUrvzbpwNAYn1KpF9tO0tDwZGKxGRIYCiEOyVT7HNYMrucrR/tbpri/7QRrA5uBJUqpSMW6w8Eqox7w0Dhj/JOgh8t4JlNG97hkjE82uxEFw/obeV6ardu+RDTayoL5l6KUQudyuHv3YtXVBeWrtYP7vT9gSiVa3/3uURXt/NQA4dlthJvH7rMkhBDiyDJaU9q5k9LOXdj19WOuA/RzOXquuorCv/6FVVND+1VX0XH55UNrDtuvvjrIDql8zEA/VjxO7NTTpPDMNPG8HI6zl3x+N+Fw7bi9CNPpdeWiMwPMmfNGZs186aSLzvh+Ht8vkEwuIRZrm1KxGiGEGMtU1xz2K6UeBO4iKBhzrzFmsmVrMcYYpdQPCNpPxIHPKKU+D7yeoBgNwC+NMf1KqXPK+wH4gTHmTeXrPwU+B0SBVyilrgVywBsqdnXnFJ/XcSOf34HrpoetWQj6GV4drDNc/nlCoWSwJmXHDlQ8AShck8L6SyfFfz1M05vfTLi9fdi42nGw7BDRhQuO7BMSQggxJu04OE88gdffj93UNOY6wNLOnez/4hfxenpoetvbqD33XFQsxrzrrsNog7IUulTCFB2gXHimv59QawuxpUul8Mwh8v0irttHsdiB5+VQlk0kMk7ar/bo7PwJe/fdQjQ6mxXLv0AyuWRS+zJG47oDhEJJGhrOJBSqmc6nIoQ4yU01OLwEeDbwJoIFpCWl1AMEgeJdwH0jKpBW82ngPwh6HX6ofBm0j2Bh7JiMMR1KqQ8S9EWcB2wescn3DnHt4zHLcbopFHYRDg9fzL6v61ekUg8yb97bhj5c3H37wHWxauO4OoPdoxj44c+JrVpF7QteMOzxxhh0JkP89NNQkk4qhBDHBD+dpvjYBozRhJrGzujI3XsvPddeixWPM+uKK4gtD1oJm6KDXw4GKxnXxU8NEFmwgMi8eVJ45iBp7VAqDeA4nbhuGqUUlpUYViSummJxL9u2fYVcfjMtLc9l3tyLJl1N1PcdfD9DPL6ARGIeo1tOCyHEoZlqQZrvAt8FUEqdCpxD0EvlEuATQJGgJO14Y6SUUk8HPkXQR2U2Qarp7cAnjTG7J3EcX1dK7SEIJNcSrJ3cUD62b0/lOR0vfD9PNruRUKh+WOpINvs4HR030NjwVGa0/gcAXiqF19WFVd+ANg4Yi/y3bwGlaLn00lFfBHRqgPCcdkKNw4vbCCGEOPKMMbidnThbtmAla7Bjserb+T79N95I+te/JnrKKbR+4AMTvo/rYhGdzxE79VTCM8YrDC6q0drF81IUi3splfoAsO34pBrTG2Po7f0TO3d9F6VsFi/6EE1NZ01qv8YYPC+FUjb19WsJhxsO5WkIIcSYDqUT6k5gG0HvwkVAC0FwOCFjTB9BOdzLx9nmbsapYGqMuRW4dfKHe3zL53eilI1lHUj9CRaxf4lIuIUFC96FUgrjurg7d6KSNYDB1wW4YyfOho00X3IJoRFFJLTjoEIhovPnH+FnJIQQYiTjujhbt+Lu24fd2DRqbfggP5Wi+6tfpbh+PbXPfz5Nb3zjhKmhfiaDwpBYuxa7tvZwHP4JyRgf103hOPtwSj2AwbZihMPViwJV43lZduz8Jv3991Jbs5KFi95DNDK5ok6DAWk02kYyuRDLkgwfIcThM9WCNM8hmCl8NvBkgmDwrwS9UN7K+IVkxEEKFrd3DUsnNcawfcfXcd1+li//H0KhGgxQ2hVMvFrhMCU9QKQrRM9PbiJ+5pnUPPvZw8Ydlk4q602EEOKo0rkchQ0bME4Ju7llzMDD2bKF/V/6En4qRcu73kXNOedMOLbf34eVTBI79VSsMWYixQHGaDwvTdHZT8npwhgfy4oSHpG9MxmZzGNs2/41SqVe2tv/k9mzXj7pdFDXTYPS1NYGLSqEEOJwm+rM4R8JKoF+m6CozIMnQ7P5o61Q7ECp0LAvCl1dv2Zg4AHmzr2ImuRSALzeXvyBfuyGRjydI+QnSV97PVY8Tss73jHqi4Ye6Cc8d46kkwohxFHmdnfjbNqEisawGxrG3C7zpz/R+93vYtfXM/uznyW6ePG44xqt8fv6CM+aSXTJElToUBKGTmzGGHw/i+N0UyzuxeBiqfCotlHjsaxYeWZPA4p9Xb9h+/avEY3OYMXyz1NTs2ySx+LjugOEw03U1CzDtiWgF0IcGVP9lLgVeCbwHoLZw7uUUncCfzXGZKb52ATg+wWc4t5h6wuy2SfY0/FDGhr+jZkzXgSAKRbxdu/Gqq1DGxfQeLc9RGnrVlo/8IFRXzZ0sYiKRolKI2shhDhqjO9T2rGD0p492HVjt6kwrkvfddeRueMOYqtX0/qe92DX1487ti6Vgt61ixYRnjtX+t9VEQSEOUqlXorFTrQuoZRNKFQz5WIvlhVDa4dHHr2IYrGDWKydFcs/z5w5b2JG6/MmXXTG83Jo7VBTs5RotE3+bkKII2qqBWleAaCUWkMQHD4buAhIKKX+BdxpjPnYdB/kyaxY7ERZ9lAai+dl2brtS4TDjSxc8O5gnaExODt3QSgMloVv0oR3hem5+Zckn/EMkk8d3kzXaI3JZomvXSPppEIIcZToYpHipk3oTAa7aey2B15fH91f+hLOE09Q99KX0vi61425FnGQn8uBWyJ22mmEmyYulnKy8f08pVIfRacT38+jlI1tJQ+pLYRlRYYCQ4BisYONmz7C2jU34HnpCR9/oEVFDXV1qwmFxq3vJ4QQh8VB1a82xjxsjPkq8CrgAuDPwFMI2luIaeL7DsViByE7+LAK1hl+A9ftZfGiDw59iHldXeh8DisexzMZIn4zqWuux66vp+mii0aNq1MDhOfNnfCssxBCiMPDHxgg/69/oQvFoPDMGIFhceNG9n7oQ5R27aL1fe+j6cILJw4MB/qxbIvEGWdIYFgh+Ezdy8DAP+nvf4B8fhsKm0i4mXCoYVjBt6nwvBw9PXfhuv1DgeGg4GcziWML+iTG4/Oor18jgeExTil1hVLKjHO5/iDGvHvw8VX2dYVS6k0THMc5k9jHjpHjH4rB8UZcHKXUFqXUVUqploptF4zYzldKZctj3K6UeptSSvKnjwFTLUgTAp5KMGP4nPL1CNAD/JwDTevFNCgWOwGw7SSWFcH3c8yd+0Zamv99aN2CzudxOzuxauvwTQFbxXB+/hfcPXuY+fGPY9cMPwuqCwVULEZE0kmFEOKIM8bg7tmDs20bVk0tVjQ65naZ22+n7/rrCbW2MvuTn5zwfdv4Pn5/f7C+cPFiyQwBtC5V9CJMTboX4UR8v8DAwAP09d9LKvUvjPGoq1tFLNY+LECMxdoZp/B6uUXFAJYVob7+DMJhOWkrRvlU+d8/A9cfxeOYrAiwGLgMeJFS6kxjTH+V7SyC9ndJYD5wHnCZUurFxpgdR+pgxWhTXXM4AMTL//6FoIH9XcaY9dN7WELrEoXibqKRGaPWMKxedS2WFcV3czg7dqBicVAG35SIblb03fYbas87j/iaNcPGNFqj8zkSa9dKUQIhhDjCTKlEccsWvP3d2I2NY84Aaseh9zvfIffnPxN/0pNouewy7OT4M0nacdDZDNEliwm3t5/069R8P08+v51SqRdjzKR7EY4/pkMq9SB9/fcwMPBPjCkRDjcxo/UFNDWdTTQ6h9WrrmXd+kuGfV5rXao6ntYlPC9NLNZGIrHooGcuxVH3X8aYKw51EGPMOYd+KEfVQmPMjnIf9F8CSwha3b0b+PSIbXcaYxYopZIEmYefBc4CVgG/VUqtNcY4R/DYRYWpRgifAv4EPGyMmbZpaTGa4+xHETTXfejhC4etYVi3/hLWrrmB4t4tUCph1dbh6gHipVn0XvvfhGbOpPHCC0eNqVMDRObPx66rO8LPRgghTm5+NktxwwaM6xJqaRlzO3f/frq/+EVK27dT/6pX0fCqV6Gs8VeA+Nks+D6J008ft9LpycAYg+N0kcs9gVIhQqGGQwqUtS6RSv2Lvv57GRj4B1oXCYUaaG15Lk1NT6emZsVQTQBjHCwrxto1NxCkkiq0LqH16BbQrpcGDLW1q4lGx349iOObUurfgfcSBD0tBLNqXQSzgFcYY7ZUbHs38CwAY4wqp5FeVzHcsypSQv9cJZhMKqW+BryGYCLn78ClxpjNExzj24CLCQK5JEE24AbgRmPMD6b2jMEYs0Ep9U3gy+WbnjLOtjmC4pbnAo8D7cAK4M3At6a6bzE9plqQ5ssTbyUOldYu+fwObLsW0FXXMBjt43Xtx6qvx9UZwlYTuRt/jdfdzazPfGZUHytdKGDF40Tmzj2Cz0QIIYSfSlF45FFUPI5d3zDmdoVHH6X7q1/F+D4zPvIREmeeOe64xhj0QD9WTQ2x5cux4pOrhnmi0tohl9tKsbiPcPjg1xBq7ZJOP0xf3z30DzyA1gVCoTqam59FU+PTqa1dOWYlU62LVYPBA/d7eN4AkUgryeRSbLt6WrE4YTwZeOGI2+YA/wmcq5Q61RjTM037+h4ws+Ln5wG/VkqtMsZ4AMaYBZUPUEq9CvjOiHHaypcUMOXgsGxKNU2MMTml1DXAf5dvejESHB41U84tVErNBt5PcHajCegF7ga+YozZN61Hd5IqlbrLDXdDGKOqrmEwRQeVTGAIym6rR3vI3nkndeefT2z58mHjGd9HF/IkzjhjwkIGQgghpo8plShu2IhKJsddX5j+5S/p//GPCbe3M+NDHyI8e/b44/o+fn8f4bY2oosWnfRLBVy3n3RmI6APqlm81h6ZzLpyQHg/vp/DtpM0NZ1FU+PZ1NauxrIO7XfseVmMcampWU40OuukT/3d99//jbNx01E9huiK5cz66EcPdZhPKaU+NeK2lxljfgH8AbiXYFasD6gl+A79MaAVeD3wtWqDGmOuB66fYLawUhFYA+wH7iSYgTuFIEC9b4zHPLP8bxZ4ErADmAX8G3BQC2CVUisIZiIH/X2SD618MSw4mH2L6THVgjTLgHuABoIX+xaCF9HlwBuUUs+YaPpajM8Yn1x+B6FQLQA9vXexYvnn2bjpIwfWMJz69WCtYSiEq1PUlObS9a1PEJ43j8ZXv3rUmH5qgOiCBaOK0wghhDh8jDEUt2zBaB97jMBQFwr0XHMN+fvvJ/G0p9FyySUTzgBqx0HnskRPOYXwrJM7yDDGJ5/fQaGwC9uundJMnDE+mcxj5YDwPjwvg2XFaWz8N5oaz6au7vRpWQdojI/rpQiH6qipOR3bThzymOK40QF8EjiXYMZw5Av0lGnc15eMMY8AKKV+SxAcQlDsZazgcHv53yTwceCfwEbgDmNMaor7317lvWgHcM0kH39QHRTE9JvqabAvEEwzP6WykpBSaj5wR/n+l0/b0Z2EHKcHY1wsqxatHXbuvIbmpmcPrWEwnk/hiY0Y28c1aRKhOaS++RP8TIYZH/3oqOp0OpfDrqkh3N5+dJ6QEEKcpNx9+/D27yfUUn0my+3sZP+VV+J2dtJ44YXUveQlEwZ6fiaNAhJr1pz068c9L0s2uwnPyxEONw2t/RuPMZpsdiN9fffQ1/83PC+FZcVoaHgyTY1nU1+/FsuKTNsx+n4Bz8+RTCwiHp87qWM8WUzDjN2xompBGhX8se8ETh3nsdOZC/54xfVcxfXx2kNcS9B54OXAheULgKOUusIY8/mDOA4X2AP8BviMMaZvko+rTHvbPuZW4rCbanD4bOAdI0vMGmN2KqWuIHiRiYNkjCaf3zbU17C754+4bj/1DWfgeWmM41DcuBEVT+Brh7Cqxbt/K7l776Xhta8lunDh8PF8H+04JFaulHRSIYQ4gvxsFmfzFuzG6hUy8w8+SPfVV6Nsm5kf/zjx004bd7yh9YV1dcH6wjFmIk8GQdGZTrLZLVhWdFQVUsuKlQM8DVj4vkMm88hQQOi6feXWEWeWA8InTfvavwMtKqI0Npw5lA0kTiqncSAwfIxg7eEu4EXArw7D/tyK65MqGmmMKQIXKKXqgNXAMoKU0H8D/lspdYMxpmO8MSosPNgWFEqpGuDSipsOx+9HTNJUg8MIkBnjvkz5fnGQSqU+tHYIhWrQ2mXv3luoqTmVutpVwYfhrl1ghzC2wRhNNFvPvv/9HyJLl1J//vmjxvNTA0QXLsSukWa6QghxpBjPo7hxI1Y8PurEnNGagZ//nNTPf05k0SJaP/ABwjNmTDieP9BPZO5cIgsWnNQn+3zfIZfbTKnUTTjcOKowjGXFRrV/WrHiC3R0/pRMZj319WfQ1Hg2DQ1Pxranv4CPMT6+n0Nrl3i8nXh84SGvVRTHLa/iukOwrm8e8P+mOE4v0AzMV0o1jtEz8KAopV4BzCaY4XykfHkqQXCoCFJhJxscHsz+EwTVTP+nfBwQVEo92EI4YhpM9R3rYeDdSqnfGWP04I0qyIO5pHy/OAjGGPKF7djlWcOe3j/hur0sXHgZAF5PDzqbDdpWmAGS9hL6v/VNTKlE67veNerLgp/LYdfWSTqpEEIcYc727ZhiEbuxCRWLYkUiGK3BQO/3v0/q5z8nec45NL/tbRPOAOpCAV0oEFuxgvDMmeNue6JznB6yuU2AIhKp3v7BsiJDgSEE1b03bvwwq1d9A8/LEwpN/8lSYwy+n0cbB1BEo7OIRWcRDp/cab+CTQTr91YAZxC0iACYam2O+wlmHRcAfeXU82nprVg+ts+Mcd9e4NFp2Ec18ysK7VRaB7xEehweXVMNDj8N3AZsVEr9jOCFMwt4FbCU0eV6xSS5bj++nyMSbi7PGt5EMnkKdbWnYVwXr6MDK1mDZzLE7FmU7v4nhX/9i6a3vGVUAGh8H+M4xFatnLA/lhBCiOnjdnfjdnRgN7egYlGM47Dr4otxOzoJt7cx+7OfJbpsGfE1ayZeX5hOoSyLxNo12LUnb1pi0N5pO8ViB6FQ3ZhrAo3x8bxs1fZPoVAdwUTI9PH9Ir6fByASaSYWW0ooVC8zhQIAY4ynlHoJcDVwNsHs4Y+B35Uvk/Vughfv04DGaT7MwaqmTyH4Ph8nqHb6Z+CTxpjCNO+vkgEKBEHzJuAm4IZyqqs4itRUetkrpVoISuJ+muAsiCL44/4T+IQx5veH4yAPhzPPPNM8+OCDR/swgOCsYyr1EMZ42Hac7u4/sGPnNSxb+knq68+gtGsXfn8/JhkGFPG+JvZ+4INElyxh5ic/OSoA9Hp7iS5ZTERmDYU4GRyVUpXH0nvosULn8+T/+S+smhpUOIxdV8uuN78Zt6NzaJtwexvzrrsOPz3WCo0g9dQf6CfU2Ej0lFOwIifvig3Py5DJbCgvuRi7ob3jdLF9+9UsWPguNm/+7Kj2T2vX3IDnpQ/5eLR28fzgbxey64jF2ohEGrCsk3cN6Ang5C33K0QVE57eUkFC/yeA9xD0Z/EJZg9fSvAfqt8Ykz+Mx3jC87wUnpcmEmnGGJ+9+24ikVhCXd1adC6H390DdTX4JkedfQrd114JlkXLpZeOCgz9bBa7oX7CHllCCCGmj/F9io8/AeHwUNVoo/WwwBDA7ejE6LFPyhrXxU8NEJk/n8j8+Sdt9ocxmkJhD/n8Nmw7QThcfcLEGENv793s3BX08S45faxedS3r1l9yoP3TqmvRunQIx+LjeRlAY1kxkonFRCJN0pJCCHFCmkzuwzsIerTcDfwDWAS8DEgZY958+A7t5JHP78CygkrDvb1/wXG6WLrkIgBKu3dDPI5vciRCc8n97i6cDRtovvRSQq3Dy6MbzwO3ROy01SftFwohhDgaSrt24WfShJqaD9yoDeH2tlEzh8qqPlGh83mMUyS2ahXhlupr6k4Gvl8gm90U9AYMN4wqOjPI89Ls2PlN+vvvo6ZmBYsWvododCaWFR1q/wQKrUtoPbVMNWN0UFjGuChCxGLtRKOt2HbNSd1XUghx4ptMcPg24LvGmIsHb1BKXQx8Qyl1sTHm4E/HCVw3jesNEAkHs4ade39OIr6Q+von4/X1ofMFVF0SRQjVWaD/xz8m/uQnU3POOaPG8lMDRJctw0rI2UwhhDhSvP5+Sjt3YTcdaKlgtKb3+99n9mc/x96Pf2xozWH71VejS6M/Nv3UACoSIb72jJO2wnTQoqKbXG4TSoWIhJvH3DaV+hfbd3wdz8swp/0NzJr10qEgUuvilIPBwf1rXcDXRUARjcwkFptJKFQn/QmFECeNyQSHi4APjLjtZ8A3gflMveqSqFAo7MJSwVqFvr57cJxOliz+CPg+3p4OrGQSYjEaE2vQKs2cq76G1dQ86syln8lgNzYRnjXraDwNIYQ4Kely/1mrtnZYxkb6tttI3XQT0VNOYd5112G0QVkKXSphigcK8Rnfxx8YINTaQmzJEtRJur5Q6xK53DaKTifhUAOWFa66ne877NnzA/Z3/5ZYbC5Ll36CZGLRIe3b///t3XmcHVWd///X5+69L9nT2SEhARLCIq4jojMK7ox+1VGZUVHGDUZ0vqgjCoKOy3eUAcVRZwZQBxfEbX46KuqIuyKiQiAkIXt6ydrb3W9Vnd8fdTu53X073R16S+f9fDzq0ber6lSdc9M5937qbH4B388QzoLaQl3daeWJZarnQURkNhtLcFgPDB3FPTCS/tSdPm0CeF6aYvEQ8XgrzgV0dH6dmpplNDdfGI5LcQGx+mZq/Lnsu+LKQU+eLZk8+gXDeR54HqnVp6u7i4jIFHFBQGHrVoBBS1IUtm2j+667qL3wQmo2bhxx8pmgWCTo6yW5ahXxpUtP2fq7VOqlv/8RHAGJ+NwR34dM5nF27LyZfL6dBfNfxJIll484c+lowoll0uACYrEG6uvXEI+3Eo1qYhkRObWNdb7lNjOrfDQXrdjfU3mic27HRGTsVJDL7SMSiWNmHDnya/L5fZy26h9x+QLegQNEGpuoqVlExxVXHR2zUmrvoP3qq8PZ7srBod/TTWrdOiI1E7+gr4iIVFfq6MA70k1szrHuj0Emw8Gbbyba0sKct751xEDHz2TKY8Q3EK/ojnoqcc4nm91DLreLaLSB2AiBmXM+nZ3foKPza8RizZyx5oM0Np5zQvfzvDTO+UQiCWprVpBMztXEMiIiFcYaHN4zwv5vV9lXfeS4DOL7WQqFropWw7tJpZbQ3PJUilu3Y4kkDh9zsePOduf39RGbO5fY/PnTUQwRkVOS39dHYft2os3HZtF0znHos5/FO3SIhTfeSLS+vnranm4iNTWk1p93yo4R97wM6fQWPK+feLx1xDF9+XwnO3b+K5nMFlpb/4Lly/6eWKz6+1pNOLFMliAoYBYnlVqsiWVERI5jLMGhZiSdBLncPsximBnd3b8jl9vNqpXXEPT0EaTTRJubKQU9uHRuxNnuXKkEgU/ydHUnFRGZKq5YDMcZ1tVj0WPPQ9M//jHZ3/yG5te8htTatcPT+T5+dzfxhQtInnba0SUvTiXhpDNdpNPbiETiJBLVW02dcxw69GP27P1PzCKsWvlO5sx55pjvc2w9QiOZmF8xsYyeX4uIHM+owaFz7gtTkZFTie/nyee7iMebcM7R0Xk3yeRiWhqfQuGxrUTq6wmch8sGHPj0LSz6yEfofO97h8125/f2kDrzTCKp1HQXSUTklOCco7BjB87ziNYda8Eq7tnDkTvuILVhA00vecmwdEGhQJDuJ3n6acTb2k7JB3pBUCCd2UaxcIBYrIVIpPpXkFKph127P0NPz/00NKxn5cqrSSbmVT23evo+wKe+bg2JxFxNLCMiMg5j7VYqEyif78AihlmEnp7fk83uYOWKq/EPHALfx2IxvKAH7+u/I/e73+G//vXDZrvzDhwgNn/+sLUORURk8pT276fU1UVs7rG6NygUOPjJT2K1tcy7+uph68wGuRyuWKD2nHOINjdPcY5nhmLxCP3pzYAjcZxAr6fnfnbuug3fz7J0yRtYsOCFY15GIghKeF4vicQ86upOJxrVg1MRkfHSwj1TLAgK5PP7iEUbwlbDjrtJJhfQUnshpQMHsPp6AlfC33WY7I9+TsPznke8tRW/r58gnQ5/9qfBEXZLOgWfPouITAc/naG4ddugcYYAR26/nVJ7O/OuvnpY8Od8nyCXpWbDhlMyMAwCj0zmcXp7/0w0kiQea6p6nu/n2LXrNrY9/s/E4y2ceea/sHDhi8ccGJZKffh+mvr6dTQ0nKXAUKaEmT3dzL5qZnvNrGBmvWZ2v5m918wahpy7wsxcebtzmrI8Iwx5L+4bw/n3VZxfbXvdJOf3pWZ2Q3lrnsx7zQRqOZxi+XwXAGZRensfJJPdxvLlb6PU0YXF45hFKHq9FO78MZHGRppf9apB6Z1zYXfSs84aNHW6iIhMHud5FLY8hiWTWOzYR2f6l78k/ZOf0HTZZdRs2DAsnd/dTXL16UQbTq2Vn5xzlErdZLKPE/h5Eonh6/MOSKe3sGPnv1IodLFw4WW0LX71mLuChq2FPcQT86ivW62gUKaMmd0AXD9kdwJ4Unm7wsye55zbPtV5kwn3UuDvyq/vBHqmKyNTQS2HUygIimRzu4nFGnHO0d7xNRKJeTTHziXo6yNSU0vgSng/f5TStp20Xn450bq6wdfo6yW+cCGxuXOnqRQiIqeewq5dBNkskYo6udTZyeHPfY7kGWcMe5AH4Pf1Eps3l/jixVOZ1WnlXEChcIje3gfo638InBGPt1QNDIPAo739y2x+7L0457H2jA+xdMnfjTkw9LyB1sIzaWw4W4GhTBkz+z8cCwz7gJcBNcAK4Bvl/acB37QZPguShU5swdDpcbFzzoZsd053pp4oM5sxFZiCwylUKBzACFsN+/sfIpPZwsIFl+G3d2G14ReOUv9h8l/9X5Jr11J30UWD0gfFIpiRWLVK3UlFRKZI6dAhSvv2EalctqJU4uDNN2ORCPPe8Y5Bs5ZCOA7RLEJy9epTor52ziefP0BPz+/p79+Ec0YiPmfEgC2Xb2fzY++ho/Nu5sy5iLPO/FcaGs4a072CwKNYPEQ01khz84WkUgtPifdYZpQPVLy+zjn3Tedc3jm3G3g10FU+tgEYPkMVYGavNrNHyt1RtwztGmlmK83si2a2x8zyZtZjZpvM7E4zm19xXsrMrjOzh80sa2YZM/u9mb1hyPWeVdEN80Yze5+Z7QI84C0Vxz47JF3lsTdU7H+1mf283JW2YGZbzezDZlY7JH2Tmf2HmXWbWZ+ZfQVYMLa3efzMbJ2ZfcnM2s2saGYHzOweM9sw5LxXmtmPyl2Cs+Uy7DCzz5rZgorzHMdaDQF2VrwfK4a8rzdUpBtpf2UX2bPN7F4zywA/qDjnEjP7oZkdKZdhl5l9yswGtQyV7/FDM+sqn3fQzH5rZh99Iu+hupVOkSDwyGbDhX4BOjruJh6fQ3OwnsA7fLTVsHD3L3CZHHPe+MZBH3bOOYK+XlLr1xNJnEwPeERETl5BLkdhyxaiTc2D6uTuu+6iuGMH8669dtjEYM73CdL91G7cOOvr6zBQO0g2u5PAlYhF60kk5ox4vnOOgwe/z959d2KW5LTTrqW15Wljvp/n9eGcT339OpLJBQoKZcqZ2SLg7IpdX6w87pwrmtlXgXeUdz0X+OaQyzyXwQHHGuAOM4s4524v7/sucGbFOUmgCTgL+BfgQDkQ+1/gyUOufwHwn2Z2nnPu7VWK8Vag8j/qn4E/AucCLzezq5xzpfKxvyn/TAN3A5jZp4Ch110N/BPwXDN7pnMuZ+F/0G8Dz6o471XARUwCM3sGcC9hK+6AeYQtuy8ws+c6535R3n8x8JdDLrES+HvgWWa2wTlXnIx8VriPwf8OmNm7CP99Ky0nfL9fYGZPcc4dMLNlwP8wuKxzy9vpwHtONFMKDqdIsXgQ53wikRh9/ZvoTz/C0kWvw+86TKS8UHJh+3aK//sgjc9/PokVKwalD/p6iS9aTHzOyB+6IiIycVwQkN+6FSLRQWsSZh94gL7vfpeGSy+l7sILh6Xze3tIrlxJtKn65CuzQRCUKBQOkM3uwjmPWKyBWOT44yqLxSPs2vVpevsepKnxPFasePuI6xwOv58Xji2Mz6G+fjXRaM3oiWRG27r1pvIMttOnoX4da9a8f7zJllW87nbO9VY5Z+cI5w9YRBgcfgt4EXBXef9HzOxLQCPHAsNbgfcSBoenAZcAA/e8mmOB4dsJx8PVALcBrwDeZma3O+ceHHL/OeW0XyjfKwfcDnyqfOy5wPfMbCnwjHKarzvn0mb2FI4FhncSBiF9wNuA/0cYmL4F+GT5Os8qn/s48MJy3r9Wfg9OxE+rPBRqcc71AP9eLv9u4K+BTYTv472EQeJthK25AF8ul3l7OU+twEcJ13c/A3g+8G3nnFk4gdBAML/SObdr4MZmtuIEy0E5nxcBO4Dl5ff7I+VjPyAMVPcTjnn8KmHweh3hv92TOBYYvorwb6mV8OHB2BeFrULB4RRwzieb3UksFn5wdnbcTTzeQlNuLcQ8LBLB9wvk77iXaFMTza985eD0pfDhTWLliqnOuojIKau4Zw9+by+x1mMP5bzDhzl0220kVqyg5fLLh6Xx+/qINrcQX7JkKrM6ZYKgSD7fRS63G+cCYrGGqmMEI5EUkUgCCIAIPb0Psm3bBwmCAsuWXcn8eZeOudXvWGvhWpJJdSGVGcWNsN9GOefXzrmBFscvm9nbgKcB8wmDlz8STnrSDFwK9AObgT875z5UcZ0XVbz+dHkb6rnA0ODwR865T5Vf9wGY2V2ELVZJwtbC7xEGHQNlGWjRrLzn68pbtXt+Enh2xb5POee2lO91I/DjKulOmJmtBtaWf10O/KHKaevNbKFzrgvoJOwefBGwEBhakZ0xkfkbwVXOuUfKrx8zszdV5OMSwuBxqOeWf1Y+gHgzsAp4DPi9c+4nTyRTCg6nQKFwmMAViUUa6O/fTF//Q7TNezXucJZoUzMAuZ/+Bn9HB3P/4R+I1A7qro3f20tq3dpZ3z1JRGSm8Ht6KO3aTbT1WMuW830O3nILrlRi3jvfOaxODopFcI7UGWuGrXV4svP9Avl8B/n8XgBisUZGmmcjEkkRBAX+/NAV5PPtpFJtrFv7UVpansmC+ZdSUzO2wDlsLewlHm+hvn6NWgtnmRNosZsp9lS8bjWzpiqthysqXu8d5RoDvw/0r57rnAvM7HLg3wi7a75v4EQz2wQ83zm3lzCYHE21Lmd/HLrDOddtZt8GXgm8pNxl9dXlw1ucc78svx7PPSvvvW+E1+N1sXPuvqE7zWxsg5ZhjpnlgF9y/LI80QpnLDHW0H+HMb+3zrkHzez9wLWErbPPGjjBzL4FvMI5540pp0PMrk+vGci5gFxuJ7Fo2HW0o/NuYrFGmvpOx8pBoNfbTeFrPyN55pnUPeMZg9IHmQzRpiYtdi8iMkWCYpH85s1YQ8OgIK/nnnsoPPooc970pmEzkLogIOjrI7lu7axaZsj3c2Qy2+np+R25/F5iscby7KMjT8AYiSR4eNNbyefbAciXJ585/bR3jjkw9Lx+fL+f+vozaGzcoMBQZgznXCdhd8UBg7oQWDjzZ2UXsHurXGZoV9PK3w+V7/Pd8v4zgBcDNwI+4XjH68rnHqhIt6TKLJ5GGDwMlatWNuCO8s964P8CG4fsH3rP14xwz4H+9ocq8zfC64lSma8fjZCvSLml7mKOBWI/ARaVj189wrVHaiEGKFS8rpyBa9VoGXbODf13qCzD+0Yow/yK9B8iHGN4HmEr70D35MuA/zPa/Uei4HCSFYtH8P0ckUiSdHorfX1/ZF7dXxLxI0Ti4VPnzFd/gMsVmPOmNw2ehCYICPJ5kqtPn3VPoUVEZiLnHIWt23DODQrycps20XvPPdRddBH1Fw2fSyHo7SGxfBnx1rGNoZvpfD9Lf3or3d33ky90Eos1kRglKBwQBIWjgeGAob+PnNajWDxMNFpHc/OTSKUWqRupzEQ3Vbz+kJldZuGsocuAL3FsPN3DwHeqpH+amb3WzOrN7NUcazU8ADwERyd9eQ7hRDA/IFwiYyAQGQgmv1txzf80s9XlfKwpX/+XhF0sx+pHHGvpHAhAfQZPulN5zw+Z2dPL91xqZpea2ZeB15SP/7Ti3Leb2RlmthCY8GZj59w2YGv5178ys3eYWXN5u8DMPkA4bg/CGVoH5IFMueXxqhEuf7ji9Tk2uFKq7Pr5V+X3YgFwzQkU44fAwERA/1ietbTWzBaZ2cUWziT7bgAzO9PMPgicQ9jy/C0Gd9WtNtZ1TNStdBI558jldhKNhstUdHTeTSzaQHP6DKw8CU1x63ZK9/2Zxhe9iMTSpYPSB329JJYuIVo+V0REJlepowPv8CFic47NGO739nLolluILVrEnDe+cVgaP50mUt9AYtkJfxbPGJ6XJpfbR6HQhVmMeLwZs9EfTjrn6O9/mI7Ou1mx4m2kUm2DAsJUqo3Bw7Cq3bsf5zzq69eQTCoolJnLOXd3OZj4AOEMokNnI4VwopPLnHN+lWOdhEHkUO+tmCX0LQyfEXTAD8s/byGceOUC4HkcC45OSLk76xcIA8OBGOH75dbSgXN+Y2b/Vs7fSsLumUPdW/HzPsIuj6sJx8TB4BbFiXQlYSCdAm4ub5V+Vv75K+Ag4SQ1L6A87hLYNsJ1f1vx+tsAZrbbObfCOddhZvcRlvE8wkAyyeAWxTFxzu0xs+uAjwEtwPernPbB8s9Wwr+/D1Q5JyAM9E+ImqMmUanUjedniEZTZDLb6e19gLnJZxKN1GCRCC4ISN/x30Ramml+xSsGpXWlEhaNkpilkxqIiMw0fn8/he3biVauZxgEHPr0p/HTaeZdcw2RmsHdG12pBF6J1Nozhq11eDLxvH76+jfR0/MApdJh4vFW4vGmUQND5xy9vX/ksS3/xJatHyCf7yCXa2f92beVA8IwMFx/9mcIguqzwh9rLaylufkCUqnFCgxlxnPOXQ/8BeHyDu2ELT79wAOEYwTPc85tHyH5vYSta5uBImFQ8vqKZSwgnDnzl4StiR6QJZxY5mrCoBDnXJZwZsrrCJejyBJ2Gd1B2JL0BqBjnEW7g8HdKG8feoJz7q3AawmDrV7Csu8jbCm8lnJQ45xzhDNt3l4+L00YSF82zjyNiXPuZ8D5hC2d+8r5OkLYGvspwqU2cM51E07080vC96wDuIHwPa/mG8CHCVvoqgX7ryFsIe4hbIn8AtUn6hlLGT5OOFPq9wkDTY9w3czflPM40Iq7g3BM6p+B7nK+ugmXNrm0ygy1Y2bhv9up54ILLnAPPPDApF1/4APTOY9otIZtj3+E/r6HWR1cRbx5PmZG9t5fkr3ju8x9xzuoHzLW0D98iOSZZxLXWEMROb5p+RY92XXoVHOlEtk//QmwQQFg73//N91f/CKtV1xB46WXDk7jHP7hQ6TOOuukrKudc3heH9nsLkqlbiKRJNFo3ZgCs/Az7gE6Ou8mk9lGIjGXRQv/mrlz/5JIJFExW6kDjCAoEgT5YdfxvDTOlairO63cWqhn1jLl9CRCpIK6lU4Sz+vD83pJJOaSze6ip+d3zI8/h1hNC2ZG0Jsm+7UfkTh7HXVPf/qgtH46TaSlldjcuSNcXUREJopzjsKOnbhCYVCrYWHbNrrvuovaCy+k4ZJLhqULerqJL1ly0gWGYVDYUw4Ke4hEao67cP3gtAE9PffT0Xk32ewOkokFrFj+VubMuXjQkhZBkK8aDB67jk+p1EM83kR9/TlEo7UjnisiIlNHweEkyWZ3EYmET587Ou8mYjW0+ucfnfo8/ZXvQaHE3DdeOXgSGt/HFQuk1p+tbjUiIlPAO3CAUmcH0YpxhkEmw8Gbbyba0sKct751WH0cZDJEampIrlgxxbk9cc4FlErdZLM7KXn9xKJ1JBJjewjpnE9392/o6LybXG4PyeRiVq64itbWi4hExvdVwvPSBEGJ+vrVai0UEZlhFBxOAs/rp1TqJpGYQy63l+7u3zDP/oJ4ffh0ubR1N8Wf/ZG6l1xCYkmVSWiWLSNSVzcdWRcROaUEmQyFrVuJNjUfDQCdcxz63OfwDh1i4Y03DpsUzHkerlAgdd55WGzmf4w651MsHiGb24nvZYlG60iOIyg8cuSXdHR+nXx+H6nUElatvIbW1meMaebSodcaaC1salJroYjITDTzP9VOQtncbiKRcAr0js6vE7EEc6JPxaJRnO+Tvv1bWGsjrS979aB0QaGAxeOahEZEZAo43ye/ZQskklj8WJfI9I9/TPbXv6b5Na8htXbt4DTO4fd0k1q3jmj9zH+IVyr10N//GEGQJxarH3P30SDwOHLkZ3R03kOh0ElNzXJOW/WPtLQ8ddxBIRxrLayrW11enkKthSIiM5GCwwnmeWmKhUPE463k8u0cOfIL5vJU4vXhmpX5H/0Wf3cXze98M9HawU9Ng3Q/qbPPPimeRIuInOyKu3cTZDJEW46tTVjcs4cjd9xBasMGml7ykmFpgt5e4osWEZs/f9ixmcQ5Rz7fTiazjWi0YRxBYYnDh39KR+c9FIsHqK1dxemnvYfm5gtPKKBzzqdY6iYRb6axcQOx2MwPqEVETmWKQiZYLteOWRwzo7Pj6xgx5tZcHE5C09NP9u57ia0/jcanXDwond/XR2zuXOJzxvYBLiIiJ650+DDFPXuJVixaHxQKHPzkJ7HaWuZdfTUWGRwMBbkclkyQXLVqRo8JD4Ii6cw2ioUDxMe8cH2RQ4d+TGfXNykWD1FXt5rly95EU9MFJ1RW5wI8rw/nHPV1a9RaKCJykpiW4NDMBhZuvAxYSLiOxw+A651ze8d5re8AL67Y1eCcS09UXsfD97MUCl3E4y3k850cPvJz5nAhiVQY8GW+/D+4kkfrG15HJHLsw9r5PvgeyVWrpiPbIiKnlCCfp/DYFiKNjYMCwCO3306pvZ0F111HtLl5UBrn+wS5LLXnnjuoC+pM43lp+vsfIXClMU024/sFDh66l66ub1EqHaG+fh0rlr+NxsaNJxgU+nh+Py5w1NQsIpVaQjRaM3pCERGZEaY8ODSzJuBXQOVAjkXA64FLzOypzrndY7zWyxkcGE6rfL4di0TLrYb3YESYV/eXAJQ276Dwiz+SeulfULPkjEHp/N4ekqtWDVtcWUREJpYLAvJbtkIkcnT2aID0L39J+ic/oemyy6g555xh6fzubpKrTyfa0DCV2R2XfH4/6fQWotEU8VjTcc/1/RwHDv6Qrq5v4Xm9NDSczaqV19DQcGIzZTvn43l9AKRSS0ilFhONpk6oHCIiMn2mo+XwAxwLDD8OfAx4DXArYZD4CeDlo12kHGTeCgRAEZjWTyHfz5PLdRKPN1Eo7OfQkZ/Sak8ikWjFeT7pO76DzWmk+a9fOahrTZDPE6mpIb5o0TTmXkTk1FDatw+/t4dY67Eu/KWuLg5/7nMkzziD5le+clgav6+X2Ly5xBcvnsqsjplzPpnMdvL5dmKx5uMuLeH7WfYf+B/27/8OntdPY+M5LF70ChoazjqheweBh+/344DammWkUouOTsgmIiInnykNDi18HPl35V+zwPudc0XgU2b2DmAV8BIza3HOdY9yuY8TBpO3AC8Flk9Kpscon+/EIoZZhI59d2MY8xueFx6799f4e/dTd80rSdYcm8TAOUeQTlO78RwsOv7Z30REZOz83l4KO3cOWujelUocvPlmLBJh3jveMWxCsKBQwCxCcvXqGTnO0PdzpNOPUSr1EY/PGZTHSCRFJJIAApxzHDhwL7v3/Bu+n6ap6XwWL3oF9fVnjHzx4wiCEp7Xj1mU2tpVJJPzy/cSEZGT2VS3HK4EBh7XPl4ODAc8QhgcxoBzgf8d6SJm9gzgTcAe4DrC4HDaBEGBfH4vsVgjheJBDnffR0v0fBLRZvwjfWTv+TGxc1bR+OTnDG417O8jvmjhsLEtIiIysYJikfzmzUTq6gc9jOu+6y6K27cz79pric2bNyiN832CdD+1GzcO6oI6UxQKh0lnHsWIkUi0DjoWiaQIggJ/fugK8vl2Uqk21q39KAsWvIjmpvOpqzv9hO4ZBEU8P41ZnPr61SQS84hEZu4YTBERGZ+pDg4XVLzuHXKs8vcR5wg3swTwecCANzvn0tP9NDef7wLALErHrq8Cjvn1Yath9sv/g/N8al/3IhLR5qNpnOdBEJBYsWLqMywicgpxpRL5Rx7FBQHR1LERCNkHHqDvu9+l4dJLqbvwwmHp/N4ekitXEm06/vi9qeZcQC63l2x2B7FYY9UWu0gkcTQwhHBM/ObH3sO5G790dGzgeARBAc9LE4kkqK87g0Ri7nG7r4qIyMlpJtXsY43w/glYB3zFOff9cd3A7ErgSoBly5aNL3cjCIISudyesNUwd4DDfT+jOX4BiUgLxUe3U/jVn0he9nTqF589qNXQ7+sjufp0IkmNzRCRk8Nk1KGTzXkeuUc3E2QzRJuaj+73Dh/m0G23kVixgpbLLx+Wzu/rI9rcQnzJkinM7eiCoEA6vY1iMVxPt9ryEEHg4Xl9RwPDAeHvblz38/08vp8mGq2loeEsEonWMS2NISIiJ6epXnRof8Xr5iHHGiteH6iW2MxqgfcCBeAOM9toZhuBysem682s6rcW59znnXMXOOcumDek+9CJKhQO4FyAWZTOXV/B4bOg5q9wnk/m9u8QmddCzUsuJh459uQ5yOWI1tUSX7DgOFcWEZlZJqMOnUzO98k/toWgr3dQYOh8n4O33IIrlZh3zTXDuowGxSI4R2rN6mFrHU4nz+unp+cPlLweEok5VQPDQvEgj215H/lCJ6lU26Bj4e9jew7r+zkKxUOYQUPDepqbn0QyOU+BoYjILDfVn3o7Cdc0BDi93EV0wMBUaR7wxxHSJ8pbEri3fN4fCSemGfBr4MaJyvDxBIFHNruLWKyBQn8XhzK/oCVxPonoHHI/+BV++wFSf/sc6mpXHv0Qd87hMplwcoMZ9KVDRGQ2cUFAYds2/O4jRFsGj8frueceCo8+ypw3vpF4W9uwdEFfH8l1a4mkZsZSDM458vkOenoexCw+4jIVPT0P8Oij7ySX20Op1M/6sz9zNEBMpdpYf/ZnCIJi1bQDPC9DsXgYsxjNTRtparqAZHKuFrAXETlFTGm3UuecM7MvAO8EaoCbzOyjwGsJJ6MB+I5zrtvMngX8tLzvC865101lXseiWDyIcx4WidOx66s4fOan/gr/cC/Ze35M/LwzSJ6/npgdaxQN+nqJLWkj2th4nCuLiMiJckFA4fHHKe0/QGzOnEHHcps20fuNb1B30UXUP+tZw9IGvT0kli8j3to67Nh0CALv6DIVI3XpdM5nX/uX6er6BjU1Kzj9tGtJpRYTiSQ5d+OXCLuSGkFQJAjyVe/jeWkCVyAea6ahYR2xWOOMnJ1VREQm13SMObwReD7hWofXlrcBXcC7RkronOuhSp8YM9vFsaUsGpxz6QnK64ic88lmdxKLNZA/vIfDhV/RnDiPZHQeff/1ZQgCUpdfTG1sydEPWFcqAUbiJBmrIyJysnHOUdy5k1JnF9EhAZ7f28uhW28ltnAhc974xmFp/XSaSH3DjKmjfT9Lf/+j+H6WRGJu1WCtWDzM9h2fIJ1+lHlzn8uyZVccXWcwCPIjBoMQvle+308QlEgk5lJbezaxWMOklUdERGa+KQ8OnXO9ZvZ04HrCJSgWEXY1/QHwAefc3qnO04koFA4TuBLRoIauPffg8Jif+kuKD2+j+NuHqHn5xcQWLBrUauj39pJat3ZGTokuInKyc85R3LWL4t59ROccW/PPUkki8QTO91h04424RIJITc3gtKUSlEqkztkwI9adLRQOkU4/ilmCeLyl6jm9vX9kx86bCYIiq1Zew5w5F43p2s4FeF4/znkkkwuoqVlKLFY/kdkXEZGT1LTMVuqcOwL8Q3kb6Zz7GOPIeefcignJ2BiF04jvJBatI9+5iyP+b2mKn0PSzaHnzv8ismAO8RecP6jV0M9kiLY0E5s/4iodIiLyBJT27qW4Zw/R1tZBgaErFNjz939Pqb2DeNti2m69FUsmcfkCUG5B6+0hddZZw4LGqeZcQDa7i1xuN7FYU9U1BJ3zae/4Kp2d91BTs5TTVl1LTc3os6o6F+D5/bjAJ5laRE2qjVisbjKKISIiJ6mZtJTFSaNU6sb3c8SDOvZ3/X8EFFlQ81fkvvtL/I6D1F/7WmLJxqOthi4IcIU8ybPO0hgOEZFJUGxvp7BjB9GW1kGTfUUSiaOBIUCpvYP2q69m2R134JeDw6Cnm/iSJcSneQZW3y+QTm+mVOodcZmKYvEIO3Z+kv7+Tcyd+xyWLb2SaPT4SyI551Py+jAglVpMKtVGNDq9QbCIiMxMCg7HyTlHNruTSLSO3O7tHHa/oym+gXh3Dd3f+gmJC84kes4SaipaDYPeHhJLlxKt1xNaEZGJVtq/n8K2x8PAcEiX0CCfPxoYHj2/vQMXhOv9BdkskZoakitWTFV2qyqVeunrfwSARKL6ZDh9fX9m+46bCYIcK1f8A3PnXjzqdT2vD+d8alJLSaUWjxpIiojIqU3B4Th5Xg8lr59YIcmBvh8RkGd+6q/I/Pt3wUHq8ucRtVpiFg7qD4pFLBYnMcMWUhYRmQ1KBw+S37yZaHPLsMAw99BDxOfPJ962eFCAGG9bjEUM53m4fJ7Ueedhsen5OAyXqWgnk9lGNNpQNXhzzqej8+t0dHyNVKqN00+7iZqapaNcN6Dk9RCPNVFfv5ZodGYsyyEiIjObFi4ah7DVcBdRUuR2beWI+x2N8bOIPpKheP8mai97NjY3ObjVsL+PxOrTsfjwcSMiInLiSkeOkH/0UaJNzcOCu/wjj3Dgox+l57+/Q9sttxBvWwxwdMyhXyji93STPGPNtPXqCIIS6fRmMpltxOMtVQPDUqmHrVtvpKPjq8yZ8yzOXPcvowaGQVCkVDpCTWoZjY0bFBiKiMiYqeVwHDyvn1KpF+v2OFL6NT455sWeTfrObxBdNJfE8y8kYvGjrYZ+fz+xOXOGrbMlIiJPjN/TQ37TI0Qbm4Y9fMs/9hj7P/IRYvPn0/LKV2GpFMvuuAMXOCxiBMUiXtd+4osWTdskYZ6Xpj/9KEFQJJGYW/Wcvv5N7NjxCTwvw4oVb2funOeMOm7d8/pwOBoaNpBM6rNHRETGR8HhOASuiCuWKHbs5pD7LQ2xddj3dxJ0HaLxvW8giBWpi63EzHC+jyuVSK5apUloREQmkN/fT+7hh4nU1Q0LDAuPP87+f/5noi0tLLj+eqJNTbh84ejkMwBBLocl4tNWP+fz+0mntxCNJonHmoYddy6gs/MbtHd8hVRqEWtWX09t7YrjXtO5gFKph3i8kfr6dWotFBGRE6LgcJxK+/fT7f6A7zLMzT+Z7Le/TuLJ64muX44ROTbWsK+P5IrlRGprpznHIiKzh5/OkHvoIaymlkhycDfMwo4d7L/pJqL19Sy84QZiLcPXB3S+T5DLUnvuuVPe3d85n2x2B7ncXmKx5qrLVJRKvezY+a/09f2R1tZnsmL5W0adWTTsRtpHbe0KamuXYTb96zSKiMjJScHhOAT9/ZS6D3LIfkN9bA3u9j+BQd3lL8B3WRriZ2BmBIUClkwQX7x4urMsIjJrBNksuYf+jCWSRFKDW8aKu3ez/6absJoaFtxww4jd+f2ebpKnn060oWEqsnzsvn6OdPoxSqU+4vG5VVss+/sfZfuOT+B5fSxf/hbmzX3uGLqR9uPwaWxUN1IREXniFByOgysW6bNNeK6f1j0XU3zgB9T+zSXQmiJGlJg14JwjSPdTs2HDtM1+JyIy2wS5XNhiGIsPW6i+2N5O1403YvE4C2+4gfgI4wj9vl5ic+ZO+YO7QuEQ6cxjGJGqy1Q4F9DV9W32tf8XyeQCzlz3MWprVx33moO7ka7VuoUiIjIhFL2MkXMBVp9iycY3s9j7W/q//l+4xfOoef4zKLk0DfE1mBl+Xy/x+fOrdmcSEZHxCwoFcps24TCiQ7rqlzo72X/DDWDGwuuvJ75wYfVr5POYRUiuWT1l4wyDwCOX21XuRtpIJJIYdo7n9bFj56309j5AS8vTWLni7USjxx+OEAQlPK+Xmppl1NauUDdSERGZMAoOx8C5gHR6Kw89fCX5fDupVBtnvfejFB/ZSRD1iFEXthr6PvgBiZUrpzvLIiKzQlAskt+0Cef5w7qClvbvp+uGG3C+z8IPfpB4W1v1a+TzuHyOmnPOIZIYHqBNBs9Lk05vxvdzxONzqgak6fRjbN/xL5RKPSxfdiXz5l06hm6kaZwr0dCwnmSy+iynIiIiJ0rrHI5BsXj4aGAIkM+388i+91D75AvwXZ6aWFvYatjbQ2LVymFjYUREZPxcqUT+kUcJCoVhgaF38GAYGBYKLPzAB0gsrb72X5DP43JhYDgV4wydc+Ry7fT0PIBzAfF4y7CAzzlHV9e3eWzL+zCirFv7UebPf/5xA0PnHMXiESKRJM3NT1JgKCIik0Ith2MQBMWjgeGAfL4dokbMwlbDIJcjWls7YpcmEREZO+d55B7dTJDNEG1qHnTMO3yYrg9+kCCTYeH115NYsaLqNYJCIQwMN05NYOj7BTKZbRSLB8tB4fDunp6XZueuW+npuZ/m5qewcsXbicXqj3vdY91Il1Jbu1LdSEVEZNIoOByDSCRBKtU2KEBMpdrAQU0s7MYUZDLUnrsRi+pDW0TkiXC+T/6xLQR9vURbBk/g4nV30/XBD+L39LDgAx8gedppVa8RFAq4bGbKWgyLxSP0pzcDDFrUPhJJlccaBgRBgd17/oPe3gdZuvQKFsx/obqRiojIjKLgcAyi2ShnLfs4j+y59tiYw2UfJ5qNE7EGgr5e4osXEW0avpixiIiMnQsCCtu24XcfGRYY+r297L/xRvzDh1lw3XWk1qypeo1BgWFj46TmN5x0ZjfZ7B7i8cGTzkQiKYKgwJ8fuuLoZ8e6dR+jbfGrSaWqz6g6wDlHqdRNLFZPQ8M5o05SIyIiMhE05nAMXC5P9z/ezFnR9/OkZV/hrOj76f7Hm4kUAc8DGLFbk4iIjI0LAgqPP05p/4HhgWF/P1033YS3fz/z3/teUuvWVb3GVAaGnpemr+9P5HL7SCRah81GGokkeHjTWweNV9+8+d3U159+3OsGQYlS6RA1NYtpbFRgKCIiU0cth2NgiQT+wUN0/t3VR/fF2xZjkSh+Xx/JM9ZM2Qx4IiKzkXOO4s6dlDq7iLYOCQwzGfbfdBOlfftY8J73UHP22VWvERQKuEyGmnM2TGpg6JyjUOgknd5GNJqqunYhQBDkq49Xx414bc/L4Fyx3I103kRmW0REZFRqORyDaGsrS277DPG2cOHkeNti2m69Ba+3j2hjw4gLLouIyNgUd+2iuHcf0dbWQePwglyOAx/+MMU9e5j/f/8vNRs3Vk0/KDCcxC7+QVCgP/0I6fQW4vGmqq16QVBiz947yOZ2h+PTK4S/Dx9nONCNNBKJ0dx8gQJDERGZFmo5HAOLhAsnL/vSnfj5DC5iuILhd3VSe955WEQxtojIiSru3Utxz57hgWE+z/4Pf5jC448z713vovb886umDwqFcFKwDesnNTAslbrp698MBIMmnamUy+1h+45PksvtIplcyPqzb+PhTW87OuZw/dmfIQiKg/Nfno00lWqjtnYVkYg+mkVEZHroE2iMLBLBsywH93yfltanEunzSCxdOiWz4ImIzFbF9nYK27cTbWkd9KAtKBQ48NGPUti6lXnveAd1T35y1fRBsXgsMGxunpQ8OueTze4il9tLLFZPJJKsco7jwIHvsXffF4lGa1h9+vtobn4SkUiKczd+ibArqREERYIgfzTdQDfS+vozSaUWTEr+RURExkrB4TglaSXqJSHqSCxZMt3ZERE5aZX276ew7fEwMKxYBigoFjnw//4f+UceYe5VV1H3tKdVTR8UiwTp9KQGhp6XIZ3ejOdly2sXDu8pUip1s3Pnp+jte5CmpvNZueIq4vEwP0GQHxQMDnDO4Xk9RKM11NefTyxWNyn5FxERGQ8Fh+MQizZQY224/j6SZ56JaRIaEZETUjp0iPzmzUSbWwYFhq5U4uAnPkH+T39izlveQv0zn1k1fRgY9lOzfnICw3DSmS7S6W1EIgkSiZaq53X33M+uXZ/G9/MsX3Yl8+ZdOurahUHgUfK6SSXbqKs7Td1IRURkxtAn0jhEIgks6xFpW0BsrhYjFhE5EaUjR8g/8gjRpmYsduxjyHkeB2++mdwf/kDrm95Ew3OeUzX90cDw7PXEWqoHbU9EEBRIZx6nWDhALNZcNXjz/Tx7997OwUP3Ulu7ilUrr6GmZumo1/b9LL5foKH+TFKphROedxERkSdCweE4WSpJ6rRVoz4ZFhGR4fzeXvKbHiHa2ITF40f3O9/n4K23kr3/flpf/3oan/e8quldqUSQToeBYevEB4alUg99/Y9yvElnMpnH2bHjk+QLnSxceBlti19NJBKveu7RfJe7kUaiKZqbzyMWq5/wvIuIiDxRCg7HIxolefrpROo0NkREZLyCXI7cQw8TqasbFhgeuu02sr/+NS2XX07jC15QNb0rlfD7+0idffaEB4bhpDN7yOV2EY02EI1Wm3TGp7Prm3R0fJVYrJkz1txIY+P6Ua8dBB6lUjepVBt1datGDSRFRESmi4LDcYi1tMAkdGESETkVuEIB5xzR5LHAywUBhz//eTI//znNr3oVTS95SfW0FYFhvLX6ovMnKpx0Zgue10883lp10plC4QA7dv4r6fSjtLY8g+XL3zym1j/PS+NciYaGM0kmF6jXiYiIzGgKDkVEZFo45zjyn/9J+ic/oellL6P55S+vfl6phN/XO+GBYTjpzH4yma2YxUkkql/78OGfsXvP53DOsXLlPzCn9VmjBnnO+ZS8XuKxRurrzyEarZ2wfIuIiEwWBYciIjLlnHN033kn/T/8IY0veQnNr3pV9fMqA8M5cybs/kFQJJN5nEJh/4iTznhemt17PseRI7+gvn4dq1a+g2Ry9LUIfT+H52eoqz2NmpolVVsiRUREZiIFhyIiMqWcc3TfdRd93/seDS94AS2vfW3VlrjJCgzHMulMX/8mdu68hWLxMG2LX82iRS/DLFr13KP5rZh0pqX5AmKxhgnLs4iIyFRQcCgiIpPOBQFBPk9iSRt+Ty/FnTtpeN7zaH3d644fGJ511oQFhmOZdCYISrR3fJWurm+STC5k3dqPUl+/ZtRrB0GBUqmf2tql1NSs0NqFIiJyUtKnl4iITCoXBBS2bmPf295Kqb2DeNtiFn/s41hjIxSLw8+vDAwnaE1Zz8uQyWylVOobcdKZXG4fO3Z+kmx2B3Pn/hXLlr6BaLRm1GuXvF4gQnPzRuJxTVomIiInLwWHIiIyqfwjR44GhgCl9g463n0ty+64A39IcHg0MDzzzAkJDJ3zyeX2kc3uJBJJVp10xjnHwYM/ZO++24lEkpx+2ntoaXnKqNcOghKlUg+p1ELq6k4jEhneEikiInIyUXAoIiKTyhWLRwPDAaX2DlzgBp/nefi9PWGL4bx5T/i+pVIv6cwWfC9HPN5cdcxgqdTDrl230dP7exobN7JyxdUjzlpayfP6cc6joeEsksn5WqJCRERmBQWHIiIyqSyRIN62eFCAGG9bjEWOBVTO8/B7ukmtW/eEA8MgKJLN7iKf7yAarRsx2OvpeYCduz6F72dZuvQKFsx/wagzi4ZLVPQQjzVRX792TN1ORUREThYKDkVEZFJFW1tZcttnBo05bLv1VoJyl1LneQQ9PWFguGD0pSJG4pyjWDxEOrMVcOWxhcNb9IKgwN69X+DAwf+hpmY5Z6z5ILW1K0a9vu9n8f08dXWnk0ot1hIVIiIy6yg4FBGRSWWRCMk1q1l+110E2SwWixEUi7h8YXCL4RMIDH0/RyaznULxIPFYE5FI/OixSCRFJJIAAoKgyM6dt3Ho8I9YsODFLGl7bfnYyJwLKJV6iMVqaW4+T0tUiIjIrKXgUEREJp1FIkRSKfJbtxFrDbt5TkRg6FxAPt9JNrsdsyjJIesWRiIpgqDAnx+6gny+nVSqjXXrPsaCBS+itnbZqNf3/QK+309NzTJqapZriQoREZnV1CdGRESmnPP9JxwYel4/vb0Pksk+TizWSCzWOOycSCTBw5veSj7fDkA+387mze+msfHs4+fPOUpeD4Er0tR0bnk2UgWGIiIyu+mTTkREppTzffzubpJr155QYBgEJXK5PeRye4lGa0jEq0844/t5wI4GhgPC313VNAPXL3k9pJKLqatbNWq3UxERkdlCLYciIjJ1goHA8AwSCxeOO3mxeISent+Tz3cQj7cQjdYOO8c5R3f3b9n0yFXkCx2kUm2Djoe/V196wvP68IMMjQ3raWhYq8BQREROKWo5FBGRqRM4kuvGHxj6foFsdgeFQhexWMOIC87n853s2fPv9PY9SE3NMnCO9Wd/5mjX0lSqjfVnf4YgKA5K55xPqdRDPN5Kff0aotHUCRdRRETkZKXgUEREpoTV1JDasJ743Lmjn1zmnKNQ6CKTfRww4vE5Iy5P0dn5TTq7volZjKVL3sD8+c8nEokRiSQ5d+OXCLuSGkFQJAjyR9N6XoYgKFBXt5pUapGWqBARkVOWgkMREZkSkWSSSLJ6i181npchk9lKqdRLLNY4aHmKSj09v2fPnv+gUNxPa+szWbrkdYMWvg+C/KBgcMCxJSrqaGw8m1isfvyFEhERmUUUHIqIyIzinE8ut49sdieRSJJEYk7V8wqF/ezZ8x/09P6eVGoJZ6y5icbG9WO6h+/n8f00NTUrqK1dhll0IosgIiJyUlJwKCIiM0ap1EM6sxXfyxGPN1cN2oKgSFfXt+jo/AZmEZYs+TsWzH/hiC2LlZxzeF4vZjGams4jHm+ajGKIiIiclKYlODSzVuADwGXAQuAw8APgeufc3lHSbgCuAJ4BLAGagHbgt8BNzrnHJjHrIiIyCYKgSDa7i3y+g2i0blC30Eq9vQ+ye8+/Uyh00tLydJYtfT2JxNjGMAZBCc/rIZlsKy9RMXowKSIiciqZ8uDQzJqAXwFrK3YvAl4PXGJmT3XO7T7OJZ4PXD1k36ry9tdmdpFz7v6JzLOIiEwO5xzF4iHSma2AIx5vrTrhTKFwkL17/5Punt+SSi5mzeobaGraOMZ7BHh+H2A0NGwgmRz7hDgiIiKnkumYku0DHAsMPw7M4Viwtwj4xCjpHfA/wCVAPbAS+N/ysRRw3URmVkREJofv5+jr30Rf/yaikRrisaZhgWEQlOjovIdNj7yN3r4HaWt7LWeddcuYA0PP66dU6iaVXEhz05MUGIqIiByHOeem7mbhp/5BwoAwC7Q454rlY9sJW/88YL5zrnuEazQ45/qH7LsA+H351y3OubXDUw52wQUXuAceeOCEyyIiMkNUX819kj2ROtS5gHy+k2x2O2ZRYrHGquf19v2ZPXs+Tz7fTnPzU1i29AqSyXljuofv5/D9DPHEXOpqVxGL1Z1QXkVk1puWOlRkpprqbqUrCQNDgMcHAsOyRwiDwxhwLsdaAwcZGhiWVa5WfNwxiyIiMn08r590eguenym3FA6fcKZYPMSevXfQ3f0rksmFrF79fpqbzh/T9YOgiOf1E4vV09R0LvF48wSXQEREZPaa6uBwQcXr3iHHKn+fP9YLmlkMuLFi12dPIF8iIjLJPK+fnp4HiUZTJOLDJ5wJAo/9B/4/Ojq+hnMBbYv/hoULLyMSSYx6bed8SqVeLBKnvv5Mksm5WsxeRERknGbSUhbjbtY3syTwFeDi8q5POee+cZzzrwSuBFi2bNmJ5FFE5JT1ROtQ53wwiEZrhx3r63uY3Xs+Tz6/l+amJ7Fs2RtJJhdUucrQawZ4fj+4gNralaRSi4lEZtJHm4iIyMljqj9B91e8bh5yrHLQyYHRLmRmDcC3gWeXd30G+IfjpXHOfR74PITjZUa7h4iIHDMZdWixeIS9++7gyJFfkEjMZ/Xp/0Rz84VjSut5/fhBgdqaJaRSy4hGkxORJRERkVPWVAeHOwnXNJwDnG5miYpxh2eVf3rAH493ETObC3wfuKC864POuRsmPrsiIjIZnPPZf+B7tLd/Bec8Fi96JYsW/TWRyOgBXuVkM421G4jF6qcgxyIiIrPflA7IcOHUqF8o/1oD3GRmLWZ2FeFkNADfcc51m9mzzMyVtzsHrmFmS4FfEAaGAfBmBYYiIjObcwG+n6cmtQSzGLt2f569e2+noX4dZ591K21tfzNqYBgEJYrFw5gZTU3n0tS4XoGhiIjIBJqOgRk3Ei5kvxa4trwN6ALeNUr6Kzi2TmIE+KyZDZqExjmnaYlFRGYI5wLS6a089PCV5PPtpFJtrFv3MebPey61tauqLno/OL0mmxEREZkKU/7p6pzrBZ4O3ArsAUqEQeGdwIXOud1TnScREZk8xeLho4EhQD7fzubN76ap6dzjBobOOUpeL57XR23tSlqaLySVmq/AUEREZJJMy5RuzrkjhJPHjDiBjHPuPqrMYFruQnrDJGVNREQmWBAUjwaGA8LfR57TxvPSBEGBVGoxNTXLNdmMiIjIFNB83yIiMqkikQSpVNugADGVaqPaCkaDJ5vRmEIREZGppL45IiIyqRKJOWxY//lyQBgGhuvP/gxBUDx6zuDJZjZqshkREZFpoJZDERGZVGYR6uvXcP55d+P7GcxiBEGRIMhrshkREZEZRMGhiIhMOrMI0WiKdGYLiXgrzjk8vw9cQG3tSlKpRUQi8enOpoiIyClNwaGIiEypgclmkqnF1GqyGRERkRlDwaGIiEwZF3hEk62abEZERGQGUnAoIiJTIhqto7n5AuLxpunOioiIiFSh4FBERKZEJBInElFgKCIiMlNpSjgRERERERFRcCgiIiIiIiIKDkVERERERAQFhyIiIiIiIoKCQxEREREREUHBoYiIiIiIiKDgUERERERERFBwKCIiIiIiIig4FBERERERERQcioiIiIiICGDOuenOw7Qws4PA7unOxzjNBQ5Ndyamgcp9alG5x+eQc+6Sic7MaFSHnlRU7lOLyj0+01KHisxUp2xweDIysweccxdMdz6mmsp9alG5ZbKcqu+xyn1qUblF5IlQt1IRERERERFRcCgiIiIiIiIKDk82n5/uDEwTlfvUonLLZDlV32OV+9SicovICdOYQxEREREREVHLoYiIiIiIiCg4nFJm9kIz+4KZbTazbjNLm9kmM/uombUOObfWzD5oZlvNrGBmB83s62Z2ZpXrRs3sGjN72Mxy5Wt/38yeNnWlGzszazCzvWbmytsDQ47PqrKb2QXl/HeZWdHMDpjZT83skiHnzZpym9mLzezHZnbYzDwz6zGz+8zs5VXOPSnLbWbzzOwWM/tdOd8Df89vr3LupJXRzF5nZvebWcbM+szsZ2b2wsko83RTHRpSHao6dMi5J2W5VYeKzFDOOW1TtAE/ANwI2w6gqXxeDPj5COf1A+cPue6XRzi3BDx/ustd5X349JB8PlBxbFaVHbgc8EbI44dmY7mBVx7n79wBr5sN5QY2jpCXtw85b9LKCPzzcd7nK6f7738S3nPVoU51aMWmOvQkLjeqQ7Vpm5HbtGfgVNqA7wC3AecBKeDJwN6Kiuid5fOuqtj3X8Ac4GUVH5B/qLjmiyrO/QmwEHgmkC7v6wAS0132ivw+BfAr8jf0i82sKTuwBsiX87IHeCHQCMwDLgWeN0vLXfkF/nqgFnhbxb7fzoZyAyuATxJ+kfu3irwN/WIzKWUEzgGC8v5N5fysL5/jgAywYLr+DibpPVcdqjpUdajqUNWh2rRN4jbtGTiVNqChyr5/rKjIPlve94eKfUsqzv1Jxf715X3fqNj3jIpz/7Ni/4umu+zlPMWBh8t5ekdF/iq/2MyasjP46f5zRjl3NpX7exX5WFve11Kx76HZVm7ghoo8DP1iMyllBD5Rse+1Fee+v2L/VdP1dzBJ77PqUNWhI507m8qtOnQK/m05BetQbdrGsmnM4RRyzvVX2Z2qeL3XzBLAhvLvfc65fRXHH6l4/aQhP4cer3budLsWOBv4JvDtoQdnYdmfU/5ZAp5rZjvLYyU2m9nbzcxgVpb7c4RPYwFeZWa1wKsrjv8PzMpyDzPJZTzp3o8nSnWo6lDVoYDq0AGqQ0UmgYLDaWRmi4CBgddZ4IuE3SVi5X29Q5JU/j6//HPBCMernTttzGw1cB1hvoYNNi+bbWVfVv4ZJ/xStwJIAGuBTwEfLR+fVeV2zv038GLCsSDXE3bN+TSQA24mfCoLs6zcI5jMMp6M78eEUh06zGwru+pQ1aGqQ0WmmILDaWJmS4H/JaycAuDvnHN7R0s2nlucaN4myecIn/Bf65zrPIH0J2PZ4xWvvw+0AhcQjn0AeJeZjfbBc9KV28yeSTghQMOQQ0lgHbBoLJcZzy3Hce5MMlllPFnfj3FRHTpuJ2PZVYcOpjp0MNWhIpNAweE0MLO1wK8In356wOXOuXvKhw+X9wE0D0naWPH6QPnn/op9ledXO3damNlzgIuBrcDvzWwjUDn9dE15n8/sKvuhitefdc51O+f+APy4vC9K2F1mtv2b38KxvPwt4WQKzyEs4yWEk4rA7Ct3NZNZxpPx/ZgQqkNVh5b3qQ6dXeWuRnWoyBRTcDjFzOwC4BfAUsJuUC9xzn154Lhzrgg8VP61wcyWVCQ/q+L174f8hMFfFqqdO10Gnn6uAR4E/kg44H7AmeV9z2d2lf0PYzgnOwv/zdeVf+acc19yzuWcc/9L+MUWYKOZzZ2F5R5mkst40r0fE0F1qOrQIVSHhmZDuYdRHSoyDaZ7RpxTaQOeDfQRzoB1CHjKCOdVm7b55Yxt2uYFwEXMkCm5y3l8aUUej7e9bjaVvZzvgfx9j3C2ufMJx5E44AiQmm3/5sD2ivxdTtgV7mKgUN5XBGpO9nITPlybW94+XpG3dw/sn8wycgpOw47qUNWhqkNVh6oO1aZtUrdpz8CptAH3VVRa1bb7yudN5IKvL5juco/wXqyoyOdkLeA87WUH7hkhfwHwt7Ox3MCVo/ydf3o2lHvI33DVbbLLyPEXcP776f77n4T3/L5R3vP7Tva/qxP8+1MdOovKjepQ1aHatE3jNu0ZOJU2xvjFpnxuLXAjsI3waeEh4OvAmVWuGwOuIVz/Kg/0EA7ef9p0l/k470Xlh8IDQ47NmrJzbJa9R8tl6QXupcqaXbOs3JcRjgsaGC/SB/yOcJbFyGwoN2P8YjPZZSRsLfo9YRfLfuBnwAun+29gkt7z+0Z5z+872f+uTvDvT3Xo7Cu36lDVodq0TctmzjlERERERETk1KYJaURERERERETBoYiIiIiIiCg4FBERERERERQcioiIiIiICAoORUREREREBAWHIiIiIiIigoJDmeHM7KVm9nMzO2BmOTPbbWbfNrNLpjtvIzGzO81s1wReb1X5mjvMrFB+L35jZjcNOc+Z2Q0TdV8ROfmpDlUdKiIyHgoOZcYys6uBbxEuensF8ALgQ+XDz56ufE0lM1sO/AHYSLgA8POAq4BfAy8fcvpTgf+YyvyJyMylOlR1qIjIeJlzbrrzIFKVme0B/uCcu6zKsYhzLpiGbI3KzO4EnuWcWzEB17oReC+w0Dl3eMixGfseiMj0Ux2qOlREZLzUcigzWSvQVe1A5Qe6mc0zs8+Z2VYzy5rZXjP7spm1VaYxsxvK3YbWmtkPzSxjZnvM7PXl45eb2WNmljazn5rZaUPS7zKz/zKzN5nZ42aWN7MHzezi0QpiZrVm9jEz22lmxfLP95nZaP8HW4E80HO896B8j6NdoszsWeXfq213TkC+RGTmUx2qOlREZFxi050BkeO4H/g7M9sBfMc5t3WE8wY+/N8LHAQWA+8CfmVma51z+SHnfx34d+BfgLcCt5vZauBZwHuAOHAL8GXgyUPSXgScD7wPKADvBr5vZuc457ZUy5yZxYAfAmcCNwEPA08B3l/O+7tGeQ/eBnzNzG4FfuecKxzn/AEPEnaRqnQx8M/A5gnIl4jMfKpDVYeKiIyPc06bthm5AWuAhwBX3g4BXwGeO0q6KLC0nOayiv03lPf9bcW+FsADDgONFfuvLp+7vGLfLqAILKvY1wAcAb5Use9OYFfF75eXr/XMIfl8X/l6849TFgM+CwTlaxSAXxB+6UgNOdcBN4xwndXlfN7Dse7kJ5wvbdq0zfxNdajqUG3atGkb76ZuDzJjufAp97mET5o/DPwJuAz4oZldV3mumb3FzP5sZmnCLyp7yofOqHLp71fcoxs4APzWOddXcc5j5Z9Lh6T9rXNu4No45/qB7zH8CXOlS4DdwK/NLDawAfcSPmF/ykgJXejNwGmEkyh8Azid8In9/WZWc5z7AmBmLcB3gceBy51zAwONTzhfIjLzqQ5VHSoiMl4KDmVGc875zrmfO+euc879JbCKsOvO9eUPbMzsKuAzwI+BvwYu5NiHcqrKZbuH/F4cYV+19PurXG8/0FZl/4D5wHKgNGS7v3x8znHSAuCc2+mc+7Rz7tXAEuDjwHrCGQhHVP6icg9hOV7snMtNZL5EZGZTHRpSHSoiMjYacygnFedch5n9B+F4ltWEH8KvAn7inDs6vsPMVk5SFhaMsK/9OGkOAzuBV4xwfNd4MuCc883sw8C1hGNdjuc24EnA051zQyemmNB8icjMpzpUdaiIyPEoOJQZy8yWOuf2Vjm0tvxz4IO6Fugbcs7rJylbT6nMl5k1EK4d9r3jpPkB8DIg7Zx77DjnDVOeLbCjohvTgIH3oPM4aa8hfCr+YufcwxOZLxGZ+VSHqg4VERkvBYcyk20ys58SLuK8E2gEng+8Gbi7YtzKD4B3m9k/ET4FfzbDFzeeKPuBe8vTnQ/MtFdHOFPdSO4i/KL1EzP7BPBnIEE4BubFwEudc9kR0r4XeE556vQ/EnZZ2kD4xPswcEe1RGb2NMIxNV8EjphZ5diXg8657U8wXyIy86kOVR0qIjIuCg5lJns34ReZGwm7HfnAVsKp0v+14rwbgWbgGsJxIT8DngfsmIQ8/Qy4j3A68yXAo8ClbuQp4nHOlczseeV8XwmsBDLAdsKn5cWR0gJfIvx/ejnhl5w6wifdPwJucs7tGyHdGsIxxa8rb5W+ALzuCeZLRGY+1aGqQ0VExsWG97QQkWrMbBfwS+fca6c7LyIiJxvVoSIiM59mKxUREREREREFhyIiIiIiIqJupSIiIiIiIoJaDkVERERERAQFhyIiIiIiIoKCQxEREREREUHBoYiIiIiIiKDgUERERERERFBwKCIiIiIiIsD/D2/wOppbdVt6AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 908.85x360 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "font = {'family' : 'normal',\n",
    "        'weight' : 'bold',\n",
    "        'size'   : 16}\n",
    "\n",
    "matplotlib.rc('font', **font)\n",
    "\n",
    "name_map = {\n",
    "    'reject_null': 'Power',\n",
    "    'data_type': 'Data Type'\n",
    "}\n",
    "sns.set_palette([sns.color_palette('tab10')[3], sns.color_palette('tab10')[8]])\n",
    "\n",
    "power_df = power_df.replace({'shotgun': 'Metagenomics'})\n",
    "power_df_renamed = power_df.rename(name_map, axis=1)\n",
    "\n",
    "\n",
    "g = sns.relplot(\n",
    "    x='sample_size',\n",
    "    y=name_map['reject_null'],\n",
    "    hue='metric',\n",
    "    col=name_map['data_type'],\n",
    "    kind='line',\n",
    "    marker='o',\n",
    "    data=power_df_renamed,\n",
    ")\n",
    "\n",
    "leg = g._legend\n",
    "leg.set_title('Metric')\n",
    "new_labels = ['Faith\\'s PD', 'Observed Features']\n",
    "for t, l in zip(leg.texts, new_labels):\n",
    "    t.set_text(l)\n",
    "\n",
    "for ax in g.axes.flat:\n",
    "    ax.set_xlabel('Sample Size')\n",
    "\n",
    "plt.gcf().subplots_adjust(bottom=0.15)\n",
    "plt.savefig('results/2.01-figure-02.png', dpi=400)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "faith-pd-bench",
   "language": "python",
   "name": "faith-pd-bench"
  },
  "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.6.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}