diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 89dc7191..d925c4be 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -62,7 +62,7 @@ jobs: shell: bash -l {0} run: | echo "Download combinatorial library from zenodo..." - wget -q -O data/combinatorial_library/combinatorial_library.tar.bz2 https://zenodo.org/record/17368450/files/combinatorial_library.tar.bz2?download=1 + wget -q -O data/combinatorial_library/combinatorial_library.tar.bz2 https://zenodo.org/record/18386001/files/combinatorial_library.tar.bz2?download=1 ls -l data/combinatorial_library/ echo "Decompress selected files..." tar -xvf data/combinatorial_library/combinatorial_library.tar.bz2 combinatorial_library/combinatorial_library_deduplicated.json combinatorial_library/chembl_standardized_inchi.csv @@ -74,6 +74,6 @@ jobs: shell: bash -l {0} run: | PYTEST_ARGS="--nbval-lax --nbval-current-env --nbval-cell-timeout=3600" - PYTEST_IGNORE="--ignore=notebooks/custom_kinfraglib/2_4_custom_filters_paper.ipynb --ignore=notebooks/custom_kinfraglib/1_4_custom_filters_pairwise_retrosynthesizability.ipynb --ignore=notebooks/custom_kinfraglib/2_1_custom_filters_pipeline.ipynb" + PYTEST_IGNORE="--ignore=notebooks/custom_kinfraglib/2_5_custom_filters_paper.ipynb --ignore=notebooks/custom_kinfraglib/1_4_custom_filters_pairwise_retrosynthesizability.ipynb --ignore=notebooks/custom_kinfraglib/2_1_custom_filters_pipeline.ipynb --ignore=notebooks/custom_kinfraglib/2_4_custom_filters_enumeration_analysis.ipynb" pytest $PYTEST_ARGS $PYTEST_IGNORE diff --git a/data/combinatorial_library/README.md b/data/combinatorial_library/README.md index ec6097b4..86c13b49 100644 --- a/data/combinatorial_library/README.md +++ b/data/combinatorial_library/README.md @@ -1,18 +1,20 @@ # KinFragLib: Combinatorial library -[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.17368450.svg)](https://doi.org/10.5281/zenodo.17368450) +[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.18386001.svg)](https://doi.org/10.5281/zenodo.18386001) This folder is meant for the metadata and properties of the KinFragLib combinatorial library, which is based on the KinFragLib fragment library at https://github.com/volkamerlab/KinFragLib. This dataset is used for the analysis of the combinatorial library. -**Note**: Since this dataset contains large files, we provide it outside this repository at https://zenodo.org/records/17368450 (DOI: 10.5281/zenodo.17368450, v2.0.2). +**Note**: Since this dataset contains large files, we provide it outside this repository at https://zenodo.org/records/18386001 (DOI: 10.5281/zenodo.18386001, v2.0.3). In order to run the analysis notebooks, please download this dataset to this folder. ## Raw data - `combinatorial_library.json`: Full combinatorial library, please refer to `notebooks/kinfraglib/4_1_combinatorial_library_data_preparation.ipynb` at https://github.com/volkamerlab/KinFragLib for detailed information about this data format - `combinatorial_library_deduplicated.json`: Deduplicated combinatorial library (based on InChIs) -- `chembl_standardized_inchi.csv`: Standardized ChEMBL 36 molecules in the form of InChI strings. +- `chembl_standardized_inchi.csv`: Standardized ChEMBL36 molecules in the form of InChI strings. - `KLIFS_download_summary.csv`: PDB codes of all KLIFS structures used to generate the KinFragLib fragmentation library. +- `combinatorial_library_custom_sampled.sdf`: Combinatorial library created from a subset of CustomKinFragLib fragments. +- `combinatorial_library_rejected_sampled.sdf`: Combinatorial library created from a subset of fragments rejected by the CustomKinFragLib filtering pipeline ## Processed data @@ -26,3 +28,5 @@ Data extracted from `combinatorial_library_deduplicated.json`, performed in `not - `chembl_exact.json`: Ligands with exact matches in ChEMBL - `chembl_most_similar.json`: Most similar ligand in ChEMBL for each recombined ligand - `chembl_highly_similar.json`: Most similar ligand in ChEMBL for each recombined ligand with similarity greater than 0.9. +- `custom_enamine_search_sampled.csv`: Most similar molecule from Enamine REAL Space for each molecule in the CustomKinFragLib combinatorial library. +- `reference_enamine_search_sampled.csv`: Most similar molecule from Enamine REAL Space for each molecule in the rejected fragments combinatorial library. diff --git a/notebooks/custom_kinfraglib/1_3_custom_filters_synthesizability.ipynb b/notebooks/custom_kinfraglib/1_3_custom_filters_synthesizability.ipynb index 93f35699..7564de61 100644 --- a/notebooks/custom_kinfraglib/1_3_custom_filters_synthesizability.ipynb +++ b/notebooks/custom_kinfraglib/1_3_custom_filters_synthesizability.ipynb @@ -68,6 +68,7 @@ "\n", "import pandas as pd\n", "from rdkit.Chem import PandasTools, Draw\n", + "from rdkit import Chem\n", "from IPython.core.display import HTML\n", "\n", "from kinfraglib import filters, utils" @@ -883,6 +884,307 @@ "# NBVAL_CHECK_OUTPUT" ] }, + { + "cell_type": "code", + "execution_count": 15, + "id": "9a769bdf", + "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", + " \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", + "
subpocketstandardized_inchiROMolROMol_dummyROMol_originalkinasefamilygroupcomplex_pdbligand_pdbaltchainatom_subpocketsatom_environmentssmilessmiles_dummyfragment_countconnectionsconnections_namebool_bb
1APANWXJTIAQXBCCR-YPKPFQOOSA-N\"Mol\"/\"Mol\"/\"Mol\"/AAK1NAKOther5te0XINAAP AP AP AP AP AP AP AP AP AP AP AP AP AP AP A...7 16 7 16 16 16 16 5 16 16 16 16 16 5 5 5 5 5 ...N/C(=C1\\C(=O)Nc2ccccc21)c1ccccc1[12*]N/C(=C1\\C(=O)Nc2cc([20*])ccc21)c1ccccc13[SE, GA][AP=SE, AP=GA]0
2APFKUKJUIMZLBIMC-SSZFMOIBSA-N\"Mol\"/\"Mol\"/\"Mol\"/AAK1NAKOther8gmcYFVAAP AP AP AP AP AP AP AP AP AP AP AP AP AP AP A...4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 4 16 4 4 4 4...CC1=C2/C(=N/c3ccccc3)N=CN=[N+]2C=C1[39*]c1cccc(/N=C2\\N=CN=[N+]3C=CC(C[42*])=C23)c11[FP, FP][AP=FP, AP=FP]0
6APWTCWKWDFGJMKBZ-UHFFFAOYSA-N\"Mol\"/\"Mol\"/\"Mol\"/ABL1AblTK2v7a627BAP AP AP AP AP AP AP AP AP AP AP AP AP AP AP A...4 4 4 14 4 5 5 1 1 4 4 4 4 4 4 4 4 4 4 3 3 3 3...COCC(=O)n1cc2[nH]nc(NC=O)c2c1[8*]C(=O)Nc1n[nH]c2cn(C(=O)[C@@H]([46*])OC)cc123[SE, FP][AP=SE, AP=FP]0
9APJQCNYBPXXQRRJX-UHFFFAOYSA-N\"Mol\"/\"Mol\"/\"Mol\"/ACKAckTK1u4dDBQBAP AP AP AP AP AP AP AP AP AP AP AP AP AP AP A...7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 7 naO=C1NCCCc2cc[nH]c21[19*]=C1CCNC(=O)c2[nH]ccc214[FP][AP=FP]0
11APSMXRCJBCWRHDJE-UHFFFAOYSA-N\"Mol\"/\"Mol\"/\"Mol\"/ACKAckTK3eqrT74AAP AP AP AP AP AP AP AP AP AP AP AP GA SE FP9 14 14 14 14 14 14 14 14 14 5 5 na na naNc1ncc2cn[nH]c2n1[17*]n1nc([24*])c2cnc(N[51*])nc213[GA, SE, FP][AP=GA, AP=SE, AP=FP]0
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# data frame with all molecules not matching Enamine building blocks \n", + "rejected_fragments = fragment_library[\"AP\"][fragment_library[\"AP\"][\"bool_bb\"] == 0]\n", + "HTML(rejected_fragments.head().to_html(notebook=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "e399c26e", + "metadata": {}, + "outputs": [], + "source": [ + "enamine_path = PATH_DATA / \"filters\" / \"Enamine\" / \"most_similar_enamine_fragment.sdf\"\n", + "enamine_frags = [mol for mol in Chem.SDMolSupplier(str(enamine_path))]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "ada57089", + "metadata": {}, + "outputs": [], + "source": [ + "# create dataframe for each pair (rejected KinFragLib fragment, closest building block) with Tanimoto similarity \n", + "enamine_matches_df = pd.DataFrame(columns=[\"Fragment\", \"BuildingBlock\", \"Similarity\", \"Name\"])\n", + "for i, mol in enumerate(enamine_frags): \n", + " if i % 2 != 0: \n", + " continue\n", + " ind = int(i / 2)\n", + " enamine_matches_df.loc[ind] = [mol, enamine_frags[i+1], enamine_frags[i+1].GetProp(\"Similarity\"), mol.GetProp(\"_Name\")]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "cc50f391", + "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", + "
FragmentBuildingBlockSimilarityName
1410\"Mol\"/\"Mol\"/0.225806451612903222x4f_altA_chainB
191\"Mol\"/\"Mol\"/0.275862068965517248bub_chainB
257\"Mol\"/\"Mol\"/0.280653950953678453bbt_chainD
\n", + "
" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# sort by similarity \n", + "enamine_matches_df = enamine_matches_df.sort_values(\"Similarity\")\n", + "HTML(enamine_matches_df.head(3).to_html(notebook=True))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "2b27c2af", + "metadata": {}, + "outputs": [], + "source": [ + "# create svgs \n", + "from rdkit.Chem.Draw import rdMolDraw2D\n", + "mols = [enamine_matches_df.iloc[0].Fragment, enamine_matches_df.iloc[0].BuildingBlock, enamine_matches_df.iloc[2].Fragment, enamine_matches_df.iloc[2].BuildingBlock]\n", + "\n", + "for mol in mols: \n", + " file_name = \"figures/\" + mol.GetProp(\"_Name\") + \".svg\"\n", + " Draw.MolToFile(mol, file_name)\n" + ] + }, { "cell_type": "markdown", "id": "8378013e-fdd4-4b64-86f1-543e788054d8", @@ -903,7 +1205,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 20, "id": "69b09b15-6bac-4c77-b287-79950d97f6bd", "metadata": {}, "outputs": [ @@ -953,7 +1255,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 21, "id": "6063ef2c-ef6f-49e6-bf04-fa5d0c270a95", "metadata": {}, "outputs": [], @@ -971,7 +1273,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 22, "id": "d3a7906c-bf9d-4d06-bdf3-6bacbb3c028c", "metadata": {}, "outputs": [ @@ -1154,7 +1456,7 @@ "" ] }, - "execution_count": 17, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1173,7 +1475,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 23, "id": "2155cee8-3cbe-45d0-a26b-7f04f6b3feae", "metadata": {}, "outputs": [ @@ -1261,7 +1563,7 @@ "Total 3414 2937 477" ] }, - "execution_count": 18, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -1307,7 +1609,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 24, "id": "2cde65fc-d66f-4339-94c8-9ab53c74a872", "metadata": {}, "outputs": [], @@ -1319,7 +1621,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 25, "id": "43fc28c6-db67-4823-861f-5c380c507ad1", "metadata": {}, "outputs": [ @@ -1328,75 +1630,75 @@ "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", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", - " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", "
synthesizability filters
 pre-filteredaccepted by 2accepted by 1accepted by 0pre-filteredaccepted by 2accepted by 1accepted by 0
