{ "cells": [ { "cell_type": "markdown", "id": "589d0f2d", "metadata": {}, "source": [ "# Replication: Zeighami *et al*, 2019" ] }, { "cell_type": "markdown", "id": "6ffe77a0", "metadata": {}, "source": [ "## Introduction" ] }, { "cell_type": "markdown", "id": "4974727a", "metadata": {}, "source": [ "This notebook attempts to reproduce the following paper (which already uses the [PPMI](http://ppmi-info.org) dataset):\n", "\n", "
\n", "Zeighami, Yashar, et al. Assessment of a prognostic MRI biomarker in early de novo Parkinson's disease. NeuroImage: Clinical 24 (2019): 101986.\n", "
" ] }, { "cell_type": "markdown", "id": "9ab29940", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "This study used longitudinal MRI data from 362 patients with de novo PD (i.e., patients not yet taking any medication) and 112 healthy controls. Subjects were split into a main cohort with 3T MRI scans (222 PD patients, 112 healthy controls) and a validation cohort with 1.5T MRI scans (140 PD patients). \n", "\n", "The demographics parameters for the PD patients were as follows (table extracted from the paper):\n", "\n", "" ] }, { "cell_type": "markdown", "id": "a51402f7", "metadata": {}, "source": [ "This paper used a method introduced in [Zeighami *et al* (2015)](https://doi.org/10.7554/eLife.08440) consisting of applying Independent Component Analysis (ICA) to Deformation-Based Morphometry (DBM) maps to identify an atrophy network related to PD. The main result is atrophy measures from this PD network is significantly correlated with disease progression as measured by differences in clinical and/or cognitive scores between the baseline visit and the most recent follow-up visit. This is illustrated in the top row of the following table (extracted from the paper):\n", "\n", "" ] }, { "cell_type": "markdown", "id": "ac976672", "metadata": {}, "source": [ "The authors also showed that the PD-related atrophy score can be used to identify patients who have a 1.5 standard deviation change in the global composite outcome (a measure they defined) between baseline and follow-up visits. The PD-related atrophy biomarker achieved an area under the receiver operating characteristics (ROC) curve of 0.63, out-performing other biomarkers, as shown in the figure below (extracted from the paper):\n", "\n", "" ] }, { "cell_type": "markdown", "id": "f95f073d", "metadata": {}, "source": [ "The remainder of this notebook is an attempt to reproduce these results using the same PPMI dataset." ] }, { "cell_type": "markdown", "id": "814499f3", "metadata": {}, "source": [ "## Initial setup" ] }, { "cell_type": "markdown", "id": "d651b5b5", "metadata": {}, "source": [ "We first initialize the notebook cache and install dependencies:" ] }, { "cell_type": "code", "execution_count": 1, "id": "02299e19-57c8-4cfe-9419-4dedd9cb1941", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "This notebook was run on 2023-01-26 22:26:49 UTC +0000\n" ] }, { "data": { "text/html": [ "\n", "
\n", " \n", "
\n" ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import livingpark_utils\n", "\n", "utils = livingpark_utils.LivingParkUtils()\n", "utils.notebook_init()" ] }, { "cell_type": "markdown", "id": "32fde65c", "metadata": {}, "source": [ "We import required libraries/functions and load some useful constants and helper functions from the `zeighamietal` module of `livingpark_utils`. The code used to create the initial cohorts based on T1 data availability is reused in another notebook. " ] }, { "cell_type": "code", "execution_count": 2, "id": "65894a5b", "metadata": {}, "outputs": [], "source": [ "import os\n", "import re\n", "from functools import reduce\n", "\n", "import numpy as np\n", "import pandas as pd\n", "\n", "from livingpark_utils.zeighamietal.constants import (\n", " FILENAME_PARTICIPANT_STATUS,\n", " FILENAME_DEMOGRAPHICS,\n", " FILENAME_PD_HISTORY,\n", " FILENAME_AGE,\n", " FILENAME_MOCA,\n", " FILENAME_UPDRS1A,\n", " FILENAME_UPDRS1B,\n", " FILENAME_UPDRS2,\n", " FILENAME_UPDRS3,\n", " FILENAME_ADL,\n", " FILENAME_T1_INFO,\n", ")\n", "\n", "from livingpark_utils.zeighamietal.constants import (\n", " COL_PAT_ID,\n", " COL_STATUS,\n", " COL_VISIT_TYPE,\n", " COL_DATE_INFO,\n", " COL_DATE_BIRTH,\n", " COL_DATE_PD,\n", ")\n", "\n", "from livingpark_utils.zeighamietal.constants import (\n", " STATUS_PD,\n", " STATUS_HC,\n", " MAIN_COHORT,\n", " VALIDATION_COHORT,\n", " VISIT_BASELINE,\n", " VISIT_SCREENING,\n", " REGEX_VISIT_FOLLOWUP,\n", " SEX_MALE,\n", " MAX_DATES,\n", ")\n", "\n", "from livingpark_utils.zeighamietal.constants import (\n", " COL_PD_STATE,\n", " COL_SEX,\n", " COL_UPDRS1A,\n", " COL_UPDRS1B,\n", " COL_UPDRS2,\n", " COL_UPDRS3,\n", " COL_MOCA,\n", " COL_ADL,\n", " COL_UPDRS1,\n", " COL_PIGD,\n", " COL_GCO,\n", " COLS_PIGD_COMPONENTS_UPDRS2,\n", " COLS_PIGD_COMPONENTS_UPDRS3,\n", " COLS_PIGD_COMPONENTS,\n", " COLS_SCORES_WITHOUT_GCO,\n", " COL_FOLLOWUP,\n", ")\n", "\n", "from livingpark_utils.zeighamietal import (\n", " load_ppmi_csv,\n", " get_t1_cohort,\n", " mean_impute,\n", " filter_date,\n", ")" ] }, { "cell_type": "markdown", "id": "cd6a3141", "metadata": {}, "source": [ "## PPMI cohort preparation" ] }, { "cell_type": "markdown", "id": "88a38019", "metadata": {}, "source": [ "We will build a PPMI cohort that matches the one used in the original study (Table 1) as closely as possible. Our cohort will be built directly from PPMI Study Data files so that it can be replicated and updated whenever necessary." ] }, { "cell_type": "markdown", "id": "de8f2f20", "metadata": {}, "source": [ "### Study data download" ] }, { "cell_type": "markdown", "id": "c06ddb34", "metadata": {}, "source": [ "We will start by downloading the PPMI Study Data files required to build our cohort: \n", "\n", "* Participant status (Parkinson's disease, healthy control, etc.)\n", "* Demographics\n", "* Age at visit\n", "* Clinical/cognitive assessment results:\n", " * Montreal Cognitive Assessment (MoCA)\n", " * Unified Parkinson's Disease Rating Scale (UPDRS) Parts I, II and III\n", " * Modified Schwab and England Activities of Daily Living scale\n", "\n", "We will use the LivingPark utils library to download these files from the notebook. If files are already present in the notebook cache, they won't be downloaded again. Otherwise, a PPMI username and password are required to obtain the files. New PPMI accounts can be requested [here](http://ppmi-info.org)." ] }, { "cell_type": "code", "execution_count": 3, "id": "444fe1d5-8bb9-49d1-a37b-5064ec972910", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Download skipped: No missing files!\n" ] } ], "source": [ "required_files = [\n", " FILENAME_PARTICIPANT_STATUS,\n", " FILENAME_PD_HISTORY,\n", " FILENAME_DEMOGRAPHICS,\n", " FILENAME_AGE,\n", " FILENAME_MOCA,\n", " FILENAME_UPDRS1A,\n", " FILENAME_UPDRS1B,\n", " FILENAME_UPDRS2,\n", " FILENAME_UPDRS3,\n", " FILENAME_ADL,\n", "]\n", "\n", "downloader = livingpark_utils.download.ppmi.Downloader(utils.study_files_dir)\n", "utils.get_study_files(required_files, default=downloader)" ] }, { "cell_type": "markdown", "id": "339378a5", "metadata": {}, "source": [ "### Subjects with T1 MRI available" ] }, { "cell_type": "markdown", "id": "7a95b22b", "metadata": {}, "source": [ "The paper uses a main cohort and a validation cohort. The **main cohort** consists of subjects with 3T T1 scans and is a subset of the cohort the authors used in the 2015 paper. The **validation cohort** consists of subjects with 1.5T T1 scans.\n", "\n", "***Main cohort***\n", "\n", "The main cohort was made up of of 222 PD patients and 112 healthy controls. In the 2015 paper, the authors used data from 237 PD patients and 118 healthy controls. MRI processing failure led to the exclusion of 5 PD patients and 1 healthy control, and so the final cohort consisted of 232 PD patients and 117 healthy controls. In the 2019 paper, an additional 10 PD patients and 5 healthy controls were excluded due to lack of follow-up data required in the analysis.\n", "\n", "*Note*: In the 2015 paper, the authors state that they used scans acquired from September 2013 to January 2014. However, if we restrict our search to this time period, the number of available scans is much lower than expected (38 PD patients instead of 237, 1 healthy control instead of 118). If we instead use all subjects with 3T scans from January 31st 2014 and before, we obtain 236 PD patients and 113 healthy controls, which is closer to what we expect thought still not exactly the same.\n", "\n", "***Validation cohort***\n", "\n", "The validation cohort was made up of 140 PD patients. The paper states that data were downloaded in October 2017, so we use all subjects with 1.5T scans from October 31st 2017 and before. " ] }, { "cell_type": "code", "execution_count": 4, "id": "144e7002", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "=============== Main cohort ===============\n", "Removing extra scans for 1 subjects\n", "Parkinson's Disease 236\n", "Healthy Control 113\n", "Name: COHORT_DEFINITION, dtype: int64\n", "=============== Validation cohort ===============\n", "Removing extra scans for 3 subjects\n", "Parkinson's Disease 130\n", "Name: COHORT_DEFINITION, dtype: int64\n" ] } ], "source": [ "df_status = load_ppmi_csv(utils, FILENAME_PARTICIPANT_STATUS)\n", "\n", "cohort_t1_map = {}\n", "for cohort_name in [MAIN_COHORT, VALIDATION_COHORT]:\n", "\n", " print(f\"=============== {cohort_name.capitalize()} cohort ===============\")\n", "\n", " df_t1_subset = get_t1_cohort(\n", " utils,\n", " cohort_name=cohort_name,\n", " filename=FILENAME_T1_INFO,\n", " sagittal_only=True,\n", " )\n", " cohort_t1_map[cohort_name] = df_t1_subset\n", "\n", " # cohort composition: number of PD patients/healthy controls\n", " print(\n", " df_status.loc[\n", " df_status[COL_PAT_ID].isin(df_t1_subset[COL_PAT_ID]), COL_STATUS\n", " ].value_counts()\n", " )" ] }, { "cell_type": "markdown", "id": "1ee97ec3", "metadata": {}, "source": [ "### Remove subjects with no follow-up data available" ] }, { "cell_type": "markdown", "id": "4e62bc29", "metadata": {}, "source": [ "The original paper excluded participants with less than 1 year of follow-up:\n", "* 10 PD patients and 5 healthy controls from their main cohort\n", "* No subjects were removed from the validation cohort\n", "\n", "We will identify subjects with less than 1 year of follow-up for the PD progression measures." ] }, { "cell_type": "markdown", "id": "25c43841", "metadata": {}, "source": [ "First, we load/compute and merge all the required clinical/cognitive measures:\n", "* UPDRS Part I\n", "* UPDRS Part II\n", "* UPDRS Part III\n", "* Modified Schwab and England Activities of Daily Living (ADL) scale\n", "* Postural instability and gait disturbance (PIGD) score\n", "* MoCA\n", "\n", "Missing values are imputed with the mean across the entire dataset, except for the MoCA score (handled below).\n", "\n", "There are two files associated with UPDRS Part I (IA: Complex behaviors; IB: Partipant questionnaire). We use the sum of the total score in each file.\n", "\n", "The PIGD score is defined in [Stebbins et al. 2013](https://doi.org/10.1002/mds.25383) and consists of the mean of a subset of UPDRS (Part II and III) measures." ] }, { "cell_type": "code", "execution_count": 5, "id": "e34625ff", "metadata": {}, "outputs": [], "source": [ "cols_for_merge = [COL_PAT_ID, COL_DATE_INFO, COL_VISIT_TYPE]\n", "\n", "df_updrs1a = load_ppmi_csv(utils, FILENAME_UPDRS1A, cols_to_impute=COL_UPDRS1A)\n", "df_updrs1b = load_ppmi_csv(utils, FILENAME_UPDRS1B, cols_to_impute=COL_UPDRS1B)\n", "df_updrs2 = load_ppmi_csv(\n", " utils, FILENAME_UPDRS2, cols_to_impute=COLS_PIGD_COMPONENTS_UPDRS2 + [COL_UPDRS2]\n", ")\n", "df_updrs3 = load_ppmi_csv(\n", " utils, FILENAME_UPDRS3, cols_to_impute=COLS_PIGD_COMPONENTS_UPDRS3 + [COL_UPDRS3]\n", ")\n", "df_adl = load_ppmi_csv(utils, FILENAME_ADL, cols_to_impute=COL_ADL)\n", "df_moca = load_ppmi_csv(utils, FILENAME_MOCA) # do not impute\n", "\n", "df_updrs1 = df_updrs1a.merge(df_updrs1b, on=cols_for_merge)\n", "df_updrs1[COL_UPDRS1] = df_updrs1.loc[:, [COL_UPDRS1A, COL_UPDRS1B]].sum(axis=\"columns\")\n", "\n", "# some subjects in the validation cohort have multiple entries on the same date\n", "# one for PDSTATE=ON and one for PDSTATE=OFF\n", "# we drop rows where PDSTATE is ON\n", "# PDSTATE=OFF is the typical functional state when participants have a poor response in spite of taking medications\n", "# PDSTATE=ON is the typical functional state when patients are receiving medication and have a good response\n", "df_updrs3 = df_updrs3.loc[df_updrs3[COL_PD_STATE] != \"ON\"]\n", "\n", "# PIGD score is build from UPDRS (Stebbins et al. 2013)\n", "df_pigd = df_updrs2.merge(df_updrs3, on=cols_for_merge, how=\"inner\")\n", "df_pigd[COL_PIGD] = df_pigd.loc[:, COLS_PIGD_COMPONENTS].mean(axis=\"columns\")\n", "\n", "df_updrs1 = df_updrs1.loc[:, cols_for_merge + [COL_UPDRS1]]\n", "df_updrs2 = df_updrs2.loc[:, cols_for_merge + [COL_UPDRS2]]\n", "df_updrs3 = df_updrs3.loc[:, cols_for_merge + [COL_UPDRS3]]\n", "df_adl = df_adl.loc[:, cols_for_merge + [COL_ADL]]\n", "df_pigd = df_pigd.loc[:, cols_for_merge + [COL_PIGD]]\n", "df_moca = df_moca.loc[:, cols_for_merge + [COL_MOCA]]\n", "\n", "df_assessments_all = reduce(\n", " lambda df1, df2: df1.merge(df2, on=cols_for_merge, how=\"outer\"),\n", " [df_updrs2, df_updrs3, df_adl, df_pigd, df_updrs1, df_moca],\n", ").drop_duplicates()\n", "\n", "# some missing values remain even if we use the screening visit score\n", "# we will impute these using the original mean\n", "mean_moca = df_moca[COL_MOCA].mean()\n", "\n", "cols_to_impute = [col for col in COLS_SCORES_WITHOUT_GCO if col != COL_MOCA]\n", "df_assessments_all = mean_impute(df_assessments_all, cols_to_impute)\n", "\n", "# keep only subjects who have a T1\n", "cohort_assessments_map_orig: dict[str, pd.DataFrame] = {}\n", "for cohort_name, df_t1_subset in cohort_t1_map.items():\n", " cohort_assessments_map_orig[cohort_name] = df_assessments_all.loc[\n", " df_assessments_all[COL_PAT_ID].isin(df_t1_subset[COL_PAT_ID])\n", " ]" ] }, { "cell_type": "markdown", "id": "17863919", "metadata": {}, "source": [ "Most subjects (including all subjects in the main cohort) took the MoCA during the screening visit, not the baseline visit. We replace the baseline MoCA score by the one from the screening visit. We plot a histogram for the number of days between baseline and screening visits, so check whether it was reasonable to use the screening visit score if the baseline score was not available." ] }, { "cell_type": "code", "execution_count": 6, "id": "751cab3c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "========== MAIN COHORT ==========\n", "Parkinson's Disease 223\n", "Healthy Control 109\n", "Name: COHORT_DEFINITION, dtype: int64\n", "========== VALIDATION COHORT ==========\n", "Parkinson's Disease 124\n", "Name: COHORT_DEFINITION, dtype: int64\n" ] }, { "data": { "text/plain": [ "" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGxCAYAAABIjE2TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAABb+UlEQVR4nO3de1zO9/8/8MdFV1dH6aCuSipEDskcJxs5FJHDfDAyI8cxLDmMmYmRsc3y0SdmM8wYdmCbMcWctthyaM6G5TjJLKWDuqrX7w+/3l+X66quuNK7rsf9drtuvF/v1/v1ej3f7+vw7H1UCCEEiIiIiGSkRmUPgIiIiOhxTFCIiIhIdpigEBERkewwQSEiIiLZYYJCREREssMEhYiIiGSHCQoRERHJDhMUIiIikh0mKERERCQ7TFAesW7dOigUClhYWODq1as68wMDA9G8efNKGBmwf/9+KBQKfP3115XSf3lduXIFvXv3hoODAxQKBSIiIsrdhkKhQFRUlNHH9rSK3ydHjx41WpuJiYmIiorCvXv3jNam3CgUCkyaNKmyh1Gix99vxZ+5/fv3V9qYngUvLy+MHDmysodRqUaOHAkvL6/KHkapAgMDERgYWK5l9L2Hd+7cKcvvVX2YoOiRl5eHt99+u7KHUaVNnToVv/32Gz777DMcPnwYU6dOrewhyVpiYiLmz59frROUqqZVq1Y4fPgwWrVqVdlDoQo2d+5cbNu2rbKHUaq4uDjExcWVaxl97+GdO3di/vz5xh5ehTCr7AHIUc+ePbFp0yZMnz4d/v7+lT2cZyo3NxcWFhZQKBRP1c7p06fRrl079O/f3zgDI3rGatWqheeff76yh1HtaTQaKBQKmJlV3s9RgwYNKq1vQzVt2rTcy1T19zD3oOgxc+ZMODo64s033yy13pUrV6BQKLBu3TqdeY/vLo6KioJCocDJkycxaNAg2NnZwcHBAZGRkSgoKMCFCxfQs2dP2NrawsvLC0uXLtXb54MHDxAZGQm1Wg1LS0t07twZJ06c0Kl39OhR9O3bFw4ODrCwsMBzzz2HrVu3atUpPlQRHx+PUaNGoU6dOrCyskJeXl6JMV+7dg2vvPIKnJ2doVKp0KRJE3z44YcoKioC8H+7FC9duoRdu3ZBoVBAoVDgypUrJbaZmZmJsWPHwtHRETY2NujZsyf+/PNPnXqXLl1CeHg4fHx8YGVlBXd3d/Tp0wenTp2S6mRlZaF27doYP368zvJXrlxBzZo18f777wMAcnJyMH36dHh7e8PCwgIODg5o06YNvvzyyxLH+qj09HSEh4fDwcEB1tbW6NOnD/766y+denv27EG3bt1Qq1YtWFlZoWPHjti7d680PyoqCjNmzAAAeHt7S+ts//79mDFjBuzs7FBYWCjVnzx5MhQKhRQHANy9exc1atTAihUrtNZrcXzm5uZwd3dHREQEsrOztcYnhEBcXBxatmwJS0tL2NvbY+DAgTqxFB/iTEpKwosvvggrKyvUr18f7733nrT9DfHxxx+jUaNGUKlUaNq0KTZv3qw1/86dO5g4cSKaNm0KGxsbODs7o2vXrjh06JBOWytXroS/vz9sbGxga2sLX19fvPXWW1p1UlNTMX78eNStWxfm5ubw9vbG/PnzUVBQUOo49e0eHzlyJGxsbHDp0iX06tULNjY28PDwwLRp03Q+N/n5+Vi4cCF8fX2hUqlQp04dhIeH486dO2Wuo6NHj2LIkCHw8vKCpaUlvLy8MHToUJ1Dz8Wf4X379mHChAlwcnKCo6MjBgwYgL///lurrkajwcyZM6FWq2FlZYUXXngBv//+e5ljKWbIur558ybGjRsHDw8PmJubw83NDQMHDsTt27e11umGDRswbdo0uLu7Q6VS4dKlSwDK/qwUu3jxIsLCwrS+h/73v/9p1Snu68svv8ScOXPg5uaGWrVqoXv37rhw4YJWXX2HeIoPSW7YsAFNmjSBlZUV/P39sWPHDp3xfPfdd2jRogVUKhXq16+P5cuXS9/5pYmIiIC1tTUyMzN15r388stwcXGBRqMBoP8QT1nb5PH38MiRI6X1VPw98+j381dffYX27dvDzs5O+nyPGjWq1BgqlCDJ2rVrBQCRlJQkli9fLgCIvXv3SvM7d+4smjVrJk2npKQIAGLt2rU6bQEQ8+bNk6bnzZsnAIjGjRuLd999VyQkJIiZM2cKAGLSpEnC19dX/Pe//xUJCQkiPDxcABDffPONtPy+ffsEAOHh4SH69esnfvjhB/HFF1+Ihg0bilq1aonLly9LdX/++Wdhbm4uXnzxRbFlyxbx008/iZEjR+qMtThed3d3MW7cOLFr1y7x9ddfi4KCAr3rJy0tTbi7u4s6deqIVatWiZ9++klMmjRJABATJkwQQgiRkZEhDh8+LNRqtejYsaM4fPiwOHz4sHjw4IHeNouKikSXLl2ESqUSixYtEvHx8WLevHmifv36OuvwwIEDYtq0aeLrr78WBw4cENu2bRP9+/cXlpaW4vz581K9qVOnCmtra3Hv3j2tvmbMmCEsLCzEP//8I4QQYvz48cLKykosW7ZM7Nu3T+zYsUO89957YsWKFXrH+vh68/DwEKNGjRK7du0Sq1evFs7OzsLDw0Okp6dLdTds2CAUCoXo37+/+Pbbb8UPP/wgQkNDRc2aNcWePXuEEEJcv35dTJ48WQAQ3377rbTOMjIyxE8//SQAiMTERKlNX19fYWlpKYKCgqSyLVu2CADi7NmzQgghsrOzRcuWLYWTk5NYtmyZ2LNnj1i+fLmws7MTXbt2FUVFRdKyY8eOFUqlUkybNk389NNPYtOmTcLX11e4uLiI1NRUqV7nzp2Fo6Oj8PHxEatWrRIJCQli4sSJAoBYv359qetMCCGts6ZNm4ovv/xSfP/996Jnz54CgPjqq6+keufPnxcTJkwQmzdvFvv37xc7duwQo0ePFjVq1BD79u2T6n355ZcCgJg8ebKIj48Xe/bsEatWrRJTpkyR6ty6dUt4eHgIT09P8fHHH4s9e/aId999V6hUKjFy5Eid8T36fiv+zD3a54gRI4S5ublo0qSJ+OCDD8SePXvEO++8IxQKhZg/f75Ur7CwUPTs2VNYW1uL+fPni4SEBPHpp58Kd3d30bRpU5GTk1Pquvrqq6/EO++8I7Zt2yYOHDggNm/eLDp37izq1Kkj7ty5I9Urfi/Wr19fTJ48WezevVt8+umnwt7eXnTp0kWrzREjRgiFQiFmzJgh4uPjxbJly4S7u7uoVauWGDFiRKnjMWRd37hxQ7i6umq957Zs2SJGjRolzp07p7VO3d3dxcCBA8X3338vduzYIe7evWvQZ0UIIc6cOSPs7OyEn5+f+Pzzz0V8fLyYNm2aqFGjhoiKitLZfl5eXmLYsGHixx9/FF9++aWoV6+e8PHx0fqeGzFihPD09NSKuXjZdu3aia1bt4qdO3eKwMBAYWZmpvV9u2vXLlGjRg0RGBgotm3bJr766ivRvn174eXlJcr6if3jjz8EAPHJJ59olaenpwuVSiUiIyOlss6dO4vOnTuXa5s8/h6+dOmSGDhwoAAgfc8Ufz8nJiYKhUIhhgwZInbu3Cl+/vlnsXbtWjF8+PBSY6hITFAe8WiCkpeXJ+rXry/atGkjfZkbI0H58MMPteq1bNlS+mEqptFoRJ06dcSAAQOksuI3WqtWrbR+XK5cuSKUSqUYM2aMVObr6yuee+45odFotPoKDQ0Vrq6uorCwUCveV1991aD1M2vWLAFA/Pbbb1rlEyZMEAqFQly4cEEq8/T0FL179y6zzV27dgkAYvny5VrlixYt0lmHjysoKBD5+fnCx8dHTJ06VSq/fPmyqFGjhvjoo4+kstzcXOHo6CjCw8OlsubNm4v+/fuXOcbHFa+3l156Sav8119/FQDEwoULhRAPkwQHBwfRp08frXqFhYXC399ftGvXTip7//33BQCRkpKiVTc7O1uYm5uLBQsWCCEe/ggAEG+++aawtLSUEr+xY8cKNzc3abnFixeLGjVqiKSkJK32vv76awFA7Ny5UwghxOHDh/W+L69fvy4sLS3FzJkzpbLOnTvr3f5NmzYVPXr0KH2liYefCUtLS62kp6CgQPj6+oqGDRuWuFxBQYHQaDSiW7duWut80qRJonbt2qX2OX78eGFjYyOuXr2qVf7BBx8IAOLMmTNa4zMkQQEgtm7dqtVer169ROPGjaXp4h+PR//IEEKIpKQkAUDExcWVOu7HFRQUiKysLGFtba31WSl+L06cOFGr/tKlSwUAcevWLSGEEOfOnRMAtD4nQgixceNGAaDMBMWQdT1q1CihVCqlJFmf4nXaqVMnrfLyfFZ69Ogh6tatKzIyMnTGaGFhIf7991+tvnr16qVVb+vWrdIPdLGSEhQXFxeRmZkplaWmpooaNWqIxYsXS2Vt27YVHh4eIi8vTyq7f/++cHR0LDNBEUKIVq1aiYCAAK2yuLg4AUCcOnVKKns8QTFkm+h7D7/++ut6x1X8mXj8D7vKxEM8JTA3N8fChQtx9OhRnUMjTyM0NFRrukmTJlAoFAgJCZHKzMzM0LBhQ71XEoWFhWntNvT09ERAQAD27dsH4OFhkPPnz2PYsGEAgIKCAunVq1cv3Lp1S2f35n/+8x+Dxv7zzz+jadOmaNeunVb5yJEjIYTAzz//bFA7jyoed/F4i4WFhenULSgoQHR0NJo2bQpzc3OYmZnB3NwcFy9exLlz56R69evXR2hoKOLi4iCEAABs2rQJd+/e1bqKpF27dti1axdmzZqF/fv3Izc3t1xjf3zMAQEB8PT0lGJKTEzEv//+ixEjRmhth6KiIvTs2RNJSUk6h1seZ2VlhQ4dOmDPnj0AgISEBNSuXRszZsxAfn4+fvnlFwAPd413795dWm7Hjh1o3rw5WrZsqdV3jx49tHb57tixAwqFAq+88opWPbVaDX9/f50rWNRqtc72b9Gihd73qj7dunWDi4uLNF2zZk28/PLLuHTpEm7cuCGVr1q1Cq1atYKFhQXMzMygVCqxd+9ere3crl073Lt3D0OHDsV3332Hf/75R6e/HTt2oEuXLnBzc9OKr/jzduDAAYPG/SiFQoE+ffpolT2+Dnbs2IHatWujT58+Wv22bNkSarW6zCuDsrKy8Oabb6Jhw4YwMzODmZkZbGxskJ2drbUOivXt21dnPACkMZX0ORs8eLBB534Ysq537dqFLl26oEmTJmW29/h3jqGflQcPHmDv3r146aWXYGVlpfP99uDBAxw5ckSr7bLWTWm6dOkCW1tbadrFxQXOzs7SstnZ2Th69Cj69+8Pc3NzqZ6NjY3Oe6Qk4eHhSExM1PpeXrt2Ldq2bVvqVaOGbJPyaNu2LYCH74mtW7fi5s2bT9WeMTBBKcWQIUPQqlUrzJkzRzoO+LQcHBy0ps3NzWFlZQULCwud8gcPHugsr1ar9ZbdvXsXAKRjvdOnT4dSqdR6TZw4EQB03siurq4Gjf3u3bt667q5uUnzy+vu3bswMzODo6OjVrm+OCMjIzF37lz0798fP/zwA3777TckJSXB399fJ7l44403cPHiRSQkJAAA/ve//6FDhw5aZ7P/97//xZtvvont27ejS5cucHBwQP/+/XHx4kWDxm7othg4cKDOtliyZAmEEPj333/L7Kd79+44cuQIsrOzsWfPHnTt2hWOjo5o3bo19uzZg5SUFKSkpGglKLdv38bJkyd1+rW1tYUQQnoP3L59G0IIuLi46NQ9cuSIznvl8e0EACqVyuDkrqR1Bvzf+2fZsmWYMGEC2rdvj2+++QZHjhxBUlISevbsqdXP8OHD8dlnn+Hq1av4z3/+A2dnZ7Rv317a5sXx/fDDDzqxNWvWDIDuZ8EQ+j6vKpVK6/N6+/Zt3Lt3D+bm5jp9p6amltlvWFgYYmNjMWbMGOzevRu///47kpKSUKdOHb3r+vHtolKpAECqW7xuH1//+j57+hiyru/cuYO6deuW2Rag+51j6Gfl7t27KCgowIoVK3Tq9erVC4DuNi1r3ZSmrPd7enq69Pl5nL4yfYYNGwaVSiWdy3j27FkkJSUhPDy81OUM2Sbl0alTJ2zfvh0FBQV49dVXUbduXTRv3tzgc/IqAq/iKYVCocCSJUsQFBSE1atX68wv/pJ6/OS4J/mhNlRqaqresuIPkpOTEwBg9uzZGDBggN42GjdurDVt6BU7jo6OuHXrlk558cl4xX2Xh6OjIwoKCnD37l2tLwN9cX7xxRd49dVXER0drVX+zz//oHbt2lplXbt2RfPmzREbGwsbGxscP34cX3zxhVYda2trzJ8/H/Pnz8ft27elvSl9+vTB+fPnyxx7SduiYcOGAP5vfaxYsaLEM+kN+RLr1q0b5s6di4MHD2Lv3r2YN2+eVB4fHw9vb29pupiTkxMsLS3x2Wef6W2zeGxOTk5QKBQ4dOiQ9MX9KH1lT6OkdQb834/BF198gcDAQKxcuVKr3v3793WWDQ8PR3h4OLKzs3Hw4EHMmzcPoaGh+PPPP+Hp6QknJye0aNECixYt0jue4uTa2IpPVv3pp5/0zn/0r/LHZWRkYMeOHZg3bx5mzZollefl5RmU0OpTvG5TU1Ph7u4ulRd/9gxR1rquU6eO1l6w0jz+nWPoZ6WgoAA1a9bE8OHD8frrr+utV/x5eBbs7e2hUCikBOtR+t7rJbXRr18/fP7551i4cCHWrl0LCwsLDB06tMxly9om5dWvXz/069cPeXl5OHLkCBYvXoywsDB4eXmhQ4cO5W7vaTFBKUP37t0RFBSEBQsWwMPDQ2uei4sLLCwscPLkSa3y7777rsLG8+WXXyIyMlL6gF+9ehWJiYl49dVXATxMPnx8fPDHH3/o/JA/rW7dumHx4sU4fvy41p6Izz//HAqFAl26dCl3m126dMHSpUuxceNGTJkyRSrftGmTTl2FQqHzg/njjz/i5s2bUlLwqClTpuC1115DRkYGXFxcMGjQoBLH4eLigpEjR+KPP/5ATEwMcnJyYGVlVerYN27cqLWrOjExEVevXsWYMWMAAB07dkTt2rVx9uzZMm9QVtpfde3atUOtWrUQExOD1NRUBAUFAXj43lyyZAm2bt2Kpk2bav3YhoaGIjo6Go6OjqV+YYeGhuK9997DzZs3MXjw4FLHaAx79+7F7du3pcSssLAQW7ZsQYMGDaS/vvVt55MnT+Lw4cM6n8Fi1tbWCAkJQX5+Pvr3748zZ87A09MToaGh2LlzJxo0aAB7e/uKDe4RoaGh2Lx5MwoLC9G+fftyLatQKCCE0FkHn376qdbVXOVRfPXHxo0b0bp1a6l869atZV7N9LiS1nVISAg2bNiACxcu6PwRVBZDPyvm5ubo0qULTpw4gRYtWmgdVqkM1tbWaNOmDbZv344PPvhAGk9WVpbeq31KEh4ejq1bt2Lnzp344osv8NJLL+n80VXWOPRtE30e/a6xtLQssU7nzp1Ru3Zt7N69GydOnGCCIldLlixB69atkZaWJu0aBiAdu//ss8/QoEED+Pv74/fff9f742osaWlpeOmllzB27FhkZGRg3rx5sLCwwOzZs6U6H3/8MUJCQtCjRw+MHDkS7u7u+Pfff3Hu3DkcP34cX3311RP1PXXqVHz++efo3bs3FixYAE9PT/z444+Ii4vDhAkT0KhRo3K3GRwcjE6dOmHmzJnIzs5GmzZt8Ouvv2LDhg06dUNDQ7Fu3Tr4+vqiRYsWOHbsGN5///0Sdyu/8sormD17Ng4ePIi3335b58usffv2CA0NRYsWLWBvb49z585hw4YN6NChQ5nJCfDwUtAxY8Zg0KBBuH79OubMmQN3d3fpUJqNjQ1WrFiBESNG4N9//8XAgQPh7OyMO3fu4I8//sCdO3ekvQR+fn4AgOXLl2PEiBFQKpVo3LgxbG1tUbNmTXTu3Bk//PADvL29pXs2dOzYESqVCnv37tVK7oCHly9+88036NSpE6ZOnYoWLVqgqKgI165dQ3x8PKZNm4b27dujY8eOGDduHMLDw3H06FF06tQJ1tbWuHXrFn755Rf4+flhwoQJZa4LQzk5OaFr166YO3curK2tERcXh/Pnz2tdahwaGop3330X8+bNQ+fOnXHhwgUsWLAA3t7eWj+mY8eOhaWlJTp27AhXV1ekpqZi8eLFsLOzk46nL1iwAAkJCQgICMCUKVPQuHFjPHjwAFeuXMHOnTuxatUqgw9LlMeQIUOwceNG9OrVC2+88QbatWsHpVKJGzduYN++fejXrx9eeuklvcvWqlULnTp1wvvvvw8nJyd4eXnhwIEDWLNmTbl+tB7VpEkTvPLKK4iJiYFSqUT37t1x+vRpfPDBB6hVq1aZyxu6rnft2oVOnTrhrbfegp+fH+7du4effvoJkZGR8PX1LbH98nxWli9fjhdeeAEvvvgiJkyYAC8vL9y/fx+XLl3CDz/88ETnwj2NBQsWoHfv3ujRowfeeOMNFBYW4v3334eNjY3Be7yCg4NRt25dTJw4EampqWUe3gEM2yb6FH/XLFmyBCEhIahZsyZatGiBhQsX4saNG+jWrRvq1q2Le/fuYfny5VAqlejcubNhK8PYKu/8XPl59Cqex4WFhQkAWlfxCPHwstoxY8YIFxcXYW1tLfr06SOuXLlS4lU8j14iKMTDs8etra11+nv8iqHis7E3bNggpkyZIurUqSNUKpV48cUXxdGjR3WW/+OPP8TgwYOFs7OzUCqVQq1Wi65du4pVq1YZFG9Jrl69KsLCwoSjo6NQKpWicePG4v3335euDCpm6FU8Qghx7949MWrUKFG7dm1hZWUlgoKCxPnz53XWYXp6uhg9erRwdnYWVlZW4oUXXhCHDh3SObv9USNHjhRmZmbixo0bOvNmzZol2rRpI+zt7YVKpRL169cXU6dOlS5DLknxeouPjxfDhw8XtWvXFpaWlqJXr17i4sWLOvUPHDggevfuLRwcHIRSqRTu7u6id+/eWpfWCiHE7NmzhZubm6hRo4bOmffFl72PHTtWa5mgoCABQHz//fc6/WZlZYm3335bNG7cWJibm0uXZk6dOlXrShohhPjss89E+/bthbW1tbC0tBQNGjQQr776qtZ76/H3ZDF9V0DoA0C8/vrrIi4uTjRo0EAolUrh6+srNm7cqFUvLy9PTJ8+Xbi7uwsLCwvRqlUrsX37dp1+1q9fL7p06SJcXFyEubm5cHNzE4MHDxYnT57Uau/OnTtiypQpwtvbWyiVSuHg4CBat24t5syZI7KysrTGZ8hVPPo+r8Wf70dpNBrxwQcfCH9/f2FhYSFsbGyEr6+vGD9+vN73yaNu3Lgh/vOf/wh7e3tha2srevbsKU6fPi08PT21rrgp6TOsb+x5eXli2rRpwtnZWVhYWIjnn39eHD58WKdNfQxd19evXxejRo0SarVaKJVKqd7t27e1xvX4e7+YoZ+VlJQUMWrUKOHu7i6USqWoU6eOCAgIkK6gK60vfVdflnQVz+uvv64zRn3ra9u2bcLPz0+Ym5uLevXqiffee09MmTJF2Nvb641Tn7feeku6FP/x71MhdK/iMWSblPQ+GDNmjKhTp45QKBTS1YM7duwQISEhwt3dXZibmwtnZ2fRq1cvcejQIYNjMDaFEP//MgeiaiY/Px9eXl544YUXjHolFhFRaTQaDVq2bAl3d3fEx8dX9nCqLB7ioWrnzp07uHDhAtauXYvbt29rnWhIRGRso0ePRlBQkHSoZdWqVTh37hyWL19e2UOr0pigULXz448/Ijw8HK6uroiLi+PD3oioQt2/fx/Tp0/HnTt3oFQq0apVK+zcuVPr0n8qPx7iISIiItnhjdqIiIhIdpigEBERkeyUO0E5ePAg+vTpAzc3NygUCmzfvr3EuuPHj4dCoUBMTIxWeV5eHiZPngwnJydYW1ujb9++Bt+BkIiIiKq/cp8km52dDX9/f4SHh5f6kLnt27fjt99+03sr6YiICPzwww/YvHkzHB0dMW3aNISGhuLYsWOoWbNmmWMoKirC33//DVtbW4Nv005ERESVSwiB+/fvw83NDTVqlLGP5GluogJAbNu2Taf8xo0bwt3dXbqx0KOPvb93755QKpVi8+bNUtnNmzdFjRo1xE8//WRQv9evXxcA+OKLL7744ouvKvi6fv16mb/1Rr/MuKioCMOHD8eMGTO0bgtf7NixY9BoNAgODpbK3Nzc0Lx5cyQmJqJHjx46y+Tl5Wk9kE/8/wuPUlJSSn3o1pPQaDTYt28funTpAqVSadS25coUYwYYtynFbYoxA6YZtynGDFSduO/fvw9vb2+DfruNnqAsWbIEZmZmOs8GKZaamgpzc3OdB3e5uLiU+PTHxYsXY/78+Trlhw8fNuiZKeVlZWWF3377zejtypkpxgwwblNiijEDphm3KcYMVI24c3JyAOg+0VofoyYox44dw/Lly3H8+PFynxsihChxmdmzZyMyMlKazszMhIeHB4KDgw160FV5aDQaJCQkICgoSNZZqDGZYswA4zaluE0xZsA04zbFmIGqE3dmZqbBdY2aoBw6dAhpaWmoV6+eVFZYWIhp06YhJiYGV65cgVqtRn5+PtLT07X2oqSlpSEgIEBvuyqVSufR4wCgVCorbENUZNtyZYoxA4zblJhizIBpxm2KMQPyj7s8YzPqfVCGDx+OkydPIjk5WXq5ublhxowZ2L17NwCgdevWUCqVSEhIkJa7desWTp8+XWKCQkRERKal3HtQsrKycOnSJWk6JSUFycnJcHBwQL169eDo6KhVX6lUQq1Wo3HjxgAAOzs7jB49GtOmTYOjoyMcHBwwffp0+Pn58bkFRGQ0QggUFBSgsLAQGo0GZmZmePDgAQoLCyt7aM+MKcZtijED8opbqVQadMuQspQ7QTl69Ci6dOkiTRefGzJixAisW7fOoDY++ugjmJmZYfDgwcjNzUW3bt2wbt06owRERJSfn49bt25JJ+QJIaBWq3H9+nWTuneSKcZtijED8opboVCgbt26sLGxeap2yp2gBAYGSpf5GuLKlSs6ZRYWFlixYgVWrFhR3u6JiEpVVFSElJQU1KxZE25ubjA3N4cQAllZWbCxsSn75lDVSFFRkcnFbYoxA/KJWwiBO3fu4MaNG/Dx8XmqHQ9Gv8yYiKgy5efno6ioCB4eHtJtCIqKipCfnw8LCwuT+9EytbhNMWZAXnHXqVMHV65cgUajeaoExXS2HhGZlMr+kiYyVcY6xMRPMBEREckOExQiIiKSHZ6DQkQmY8znR6HAs7vCYc3Its+sr9KEh4cjIyMD27dvf6p28vPz0bRpU6xfvx4dO3Y0zuDIIGlpaWjWrBmSk5Ph7u5e2cN5JrgHhYiomouJiTH4NhClWb16NTw9PattcjJ+/Hg0aNAAlpaWqFOnDvr164fz589r1fHy8oJCodB6zZo1q9R2o6Ki4OvrC2tra9jb26N79+5az8y5cuWKTpvFr6+++goA4OzsjOHDh2PevHnGD1ymmKAQEVVzdnZ2qF279lO3s2LFCowZM+bpByRTrVu3xtq1a3Hu3Dns3r0bQggEBwfr3PhswYIFuHXrlvR6++23S223UaNGiI2NxalTp/DLL7/Ay8sLwcHBuHPnDgDAw8NDq71bt25h/vz5sLa2RkhIiNROeHg4Nm7ciPT0dOMHL0NMUIiIZCIwMBCTJ09GREQE7O3t4eLigtWrVyM7Oxvh4eGwtbVFgwYNsGvXLmmZwsJCjB49Gt7e3rC0tETjxo2xfPlyrXbDw8PRv39/rX6mTJmCmTNnwsHBAWq1GlFRUaWO7fjx47h06RJ69+4tlRX/5b9161a8+OKLsLS0RNu2bfHnn38iKSkJbdq0gY2NDXr27Cn9GBdbu3YtmjRpAgsLC/j6+iIuLk5r/ptvvolGjRrBysoK9evXx9y5c6HRaKT5UVFRaNmyJTZs2AAvLy/Y2dlhyJAhuH//vqGrW8e4cePQqVMneHl5oVWrVli4cCGuX7+ucz8vW1tbqNVq6VXWDcnCwsLQvXt31K9fH82aNcOyZcuQmZmJkydPAgBq1qyp1Z5arca2bdvw8ssva7Xt5+cnzTMFPAelihi9Lqncy8jl+DcRGW79+vWYOXMmfv/9d2zZsgUTJkzA9u3b8dJLL+Gtt97CRx99hOHDh+PatWuwsrJCUVER6tati61bt8LJyQmJiYkYN24cXF1dMXDgwFL7iYyMxG+//YbDhw9j5MiR6NixI4KCgvTWP3jwIBo1aqT3CfLz5s1DTEwM6tWrh1GjRmHo0KGoVasWli9fDisrKwwePBjvvPMOVq5cCQD45JNPMG/ePMTGxuK5557DiRMnMHbsWFhbW2PEiBEAHiYB69atg5ubG06dOoWxY8fC1tYWM2fOlPq9fPkytm/fjh07diA9PR2DBw/GkiVLpDrR0dGIjo4udX3v2rULL774ok55dnY21q5dC29vb3h4eGjNW7JkCd599114eHhg0KBBmDFjBszNzUvtp1h+fj5Wr14NOzs7+Pv7661z7NgxJCcn43//+5/OvHbt2uHQoUMYNWqUQf1VZUxQiIhkxN/fXzpkMHv2bLz33ntwcnLC2LFjAUD6oT958iSef/55KJVKzJ8/X1re29sbiYmJ2Lp1a6kJSosWLaTzGXx8fBAbG4u9e/eWmKBcuXIFbm5ueudNnz4dPXr0AAC88cYbGDp0KPbu3SudqzJ69Gitc2DeffddfPjhhxgwYIA05rNnz+Ljjz+WEpRHD5t4eXlh2rRp2LJli1aCUlRUhHXr1sHW1hbAwwfW/vzzz1Kd1157DYMHDy5xHQDQOeE0Li4OM2fORHZ2Nnx9fZGQkKCVfLzxxhto1aoV7O3t8fvvv2P27NlISUnBp59+Wmo/O3bswJAhQ5CTkwNXV1ckJCTAyclJb901a9agSZMmeh+g6+7ujhMnTpTaV3XBBIWISEZatGgh/b9mzZpwdHSEn5+fVObi4gLg4VUdxVatWoVPP/0UV69eRW5uLvLz89GyZUuD+wEAV1dXrTYfl5ubCwsLizLbKh7f42MubvvOnTu4fv06Ro8eLSVdAFBQUAA7Oztp+uuvv0ZMTAwuXbqErKwsFBQU6Oy98fLykpITfTE4ODjAwcGhxJj0GTZsGIKCgnDr1i188MEHGDx4MH799Vcp9qlTp2rFbW9vj4EDB2LJkiU6D8t9VJcuXZCcnIx//vkHn3zyCQYPHozffvsNzs7OWvVyc3OxadMmzJ07V287lpaW0jOmqjueg0JEJCNKpVJrWqFQaJUV36WzqKgIALB161ZMnToVo0aNQnx8PJKTkxEeHo78/Pxy91Pcpj5OTk4lnpypb3yPlxW3XfzvJ598guTkZOl1+vRpHDlyBABw5MgRDBkyBCEhIdixYwdOnDiBOXPm6MRUVgzR0dGwsbEp9XXo0CGtNuzs7ODj44NOnTrh66+/xvnz50s95+P5558HAFy6dKnEOgBgbW2Nhg0b4vnnn8eaNWtgZmaGNWvW6NT7+uuvkZOTg1dffVVvO//++y/q1KlTal/VBfegEBFVYYcOHUJAQAAmTpwolV2+fNno/Tz33HNYuXIlhBBPdStzFxcXuLu746+//sKwYcP01vn111/h6emJOXPmSGVXr14td19PcojncUII5OXllTi/+HCLq6trucZWUrtr1qxB3759S0xCTp8+jcDAwHL1VVUxQSEiqsIaNmyIzz//HLt374a3tzc2bNiApKQkeHt7G7WfLl26IDs7G2fOnEHz5s2fqq2oqChMmTIFtWrVQkhICPLy8nD06FGkp6cjMjISDRs2xLVr17B582a0bdsWP/744xNduVKeQzx//fUXtmzZguDgYNSpUwc3b97EkiVLYGlpiV69egEADh8+jCNHjqBLly6ws7NDUlISpk6dir59+6JevXpSW76+vli8eDFeeuklZGdnY9GiRejbty9cXV1x9+5dxMXF4caNGxg0aJDWGC5duoSDBw9i586deseYk5ODY8eOlXnib3XBBIWITManr7apdg8RfO2115CcnIyXX34ZCoUCQ4cOxcSJE7UuRTYGR0dHDBgwABs3bsTixYufqq0xY8bAysoK77//PmbOnAlra2v4+fkhIiICANCvXz9MnToVkyZNQl5eHnr37o25c+eWeSn007CwsMChQ4cQExOD9PR0uLi4oFOnTkhMTJTOE1GpVNiyZQvmz5+PvLw8eHp6YuzYsVon7gLAhQsXkJGRAeDheUTnz5/H+vXr8c8//8DR0RFt27bFoUOH0KxZM63lPvvsM7i7uyM4OFjvGL/77jvUq1dP71VH1ZFCCCEqexDllZmZCTs7O2RkZOi95O1paDQa7Ny5E7169dI5vlmZKvIyY7nGXNEYd/WM+8GDB0hJSYG3t7d0YmNRUREyMzNRq1atapeglMbYcZ86dQrdu3fHpUuXtE5OlZPqvK3btWuHiIgIhIWF6cyTU9z6PoPFyvP7Xb22HhERVRg/Pz8sXbpU58ZlVPHS0tIwcOBADB06tLKH8szwEA8RERms+D4l9Gw5OzvrHEqq7rgHhYiIiGSHCQoRERHJDhMUIiIikh0mKERERCQ7TFCIiIhIdpigEBERkewwQSEiIiLZ4X1QiMhkKL4cAjzFg+7KLWzLs+vr//Py8kJERIR023h7e3t88803GDBggN76V65cgbe3N06cOIGWLVs+cb/GascQ+fn5aNq0KdavX4+OHTtWaF+kLS0tDc2aNUNycnKZD1p8WtyDQkRUjZ0/fx4hISFGbXPkyJHo37+/VpmHhwdu3br11A8SNMTq1avh6elZbZOT8ePHo0GDBrC0tESdOnXQr18/nD9/XqvOokWLEBAQACsrK9SuXdugdkeOHAmFQqH1ev7557XqBAYG6tQZMmSINN/Z2RnDhw/HvHnznjrOsjBBISKqxlxcXKBSqSq8n5o1a0KtVsPMrOJ3zK9YsQJjxoyp8H4qS+vWrbF27VqcO3cOu3fvhhACwcHBKCwslOrk5+dj0KBBmDBhQrna7tmzJ27duiW99D05eezYsVp1Pv74Y6354eHh2LhxI9LT058sQAMxQSEikoGPP/4Y7u7uKCoq0irv27evdHv5y5cvo1+/fnBxcYGNjQ3atm2LPXv2lNquvb09tm/fLk3//vvveO6552BhYYE2bdrgxIkTWvULCwsxevRoeHt7w9LSEo0bN8by5cul+VFRUVi/fj2+++476S/s/fv348qVK1AoFEhOTpbqHjhwAO3atYNKpYKrqytmzZqFgoICaX5gYCCmTJmCmTNnwsHBAWq1uswnFh8/fhyXLl1C7969pbLivrdu3YrOnTvD1dUV7du3x59//omkpCS0adMGNjY26NmzJ+7cuaPV3tq1a9GkSRNYWFjA19cXcXFxWvPffPNNNGrUCFZWVqhfvz7mzp0LjUajtT5atmyJDRs2wMvLC3Z2dhgyZAju379fahylGTduHDp16gQvLy+0atUKCxcuxPXr17WegTR//nxMnToVfn5+5WpbpVJBrVZLLwcHB506VlZWWnXs7Oy05vv5+UGtVmPbtm1PFJ+hmKAQEcnAoEGD8M8//2Dfvn1SWXp6Onbv3o1hw4YBALKystCrVy/s2bMHJ06cQI8ePdCnTx9cu3bNoD6ys7MRGhqKxo0b49ixY4iKisL06dO16hQVFaFu3brYunUrzp49i3feeQdvvfUWtm7dCgCYPn06Bg8erPWXeEBAgE5fN2/eRK9evdC2bVv88ccfWLlyJdasWYOFCxdq1Vu/fj2sra3x22+/YenSpViwYAESEhJKjOHgwYNo1KiR3ifhzps3D2+99Rb2798PMzMzDB06FDNnzsTy5ctx6NAhXL58Ge+8845U/5NPPsGcOXOwaNEinDt3DtHR0Zg7dy7Wr18v1bG1tcW6detw9uxZLF++HJ988gk++ugjrX4vX76M7du3Y8eOHdixYwcOHDiA9957T5ofHR0NGxubUl+HDh3SG292djbWrl0Lb29veHh4lLheDLV//344OzujUaNGGDt2LNLS0nTqbNy4EU5OTmjWrBmmT5+uN9lq165diWM2Fp4kS0QkAw4ODujZsyc2bdqEbt26AQC++uorODg4SNP+/v7w9/eXllm4cCG2bduG77//HpMmTSqzj40bN6KwsBCfffYZrKys0KxZM9y4cUPrMIFSqcT8+fOlaW9vbyQmJmLr1q0YPHgwbGxsYGlpiby8PKjV6hL7iouLg4eHB2JjY6FQKODr64u///4bb775Jt555x3UqPHw7+MWLVpI5zP4+PggNjYWe/fuRVBQkN52r1y5Ajc3N73zpk+fjh49eiAzMxOTJ0/GsGHDsHfvXulcldGjR2PdunVS/XfffRcffvihdAKxt7c3zp49i48//ljaa/X2229L9b28vDBt2jRs2bJF68F9RUVFWLduHWxtbQEAw4cPx969e7Fo0SIAwGuvvYbBgweXuK4A6JxwGhcXh5kzZyI7Oxu+vr5ISEiAubl5qW2UJSQkBIMGDYKnpydSUlIwd+5cdO3aFceOHZMOAw4bNgze3t5Qq9U4ffo0Zs+ejT/++EMnaXR3d9fZ+2ZsTFCIiGRi2LBhGDduHOLi4qBSqbBx40YMGTIENWvWBPDwr+n58+djx44d+Pvvv1FQUIDc3FyD96CcO3cO/v7+sLKykso6dOigU2/VqlX49NNPcfXqVeTm5iI/P7/cV+acO3cOHTp0gOKRq6Y6duyIrKws3LhxA/Xq1QPwMEF5lKurq96/6ovl5ubCwsJC77xH23JxcQEArUMgLi4uUtt37tzB9evXMXr0aIwdO1aqU1BQoHVI4+uvv0ZMTAwuXbqErKwsFBQU6Oy98fLykpITfTE4ODjoPZRSmmHDhiEoKAi3bt3CBx98gMGDB+PXX38tMXZDvPzyy9L/mzdvjjZt2sDT0xM//vijlKQ9ui6aN28OHx8ftGnTBsePH0erVq2keZaWlsjJyXnisRiCh3iIiGSiT58+KCoqwo8//ojr16/j0KFDeOWVV6T5M2bMwDfffINFixbh0KFDSE5Ohp+fH/Lz8w1qXwhRZp2tW7di6tSpGDVqFOLj45GcnIzw8HCD+3i0L8Vjl3QX9/9ouVKp1KqjUCh0zsN5lJOTU4knZz7aVnEfj5cVt1387yeffILk5GTpdfr0aRw5cgQAcOTIEQwZMgQhISHYsWMHTpw4gTlz5uisi7JieJJDPHZ2dvDx8UGnTp3w9ddf4/z580Y/58PV1RWenp64ePFiiXVatWoFpVKpU+fff/9FnTp1jDqex3EPChGRTFhaWmLAgAHYuHEjLl26hEaNGqF169bS/EOHDmHkyJF46aWXADw8J+XREyfL0rRpU2zYsAG5ubmwtLQEAOnH+NE+AgICMHHiRKns8uXLWnXMzc21rigpqa9vvvlGK1FJTEyEra3tU90/47nnnsPKlSv1JkDl4eLiAnd3d/z111/SOT6P+/XXX+Hp6Yk5c+ZIZVevXi13X09yiOdxQgjk5eWVu+/S3L17F9evX4erq2uJdc6cOQONRqNT5/Tp0wgMDDTqeB7HPShERDIybNgw/Pjjj/jss8+09p4AQMOGDfHtt98iOTkZf/zxB8LCwkrd2/C4sLAw1KhRA6NHj8bZs2exc+dOfPDBBzp9HD16FLt378aff/6JuXPnIikpSauOl5cXTp48iQsXLuCff/7Ruqql2MSJE3H9+nVMnjwZ58+fx3fffYd58+YhMjJSOv/kSXTp0gXZ2dk4c+bME7dRLCoqCosXL8by5cvx559/4tSpU1i7di2WLVsG4OG6uHbtGjZv3ozLly/jv//97xPtxXBwcEDDhg1LfRUnjH/99RcWL16MY8eO4dq1azh8+DAGDx4MS0tL9OrVS2rz2rVrSE5OxrVr11BYWIjk5GScOnUKWVlZUh1fX19pvFlZWZg+fToOHz6MK1euYP/+/ejTpw+cnJykhPfy5ctYsGABjh49iitXrmDnzp0YNGgQnnvuOa17zuTk5ODYsWMIDg4u/0ovB+5BISKTIYZuhuIpfhyfha5du8LBwQEXLlxAWFiY1ryPPvoIo0aNQkBAAJycnPDmm28iMzPT4LZtbGzwww8/4LXXXsNzzz2Hpk2bYsmSJfjPf/4j1XnttdeQnJyMl19+GQqFAkOHDsXEiROxa9cuqc7YsWOxf/9+tGnTBllZWdi3bx+8vLy0+nJ3d8fOnTsxY8YM+Pv7w8HBAaNHj9Y66fRJODo6SnuZFi9e/FRtjRkzBlZWVnj//fcxc+ZMWFtbw8/PT7oLb79+/TB16lRMmjQJeXl56N27N+bOnVvmpdBPw8LCAocOHUJMTAzS09Ph4uKCTp06ITExEc7OzlK9d955R+tqo+I9bXv37kXXrl0BABcuXEBGRgaAh/epOXXqFD7//HPcu3cPrq6u6NKlC7Zs2SKdP2Nubo69e/di+fLlyMrKgoeHB3r37o158+ZJ50EBwHfffYd69erhxRdfrLD1AAAKYchBSZnJzMyEnZ0dMjIy9F5q9jQ0Gg127tyJXr166RxXrEyj1yWVXekxa0a2NaieXGOuaIy7esb94MEDpKSkwNvbWzqhsKioCJmZmahVq9ZT/fVe1VTXuE+dOoXu3bvj0qVLWienAtU35rI8y7jbtWuHiIgInQS6mL7PYLHy/H6bztYjIqJqwc/PD0uXLi3X+TdkHGlpaRg4cCCGDh1a4X3xEA8REVU5xfcpoWfL2dlZ6x4wFYl7UIiIiEh2mKAQERGR7JQ7QTl48CD69OkDNzc3KBQKrYdQaTQavPnmm/Dz84O1tTXc3Nzw6quv4u+//9ZqIy8vD5MnT4aTkxOsra3Rt29f3Lhx46mDISIqVgXP/yeqFoz12St3gpKdnQ1/f3/ExsbqzMvJycHx48cxd+5cHD9+HN9++y3+/PNP9O3bV6teREQEtm3bhs2bN+OXX35BVlYWQkNDy7zxDxFRWYqvTKro23ATkX7Fd9p99NLkJ1Huk2RDQkIQEhKid56dnZ3OA4VWrFiBdu3a4dq1a6hXrx4yMjKwZs0abNiwAd27dwcAfPHFF/Dw8MCePXvQo0ePJwiDiOihmjVronbt2tKzUKysrCCEQH5+Ph48eGByl56aWtymGDMgn7iLiopw584dWFlZwczs6a7DqfCreDIyMqBQKFC7dm0AwLFjx6DRaLTuQOfm5obmzZsjMTFRb4KSl5endYvf4hsTaTQavXcwfBrF7Rm73adlBsPvFlnM0BjkGnNFY9zVN25HR0cUFhbi9u3bAB7ucn7w4AEsLCye6vboVY0pxm2KMQPyirtGjRpwc3NDQUGBzrzyfO9UaILy4MEDzJo1C2FhYdINWVJTU2Fubg57e3utui4uLkhNTdXbzuLFi7Ue/10sPj5e66mcxvT4nqDK1su+7DqP27lzZ7nqyy3mZ4VxV18KheKpdzMTkeGEECgsLMSFCxf0zi/PodcKS1A0Gg2GDBmCoqIixMXFlVm/tAc/zZ49G5GRkdJ0ZmYmPDw8EBwcXCF3kk1ISEBQUJCs7rI5aePxci8TO6xV2ZUg35grGuM2nbhNMWbANOM2xZiBqhN3eR7NUCEJikajweDBg5GSkoKff/5ZK4lQq9XIz89Henq61l6UtLQ0BAQE6G1PpVJBpVLplCuVygrbEBXZ9pMoeIIrwss7frnF/KwwbtNhijEDphm3KcYMyD/u8ozN6GfSFCcnFy9exJ49e+Do6Kg1v3Xr1lAqlVq7l2/duoXTp0+XmKAQERGRaSn3HpSsrCxcunRJmk5JSUFycjIcHBzg5uaGgQMH4vjx49ixYwcKCwul80ocHBxgbm4OOzs7jB49GtOmTYOjoyMcHBwwffp0+Pn5SVf1EBERkWkrd4Jy9OhRdOnSRZouPjdkxIgRiIqKwvfffw8AaNmypdZy+/btQ2BgIICHjww3MzPD4MGDkZubi27dumHdunU8mY2IiIgAPEGCEhgYWOpd4gy5g5yFhQVWrFiBFStWlLd7IiIiMgGmcxcbIiIiqjKYoBAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHslDtBOXjwIPr06QM3NzcoFAps375da74QAlFRUXBzc4OlpSUCAwNx5swZrTp5eXmYPHkynJycYG1tjb59++LGjRtPFQgRERFVH+VOULKzs+Hv74/Y2Fi985cuXYply5YhNjYWSUlJUKvVCAoKwv3796U6ERER2LZtGzZv3oxffvkFWVlZCA0NRWFh4ZNHQkRERNWGWXkXCAkJQUhIiN55QgjExMRgzpw5GDBgAABg/fr1cHFxwaZNmzB+/HhkZGRgzZo12LBhA7p37w4A+OKLL+Dh4YE9e/agR48eTxEOERERVQflTlBKk5KSgtTUVAQHB0tlKpUKnTt3RmJiIsaPH49jx45Bo9Fo1XFzc0Pz5s2RmJioN0HJy8tDXl6eNJ2ZmQkA0Gg00Gg0xgxBas/Y7T4tMxSVexlDY5BrzBWNcZtO3KYYM2CacZtizEDVibs84zNqgpKamgoAcHFx0Sp3cXHB1atXpTrm5uawt7fXqVO8/OMWL16M+fPn65THx8fDysrKGEPXkZCQUCHtPqle9mXXedzOnTvLVV9uMT8rjNt0mGLMgGnGbYoxA/KPOycnx+C6Rk1QiikUCq1pIYRO2eNKqzN79mxERkZK05mZmfDw8EBwcDBq1ar19AN+hEajQUJCAoKCgqBUKo3a9tOYtPF4uZeJHdbKoHpyjbmiMW7TidsUYwZMM25TjBmoOnEXHwExhFETFLVaDeDhXhJXV1epPC0tTdqrolarkZ+fj/T0dK29KGlpaQgICNDbrkqlgkql0ilXKpUVtiEqsu0nUfAEV4SXd/xyi/lZYdymwxRjBkwzblOMGZB/3OUZm1Hvg+Lt7Q21Wq21iyk/Px8HDhyQko/WrVtDqVRq1bl16xZOnz5dYoJCREREpqXce1CysrJw6dIlaTolJQXJyclwcHBAvXr1EBERgejoaPj4+MDHxwfR0dGwsrJCWFgYAMDOzg6jR4/GtGnT4OjoCAcHB0yfPh1+fn7SVT1ERERk2sqdoBw9ehRdunSRpovPDRkxYgTWrVuHmTNnIjc3FxMnTkR6ejrat2+P+Ph42NraSst89NFHMDMzw+DBg5Gbm4tu3bph3bp1qFmzphFCIiIioqqu3AlKYGAghBAlzlcoFIiKikJUVFSJdSwsLLBixQqsWLGivN0TERGRCeCzeIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDtMUIiIiEh2jJ6gFBQU4O2334a3tzcsLS1Rv359LFiwAEVFRVIdIQSioqLg5uYGS0tLBAYG4syZM8YeChEREVVRRk9QlixZglWrViE2Nhbnzp3D0qVL8f7772PFihVSnaVLl2LZsmWIjY1FUlIS1Go1goKCcP/+fWMPh4iIiKogoycohw8fRr9+/dC7d294eXlh4MCBCA4OxtGjRwE83HsSExODOXPmYMCAAWjevDnWr1+PnJwcbNq0ydjDISIioirIzNgNvvDCC1i1ahX+/PNPNGrUCH/88Qd++eUXxMTEAABSUlKQmpqK4OBgaRmVSoXOnTsjMTER48eP12kzLy8PeXl50nRmZiYAQKPRQKPRGHX8xe0Zu92nZYaisis9xtAY5BpzRWPcphO3KcYMmGbcphgzUHXiLs/4FEIIYczOhRB46623sGTJEtSsWROFhYVYtGgRZs+eDQBITExEx44dcfPmTbi5uUnLjRs3DlevXsXu3bt12oyKisL8+fN1yjdt2gQrKytjDp+IiIgqSE5ODsLCwpCRkYFatWqVWtfoe1C2bNmCL774Aps2bUKzZs2QnJyMiIgIuLm5YcSIEVI9hUKhtZwQQqes2OzZsxEZGSlNZ2ZmwsPDA8HBwWUGWF4ajQYJCQkICgqCUqk0attPY9LG4+VeJnZYK4PqyTXmisa4TSduU4wZMM24TTFmoOrEXXwExBBGT1BmzJiBWbNmYciQIQAAPz8/XL16FYsXL8aIESOgVqsBAKmpqXB1dZWWS0tLg4uLi942VSoVVCqVTrlSqaywDVGRbT+Jgic4Xai845dbzM8K4zYdphgzYJpxm2LMgPzjLs/YjH6SbE5ODmrU0G62Zs2a0mXG3t7eUKvVSEhIkObn5+fjwIEDCAgIMPZwiIiIqAoy+h6UPn36YNGiRahXrx6aNWuGEydOYNmyZRg1ahSAh4d2IiIiEB0dDR8fH/j4+CA6OhpWVlYICwsz9nCIiIioCjJ6grJixQrMnTsXEydORFpaGtzc3DB+/Hi88847Up2ZM2ciNzcXEydORHp6Otq3b4/4+HjY2toaezhERERUBRk9QbG1tUVMTIx0WbE+CoUCUVFRiIqKMnb3REREVA3wWTxEREQkO0xQiIiISHaYoBAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsMEEhIiIi2TH6wwLJMKPXJemUTb79don1J5fR3gqXhU85IiIiIvngHhQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItmpkATl5s2beOWVV+Do6AgrKyu0bNkSx44dk+YLIRAVFQU3NzdYWloiMDAQZ86cqYihEBERURVk9AQlPT0dHTt2hFKpxK5du3D27Fl8+OGHqF27tlRn6dKlWLZsGWJjY5GUlAS1Wo2goCDcv3/f2MMhIiKiKsjM2A0uWbIEHh4eWLt2rVTm5eUl/V8IgZiYGMyZMwcDBgwAAKxfvx4uLi7YtGkTxo8fb+whERERURVj9ATl+++/R48ePTBo0CAcOHAA7u7umDhxIsaOHQsASElJQWpqKoKDg6VlVCoVOnfujMTERL0JSl5eHvLy8qTpzMxMAIBGo4FGozHq+IvbM3a7jzNDkU5ZUQ2lUdszNIZnFbPcMG7TidsUYwZMM25TjBmoOnGXZ3wKIYQwZucWFhYAgMjISAwaNAi///47IiIi8PHHH+PVV19FYmIiOnbsiJs3b8LNzU1abty4cbh69Sp2796t02ZUVBTmz5+vU75p0yZYWVkZc/hERERUQXJychAWFoaMjAzUqlWr1LpG34NSVFSENm3aIDo6GgDw3HPP4cyZM1i5ciVeffVVqZ5CodBaTgihU1Zs9uzZiIyMlKYzMzPh4eGB4ODgMgMsL41Gg4SEBAQFBUGpfPI9GmWZtPG4Ttn4O+8+cXsf15mrUxY7rJVByz6rmOWGcZtO3KYYM2CacZtizEDVibv4CIghjJ6guLq6omnTplplTZo0wTfffAMAUKvVAIDU1FS4urpKddLS0uDi4qK3TZVKBZVKpVOuVCorbENM3XoKBQaeQ7xmZNtyt6+v7RpFT75rTl975V03Fbk+5Yxxmw5TjBkwzbhNMWZA/nGXZ2xGv4qnY8eOuHDhglbZn3/+CU9PTwCAt7c31Go1EhISpPn5+fk4cOAAAgICjD0cIiIiqoKMvgdl6tSpCAgIQHR0NAYPHozff/8dq1evxurVqwE8PLQTERGB6Oho+Pj4wMfHB9HR0bCyskJYWJixh0NERERVkNETlLZt22Lbtm2YPXs2FixYAG9vb8TExGDYsGFSnZkzZyI3NxcTJ05Eeno62rdvj/j4eNja2hp7OERERFQFGT1BAYDQ0FCEhoaWOF+hUCAqKgpRUVEV0T0RERFVcXwWDxEREckOExQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDsV8iweMh2j1yWVq/6akW0raCRERFSdcA8KERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsVHiCsnjxYigUCkREREhlQghERUXBzc0NlpaWCAwMxJkzZyp6KERERFRFVGiCkpSUhNWrV6NFixZa5UuXLsWyZcsQGxuLpKQkqNVqBAUF4f79+xU5HCIiIqoiKixBycrKwrBhw/DJJ5/A3t5eKhdCICYmBnPmzMGAAQPQvHlzrF+/Hjk5Odi0aVNFDYeIiIiqELOKavj1119H79690b17dyxcuFAqT0lJQWpqKoKDg6UylUqFzp07IzExEePHj9dpKy8vD3l5edJ0ZmYmAECj0UCj0Rh13MXtmaGo3MuUh772i2ooy91Oae0ZOq7iesaKw5C+5OBp4q7KTDFuU4wZMM24TTFmoOrEXZ7xKYQQwtgD2Lx5MxYtWoSkpCRYWFggMDAQLVu2RExMDBITE9GxY0fcvHkTbm5u0jLjxo3D1atXsXv3bp32oqKiMH/+fJ3yTZs2wcrKytjDJyIiogqQk5ODsLAwZGRkoFatWqXWNfoelOvXr+ONN95AfHw8LCwsSqynUCi0poUQOmXFZs+ejcjISGk6MzMTHh4eCA4OLjPA8tJoNEhISEB8ujMKDDwCFjusVbn7mbTxuE7Z+DvvlrudYh/XmatTZui4imMOCgqCUlm+vTj64ijNk6yrivI0cVdlphi3KcYMmGbcphgzUHXiLj4CYgijJyjHjh1DWloaWrduLZUVFhbi4MGDiI2NxYULFwAAqampcHV1leqkpaXBxcVFb5sqlQoqlUqnXKlUVtiGKEANgxOUJxmDvrZrFD35rjl97ZV3XE+yPg1dR4/2ITcV+T6SM1OM2xRjBkwzblOMGZB/3OUZm9FPku3WrRtOnTqF5ORk6dWmTRsMGzYMycnJqF+/PtRqNRISEqRl8vPzceDAAQQEBBh7OERERFQFGX0Piq2tLZo3b65VZm1tDUdHR6k8IiIC0dHR8PHxgY+PD6Kjo2FlZYWwsDBjD4eIiIiqoAq7iqc0M2fORG5uLiZOnIj09HS0b98e8fHxsLW1rYzhEBERkcw8kwRl//79WtMKhQJRUVGIiop6Ft0TERFRFcNn8RAREZHsMEEhIiIi2WGCQkRERLLDBIWIiIhkhwkKERERyQ4TFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHsVMqt7quC8XfeNfzpwptq/9//w7ZUyHiIiIhMCfegEBERkewwQSEiIiLZYYJCREREssMEhYiIiGSHCQoRERHJDhMUIiIikh0mKERERCQ7TFCIiIhIdpigEBERkewwQSEiIiLZYYJCREREssMEhYiIiGSHCQoRERHJDhMUIiIikh0mKERERCQ7TFCIiIhIdpigEBERkewwQSEiIiLZYYJCREREssMEhYiIiGSHCQoRERHJDhMUIiIikh0mKERERCQ7TFCIiIhIdpigEBERkewwQSEiIiLZYYJCREREssMEhYiIiGSHCQoRERHJDhMUIiIikh0mKERERCQ7TFCIiIhIdoyeoCxevBht27aFra0tnJ2d0b9/f1y4cEGrjhACUVFRcHNzg6WlJQIDA3HmzBljD4WIiIiqKKMnKAcOHMDrr7+OI0eOICEhAQUFBQgODkZ2drZUZ+nSpVi2bBliY2ORlJQEtVqNoKAg3L9/39jDISIioirIzNgN/vTTT1rTa9euhbOzM44dO4ZOnTpBCIGYmBjMmTMHAwYMAACsX78eLi4u2LRpE8aPH2/sIREREVEVY/QE5XEZGRkAAAcHBwBASkoKUlNTERwcLNVRqVTo3LkzEhMT9SYoeXl5yMvLk6YzMzMBABqNBhqNxqjjLW6vqIbS8GUeXY0GjscMRTpl5enTkPYMXTfF9Z5kXerr15C+5OBp4q7KTDFuU4wZMM24TTFmoOrEXZ7xKYQQoqIGIoRAv379kJ6ejkOHDgEAEhMT0bFjR9y8eRNubm5S3XHjxuHq1avYvXu3TjtRUVGYP3++TvmmTZtgZWVVUcMnIiIiI8rJyUFYWBgyMjJQq1atUutW6B6USZMm4eTJk/jll1905ikUCq1pIYROWbHZs2cjMjJSms7MzISHhweCg4PLDLC8NBoNEhIS4H5pHWoUGZbp+bnb/d/EoHUGLTNp43GdsvF33jVoWX0+rjNXpyx2WCuDli2OOSgoCEpl+fbi6IujNIaO6Vl4mrirMlOM2xRjBkwzblOMGag6cRcfATFEhSUokydPxvfff4+DBw+ibt26UrlarQYApKamwtXVVSpPS0uDi4uL3rZUKhVUKpVOuVKprLANUaNIY3CCokTBo4MyaJkCPecnG9qfoe2Vd908yfrU129ZfchNRb6P5MwU4zbFmAHTjNsUYwbkH3d5xmb0q3iEEJg0aRK+/fZb/Pzzz/D29taa7+3tDbVajYSEBKksPz8fBw4cQEBAgLGHQ0RERFWQ0fegvP7669i0aRO+++472NraIjU1FQBgZ2cHS0tLKBQKREREIDo6Gj4+PvDx8UF0dDSsrKwQFhZm7OEQERFRFWT0BGXlypUAgMDAQK3ytWvXYuTIkQCAmTNnIjc3FxMnTkR6ejrat2+P+Ph42NraGns4REREVAUZPUEx5KIghUKBqKgoREVFGbt7IiIiqgb4LB4iIiKSnQq/URtVb5Nvv12+BTbV/r//h20x6liIiKj64B4UIiIikh0mKERERCQ7TFCIiIhIdpigEBERkewwQSEiIiLZYYJCREREssMEhYiIiGSHCQoRERHJDhMUIiIikh0mKERERCQ7TFCIiIhIdpigEBERkewwQSEiIiLZYYJCREREssMEhYiIiGSHCQoRERHJDhMUIiIikh2zyh4AycekjcdRUM6cdXIFjYWIiEwb96AQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDu8DwpVO6PXJRlUzwxF6GX/8P4vH49sX8GjIiKi8uAeFCIiIpIdJihEREQkO0xQiIiISHaYoBAREZHs8CRZkj1DT3olIqLqg3tQiIiISHaYoBAREZHsMEEhIiIi2WGCQkRERLLDk2QJ+GokYD0Y4++8ixpFmsoeDREREfegEBERkfwwQSEiIiLZ4SEeomekvPdzWTOyrVH6mHz7ba3pohpKoNFYnIp5Ca3crUtvMGxLucdARGQMlboHJS4uDt7e3rCwsEDr1q1x6NChyhwOERERyUSlJShbtmxBREQE5syZgxMnTuDFF19ESEgIrl27VllDIiIiIpmotEM8y5Ytw+jRozFmzBgAQExMDHbv3o2VK1di8eLFlTUsIjKyJ3lUwZMc3iLTUtL7ygxF6GUPTNp4HAWP/A1usu+pTS8/+bKVfIi3UhKU/Px8HDt2DLNmzdIqDw4ORmJiok79vLw85OXlSdMZGRkAgH///RcajXEvi9VoNMjJyUFmPlCjyLBl7uaIRybuGrRMUe59nbLMfMP6M7S9uwaORZNThBxF+WJ+UsZaV8ZQhCLkqHJQlHvf4HX1VP2VM44nGZMh76uiGpDe41rbQ/8gyj0GQ8ZUFmNvj+LP9d27d6FUKo3atpxV57hLel89+rkueiRBeRaf8cpU4rYu6zNemgpYZ/fvP9xuQhgwLlEJbt68KQCIX3/9Vat80aJFolGjRjr1582bJwDwxRdffPHFF1/V4HX9+vUyc4VKvYpHoVBoTQshdMoAYPbs2YiMjJSmi4qK8O+//8LR0VFv/aeRmZkJDw8PXL9+HbVq1TJq23JlijEDjNuU4jbFmAHTjNsUYwaqTtxCCNy/fx9ubm5l1q2UBMXJyQk1a9ZEamqqVnlaWhpcXFx06qtUKqhUKq2y2rVrV+QQUatWLVlv5IpgijEDjNuUmGLMgGnGbYoxA1Ujbjs7O4PqVcpVPObm5mjdujUSEhK0yhMSEhAQEFAZQyIiIiIZqbRDPJGRkRg+fDjatGmDDh06YPXq1bh27Rpee+21yhoSERERyUSlJSgvv/wy7t69iwULFuDWrVto3rw5du7cCU9Pz8oaEoCHh5PmzZunc0ipOjPFmAHGbUpxm2LMgGnGbYoxA9UzboUQhlzrQ0RERPTs8GGBREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwTlEXFxcfD29oaFhQVat26NQ4cOVfaQjCoqKgoKhULrpVarpflCCERFRcHNzQ2WlpYIDAzEmTNnKnHE5Xfw4EH06dMHbm5uUCgU2L59u9Z8Q2LMy8vD5MmT4eTkBGtra/Tt2xc3btx4hlGUX1lxjxw5UmfbP//881p1qlrcixcvRtu2bWFrawtnZ2f0798fFy5c0KpTHbe3IXFXt+29cuVKtGjRQrpLaocOHbBr1y5pfnXczkDZcVe37fw4Jij/35YtWxAREYE5c+bgxIkTePHFFxESEoJr165V9tCMqlmzZrh165b0OnXqlDRv6dKlWLZsGWJjY5GUlAS1Wo2goCDp6ZNVQXZ2Nvz9/REbG6t3viExRkREYNu2bdi8eTN++eUXZGVlITQ0FIWFhc8qjHIrK24A6Nmzp9a237lzp9b8qhb3gQMH8Prrr+PIkSNISEhAQUEBgoODkZ2dLdWpjtvbkLiB6rW969ati/feew9Hjx7F0aNH0bVrV/Tr109KQqrjdgbKjhuoXttZx1M/mriaaNeunXjttde0ynx9fcWsWbMqaUTGN2/ePOHv7693XlFRkVCr1eK9996Tyh48eCDs7OzEqlWrntEIjQuA2LZtmzRtSIz37t0TSqVSbN68Wapz8+ZNUaNGDfHTTz89s7E/jcfjFkKIESNGiH79+pW4THWIOy0tTQAQBw4cEEKYzvZ+PG4hTGN729vbi08//dRktnOx4riFqP7bmXtQAOTn5+PYsWMIDg7WKg8ODkZiYmIljapiXLx4EW5ubvD29saQIUPw119/AQBSUlKQmpqqtQ5UKhU6d+5cbdaBITEeO3YMGo1Gq46bmxuaN29e5dfD/v374ezsjEaNGmHs2LFIS0uT5lWHuDMyMgAADg4OAExnez8ed7Hqur0LCwuxefNmZGdno0OHDiaznR+Pu1h13c5AJd7qXk7++ecfFBYW6jxJ2cXFReeJy1VZ+/bt8fnnn6NRo0a4ffs2Fi5ciICAAJw5c0aKU986uHr1amUM1+gMiTE1NRXm5uawt7fXqVOV3wshISEYNGgQPD09kZKSgrlz56Jr1644duwYVCpVlY9bCIHIyEi88MILaN68OQDT2N764gaq5/Y+deoUOnTogAcPHsDGxgbbtm1D06ZNpR/a6rqdS4obqJ7b+VFMUB6hUCi0poUQOmVVWUhIiPR/Pz8/dOjQAQ0aNMD69eulE6uq+zoAnizGqr4eXn75Zen/zZs3R5s2beDp6Ykff/wRAwYMKHG5qhL3pEmTcPLkSfzyyy8686rz9i4p7uq4vRs3bozk5GTcu3cP33zzDUaMGIEDBw5I86vrdi4p7qZNm1bL7fwoHuIB4OTkhJo1a+pklGlpaTpZeXVibW0NPz8/XLx4UbqapzqvA0NiVKvVyM/PR3p6eol1qgNXV1d4enri4sWLAKp23JMnT8b333+Pffv2oW7dulJ5dd/eJcWtT3XY3ubm5mjYsCHatGmDxYsXw9/fH8uXL6/227mkuPWpDtv5UUxQ8PAN0Lp1ayQkJGiVJyQkICAgoJJGVfHy8vJw7tw5uLq6wtvbG2q1Wmsd5Ofn48CBA9VmHRgSY+vWraFUKrXq3Lp1C6dPn6426wEA7t69i+vXr8PV1RVA1YxbCIFJkybh22+/xc8//wxvb2+t+dV1e5cVtz7VYXs/TgiBvLy8arudS1Ictz7Vbjs/89NyZWrz5s1CqVSKNWvWiLNnz4qIiAhhbW0trly5UtlDM5pp06aJ/fv3i7/++kscOXJEhIaGCltbWynG9957T9jZ2Ylvv/1WnDp1SgwdOlS4urqKzMzMSh654e7fvy9OnDghTpw4IQCIZcuWiRMnToirV68KIQyL8bXXXhN169YVe/bsEcePHxddu3YV/v7+oqCgoLLCKlNpcd+/f19MmzZNJCYmipSUFLFv3z7RoUMH4e7uXqXjnjBhgrCzsxP79+8Xt27dkl45OTlSneq4vcuKuzpu79mzZ4uDBw+KlJQUcfLkSfHWW2+JGjVqiPj4eCFE9dzOQpQed3Xczo9jgvKI//3vf8LT01OYm5uLVq1aaV22Vx28/PLLwtXVVSiVSuHm5iYGDBggzpw5I80vKioS8+bNE2q1WqhUKtGpUydx6tSpShxx+e3bt08A0HmNGDFCCGFYjLm5uWLSpEnCwcFBWFpaitDQUHHt2rVKiMZwpcWdk5MjgoODRZ06dYRSqRT16tUTI0aM0ImpqsWtL14AYu3atVKd6ri9y4q7Om7vUaNGSd/NderUEd26dZOSEyGq53YWovS4q+N2fpxCCCGe3f4aIiIiorLxHBQiIiKSHSYoREREJDtMUIiIiEh2mKAQERGR7DBBISIiItlhgkJERESywwSFiIiIZIcJChEREckOExQiIiKSHSYoREREJDtMUIiIiEh2/h8H/ithEwnRtAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "col_date_diff = \"date_diff\"\n", "max_date_followup = MAX_DATES[VALIDATION_COHORT]\n", "\n", "re_followup_compiled = re.compile(REGEX_VISIT_FOLLOWUP)\n", "\n", "cohort_assessments_map: dict[str, pd.DataFrame] = {}\n", "for cohort_name in cohort_assessments_map_orig:\n", "\n", " print(f\"========== {cohort_name.upper()} COHORT ==========\")\n", "\n", " date_diffs = []\n", "\n", " df_assessments_cohort: pd.DataFrame = cohort_assessments_map_orig[cohort_name]\n", " df_assessments_baseline = df_assessments_cohort.loc[\n", " df_assessments_cohort[COL_VISIT_TYPE] == VISIT_BASELINE\n", " ]\n", " df_assessments_screening = df_assessments_cohort.loc[\n", " df_assessments_cohort[COL_VISIT_TYPE] == VISIT_SCREENING\n", " ]\n", "\n", " # try to fill in missing baseline data\n", " for idx_row_baseline, row_baseline in df_assessments_baseline.iterrows():\n", "\n", " subject = row_baseline[COL_PAT_ID]\n", " date_baseline = row_baseline[COL_DATE_INFO]\n", "\n", " # for each score columns\n", " for col in [COL_MOCA]:\n", "\n", " # fill missing values with screening data\n", " if pd.isna(row_baseline[col]):\n", "\n", " df_screening_subject = df_assessments_screening.loc[\n", " df_assessments_screening[COL_PAT_ID] == subject\n", " ]\n", "\n", " # some subjects in validation set had multiple screening visits\n", " # in this case we sort them by how close they are to the baseline visit\n", " n_screening = len(df_screening_subject)\n", " if n_screening > 1:\n", " df_screening_subject[col_date_diff] = (\n", " date_baseline - df_screening_subject[COL_DATE_INFO]\n", " )\n", " df_screening_subject = df_screening_subject.sort_values(\n", " col_date_diff, ascending=True\n", " )\n", "\n", " # find corresponding assessment score in screening visits\n", " for idx_row_screening, row_screening in df_screening_subject.iterrows():\n", " new_value = row_screening[col]\n", " date_diff = date_baseline - row_screening[COL_DATE_INFO]\n", " if not pd.isna(new_value):\n", " break\n", "\n", " # replace\n", " if not pd.isna(new_value):\n", " df_assessments_baseline.loc[idx_row_baseline, col] = new_value\n", " date_diffs.append(date_diff.days) # for plotting\n", "\n", " # plot baseline-screening date difference\n", " date_diffs = pd.Series(date_diffs)\n", " ax = date_diffs.hist(\n", " bins=30, alpha=0.7, label=f\"{cohort_name} (mean={date_diffs.mean():.2f})\"\n", " )\n", "\n", " # pick latest follow-up visit\n", " df_assessments_followup = df_assessments_cohort.loc[\n", " (df_assessments_cohort[COL_PAT_ID].isin(df_assessments_baseline[COL_PAT_ID]))\n", " & (\n", " df_assessments_cohort[COL_VISIT_TYPE].apply(\n", " lambda v: re_followup_compiled.match(v)\n", " )\n", " )\n", " ]\n", "\n", " # keep most recent follow-up data up to retrieval date in original paper\n", " df_assessments_followup = filter_date(\n", " df_assessments_followup, max_date=max_date_followup\n", " )\n", " df_assessments_followup = (\n", " df_assessments_followup.groupby(COL_PAT_ID)\n", " .apply(lambda df: df.sort_values(COL_DATE_INFO, ascending=False).head(1))\n", " .reset_index(drop=True)\n", " )\n", "\n", " # we keep subjects who have both baseline and follow-up data\n", " subjects_common = set(df_assessments_cohort[COL_PAT_ID])\n", " for df_visit in [df_assessments_baseline, df_assessments_followup]:\n", " subjects_common = subjects_common & set(df_visit[COL_PAT_ID])\n", "\n", " # print cohort composition\n", " print(\n", " df_status.loc[\n", " df_status[COL_PAT_ID].isin(subjects_common), COL_STATUS\n", " ].value_counts()\n", " )\n", "\n", " # combine baseline and follow-up\n", " df_assessments_baseline[COL_FOLLOWUP] = False\n", " df_assessments_followup[COL_FOLLOWUP] = True\n", " df_assessments_merged = pd.concat(\n", " [df_assessments_baseline, df_assessments_followup], axis=\"index\"\n", " )\n", " df_assessments_merged = df_assessments_merged.loc[\n", " df_assessments_merged[COL_PAT_ID].isin(subjects_common)\n", " ]\n", "\n", " # impute remaining missing MoCA values\n", " df_assessments_merged.loc[\n", " df_assessments_merged[COL_MOCA].isna(), COL_MOCA\n", " ] = mean_moca\n", "\n", " cohort_assessments_map[cohort_name] = df_assessments_merged\n", "\n", "# NOTE: date resolution is months\n", "ax.set_title(\"Number of days between baseline and screening visits\")\n", "ax.legend()" ] }, { "cell_type": "markdown", "id": "8fd3d767", "metadata": {}, "source": [ "### Global composite outcome (GCO) measure" ] }, { "cell_type": "markdown", "id": "0095f122", "metadata": {}, "source": [ "The global composite outcome is the average of the z-scores of the other measures. Following the original paper, we use the mean and standard deviation of the baseline session to compute the z-scores. " ] }, { "cell_type": "code", "execution_count": 7, "id": "d0e63416", "metadata": {}, "outputs": [], "source": [ "for cohort_name, df_assessments in cohort_assessments_map.items():\n", " df_assessments_baseline = df_assessments.loc[\n", " ~df_assessments[COL_FOLLOWUP], COLS_SCORES_WITHOUT_GCO\n", " ]\n", " gco_means = df_assessments_baseline.mean()\n", " gco_stds = df_assessments_baseline.std()\n", " gco = ((df_assessments[COLS_SCORES_WITHOUT_GCO] - gco_means) / gco_stds).mean(\n", " axis=\"columns\"\n", " )\n", " cohort_assessments_map[cohort_name][COL_GCO] = gco" ] }, { "cell_type": "markdown", "id": "f5f4c274", "metadata": {}, "source": [ "### Final cohorts" ] }, { "cell_type": "markdown", "id": "f6d82712", "metadata": {}, "source": [ "We check the average time between baseline and follow-up visits. In the original paper they report an average of 4.5 years." ] }, { "cell_type": "code", "execution_count": 8, "id": "684e2a3e", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4.616 (± 1.134) years\n" ] } ], "source": [ "dfs_duration = []\n", "for df_assessments in cohort_assessments_map.values():\n", " dfs_duration.append(\n", " df_assessments.groupby(COL_PAT_ID).apply(\n", " lambda df: (\n", " df.loc[df[COL_FOLLOWUP], COL_DATE_INFO].item()\n", " - df.loc[~df[COL_FOLLOWUP], COL_DATE_INFO].item()\n", " )\n", " )\n", " )\n", "\n", "df_duration = pd.concat(dfs_duration)\n", "print(\n", " f\"{df_duration.mean().days / 365:.3f} \"\n", " f\"(\\u00B1 {df_duration.std().days / 365:.3f}) years\"\n", ")" ] }, { "cell_type": "markdown", "id": "e96062c8", "metadata": {}, "source": [ "Finally, we create a demographics table similar to the one in the original paper:" ] }, { "cell_type": "code", "execution_count": 9, "id": "485e9eab", "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
cohortmain (n = 223)validation (n = 124)
is_followupFalseTrueFalseTrue
Age at diagnosis60.5 (9.3)-62.0 (10.2)-
Male (%)64.6-59.7-
UPDRS Part II5.7 (4.0)10.8 (7.4)6.2 (4.3)10.6 (6.9)
UPDRS Part III21.5 (9.0)23.4 (12.1)19.4 (8.2)27.4 (13.4)
S&E ADL93.5 (5.6)86.0 (12.1)92.0 (6.0)81.9 (12.8)
PIGD0.2 (0.2)0.6 (0.6)0.3 (0.2)0.7 (0.7)
UPDRS Part I5.4 (3.7)9.5 (6.3)6.2 (4.6)9.9 (6.0)
MoCA27.3 (2.2)26.4 (3.3)26.4 (2.7)26.1 (3.1)
Global composite outcome0.2 (0.4)0.3 (0.6)0.0 (0.4)0.2 (0.6)
\n", "
" ], "text/plain": [ "cohort main (n = 223) validation (n = 124) \\\n", "is_followup False True False \n", "Age at diagnosis 60.5 (9.3) - 62.0 (10.2) \n", "Male (%) 64.6 - 59.7 \n", "UPDRS Part II 5.7 (4.0) 10.8 (7.4) 6.2 (4.3) \n", "UPDRS Part III 21.5 (9.0) 23.4 (12.1) 19.4 (8.2) \n", "S&E ADL 93.5 (5.6) 86.0 (12.1) 92.0 (6.0) \n", "PIGD 0.2 (0.2) 0.6 (0.6) 0.3 (0.2) \n", "UPDRS Part I 5.4 (3.7) 9.5 (6.3) 6.2 (4.6) \n", "MoCA 27.3 (2.2) 26.4 (3.3) 26.4 (2.7) \n", "Global composite outcome 0.2 (0.4) 0.3 (0.6) 0.0 (0.4) \n", "\n", "cohort \n", "is_followup True \n", "Age at diagnosis - \n", "Male (%) - \n", "UPDRS Part II 10.6 (6.9) \n", "UPDRS Part III 27.4 (13.4) \n", "S&E ADL 81.9 (12.8) \n", "PIGD 0.7 (0.7) \n", "UPDRS Part I 9.9 (6.0) \n", "MoCA 26.1 (3.1) \n", "Global composite outcome 0.2 (0.6) " ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def to_1_decimal_str(f):\n", " return str(round(f, 1))\n", "\n", "\n", "df_age = load_ppmi_csv(utils, FILENAME_AGE)\n", "df_demographics = load_ppmi_csv(utils, FILENAME_DEMOGRAPHICS)\n", "df_pd_history = load_ppmi_csv(utils, FILENAME_PD_HISTORY)\n", "\n", "col_male = \"is_male\"\n", "col_cohort = \"cohort\"\n", "col_age_diag = \"age_diag\"\n", "\n", "dfs_summary = []\n", "for cohort_name, df_assessments in cohort_assessments_map.items():\n", "\n", " subjects = df_assessments[COL_PAT_ID].drop_duplicates()\n", " subjects_pd = df_status.loc[\n", " (df_status[COL_PAT_ID].isin(subjects)) & (df_status[COL_STATUS] == STATUS_PD),\n", " COL_PAT_ID,\n", " ]\n", "\n", " # the paper only report measures for the PD patients\n", " df_assessments = df_assessments.loc[df_assessments[COL_PAT_ID].isin(subjects_pd)]\n", "\n", " df_summary = df_demographics.merge(\n", " df_pd_history,\n", " on=[COL_PAT_ID],\n", " )\n", " df_summary[col_age_diag] = (\n", " df_summary[COL_DATE_PD] - df_summary[COL_DATE_BIRTH]\n", " ) / np.timedelta64(1, \"Y\")\n", " df_summary[col_male] = (df_summary[COL_SEX] == SEX_MALE).apply(\n", " lambda v: 100 if v else 0\n", " )\n", " df_summary = df_summary.loc[\n", " df_summary[COL_PAT_ID].isin(subjects_pd),\n", " [COL_PAT_ID, col_age_diag, col_male],\n", " ]\n", " df_summary[COL_FOLLOWUP] = False\n", "\n", " # combine with clinical/cognitive scores\n", " df_summary = df_summary.merge(\n", " df_assessments, on=[COL_PAT_ID, COL_FOLLOWUP], how=\"outer\"\n", " )\n", " df_summary = df_summary.drop(columns=COL_PAT_ID)\n", "\n", " # append\n", " df_summary[col_cohort] = f\"{cohort_name} (n = {len(subjects_pd)})\"\n", " dfs_summary.append(df_summary)\n", "\n", "df_summary = pd.concat(dfs_summary)\n", "df_summary_means = (\n", " df_summary.groupby([col_cohort, COL_FOLLOWUP]).mean().applymap(to_1_decimal_str)\n", ")\n", "df_summary_stds = (\n", " df_summary.groupby([col_cohort, COL_FOLLOWUP]).std().applymap(to_1_decimal_str)\n", ")\n", "df_summary_stds = \" (\" + df_summary_stds + \")\"\n", "df_summary_stds.loc[:, col_male] = \"\"\n", "df_summary_combined = (df_summary_means + df_summary_stds).T\n", "df_summary_combined = df_summary_combined.applymap(lambda x: \"-\" if \"nan\" in x else x)\n", "df_summary_combined = df_summary_combined.rename(\n", " index={\n", " col_age_diag: \"Age at diagnosis\",\n", " col_male: \"Male (%)\",\n", " COL_UPDRS2: \"UPDRS Part II\",\n", " COL_UPDRS3: \"UPDRS Part III\",\n", " COL_ADL: \"S&E ADL\",\n", " COL_PIGD: \"PIGD\",\n", " COL_UPDRS1: \"UPDRS Part I\",\n", " COL_MOCA: \"MoCA\",\n", " COL_GCO: \"Global composite outcome\",\n", " }\n", ")\n", "df_summary_combined" ] }, { "cell_type": "markdown", "id": "e66e770c", "metadata": {}, "source": [ "The values in the table above are generally similar to those obtained in the original paper, though not exactly the same. We were unable to obtain the same number of PD patients as the original paper: we have 223 instead of 222 for the main cohort, and 124 instead of 140 for the validation cohort. Our validation cohort has a smaller percentage of males (59.7%) compared to the original paper (67.9%). Mean clinical and cognitive assessment scores are generally close to those reported in the original paper, with some exceptions (e.g., UPDRS Parts I and III in the follow-up visits for both cohorts)." ] }, { "cell_type": "markdown", "id": "1a12465b", "metadata": {}, "source": [ "#### Cohort ID" ] }, { "cell_type": "markdown", "id": "85437eb5", "metadata": {}, "source": [ "We generate a cohort ID that uniquely identifies the main/validation cohorts. We will use these IDs to avoid recomputing the same results multiple times." ] }, { "cell_type": "code", "execution_count": 10, "id": "a0d0f31b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "main cohort id: _1606091907888136448\n", "\tCohort patient ids saved in zeighami-etal-2019-cohort-_1606091907888136448.csv\n", "validation cohort id: _7192068301964860554\n", "\tCohort patient ids saved in zeighami-etal-2019-cohort-_7192068301964860554.csv\n", "Do not share these files publicly!\n" ] } ], "source": [ "cohort_ids = {}\n", "fpaths_cohort = {}\n", "for cohort_name, df_assessments in cohort_assessments_map.items():\n", "\n", " # get cohort ID\n", " cohort_id = livingpark_utils.dataset.ppmi.cohort_id(\n", " df_assessments.drop_duplicates(COL_PAT_ID)\n", " )\n", " print(f\"{cohort_name} cohort id: {cohort_id}\")\n", "\n", " df_t1 = cohort_t1_map[cohort_name]\n", "\n", " # save patient ids\n", " filename = f\"zeighami-etal-2019-cohort-{cohort_id}.csv\"\n", " df_to_save = df_t1.loc[df_t1[COL_PAT_ID].isin(df_assessments[COL_PAT_ID])]\n", " df_to_save[COL_PAT_ID] = df_to_save[COL_PAT_ID].astype(np.int64)\n", " df_to_save.drop_duplicates().sort_values(by=COL_PAT_ID).to_csv(\n", " filename, index=False\n", " )\n", " print(f\"\\tCohort patient ids saved in {filename}\")\n", "\n", " cohort_ids[cohort_name] = cohort_id\n", " fpaths_cohort[cohort_name] = filename\n", "\n", "print(\"Do not share these files publicly!\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "3b5b417a", "metadata": {}, "source": [ "## Download DBM/ICA results from BIC server\n", "\n", "Given the large number of subjects in our cohorts, it would be too computationally expensive to compute DBM maps from the notebook. Instead, we will use pre-computed results available from the BIC (the Montreal Neurological Institute's Brain Imaging Center) server.\n", "\n", "The code for preprocessing the T1 images and computing the DBM maps is available in the `dbm_ica` directory of this repository. We attempted to follow the original paper's methods as closely possible, though software names and exact versions were not always specified. We implemented the DBM workflow using the MINC toolkit. For the ICA, we used FSL MELODIC to obtain z-statistic maps for each ICA component, as described in the original paper. The complete MRI processing workflow is summarized in the following diagrams:\n", "\n", "| DBM pipeline | ICA pipeline |\n", "| :-------------------------------------------------: | :------------------------------------------------: |\n", "| | |\n", "\n", "We used a Singularity container with the MINC toolkit `1.19.16`, FSL `5.0.11` (for the ICA), and some Python packages. The recipe file for this container is available in the `dbm_ica` directory.\n", "\n", "**Prerequisites for getting the DBM/ICA results**\n", "1. A BIC account\n", "2. Set up SSH key authentication. There are plenty on online tutorials on how to do this, for example [here](https://www.digitalocean.com/community/tutorials/how-to-configure-ssh-key-based-authentication-on-a-linux-server).\n", " 1. To login from your local machine (on which this notebook is running) to `login.bic.mni.mcgill.ca`\n", " - **Note**: If you decide to use a passphrase, make sure to use `ssh-add` to avoid being prompted for it when running the notebook. See [here](https://www.ssh.com/academy/ssh/agent#:~:text=The%20ssh%2Dagent%20is%20a,sign%2Don%20(SSO).) for instructions.\n", " 2. To login from `login.bic.mni.mcgill.ca` to `ducky.bic-node.mni.mcgill.ca`\n", " - This is because we need `singularity`, which isn't available from `login.bic.mni.mcgill.ca`\n", " - ***IMPORTANT***: Do not use a passphrase here\n", "3. Clone this repository on the BIC server in your home directory:\n", " ```\n", " >> cd ~\n", " >> git clone https://github.com/LivingPark-MRI/zeighami-etal-2019.git\n", " ```\n", "4. Build the Singularity container using the recipe file in `zeighami-etal-2019/dbm_ica` and copy it to the BIC server in the `zeighami-etal-2019/dbm_ica` directory" ] }, { "cell_type": "code", "execution_count": 11, "id": "48313115", "metadata": {}, "outputs": [], "source": [ "from pathlib import Path\n", "import re\n", "import subprocess\n", "\n", "\n", "def run_singularity_on_bic(\n", " args: str,\n", " fpath_container,\n", " username,\n", " dpaths_mount=None,\n", " host=\"login.bic.mni.mcgill.ca\",\n", "):\n", "\n", " if dpaths_mount is None:\n", " dpaths_mount = []\n", "\n", " components = [f\"ssh {username}@{host} ssh ducky nice -n 10 singularity run\"]\n", "\n", " for dpath_mount in dpaths_mount:\n", " components.append(f\"--bind {dpath_mount}:{dpath_mount}\")\n", "\n", " components.append(fpath_container)\n", " components.append(args)\n", "\n", " components = [str(component) for component in components if component != \"\"]\n", " # print(' '.join(components))\n", " components = (\" \".join(components)).split() # split on whitespace\n", "\n", " # ssh to BIC and run command\n", " return subprocess.run(components, capture_output=True)\n", "\n", "\n", "# TODO store username in file\n", "def check_result_availability(\n", " cohort_id,\n", " cohort_file,\n", " dpath_repo,\n", " dpath_outputs=\"outputs\",\n", " fpath_container_rel=\"dbm_ica/nd-minc_1_9_16-fsl_5_0_11-click_livingpark_pandas_pybids.sif\",\n", " dpath_bids=None,\n", " dpath_out_dbm=None,\n", " username=None,\n", " host=\"login.bic.mni.mcgill.ca\",\n", " varname_dpath_ica=\"DPATH_ICA_RESULTS\",\n", " varname_cohort_id=\"FINAL_COHORT_ID\",\n", " varname_fpath_proc_status=\"FPATH_PROC_STATUS_COHORT\",\n", " varname_fpath_dbm_list=\"FPATH_DBM_LIST_COHORT\",\n", "):\n", " def run_scp(source, dest, from_remote=False):\n", " if from_remote:\n", " source = f\"{username}@{host}:{source}\"\n", " else:\n", " dest = f\"{username}@{host}:{dest}\"\n", " args = [\n", " \"scp\",\n", " \"-r\",\n", " source,\n", " dest,\n", " ]\n", " subprocess.run(args)\n", "\n", " def get_var(name, output, sep=\"=\", end=\"\\n\"):\n", " match = re.search(f\"{name}{sep}(.*){end}\", output)\n", " if not match or len(match.groups()) != 1:\n", " raise RuntimeError(f\"Did not find name in command output\")\n", " return match.groups()[0]\n", "\n", " # TODO first check if results are already available locally\n", " # NOTE: cohort IDs might be different, in that case we will have to run things on the BIC server\n", "\n", " if username is None:\n", " username = input(\"Please enter your BIC username: \")\n", "\n", " dpaths_mount = [\n", " dpath for dpath in [dpath_repo, dpath_bids, dpath_out_dbm] if dpath is not None\n", " ]\n", "\n", " dpath_repo = Path(dpath_repo)\n", " fpath_container = dpath_repo / fpath_container_rel\n", " fpath_script = dpath_repo / \"dbm_ica\" / \"check_results_availability.sh\"\n", "\n", " # copy cohort file to BIC\n", " run_scp(cohort_file, dpath_repo, from_remote=False)\n", "\n", " completed = run_singularity_on_bic(\n", " args=f\"{fpath_script} {cohort_id}\",\n", " fpath_container=fpath_container,\n", " dpaths_mount=dpaths_mount,\n", " username=username,\n", " host=host,\n", " )\n", " output = completed.stdout.decode(\"utf-8\")\n", " print(output)\n", "\n", " if completed.returncode != 0:\n", " error = completed.stderr.decode(\"utf-8\")\n", " print(f\"STDERR:\\n{error}\")\n", " raise RuntimeError(\n", " f\"Error running script on BIC (returned {completed.returncode})\"\n", " )\n", "\n", " # parse output\n", " dpath_results_remote = get_var(varname_dpath_ica, output)\n", " final_cohort_id = get_var(varname_cohort_id, output)\n", " fpath_proc_status_remote = get_var(varname_fpath_proc_status, output)\n", " fpath_dbm_list_remote = get_var(varname_fpath_dbm_list, output)\n", "\n", " # copy ICA results from BIC\n", " dpath_results_local = Path(dpath_outputs) / Path(dpath_results_remote).name\n", " fpath_proc_status_local = (\n", " Path(dpath_results_local) / Path(fpath_proc_status_remote).name\n", " )\n", " fpath_dbm_list_local = Path(dpath_results_local) / Path(fpath_dbm_list_remote).name\n", "\n", " if fpath_dbm_list_local.exists():\n", " print(\"ICA results have already been downloaded, skipping scp\")\n", " else:\n", " run_scp(dpath_results_remote, dpath_results_local, from_remote=True)\n", "\n", " return (\n", " final_cohort_id,\n", " dpath_results_local,\n", " fpath_proc_status_local,\n", " fpath_dbm_list_local,\n", " )" ] }, { "attachments": {}, "cell_type": "markdown", "id": "cc42d18e", "metadata": {}, "source": [ "We download ICA results for the main cohort. If the DBM maps are available but the ICA results are not, this will compute the ICA (which could take a few hours), and it might be necessary to rerun this cell once the ICA is done." ] }, { "cell_type": "code", "execution_count": 12, "id": "c6df4ea3", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Some packages in this Docker container are non-free\n", "If you are considering commercial use of this container, please consult the relevant license:\n", "https://fsl.fmrib.ox.ac.uk/fsl/fslwiki/Licence\n", "-----------------------------------\n", "| COHORT_ID: _1606091907888136448 |\n", "-----------------------------------\n", "---------------\n", "| BIDS-FILTER |\n", "---------------\n", "\u001b[33m[RUN] date\u001b[0m\n", "Thu Jan 26 17:27:06 EST 2023\n", "--------------------\u001b[0m\n", "Loaded BIDS list:\t\t(2065, 8)\u001b[0m\n", "Loaded cohort info:\t\t(332, 40) (ID=_1606091907888136448)\u001b[0m\n", "\u001b[33m4 subjects are not in the BIDS list\u001b[0m\n", "Filtered BIDS list:\t\t(338, 48)\u001b[0m\n", "Removed up to 14 bad scans:\t(328, 48)\u001b[0m\n", "COHORT_ID=2228656744226345740\n", "\u001b[34mWrote filtered BIDS list to: /data/origami/livingpark/zeighami-etal-2019/out/dbm/bids_list-_1606091907888136448.txt\u001b[0m\n", "\u001b[32m[SUCCESS]\u001b[0m\n", "--------------------\u001b[0m\n", "\u001b[33m[RUN] date\u001b[0m\n", "Thu Jan 26 17:27:08 EST 2023\n", "-----------------------------------------------------------------------\n", "| COHORT ID CHANGED TO 2228656744226345740 AFTER GENERATING BIDS LIST |\n", "-----------------------------------------------------------------------\n", "'/data/origami/livingpark/zeighami-etal-2019/out/dbm/bids_list-_1606091907888136448.txt' -> '/data/origami/livingpark/zeighami-etal-2019/out/dbm/bids_list-2228656744226345740.txt'\n", "--------------\n", "| DBM-STATUS |\n", "--------------\n", "\u001b[33m[RUN] date\u001b[0m\n", "Thu Jan 26 17:27:10 EST 2023\n", "--------------------\u001b[0m\n", "Checking processing status for steps:\u001b[0m\n", "\tdenoised:\t.denoised.mnc\u001b[0m\n", "\tlin_reg:\t.denoised.norm_lr.masked.mnc\u001b[0m\n", "\tlin_reg_mask:\t.denoised.norm_lr_mask.mnc\u001b[0m\n", "\tnonlin_reg:\t.denoised.norm_lr.masked.nlr.mnc\u001b[0m\n", "\tdbm_nii:\t.denoised.norm_lr.masked.nlr.dbm.reshaped.masked.nii.gz\u001b[0m\n", "328 input files total:\u001b[0m\n", "\t326\tfiles with all results available\u001b[0m\n", "\t2\tfiles with some results available\u001b[0m\n", "\t0\tfiles with no results available\u001b[0m\n", "\u001b[34mWrote file to /data/origami/livingpark/zeighami-etal-2019/out/dbm/proc_status.csv\u001b[0m\n", "\u001b[32m[SUCCESS]\u001b[0m\n", "--------------------\u001b[0m\n", "\u001b[33m[RUN] date\u001b[0m\n", "Thu Jan 26 17:27:20 EST 2023\n", "-----------\n", "| COPYING |\n", "-----------\n", "'/data/origami/livingpark/zeighami-etal-2019/out/dbm/proc_status.csv' -> '/data/origami/livingpark/zeighami-etal-2019/out/dbm/proc_status-_1606091907888136448.csv'\n", "------------\n", "| DBM-LIST |\n", "------------\n", "\u001b[33m[RUN] date\u001b[0m\n", "Thu Jan 26 17:27:23 EST 2023\n", "--------------------\u001b[0m\n", "Loaded status file: (328, 14)\u001b[0m\n", "\tCohort ID: 2228656744226345740\u001b[0m\n", "Selected 326 files\u001b[0m\n", "COHORT_ID=_8939046573348885543\n", "\u001b[34mWrote DBM filename list to /data/origami/livingpark/zeighami-etal-2019/out/ica/dbm_list.txt\u001b[0m\n", "\u001b[32m[SUCCESS]\u001b[0m\n", "--------------------\u001b[0m\n", "\u001b[33m[RUN] date\u001b[0m\n", "Thu Jan 26 17:27:23 EST 2023\n", "-----------------------------------------------------------------------\n", "| COHORT ID CHANGED TO _8939046573348885543 AFTER GENERATING DBM LIST |\n", "-----------------------------------------------------------------------\n", "-----------\n", "| COPYING |\n", "-----------\n", "'/data/origami/livingpark/zeighami-etal-2019/out/ica/dbm_list.txt' -> '/data/origami/livingpark/zeighami-etal-2019/out/ica/dbm_list-_8939046573348885543.txt'\n", "----------------------\n", "| Found ICA results! |\n", "----------------------\n", "------------------------\n", "| COPYING COHORT FILES |\n", "------------------------\n", "FPATH_PROC_STATUS_COHORT=/data/origami/livingpark/zeighami-etal-2019/out/dbm/proc_status-_1606091907888136448.csv\n", "FPATH_DBM_LIST_COHORT=/data/origami/livingpark/zeighami-etal-2019/out/ica/dbm_list-_8939046573348885543.txt\n", "DPATH_ICA_RESULTS=/data/origami/livingpark/zeighami-etal-2019/out/ica/output-_8939046573348885543-30\n", "FINAL_COHORT_ID=_8939046573348885543\n", "\n", "ICA results have already been downloaded, skipping scp\n" ] } ], "source": [ "_, dpath_outputs, _, _ = check_result_availability(\n", " cohort_id=cohort_ids[MAIN_COHORT],\n", " cohort_file=f\"zeighami-etal-2019-cohort-{cohort_ids[MAIN_COHORT]}.csv\",\n", " dpath_repo=\"/data/origami/livingpark/zeighami-etal-2019/\",\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "16debd4d", "metadata": {}, "source": [ "We load the scores (average DBM value for each ICA component for each subject) and split them into a PD group and a healthy control group:" ] }, { "cell_type": "code", "execution_count": 13, "id": "cd1d34cf", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Parkinson's Disease 219\n", "Healthy Control 107\n", "Name: COHORT_DEFINITION, dtype: int64" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df_scores = pd.read_csv(dpath_outputs / \"scores.csv\", index_col=0)\n", "df_scores.index = df_status.set_index(COL_PAT_ID).loc[\n", " df_scores.index.astype(np.int64), COL_STATUS\n", "]\n", "df_scores.index.value_counts()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "225ff003", "metadata": {}, "source": [ "As in the original study, we use t-tests to determine whether any component is significantly different between the two groups. We apply Bonferonni correction to the p-values to account for multiple comparisons." ] }, { "cell_type": "code", "execution_count": 14, "id": "1face337", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "IC14 3.174376\n", "IC24 6.299118\n", "IC28 7.507985\n", "IC30 7.653876\n", "IC6 7.657949\n", "IC25 8.287577\n", "IC29 8.656146\n", "IC22 9.143906\n", "IC12 9.805824\n", "IC16 10.195953\n", "IC21 13.910982\n", "IC10 14.441574\n", "IC18 15.022137\n", "IC9 18.135936\n", "IC1 19.096704\n", "IC7 19.595994\n", "IC13 20.371846\n", "IC27 20.685240\n", "IC19 22.113971\n", "IC15 23.497549\n", "IC23 23.553747\n", "IC11 23.670163\n", "IC2 24.100165\n", "IC4 25.550303\n", "IC26 25.668745\n", "IC17 25.975309\n", "IC20 26.523785\n", "IC8 27.226697\n", "IC5 29.231923\n", "IC3 29.512377\n", "dtype: float64" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from scipy.stats import ttest_ind\n", "\n", "correct = True\n", "p_values_data = {}\n", "\n", "for component in df_scores.columns:\n", " t_stat, p = ttest_ind(\n", " df_scores.loc[STATUS_PD, component],\n", " df_scores.loc[STATUS_HC, component],\n", " )\n", " p_values_data[component] = p\n", "\n", "p_values = pd.Series(p_values_data)\n", "\n", "if correct:\n", " p_values = p_values * len(p_values) # Bonferroni correction\n", "\n", "i_components_sorted = np.argsort(list(p_values))\n", "i_component_top = i_components_sorted[0]\n", "\n", "p_values.sort_values()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "3d9bbf95", "metadata": {}, "source": [ "We plot the DBM score distributions for each IC:" ] }, { "cell_type": "code", "execution_count": 15, "id": "5126563e", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "\n", "x_label = \"IC\"\n", "y_label = \"Mean DBM value\"\n", "\n", "df_scores_to_plot = pd.melt(\n", " df_scores.reset_index(),\n", " id_vars=[COL_STATUS],\n", " var_name=x_label,\n", " value_name=y_label,\n", ")\n", "\n", "ax = sns.stripplot(\n", " df_scores_to_plot,\n", " x=x_label,\n", " y=y_label,\n", " hue=COL_STATUS,\n", " order=p_values.sort_values().index,\n", " alpha=0.4,\n", ")\n", "ax.tick_params(axis=\"x\", rotation=90)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "3259b541", "metadata": {}, "source": [ "None of the corrected p-values reach significance: our lowest p-value is 3.37 compared to 0.003 in the original paper. This means that our replication has failed at this stage, since we are unable to obtain the PD-ICA component presented in the original paper. \n", "\n", "Our top ICA component looks like this:" ] }, { "cell_type": "code", "execution_count": 16, "id": "127c93f9", "metadata": {}, "outputs": [], "source": [ "import nilearn\n", "import nibabel as nib\n", "\n", "\n", "def plot_IC(fpath, i_component=None, threshold=3, display_mode=\"z\"):\n", " img = nib.load(fpath)\n", " if i_component is not None:\n", " img = nilearn.image.index_img(img, i_component)\n", " display = nilearn.plotting.plot_stat_map(\n", " img, threshold=threshold, display_mode=display_mode\n", " )\n", " return display" ] }, { "cell_type": "code", "execution_count": 17, "id": "7a5f18fb", "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAABl4AAAD6CAYAAADA6jrVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAADFq0lEQVR4nOy9eZRcVb32/yQhISRAEgghAyTMMgQRFAVRUZxAL4hXRLgvCCIOKCLXn69evM6i4rBwYgnXK8qkMsrgAOKMgggI+jLIJAEyQ0IGCCQhSf/+6PrUqXqqd6qT7nQ66eezVq/TVXXOPvucs797n6rzPPs7qKOjo0MhhBBCCCGEEEIIIYQQQgihxwxe3xUIIYQQQgghhBBCCCGEEELYWMiDlxBCCCGEEEIIIYQQQgghhF4iD15CCCGEEEIIIYQQQgghhBB6iTx4CSGEEEIIIYQQQgghhBBC6CXy4CWEEEIIIYQQQgghhBBCCKGXyIOXEEIIIYQQQgghhBBCCCGEXiIPXkIIIYQQQgghhBBCCCGEEHqJPHgJIYQQQgghhBBCCCGEEELoJfLgJYQQQgghhBBCCCGEEEIIoZfIg5cQQgghhBBCCCGEEEIIIYReIg9eQgghhBBCCCGEEEIIIYQQeok8eAkhhBBCCCGEEEIIIYQQQugl8uAlhBBCCCGEEEIIIYQQQgihl8iDlxBCCCGEEEIIIYQQQgghhF4iD15CCCGEEEIIIYQQQgghhBB6iTx4CSGEEEIIIYQQQgghhBBC6CXy4CWEEEIIIYQQQgghhBBCCOuNm266SYcffrgmTpyoQYMG6Zprrmn6/Kc//ane+MY3auzYsRo0aJD+/ve/r5d6dpc8eAkhhBBCCCGEEEIIIYQQwnpjyZIl2meffXTOOecUPz/ooIN01lln9XHN1o5N1ncFQgghhBBCCCGEEEIIIYQwcDnssMN02GGHFT8//vjjJUmPPvpoH9WoZ8TxEkIIIYQQQgghhBBCCCGE0EvE8RJCCCGEEEIIIYQQQgghhI2epUuXavny5d1ad9iwYRo+fPha7WeDc7xccMEFGjRokO644471XZWwgUHb4W+TTTbRhAkTdMwxx+ihhx5a39XrdyTWQk9IvK0ZibewtiTW1ozEWugJibc1I/EW1pbE2pqRWAs9IfG2ZiTewtqSWOs/LF26VDvuuKNGjRrVrb8dd9xRS5cuXat9xfESBhw//OEPtfvuu2vp0qW6+eab9cUvflG///3vdf/992vMmDHru3ohbFQk3kLoGxJrIfQdibcQ+obEWgh9R+IthL4hsbb+Wb58uebMmaPp0+/Rlltusdp1Fy9+WttvP1XLly9fK9dLHryEAcfUqVP1kpe8RJL06le/WitXrtRnPvMZXXPNNXrXu961nmsXwsZF4i2EviGxFkLfkXgLoW9IrIXQdyTeQugbEmv9hy23HKYttxzWZq12n6+ePHgJAx46vLlz567nmoSw8ZN4C6FvSKyF0Hck3kLoGxJrIfQdibcQ+obEWjPPPPOMHn744frradOm6e9//7u22morTZ48WU899ZQef/xxzZo1S5L0wAMPSJLGjx+v8ePHr+Helkoa2o111p4NLsdLCL3NtGnTJEm77bbbeq5JCBs/ibcQ+obEWgh9R+IthL4hsRZC35F4C6FvSKw1c8cdd2jffffVvvvuK0n6yEc+on333Vef/vSnJUnXXXed9t13X735zW+WJB1zzDHad999dd55563F3hZLWtTmb3GPjieOlzDgWLlypVasWFGfT/HMM8/Uq171Kh1xxBHru2ohbHQk3kLoGxJrIfQdibcQ+obEWgh9R+IthL4hsbZ6Xv3qV6ujo6P4+YknnqgTTzyxl/a2TO0fjSzr0R7y4CUMOA444ICm13vssYeuvfZabbJJwiGE3ibxFkLfkFgLoe9IvIXQNyTWQug7Em8h9A2Jtf7EUklDurHO2pOpxsKA46KLLtLtt9+u3/3ud3rf+96nf/7znzr22GPXd7VC2ChJvIXQNyTWQug7Em8h9A2JtRD6jsRbCH1DYq0/sbSbf2tPHqeFAccee+xRT171mte8RitXrtT3v/99XXnllTrqqKPWc+1C2LhIvIXQNyTWQug7Em8h9A2JtRD6jsRbCH1DYq0/sUjS823WebZHe4jjJQx4vvrVr2rMmDH69Kc/rVWrVq3v6oSwUZN4C6FvSKyF0Hck3kLoGxJrIfQdibcQ+obE2vpkmdq7XQZojpff/e53evTRR1vef9Ob3qQRI0b0fYXCBsuYMWN0xhln6GMf+5h+/OMf67jjjlvfVepXJNZCb5J4Wz2Jt9BbJNZWT2It9CaJt9WTeAu9RWJt9STWQm+SeFs9ibfQWyTW1ifL1N6TMkAfvHz84x/v8v1p06Zphx126NvKhA2eD33oQzrnnHP0+c9/Xscee6yGDGmXXGngkFgLvU3irUziLfQmibUyibXQ2yTeyiTeQm+SWCuTWAu9TeKtTOIt9CaJtfXFMkmDurHO2jOoo6Ojo0clhBBCCCGEEEIIIYQQQggh9GMWL16sUaNGadGiM7TllsPbrLtUo0Z9WYsWLdKWW265xvvaYB0vIYQQQgghhBBCCCGEEEIIa0Z33CwDdKqxEEIIIWyYXHjhhZIkTLeDBnXae0eOHClJGj68U3Xy/PPPS5Le+ta3ti3z6quvliQNHTpUkrR06VJJ0pIlS7rc1wknnNDDowghhBBCCCGEEMKGyVJJ7SYCy4OXEEIIIYQQQgghhBBCCCGEbrBM7R+8LO/RHvLgJYQQQgi9yrXXXitJ9TlQcbDgOtl6660lVa4UXCqjR49uWh/Hy3XXXSdJOuKII1r2xWfbbLNNU1leNmVR9i233CKpcsCw/uLFiyVJb3nLW9b0sEPo91xyySWSpGHDhkmSBg8eLEk66qij1risK6+8UpK0atUqSdLy5Z1fSo477rge1zOEEEIIIYQQ1i1LJa1qs07PHrwM6uBXkBBCCCGEteDyyy+XJG2//faSqocdPNTgx11uOZ5++mlJ0sKFCyVVD0O22GILSdUDmGeeeaZpvUcffVSStGDBAo0ZM0aStMMOOzRts/nmmzdtw754sMJ67Is68uMxdeRBzfTp0yVJRx99dPdORgjrkXPPPVeSNGLECEnSVlttJUnaZJNOrdWKFSskVXGy6aabSqoemsybN09S1w9ieNAyduxYSdXDm2XLOu33xKvv66mnnpIkPfvss5KkU045pUfHGEIIIYQQQghry+LFizVq1CgtWnS4ttxyaJt1n9eoUT/TokWL6sLSNSGOlxBCCCGEEEIIIYQQQgghDBCWSlrZZp3ne7SHPHgJIYQQwlpx3nnnSZKmTp0qqVLAb7bZZpIqxTtL3CSo7FGMsD5uFNZDhQ9sN2jQoPr/wLo4WFD647ahbmznhl9cOqj1n3vuOUnSxIkTm471/e9/f+l0hNBnMJ0f0K532WUXSVU7xtniMUXMsR2uFeLkwgsvlNTpHCMud91116ZtfFtiiDKIRepAP3DDDTc0bQeZ3i+EEEIIIYTQdyxT+wcvK3q0hzx4CSGEEEIIIYQQQgghhBDCAGGp2j8ayYOXEEIIIawDfvKTn0iqnChDhgyRVOVNIY8EOVpQwKNwB/KruDIexwvl40554oknml6zPvtZsWJF/X8+Y11ys4wbN65pH+R8QXWPGp86Ux54zheO9aqrrpJU5YhZuXJlU/nHHnusQuhtyKM0YcIESdLWW28tqWp/tE/gfeKCdk679fVp58THtttuK0maP39+/X/iH0cLZbEkhwv7Jt5x17A9sD7v/+lPf5IkzZ49W1LyKoUQQgghhBDWJYskDWmzTjtHzOrJg5cQQgghhBBCCCGEEEIIIQwQlkka3GadVT3aQx68hBBCCKGJSy65RFKleh85cqSkSpmOo2XWrFmSWtX1rrJH8Y6qnnJwq8AzzzzTVB7ruVp/yJAh9f/5jHXZFscKdWWJI4b1cL4AKn2OwR0FOA58f+TU4Nwdd9xxCqGnfP/735ckTZo0SVLlNiGWeE2M4lihXRJ7fI6zi/aL64Q4cIfXkCFD6v/zGetSBp+zxOG2ZMkSSVW+JNYnViiPWKVcYptjP/nkk9ufqBD6MVdeeaWkyoFJDODuPOaYY1q2ufTSSyVV7k1ie/HixZKko446ah3WOIQQQghhIJAHLyGEEEIIIYQQQgghhBBCCL3EUuXBSwghhBD6BNwa7ibBmcJrVPLuIkG57qDuRfGOmwTYjqWvx/uNuSL4H5U867Kt18VdOHyOMwA1sdeJY+NYKYf945BxV06cL2FtuPrqqyVVMTdq1ChJlWuE/Eq0e9oh4Gxx54rHsucw8vhpzJ3E/x6Xvi1x7mXxPnUmZog5jo3yeM2x//znP5dUxeJb3/rWlvMWQn/iwgsvlFTlL2P8IB5xqvE+659wwgn1//fYY4+mMpcvXy6pit1rr71WUpVf7IQTTuj14wghhBBC2LhZJGlQm3U6erSHPHgJIYQQQgghhBBCCCGEEMLAYOUqaWW7dXq2izx4CSGEEAY4l19+uSRp4sSJkiplOop0zyeBYp3XrOcuEhTvJacL5XpeFtT54E6Yrspkm5KjhWNyh0y7unBsHCv75TX5LFiPOfxxvnBujz76aIXg4IzaZZddJEk77LCDpNacKzhdyAlB+yT/AzFJ+6N94lZhSXng+VqgMW48jxHren4kXhOD7oRBsU+OCl7Pnz+/aX2OiRjyc3HrrbdKkh5++GFJcZWFvuO6666TVDlViMt58+ZJksaOHStJmjp1qqRWZ5m7R8mDRA6nc889V7vuuqukqt3jYvNxl8+32247SZUDxutCHJFD7Ygjjlj7ExBCCCGEsDGxvPbXbp0ekAcvIYQQQgghhBBCCCGEEEIYGDxf+2u3Tg/Ig5cQQghhgIJCFsWsu0BQ2KKsRWnLeu6A8VwvJXcJsB6qX3I7UB5LlPHMZb9y5cr6/2PGjFntPngf1a8r+/mcunpuF9T+ruJ31THlulvH1chvectbuqxnGFiQx2HnnXeWVCnhyQGBQt5zFeEeeeSRR7pcj3Y4fPhwSeW48JxGQHtvzLvC/+y7VJbHlueGcTcZdSe+d9ppJ0lV3hqPOY9R3EGN+TFC6E2uvPJKSdL2228vqerPaYuMP7TJ8ePHS2rNd8R4gXuFWCBfGnHf+L87XnCzMV56zhf2zevJkyc3HQv5Zv76179KkqZPny5JOuqoo7pzKkIIIYQQNj5WqP2Dla6/NnWbPHgJIYQQQgghhBBCCCGEEMLAYImkrnVqzev0gDx4CSGEEAYYl156qaRKMY4yHRUuSnSU56h3Ue0yvz2uEJYo30t5Izy/BMpd3Cuu5AXqRT2HDRvWUmdyrbCkrtTNnS/gdfX8Np6ngmOnfN7nXHGMlEM9t912W0nVuT/mmGMUBi4o6Gk/uDtQtwOuL885hHrd3SDuSgPapecyItY8TmjPw4YNq//PZ6zLtu3yx5RcYrzPsXg+Gs/bBN7vcC5D6C1uuOEGSZUjzfOcuduTfCq0XRxnuFRow8QdY57jeZOkKs6IExwx7JucSZRNXbxv8XGVY+NYDz300C7rFEIIIYSw0ZKpxkIIIYQQQgghhBBCCCGEEHqJTDUWQgghhN5mwoQJkip1Lop2FLPu9vCcCyhpPVcDrhFX3bN01T4OF1wq4Lkd3EkzfPjwuuq3XZ0om32xnc/BD9Tdc2WMGjWqacnnOBTIg8H+Kd9dP5z7MDC5+uqrJbW2A9wbtFfPXUQM0M7cHcKylIcFPGeMK+zZH+12xIgR9f89VnxbzzPjULdS3cH7JWJ8wYIFkqpzBcQ05/atb31rl/sPoR3XXXedpMpFRRvH6ejuK8ZMPmecYRxhfWKCnC4siZnGccvfY13iAdcmZRMPrEddiDfGMJY4ZagrbkyO/YgjjljtOQohhBBC2GiI4yWEEEIIIYQQQgghhBBCCKGXeFZS60yvrev0gDx4CSGEEAYIF154oSRpp512klSpeVHGMh+9q+Jdme5qXlwgrg52pwuguOVzFOvukEHBiwsAF8vQoUPr/+MEQM1LWa4apkz27Q4ZzwEzadKkpn16ngveZ332D34MnteCa3HCCScobPx8//vfl1Spy1Gpu8us1K5Y/5lnnmkq111ppbxKnn+F7Yhh4sDzNQ0ZMqQlD5I7UUr5ZKC0PYp7r5Mr9KkTuSyIqcY6SlVMc65PPvlkhdAd6I/33ntvSVWbJQ4Z+zw+iF93p3iuJsCxRr4VYoVxadCgQfX/2Sfrsq3nKXPHiztY2c5zvhBvTz/9tCRpu+22azoXGZvChsy1117b9Potb3nLOtkmhBDCBk4cLyGEEEIIIYQQQgghhBBCCL1EHryEEEIIobdAXYsCFqW4q3ZHjx4tqTVPiTtSeN9zNLAfd7rwPgpdPmd76oWyHVUx4HxZvnx5/X9U8QsXLpRUOQJw76D+dUU/dUHZ7HV1VbHD+uyfY6DO1Ac1MfvlGN0VEDZuttpqK0lVzCxatEhS1S5op8Qc7YT3UdDjEqF9ek4jKDldUM/TLlHJ877H5jPPPFP/HyU+bZttcZm5S6fkfPH+ge38WDkX9AfUkRj3fDecW851CO3AHTV+/HhJVRulDeIOcWeKxwnvO7RhxgXaMutT7rx58+rr8T/OUurEtltvvXVT2Y47ShnfS47VxlhvLD/OsbAh8JOf/ESSNHbsWElV/0+eJmLspptukiS96lWvaimDz3B9EXN/+9vfJElPPfWUpCpOjz322F4+ihBCCOuN5ZKGdmOdHpAHLyGEEEIIIYQQQgghhBBCGBg8p/Y5Xp7r2S7y4CWEEELYyLnyyislSVOmTJFUKVxR0KJ8LTlfPL9JOzxvCurBkuIdpS1Lnz8fBS8q/UGDBtUViKjl/RgWLFggqVImk3fGnS7gdfJcGY6riVHj4wbg3KLK93n7uRZcm6OOOmq1+wsbJrfccoskafLkyZKqdoZzBeeL5yTy3C+0N2KSdo3zy3MPuduE9jd79uym/Zf2O3/+fEmd7XrWrFmSKiW855wgLonfiRMnSmp1C4A75nDIcGx8Xsqj4f0LsY1Lgdjm3L/85S9XCI2gkqc/xj3i/TquLs8jRAywJL5wWrrryl1axC2xw3g2ZMiQ+v84U9x9SVnEC/uiDu5oJQ697h5XHDvrcW44V1H5h/7Az3/+86bXxAexB36/iTPzggsukNTZ7mnzU6dOXe22lE2MeR3+7d/+bS2PJoQQwnonU42FEEIIIYQQQgghhBBCCCH0Es+r/VRiefASQgghhK648MILJUkveMELJFUKWM93grIcNZ8rZ1Gkdxd3uvDa86Kg9mc/KHFRGVJf1IYo2pcuXVqfk591Sup4ykb168fideuuqwc8b46fQ84BqnxUxOwHNxHX6oQTTlij/Yf+yR//+EdJVZtFbUvMubrc8zJ4rJbcaCjneQ3uMpk7d66kSmHPkjnraae0T5T+Q4cOra9LHTxPEnPrUzf2xRz7wD6oKzFLTHq/xDnwHFPEsudxcqU+cC0OPvhghYHNT3/6U0lVPNK2iCOPT9oobZM2TCxQDnHOcsyYMZKqGMEBSfnElDsjN9tss5ZcZ0BdeX/UqFFN+6KOuNnYN8eGU4b3vQ9yFx1xRbxx7v793/9dIfQ1v/71ryVV443n0/Oxk/ZLu2ZM415s/vz5dRcnsUM8e95BzwHoeRCp2+tf//oeHmUIIYQ+53m1fzKSBy8hhBBCCCGEEEIIIYQQQgjdIA9eQgghhLC27LTTTpJaleKuWOdzX8+V5I6rAH09z8kAzF2P8hAlLu+7Y8YZM2ZMixqepedqoU7si32UjsFzu6CqBHfEUD7nCucC57Dd/Pmoi7lWYcPmoosukiTtscceklrzl9CmUd/SHnF70S7YjvWJWRS4tCPUv5TjThe2QxVM7iO2J/eMxxzbPfLII9phhx2a6uYxxrFQNuBK8+2oK3VHwc85AOrIuXA1MuXwPkuvH6+5Nu985zsVBhY33HCDpMol4k5Ez+niOV/o12mrtDVcV5RLW/U2yDjCfnHG+PrPPfdcPWfLuHHjJFVjEtu6C4c64nxhLMJRypJjc6eYHzvHRu4Mz3fBuTz00EMVwrrmZz/7maQqZtwZ7TnHiAfGCXevUM6TTz7ZkheMtg+em6mUH4kYpa6HH354D444hBBCn/KcpI426yzt2S7y4CWEEEIIIYQQQgghhBBCCAOD5ZLazTTeLgdMG/LgJYQQQtjIuOyyyyRVanaUrSj/UPPiygDUfqh3PVcCCkN3onieFEAV6LleWKK8pVyUuWznbgDUxoMHD67vy50srIsCkWNhX+5YcVW8Uzo2X596eC4ZVMRenjsMOGau3Tve8Y4u6xP6N9ttt52kVkU97dMdUrRPzy1B7FEO26N295h2hT3befv2XEOePwVYf+TIkcXcKa72dSedx4wr9CmPfgdVsTvfeL3ttts2leP9GXCOOFZcZVybMHD4zW9+I6nqj2lTvPa2i7OF156PyMdMcIeajw98zvbexomBBx54QDvuuGPTuh7TnqfMx2XPoQaU53GHG45yGCtZj7GJOOKccW5f97rXdXlOQugJV199tSTVHWDEiuciIl8S7dJji/HBcwc2/u9uTOKdfeHmZF/EGEtihdih7m9961vX7uBDCCH0Hc9LGtKNdXpAHryEEEIIIYQQQgghhBBCCGFgsELtH6ysaPN5G/LgJYQQQtjImDBhgqRK6Yey1dXtfO5qfHAlLa9L7hDHnS5eLvtDJehzeKM+RmXYOA8+88+zDspk5rnnmDhmVz163VydX6K0nqspUWlybByTz8/vuV64dmHDpJSbhevrCllXwHus8Zp2xfq8Ljm2PMboA4gXd1qxHuXxfkdHR/1/cOWx9yvU0WPO61bKd8H7fi7c3eOuHj/XvC45BcLGy+9//3tJlaOMtug5klwd76p5z0fm+SVoY+7mchgHaIvEoecEGzFiREuME7u8z9jnuNPMXXSU99RLXtK5Xm07slqMsvLwaj5dWw67+WZJlduOsYxz/ZrXvKbLeoWwJnz/+9+XJO21116SWsdI+nde086JCx8riTHiYtgb3yhJ2kPS4muvbfrMnW2U5TFHPLvzhf6BunEsJ5988pqdhBBCGEB89rOf1ec+97mm97bddlvNmTOny/VPPPFEXXjhhS3v77nnnrr33nvXvAJL1P7ByrI1L7aRPHgJIYQQQgghhBBCCCGEEEKfsddee9WnMJWap4V0vvWtb+mss86qv16xYoX22Wcfvf3tb1+7nT+v9jleMtVYCCGEEBpBbeeqelS+pZwrpZwMrrov4Qp1L8/3B67e5zVzz6NYRI345JNP1h0lfMa6EydO7LLOJSUy+/S6tjsWaHQGdLUfz2fhc4pzTD6fftiw+J//+R9J0qRJkyRV+UjIS0Q7dYWs511w15m7P8DdZyUHF+/jCJs9e7akshqeetIOlyxZUv+fbVDg+/scA/vyurMvr3tXc+93hbt0PC8HSmiWrnR+6qmnJFXX6n3ve99q9xc2PMitQD4fH/uAtuq5kmhTvE+cuoPMHSv044y94NuhnGc9V9oPGzasxeHFNiUnmfcNlEXdhh50kKTK0bJ7bTm6thyE5YUUTrUfF5bULC8za28/VitndE1N6vGavBZhbcAVQr+9yy67SKpihBjEGen3dO5q5t6Q14/U7glH1/a3VcO+t3nLWyRV7q7lDzzQtC/KAvoFYpHXjIlLliyRVMUm/dDNuDtr5byom67xEEIYKGyyySYaP358t9YdNWpU3dEsSddcc40WLFigd73rXWu38xVq/+Clh1ONtSs+hBBCCCGEEEIIIYQQQgih13jooYc0ceJE7bjjjjrmmGP0yCOPdHvb888/X6973es0ZcqUtdv589386wFxvIQQQggbGe728PnnPefCs8926v3IpcJrz+GA8pY8Kqj+UKC7o8XdIixdfewKXsqjHrxesGBBvZ78v/XWWzety7FTpu8LUAVDKW+EOwdQETfWpbGOqJRRQLpaGdyZwDl29XLo31xyySWSpBe84AWSqjnecZbQDjzHCk4Yrjs5JFyt67HqTiza3dZb/7+m9RYseFHT+rRD9kuuC9TE1I84gq6cYqwLKJVR/7IvryuUYqu0PtAf4Vx55plnJLW6zjjHHAtLjpVrxbU77rjjutxf2HC4+OKLJUm7797p56Ddopp3V5U7GMnZAMSf5y3yfpy2167f9nj1Nts4Vvp7vk07Z9hjNbcdWtDRteU2teWgifaGJ3d5snMxclZt+0Wdy0VsXztWz7GBup9rcfzxx6+2nmFgcumll0qSxh97rKTOXCuN8NsWuYU2v/9+SVV7c7cJ7Y/3H6n98Da6tv2k2pJmjutE6pzWX6ocLwtrY8ODtdcveLIzGLivq7vIaq/dEcdY+HQtj9LWtm/8cI/WYmh57fVuccCEEAYwL3vZy3TRRRdpt91209y5c3XmmWfq5S9/ue6999769/wSs2fP1vXXX68f//jHa1+BZ9X+wUoevIQQQgghhBBCCCGEEEIIYUPgsMMOq/+/995768ADD9TOO++sCy+8UB/5yEdWu+0FF1yg0aNH68gjj1z7CnTnoUoevIQQQghBkr761a9Kkl7xildIqtT3rtJDxYvqff78+U3roSgHHC6o5XGLMA8286yWcjag1F20qFMzSw4I6uEOHVSEkydPliQ98cQTkiqF+xZbbFFXN7LvcePGNW1byieB0pmcMGzvuVd8yfrM4V1y4wDOBRSQKHbcJcQ551rxPtfyYx/7mEL/Zeedd5bUmsOBduY5U3BIlVxnbEeOGHec8Dnbb731P2ufjNTqIPZRpbvinvYHjfPnex1QGhM7Hr8ll5k7XErOuNIxz5s3r2lJbEGpH6Ge7jLj2oUNH/pXz6nlOVhQx9PeiTv6a9qK50OjPJwx9Pe0tdL4wX5pc8Sd14fPn3nmmfr/fMa61MnzwvD+v2rnwI0sY8jdMtGWO9SWGNj8R4WaxWVkbUkxnDP26/lx2qlTw8Dk3losvbL2erR9zghEM6znXam52Oa2KZ8RdVcrn+Zdz2XUYNgcVtvZmNrORtdeL6x9PnebbZrqgkOGOg61JaPwRHvNLnG8cKyU+2Dt3MT5EkIInb8v7L333nrooYdWu15HR4d+8IMf6Pjjj2/JsbdG9MGDl+R4CSGEEEIIIYQQQgghhBDCemHZsmX65z//qQkTJqx2vT/+8Y96+OGH9e53v7tnO1zezb8eEMdLCCGEsJGAO+LGG2+UVKl/PQcDSlmcLThfULKyPupfaFTlSpV6n/JQDXvOBs/dcPfdd0uS9tlnH0mtOWIAZwzKdZw3W2yxRT2BHg4Dn2sbvGz2jfLf5+b3efU5R6jsS3P542TB1cM54pxRDmpgyuFcoxZmuzhd+jdXXXWVJGn77beXVLm/uK60H2LOcQU8Syg5r9w1UoHm9vmm9T0GPZeQt3dU7J7fqfEzd7a4g6UUU6XcU35sUMr54vPrU15X+WgacVcCsca1fNvb3rba7UP/4/zzz5dUOVHof8lD5LkXcCzyPv02bYPXtDHHc76Qm8lxxwtLHDi+pF7Lly+vt0v6FNYpOcX+UXPHkVK2xemyjS3d+YIcv5bbRW1EozhfiT/qxf0Dx8K16fEPImGD5O+1djG69honyrCxtX9oj7X2NpIftUgmtLBz0VGzhTRnH6ugmQ/jnxH2gdtOGs2hKJhrVpaRtZ2MrL2euKh53+548Tr4rgaNUJeMqBXooYYraGHt9UFxwIQQBgAf/ehHdfjhh2vy5Ml64okndOaZZ2rx4sU64YQTJElnnHGGZs6cqYsuuqhpu/PPP18ve9nLNHXq1J5VYEX7Vbq1zmrIg5cQQgghhBBCCCGEEEIIIfQJM2bM0LHHHqt58+Zpm2220QEHHKBbb721LrKcPXu2Hn/88aZtFi1apKuuukrf+ta3el6BZ9X+yUgevIQQQgihERSnrvr1fA6ocFGssj7qd5wwpfnpUfPj5sChUlLrs59bb71VkjR3bues3YceemhTueCqZJZbbbVVi7rdVfHUGVX+DTfcIEmaNm2aJOntb39703autnenCmpezomr/1Elo1LmXHLMHBvnnrloXRnNtQv9G+zvXH+U756fwV0g7VwZtB+PHafV8UK7ebZpPyU3GVBfVOy+Hqr2xs9YF/dWoyumq7LdZVNy7fix+jmgfym5EXy/HtulHFftpjII/RdckMSNz/FNG6O/5nP6YW+DpbZDW6F/phz263i/Th41tneHW2NM8L/nIyOO2OfWltOFZd3pMsqWrvivWwWs8subl557w51uwDnBfVTqF8LGDflKvF3WnS5YX3aoLWmfNDCcVws7F4PINVS6NfL27C6TYfZ+Y7v3ZCvNw6gG4YSp1W1kPfFMm314naBWXv2Yase6vFa+57e55JJLJEnHHXecQujPLDCH26BuuLUeNYfXi+LwGrBceumlq/38ggsuaHlv1KhR9e/mPeZ5SavarLOyzedtyIOXEEIIIYQQQgghhBBCCCEMDPLgJYQQQgjd5ZxzzpEk7b777pIqZSqqdXd1oFB1Rwvvz5w5U1KV6wWFLeUCylbPE+HqedZ7zWteI0n685//LEn6y1/+Ikk64IADJLU6cXw5evTouuq+5K6hDpQ9Y8aMpn27Ct/V+ByLz/3P0pXM5BbYcccdm8pje1disx+uDaodctZwLU899VSF/sMPfvADSdKee+4pqWoPtDfaBe0HJxTtEtcF7YGl55bw/CYl58uiRXtLKju2oBQnOHOIdfbP8Tz33HP1/2mjtHWU7Z5zouQ+c4V8OxeOxyZ189wXuBdYckzudvBrxWvW59qedNJJXdYr9B+uu+46SdLEiZ2JSjx+3JXh8chrPse96fmHgLimzZba/sO1PGcuuqflb1pbuhAe0f9EtYjuNewPf2iqMzlgnt1vP0mVgWAMOx1thaK+d2eL5beo79CWLvJ3p5u7ezw+uVZHHHGEwsbP6Nqy3uxol26BmWKvCQoa3EJblhKrDLPXJUOkv9+V48Vj4vk27/s+RxfqxnYLa8tZzeuNfqy5GrDDDjsohPXCDrVRa2HnoqPm0vIwJLfSGMab0bXlnrXt7+vi3nVY52dsQhiSF4pw8dD2IW5cHDKht8iDlxBCCCGEEEIIIYQQQgghhF7iWUmrnwm6/YOZNuTBSwhhg+DGG2+UVKkSwefCRs0+kPj9738vqVJeuoqYucnf8IY39G3FQp+D4tTnVud9d5KAK9WZU57cB7gwXEVMW8MR47lceE0bfPLJJ5vef+UrX9n0/oMPPihJ2nnnnSVVce2q4sbP/DXrUhYqYfbFeuyTY6Jv8br7sXnumG233VZSldOFc8f7rv5HlY8a2OHaeb6b0D/w3D20N79entuntGR7L9fLKblI/HUpBsE/xyFA+0dNz/LJJ5+sf0YeG5bt3Dnddb6U8HLdRcY5xImDc8Wdd54Txs+957gK/R/GJq4x+X+4hu7KpO25I81f+/2TO2K87f+9lmMG0f7E2pKWhGLX86Q4jcJ6tq2nnXj1q5vWpUz2NY7mTSVGWyVclV9S71tujeXPNq9GfXbbpnNHfq48Hv0+ImzcPGE5Hoa5C8SXWGJot7RX2iMNHLwds70HG7ibBZ5fzTrP2/u+TSmAS3XyWMPpMqz580ELa8Usai6Wfuyyyy6TJL3jHe8oVCCEHvKW2n2Zx1+tLQ8a3bkc1s7txZIYoNxrO6T9a//XYn70rOZdsvTMae50ocvQ6EHNG8yMAyasJc8rD15CCCGEEEIIIYQQQgghhBB6hTx4CSEMdK6//npJ1ZzRKF9R2vkc07g/UNi/6U1v6rvK9hG//OUvJbUq9N3l4DkkOJeHHXZYn9Qz9D2nn366JOnaa6+VVM17Tz4UKCnSyVdCfKHupW2hJiYvhecvYTvaHgp0XB6s53kvUCujsp81q1MGxfz9Xt9nnnmmRT3PvtmWsijb+w7qQt14HyWzr0c5KKPZbsmSJU3nivc5l8yHT308bwVwPFwrrmXoX6DqJs8J0NbJ/YBS1cco7689H5Kv53jMeh4T2mMph5HnMmK7XXftzBSxYMECSdK8efMkdcYDbXjs2LGSpDE1lT/butvM3TcsiR3Gc1/Pj6l07OzHz7E7/vwcs39ibOnSpZKqaxmXWf/nkksukVTlMWNMYqxzp5k7w8DvIR13dzIO3FlzQLpY380mw5pNVvX1O0wx70rf5WpV/Y5WM54yo65MZsmGntOC16j56cJcjV9bLrTVptbGVo8Td45xLbg2Tz/9tKTq2h133HEKGx8tzW6ELV0h7+97AZ4nxW1lm/HPDrUlGZRosXOal8/V+oJGC5fbudzx4kkmnJL638FNxjGy3cLa8tHm1dk9vRPf40JYZ3jbHW3v+2Dlces5Xty2csKgKoZxetXib2QtZOsuT9vUw3CQx1sp7kLoLitUJeMr0UNDVR68hBBCCCGEEEIIIYQQQghhYLBEefASQhiYnHfeeZKkXXbZRVKrOpe8C4DDhSWKuxtuuEGSdOihh67jGq97OBaODZUhzhfPf+MqXpT8nNv3v//967jGYX0xffp0SVUbQHnq6l4U4Lgx+HyHHXaQ1Kr2pY15zgTPF4FqHhcAbhB3mRDX7pyZM2dO02sU9o1uA5/Ln32yLXV1x4E7Wfic7TkG9ok7h/dZsp3nldhqq60kSY8++qikyvni7iFgO+bFd3dS6F/Q7lCgcv1wT9A/e5t3hxbrucOq5BbxfGbunPFcM8QF7Yo8TaW8K5Qzbtw4Sc05ijzXitfFoS4o3TlnnlvFy/EYLeF5cTiH7qRzJT79HNeKa8e1TI6X/g/Xyp1bPqaw9Fwupbbh/Trv314bB0bX9o9g11M58PkwV/EDCt/aS5wvqxPquuC//totLxPtdTt1PkvkxQtry5oqf8mzTS/r6mPi2V12pT7I+6qo9jdOZtauL82vqEYvObEcX390bTmlttzk5bV/Dq4tX1Zb8r1wbm35aG35QOdis5rzZbPHau/PkVY81fnvwtpblmOlJcALcV3M/ULwuGvAy6u9T0iyHFIbv7lfuOaaayRJRx55ZGGHIawhb6qNSiX3iLu0ZOv5eOSDZKNDZoltM7TrXTqeI43xc5DH3661Y3kouV7CGtIHhvc8eAkhhBBCCCGEEEIIIYQQwoBguaoHfKtbpyfkwUsIoV/x3e9+t+m1509AYYeK2F+zRNkK5EXZEHO+UHcUT66oRtnPufD5t1F8ci5RIXKuP/CBD6yzuof1A9ccBSpthvhA9YtCHEUquRxoIx5nrjJmP+S1wK2B08bVxB6nrlAHlLGPPdapTEStv3DhQknSjBkztN1220mqcq+wrju/PLdFqQ645XAIoOKlPI7NFdGu+kV5zbl88sknm86B5yJgfVfhh/7FueeeK0l68YtfLKm63u5ccaeVK+tpL+DuD8ffd8eUxw714X0cVw880Kn63XvvvZvWw7HlavXGXDOed8b7AXec3H333ZKqnDCcE/bpdXeHiztr/HN/391ofgysj6OF+nPs1Jt+h2t9yimnKPQv6J+5ZiXnirdRh362ND4Awly09C7C5/NBrODS3Zp0vaO2LAnkGxW97nRp2Qc7LyWYKc3Jb3Vyp0vHrKaX9Y8n3H+/uoJz6O484ooxjWvFtQsbB383pwvNbJiv2PKGbVBaAu15EyJh29ryBbUljpfxteUcW4/3H60tR9eWw6tfwoY91bwvr8NmjEHjm9/fZGnt84WdyxWrmrcvOWQ8t0xtWStFK2s5OYfVxnvucxnbLr/8cknS0UcfrRDWij1r7hB3qLSDwcrb9jBbuoNmiVr7gkLfUEonw+oLa8vRNYdaywxRk2rvzIzzJXSP51U2Ljau0xPy4CWEEEIIIYQQQgghhBBCCAOC59T+wchzPdxHHryEENYrl1xyiaRKzbPTTjtJKrs2ANUw6kZ/jSr4qaeeairvyiuvlCQdddRRvXcQ6wjqitrf89uMHNkpT3EFvsO5Y73Jkyc3lffzn/9cUuUmOO6443rvIMJ6YcKECZJUd4WAxxEK8JLLAuUqrgzPa+HuEtT1tC3UxswNT5yzX8pnCZ7TiXIpZ/bs2XXHF3XxfdLeXZXveRwoE9iOfXIOUevjjAHOjR8DEL/kjPE45XMcMq64Dv0Dd2uUcrm40wV47e6R0mvWL+V+ccU++yVGPVfQv/71L0nSE088IUk66KCDJFXtEnW6OwAa26s7SNgX+ZFuvvlmSVVM4XghRnDGuWOOct3N424Gzxnhbh8vx50xLOkrqBc8a/Pph/4Hbe3xxx+XVOXU8nw/XEO/Pyo5zDz/0P21MdTFwKN57fPbs4JNRt9hSnYE7gje1by6hqpS9WJwqY9Yvk/PJ1OaKJ86+c6p1JPNL72u7oor9UU4W1ifeOI+nGsXNg5clU4zG2H5jFoSNLBcWFs2KuKlKshc7r5NrUXiLtHSQs3IJURBi+z16Ib1ljbXkaJp/PUYq/UXY1mBfVgd/NhYklbm0dqy5i7TzM7FguebV6df8/sJ/x4XwlpDWPhXDs/N4vELnr9ouS2JndXZBJavfldeZIm686VdzqUQCmSqsRBCCCGEEEIIIYQQQgghhF4iU42FEDZarrrqKknS+PGd8+W6ahc8VwXqYlSNfO4qdJS4qCBdcbshQF05NxwLx4ZCGXAfcG44V6gPObelc0y5XJu3ve1tvXUooY8455xzJEk777yzpHJ+CNoEnxMfKFTdQUbOJNqY545BRe9Kc+A15bjzBXV+qR+YMWOGpKpNL1++vN5u+YyyXOHs8YMzAYeXq+jdMcOxjRs3rukY/JiAc4vKl3PpfRnn1s8VDhiu5amnnqqw/iFHFm3Vr7/ncKGd0a+6M6bk1nBnDLTLWQG0M2KZ/W+zTad2f/bs2ZKk3/zmN5Kkl770pZIqBS3bN6rc3TVGbJBX6bbbbpNUjUk47tg3dXGXptMu50vpHPi5oj/j2lAv3vccMMD6XOvQ/yCOiEOurY8pnhPPczGVHGkP7bhjZ3m190smkxani9FRU+CSL4Wlm066Smcx2t5DkDyyXU4MT6HieST8da2Oyxc1vayvNunee5uKI+48N5IviXfGWOKOaxc2bK677jpJ0vi//lWStPBlL+tyvTGuqCdWRtiKtEeCbXRtieWL9s32O2MfmWNLWFhbzrXXS225UHqutnMcKI/ZJtS1noul9s8ICzbPm8Ryli0fqi3va94fH0+uOVPBc3fiJiXWuBZHHHGEQugOM2v3UZPcKVnKR1SythGPxPeiwvteXhdllpwuD/7gB5Kq8X3Mv/97S1GNr4d6WHKsHcn1ElbPCrV/sLKizeftyIOXEEIIIYQQQgghhBBCCCEMCOJ4CSFsdPygpl7YsaYqBFSIKFBR9/i89ageUDkuWrSo6TXr4xZB5egq4ksvvVSSdMwxx/TOgfUi1I358VH5ciwonVB8umOFHDB+rlhyDlBSsUTFyNzCXKuTTjqpF48urEu4hjjAcE+AK8VpS7QJ2k4pDmkrfM72rOeOFZ8D3p02KOBdMevuEObznzp1an17/2zPPffssg7EDfty1S6U8klwbNTNnQ1+jH4uUdGzPa6hknOBa1fKGRPWD+T6Qc1NDiDGLvpfV9jT73L9yeXDdu7MKuUxKeVe8XwLuDVQmdMuGXOpz5w5nSrh3/72t5KkF77whZKk3Xffvan+K1eurLd1tr3//vslSf/v//2/pjrgYGVfHu/UjX7Jc7B4/qN254LXLNkf14ZYKinzOR62IzY9N1ZYf3A/tMsuu0iSXvSiF0mqrtmTT3Z6SbgX9Dw+3o/6/RJx+Hit3buzxcW7g0rqYCS6NdXvwtpLd7xsXYuZsTX3B85I3CEPPfJIPdehXve65joxjz2VcpV9yfHin9deuyuH1cY//LCkauzjHBIv/j7nlM8Z8+jrcNtxru+44w5J0sO1/fTH+/BQhtiqc9ddkqSZ++4rqcHNVQu9bWp2jnrv7nlQaM9D7fU2tj6BMOWRWkUeqL3xj9rSnTDsYJG9X9tuxX1FB0p9U8CSMrG2HG119lj0wPccL7X9zqxtN7Y2Hvt3VcZxH+eh5VqEYFxzzTWSqjFyl9r7Q2txNe5J26DkSPOvJP5+aWwc2rBeId9TybyJe5p7s2G33NL5unYPOXPvvSW1diFu8vzNhRdKqr6XHXnkkQqhkSVqGKNWs05PSG8dQuhT/IELN408JPAfRfmixoMUfkiZN2+epOqmlB9i+ELoiVJf97rOcn/zm87XfOnuj1A3/xEK/Idgv0Hnyy8PbvgxjAc1fm45RyQ+pXy/VqH/wrRUXFNusLnJ9GTR/sMlP4QyFYi3PW56/TX78Qctjv9AShvjYQgP+/jBlB+3aau0TfqLwYMH1//nM9ZlKieWlM254cffdlM2eTJmjpVzRZxxzny6Q8556Udjh3hmP9Q3U46tX37+859LkiZNmtT0Pv3trFmdv8jwIINk9YxZ/sMIP1LSPqE09Zi/9gd8Xq4njPf2xo+6/NDLVHo333yzJGn69OmSpP33319SZx/CeHv77bdLqh52sk+m4av/YFzYtz8MAv9Ryacia3du2I+X60m/GQPpM4hdrq1fE679v/3bvymsH2hTXGN/YMn9Dfc7tFX6Z9YHb5M8cGEtWkBxFpbGH5Eaqf22S5Jsn2Fo+3/+U1I1dvq0n41tn//5PczrMMZ/KPOMr/7Ddu1XqOW1JT8eLLLV6rnNa3VjnIbS2MW55nOmOqXvc+EGx+z9Rdgw4GEhbZnrPrz2QG157Z7pvv32k1Q9P5lYC4Z6+2UqMf/VdHRtubC2XG7v8xBjZx64ODxgoYU3TC0mSYtrFblP1QMXlgSsxxh13aG25KA8gTi/+PqDl5m1ZeezRi2Y17zb/Wqxwb0v94EuXnARA9ciBAdRzcSJnU8LeRD+0A9/2LnCu97Vuay12W1qcTXIHrx01D73IW9YaSx0Gqfrs0GHMWlh89saXxMoMLUe36d8yt4VtYe+dRFAre/5Z22aTOJl59pYQzmcm9e+9rVtKh8GCplqLIQQQgghhBBCCCGEEEIIoZfIVGMhhI2GH//4x5Iq2ygKOE/WjZrBE5+iJked6yog1sctgpJ+t92QGTGVWefz6v5sz/YpjMCnZ/LEwXyOupdzhSIUV5GXh8KKa8Fr1MJcu//4j//o2YGFdQbX2KcAcwU4oFBkPeKHNkEbpE3Q5lDZ8RpFrKuK3U1C+Z743tseiixUTnPndiZHRVHP8YwZM6ZFbc+6ru7axJSErpwunSNX3dPn8D7nwl1C9FWU61OWlRIMsz712nbbbZvKDesH2pFPY4lrgvbmjkFXqBKbHivtnFDgyvh2U5OVykcpiEOAuGEcefDBByVVfcPLX/5y3VKb3uGxx5Aad0JsURZlt6sLbd2nFPRz5ufK8fJ9ylIvD5j6CHcS9eY1zhiufeh7Lr/8ckmVKwKlqjt1vQ0xFtLf0669n2f97e7r1JzPrU1VufoWp5Y5UTpqy4W1txHMj6vdf21rbmx3Z/mYOGTIkPr/o267TZL05Etf2ly32j5HM4UTO6/RYSpiRMb1KaDsNSDWp07uQPcpx3jN/cCIEZ3SZp/ujfL82lEO1/roo49W6P/glsTByD0N15/Xw//yl871arH7VG3sfLg2beA2NdfHqNqyPq0f7pKFtuO6daa2HFHzi4yuLd3p5Q2eBt7oPsFy8mht6VON+TRnD1sdRteWrv5n3zbV2IJazOLVeXHN5c39A2OPT4fJ9z36NX8dAlx55ZWSpClTpkhqnQWA2Szu+973JEnPv/e9kqrwGmlNymcHq88IaFMJDis5LxsdL8Tek02L+vIFNQc5ji/GferOa8YejwN+9yB+dtttN0nVTAU+VS/n6qijjlIY2CxX+/s/b+JrSv/95TGEEEIIIYQQQgghhBBCCKEX+et//VfbNARLly6VzjprrfeRBy8hhD7B1duucGWeWtQ+qIpRN6AuRyXoSnvWw1Gzyy615Is2AW+7vA79CerKsbkCn2OdPXu2pErhgRKEc8y5Q33o891zLlGU+LXh2oX+x9VXXy2pukYoEFGxowbimvo1Zj58lN2lPBKew4X9UI471FjPnS6ecNz3hyoJBwxt3HO+jBkzpv4/CmfUlmxL34B7xvNBsR7xUKo78JpySufGzx2vyV+DO4D4ojy/VuSm4Zpxrd/61rcq9A3f/va3dcABB0iq2i435lxHxi5iyPOK0L+6wr27+JhZSizv+Rh8e5bEjbs5GB+o54wZMyR1Kg/5v1GV3whlUXZ385S1O7aSc6YE9fL7BMrhmrFeKQ+UOwa//e1v67TTTutWHULv4O2T/trjy9sKS8aDUpvg/fp9U20/PpWEC9hJGI7y0VM6TKopbqHksHTHWlfwGSrge2ruOvbJcqjNwe85XHap9VFb2pjkccf7rrr33Ik+hno+M6A/8HtMtuM+IM6yDQOcSXvttZek6jp63knaD+pzz+G5Xa09026W19rJw7V7uW1qDXdKbVlvVS5HnmXv0/A9QGSfL6wtH1OL0+UJc4vVVf7kwai5c8Y8VPtgdG3pCcnZ8MnmcjHYvLB2P8g5w0XEfSKvfRYHziXjNQ7ruMYC0GZ89gz6Z35foS3d853vSKpy3fF9kvVYPv1kZ2N+uhavTx54oKQqrCaZc63+QWPG+1rMPmG50MbUcrJ4vl7GEGDM8tka+J2DuPFj8HtJzk1/zvcbNj4Gt18lhBBCCCGEEEIIIYQQQgghdIc4XkII65QzzzxTkvSKV7xCUqsiDpWCK+l47UopFHOoFVEBoWRFNd464W7z/PgldXB/wN08HCvvM/cpSo3ttttOUuVe4Jz6PN0oo1CEuOsAZQn7dXUz1/KTn/xkrxxnWHsuuOACSdX8tYCCECUiykPaBNfWlenkNnBnCmohVx252ghcdYyqiP16vgt3ffA+cU88l/JidFU227o7x/NBAefK1bmukHKlFbAd5wpYj3PLNZg2bVpTvT1flbv92C8KLq79iSeeqLBu2WqrrertwJ2HXD9iiOtLm3XVIa4Kd6qUXCHe7nw9jyVgjCzN/e6x6U4c9tcYDz42ANtSVrtjoW7+Psfi+S78cy/fzyX4uSamqSc5CLh/cJcn15oxk/JC38G18THJxwofm0qOMMoptdWd//UvSdLjO+8sqVVcz158vvuFteWuNZcpeNt1Su6xxvHJ42Gf2j54/fdafjO/22W9MXY/7X1Ju6XX1XMjenyVHGr0G2xfuo8P/RPctjvXYsOdzA79Je0C17HnCPIxdYeaQ4bt/lFzeE2p5VUZs7C2A+xlo2vLRkW91JrbxW1sDflXltRcNY9a0aPuvLOpbsNrbfT5miv79tr92KjaPhnZ3HyD64xjm2qx5fmSiBHycHieJMfv1eOMDp7PBEruUMYovgt19z5rmwceaNrfo7V4xRXGEp5VFV+keln6m9907rN2v+p599rVwd2Xfq9YGpN4n7qH0BfE8RJCCCGEEEIIIYQQQgghhNBLxPESQlin+NzNrlJEMctrVyn4vNyoe1ApoCp+sjb36IIFC2p76tz+T3/qVEEsX76qtp9m90d/hLqh4EDh6Z9zLlGIbLPNNpIqNS8qM88x4LlgSsprf515uPsPE2vKInCFNm3C55UnHwWuJ1R1tAFXpnrb8bwlpXnqUUQSn+7qcOWsq5JcCUksbL/99pKku+66S7vvvrskafr06ZKqOGFbPyZXPHmdqStOAY7R61g6F8CxUT7nkLjE8YIzB3Uox8p6wPEQt37tw7pjiy22aHFIgSvWuZ6jRo2SVFYXOiXVeClfgseOO1ZQCnp79vq4cwtKx9v4mccSZZFXw9WJxC91IzY814Sfi5JTzl0MDvtjzvJ2Ss92xxtVZN9xzjnnSJIOOuggSa2Kb9o1bQ2nmd9Telvy/pprS/m0GXIv/L/a/Q7KdUA8P7V2z0kGPI+JUq4wb4u4PXAyc1yNn5Xuzfat1cGPydcr4S5QlpwL+g7GVs99VKoX5RC/HJPnfvK+jGt/6qmnrrbeoW/BVe/XlXsVbz+e88Vzcfo9UinH0KC//12SdMeLXiRJmlJT0JNLwtOqlAwvJRaqUuBv+be/dR5rzTnibjN3i+1Yiz3imbyKxEzdiVJr837v66+5byBGPH+Sb8cShy39H9cqDDwuvPBCSap/N3InL22X74l8H3SXfanN049TXuNYJUkravF6Xy1eR1v9lkj6V62OfJfbrLZPd1NTtucTLdXNnV8cG44y4snHZeKNc3fCCScohHVFHC8hhBBCCCGEEEIIIYQQQgi9RBwvIYR1CioEV+ShzkGtgwoBhZ/nN0CVgMKK17g6cLqgbvjVr5qV9qV69UdKdXOHCsfKsXNuUOeikOIccy4pn/JQaFEe5bjauD+fs4EGaiBXy3GNUQHTFngfxTmKQuKHHEkooWgTqP5wZbiitpQXgv242pj3Wc/j2xXtPlc4quA777xTO+20U9O2tNuS2p727fmiPLcL77O+x4HPl89yfk0p7Wpgtudcs/748eOb6u15LugLuYYouFxlFtYdS5YsqV8vH6u4Dt4+SrjSDiWf59ziurMs5Tfy/dHuWLoLztXplTu063pCY8z7Z14WTjt3lviY45RyuLgjln6NJbGP28gdNaVj8+PwsZDyvT8N6x53QQBtgWuMA5c4oX91R6+7m9ypRhtyZ+RetZwM3i+7O8uXpdxLpVxNjE++XuNnpfnqXf1eygtV2t7dQe5o4Nx4TjdXHXsut5Izne3cxQ2lax/WD9dcc40kaYcddpDU6ojiOno/z3X07xylGQ14zf0d4wnlb/GXv3SWW8tp9FxN1X5LzeX/olqs0k49JukLuO9lTPzXv/5Vz1vjdXPHS7t8GdwPcJ/Asfj46zkIfXvOrd9fEuN+jKXcFly7I488UmFgQDzRBj3u+O7y6KOPNm2HM5i25P04bbDkcAP6+4677pJUxS/x/OCDD2q3Wm4kxm3Gc3cVU7bn+fU+xe+PORZmFuBYd911V0mtzjHOlc9cEMK6II6XEEIIIYQQQgghhBBCCCGEXiLSkhDCOgWFhbsuXO3j89P7HMKuakCtgJKJ7V3p6q9RO7Cfiy++WJJ0/PHHr83h9SrUBdUwdS2pdF2J6Xk0UBl6ng1UvZwDFFRsh/La3+dahvXL//7v/2qPPfaQ1Bo3OFdcqc01dFcUuZG41rgwwBW37K+kKORz2i6KJ3/teSnA2xqqJra7+eab6/vj/xe/+MVN63quDHBHgOeAcceLx5X3Xa6IZHvPHzVnzhxJldoSBRfXwp0xKMFw+5TyWfzv//6v3vOe9yisO5555hnNmDFDkrRtTamHsp42iduMduOqcleT0/8+UVPp0l7cieXXnWUpv4KPdaX+mnrMmzevqVxX9rLekCFDWhSOXjfK2mWXXbrcJ3VxRbsr6D0mgXNNLHIN6N84p+NqimhXAYPvh3JRJ3sOC+bt5/4lrHu4xpz7CRMmSKquAf0m/b07xDy/BG3DxwXK8Twq7XIyQSnHl7ex0narywFVcqj4507J0eIxXtrOP6dvI249fxrvo9Z3xwOwPteEa0l8cq1LjriwfqA/dUcL+P0l/ba3Q7+H8pw/LN0h7Up7YhXIceQ5w/y7EP085fP5smXL6v9Td8Zjn6XBHXGu9qdu1BUnaynXFN+zWNJPrem59PwclMe1CwOHk046SZJ03nnnSapc8nzf4zsIDpTddttNUqtTmbbk/bmPQz72uXuFGGichYP/GZN4zbZept//lhyjPqsDrx988EFJne42qYoX7iGZqeD973+/QljXxPESQgghhBBCCCGEEEIIIYTQS8TxEkJYp6C+ceUSuCIVVQNqHRQXpXnwUTeAz0mNssrVSaiG+oPTBajL1VdfLalV3eVz/HKswLlAsVWaB59z+/jjj0tqvSZ+rlAncu7D+mXMmDEtrg2uEWqebWpzXxNPqOlQ/rEeSu8pU6ZIalWq8tpVgeDqeNRH7oDx9Xxea+Bzn1Oe17Tdhx9+uP6/xzr7pu8gbognzkVpTm+251h8fVf/e14bjx/O7T333COpOveUx3bUH6cL9UaZ5SpmVGqh9zn33HMlSfvss089tlDObbfddpJanU7ueAFXrNI/05+Wcga5itfLZTtXBIKX5w4AYtldc8R8Y64hYsGVyfQnlEXZnv/GXWQO5Xm+HM9l4bHFdpxLzi31LDlsXYXMcRBruJzoY6ZOnVpvE6ecckqXxxB6h6lTp0qqrjnOMBxnqHa5b/G4o43RBks5sUqOsdK4UGqL7fKteNvz/fl6K1euLOaPKTnESnUr9Skl16Z/XnIHtcPvT4gv+lLijmtL3HPtw/rlnHPOkSQddNBBklrvVdy57O5Jjxn6Zdoh9y7EJvdE7pjm3spzxoC3f+rleZ6op+fwWrlyZUv+Lo7V73nZh+cjLOU78tyYfi9OP8ZrXAhs525zd2zjbvf7D46d7bmWp556qsLGzWWXXSap6q+JSxyFwH0NedJos/Tvfv8ExBdtl7bmeSmJGR9/Bg0a1PIe2/rvFp6r0J1d7IO+hHtAtufYWDLWsHTHDefuHe94h0JYV8TxEkIIIYQQQgghhBBCCCGE0EvE8RJCWKcwP3dJ0eTz2aL25vXMmTMlVQoL1D2oGiZOnCipdV58n+PX1Yko/fsj1I35tV2NCJ6vhnM2a9YsSZWSivU4Z1wTlNvMA+tzB3OuuXZsF9Yv48aNa5n/mWvFNeeasUSZBMQhqjjKo6343NsoVd1F4m3GFVLsx/NNlJxoPgc38Uobx7W12Wab1f/nMxRPfk7cxcO+fS5v75NcJVxSE3NuXXnl9eFcu+qf11wrynV1sKtOM4f3uoMcSiNGjKirB1H7cf5Z+hzTUMqngCqQdsPYRjvkffbrylofB1x1SDv2PGklJSHl055cDT969Oj6WOHum+nTpzeVxeeeU8qdLLTpUuy5Ypr9eT9GucROSZHv18Idepwb72fIebVq1ap6mwjrjiuuuKI+7zzXdvbs2ZKqe0HaInHjrip3cnlcll6X+nmf197fLzlbSp+X1oPGsbLduqXcL+0cM+5IgdIY1y53YinHhudmYn9cS64Z95asd8UVV+jtb3+7wvrB3fTAdfb7xEmTJklqdX94u2DpLl6PqXb3laW8l56Dxu8/fWzbZJNNWpT0ntfC8xt5HZySI5qxi5hgzOFzxhp3DZXcapxrHzud0rUMGz4XXXSRJGn33XeXJO29996SWuPu0UcflVTNcuHfNfz7nrdhv6/jeyaOGlwjnvvL7/dWrVrV4m6mL/B8wLyPs8vvh/17FHV3dxvHiutn8uTJkqQddtihqRyO9bbbbpMk3X///ZKkd77znQqht4jjJYQQQgghhBBCCCGEEEIIoZeI4yWEsE7xfAWohlCUuroINQPqBFSNrrhHHeHqCZ9z3lXvlMeyP+J1xPnix4riyY/V1V2cO0DZQR4QlFZshzKLvDoosriWYf1w+eWXS+pU7KDsRrHt89N7W3HlErh6zufuRg3kamDw+at9O8fdAV6ex68rpqjnuHHjWtS9Pg84ZZUUztTFcxf5sbiSyt107v5xZ4Gr94HPqY/HMcfH/t2ps2TJknqbOProoxV6j8YcYpx/lPZ85i7O0lzs4NcZJR9qQVeFe2yU1Ovu6PLtqR/7Y+ylneGwZC5s+n+Od/DgwXUXArlPiHvGFhTPLD1PTDu1bslFAGxPDPhc4t4PeT4kcDUx9WAspBz2g8py6dKl3c5vEdaexn6d+OLaP/zww5KqXFnbb7+9pOr+yFXyrs7nWvLaXVDt3CQeV6W2WlLCOx7Hjepjf6+UJ6ZUpo+Nfn/QXSeNK6c9N5K7MkvqfPoYHHKMvVxDrjXu67g51y8nn3yyJOnXv/61pOo7Avce9JPElLst/Z7LlfKsR3m0D88FhBOKMbhdzHqevZLbpNHN4nX2McXd4I7XibqyPY497jPdmef5k0pu8JJb1I+R+uBG4FqGjQ/6Sc/T6t/7dt55Z0lVG2HpbYrfHDwWSjHCvSvxSnzRlimf33NWrFhR/99djnxvogzK9mPxvH7+fczHLo6VHHGcC88xQzxxLjMGhXVBHC8hhBBCCCGEEEIIIYQQQgi9RBwvIYR1wve+9z1JlboAVYHPo+tKe+b1RHnhqnLUD+76cEUGywULFkiqlFVz5syRJJ122mm9c6DrAOr23e9+V1Krop5cEq54dgcM23HsvObcck1QlpSuEdeG7bm2733ve3vhaEN3QbEzZMiQuirO550GjwPW93nxUQeRFwg1PKo9d4yVVHiuHmrnvPF6eg4Yti8pchvLcfWuKxBd+exleLz4uWmcn7irY6BcX8+dY5RH+eAKR9ZDFexwfEuXLq23idC7NKrmiAVUfK7qRnmHmpcl/abPe+9uMHe60I5Qxvr8+SX3GeWXnGAsqdeUKVOatvf23eiE5P/58+dLqvqdPffcs6kszhV1h5Jiv5RXw50rqHddsexjHvic5J4riphjyfb0fyjwG+cL766TIaw9Q4YMaelfcWJx7XBFsKRNtlOso6h1d5O7otwpBt5227XlxmPqilJ76mr9dm2v1Bf4eAylcdVdmA7x9+STT0qq7i1dde8qZK7BjjvuKKlyT3Pv6fstnbPQt+Ay4/qQU5Mxj+vtynh3PLpCnn4XpbznO3MHlecjg3ZxUXKINY7hpbbeXXdZKc9MKX+G55Rx15DnueHc+4wGft/g9/LTpk2TJL3+9a9f7XGEDRfuV8BzL7k7hPjldxB3oLlT2OOPcnGZEse0acYD9st3n8Y8Lvzvs59wf40zm3359zHGcXft+FjHsREnHLvHJcfOOaLufm5D6A3ieAkhhBBCCCGEEEIIIYQQQugl4ngJIawTfH5uV2KgnEO1gJoBlYKriV1tzGvPSeGqQ1SRqCbY/4YAdeUYUG6gNvH5t31+VdbnNecSlQrn2p0Crm5BxcK14tqGvqUxH5LnRnIFq6vwaANsR9tBefrEE09Iqua1dRWgK1BdZeTKRnewgOcvcRW/z8+LIpK2DCippFblEwpCdya0m5vfKeVOKqnz/X0U2qiDObd+LTx3hLv4SurkxnYQeoevfOUrkqTXvOY1kjqvravJaYss6R/pX1nSH7uqkH7V3V60aR/rSsrbdu3YXSaulKXt4GZBKYsqmXouWLCg7rLkM46Nbd0d6W4br4vHZOkYve6oHVmiSmQ/ft/Adox5HsO8xl3mzryu3A+0kY9//ONd1jmsPcuWLaufc66xK8VpgzhXiD+PN+KJ16zPtfZ8ECVKOZdK7k1wp1spTkuOm64+8zr5Pkvvl9w4JZdoyc3DeIwzgbGN+CIeec055pzzPuUzdhOv7hYN64ef/exnkqSXvOQlkqrr/tBDD0mqriv3Wlxfln6/SL/q9z60F7+Hc4dMuxgF+gBfer9PnCxdurQlvt3hz7GybHfPRV2pe7v8psA5oN/ze176Avo7lp5fg3t6rh3X8vDDD19tvcOGA7NOHHDAAZJav3O449idK8QnbQiIZ9qa30d5/hWWxL3n4OVz7s+efvrp+j0jOV48PxRjhDu0GXOIC88HyjHiqOHYfCYPnymEc+VjJPXIDB+hN4njJYQQQgghhBBCCCGEEEIIoZeI4yWEsE5AVYByApWCqxb43JWwPq8tSgzUDaiDUDd4OcwJj+rhlFNO6c3D6xNOOumkptdnn322pOrYmLMURSfnBAWHz3uPksodMpxjlF/uXvBr1V31Wegdvva1r0mSXvnKV0rqvD6udi/NzQtcS1S/s2fPllTljSEXkscfbQqlIioh2pLjzjN3vlAP2hife7y76tDLX7x4ccuxumIRSu4dz53k67va2PsydybQ1/g54Jg5134tPE79Wrp61ONUqtrI//2//1eh5zCOrFy5sn69fd56n4Pac0qgFqQ/ducUStW5c+dKknbfffem7cltAaVY8PbtYyEQy3xecnegXuR4582b1+IW4Nh8357bweetLzlcvK37en4uOPf333+/pCq2uE/w+bvd8eo5srye3h+tXLmy7Zz/oefMnTu3xSVBu6Wt8T7XmmvJerzv887TNv1+x69rycnianm/Z/WxrtRv+/6IJWgcj/jM832V3DOu2i3lZiu5cUouO88/RTyR24n6eY4nVxnT53neQcZs3qdPDH0L7ghy8XD9cDwyDpBXCTc+zie/96JfxuVB2+Y17YR2gxqe/tfz8pVcnpS7aNGipnr4mMl21HvZsmX1/xlj6EdY0iapK+fCcwO6e8xdovQHpftVHHrsj9ceC/79DocL9edceq7AOF82HvwerpTrFmgLtGm/n3P3Pd/vaIu89vsrv+dlLHb3KW1z2rRp9f+ps48Z/n2I2KYsxhDPkeTfxzxXrd8fQLtcuSXXaehffPe739XXvvY1zZ49W3vttZe++c1v1n8z6U/k17MQQgghhBBCCCGEEEIIIfRrLrvsMp1++un67//+b91111165StfqcMOO0yPP/74+q5aC3G8hBDWCagSUFSguPD5uF1d4I4WV+WW3Bqoh8hV8c53vrNXjuOcc86RJO23336SWvOb4LhZtGhRPfcKCifA5XPnnXdKkk499dS1qstHPvKRptcXXXSRpNa8HJwTV1j5ueVzVJUoS7hWKFBc7ci1DX0D7apRhe/z15ZUu674RpGESg7l4g477CCpyvOAkrWkYHe1r8/HW1IJ8z5LL9+3K8X9ypUri3P8+ral3CyU6Q4B6kr5nj+C9UrOGcqfPn26pOrcUg7nnmsBrsguqTUb601daCOhZ5C349Zbb5XUOV65IwpcUcfS84nQv6LYI3ZR+nE9PUbchVGilIOC7T0PGvCaeoE7e2bPnq2pU6c2fQZs64p8d4e566e7eZbc3eUK/bFjxzYt3RXBtXAHjDv6fOmsWLGivk1yu6w7Bg8e3OKK8DngaUvce6Esd6eWz3fvbg1XqPuYBu4iaZezpfFYGimtT//QVd4Jd8N43LhzpV1OmNIxlu4ffDvPU+F5q/x+g/rjqPX7f3e8xlW9fkEJD6jD3eVJrPl3D3eU/PWvf5VUuTlxtNDP+njiyv0Sfq/nYy19g39O++M72apVq+rfGd1d5u4Bvtd5P9KuP/Bj8f6Ec8FYyYwGuDlf9rKXSaruGz2G3V3Gax/j/NqGDRfP10dcusvSxzbakM9qwfaeU4+2hOOlNLOCj40eG41uEo8rXxd8TPPfIYhHz0nLa+LZ89aU8pr5d1v/Phb6L2effbbe/e536+STT5YkffOb39SvfvUrnXvuufryl7+8nmvXTO5sQgghhBBCCCGEEEIIIYTQb1m+fLn+9re/6Q1veEPT+294wxt0yy23rKdalYnjJYSwTpgxY0bT65IKGKUEKgXUBihpUSuUFLUoMR588EFJvadGvfDCCyVJb3zjGyWVlbAozceOHdui3gdcMpRF2SeccEKP6oir5ytf+YokabfddpNUzXXqCizmDEZRyjXx+V9RmriKkWvi1zasW3xOWqlSjLoauKRodcU4ilXi0eMO1R1qYp9z25XjJYeNq4dYz+OJNkg8u/rIFV6DBg1qUSShzmIb2jnxAK629DpTjteZOpbOAeccdS/XDWUW/QDnvqTadIWVK726UjV31UbC2jNz5kxJnXPUlxwv3l/SHrgWjGm8z1hBe6Q/Zh583GeugJ88ebKk1uveLk+KqxPBc3eh/i2p5VEEd7UvtqVtl/KC+Vjk/Ua7YyGHAHP4c+45d8SsK/HdDYQSmr7B3WXeb8KqVauSd2IdcuWVV0rqzC3BtXT1rvez7qZg7niPO1eAu2PRKblDSnmK2uWIgVKOIM97NnLkyBZFcnfL8jGldAx+LO3cdY11a1zP7yt8fOfaeL6rkkKba7TVVlvV28RRRx3VZZ1C78P18evpjieun/fzLLlvxOHCdw3Pm1BycPmyNI6AO6/A+wx3Gc+fP78+dtF/uCLf3T7dzTvjMdUuL6O70jl37uijXO8jfP9+Dbm2YcOHNjNnzhxJlaueeKRteN4Ud0i6y5+lu7f9O4/PZOKUxsCuxtzSup6jiO+87mT1PH0ck8/YUcrRBn6fz7lNjpf+zbx587Ry5cr6dwHYdttt69ewPxHHSwghhBBCCCGEEEIIIYQQ+j3+IK2jo6MoUFmfxPESQlgnfPrTn256/clPflJSpTr40pe+1K1ycLCgukXFwBzCKPO//e1v97DGnZx77rmSVLctosAvqTJQYSxbtqzt/MTML/yKV7yiaV+nnHJKj+rMOTrttNMkVfPdM58rdUSxi0OmHZ/4xCckVcd+5pln9qieYe1wddKKFSvqqh2fH9fVwqUbDz6njaDqYR5o2iqgfGI71kcl6Oo7V9KCuzrc0YJ6qaQqbsxHwf84SlzNRRyWHCQ+x7DX1evCseJMYH3ODWp66oNSC5Wwz6/suHq4lM+qUWXqxxx6h9mzZ0vqvKZcX9qDx5wrVblOpTwJrs7lc9oX/TTloRb39V3N7gpXcLUyn3OMjHG034kTJ0qq2lljnhu2xXniudW23377Lo8d/P1S7ifq7PnHqCvqNp+j3J0spXPl+W3crcprlPvPPvtscputQxrHkZKatuSy5NpyrdxNUXKF+rKkXPfPwXPp+frt8DEcGuO3pGYv4fv29t6uriUHAtCHlD4HroX3PZ4/yrdvdCfRJkLf4Q4RV4F77k2ficD7Ta6z3ye6OxlKuf5KbjOgPn4v6I7GRkeVJD3++OP1/91RUnKyekyWxjJ32JXyKrkjz+8DvF9jfZ+JgHNPrIEfe9jwIJ/rTjvtJEnaZZddJEn/+te/JHU6RaWym9/boH8n8ntG2po71KCdm6vkHO4qX0q73Gm0d+LU61CqSyne/Fipk49ZnFvO9Z///GdJ0iOPPCKp9/IIh54xduxYDRkypMXd8sQTT7S4YPoD+aYeQgghhBBCCCGEEEIIIYR+y7Bhw/TiF79Yv/71r5ve//Wvf62Xv/zl66lWZeJ4CSH0CWvrluiuO6OnnHXWWZKkI444QlKl+HelCAoSV16tXLmyxemCssLV/ZR98MEHN+37v/7rv3p0DL3l+oHuupLCugVFW2NeF1cW+rz1Pkevq3tdrY/The1Qv6N8IncCoMrzeaOpY2lOeVcFgiscee3qZ+aMHzFiRP1/5jdmXVc6uTK6pHB2tWfJReRKXM4N26PS99wuPs+yKxEb1fWNr1c3H7or90PvwDkePnx4yxzrnj+EWMQF4rFYmie/5FIiFwyxRC4YnCjePkux7fnTaCsoaXFu0c7I1+JK2iFDhtT/5zNf1/eF0szViH7Mpbn9WY9j51xwboBjwo1CPTgmVz96LNE/ej/JmM1YvWrVqnqfGHqfRrW5O8d8rPN8Et7v4jAsuScdb4MlR427OEvOZndv+XhUcs5A4/olt2a7vDKuti/lPCrlg/L58aFdXhuukTvVHM8lwNhIPZ977rkWN0VY9zz++OOSqnyR9PPer/IaFTr9cul6+/V151Rp2S73V8kxxT2X9x04Jhtdq+4445631DYdjx1X7nv+sJKLjO27cgU0HjP14X6D2R/Yr99fUA+u7f77799l+aH/Qpz5Eu666y5J0n777SepaufeFnzGAY8nz2Pk97IlhyTlsV9v+7z/3HPP1f8nRnlN2Yzf/n3Jx7CSi4exx4/NXUDep1HenXfeKalyb+MyAu5JQ//hIx/5iI4//ni95CUv0YEHHqjvfe97evzxx/X+979/fVethTx4CSGEEEIIIYQQQgghhBBCv+Yd73iH5s+fr89//vOaPXu2pk6dql/+8peaMmXK+q5aC3nwEkIIkg444ABJlRoCha0rdUt5XFasWNGirPBtXfHEeuw7hK5AyTNz5kxJnepsb1uuxi+p2JmnGrWRz72Oe4PPXbWPgpD3fQ5tcFeJK9lLLhNX87M/tqd+y5Ytq//PZ163kvOl5ETwugN9gW9P3VFmjRs3run9Us4NFFlcG89LAa6AbFTfU0+cCCWVZFg7uKajRo2qK/C8vZRe+/z4LF0FToyh8GefxCiOLq6751lxFaO3a2IMZSxzIPuc8Dg5PJcM748bN67+v+ed4X32iZuG98ePH18/j43rgdfdXUR+7LiPfD2OiZjy3C/0b/STPn+/nzPe59qvWLEiSsd1SGMMuSqea8w1dXdfKW+P52Jqh48X7nIuzZdPmymNK6UcMdTX29UzzzxTVzTzWSl+Sk4xHwPb9Vnt8qC1g/1w7t1xU8qHhUPBcwkMHjy4XybG3dhhrLj33nslVf0t14J7Fe51UKszZhGzuH3Znu3oT2kn7jKjHXn78HYNpdhySjknutqutK5v4/v2+Pf7AI7Zj8XHMs4p545z6c4Y1uNenzxrXAt3iccVveHieShpQy94wQskSbNmzZJUuTX22WcfSa2562iz3CcR75MmTZJU3W95niAoxSH7wUUNtM0ZM2ZI6my75E7ZbrvtutyXjwml74qOu5w5J4yd7oLzOP3HP/4hqXJr4zAH1nOHXOgffOADH9AHPvCB9V2NtiTHSwghhBBCCCGEEEIIIYQQQi8Rx0sIYUBz3XXXSZL22msvSa1zGLu6uKSsalTntctn4XOSMpcodSHPTAhSpf5D+bbJJpu0qOk8x4ErTFF+sz6KJ1wj5C0puUBKeSUclFDuGEMtTJsnznyuYZaNc/437pdcNJtttlld2YdCyhWIqPLdnePq95J7h3JdvVtyOPg58PVRg6FiptySI6LUBzWqQNlXaW71sHZwzZYvX15vq6W50z13CxBzXEcUd8Qe7hA+R5nHdqX5s1mvlHuCvoDy77///qb9sx7HhTuFvoD4YL299tqrxc3JurRl6sx6zDv/6KOPSpJ23313SZWakNj1unNM1MljknKJFRSbXBOU2BxrSekP7rTz9zlHy5cvjwJ/HdLYd7vLkbblYxnqXJY+5nn/W8rt5fdp7liGkpOypIT18v1YXbHe6Nxxl6Wr4Nvto+RQ9WNxSg6wdueS15wDV2gz1vqY6+MXy46OjsRbH3L55ZdLqlTo9Lu4JWijXJ8JEyZIqtqs51finpX8e4xFjE187i4yv5fzdlZyYFEPyid+/F6KchqdwvzPmOHHSlumboxdfm8KpZjhfo/+ysf3xpxqUnXuOFe8T1/gYydjI2Mn9yMcFy46rvXRRx+tsGHh15w2iTuDtnXTTTdJqu6HGDPd6eLfPchnQjmlvJfEgMcG96ZsT1ttdFR6nhm+1zI2eN7Qdt9xfSx75JFHJFX3no3udamKB44Zpxi/w3AuiR/PWxpCT4jjJYQQQgghhBBCCCGEEEIIoZeI4yWEMCA555xzJEmHH364pEqh4fkbXOXgysJGxaGrqsCVybx2tR/zslK3U089dS2PLmxMoFpC+daItyl3U9GOUfGhQHI3B0pFlFFAOa4idrdHaU55V0S6cpHy+byktKV81ttkk01aHC0ef5SNYolj49i9bqU5+l2B5cfuc3S7ipPycbygbKRenkPA8+74OelK9ek5p0LP4No999xz9etM+0Gh5+2kXU4IV/gRU48//rikSqnq15IYhZLKnHY1e/ZsSdLNN98sqWpPxDh9AapHlIQvfelLm/aDQnDIkCEt+YZ22203SdLvfvc7Sa0xwjGgsPzTn/4kSTrooIMkVXOK06e1y4Ph54BzxfqU5zld3L3gxwF8zjX0vDfLli2LAn8dwrg0ZMiQej/J+UYJ29gepUp1623I+812ObwctivFXSl3WLucLo6rlll/+PDh9Zj18a8dJVcm+Pjs56JdDpnSuWQ7z83RzvXteawa76dpE2Hdwz0mYxPXFYcx14lcDVwbrjf3Mp6fwXMJcp0Zq0o5tTy/Q+m+0Pt1+m1vO749fcyKFSvq/3vMeZxTN3dtldxf7oRje3c6c+zkQ6N86uPfEznX7pzjGHEj4Y7zXDI+Vof+D9fccyW5G5Rrz3qec4sxFHcHbZR70Ntuu02SNHbsWEmt36XoJ4D4pg37a3e2zZs3r+7kwv1M+/R1qTPHwr0kDhW/v543b17TueD3FOLCc2pyH0yccO48NxznnjjjdQhrQxwvIYQQQgghhBBCCCGEEEIIvUQkkiGEAQnqXp9LG4WHO19YuvKwK0WfqwLZtjQnqSsrXHkcBjYoexvxeW7B504vbec5WHiN2s7btbdd2nQ7Va87b3zObY6N+addVewK9Ub1E+oqdxpQR1Rhjfk6pErpRNmurizFuL92ZVZJLeznmvJRn5XmLXdWp07uqo2EtQf13aabblq/vjhEUL5xzlGmejuizXruCJaoFVG6ki8FVSHroVB1p423S2Ljr3/9q6TW3EQo/tgOdTD7QwXZlXLf82ewLtuiiHYVos9vT93e8IY3SGp18bEfjhXFNbHi/QCfu9PFx1R3p3mOLPoEyvV8UJtuummXjsPQOzz55JOSOhXxnkvJVfKocbkenlul5PrwfCgl1Xw7R4xvt6Zzvzc6W6SqHyEeu+rXPe9Td91XpRxKJTxeS9v5Ofb9lBwuXEPUyY2Ossb1li1bVo/FsO5xp7PnBEQVTrvAVeluM3dIuyvN3ZdO6btR6bW73Bgrqbc7G3mfMbzRWcVnjTn0uirbxxivi9fVcwZ6nibwvEjUnfsCz4NEvbkW7nRx9xH9qF/r0P9pzEkktX7/Iq74/rbzzjs3bU8bcBcV25Ozj37Zc3Fy74szZv/9928qh+9iHjtsR5scNGhQS/unj3CnN+2bcfGOO+6QVN0Lch/AMU2ZMqXL94lL8ph6Didwp5mfa8/FFMLaEMdLCCGEEEIIIYQQQgghhBBCLxHHSwhhQHH55ZdLqlwlrnoo5WcpqdLdEbC6dVwRVVIvoiKmrkcffXSx7LDx8r3vfU+StOeee0pqnpvZ1bslSkpVVxW7otYdNWyH+uipp55qWh/FVEkN6Pt3Vd+sWbMkSX/7298kVYp3lFWA+m/BggVN6tjG5e23395U1xe/+MWSqrhqN1++q+Vdecgx4NJBvekKR9bj3LqiqpQLoLvXtPHaUlfazHvf+97VlhG65vvf/76kyoUybNiwuuINdTZL2hcKOB8rfB5uv66sh+IPRSpLFHoo+Bz2x/7/8Ic/SCrncaKNMOahgnz961/fVB/vM1atWtXyGcfCtldffXVTXSjb3WDUjbqSY80V0KzPsaPE5JwTQ5w7jz3PdcU1Y//ugHFVI9eM5ZAhQ+rHRBs5+eSTFXoHVKwjR46st1OuNe2Vfht3FbRz+7kjpdTvlnI1gLs/SmNku/6bzxlPGtX3Uuc4xv98xrhKPJScK6X8T+D3qz5WQal8P8Z2xwr0C1w7rimuFuKTa7nlllt2O69N6Dl+vblX4XrQ/7oynpwvjJe0U9od15n7Oc9jByXXmLuZvb25M9qdOr6e5/1r/N/7fmKEcZT33Q1Wcr6428Zjz7fz+wz6P2LEXTxz5sxp2p5rQ73cpcR9RXKVbXjQFnwM4toSH4yjxC/4eFBqez6LAG1uxx13lCTNnDlTkjRt2jRJ0u677960P88FCo3jUmncBfZJe2Vfe+yxh6Qqnx/78mPymQ/Aj8nr4bk/3QFLeVyLENaGOF5CCCGEEEIIIYQQQgghhBB6iTheNhK+853vSJKmTp0qqVKX3H///fUn0jylveeeeyRJH/rQh/q6miH0Otddd52k1vm+Ub8z/y2vDz30UEmVqsjV412pyaXWefuhUeXsKlpwlUq7faHAOuCAAyRVKnZUYszly2sUHKgKjzjiCIUNH1ctNapUUeNAu3nmaYOuOCzNr0t5rphlHEGtiwKX9ZjTlzn7t91226btqTflzJ8/X1KlhEX5Tjk33XSTpEqJRbmN///973+XVOWwIH4YB5mXmH3iJPCcGRwzKk7PL8ExovbkNXV2F4+fcxwyKBipp+eRKuEqtU022aTlPW8zYc1A1Yp6dPjw4fWxwq+35xXx/En0x7Q7PucauUqQfp3xgDZfGotQ6P3mN7+RVLnQPJaB46AejBPufoOu8kj5Omz75je/WVI1HpfyZRAT1JW6H3XUUZKqc+fbcS5wAHCuiDV3C7H03DTEvM9F7s4YdwI2tgP6vtB7NOZR4JxzjRgjPH7cTeU5eNrlQ/HPSy7NktOlnYO5pM5nrCMGvP9funRpPQ48XlzN7vlr2rl2oORuc5Vwd8srOV88pwt9IfHJfTljMtd+1apV9c/Cusdjye+huC6eC5A+kXsxtudzXpfubdxZ405J8Jhj6e3KY9RzgnFf2diO+Z+49PyD4HHLueEet+QWB2KL72vcrxILDu2f/o/1/D6Dc+gOa/pU367dfWbof+Cu/fnPfy5J2mmnnSRVbaA0gwHQNmh7xC34dxVe07bYjs/5buTfncDzaHLPtHLlypbvjqzL+O0uN2Z84PNSbjd3Lfv44c610pjl8cUxPvHEE5LidA49I46XEEIIIYQQQgghhBBCCCGEXiKOlw2cH/zgB5IqZTwKDZ5uv+hFL6o/NUalyTpse9JJJ/VdhUPoIbg/cHehNnI1L4plFLL77LOPpFZ1kauUXNnn76OyaJwjWOpUhLj60OfYpyzUJP6+K6So6+te9zpJ0j/+8Y8uj406cS5uueUWSZW7LfkeNg4a545G1dNVPoautnG1Gwom1EOubKWNeltFRUSbo42iAqRcyps7d25TOd7G2T+uFLZjvEIdhWKxMR5Zl/wwvCY+WBc1JHMDgzsRPB6ZQxvFoTsUOBelc1bqSzzPhF+zUi4Q6tf4uc+VHnoG17ZR+Ud7os939a23aRR1tGFiwueu9lgiFnBGlebLZv/Mt03sMN6wPsfgsXvkkUdKquKkHUOGDGnrYKGsww47TJJ0zTXXSKrap7uC2I66cyyoIEvOGmKY/gbVsKsb/Ryy9BgF6sU18Pn9n3/++Zb8BaH3wBmxySabtDhaON+Med5vlu7dSrSbY77Ub0NpjC3lSeE4aKuo7p1GZ00pvwnb8jlOMHe5lXKxeE4jX790TGua08Xvq0u5l9zhwOfPPfdcvU2EdQ/9Kd8haKue+4F7JhTv9MtcR64fDhjcw8S03wfiGmE79uN9rLc7xlLuD1Gj+z0S6/G+q+YXLFjQoqDHRYPDxcdhvycujdel3BXeD5TuQ7lPoNzttttOUnXuKI+xz52ynkMKuNZhw4MZPLi3JF651tyvuIMF3IXNPS0xwHa0ReKb+zvi1d0p4K4T2h7foRr/p0/w3EnUmX3S3n1MpB3T/v17EsfKOfG6A3X1XIj0IXyH5dyH0BPieAkhhBBCCCGEEEIIIYQQQugl4njZwCF/i+d6aFRGu1KJddk2hA2BSy65RJK07777SqpUDqgZUID4nKd77723pKr9l+Yc9jmOS+sRW+y3Uf3s25YU7dTN5/YuqYmpO8eCigSlBnUB+gHOFefuuOOOU9hwwOUBjSpwrn07Baorx0tq35LDy8FdQhv2tu2KRs93gtoIlRNOtb322kuSdPfdd0sqz/HdWC9X1bIPnx+fuGnM29G4b3fTuDofWJ8lisjJkyc3rVdyrJTcR+0U1U6jo8Gvr7eZsGZ0NZc875XUhO1ypNAefV5tKOVb8jbv5T/88MNN6zuu/MON4nPSl2Kdcjs6Opr+7wrOF2Xj0rz++usltaoMfR8cC46XktuAc4XiGtVkyb3j+UJK14j7CVc/NraHUp1Cz0Ehv3z58vq1pG24C4lrTu6tdmOc0y6Pn792R3K77b2duGvTlfOuoB8xYkTRmcW2qObZB6r7Us6XknOl5LYube+fl14D5XKt3B3qsdSYQ67kDAq9Dy4P2iBjEd8l3FXv9xn0y4xx9M/Tpk2TVH0/ox0Q257HxGcsKLk+fSxljHMHmM9UQHtsdCu7wp4yuvo9Rapiz+vi38PA3TncN1Iu+Zoon/Wo48SJEyU15xtr/JxrxRKnDOXwmmvG/sOGx3ve8x5J0rnnniupcuWPHz9eUtUGGCM9DmgLxCVtk/UbHb5Sq7PN1ys5G/ncHcddvef31f47ijtHOQb6DO4dfDYSd4yRF8d/b/E8gcQJ55Y4OuWUUxRCT4njJYQQQgghhBBCCCGEEEIIoZeI42UDxxUPrl5atWpVUdnkc2KH0B+58MILJVVKC1dgoVpw1bCrj0pzTZfmQnU3Cp+X5vVvfK+kOnQ1bTtlh6sNfV5kjplyPWcA54pzwbk84YQTWuoe+h+oEN09QhuXqmvMZ94uvQ3RNmhDKBGh5M6gfFRGrIfSyufhdxUhSnZX8LIeikXiHLVrd+eUb1zXVZu0f16joEbZuPXWW0uqzjeKRj8WzjVKKD83nlvD6+6qT9S9lFtyNrgTh3O9+eabt8xvzDGEtcPnS+/o6Gi5LrTRktMFfGwi5taUUs4Kv4fzcQdn5EEHHSRJ2nXXXSW1ji+ugvf3/f+u1vVt2BdxfPPNN0tqPWfuOCkde8lFRgy3o1QOeN4m+qPGnAGUkXvn3oc+cIsttmi5v+Gaeb5KH0tK92rQ3Rww4M4Ub7PtXCOMIyhyPVY8P1ejip+yfB3anueL8vHWx2+/1/Rxfk1pF//uWOU4uA9w17bH1sqVKzOW9SEnnniiJOm8886TVLkwxo0bJ6lqyxMmTJCklrxntF3/DsO9DvdYtAPuwWi/jBN+f8l24O2EOCBG/X6W9agf69O/d3R01P+nDp7njTqzpO2Wcqz4GMO582Nj7OJ+gnq4A87Ha8/P6G5O9kO9PGfN+9//foUNG9wX3/72tyVV19idKbQx2o7nLdp+++2bXuPuYEmcexv0PEGeJ8nrQb//wAMP1P8v3Ud7jILXxZ1kuPH4Tsrn06dPl1TNpkDfRpwSn557kc9PO+00hdBbxPESQgghhBBCCCGEEEIIIYTQS8Tx0k/54Q9/KKl6Wn3UUag+Op/gfulLd0iSXvnKV0pqVcQ25qfw+cJRGPFk+stf/rKk6ikwChVUFDwNfte73tV7BxhCgT/96U+SKiUVigza4T333NP0viunmJPUlVeledld8ef5F5hPl/dRYcydO7dp+3vuuUdTp06VVCklUGCg7KAsV4+0Ux+W8miwPooPn9MfpQeqNZQmv/3tbyVVMU4/EvoXn/rUpyRJv/nNbyRVyqCRI0fWryXXGnWPK1zp/2l7nmPFVXqU42pjVH7Mf4sq+ZFHHpEkveAFL5Ak7bzzzk37Lc0d7/NQo9KjPtSP43P18fjx41ucJyz92CjbXXDEJWUSr/QhjJWPPfZY07GyHeeCc8PYyX7pwxhr2Q/xyPjOMaLKZL9+LSmHa7hixYq6ShOVFm0mrB0oAhv7XK6bz0ldytnjavBSboiSO80Vs+zfXW1eLtvR7vbff39J0otf/OIut/f9+vu0+1WrVtU/mzJlStM6pZxR7It9U6c77ui8d/VzWMqPRj/iOa3c3QPuRnBXgl8bH0t9jvPGvoX/M0d+78N1GTFiRIuzhdeujncnjOc6KMVdu3tB/7w0hpVy89F2cLo0ujik1hx/jQ7Wxvcb9+15yCiT9su+OGeNc+o3lukuoZKLx9932uWM8fsFd7a4Q93d4CNGjFgjt2voHej/PCdXKV8lscj15nsa7Yfry3Xn3slzULC+3zNBKX8SruGSc9vvBYH3n3zyyXoOFT/m0j7ZF/vmfq60nbvMPS8pn/v4zefcI+My4L6Rz7lfLV0jjotrFDYeaEvEE/1oY64sqWqLuEZ22WUXSVV8+ncLoJ/mc76rzJw5s+lzyuG1jzOrc0+7u5ixjbHD8/m6q4bvbcSxz47Ceg8++KAk6fHHH2+qB3VlPeKL+40QepM4XkIIIYQQQgghhBBCCCGEEHqJOF76Cd/85jclVcqJnXbaSVL1ZPdPf+pUMDz/fOcT2gcf3EpSqyq5pJBt/Ix12XarrTrL2m233Zq2oQyU1T/+8Y8lSU888YQk6fTTT1/7Aw7B+POf/yypUiKhQkD1gJoBZxbqcM/Rwmvae8nRUlILl1RO1Au3CEqvRuXtXXfd1bQNCvg3v/nNTXUuqXVd/et5aLxOpfw0bI8LAQUI6hdXuXDuX/GKVyj0P1DA0QaXLVtW77+ZA9vnVPd4WFP1L5TUfjhbUBvRprwetHHaHvFMLKCQRKHlbbo0T//TTz9djB8/dsoGlH+cT+qOGoxzhcJq9913lyRtt912kiq320MPPdR0btrlkSjlCnFXHecQ9RpwPLSHJUuWtLhrQs/wfAwrV65sUf1xfWhHPt+8xxTbufMJBWx3c1KU8vT5vd2BBx4oqXKbuDLf60e9adfE5LRp0+rbNcadVKkCiX9XKLvj9IADDmha77bbbmuqs+dNKY3f3n+BKz19HnCW4PfIXGNi0fOkrVy5sr5P2kjoPWhzjXC+fcygr6ONuMqWJf2r32+xdBeVq+/9e1UpPoHtaB+l3F1d5eJspLGt+me+rTtV2TdjlbvwvO6l+17OTSl/Wem+GpUwS66Z5yJzhwvXqpGu2kRYt7g7nlhyt7CPeVwrvhfxGwbXFSU9S3eR+m8ZJVcmlO7ZKJd+3NsZ5Te6V/me5t+z/F6UtkxdafPuWCvVlWP38imHzz0HKHXFcQ1cE64F9fKchlyDtc3nFPov/B7C7yMej/5dg3tO2hrxQ1v03wd9SbnEAveIxLvnlKEt4zJp/J86+DjJPmjv5JViPfbhdSPm+dxnO8Hlwz0iYxSfsx3xNmvWLIXQ28TxEkIIIYQQQgghhBBCCCGE0EvE8bKeOPPMMyVVbhPyVfjTZ1cH8USX9Znzc/z48U3rowhbtGhRXc2BaoOnymxLWZTNU2VXDaNs5Onyd7/73aZyPvnJT67FmQgDHfJX+LzeqHZcbYhyA1UC26Ge8HbuqkZXNfnSY4/9XH/99U2f4zQgHgYPHtwy/zb7vPHGGyVJhx12mKQqxtrVoTR/tqsOUTYxV6rn92A9zhHn2Ofj5lq87nWvU+g/oGJFkbN8+fK6Wsfnp3WloFNSkENpDnjibtddd5UkTZ48WVIVp6W8JDgkyYvAetSfNorCct68eZKqNlmag/65554rKo7ZB+ouyibucN9wTOyLcZOxztXGlMe5BldW+3z6JaWhO2Q8zwV9j/crnLtGl0tU+L3Dl770JUmVC7Cjo6MlxwqKPK6DK+s8FogR7sXcVQwlR4q/pr1QLnO8v+xlL5NUxWZJPQw4CciV5POFNzq8PF8ZZaNe5B7U5/T3No4Lhzr/9a9/bdp3KWeLH7sr/j12iBWuFbHiY6MrpV2h3Xjtua60kdB7fOxjH5PUea/kTkWuESpb8LxlxJXf85VcIqznc8FTbskpU2pz9AO0OVeyl1hdvLu72cdncKWzj0Gl3EfgjljKI47cred9lZ9T1udek/W5hiyJe641+3v22WfrbSL0HcSA57zyHCr+vYzPyafn31U8rxH4d54SPo4QU5MmTZJUjcXuTvV2yZjHd6WhQ4e25BVkDPPvTx4TPla4a6zUT4DnivIcUO7s4xg8prz/8GvlTp2w8eBOMvA8Z+7i57dGXnsb8e86bO8z5eBwu/vuuyW1jhNd5UOjr7/zzjvr7zWuQ5xxj8i+SnXxurI98cyxgv+25GMstBu3w8bHWWe9UtLINmstkXTWWu8jD15CCCGEEEIIIYQQQgghhDBAGFr7a7fO2pMHL+uIr3/965Ja59ZGQcE8qizdlYKygSezrgbkafbs2bMlVaoPaJz70JUmPNVF9cv8icC+XD3M+zx99vlPzz777Kb13WHw0Y9+tOU8hYHLL3/5S0mV0sKVc6jUUe+4ioF25k4ZcKWHK1tLKsiSahn1A+oK4of8DytXrqyXff/990uqlBYoPFwl5qrb0lz+rhLzOruDxc8N55j12B63Gio13ufavOlNb1JY/0yfPl1SlYerUa3qc7H73NmlOdmhlJfElauUg5re1UWs7w4VlIW0QeKG2MDFw/iCyg8HB2Md2xP/m222Wcs88ny292mnSWrVrSypLZ/52c8kVe4a6kJdXUHouVY4ds6Fx7Hnq4B2c2yXlNge/43rc71pI6F3oP1tu+229etAO6M/97ZfyhlBu3T1sPf7UFLMAu/vvffekqqxyfMk+HYllTLtmOPhvpLtn3322Za4xvHp+WtKdff32SeqRmKvpMT3e2nwvGgck8+T3y5nBUufb7zxfiGusnXPnDlz6ueesYBryljBtfLvKt3NC+RjpN8bQsktUhoz/R6StuQOxlJ+lEZlfSmfn+/Lcxj5vWG7c9Eur2Apf46X5/tzF4GP78RhY74yqepjyTcV+hYU7P6dArg+9K8+MwbXne8Uri73/tVj2x03JVcH77Od51lhfc9952P0ihUrWu67wF0CpfG1lPup5JhzNyZtn3LoJ1iPc1nKPcO1cEeg5wzk2oaNB2+ztB2+0/j3N/+uQpvg/ovy+P3F+3/PFbPjjjs2rUe8kXuG98mX8vTTT9frRl4a2jmzIhBvfM6+2Dd1YR/c//J7hs+Cwu+r/N7q94L0ScSh39eHgcQmav9gpWePTvLgpZf4zne+I6nq5DzhqNt2uRn1RJ7+JRHYzjtHpne45557mrang5k1a1a982LKFwZjHrj4D2Z0Vu2maKIzo2P1xJf+xeC8885rev2hD31IYeBx3XXXSWpN3sgNAO2Dts6g61OEeMJAn5YHiB23s/qX5FKScX5sIZm4f0Ft/NLsSdqIT+KRsvjRym24pS/NnnjSP/fY9dhz+73/cEh9iWnqw7U64ogjujw3oW9gGsdbbrml/h5tjbjxH/u55v6jLGOOW8G9LfmP/muaeJj32Z+3cb5wu53bhQL8MMv7HO/KlSvrx0Sc1adFqZXlt088iBl6+OGSpM3tcx5vrKoljCw9EPUElP7jMMvSj9HeFzF28iCJvq90TRun0aDMTPXZu/zrX/+S1PkFli9kPhWCX+/Sw09P1M50J/6DTnenpmPpU9M6pWmF/H3aHw9cOB7u5RYuXFj/n35gxowZkqr7SJ/iE0r9A3Ds/iO6lwPtknpTT861X4PSAxgvl2vOuV22bFm9TYR1x4IFC+riLv9hxftb+kef2pX7mVJc+A+q3kZLbbDd9FwlEZC3OcfruWTJkpZtSg/fgXPDvj0eSw9vSw9K/Qe70lhYmh6XPs7vYYl3n4qK19yb8iNc6Fvo1/3BOtfFr79/l+C7Dv0nP7hy3b3f9Wkz/QGij42lB/BA+bQf/z2i9D2v8TMeiPjvNvRHtFnHfyuhrp7Em/eJEQRALthgO46Jc+sPv0oPetiO/pFrGzYeaKvg96L+wNOnm2N7fptw0aY/5GNJ/+C/J/pYyOd8R5sxY0b9f8Z1Hpry+4M/lGVfLkxnSR/E/Svr+XdHIB78NxwfY/3choHASLWfaqzr7ybdJQ9eQgghhBBCCCGEEEIIIYQwQMhUY/2ec889V1LlcOGJbVeJOaVWdX5pepaSOqmk5icJKklSb7vttnr5qBx22mknSZV9j7q5GqOk6vK6cQwoUtxC7DZYVLwoljl3p5xyisLAAZUu7QlVg7dHVAmujHcVEpRs3eDtu91UY+wH5RbKfaBeqC1GjhxZX7c07Rmf4/YpOV1KdW03zYqfk5J13ZNDsnR1myelC+sXFD1jx46tX1sUfZ7guzFJrVSpimh77dqSx6M7IV1t57A96mPK9cTFONqIDVcTUg5jLMuOjo6WY5g5c2aXdSndJg2zz1kurNnnF9Ze7/joo/V9SmVnA+ea90vjuDvSUGeigHS1Wmnaz+XLl9fVkqF3YWrUX/7yl/XryXn3afa8n2V9b+vuaOL6Epu0bSgllgdXmZfU7SVXZ+NUYlKrQpZpAQcPHtz0f+M58P6lNF2Lq/rbKeZL47ePlTi5iR1X5rty2t1mQL/j7nPOxXPPPZfpcvuAD3/4w7rxxhsltX6X8PsXdwTSBv1au7q+NG0RlNqax1VpDETRy9Qn1NOnNvElSvaOjo76PZj3Ie7g8uTluIVKcVRyAbWb0qlUnp8jzj39AnHpyc9ZujOHPvbDH/5wl/UM65bTTz9dknThhRdKav1NgzbM9eT+jbGL9kKbZ8o4vvdzv0o78WkF/fsf7RnVu8eq/z6Bcp92V5qqj/KXL19e/5+y/R7X779Q95dmKGCfxD9Ld32xHcfM0u8z+H3HZz7g3HIPSLnElP/mwrUNGw8nnHCCJOnXv/61pCpOuPbuEPPvY97f8xsiv2GwnY9HxD0uLO8fiDe2axyvfAyjLJ9dgfGcOvA9yaenJ76oO/Hi34Xd0eYONV5THuc2DCQy1VgIIYQQQgghhBBCCCGEEEIvEcdLv4c5BFE4Nc69LrWq6FA0eL4Kd774PI0+/3UpCSRuFtTD06dPrytR+MwVI67ObZzTuhF/Ql6a89/VZhwD6nlPLBsGFq7QcyW8txtX2Jbmpi6pg12V6LHpCek96RztuaQQoV13dHTU/0cdXFLdUjbqE49zd4uV5iBvp1L0HBM+z6tfC4/hUpLwsH649957JUkHHHBAS+Jfd0m5Wo9rSRvw3Ee+9Dbo6v52uRuA/r7kEuA4XLHuLhLGNI5v6NChLWWxLjxfqJM7XFjiU/PtSopoT8gNpbHR+yy2c0WWq/H9XDc6E2gTb3vb27o+2NAjnnrqqZY8Y66UK92PlRS0XE93mjB+eB6mUs6JUuyhMkS55w4qYp/7V1TNPrc96snZs2fX//exg21pwyiOUTD7vS4KZneFQsm94+cU1SNjLecS5WVpO88h5ZTGWM5lWPcwFnAtve/nmqOIZT3ix+8tS4nm2+URaueMKY2d3D/hLiUWiBGOxxPNNyqB6XN8bn1i18dVV8mXnCqlc+BjTHdzLIHfp7tbmvhEtcznfm/KtQ/rF9Tel1xyiaTWdkc/zvvEIG2YsYRxw/Od0A6IBfpztmN9z13kbhG/l3KXB+X6WEo76+joqDtH6E/8PsxdZ+zLx33aMsfIseHKdBe451Kjv/C8NpwDtmP/rM/73r9wjFHub/wws00pfxltBHzMIU6JY8rjXpI2SIwQZ+6I83hkP425lkrjns9qQnsmlqkL7ZrPeb3bbrtJap3Bw3/bYUlfw2vqlVxIA5lhqubCWN06a08evIQQQgghhBBCCCGEEEIIYYCwmaQRbdZZ0ebz1ZMHL2sJ+Ul22GEHSZUigqe9PIl11TCvfb5b8PlIXXnB+66w9fn4cbnMmTOn/j/b8DTY1Zc8Iff3vS4O++Tpsh8rT5s5Vs4VCpbkehkYXHXVVZKk7bffXlJrvgTaj8+D644TpzRHvKsQ3flCe/bcRFBSCrqKknqvWrWqOCd4u3myXSVCmaVjdOVGSYXoiizOJXhMcy3cFcS1i6p+/fLpT39aUmfeCXe0gL/v+SlK/TlqH3fC+Pz67qIqOc/cFeBKeSjlhKCtot5DAdw4X77PF8+6jI7oUtzBUnK6+PtLasvSsfr85J5jyRWNJWcE27kzwcfgrhyxtImwbnjwwQc1adIkSa2xUxobSvmXUN+689Bj1dtXyV3mMTx//nxJlSPA7xP9fhLVMc4X7hVxrTTWy+ePZxtesw33g64ybJxTX6oU7ygtS24eP9fer3j/xzHRT7l7yHO4lJyCfn/y4IMPKvQNDzzwgKRmN7FUtQlUtlxL1vPvNrQ1rrHnYCq5QKDU33c3D4qPlaWZDhi3UBFvttlm9XVQAfN9yWdR8FwvpTgqOWF9vRJerjthvQ8r3WvyOcfq975c+9A/cDcZ15X3ee33jf69yt30tB/yFrqzBUcN7ZpYZr2S49sdXz4GdjVW+/c2b9vUmbJLudK83/GxEoU9YyVjIueWY3aXpn8XZkyjPp47jj6B+42w8fOud71LUuVQ475qzJgxklq/f/n3O49P3scNRtvl/oo8KrRhYoCx2e+fGt0l/E8f4u4YHC6eowUnCvFBHfkdFleP90U+3vv3Ro6J+2fOZRiIZKqxEEIIIYQQQgghhBBCCCGEXiJTjfVbXKnoCkeexKI4KCmd+BwFQ2kefVcVQUmBtTpc4Qc+fynrlRT+3T02nwffz527fsLGic+36XkSAGV7u7xGJbViKRZcKevKP1e1M5epq4lc8dGYK4ayUDih0EB1wrqU7YqMUv6l0jG5irC7Sk7Wo79i7tRGN4HUmm8j9A8efvhh7bPPPpJa+113W7mDhM9pzz7mUA5qJI87309pnntX17v639us50VBvYQK6dFHH5VUKbmGDh1aLxPVpCv8cKx46y29Zvm8LUvz4rtbx+OPc0xc+Rjq6mAfU8HHWK7Zww8/rLBu+fznP68f/vCHklR3vnguP2/rnrvH73Vo25RDjkCPNXAHorc75rjG6YKiEOUgYyn7Q1Xs8+Ez9tIeKXfo0KEt6lvuWdnW89XU3We1c0GsoogEnzscSgp+4Fxx7ubMmdNUHvtnvHZFtMeg3wdQ75kzZ0rqbAehbzjjjDMkSRdffLGk6l6LuKEN8pq2Qh4err2799lu3LhxTdtBKReXvy65TNvlP/F72XbbNX7WzvXseN9U6lvaHavvn/gmb4XnLWU/9DH0Kaj56ZuA18QZ1z70D3BnEDP++wDXn/fpxz1PCe2G9WlPtAvPz+QzIHiOGNqXxwX3rY33iVJ5FoIhQ4bUt2HpDlP6Gb8n9lihbtTVZ2vw3JmM1z6+u+vAndT0b/5d2q8N1y4MHI477jhJ0hVXXCGpygPkvyF42/LfGnymAt5/7LHHJEn33XefpCo2+M2jlFOmMecf/wPbMBa4M4zX9BVTpkyplyVVcck+3YFWig/PL8q5CwOYTSSt3vwrdahHs43lwUsIIYQQQgghhBBCCCGEEAYGI9W9By+L1n4XefCylrhSqaQqcnWvK69QSJScLz4/dknl5Gr+xjkS+R8lSsnp4vMhu3q35HTxOVs9p4YrC11Nwnph46akBnY3hasWSm4Pb5+l9VwtXlKdN+ZNaHwft4rnmkAp0qhycgX75MmTm8pGpeV1p26uZvTPS+rGknvHY8tdbKzHtXD1mqvNQv/gtNNO029/+1tJrW3Gr7HnOMDdhELd+2l3Y9GW+bw0p7tTyoPiY5krrlyVz+c4X6jX8OHD62MRn7Hu09dd17nOEUc01am7vq1na8uFteW2hWP03AGufGSJoopz5+pMz3/meSb82tJHnXbaad08otATmPP5Bz/4gaTW/AWuuuVzVLzexrneKPhoB14OlJT2vI8ikHZBrLnClnZI3JDTBadAKY9To+OFz+bNmyepGhepC7FI26dNUxfq5nN/u4K5lC/Nx2u2mzBhQtOxeM5B9ku92K/HGrDeSSedpLB+wMnIHO7e39KGmIee9usKV9bznA3c25UcjSVHm/f3rnz3HJ/edkt5BRvjuxTr/l3P7/U8p2bJweJjkZ+DUl4z7h+IH+Lfc89wf8F67kDw7bjWoX/xvve9T5J0Xe2eCueL39P4mMGYx1jjeYxYD6U825fcJ54fzX+n8Hbtzmng88b27/nA/DupzwZSyh/qn3s+W47d73VR9uOAYazye2DOIWOcn3vOCZ9z7cLA4+1vf7sk1b8n0hbdcea5X2hD3JvSBol33Kdsj6OYtr3jjjtKar3vasyD6e9RBnXDVUNdGDtwnFMnvqv6rDml70uU7/fNnKsQtImkrn9mq+j+BFPFXYQQQgghhBBCCCGEEEIIIWz8DFUevPRXeEKLEounvTyJ5UkuT2JRJrijxT/niawrLlBI8Lk/neY1+501a5akzvlyv/GNb0iqlCUoSXz+Q1dJAk+2vW6ugHZHjKvlXbXhT8zDxo3P00l7c6WSz1/vilRX1pVcYCUHDOX79iVXB+2W7R555JGm+jCH6uDBg+vHQG4Xjm2nnXZqKquEH4PXtd36HHNJ8emKaleCumKaGPZ5ucP655///Kckae+995bUmjvL4wTno7uawNW8tFWPO48TVwM6rpj1uPf5fl3Zi2KR+uMiGD16dF0hyHzz5I9g281vuaXpWJ56yUs6X1sdPafLwtpyl+nTm47ZVfR+rl1hhfKZMdGPlc89bwbX0nMtsT7X/rWvfa1C3+HOElwWuCA9Z4TP2c69lzsfSzkefGykfXjMudvYc8a4Gh5F7PRa+2YMI268L2n83/MW0Z/ggCFeJ06c2HQOvC5s7/ehPi4TO6UxkGN295grrKknn9OPcE5Q8qO8Z7uw/vjYxz4mSfrlL38pqWpDtAn6f+KA+HRlq89n7/eY4GMVbZL9oPolXmhzQL3IN0Qbpq2h0PVxpCtnjefidJU8ZdNuqSPb0Qf49znignilTtSxXZ/k94yca7/H9Dw8qPr9OzD151qH/skRNfcwuSP83ofvdT4jBu2D9sl9HMp4YsjvgTyfWekey91krqInfiiXZaML1XOgcQwsPR+Nz1hQ+n5Fnd35xmvODYr+adOmSaruYz2HhdeLcdxzvUTBHwD3CPA7YMmxVrofY3ygzXN/h2ua72D89ogzznNBbbbZZvX/uQekDpTBviiDeOI+m8+Jg1KeMZ9dxXMf+bkJIQ9eQgghhBBCCCGEEEIIIYQQeosRkrqeWbyihzPv58HLWsKTWRQHPJl1Na/nM+HJa0nR6g4YVxWi4vB5fHlKTX0+8pGP1Ov6n//5n5Kks88+W1KrasPnI2beYxQo7MPnUfQn4pRTOnbPIUNdOZdh4+aEE06QJP35z3+W1KoaAm/7rk70ueZplz6PfomSchbaqZle8IIXSKraMYq9wYMH19/bbbfd6u81llGan3tt6+pzj3sejdJc4qWcMV4/lly70H849dRTJUk///nPm953RSzKbVc40SZR05XySnjOmHa46p/tiVMfw3x/xBOvUf+h1EWltGjRorqKkn2644V8EyilNv3jHyVJyw8+WFKr0wU/ysLacrypLtvhKmXweOea+HzjpVxxxDPnhmsf+pbTTz9dknT55ZdLqu6V3CXmeU1K/a0r8Vjf85v4OOHKPsr3/CglRyT1pp7uGCNeGueu9/GYtoiCmXtgP4ZS3jLqWspvBu5C8H7J1Y6Uh6uI+vg83+5CcxXye9/7XoX+wS015+Khhx4qqTWvEGMbLg7aL24Ld+mXxjLvt2nzOGlYenz7+vTv1NPvaYk/zzsIjWNoKQ8gYxt14vsU7d7dlH6u3CHjrrx2fY/njnPXEdeC9bkmnBP2y7V905vepND/wU1x8cUXS6pm/fAxyN1cPmOGu0E814S3O3fz+72W9/vEIO2c9gqNeVFK37OIIRT2lO1x63VyfKzz33ncne6OPXe0usvo0UcflSQdf/zxXe4/DFzIUXfRRRdJqvpn2jRjkbtBafu8z2sckowXjCe0acYhvudxf0VbPuGEE/S9731PUuU8YR84SWnXlMk+PYe138N5H+LuN/oC7l2Tvy+0MFTtH7x076eQInnwEkIIIYQQQgghhBBCCCGEgUEevPRfvv71r0uSzjzzTEmVmoKnyKh7eErsKnqe1JZUfjwB5sns3Llzm5YoJT7/+c93u86NLphGPv3pT0uq1BY8JWYOR46lpEDxY/H1eArNsfDE/aGHHpJUncswMOD6ox5CYUH78ZxDrjYvzRXP+646dgV+qR37/l2B7/PoUv9G9xr/d+WGkaq4ZU5fVyizz5ITxec3dsWHq8xcMeXH7C4hlsntsuFw1113SZJeUstfQrtvl0OFa+/zW3v8eRx5bi/H49n353O+uwPHc7u4Agu10zPPPFM/RuLJlcSosVDZ1o/hd7+TJD17yCFNdV9YW76gNk9xO6eLKyXdeeauUI9fj0vi2VVmvM+1/rd/+7fV1iusWzymiBHU4p4Xz3OxlPKZcf/IPNw+DrBf2gftif0y3tDe3XHjyly222677Zq2RyHYOKZSJsdAmWzrOaA4B56nxh0q1MEdKxyr3yNTdxT/qBjB+ynPjeGKa3ef+bUN6x++Z5133nmSKpU9YwXXkJxL3Jv5/ZU7z/x+y10htDG/v/L7LHA3NvGN+8PvNd2R03gvS53c2c09Ge0ehbGPNe4UAz8Gjo3xmLEUlbHPYEC96IO8nvQ5bE89vV9Apc+1DRsW9JfuwvB8YrQ/2gXtjM/dveb5Te6r5ZDgbnOb2j2Qt2PKRy3vin2fHaBxHPP3aMu4OBnfKdvdliw5Fo8N/27JOEu/5eeC8d9nXfCx1+8nQijxzne+s+n1VVddJalqi/59kf6b71Se24v7Nn4fpK0TI/4bRaODmP8vueQSSdV4zbbEMu/TzhmXPT8g96t87vlJqfPb3va24vkJQVLng5d2T0a6NwFGkR4+twkhhBBCCCGEEEIIIYQQQugeJ554ogYNGtT0d8ABB6x2m1e/+tUt2wwaNEhvfvOb17wCI7r51wPieOkhs2rKWBQNO++8c9Pnrtr1+UhdBeQKLhRXc+bMkVS5U3oTd83wGoWVP312JaPnfnEFDAot3Dr/+te/JFXnLgws7r77bknSq171Kknlee/BY8OVfSVVEEoLn/vXVertclhQDkp7FCC0axQfUtUP8JnPx42ayynlRQIUGyiivD/x+bjdYeP7YX0/1yhFOGe33nqrpMy/3Z/51Kc+JUn63//9X0mV6hfcweXqX3AVfin/kCtcfT3iBVALsh2qfkBx5Q43V6YzljIe7b///rr99tub1nW3D6osyqB9E7Ojp0+XJD28/faSpF1qr4kzPwZXNJf6DOKKZWkOf49fd9VRj9mzZ0uqrnVYvzzwwAOSKuW996Mlp4tfZz73nCwo/7w/d8cU7xMb7ioGd3+4S9RV6j4ezZ49u96vlHK1uKKY+0LPc8Z67Iu6+3rg+6N8z7vh9wWeK8CdLxyzXzuubeh/vP/975fUOtZNmjRJUqvC3NsgbcKdad7fuhuTuKLNMI6AO8lcfc93HXePUj/eR7HbODbzmTs++Y7IkhkK2LfXyZ0qPhMB54Jj57V/7+PcubOB/VBPxli2x/XDWMa1DBsm5Ee4+uqrJUnjx4+XVM7NSbukPc+YMUOStG3N0eIufJZ8g9nsT3+S1JojkJihXeLYwq3iMxb4fe7gwYPr/QVl+Bjis37Qlok9YoF9+XdMjoV7XOrMvTK/jZRyR3E/4TFHrCZXRVhT3P2B+8TzSeJY9DxH7nzx/EbEynHHHVesA5/dcMMNTe/7bDqeM40ldfP4YGxb3b5D/+XQQw/VD3/4w/prv99yfvrTnzY51efPn6999tmnno9sjdhEna6XdUgevIQQQgghhBBCCCGEEEIIoc/YdNNN6w/yuwMCF7j00ks1YsSItXvwMkztH7x0rUntNnnw0kO++93vSpJOO+00Sa1OFRRZqDpcZewKRJ7g4nBBFfK5z31undS/K3DVfOYzn5FUqTQIBJ5881TZFc+oMWbOnCmpUjih+kKxxbkLA4uPf/zjkqTf/va3klodU+7mQAVUmjvYc0n40tXnJQeXKzaA+rEflCAoqxpV7dSNfdAPuALTcacLx4qyA0UHoF50RbRvT7n0O9QDJYnHLq/px7hWof/znve8R5J08cUXS2pVurpCHbwNeQ6l0jz2Xg7bMV7QxlBGNTrDpNZxxOeCL82PjWPupptuqo8le++9t6RWNa63e/bpikKcLsQ28UbfQ19ROgelnEq+5Bg4J55Xwvsijo9rG/oHX/jCFyRVKkGcL359UbZ63iNwx4u707x9sT3bufOKLyA+Vz3uEt8eSs4t3CTDhw9vcZ45Pn6ybx+3fT5vH7v82Ernws+179/dRtSfcwHUi5wTXNvQf6E/vOmmmyRVbYNry9JdT97WgDblSnbGJFzOjFWMM8B44Yp3xg9yNqBQJwZQ73ueo0GDBrWM26xLeya3C2W7m8brwj7Zl7s4qRtjJOfC3UH0Ibi3vc9yJwL1oN9IfrKNi7e+9a2SpMsuu0xS1S5QKfM9yfOgPfzww5Kq3zh23HFHSdV3Hvrvbf/xD0nStGnTJFXtiftJ2iP7YbuxY8dKqvoC3ueeqvH+0vuF0uwI/C5DHfh+544X6kab55g8VxTHTgztsssuTfv1fGZszzG84x3vUAi9gbtDLrzwQknV2MbvHJ5H052VxNma5IdlXeLF3ZOUyRjI0n83efe7393tfYb+yx/+8AeNGzdOo0eP1sEHH6wvfvGLdQdjdzj//PN1zDHHtHxv7xZDFcdLCCGEEEIIIYQQQgghhBA2Dg477DC9/e1v15QpUzRt2jR96lOf0iGHHKK//e1vReFyI7fddpvuuecenX/++WtXgTx42XD49re/3fT6wx/+sCTp8ccfl1Sp+1i6MpenyigbeKL7la98ZV1We7XgskH1Tt1QlqAaRnGCSgwlFkve/9a3vtUX1Q4bCLfddpsk6bWvfa2kVmUq7cbnw/b8SD5nr5fjOYd8/n0UUZ6zgnJo57R71EYPPvigJGn7Wn6IRqbXFPQ8pUcF5kp7VxqXlNI+/72riIlBP2bPr+EKEvohykGl9qfafMpcm7DhcPzxx0tS/cbD8zeAK5RoQ+0cMiUFuuc/QeXncez5JmijKBRpiyxps9SL45g/f35dnevuGM/t4kt3pnAOqKvniyi5hEpuoFLuFne++HruuImCq3+DSvBnP/uZpKpter6TEqznY5s7o8FzVbhjBoVXKeeEb+/uERS1Pi658rdxG8YMVw27ItLHMneccixs5y4g8HNE3dwV6nAtPJcUY23mA9/wwEU/ZcoUSdVY4Ypxx++TiAPaIG4Pn9ee+Ha3P22I722sz5I2584a7g/dgdbYlrnf9G15TV1Y+jz4xKfXnWOj7n7srOd5SD1+HMrhWnANktNz4wb3xY9//GNJ1QwZPgsAkA/3vvvuk1T9XuCOa9Tw3Bu50wpXGu14u+22a/ocRxjt13MSrVy5smWM8vu9J554oqkuOFVYH4cLdSNmWd+/v3GsxPmee+4pqfXeuDFvQeN2//Ef/6EQ1iUnnHBC02scMHxH8txKHo9HH310t/fFuj//+c8lqeV7neczY+w78cQTu72P0P/40Y9+pPe9733119dff32Ti2/q1Kl6yUteoilTpugXv/iF/v3f/71tmeeff76mTp2ql770pWtXqRHqnG5sdSxv83kb8uAlhBBCCCGEEEIIIYQQQgi9zhFHHKGXvexl9deTJk1qWWfChAmaMmWKHnroobblPfvss7r00kv1+c9/fu0r1R3HS0ebz9uQBy/rCHd3fOhDH5IkPfbYY5KqJ7ksUXd85zvf6asqdht33XAsPve+z7fYH48l9B/OOOMMSdXcwKgWiQV3haEWciUtuSRcKe/zZrurwxWvqJb4HMUe6iXKY4makRxG22yzTcsc3q68pyzUhCicUDa504XtXDHpx+4uIFc4u8rLzy0xyzzKXJuw4YJDcbfddpNUtUlXFILnF2E9z0vheL4TV+CW5gB2pw1x523bHWq4RhctWlT/3x0rxAlzBnuc+bH7MbO+K5tdCen4OfMx0T8nTt0Jg6IybBjcddddkqQ99thDUqu6151T7lTx3BTuOqNdA+XT77tSl7HM27XHIGMc23telsb1fVv2hRLZnane1qmTu2k8DxkwFoKP55wrYtoV9p7/hmOkP2H5z3/+U5J0+OGHK2xYHHPMMZKkG264QVKrW9nHNHeY4bJ0h0wpX1HJNUrb8rGNNgnEAgp6XCmU2+hIJkcmdSUe2AZ1Pbib2Z3gPhb5Pv2Y3JVJnOGIcSeq91nsl3terlXYuMGNgfOF+zoglliS24XvHj724BrBHYYa3h1f3DOxJO8a27syv3G88PyfwLaMv5Tt7hryXvg9MOu784XviRy75zPzMYrcMnG6hPWFO2B+8pOfSKrim/GmJ/08+b8uvfRSSa3f24499ti1Ljv0P7bYYouW3K/O/PnzNX369Hq+9NVx+eWXa9myZT1zr2+i9g9eujZSd5uuM2qGEEIIIYQQQgghhBBCCCH0Is8884w++tGP6i9/+YseffRR/eEPf9Dhhx+usWPH6q1vfWt9vXe+851dioPPP/98HXnkkfW0AGvF0G7+9YA4XvqIjcn9sTEdS1j/MKfj9ddfL6lStKN8QvVQUvKhAEQVUVLeu3IPeE25KDhQJ7I9c5einEJxiAXy+eefryujdt1116Yy2Jan++4iYN+lurE+x8Z+cAVwbK4ucxWxn0vKY+7gxvk1w4bNxz72MUnSNddcI6k1v4PPeU0boo2Qe8XxnC6uYOd9HDa+P3AXF6pD4pnXtE2UjqiUZ86cWf8fFSPr8j5lOdTF44VjdgeBq3pdDezHRjnuxgPOCXHtuWK4dmHD4NOf/rQk6Zvf/Kakan57HFfebnjNeMCYwvqeg4jxg/bE+ttuu62kVhcb2/t+3T3qzkrPBdbosHQlu+el8Xxj7irzurgLDObOnSupGuOIJXfScK44J+yPmPdzwBL1MSpirl3YcLnxxhslSa961askVfn4Sq582gxMnDhRUtXGUNfTFhl72K6Uy4m2isuD+yw+Z3vucVnfHc+N/xNf3G+WcrlQNnFDHd1BwDlhfeqIQ5Y+xd2eOF04ttLYyP4o76abbpIkHXrooQoDB9wZ5557rqQqj4k7H3GZ0J6IOdop08/4j2n07+Rw4TX5Nenn3flI+2x0evG/xykxSFksyevJvv0el/GffeNeo3x3PHv/xH7Jf3PKKacohP7EunSfxB05MBkyZIjuvvtuXXTRRVq4cKEmTJig17zmNbrsssuanDGPP/54y+8ODz74oP785z/X7wXXmpGSNm2zTg+fnOTBSwghhBBCCCGEEEIIIYQQ1jmbbbaZfvWrX7Vd7w9/+EPLe7vttluLgHGt6M5UYyvbfN6NXYQQwnrnl7/8pSTpsMMOk1SpDj2vCco7FLaupEXp5wr+dvN+u1rYHS+eE8bVSjNmzKgrI1HSsy7qf1fturIZXEXI0rfz/bjqFyUWDgC2433mGsdtxLkPGw/kIGIeatqix5XPmc3S5253/H13nLXLKcM81qgOeY3qEFWwK3iHDh3asg9XKvrc+6zvOZCgXV6bdueA8tgPdfYcH6zHa5SUXKuwYXL66adLkn74wx9KqtoZ/bTHFu8zbvC+Q39NO0NNDu58QUHvKneg/RFbnkvM3XFDhgxpccVQl5JLzHHXF8fuSmeOzevmcK44d/5+KecF/QvXKmz4nH322U2vzz//fEnVWEc/XHJnMV7gRPHP6Z95jePM2zRtj7aLU23BggVN26HiZ1wAVJ333XdfXVXPuA20Y/JHcD/Men6vBx6f5GbyY6PunAvODUvP6eT3xdx7vvvd75YkHXnkkQoDF9wan/3sZyVJ++67r6Sq38ah5TMP4ELD6eIuYWB9XCaei4i4IBaJC/KsbLHFFvX/2RfrAmUxzrqjxeOYe1TKIzZmzZrVtD7fv+gX2C854zhnIYQQ+oDuTCWWBy8hhBBCCCGEEEIIIYQQQgjdYFjtb3Ws6tku8uAlhNAvIHcQCqmDDz5YkjRlyhRJlXoXhR1KKZ8n3/OooMBzFa/jCkG2Y3/MKe9Kv0ZVvbtwmJebunkeC+raziLpCmZUiSineJ/yOTfsl89Rhz322GOSpD/+8Y+SqnmYw8YH8cTcp6jxUAO7+4Klq/hcyU6b9bbr+Ygc2iKKd2KGeqFOJt6AuEOx3lg+ZeGS8335MbG+59xgPXcYlI61dE7YD44H4tVdRp7PJnN5bxy8613vkiRdeeWVksoOKNoHsQj098QE/Tjvo1JHIUv7Zc55d3m624z27/PduwsUGpX97hBlW3efAeu5a5PYQW3MsXCMPnZ6vjOO0R189A/UB7Ux5XNtwsYLbgucZ8Qd/bC3XeIJRTttC1U+TkTK8bbo+So8L5E7zyjfc8UQZ8OGDWu5r2Uf7qJmX9SdOnj+P7Z3ZwHH5sdOH4ETjXNF+e4WIu449yE00l33xve+9z1Jrfeffi/n4wkxzRiIM4v2S7vFvXLCCSe07Puyyy6TVLnGaNPsm7J9315HHz/d8XzSSSd1ffA13vKWt6z28xBCCOuAzWp/q6Prnza6TR68hBBCCCGEEEIIIYQQQghhYNCdqcZWtPm8DXnwEkLoV7j7gvm7d911V0mVKhAlIKpElH+epwG1EeollH6Ass9V6ajRWfo84Sis2G7MmDH1/105jwPF1YquxPR8F+CKSn+feYxROVI3zhVzjD/00EOSpI985COSpGOOOUZhYMC80QcddJCkqm26+t0VhaW8EyW3h+dN8RwyDrHgOZOAehFDje4uV99TVimnRSlfjTta3AEDJRePQx9DHHveKFTHxCvX5g1veEO3yg8bBvfff7+kSk1Oe/VcL4DyftGiRZKq9uYuEdoTLg7aP+sxHpQUuZTDfhh3XGXcmLeBdRmzgLZO/DKvPZScLk899ZSkyvGCQtlzv3BOPAcbjhjq4+4CH0O5FmHggLvpJz/5iaRWdzRwn+T9tbcl2jrrl5wrnkPM45/9sx7x1zju+Jjl4yM5WPjcHTA+jrP0Y3G3G8fO+36/DYxhxG2cZKE3eO973yupilnavTu/vH2D9/vkUaF9n3zyycV9v+Md75Akff/7328qmzGJsn0GA48dXnPPyvcvji2EEEI/JA9eQgghhBBCCCGEEEIIIYQQeomhap/jJQ9eQggbM7gzWO6+++6SWue0LuU7QWnLeq4+93wpPjc2MDewz/OLIvBDH/pQ3a3DZ6h02dZdNeyL91HxunMFdZfnw/D5uF0hzX5vvfVWSZV7KAw8Pv7xj0uSLrroIknSC17wAkllR4qr8UuOlZILxF0knkPGnS2eh8g/7w6ed4k49Dm2S+6cUp2ddjmZSqp7yuMYH3nkEUnVtQkbF5/85CclSeecc44k6SUveYmkVqcKClpcJThNPGZor7g8aWeozufPn9+0f8aTkmOG990FSrywHDJkSIsbhm1YovovKZLdpUNdUc4zrz7r4zT1/sljj3qhLuZccG7/8Y9/SKquRRh4HHvssZKkCy64QJK00047SWrN9eWuSpTquLhKcVRyOtM23S3ieI6XVatWNf3fCM4WzwvldfO48zGN9Tk2jpW+xc8F2xGv06ZNkySdeOKJqz22ENYGYpacL7RLYpb2TD/POES77UmuoZIr5vzzz5dUxXPj+Ci1xghjXZwuIYSwAdAdx0u7z9uQBy8hhBBCCCGEEEIIIYQQQhgYbCZp9ToZafW6y7YM6mgn3QwhhH7ImWeeKUl6+ctfLknacsstJbXOd49Cyue6dqUUXSFKfz5Hhcxc8yh7eX3EEUe01O26665rqhMKZl67EhllPIopV1KhOmSJosqPlTrdcsstkqLyDWUuv/xySdJ2220nqdUBxnz4nlfIlYbeZn09X99xdwgqQc+t5Llobr/9du2///5NdScuPJcSakli250u4MpFd7x4X+HrA3P2o753B9uMGTMkSUcffXSX9QgbJ+58od2Qk4X24rleUNgyfnhOCWIFFwnr4SKhfFfB007d5Ylin3L//ve/60UvepGkKqZQ5HMM9Bv0F+5sQ1GPC5NjRHFPudSRGGY9lMyMnRwj/RTlcwx33HGHJOnUU09VCI18+ctfliS99KUvlVTFF/05/TQ58XbZZRdJrfdv7h7x8YByGJfcRcKYRhwy9t15553ab7/9JFVjF3FFWcQJdacs6uDjrudI8vvahx9+WFKVS9HPBXW/7bbbJElnnHGGQgghhBA2ZBYvXtx5X3fdImnklqtfecli6YhRWrRoUf2ecE2I4yWEEEIIIYQQQgghhBBCCAODTDUWQghd424O5gLeZ599JFXKPlS7gFIX9TrqRFcOAkpc1PIoce+9915JXTte+AxFJXlhUBIDdaROqAp5HxeBb+ev77zzTknVXMKHHHJIS51CaAS3xaWXXipJmjx5sqTWeepRvKLSdQVtSfVbyskAvE+5no+F9+fMmSNJmjRpUtP+VqxY0aIsZl2fg5uyfb56d6qU8tFQPq4cd7ywZD+cO9/+8ccflyQdc8wxXZ6TsHGD++LrX/+6JOmggw6SVKnPvT3iRPGxyV2ZjB+4Pzw/BK9LucDcFepx0tHR0bKNx2nJ/VWqC3XlWFyxj7LfzwVuA1fuU/7NN98sSfroRz+qELrC3RrcO+6www6SqntG2pzndKFtept1NzXbc8+II402T1xzLzp9+nRJnbHB/6zDvrlHZCzCMYYLDmcMdQLijrr7WEddGUO573300UclVfeWr33taxVCCCGEsFGRBy8hhBBCCCGEEEIIIYQQQgi9xAhJI9us08MELXnwEkLYKECRB9/85jclSXvvvbekaq5sV7OjTmeJIhAFLTCH/F/+8hdJ0uc+97liXVBUfuYzn5EkHXjggZIqdaLP082+USuiTuR91MXMAX733XdLkk4//XRJ0ste9rJiXUJYHX/84x8lSYcffrikqk2iyqXtleaKZz1XBZdw54wr4lERo2znc9o+6z333HN1BTF19m157ftwx0op50vJAUP8Uq47X1Awo06m7pzrOF4GNrgxPvGJT0iqxgfaK7leGC+22morSVUeFZbuKmNJey7lWwFU8yjyiXVXza9YsaJFQY8rgLaO4t5zPbFvyiTfDHXhfZT9rE+5nAPeJ+aJQZaMy1/60pcUwprg947OZZddJkmaMmWKpGrs4v7M8xMRh57bi3ijrfOaNk1MnHTSSbrkkkskSU8++aSkKg48L6C7a8BjnnhlzGJ9XJjtzkEIIYQQwkZLHC8hhBBCCCGEEEIIIYQQQgi9xCZq/2Clh09OBnW0k6eGEMJGwIc+9CFJVb6VsWPHSqrmmkepi9IWFSJzXp911lk9rsN//dd/SZLGjx8vqVIx+r5RPM+bN09SpXr8zne+0+M6hNAVH/jAByRVOYtom55PwpXqKN1Zz28peE3bZvncc881fe45X9gf6wEukn/84x/1fE4oiMEV+yiR3bnCesQfS89TwWt3CFA3ync1Mn3IddddJ0n67ne/qxBKfPWrX5UkTZw4UZK06667SqoU9VtuuaWk1lgjpnB/0A49dmmXxBivFy9eLKlq5zjGKO93v/tdPW8Yrhxyq1AHr5s750pKfcrz2PO6odh/6KGHJEmzZs2SJH3sYx/z0xjCOuGcc86RJO20006SqjZfGm+IH+7jiFO2Yyzj8+OPP75lnxdffLGk6n6VsY64IG74nHgqjaNs98gjj0iq8k6FEEIIIQw0Fi9e3Pm9555F0hZbrn7lpxdLU0dp0aJF9Xu5NSGOlxBCCCGEEEIIIYQQQgghDAxGqn2Ol1VtPm9DHC8hhBBCkCSdcsopkqQDDjhAUuV8IUcSCg9U+ChwUfu6g8Xzq6C4Je8J+SqYL5/12M7Lmzt3riTpwQcf1G677SZJ2nbbbSWV8zehQPb57f2YPOeSl4d6GKUyKnw/Jpwut956qyTp3HPPVQhryq9//WtJVY4XYg6Fveca4nPPs4I7haXHKu4SyoUnnnhCkjR9+nRtv/32kqRx48Y1rYOS3nM9ESu4Z1gC6n9iiJhDsU+5fP7UU09Jkl7/+tcrhP7AmWeeKalyURN/tGWgrfu4sja5vi699FJJreOrxzzvEz+4pj/5yU+u8T5DCCGEEDZG6o6X6Yukdi6WxYul7eN4CSGEEEIIIYQQQgghhBBCWD1D1T7HS7vP2xDHSwghhBC65Otf/7qkygGDwgMFO+p54DWKd5S3qH1dgbtgwYKm8tz5ggsFVT45HhohFwaqe9+WOqD4HzNmjKRWpbLX1Y8FeE15OF5wuHz0ox9tqWMIa8tll10mSdpll10kVe0SJT0OLpxfuNBo/+SQwDWCYwuHi+dnobx77rlHUqfLBffL1KlTJVVONc/FglOFOuDWIQcFsUkdcLBRHsp9Yuzhhx+WJL3jHe9of6JCCCGEEEIIoRvUHS9PddPxslUcLyGEEEIIIYQQQgghhBBCCKtl8BBp0JDVr9MxpGdpXuJ4CSGEEMJqYT77N77xjZIqNT0qedTzKNY9hwOKdtZ/+umnJVV5UWbNmiWpUrrjQiHnAw4Zyj3ppJP0gx/8oGmfOFjIfcG+cQhMnDhRUpXbZYsttpBUqfZR+nuuDPaJmp/1Ue//6le/kpT588O65XOf+5wkaa+99pJUxQaxNX78eElVjNGOcZfgeKH9EheUw3L69OmSqlg88sgjdc011zRtQ84XYo0l21AHHC84YIhJ6jBnzhxJVexRzr333itJ+sxnPtPNsxNCCCGEEEII3QPHy5hFizS4jYtl1eLFWjAqjpcQQgghhBBCCCGEEEIIIYTVMlzS4Dbr9MTtIsXxEkIIIYRu8uEPf1iSdMghh0jqzP8gVep6d5GgtkfJjkIEBTxKd3edoLondwTukpNPPrmlTt///vclVS4c9oEq3902vKZu7APFP3Vzdw5qffJd/O53v5Mkfetb3+riTIWwbvnCF74gSdpxxx0lSZMmTZJUuUxwbAHtnPYNzzzzjKTKfUbuomOPPbZlnz/5yU8kVTmZcI9tvvnmTesRW64Iwz2G+2bmzJmSpGnTpkmSPvWpT3V5rCGEEEIIIYTQW+B42aGbjpdH43gJIYQQQgghhBBCCCGEEEJYPZtKapPiRSt7uI84XkIIIYSwVpB34hWveIUkaezYsZKkQYMGSapyPqxYsaJpO3LCsATyqOB8ueeeeyRJJ554Ytu6XHDBBZKkqVOnSqqcLaV9sIRNNunUopDHgtujefPmSZL+/Oc/S0reidA/+cQnPiFJ2mmnnSRJkydPllTFAW4THC+0b/IrHXXUUWu8zyuvvFJSlT+JuMfxguuGeH788cclSY888ogk6Utf+tIa7zOEEEIIIYQQegKOl5cuWqRN2rhYVixerNvieAkhhBBCCCGEEEIIIYQQQlg9w9X+wciKNp+3I46XEEIIIfQKn//85yVJu+++uyRp2223lVSp7rnl4DUuEyBPy4wZMyRJb3jDG9a4DjfeeKMkabvttpNU5YcB3Deo8FHp83ru3LmSpPvvv1+S9OlPf3qN6xBCf+W//uu/JElnnXXWBlV2CCGEEEIIIfQGOF5ev2iRhrZxsTy/eLF+HcdLCCGEEEIIIYQQQgghhBDC6hkuaWibddrlgGlHHC8hhBBCWCeceuqpkqrcLzhgttlmG0mt+SdmzpwpqXKdfOELX1jjfX7qU59q2tekSZMkteabePLJJ5v2RS6Xc845Z433GUIIIYQQQgghhP4Pjpf/s2iRhrVxsSxfvFg/6oHjJQ9eQgghhBBCCCGEEEIIIYSwUcODl3d388HL+ZlqLIQQQgghhBBCCCGEEEIIYfVsWvtbHYN6uI88eAkhhBBCCCGEEEIIIYQQwoBguPLgJYQQQgghhBBCCCGEEEIIoVfYVJ0PX9YlefASQgghhBBCCCGEEEIIIYQBwWi1f/CytIf7yIOXEEIIIYQQQgghhBBCCCEMCLrjeOno4T7y4CWEEEIIIYQQQgghhBBCCAOCTdU+x8uqHu4jD15CCCGEEEIIIYQQQgghhDAg6I7jJQ9eQgghhBBCCCGEEEIIIYQQusEoSSPbrDO0h/vIg5cQQgghhBBCCCGEEEIIIQwIhqu942VlD/eRBy8hhBBCCCGEEEIIIYQQQhgQ5MFLCCGEEEIIIYQQQgghhBBCL9GdHC8reriPwT3cPoQQQgghhBBCCCGEEEIIYa346U9/qje+8Y0aO3asBg0apL///e8t63zve9/Tq1/9am255ZYaNGiQFi5cuNb721KdeV5W97flWpfeyUb74OXaa6/VwQcfrC233FIjR47UXnvtpe9973st6/3mN7/RgQceqBEjRmjs2LE68cQT9cQTT6yHGoew4fGb3/xGr3/96zVx4kRtuummGjdunA455BD98pe/bFl32bJl+trXvqapU6dq5MiR2nbbbXXYYYfplltuWQ81D2HD4qc//amOPfZY7bLLLtpss820ww476P/8n/+jhx56aH1XLYQNlnvvvVcf+MAHdOCBB2rkyJEaNGiQ/vCHP3S57uLFi/Xf//3f2m233TRixAhNmjRJb3/723Xvvff2baVD2AD5yU9+ole96lXadttttemmm2rixIk6/PDD294Dzp07V1tvvbUGDRqkK6+8so9qG8KGzWc/+1kNGjSo5W/48K41vZdeeqle9KIXafjw4Zo4caJOP/10PfPMM31c6xA2TDo6OvTDH/5QL33pSzVy5EhtueWW2m+//XTttdcWt8nYFkKZJUuW6KCDDtJZZ51VXOfZZ5/VoYceqk984hM93t/wbv71hI1yqrGzzjpL//3f/633v//9OuOMMzR06FDdf//9Wr58edN6f/zjH3XYYYfpzW9+s6699lo98cQT+vjHP67Xvva1uuOOO7TpppuupyMIYcNg/vz52muvvXTyySdr/Pjxeuqpp3TeeefpzW9+sy6++GIdd9xx9XXf85736Ec/+pHOOOMMHXLIIXrqqad01lln6eCDD9bNN9+sl770pevxSELo33zlK1/R+PHj9d///d/aaaedNH36dH3pS1/Sfvvtp1tvvVV77bXX+q5iCBscd9xxh6655hrtu+++eu1rX6uf/exnxXUPP/xw3XHHHfrsZz+rl7zkJZoxY4Y+//nP68ADD9Tdd9+tKVOm9GHNQ9iwmD9/vg466CB9+MMf1tixYzV79mydffbZetWrXqXf/va3Ovjgg7vc7oMf/GDxx+IQwuq54YYbNGrUqPrrwYNbNbc/+tGPdNxxx+nkk0/WN77xDT344IP6+Mc/rvvuu0833nhjX1Y3hA2SU045RRdccIH+8z//U1/+8pe1YsUK3X333Xr22WeL22RsC6HM8ccfL0l69NFHi+ucfvrpklQUzK0J3ZlqbHmbz9vSsZFxxx13dAwePLjjK1/5Stt1999//44999yz4/nnn6+/d/PNN3dI6vjud7+7LqsZwkbL8uXLOyZNmtTxyle+sv7e0qVLO4YMGdJx3HHHNa07a9asDkkdp512Wl9XM4QNirlz57a8N3PmzI6hQ4d2vPvd714PNQphw2flypX1/6+44ooOSR2///3vW9Z76KGHOiR1fPKTn2x6/5ZbbumQ1HH22Wev66qGsNGxcOHCjqFDh3Ycf/zxXX5+5ZVXdmy++eYdF154YYekjiuuuKKPaxjChslnPvOZDkkdTz755GrXW7FiRceECRM63vCGNzS9/6Mf/ahDUscvf/nLdVnNEDZ4rr766g5JHZdddlm3t8nYFkL3mDZtWoekjrvuuqu4zu9///sOSR0LFixY4/IXLVrUIalj7qJFHc91dKz2b25t3UWLFq35gXR0dKzzqca6srnyt7onWGvLOeeco0033VQf+tCHVrvezJkzdfvtt+v444/XJptUxp+Xv/zl2m233XT11Vf3et1CWNf0dbx1xdChQzV69OimuBo8eLAGDx7cpLqSpC233FKDBw+O4iNscPR1rI0bN67lvYkTJ2q77bbT9OnTe31/IfQn1lW8daX+7YqhQ4dKUssYNnr0aEnKGBY2GvpybNtiiy00fPjwpvtFeOqpp/TBD35QX/ziFzV58uRe3W8I/YX1/b3t1ltv1ezZs/Wud72r6f23v/3t2nzzzfN7SNhoWFex9q1vfUs77LCDjj766G6tn7EthP7H8sWLu/XXE9b5VGN/+ctfml4/99xzOv7447Vy5UpttdVW6ujo0MqVK7tVVlc35s5NN92kPfbYQ1dddZW+8IUv6OGHH9aECRN03HHH6fOf/7yGDRsmSbrnnnskSS984QtbynjhC1+om2++uVt1CqE/0dfxBqtWrdKqVav0xBNP6H/+53/04IMP6itf+Ur986FDh+oDH/iAzj//fL3uda+rTzX2iU98QqNGjdJ73vOebu8rhP7A+oq1Rh555BE99thjOvLII9dq+xA2FNZ3vE2ZMkVvectb9I1vfEMvfvGLtf/++2vGjBk67bTTNHnyZB1zzDFrXGYI/ZF1HWsrV67UqlWrNHPmTH35y19WR0eHPvjBD7asd9ppp2nHHXfUqaeeqptuumntDiaEfs66jre9995bTzzxhMaOHas3vvGNOvPMM5t+7C39HjJ06FDtvvvu9c9D2NBZF7G2YsUK/eUvf9Gb3vQmnX322frWt76lGTNmaMqUKfrABz6g/+//+/80aNCgpm0ztoXQzI9+9CO9733vq7++/vrr9cpXvrJP9j1s2DCNHz9e22+/fbfWHz9+fP15wpqyzh+8HHDAAfX/V65cqbe97W1atGiR/vjHP2rLLbfUBRdc0KKyKNHR0dF2nZkzZ+rJJ5/Uaaedpi984Qvac8899dvf/lZnnXWWpk+frh/96EeSOucalqStttqqpYytttqq/nkIGxJ9HW/wpje9Sb/61a8kdbpYLrvsMr35zW9uWucb3/iGRo0apbe97W1atWqVJGny5Mn63e9+p1122aXb+wqhP7C+Yg1WrFihd7/73dp88831n//5n2u8fQgbEus73iTpiiuu0Ac/+EEdcsgh9fde+MIX6o9//KPGjBmzVmWG0N9Y17G211576YEHHpAkTZgwQTfccINe/OIXN63zi1/8QpdffrnuvPPObrvSQtgQWVfxtvPOO+uLX/yi9t13Xw0fPly33XabvvrVr+rGG2/U3/72N02aNElS+99D+mq2hBDWNesi1ubNm6dly5bpt7/9rW6//XZ98Ytf1HbbbacrrrhC//f//l8tWLBAX/ziF+vbZWwLoZUjjjhCL3vZy+qvGZ/6guHDh2vatGktueBLDBs2bK1nOVjnD14aOfXUU/WLX/xCP/vZz7TffvtJ6kxWevvtt69ROV09kebJ86pVq/T000/rJz/5SV2B+JrXvEZLlizRN7/5TX3uc59r+pHXn0K3ez+EDYW+iDf4zne+o4ULF2r27Nm65JJL9I53vEMXXnihjj322Po6X/ziF/X1r39dn/3sZ/XKV75Sixcv1jnnnKPXv/71uvHGG7Xvvvuu5ZGGsH7py1hjvXe/+93605/+pKuuuqrbKo0QNgZ6K97WlFNOOUVXX321vvGNb2i//fbTnDlz9LWvfU2HHHKIfv/732vKlCnrdP8h9DXrItauuuoqLVmyRI8//rjOO+88HXbYYbruuuv06le/WpK0aNEive9979PHP/5xTZ06tTcOI4QNgt6MNxITw2te8xq95jWv0YEHHqivfvWr+ta3vtX0eX4PCQOJ3oo1hKSLFy/Wr371q/rDnUMOOURz5szR2WefrTPOOEObb755xrYQCmyxxRbaYost1tv+hw8f3jdTRq9VZpi14Atf+EKHpI7zzz+/6f1Vq1Z1PP/88936gx/+8Icdkpr+YPz48R2SOp566qmm/fzqV79qSnx1ww03dEjq+MUvftFS16OOOqpjwoQJvXn4IfQpfRVvJQ499NCOMWPG1BMX33fffR2DBg3q+NrXvta03vLlyzt22WWXjle/+tW9cNQh9D19HWurVq3qOOmkkzoGDx7ccfHFF6/z4wuhP9Gb8eZcccUVHZI6fv/737d8dv3113eZAHXBggUdo0aN6jjx/2/v/kKi6P44jn/N/INKPrZRKoJdiGaKZqltXmQRFhEWZZCFiQjbHyspDAmEXOrCQoPAokRKI6kgoYtqi0XIAsvK2kC6KAklwrXI1kqkMPr+LsKlHrWf5eyuT71fsBczc2bPORcfhpkvc6aoyJD5AVOFJ7M2Ynh4WJOTkzUlJcW9b9euXTp37lzt6+tTl8ulLpdLr169qiKi586dU5fLpV+/fjV8voAveSNvqqrz5s3TzMxM9/bp06dVRPTp06ej2qanp+uSJUsmNzFgijEya0NDQ+rn56czZswY1U9dXZ2KiN6/f19VubYBv6K/v18dDodev35dRUQvXbqkDodDnU6nu43T6VSHw6H19fUqInrnzh11OBza39/vw5GPzyuFl5GHSVarddxjE/mNePv2rT58+PCH34iVK1eOWXgZKbSM3DS/evVKRUSPHDkyakwJCQmak5Nj1PQBr/Jm3sZz8OBBFRHt6+tTVdWLFy+qiGhra+uotnl5eTpr1qxJzBjwDW9nbaTo4ufnp2fPnvX4/ICpxOi8/dvPCi9VVVUqItrT0zPq2KJFizQ9PX1ScwOmEk9n7XuFhYUaHBzs3s7Ozv6//+tyuYyaKuBz3sxbQkKCms1m93ZbW5v7odb3hoeHNSwsTC0Wy+QmB0whnshafHz8mIWXkaLmyL0c1zZg4sbLY2VlpbtNZWXlmG0aGhp8Nu6f8fhSYzdv3hSLxSLFxcVSWVk56vjvvNZnMpnEZDKNeSwvL0/sdrvcuHFDtmzZ4t5vs9lk2rRpkpGRISLf1o7LzMyUpqYm2b9/v/j7+4uISHt7uzx79kz27t37S2MCpgJv520sqiq3b9+Wf/75x31edHS0iHzLV3Z2trvt58+f5fHjxxITE/NLYwJ8zdtZU1WxWCzS0NAgdXV1E16HGPgTeCJvv+L7a9j3S4r19/fL8+fPZcWKFR7rG/Amb2bt06dP0t7e/sMS0MePH5eBgYEf2j158kT27dsnVqtVsrOzJSwszJD+AV/zZt7a29ulq6tLSktL3fsWL14sUVFR0tjYKJs2bXLvb25ulsHBQdmwYYMhfQO+5qms5eXlSVVVldy9e1eysrLc+202m4SFhUlSUpKIcG0DfkVRUZEUFRX9tI3VahWr1eqV8RjBT/U3vzI6Ad3d3ZKSkiLR0dFy5syZUWvVp6WlSVBQkKF9Dg8Pi9lslhcvXsihQ4dk/vz50tLSIjU1NbJz506pra11t21tbZWcnBzJzc2VkpISefPmjRw4cEDCw8Olo6PD8LEBnuSLvK1bt05SU1NlwYIFYjKZpLe3VxobG8Vut8vJkyelpKRERL6tgWo2m6Wzs1PKy8tl6dKl8v79e6mtrZXW1lY5f/68FBQUGDo2wFN8kbU9e/bIiRMnpLi4WCwWyw/HgoKC+EYS/liezNvQ0JDYbDYR+fZQ6tixY2K1WiUpKUlCQ0Nl9erVIiIyODgoycnJ8uHDB6moqJCFCxeK0+mU6upq6ezslJaWFvc3KoD/Kk9mLSsrS9auXSuJiYkSHh4uPT09curUKXn06JFcuXJFcnNzxz23tbVVli9fLpcvX5aNGzf+Vv/AVOPJvKWmpkpBQYEkJiZKcHCwPHjwQKqrqyUkJEQ6OjokKirK3bapqUm2bt0q27Ztk82bN0tXV5eUl5dLRkaG2O32Sc0RmAo8mbV3795JWlqafPnyRQ4fPiwxMTHS3Nws9fX1UlNTI2VlZeOey7UN+It48nWaW7du/fR1uu7ubo/029/fr9u3b9c5c+ZoQECAxsfHa3V1tft7E9+z2+1qNps1ODhYZ86cqYWFhfr69WuPjAvwJF/k7ejRo5qRkaERERHq7++vJpNJV61apdeuXRvVdmBgQCsqKjQxMVFDQkJ09uzZumzZMrXZbIaPC/AkX2QtNjZ23P5iY2MN7w+YKjyZt+7u7gnnyul06u7duzUuLk6Dg4M1Ojpa16xZo/fu3ZvcBIEpwpNZKysr09TUVA0PD9fp06drZGSkrl+/Xtva2iY8rn9/Ywn4L/Nk3vLz8zUuLk5DQ0M1ICBAY2NjdceOHdrb2ztm+wsXLmhKSooGBgZqZGSklpaW6sePH3+7f2Aq8fR928uXLzU/P18jIiI0MDBQU1JSJrQkNNc24O/h0TdeAAAAAAAAAAAA/ibTfD0AAAAAAAAAAACAPwWFFwAAAAAAAAAAAINQeAEAAAAAAAAAADAIhRcAAAAAAAAAAACDUHgBAAAAAAAAAAAwCIUXAAAAAAAAAAAAg1B4AQAAAAAAAAAAMAiFFwAAAAAAAAAAAINQeAEAAAAAAAAAADAIhRcAAAAAAAAAAACDUHgBAAAAAAAAAAAwCIUXAAAAAAAAAAAAg/wPGy2vASLzCdoAAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig_IC = plot_IC(\n", " dpath_outputs / \"melodic_results\" / \"melodic_IC.nii.gz\",\n", " i_component=i_components_sorted[0],\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "360efdfa", "metadata": {}, "source": [ "We compare our top ICA component with the PD-ICA component from the original paper (available [here](https://identifiers.org/neurovault.image:12551)):" ] }, { "cell_type": "code", "execution_count": 18, "id": "2d013717", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ICA file already exists, skipping download\n" ] } ], "source": [ "%%bash\n", "if [ ! -f ${FNAME_PD_ICA} ]\n", "then\n", " wget \"https://neurovault.org/media/images/860/melodic_IC_0007.nii.gz\"\n", "else\n", " echo 'ICA file already exists, skipping download'\n", "fi" ] }, { "cell_type": "code", "execution_count": 19, "id": "18c445f6", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "fig_IC_orig = plot_IC(\"melodic_IC_0007.nii.gz\")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "26e2251e", "metadata": {}, "source": [ "Our most significant component does not match the PD-ICA component described in the original study: we obtain regions mostly in the frontal lobe, while the original ICA component mainly includes subcortical regions. Moreover, our clusters tend to be bigger than those in the PD-ICA component, suggesting that there could be inconsistencies in spatial smoothing procedures between our pipeline and the one used in the original study. " ] } ], "metadata": { "kernelspec": { "display_name": "Python 3.10.6 ('livingpark')", "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.10.6" }, "vscode": { "interpreter": { "hash": "7c1dce6928164983c9394696a67460054b2345bd05d18f1e86972521ab8096b4" } } }, "nbformat": 4, "nbformat_minor": 5 }