AP1164520533111AP1164520533111
FP1071456486129FP1071456486129
SE72137631629SE72137631629
GA352279676GA352279676
B14734121B14734121
B25945140B25945140
Total341417101428276Total341417101428276
\n" ], "text/plain": [ - "" + "" ] }, - "execution_count": 20, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -1421,7 +1723,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 26, "id": "4379c74f-08ff-40d5-b7f7-2fdaee686f78", "metadata": {}, "outputs": [ @@ -1452,7 +1754,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 27, "id": "16041f35", "metadata": {}, "outputs": [ @@ -1641,7 +1943,7 @@ "" ] }, - "execution_count": 22, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -1662,7 +1964,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 28, "id": "d1155b8e", "metadata": {}, "outputs": [ @@ -1989,7 +2291,7 @@ "" ] }, - "execution_count": 23, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } diff --git a/notebooks/custom_kinfraglib/2_4_custom_filters_enumeration_analysis.ipynb b/notebooks/custom_kinfraglib/2_4_custom_filters_enumeration_analysis.ipynb new file mode 100644 index 00000000..413c86cf --- /dev/null +++ b/notebooks/custom_kinfraglib/2_4_custom_filters_enumeration_analysis.ipynb @@ -0,0 +1,1191 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Analysis of enumerated molecules" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Aim of this notebook \n", + "\n", + "We create two enumeration subsets, one with fragments from CustomKinFragLib, one with fragments rejected by CustomKinFragLib filters. We compare these enumerated subsets regarding drug-like properties and synthesizability. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Table of contents\n", + "1. Load the fragment libraries\n", + "\n", + " 1.1. Load pre-filtered fragment library\n", + " \n", + " 1.2. Load custom-filtered fragment library\n", + " \n", + "\n", + "2. Select fragments for recombination sets\n", + " \n", + " 2.1. Sample fragments from CustomKinFragLib \n", + " \n", + " 2.2. Sample fragments from KinFragLib \n", + "\n", + "\n", + "3. Recombination of molecules \n", + "\n", + "\n", + "4. Load combinatorial library and deduplicate\n", + "\n", + " 4.1 Load CustomKinFragLib combinatorial library\n", + "\n", + " 4.2 Load combinatorial library based on rejected fragments \n", + " \n", + "\n", + "5. Sample enumerated ligands \n", + "\n", + " 5.1 Get subpocket frequencies \n", + "\n", + " 5.2 Sample enumerated molecules \n", + "\n", + "\n", + "6. Molecular property analysis of enumerated molecules \n", + "\n", + " 6.1. Drug-like properties \n", + "\n", + " * Lipinski's Rule of 5 and Veber's rule \n", + " * QED score \n", + "\n", + " 6.2. Synthesizability \n", + "\n", + " * SYBA score \n", + " * Similarity to Enamine REAL Space \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports and preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path \n", + "from rdkit import Chem \n", + "from rdkit.Chem import Lipinski, Descriptors, QED\n", + "\n", + "import pandas as pd \n", + "import numpy as np\n", + "import sys\n", + "import os\n", + "from kinfraglib import utils, filters\n", + "import matplotlib.pyplot as plt \n", + "from syba.syba import SybaClassifier\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define paths " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "HERE = Path(_dh[-1])\n", + "PATH_TO_DATA = HERE / '..' / '..' / 'data' " + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# paths for sampled fragment libraries \n", + "original_lib_path = PATH_TO_DATA / 'prefiltered_fragment_library'\n", + "lib_path = PATH_TO_DATA / 'custom_fragment_library_sampled'\n", + "ref_lib_path = PATH_TO_DATA / 'reference_fragment_library_sampled'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Load fragment libraries \n", + "\n", + "- Read pre-filtered fragment library\n", + "- Read custom filtered fragment library" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.1 Load pre-filtered fragment library" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(3414, 19)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fragment_library = utils.read_fragment_library(PATH_TO_DATA / \"fragment_library\")\n", + "fragment_library = filters.prefilters.pre_filters(fragment_library)\n", + "pd.concat(fragment_library).shape\n", + "# NBVAL_CHECK_OUTPUT" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 1.2 Load custom-filtered fragment library" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(837, 15)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "custom_fragment_library = utils.read_fragment_library(PATH_TO_DATA / 'fragment_library_custom_filtered')\n", + "pd.concat(custom_fragment_library).shape\n", + "# NBVAL_CHECK_OUTPUT" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Select fragments for recombination space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.1 Sample fragments from CustomKinFragLib" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# select random fragments from each pocket \n", + "num_fragments = 80\n", + "pocket_df = {}\n", + "np.random.seed(1)\n", + "for p in custom_fragment_library.keys(): \n", + " subpocket_length = len(custom_fragment_library[p])\n", + " sampled_ind = np.random.choice(subpocket_length, min(subpocket_length, num_fragments), replace=False)\n", + " df = custom_fragment_library[p][custom_fragment_library[p].index.isin(sampled_ind)]\n", + " pocket_df[p] = df\n", + " for ind in pocket_df[p].index: \n", + " pocket_df[p].loc[ind].ROMol_original.SetProp(\"Index\", str(ind))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('AP', 80), ('FP', 80), ('SE', 80), ('GA', 80), ('B1', 18), ('B2', 26)]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[(key, len(val)) for key, val in pocket_df.items()]\n", + "# NBVAL_CHECK_OUTPUT" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def save_fragment_library_to_sdfs(path_output, fragment_library_concat):\n", + " \"\"\"\n", + " Save fragment library to file (for each subpocket sdf file).\n", + " \n", + " Parameters\n", + " ----------\n", + " path_output : str or pathlib.Path\n", + " Path to output folder for sdf files.\n", + " fragment_library_concat : pandas.DataFrame\n", + " Fragment library data for one or multiple subpockets.\n", + " \"\"\"\n", + " \n", + " #path_output = Path(path_output)\n", + " path_output.mkdir(parents=True, exist_ok=True)\n", + " \n", + " for subpocket, fragments in fragment_library_concat.groupby('subpocket'):\n", + " \n", + " with Chem.SDWriter(str(path_output / f\"{subpocket}.sdf\")) as w:\n", + " for mol in fragments.ROMol_original:\n", + " w.write(mol)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 2.2 Sample fragments from KinFragLib \n", + "\n", + "When sampling these fragments, we first exclude all fragments that are included in CustomKinFragLib. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# extract PDB for all fragments in CustomKinFragLib \n", + "custom_pdbs = {}\n", + "for p in custom_fragment_library.keys(): \n", + " custom_pdbs[p] = list(custom_fragment_library[p].complex_pdb)\n", + "\n", + "num_fragments_reference = 80\n", + "np.random.seed(1)\n", + "reference_library = {}\n", + "for p in fragment_library.keys(): \n", + " # exclude all customkinfraglib fragments from KinFragLib\n", + " new_inds = []\n", + " for i, row in fragment_library[p].iterrows(): \n", + " if row.complex_pdb not in custom_pdbs[p]: \n", + " new_inds.append(i)\n", + " # sample fragments from remaining KinFragLib \n", + " subpocket_length = len(new_inds)\n", + " sampled_ind = np.random.choice(subpocket_length, min(subpocket_length, num_fragments_reference), replace=False)\n", + " df = fragment_library[p][fragment_library[p].index.isin(sampled_ind)]\n", + " reference_library[p] = df\n", + " # reset index \n", + " for ind in reference_library[p].index: \n", + " reference_library[p].loc[ind].ROMol_original.SetProp(\"Index\", str(ind))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[('AP', 80), ('FP', 80), ('SE', 80), ('GA', 80), ('B1', 29), ('B2', 33)]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[(key, len(val)) for key, val in reference_library.items()]\n", + "# NBVAL_CHECK_OUTPUT" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# write reference fragments to file \n", + "save_fragment_library_to_sdfs(ref_lib_path, pd.concat(reference_library))" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# write pre-filtered library to file\n", + "save_fragment_library_to_sdfs(original_lib_path, pd.concat(fragment_library))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Recombination of molecules\n", + "\n", + "We use the functionalities of KFFL ([KinaseFocusedFragmentLibrary](https://github.com/volkamerlab/kinasefocusedfragmentlibrary)) for recombination. The notebook `docs/notebooks/ligand_recombination/ligand_recombination.ipynb` in the KFFL repository contains the code used for recombination. \n", + "\n", + "The recombination set is available on zenodo for download and place them in this repository to execute the rest of the notebook. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. Read combinatorial library and deduplicate\n", + "The deduplication is done based on the fragment IDs for all ligands." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def sort_ligand_name(lig_name):\n", + " \"\"\"Sort fragments in ligand name\n", + "\n", + " Args:\n", + " lig_name (str): string with all fragments present\n", + "\n", + " Returns:\n", + " str: ligand name with fragments sorted alphabetically\n", + " \"\"\"\n", + " lig_name = sorted(lig_name.split(\",\"))\n", + " lig_name = \",\".join(lig_name)\n", + " return lig_name\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def deduplicate(mols): \n", + " \"\"\"Deduplicate molecules based on sorted ligand name (fragment IDs)\n", + "\n", + " Args:\n", + " mols (list): List of molecules to be deduplicated\n", + "\n", + " Returns:\n", + " list: Deduplicated list of molecules \n", + " \"\"\"\n", + " lig_name_dict = {}\n", + " for mol in mols: \n", + " if mol is not None: \n", + " lig_name = sort_ligand_name(mol.GetProp(\"frag_ids\"))\n", + " if lig_name not in lig_name_dict: \n", + " lig_name_dict[lig_name] = mol \n", + "\n", + " mols_dedup = list(lig_name_dict.values())\n", + " return mols_dedup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.1 Load CustomKinFragLib combinatorial library \n", + "**Note**: Reading the SDF might take around five minutes. " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "786212" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mols = [mol for mol in Chem.SDMolSupplier(str(PATH_TO_DATA / \"combinatorial_library\" / \"combinatorial_library_custom_sampled.sdf\"))]\n", + "mols = deduplicate(mols)\n", + "len(mols)\n", + "# NBVAL_CHECK_OUTPUT" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 4.2 Load combinatorial library from rejected fragments \n", + "\n", + "**Note**: Reading the SDF might take around five minutes. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "774070" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mols_ref = [mol for mol in Chem.SDMolSupplier(str(PATH_TO_DATA / \"combinatorial_library\" / \"combinatorial_library_rejected_sampled.sdf\"))]\n", + "mols_ref = deduplicate(mols_ref)\n", + "len(mols_ref)\n", + "# NBVAL_CHECK_OUTPUT" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. Sample enumerated ligands \n", + "\n", + "We aim to subsample the enumerated space to create a chemical space that is more similar to actual kinase ligands, such as ligands recorded in KLIFS. \n", + "\n", + "### 5.1 Get subpocket frequencies \n", + "\n", + "We want to extract how large kinase ligands usually are, in our case how many fragments are usually present in a kinase ligand. Using this information, we can build a more reasonable chemical space with ligands that have a similar size to known kinase ligands (in KLIFS). \n", + "\n", + "This section of the notebook is taken from **KinFragLib Notebook 2.2**. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# read unfiltered KinFragLib library \n", + "fragment_library_original = utils.read_fragment_library(PATH_TO_DATA / 'fragment_library')\n", + "fragment_library_concat = pd.concat(fragment_library_original.values())\n", + "# Remove pool X\n", + "fragment_library_concat_wo_x = fragment_library_concat[\n", + " fragment_library_concat.subpocket != 'X'\n", + "].copy()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "n_subpockets_per_ligand = fragment_library_concat_wo_x.groupby(\n", + " ['kinase', 'complex_pdb', 'ligand_pdb', 'subpocket']\n", + ").first().reset_index().groupby(\n", + " ['kinase', 'complex_pdb', 'ligand_pdb']\n", + ").size()" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "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", + "
ligand_countligand_frequency
11470.045483
29640.298267
316390.507116
44350.134592
5440.013614
630.000928
\n", + "
" + ], + "text/plain": [ + " ligand_count ligand_frequency\n", + "1 147 0.045483\n", + "2 964 0.298267\n", + "3 1639 0.507116\n", + "4 435 0.134592\n", + "5 44 0.013614\n", + "6 3 0.000928" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "n_subpockets_per_ligand_distribution = pd.concat(\n", + " [\n", + " n_subpockets_per_ligand.value_counts().sort_index().rename('ligand_count'),\n", + " n_subpockets_per_ligand.value_counts(normalize=True).sort_index().rename('ligand_frequency')\n", + " ],\n", + " axis=1\n", + ")\n", + "n_subpockets_per_ligand_distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 5.2 Sample enumerated molecules" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We sample a subset of the enumerated molecules to keep the fraction of molecules with 2, 3, or 4 fragments the same as in known kinase ligands (KLIFS)." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "def split_mols(mols): \n", + " \"\"\"Divide the recombined molecules by number of fragments \n", + "\n", + " Args:\n", + " mols (list): List of RDKit molecules, containing the recombined molecules \n", + "\n", + " Returns:\n", + " dict: Containing a list of molecules for each number of fragments. \n", + " \"\"\"\n", + " mols_subset = {}\n", + " for mol in mols: \n", + " lig_name = mol.GetProp(\"frag_ids\").split(\",\")\n", + " if len(lig_name) in mols_subset: \n", + " mols_subset[len(lig_name)].append(mol)\n", + " else: \n", + " mols_subset[len(lig_name)] = [mol]\n", + " return mols_subset" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def total_sampled_mols(split_mols_ref, n_subpockets_per_ligand_distribution): \n", + " \"\"\"Calculate the maximum number of molecules we can sample for our chemical space. \n", + " This is done, because the number of molecules with more fragments is exponentially \n", + " larger and we want to balance this number based on frequencies of fragment numbers \n", + " instead. We base the number of total molecules based on the number of molecules \n", + " with the least number of fragments. \n", + "\n", + " Args:\n", + " split_mols_ref (dict): contains a list with molecules for each number of fragments per molecule\n", + " n_subpockets_per_ligand_distribution (pd.DataFrame): contains frequencies for the number of fragments \n", + "\n", + " Returns:\n", + " dict: number of molecules that we should sample for each number of fragments \n", + " \"\"\"\n", + " min_frag = min(split_mols_ref.keys())\n", + " min_freq = n_subpockets_per_ligand_distribution.loc[min_frag].ligand_frequency \n", + " total_sampled = 1 / min_freq * len(split_mols_ref[min_frag]) \n", + " frag_numbers = {}\n", + " for num in split_mols_ref.keys(): \n", + " frag_numbers[num] = int(total_sampled * n_subpockets_per_ligand_distribution.loc[num].ligand_frequency)\n", + " return frag_numbers" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "split_mols_ref = split_mols(mols_ref)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "split_mols_custom = split_mols(mols)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# rejected molecules \n", + "# set seed\n", + "np.random.seed(1)\n", + "frag_numbers = total_sampled_mols(split_mols_ref, n_subpockets_per_ligand_distribution)\n", + "sampled_mols = []\n", + "for num in frag_numbers.keys(): \n", + " # sample molecules\n", + " sampled_mols += list(np.random.choice(split_mols_ref[num], frag_numbers[num], replace=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# sample CustomKinFragLib ligands \n", + "np.random.seed(1)\n", + "frag_numbers_custom = total_sampled_mols(split_mols_custom, n_subpockets_per_ligand_distribution)\n", + "sampled_mols_custom = []\n", + "for num in frag_numbers_custom.keys(): \n", + " sampled_mols_custom += list(np.random.choice(split_mols_custom[num], frag_numbers_custom[num], replace=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# write our new chemical space to file \n", + "with Chem.SDWriter(str(lib_path / \"sampled_mols_custom.sdf\")) as mol_file:\n", + " for m in sampled_mols_custom:\n", + " mol_file.write(m)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "with Chem.SDWriter(str(ref_lib_path / \"sampled_mols_reference.sdf\")) as mol_file:\n", + " for m in sampled_mols:\n", + " mol_file.write(m)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Molecular property analysis of enumerated molecules \n", + "\n", + "### 6.1 Drug-like properties\n", + "\n", + "Calculate molecular properties from Lipinski's Rule of 5 and Veber's rule. Record thresholds and how many molecules are passing each filter. " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_prop(mols): \n", + " \"\"\"Calculate molecular properties, applies Lipinski's and Veber's rules\n", + "\n", + " Args:\n", + " mols (list): List of RDKit molecules\n", + "\n", + " Returns:\n", + " list: List with summary statistics for each property and the overall Lipinski's rule \n", + " \"\"\"\n", + " # calculate molecular properties \n", + " hba = [Lipinski.NumHAcceptors(mol) for mol in mols]\n", + " hbd = [Lipinski.NumHDonors(mol) for mol in mols]\n", + " nrot = [Lipinski.NumRotatableBonds(mol) for mol in mols]\n", + " mw = [Descriptors.MolWt(mol) for mol in mols]\n", + " logp = [Descriptors.MolLogP(mol) for mol in mols]\n", + " tpsa = [Descriptors.TPSA(mol) for mol in mols]\n", + "\n", + " # calculate rule of 5 \n", + " mw_bool = [weight <= 500 for weight in mw]\n", + " hba_bool = [acc <= 10 for acc in hba]\n", + " hbd_bool = [don <= 5 for don in hbd]\n", + " nrot_bool = [rot_bonds < 10 for rot_bonds in nrot]\n", + " tpsa_bool = [polar_surface < 140 for polar_surface in tpsa]\n", + " logp_bool = [logp_val <= 5 for logp_val in logp]\n", + "\n", + " # lipinski filter \n", + " lipinski_bool = []\n", + " for i, mw_val in enumerate(mw_bool): \n", + " lipinski_bool.append(all([mw_val, hba_bool[i], hbd_bool[i], nrot_bool[i], tpsa_bool[i], logp_bool[i]]))\n", + "\n", + " # fraction of passes for each rule and total \n", + " summary_stats = [sum(mw_bool) / len(mw_bool) * 100, \n", + " sum(hba_bool) / len(hba_bool) * 100, \n", + " sum(hbd_bool) / len(hbd_bool) * 100, \n", + " sum(nrot_bool) / len(nrot_bool) * 100, \n", + " sum(tpsa_bool) / len(tpsa_bool) * 100, \n", + " sum(logp_bool) / len(logp_bool) * 100, \n", + " sum(lipinski_bool) / len(lipinski_bool) * 100]\n", + " \n", + " return summary_stats\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "custom_summary_subset = calculate_prop(sampled_mols_custom)\n", + "reference_summary_subset = calculate_prop(sampled_mols)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "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", + "
Ligands from rejected fragments (#19053)CustomKinFragLib ligands (#21618)
074.48695787.242113
191.06702499.481913
295.89565999.962994
395.62273799.366269
479.10565397.724119
578.78549377.375335
655.69201772.078823
\n", + "
" + ], + "text/plain": [ + " Ligands from rejected fragments (#19053) CustomKinFragLib ligands (#21618)\n", + "0 74.486957 87.242113\n", + "1 91.067024 99.481913\n", + "2 95.895659 99.962994\n", + "3 95.622737 99.366269\n", + "4 79.105653 97.724119\n", + "5 78.785493 77.375335\n", + "6 55.692017 72.078823" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Collect data in one DataFrame\n", + "bar_data_subset = pd.DataFrame(\n", + " {\n", + " f'Ligands from rejected fragments (#{len(sampled_mols)})': reference_summary_subset, \n", + " f'CustomKinFragLib ligands (#{len(sampled_mols_custom)})': custom_summary_subset, \n", + " }\n", + ")\n", + "bar_data_subset.index.name = None\n", + "bar_data_subset" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA24AAAK9CAYAAABcjD9SAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAADh4ElEQVR4nOzdd3hUVf7H8c+kTXpISCFACBBCL6GIFAERWAugoggqsgJi11VZ/CHqrmBH17bq7qIiYgPFDjZUepEaeguBkEACCWmTkJ7M748xAzEJpEwyk+T9ep55nNx77tzveCHMZ8655xjMZrNZAAAAAACH5WTvAgAAAAAAF0ZwAwAAAAAHR3ADAAAAAAdHcAMAAAAAB0dwAwAAAAAHR3ADAAAAAAdHcAMAAAAAB0dwAwAAAAAH52LvApqakpISJSYmysfHRwaDwd7lAAAAALATs9msrKwstWzZUk5OF+5TI7jVs8TERIWFhdm7DAAAAAAOIiEhQa1bt75gG4JbPfPx8ZFkuTi+vr52rgYAAACAvZhMJoWFhVkzwoUQ3OpZ6fBIX19fghsAAACAKt1CxeQkAAAAAODgCG4AAAAA4OAIbgAAAADg4AhuAAAAAODgCG4AAAAA4OAIbgAAAADg4AhuAAAAAODgCG4AAAAA4OAIbgAAAADg4AhuAAAAAODgCG4AAAAA4OAIbgAAAADg4AhuAAAAAODgCG4AAAAA4OAaRHA7deqUPvnkE82YMUOXX365fH19ZTAYZDAYqnT81q1bNWHCBIWGhspoNCosLEzTpk1TTExMnR4LAAAAALZgMJvNZnsXcTGvv/66HnnkkQr3Xaz8RYsW6Y477lBxcbECAwMVHh6umJgYmUwmeXp6atmyZbriiitsfmxlTCaT/Pz8lJmZKV9f32odCwAAAKDxqE42aBA9br6+vrriiis0c+ZMLV68WB9++GGVjtu3b5+mT5+u4uJizZo1S4mJidq2bZuSkpI0adIk5eTkaPz48UpNTbXpsQAAAABgSw2ix+3P1q9fryFDhki6cI/bhAkTtHTpUg0aNEgbNmwosy8/P19dunTRsWPHNHv2bD3//PM2O/ZC6HEDAAAAIDXCHreayMnJ0fLlyyVJ9957b7n9RqNRU6ZMkSQtXrzYZscCAAAAgK012uAWHR2t3NxcSdLQoUMrbDNs2DBJUlxcnJKSkmxyLAAAAADYWqMNbocOHZIkubm5KSwsrMI2ERER1ucHDx60ybEAAAAAYGsu9i6grqSlpUmS/P39K102ICAgwPo8PT3dJsf+WX5+vvLz860/m0ymKlQPAAAAAOc02uBWOtTRzc2t0jbu7u7W5zk5OTY59s9eeOEFzZ079+IFA4AtzR9m7wqq7+419q4AAACH1WiHSnp4eEiSCgoKKm2Tl5dnfe7p6WmTY/9s9uzZyszMtD4SEhIuXjwAAAAAnKfR9rj5+/tLsgxjNJvNFQ55LB0SeX772h77Z0ajUUajsfpvAAAAAAD+0GiDW+fOnSVZes3i4+MVHh5erk1sbGy59rU9FmgSGIYH2AZ/lwAAVdRoh0pGRUVZhzyuXbu2wjZr1lj+8Wnbtq1CQ0NtciwAAAAA2FqjDW5eXl4aPXq0JGn+/Pnl9ufn5+uDDz6QJE2cONFmxwIAAACArTXa4CZJTz31lFxcXLRhwwY99thjKiwslGSZBXL69Ok6duyY/Pz8NHPmTJseCwCNiquH5N9WCu5iefi3tWwDAAD1pkHc45aQkKDevXtbfy4qKrI+DwwMtD4fPHiwvv32W+vP3bt31/z583XXXXdp3rx5WrBggcLDwxUTEyOTySQPDw8tXbq0zGvY4lgAaPB8W0rdb5TCB0neIRW3yU6Wjm+U9n4pmU7Wb30AADQxDaLHrbi4WKmpqdZHZmamdV9l20tNmzZNGzdu1I033ihnZ2ft2bNHPj4+uv3227Vz506NGjWq0vPW5lgAaLC6jZMmLJK63yD5tJDyTVJqrHR6n+WRGmvZ5hMidS9te6O9qwYAoFFrED1ubdu2ldlsrvHx/fv31xdffFHvxwJAg9NmgDT4b1KeSYr+SIpdLeWcqbitZ6AUMVzqfZs08H5Lr1v87/VaLgAATUWD6HEDANSTXjdLRXnSN/dJe76oPLRJln17llraFhdYjgUAAHWC4AYAOKd5pHRiW/XuWTOdtBzTPLLu6gIAoIlrEEMlAQD1xSw5uVb/MCf+OUEjxSLpABwEPW4AgHNSY6XWfaWgzlU/JriL1LqflBpTd3UBANDEEdwAAOfsWmLpPRv7hjTgPimkm+TsVr6ds5tl38D7pTGvSwYny7EAAKBOMLYFgGPwDLT09Hg2lwpzpTOHLVPPo37Fb5I2viUNuFfqMd7ykKT8LKkoX5JZcnGXjD6W7QaDVFIi/f4fZpR0JD6hlkXS047auxIAgI0Q3ADUjy5jpYx4KWnXn3YYLCGh+w2WXpvzpR6Rfp0jmRLrq0pIlgW143+Xet5kWR7AO0Ry9y3fLvu0pd2eL6TME/VfJyo3bJYU2kN6d4S9KwEA2AjBDUD9GDJDOvRT+eA2+G9St+ul4kIpbr0lABh9LIEhMFIa86r0xR1SwVm7lN1kmU5K61+3PHfzsoQ3Vw/Lz4W5ltDGNXFwBnsXAACwIYIbAPvxC5O6XmdZ7HnZQ1J63Ll9Ti7SyDlS+CCp+43Sjg/tVSUKzjLkzlFM+7lq7ZxdKmhvlt6/yuYlAQDqB5OTALCf8EGWe6S2Ligb2iSppEha+7Kldyd8sF3KAxyOi5vk7Gr574UeBifL360y2432rh4AUAv0uAGwH99QyWyWEjZXvD8v0zJJSWDH+q0L1eMZcG4dt+xk+9bS2GXEW3qq9y+TtsyvfLjqmNel0J7Su1fUa3kAgLpDcANgPyUllv/mpFXeJjfd0sNgZ2PfXG/vEqplWQUz+NeZMa9Lfq0lmZkMo659MU3qPVmKulVqO1ja9B8p9jd7VwUAqAcMlQRQfzwDLL0ApQ+ZLdu9gyo/xitIyjfVS3moBYOh/KygsL2SYmn7B9KXd1pmW73iCemaf0m+Le1dGQCgjtHjBqD+tL7E8vizln0qmfLfIDVrI2Um1HlpqIXP/2rvCiQ1vF5RqRY9oxnHpe8elLpcK116lzR+obTzE8ujpNimNQIAHAPBDUD9OHyB2fCcK/n0Gj7Qsn7Y4f11UxPQ0B34zrKMxmUPS/2mSh1GSutfs3dVGPqolLRbOrZWKsq1dzUAGgmCG4D6sfrF6h+TES8te5geN+BCctOkX/5pmX31soel0a9IxQX2rqpp63yN1OlqacjDlmAd84uUsFXW4eEAUAMENwCOK/OE5QH7cXKxDFf1Dv7TAtzJlmBdUmTf+nDO8Q3SyR2WoZNtBtq7GhQXSi7ull7QiBFSXoZ05DcpZoV0Jsbe1QFogAhuAIDyQntJPSdIrfpWPpS1uFA6uV3a/bmUtLNey0MlinKlDW9YHrCv2JXSzk+ljldKHUZIPi2k7jdaHhnxluHjR36VzqbYu1IADQTBDQBQ1oB7pR43WWaKLCqwrKV3NkUqzJMMsvQieAVJ/u0s9yG2GSDt/VLa9La9KwccS2aCtPU9y6NFDynyL1L7YZJ/uNT/Tqn/dMu9cDErpKOrLb3ZAFAJghsAxzX6Fcs052aztORWe1fTNEReaelpyzwpbf6fFL+p8lkKDc5S+CBpwD2WXoQzR6SYC0xCAzRlp/ZYHhtel9oMkjr+RQq7VGoZZenhHvywZbhrzAop/nc7FwvAERHcADguryDL8CIzN/TXm27XS/lZ0rf3S3mZF25rLpbi1lk+jE78yHIswc3x8AWIYyn54+9N3DrJzUuKuEKKHCWFdJcihlt65FjIHkAFCG4AHNeq5yUXo72raFr820oJmy8e2s6Xl2G51y3s0rqqCrXBFyCOq+CsdGCZ5eEdbBlK2YHQBqBiBDcAjivloL0raHpKCiV3v+of5+5nORaOhy9AGobsZCn6Y8sDACpAcAMAnJN8QGrdz7Im2PENVTum7RDLPToJW+q2NtQMX4AAQKNAcAOAOtYmwFMD2geoXaCXgn3d5eHqLLPZrOz8IsWn5WjPiUxtjE1VUYkDDGXb8aHUqp/0l2csCwcfW2uZVTI7RSrKs7RxcZe8g6TAjpb7ccIHW4bhRX9k39rriLOTQT7uLsorLFZeYYm9y0FD8OnNzBAJwOYIbgDqX5uBUtvLpOYRlntvXD0lc4llUoz0OCkx2rLGUU6qvSutFX9PVz04IlJ92vhLssyuL1kyTunzzqG+GtW1habnFer99ce0+pCd13Q6vU/6dY50+Syp3RDLdboQg8Fyn86aeZZjGxiji5O8jC7KyitUYXHZ4Ny7TTNN6BemTi185PTHBTuVmacf9ybp252J9igXDUX2aXtXAKARIrgBqD/+baUR/7T8tzS5nM/FKHkFWobq9Z0i7fiowfbi+Li76OWbeinIx6jU7AIdOmVSVl6Rgn2N6tGqmQwGacmWeJnyitQ7rJn6tQ3QwyM7qoWfu5ZsSbBv8XHrpE+jpS5jLGu0BURIRu+ybQrOSqlHLNOWH1guFWTbp9ZamjK4ra7uHqoHP92hhPRzPSRje4bqjiHty/0xDW3mrqmD26ln62Z6dvl+2bWPtIl8AQIAsCC4Aagf3iHSdW9Zpr9OPigl7ZLyTZJ3C8twOzdPacu7lg+crfpJHa+U+k21fCBd+7K9q6+2W/q3UZCPUd/uTNSHG+PKDIMM8jbqqWu7amyvlrrvkx36ae8phfq564nRXXTzJW20+0Sm9iea7Fi9LEFs1xLLQ5JcPSwPGaTCnEYzDKx7Sz8lZuSWCW3BPkZNvaydSsxmfRedqF8PnNZpU5583F3Vs7Wfbrs0XH3D/XV1j1D9sCep/otuQl+AAADOcbJ3AQCaiH5TLaFt41vSN/daFnfe+am0/lXp04nS6f1S36lS2jHp9/9ISyZJp3ZLna62LPLcwPRvG6DEjFy9v/5YuXvXUrLz9faqI/L1cNWwjkGSpKTMPD27/IBKzGZd16ulPUq+sMJcKSfN0nvTSEKbJAX6GHUyo+z7GdQhUM5OBn206bg+2BinE+m5Kiw2K+1sgVYfStGT3+xVflGxRnYJrv+CS78ACWgnpRySdn1m+cJj/zIpzySVFEm//1f6cZa0e6nlWvWbKg19tP5rRfWMfkW6ZbF086f2rgSAgyK4AagfrftJqbHS3i/L7yvKkza+Kbm6Sx1GWrYVZEu/zJGKC6Su19Vrqbbg7+WmuDM5le4/mnJWkhTm72nddsqUp/2JJnUO9a3z+qrNxV3y8Lc8XNztXY3NOBsMKiwuO+FIqK+7zGZp1aHkCo85ZcrTgaQstT7v2tWbJvYFSJNSut6eTwt7VwLAQTFUEkD9MPpKpy4weUXmCct/fULPbcvLsHzoDOpcp6XVhay8QoUFeFS6PyzA8qE/v6i4zPb0nAJ1cYTg5uYldbrG8mE/oL1k9Cm7vyBbSj0qHd8oHfqhwd7jdtqUp4igsvfv5ZVekwvewGZWiT0WtK7KFyA3vmv5AmTX4nNfgNy6xPIFyPGN9V4yqoj19gBcBD1uAOpHbroU2EFSBffkSOfC2Z8DQF7WH/dWNSx7Tmaqtb+nJl4SVm6ft9FF914eIbNZ2p+UVWafv6ebsvLsvJB1+GDpliXSgHulllGSu69lMpKcVMuj4KwlyLXsJQ24xzK862KzTzqo34+mKsTXXVd1O9fLsTMhQwaDNKxTUIXHBPsY1SXUV3GpZ+urzHOMvlLmycr3N7IvQJqUlD/u/U3aZe9KADgoetwA1I+EzVLnMdLQv1uGeZWuCSZJzdpIQ2da5slP3FH2OK9AS+hrYD7bmqBL2zXXLf3baGjHIO07mans/CIF+xjVr22APNycFXfmrDYfPTfjn4uTQRFB3jp4yo4Tk4R0k0Y9LZmLpX1fSUfXWNZxK8ov287F+Mc6bpdLXcZKI+dKy/7W4JYE+GrHSY3oEqy7h7VXiJ+7vt15UtHxGdp8NE23D2orb6OLfj1wWilZ+fI2uqhn62aaPDBcRhdnLd9lh4lJynwBUkGPXyP7AgQAcA7BDUD92P6h1G6oZfhd2yHSmUNSfrZlsoWgzpKTk2X68hPbzh3j6iEFdZJObLVf3TV0Ij1Xz36/XzP/0kmt/T3U2t+jzPptR5Kz9fz3B8p89A71c9fvR1O16agdp2/vPVlSibTsISn5QOXtivKlU3ssj9iV0tg3LMf+9Fi9lWoLuYXFevKbvZp7bXfd0KeVxvVupfi0HJ02Wb5YuKlfmG7qV7bX1GCQvt5xUuuPnKn/gpvYFyAAgHMIbgDqR84Zadkj0ognLfdMtb6k7P6ja6W1L5Xd5hFguU/nZHT91WlDu09kavqibRoY0Vwdgr3l7uqkzNxC7T1p0s6EjHLtE9Jz9cZvMfVf6PlCukond1w4tP3Z6X2WwB3Sre7qqkOJGXl64NMdGt+3tUZ1DVF4c0+FNy8/8UhJiVn7Ek36cvsJRVdw/epFE/sCpMEa/YqUtFs68otkYrF2ALZBcANQf9KPSV/cIYV0t3yQdHG33H+TtOvcvTnnM52Uti+q9zJtqaC4RGsOp2jN4RR7l1I1Tq6WmTyrq6RIcmq4/6TkF5Xok83x+mRzvNoEeKpNgKe8jS5ycpJyC4p1OitfcWfOKqeg+OIvVpea4BcgDVKrPlLL3lLf2y1fbMSskGJXNdhJfAA4hob7ryzQSIx9c729S6i2ZW61fIHTey0POJ6M45aZC31Cpawq3sPl20pq3VdKP163tdWT+LQcxadVvpSD3TXBL0AapHyT5Ooptehu6Y0e9KBlqOvhFVL8RqnEzl8CAGhwCG4A6p+bt9RmgNS8g2XNIldPyVwiFWRJaXFS0s4GN8lFo7H3a2n4Y9K4/1qG5R1bY5lJsiKezS2Tk/SZLDkbLcei/vAFiGM7vkna9JbUfrgUOUpq0cMy+2r4YEvPW+xqy1DKU3vsXSmABoLgBqD+uLhbpo/vdE3Fw+oMBsvECpKlV2HDG5b7RJqIp6/rplA/D5ll1l0fbrdPETE/W2Yt7DFeGvSA5ZGXIZ1NsUxIYjZbFkr3CpLcm1mOMRikPV9YjkX94QsQx1dwVjq43PLwCpIi/yJFjpT820pdx0pdxkjZpy1DKWN+qbjHFAD+QHADUD+c3aRr35SaR0jF+dKZo5ahRN4tpGZhlnukdn0uyWAZqhcYKY15TVr7imWB5yYg0NuoYF+j7LGucxmb3rYs1NxzouVeHQ9/y+PPigstE5ns+dzy3ybC7gGbL0AaprMp0s5PLI/mkVLHv0gRwy2hu/dkyyPloCXE7fvG3tUCcEAENwD1o/dtlp6co6ul9a9LeZnn9gV3lUbOkSJGSEunSFvekUJ7SSP+IQ15xPJhJu2ofequR6/9clhGFyd7l2GRGG15OLlappn3CZFcPCyhoDBHyjotZSbUbCKTBs6uAZsvQBqH1BhpU4y06T9Sq76WENf2Mim4i2V2UIIbgAoQ3ADUj4jhliFBK58tf1N+8n5p3b+kq+dJHUZIB7+3TLTw02xp3P+kXjdLq563T931KCbZAWecKymU0mItD0iyc8DmC5BGxiyd3GZ5OLtZlnroMNLeRQFwUA7y1S6ARs87REo5VPlMakl/3KDfvMO5bWdiLOuJtexd9/WhdsIulSKvtHcV9SImOVt7E03am2iq/5Of/wXI+aFNOvcFiE+I5QsQ6dwXIAYnyxcgcFzFBdKRXxvcIvYA6g/BDUD9KMy1hLfKeAdb/mv+U7DLOiW5+9VdXbCNvrdLl8+ydxWNH1+AAECTxVBJAPXj9F6pzUBLr8yfZx80OEsD77NMqJByqOw+d79GuWhtpxAf9Q5vpgBPN+UVFutIcrY2HU1VYbG9ZyaBQ6vNFyCBHeuuLpT1znB7VwCgESK4Aagf0Z9IYQMsvTIdRlimKs/PssyoFjHC8oEzO9mytlEpg5Ol5yA9zk5F19zkgeGKTc7Wxtiya6AZXZw0Y1RHXdq+uSTLXB+SJbOm5xToxR8O6tDprPouF5VwuIDNFyAA0GQR3ADUj+T90uoXpKGPSmGXWGa8K2UwWO7b+Wm2ZTKMUv7tpPTjlvWNGpjxfVvrtwPJ5YLbwyM7akBEc2XlFenX/aeVmJkrb6OLBkY0V8cQH/1zbFc98OkOpecUVvLKdWxaDddic3a1bR31pMEF7Cb2BUijwHp7AGyE4Aag/hz5VUrcKXW6SgrqZFmPKi9DStwlHfnFssDz+dJipeUP26HQuhER5KVBHZorNTtfMz7fpYzzwtlXO07qvssjdGX3Fro2qpUWbYyzT5EubjU/1u4L0FVfgwvYTewLkAaN9fYA2BjBDWhCRnYJUaC3m5ZsTbBfETlnpOiP7Xd+O+ob7i+zWVq4Ia5MaCu1YP0xDeoQqL7h/vYLbmfPSJ7NpY/GlZ+18EKu/49l/alGwOEDdhP/AqRBYL09AHWA4AY0IVd2C1FkiI99g1sT1tzbKEnaV8k08vlFJYpNzlbnUJ/6LKus5AOWhYCDOksJm+1Xhx01iIDdhL8AaRBYbw9AHWA5AACoJ4VFJZKk7LyiStucLSiSc+kNVfaQfMAyhCu4cfSe1URVA3aIr7E+y0JDwnp7AOoAPW5AA+TnUbOJIJyd7BgImqBQP3cN7xxs/dnb3fIrN9jXqBPpuRUeE+RtlCnPThOTSNLJbVJct/LD7S5m+yLJo1mdlFTfGkTAhmPzDpHiN7HeHgCbIrgBDdCHd/Sv0TwQ598Lj7rXJdRXXUJ9rT+X/v/vG+5fYXBzcTKodYCnYpPtOG37mRhpxZPVP64BD6tskAEbjo319gDUAYIb0ICdyaper4i/lxu9bvVk8Zb4SvdVdN+UJA2JDJSnmzPruNWzBhmw4dhYbw9AHSC4AQ3QaVOegn3c9X9f7lba2YIqH/fy+J6KDLHjxBdNyJIt1Z8AZtvxdE1ftE1Z9OTUGwI26gTr7QGoAwQ3oAE6fDpbwT7uigz21uZjafYuBzaSlVekrAvcVwXbI2CjTrDeHoA6QHCDY5k/zN4VVN/da+r9lIdPZWlIZKA6tvCpXnBjlKRdeBmd1S88QO0CvRTia5SHm7NKzJbJL+LTcrTnZKYOnaL3pqEgYKNKWG8PgI0R3IAGaNvxNAX7GJWYUfHECZX576pYebo511FV+DOji5OmDm6rUV1bVHhv4fmTxcSn5Wj+mthKp6BH3SNgw+ZYbw+ADRHcgAYoMSNP760/Vu3jjp45WwfVoCJuzk6ad2NPtQ30UkFRieJSzyorr0jBPka18vdQcYlZ3+w4KYNBigrzV/sgLz03rofeWnlEvx44be/ymxQCNgCgISC4AUAduKlfa7UL8tKGI2f0v9WxMp03tK5TiI9mXd1JQyODdP+nO7Ro43F1b+mrmVd20n3DI3QkOUtxqTl2rL7pIGADABoKJ3sXAACN0WWRgUrJytcrKw6XCW2SdOh0lt5aeURBvkYN6xgkSdqbaNIzy/fLyWDQuD6t7VFyk1QasDfGntH0RVv19893ac53+3TfJzv0f0t3KyOnQEMjg7RkS4Ie+WynnvhqjzJyCnTf8Ai1be5p7/IBAE0IwQ0A6kCQj1FHkrNVXFLxiuf7kyxD7doFeVm3xaac1aFTWerRyq9eagQBGwDQcDBUEmginr6um0L9PGSWWXd9uN3e5TR6eYUlCvIxVro/yNuy78/BLjkrTx2Cveu0NpwT5GPUtrh0AjYAwOHR4wY0EYHeRgX7GhXs427vUpqEA0kmRQR5a3jn4HL7nAzStMvayWyWjiRnl9nn6+6qs/lMNV9fahOw/Txc67Q2AADOR48b0ES89sthGV34rqa+fLHthPqF++uhEZEa1jFQe0+alJ1XZBl2FxmkQB+jzmTla33MGesxTgZLz048E5PUmwNJJl3SNkDDOwdr1cHkMvsI2AAAR0JwA5qImD998ETdOnQ6S6//GqMHr+ig3m38FRXmb91nMEgpWfl6evl+FZ3Xk9OmuZcS0nK0+lCKPUpukgjYAICGguAGAHVkzeEU7TmZqZFdghUR7C13F2dl5hZqb2Km1hxKUX5RSZn2cWfO6omv99qp2qaJgA0AaCgIbgBQh9LOFujzbSfsXQYugIANAGgICG5oXLyCJK9AKSdNyr7I4rh+rSXPAClpd/3U5gAm9AtTiK9Rb648Yu9SAIdCwAYAODqCGxoH31bS5Y9JId3ObUs7Km3+n3RiW8XH9L5NivyL9O4V9VOjA7ikrb8iQ3wIbgAAAA0MU8yh4XP3k679t9Siu+WmlLxMyVwiNY+Qrn5JGnCvvSsEAAAAaoUeNzR8UbdYhjwmbJFWz5Ny0yQ3L6nbOKn3ZKnHTZYhlCufk8zF9q7WJiJDarZAs7urs40rAQAAQH0guKHhazNQys2Qfp0jFeZathWclaI/luI3S395Rmp/uSXMrfiHVFxgx2Jt41839ZLZfPF2f2YwqEbHAQAAwL4Ibmj4vFtIJ7aeC23nS42RvrlXuuZlqfUl0uh/ST/OqrhtA1IavvYlZlbruIggb3rdAAAAGiCCGxq+4nyp5AJDIHPTpe/+Jl39otSihzT2den7R+utvLpwMiNXrZp56N+/xei0Kb/Kx708vqciQ3zqsDIAAADUBSYnQcOXlWSZiORCCnOk72dK8b9LgR0tk5l4Nq+f+upAzOksSVJkMCEMAACgKSC4oeE7vV/ybSkFtL9wu+IC6ecnpCO/Sv7hUqu+9VNfHTh0KksGg9SxupOUGOqmHgAAANQthkqi4YvbIHW73jK75MrnLtzWXGJpk5cldR/XYGfq2HIsTS7OTjqVmVet4577/oBcnfm+BgAAoKEhuKHhS4yWvv979ULYxn9LJ7dJxoY51DD1bIGW7Uqs9nEZOYV1UA0AAADqGsENDZ+5WDq5o/rHHd9o+1oAAACAOkBwAxo4L6Oz+oUHqF2gl0J8jfJwc1aJWcrOK1J8Wo72nMzUoVNZ9i4TAAAAtUBwAxooo4uTpg5uq1FdW8jZqfysI+cvth2flqP5a2K1L9FUz1UCAADAFghuaJpGv2KZidJslpbcau9qqs3N2UnzbuyptoFeKigqUVzqWWXlFSnYx6hW/h4qLjHrmx0nZTBIUWH+ah/kpefG9dBbK4/o1wOn7V0+AAAAqonghqbJK0jyadFgZ5W8qV9rtQvy0oYjZ/S/1bEy5RVZ93UK8dGsqztpaGSQ7v90hxZtPK7uLX0188pOum94hI4kZykuNceO1QMAAKC6mBccTdOq56VlD0vLH7F3JTVyWWSgUrLy9cqKw2VCmyQdOp2lt1YeUZCvUcM6BkmS9iaa9Mzy/XIyGDSuT2t7lAwAAIBaaBLBLT8/X2+88YYuu+wyBQQEyMXFRf7+/ho8eLBee+015eVVvhbW1q1bNWHCBIWGhspoNCosLEzTpk1TTExMPb4D2FzKQSlpl+XRAAX5GHUkOVvFJRX3GO5PstzL1i7Iy7otNuWsDp3KUo9WfvVSIwAAAGyn0Qe3tLQ0DRgwQA8//LA2bNggV1dXRUVFycvLSxs3btSMGTPUv39/nTlzptyxixYt0sCBA7V06VIVFRWpR48eMplMWrhwoaKiorRy5Uo7vCNAyissUZCPsdL9Qd6WfX8OdslZefLzcK3T2gAAAGB7jT64zZ49Wzt37pSbm5uWLl2q06dPa9u2bTpx4oR+++03NWvWTHv27NH//d//lTlu3759mj59uoqLizVr1iwlJiZq27ZtSkpK0qRJk5STk6Px48crNTXVTu8MTdmBJJMigrw1vHNwuX1OBmnaZe1kNktHkrPL7PN1d9XZ/KJyxwAAAMCxNfrg9vXXX0uS7r33Xo0fP77MviuuuEJz5syRJH333Xdl9s2dO1dFRUUaNGiQXnzxRbm6WnopPD09tWDBArVr107p6el65ZVX6v5N4MJGvyL1ud0yS2QT8cW2EzKbzXpoRKTmXNtV4/u21lXdWmjywHC9M7mferfx15msfK2POdeT7GSwDJ2MT2NiEgAAgIam0Qe3nBzLh9QOHTpUuL9jx46SpMLCwjLHLF++XJIl8P2Z0WjUlClTJEmLFy+2ZbmoiVZ9pL63SxM/lq59U+oyVnLztndVderQ6Sy9/muMiopL1LuNv24bEK57Lo/QjX1aK8jXqDPZ+Xp6+X4VnTdUsk1zLyWk5Wj1oRQ7Vg4AAICaaPTLAfTp00fr1q3T+vXr9cADD5Tbv3btWknSwIEDrduio6OVm5srSRo6dGiFrzts2DBJUlxcnJKSkhQaGmrr0lEd+SbJ1VNq0V0K6SYNelBK2CwdXiHFb5RKiu1doc2tOZyiPSczNbJLsCKCveXu4qzM3ELtTczUmkMpyi8qKdM+7sxZPfH1XjtVCwAAgNpo9MHtueee06hRo/TZZ5+pVatWuvfee9W6dWudPn1aH3/8sV5++WUFBATo5Zdfth5z6NAhSZKbm5vCwsIqfN2IiAjr84MHDxLc7O34JmnTW1L74VLkKKlFD6ntZVL4YKkgW4pdLR35RTq1x96V2lTa2QJ9vu2EvcsAAABAHWv0wW3IkCFav3695syZo9dff12vvvpqmf3Tpk3Tk08+qXbt2lm3paWlSZL8/f1lMBgqfN2AgADr8/T09ErPn5+fr/z8fOvPJpOpRu8DVVBwVjq43PLwCpIi/yJFjpT820pdx0pdxkjZp6WYFVLML1ImgQcAAAANQ6O/x02yDGc8deqUSkpKFBgYqD59+qhFixaSpK+++krvv/++iovPDaUrHSbp5uZW6Wu6u7tbn5feR1eRF154QX5+ftZHZT14sLGzKdLOT6SlU6Uv75L2fCHlpkk+LaTek6UJH0rX/0fqdr29KwUAAAAuqtEHt9dee0033XSTjh49qq+//lopKSnavn27kpKStHbtWvn5+enZZ5/V1KlTrcd4eHhIkgoKCip93fMX7fb09Ky03ezZs5WZmWl9JCQk2OBdoVpSY6RNb0sf3yR9/6h05FepKE8K7iIN+pu9qwMAAAAuqlEHt5SUFD355JOSLAHu+uuvL7N/yJAhWrRokSTpo48+0rZt2yRZhkhKliGQZnPZBYxLlQ6nPL99RYxGo3x9fcs8YC9m6eQ2adXz0ofXSyufkxK22LsoAAAA4KIadXDbtm2bdRjj1VdfXWGbIUOGyMvLS5K0efNmSVLnzp0lWXrc4uPjKzwuNjbW+ry0PRqQ4gJLz9tPj9m7EgAAAOCiGvXkJFWdCKS0V6303raoqCh5eHgoNzdXa9eu1eTJk8sds2bNGklS27ZtmVESAIAqGPvmenuXUG3LKr/dHQDqVaPucevUqZP1+Q8//FBhm9WrV1t75bp06SJJ8vLy0ujRoyVJ8+fPL3dMfn6+PvjgA0nSxIkTbVkyauKd4dKaefauAgAAAKgzjbrHLSoqSn369NGOHTs0Y8YM+fv767rrrrPuX716taZMmSJJCg8P18iRI637nnrqKX3zzTfasGGDHnvsMT3zzDNydXVVTk6O7r77bh07dkx+fn6aOXNmfb8tAACAOtMge0YfvMzeJQB1rlEHN0n69NNPNWLECJ08eVLXX3+9AgMD1aZNGyUmJurUqVOSpObNm2vp0qUyGo3W47p376758+frrrvu0rx587RgwQKFh4crJiZGJpNJHh4eWrp0qQIDA+311vBnPi2kwE5SvklK2i2Z/1jiweAkdbpaahklGX2lrFPS0dVSYrQ9qwUAAACqrNEHt06dOmnfvn16++23tWzZMh08eFC7du2Sp6en+vTpo6uvvloPPvigQkJCyh07bdo0de/eXS+99JLWr1+vPXv2KCgoSOPGjdPjjz+ujh072uEdoUL975R63SzpjwXTs5Kk7/8u5aRJo1+RQrpJ5y+m3mWsdGCZtP41u5QLAAAAVEejD26S5Ofnp8cff1yPP/54tY/t37+/vvjiizqoCjbTbqgUdatUVCCd2GrZ1voS6YonpZPbpRbdpeMbpdhVUmGOFNRZ6nGTJbwl7bRsBwAAABxYkwhuaOS6XieVlEjLH5aSD1i2hXSTrv235N9W2r9MWv/qufbHN0rxv0vXvSl1HkNwAwAAgMNr1LNKookIjJRO7zkX2iTp9D7p1B7J1VPavaT8Mcn7pdP7peYd6q9OAAAAoIYIbmj4XD2ls6nlt+ekWf579kzFx+Wckdw8664uAAAAwEYYKomGL88k+bYsv710m39b6czh8vubtZUKztZlZQAAoD7MH2bvCqrn7jX2rgANED1uaPhO75WCOkntzvul3f5yy7asU9KAeyRnt7LHdLlWCmgrpVQQ6AAAAAAHQ48bGr5dS6S2g6WRT0kZ8ZZtzdpI+dnSiielcf+TJn4oJWyVCs9KgZ2l0J6S2Szt/9a+tQMAAABVQI8bGr7k/dJvz1gW3vYPtzyykqSfH5fSjkqr50mezaUuY6QeE6SWvSxruu3+TDq+wd7VAwAAABdFjxsah6OrpWNrLT1txYWSKVGS2bIv9jcp5aAUcYXkHWSZtCRug5QaY8+KAQB1bGSXEAV6u2nJ1gR7lwIAtUZwQ+NhLpHS4yreZzopRX9Ur+UAAOzrym4higzxIbjVo+4tfRUZ4qOsvCL9fjRV2flFkiQvN2eN69NKPVr5ydvdVcmmPK0/ckYrDySXfs0K4CIIbgAAAKi1mX/pqMsig6w/Tx3cVv/8dq9SsvL14o091bKZhwwGy77W/h7q3cZfA9s317PfH6jkFQGcj+AGAAAcmp+Ha42Oc3Yy2LgSVOYv3UI0pGOQTLmFWnMoRZI0rFOQHh7ZUTsTMtSymYe+352k9UdSlFNQrI4hPpp0aRv1axugq7q10E/7Ttn5HQCOj+AGAAAc2od39Je5BuPpDAbV6DhU34jOISosLtGjS3frlClPkvT9niS9dWsftWzmoc+3JejTzfHW9sdTc7Q/0aQ3bonS8M7BBDegCghuAACgQTiTlV+t9v5ebvS61ZPw5p7an2iyhjZJSsrM077ETPVs3Uy/7Dtd7piTGbk6mJSliCDv+iwVaLAIbgAAwKGdNuUp2Mdd//flbqWdLajycS+P76nIEJ86rAyl3FyclJVXVG576TZTXmGFx2XlFcnoyupUQFXwNwUAADi0w6ezJUmRwfTMOKqMnAKFBXiW297mj20dKrl27YO8ZMqtONQBKIvgBgAAHNrhU1kyGKSOLarZe8YoyXqz56RJbQI8dV1US+u2cb1bqU1zTx07c1Z3DW2vZp5lJ5mZPCBcLfzcdehUVn2XWz0+oVJAe3tXATBUEgAAOLZtx9MU7GNUYkZutY7776pYebo511FVON/SbQkaFNFcUwe3062XtpEkGV2clZqdr+d/OKB/39xb/7utrw6dylJOQbHaB3kpxNddZrP03a5EO1d/EcNmSaE9pHdH2LsSNHEENwAA4NASM/L03vpj1T7u6JmzdVANKnIiPVdPfbtPdw1tr3ZBXjKbpX2Jmfrv6lilZOXrhR8PaNZVnRXVppn1mMLiEr2/Pk77Ek32K7zK6L6F/RHcGrmxb663dwnVsszN3hUAAICa2J9k0sOf7ZTRxUnFJWYVlZxbi2H3iUzd9eE2XdIuQIHeRqWfLdD2+HRl5Njx/rZpP1etnbNLBe3N0vtX2bwk4EIIbgAAALCZ/KKSCrefLSjW6j8W53YILm6Whf4MVexNc+HbZdgXwQ0AAABNT0a85Bcm7V8mbZkvFVQytHbM61JoT+ndK+q1PODPCG4AAKDRefq6bgr185BZZt314XZ7lwNH9MU0qfdkKepWqe1gadN/pNjf7F0VUCmCGwAAaHQCvY0K9jXKbL54W9iH3cN1SbG0/QMpdpU0dKZ0xRNSp6ul9a9KJgef6RJNEsENAAA0Oq/9clhGF5ardWQOE64zjkvfPSh1uVa69C5p/EJp5yeWR0mxnYsDziG4AQCARicmOdveJeAiHC5cH/hOilsvXfaw1G+q1GGktP41e1cFWBHcAAAAUO8cMlznpkm//FMKH2wJcKNfkYoL7F0VIIngBgAAAJR1fIN0codl6GSbgfauBpBEcAMAAA3IJW39dWn75moX6KVgH6M83JxlNkvZ+UWKT83RnpOZWnkwWWln6SVBLRXlShvesDwAB0BwAwAADq9NgKdmXtlJbQI8K1wvOcDFTQFebopq00w39w/T51tP6PNtCfVfaBPmZJAu7xSsyBBvZecVafWhFJ3MyJUkhfgaNenScPVo7Scfo4tOZ+Vrw5Ez+nL7iUoX7AZQFsENAAA4tCAfo+bd2FOeRmfFnM7W3pOZys4vUpCPUYM7BMrTzVkfbjqu+NSzimrjrys6B+vWS9soxNeoN1cesXf5TYKLk0HPXN9dXUJ9rcH6xr6t9ezy/TqRnqt5N/aUv5ebtX1rfw9N6BemvuH+mvXFbhWV2HtqScDxEdxQbQFebooKa6YALzflFhbrSHK2Dp3KsndZAIBG6tb+beRpdNZ7645p2a6y62u9v/6Y5lzbTbf0D9P9n+zQjvgMfbY1Xk9c01UjuoRo87E0bTmWZqfKm46xvVqqa0tfJWbk6oc9pyRJ1/RooXsv76A9JzPlZXTR++uPaV3MGeUWFCsyxFvTh7RXRJC3ro1qqa92nLTzO6ii0a9Ivi0ls1lacqu9q2lY5g+zdwXVd/cae1dQhgPNwQpHcWW3EHVv6Vtuu0HStMva6b3b++lvIyJ124Bw3Tmkvebd2FOvTYxSC1/3+i8WANDo9W7TTMfOnC0X2iQpv6hE76w9KndXZw3tGCRJOptfrHk/HVRhcYmu7t6ivsttkoZ2DFJuQbFmfbFby3YlatmuRD325R75erjois7BWrQxTt/uTFTa2QLlFhZr94lMzflun/IKizUkMsje5VedV5Dk08LyAOoZPW4o577hHfTbgWTtTTSV2X7XsPa6pkeoiorN2nT0jBIz8uRtdFG/tv5qH+SlZ8d1198WRyungMUqAQC24+PuqgNJlY/sSLTeR3XuC8TM3ELtSzQpMsSnzuuD1LKZu/YlmmTKK7JuK70Gfdr4a8ORM+WOSTtboIOnstQltAFdo1XPSy5Ge1eBJorghipp1cxDV3cPVXZekWZ/tUfxaTnWfS7rDPq/qzqrf7sAje3VUp9t5WZwAIDtZOQUqH2QlwySKroTqjSc5RQUldmenVcod1cGF9UHFycn5ReW/+K2dFteYcUTkBQUlcjFqQFdo5SD9q4ATVgD+psCe+rfLkAGg/TR78fLhDZJKiox662VMcorLNal7QLsVCEAoLHafjxdIb7uum94Bxldyn50ae3voQeGd5DZLO1OyCyzr7m3UZk5hfVZapOVejZf7YO8y20v3datVflbMFycDOoQ7K2MHJZuAKqCHjdUSYivUWaz5R/PipjyinQkOVsdgsv/0gYAoDaWbE3QwIjmGtU1RIMimismOVvZ+UUK9jEqMthbTk4G7TmRqeiEDOsxHq7O6hDsrR3xFf+7BduKjs/Qld1aaPqQdvr8j5E3Ey4JU4ivu3YlZOjuoRE6k7VfcamWL3+NLk669/IIBXi5ae3hFHuWDjQYBDdUSeksvekXWNA0M7dQrs504gIAbCvtbIGe+HqvZl7ZSeHNPdW7TbMy+zceSdWbK2PKbGvm6aovd5zQ7hNle+FQNz7bmqDBHQI1pmdLjenZUpJkMEjHU3P08s+H9O9beuu1iVE6ZcpTbkGxWvl7yOjirBKzWV9F22lGydGvSEm7pSO/SKbyE98Ajobghgr5e7qq23kzS5r/CG6B3kadMuVVeExzbzdl5TEkBQBge/FpOfrb4mh1CfVRhyBvGV2dZcot1N7ETCVmlP93KSkzT0u2cM91fUk7W6BHl+7SlMFt1a2lnwqLS7QzPkOLNsUpO79ITy/bp1lXd1bLZh7WYzJzCvX2qiOKO3PWPkW36iO17C31vV06vU+KWSHFrpIKsu1TD3ARVQpu06ZNs+lJDQaDFixYYNPXhG31buOv3m38y23vGeanU/vK/wNpkNTa31Mn03ProToAQFN1ICnrgjNMwn6SMvP0wg8VT94Rl5qj+z/Zoc4tfNXc203pOYU6mGSy/8Lb+SbJ1VNq0V0K6SYNelBK2CwdXiHFb5RKmCkbjqNKwe2DDz6QwWCQ2Wybv1wEN8e28kBypfvcKhkKeUm7APm4u+jQaf4xBQDY1oR+YdqfmFlumRo0LCVmaX+Sg13D45ukTW9J7YdLkaOkFj2ktpdJ4YMtPW+xqy1DKU/tsXelQNWHSoaFhWnq1Km1PuH777+vEydO1Pp1UHfe+C3m4o3+5ER6jp74ao9OZtDjBgCwrUkD2shsls5k52v1oWStPpSiE4zwcCgNOlwXnJUOLrc8vIKkyL9IkSMl/7ZS17FSlzFS9mnLUMqYX6RMPsfCPqoc3Nq0aaOnnnqq1if89ddfCW6NUGJGXoX3GAAAYAsGgxTkY9T4vmEa3zdMR1OytepgstbGnFFmLvdX21ujCddnU6Sdn1gezSOljn+RIoZLPi2k3pMtj5SDlhC37xt7V4smpt4nJ7HVcEsAANB0rDqYrLWHUzS8c7D6twtQRLC32gd5a+pl7bQzPkMrDyVr89FUFRbzOcNeGl24To2RNsVIm/4jteprCXFtL5OCu0hBnQluqHdVCm6rVq2Sn5+fTU741ltvKTOTqXkBAEDVlZilHfEZ2hGfIaOLkwZFNNflnYLVs7Wf+rb1V59wf+UVFmtjbKpWH0pmGQA7aLzh2iyd3GZ5OLtJ7YZKHUbauyhcSKdrLMNedyyydyU2VaXgNmzYMJudMCoqymavBcfx9HXdFOrnIbPMuuvD7fYuBwDQiOUXlWjVoRStOpSiZh6uGtYpSMM7BatdkJdGdAnWFZ2DlXa2wDpkLz4tx94lNwlNIlwXF0hHfrU84Li6jLH0ijbF4AZcTKC3UcG+RjESFgBQnzJyC/XtzkR9uzNRrf09NLxzsIZFBinI16gb+7bWDX1a6/q3N9i7zCaHcA3Yns2Dm9ls1qFDh5Senq6goCB16NDB1qeAA3rtl8MyulS8VAAAAPXhRHquPtp0XB9tOq6uLX01vFOwBkU0t3dZTZ7Dhut3htf/OVE97s1qdpyTs03LcBQ2DW5vvvmmnn32WZ05c8a6rU2bNpo3b54mTJhgy1PBwcQkZ9u7BAAArPYnmrQ/0aT5a2LtXQrOQ7hGtfz1a9VoOJfBULPjHJzNgttrr72mv//97/L29taVV14pX19fHT58WDt37tQtt9wiNzc3XX/99bY6HQAAwEUVlTS+D2+Nhd3Dde/J0qndUtIu+5wfVZedXL32ngGSU+O7I8wm78hsNuv5559X3759tWLFCvn7+1v3ffnll5o4caKeffZZglsj07mFj3w9XLXlWJq9SwEANGJPfLVH6TkNcDp5VIndwvUl0yy9MmeTLQtrx/wqZRy3Ty2omCnJsobetw9IOWcu3r7U9f+xTE7SyFT5pqTly5dXui85OVmpqam6//77y4Q2SbrxxhvVuXNn7du3r+ZVwiFNHhiux6/pYu8yAACN3N5Ek05mNMDFnJuQJ77aoy+3n7B3GdVnMEjeIVLUJOmmhdK4+VL3G2t+bxVsK+Wg5b9Bnexbh4OocnC79tprNXHiRJ0+fbrcPm9vbzk5OenIkSPl9uXk5CgpKUm+vr61qxT1xs/DtUoPFyfLHx9fd5cy2wEAQNPSYMP14RXSj7Ok2JVSUb4U1FEaeL902xfSVS9IEcMta7fBPpL3W8J1SFd7V+IQqjxUcubMmXr99df1yy+/6KWXXtL06dOt+7y8vDR8+HC99NJLcnFx0ZgxY+Tr66uYmBi9+OKLysjI0NSpU+vkDcD2Pryjf7Xu5/zwjkvL/My0ywAAoEEwl0gJWywPF6PUbpgUOUpq2UdqM0AKu1QqzJWOrZViVkiJ0fauuGmJ/93SI5pZzd7cda9Jbp51U5MdVTm4vfTSS5o0aZLuvPNO3X333fr444/1zjvvqGPHjpKk+fPna/jw4Xr66af1zDPPWI8zm83q3r275s2bZ/vqUafOZOVfcH8zL0uv28XaAQAAOLyifEs4i1khefhLHUZZQlxgB6nTVVLHK6Wc1D/a/CqlH7N3xY1f5glp09vVPy41xva1OIBqTU7Sq1cvbd68WW+88Yb++c9/qlevXnr88cc1e/ZstW/fXnv37tWCBQu0YcMGZWZmKjAwUFdccYUmT54so9FYV+8BNrb7RKZ6tvbTiYwc/Xd1rE6bKg5mz43rrm4t/TT9w231XCEAAEAdyk2X9nxueTRrYwltESMknxAp6lap183SuyPsXSWamGqvmGwwGPTwww9r3759GjlypJ566ilFRUVp48aN8vHx0cMPP6ylS5dqxYoV+vTTTzV9+nRCWwPzj2/26t+/xqhDsI/eurWPxvdtLSeDvasCAACwg4x4acu70uKbpe8ekg5+LxWctXdVaIKqHdxKhYWFadmyZVqyZIlSU1M1dOhQ3XfffTKZTLasD3by28Fk3ffxdv1+NFWTB4br37f0VteWTDADAACasFO7pbX/kj66wd6VoAmqcXArNWHCBB08eFDTpk3T/Pnz1aVLF3399de2qA12Zsor0isrDmvOd/vk7uKs58f10INXdJCX0dnepQEAANhPSZG9K0BlRr8i3bJYuvlTe1dic9UObunp6frxxx+1ZMkSrVmzRvn5+fLz89M777yj1atXy9fXV+PHj9e4ceN08uTJuqgZ9Sw6PkP3fbJD3+1K1BWdg/Xf2/pqROdgGcT4SQAA0EAte1ja2fg+3Dd5XkGWRbt9Wti7Epur1uQkTz/9tF588UXl55+brCIwMFD//e9/dcMNN2jIkCHavXu3nn32Wc2bN09du3bVCy+8oPvuu8/mhaN+FRSX6P31x7TmULIeuCJSD46ItHdJAAAANZe0y94VoC6set6ytEMjVOUet//85z+aM2eODAaDJk2apEcffVTXXHONzpw5o5tvvlnbt2+XJLm6umru3LmKjo5Wz5499cADD2jQoEHav39/nb0J1J/YlLOa8dlOfbAxTvsSM7UvMdPeJQEAAAAWKQctobwRBvMq97i99dZbcnNz0+bNm9W9e3fr9vfff1/Tp0/X/Pnz9c4771i3d+nSRevWrdP8+fP12GOPqU+fPsrLy7Nt9bALs6Rvok/qm2iGwgIAAAD1oco9brGxsercuXOZ0CZZJieRpKNHj1Z43N13360DBw7o2muvrUWZqE8T+oWpOzNIAgAAAA6jyj1ugYGBOn78uEwmk3x9z32o37XL0g0ZEBBQ6bEtWrTQ559/XosyUZ8mDWgjs1k6k52v1YeStfpQik6k59q7LAAAADRFBicppLvk1VzKSZNO75VKiitvH9JN8m0txfxcfzXWgyoHtxtvvFFvvfWWhg8frr/97W8KDQ3VgQMH9NJLL8lgMOiGG1jPojExGKQgH6PG9w3T+L5hOpqSrVUHk7U25owycwvtXR4AAACagpBu0hX/kLyDz23Ly5C2vi8dXF7xMV3GSpF/abrB7YUXXtCuXbu0bt06TZs2TZJkNpslSffcc49uvvnmuqkQdrHqYLLWHk7R8M7B6t8uQBHB3mof5K2pl7XTzvgMrTyUrM1HU1VYbLZ3qQAAAGiMvFtIV78kuXlKBWeljATJJ0Ty8JeGzJDCLpF+e1YqaRqdClUObl5eXlq9erW+//57rVmzRpmZmWrRooVGjx6tSy+9tC5rhB2UmKUd8RnaEZ8ho4uTBkU01+WdgtWztZ/6tvVXn3B/5RUWa2NsqlYfStbuE8wuCQAAABuKutUS2g79KK177Y+AZpA6jJAGPSC1HSKNfln66XGpMMfe1da5aq3jZjAYNGbMGI0ZM6au6oEDyi8q0apDKVp1KEXNPFw1rFOQhncKVrsgL43oEqwrOgcr7WyB9X64+LTG/xcHAAAAdax1Xyk7RVr3ynn3tJmlI79apvu/8lkptJc09nXph0elvMbdkVDlWSUBScrILdS3OxP18Gc7df8nO/TF9hM6k5Wv5t5uurFva/37lt72LhEAAACNgVeQlHKg4olIzqZI3/1NOrFVCoyUrv235BlY/zXWI4IbauxEeq4+2nRc0z/cptlf7dGKfad1Nr/I3mUBAACgMSg4a5lRsjJF+dKPs6Wjq6VmbaTr3pR8W9ZbefWtSsGtffv2Npt8ZMKECYqIiLDJa8Fx7E806e1VR3T7+1vsXQoAAAAag6wkKbDThduYi6Vf50oHlkk+LSw9b36t66e+elal4BYXF6fExESbnDApKUlxcXE2eS04nqISZpkEAACADSTtlrwCLWu4Xcy6V6Wdn0qezaXgrnVfmx1UeXKS/Px8xcfH1/qE+fn5tX4N1K0nvtqj9JymMa0qAAAAHNTxDVKviVKfydKPsy7efsu7Um6mNOCeuq/NDqoc3LZt26Z27drVZS1wEHsTTfYuAQAAAE3dqT3SkkmSuRojuvZ8Lp3cLhm9664uO6lycDNX53/YRRgMBpu9FgAAAIBGylSD27XSYm1fhwOoUnArKSmp6zoAAAAA4Jzek6VTuy1rtqF6C3ADAAAAQL24ZJplmOTZZCnmFynmVynjuL2rshuCGwAAAADHZDBI3iFS1CTL40yMFLNCOvKblJdh7+rqFcENAAAAgGM6vEKK/U2K/IsUPlgK6igFRkoD7pVObLWEuLgNUnGBvSutcwQ3AAAAAI7JXCIlbLE8XIxSu2FS5CipZR+pzQAp7FKpMFc6ttYS4hKj7V1xnSG4AQAAAHB8RfmWcBazQvLwlzqMsoS4wA5Sp6ukjldKOal/tPlVSj9m74ptiuAGAAAAoGHJTbes2bbnc6lZG0toixgh+YRIUbdKvW6W3h1h7yptiuAGAAAAoOHKiJe2vGt5tOgpdfyL1G6ovauyOYIbAAAAgMbh1G7LY/3r9q7E5pzsXQAAAAAA2FRJkb0rsLk6CW5ms1lbt27VN998o/j4+Lo4RY1ER0frzjvvVEREhDw9PeXn56cuXbpo6tSp2rJlS4XHbN26VRMmTFBoaKiMRqPCwsI0bdo0xcTE1HP1AAAAQBOy7GFp56f2rsJh1Di4rVq1Srfeeqs+//zzMttTU1M1ZMgQDRgwQDfeeKMiIiL06quv1rrQ2nrqqafUr18/vffee0pLS1PXrl3Vpk0bnTp1Sh988IFWrFhR7phFixZp4MCBWrp0qYqKitSjRw+ZTCYtXLhQUVFRWrlypR3eCQAAANAEJO2SMhPsXYXDqHFw+/TTT/XZZ58pNDS0zPbZs2dr48aNkiQ/Pz8VFxfr0UcftW6zh+eee05PP/20AgMD9fXXX+vMmTPatm2b9uzZo/T0dEVHR2v06NFljtm3b5+mT5+u4uJizZo1S4mJidq2bZuSkpI0adIk5eTkaPz48UpNTbXTuwIAAADQVNQ4uG3ZskWenp4aMmSIdVtubq4+/fRTeXh4aMeOHUpLS9MLL7wgs9ms//znPzYpuLr27t2rOXPmyGg06tdff9X1118vZ2fnMm2ioqLUu3fvMtvmzp2roqIiDRo0SC+++KJcXV0lSZ6enlqwYIHatWun9PR0vfLKK/X2XgAAAAA0TTUObqdOnVKrVq3KbNu4caNycnI0btw49erVS5I0Y8YM+fn5acOGDbWrtIZee+01FRUVacqUKerRo0eVjsnJydHy5cslSffee2+5/UajUVOmTJEkLV682Ga1AgAAAEBFarwcQHp6utq1a1dm26ZNm2QwGDRq1CjrNldXV7Vr104HDhyoeZU1ZDab9fXXX0uSxo0bp2PHjum9997Tzp07VVRUpA4dOmjcuHEaOXJkmeOio6OVm5srSRo6tOI1IIYNGyZJiouLU1JSUrkhowAAAABgKzUObt7e3jp9+nSZbevXr5ckDRo0qMx2Z2dnubjU/5JxR44cUXp6uiQpJiZGN9xwg3Jycqz7V6xYof/85z8aN26cPvnkE3l4eEiSDh06JElyc3NTWFhYha8dERFhfX7w4MFKg1t+fr7y8/OtP5tMptq9KQAAAABNTo2HSnbp0kXx8fHas2ePJCk5OVmrV69WcHCwIiMjy7Q9ceKEgoKCaldpDSQmJlqfz5gxQyEhIfrhhx+Uk5Oj5ORkvfrqq3J1ddXXX3+t+++/39o2LS1NkuTv7y+DwVDhawcEBFifl4bDirzwwgvy8/OzPioLggAAAABQmRoHt1tuuUVms1mjR4/W3//+d40YMUKFhYW65ZZbyrSLi4vT6dOn1bFjx1oXW11ZWVnW5yUlJVq+fLmuvvpqeXh4KCgoSI888oieeeYZSdIHH3xg7WkrHSbp5uZW6Wu7u7tbn5/fi/dns2fPVmZmpvWRkMCUpgAAAACqp8bB7Z577tGIESN04sQJvfbaa9q3b586duyoJ554oky70nXeLr/88loVWhOlQx8laezYseratWu5Nn/729/k7u4us9msH374ocxxBQUFlb52Xl6e9bmnp2el7YxGo3x9fcs8AAAAAKA6anzjmYuLi1asWKFly5bpwIEDCg8P1/XXX1+mJ6q03UMPPaQbb7yx1sVW1/nDGbt161ZhGw8PD7Vv31779+/X0aNHJVmGSEqWIZBms7nC4ZKlwynPbw8AAAAAdaFWM4YYDAZde+21uvbaayttM2PGjNqcolY6deokJycnlZSUyGg0VtqudF9RUZEkqXPnzpIsPW7x8fEKDw8vd0xsbKz1eWl7AAAAAKgLNR4q2RB4enpaF9Y+cuRIhW3MZrO1p6104pCoqCjrcMm1a9dWeNyaNWskSW3btmUpAAAAAAB1qtbBLSMjQ//617909dVXq3v37mWmyZek77//Xh9++OEF7xerS7feeqsk6euvv9aZM2fK7f/ss8+UmZkpSdb157y8vDR69GhJ0vz588sdk5+frw8++ECSNHHixLooGwAAAACsahXc1q5dq06dOmnWrFn6+eeftX//fsXFxZVps3nzZk2dOlW//vprbU5VY/fee6/atGmjrKws3XbbbWXC29atW/XII49Ikq655hpdcskl1n1PPfWUXFxctGHDBj322GMqLCyUZJlBcvr06Tp27Jj8/Pw0c+bM+n1DAAAAAJqcGge3uLg4jR07VikpKRo9erQWLlxY4QQgN998s8xms7755pva1FljHh4eWr58uQIDA/Xzzz+rdevW6tevn7p06aL+/fvr1KlT6tOnjxYtWlTmuO7du2v+/PlydnbWvHnz1LJlS/Xr10+hoaH6+OOP5eHhoaVLlyowMNAu7wsAAABA01Hj4DZv3jxlZWXp0Ucf1Xfffafbb79dzZo1K9eua9euatasmbZv316bOmulR48e2r9/v/7+978rPDxc+/bt04kTJ3TJJZfo1Vdf1YYNGyoMYNOmTdPGjRt14403ytnZWXv27JGPj49uv/127dy50zq0EgAAAADqUo1nlVyxYoU8PT2tC1hfSLt27ZSYmFjTU9lEUFCQ/vWvf+lf//pXtY7r37+/vvjiizqqCgAAAAAursY9bidPnlRkZKTc3Nwu2tbNzU3p6ek1PRUAAAAANGk1Dm6enp7KyMioUtsTJ05UOIwSAAAAAHBxNQ5unTp10okTJ5SQkHDBdjt27NDJkyfVq1evmp4KAAAAAJq0Gge3G264QcXFxXr44YdVXFxcYZvs7Gzdc889MhgMuummm2pcJAAAAAA0ZTUObvfff7/at2+vb775RoMHD9Y777wjk8kkydLL9sYbb6hnz57avn27unfvrttvv91mRQMAAABAU1LjWSU9PT31ww8/aMyYMdqyZYu2bt1q3Ve6kLXZbFZkZKS+/fZbubq61r5aAAAAAGiCatzjJkkdO3ZUdHS0XnrpJfXt21cuLi4ym81ycnJSjx499Oyzz2r79u1q27atjcoFAAAAgKanxj1upby8vDRz5kzNnDlTkpSTkyNPT89aFwYAAAAAsKhVj1tFCG0AAAAAYFs2D24AAAAAANuq0lDJDz/80CYn++tf/2qT1wEAAACApqRKwW3KlCkyGAy1PhnBDQAAAACqr0rBbejQoTYJbgAAAABqZ+yb6+1dQrUtc7N3BQ1flYLb6tWr67gMAAAAAEBlmJwEAAAAABwcwQ0AAAAAHBzBDQAAAAAcXJXucatI+/btq9XeYDAoNja2pqcDAAAAgCarxsEtLi6uWu2ZlRIAAAAAaqbGwW3VqlWV7isoKNCRI0f03nvvaf/+/frXv/6l7t271/RUAAAAANCk1Ti4DRs27IL7R40apbvvvlu33Xab5syZo507d9b0VAAAAADQpNXp5CROTk56++23lZWVpblz59blqQAAAACg0arzWSX9/f3VrVs3/fjjj3V9KgAAAABolOplOYDs7GylpKTUx6kAAAAAoNGp8+AWHR2t2NhYBQcH1/WpAAAAAFTgwSs6aHjnYLm7soxzQ1XjyUni4+Mr3Wc2m3X69Glt2LBBL7/8ssxms8aOHVvTUwEAAACohZFdQzSiS4juHRah34+mavWhZEXHZ8hs78JQZTUObu3atatSO7PZrA4dOjA5CQAAAGBHRcUlMro6aVinIA3tGCRTbqHWHE7R6kPJik05a+/ycBE1Dm5m84XzuZeXlzp27Khrr71WM2bMkI+PT01PBQAAAKCW1sac0ZfbT+iKzsEa2jFIwb5Gje3VUmN7tdTJ9BytPJisNYdTdCa7wN6logI1Dm4lJSW2rAMAAABAHTuZkauPfj+uj34/rq6hvhreOUiDIgLVOsBTkwe21eSBbbX3ZKZWHUrWxiOpyi0stnfJ+EONgxsAAACAhmt/kkn7k0z635qjuqRtgIZ3DlLfcH/1aO2n7q38LPfDHUvT6kPJ2haXbu9ymzyCGwAAANCEFZeY9fvRVP1+NFWebs4aEhmoyzsFq0uor4ZEBuqyDoG6/u0N9i6zyatxcDtw4IDeffddDR48WDfeeGOl7b744gtt3LhR99xzjzp27FjT0wEAAACoYzkFxfp532n9vO+0gryNurxzkIZ1DLJ3WVAt1nFbsGCB3njjDXl5eV2wnbe3t15//XUtXLiwpqcCAAAAUM9SsvO1dNsJPfBptL1LgWoR3H777Td5eHjoqquuumC7K6+8Uh4eHlqxYkVNTwUAAAAATVqNh0omJCQoPDz8ou0MBoPatm2rhISEmp4KAAAAQC1MX7RNecwQ2aDVOLidPXtWnp6eVWrr6ekpk8lU01MBAAAAqIWUrHx7l4BaqvFQyZCQEB0+fFhFRUUXbFdUVKTDhw8rKIibGgEAAACgJmoc3AYNGqTs7Gy98847F2z37rvvKisrS4MGDarpqQAAAACgSatxcLvvvvtkNps1Y8YMvfvuuzKbzWX2m81mvffee5oxY4YMBoPuueeeWhcLAAAAoH48fV03vfvXfnrnr33tXQpUi3vcLrvsMt1///16++23dc8992jOnDm69NJL1axZM2VkZGjz5s06deqUzGaz7rnnHg0fPtyWdQMAAACoQ4HeRgX7GvWn/hnYSY2DmyS9+eabCg4O1osvvqikpCR98803ZfZ7eHjoscce05NPPlmb0wAAAACoZ6/9clhGlxoP0ION1Sq4SdI//vEP3Xvvvfr++++1Z88emUwm+fr6qmfPnho9erSaN29uizoBAAAA1KOY5Gx7l4Dz1Dq4SVJgYKBuv/12W7wUAAAAAOBP6PsEAAAAAAdX6x63jIwMvffee/rtt9+UkJCg3NxcxcbGWvd///33Sk1N1c033yw3N7fang4AAACAjXUK8VHv8GYK8HRTXmGxjiRna9PRVBUWMzOJo6hVcFu7dq1uuukmnTlzxrocgMFgKNNm8+bNeu655xQYGKhrrrmmNqcDAAAAUAOTB4YrNjlbG2NTy2w3ujhpxqiOurS9ZV6K0o/yZrOUnlOgF384qEOns+q7XFSgxkMl4+LiNHbsWKWkpGj06NFauHChunXrVq7dzTffLLPZXG7GSQAAAAD1Y3zf1urXNqDc9odHdtSAiObKzi/SN9En9faqI1q0MU4xyVkK8HLTP8d2lb+nqx0qxp/VuMdt3rx5ysrK0qOPPqp58+ZJkt57771y7bp27apmzZpp+/btNa8SAAAAgE1FBHlpUIfmSs3O14zPdykjp9C676sdJ3Xf5RG6snsLXRvVSos2xtmvUEiqRY/bihUr5OnpqWeeeeaibdu1a6fExMSangoAAACAjfUN95fZLC3cEFcmtJVasP6YsvKK1Dfc3w7V4c9qHNxOnjypyMjIKk044ubmpvT09JqeCgAAAICNNfc2SpL2JZoq3J9fVKLY5GyF+BrrsyxUosbBzdPTUxkZGVVqe+LECTVr1qympwIAAABgY4VFJZKk7LyiStucLSiS858mH4R91Di4derUSSdOnFBCQsIF2+3YsUMnT55Ur169anoqAAAAALUU6ueu4Z2DrQ9vd8t0F8EX6FEL8jbKlFd+GCXqX40nJ7nhhhu0efNmPfzww/r888/l7Oxcrk12drbuueceGQwG3XTTTbUqFAAAAEDNdQn1VZdQX+vPBoNl2v++4f46kZ5brr2Lk0GtAzwVm5xdn2WiEjUObvfff7/mz5+vb775RoMHD9a0adNkMlnGx+7YsUPr1q3TG2+8oePHj6t79+66/fbbbVY0AAAAgKpbvCW+0n0VTUwiSUMiA+Xp5sw6bg6ixsHN09NTP/zwg8aMGaMtW7Zo69at1n2XXHKJJMlsNisyMlLffvutXF1Z/wEAAACwhyVbLnx7U0W2HU/X9EXblMVQSYdQ43vcJKljx46Kjo7WSy+9pL59+8rFxUVms1lOTk7q0aOHnn32WW3fvl1t27a1UbkAAAAA6kNWXpFSsvKVV1hi71KgWvS4lfLy8tLMmTM1c+ZMSVJOTo48PT1rXRgAAACA+uHiZFDnFj7y93JTXmGxYlPOKu1sgb3LwnlqHdz+jNAGAAAAOJbeYc2UerZA8Wk55faN6RmqWy9tI0+3stFg87FUvb3yiEwXWC4A9adWQyUBAAAAOL4513XTdVEty22f0C9M04e0l5fRRbEp2VoXk6Lo+HTlFxVrQPvmenZcD7k4sY6bI6hSj9uHH35ok5P99a9/tcnrAAAAAKgew58W0g70dtPN/cNUUFSi5384oJ0JGdZ9vu4uemJ0F3Vq4aure4Rq2a7Eeq4Wf1al4DZlypRyF7omCG4AAACAYxjQvrmcnQz6dHN8mdAmSaa8Ir2y4rD+M6mPLusQSHBzAFUKbkOHDrVJcAMAAADgGFo285DZLG04cqbC/clZ+TqSkq02Acxh4QiqFNxWr15dx2UAAAAAqE+lt66lZOVX2uZMdoE6hvjUU0W4EJvPKgkAAADA8Xi4OinI22j9OeuP2SIDvNyUXEl48/d0VTazSjoEghsAAADQBAyMCNTAiMBy27uE+io5K6XCY1o189CZ7Mp75FB/bBLctm3bpu+//14HDx6UyWSSr6+vunTpotGjR6tv3762OAUAAACAGtp30iSzzBXua9nMo8Lt3Vv5yd/LTZuOptZlaaiiWgW31NRUTZkyRT/88IMkyWw+94fBYDBo7ty5GjNmjN5//301b968dpUCAAAAqJHHv95T7WMKior1xq8xOnw6qw4qQnXVOLjl5+fryiuvVHR0tMxms6KiotSzZ0+FhoYqKSlJe/bsUXR0tJYvX66rrrpKGzZskJubmy1rBwAAAFBHDp/O1uHT2fYuA3+ocXD773//qx07dqhVq1Z6//33NWrUqHJtfv31V91xxx3asWOH/vvf/+qhhx6qVbEAAAAA0BQ51fTAzz77TAaDQd98802FoU2SRo4cqS+//FJms1lLliypcZEAAAAA0JTVOLgdPHhQkZGRF518pF+/furYsaMOHDhQ01MBAAAAQJNW4+CWl5cnH5+qLcbn4+Oj/HymEQUAAACAmqhxcGvVqpUOHDig7OwL37CYlZWl/fv3q2XLljU9FQAAAAA0aTUObldccYVyc3P14IMPllkG4Hxms1kPPPCA8vLyKr0PDgAAAABwYTUObv/3f/8no9GoDz/8UN26ddM777yjTZs26dixY9q0aZPeeecdde3aVR9//LHc3d01c+ZMW9YNAAAAAE1GjZcD6NChgxYvXqxJkybp4MGDuvfee8u1MZvN8vT01CeffKIOHTrUqlAAAAAAaKpq3OMmSdddd5127dql6dOnq0WLFjKbzdZHixYtdOedd2rXrl267rrrbFUvAAAAADQ5Ne5xKxUREaF33nlHkmUiEpPJJF9f3yrPOAkAAAAAuLBaB7fz+fj4ENgAAAAAwMZqNVQSAAAAAFD3qtzj9umnn9b6ZLfeemutXwMAAAAAmpoqB7fbbrtNBoOhxicyGAwENwAAAACogWrf4xYSEiKj0VgXtQAAAAAAKlDt4FZQUKDx48dr6tSp6t27d13UBAAAAAA4T5UnJ/n5559100036ezZs3r77bfVr18/9enTR2+99ZbS09PrskYAAAAAaNKqHNxGjRqlJUuWKCkpSW+88YZ69eqlnTt36qGHHlLLli11880366effpLZbK7Lem0iPj5evr6+MhgMMhgMWr16daVtt27dqgkTJig0NFRGo1FhYWGaNm2aYmJi6q9gAAAAAE1atZcDaNasmR544AHt2LFDO3fu1P333y9vb299/vnnGj16tNq0aaN//OMfio2NrYt6beLOO+9UVlbWRdstWrRIAwcO1NKlS1VUVKQePXrIZDJp4cKFioqK0sqVK+uhWgAAAABNXa3WcevZs6f+/e9/KzExUUuWLNHIkSOVlJSk559/Xh07dtT9999vqzpt5r333tOKFSt0ww03XLDdvn37NH36dBUXF2vWrFlKTEzUtm3blJSUpEmTJiknJ0fjx49XampqPVUOAAAAoKmyyQLcrq6umjBhgn7++Wdt3rxZ4eHhkuRwwwlPnDihv//972rXrp2eeeaZC7adO3euioqKNGjQIL344otydXWVJHl6emrBggVq166d0tPT9corr9RH6QAAAACaMJsEt5KSEi1btkzjxo3ToEGDFBcXJ7PZrHbt2tni5W3mrrvukslk0jvvvCNPT89K2+Xk5Gj58uWSpHvvvbfcfqPRqClTpkiSFi9eXCe1AgAAAECpai8HcL4DBw5o4cKF+uijj5ScnCyz2ayQkBBNnjxZ06ZNU+fOnW1VZ60tXLhQP/74o6ZOnaqRI0cqLi6u0rbR0dHKzc2VJA0dOrTCNsOGDZMkxcXFKSkpSaGhoTavGQAAAACkGgQ3k8mkJUuW6P3339fWrVtlNpvl4uKia6+9VlOnTtXo0aPl7OxcF7XWWGJiombMmKGQkJAqDW08dOiQJMnNzU1hYWEVtomIiLA+P3jwYKXBLT8/X/n5+dafTSZTdUoHAAAAgKoHt5UrV2rhwoX66quvlJeXJ7PZrK5du2rq1Kn661//qqCgoLqss1buvvtuZWRkaOnSpfL3979o+7S0NEmSv7+/DAZDhW0CAgKszy+0jt0LL7yguXPnVrNiAAAAADinysFt5MiRMhgM8vHx0V//+ldNnTpV/fv3r8vabOKjjz7S8uXLdf3112v8+PFVOqZ0mKSbm1ulbdzd3a3Pc3JyKm03e/ZszZgxw/qzyWSqtBcPAAAAACpS7aGSPj4++u233/Tbb79V6ziDwWAdglhfTp06pYceekh+fn56++23q3ych4eHJKmgoKDSNnl5edbnF5roxGg0ymg0VvncAAAAAPBn1QpuZrNZJ0+erNGJKhtyWJceeOABpaen65133lHLli2rfFzpcMr09HSZzeYKay8dTnl+ewAAAACoC1UObgsXLqzLOurEtm3bJElPPvmk/vGPf5TZV1xcbH1+ww03yM3NTRMnTtQbb7xhnQ2zoKBA8fHx1nXpzhcbG2t97kizZwIAAABofKoc3G6//fa6rKNOJScnX3B/6eQimZmZkqSoqCh5eHgoNzdXa9eu1eTJk8sds2bNGklS27ZtWQoAAAAAQJ2yyQLcjqp0IfCKHseOHbO2W7Vqlcxmsz744ANJkpeXl0aPHi1Jmj9/frnXzc/Pt7adOHFinb8PAAAAAE1bow5utfHUU0/JxcVFGzZs0GOPPabCwkJJlhkkp0+frmPHjsnPz08zZ860c6UAAAAAGjuCWyW6d++u+fPny9nZWfPmzVPLli3Vr18/hYaG6uOPP5aHh4eWLl2qwMBAe5cKAAAAoJEjuF3AtGnTtHHjRt14441ydnbWnj175OPjo9tvv107d+7UqFGj7F0iAAAAgCag2uu4NRZt27aV2Wy+aLv+/fvriy++qIeKAAAAAKBi9LgBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAg6tVcHN2dtaVV15pq1oAAAAAABWoVXAzm83lptT/29/+phEjRtSqKAAAAADAOVUObo8//rh++uknmUymC7aLjo7W6tWra1sXAAAAAOAPVV6A+8UXX9S8efPk5OSknj17asiQIXVZFwAAAADgD1UObp9//rnWrVuntWvXateuXYqOjpYkrVq1SgMGDNCVV16pkSNHqqioqM6KBQAAAICmqMrBbfz48Ro/frwkKTMzU2vXrtV1110nFxcXbdu2TVu2bNGzzz5rbf/yyy/rsssu0yWXXCIXlyqfBgAAAADwJzWanMTPz09jx46VJA0ZMkTJyclavHixpkyZIm9vb0nSrFmzdNlll8nPz09XXHGF5s6da7uqAQAAAKAJqXJwW7lypXJzcyvcFxAQoIkTJ2rBggXq2bOnJOm9997TbbfdphYtWmj16tV6+umnbVMxAAAAADQxVR7DOHLkSLm6uqpPnz4aOnToRScnmTZtmqZNmyZJSkxM1Nq1a2tXKQAAAAA0UVXucbvjjjsUERGhzZs36+WXX9Z1110nSdq5c6cef/xxrVmzptKJSVq2bKmbb77ZNhUDAAAAQBNT5eD27rvvav/+/UpOTtZXX32lhx56SJJ05swZvfjii7riiisUEBCgXbt2SbKs51ZSUlI3VQMAAABAE1LtyUkCAwN1/fXX69VXX5UkDRw4UIsXL9bkyZPl4+Oj7OxsSVK/fv3k7++vq6++Ws8//7zWr19v28oBAAAAoImo9Tz9Xl5emjhxoiZOnCjJEuS2bNmiCRMmaN26dfr555/1888/y2AwqLi4uNYFAwAAAEBTY/MF1krXbFu8eLEkKTY2VqtXr9a6detsfSoAAAAAaBJqFdzatGmjFi1aXLBNRESEIiIidMcdd9TmVAAAAADQZNUquMXFxZXbZjaba/OSAAAAAIA/sflQyS+//FJ5eXm2flkAAAAAaLJsHtxCQkJs/ZIAAAAA0KRVezkAAAAAAED9IrgBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDI7gBAAAAgIMjuAEAAACAgyO4AQAAAICDa/TBbc+ePXruued05ZVXqlWrVnJzc5OPj4+ioqI0e/ZsJSUlXfD4rVu3asKECQoNDZXRaFRYWJimTZummJiYenoHAAAAAJq6Rh3cYmNj1bNnTz355JNasWKFSkpK1KtXLzVv3ly7d+/Wiy++qK5du2rVqlUVHr9o0SINHDhQS5cuVVFRkXr06CGTyaSFCxcqKipKK1eurOd3BAAAAKApatTBzWw2KzAwUP/85z916NAhJSUlaevWrYqLi9POnTvVs2dPZWRk6MYbb1RKSkqZY/ft26fp06eruLhYs2bNUmJiorZt26akpCRNmjRJOTk5Gj9+vFJTU+307gAAAAA0FY06uLVu3VpxcXGaO3euOnbsWGZfz5499fXXX8vFxUXp6elavHhxmf1z585VUVGRBg0apBdffFGurq6SJE9PTy1YsEDt2rVTenq6XnnllXp7PwAAAACapkYd3Nzd3eXl5VXp/vbt26tLly6SpAMHDli35+TkaPny5ZKke++9t9xxRqNRU6ZMkaRygQ8AAAAAbK1RB7eqyMvLk6QyAS86Olq5ubmSpKFDh1Z43LBhwyRJcXFxF53gBAAAAABqo0kHt82bN1tnhywNYpJ06NAhSZKbm5vCwsIqPDYiIsL6/ODBg3VYJQAAAICmzsXeBdhLXl6e7rnnHklSVFSURo8ebd2XlpYmSfL395fBYKjw+ICAAOvz9PT0Ss+Tn5+v/Px8688mk6lWdQMAAABoeppkj5vZbNadd96pnTt3ysPDQx9//LGcnM79rygdJunm5lbpa7i7u1uf5+TkVNruhRdekJ+fn/VRWQ8eAAAAAFSmSQa3hx56SB9//LHc3Ny0dOlSdevWrcx+Dw8PSVJBQUGlr1F6b5xkmWmyMrNnz1ZmZqb1kZCQUMvqAQAAADQ1TW6o5COPPKI333xTbm5u+uKLL8oMkSzl7+8vyTIE0mw2VzhcsnQ45fntK2I0GmU0Gm1QOQAAAICmqkn1uD3yyCN6/fXX5erqqqVLl2rs2LEVtuvcubMkS49bfHx8hW1iY2PLtQcAAACAutBkgtuMGTPKhLZrr7220rZRUVHW4ZJr166tsM2aNWskSW3btlVoaKjtCwYAAACAPzSJ4DZz5ky99tpr1tB23XXXXbC9l5eXdQjl/Pnzy+3Pz8/XBx98IEmaOHGizesFAAAAgPM1+uA2e/ZsvfLKK9Z72i4W2ko99dRTcnFx0YYNG/TYY4+psLBQkmUGyenTp+vYsWPy8/PTzJkz67J8AAAAAGjck5Ns2rRJL774oiTJ19dXL730kl566aUK215zzTV6/PHHrT93795d8+fP11133aV58+ZpwYIFCg8PV0xMjEwmkzw8PLR06VIFBgbWy3sBAAAA0HQ16uB2/sLXZ86c0ZkzZypt26FDh3Lbpk2bpu7du+ull17S+vXrtWfPHgUFBWncuHF6/PHH1bFjxzqpGwAAAADO16iD2+WXXy6z2Vyr1+jfv7+++OILG1UEAAAAANXX6O9xAwAAAICGjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuAGAAAAAA6O4AYAAAAADo7gBgAAAAAOjuBWBVu3btWECRMUGhoqo9GosLAwTZs2TTExMfYuDQAAAEATQHC7iEWLFmngwIFaunSpioqK1KNHD5lMJi1cuFBRUVFauXKlvUsEAAAA0MgR3C5g3759mj59uoqLizVr1iwlJiZq27ZtSkpK0qRJk5STk6Px48crNTXV3qUCAAAAaMQIbhcwd+5cFRUVadCgQXrxxRfl6uoqSfL09NSCBQvUrl07paen65VXXrFzpQAAAAAaM4JbJXJycrR8+XJJ0r333ltuv9Fo1JQpUyRJixcvrs/SAAAAADQxBLdKREdHKzc3V5I0dOjQCtsMGzZMkhQXF6ekpKR6qw0AAABA00Jwq8ShQ4ckSW5ubgoLC6uwTUREhPX5wYMH66UuAAAAAE2Pi70LcFRpaWmSJH9/fxkMhgrbBAQEWJ+np6dX2CY/P1/5+fnWnzMzMyVJJpPJVqVeUGHu2Xo5j62YiovsXUL11fJaNrRrJHGdGgKuUcPQ1K4T16ie8HfJ8XGNGoZ6+LxemgnMZvNF2xLcKlE6TNLNza3SNu7u7tbnOTk5FbZ54YUXNHfu3HLbK+vFa+r87F1ATTzSIKuulQb5jpvYdWqQ77aJXSOJ69QQNMh328SukdQArxPXqGGox+uUlZUlP78Ln4/gVgkPDw9JUkFBQaVt8vLyrM89PT0rbDN79mzNmDHD+nNJSYnS0tLUvHnzSnvymiqTyaSwsDAlJCTI19fX3uWgElwnx8c1ahi4To6Pa9QwcJ0cH9eocmazWVlZWWrZsuVF2xLcKuHv7y/JMgTSbDZXGLJKh1Oe3/7PjEajjEZjmW3NmjWzXaGNkK+vL3+pGwCuk+PjGjUMXCfHxzVqGLhOjo9rVLGL9bSVYnKSSnTu3FmSpcctPj6+wjaxsbHl2gMAAACArRHcKhEVFWUdLrl27doK26xZs0aS1LZtW4WGhtZbbQAAAACaFoJbJby8vDR69GhJ0vz588vtz8/P1wcffCBJmjhxYn2W1mgZjUY99dRT5YaWwrFwnRwf16hh4Do5Pq5Rw8B1cnxcI9swmKsy92QTtXfvXvXu3VtFRUWaNWuWnnnmGbm6uionJ0d33323Pv74Y/n5+enIkSMKDAy0d7kAAAAAGimC20W8//77uuuuu1RcXKzAwECFh4crJiZGJpNJHh4e+vbbbzVq1Ch7lwkAAACgESO4VcGWLVv00ksvaf369UpPT1dQUJBGjhypxx9/XB07drR3eQAAAAAaOYIbAAAAADg4JicBAABAnbv88stlMBisk7uh8Vi9erUMBoPatm1r71KqbPHixRo4cKB8fHxkMBhkMBi0evVqe5d1QQQ31NqUKVOsf+C9vLxkMpku2P7xxx+3tjcYDDpx4oQk6aqrrpLBYNDkyZMrPfbdd9+1Hvfcc89V2m7WrFkyGAzq2bNnzd5UI1B6XS6//PKLtm3btq0MBoPmzJlTZnvpP7J/fri6uqpFixa6+uqr9emnn6qqHfdfffWV9TXGjBlTg3fVuDjCNZozZ065Y11cXBQQEKD27dtrzJgxmjt3rg4dOmSDd+x4zv/9dbHr0KFDhwo/dJZem/Mfzs7O8vf314ABA/TMM88oPT29SvVkZWXp1Vdf1YgRIxQaGio3Nzc1b95cffv21WOPPaa4uLgKj6voz0BVHn/+8+TIavse4+LiKtxvNBrVsmVLjR49WkuWLKn078rhw4f10EMPqWfPnvLx8ZGbm5tatmypqKgoTZkyRQsWLFBKSspF30d0dLT13N27d7fl/yJUQ0W/O52cnNSsWTP1799fTz31lM6cOWPvMqvt/N9p578vHx8fde/eXffff3+j/X1eHZ9++qluvfVW/f7772rRooUGDx6swYMHV3khbHtxsXcBaFxycnL02Wef6c4776xwf3FxsT788MMK9w0fPlw///yzVq1aVenrn/9NyKpVq/TEE09csN3w4cOrVjguKDg4WJGRkdafs7KydOzYMf3000/66aef9Nlnn+mrr76Ss7PzBV/n/ffftz7/6aefdPLkSbVq1arO6m5KanuNjEaj+vXrV+b4U6dO6fvvv9f333+vOXPmaMyYMfrf//7XaK/ZmjVr9MMPP+iaa66p0fFhYWFq06aNJKmgoEDHjh3T5s2btXnzZv3vf//TmjVr1KFDh0qPX758uaZOnWr9sNiqVStFRUUpMzNT0dHR2rFjh1577TX985//LPe7b/DgwRW+5rZt25Sfn1+mtvNVtM1R2fI9du/e3foBzWQy6ciRI/rhhx/0ww8/aMmSJfriiy/k4nLuI9KCBQt03333qaCgQE5OTmrdurVCQkKUk5OjAwcOaNeuXVq0aJE++ugj3XbbbRd8HwsWLLA+37dvnzZv3qxLL720Sv8PYHvn/+4sKirSsWPHtHXrVm3dulX/+9//9NtvvzXIgO3r66sePXpIkkpKSnTixAnt379f+/bt04IFC7R48WKNGzfOzlXaz2uvvSZJev755zV79mw7V1MNZqCWbr/9drMkc5cuXcySzAMGDKi07ffff1+mrSRzQkKC2Ww2mzdv3mzdFhMTU+HxrVq1MhuNRnOrVq3MHh4e5vz8/HJtsrKyzC4uLmZJ5q+//tom77EhKr0uw4YNu2jb8PBwsyTzU089VWb7sGHDzJLMt99+e7lj8vLyzM8884z1mr377rsXPMfJkyfNzs7OZklmf39/syTzc889V4131Pg4wjV66qmnzJLM4eHhFZ732LFj5qeeesrs5eVllmQOCQkxHz16tArvrmEovQalfzZ79uxpLi4urrBtRESEWZJ54cKFZbZXdm3MZrP5s88+MxuNRrMk8/Dhwyut47PPPjM7OTlZ/zxs3769zP7ExETzfffdZ72WDz/8cJXe34Vqayyq+h6PHTtm/f+3atWqMvuysrLM99xzj3X/K6+8Yt23Y8cO67WZPHmyOS4ursyxBQUF5l9//dU8bdo085dffnnBGnJzc62//0r/e+edd1br/TZkpb+v/vx3yJ61VPS78+uvvzZ7e3ubJZl79eplLikpqf8Ca+hC/65s377d+nvM39/fnJGRYbPzrlq16oL/ljgaDw8PsyTzvn377F1KtTBUEjYzaNAgderUSb///rsOHjxYYZvSHpdp06aV29e3b1/5+vpKUoVjjGNiYnTy5EkNGDBAI0aMUG5urjZv3lyu3bp161RUVCQnJycNGzasFu8IF2I0GvXkk0+qb9++kqQff/zxgu0/+OADFRcXKzIyUo8//rgky58HM/Mj1ZnqXqOKtG3bVnPmzNHmzZvl7++v06dPa/z48Y3uul133XVq1qyZdu/erY8//thmrzthwgQ99NBDkiy/15KTk8u1iYuL0x133KGSkhKNGTNGv/zyi/r06VOmTWhoqN5++2298MILkqTXX39dX3/9tc3qbOq8vb311ltvWXsoPvroI+u+d999VyUlJerWrZs++OADhYeHlznW1dVVI0aM0IIFC3TDDTdc8DxfffWV0tPT5evrqzfeeEOStGTJEp09e9bG7wi1cf311+uf//ynJGnXrl3avXu3nSuyjT59+ujNN9+UJKWnp2vFihV2rsh+cnNzJUmenp52rqR6CG6wqSlTpkgqOySu1JkzZ7Rs2TI1b95c1157bbn9zs7OGjJkiCRVOFyydNvll19uDWQXaterVy/5+/vX7I2gykpvRC4oKKi0jdls1sKFCyVZ/ozcdtttcnFxUWxsrNasWVMfZTZpVblGF9OtWzfrB80dO3Zo2bJltijNYfj7+2vWrFmSpH/+85/Kz8+32WsPHDhQkuXvwbFjx8rtf/HFF5WdnS1fX1+9//77cnV1rfS1Zs2aZX29f/zjH40uQNuTs7Ozhg4dKslyP1up2NhYSZbhlU5OtfvYVDpMcuLEiZo4caICAgKUlZWlpUuX1up1G4OYmBjdddddioiIkLu7u5o1a6YBAwbotddeU15eXqXHpaSk6MEHH1SbNm1kNBoVFhamu+++W4mJifrggw+qfB/xn51/q8X5fx4autLfH5J09OjRMvtK73ku/SxXkdpMMPP777/rtttus14rf39/DRs2TB988IFKSkqq/XqS5RacBQsW6PLLL1dAQICMRqPatGmj2267TdHR0eXal973V6pdu3bWbRd6346C4Aabuv322+Xs7KyPPvpIRUVFZfZ9/PHHKigo0KRJk+Tm5lbh8aW/KCvqcSvdNmzYMGtwu1A77m+re4WFhdZfjN26dau03Zo1a3TkyBE5OTnpr3/9q1q0aKErr7xSUtn7PWB7Vb1GVXHLLbcoODhYkvTNN9/UtjSH89BDD6lVq1Y6fvy43n77bZu9bk5OjvW5t7d3mX3FxcVasmSJJGnSpEkKCgq64GsZDAZrD96+ffsq/GCCmqsoCJeOBNm6desFA8TFHDt2zPrF4pQpU+Tm5qZbbrlFEr8Hv/32W/Xs2VPvvvuukpKS1K1bNwUHB2vz5s2aMWOGBg8eXOHEL8eOHVOfPn301ltv6eTJk4qMjFTz5s31/vvvq3fv3jp+/HiNa2qsX4pc6PdRXfrHP/6hgQMH6pNPPlFGRoa6dOkib29vrV27VlOnTtX48eNVXFxcrdc8e/asrrzySk2fPl1r1qyRr6+vevbsqYyMDH3yySe65JJL9M4775Q5pnQSklL9+vWzbmsIazMT3GBToaGhuuqqq3Tq1Cn99NNPZfaV9rhUNEyyVGnYSkxMVExMTJl9a9askZubmwYMGKCIiAi1bt1amzZtKvPNeFZWlnbs2CFJuuKKK2zynlBedna2tm/frgkTJujo0aMKDAzUgw8+WGn70h7YkSNHqnXr1pLO9c5++eWXyszMrPOam5rqXqOqcHFx0aBBgyRZvjltbDw8PKwzED7//PM2+3NZ2jvZrFkzRURElNm3e/du63lGjBhRpdc7/3fbunXrbFIjLCF67dq1kqROnTpZt5eOEDl69KhGjhypL7/8UmlpadV+/YULF8psNqtjx47Wv0elvwfXr1/fqHp1quPIkSO69dZblZeXp8mTJ+vUqVPavn27Dh8+rC1btqhVq1basWNHhb0ht912m06cOKFu3brp4MGD2rt3r3bu3Km4uDhFRkbq+eefr3Fd54/oOf/PQ0N3/miJ0mH0de2dd97Rs88+q2bNmmnRokXKzMzUzp07lZCQoM2bNysiIkJff/11ta/XI488ot9++00BAQH69ddfFRcXp61btyo5OVkPPvigiouLdd9995X592r9+vVav3699eelS5dat5XexuHICG6wudJgdv5wyW3btmn37t3q06ePevXqVemxUVFR1uGN5/emHT58WImJibr00kvl4eEhydLzlpeXV+Yv5Lp161RcXFxm2GVTt2bNmotOl32xbyUXLVpUpr2Pj4/69eunZcuW6e6779a2bdsqnWkwMzNTX3zxhSSV+Yf32muvVUBAgHJzc7V48WKbvd+GyN7XqDpK7+85ffp0rV/LEU2dOlVdunRRamqqXnrppRq/TkFBgQ4dOqSHHnrI2qP2+OOPy93dvUy7hIQE6/MLzTh5vqCgIOuMiOcfj5o7e/asHnjgAe3du1eSyixLM2nSJN16662SpA0bNmj8+PFq3ry52rVrp5tuuklvv/32Rf8+lJSUWIeWnf97sF+/ftYZCyu6xaApeOmll5STk6OOHTtq4cKF1h5OSbrkkkus/19++OEHbdmyxbpvzZo12rhxo5ydnfXll1+WmVW3VatW+uqrr2Q0GmtU03fffadnnnlGkuW2i9J7HxuqkpISJSQk6K233tKjjz4qSbr66qs1YMCAOj93bm6udRbc999/X3/961/LDFXs37+/Fi9eLIPBoFdffbXKQ/rj4+OtfzbeeOONMl98ubu769///rcGDRqk4uJiPf300zZ8R/ZFcIPNjR07VkFBQVq+fLl1aMOFJiU5n5OTk/Ueg/O/7Sp9fv5kIxXd51b6/PyJTpo6X19f6zCAyh4X+8ctODi4TPt+/fopJCTEOszrvffeq3R8+uLFi5Wbmys/P78yUw8zTOgce1+j6igdWnOx9RobKmdnZ+u3vq+//rqSkpKqfOzcuXPLrA3WuXNn/fvf/1ZISIhee+016wem82VlZVmfV2fYUmlbeqtr5sEHH9Rll12myy67TL169VJQUJD+97//SbJMVHN+77STk5M++eQTffXVVxo1apT1HsS4uDh98cUXeuCBBxQeHq4nnnii0qFeK1asUEJCgnW4+Pluv/12SZYvX/58i0FTsHz5ckmW3pOKliv5y1/+oqioKEnS999/b91eOtnSsGHDKuwRCw4O1vXXX3/R8//444/WPwsDBgxQSEiIrrvuOmVnZys4OFgff/xxmaDRUJz/haCzs7PatGmjBx98UIWFhbrnnnusX6jWtZUrV+rMmTNq0aJFpcsPXHLJJWrTpo0yMjK0ffv2Kr3uTz/9pOLiYrVs2dL6WeLP/u///k+S9Ntvv9n0vmV7Yh032Jyrq6smTZqk119/XR9//LHuvfdeLV68WEaj0fqt5YUMHz5c3377bZket9Ln599gfH5wKx3exP1t5fXu3bvCewHP17Zt2wv26Fx99dUV3oi8du1a3XbbbXr22Wd1+vTpcmPJpXOh7Oabby7X2zBlyhS9/fbb1h7Zprpgur2vUXWUBg1HX6S0Nq6//noNGjRIGzdu1Jw5czR//vwqHXf+OmKla4Pl5uaqWbNmlc5w6+PjY32enZ1d5RpL2zbm61CXSnvWJMsQ4ObNm2vYsGGaPHmybrnllgo/qI8bN07jxo1TXl6eoqOjFR0drXXr1mn58uXKzs7W888/r+zsbOskPucr/T04atSocj3ft912m2bPnq1Tp07phx9+qHDyrsbKZDJZvxy5UK9Wz549tXPnzjIzVpcuIl0a6irSu3fvMjOEViQ5Odk622vpaIU+ffrommuu0UMPPaTAwMCqvh2Hcv46bvn5+Tp69KjS0tLk4eGhyy67rN5mU9y1a5ckS8/bZZddVmm70uHHCQkJZSZQqUzpn4WuXbtWuj5p6WeKgoICHT16VF26dKlW7Y6IHjfUiTvuuEOSZUz/l19+qYyMDF1//fVVmuWxNHQlJSVZx/yvWbNGrq6uZf4yd+zYUaGhof/f3n2HRXH8fwB/H703KQKCFAUFKyJYEFDswRhLYg0oaqKxG6NJ7BoTW2yJLfYuGsXYCyoqoCAiimJBBcECKkoHafP7g9/u944rHAJyyOf1PPc8uruzO3ezu+zszHwGERERyM/PR2ZmJj9Qnypun4anpyfWrl0LANiyZQvu3bsnsv7OnTuIiooCAInjE4S7CdX1VrfqUl4ZVVRiYiIAwMzMrLJZU2hLly4FUNpbgHtALE9AQAA/VuLOnTt4+fIlAgIC8PDhQ3Tr1g3Pnz8XS2NlZcX/+/Hjx3Id582bN3xLGzdmlFTMpUuXwBgDYwyFhYVISUnB6dOnMXTo0HJbVzQ0NNC+fXv88MMP2L9/PxISEvgH0nXr1uHly5ci2799+xbHjh0DIPk+WJeDNQm33NevX1/qdubm5mLbcy+RZPWuEX4xIo2/vz9/LpSUlCAjIwM3b97EokWLam2lDSittHL3oxs3biA1NRV///030tPT8e2334q0Xlan9+/fAyjtHRAWFib1w5WncPAUWbhzQZ7zRnj72o4qbqRaNGvWDK6uroiNjcXs2bMBlN9NktO8eXP+Znnp0iU8ePAAr169gpubm9gbIk9PT3z48AHh4eG4cuUKiouLoaqqKvOtDqla3FhCxphYwArhh5D27dtLHLvFvfnes2fPZ9OVQdHIKqOKKCoqwrVr1wCAD67wufLw8ICvry+Kioo+esC6gYEB/vnnH7Rr1w5paWkYO3as2DYtWrTgHzwvXLgg134vXrzI/5vG8tY8Y2NjrF+/HkBpgBPhcVhA6Zxw3LgdrjWv7Id7iD516hRSUlI+7ReoQcKVLlnfm2uVE96eq5TJeiAX7opc16moqGD8+PGYPn06GGMYPXq0WCs/99JCVkTNik4rw3Xr7t27N19BlvWRNyQ/dy7Ic94Ib1/bUcWNVBuuopaYmAgrKyt07dpVrnQCgUAk3L/wNABlcV0nhbdzc3ODtrZ25TJP5CY8burt27f8vwsKCrB3714ApQ+wZmZmUj9KSkp49+4d/vvvv0+e/7pAWhlV1P79+/lxq9LGKnxOlixZAiUlJRw5cgQREREftQ9lZWWsWrUKQOn4nLJzTyorK2Pw4MEAgH379pVbPowxvgXVyclJbKJuUjOEA2OUfbDlxnjr6urKvA+qqqqiqKgIu3bt+qR5r0l6enp8q0hsbKzU7bh1wl3duHFtXFc8SWJiYqogl5+XOXPmwMTEBCkpKVi+fLnIOu7ZSVawHW5eQ3lx3RUjIiKqdAxnkyZNAABxcXFSx5Zy542amhrs7Oyq7Ng1iSpupNoMGTIE3bp1g4+PD3755ZcKTVzKdXW8fPmyxPFtHOFxbjS+rWYIhyMXjop39OhRpKWlQUlJCbGxsUhJSZH66du3L4C6103oU5FWRhVx7949fv6wtm3bonfv3lWSN0Xm7OzMB5LgJuf+GO3atUOvXr0AlE7uXdbMmTOhra2NjIwMjBw5UubDzdKlSxEeHg4AWLhwYa0MmlDbyBNBlZtGAIDIXFCRkZF8r4KzZ8/KvA9OmDABQN2LLunr6wsAWLVqlcQH8ODgYH4YxBdffMEv566pkJAQsemDgNKXVJ/jfJOVpauri+nTpwMoDcAkPLUFd+5GR0dLnLMwKCiIHw8or27dusHQ0BBpaWlVOj9mr169oKysjJcvX0qNTM1FBu7atetHRxhVNFRxI9XGwMAA586dQ3BwMMaNG1ehtMLj3I4dOwZVVVWJXbOaNm0KU1NTREZG8m/WqOL26Vy+fBmTJk0CAFhYWKBnz578OuHB+OWNwxk5ciSA0j/QSUlJ1ZTbuklWGckjMTERCxYsgLu7O96/fw9zc3McOnSoOrKqkBYuXAgNDQ1cvnyZH9/3MRYsWACgdA6hc+fOiayzs7PD5s2boaSkhBMnTqBr165iE2u/evUK48ePxy+//AKgNCrigAEDPjo/RH4TJkyAj48P9u3bh/T0dJF1RUVFCAwM5Cv4bm5uIsEyuPtgkyZNyg24wPVSefjwocg8U5+7GTNmQEtLC48ePcLIkSNFuj5GRUXxv8sXX3yBtm3b8uu8vLz4cO8DBgwQGSP66tUr9O/fv1ITpn/Oxo8fDxMTE2RmZmLFihX88i5dukBHRwdv3rzBtGnTRF4inT59GqNGjYKamlqFjqWjo8NH6p0+fTqWLl2KnJwckW2ys7Nx+PBhjB49Wu79WllZ8fEUJk+eLNLVPD8/H9OmTUNYWBiUlZUxZ86cCuVZkVHFjSgkJycnPvhBXl4eXF1dpXZ/9PT0REFBAYqLi6Gurv7Zj72pCcLhkj08PNC2bVvUr18f3t7eePHiBYyMjPDvv//yZZSUlITg4GAA8o1t7N27N8zNzVFSUsJP1E4qpqJlVFZKSopI+latWsHMzAy2traYP38+cnJy8OWXX+LmzZv8XG51gZWVFd8SIq07jjyEWynnzZsntn7IkCE4cuQIjIyMcPnyZbi4uKBBgwZwc3ODo6MjLC0tsX79eqiqqmLBggV8d0nyaVy8eBHDhg2DkZERbG1t4ebmBicnJxgaGmLw4MFITU2Fo6MjAgMD+TS5ubn8HH7cyylZuLHhQN3qfdCoUSPs3bsXGhoa2L17N+rXrw9XV1c4Ojqibdu2SE5ORuvWrSX+bdi9ezcsLS0RGxsLR0dHtGjRAq1bt4a1tTUePHjAv+iQFnWwrtLW1uanJ/nrr7/4Lto6Ojp8K9WGDRtgbGwMV1dXWFlZoXfv3hg4cKBcER/LGjt2LH7//XeUlJTg559/hpGREVq2bIl27dqhcePG0NfXx8CBA/nnBnmtXLkSXbp0wbt379C1a1f+2uSmYFFWVsb69es/yXx1nwpV3IjCkhT6XxLhde3atRMLOU8q7/Xr1yLRn27evIn8/Hy4urpizpw5uH//vsjNfPv27SgpKYGRkRHfDVIWZWVlfsLb7du3yxwYTSSraBmV9eHDBz7t9evX8ezZM2hra+OLL77AggUL8PDhQ/z3338iUbrqil9//RUGBgaV3g83bcn169dx6tQpsfV9+/ZFQkICli9fDm9vbxQWFiImJgZv3rxBq1atMGPGDDx8+FBid0tSfbZt24Zjx45h4sSJcHd3R0lJCe7cuYOEhAQYGhriiy++wD///IM7d+7AxsaGT3fo0CFkZmZCWVlZbO42abgXXYcOHapTgTW++uor3L59G2PGjIGZmRliY2P5oGR//vknwsPDYWJiIpbOzs4O0dHRGD9+PCwsLPDw4UO8efMGfn5+uHXrFh/o7HMJTFGVxo8fD1NTU2RnZ/OVNQAYN24c/v33X7Rv3x5FRUV48OABLCwssGPHjkpNJ/PLL7/gzp07GDt2LGxtbfH48WPExsaCMYbOnTtj2bJlOH/+fIX2qa2tjbNnz2Lz5s3w9PTE+/fvERMTAz09PQwbNgyRkZH47rvvPjrPikjA6AmJEEIIIYR8ZsaPH4/169dj2rRp+PPPP2s6O4RUGrW4EUIIIYSQz0p6ejoOHjwIQHavHUJqE6q4EUIIIYSQWic5ORnLli0Ti3QYHx+PPn364O3bt7C3t68TUXBJ3UBdJQkhhBBCSK3z4MEDfm43c3NzNGjQAO/fv+cjTBoZGeHs2bN80BdCajuquBFCCCGEkFonKysLK1euxPnz5/H06VOkpaVBRUUFNjY26NmzJ6ZNmwZLS8uaziYhVYYqboQQQgghhBCi4GiMGyGEEEIIIYQoOKq4EUIIIYQQQoiCo4obIYQQQgghpFYLCQmBQCCAjY1NTWel2lDFjdSIHTt2QCAQyPz4+vqWu58bN27gm2++gbm5OdTV1WFlZYWAgADEx8dXa1oCpKSkYO/evZg2bRq8vb2hp6fHl11FUDnUnKq6Dknl0LWkGKqqHIQlJSWJ7CckJETm9lSG1au23fNsbGzKzW9UVNRH77+4uBjr1q2Dm5sbdHR0oK2tDQcHBwwePBj79u376P127twZAoEAX331ldxp3N3dIRAI4Ofn99HHrQtUajoDpG7T09ND8+bNJa5zdnaWmXbnzp0YNWoUiouLYWxsjObNmyM+Ph7bt29HYGAgjh8/ji5dulR5WlLqwIEDmDp1aqX2QeWgGCpzHZLKo2tJMVRFOZQ1ZswYZGVlybUtleGnU9vuec2aNYO+vr7Edbq6uh+1T8YYBgwYgP/++w8AYGFhAQsLCzx//hyBgYEIDAzE0KFDP2rfo0aNQkhICE6ePInU1FSYmZnJ3D4uLg6RkZF8WiIDI6QGbN++nQFgXl5eH5X+7t27TEVFhQFgM2fOZAUFBYwxxnJyctiwYcMYAGZoaMjevn1bpWnJ/2zdupV16dKFTZ8+ne3fv5/t2rWLAWDy3laoHGpeZa9DUjXoWlIMlS2HsjZv3swAsP79+/P7uXTpksRtqQw/jdp2z2vYsKHM86YygoKCGACmpKTEdu/eLbIuJiaGff/99x+979zcXKavr88AsBUrVpS7/Y8//sgAsEaNGrGSkpKPPu6lS5cYANawYcOP3oeio4obqRJFRUUsPDyczZkzh0VHR5e7fWVvnl9//TUDwDp06CC2Lj8/n9na2jIA7JdffqnStJ+zipZhWVevXq3QQw6VQ9X71NchkYyuJcXwqctBWHJyMtPT02O2trbs3r175VbcqAw/zud+z6vOituUKVMYANa9e/cq3zdjjI0bN44BYM7OzjK3KywsZGZmZgwA+/333yt1zLpQcaMxbuSjpaamYteuXRgyZAhMTU3RoUMHLFq0CKmpqdV63NzcXJw4cQIAMG7cOLH16urqGDFiBABg//79VZb2c1Qby5CIqqkyJKLoWlIMinI9fPfdd8jMzMQ///wDLS0tmdtSGVaMopRxbaeiUjpaqrCwsFr2z3V5vHfvHt8NUhKuO6WysjL8/f1F1l2/fh3Dhw+HtbU11NXVYWhoCC8vL+zYsQMlJSXl5mHPnj3o0KED9PX1oauri44dO+LAgQMy0+Tk5GD58uVo164dDA0Noa6uDjs7O4wdOxYJCQkS03h7e0MgEGDHjh1ISUnBhAkTYGdnB3V1dbRq1arcfFYEjXEjcisuLkZkZCROnz6NU6dOITo6Guz/528XCARo06YNevfujdatW8u9z6SkJIwcORJJSUnQ0NCAvb09vvjiC/To0UNqmlu3biEvLw8A4OnpKXEbLy8vAEBiYiJevXoFc3PzSqf9HFRHGX6Mul4OlaEo12FdR9eSYlCUchC2fft2nD59GiNHjkTXrl2RmJgoc/u6XobloXsesGnTJvz555/Izc2FiYkJ3NzcMHz4cJiamn70PgcMGIAVK1YgJCQEx48fR58+faowx0CbNm3QsmVL3L59G9u2bYObm5vE7bZt2wYA6NmzJywsLPjlc+bMwW+//QagdBxf06ZNkZaWhitXruDKlSs4duwYDh06BGVlZYn7/emnn7BixQqYmJjAwcEBz549Q3h4OMLDw3Ht2jWsWbNGLM2jR4/Qu3dvPHnyBEpKSmjQoAGsra0RHx+PTZs2Yd++fTh27Bi8vb0lHvPJkydo0aIF3r17h6ZNm8LZ2RlqamoV+dnKV5PNfUTxpaSksJ07d7LBgwczIyMjvrsHAKavr88GDhzItm3bxlJSUiq0X667grSPh4cHe/HihcS0W7duZQCYmpqa1L7QycnJ/L4uXrxYJWlrq+oqw7Iq0q2oLpZDZSjidVgX0bWkGBSxHDgvXrxgBgYGzMzMjL17944xxlhCQoLMrpJ1sQzLQ/e8UlxXSUkfTU1NtnHjxkrtn+uiq6Wlxa5cuVJFuf6fNWvW8GWWm5srtj41NZUf23nkyBF++aZNmxgAZmBgwHbu3ClyXURERDB7e3sGgC1cuFBkf1xXSRUVFaakpMTWrl3LiouLGWOMFRcXs7Vr1zIlJSUGgAUGBoqkzcrKYo0bN2YAWN++fVliYiK/Li8vj02fPp0BYMbGxiwtLU0krZeXFwPAlJWVmY+PD3v+/Dm/TtL3rgyquBGJTpw4wdq0acMEAoHIjaJZs2ZsxowZLCQkhBUWFn70/oOCgti4cePYpUuX2IsXL9iHDx/Y06dP2ZIlS5iWlhbfLzo7O1ss7fLlyxkAZmZmJnX/OTk5fJ4PHz5cJWlrm+ouw7Iq8pBTl8qhMhT5OqxL6FpSDIpcDhxfX18GgB06dIhfVl7FrS6VYXnonidq8ODBbOPGjSwuLo5lZ2ezjIwMFhwczFcUALAdO3Z81L53797N1NXVmYmJCQPAtLW1q/ylQFpaGlNXV2cA2J49e8TWc+e+qakpH5AnNzeXGRsbi1XmhEVGRjKBQMAMDAzYhw8f+OVcxQ0ACwgIkJh25MiRfDlLyourqyufl7K463vp0qUiy7nyMDExYenp6dJ/kCpAFTci0bx588RumsHBwZ/k2FevXmXKysoMAFuyZInY+oULFzIAzMrKSuo+iouL+bwLR0uqTNra5lOXYUUecupSOVSGIl+HdQldS4pBkcuBMcZHofzqq69ElpdXcatLZVgeuufJp6ioiPXu3ZsBYPXq1atwRfP48eNMSUmJWVlZseTkZLZy5Uq+Fe/s2bNi2+/Zs4cBYO7u7hXO66BBgxgA5uPjI7bOycmJAWDTp0/nl504cYIBYPXr15e5X641Mjw8nF8mXHG7e/euxHSxsbH8NgkJCfxyV1dXBoBt2LBB6jG5FtuyAV24itu4ceNk5rkqUHASIlGnTp3QuXNnqKqqAgDu3r2Lrl27olGjRpg4cSJOnTqF3Nzcajm2h4cHBgwYAAA4dOiQ2HpNTU0AQEFBgdR95Ofn8/8WHhhembS1TU2WYXnqUjlUhiJfh3UJXUuKQZHLISUlBZMnT4a+vj7WrVtXobR1qQzLQ/c8+SgrK2PFihUAgLS0NFy6dEnutB8+fMDo0aNRUlKCzZs3o0GDBpg6dSr+/PNP5OXl4csvv8TJkydF0jx9+hQA0LZt2wrnlQtScvHiRZHxnhEREYiLiwMABAQE8Mtv374NAMjLy4OHh4fUz7t37wAAycnJYsdUUVFBkyZNJOanadOmfGAW7vjCx12/fr3UY3K/uaRjAp9oDsBqrxqSWi0zM5MFBQWxMWPGMCsrK5E3YRoaGqxHjx5s9erV7OHDh1V6XK5ftK6urti6LVu2MODjxgNUJm1t9anKsCJvp+tiOVSGIl6HdRFdS4pBEcthwIABDAD7559/xNaV1+JWF8uwPHTPk4+hoSEDwP7880+50xw5coQBYNbW1mLruO6CampqLCgoiF/erl07BoBdvny5wnksLi7mW8fmz5/PL//+++8ZID4FBjeWTN7P9u3b+bRci1t5rXXc9AMHDhxgjDGWnZ1doWOWnW6Aa3ETzkt1oYobqZDY2Fi2dOlS5u3tzVRVVUVOZDs7OzZ+/HiWnJxc6eNs2LCBv0GXFRoayh9TePCosJCQEH6bly9fVknaz0V1lWFFHnKoHCpHEa5DQteSolCEcuAeTE1NTZmZmZnIhxuvA5ROom1mZsYmTZrEp6UyLB/d8yTjKiAV6dq5dOlSBoB16tRJ4vply5YxoDTAR2BgIH9+fkw3SQ7XBdbGxoaVlJSITNC9ZcsWkW3nz5/PALDevXtX+DjCwUmKiookblNUVMQHRDl58iRjjLGSkhK+m2xkZGSFj0sVN1IrZGZmssOHD7PRo0ezBg0a8DfR06dPV3rfP/zwAwPAGjduLLYuOzubaWpqMgBs165dEtMvWLCAv0lUVdrPUVWWYUUecqgcqk5NXYdEFF1LiqGmykFW9D9JH39/fz4tlWHF0D2vVGpqKh/EZe/evXKnW7duHQPALC0tpbbwcpU7ZWVl1qBBA6akpMRCQ0M/Oq+JiYl8NMcLFy7wY+Z0dHRYVlaWyLZci2C9evUqHIhGeIzbvXv3JG5z9+5dfhvhMW4tWrRgANjKlSsr/P2o4kZqpdu3b7MlS5aw27dvV2o/ycnJTE9PjwEQeSspbODAgQwA69ixo9i6/Px8ZmtrywCwmTNnVmnaz11lyrCiA/mpHKrHp7wOiXR0LSmGT1kO0pTXVZIxKsPKqKv3vGnTpjEATFVVtULTIty/f58/H7dt2yZ1Oy5oDgD29ddfVzq/3bp1YwDYsGHDWJcuXRggOfJjVlYW3wV09erVFTqGcMVt9OjRErcZNWoUA8CcnJxElv/2228MKO0GmZGRUaHjUsWNfNaSkpLYt99+y65duyb2tic0NJQ5ODgwoHTeD2ldH2JjY/mm7pkzZ/KhW3Nyctjw4cP59G/evKnStES6ij7kUDnUrKq4Dkn1oGtJMXzKihuVYfWrbfe8BQsWsA0bNojNGZaRkcF+/vln/pz68ccfK7zvESNG8JW+ZcuWicw1VlxczE6ePMlHfORa3oSnuPgYBw4cYACYuro631IYFhYmcVuuy6qKigpbsmSJWNTMrKws9u+//7JRo0aJLBfuKqmsrMzWrVsnMo/bunXr+Ja//fv3i6TNzMzk53FzdXVlUVFRYvm6d+8emz17Njt27JjIcqq4kRq3ePFipq2t/VGf8+fPy9y38B8xXV1d1rJlS+bu7s4sLCz45aampuzq1asy97N161a+T7KxsTFr06YN/7ZMU1OTnTt3rlrS1hbVWYaMlf4RrFevHv/h+qtzXRy4z5dffil1H3WhHCqjNlyHdQFdS4qhNpSDJPJU3BirG2VYHrrn/Y+/vz8DwAQCAbO1tWVubm6sRYsWTE1Njc+vn5/fR81rl5+fz0++zZ1frVu3Zi4uLvx5r6yszH755Rc2a9YsBpQGLKlMd9T8/HyRydSbNGkic/vff/+dr2SpqamxFi1aMHd3d9aoUSN+edkgIVzFrWHDhnyQE1NTU9a2bVtmamrKH3v8+PESj/nkyRPWrFkzfjtLS0vm7u7OWrduzQwMDPjlZStoVHEjNa7sXCoV+ZR3Yefk5LAlS5awfv36MQcHB2ZoaMhUVFSYoaEh69ChA1u8eDF7+/atXPmMiIhgAwYMYGZmZkxNTY1ZWloyf39/uSJNVSZtbVCdZciY6B9BWR8vLy+Z+/ncy6Eyast1+Lmja0kx1JZykLVfWRU3xj7/MiwP3fP+JyQkhE2cOJGvXKqrqzMNDQ1ma2vLhg4dWiXz2506dYoNHDiQWVpaMlVVVaarq8tatGjBfvzxR/bkyRPGWGngjsGDBzOgtIJ35cqVjz7epEmT+PJatmxZudvfvXuXjR07ljk6OjItLS2mpaXF7O3tmY+PD1u2bBl79OiRyPbCFTfGSicZb9euHdPV1WXa2tqsffv25Y4HzM/PZ5s2bWJdu3ZlJiYmTFVVlZmamrJWrVqxUaNGsWPHjrG8vDyRNJ+y4iZgjDEQQgghhBBCCFFYNAE3IYQQQgghhCg4qrgRQgghhBBCiIKjihshhBBCCCGEKDiquBFCCCGEEEKIgqOKGyGEEEIIIYQoOKq4EUIIIYQQQoiCo4obIYQQQgghhCg4qrgRQgghhBBCiIKjihshhBBCCCGEKDiVms4AIZ9SUVERioqKajobhBBCCCEKRUlJCaqqqhAIBDWdFSIFVdxInZCbm4u3b98iJyenprNCCCGEEKKQVFVVoaurC2NjYygrK9d0dkgZAsYYq+lMEFKdCgoKkJCQAFVVVRgZGUFdXZ3eJhFCCCGE/D/GGIqLi5GdnY2MjAyoq6vDysqKKm8Khipu5LP3/Plz5Ofnw9bWlm5AhBBCCCEy5OXlISkpCQYGBjAzM6vp7BAhFJyEfNYYY8jNzYW+vj5V2gghhBBCyqGpqQk9PT1kZWWB2ncUC1XcyGetsLAQxcXF0NTUrOmsEEIIIYTUCrq6uigsLERhYWFNZ4UIoYob+ayVlJQAALW2EUIIIYTIiXtu4p6jiGKgihupEygYCSGEEEKIfOi5STFRxY0QQgghhBBCFBxV3AghhBBCCCFEwVHFjRBCCCGEEEIUHFXcCCFVYv78+RAIBBgxYkRNZ6XahYSEQCAQwMbG5pMcLz4+HoMHD0b9+vWhrKxcZ37n6jRixAgIBALMnz+/prNSoypz3RYUFGDRokVo2rQpNDQ0IBAIaFxMHfXdd99BIBAgODi4prNC/p+7uzu0tLSQlJRU01khVUilpjNAiCLo81doTWfhox2f6FHl+xwxYgR27twJLy8vhISEVPn+ifzevXuHTp06ITU1FUZGRnB1dYWqqiocHBxqOmukCuzYsQOJiYn46quv0KpVq5rOToWMHz8eW7ZsgYqKCpycnKCrq1vTWaqzavI8iomJwdatW9G5c2d07dpVrjRhYWHw8PDAsGHDsGfPHgCl0QuNjIygoaGBlJQUienS09MRHByMmzdv8p93794BABISEsp9mVZSUoI9e/Zg586diImJQXZ2NszMzNC1a1fMmDEDTZo0kZk+Pj4ef/zxB86fP4/Xr1/DyMgInp6e+Omnn+Dq6ioxTUhICDp37ixzv87Ozrh7967Y8tDQUBw9ehQ3b95EQkIC3r59i8LCQpiamqJt27YYOXIk+vTpI3GfixcvRrdu3TBjxgwcOHBA5vFJ7UEVN0JIlTA2NoajoyPMzc1rOiuflf379yM1NRWtWrVCWFgYtLS0ajpLnwVzc3M4OjrC2Ni4RvOxY8cOXL58GTY2NrWq4paRkYEdO3YAAC5fvowOHTrUbIbquJo8j6ZNm4aSkhIsWrRI7jShoaUvSzt16sQvi4mJQUZGBrp16yY1XUhICL7++uuPyueHDx/Qv39/nDp1CgBgZWUFe3t7PH78GNu3b8e+ffsQGBiIvn37Skx//vx59O3bF3l5edDX10fz5s3x7NkzHDx4EEeOHMH27dsxfPhwqcdXV1eXWrmzs7OTuHzHjh3YunUrBAIBTExM4ODggPz8fDx79gxBQUEICgrCoEGDsHfvXrFpj7p27QoPDw8EBgZi8uTJaN++vTw/E1Fw1FWSEFIlJkyYgAcPHuCPP/6o6ax8Vu7duwcA6NatG1XaqtAff/yBBw8eYMKECTWdlVrp4cOHKCoqgomJCVXa6rBbt27h0qVLaNq0KTp27Ch3uqtXrwIAPD09+WVXrlwRW1aWpqYmPDw8MGnSJOzcuRPnzp2T+5gzZszAqVOnoKmpiaNHjyIpKQmRkZFITU3F3Llz8eHDBwwZMgSJiYliad+8eYOvv/4aeXl5GD58OF6+fImoqCi8fPkSM2bMQFFREQICAvDw4UOpx69fvz5CQ0Mlfnbt2iUxja+vL4KCgpCWlobU1FRER0cjLi4Or1+/5rt5BwYGYu3atRLTjxkzBgCwcuVKuX8notio4kYIIQosLy8PAKjSRhQKnZcEAP7++28AgL+/v9xpGGMICwuDsbGxSNfEy5cvAxBthSurR48euHr1KtasWQM/Pz80bdpUrmOmp6djw4YNAIBffvlFpFVNVVUVCxYsQOfOnZGXlydx3Ovy5cuRkZEBW1tbbNmyhT/vVVVVsWTJEnTo0AGFhYVYsGCBXPmR11dffYWvvvoKhoaGIsu1tbUxb9489OzZE0Bp5U2SAQMGQEdHB0ePHsWrV6+qNG+kZlDFjRBSJcoLcpCQkAB/f3+Ym5tDQ0MD9vb2mD59OjIyMmSmDQ0NxcyZM+Hu7g4LCwuoqanB2NgY3bp1w/79+6Xmx9vbGwKBADt27MD79+/x448/ws7ODurq6jAzM8OwYcPw9OlTqelzc3Mxb948ODg4QENDA/Xr18fgwYMRFxcn83fIzs7G77//DldXV+jp6UFNTQ3m5uZwcXHBhAkTcPPmTZnpOVzwDK472oIFC/jgD8IBIISDbGRmZuKXX35BkyZNoKWlBQMDA5F9RkdHY/jw4bCysoK6ujqMjIzg7e2N7du3o7i4WGI+uOMlJiYiOjoa/fv3h6mpKbS1tdGmTRvs27eP3zYrKwtz5syBo6MjNDU1YW5ujnHjxuH9+/dyfWdhwudEQUEBlixZgpYtW0JXVxcCgQDp6en8tjk5OVi+fDnatWsHQ0NDqKurw87ODmPHjkVCQoLM31dacJLCwkJs2rQJnTt3Rr169aCmpoYGDRpg+PDhuHPnjsy83759G6NHj0bjxo2hpaUFfX19ODs7Y9y4cYiIiADwvwA33MPqyJEjRcrX29tbbL/JycmYOnUqnJycoKOjA21tbbRs2RILFy5EVlaW1PwkJSUhICCAv/bs7OwwdepUkd9QXly+ufw9e/ZMJN/c+Vo2gE9gYCD/WwoEAhw9ehRA6fWyd+9eDBs2DE5OTjAwMODzGBAQUO71dvv2bQwYMAAmJibQ1NRE06ZNsWjRInz48EFqGZfN26FDh+Dh4QF9fX0YGhqiR48eiIyM5Ld//PgxAgICYGVlBQ0NDTg4OGDp0qUoKSmRmq+POSc/5p5V0fPoxIkT8PX1hbm5OVRVVWFoaAhHR0cMHDgQW7dulflbl1VYWMhXGPr16yd3utjYWKSnp6NTp078vYwxhtDQUOjr66NFixYVyoc8rl+/jsLCQgDA4MGDJW7DLT9y5Ajy8/NF1nHfMyAgAOrq6iLrBAIBvv/+ewDAf//9h9zc3CrNuyxOTk4ASs83SbS1tdGtWzcUFRXJ/HtJag8a40YIqXZRUVHo2rUrMjIyoKqqCmdnZxQWFmLlypU4fvw4evXqJTXtV199hbS0NBgaGqJ+/fqwsLDAy5cvERwcjODgYJw7dw7bt2+Xmv7Fixdo3bo1nj9/jqZNm6JRo0Z49OgR9u3bh/Pnz+PmzZuwsrISSZOeng4fHx9ER0cDABo3bgxdXV0cPXoUx48fx7x58yQeKycnBx06dEBsbCwEAgHs7OxgZGSEtLQ0xMXF4datW9DR0UGbNm3K/c0cHBzQsWNHxMfH4/Xr17CysoK1tbXU7dPS0tCmTRs8efIEDg4OcHJyQmpqKr9+w4YNmDBhAkpKSqCnp4cWLVrgzZs3uHz5Mi5fvowDBw7g6NGj0NTUlLj/06dPY8qUKdDS0oK9vT2SkpIQHR2NYcOGIS0tDUOHDoWXlxfu378PJycnNGzYEPHx8di4cSNu3LiBa9euQVVVtdzvXVZ+fj68vb1x7do12NnZoWnTpnj8+DG//tGjR+jduzeePHkCJSUlNGjQANbW1oiPj8emTZuwb98+HDt2TGJFSJrU1FT4+voiKioKAoEA5ubmaNiwIR4/foy9e/fi4MGD2LVrl8QHwKVLl+LXX39FSUkJ1NXV0aRJE5SUlCAhIQEbN27Eq1evcPToUejr66Njx46IjY1FZmYmGjduDFNTU34/zZs3F9nvsWPHMHToUOTk5EBNTQ22trYASrvS3rlzB/v378eFCxdgYWEhki4mJgY+Pj549+4dVFRU4OzsjIKCAqxZswYnT56Uee1JwuU7IyMDd+/eFRu3Y2ZmJpZm6tSpWL16NUxNTWFvby/SShcSEoLhw4dDWVkZZmZmsLe358fwbN++Hfv370dQUBDfsiDs5MmT6N+/PwoKCqCpqQlnZ2dkZmZi7ty5OHfunMzrhTNnzhz89ttvsLS0RKNGjfDw4UOcO3cOV69exaVLl8AYQ69evfDhwwc4OTmhpKQE8fHx+Pnnn/Hy5UusWbNGbJ+VPScrcs+qyHm0cOFC/t5lbGyM5s2bo7CwEM+fP8fhw4cRGhqKUaNGlfubcSIiIpCTk4N69erJDJY0f/58iS1RQUFBEqOQCo/V2r59e5VE0E1LS+P/3aBBA4nbcL9pVlYWbt++DXd3dwCl5cFFZpTWjdPLywtA6Qu/27dvSxxPlpmZibFjx+LJkydQUVFBw4YN0a1bN3z11Vdi49PkUVJSwo8VdHNzk7pd+/btERQUhIsXL2LatGkVPg5RMIyQz1heXh6Li4tjeXl5MrfzXXu11n6qg7+/PwPAvLy85E4zb948BoD5+/uLLM/Ly2N2dnYMAPP09GQvX77k192/f581adKEqampSUzLGGObN29mjx8/Flt+/fp11qhRIwaAHTp0SGy9l5cXA8BUVVWZj48Pe/78Ob/uyZMnzNHRkQFgI0aMEEvr5+fHADBTU1MWHh7OL3/79i374osvmKqqKgPAGjZsKJJu9erVDABr1qwZe/Lkici6wsJCdvLkSXby5Emx48nClcW8efNkrldWVmYtW7ZkDx484Nfl5uYyxhi7evUqU1JSYgDYjBkzWH5+Pr/N6dOnmZ6eHgPAfvjhB7H9A+B/x7lz57IPHz4wxhgrKSlhs2fPZgCYnp4e6969O3N3d2cJCQl82oiICKavr88AsG3btlXoe3Pnk7KyMrO2tmYRERH8uvz8fFZcXMyysrJY48aNGQDWt29flpiYyG+Tl5fHpk+fzgAwY2NjlpaWJvF3K/u7FhcXs44dOzIAzMPDg929e5dfV1RUxFasWMGUlJSYhoYGe/jwoUjaXbt2MQBMIBCw2bNns+zsbJH1V65cYZs3bxZZxp2n27dvl/pbxMTEMA0NDQaAzZo1i2VlZfHrXrx4wbp3784AsC5duoiky8/PZw4ODgwAa9++PUtOTubX3b17l9nb2/PnsqRrT5ZLly5JvAbKrldWVmbq6ups586drKSkhF/P3ZMfPHjADh06xDIzM0XS5+XlsbVr1zJlZWVmYmLCn8uclJQUZmBgwACwgQMHsvT0dH7d9evXmZmZGX9fKVvGXN5UVVWZtrY2O3z4ML8uKyuL9ezZkwFgbm5urGHDhmz06NEiv/mmTZv4ci57b6rMOVmZe1Z559Hbt2+ZiooKU1FRYQcOHGDFxcUi6+/fv89WrVolMa00ixcvZgBYz549ZW63c+dO5uPjw3+4+42npye/zMbGhgFgzZs3F9n27NmzMvednJzM36OE7z1lnTx5kt/u0aNHErfhyrXs73jhwgV++YsXLySmLS4u5s+3svc67nyT9nF2dmZxcXEyv6ew9PR0FhERwfr3788AMEtLS5aUlCR1+ytXrvD36bLlLou8z0/k06KukoSQahUYGIinT59CX18fhw8fFok62aRJExw+fBhFRUVS048ePRr29vZiy93d3bF+/XoAkNnipquri4MHD8LS0pJfZmdnh99//x1AaUuGsKSkJD489V9//SXy5rRevXo4cOAAdHR0JB7r/v37fJ7LRglTUVFB79690bt3b6l5rQwlJSUcPXoUjo6O/DKu9WzhwoUoKSmBj48Pli5dKtLVp2fPnli+fDkAYPPmzXjx4oXE/fv4+GDBggVQU1MDUNo9aN68ebCwsEBmZiYuX76MwMBAkXDcbm5u/OD448ePf9T3Ki4uxv79+0XeKKurq0NJSQkbN25EfHw8XF1dcejQITRs2JDfRkNDA8uXL4evry/evn2LLVu2yHW8I0eOICwsDNbW1jh+/DicnZ35dcrKyvjxxx8xbtw45OfnY/Xq1fy6goIC/PzzzwBKgyAsWrQI2traIvvu1KkTRo8eXeHfYNasWcjPz8ekSZPw22+/iZx/FhYWOHToECwsLHDx4kWRLn6HDh3Co0ePoKamhoMHD4q0NDg7O2Pnzp1897HqUlxcjLlz58LPz0+kdUVDQwMA+G56ZacS0NDQwMSJEzFo0CC8efMGJ06cEFm/ceNGpKenw87ODnv27IG+vj6/zt3dHTt27EBBQYHMvBUWFmLOnDno378/v0xHRwd//vknACAyMhI6OjrYuHGjyG/+3XffwdXVFYwxnDx5UixflT0nK3rPkkd8fDyKiorQrFkzDBo0CEpKoo9/TZo0wZQpUyq0T67Lp3A+JfHz8+N7SJw+fRqMMZiZmSEkJIRfzrUMHjhwgF8WHByM7t27VyhP0rRt25b/zgcPHpS4zaFDh/h/c1MMlP23kZGRxLRKSkr8OVi2a7impia+/fZbnD59Gs+ePcOHDx/w/PlzbNiwAfXq1cO9e/fg4+Mjcwza48eP+e6vBgYGcHd3x4kTJzBlyhSJvUaEcdd9ZmamSMsjqZ2o4kYIqVanT58GUDpIWlLodScnp3KjkT18+BC//fYbvv76a3Tp0gUeHh7w8PDAr7/+CgAyx40NGzZM4h9brkL27t07kT/Mp0+fRklJCSwtLTFw4ECxdDo6OlIfvrmHtP/++w+ZmZkyv1NV69q1q8Q5jHJzc3Hp0iUAwPTp0yWmHTlyJExMTFBYWCg1Shs3hkOYiooKPx6lZ8+eIg+pHK4bnXD3xopo2rSp1KiF3LiTUaNGSe2GOWDAAADAhQsX5Doet88hQ4aIjRHkcOeF8D7Dw8Px8uVLqKqq8hW4qpCZmYkzZ84AAMaNGydxGz09PT6EunCeuErFgAEDJHYP69ixI9q2bVtleZWmvO53JSUlOHnyJCZPngxfX194eXnx1zgXfbDsNc7dV0aMGCE25ggoPR/l6Sop6bx2cnLiX3qMHj1aYjc2aed1VZyTFb1nyYO7Nh89eiRSua+MN2/eACh9oSWvsLAwZGVloXv37nxFvqioCCEhIbC0tOTHbFU1ExMTDBs2DADw+++/i4z3KiwsxMyZM0UmDxcep8YF4gHAv7iShHsZUXaMm7u7O3bt2sWfk2pqarC0tMTYsWMRHh4OXV1dvHr1CgsXLpS6b01NTXTs2BEdO3bkx10XFBQgKChI7KVGWcLl8/r1a5nbEsVHY9wIIdWKC48sa26h1q1b8w9oZc2dOxeLFy+WGQhA1ltE4RYoYcJjcbKzs/kHpQcPHgAofXgr+1aaI9wKIywgIAArV67EpUuXYGFhAR8fH3Ts2BHt27eHu7u7zD/6lSUtT48fP+ZbNMuOm+KoqqqiadOmePPmDf/9y2rcuLHE5dx4mvLWZ2dnS8+8DNK+F1AamAIA1q9fz7eSlsUF4EhOTpbreNw+jxw5wo8fKYsLXCC8z9jYWADgA2xUlbt37/KBY2S11j179kwsT1xZNmvWTGo6Z2dn3LhxoyqyKpGxsbHEcW+c169fo0+fPuVWJspe4/LcV1q1asWPTZKWN2llZWJigqSkpAqf11VxTlb0niUPc3NzfPvtt9i9ezfc3d3h6uoKb29vtGvXDp6enjAxMZF7XxyuQsNVWOTBvYTo0aMHv+zatWvIysriK7TV5a+//sL9+/cRFRWFoUOHYtKkSWjQoAEePXqE3Nxc9O7dG7du3cKrV6+gp6fHpxMe91tQUCD1+3L3hYpEWnVwcMC4ceOwbNky/Pvvv1i/fr3EcX+WlpYi96Pc3Fz8/fffmD17NkaPHo2srCypLabC+RWuhJLaiSpuhJBqxUW7E/5DWFbZblKcQ4cOYdGiRRAIBPj1118xcOBA2NnZQVdXF0pKSnj69Cns7e1ldrUs212NI1wpE64UcvmV9bApbZ2ZmRkiIyOxaNEiBAUF4dixY3y3JgMDA4wZMwbz58+vlhDq0r6ncMufrO/EdWGV1lIobf/cQ0Z562VVvGWRtt+cnBy+mx9XaZJF3khvXDen+Ph4xMfHy9xW+CGI+92qstImnB+gtLWiPMLfszLnclWRVn6ckSNHIjIyEtbW1li8eDE6duzIR78ESl/cLFq0SKxLZ2XuK/Lk7WPO66o6Jyt6z5LX1q1b0bJlS2zZsgVRUVGIiori99utWzcsW7asQhEduR4Uslr/Jk6ciFu3bvH/56KErlixgg/Pn5KSAqA0UI2Hhwe/7b///ov69evLnZ/y6OvrIzQ0FOvXr8eBAwcQFxeHhw8fwsHBAQEBAfjuu+/480m4S79wKP60tDSJXUNLSkqQkZEhtr08uB4nb9++xfv37+WqkGtpafHzx82aNQtz587F2LFjJVYqhctHUq8XUrtQxY0QUq24hydZXQelhTLnxq5NmTIFixcvFltfHf31ufwKR2QsS9Y6W1tbbNu2DVu2bMHdu3cRFhaGM2fO4OTJk1i+fDkSExOljrGoDsIPtqmpqVLHo3DjK2Q9CCsSLS0tKCsro7i4GJGRkVXW5U9HRwdv377FwYMH8fXXX8udjvvdPibEfnn5AUof5ivaalnZc7m6paam8l0ejx8/LrHSIO0a19XVRXp6+kfdV6pLdZ2TVUVVVRU//vgjfvzxR7x69Qrh4eH82NSzZ88iMjISd+7ckRp1sSyuUiXrPhwbGyvxhUNMTIzYssTERJHJr8uG5K8K6urqmDp1KqZOnSq27saNG3zFW3hMrfBcc48fP5Z4D01OTubHVApvLw/hnhgVHXP65ZdfYtasWcjKysKjR4/KvYaEI46S2onGuBFCqhXX7YfrQiSJpD/iAPDkyRMAkBo2Ozw8vFJ5k4T7o3v//n2pb7Xv3btX7n6UlJTQokULjBs3Dv/99x/+/fdfAKWtiJ/yYblRo0ZQUSl9RyetFaCwsJDvVifvhLY1TSAQ8N0opXVp/Bjcg09F98mli4uLq1DlTVK3KGHOzs5QUlJCTk6OSMuFPLhzWdb5Ks+5XF2ePn0KxhgMDQ2ltvRIu8blua/IWlcdquuclPfYFWFubo4BAwZg7dq1ePjwIRo2bIj3799j7969cu+Dm9bk7t27UrcJCQkBYwyMMb6SPn78eH5Zbm4u1NTU4OjoyC/jPpLG7FanAwcOAABcXFxExutaWlry4yWvXLkiMS03j56WlhZatmxZoeNy92VNTc0Kt4gJV/SkzcUp3I27Onp7kE+LKm6EkGrFzRN1+PBhiV1qHjx4IPUhh/sjIynaVl5eHv7+++8qzGmpnj17QklJCc+fP8eRI0fE1ufk5FR4olpAtPIpLXJjddDS0kLnzp0BlHZPkmTnzp14/fo1VFVVqyyK26fwzTffAADWrFlTZcFguH1u375d7nFxANChQwdYWFigsLAQy5Ytkzsdd45LG3tibGyMLl26AAAWLVok934B8BFM//33X4nn3LVr16p1fFt5uO+elZUlcQLh8+fPS32pw91Xdu7cKTF65Llz5/hxf59SdZyT8ijvPJLFwMCAHytYkXsTd1+5d++eXK3BXKWnU6dO/LLr16+joKBAZFlNiI+P57tuSgriJHxf+PDhg8g6xhg2bdoEAOjTp0+FKkeZmZl8dORu3bpVeD43rveGtra21Ja+a9euAfhfeZHajSpuhJBqNWjQINjZ2SE9PR0DBw7kxzMApRHO+vfvz7cIlcVVdn7//XeRoBmvXr3CV199hefPn1d5fhs2bIihQ4cCKB2fERERwa979+4dhgwZIrUL1i+//IJ169aJfEegtLI3d+5cAKVdvKQFH6guc+fOhZKSEi5cuICff/5Z5MHj3Llz/IPKd999JzaBsyKbNGkSGjdujGfPnsHHx0didNG4uDjMmTNH7ukIhgwZgg4dOiArKwtdunTBxYsXxbZJSEjAsmXLRMK5q6qq4o8//gAALFmyBPPnzxcbwxQaGioWAr5Ro0YA/tcyIcmyZcugqamJoKAg+Pn5iT1cFxUV4cqVKwgICBBZ980336BRo0YoKCjAoEGDRNbFxcXB39//oyZFryrOzs4wNjZGUVERxo8fL/J7nTt3DoMHD5YaCGLs2LEwMDDA48eP4efnJ1JJioyMxIgRI6o1GJA01XFOyqO88yg4OBiTJ09GVFSU2PozZ87wERUr0r3T3NwcrVu3RklJidTgUsK4ipvwJNZcOmkTW1el+Ph47N+/X+Q8Y4zh3Llz8PHxQV5eHvr164chQ4aIpf3pp5+gp6eHhIQEjB49mt9HYWEhfv75Z4SHh0NFRYWf4FxYnz59cOHCBbEWsdjYWHTv3h2JiYlQU1MTS/vixQtMnDgR0dHRYmWWnp6OhQsX8i+JJkyYIBJERVhISAgA4IsvvijnFyK1AVXcCCFShYWFwdjYWOanvLfKGhoaOHDgAPT09HDp0iVYW1vDxcUFzZs3R5MmTVBUVMSHOS/7tnHGjBkwNzdHUlISmjVrBicnJ7Rq1QrW1ta4cuUK1q1bVy3fe+3atWjZsiVSUlLQrl07ODo6ok2bNrCwsMCFCxfw22+/SUx3//59TJgwAebm5rCysoKbmxtatmwJMzMz/PXXX1BRUcGmTZvKDdhQ1Tw8PPDXX39BSUkJS5cuhampKdzc3GBra4sePXogIyMD3bt35+dzqy10dXVx5swZNGvWDFFRUXB1dUWDBg3Qrl07uLi4wNDQEM7Ozvjtt9/kHg+ppKSE//77D56ennj8+DF8fHz438vV1RVmZmaws7PDzJkzxV4c+Pn58a1iCxYsQL169dC6dWu0aNECenp66NSpk1jo7mHDhkFJSQkHDx6EtbU1OnXqBG9vb5EIca1bt8aRI0dgaGiI3bt3w8rKCg4ODmjfvj2aNWsGXV1deHl5Yfv27SJdp9TV1REYGAgDAwOEhYXBxsYGrVu3RrNmzfhIk9KmGPgUVFRU+HNu586dMDc3h6urKxo2bIgePXrA2toaEyZMkJjWzMwMu3fvhpqaGgIDA2Fubo62bdvC0dER7u7usLOz46MUVrQVozKq45yUR3nnUXZ2NtauXYu2bdtCX18frVq1gpubGywsLNCrVy/k5OTgyy+/5EPmy4s7f3bv3i1zu7y8PNy4cQP29vYigT8ktcKVR/jvj3AXWxcXF365i4uLWLoXL15g6NChMDAwQKNGjeDm5ob69eujR48eSE5ORv/+/UWmCRBmamqKgwcPQkNDA3v27IGFhQVcXV1hYWGBZcuWQVlZGVu2bJHY1fzEiRPo2rUrdHV10bx5c7Rv3x62trZo0aIFIiIioKOjg/3794vlubCwEH///TfatGkDfX19tGzZEu3bt0fTpk1hYmKCefPmoaSkBAEBAVL/JsXGxuLOnTuwsbERieRJai+quBFCpCoqKkJaWprMjzzRzdq2bYtbt27h22+/hZGREd+1ZvLkyYiMjORb3MoGxjA3N0dERAT8/f1hbGyMx48f4/Xr1xg4cCAiIyP5LmRVzdDQEKGhoZg9ezYaNWqExMREPH/+HH379sWNGzdEBq4LmzNnDubMmQNPT08IBALExsbi4cOHMDc3R0BAAKKjoyW+zf0UfvjhB0RGRmLo0KHQ1dVFTEwM0tPT4enpia1bt+LUqVNS39gqMjs7O0RFRWHTpk3o2rUrCgoKEB0djRcvXsDGxgajRo3CsWPHMHjwYLn3aWxsjIsXL+LAgQPw9fWFsrIyYmJikJiYCDMzMwwdOhQHDhzAtGnTxNLOnj0bN27cwLfffgszMzPExcUhOTkZ1tbW+OGHHzBr1iyR7d3c3HD06FF4e3sjOzubDxhRtotgz5498fDhQ8ybNw+urq54/fo1oqOjkZGRgVatWmHmzJkIDw8Xm0vPxcUFt27dgr+/P+rVq4e4uDjk5ORg0qRJiIyMrHAEvKo2YsQIHD9+HB4eHigqKsL9+/eho6ODuXPnIjw8XOZLDl9fX0RERKBfv37Q0NBAbGwsPzH8hQsX+C6UnzrgTnWck+Up7zzq1KkT1q1bh4EDB8Lc3ByJiYm4desWiouL0b17d+zevRtBQUFSp0CRZtiwYTAwMMDRo0f5qIqScF0ihVvWioqKcP36dVhZWVVoPJvw3x/hqKvv37/nl0vqlu/g4IBJkyahefPmSE9PR0xMDJSVldGvXz8cP34chw8fljgnIKdHjx6IiYmBv78/dHR0EBsbC2VlZQwcOBDXrl2Dv7+/xHSrVq3C4MGDYWNjg1evXiEqKgrv3r1DmzZt8Msvv+D+/fsik8Bz6tevjy1btuDbb7+FtbU1Xr58iRs3buD58+dwdHTE6NGjERoaiq1bt0rttbJz504ApRXsipYtUUwCJq1vBiGfgfz8fCQkJMDW1rZCc82QT+uLL77AqVOnsHbtWkycOLGms0PqAD8/P+zevRuLFi3C7Nmzazo7pBo4OzsjLi4Ox44dQ58+fWo6O5+tZcuWYebMmfjtt9/EXkyQmvP+/XvY2dlBU1MTjx494iPUyouenxQTVb8JITUqISEB58+fB/BpxjkQAvxvfrSKTGJMao+wsDDExcVBVVUV7du3r+nsfNamTJkCe3t7rFixQqQFjNSsZcuWIT09HX/88UeFK21EcVHFjRBS7W7evIlNmzaJjYeLjo6Gr68vCgsL4eXlVeEwyoR8jJcvX/JzS0kaC0Nqh3PnzmH//v1ikRQvXLjARwEcOnQoTTpczdTU1LBr1y5MnjwZT58+renskP9Xr149LF26FH5+fjWdFVKFqKsk+axRU79iOHPmDHr16gUlJSVYWlrC3NwcKSkpSEpKAlAayfHSpUuwtbWt4ZySz9mtW7cwZswYPHjwADk5OXB1dUVkZGSF58AiimHjxo0YN24cVFRUYG1tDWNjYyQlJfFRXVu1aoULFy5QqyohH4GenxQTtbgRQqpdy5YtMXPmTLi4uODDhw+4desW3r9/j9atW2PevHm4desWVdpItcvIyEB0dDS0tbXh7++PkydPUqWtFuvSpQsmTZoEJycnZGZmIjo6Gvn5+WjXrh1WrFiBsLAwqrQRQj4r1OJGPmv0xogQQgghpGLo+UkxUYsbIYQQQgghhCg4qrgRQgghhBBCiIKjihshhBBCCCGEKDiquBFCCCGEEEKIgqOKGyGEEEIIIYQoOKq4EUIIIYQQQoiCo4obIYQQQgghhCg4qrgRQgghhBBCiIKjihshhBBCCCGEKDiquBFCCCGEEEKIgqOKGyGEEEIIIYQoOKq4EUJILTVixAgIBALMnz+/prPyWbGxsYFAIEBISIjI8h07dkAgEMDb27vKj+nt7Q2BQIAdO3aILE9MTIRAIIBAIKjyYyoiab99dfruu+8gEAgQHBz8yY5JZHN3d4eWlhaSkpJqOiuEKBSVms4AIQphk1dN5+DjfX+5Wnf/5s0bbNmyBefPn8eDBw+QlpYGNTU1WFhYwM3NDf3794evry9UVVWrNR+ycBWXKVOmwMDAoMbyUVGJiYmwtbUFAFy6dElihYAxhqlTp2LNmjUQCARYvXo1Jk2aVK35srGxwbNnz8rdjjFWrfmoClyFZ/v27RgxYkTNZoYonJiYGGzduhWdO3dG165d5UoTFhYGDw8PDBs2DHv27AEAlJSUwMjICBoaGkhJSZGY7smTJ/jvv/8QEhKC27dvIyUlBSoqKmjYsCF8fHwwefJkNGrUSGLa9PR0BAcH4+bNm/zn3bt3AICEhATY2NjIlfcnT55g7dq1OHfuHJKTkyEQCFC/fn24urpi5MiR6N69e5Uet6SkBLt27cKePXtw+/ZtpKenQ1NTEw4ODujTpw8mT54s8Z69ePFidOvWDTNmzMCBAwfk+m6E1AVUcSOESPX333/j559/Rk5ODgDAzMwMzZs3R2FhIZKSkrBnzx7s2bMH9vb2OHv2LOzt7WsknwsWLABQ2gJVmypu5SkuLsaoUaOwc+dOqKioYNu2bfj222/59ebm5nB0dISxsXG1HN/KygrW1tbVsm9FZm9vDw0NDWhpadV0VqCqqgpHR8eazsZna9q0aSgpKcGiRYvkThMaGgoA6NSpE78sJiYGGRkZ6Natm8Q0xcXFIpWyevXqoVmzZsjIyMCjR49w//59bNmyBdu2bcOQIUPE0oeEhODrr7+WO4+S/PPPP5g0aRI+fPgAbW1tPj8vXrzAgQMHoK2tLVZxq8xxP3z4gD59+uD8+fMAACMjI7Ro0QJpaWmIjo7GzZs3sWXLFly6dEmswtq1a1d4eHggMDAQkydPRvv27T8qD4R8bqjiRgiR6Oeff8bSpUsBAIMHD8asWbPQrFkzfn1JSQmuXbuGlStXIigoCMnJyTVWcfscffjwAYMHD8bRo0ehoaGBwMBAfPnllyLb/PHHH/jjjz+qLQ8BAQF1shvmhQsXajoLPEtLSzx48KCms/FZunXrFi5duoSmTZuiY8eOcqe7evUqAMDT05NfduXKFbFlwhhj0NHRwZgxY+Dn54eWLVvyrcEJCQkICAhASEgI/P390apVKzRt2lQkvaamJjw8PODi4oI2bdrA3NxcrJIly549e/D9999DW1sb69atg5+fn0gviUePHuHNmzdi6Spz3JUrV/KVtr/++gvjxo2DsrIyACA6OhoDBgxAYmIivvvuO1y8eFEs/ZgxYxAaGoqVK1fi0KFDcn9XQj5nVHEjhIj577//+ErbggULMHfuXLFtlJSU0LFjR3Ts2BEnTpyAvr7+p87mZys7Oxt9+/bFxYsXoaenh2PHjsHLqxZ35yVEAf39998AAH9/f7nTMMYQFhYGY2NjNGnShF9++XJpl3XhVjhhysrKSExMRL169cTW2dra4siRI3BwcMDbt2+xefNmrFy5UmSbHj16oEePHvz/nz9/LneeX79+jQkTJkAgEODIkSMSK14ODg5wcHAQW16Z4wYFBQEA+vbtiwkTJoisc3FxwerVq/HVV18hJCQEWVlZ0NXVFdlmwIABGD9+PI4ePYpXr17B3Nxc7mMT8rmi4CSEEBGMMcyaNQsA4OHhgTlz5pSbxtfXF61bt+b/P3/+fAgEApljiqQFYwBKuyJ98803sLKygpqaGvT09NCoUSP4+vrizz//RElJichxOLa2tnwgB0lBO4qLi7F161Z4e3vDyMgI6urqsLa2xvDhw3Hr1i2J+RQOSMEYw8aNG9GmTRvo6OjAxMQEAwcOxMOHD/nto6Oj8fXXX8Pc3BwaGhpo0aIFtm7dWu5vyElLS4OPjw8uXrwIExMTXLp0SWqlTVpwkrIBLcLCwtCnTx8YGxtDQ0MDTk5O+P3331FUVCR3vqQJCQmBQCDgx7oEBgaic+fOqFevHgQCAY4ePQqgtDK6d+9eDBs2DE5OTjAwMICGhgbs7OwQEBCAuLg4mce5ffs2BgwYABMTE2hqaqJp06ZYtGgRPnz4UOVBWuQJkFFSUoK1a9eidevW0NbWhoGBAbp164Zz585VSR445QUnKSwsxPLly9GsWTNoamrCxMQEX375JSIiImSmff78Of766y/07t0bjRo1gpaWFnR1ddGiRQvMmjULaWlpEo9XNkDLrl270L59e+jq6kJHRwcdOnTAv//+K/M7HTt2DN7e3tDT04Oenh7atWuHXbt2lftbnDhxAr6+vjA3N4eqqioMDQ3h6OiIgQMHVugaA0p/t8DAQABAv3795E4XGxuL9PR0dOrUif9dGWMIDQ2Fvr4+WrRoITGdQCCQWGnjGBoa8t0B79+/L3d+5LFp0yZkZGSge/fuFWqlq6zc3FwAkDpuj6soMsYk3ou0tbXRrVs3FBUVYf/+/dWXUUJqEaq4EUJEREdH4969ewCAyZMnf/Jodjt37oSnpycOHTqErKwsNG3aFPb29sjIyMDJkycxffp0FBQUAACsra1Fuji5urryrYAdO3YUGZ+Vk5ODHj16YPTo0bh8+TL09PTQokULpKenY+/evWjbti3++ecfmXnz9/fHuHHjkJ6ejkaNGiErKwuHDx+Gh4cHnj59iv/++w8dOnTA+fPnYWlpCT09PcTGxmL06NFYtWpVud/95cuX8PT0RGRkJKytrXH16lW4uLh85C9ZaufOnfDy8kJoaChsbW1hZGSE+/fvY9asWRg+fHil9l3W1KlTMXjwYMTFxcHe3h4NGjTg14WEhGD48OEIDAxERkYG7O3tYW9vj9evX2P79u1o06YNzpw5I3G/J0+ehJubG44cOYKcnBw4OzujuLgYc+fORdeuXVFYWFil30MegwcPxuTJk/HmzRs4OTnxUQl79OghV1lXhfz8fPTs2RMzZszAvXv3UL9+fdjY2CAkJAQeHh44duyY1LRckJtLly6huLgYzZo1Q/369fHgwQP8/vvvcHFxKTei35gxY+Dv74/k5GQ4OjpCWVkZ165dw9dff40NGzZITLNw4UL07dsXly9f5sfvJSYmwt/fH9OnT5d6rIULF6JPnz44efIkioqK0Lx5czRo0ACvX7/G4cOH+ZdN8oqIiEBOTg7q1asnsaWJw70c4j4tW7YEUNqaxC1TUlLC27dvkZGRAWVlZX65pJdSsuTn5wMorbBUpSNHjgAoraCmpqZi8eLF+PLLL9GtWzeMHj0aQUFB1RJoiLt3hYeHS9w/173U0dERhoaGEvfBVWYldaUkpC6iihshRAQ3fgMAOnfu/EmPXVxcjOnTp4MxhlWrVuHNmze4ffs2bt26hTdv3uDZs2dYunQpP04iICCADxQAAIcOHUJoaCj/CQgI4NdNnToVFy5cgJGREYKDg5GYmIgbN27g9evXmDhxIoqLi/HDDz/g+vXrEvMWHh6Os2fP4sqVK3jy5AliYmKQlJQEFxcXvH37FmPHjoW/vz9mzJiB169fIyoqCqmpqfj1118BAHPmzEFWVpbU7/7kyRN07NgRcXFxaNKkCUJDQ6skKMX333+PJUuW4M2bN7hx4wZevnyJ3bt3QyAQIDAwkO/iVVnPnz/Hhg0bsHPnTqSkpCAyMhLJycno2bMnAKBx48Y4dOgQ3r9/jxcvXuDmzZu4d+8e3r59i7Vr16KwsBB+fn7Iy8sT2W9qaiqGDx+OgoICDBw4EK9evUJUVBQePXqE69evIz4+vtwWnqoWHh6O48eP4+DBg3j+/Dlu3LiB1NRU/PzzzwCA6dOn49q1a9Wej4ULF+LixYvQ1dXF6dOnkZCQwOdlzJgx+Omnn6Sm7dWrFy5evIisrCwkJCQgMjIS8fHxeP78OQICApCUlIQffvhBavrw8HAcPnwYp06dwvPnzxEVFYW3b99i3LhxAICZM2ciOztbJM2lS5cwb948AKUVotTUVNy4cQOvXr3Chg0bsHr1arx48ULsWGlpaVi0aBFUVFRw4MABpKamIjo6GrGxsXj//j3u37/P//by4ioNbdu2lbmdnZ0dfHx8+I+enh6A0rFs3DKutbl58+Yi21pYWMidn+TkZL6Ftyq7Refl5SE2NhYAkJmZCScnJ8yePRvHjx9HcHAwtm7div79+8PT0xNv376tsuMCwOzZs2FgYIBr167Bz88Pd+/eRV5eHl6+fIn169dj+vTp0NDQ4LusStKuXTsApX+XuJ4WhNRlVHEjhIhITk4GAOjr68vs2lMd3rx5g7dv38LAwABTpkwRm2LA2toaM2bMqPDUA0lJSdi2bRsAYM2aNfDx8eHXaWhoYO3atejQoQOKi4uxcOFCifsoLCzE2rVrRcawmJqa8tHozp8/j/bt22PhwoVQU1MDAL77nrm5OXJycnDp0iWpeRw7diwSExPh4uKCq1evwsrKqkLfUZohQ4Zg+vTpUFH535Dm4cOHw9fXFwBktsosWLBApLVB+FO2GyHXAubn5yfSSquhoQEAfJe2suNYNDQ0MHHiRAwaNAhv3rzBiRMnRNZv3LgR6enpsLOzw549e0TGUrq7u2PHjh18C+ynUlhYiF9//VUk2p6amhr++OMPdO7cGSUlJVi8eHG15iE7O5t/4F25ciVfQQZKA0qsW7dOZmutj48POnfuLHJeAKXn9JYtW2BpaYlTp04hNTVVYvrCwkKsWrUKvXr14pepqqpi5cqVMDExQVZWltj5zv0mvXr1wrx58/hjCwQCjB07FgEBARK7zMXHx6OoqAjNmjXDoEGDoKQk+ujSpEkTTJkyRep3lSQhIQFAafAXWfz8/BAcHIzg4GCcPn0ajDGYmZkhJCSEX968eXMAwIEDB/hlwcHBcndLZIxh7NixKCwshIWFhcgLp8p6/fo1iouLAQCzZs2CkpIS9u/fj6ysLKSnp2P79u3Q1dVFaGgoBg0aVGXHBUq7QkZGRmLQoEE4ePAgmjdvDi0tLVhaWmL8+PHo2rUrIiIiZE7DwLXaZ2ZmSu2+S0hdQhU3QoiIzMxMAICOjs4nP7apqSk0NTWRnp6O48ePV9l+z5w5g+LiYlhYWEgMtQ0AM2bMAFAaUfDDhw9i6w0MDCQ+2LRp04b/9/fffy+2XlVVle9e9fjx43LzmpaWJtZSURkTJ06UuJzrghQfHy81rZWVlUjXU+GPpGA0o0aNkpmXkpISnDx5EpMnT4avry+8vLzg4eEBDw8PvqX35s2bImlOnz4NoHQ8n7q6utg+e/bs+cmnLFBRUZH6u06bNg1AaUVe0nlUVUJDQ5GVlQUtLS2JXV4FAgHGjBkjcx/Z2dnYvn07Ro0ahZ49e6JTp07w8PBAp06dkJWVBcaY1LGfenp68PPzE1uuoaHBj3cVPrdyc3P51l1plSxpyxs2bAigNPJhZGSkzO8kLy6CYkVeToWFhSErKwvdu3fnX04UFRUhJCQElpaWcHJy+qi8zJ49G6dOnYKSkhJ27dpVpV0lhVv5CwsLsWfPHgwePBg6OjrQ19fHiBEjsHnzZgCl3RGreozm8+fPkZKSgsLCQujr66N169awsrKCQCDAuXPnsGHDBrFWdmHC5fP69esqzRshtRFFlSSEiOC6AlVl5UFeSkpKmD59OhYtWoQvv/wSTk5O6NKlC9q1awdPT8+PboXiwqk7OTnx3SzL4oIKFBQU4OnTp2LhuKUNsDc1NeX/3bhxY5nbyPpN//rrLyxcuBDPnj2Dl5cXQkJC+Mm5K0Nad0szM7Ny81SR6QCMjY35fUry+vVr9OnTp9wH77Jv1bnAL61atZKaplWrVuWOx6pKDRo0kDpfIDdlRkFBAZ48efLRD/Pl4X6XJk2a8K2aZQkHDCrr2rVrGDBgAF69eiXzONJaORwcHKSOf5V0bnGtZgBEphUR5ujoCBUVFbFWN3Nzc3z77bfYvXs33N3d4erqCm9vb/6+YGJiIvM7SMJVFqT9dpJwYzCFoyxeu3YNWVlZGDBgQIXzAAB//vknfv/9dwgEAmzcuFGkN0BV0NTU5P/dsmVLkbxzvvnmG/z8889ITEzEyZMnqyyAyb///ovBgwdDWVkZmzdvxsiRI/nW0jt37sDPzw8bN25EXFwcH+SoLOHykVXBI6SuoBY3QogIrmtKRkZGjXRNWbBgAbZu3QoXFxfcv38ff//9N4YPHw5ra2t06NDho8Zkca2I9evXl7qNcKhpbnth0t6CCz9slLeNrDEaTZo0QUhICCwsLJCUlAQvLy88ffpU6vbykpYn7gGqqsaNlNdKMHLkSD7oyu7du/H06VPk5eWBMQbGGB+9tGygEa7FgHuhIEnZ7pfVTdZ5JLxO1pjGyqrM75KVlYV+/frh1atX8PT0xOnTp/Hq1St8+PCBLw+uS7C0wC+yylvSuSX8Wwi/7BCmrKwstQVs69atWLFiBZo0aYKoqCisWLECAwcORP369dGzZ0/cuXNHan4k4Satf/fundRtJk6cyLcIe3h48MGLVqxYwS8bOXIkAPABYbhPSkpKuXlYvXo1pk+fDoFAgPXr15fbQvoxjIyM+H9LqzALBAL+BUNV3HOA0vNm0qRJKC4uxq+//opRo0aJdHFt0aIFDh8+DGVlZVy5coUPoFKWcPlwZUZIXUYtboQQEcITyF68eFFkHI+8hMNkSyNtXJJAIEBAQAACAgLw7t07hIeH4+rVqzh48CCuXbuG7t274/r16zJbE8riHm5lPUwJtzzIehiuTg4ODggJCUHnzp2RnJzMt7zV9onNU1NT+S6Px48flxgyXdpLAl1dXaSnp0usTHOqs4IkibRxX2XXVWeFktv3x/wup0+fRmpqKho0aIDTp09DS0tLbJuqfmkj/Fu8fv1aYuCO4uJiqcdVVVXFjz/+iB9//BGvXr1CeHg4Ll++jMDAQJw9exaRkZG4c+eOSCRTWbgKtqzvGRsbi7CwMLHlMTExYssSExORmJjI/5+LECnN6tWrMXXqVADAunXrMHbsWDlyXXGGhoYwMzNDamqqxK7GHG5dVUwRApR2C+fuqcLjIIXZ29ujcePGePDgAa5fvy6x1VK4fKRV+AmpS6jFjRAiwsXFhX/7umbNmo8KE829jZf1gPvkyZNy92NkZARfX18sXboUDx8+hJubGwoKCsoN218WN1FuXFwcP1C/LC7ympqaGuzs7Cq0/6rUuHFjhISEoEGDBnj+/Dm8vLxkjkOrDZ4+fQrGGAwNDaXOcxUeHi5xOdfV8/bt21L3L2tddUhOTkZGRobEdXfv3gVQeh5VZ4Wb+10ePHggdSydpAoG8L9rr23bthIrbe/evROZm7AqNG7cmO+mzE03UtbDhw/lqjiYm5tjwIABWLt2LR4+fIiGDRvi/fv32Lt3r9z54camcuUlSUhICN8Cyb14GD9+PL8sNzcXampqcHR05JdxHy7SpCRr1qwRqbRxkTiri4eHBwDZY2y5c6KqgiLJeqEgibRukNx92cnJSeK5SkhdQxU3QogIgUCA3377DUDpYHzu37KcPHlS5CGRmxcpOjpa4pvnoKCgCg80V1NT4wNqlA0Zzv1Bl/bHv1evXlBWVsbLly+lTuS6bNkyAEDXrl1lvpn+FBo1aoTLly/DysoKL168gLe3Nx49elSjeaoMrnyysrKQk5Mjtv78+fNSKxnc2/qdO3dKbKU9d+4cnj17VnWZlUNRUZHUEObcHG7VfR55eHhAV1cXubm52Ldvn8RttmzZInE5Vx7Sxrf9+eefUl9wfCwtLS0+zP2aNWskbiNtuSwGBgb8+EdJUwlIw011cu/ePbnG83LTBwhHlb1+/ToKCgpElpXnr7/+wpQpUyAQCLBu3TqZUy5UlaFDhwIovZ9Lmuj++vXrfFfTqhrf1rhxY75r5KlTpyRuEx8fz7+UKjummMNNq/Gpp6YhRFFRxY0QIqZfv378ZLhz587FkCFDxN6Sl5SUICIiAoMGDUKfPn2Qnp7Or+vSpQt0dHTw5s0bTJs2TeQt+unTpzFq1Cg+ZL6wuLg4jBw5EpcvXxZ7cLxx4wYCAwMBiM+9xAUOkTZJq5WVFR/xcPLkybhw4QK/Lj8/H9OmTUNYWBiUlZX5sVY1zc7ODpcvX0bDhg3x8uVLeHt7V3kryKfi7OwMY2NjFBUVYfz48cjNzeXXnTt3DoMHD5YaJGLs2LEwMDDA48eP4efnJ/ImPzIyEiNGjJB4LlUnVVVVLF68WGRcTmFhIWbPno0LFy5ASUmJn7+vuujo6GDChAkASqMxCkcDzM/Px8SJExEVFSUxrbe3N4DSB/YNGzbwrepFRUVYtWoVlixZUqGgHfLifpOTJ09i8eLF/DXOGMM///yDrVu3ik1PAADBwcGYPHkyoqKixHoAnDlzBsHBwQDKn5NNmLm5OVq3bo2SkhKRuSul4Spuwl3JuXTCy2TZsGEDJk2a9EkrbUDp/dzNzQ3FxcX49ttvRV50xMfH89MPNG/eHP369auSYxoZGaFv374AgD/++APbtm0TGfMYExODAQMGoLi4GLq6ulK75HPTjnzxxRdVki9CajuquBFCJFq+fDlWrVoFLS0tHDhwAM2aNYO5uTlcXV3RqlUrGBsbo127djh48CAaNWokEpJdR0eHb8HasGEDjI2N4erqCisrK/Tu3RsDBw7kW8+EFRQUYMeOHfD29oauri6aN28Od3d32NjYwM3NDSkpKXBzc+NDrnO4sOQTJkyAk5MTvLy84O3tjR07dvDbrFy5El26dMG7d+/QtWtX2Nraws3NDWZmZli1ahWUlZWxfv16fsJXRWBra4uQkBDY2Njg1atX8Pb25iNk1iYqKipYvnw5gNKWM+48atiwIXr06AFra2u+ElKWmZkZdu/eDTU1NQQGBsLc3Bxt27aFo6Mj3N3dYWdnx4+NkRYxFCgNNGFsbCz1Iym0vTQdOnSAr68vBgwYACsrK7i5ucHU1JSfp2zJkiXo2LGj3Pv7WHPnzkXnzp2RmZmJHj16wM7Ojj+nN27cyF+DZec9a9myJUaMGAEA+OGHH2BhYYG2bdvCzMwM06ZNw6hRo+Du7l7l+fXx8cHcuXMBlIbANzMzg5ubGywsLPD9999jypQpEudVy87Oxtq1a9G2bVvo6+ujVatWfLpevXohJycHX375JYYNG1ah/HBdFHfv3i1zu7y8PNy4cQP29vYiQYwktcJJ8/LlS4wfPx5AaVfyvXv3igQzEf5Im2pC+HwV7nLs4uLCL5c0d59AIMDhw4dhb2+P6Oho2Nvbo1WrVmjRogWaNGmC+/fvw9bWFkFBQRKvoY897oYNG+Ds7IyCggKMGjUKRkZGcHFxgbW1NVxcXBAbGwstLS3s27dP4vi12NhY3LlzBzY2NhKjYRJSF1HFjRAi1ZQpU5CQkIDFixfzb+ljY2MRHx8PY2NjDB06FIcPH0ZcXJzYuLBx48bh33//Rfv27VFUVIQHDx7AwsICO3bskDpGzcHBAVu3bsXw4cNhY2ODly9f4ubNm8jKyoKnpyf+/vtvXL16VSyi3dSpU7FixQq0bNkSz549w5UrV3D58mWRYAHa2to4e/YsNm/eDE9PT7x//x4xMTHQ09PDsGHDEBkZie+++65Kf7+qYGNjw08NkJKSAm9vb4ndnRTdiBEjcPz4cXh4eKCoqAj379+Hjo4O5s6di/DwcJlRCn19fREREYF+/fpBQ0MDsbGxEAgEmDdvHi5cuMB3oZQVVCY7OxtpaWlSPxUdk3PgwAGsWbMGxsbGuHfvHkpKSuDj44MzZ87gp59+qtC+PpaGhgbOnDmDpUuXwsnJCS9fvsTTp0/RqVMnXL58mQ8tL+l32bp1K/788084OTnh3bt3iI+PR5MmTbBt27YKjyGtiAULFiAoKAidOnXChw8fcP/+fVhbW2PHjh1YsWKFxDSdOnXCunXrMHDgQJibmyMxMRG3bt1CcXExunfvjt27dyMoKEisglqeYcOGwcDAAEePHpU6ZhH4X5dI4Za1oqIiXL9+HVZWVjLHs3EKCgr41sLs7GyEhYVJ/XDjusoSPl/fv3/PL3///j2/XFqUzAYNGiAmJgYLFiyAk5MTHj9+jMePH8PZ2Rnz5s3jK3RVeVwzMzNERUVh7dq18PLygoqKCmJjY/Hu3Ts4Oztj8uTJiI2Nha+vr8Tj7ty5E0Dp35KKli0hnysB+5jIA4TUEvn5+UhISICtrW21dP0hhNQ8Z2dnxMXF4dixY+jTp09NZ0dhHDp0CN988w1cXFzEJjYnpZYtW4aZM2fit99+w6xZs2o6O+T/vX//HnZ2dtDU1MSjR4+go6NT01mqc+j5STHRKwxCCCG1FhdwQVVVVWL327qMaznjgoIQcVOmTIG9vT1WrFgh0ppEatayZcuQnp6OP/74gypthAihihshhBCFdu7cOezfv18sauiFCxfwzTffACiNnFcXJ+idN2+e2LjH9+/fY9y4cQgODoaamhq+//77Gsqd4lNTU8OuXbswefLkKpt8mlRevXr1sHTp0gqNPSWkLqCukuSzRk39hNR+GzduxLhx46CiogJra2sYGxsjKSmJn1C9VatWuHDhAoyMjGo4p59e/fr1kZqaCgMDA9ja2vLjSQsLC6GkpISNGzdizJgxNZ1NQkgtQ89Piola3AghhCi0Ll26YNKkSXByckJmZiY/P2C7du2wYsUKhIWF1clKGwAsWrQIvXv3hq6uLh4+fIhHjx7B3Nwcw4cPR0REBFXaCCHkM0ItbuSzRm+MCCGEEEIqhp6fFBO1uBFCCCGEEEKIgqOKGyGEEEIIIYQoOKq4EUIIIYQQQoiCo4obqRNoKCchhBBCiHzouUkxUcWNfNaUlEpP8eLi4hrOCSGEEEJI7cA9N3HPUUQxUGmQz5qqqiqUlZXFJu4lhBBCCCGSZWVlQVVVFaqqqjWdFSKEKm7ksyYQCKClpYWMjAxqdSOEEEIIKUdeXh4yMzOhq6sLgUBQ09khQmgeN/LZKygoQGJiIlRUVGBkZAR1dXW6ERFCCCGE/D/GGIqLi5GVlYXMzEyoq6vDysoKysrKNZ01IoQqbqROyM3Nxdu3b5GTk1PTWSGEEEIIUUiqqqrQ1dWFsbExVdoUEFXcSJ1SVFSEoqKims4GIYQQQohCUVJSgqqqKvVKUmBUcSOEEEIIIYQQBUfBSQghhBBCCCFEwVHFjRBCCCGEEEIUHFXcCCGEEEIIIUTBUcWNEEIIIYQQQhQcVdwIIYQQQgghRMFRxY0QQgghhBBCFBxV3AghhBBCCCFEwf0fARaVU/tuFXYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Code taken from KinFragLib Notebook 4.2\n", + "ax = bar_data_subset.plot(\n", + " kind='bar',\n", + " width=0.85,\n", + " rot=0,\n", + " figsize=(10, 7),\n", + " color=['tab:blue', 'tab:orange'], \n", + " alpha=0.8\n", + ")\n", + "\n", + "# Edit labels for y axis and x/y ticks\n", + "plt.ylabel('# Molecules [%]', fontsize=17)\n", + "plt.xticks(range(7), ['MW\\n'+r'$\\leq 500$', 'HBA\\n'+r'$\\leq 10$', 'HBD\\n'+r'$\\leq 5$', 'NROT\\n'+r'$\\leq 10$', 'TPSA\\n'+r'$\\leq 140$', 'logP\\n'+r'$\\leq 5$' , 'Rule of\\n 5 & Veber'], fontsize=17)\n", + "plt.yticks(fontsize=17)\n", + "plt.legend(fontsize=17, loc='upper left')\n", + "legend = plt.legend(loc='upper center', \n", + " bbox_to_anchor=(0.5,-.1),\n", + " fontsize=17\n", + " )\n", + "\n", + "# Add percentages to bars\n", + "bars = ax.patches\n", + "bar_labels = bar_data_subset.transpose().values.flatten()\n", + "for bar, label in zip(bars, bar_labels):\n", + " \n", + " plt.text(\n", + " bar.get_x() + bar.get_width() / 2, \n", + " bar.get_height() - 6,\n", + " round(label, 1), \n", + " ha='center', \n", + " va='center', \n", + " fontsize=15,\n", + " color='white',\n", + " rotation=90\n", + " )\n", + "\n", + "plt.savefig(\"figures/ruleof5_molecules.pdf\", bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "# calculate QED score for all molecules \n", + "qed_mols = [QED.qed(mol) for mol in sampled_mols_custom]\n", + "qed_refs = [QED.qed(mol) for mol in sampled_mols]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins = np.linspace(0, 1, 100)\n", + "plt.hist(qed_refs, bins, alpha=0.5, label='Rejected ligands', color=\"tab:blue\")\n", + "plt.hist(qed_mols, bins, alpha=0.5, label='CustomKinFragLib', color=\"tab:orange\")\n", + "plt.axvline(np.mean(qed_mols), color=\"tab:orange\")\n", + "plt.axvline(np.mean(qed_refs), color=\"tab:blue\")\n", + "plt.legend(loc='upper right')\n", + "plt.xlabel(\"QED Score\")\n", + "plt.ylabel(\"# Molecules\")\n", + "plt.savefig(\"figures/qed_distribution_molecules.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 6.2 Synthesizability \n", + "\n", + "We calculate the SYBA score and compare the molecules to the Enamine REAL Space, by extracting the most similar molecule and analyzing how similar our chemical space is to the commercial library. " + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "syba = SybaClassifier() # loading the classifier to calculate the SYBA score\n", + "syba.fitDefaultScore() # fit the classifier to the default score\n", + "\n", + "syba_mols = [syba.predict(mol=mol) for mol in sampled_mols_custom]\n", + "syba_refs = [syba.predict(mol=mol) for mol in sampled_mols]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins = np.linspace(-100, 250, 100)\n", + "\n", + "plt.hist(syba_refs, bins, alpha=0.5, label='Rejected ligands', color=\"tab:blue\")\n", + "plt.hist(syba_mols, bins, alpha=0.5, label='CustomKinFragLib', color=\"tab:orange\")\n", + "plt.axvline(np.mean(syba_mols), color=\"tab:orange\")\n", + "plt.axvline(np.mean(syba_refs), color=\"tab:blue\")\n", + "plt.axvline(0, color=\"red\")\n", + "plt.legend(loc='upper right')\n", + "plt.xlabel(\"SYBA Score\")\n", + "plt.ylabel(\"# Molecules\")\n", + "plt.savefig('figures/syba_distribution_molecules.pdf')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We extract the most similar molecule from Enamine REAL Space for each molecule in our chemical space. We used [SpaceLight](https://pubs.acs.org/doi/full/10.1021/acs.jcim.0c00850) for the similarity search. \n", + "\n", + "**Note**: We deposited our results in the combinatorial library data folder, please first download the data from zenodo to run this notebook. " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "enamine_subset_df = pd.read_csv(str(PATH_TO_DATA / \"combinatorial_library\" / \"custom_enamine_search_sampled.csv\"))\n", + "ref_enamine_subset_df = pd.read_csv(str(PATH_TO_DATA / \"combinatorial_library\" / \"reference_enamine_search_sampled.csv\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGwCAYAAABIC3rIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABWh0lEQVR4nO3deVxU1f8/8NfIDsIoIAwkiyauYKCkAZWoLJrrxwpNI80ly1xQcPuYivuWikuamoK5hFnpV81QNHdzQ0lTwlQUF4hMZHEBhPv7wx/34zCIDM4wM9zX8/GYx4N77rn3vu8ZmHlz7rnnygRBEEBEREQkYbV0HQARERGRrjEhIiIiIsljQkRERESSx4SIiIiIJI8JEREREUkeEyIiIiKSPCZEREREJHnGug7AUJSUlODOnTuwtraGTCbTdThERERUCYIgIC8vD87OzqhV6/n9QEyIKunOnTtwcXHRdRhERERUBTdv3kT9+vWfu54JUSVZW1sDeNqgNjY2Oo6GiAzdw8InaDNrPwDg1KSOsDTVw4/jwgfAwiZPf45MBUytdBsPURXk5ubCxcVF/B5/Hj38C9RPpZfJbGxsmBAR0UszLnyCWmaWAJ5+ruhnQmQEmP3/IQI2NkyIyKC9aLgLB1UTERGR5DEhIiIiIsljQkRERESSp4cXrQ1bcXExioqKdB0GUaWYmppWeBsqEZFUMCHSEEEQkJmZifv37+s6FKJKq1WrFho0aABTU1Ndh0JEpFNMiDSkNBlycHCApaUlJ28kvVc62WhGRgZcXV35O0tEksaESAOKi4vFZMjOzk7X4RBVWr169XDnzh08efIEJiYmug6HiEhnOHhAA0rHDFlaWuo4EiL1lF4qKy4u1nEkRES6xYRIg3jJgQwNf2eJiJ5iQkRERESSx4SIiIiIJI+DqrVoceLlaj3e6ODG1Xq8UjKZDNu2bUPPnj11cvyKvCi2wMBAeHt7IyYmBgDg7u6OiIgIREREVFuMz1M2NiIi0h72EEnYgAEDIJPJIJPJYGxsDFdXV3z22WfIzs5Waz8ZGRno3LmzxuKSyWTYvn27xvanjtOnT+OTTz7RybGJiEh32EMkcZ06dUJsbCyePHmCS5cuYeDAgbh//z6+++67Su9DoVBoMcLqVa9ePV2HQEREOsAeIokzMzODQqFA/fr1ERISgt69e2Pv3r1KdWJjY9GsWTOYm5ujadOmWLFihdL6sj06t2/fRu/evVG3bl3Y2dmhR48euH79utI269atQ4sWLWBmZgYnJycMHz4cwNNLVgDwn//8BzKZTFwGgJ07d6J169YwNzdHw4YNMW3aNDx58kRc/9dff+Htt9+Gubk5mjdvjsTERLXbw93dXekS1Z9//ok333xT3Oe+fftUznf8+PFo3LgxLC0t0bBhQ0yePFnp8S3R0dHw9vbGhg0b4O7uDrlcjj59+iAvL0+s8+DBA3z00UeoXbs2nJycsHDhQpXYVqxYAQ8PD5ibm8PR0RHvvfee2udHRETlYw8Ria5du4aEhASlCfrWrFmDqVOnYvny5fDx8cG5c+cwZMgQWFlZoX///ir7ePjwIdq3b4+33noLhw8fhrGxMWbOnIlOnTrh/PnzMDU1xcqVKzFmzBjMnTsXnTt3Rk5ODo4dOwbg6SUrBwcHxMbGolOnTjAyMgIA7NmzBx9++CGWLl2Kt956C1evXhUvbU2dOhUlJSXo1asX7O3tceLECeTm5r70OKCSkhL07NkTrq6uOHnyJPLy8hAZGalSz9raGnFxcXB2dsaFCxcwZMgQWFtbY9y4cWKdq1evYvv27di1axeys7MRFhaGuXPnYtasWQCAsWPH4sCBA9i2bRsUCgX++9//IikpCd7e3gCAM2fOYOTIkdiwYQP8/f1x7949HDly5KXOj4hIpw7MUV5uP1E3cfx/TIgkbteuXahduzaKi4vx+PFjAMCiRYvE9TNmzMDChQvRq1cvAECDBg1w6dIlrFq1qtyEKD4+HrVq1cI333wjznETGxuLOnXq4ODBgwgJCcHMmTMRGRmJUaNGidu9/vrrAP53yapOnTpKl+JmzZqFCRMmiMds2LAhZsyYgXHjxmHq1KnYt28fUlJScP36ddSvXx8AMHv27Jca27R3715cvXoVBw8eFGOZNWsWgoODlep98cUX4s/u7u6IjIzEli1blBKikpISxMXFwdraGgAQHh6O/fv3Y9asWcjPz8fatWvx7bffivtev369eB4AkJ6eDisrK3Tt2hXW1tZwc3ODj49Plc+NiIiUMSGSuPbt22PlypV4+PAhvvnmG1y+fBkjRowAAPzzzz+4efMmBg0ahCFDhojbPHnyBHK5vNz9JSUl4cqVK+IXf6nHjx/j6tWryMrKwp07d9CxY0e14kxKSsLp06fFHhUAYhL38OFDpKSkwNXVVSmJ8PPzU+sYZaWmpsLFxUUpMWvTpo1KvR9++AExMTG4cuUK8vPz8eTJE9jY2CjVcXd3V2oTJycnZGVlAXjae1RYWKgUr62tLZo0aSIuBwcHw83NDQ0bNkSnTp3QqVMn/Oc//+Hs6EREGsKESOKsrKzQqFEjAMDSpUvRvn17TJs2DTNmzEBJSQmAp5fN2rZtq7Rd6aWsskpKStC6dWts2rRJZV29evVQq1bVhq2VlJRg2rRpYk/Vs8zNzSEIgkr5y87CLAjCC/dx4sQJ9OnTB9OmTUNoaCjkcjni4+NVxgCVfU6YTCYT27e82MuytrbG2bNncfDgQezduxdTpkxBdHQ0Tp8+jTp16qh3YkREpIIJESmZOnUqOnfujM8++wzOzs545ZVXcO3aNfTr169S27dq1QpbtmyBg4ODSi9JKXd3d+zfvx/t27cvd72JiYnKs7VatWqF1NRUMXkrq3nz5khPT8edO3fg7OwMAPjtt98qFfPzNG3aFOnp6fj777/h6OgI4OkYp2cdO3YMbm5umDRpklh248YNtY7TqFEjmJiY4MSJE3B1dQUAZGdn4/Lly2jXrp1Yz9jYGEFBQQgKCsLUqVNRp04d/Prrr+UmiUREpB4mRKQkMDAQLVq0wOzZs7F8+XJER0dj5MiRsLGxQefOnVFQUIAzZ84gOzsbY8aMUdm+X79+WLBgAXr06IHp06ejfv36SE9Px08//YSxY8eifv36iI6OxqeffgoHBwd07twZeXl5OHbsmHiprjRhCggIgJmZGerWrYspU6aga9eucHFxwfvvv49atWrh/PnzuHDhAmbOnImgoCA0adIEH330ERYuXIjc3FylJKUqgoOD8eqrr6J///6YP38+8vLyxH2W9hw1atQI6enpiI+Px+uvv46ff/4Z27ZtU+s4tWvXxqBBgzB27FjY2dnB0dERkyZNUupN27VrF65du4a3334bdevWxe7du1FSUqJ0WY2IiKqOCZEW6Wrm6Jc1ZswYfPzxxxg/fjwGDx4MS0tLLFiwAOPGjYOVlRW8vLyeeweXpaUlDh8+jPHjx6NXr17Iy8vDK6+8go4dO4o9Rv3798fjx4+xePFiREVFwd7eXukW8oULF2LMmDFYs2YNXnnlFVy/fh2hoaHYtWsXpk+fjvnz58PExARNmzbF4MGDAQC1atXCtm3bMGjQILRp0wbu7u5YunQpOnXqVOV2MDIywvbt2zF48GC8/vrraNiwIRYsWIBu3brB3NwcANCjRw+MHj0aw4cPR0FBAbp06YLJkycjOjparWMtWLAA+fn56N69O6ytrREZGYmcnBxxfZ06dfDTTz8hOjoajx8/hoeHB7777ju0aNGiyudHRET/IxMqM4CBkJubC7lcjpycHJVLQY8fP0ZaWhoaNGggflFKRUFBAczNzZGYmIigoCBdh6N1x44dw5tvvokrV67g1Vdf1XU4L03Kv7u69rDwCZpP2QMAuDQ9FJamevj/aeEDYPbTS9D47x3A1Eq38VDNUk233Vf0/f0sPfwLJEORm5uLn376CbVq1ULTpk11HY5WbNu2DbVr14aHhweuXLmCUaNGISAgoEYkQ0RE9D9MiKjKpk6dis2bN2PevHlKt7vXJHl5eRg3bhxu3rwJe3t7BAUFlTuLNBERGTadPrrj8OHD6NatG5ydnV/4QM+hQ4dCJpOpPPm7oKAAI0aMgL29PaysrNC9e3fcunVLqU52djbCw8Mhl8shl8sRHh6O+/fva/6EJGbx4sX4+++/ERUVpetQtOajjz7CX3/9hcePH+PWrVuIi4uDnZ2drsMiIiIN02lC9ODBA7z22mtYvnx5hfW2b9+OkydPirdTPysiIgLbtm1DfHw8jh49ivz8fHTt2lXptu2+ffsiOTkZCQkJSEhIQHJyMsLDwzV+PkRERGSYdHrJrHPnzi98tMLt27cxfPhw7NmzB126dFFal5OTg7Vr12LDhg3igN6NGzfCxcUF+/btQ2hoKFJSUpCQkIATJ06IkwuuWbMGfn5+SE1N5W3LREREpN9Puy8pKUF4eDjGjh1b7u3FSUlJKCoqQkhIiFjm7OwMT09PHD9+HMDTyfnkcrnSTMtvvPEG5HK5WKc8BQUFyM3NVXoRERFRzaTXCdG8efNgbGyMkSNHlrs+MzMTpqamqFu3rlK5o6MjMjMzxToODg4q2zo4OIh1yjNnzhxxzJFcLoeLi8tLnAkRERHpM71NiJKSkrBkyRLExcWp/Uyqss+gKm/7Fz2nauLEicjJyRFfN2/eVCsGIiIiMhx6mxAdOXIEWVlZcHV1hbGxMYyNjXHjxg1ERkbC3d0dAKBQKFBYWIjs7GylbbOyssRnTykUCvz9998q+//nn3/EOuUxMzODjY2N0otqhujoaHh7e+s6DI1wd3dXuvPyRXdrEhFR+fR2HqLw8HCVmY9DQ0MRHh6Ojz/+GADQunVrmJiYIDExEWFhYQCAjIwM/PHHH5g/fz4AwM/PDzk5OTh16hTatGkDADh58iRycnLg7++v3ZMoOwuntlVxls/MzEzMmjULP//8M27fvg0HBwd4e3sjIiICHTt2fKmQrl+/jgYNGuDcuXPVkoRER0dj+/btSE5OFsuOHDmCbt26ITw8HEuXLkVUVJT43LTKCgwMxKFDh1TKi4qKYGysvT+j8s7nWadPn4aVFWcPJiJ6WTpNiPLz83HlyhVxOS0tDcnJybC1tYWrq6vKfC8mJiZQKBTinWFyuRyDBg1CZGQk7OzsYGtri6ioKHh5eYnJVLNmzdCpUycMGTIEq1atAgB88skn6Nq1K+8ww9OEJSAgAHXq1MH8+fPRsmVLFBUVYc+ePfj888/x559/6jrEl/Lzzz/j/fffx9ixYzFt2jQATx+mWrt2bbX3NWTIEEyfPl2prLxkqLCwEKamplULWE316tWrluMQEdV0Or1kdubMGfj4+MDHxwfA04eK+vj4YMqUKZXex+LFi9GzZ0+EhYUhICAAlpaW2LlzJ4yMjMQ6mzZtgpeXF0JCQhASEoKWLVtiw4YNGj8fQzRs2DDIZDKcOnUK7733Hho3bowWLVpgzJgxOHHiBK5fvw6ZTKbUQ3H//n3IZDIcPHgQwNOJL/v164d69erBwsICHh4eiI2NBQA0aNAAAODj4wOZTIbAwEAAT+8gnD59OurXrw8zMzN4e3sjISFBPEbpcb///nu89dZbsLCwwOuvv47Lly/j9OnT8PX1Re3atdGpUyf8888/5Z7b5s2b0atXL8ydO1dMhgDVS2YDBgxAz5498eWXX8LJyQl2dnb4/PPPUVRUpLQ/S0tLKBQKpRfw9LLVzJkzMWDAAMjlcgwZMgQAMH78eDRu3BiWlpZo2LAhJk+erLLPmTNnwsHBAdbW1hg8eDAmTJigVk9a2UtmwNNe0s6dO8PCwgINGjTA1q1bK70/IiKp0mkPUWBgINR5tuz169dVyszNzbFs2TIsW7bsudvZ2tpi48aNVQmxRrt37x4SEhIwa9asci+71KlTp1Izek+ePBmXLl3CL7/8Ant7e1y5cgWPHj0CAPFS5b59+9CiRQux52TJkiVYuHAhVq1aBR8fH6xbtw7du3fHxYsX4eHhIe576tSpiImJgaurKwYOHIgPPvgANjY2WLJkCSwtLREWFoYpU6Zg5cqVSjF99dVXGDNmDNauXYsPP/zwhedw4MABODk54cCBA7hy5Qp69+4Nb29vMbl5kQULFmDy5Mn44osvxDJra2vExcXB2dkZFy5cwJAhQ2BtbY1x48YBeJqoz5o1CytWrEBAQADi4+OxcOFCMYmsqsmTJ2Pu3LlYsmQJNmzYgA8++ACenp5o1qzZS+2XiKgm09tB1aR9V65cgSAIL/1g1vT0dPj4+MDX1xfu7u4ICgpCt27dAPzvko6dnR0UCgVsbW0BAF9++SXGjx+PPn36oEmTJpg3bx68vb1VejuioqIQGhqKZs2aYdSoUTh79iwmT56MgIAA+Pj4YNCgQThw4IDSNikpKRg+fDhWrlxZqWQIAOrWrYvly5ejadOm6Nq1K7p06YL9+/cr1VmxYoV4ua127dqIjIwU13Xo0AFRUVFo1KgRGjVqBAD44osv4O/vD3d3d3Tr1g2RkZH4/vvvxW2WLVuGQYMG4eOPP0bjxo0xZcoUeHl5VSreirz//vsYPHgwGjdujBkzZsDX17fCfxiIiIgJkaSV9s6pO61BWZ999hni4+Ph7e2NcePGVTjhJQDk5ubizp07CAgIUCoPCAhASkqKUlnLli3Fn0vvCnw2aXB0dERWVpbSNvXr10erVq0wf/58ZGRkVOocWrRooXSZ1cnJSWW//fr1Q3JysviaOPF/g9h9fX1V9vnDDz/gzTffhEKhQO3atTF58mSkp6eL61NTU8WB/qXKLleFn5+fynLZdiUiImVMiCTMw8MDMpmswi/LWrWe/oo8e2mz7DiYzp0748aNG4iIiMCdO3fQsWPHSj3wtWwiVt7cUCYmJir1y5aVlJQobWNtbY19+/bB2toagYGBuHPnzgtjeXafz9uvXC4Xe4AaNWoEe3t7cV3ZS44nTpxAnz590LlzZ+zatQvnzp3DpEmTUFhYqHKcZ6lzCVkdL5v0EhHVdEyIJMzW1hahoaH46quv8ODBA5X19+/fFy95PdvTUt4t4PXq1cOAAQOwceNGxMTEYPXq1QAgjhl69mG7NjY2cHZ2xtGjR5X2cfz4cY2Nc6lbty727duHunXrIjAwELdv39bIfivr2LFjcHNzw6RJk+Dr6wsPDw/cuHFDqU6TJk1w6tQppbIzZ8689LFPnDihsvyyl0WJiGo6vZ2HiKrHihUr4O/vjzZt2mD69Olo2bIlnjx5gsTERKxcuRIpKSl44403MHfuXLi7u+Pu3btKA4cBYMqUKWjdujVatGiBgoIC7Nq1S0xsHBwcYGFhgYSEBNSvXx/m5uaQy+UYO3Yspk6dildffRXe3t6IjY1FcnIyNm3apLFzk8vl2Lt3Lzp16oTAwEAcOHAA9evX19j+K9KoUSOkp6cjPj4er7/+On7++Wds27ZNqc6IESMwZMgQ+Pr6wt/fH1u2bMH58+fRsGFDpXqPHj1SSUJr164tjlUqa+vWrfD19cWbb76JTZs24dSpU1i7dq1Gz4+IqKZhD5HENWjQAGfPnkX79u0RGRkJT09PBAcHY//+/eKdW+vWrUNRURF8fX0xatQozJw5U2kfpqammDhxIlq2bIm3334bRkZGiI+PB/B0np6lS5di1apVcHZ2Ro8ePQAAI0eORGRkJCIjI+Hl5YWEhATs2LFD6Q4zTbCxscGePXvg6OiIwMDAansES48ePTB69GgMHz4c3t7eOH78OCZPnqxUp1+/fpg4cSKioqLQqlUrpKWlYcCAATA3N1eqd/nyZXF6itLX4MGDn3vsadOmIT4+Hi1btsT69euxadMmNG/eXCvnSURUU8gEbQ1aqGFyc3Mhl8uRk5Oj8hiPx48fIy0tDQ0aNFD5MiNSR3BwMBQKRbXNk8XfXd15WPgEzafsAQBcmh4KS1M97LAvfADMdn7683/vAKacFZ00qOzTHKr4tIUXqej7+1l6+BdIJA0PHz7E119/jdDQUBgZGeG7777Dvn37kJiYqOvQiIgkhwkRkY7IZDLs3r0bM2fOREFBAZo0aYIff/xR5Rl+RESkfUyIiHTEwsIC+/bt03UYREQEDqomIiIiYkKkSRyfToaGv7NERE8xIdKA0lmOHz58qONIiNRTOnP2s48tISKSIo4h0gAjIyPUqVNHfPaVpaUlH5VAeq+kpAT//PMPLC0tYWzMjwIikjZ+CmqIQqEAAJUHghLps1q1asHV1ZUJPBFJHhMiDZHJZHBycoKDg4PKw0+J9JWpqan4AF8iIiljQqRhRkZGHI9BRERkYPivIREREUkeEyIiIiKSPCZEREREJHlMiIiIiEjymBARERGR5DEhIiIiIsljQkRERESSx4SIiIiIJI8JEREREUkeEyIiIiKSPCZEREREJHlMiIiIiEjymBARERGR5DEhIiIiIsljQkRERESSx4SIiIiIJI8JEREREUkeEyIiIiKSPCZEREREJHlMiIiIiEjydJoQHT58GN26dYOzszNkMhm2b98urisqKsL48ePh5eUFKysrODs746OPPsKdO3eU9lFQUIARI0bA3t4eVlZW6N69O27duqVUJzs7G+Hh4ZDL5ZDL5QgPD8f9+/er4QyJiIjIEOg0IXrw4AFee+01LF++XGXdw4cPcfbsWUyePBlnz57FTz/9hMuXL6N79+5K9SIiIrBt2zbEx8fj6NGjyM/PR9euXVFcXCzW6du3L5KTk5GQkICEhAQkJycjPDxc6+dHREREhsFYlwfv3LkzOnfuXO46uVyOxMREpbJly5ahTZs2SE9Ph6urK3JycrB27Vps2LABQUFBAICNGzfCxcUF+/btQ2hoKFJSUpCQkIATJ06gbdu2AIA1a9bAz88PqampaNKkiXZPkoiIiPSeQY0hysnJgUwmQ506dQAASUlJKCoqQkhIiFjH2dkZnp6eOH78OADgt99+g1wuF5MhAHjjjTcgl8vFOuUpKChAbm6u0ouIiIhqJoNJiB4/fowJEyagb9++sLGxAQBkZmbC1NQUdevWVarr6OiIzMxMsY6Dg4PK/hwcHMQ65ZkzZ4445kgul8PFxUWDZ0NERET6xCASoqKiIvTp0wclJSVYsWLFC+sLggCZTCYuP/vz8+qUNXHiROTk5IivmzdvVi14IiIi0nt6nxAVFRUhLCwMaWlpSExMFHuHAEChUKCwsBDZ2dlK22RlZcHR0VGs8/fff6vs959//hHrlMfMzAw2NjZKLyIiIqqZ9DohKk2G/vrrL+zbtw92dnZK61u3bg0TExOlwdcZGRn4448/4O/vDwDw8/NDTk4OTp06JdY5efIkcnJyxDpEREQkbTq9yyw/Px9XrlwRl9PS0pCcnAxbW1s4Ozvjvffew9mzZ7Fr1y4UFxeLY35sbW1hamoKuVyOQYMGITIyEnZ2drC1tUVUVBS8vLzEu86aNWuGTp06YciQIVi1ahUA4JNPPkHXrl15hxkREREB0HFCdObMGbRv315cHjNmDACgf//+iI6Oxo4dOwAA3t7eStsdOHAAgYGBAIDFixfD2NgYYWFhePToETp27Ii4uDgYGRmJ9Tdt2oSRI0eKd6N179693LmPiIiISJp0mhAFBgZCEITnrq9oXSlzc3MsW7YMy5Yte24dW1tbbNy4sUoxEhERUc2n12OIiIiIiKoDEyIiIiKSPCZEREREJHlMiIiIiEjymBARERGR5DEhIiIiIsljQkRERESSx4SIiIiIJI8JEREREUkeEyIiIiKSPCZEREREJHlMiIiIiEjymBARERGR5DEhIiIiIsljQkRERESSx4SIiIiIJI8JEREREUkeEyIiIiKSPCZEREREJHlMiIiIiEjymBARERGR5DEhIiIiIsljQkRERESSx4SIiIiIJI8JEREREUkeEyIiIiKSPCZEREREJHlMiIiIiEjymBARERGR5DEhIiIiIsljQkRERESSx4SIiIiIJI8JEREREUkeEyIiIiKSPCZEREREJHlMiIiIiEjymBARERGR5DEhIiIiIsnTaUJ0+PBhdOvWDc7OzpDJZNi+fbvSekEQEB0dDWdnZ1hYWCAwMBAXL15UqlNQUIARI0bA3t4eVlZW6N69O27duqVUJzs7G+Hh4ZDL5ZDL5QgPD8f9+/e1fHZERERkKHSaED148ACvvfYali9fXu76+fPnY9GiRVi+fDlOnz4NhUKB4OBg5OXliXUiIiKwbds2xMfH4+jRo8jPz0fXrl1RXFws1unbty+Sk5ORkJCAhIQEJCcnIzw8XOvnR0RERIbBWJcH79y5Mzp37lzuOkEQEBMTg0mTJqFXr14AgPXr18PR0RGbN2/G0KFDkZOTg7Vr12LDhg0ICgoCAGzcuBEuLi7Yt28fQkNDkZKSgoSEBJw4cQJt27YFAKxZswZ+fn5ITU1FkyZNyj1+QUEBCgoKxOXc3FxNnjoRERHpEb0dQ5SWlobMzEyEhISIZWZmZmjXrh2OHz8OAEhKSkJRUZFSHWdnZ3h6eop1fvvtN8jlcjEZAoA33ngDcrlcrFOeOXPmiJfY5HI5XFxcNH2KREREpCf0NiHKzMwEADg6OiqVOzo6iusyMzNhamqKunXrVljHwcFBZf8ODg5infJMnDgROTk54uvmzZsvdT5ERESkv3R6yawyZDKZ0rIgCCplZZWtU179F+3HzMwMZmZmakZLREREhkhve4gUCgUAqPTiZGVlib1GCoUChYWFyM7OrrDO33//rbL/f/75R6X3iYiIiKRJbxOiBg0aQKFQIDExUSwrLCzEoUOH4O/vDwBo3bo1TExMlOpkZGTgjz/+EOv4+fkhJycHp06dEuucPHkSOTk5Yh0iIiKSNp1eMsvPz8eVK1fE5bS0NCQnJ8PW1haurq6IiIjA7Nmz4eHhAQ8PD8yePRuWlpbo27cvAEAul2PQoEGIjIyEnZ0dbG1tERUVBS8vL/Gus2bNmqFTp04YMmQIVq1aBQD45JNP0LVr1+feYUZERETSotOE6MyZM2jfvr24PGbMGABA//79ERcXh3HjxuHRo0cYNmwYsrOz0bZtW+zduxfW1tbiNosXL4axsTHCwsLw6NEjdOzYEXFxcTAyMhLrbNq0CSNHjhTvRuvevftz5z4iIiIi6ZEJgiDoOghDkJubC7lcjpycHNjY2Og6HCIycA8Ln6D5lD0AgEvTQ2Fpqof3uBQ+AGY7P/35v3cAUyvdxkM1y4E5ysvtJ2rlMJX9/tbbMURERERE1YUJEREREUkeEyIiIiKSPCZEREREJHlMiIiIiEjymBARERGR5DEhIiIiIsljQkRERESS99IJUXFxMZKTk1UesEpERERkKNROiCIiIrB27VoAT5Ohdu3aoVWrVnBxccHBgwc1HR8RERGR1qmdEP3www947bXXAAA7d+5EWloa/vzzT0RERGDSpEkaD5CIiIhI29ROiO7evQuFQgEA2L17N95//300btwYgwYNwoULFzQeIBEREZG2qZ0QOTo64tKlSyguLkZCQgKCgoIAAA8fPlR6wjwRERGRoVD78coff/wxwsLC4OTkBJlMhuDgYADAyZMn0bRpU40HSERERKRtaidE0dHR8PT0xM2bN/H+++/DzMwMAGBkZIQJEyZoPEAiIiIibVM7IQKA9957DwDw+PFjsax///6aiYiIiIiomqk9hqi4uBgzZszAK6+8gtq1a+PatWsAgMmTJ4u34xMREREZErUTolmzZiEuLg7z58+HqampWO7l5YVvvvlGo8ERERERVQe1E6Jvv/0Wq1evRr9+/ZTuKmvZsiX+/PNPjQZHREREVB3UTohu376NRo0aqZSXlJSgqKhII0ERERERVSe1E6IWLVrgyJEjKuVbt26Fj4+PRoIiIiIiqk5q32U2depUhIeH4/bt2ygpKcFPP/2E1NRUfPvtt9i1a5c2YiQiIiLSKrV7iLp164YtW7Zg9+7dkMlkmDJlClJSUrBz505xkkYiIiIiQ1KleYhCQ0MRGhqq6ViIiIiIdELtHiIiIiKimqZSPUR169aFTCar1A7v3bv3UgERERERVbdKJUQxMTFaDoOIiIhIdyqVEPE5ZURERFSTqT2oOj09vcL1rq6uVQ6GiIiISBfUTojc3d0rHE9UXFz8UgERERERVTe1E6Jz584pLRcVFeHcuXNYtGgRZs2apbHAiIiIiKqL2gnRa6+9plLm6+sLZ2dnLFiwAL169dJIYERERETVRWPzEDVu3BinT5/W1O6IiIiIqo3aPUS5ublKy4IgICMjA9HR0fDw8NBYYERERETVRe2EqE6dOiqDqgVBgIuLC+Lj4zUWGBEREVF1UTsh+vXXX5USolq1aqFevXpo1KgRjI2r9Gg0IiIiIp1SO4MJDAzUQhhEREREuqP2oOo5c+Zg3bp1KuXr1q3DvHnzNBJUqSdPnuCLL75AgwYNYGFhgYYNG2L69OkoKSkR6wiCgOjoaDg7O8PCwgKBgYG4ePGi0n4KCgowYsQI2Nvbw8rKCt27d8etW7c0GisREREZLrUTolWrVqFp06Yq5S1atMDXX3+tkaBKzZs3D19//TWWL1+OlJQUzJ8/HwsWLMCyZcvEOvPnz8eiRYuwfPlynD59GgqFAsHBwcjLyxPrREREYNu2bYiPj8fRo0eRn5+Prl27chJJIiIiAlCFS2aZmZlwcnJSKa9Xrx4yMjI0ElSp3377DT169ECXLl0APJ0l+7vvvsOZM2cAPO0diomJwaRJk8T5j9avXw9HR0ds3rwZQ4cORU5ODtauXYsNGzYgKCgIALBx40a4uLhg3759CA0N1WjMREREZHjU7iFycXHBsWPHVMqPHTsGZ2dnjQRV6s0338T+/ftx+fJlAMDvv/+Oo0eP4p133gEApKWlITMzEyEhIeI2ZmZmaNeuHY4fPw4ASEpKQlFRkVIdZ2dneHp6inXKU1BQgNzcXKUXERER1Uxq9xANHjwYERERKCoqQocOHQAA+/fvx7hx4xAZGanR4MaPH4+cnBw0bdoURkZGKC4uxqxZs/DBBx8AeNpbBQCOjo5K2zk6OuLGjRtiHVNTU9StW1elTun25ZkzZw6mTZumydMhIiIiPaV2QjRu3Djcu3cPw4YNQ2FhIQDA3Nwc48ePx8SJEzUa3JYtW7Bx40Zs3rwZLVq0QHJyMiIiIuDs7Iz+/fuL9cqbF6miB9BWps7EiRMxZswYcTk3NxcuLi5VPBMiIiLSZ2onRDKZDPPmzcPkyZORkpICCwsLeHh4wMzMTOPBjR07FhMmTECfPn0AAF5eXrhx4wbmzJmD/v37Q6FQAFAd15SVlSX2GikUChQWFiI7O1uplygrKwv+/v7PPbaZmZlWzomIiIj0T5WfZZaZmYl79+7h1VdfhZmZGQRB0GRcAICHDx+iVi3lEI2MjMTb7hs0aACFQoHExERxfWFhIQ4dOiQmO61bt4aJiYlSnYyMDPzxxx8VJkREREQkHWr3EP37778ICwvDgQMHIJPJ8Ndff6Fhw4YYPHgw6tSpg4ULF2osuG7dumHWrFlwdXVFixYtcO7cOSxatAgDBw4E8LS3KiIiArNnz4aHhwc8PDwwe/ZsWFpaom/fvgAAuVyOQYMGITIyEnZ2drC1tUVUVBS8vLzEu86IiIhI2tROiEaPHg0TExOkp6ejWbNmYnnv3r0xevRojSZEy5Ytw+TJkzFs2DBkZWXB2dkZQ4cOxZQpU8Q648aNw6NHjzBs2DBkZ2ejbdu22Lt3L6ytrcU6ixcvhrGxMcLCwvDo0SN07NgRcXFxMDIy0lisREREZLhkgprXuhQKBfbs2YPXXnsN1tbW+P3339GwYUOkpaXBy8sL+fn52opVp3JzcyGXy5GTkwMbGxtdh0NEBu5h4RM0n7IHAHBpeigsTfXwWZCFD4DZ/386lf/eAUytdBsP1SwH5igvt9fsjVmlKvv9rfYYogcPHsDS0lKl/O7duxyETERERAZJ7YTo7bffxrfffisuy2QylJSUYMGCBWjfvr1GgyMiIiKqDmr30S5YsACBgYE4c+YMCgsLMW7cOFy8eBH37t0rdwZrIiIiIn2ndg9R8+bNcf78ebRp0wbBwcF48OABevXqhXPnzuHVV1/VRoxEREREWlWlUXwKhYKPtSAiIqIao1IJ0fnz5yu9w5YtW1Y5GCIiIiJdqFRC5O3tDZlM9sLZqGUyGYqLizUSGBEREVF1qVRClJaWpu04iIiIiHSmUgmRm5ubtuMgIiIi0pkqDaq+evUqYmJikJKSAplMhmbNmmHUqFG8y4yIiIgMktq33e/ZswfNmzfHqVOn0LJlS3h6euLkyZNo0aKF0hPliYiIiAyF2j1EEyZMwOjRozF37lyV8vHjxyM4OFhjwRERERFVB7V7iFJSUjBo0CCV8oEDB+LSpUsaCYqIiIioOqmdENWrVw/Jyckq5cnJyXBwcNBETERERETVSu1LZkOGDMEnn3yCa9euwd/fHzKZDEePHsW8efMQGRmpjRiJiIiItErthGjy5MmwtrbGwoULMXHiRACAs7MzoqOjMXLkSI0HSERERKRtaidEMpkMo0ePxujRo5GXlwcAsLa21nhgRERERNWlSvMQlWIiRERERDVBpROiDh06VKrer7/+WuVgiIiIiHSh0gnRwYMH4ebmhi5dusDExESbMRERERFVq0onRHPnzkVcXBy2bt2Kfv36YeDAgfD09NRmbERERETVotLzEI0bNw6XLl3C9u3bkZeXh4CAALRp0wZff/01cnNztRkjERERkVapPajaz88Pfn5+WLJkCbZu3YqvvvoKUVFRuHPnDmxsbLQRIxGR1ixOvKy0PDq4sY4iISJdqvJdZmfPnsWhQ4eQkpICT09PjisiIqqqQ18CxsLTn9tP1G0sRBKl1qM77ty5g9mzZ6Nx48Z47733YGtri5MnT+LEiROwsLDQVoxEREREWlXpHqJ33nkHBw4cQEhICBYsWIAuXbrA2PilpjEiIiIi0guVzmgSEhLg5OSE9PR0TJs2DdOmTSu33tmzZzUWHBEREVF1qHRCNHXqVG3GQURk2A7MUV7mWCAig8KEiIiIiCSPg4CIiAxN2d4ogD1SRC9JrbvMiIiIiGoi9hAREVWXZ3t2nsgAeOksFCJSxh4iIiIikjz2EBER1QS8y43opVSph2j48OG4d++epmMhIiIi0olK9xDdunUL9evXBwBs3rwZ48aNg62tLby8vLB79264uLhoLUgiIl3S6QNgy7ujjIg0rtIJUdOmTWFnZ4eAgAA8fvwYN2/ehKurK65fv46ioiJtxkhERESkVZW+ZJaTk4OtW7eidevWKCkpwTvvvIPGjRujoKAAe/bsQWZmplYCvH37Nj788EPY2dnB0tIS3t7eSEpKEtcLgoDo6Gg4OzvDwsICgYGBuHjxotI+CgoKMGLECNjb28PKygrdu3fHrVu3tBIvEdV8ixMvq7yIyLBVuoeoqKgIbdq0QZs2bTBz5kwkJSUhIyMDQUFBWLduHaKiolC/fn2kpqZqLLjs7GwEBASgffv2+OWXX+Dg4ICrV6+iTp06Yp358+dj0aJFiIuLQ+PGjTFz5kwEBwcjNTUV1tbWAICIiAjs3LkT8fHxsLOzQ2RkJLp27YqkpCQYGRlpLF4i0m+VSVzKq/NG+mql5ROun2gsJhW8REakE5VOiGxsbODj44OAgAAUFhbi4cOHCAgIgLGxMbZs2YL69evj1KlTGg1u3rx5cHFxQWxsrFjm7u4u/iwIAmJiYjBp0iT06tULALB+/Xo4Ojpi8+bNGDp0KHJycrB27Vps2LABQUFBAICNGzfCxcUF+/btQ2hoqEZjJiICwMSGyMBU+pLZnTt38MUXX8DMzAxPnjyBr68v3nrrLRQWFuLs2bOQyWR48803NRrcjh074Ovri/fffx8ODg7w8fHBmjVrxPVpaWnIzMxESEiIWGZmZoZ27drh+PHjAICkpCQUFRUp1XF2doanp6dYpzwFBQXIzc1VehERPc9v1/5VehGRYal0QmRvb49u3bphzpw5sLS0xOnTpzFixAjIZDJERUXBxsYG7dq102hw165dw8qVK+Hh4YE9e/bg008/xciRI/Htt98CgDhuydHRUWk7R0dHcV1mZiZMTU1Rt27d59Ypz5w5cyCXy8UX76IjIiKquao8U7VcLkdYWBhMTEzw66+/Ii0tDcOGDdNkbCgpKUGrVq0we/Zs+Pj4YOjQoRgyZAhWrlypVE8mkyktC4KgUlbWi+pMnDgROTk54uvmzZtVPxEiIiLSa1VKiM6fPy/OSeTm5gYTExMoFAr07t1bo8E5OTmhefPmSmXNmjVDeno6AEChUACASk9PVlaW2GukUChQWFiI7Ozs59Ypj5mZGWxsbJReREREVDNV6dEdz14++uOPPzQWTFkBAQEqd61dvnwZbm5uAIAGDRpAoVAgMTERPj4+AIDCwkIcOnQI8+bNAwC0bt0aJiYmSExMRFhYGAAgIyMDf/zxB+bPn6+12IlIt3grPBGpQ6+fZTZ69Gj4+/tj9uzZCAsLw6lTp7B69WqsXv30FliZTIaIiAjMnj0bHh4e8PDwwOzZs2FpaYm+ffsCeHppb9CgQYiMjISdnR1sbW0RFRUFLy8v8a4zIiIikja9Tohef/11bNu2DRMnTsT06dPRoEEDxMTEoF+/fmKdcePG4dGjRxg2bBiys7PRtm1b7N27V5yDCAAWL14MY2NjhIWF4dGjR+jYsSPi4uI4BxEREREB0POECAC6du2Krl27Pne9TCZDdHQ0oqOjn1vH3Nwcy5Ytw7Jly7QQIRFJTdmJGonI8Ol9QkRERFVQ3sSQ7SdWfxxEBqLKt90TERER1RTsISKiGsEQ7ip7dgbrxyX8f5RInzAhIiKDYwjJDxEZFv6LQkRERJLHhIiIiIgkj5fMiIikouydZ7zrjEjEHiIiIiKSPPYQERE9g5MuEkkTEyIiIi149hZ7ItJ/vGRGREREksceIiKSNF4iIyKAPURERERE7CEiIiI18fZ9qoGYEBGR3uOjOohI23jJjIiIiCSPCRERERFJHhMiIiIikjyOISIivcLxQjr27IDp4kLdxUFUzZgQEZFOMQECTl6/B/NaJQAAv4Z2SuvKm/G6bB0ienm8ZEZERESSx4SIiIiIJI+XzIiIDAwvoxFpHhMiIiKpKjvjNJGEMSEiIskwhAe5ltf7Q0TaxzFEREREJHlMiIiIiEjymBARERGR5HEMERFVG07CKHFlB3G3n6ibOIjKwR4iIiIikjwmRERERCR5TIiIiIhI8pgQERERkeQxISIiIiLJY0JEREREksfb7omoRjKEx3QQkf5gDxERERFJHhMiIiIikjyDSojmzJkDmUyGiIgIsUwQBERHR8PZ2RkWFhYIDAzExYsXlbYrKCjAiBEjYG9vDysrK3Tv3h23bt2q5uiJpGdx4mWlF0nIgTmqL6Jn/HbtX6WXrhnMGKLTp09j9erVaNmypVL5/PnzsWjRIsTFxaFx48aYOXMmgoODkZqaCmtrawBAREQEdu7cifj4eNjZ2SEyMhJdu3ZFUlISjIyMdHE6REQ1B5MdqgEMoocoPz8f/fr1w5o1a1C3bl2xXBAExMTEYNKkSejVqxc8PT2xfv16PHz4EJs3bwYA5OTkYO3atVi4cCGCgoLg4+ODjRs34sKFC9i3b99zj1lQUIDc3FylFxEREdVMBpEQff755+jSpQuCgoKUytPS0pCZmYmQkBCxzMzMDO3atcPx48cBAElJSSgqKlKq4+zsDE9PT7FOeebMmQO5XC6+XFxcNHxWREQG5PCXvPRFNZreXzKLj4/H2bNncfr0aZV1mZmZAABHR0elckdHR9y4cUOsY2pqqtSzVFqndPvyTJw4EWPGjBGXc3NzmRQR6THeZk9EL0OvE6KbN29i1KhR2Lt3L8zNzZ9bTyaTKS0LgqBSVtaL6piZmcHMzEy9gIkkjIOmiciQ6fUls6SkJGRlZaF169YwNjaGsbExDh06hKVLl8LY2FjsGSrb05OVlSWuUygUKCwsRHZ29nPrEBEZOn27Y4fI0Oh1QtSxY0dcuHABycnJ4svX1xf9+vVDcnIyGjZsCIVCgcTERHGbwsJCHDp0CP7+/gCA1q1bw8TERKlORkYG/vjjD7EOERHpCd6qTzqi15fMrK2t4enpqVRmZWUFOzs7sTwiIgKzZ8+Gh4cHPDw8MHv2bFhaWqJv374AALlcjkGDBiEyMhJ2dnawtbVFVFQUvLy8VAZpExERkTTpdUJUGePGjcOjR48wbNgwZGdno23btti7d684BxEALF68GMbGxggLC8OjR4/QsWNHxMXFcQ4iIqqxyrts5tfQTgeREBkGg0uIDh48qLQsk8kQHR2N6Ojo525jbm6OZcuWYdmyZdoNjoiIiAySXo8hIiIiIqoOTIiIiIhI8gzukhkREdUQ2ryLrOy+20/U3rGoRmBCREREomcHY9cqKUJbHcaiF8pL2phc1Ui8ZEZERESSx4SIiIiIJI+XzIiIJIqP+CD6H/YQERERkeQxISIiIiLJ4yUzIiKJqDGXyHhLPWkBEyIiMjhvpK/WdQhUE/CWenoGEyIiIjJs2pzgkSSDY4iIiIhI8thDREREVIq9TZLFhIiIiNRSdnC2X0M77R1MUwkKEx16ASZERERE6uBdbjUSxxARERGR5DEhIiIiIsljQkRERESSx4SIiIiIJI8JEREREUkeEyIiIiKSPN52T0RqW5x4WdchEBFpFBMiIiIibeODZPUeEyIieiH2CBFRTceEiIiIXkrZR3k8j1Yf8aFv+KgQg8OEiIiIqkW1PgOtOjH5qRGYEBGR3nsjfbWuQ5C8k2n3UFLLRNdhEGkNEyIiItKJ8i611ZheIzI4nIeIiIiIJI8JEREREUkeEyIiIiKSPI4hIiIivVFj70QjvceEiIiISBfK3q7Pmat1igkREREZFPYikTZwDBERERFJHhMiIiIikjy9TojmzJmD119/HdbW1nBwcEDPnj2RmpqqVEcQBERHR8PZ2RkWFhYIDAzExYsXleoUFBRgxIgRsLe3h5WVFbp3745bt25V56kQERGRHtPrhOjQoUP4/PPPceLECSQmJuLJkycICQnBgwcPxDrz58/HokWLsHz5cpw+fRoKhQLBwcHIy8sT60RERGDbtm2Ij4/H0aNHkZ+fj65du6K4uFgXp0VEFXgjfbXKi4hI2/R6UHVCQoLScmxsLBwcHJCUlIS3334bgiAgJiYGkyZNQq9evQAA69evh6OjIzZv3oyhQ4ciJycHa9euxYYNGxAUFAQA2LhxI1xcXLBv3z6EhoaWe+yCggIUFBSIy7m5uVo6SyIiIpT/kFjeeVZt9LqHqKycnBwAgK2tLQAgLS0NmZmZCAkJEeuYmZmhXbt2OH78OAAgKSkJRUVFSnWcnZ3h6ekp1inPnDlzIJfLxZeLi4s2TomIiIj0gF73ED1LEASMGTMGb775Jjw9PQEAmZmZAABHR0eluo6Ojrhx44ZYx9TUFHXr1lWpU7p9eSZOnIgxY8aIy7m5uUyKSBIWJ17WdQhERNXOYBKi4cOH4/z58zh69KjKOplMprQsCIJKWVkvqmNmZgYzM7OqBUtEREQGxSASohEjRmDHjh04fPgw6tevL5YrFAoAT3uBnJycxPKsrCyx10ihUKCwsBDZ2dlKvURZWVnw9/evpjMg0l/sESJDV3aiRoCTNZL69HoMkSAIGD58OH766Sf8+uuvaNCggdL6Bg0aQKFQIDExUSwrLCzEoUOHxGSndevWMDExUaqTkZGBP/74gwkREZGe++3avyovIm3Q6x6izz//HJs3b8b//d//wdraWhzzI5fLYWFhAZlMhoiICMyePRseHh7w8PDA7NmzYWlpib59+4p1Bw0ahMjISNjZ2cHW1hZRUVHw8vIS7zojIiIiadPrhGjlypUAgMDAQKXy2NhYDBgwAAAwbtw4PHr0CMOGDUN2djbatm2LvXv3wtraWqy/ePFiGBsbIywsDI8ePULHjh0RFxcHIyOj6joVInoOzjNEVAHeil9t9DohEgThhXVkMhmio6MRHR393Drm5uZYtmwZli1bpsHoiIiIqKbQ6zFERERERNWBCRERERFJHhMiIiIikjy9HkNERESkCZyriF6ECREREUkSkyR6FhMiIiKi/69sksQESTqYEBFRteGcQ0Skr5gQEUkIn1tGUsFHfJC6mBARERGpgZfVaibedk9ERESSxx4iIiKi59DLS29ln2/GZ5tpBHuIiIiISPKYEBEREZHkMSEiIiIiyeMYIiIiIg3jnWiGhwkREWkNJ2IkIkPBhIiINILJD9Hz8blp+o8JEVENxpmpiYgqh4OqiYiISPLYQ0RERPQSdD55Y9mJGgFO1lgFTIiIagheHiMiqjpeMiMiIiLJY0JEREREksdLZkRERDqg1ckbtfUA2Bo8XokJERERkR7gXEW6xYSIiNTGSRiJqofGkqQa3LOjKRxDRERERJLHHiIiIiIDwgfHagcTIiIDwDmGiOh5OPZIM5gQERERSVFl7kQrb+xRDcWEiIheiIOoiaim46BqIiIikjz2EBHpGY4XIiKdqOrlsRpySz8TIiIiohpG53eiaWumbC1iQkRESjheiIg0zgAGZzMhItIxXiIjIm3jrfkvxkHVREREJHmS6iFasWIFFixYgIyMDLRo0QIxMTF46623dB0WkU7xEhmRNOl8nJGekUxCtGXLFkRERGDFihUICAjAqlWr0LlzZ1y6dAmurq66Do8kgpfHiIj0k2QSokWLFmHQoEEYPHgwACAmJgZ79uzBypUrMWeO/g/2IsOk6wSIvT9EVFnljTMqq7K9SJXZl76RREJUWFiIpKQkTJgwQak8JCQEx48fL3ebgoICFBQUiMs5OTkAgNzcXO0FSgbtq1+vvLDO67diVcpO1/+4SttVxoMqbUXV4XFJLZQUPAQAPHhUgOJaJTqOSFWtkiLkFggAnsZYoocxUvXad/GO1vatre/X0v0KglBhPUkkRHfv3kVxcTEcHR2Vyh0dHZGZmVnuNnPmzMG0adNUyl1cXLQSI0nZcl0HQDqzFADQTcdRVM4qXQdANd0I7X4W5uXlQS6XP3e9JBKiUjKZTGlZEASVslITJ07EmDFjxOWSkhLcu3cPdnZ2z92mKnJzc+Hi4oKbN2/CxsZGY/slVWzr6sF2rh5s5+rBdq4e2mxnQRCQl5cHZ2fnCutJIiGyt7eHkZGRSm9QVlaWSq9RKTMzM5iZmSmV1alTR1shwsbGhn9s1YRtXT3YztWD7Vw92M7VQ1vtXFHPUClJzENkamqK1q1bIzExUak8MTER/v7+OoqKiIiI9IUkeogAYMyYMQgPD4evry/8/PywevVqpKen49NPP9V1aERERKRjkkmIevfujX///RfTp09HRkYGPD09sXv3bri5uek0LjMzM0ydOlXl8hxpHtu6erCdqwfbuXqwnauHPrSzTHjRfWhERERENZwkxhARERERVYQJEREREUkeEyIiIiKSPCZEREREJHlMiKrBihUr0KBBA5ibm6N169Y4cuRIhfUPHTqE1q1bw9zcHA0bNsTXX39dTZEaNnXa+aeffkJwcDDq1asHGxsb+Pn5Yc+ePdUYreFS9/e51LFjx2BsbAxvb2/tBliDqNvWBQUFmDRpEtzc3GBmZoZXX30V69atq6ZoDZe67bxp0ya89tprsLS0hJOTEz7++GP8+6/hPcy0Oh0+fBjdunWDs7MzZDIZtm/f/sJtqv27UCCtio+PF0xMTIQ1a9YIly5dEkaNGiVYWVkJN27cKLf+tWvXBEtLS2HUqFHCpUuXhDVr1ggmJibCDz/8UM2RGxZ123nUqFHCvHnzhFOnTgmXL18WJk6cKJiYmAhnz56t5sgNi7rtXOr+/ftCw4YNhZCQEOG1116rnmANXFXaunv37kLbtm2FxMREIS0tTTh58qRw7Nixaoza8KjbzkeOHBFq1aolLFmyRLh27Zpw5MgRoUWLFkLPnj2rOXLDsnv3bmHSpEnCjz/+KAAQtm3bVmF9XXwXMiHSsjZt2giffvqpUlnTpk2FCRMmlFt/3LhxQtOmTZXKhg4dKrzxxhtai7EmULedy9O8eXNh2rRpmg6tRqlqO/fu3Vv44osvhKlTpzIhqiR12/qXX34R5HK58O+//1ZHeDWGuu28YMECoWHDhkplS5cuFerXr6+1GGuayiREuvgu5CUzLSosLERSUhJCQkKUykNCQnD8+PFyt/ntt99U6oeGhuLMmTMoKirSWqyGrCrtXFZJSQny8vJga2urjRBrhKq2c2xsLK5evYqpU6dqO8QaoyptvWPHDvj6+mL+/Pl45ZVX0LhxY0RFReHRo0fVEbJBqko7+/v749atW9i9ezcEQcDff/+NH374AV26dKmOkCVDF9+FkpmpWhfu3r2L4uJilQfIOjo6qjxotlRmZma59Z88eYK7d+/CyclJa/Eaqqq0c1kLFy7EgwcPEBYWpo0Qa4SqtPNff/2FCRMm4MiRIzA25sdNZVWlra9du4ajR4/C3Nwc27Ztw927dzFs2DDcu3eP44ieoyrt7O/vj02bNqF37954/Pgxnjx5gu7du2PZsmXVEbJk6OK7kD1E1UAmkyktC4KgUvai+uWVkzJ127nUd999h+joaGzZsgUODg7aCq/GqGw7FxcXo2/fvpg2bRoaN25cXeHVKOr8TpeUlEAmk2HTpk1o06YN3nnnHSxatAhxcXHsJXoBddr50qVLGDlyJKZMmYKkpCQkJCQgLS2Nz8XUgur+LuS/bFpkb28PIyMjlf80srKyVDLfUgqFotz6xsbGsLOz01qshqwq7Vxqy5YtGDRoELZu3YqgoCBthmnw1G3nvLw8nDlzBufOncPw4cMBPP3SFgQBxsbG2Lt3Lzp06FAtsRuaqvxOOzk54ZVXXoFcLhfLmjVrBkEQcOvWLXh4eGg1ZkNUlXaeM2cOAgICMHbsWABAy5YtYWVlhbfeegszZ85kL76G6OK7kD1EWmRqaorWrVsjMTFRqTwxMRH+/v7lbuPn56dSf+/evfD19YWJiYnWYjVkVWln4GnP0IABA7B582Ze/68EddvZxsYGFy5cQHJysvj69NNP0aRJEyQnJ6Nt27bVFbrBqcrvdEBAAO7cuYP8/Hyx7PLly6hVqxbq16+v1XgNVVXa+eHDh6hVS/mr08jICMD/ejDo5enku1Brw7VJEIT/3dK5du1a4dKlS0JERIRgZWUlXL9+XRAEQZgwYYIQHh4u1i+91XD06NHCpUuXhLVr1/K2+0pQt503b94sGBsbC1999ZWQkZEhvu7fv6+rUzAI6rZzWbzLrPLUbeu8vDyhfv36wnvvvSdcvHhROHTokODh4SEMHjxYV6dgENRt59jYWMHY2FhYsWKFcPXqVeHo0aOCr6+v0KZNG12dgkHIy8sTzp07J5w7d04AICxatEg4d+6cOL2BPnwXMiGqBl999ZXg5uYmmJqaCq1atRIOHTokruvfv7/Qrl07pfoHDx4UfHx8BFNTU8Hd3V1YuXJlNUdsmNRp53bt2gkAVF79+/ev/sANjLq/z89iQqQedds6JSVFCAoKEiwsLIT69esLY8aMER4+fFjNURseddt56dKlQvPmzQULCwvByclJ6Nevn3Dr1q1qjtqwHDhwoMLPXH34LpQJAvv4iIiISNo4hoiIiIgkjwkRERERSR4TIiIiIpI8JkREREQkeUyIiIiISPKYEBEREZHkMSEiIiIiyWNCRERERJLHhMhABQYGIiIiQtdhvLS4uDjUqVOn2o+rifYrG3t0dDS8vb1fap8AcPDgQchkMty/f/+l90XK9Pl9r07u7u6IiYmptuNdv34dMpkMycnJVd6Hrj4rqlNN+Vw3VEyI9NiAAQMgk8lUXleuXMFPP/2EGTNm6DrEl9a7d29cvnxZrW008aGhifarSuyV4e/vj4yMDPGp5Zr6IjD0RKumv+9UMU20e+nfQHmvsk9W14Xq+FwvTU5LX3K5HG+88QZ27typVC8uLq7cdjI3N1fZ5/Hjx2FkZIROnTo993gvkwxXF2NdB0AV69SpE2JjY5XK6tWrJz5dWdcKCwthampapW2LiopgYWEBCwsLDUf1Yra2ti+9D23EXlRUBFNTUygUCo3ul57S5/dda0/wriE02e6pqamwsbFRKnNwcNDIvl+GJn4/K2vfvn1o0aIF7t+/jxUrVuDdd9/F2bNn4enpKdaxsbFBamqq0nYymUxlX+vWrcOIESPwzTffID09Ha6urlqPXxvYQ6TnzMzMoFAolF5GRkYq/y27u7tj9uzZGDhwIKytreHq6orVq1cr7ev48ePw9vaGubk5fH19sX37dpXM/dKlS3jnnXdQu3ZtODo6Ijw8HHfv3hXXBwYGYvjw4RgzZgzs7e0RHBwM4OkfycqVK9G5c2dYWFigQYMG2Lp1q7hd6X8J33//PQIDA2Fubo6NGzc+9/LDhg0b4O7uDrlcjj59+iAvLw/A016zQ4cOYcmSJeJ/LNevXy+37VasWAEPDw+Ym5vD0dER7733ntJ5lG2/mTNn4qOPPkLt2rXh5uaG//u//8M///yDHj16oHbt2vDy8sKZM2fEbV7Uc3P69GkEBwfD3t4ecrkc7dq1w9mzZ5XqyGQyfP311+jRowesrKwwc+ZMpZ6cgwcP4uOPP0ZOTo54vtHR0Zg+fTq8vLxUjtm6dWtMmTJFpfz69eto3749AKBu3bqQyWQYMGAAAKCgoAAjR46Eg4MDzM3N8eabb+L06dPPPa+qthcA/Pjjj2jRogXMzMzg7u6OhQsXKq1/3nsmhfe9Otu5rJycHHzyySdwcHCAjY0NOnTogN9//12pzo4dO+Dr6wtzc3PY29ujV69eSuezfft2pfp16tRBXFzcc4/5os+astT9rKiIg4ODyudqrVpPvw4HDBiAnj174ssvv4STkxPs7Ozw+eefo6ioSNx+48aN8PX1hbW1NRQKBfr27YusrCxxfenf8J49e+Dj4wMLCwt06NABWVlZ+OWXX9CsWTPY2Njggw8+wMOHD8XtqvK5fvv2bfTu3Rt169aFnZ0devTo8dy/jWfZ2dlBoVCgadOmmDVrFoqKinDgwAGlOjKZTKWdHB0dleo8ePAA33//PT777DN07dq1wvdc3zEhqkEWLlwIX19fnDt3DsOGDcNnn32GP//8EwCQl5eHbt26wcvLC2fPnsWMGTMwfvx4pe0zMjLQrl07eHt748yZM0hISMDff/+NsLAwpXrr16+HsbExjh07hlWrVonlkydPxrvvvovff/8dH374IT744AOkpKQobTt+/HiMHDkSKSkpCA0NLfc8rl69iu3bt2PXrl3YtWsXDh06hLlz5wIAlixZAj8/PwwZMgQZGRnIyMiAi4uLyj7OnDmDkSNHYvr06UhNTUVCQgLefvvtCttv8eLFCAgIwLlz59ClSxeEh4fjo48+wocffoizZ8+iUaNG+Oijj1DZ5yHn5eWhf//+OHLkCE6cOAEPDw+88847Kh/YU6dORY8ePXDhwgUMHDhQaZ2/vz9iYmJgY2Mjnm9UVBQGDhyIS5cuKSUu58+fx7lz58RE51kuLi748ccfATz97zgjIwNLliwBAIwbNw4//vgj1q9fL55naGgo7t27p9H2SkpKQlhYGPr06YMLFy4gOjoakydPFj9AK3rPpPa+a7OdyxIEAV26dEFmZiZ2796NpKQktGrVCh07dhR/B37++Wf06tULXbp0wblz57B//374+vpWqj3KU9nPmhep6LPiZRw4cABXr17FgQMHsH79esTFxSm1X2FhIWbMmIHff/8d27dvR1paWrl/d9HR0Vi+fDmOHz+OmzdvIiwsDDExMdi8eTN+/vlnJCYmYtmyZRXGUtHn+sOHD9G+fXvUrl0bhw8fxtGjR1G7dm106tQJhYWFlTrXoqIirFmzBgCq1Eu5ZcsWNGnSBE2aNMGHH36I2NjYSv+t6B2B9Fb//v0FIyMjwcrKSny99957giAIQrt27YRRo0aJdd3c3IQPP/xQXC4pKREcHByElStXCoIgCCtXrhTs7OyER48eiXXWrFkjABDOnTsnCIIgTJ48WQgJCVGK4ebNmwIAITU1VTyut7e3SqwAhE8//VSprG3btsJnn30mCIIgpKWlCQCEmJgYpTqxsbGCXC4Xl6dOnSpYWloKubm5YtnYsWOFtm3bistlz708P/74o2BjY6O0n2e9qP0yMjIEAMLkyZPFst9++00AIGRkZDw39tdee+25MT158kSwtrYWdu7cKZYBECIiIpTqHThwQAAgZGdnl3ucUp07dxbbVxAEISIiQggMDHzu8cvuVxAEIT8/XzAxMRE2bdoklhUWFgrOzs7C/Pnzn7uvqrRX3759heDgYKX9jB07VmjevLkgCOq/Z+Ux5Pe9PNpo59L9Ll68WBAEQdi/f79gY2MjPH78WGmbV199VVi1apUgCILg5+cn9OvX77lxAhC2bdumVCaXy4XY2FhBEP7396/OZ01ZVfmsKKv0b+DZz1QrKyuhcePGYp3+/fsLbm5uwpMnT8Sy999/X+jdu/dz93vq1CkBgJCXl6d0nH379ol15syZIwAQrl69KpYNHTpUCA0NFZfV/Vxfu3at0KRJE6GkpESsU1BQIFhYWAh79uwpN9bS98LCwkKwsrISatWqJQAQ3N3dhX///VesFxsbW25blf3d8vf3Fz/Xi4qKBHt7eyExMVHleKXvvT5jD5Gea9++PZKTk8XX0qVLn1u3ZcuW4s+lXZ2l3bipqalo2bKl0oC4Nm3aKG2flJSEAwcOoHbt2uKradOmAJ7+J1bqef8Z+vn5qSyX7SGqzH+V7u7usLa2FpednJyUuqMrIzg4GG5ubmjYsCHCw8OxadMmpa7p8jzbfqXdws9eliotq2wsWVlZ+PTTT9G4cWPI5XLI5XLk5+cjPT1dqV5V/9MeMmQIvvvuOzx+/BhFRUXYtGlThT0N5bl69SqKiooQEBAglpmYmKBNmzYq711Z6rZXSkqK0nEAICAgAH/99ReKi4ur9J6VVRPfd023c1lJSUnIz8+HnZ2d0t9+Wlqa+HefnJyMjh07VireyqjsZ82LVPWz4siRI0qfq3v27FFa36JFC6VxmmX3e+7cOfTo0QNubm6wtrZGYGAgAKi8x2XfO0tLSzRs2FCp7EXxVvS5npSUhCtXrsDa2lpsR1tbWzx+/PiF7bhlyxacO3cOO3bsQKNGjfDNN9+ojGGytrZWaqfk5GSlMa2pqak4deoU+vTpAwAwNjZG7969sW7dugqPra84qFrPWVlZoVGjRpWqW7a7UyaToaSkBMDTbvGyg+GEMt2aJSUl6NatG+bNm6eybycnJ6WYKqvsMSuzbUXnUVnW1tY4e/YsDh48iL1792LKlCmIjo7G6dOnnzv+49njlsZdXlllYxkwYAD++ecfxMTEwM3NDWZmZvDz81PpylanPZ/VrVs3mJmZYdu2bTAzM0NBQQHeffddtfZR+jtQ3u9GeYMnn6Vue73od7Aq71lZNfF913Q7l1VSUgInJyccPHhQZV1pm71oMLNMJlM5xrNjbso7ZmU+a16kqp8VDRo0qPB3qqL9PnjwACEhIQgJCcHGjRtRr149pKenIzQ0VOU9Lvs+VSXeirYpKSlB69atsWnTJpXt6tWrV+F+XVxc4OHhAQ8PD9SuXRvvvvsuLl26pDS4vFatWhV+/6xduxZPnjzBK6+8IpYJggATExNkZ2ejbt26Fcagb9hDJBFNmzbF+fPnUVBQIJaVHYjZqlUrXLx4Ee7u7mjUqJHSqzIf3idOnFBZLv2vT5NMTU3L/U+3LGNjYwQFBWH+/Pk4f/48rl+/jl9//VXj8TzPkSNHMHLkSLzzzjviANeKBo0+z/PO19jYGP3790dsbCxiY2PRp08fWFpaVrgfAEr7atSoEUxNTXH06FGxrKioCGfOnEGzZs3UjrUizZs3VzoO8HSgf+PGjcX/xit6z6T2vldVZdr5Wa1atUJmZiaMjY1V/u7t7e0BPO2l2L9//3OPWa9ePWRkZIjLf/31V4U9cy/7WaNLf/75J+7evYu5c+firbfeQtOmTdXuwdaUVq1a4a+//oKDg4NKO5ZO21EZ7dq1g6enJ2bNmlXpbZ48eYJvv/0WCxcuVOpB+v333+Hm5lZukqbvmBBJRN++fVFSUoJPPvkEKSkp2LNnD7788ksA//sP8/PPP8e9e/fwwQcf4NSpU7h27Rr27t2LgQMHVuqLaOvWrVi3bh0uX76MqVOn4tSpUxg+fLjGz8Xd3R0nT57E9evXcffu3XL/w9q1axeWLl2K5ORk3LhxA99++y1KSkrQpEkTjcfzPI0aNcKGDRuQkpKCkydPol+/flW6bdjd3R35+fnYv38/7t69q/RFM3jwYPz666/45ZdfXni5zM3NDTKZDLt27cI///yD/Px8WFlZ4bPPPsPYsWORkJCAS5cuYciQIXj48CEGDRqkdqwViYyMxP79+zFjxgxcvnwZ69evx/LlyxEVFQXgxe+Z1N73qnpRO5cVFBQEPz8/9OzZE3v27MH169dx/PhxfPHFF+I/TVOnTsV3332HqVOnIiUlBRcuXMD8+fPFfXTo0AHLly/H2bNncebMGXz66acVDtB92c+al5WVlYXMzEylV0U9Ws9ydXWFqakpli1bhmvXrmHHjh06mxOuX79+sLe3R48ePXDkyBGkpaXh0KFDGDVqFG7duqXWviIjI7Fq1Srcvn1bLBMEQaWdMjMzUVJSgl27diE7OxuDBg2Cp6en0uu9997D2rVrlfafmpqqcvmtsgO/qwsTIomwsbHBzp07kZycDG9vb0yaNEm8Pbt0XJGzszOOHTuG4uJihIaGwtPTE6NGjYJcLhdvSa3ItGnTEB8fj5YtW2L9+vXYtGkTmjdvrvFziYqKgpGREZo3by52V5dVp04d/PTTT+jQoQOaNWuGr7/+Gt999x1atGih8XieZ926dcjOzoaPjw/Cw8PFW9vV5e/vj08//RS9e/dGvXr1lL6IPDw84O/vjyZNmqBt27YV7ueVV17BtGnTMGHCBDg6OorJ6ty5c/Huu+8iPDwcrVq1wpUrV7Bnzx6Nd3e3atUK33//PeLj4+Hp6YkpU6Zg+vTp4t05L3rPpPa+V9WL2rksmUyG3bt34+2338bAgQPRuHFj9OnTB9evXxfHJwUGBmLr1q3YsWMHvL290aFDB5w8eVLcx8KFC+Hi4oK3334bffv2RVRUVIW9lS/7WfOymjRpAicnJ6VXUlJSpbatV68e4uLisHXrVjRv3hxz584V/7msbpaWljh8+DBcXV3Rq1cvNGvWDAMHDsSjR49U5ll6ka5du8Ld3V2plyg3N1elnUrHU61duxZBQUHl9kS9++67SE5OVppuok+fPvDx8VF63blzp+onrwUyoaKLy1Sjbdq0SZzj5mX/g5XJZNi2bRt69uypmeCoUgRBQNOmTTF06FCMGTNG1+EQERksDqqWkG+//RYNGzbEK6+8gt9//x3jx49HWFiYTmaKppeXlZWFDRs24Pbt2/j44491HQ4RkUFjQiQhmZmZmDJlCjIzM+Hk5IT3339frUF0pF8cHR1hb2+P1atXG9zdHERE+oaXzIiIiEjyOKiaiIiIJI8JEREREUkeEyIiIiKSPCZEREREJHlMiIiIiEjymBARERGR5DEhIiIiIsljQkRERESS9/8AQ6SJjcA+t/MAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bins = np.linspace(0, 1, 100)\n", + "\n", + "plt.hist(ref_enamine_subset_df[\"fingerprint-similarity\"], bins, alpha=0.5, label=\"Rejected ligands\")\n", + "plt.hist(enamine_subset_df[\"fingerprint-similarity\"], bins, alpha=0.5, label=\"CustomKinFragLib\")\n", + "plt.axvline(np.mean(enamine_subset_df[\"fingerprint-similarity\"]), color=\"tab:orange\")\n", + "plt.axvline(np.mean(ref_enamine_subset_df[\"fingerprint-similarity\"]), color=\"tab:blue\")\n", + "plt.legend(loc='upper left')\n", + "plt.ylabel(\"# Molecules\")\n", + "plt.xlabel(\"Fingerprint similarity to most similar molecule in Enamine REAL\")\n", + "plt.savefig(\"figures/enamine_similarity_enumerated_mols.pdf\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.06730502359145157" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(enamine_subset_df[enamine_subset_df['fingerprint-similarity'] == 1.0]) / len(enamine_subset_df)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.021926348602525493" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(ref_enamine_subset_df[ref_enamine_subset_df['fingerprint-similarity'] == 1.0]) / len(ref_enamine_subset_df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "kinfraglib_custom2", + "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.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/custom_kinfraglib/2_4_custom_filters_paper.ipynb b/notebooks/custom_kinfraglib/2_5_custom_filters_paper.ipynb similarity index 100% rename from notebooks/custom_kinfraglib/2_4_custom_filters_paper.ipynb rename to notebooks/custom_kinfraglib/2_5_custom_filters_paper.ipynb diff --git a/notebooks/custom_kinfraglib/README.md b/notebooks/custom_kinfraglib/README.md index c4f9c567..c236cdd0 100644 --- a/notebooks/custom_kinfraglib/README.md +++ b/notebooks/custom_kinfraglib/README.md @@ -22,7 +22,9 @@ single filtering steps and modify the parameters. This notebook analyzes the custom-filtered fragment library and compares it with the pre-filtered and the reduced fragment set from the previous study. ### `2_3_custom_filters_kinase_mapping.ipynb` This notebook analyzes the number of kinases that have bound ligands represented in the fragment library. -### `2_4_custom_filters_paper.ipynb` +### `2_4_custom_filters_enumeration_analysis.ipynb` +This notebook creates two fragment enumeration sets to compare molecules from CustomKinFragLib fragments with molecules from rejected fragments. It analyzes the full molecules for drug-likeness and synthesizability. +### `2_5_custom_filters_paper.ipynb` This notebook contains all the code used to generate figures for the CustomKinFragLib paper. ## Requirements To successfully apply the pairwise retrosynthesizability filters in `1_4_custom_filters_pairwise_retrosynthesizability.ipynb` and `2_1_custom_filters_pipeline.ipynb`, the ASKCOS API might need to be installed following the [Documentation](https://askcos-docs.mit.edu/guide/1-Introduction/1.1-Introduction.html). Note that for the data used in the notebooks, all results from ASKCOS are already precomputed and ASKCOS does not need to be installed to run the notebooks. However, if new data is added ASKCOS needs to be installed and run (using `make start` within the `askcos2_core` directory which is obtained following the [installation](https://askcos-docs.mit.edu/guide/1-Introduction/1.1-Introduction.html)). The full ASKCOS installation needs up to 32GB of RAM, so we recommend using a partial deployment as explained in the [documentation](https://askcos-docs.mit.edu/guide/4-Deployment/4.1-Customizing-local-deployment.html). \ No newline at end of file