From ae79f6ec1ce8bb690a17161ef1518708ac932cc1 Mon Sep 17 00:00:00 2001 From: Jalil Nourisa Date: Fri, 20 Sep 2024 20:30:06 +0200 Subject: [PATCH] binarize metric 1 --- batch_run.sh | 3 +- runs.ipynb | 674 ++++++++++------------ scripts/run_grn_evaluation.sh | 11 +- src/methods/single_omics/tigress/script.R | 24 +- src/metrics/regression_1/config.vsh.yaml | 5 + src/metrics/regression_1/main.py | 11 +- 6 files changed, 340 insertions(+), 388 deletions(-) diff --git a/batch_run.sh b/batch_run.sh index e4e08ecf8..2f21c876d 100644 --- a/batch_run.sh +++ b/batch_run.sh @@ -5,7 +5,8 @@ # sbatch --job-name=grnboost2_donor0_hvg scripts/sbatch/single_omics.sh scenic grnboost2 # sbatch --job-name=genie3_donor0_hvg scripts/sbatch/single_omics.sh scenic genie3 -sbatch --job-name=ppcor_donor0_hvg scripts/sbatch/single_omics_R.sh ppcor ppcor +# sbatch --job-name=ppcor_donor0_hvg scripts/sbatch/single_omics_R.sh ppcor ppcor +sbatch --job-name=tigress_donor0_hvg scripts/sbatch/single_omics_R.sh tigress tigress # sbatch --job-name=scglue_donor0_hvg scripts/sbatch/scglue.sh scglue scglue diff --git a/runs.ipynb b/runs.ipynb index 95253d546..9a27f1c23 100644 --- a/runs.ipynb +++ b/runs.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -63,6 +63,8 @@ " df_reg1 = extract_data(data, reg='reg1').reindex(models_all).drop(columns=['Mean'])\n", " df_reg2 = extract_data(data, reg='reg2').reindex(models_all).drop(columns=['Mean'])\n", " # df_all = pd.concat([df_reg1, df_reg2], axis=1).fillna(0)\n", + " # df_all_n = (df_all-df_all.min(axis=0))/(df_all.max(axis=0)-df_all.min(axis=0))\n", + " # df_all['Rank'] = df_all_n.mean(axis=1).rank(ascending=False).astype(int)\n", " df_all = pd.concat([df_reg1, df_reg2], axis=1)\n", " return df_all" ] @@ -71,7 +73,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Add to process data pipeline" + "# Add to somewhere" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# process multiomics data pipeline" ] }, { @@ -122,6 +131,55 @@ "adata[adata.obs.donor_id=='donor_0', adata.var.highly_variable].write('resources/grn-benchmark/multiomics_rna_d0_hvg.h5ad')" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## binarize grn" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import pandas as pd\n", + "\n", + "# Define base directory and subfolder to save binarized files\n", + "base_dir = 'resources/grn_models/d0_hvgs'\n", + "output_dir = os.path.join(base_dir, 'binarized')\n", + "\n", + "# Create the subfolder if it doesn't exist\n", + "os.makedirs(output_dir, exist_ok=True)\n", + "\n", + "# Define the binarization function\n", + "def binarize_weight(weight):\n", + " if weight > 0:\n", + " return 1\n", + " elif weight < 0:\n", + " return -1\n", + " else:\n", + " return 0\n", + "\n", + "# Iterate through all files in the base directory\n", + "for filename in os.listdir(base_dir):\n", + " # Check if the file is a CSV (or the appropriate file extension)\n", + " if filename.endswith('.csv'):\n", + " file_path = os.path.join(base_dir, filename)\n", + " \n", + " # Read the file into a DataFrame\n", + " df = pd.read_csv(file_path, index_col=0)\n", + " \n", + " # Apply binarization to the 'weight' column\n", + " df['weight'] = df['weight'].apply(binarize_weight)\n", + " \n", + " # Save the modified DataFrame to the subfolder\n", + " output_file_path = os.path.join(output_dir, filename)\n", + " df.to_csv(output_file_path, index=False)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -261,7 +319,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Test analysis" + "# Runs\n" ] }, { @@ -499,34 +557,247 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "methods = [ 'pearson_corr', 'pearson_causal', 'positive_control', 'portia', 'ppcor', 'genie3', 'grnboost2', 'scenic', 'scglue', 'celloracle']" + ] + }, + { + "cell_type": "code", + "execution_count": 11, "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "download: s3://openproblems-data/resources/grn/results/d0_hvgs/trace.txt to resources/results/d0_hvgs/trace.txt\n" - ] - }, - { - "ename": "FileNotFoundError", - "evalue": "[Errno 2] No such file or directory: 'resources/results/d0_hvgs/scores.yaml'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mFileNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[3], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m RUN_ID\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124md0_hvgs\u001b[39m\u001b[38;5;124m\"\u001b[39m \n\u001b[0;32m----> 2\u001b[0m df_all \u001b[38;5;241m=\u001b[39m \u001b[43mprocess_data\u001b[49m\u001b[43m(\u001b[49m\u001b[43mRUN_ID\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmodels_all\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n\u001b[1;32m 3\u001b[0m df_all\u001b[38;5;241m.\u001b[39mstyle\u001b[38;5;241m.\u001b[39mbackground_gradient()\n", - "Cell \u001b[0;32mIn[2], line 35\u001b[0m, in \u001b[0;36mprocess_data\u001b[0;34m(RUN_ID, models_all)\u001b[0m\n\u001b[1;32m 31\u001b[0m base_folder \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mresources/results/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mRUN_ID\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m 32\u001b[0m result_file \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mbase_folder\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m/scores.yaml\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[0;32m---> 35\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28;43mopen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mresult_file\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mr\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m \u001b[38;5;28;01mas\u001b[39;00m file:\n\u001b[1;32m 36\u001b[0m data \u001b[38;5;241m=\u001b[39m yaml\u001b[38;5;241m.\u001b[39msafe_load(file)\n\u001b[1;32m 39\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m models_all \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n", - "File \u001b[0;32m~/miniconda3/envs/py10/lib/python3.10/site-packages/IPython/core/interactiveshell.py:324\u001b[0m, in \u001b[0;36m_modified_open\u001b[0;34m(file, *args, **kwargs)\u001b[0m\n\u001b[1;32m 317\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m file \u001b[38;5;129;01min\u001b[39;00m {\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m}:\n\u001b[1;32m 318\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 319\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIPython won\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mt let you open fd=\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mfile\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m by default \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 320\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mas it is likely to crash IPython. If you know what you are doing, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 321\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124myou can use builtins\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m open.\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 322\u001b[0m )\n\u001b[0;32m--> 324\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mio_open\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfile\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n", - "\u001b[0;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'resources/results/d0_hvgs/scores.yaml'" - ] + "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", + "
 ex(False)_tf(-1)ex(True)_tf(-1)static-theta-0.0static-theta-0.5
pearson_corr0.2396200.5182170.5295020.524232
pearson_causal0.3646560.5924570.7413280.560490
positive_control0.4925630.6815680.6554070.574608
portia0.0100700.0125560.4512560.518048
ppcor0.0090180.0069490.3966800.509874
genie30.1627380.2042690.7540730.576580
grnboost20.1283550.1704970.7818520.609075
scenic0.1377830.1490620.6008390.574294
scglue0.0670170.2001350.4486170.527076
celloracle0.2547190.3586230.6395560.580147
\n" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "\n", "RUN_ID=\"d0_hvgs\" \n", - "df_all = process_data(RUN_ID, models_all=None)\n", + "df_all = process_data(RUN_ID, models_all=methods)\n", "df_all.style.background_gradient()" ] }, @@ -534,32 +805,28 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Commands" + "# Sync" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "delete: s3://openproblems-data/resources/grn/grn-benchmark/multiomics_atac_0.h5ad\n", - "upload: resources/grn-benchmark/multiomics_atac_d0.h5ad to s3://openproblems-data/resources/grn/grn-benchmark/multiomics_atac_d0.h5ad\n", - "delete: s3://openproblems-data/resources/grn/supplementary/JASPAR2022-hg38.bed.gz\n", - "delete: s3://openproblems-data/resources/grn/supplementary/grn_models_noised/granie.csv\n", - "delete: s3://openproblems-data/resources/grn/supplementary/grn_models_noised/scglue.csv\n", - "delete: s3://openproblems-data/resources/grn/supplementary/hvgs.txt\n", - "delete: s3://openproblems-data/resources/grn/supplementary/grn_models_noised/collectri.csv\n", - "delete: s3://openproblems-data/resources/grn/supplementary/gene_location.csv\n", - "delete: s3://openproblems-data/resources/grn/supplementary/cell_topic.csv\n", - "delete: s3://openproblems-data/resources/grn/supplementary/grn_models_noised/figr.csv\n", - "delete: s3://openproblems-data/resources/grn/supplementary/grn_models_noised/ananse.csv\n", - "delete: s3://openproblems-data/resources/grn/supplementary/gencode.v45.annotation.gtf.gz\n", - "delete: s3://openproblems-data/resources/grn/supplementary/grn_models_noised/celloracle.csv\n", - "delete: s3://openproblems-data/resources/grn/supplementary/grn_models_noised/scenicplus.csv\n" + "upload: resources/grn_models/d0_hvgs/binarized/scglue.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/scglue.csv\n", + "upload: resources/grn_models/d0_hvgs/binarized/genie3.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/genie3.csv\n", + "upload: resources/grn_models/d0_hvgs/binarized/scenic.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/scenic.csv\n", + "upload: resources/grn_models/d0_hvgs/binarized/celloracle.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/celloracle.csv\n", + "upload: resources/grn_models/d0_hvgs/binarized/portia.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/portia.csv\n", + "upload: resources/grn_models/d0_hvgs/binarized/pearson_causal.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/pearson_causal.csv\n", + "upload: resources/grn_models/d0_hvgs/binarized/positive_control.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/positive_control.csv\n", + "upload: resources/grn_models/d0_hvgs/binarized/grnboost2.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/grnboost2.csv\n", + "upload: resources/grn_models/d0_hvgs/binarized/pearson_corr.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/pearson_corr.csv\n", + "upload: resources/grn_models/d0_hvgs/binarized/ppcor.csv to s3://openproblems-data/resources/grn/grn_models/d0_hvgs/binarized/ppcor.csv\n" ] } ], @@ -567,26 +834,8 @@ "!aws s3 sync resources/grn-benchmark s3://openproblems-data/resources/grn/grn-benchmark --delete\n", "!aws s3 sync resources/grn_models/ s3://openproblems-data/resources/grn/grn_models --delete\n", "!aws s3 sync resources/prior/ s3://openproblems-data/resources/grn/prior --delete\n", - "!aws s3 sync resources/supplementary/ s3://openproblems-data/resources/grn/supplementary --delete" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "delete: resources/grn-benchmark/multiomics_rna_qc.h5ad\n", - "download: s3://openproblems-data/resources/grn/grn-benchmark/multiomics_rna.h5ad to resources/grn-benchmark/multiomics_rna.h5ad\n", - "download: s3://openproblems-data/resources/grn/grn-benchmark/multiomics_rna_0.h5ad to resources/grn-benchmark/multiomics_rna_0.h5ad\n" - ] - } - ], - "source": [ - "!aws s3 sync s3://openproblems-data/resources/grn/grn-benchmark resources/grn-benchmark --delete" + "!aws s3 sync resources/supplementary/ s3://openproblems-data/resources/grn/supplementary --delete\n", + "!aws s3 sync resources/results/ s3://openproblems-data/resources/grn/results --delete" ] }, { @@ -2383,311 +2632,6 @@ "source": [ "(corr_scores\n", - "#T_741a5_row0_col0, #T_741a5_row0_col1, #T_741a5_row0_col2, #T_741a5_row0_col3, #T_741a5_row1_col0, #T_741a5_row1_col1, #T_741a5_row1_col2, #T_741a5_row1_col3, #T_741a5_row3_col4, #T_741a5_row4_col0, #T_741a5_row4_col1, #T_741a5_row4_col2, #T_741a5_row4_col3, #T_741a5_row5_col0, #T_741a5_row5_col1, #T_741a5_row5_col2, #T_741a5_row5_col3, #T_741a5_row6_col0, #T_741a5_row6_col1, #T_741a5_row6_col2, #T_741a5_row6_col3, #T_741a5_row7_col0, #T_741a5_row7_col1, #T_741a5_row7_col2, #T_741a5_row7_col3, #T_741a5_row8_col0, #T_741a5_row8_col1, #T_741a5_row8_col2, #T_741a5_row8_col3, #T_741a5_row9_col0, #T_741a5_row9_col1, #T_741a5_row9_col2, #T_741a5_row9_col3, #T_741a5_row11_col0, #T_741a5_row11_col1, #T_741a5_row11_col2, #T_741a5_row11_col3, #T_741a5_row13_col0, #T_741a5_row13_col1, #T_741a5_row13_col2, #T_741a5_row13_col3 {\n", - " background-color: #fff7fb;\n", - " color: #000000;\n", - "}\n", - "#T_741a5_row0_col4, #T_741a5_row1_col4, #T_741a5_row3_col0, #T_741a5_row3_col1, #T_741a5_row4_col4, #T_741a5_row5_col4, #T_741a5_row6_col4, #T_741a5_row7_col4, #T_741a5_row8_col4, #T_741a5_row9_col4, #T_741a5_row11_col4, #T_741a5_row12_col2, #T_741a5_row12_col3, #T_741a5_row13_col4 {\n", - " background-color: #023858;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row2_col0 {\n", - " background-color: #0872b1;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row2_col1 {\n", - " background-color: #045b8e;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row2_col2 {\n", - " background-color: #045585;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row2_col3 {\n", - " background-color: #03456c;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row2_col4 {\n", - " background-color: #ece7f2;\n", - " color: #000000;\n", - "}\n", - "#T_741a5_row3_col2 {\n", - " background-color: #0569a5;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row3_col3 {\n", - " background-color: #023d60;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row10_col0 {\n", - " background-color: #fcf4fa;\n", - " color: #000000;\n", - "}\n", - "#T_741a5_row10_col1 {\n", - " background-color: #fdf5fa;\n", - " color: #000000;\n", - "}\n", - "#T_741a5_row10_col2 {\n", - " background-color: #5ea0ca;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row10_col3 {\n", - " background-color: #04588a;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row10_col4 {\n", - " background-color: #a5bddb;\n", - " color: #000000;\n", - "}\n", - "#T_741a5_row12_col0 {\n", - " background-color: #60a1ca;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row12_col1 {\n", - " background-color: #4697c4;\n", - " color: #f1f1f1;\n", - "}\n", - "#T_741a5_row12_col4 {\n", - " background-color: #d0d1e6;\n", - " color: #000000;\n", - "}\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
 ex(False)_tf(-1)ex(True)_tf(-1)static-theta-0.0static-theta-0.5Rank
negative_control0.0000000.0000000.0000000.0000009
pearson0.0000000.0000000.0000000.0000009
pearson_causal0.3646560.5924570.7413280.5604902
positive_control0.4925630.6815680.6554070.5746081
collectri0.0000000.0000000.0000000.0000009
granie0.0000000.0000000.0000000.0000009
figr0.0000000.0000000.0000000.0000009
celloracle0.0000000.0000000.0000000.0000009
scglue0.0000000.0000000.0000000.0000009
scenicplus0.0000000.0000000.0000000.0000009
portia0.0100700.0125560.4512560.5180484
ppcor0.0000000.0000000.0000000.0000009
grnboost20.2656090.4032310.8310480.5883933
genie30.0000000.0000000.0000000.0000009
\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "\n", - "!aws s3 sync s3://openproblems-data/resources/grn/results/{run_id} resources/results/{run_id}\n", - "\n", - "base_folder = f'resources/results/{run_id}'\n", - "models_all = ['negative_control', 'pearson', \n", - " 'pearson_causal', 'positive_control', 'collectri','granie', 'figr', 'celloracle', \n", - " 'scglue', 'scenicplus', 'portia','ppcor', 'grnboost2', 'genie3']\n", - "\n", - "def extract_data(data, reg='reg1', dataset_id='scgen_pearson'):\n", - " i = 0\n", - " for entry in data:\n", - " if entry['dataset_id']!=dataset_id:\n", - " continue\n", - " try:\n", - " rg, method_id = entry['method_id'].split('-')\n", - " except:\n", - " rg, method_id, _ = entry['method_id'].split('-')\n", - " if rg != reg:\n", - " continue\n", - " dataset_id = entry['dataset_id']\n", - " metric_ids = entry['metric_ids']\n", - " metric_values = entry['metric_values']\n", - " \n", - " df = pd.DataFrame([metric_values], index=[method_id], columns=metric_ids)\n", - " if i==0:\n", - " df_reg = df\n", - " else:\n", - " df_reg = pd.concat([df_reg, df], axis=0)\n", - " i+=1\n", - " return df_reg\n", - "import yaml\n", - "import pandas as pd\n", - "\n", - "\n", - "result_file = f'{base_folder}/scores.yaml'\n", - "with open(result_file, 'r') as file:\n", - " data = yaml.safe_load(file)\n", - "if True:\n", - " df_reg1 = extract_data(data, reg='reg1').reindex(models_all).drop(columns=['Mean'])\n", - " df_reg2 = extract_data(data, reg='reg2').reindex(models_all).drop(columns=['Mean'])\n", - "else:\n", - " df_reg1 = extract_data(data, reg='reg1').drop(columns=['Mean'])\n", - " df_reg2 = extract_data(data, reg='reg2').drop(columns=['Mean'])\n", - "df_all = pd.concat([df_reg1, df_reg2], axis=1).fillna(0)\n", - "df_all[df_all<0]=0\n", - "df_all_n = (df_all-df_all.min(axis=0))/(df_all.max(axis=0)-df_all.min(axis=0))\n", - "df_all['Rank'] = df_all_n.mean(axis=1).rank(ascending=False).astype(int)\n", - "df_all.style.background_gradient()" - ] - }, - { - "attachments": { - "image.png": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABSsAAAGlCAYAAAASx6OeAAAgAElEQVR4Aey9+9dtV1nneYZS/0OPdnSNtstRWm1DqmzLSykCGhJL7SrbilaQ8tIGK9il0tFKtTUqQYhXEFsgAQllQDECMQpICCSBcEuAJObCyYWcBHKSnOQkOTnnTTyOkfiDP6we343fxfM+71xr7f3uy7vW3J93jO1ca16eOednrhPW+jjX3oca/iAAAQhAAAIQgAAEIAABCEAAAhCAAAQgAAEIjIDAoRGMgSFAAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACEGiQlVwEEIAABCAAAQhAAAIQgAAEIAABCEAAAhCAwCgIICtHsQwMAgIQgAAEIAABCEAAAhCAAAQgAAEIQAACEEBWcg1AAAIQgAAEIAABCEAAAhCAAAQgAAEIQAACoyCArBzFMjAICEAAAhCAAAQgAAEIQAACEIAABCAAAQhAAFnJNQABCEAAAhCAAAQgAAEIQAACEIAABCAAAQiMggCychTLwCAgAAEIQAACEIAABCAAAQhAAAIQgAAEIACBVlaePHmy4QMDrgGuAa4BrgGuAa4BroFpXgPc1kIAAhCAAAQgAAEIQKAGAshKJC2SmmuAa4BrgGuAa4BroIJroIYbU+YAAQhAAAIQgAAEIAABZGUFDyfsgJnmDhjWjXXjGuAa4BrgGljlNcBtLQQgAAEIQAACEIAABGoggKxEVrKbhmuAa4BrgGuAa4BroIJroIYbU+YAAQhAAAIQgAAEIAABZGUFDyer3JVBLHb5cA1wDXANcA1wDUzzGuC2FgIQgAAEIAABCEAAAjUQQFYiK9lNwzXANcA1wDXANcA1UME1UMONKXOAAAQgAAEIQAACEIAAsrKChxN2wExzBwzrxrpxDXANcA1wDazyGuC2FgIQgAAEIAABCEAAAjUQQFYiK9lNwzXANcA1wDXANcA1UME1UMONKXOAAAQgAAEIQAACEIAAsrKCh5NV7sogFrt8uAa4BrgGuAa4BqZ5DXBbCwEIQAACEIAABCAAgRoIICuRlSvZTfORj3ykOXToUPNrv/ZrzQMPPNB8//d//+xcef6obOgBWHVU/x3veMdg3a5YjqExddWZJz/OQ/PRudrFuQ7F+cIXvtB867d+62xOHs+xY8ean/7pn57lq3woxibL49he97rXtWvnNYyp57PK8a177bwe4q+59o3dLDRnX7vO05qObe365qIy/ZuKcxmqP2+512yZf7Pz9jVPPY9Hc43/bkttvZ6+rue5LkpxDiqPNd0rFOP6e11XdW3G/01wbKWrvG7cx37/G1PDjSlzgAAEIAABCEAAAhCAALISWdkrbOZ5CPfDlcWAz+PDnI4tfPpi+kFzmYdLCwiPp68/lZXko2N4Do7lufm8K7brub3SKPdcvsqH3K6xLJJv+aHUx3EO8TjOZ5E++uqa+xBfx1hk7Rx7Hgng69DzjdfupteuNEfPvysttfF6xrl0te/KL8U1K8XvateXb57zrnlfLI/F66a069+Yr4dYV8fL8OkbWywrcYzlpeNSm1WsqWPE9TPHmFcaU1fe2NZ0v/PI8/O88jXTd53lGEPn7mOe/06VYnFbCwEIQAACEIAABCAAgRoIICuRlfsSDPEhyQ/RfiBc5mFr2Ydkj0tj0QOkx+T8Uuq6UVJ0zSHPtRRPeW4vUSIJo7Gobazvueb8WGeTx5Y3JWnksc7Dc9kxez3m6ct151k776qMdbvGqjrioPXT2uU2Oi+taVe8ZfJLcxyKt582QzFVXoprFiqbJ0au43UpXXe5bt+541jy+N9g1zr537L7ze37+lq2rMRxKOZ+2gzFVHlp/Up588RyHbM0W+cvmjrOvGva99+wRfsu1fc15fGoTr6OSu0WySv1sUj7Gm5MmQMEIAABCEAAAhCAAASQlcjKmWDwA5ce7PWxePBDqx86/SDlOn44jA9vrhPz/LDlMvejVH243P25/zyuuEsql7mNYvkhN9Z3HzF1fx6Pxvz+97+/fXXb+Yrz4IMPLvz6dpyvxhv79vjj/GP5fo5jfxq7528eyjMnpTr32vaNx5zcVmNz+1/8xV+c9aM411133YydY8Z6cZ7uy3xjXI/VY+/i4DE5Rt/a6Tp1/bwOXfGV7zZx7Mr3+HN+X6yhMvfl+YhJzvO/Kffvuko9r642Xq84ZrN2nD7mXXGdH8frcXrOXddlaR6Kk+trfHHcjhtTx4pziGOLdXWcefi/ZZFlbrPoufs338jIeWbl8Ts/jiPHcZs8B41v3jWN83Wf/nfr/uJ43acZ5DUy99I8FCfXV5/qx/FKqWM5turEseU2nlOsn+ssc+45RBZeA/fpMZipUpepb9fXPHysOjpWee4jrucQL7XnDwIQgAAEIAABCEAAAjUQQFYiK3c9MMUHLD0oxgcvPUz54coPTX6w8kNufNiKsXSsePHBK5b7QS0+iJbq+qHP44gx3IfG4HHHcSk/f9yf4+ghtEtW3n333TOxNxQz9mE+cWwud5nn5Pz9piVe6tdr5Qd/jf+WW26ZzaX00O21iOMwp1iW10Bx55GVuZ3Za3zqcx1rtx/RrLF43mZoJqteuxIT5bl/M/J6leq7bKiN5+LrwbGV9l2LXXFzvuM5Vt91WRqD5tbVRmVeg5yaiecX16/UzuN2ma87jd/XYu5jkXOPxzyUKs/9Ot/rVqrvsqE2nnOJp9chjz3O12Pxf9tyfy53rK71UbvSGDS3rjYqy2PzuZl4fsr32Ert/O/S41XqMTvmMmkpvvvyNdNVx3PwnNzOqdm7vdb+U5/61Gz8quP2Q+Ov4caUOUAAAhCAAAQgAAEIQABZWRBYQw8DNZXHB1Y/bPlh0w9H+SHTD1Xi4LL4QOiHLT+EOXX8yM8Pbu5Lqeor37F1HtvOM2bX8cN+7DMf5zGo3HOI7T2eONccK587Tp5D7CPyzO0XOc/zcN8xvvl6TdTGfbgsss5lsb77i/HNKOa5nuJ7XSKPfL25TmTvceQ0xnaZ5x3bOy+Oy/X7UjNRGuvtN16MEY89j9L4XJbH4PbmFZmW2sS82KYrruPHNMZwfmbk9fRccpvMrnTNOLbTHMP5MS3V8dhUFuvqOJdFJqV/A7n90LnHYw6xvsu62JfGUmoT82KbrrhxDD7OHJTvPMeZypr62vJ/35x6Hp7zftNS/PjfmVJcs/P/bnjNfO7r33Hch85///d/f/a/h65bip/zuK2FAAQgAAEIQAACEIBADQSQlVsuK/1g5Ie6mMYHPD+8qlwPW35A8oNWfJhyTD98ua5S14/96Nh9uR/34XPX17njOy+mjuMH99IY4nh07IdHt1We+4jtPfbSXD2GWBbjqDwLEPdRkhl5jPOcZ1YeU4zvOags5iu+2+dxxjKvi/JK3Bw/xo71PGePLabmv461c79xXM7zGPLaxXl7bMrTx21jPJftJ3U8j0Wp1yHyc2znxfrzttFc3F+8vh1bqa8FxYx13G/k4boqU9t8Dbg8j9Xscv0YI7dxvzGmx+exxXV0PY+tNEfH9HUXOcb6ix6bcZzDGNe0xCjn5TVyeZybjg96TfMaiXccVy5f9Nxr6muuFN91Mhtfl75Ofd3F+ooXzx2jdP12jb2GG1PmAAEIQAACEIAABCAAAWQlsnL2gKmHIj9I54cgP6j6wckPaqrnBys/pMa8WM8x9YAW8/3Q6wc3n+eHMz8Uagzve9/7Bsds8RDH5THkND88ds2hb65m4wdS9+E2Jb4uy23cdtHU7Myy1N51PN5Y1xwye8Vxu1jm+jGGrxWvsddB/ame51zi4fG6zSrXzjE9LvUVx6LxlNbB845zjG1LbTyP/abu0/PPnD1u9+3zyDS30VhinnmojfI91ve85z2z3a8eg8ojsxjDbVzXcXwNePwuV+o2Mc31Vaa6sd8cw+dxfI7jdvk89qlj/zfF48znuf4y5x6v+8ocvYYHsaYem9dP88x5Zunxu1xpiUuu75heG59r/RzDMZdZ0zwWczbXXL7oudfJ84j/jjwP9+n/PfW5x+Bz13dMzVttfK4+9O9RqfubZ7zc1kIAAhCAAAQgAAEIQKAGAsjKLZeVevjxw5MelvzxQ6kfnPwg5QdKP2j5YS0+TLlNzPNDltu7H6eO53KNyQ+8rqPUMfvGrL48Bj8guv9SGmM5vtv7XO1Kcy3Fi3mOo7H74dXlnp/n7vz9po4XecV+PU8x0XehaW5xfpY1pfHEdfH4HC/Wj/P1OH70R390dl25ntu5XKmvN8V2jFWuneJ6DnkdPJ9S6jYeu+uYdc53+aJpiYnnH8u0Xtdff30r6yNDHXtuuY3G6zyP2ecxhvvsGn9s42vHjFSmdmbjNfV57CeONZcrjmPmNh57aXz+95nbeE7ux+PydZbr9/VR6rcrL7JyHx5LLDvoNY2szcZ5U1tTr7F5O/U8utZq3nxfM7721S72qX9/cW3dv9K89r7OHFN11N7n7sNr4fZDY63hxpQ5QAACEIAABCAAAQhAAFmJrJwJhvyApYfWw4cPt1/u7wclP0jpwcoPgG7rc9fxw1Z8uIoPdnoIc1s/uPnBTPmxrh/6LGMU021d5gdtlaleHGMcQz72eFXfY3aez93GfSp1Xl/qOIodx642jpXz++INlXUxM484Dvdvbh6rz2NfcV2c7/ZeO+fHvlRWquc8jUef2Kfbq45jdqUes2J4rZznc7d13Dxel5dSzzu38fgVs9Ru0TzHK/HwfOIcY/2rr766/Xfq8fS1iXMxE/cby0pzKMU1I6+Xr8G4ps5zP0o9VvXjGMpXnFhfZZ7v0PiysPR/t9SHY8Zxxfmo76H4JSZdeR6z59zVr6/TWH+Ta2ouGqfH6PXQmLrYxXae40Gv6dCYutZq3nxfL14ztzMv8bv11lvb/2eCrj+tpfj4WvQ6+1pzTNURP5+7D5/HGO63lHJbCwEIQAACEIAABCAAgRoIICuRlUvLFj9M+UG39AC1yTwLi3WMZ1VzdRw/wG6ST19ffpC2pOiru46yda6dY1sC7Hf8Y127/c6Hdl/9HlI4wKGGa6CGG1PmAAEIQAACEIAABCAAAWQlsnJpWakHPO/Q8m6Rg3zo8y6Xrl0+3gW0X2m17FxXJc3Wwfigx7butfPOq/1K4oPms441JyaSjmugnmuA21oIQAACEIAABCAAAQjUQABZiaxciazkYbeeh13WkrXkGuAa4BqY5jVQw40pc4AABCAAAQhAAAIQgACyElmJrOQa4BrgGuAa4BrgGqjgGuC2FgIQgAAEIAABCEAAAjUQQFZW8HDCDphp7oBh3Vg3rgGuAa4BroFVXgM13JgyBwhAAAIQgAAEIAABCCArkZXspuEa4BrgGuAa4BrgGqjgGuC2FgIQgAAEIAABCEAAAjUQQFZW8HCyyl0ZxGKXD9cA1wDXANcA18A0r4EabkyZAwQgAAEIQAACEIAABJCVyEp203ANcA1wDXANcA1wDVRwDXBbCwEIQAACEIAABCAAgRoItLKyhskwhwKBv/v7puEDA64BrgGuAa4BroHea+DrvuvcZuqfwl0AWRCAAAQgAAEIQAACEJgcAWTl5JZswQHzcNr7cIrIRWZzDXANcA1wDegamLqo1Pj5gwAEIAABCEAAAhCAQA0EkJU1rGLfHJCVyEquAa4BrgGuAa6BwWsAWdl3M0EZBCAAAQhAAAIQgAAENkcAWbk51gfTEw+ogw+o7KpiVxXXANcA1wDXALLyYG5T6BUCEIAABCAAAQhAAAKZALIyE6ntHFmJrOQa4BrgGuAa4BoYvAaQlbXdADEfCEAAAhCAAAQgAIGpEkBWTnXl5h03D6iDD6jsqGJHFdcA1wDXANcAsnLeGwvqQQACEIAABCAAAQhAYL0EkJXr5Xvw0ZGVyEquAa4BrgGuAa6BwWsAWXnwtyyMAAIQgAAEIAABCEAAAiKArKz9OuABdfABlR1V7KjiGuAa4BrgGkBW1n5DxPwgAAEIQAACEIAABKZCAFk5lZXa7ziRlchKrgGuAa4BrgGugcFrAFm53xsN2kEAAhCAAAQgAAEIQGC1BCYrKy+55JJGn238e/7555vzzz+/ufnmm4enX9kD6vPP/G1z/qt+vjl06NDsc+W7/6TzAfTmT36mrXf2y89qTh1/qq07FEd11cb9KFbceaV+XabxKJ7Ll2nrGDWmQ8zjnJdhuM62fddUHP+2HC+ypkPs1vVvapnrYVvWMc5zVWs6FGeZdVmmbZxrPj4IWXnR29/bHD7yUPOSV/96U+r/squubU6e2mlUr1Se84ZvCqgBAQhAAAIQgAAEIACB8ROYhKw8depUc+655zZHjhwZP9GBEWoOmovmtN+/bZaVl7z2dY0+esj0A2sWiSo7cvi+5qwzXz5LdS4REqViXxw/ZFuE5ljqL8rPGGuZtvnBubbzyKlv7ZZhuM62+TrI11Rt6zXPfOZd0yF26/o3tcz1MM/8a6yzqjXti7PMuizTdmi9svhb9/mtd9/fnD59urn/oUeKslICU2XIyv3eLdEOAhCAAAQgAAEIQGCqBJCVG145ZOX+vxdNguvcH//3rYDUg6eEkR6K80Nozo9t47HbxfoSK+pH9VyuPlRH5/FY57F+PF60revXmA4xj3NehuE628ZrROMtzSnOo/bj0vwzIzPI+bntuv5NLXM9eOzblOZ10dzz2plHzo9t43Gp/jLrskxbj6UrXbecjPElKvXRzskuWemyo8eOs7Nyw/dqdAcBCEAAAhCAAAQgcLAE5paV3s33oQ99qDn77LNnr8CeccYZu3Y7uo5fj82vaV955ZXtq7N+jVt5+stt1Yd2H0ruqR/H1OvPqqt2iuF28ZXonKcyt89j7sKf++0aZ47ncWls7tNt4zhUFsd/+eWXz+bp+Wnu5qy65hFZxTl3zaProWyK+dp9FXdHag6lB1fvvMk7Li1EhuLkh3D14zaPf+WRPcI09rdM2ymuybxjNj+xcpvS2qlsGYbrarvzxInZtdd1TXlO25TOu6bx30fk43+PJbEV26xrTYf+LcexbsvxqtZ0KM5Y1zTKxE0dW0jm18BfcdGbG0lKlSMrO+9wKIAABCAAAQhAAAIQqJTAwrIySjPJNss1C0KLOZ9bqCnfdcXS4s71JQclQvXnti4rvQauMvWvv3isc8V2XzqOY45ls8aF/6OxnHXWWa2IVf833HBDOy73675ifI1FclH9uDwKTcWOr4F7rh6v2lhUev7K07HruI37mHXU9X8q+s7KoQdgC4UoOpyn1HJkKM5YH6TjXKZ2PMQ8zueg+Pf1i6zcuyN63jUd+veIrNzLNv572OTxqtZ0KE7fv7UhibxM2yGWmxKUsZ8uWaldl9d85tbG0pLvrOy6ySEfAhCAAAQgAAEIQKBGAgvLyijIoniLxwalunH3YGyrOiqLQs7tlCrfUnBIVua+Y9x4rLgSfRdeeGErImOfPs5tnJ/7cTxJRM8tjrtUnmOUxKNiWUy678ig1Mb19qTIynYnH7Ly4KTIkLyIEmEZGbGutsjKvdfOvGuKrNzLLl7vYzpe1ZoOxVnXv9Mh0TnEOkrETR2XZGXMQ1buuashAwIQgAAEIAABCEBgCwisTFZKsPm155hKuj3++OPFH8jJUlDnsa3O9RdFndckS0HV1RhUV30qtdSLMX1sueh4Tt2mVK68LBHVLs4jjyvHm0dW5hjqI8aJxx53Z7oFsvLCC351169x98kRPUR3PUg7TteDtGRn1y4wtdVrzcu0HXqQnnL5EPM4t2UYrqvt0DUVx78tx/Ou6RC7df6bWuZ62JZ1jPNc1ZoOxVlmXZZpG+daOt6UoIz9RDGpfO2gPP7UifY7KpGVnXc3FEAAAhCAAAQgAAEIVExgZbJSEk47FiXS8p/EoV6VjgLQwk1iTn9R+Ok8Crt5ZKViW1gq9Z/zfD5PmsfiNlk0Oj/2Ecetcs/Tc88xcrnalKSo6nlHaKmNx7InrUhWlr7jsPTgqodQ76L0A2kUIkNxSg/ajlcSLzHeMm091hrTyMjz61q7ZRiuq63G7GvA44/XlPO2KV1kTfvYrfPf1DLXwzatpee6qjUdirPMuizT1vPsSqNE3NRxlpV69Vu/EF76qGxoXHvuAciAAAQgAAEIQAACEIDABAmsTFZaoFk+ZhYSenFXooScdjmqvtta6PlcbfQ3j6xUHcXXx3HUVsfxOyXzuErnahO/Z1KxF/nOSo9bsT0Xj2keWan+NObIUsfml2OW5tDmVSQr9YAp6aGPjiWLzn75WbOdkrlMD8tnnfny9pfDJcbij/P0xbE8URvFzbH0sKx+1X/ud5m2ilXzp495ZLoMw3W2zddBvqZqXruuufWtaSwbYhfXX33Ftutc075+u+Zce35kv23/jR0Sgesoz7Iy98HOyvZuhgMIQAACEIAABCAAgS0isDJZKWaWbH7VWqklnQWbyyT09LGQUz2XSRRqF2GUfqqncgs7ncdy9a9zl8c1dFvHL9WJ9XUcx6N2XfPIIjSPy/N2e49TMTXeUrnqZJZxzF1t8hxm55UJMIsLr6Vkg+VBfMhWnspcL4pKlfXFUbkf0tX+jBe9qJWe7kuiyrHVr/OXbRvj1HbcxzxLo4PiP9Rv3zVV23rNM5++NV3k36P6Wte/qaE17et3Hga11VnVmvbFEbNl1mWZtn3rlUXhJs6RlcU7FzIhAAEIQAACEIAABLacwNyyctWcFhJuq+58m+JVJiv7HjQpq3tnJuvL+nINcA2s8xrYhJxcdx/bdHvDXCEAAQhAAAIQgAAE6iVwYLJSOxDzrsRNYtbr2NrB6d1xTvNuzU2OaS19ISt37Xpc54MusREpXANcA1wD070G1i0SNxF/LfcRBIUABCAAAQhAAAIQgMCGCWxMVuZXsQ9SVG6Y8cF2h6xEVnINcA1wDXANcA0MXgObkInr7uNgbzjoHQIQgAAEIAABCEAAAqshsDFZuZrhEmVhAjygDj6gshNqujuhWDvWjmuAa2BV18C6ReIm4i98j0ADCEAAAhCAAAQgAAEIjJAAsnKEi7LSISErkZVcA1wDXANcA1wDg9fAJmTiuvtY6f0DwSAAAQhAAAIQgAAEIHBABJCVBwR+Y93ygDr4gLqqXTnEYYcX1wDXANfAdK+BdYvETcTf2L0FHUEAAhCAAAQgAAEIQGCNBJCVa4Q7itDISmQl1wDXANcA1wDXwOA1sAmZuO4+RnHfwSAgAAEIQAACEIAABCCwJAFk5ZIAR9+cB9TBB1R2Qk13JxRrx9pxDXANrOoaWLdI3ET80d+TMEAIQAACEIAABCAAAQjMQaCVlc8991zDpz4G3/nmTzd86mDwj87/k4bPNBn8Dxd9tOFTF4MX/MTvNHzqYvCeTzzYTP0zx30fVSAAAQhAAAIQgAAEIDB6AsjKyiUtorIOUal1RFROU1Rq3RCVdYlKrSeisi5RqfWcuqjU+PmDAAQgAAEIQAACEIBADQSQlchKdl5OZPcpshJZifQcj/REViIrxyg3a7gxZQ4QgAAEIAABCEAAAhBAViIrkZXISnZtrvkVeyTjeCTjqtYCWYmsRFZyEw0BCEAAAhCAAAQgAIH1EEBWIiuRlchKZCWyklfVF/xeUWQlshJZuZ4bU6JCAAIQgAAEIAABCEAAWYmsRFYiK5GVyEpkJbJy67+Hc4zycdExcVsLAQhAAAIQgAAEIACBGgggK5GVyEpkJbISWYmsRFYiK/k18Brua5kDBCAAAQhAAAIQgEAFBJCVyEpkJbISWYmsRFYiK5GVyMoKbmuZAgQgAAEIQAACEIBADQSQlchKZCWyElmJrERWIiuRlcjKGu5rmQMEIAABCEAAAhCAQAUEkJXIyknJyvOvur156ImTzenTp2efTx95vDj+XE9tlPedBTF596MnZjFjueK6j1PP/E3z9s8+0LbVsfJcrvYxbi5//18f3VXuusrPsV1WSv/RmoXauuN//xuvbY4ce6rlds0dXxmUpG5z24OP76qrc/PPZRf/5W3NyZ1nZ+VKde65vfLyTzbHn97pbKt6Xe09FverNPftfnK6ql+gHlucH33n55oHH3+65XndPceK0jPXE7s7HnpyV12dm61iqo3nq7guO/XMs83vXHdvW6Y6sTy3dQyPIfZ7/vtub544+UwbW310zcFxnNb6Azsve+17mvsfOd4yuebW+4oSM9cTu9vuf7itq3ZeM6Vv+8gX2jKxi+Und55pLv6zG3eVm69i5raqqzaO7/JX/sEHmuMnTrX5Li/17/gxXfT7Iddd/9/97GuaQ4cOzT46nqe/Cu5LmQIEIAABCEAAAhCAAAQaZCWysijSSrJsDHkSg5aD/+2au5unTj3blGSg8mJ+bBfnYbEYZabifv7B4y0XxVE/ylfb6+851srLPIZ8rvhqqzT2a5m6TbJSYs9yz9LwbR+/uxWJWfDpXOUSDW6nvBjH5xafEo2SkRaUSo8+cbJRf6r75194oC2zfHRb95cFp/L1UQzFcmznz5NacNWWSvxZ/ln8/dFND+4SiZqzyh556tQeyWgeEoRRMua4n/rSY21MxZdgVEy1z+exreO7nq4lj1d5kp4al2PF+kPHUXLVdCw5aOlo+WcZGOepsqPHTxQlo0Tmx+98oFGqNmoviag2Old6wx1HWjmZy1UnCsnYfx6T6il2l+xUW8lXjyXOIR/PIwM3UeePrr27edmPnNvMKyjjmLivhQAEIAABCEAAAhCAQA0EkJXIyl0SLQq1sR1LBB47sbNL/GkHpOVl33glC9XWwtF1LTGjrHSZU4vFKD9dplQxvMMz99PVVrHUZ55PjJuP55FiY61TEn2ShFFC5rFLJt798BOzj+uV4kQhWYqptlFIxn4kQ7XbU31ZXnYJVPWtukpjjHmOh8TXFMtLAlLSMcpAz0t1JSO7pKDaxB2NEpBRXjqOUu+QtBTNbUsCUm3uPXZi9onjU13lx12csa++4yy6ajgvCUjtgLS8jHNUXUlApTG/dFyKG+t5l6alpKgMLPsAACAASURBVAXkG//yplkfzlcblUmSut/cti9uLCsdR+l3kMcXv+X9M1kpabnoOGq4MWUOEIAABCAAAQhAAAIQ2GpZeezYseacc85pbrzxxubMM8+cvWr1whe+sLnrrrua5/5BYu7s7DTnnXde+yrWxRdf3JapvdvpVS3VU321VUydX3DBBbO2OldcxfdrXcpzP1dccUWbr3Kdu8yxLr300rZOHIfrldIsvKZ8bsEXX9fOcrBrfqW2zvurLz6y5zXwGKckSV2e+7ec7JKXaud46n9bZGWUgpZ7UTI6L6YWj05VVpKVMS/WdaxSXqlM45EclbR0eUyHxhvr5uM+6TXVspJQLIlCza8r33Mv7Y6M8tL1lEZJGo9dJ8tM5VuiOnXd0hxcNpSWZNfU80q7ELMc9By78l0e0y7h6TpdMrMkIp2nmGrfN47SfNxnKV1UDK6rvnZUSljuJz63tRCAAAQgAAEIQAACEKiBwNbLSslGfSQeJfskBn1uUWlx6HNLRqU+trj0uVJJR5/ntqp/+PDhWZ+K7z41hq5YHoelp2OXJKXzLNVqSC0XF5WVWSBGYSjZWIobeUk8xp2XjqdXSmO+28Ty+Pq4y70T09JSY3BZX5oF2JTOF5WVUQxm2ZhfA1e5X91Wu/gauESmzr0zMzJzmXdSKnVsrW1+/Vyx/V2YKvOOzBiz63hIfE2xvCT6uqSk8vVdk+Za2jWpeC7vEpXipDK3n0dWxjGVZKX7VBp3XQ6tSUl2TT2vJPe6ZKDy4/dG5letY7nFYhcflef2qmsxGXdWxnytWXy9PMbvahvr5OP9yMFVt9Fuyh/6iVc1/88lb2/+8T/5ltl9hNI3vPv6ueRlDTemzAECEIAABCAAAQhAAAJbLyu1s7K0k1IiUPkqt8i0zOza1ah8C0W1jzstLStdbpno/CweVc/95FhqG/tyrFLaJ7+mVlaSinlnY56TxWF+VdzCUPVLcR1HorIkHF2u/vW9k4qhvCwgda72Lo995bqO2ZV2ibAp5C8iK/Pr2FlWutyS6aYvHdv1XZLqy2USlSrPstKiUrHNz+2UKs/9xDquq1Qx5xWWQ+JriuWLyMo8P0lBC0eVZYkYhWRsq/z4fZVDsjLvssz9xNiuO6+wzKKrhvNFZGWer14VLwlH1ZOM7JKKfWUl4Zh3YepcsbPQlCy9+yuPzfVdlZ7LqsXjfuL5+yr1nZV+DVy7LF/47S9u3v6B2waFJbe1EIAABCAAAQhAAAIQqIEAsjLJSotACUJ9/Mp2TC0hLRpjmWVkSTDG+haREqFZmGoMsX08tpBEVn56JgclC488Xv6l7ywSLQHzTskoEF2nS3K6PKaxvWJnMapy5Wk88cd2kJXl1669u9FiMMtK5zuNuzCdF1PFi8JRMtI7MWM95Wf5WMpzm/j6ufO60ijFajnukpXzfAdklIzx2GwkDhVHuyKV1yUSh9pKPEb52Ccr1U/chemxdKUWXDWlXbJyHumXJWLmIpkZd1haRJa+D9NtXSeKSMXIbVSe81Qv9ueYfel+5OKq21hWxtfAS3ld/dZwY8ocIAABCEAAAhCAAAQggKxMstJCUYJQOyv1nZPKsyR0Gus5LwrEkmB0PaWqq08pjsrVXuU+tiB1jNiX80pplGpTP5bsyz+SU5KDmmeprvItIb3zLqb+ZW7XkWSch9m8slJjjf3FY5UN9dUlwqaQXxKKJQnpHY+RjY+1S1Lleb6lOK6ThWKffNQY83dW9tVX7Hl/cKdLeE05vyT2hmSg5yvJqJ2VSoeEo0Wl5KjbOy2VeVyXf/arvxru6yemcXemYylV23lkq+r2Sa+plpVe+S7JwdL8JCv7fnAnysqShCzFLNUrjSfLSrWTYNV8SnG78roE4Kbz83dWIiu5WYcABCAAAQhAAAIQ2DYCWy8r9V2RloKSfdoZaTFokejdklEG5h2R/p5J182yUuWXXXZZKz1Vz/3qeOg7Kz0mj2EbZaVknnYoeudifsU6lul4HgGomFE2ls6jRJTI/MKXn5hJT+V7DO6rtHsyvgYeY23TzkrJw7hj0lJSMlBlSvcjIyUY1U6pBWVMY59+rdt9xno6drl3YebzN157565+YuwcK59HIVbTcdy5KOkoCWipGMve+sn7212Smn8sK51Levo18dIOzshQ5VE+5tixbpap7731ofYXyi0+VSe26TruEl5Tz5dU9C7F/Ip1LNMvdUcZGMuUf9VnD7eiUDJR32/p+jrvemU88ivJSsXQa9+Olceo9iqLvxgeY/Ydb1pKdvWXX/vO513tlM8fBCAAAQhAAAIQgAAEaiCw9bJSr2DHX9mO0lBi0BIyvuotEWmx6Xy1k1DskpUWn66f5aPauUyp+1A/WXwqb1tlpXc9epdU3P2YZaXrxDTWtzgsycrYxseWpEqdp9Si0vEkLLVL03Vyuettm6y0/DOXKA0XkZWSiY6RX+e2BHW5hKLFYe7fdWKMXMfiUjE0RrdRGmO7j660S3hNPd+Cz1wsKjWvKA2V7zpKVZbnrjzXifIxt3WdGEOCsZSf+8iyMrZT+3lFpeL2Sa8pl1kQmqfEoucThaTyXUepBafqWiC6PIpKlee2rhdjqJ7HEsegfMnI+OM++XVv1c+x1G7o0ycBN10mQel7gnm/rxJZWcNtOXOAAAQgAAEIQAACEBABZGV6DVwisKaPxRjpV7/jcsocukQY+X/SCsmxssjSjPOP7pGVU2MyJL4oH5aDY2O0aSG5jv64tYUABCAAAQhAAAIQgEANBJCVyMrB70qcsuCraexjFXGMa1iWTk3EMd5hmTo20cZ4lpej65CHm45Zw40pc4AABCAAAQhAAAIQgACyElmJrHzzNHZdIgWHpeBYGSH/huXf1BghB5eXg2NjuGmxuI7+uK2FAAQgAAEIQAACEIBADQS2WlbW9Lp311xq2lm47XMZq4hjXMMSdWoijvEOy9WxiTbGs7w8XYc83HTMGm5MmQMEIAABCEAAAhCAAASQlZV9R2WWltsu+GqaP1JwWAqOlRHyb1j+TY0RcnB5OTg2hpsWi+voj9taCEAAAhCAAAQgAAEI1EAAWYms5DVwXgMf/Q/UjFVCzjuuqYk4xjssV8cm2hjP8vJ0HfJw0zFruDFlDhCAAAQgAAEIQAACEEBWIiuRlchKZOX56921ifwbln9TY4QcXF4Ojo3hpsXiOvrjthYCEIAABCAAAQhAAAI1EEBWIiuRlchKZCWyspmaLDzo8Y5NtDGe5eXpOuThpmPWcGPKHCAAAQhAAAIQgAAEINDKSlDUSeDrvuvchg8MuAYO+Bp48c82X8enKgZff9YvN3zqYtD83d83k//UeSvDrCAAAQhAAAIQgAAEtowAsrLyBUdSHbCkQhYjy3UNICqrY4CorEtUaj0nLyolW/mDAAQgAAEIQAACEIBABQSQlRUsYt8UkJXISq6BEVwDyEpkJTsxR78TFVnZdzdBGQQgAAEIQAACEIAABDZHAFm5OdYH0hOiagSiit2V7K5EViIrkZXIyk28Zn4gdxp0CgEIQAACEIAABCAAgdUSQFaulufooiErkZVcAyO4BpCVyEpkJbISWTm6eyQGBAEIQAACEIAABCAwTgLIynGuy8pGhagagahiZyU7K5GVyEpkJbISWbmyexsCQQACEIAABCAAAQjUTQBZWff6IokQhVwDY7gGkJXISmQlshJZWfkdF9ODAAQgAAEIQAACEFgVAWTlqkiONA47K9lZyTUwgmsAWYmsRFYiK5GVI71TYlgQgAAEIAABCEAAAmMjgKwc24qseDyIqhGIqjHs7GMMB7vDFFmJrERWIiuRlSu+wyEcBCAAAQhAAAIQgECtBJCVE1zZ559/vjn//PObm2++eXD0tcnKl7z615v7H3qkOX369OxzzWduLUqoV1z05ub4UyfaemqjtuaRy2McHTt+TGOMW+++v60T8xX/ore/tzl5aqctv+yqa2f95j5jbNfx+GpM5107zz1yFE+dqyxz1Fq4TUxV//CRh3ateyxXuy7uHmuOHa8NXV8aS4zZeVyprHzJf/qt5v6HHm2v9Ws++9edUlJlvuaPP/V084pff1ux7q33PNBcdvV1xbKLLv/z5vADRxv1+3WBqdo4to5dFvt0uVKN2TFinZjvGF3p11cqH1/6K29u7j/6WMvzmpvvKkrGXE9cb73vy7vq/uRvvqs5fuJkG+uyD3xyVq6YcT18rH5f/8fX7GrjMqVur36cf3LnmeaiK/6q7VfHynN5HlPfujWbkIkL9nHJa1/X3PzJzzRzj23wroAKEIAABCAAAQhAAAIQGD8BZOX412jPCLdZVkoeWSBZWpWEk/Kcb/FkIZnP++JIPrm+4ylOFJR9Y5Iwk9SyaMsySzFjrFxe03kfpzxPcYmCMpZfdf1NLU+vjdfW9dSXZEWJrdbCMtlr6nZOla/2vtaUr7woKPN14LbFNIi1Lvk1xXyJQctByUdJyJJoVF4UlBKEWQxKRLbrUpCVFpK5XRyDGOpc8Us8LVc9xjyuHKsUw3l90mvKZZJ7FnyWjZaEcV4qO/rYk7tEYSy3NCy1jfV0bPHZVVf5Epmqp35vuPXuVk5KfLpMsa668dZ2TH3jz2PQ+dxCcEHhuJ+4Rw7f15zxohc1hw4dQlbuuQsiAwIQgAAEIAABCECgdgLIygmu8LbKSknFo8eOt6JKUkjCKAqloihK9UpxFCMLL8eSpIrSK9eN5RJhGqP6UHvLNNVxPKd9Za5TS1pi3rV2i3KJ/MVL66NPzleZ5fEb/vgDszXtWhftyNRHcbwGebx5rV2vmFYoKyUnjz72RCPJaIEnSSjh53OnOV9t1Na7K3UumfmGP/3wTGJaJrq9JaLyo6wsjSHHdgyluX0Wm31tYxwdl2TX1PNKAlIy0PIyzk91JQmVxnwfq03XrkzXcRplpPOcDolMSVFJ01WMYz9ScR1tJCrPOvPlzV233t6c/6qfR1ZO8D6NIUMAAhCAAAQgAAEILEdgpbLSEu2GG26YvaasHQGzXQHpdeUrr7xylq+ys88+uzl16tRsFm7vdrFMdc4999zm8ssvn7W95JJLZu1Ux/UV1396Rdr5SlXff471oQ99qDnjjDNm9WJfrldKjxw50rZRXPeZ+3O++1I7/6muXuPWfPXXxSPmqy+/9m1OPnfcUloUJxP9/sIu+RTlYGm+JVFmoaX6pXLHKYkzjSPusFMsi07X93mf0CrNx/3Wlpbm2sVG+X2vb2c2WSK6vNSny7xOquM8p47n1PkaV9wlm8tdr5hWKCuz+JPA65J9lpFKVS/LS4vAvPPR+U5znyVZWcpT+xy7VC/Xcb+l1DKtprQkDbtkYFe+eAyJzMhsSEaWxhTb90nRvjHGGD5eh3hcJubzz/wtsrJ0Y0MeBCAAAQhAAAIQgED1BNYiKyUALeeUnnXWWe25BFwWdRaJqiuBqD8LuSj9JBRdV3V07HLVv+uuu2ZtJfHiGLpieRwuj7FngdL/yXORiJSY1d873/nOVrqqf8vPIVmpmJKwqqe/Bx54YHasMUnMKtVf5ObxIiu/ulOuS1ZKIupV3igWo0hyedfrxqrbJbyU7+9Ek7SKcS3C+vp2nZIsi7FqOS5x7JKVqmuZbMY6L7GQaNb6ljiW+nSMLv5xTCUZqXK/qtw1JvexK91yWSnZJ1HZsivsviwJxSwJs6xUuXdduq5E6OzfdNjxqbLcFln5y3t2RJbEYJfwU378bsj4KrbKDj/4SPPx2+5p/zsZyy0HlZb6dHmXyFQb/7dBx66v1G1U3tVnrB+PlxGL62iLrJzd/vB/IAABCEAAAhCAAAS2kMBaZGWWaJaKJckmSSdpaFkX10CCzgKxJP1U5vLYzv3FPI3JcrIUK5bHdvG4FDeW+zjGj8cuj31lAeo6OY1Ss8Qx1/f5LmEy0R2VnkNJPkW55Ho5tdCyVMyiyucuj+0lpLIIyxJL535NPO/SdN85hsa9yO7BOKYpHi+ydqor0WBmXetjtqV1E6NSn2bnmO5D+Tkvr3OOp/MuEe5+2nTLZWUWhTqP32Fp0Ti0szHHUTu3sbz67J337Xk9XfUkNdXefSErl5OVUfLpWDscLQctMuNr4CrXp9QuC0fXsfSUgHReTmO/uczj6Iqf669DOC4TE1npOxlSCEAAAhCAAAQgAIFtI7ARWSnpqI/EXXxt269px12QEoLOV2oZWZJ+WizXt4jsEnlR9pViRYFYugi64rqu4vuVco3bc5qnr9hW4/CfjiML79YcGovbK21lycRFpeaRZZHy5pV+UWrOG0cyTBJSqTnqOH9vpiSXxKP6yILL48678FSvS7K5r5rSeZmbl+WvGeT2Ou/bEdsVx/GymFS+1iiuU1zLUn230VgctzPdIlmZf63bMjGKwpI8jOIx17VgLMlKlzktvYouManvulTqel2yUuP36+quW0qz6KrhXFLPwtHzmUcYqq5e/fYP7qhN/h7JUt7Q6+KSnVF4ekwx9U7KLiFZmlNsH4+XEYvraIusjHczHEMAAhCAAAQgAAEIbBOBjchK70iUZLvwwgvbV8IzaNdz/tDOStdTqroWljmOyiUE1bfGMI9AjLF9XIrr2PFV7hg/HjtOlxhVXQlJlec6UbZuq6yMwtFSKAol55XS2DaLL9VXed7pqHpRXqneKmRllJulsdaYF/l7fl1r17UWFpil9XPMmPbVy/JR66pdkt6dF1Plv+6dVxV/kEfXh/qJ/RaPK5SVJSlY+i7KTcvK0hgkObWzMkrH0rhKc4pt4nGUXLUcl4SiZGFpR2SecxSP8dj1SrElErtiS0LqVXK1c4xSiqz8+92/Yu4bDVIIQAACEIAABCAAAQhMmMBaZKWlobhIunlHoM6jVIzcsoDzuQSh/rL0U3n8Tsco93TsnY1q61jquxRLebH9rFLh/+S4GpO+szK3jfVKfYuHGamuPvpzXZ1HUasynZtjrFcY5q6sojiZ8C7LuPvNgsmyKJZd//k72h2RFlMWj7mdy/NOR9XPeeIZ+9G56likSbRJbilVWe5LeSVxp/zaP5Fb5qI19CvVeT3iuY+95n3MVMfrkuvNEyfL1LjOihfHnOPvOa9QVkrcxe+L1E5FvdrtXZGxTAIx/oq36qzqNfAoECUbFTfvjNRYNIZYV8d5HHHMuW4+L4mzGvIkDy0QJR2Pnzg5+15JzS2WveG91+0SibEs1y2dO69r52RJbqqNBGfcRan2GqPGKnGp78lUqroef1cfqhM/69gduUxMdlbuup3hBAIQgAAEIAABCEBgiwisRVZKIvqV6CgNzVUCMr7ebCEpSed8tdNOSJdlWalYMY5FnvuIsRTTolLlpViqb4HoGKU0x9W55aHHrjjaaandkPqLr3lrnPoRIfcVy+I4NUbVdUyx8O5N96e+h/72SJOJSzFLJu98i9IqyjCJJddRqrLIwrLMdXK5+vGr3bGdj1XfbS3ZXCYZ6R8SUR2NxWVKNebcXyyv9bhv7bL4y3XNMOd7DUqvhCvmKmWl1iVeV6U+O9euUlnp3YleB4tKib0s/iQLXW/GLv0Ajto4XowTJaHyo/RU2VBcxex7tTu215hjf33HUXLVdOydil6rKAajkFS+6yi14IwslOc6uVz99O2cVPzcRrElMeMP+1hUut/Yp/qeV1Sq/TJicR1tkZVDdziUQwACEIAABCAAAQjUSmAtsnIeiVYr0LHNq1OeTFxaMq/6d2JWtcaVyso+mVd7meUY6e7diVPmsQ7huPGYY7sJYTwQgAAEIAABCEAAAhDYBwFkZYKmHZjezRjTqQrYqoQPgnXXDk3WdkLCFlk5947FqUjOKUs5xl4WrBsXi3+Xvm9yFefpnoZTCEAAAhCAAAQgAAEITJEAsnKKq7bAmBFaExJayNh6ZSyyElmZvh8RYVgWhgfJBVm5wM0FVSEAAQhAAAIQgAAEILBGAiuVlWscJ6H3SQBZiazkGhjBNYCsRFYiK3f9mM1BSsmuvpGV+7zRoBkEIAABCEAAAhCAAARWTABZuWKgYwuHqBqBqGLHZL07JuddW2QlshJZiaxcxWveQzHGdhPCeCAAAQhAAAIQgAAEILAPAsjKfUCbUhNkJbKSa2AE1wCyElmJrERWDonGVZRP6QaFsUIAAhCAAAQgAAEIQKCDALKyA0wt2YiqEYiqeXffUa/eHZjISmQlshJZuQoZORSjlpsX5gEBCEAAAhCAAAQgsNUEkJWVLz+yElnJNTCCawBZiaxEViIrh0TjKsorv6dhehCAAAQgAAEIQAAC20GglZXPPfdcw6c+Bi+59LMNnzoYXPD+Oxs+02Twa1d/seFTF4Ov++6fbPjUxeA3PnhPM/XPdty6MksIQAACEIAABCAAgdoJICsrl7SIyjpEpdYRUTlNUal1Q1TWJSq1nojKukSl1nPqolLj5w8CEIAABCAAAQhAAAI1EEBWIivZeTmR3afISmQl0nM80hNZiawco9ys4caUOUAAAhCAAAQgAAEIQABZiaxEViIr2bW55lfskYzjkYyrWgtkJbISWclNNAQgAAEIQAACEIAABNZDAFmJrERWIiuRlchKXlVf8HtFkZXISmTlem5MiQoBCEAAAhCAAAQgAAFkJbISWYmsRFYiK5GVyMqt/x7OMcrHRcfEbS0EIAABCEAAAhCAAARqIICsRFYiK5GVyEpkJbISWYms5NfAa7ivZQ4QgAAEIAABCEAAAhUQQFYiK5GVyEpkJbISWYmsRFYiKyu4rWUKEIAABCAAAQhAAAI1EEBWIiuRlchKZCWyElmJrERWIitruK9lDhCAAAQgAAEIQAACFRAYray8+OKLG32e65CJQ+Vd7WrI39nZac4777zmxhtv7OTjeb5kIiJu3nH+0tV3NkefPNWcPn169rnpgeNF2ZrrqY3y3I/aOYbSq28/2papTi5/6tSzzeuuvaetc8+jJ9r2Obbav/OmB5tTz/zNrI5Snbtvp4qR+3VZKb1gzUJt3fHf+vH7m8dO7LTcvnj0qU5J+pXjJ9t6zzz7N82H73ikWFf1PnXvY7vKutr+8U1fbk7+w5rEtdexY2hMLsv95vFrLsqbh9uqfoF6bHH+8MYjzeNhTe9++MSg9PzoXY82YvvZ+x7fVVdtzV4xFTvO1+1UR+117vKHwvWiY+c77Wob8xW31NYxclrrD+y85NWvb+5/6NF2La75zG1FiZnrid+tdx9p677iorc0x596uo1z2VUfbcsiO8eJbVWuc18PucztL/rD9zWHH3ioUQznOZ2nves6XfT7IddR/+ovHG3/t8Pzd/r5+483Q31WcF/KFCAAAQhAAAIQgAAEINCMVlZatik9duxYc8455zR33XXXoJyL7cZ4rDloLprTfse3zbJSgk8fyTzJQ0nEkvBTXsyP7SQtb/nyE628VL2SjOwSocqPgjLG1rgUr0tQqjyKzDjGkqCMefNIsTHXkUTUR2O0OLQkjONW2T2PnGgloARiFoOSlxJWeoiPMeZpG/tSW8fObVUmual8tdF57CvOJ8YsHWfRVcu55J4F35Wf+8qMV5aQea6qr3WL9XQs1oqh+jGuzlWeBaXj5ro6j9K0r+3tX3mylZ7zjt/9WnDVlkryWQ5aOJZEo8qOHjveSBhmBrldX13F1vXgPhUrjsHnWZqqjtpJrEZZ2SU/8xhL50Mi8KDKJSmPP73TvPvTDyIruXGHAAQgAAEIQAACENgKAsjKjp2b+xWJQ+2QlZ/ds8MwCrm+Y8nJx57e2bVLUeLQ8rKvrQSh2sbdka5fiquYXSJRZVFkqp7lpXd0drXVOCRG//SWr8zadNXz2GJakmBTyZPwe/LkM7t2SEpCWl72zUNiUm0tDXUusXX94WMz0RgFYo6T28Zy75Tsaj9U3hc79qNjC66aUsk9rUvc4ShJKFnYNU/V1a5JtYuyMgtG1VMd9eHdm7G+45fGMG9bx4hpHkcsy8cl2TX1vJJUlCSMItFzVF2JQqXOcyoBmSViKY7EonZG6uM+SmOQEJUYdV+WmaV+Snke11B6UDKyr18JSonKeXZVKg5/EIAABCAAAQhAAAIQqIHAUrLSOx71OvKZZ57ZHDp0qHnhC1+4awekdwGqrFQueac2LverzVdcccXsNfBcrtefFdPlju92koU5T2WOn8fXJRdzv+ovxu6K53HpNXXXcds4DpWpjsd66aWXzjh4fmJrpqqrY+/GdJs45655RNk19eMoBT2XPgnpOkpLbV2eheeQcFSsuBMzykuN54HjJ9tdm+4jp0N95Po6zwJsSucSgt7B6HHPK/skNEuvjA/JRPXT1VZlpTF5bEpLgjWWD7WPdbPoquFc8jC/rh1FYZ6jpeMXHnhi1s7ysSQcXVd1FPPRp/a+Fq74pbYxr69tHl/f2HNdnQ+JrymWl0RfFoWeV1e+yktxSnkWmE7VtiQrS3ld/Uhkqi+Pc5G0TxoeVNkiuyqRlTXcljMHCEAAAhCAAAQgAAERWFpWSqJFkSaB5nNLtfjdk6VySzfJuMOHD8+koKWfJJylqASipVwsj8cqVzxLv9hfLnOsnKofzcH9qf8Pf/jDrVjsmo/iaCySi56T0ihIFTO+Bm5GHq9iqD/1r1gem45dx23ch+uU0pL0mmpeSTjOIystBuNuSLXzd0rGfLFxfb1iqE/plW6NxeWxvfIlL/VxuY4zc/eh+rms6zzKr6kdl8Ren6xUffPTcWm+XbJymbaxn9Lr5y533yWJ6joxLcmuqectKiu96zKKSDGIctFMYh31ox2P+via0LHruszn6sevjA+1dT+Km8Wr43Wli0iwqdQtCcUuKan8k6e+9h20cSel5KK+r9LS0K9mxzoxbpSVYuWdk+amcvWlNs5TmsfrnZpXXX9TO7ZSuxgjHh+UkOzqd9FdlchKbuwhAAEIQAACEIAABGohsLSszN8lGUVaFnOSabHcx1HKWbgpz1JwSFbmftTOMeOx+7/go23DpAAAIABJREFUggtaEen+YprbuCz343iSiBaHcdyl8hzDDNxebXRsMem+I4NSG9fLaZf4mmL+fmSlpWBJGJqBZGPcKel8p+o3CkvVj/F07tfAVVfiwxLS/UehqbjOdz331ZdG+TW140VlZZyfdkfmXZkqtzDskpmq09VWovSRJ091/kCOJGT8vso4Hver2DG/77hLeE05fxFZGXctWhCqveY/j6zUvynXd3t/L6XPLTIffPxk+3q62vS1jfw1RklO9xPLSsdRctVynOWf5hWlYt88JRizjLTMVHrDF+5syy0vLTOzrHS51/Szd9xb/H7MPF63i+NQHYlTv0LeN4cuaXhQ+R8/fKw59tR831XpMdZyc8o8IAABCEAAAhCAAAS2m8DKZaVkmWSfhFtJurncMtHiza9FW7ZF6RdFXancMdWf6kr0KY2xFT9+VNexYuo2pfJ55hPHrbg53jyyMsfIcXLMOP583Ce/plYmsWcp6LH3vXbt3ZPzCEHJxywU3YdSl5e+31LiUa9+q7/SGEt5yMo7Z99f2ScMLf8sB7OU7Mp3O6VddSQjS7siXb9LREpySmjlscQ+S8cl2TX1PEm9vBux9Nq1ZKTEryWg5aLPu2SlXv1WvFI/pTzzjGK0VK+U57Z9Za7jtE96TbUsyz/NQ7Ky6xe34zy7XtV2nSgkSzsnlee6Oe0Spnm8lpXKd4xSnstyauE3lvTeR040+iwynu2+pWX2EIAABCAAAQhAAAK1EFi5rIwiLYs5izTLTJ87Vb4+Oo/Cbh5ZKZHouI6hOM5zH/OkaqP+c9155hPHrfaRh85zjFyuOiUpqnreEVpqk8fq8yjcpn4sGZh/JCfvcvQcS3VdVkotI0tlylO5pOOQrFS/+TsrkZVfFZPxR3Ik9CQLu6RgFH4WiFkQduUPtVU7SVKJx6G6sbzvtfVYr3RswVVTGqWg5+VXvX2uVALQO+Ryqle4s7xUmxhbx/k7K/ukYhzDom374sY56TiLrhrOS1IwSsa+OUpWakdjaQdjFIYq107HfC3ovGsHZNcYsqzU+CQ9a5CVegVcuyq1uxJZWcstN/OAAAQgAAEIQAACEJiXwNKyUt+tGOWgZJ1fYbZUi+UScf5OS0nIyy67rJWCUfTF43lkpeqoX33Uh2Vd7M95Q6naxO+ZVOxFvrMyztcMPKZ5ZKX64zsry78aLmmojwSixKFe35YMtFB0mdKunZISih+/97H2uyLVPr7mrbgfOfzorvL4mngcg/pVP97x6R2T7jufq74+zvfYnd+XliTYlPIkJi0n9eM12m1nAanUr13r2PmaX9cr2SVZOU/bLumotqXXzc1YYy/txnR5X5pFVy3n8fsi8w7KWBbnW5KTkoRaf8VQ3djW9fNr3z6PsSUnFUep8vvaquy+R0/M6qiux1+KG/vwcZ+4m3JZ3PVosWj5F8ve8Ccf3PUdkrEsz1+yMb6aXSpX+5yvcwlUSUylubwkK5UXpWc+zzHi+SJScN11JSln//v2haPIynnvaKkHAQhAAAIQgAAEIFANgaVlpb6zUr9k7VesLSItBC3rSuW5zJJTbaOs9LliuE4uVx1JQpe7/9jWYyjVifV1LLno+kotG/OY83zzuFzf7RVb41RMpaVy1bGw9BjimLva5DnovE9+TbHMks+7cqLsixJRx64TU9W35HR+FJViksujqDSzGD+X5zFaXLqtUteJ44/lpeM+GTaFMstFc49CUseWlX7V2vWcn+foeDHOPG1V39I0xlS++4yp6yqN+T6O/cd48diCq7bUMtAsJB09xygcnafUbWJd5UsSOo7altq4PArF2M4/rDNvW/XjmEpj3BijdBwlV03H3gVpLhaVmmMUksp3HaVRNuYYfaJScfPOSZ07dt8P5GgMpdhxbFFcDq3TugXkIvH1K+APP3FqIVGp+PxBAAIQgAAEIAABCECgBgIrkZXaLVgSZeQ9d+BcStKLvPKuzbFzifKL4zt3vcI9dh4l2UXeF3cJyanxGBJflP/knp2QY2eyiEwca90abkyZAwQgAAEIQAACEIAABLZWVkqw6lVv71x0Gl/hrkG2jl3AMb75xenYhRzj6xaoUxNxjHdYpI5dvDG+xWXpWAXkIuPithYCEIAABCAAAQhAAAI1ENhaWVmDiJxnDsjA+WXg2FkhA7tl4NjZIP+G5d/UGCEDF5eBY2e2iBQca90abkyZAwQgAAEIQAACEIAABJaSlfPIMuoc7KvgYxdwjG9+mTp2Icf4umXq1EQc4x2Wq2MXb4xvcZk6VgG5yLi4rYUABCAAAQhAAAIQgEANBJCVzx2sTFy3zEUGzi8Dx84KGdgtA8fOBvk3LP+mxggZuLgMHDuzRaTgWOvWcGPKHCAAAQhAAAIQgAAEIICsRFZW94vhY5eO+x3f2IUc4+uWqVMTcYx3WK6OXbwxvsVl6lgF5CLj4rYWAhCAAAQgAAEIQAACNRBAViIrkZWXTmP3JTKwWwaOnQ3yb1j+TY0RMnBxGTh2ZotIwbHWreHGlDlAAAIQgAAEIAABCEAAWYmsRFYiK5uxy76pj29qIo7xDsvVsYs3xre4TB2rgFxkXNzWQgACEIAABCAAAQhAoAYCraysYTLMoUDg7/6+afjAgGvgQK+BH/zDmxs+dTF4wU+9teFTGYOfeVvzgol/CncBZEEAAhCAAAQgAAEIQGByBJCVk1uyBQeMpDpQSYUoRpbrGkBU1iUqtZ6IyspEpeTzxEWlxs8fBCAAAQhAAAIQgAAEaiCArKxhFfvmgKxEVnINHPg1gKxEViI3JyA3kZV9dxOUQQACEIAABCAAAQhAYGMEkJUbQ31AHSGqDlxUsbuS3ZXISmQlshJZuYmdmwd0p0G3EIAABCAAAQhAAAIQWCkBZOVKcY4wGLISWck1cODXALISWYmsRFYiK0d4j8SQIAABCEAAAhCAAARGSQBZOcplWeGgEFUHLqrYWcnOSmQlshJZiaxEVq7w3oZQEIAABCAAAQhAAAJVE0BWVr28DaIOWcs1MIJrAFmJrERWIiuRlbXfcDE/CEAAAhCAAAQgAIFVEUBWrorkWOOMQNSws5Cdhdt+DSArkZXISmQlsnKsN0qMCwIQgAAEIAABCEBgbASQlWNbkVWPB1nJzkKugQO/BpCVyEpkJbISWbnqGxziQQACEIAABCAAAQjUSgBZucTKnjp1qjn33HObI0eOzKJceeWVzSWXXLJExPmaqt+zzz67ufnmm4cbVCaqnn/mb5vzX/XzzaFDh2afK9/9J50i6uZPfqatd/bLz2pOHX+qrTsUR3XVxv0oVtwdqH5dpvEonsuXaesYNaZDzOOcl2G4zrZ911Qcfz6uVVb+6gfuah5+8lRz+vTp2edzDx5vhub6rs99udl59m+aD9758K669x070cZRTMV2LLdRP2qr81KZyhXHZTFVmy8fP7krrstj313tXddprfLxZb/x5839jz7RrsU1tx1pSnPN9cT+tiOP7qn7ykuvncVT2hcnt9W5ryuNR/25/cVX3dSc3HlmVq5U5y5zGtvn2K6zJ/2ZtzWbEIqxj4v//Obm7qPHm5f95l+0fb/yso81x5/eaed/2wPH2rLYtnQ8fFNADQhAAAIQgAAEIAABCIyfALJyiTVah6zMMZcY3lebViYrL3nt6xp9JIMspbJIVNmRw/c1Z5358lmqc8nFKBX74liqWYTmWOovys8Ya5m2WXDVdh459a3dMgzX2TZfB/ma6lsvC67aUok9y73fvu6+5sTOs3skZJ6zxWCUlZKcUVDGuJKMimtBqfTxp3ca9afYn/zSY21Z1xjcZ+xDbS1bPYc81r7zPaLrpyawc3COMUrsWe5JMB5/+lTzto/dvkcGquzo8RNFUWg2Ep0SjorRJSsVO4tOtYuCMo5JYlLxLCiVahyOb4nqOXgsc6UblpWSkJr7/Y8+uUtWXvW5+xpJTMlISUyVX/PXD8wlLJe+ZyAABCAAAQhAAAIQgAAERkAAWbnEImSxuIqdlTnmEsP7atOKZKUE17k//u9bAWkJaXkZZZFEUsyPbeOx28T6klLqR/VcrliWl/FY5bF+PF60revXmA4xj3NehuE628ZrROMtzSnOIx73Sa+plkkMShpaImoeko594k91JQzVLspKtYm7MlVmsViKmetHhrlM5/rEmK5fynPZUDqX/JpDDo4pTklAShyWxJ/qSihaEuZ5WDi+8UO37JKJsZ7E4t0PPT77xD50rPauK6FpeVkaT6wf67r93OkGZaVEpT5vu+6OPbIy75icp47bLH3PQAAIQAACEIAABCAAAQiMgACy8h8WQa9U+7VepX7FOufH17yzWMyyMrY944wz2tfFve6K5T71Wvctt9zSqJ7zzj///GZnZ6dRevnll8/KYp7H6HjFtCJZqR2NcXekZFBJTnl3Xd5xack4FCdLKfXjNo9/5ZE9wjT2t0zbKLdqOzY/sfLcSmunsmUYrqvtzhMnZtde1zXlOXWlQ+JriuUl0Zd3PcZ5eRfjx+4+NhORau9yHWv3pHdLRuFYkpWlPMXq6780XktMj2ORdG4BNiFhWRJ9eeei592V73KnffUsHp26jcYRd2NGGZnrqk3MU121d6yF0g3KSsvFeUSkdlXO+yp48T6ATAhAAAIQgAAEIAABCEyMALKyaWZiUrJQ8lF/+g7Ku+66a5YfJePzzz8/E4eSkvrrk5USiTGmziUaFUN/EpVRfN5www2zeDmm+4xtnYesRFZ2ybGx5SMr6/uBmZL865OFFoyWllFWShLq3N9RqLoWh4oZXwP3q94SjarjeGrr3ZhuG9M8XrXTd1jqNXJ9D6ba5+/DjO3z8UISbCLCclFZ6e+N/OqrzLu/V9J8umRlzI+y0e00Fl8PKne+2sXXwLWzU+eSlN6pedXN9w5+p6Xj7UpHKCv9/ZWSmhacfensBoP/AwEIQAACEIAABCAAgYkT2HpZ2Sf+JBMtJr3OUTpmsRh3Vua26ufCCy+ciVDJUP0wj+WoYyvNMUvjK+XFGLuO2VnZ7uRjZ+Xftyw2LTORldstK6PEtFyMstIi00JQ51E8RpEpcfnFR54qvm6ufko/3qO4JVmpPnI/cYenx1NKd0muicjIoTEvIitzLMlCv6ody6KUdL6/V9I7ILOsLJ3H2FFkSlTedO/DraxUvVw37tL0GIrpyGSlReW831cpickfBCAAAQhAAAIQgAAEaiCw9bIyy0EvapcQjKIxt7WsdFu/zh1Tyc4oPN2f0xzTseIuylKe2+9Jt0BWXnjBr+76Ne74WnaUcpKVkmZd4sxxul4lVvvS9xSqP7XVa83LtI1jre14iHmc7zIM19V26JqK4y8dl2TX1POy/NN8JAvzL257J6TlZJaVpe++9K5HxStxiq+J5/LSuFQn5+dxqE4pL8f3eVF2TVxadslKfa+kBGPfnEvfd6n6JVkpsamP40U5WYrjHZOK5TYxVSzFyBJUdUp5se2u4xHJSu2kPLnzbPtDO327KWPZnnsAMiAAAQhAAAIQgAAEIDBBAlsvK/vEX94dqfWVrNQOSbXLYtGyUvXUNgrGeG1E4RnzdZxjlsZXystx2vOKZGXpOw5LckqyyLsoLY6iZByKUxJrjleSVjHeMm091hrTyMjz61q7ZRiuq63G7GvA44/XlPO6UguumtK4W9LzyjsklS9J6Nd5cyrpuKisLNV3/+4v7pZ0WZaVys/fWbntsrIkFqNI3CX2kpiVZNSORqWxXo6pcu10zNeCzpX/1mv/es+vjPfJyiw3JS69Y1PjmKKsnOd7LKOgjMft//ZzAAEIQAACEIAABCAAgQkT2HpZqbWTZIzfLymZuOrvrIzXiGWjhKb/hr6zMopPt495jrMnrUhWWhhJGulYsujsl5812ymZyyTHzjrz5e0vh0uMxR/nUYyuOBaSaqO4OZaEmPpV/7nfZdoqVs2fPuaR6TIM19k2Xwf5mupbOwuz2lLJPn00r7yDMpbFeZeEYK6bXwOP7WNdxbrtK0/OdkTGMah9bKPjkqxUXnztO5/nGPE8CrmajuOuR4tFy79Ypl/5jjsdY1nkkWVlLPNxFqI5lsrjq91upzTX1Vjja9/5PLbdczyCnZUv+82/mP06+LzfURlFpY75gwAEIAABCEAAAhCAQA0EkJX/sIoSln5dO/6ojoSg85Wqnv/yLsi4s1J1Yky1Lf1IjmPHMrdTnn8NPIrJbZaVllHmJsllSRRlmPJU5npRVKqsL47KLULV/owXvaiVnu5LosqxLT1dtkxbx6gx7WMeZaXmvgzDdbbtu6b61ixKrpqOLR69S06yz/OLUtF5St0m1lW+6jtOFIiWoC5TvRgvtlOdkqhUffXXtePSsWO/sY/S8R7RlXYaTrXcOxHNxKJS84liUPmuo1RlpTnvR1a6L8eP8tEC1WWlfuPYYtvS+HbljUhWen5O530l3PcnpBCAAAQgAAEIQAACEJgyAWTllFdvnrFXvluvTxBRVvdOzSmtb0l2kTftHx3aJbkqEZVbP6cDkJV5Z+Sy5/PcFlAHAhCAAAQgAAEIQAACYyeArBz7Ci07PmRlu/NySnKLsdYlWhGT0xaTpfXberFXo6BFVi57x0F7CEAAAhCAAAQgAAEIrIQAsnIlGEccBFmJrOQaOPBroCS7yJu2wERWvrX42vekuSArR3wzw9AgAAEIQAACEIAABLaJALKy9tVGVB24qGKXZF27JPeznojJaYvJ0vpNWsrVuCtyFXNCVtZ+R8T8IAABCEAAAhCAAAQmQgBZOZGF2vcwkZXISq6BA78GSrKLvGkLTGQlOyuX/X7JdbTf970CDSEAAQhAAAIQgAAEIDAiAsjKES3GWoaCqDpwUbWfnXi0qWs3JmJy2mKytH7ISmTlOmTjsjHXch9BUAhAAAIQgAAEIAABCGyYALJyw8A33h2yElnJNXDg10BJdpE3bYGJrERWLisW19F+4/cYdAgBCEAAAhCAAAQgAIE1EEBWrgHqqEIiqg5cVLFLsq5dkvtZT8TktMVkaf2QlcjKdcjGZWOO6v6DwUAAAhCAAAQgAAEIQGCfBFpZ+dxzzzV86mPw+dsfa/jUweCam442fKbJ4C3XfqnhUxeDF7ziTQ2fuhh8w2s/1kz9s897QZpBAAIQgAAEIAABCEBgVASQlZVLWkRlHaJS64ionKao1LohKusSlVpPRGVdolLrOXVRqfHzBwEIQAACEIAABCAAgRoIICuRley8nMjuU2QlshLpOR7piaxEVo5RbtZwY8ocIAABCEAAAhCAAAQggKxEViIrkZXs2lzzK/ZIxvFIxlWtBbISWYms5CYaAhCAAAQgAAEIQAAC6yGArERWIiuRlchKZCWvqi/4vaLISmQlsnI9N6ZEhQAEIAABCEAAAhCAALISWYmsRFYiK5GVyEpk5dZ/D+cY5eOiY+K2FgIQgAAEIAABCEAAAjUQQFYiK5GVyEpkJbISWYmsRFbya+A13NcyBwhAAAIQgAAEIACBCgggK5GVyEpkJbISWYmsRFYiK5GVFdzWMgUIQAACEIAABCAAgRoIICuRlchKZCWyElmJrERWIiuRlTXc1zIHCEAAAhCAAAQgAIEKCCArRyor77rrrubMM89slD63xBg/PxERN+84P/W5Lzc/+mP/oTl06NDs8+u/8dZB2ao6ud5QnPf/5aebb/qn/2vbzzuu+EDbz8duvLv5zu9+SVumscT4Ovb4lKqu2uQ5Kqb6UF+5rHR+zZqF2rrj/+UnvtT84L/9yZbNr178B52SVGVm+I3f9M+ad/zZJ3bVjeWKqdgev+qqjdqX2rreK8+7oHnj269u2yk/xs1t8/gVXzEcry9d1S9Qjy3Omz54Z/M9//on2rX6qf/8xqL0/O33f775lm/73rae2qit55PLxTbH+m+XX9t8wzd+8yyGUp2X2vm6ec3vXTmLH9upzPnu26nyHdd5fWmtP7Dzste9t7n/kSea06dPzz7X3Hp/UWLmeqp/25FH2rpv++itbQyV6Twzu/h9n25O7jwzq6dU566jfj0GjUf9ueyVb/mr5vjTp9ryHFvj6GrrGKV00e+HXEX9373+vua+YyeaH/vvn29ivOvvOdbO4cHHn95THuvG4wruS5kCBCAAAQhAAAIQgAAEGmTlEiJwGYm4qbYl6TXlvJ9/9X9u9NEcLA2jSIxzc7kERZSJqtMXx+0cVzLxO77r+1qpqPMzz/o3RQHp2Lm/OC4dW5Zuk6yU2LPce+9H7mi+7Tu+b48slPBT2S/+l99uJaCEouoqX+X5PMaVqPwX3/HiVm7q/Pt+4P9o26p9lJlRVg71q3LFUvs+MVkq65NeUy77of/wS40+moPFYUkGKs/5FpxRRkooftv3/dAsRonHIiJRdS1D85jUz7d82/fMRGfsx2NCVr5pJhwtHS0FswyU6FPZ0eMndglGC0CJxY/f+WArGCUhJRejjFTMLCjdXmWqrz6Up/F4TJaklqg5tvKj3IxtHb8rjdJvE8d3HH1yJiSzjLzi5gebJ04+0/zC+2+fCUzV02eeMXFfCwEIQAACEIAABCAAgRoIICuRlXPt6suy7SDOJRElCeNORElBy8s4pigcVR7l4VCcLCMtFqO8fOVPv3omHGOfPlZ/ruu8nKpcO0TzfHK9eF6SYFPJK4k+7WK0vOybh3c0Wiyqjdq6TRSSpZixvupKZr7lXR+Z7fJ0TMeKae5Xc9AuTqWx3jzHUYzVciwRKMEoAeg5SUBaXjqvlOZ6ivED/+7ndu22dDuLRMtO55fSXDdL0FzuGBaceT4uL6VdwmvK+SUBKflnURjnprqSghaKsax0rBgWjBaOJQmqtrGuziUkJUbVVzx2P7F+PFa5+ojy0m1K6TwycFV1LCAlJrOsVJl2Vrov7b585KlTrbx0fimt4caUOUAAAhCAAAQgAAEIQABZuYCsvPHGG9vXGM8777zm0ksvbS6++OLZa9rHjh1rzjnnnFmedvI5/4orrmjbKF8xtKvS9a+66qrmhS984ayOXvtWfiz3a+A7OzuN+lSMGH9oh2aUXVM/tuCTPPRcslh0fkyzrByKYzlpwZn7KLV3f26rOs7LqWWp6myLrJQULL2unXc9lsRfFJ3x2HWjVCzJylJebOM4Oc19RSma6w6dl2TX1PMs+CQAPZcsB50f05LkLMVymz6R6TpOcxzLSe/iLI3P41HbbZeVJbFXkoMSfV35JQmY5aTa3v3Q4+3Oy9imJExj+5I8jePWcd6VaUka+ykdl+TfuvOyrNRuSolJCUr3rVfEJTRV13ldKbe1EIAABCAAAQhAAAIQqIEAsnJOWSnJGGWiJKIko6WkJKPKfS6JKMEooalU5xKXEo46d32fW0a6vWWm+nGZ2juu2ll89gnLLMqmfF6ShFkklua3qKxUDEtHieH8nZMah6WxUsV3v7GdykqveXs8lpaag9v3pUNCbMzly8hKyUaLziwQNecoHr1zUqnKVF+vkOcdnLFNF7fYr+oopr8LU2vrMXW1j/mWaTWlWQxqbiUZ6Dlrx6W46bsrJQidr1SxVOZP3J2pMp27verEcsexmFR95yl1flffiiWZaWmpOcT2Xccl2TX1vCj9PJcuKal8f9+kvh+yb/diFog61w5IffzdkjpWn8vKSsVQfMedV1SqXZcAXGc+srKGW2nmAAEIQAACEIAABCCwagLIyjllpSSiZaHloM5LctHlOZV41O5LicgoI11P8tHyMpbHdrGu+3ZeKe2TX1Mr25SszBJR5xKW6j8zs5yMwjLWUZsoLOMccj+xXek4yq+pHe9XVkoYxu+rHJKV4qK+LL3U9lW/dNHCsjL3W+ItATqvsOwSXlPOX1RWeq6SghKW3u3ofKeWixaSFpmWkC7P7Us7MLOAdN+OFeeQ63o8XallXk3pIrIyz1uysSQsFTN/N6VlolLF8c5JicVlZWXeeanz0rjy+HW+TinZFRtZuerbWuJBAAIQgAAEIAABCNRAAFk5h6z0zsa8k3EeWak2FidKvTszykhLxi5ZmWM4nsWm25fSkvSaal4UfZ6DdiX2fX+k6nkno9sMxSl9D6badAnJod2d7l/14g/1ICs/0fzYK/7jrl/ythT0zse8I7JLViqOd1M6htP4nZXOc3yJTecpdX7uN9bxcWksLstpl/Cacn4UfZ5HSRi6LKZ9OzBVL5aX+inlSV5mgalzS0/3r7bKUx/xx3aQleXvd+x7ZTsKv5Jk7BOYWSBalL7+qs/s+eEeyUy9Nq6xZBmpMait+iqNIbaN4y0ddwnFdebPKyv1i+Hx1fCuMdVwY8ocIAABCEAAAhCAAAQggKxcQFbmnZXa2ejdjUPyUSIx7pAcqh/L1e6CCy5oXycvScmuPAu6GtKSFCyJxTxXy0LnD8UpxRySlX3CVP2rveJaNOdUZR5fV5oF2JTOJRLz91Nq92JJCloYZpGo+ZbKSrHNpksoluKU8hynlCq2dlYqLZXHPIuymtIoFD2vkhx0WUxLbXO5f3BHdX3sOllWarel6qiu6ygtjceyUmX536HPVRbjlI5LsmvqeaVXvktysDRPiUIJSKUqlzxU21LdkgC1rPzlK66fxfGuS7WP43I9SUjHdl81yMrS91PyAzvcrEMAAhCAAAQgAAEIbBsBZOUcslIiUKLSuyItHvN3VuoVb4lFi8O48zLHiDLS9bt2VnpnZ5albteXdomvqeZL/Omj8efXs2NZnJ/yswyMdXOc0g7I+Br4m9/23lnf6sOvgTu+Yqnc/UtS5u+8dNk27ayUuJOYtJyU4NMr2haSSv26t477Xq+OdXPcKAj7ykpicqhf/YJ43L0Z55P7zecl2VVDnnYoeudifsU6lp37S69vv6fSr3G7nTj837/5R3vKLQxdv+tc7bvkp/Lz7km9gi5hmfmzs/JNrWSU/JMIlPzTj9VYHCrfZW/84OdmEjEKQ5dFuejymMbXvpWfz9Vf/pFnwfNyAAAgAElEQVQcx8511ZfqKlWsOEadT+01cO2Y1G7LJ04+0/76t385vGs3ZczftptY5gsBCEAAAhCAAAQgUCcBZOWcslJCULsovfNGr2CXfg08ykoJSQlOt9HuyP18Z6X6zrEUU3KzT1SqzGKsltRy0EwlAz23KCCdp7QkK/viqI2Epb5r0v1YRqpMx85XGsssPl3eJSoVZ9tkpQWh2UgOWupFAalj14mpRafaaFemy2K+JWipzH0p9VjyGNwupo6fx+X8GLfrOIuxWs4tEs0rSsAoK/MuxigqxSKXW0yaU+4nl3u3pOvHVMLyG77xm9vrJbd1XWTlV2WlZaB/oMaiMotA5buOUstE1ZM4jD++43rx1e/cT96FqXO3i7EV3xJV5fn7MD1Ot43SU2V9nyj9NnWcXwN3v9ffc6ydv2Sl84fSOm9VmRUEIAABCEAAAhCAwLYRQFYuICuzGJS83M9uxxxnneeSYnzqYNAlwsg/2krPsbKwECP90p4djVNl0ie9KOuXgmPlMyQCp1C+bTexzBcCEIAABCAAAQhAoE4CyMp9ykrtatRr4HEn5Tql435jIyrrEJVax7GKOMY1LEunKuQYd7dcHatwY1z7F6VTkJFDY6zzVpVZQQACEIAABCAAAQhsGwFk5ZyyMv8i9xREpQQnshJZiUwclonrZoT065Z+U2WDFNy/FBwruyEROIXybbuJZb4QgAAEIAABCEAAAnUSQFbOKSv3u7PxoNshK5GV6xZxxB+WoVMVcoy7W7KOVbgxrv1L1CnIyKEx1nmryqwgAAEIQAACEIAABLaNALISWcnuy4l8rydScFgKjpUR0q9b+k2VDVJw/1JwrOyGROAUyrftJpb5QgACEIAABCAAAQjUSQBZiaxEViIr+T7Mm9YrQqcq5Bh3t2Qdq3BjXPuXqFOQkUNjrPNWlVlBAAIQgAAEIAABCGwbAWQlshJZiaxEViIrq/mV7k0JVqTg/qXgWNkNicAplG/bTSzzhQAEIAABCEAAAhCokwCyElmJrERWIiuRlcjKa7t3UZYE6FiFG+Pav0SdgowcGmOdt6rMCgIQgAAEIAABCEBg2wi0snLbJr4t833XDQ80fOpg8JefeajhM00GL3jVFQ2fuhh8/dmvafjUxeDn3vPXzdQ/23JvwzwhAAEIQAACEIAABOomgKyse30RlRXJWkTlNEWl1g1RWZeo1HoiKusSlVrPqYtKjZ8/CEAAAhCAAAQgAAEI1EAAWVnDKvbMgV2Vdeyq1DoiK5GVSM/xSE9kJbJyjHKz53aAIghAAAIQgAAEIAABCEyGALJyMku1v4EiK5GVSM6Dl5xIxvFIxlWtBbISWYms3N99Ca0gAAEIQAACEIAABCAwRABZOURo4uXISmQlshJZuSpBR5yvSVdkJbISWTnxGySGDwEIQAACEIAABCAwWgLIytEuzWoGhqxEViIrkZVIxq9JxlWxQFYiK5GVq7lPIQoEIAABCEAAAhCAAAQyAWRlJlLZObISWYmsRFauStAR52vSE1mJrERWVnbDxHQgAAEIQAACEIAABEZDAFk5mqVYz0CQlchKZCWyEsn4Ncm4KhbISmQlsnI99y1EhQAEIAABCEAAAhCAALKy8msAWYmsRFYiK1cl6IjzNemJrERWIisrv4FiehCAAAQgAAEIQAACB0YAWXkA6I8cOdKcccYZs88tt9zSnH322c3NN9+8lpHUJivfcc3h5qU/fG5z6NCh2ec//tqbmqE5qk6u91//4H1tDMX6n/6Xb2l++13X7Ynl/v7Pn3nNrjLF8xg0HtXL4+hq63oaQ1e/rhPTqUvH991wX3PWv3lFy+01F/1/TdecVGa+//M3/bPm0j/9eFv3j6+5o/nn3/F9bfm5P3dBW6Z4ufy3LvvztjyX5bZ9/ebxa3y5fdd8apV8L/vdDzf3H3uqOX369Oxzze1fbvrmqnLXVTu1d/3bHniss+yV7/hEc/zpnbb8bTd8cdYu5zu2Ute5+C9uaU7uPLunrft1qv7dxnl9aa2y8qW/+ubm/oe/thbXfO6upjTXXE/Mb73vy7vq/uRvvbs5fuJky/6yD36yLVfcuF6qp/q5Tazj9rHtyZ1nmove9VezuPO0Lc3FeWOSjw88/nTL59GnTjW/89F7m3nGt5YbCYJCAAIQgAAEIAABCEBgwwSQlRsG/vzzzzfnn3/+2uRknk6UXTUcSxpaHL71L25t/rdv/95G0q80N5dLKmVZqXPHKbV1nqVmrKs89av4qhfH5HZKS21dbpG5TbJSYs9yz9IwikSLPpW9+sLfagWj6khOKl91/t/furyVlxaIFp/5XJLzjH/54rZ+X9uhflX+vT/wI20sj3eetE96TblMgk8fzcHisEv4qV4WlJ67JGYsi3EtRC1CJR8lLpW6fUzVv2PlMZXaRpnZNfYY38cWXLWlEo6WjpZ/loRxrio7+viTrSiMZTqWQJRILLVVufroEqE5lmJIoEqQqt8bbr2nlZ4qs+jM7XQe25bKY948MnATdW5/6MkmCkqJS33m6TvfA3AOAQhAAAIQgAAEIACBKRJAVm541U6dOtWce+65jXZXbuLPcqyGVHLwO1/6w7t2QHZJR4tKCUPJxJKszHmZkYTiD/74q2afKCtzPO3I1LgsLxWnq6370Li0IzPPx+WldB4pNtY6JdEnwWh52TduC8iS2FQ75WvHpupJTkooWmyqXH1YZuZ+YttclvtVTPUTY+c2XecWXDWlEoFHn3h6lzSUULS8jHOVEFRdtYn5PlYby0jlReFYapvrO47FpqVjblsql/h840dunwlOt3O8vjRKrlqOSwJSQtHyMs5TdSUQlcZ8Hw/JSJV3iUzHUOodnF11+8r7ymIfPp5HBm6ijsSkhKX7uv7uY7vkpfNL6SbuK+gDAhCAAAQgAAEIQAAC6yaArFw34RDfr3/79VbtsNzZ2dmz0/LKK69sX3G95JJLGn2Upz+9Lq52F1544azO0OvjJek11TwLPolAz6EkCl3mNMtF5ZfyXN+pRahT5ZeEqXdJanx9bV3mGKq/LbKyJAVLYrEk+0qiM9aL0jMeu06pb5eV6rss9zvveN0+pn3Sa6plUSh6DlkOOl8iMspI5ztVLElDy8woI0sCtNS3YuV8y0n33TU+11N7j2koteCqKS3tQtQOSe2gzFKyK188hkTmIhKxNKbIXH117fAcahvj6Lgk/w4iT3Ly6Z1nm7d/6oHZmLK87BtTuOXgEAIQgAAEIAABCEAAApMlgKzc8NLlnZX5tXBJSclI5etPMlJyM8pKnQ9JSk/LgqyGdNWy0tJYaRSNYhUl6KKysqut18Ci1NJS9V3Wl0b5NbXjkjCcV/5JKHrnZJ63hKJeEVd8lZXkY6lv1c1tc+zcr8ar78/0ddM1phxH50Pia4rlWQxqDl0yUPLxqs/fX/zeSc9d8fz9hJaLKptXVnYJR+crdhSi7lep6yArv/a6tUVel5T0a95eM7+mrXYqO/zgI83Hb7unXdNYblnptvF7J92vUtfr2lWpOtr5GWO7/TxtXddpnwTcdJmEpfnEXZZD4/D/9pNCAAIQgAAEIAABCEBgygSQlRtevT5ZmcWlh1baWWmZ6TpdaZ/8mlrZKmVlnLtkob470sIy75RcRFb2tVWfcQ7Iyr2vbGfRJ2EYv68ylls2qo7z55WVpbaOobSvX9fT6+XzCssoxmo5XlRWRlEoqalzpeKRhaTO/b2TuUz1u/q+++gTu360J7+qrnP1m6UksvKrv+xd2onYJSst+JzqtW5LQ4vM+J2UKtfH9WOqfkvC0tJT4jHW97Hid31f5VBbx4jpkAjcVLnkZPyOyvwdln3j6LoXIB8CEIAABCAAAQhAAAJTIoCs3PBq9cnKXOahISsfmO08jKLPslGiUd8rGV8Nd5lT72T0eSmNQlL19XG9WFYSjOpbY9BY+tqq/Fv/9+9tv3OzFMt9llJLsimmpd2N2qn4b1/x87Pvmsxz8vdFdn2npeLlXwlXjC5ZGeN0tVX7oX7jOCU85/3BnVoEZZzHvMJQbeJr3Y7hvCwUVS55KPEomdklK9XesZSqnj45L9fTuHMesrJfVmqXZJcwtOyLr2OXBGcpz22VSmRGuak8nec85XvXZJf87Gursq5PnwTcVJle/X7i5DPN1bc93L6Wrl8CP/rkqV15XePxfQMpBCAAAQhAAAIQgAAEpkwAWbnh1ctCMu6mVNnZZ5+96xVvl8fXwONr4kPDL0mvqeZJ9uUfsokisWte88pKxZJA1C99+1XfmCr/99/72dkP43gXpvr0uH7n3Tf0tv3p17y+GFd9qO+u8Ts/irKpHZde+S6JxSgMJRVL8yyJT9crlcUf2CmVu61FZVe/rudUsnLeH9yJAq2W49Ir3yWx2CUS55WVJSnqtmYZ5abz3G8Wk8jKbllXEoqShX1S0OIvfk9lPHZ5KbbLlKqP+Lq3hKQkqdrFehaVsW4s13FX21wvn3cJwE3mIyuH7moohwAEIAABCEAAAhDYBgLIyg2vcp+s1FC0izLKyNJ3VsbyoeFbdNWSxp2LFosWh7EszjfLSu2E/KXXvb2Vg3nHY2yr4yxE1Z/EpfpXeVe/pbYx9jbtrJTgkzT0Dke/hm0xqNSvey8jFC0cJULVpyTpGf/yxbPUZe7T0tFpX7+q86YrrpnFcf04H+d1pVGg1XQsEWgZmF+xjmX5te98HutaMvo1cO969K7J3Fb1S+LU+fF18zxGr4X7kMh03lCaRVct55KGlpOSjnrN2mIwlr3hfdftEomxTCz6zhX33R+7uZWQip9f5+6Sm6rr1827mHe17arv/E1Kyb6+9Ao4r4EP3d1QDgEIQAACEIAABCBQMwFk5YZXd0hWeield/RJXvIa+FdfA5fo83dCmo9FZZ80LMnKl/7wue0uR31fpYRlFInxOMtKlSnPY1D8WD8el9q6fNtkpWWhuUVpqOMoK10nppKDOYbL4yvhFqEqi/lDbTUGx4upBWsud36XoIz5Q+JrquWWfP4hkCj7soCUUDy58+zsR0OU6jzOW/UdJ36/pepYMqq81La0W9KxY79qb+npcqWeRxx/LC8dW3DVlnrnotfColLzjAJS+a6jVGWZhfJcJ5Zbgrosi0rFUfzYxrFzv44R63a1dYyutE8gbrpMstJzi78MPjSODd/S0B0EIAABCEAAAhCAAATWQgBZuRasqwtqeTnvr3/nni3GSL8mPKfKIsovjh8qviI+Vi4l2UXeFbtk5dR4dAkv8rtfMx87myEROIXyfA/AOQQgAAEIQAACEIAABKZIAFk58lXTd1Xqeyy1I3M/f1MVc4x7r1wdq4hjXMPidGoijvEOi9SxizfGt7g0nYKMHBrjfu4TaAMBCEAAAhCAAAQgAIGxEUBWjmxFJCfjK6jLiEpNDem3V/pNlQlScFgKjpUR8m9Y/k2NETJwcRk4dmZDInAK5SO7pWE4EIAABCAAAQhAAAIQ2BcBZOW+sE2n0VTFHOPeK1nHKuIY17BEnZqIY7zDcnXs4o3xLS5TpyAjh8Y4nbsTRgoBCEAAAhCAAAQgAIFuAsjKbjZVlCD99kq/qTJBCg5LwbEyQv4Ny7+pMUIGLi4Dx85sSAROobyKGxcmAQEIQAACEIAABCCw9QSQlZVfAlMVc4x7r2Qdq4hjXMMSdWoijvEOy9WxizfGt7hMnYKMHBpj5bc0TA8CEIAABCAAAQhAYEsIICsrX2ik317pN1UmSMFhKThWRsi/Yfk3NUbIwMVl4NiZDYnAKZRXfkvD9CAAAQhAAAIQgAAEtoQAsrLyhZ6qmGPceyXrWEUc4xqWqFMTcYx3WK6OXbwxvsVl6hRk5NAYK7+lYXoQgAAEIAABCEAAAltCoJWVzz33XMOnPga/9+F7Gz51MLjyEw82fKbJ4Bf+7PaGT10MXnDObzR86mLwPW/9TDP1z5bcuzJNCEAAAhCAAAQgAIHKCSArK5e0iMo6RKXWEVE5TVGpdUNU1iUqtZ6IyrpEpdZz6qJS4+cPAhCAAAQgAAEIQAACNRBAViIr2Xk5kd2nyEpkJdJzPNITWYmsHKPcrOHGlDlAAAIQgAAEIAABCEAAWYmsRFYiK9m1ueZX7JGM45GMq1oLZCWyElnJTTQEIAABCEAAAhCAAATWQwBZiaxEViIrkZXISl5VX/B7RZGVyEpk5XpuTIkKAQhAAAIQgAAEIAABZCWyElmJrERWIiuRlcjKrf8ezjHKx0XHxG0tBCAAAQhAAAIQgAAEaiCArERWIiuRlchKZCWyElmJrOTXwGu4r2UOEIAABCAAAQhAAAIVEEBWIiuRlchKZCWyElmJrERWIisruK1lChCAAAQgAAEIQAACNRBAViIrkZXISmQlshJZiaxEViIra7ivZQ4QgAAEIAABCEAAAhUQQFYWZOUVV1zRXHzxxc1zzz3X3Hjjjc15553X7OzszM6Vt4nPsWPHmnPOOae56667lurv9yYi4uYd52//xR3Nd/3gTzSHDh2afV7xK787KFtVJ9b7T2/407a94yj95m/7nub1f3bzrnj/5Q8/0rz0x/6vRv3mMZ79yl9s4+jY5WrzP37jN7dl6k9liq0+Yp8+dh3HKKVXrlmorTv+u669u/n+Hzm3nf8v/Nc3dUpSlZnNP/4n39L83ruvb+vqWHkuP+dnX9OWaQ6xreq86Ntf3LzjA7e1dVTfbTUejSvPXX388E+8qljmPvrGn+Ot6heoxxbnTdfd1xx7aqc5ffr07HPnQ08NSs8P3P5ws/Ps3zSfuOdYW9d5jvPg4yfbMs1ZcV2mtqqfWaiN6+T2qqs2Dz95qtGYdf7fP/Ng8/TOs20bt1Uax5b78XmtP7Dzsove3dz/yPGWyzW33FuUmLmeuN12/8NtXbWLTN/2kc+3ZWZ38ZUfb07uPDOrp1TnKnvl71/dHD9xalf7OA7149ixneM6VZ995a7ndNHvh1xn/XsePdHOUcfz9lXBfSlTgAAEIAABCEAAAhCAQIOsLMhHZOW9rXgrSbODzJMUtBi0/OsSfS6XmIqysjR+xcx1lKe2kqNRVlqYehwxnvv0mCQu/+m/+FeN0ljPx6qX47ssp1mATe1cktBiUfJQEvG1b3n/HlGosvN+5TfbfNWJwvGCS97eystSHPXRJRKVHwVlHJN5Kk/rHuu5zP2pvKsP142pBVdtqaSgxaDl35Dos1SM9W558IlWQOY4Oj/88NckqNpJMipfPC1MPY4SY/cpsWpZWaqn2EN13M6Cq7ZUItDS0dKwJBpVdvT4U61gjBwkMj9+x5FGqfLVXvJRbVyvTyRKWip2rO92yrvh9vvbOJKYkqvuy/UsU6coKyUno6DU8WePHJ9LWHJfCwEIQAACEIAABCAAgRoIICuRlUWJlkXZGM4lAv/5i//1LvEnwTgkDUsiMs5HIlFxFd/5aqNPSSaW8twux7LYtLx0PaV9ZbGej6P8mtqxJN93v+yHW8mo8Uv2WV72zcc7MktiU+2ynNT5vHVVL0pJtXX7mK9+LCrVJvfZN36VWXDVlEoWPnHymVYyam7aAdknDbW7UTJQ7aKszFwUo2uXpuWk2w8JRsXSZ6hejpvHlM8txWpKSwJSMtDyMs5VdSUJS0Ix1tNxjmuRWJKgqi9ZefdXju0RkDmu65bEpmJrfF1CtRRr3t2L66x38bX3NI+d2GnecdODrZzUsfJUNtR3DTemzAECEIAABCAAAQhA4P9v722fLqvO+0xKY/8bU/NlkirHSDVTmRrZH4wlNVCpciWTBCvI8swowg5OJCfBGlK2AtaL44qkxLZkNbKhhF5KGKVR9GKwJdEEIxAIgXhtgbobqVtNi4aGfkEkA05mPuzU77R+u+/nftbe55x+znnOWetcT9XJ2nute91rres00c6VtfaBQPOyUseoL7744v7Yp3ZN6hi3jnXreLd2SOnjY99qG9tZmfspdzyqrb7XXHPNJLfbdJTc46j0HHycPLfrPh8Dz+PG+TpPqbToaqEsScIsB0vrnCYrx9pLY1pilsaygPQuzbH5lXKXcrpumhBb5/YsBTVXHbWWwJQEHJt7SXQ6PueYJjY1j7hLc0g6lubrMVUO9Ysx8TqLrhbuS/JPMlIi0rse4zotA+87+NxEWFo2xhhdj+VQe5akFpE5T74vzTfGTGuPsbouya7a6yz44i7FoV2OQ/UlBll4TpORpXmU8qpOIjUeEVed5ajytCArSwJzSFryWAsBCEAAAhCAAAQgAIEWCDQtKyUR9+zZ08tECcDbb7+9F5WWhhaBkoRjstJxURSqj8ZQbve1pLQ83Lt3b9+e4/O95vzggw9ukZUed2i+HqdUWnS1UJbk3pgM9JrHZOS0/nlMyUi9w/Id//qP+/dS6v2UyuPxLCwlpkvvwVScY5Tf/aaVUX7Vdl2Sf1k0Dq0pH922kBTfvPsxtqk9v+9SY2guatNn6Ch3ab5xfsjKR4o7FcdEo3ddWlpGWek6vYdw2jFs5XGM+uk9lDpGrndZqv/QOy3HZKTHj3PKcjLfD8mzmutLknBISqpeR6z97sh8FDu2Z5mocXzc3P3j7k21u15lbBPf2K7rzNwC09JSc8kxpfshAbjb9fkYuI6Anz774y27LYfm1MKDKWuAAAQgAAEIQAACEIBA07JSUtGCL4o8CUH9eI0Fo9okDS0h1cfXqvcP7JT6WSQqTnli3zimr+OOydzXMSpjXGncON/YL19PE2A1tWdxqLlPk42KGZOV2gHpXZAlFnlMS8b4nknFWErmo+r5HZYeQ/Me+uEex+QyyrLarkvybxZZKZkYd0LmdSuHhKTy5zbdqz4Ky3z0PItQ5yjN120qkZXzycooMaeJQcXmH+CxKJSoLL2v0vJScRKOMcZ9x2Slxow/vuM+Y2VJdtVeJ/FXko6lY9Z5rRKEua9jJCvjOystGy0afSw8S031d1sWls6dx41rqFVW/rPbHu2OPH/+B6Me++HJbUfDkZU8wEMAAhCAAAQgAAEItEygWVk5JgIl+ryzKpaWklE4RlkZr6MUjFI09nWMZGM8iu6dl1FIOtZlbJs2X/cplVl41XyfxaHWMov0G5KV3iUZd0VmPnlMy0rVOzbWld6hqVjNwfEqp0nSGOvrKMtquy7JP4nGoV/c9g5JScFpay3ljn0sFkvHyTWO5qC5xD6z5ox9xq7HpFetbSX5V5J+OrYteehdi9NkpXjk3O6jI9+Rl+udW22lulLOmEcSVJ9YN+3asqylMoo+r0u7Emd5f+Q0MejdjspbGqdUF+cwJEwtM9Vfc5UU9U7KaXNyfpdDAnDV9byzsuXHcNYGAQhAAAIQgAAEIFAi0KyslLiLEjGKPMlDvVdSQjPW+zoKxygoSzscPY7idB376j73iRJyTKjGuGnz9bxLpUVXC2VpF2VJDua1DsnKWURnlpXKrXw7kZWzSNK8Bt2PybB1byvtosy7HL0Gi0oJQ9eNlbOIRcUgKx+ZS8ZNk3Vxt6RjJfyyUJRIjEd643WOdZ4oK4fko2PzOyuH4mNO91WpeO2q1Hpi/bRrC66WSkm+LAW123FoV2Ncu8SgdlaqjPW+jrKyJECnycohYRplpeYa/33F69KuTc/N5aql5ND4OgYefx18KE71/EEAAhCAAAQgAAEIQKAFAk3LSglE72KUyJMALL2zMku+KByjrLRc9BFx9VN7fmdlbveOTcfHOWms2F9icto7K/N8x+5L0qvmOolC71LMR6xjW1yj6ktHvWcRnSVZqTof+9Y48V4C9G/8Lz/fv8Myz1HxJeka5zt0PSbsamjTDkfvlJQ41PFuC0mVPu49Jh8lMt95ze91KrVm55H49P1vf/jTveSMedUe56B7joHvTGBKFFo45h2UsS2KvywTdX/g2MmJNFSc83in45BkdE61x2Pf+T7GxePiri9JV7eNlRZcrZWSipaTEo/aqSiRqHXGto988d5+B2Nuk4zcd+8TvbRUf73f0jseLRgtEPP9p+/6Ti89c5tyeT4aVzniEfP4fbSws1K7Kk+efnmm91UiK1t4LGcNEIAABCAAAQhAAAIi0LSstByMR729A1LiUpKw1DYkK5XPwtL9omhUe+xbipe41PsyJSXV7j7OZ5EZd1YqZmy+zlMqh8RXrfU+cm1ecYfjvLJS8bF/iYna4/spHaN6zyGKS7VLRupHd9yeRan6amznmrWUXKv54x2T5mJRqTVFqahrx8TSolNlrLeoVB7LS7dbgEZusX+p3fPJP96Tc8RxY1vpekx61dxm8egdbBKFXs+sslLxinUOlRaValPO2OZrS9IcE8Wl5+KYkqxU/pgr9hm7jlKspWvLQXOOYjDKStU7RqUFp1hYcro9ikqzyuNYXKpd1+6rMrZJeMYf9hkSlZ5Hbb8GLuGonZRe/6w/rOPdljzaQgACEIAABCAAAQhAoAUCzcvKksDbpLpZRRhxT80tD3ebWUmCUVeHwB2TXrTtbHfnqvhZulH+Xr+DsnYWFn41ly08mLIGCEAAAhCAAAQgAAEIICt/sruxVYG520KN8ZYnPRGTdYjJ0ve0KqHGuMsTobWLOea/XbLWLCk9dx5rIQABCEAAAhCAAAQg0AIBZCWycu13FCJAzwnQkgSjrg6BiTRcnjRcFVtk33bZVzsTC7+ayxYeTFkDBCAAAQhAAAIQgAAEkJXISmTl7cvbDblI0YqYrENMlr6nVQk1xl2eJK1dzDH/7bK1ZknpufNYCwEIQAACEIAABCAAgRYIICuRlchKZGXVP9xTkoPrVoc0XJ40XBVbZN922Vc7Ewu/mssWHkxZAwQgAAEIQAACEIAABJCVyEpkJbISWbnkX1pflVBj3OVJ0trFHPPfLltrlpSeO4+1EIAABCAAAQhAAAIQaIEAshJZiaxEViIrkZUdYnM+sYns2y77amdi4Vdz2cKDKWuAAAQgAAEIQAACEIAAshJZiaxEViIrkZXIygFkwbAAACAASURBVD9DVtYuG3c6/5olpefOYy0EIAABCEAAAhCAAARaINDLyhYWwxq2E/hf/+Cejk8bDD7wpQMdnzoZvO4X3tnxaYzBG6/sXsenKQZPPXWyq/2z/SmAGghAAAIQgAAEIAABCNRHAFlZ33c214wRlW2ISn2PiMo6RaW+N0RlY6JS8hlR2RyD2kWl5s8fBCAAAQhAAAIQgAAEWiCArGzhWxxZA7ISWYnkXL3kRFYiK5Gb678TFVk58jBBEwQgAAEIQAACEIAABHaRALJyF2GvYihkJbISWYmsRJYuQZays5KdlWt4bHwVzxmMCQEIQAACEIAABCAAgUUTQFYumuia5UNWIiuRlchKZCWykp2d03d2srNyzR5gmA4EIAABCEAAAhCAwMYSQFY2/tUjK5GVyEpkJbISWYmsRFY2/rjD8iAAAQhAAAIQgAAEGiKArGzoyywtBVmJrERWIiuRlchKZCWysvSMQB0EIAABCEAAAhCAAATWkQCych2/lQXOCVmJrERWIiuRlchKZCWycoGPFqSCAAQgAAEIQAACEIDAUgkgK5eKd/XJkZXISmQlshJZiaxEViIrV/9EwgwgAAEIQAACEIAABCAwGwFk5WycFh51+vTp7sorr+wOHTq08NwxYWuy8qrPP9L94PlT3SuvvDL53HPwua60xhynPqorxT557OQkZ2xXXo+h8uTpl7vfvv3JLf3VzzG6Vu7cz+1x/BgT60tzi3W1S8dP3fNMd+LFMz2zp4692A2tSW1md/blH3f7nzi+Jfbo86f7duVUbudSrPqo/7S+yuN+KmPeUl/HeowHDp7Y0t/tuWxVFl7y7n/bHTz6bP9d3HHfI93QWtXm7/TEyZe6t73vE8XYh757uNv7hTu3tClWfdw/tl934xe6U6fP/7tS/ziH3B77Kk7xzpv7xjzbrhv9NfBLfuN93cEjx3omd9z7UPFXv3OcGD504GAf+7brPtqdOHn+v+O9+/6yb5M4ve4Tt/bfm74/3Vuo5r4xr2NK/XM/f68q8/jOE8t1/IGdz33u9u5v/s2/1f3FXzzQzTK/+L//XEMAAhCAAAQgAAEIQKBWAsjKFX1zyMoL2/EoKWgxKHkoiXjrw0e2SEQJPtXF+tgvCsC93zjcnT778jZZqfhpItTziPnytaWp56Iyis+heeU8us8CrLZ7iUDLwdsePNKdPvvjriT71Hbw2Zf69SpGsarXmiUyo6CMeSURFWu5qfLk6bN93xirXLq3NM3j5nEib/WTACnNP8b5epvo+oUl7PRbQU7JPQs+C8UsA7V21UVBKXEpySnZaTZRKsYcFqIWoYpTLpXqu++ub/XXeQ75PveN81cu3Xscz2uwbFRWSgxaDlr+lUSf2o4eP7FFMlr85X45VqJRItOCUqVyKU459t35zb7NUjRKU80nC06PnUvFSr4qT27L97PIwN2MefTRY91b3/p/IStX9JzGsBCAAAQgAAEIQAACqyOArFwRe2Tl/LJScvL4i2c6CUbLPAnFWaSh+qhvaXek+ucdjqqzYPRYLlWf492WyxyrvFGCDs0r59G9xVeNpUSgpKElotYgGSjpN2093pFpMRgFo/qq3vKylNPxpTlkmRnnMtSmeo2n9XhOsV/pelB4rUAwLmouEoFHf/R8LwqVV6LP8jKOk+slDdVXORRnifjhz90xkZhRVuZYxY9JxdiW+1p8Kn9p/jk+rmHbdYOyMktFyTxJQsvLKPcUKwlowRjbSoIw5onX7qcxopB0vcqYz/JSdTGmdD1PrPrvpoicZSztqpSs/Dt/5/9gZ+WKntUYFgIQgAAEIAABCEBgNQSQlTNyv+WWW7qLLrpo8rn88ss7yUb/ffCDHyy23X///X391Vdf3d14442dYvWXZaXqNYb/cvtrr73WKYfn4DyOHypL0qvWuiz+tI5ZZV+pr+u+/PixLfIx74bMvMZEZozNeUqyNcfE/vm6JMFqqYtC0XMekoFud5klo3LFnZaWkYovyUrX5TyKL9V53JjXdRan33nm+Ymw3GRZKeFX2h0ZJaQFn2WkStVleem4KBNdV4otja34LBudTzlye0lWluo8j21lg7IySkHLv7zrcVq92kt5Yl1JVpbqPFZs03yePHRkpp2ScUznGitnEYi7FXP//QcnklLCElk59IRDPQQgAAEIQAACEIBAqwSQlTN8s3qvpN4vaUF5+PDh/lrSMIrD/fv3T9okKqPUVI43vOENfWyWkWOy0qLSMtP3GmPaXxZeNd9bLkrweR2zyEoLwbijMYrDnNfxft+ZjolrHI2ptkPPvdR97bs6bvzy5ChwbPe8VOa8cUzHeSzFum6otDCrsdyJrJRs9M5Jr135/P2o3fUSoPEYuGSk7iUeFaPS17pX3/huypi3JCItPi0tSzGeSyy3ia6Kd1R6LSVhmGWhY1Wqze+WLO2+VIzlonK77zRZ6T7695Dlacyp9ngUXW2aR5yLxpocL/6JVPUciiWysv8+J+zDUWvtttQxb8lCyUHvcPRxbAnHeAzc8UM7OGMu5VScPv6/A0r9PKbnMCYp3bZbInKWcd797n/VfehDN3SWlryzctrTDu0QgAAEIAABCEAAAi0RQFbO8G1KNF522WXbfgwnS8yYKstHtUk2WmzOIytL40hUOlccN18Pia8a67P80xqmyUrLQO2GjGuOx7FLeWOs2i0knS8eA1d7fA+l++YdmMjK7T+EE98nGeWeryUH4y5K1VsYxpgoM6NwVN/vP3eqF5SWjJYcasvH051XUjPmjTtBnQdZuf29k6WdlVls6j6LwygW55GVUSRaiLp/3impe43r9ig69W/ivsee3na0Pebfcr3hstKCz6WEoWWk6iQkLadV7n/wsS3tkoj+71Ay8r5Hv7vtuLklZjwe7n6WkJaSMcbjz7oD02uYRSLuRoyPf+udlcjK/FTDPQQgAAEIQAACEIDAJhBAVs74LXtnpI5he0ejSh3N1k7H+De08/FCZaXG8fHvWJbGjvPQtcVZC2VJKkpWaqejJGJeo9okGdUvtmmHZZaN8T7G+tpy07Iy5izVSUwqp0rnGJKVmr93bjq2VFqi1VhK6kXxpzVI/h0/uVVgem2WgXEXpNpKx7YVqzzK5/6xVA4Jzljn6yggXefSc9DcvUPTcjK2OX6s3CK5GthVqfVI+OWdjJKFTx4+uuWHcywELQjNQjsac10pdmhnZdwR6Zx5XvP2HdsZGseYXG+QrJxF+kksDv3gjmRgPMptORhLyc4oHCUjJ7tcw6+EK171UYoO1SlXzBfHGrreDRE5bQztoPz5n//F/h2VyMr8VMM9BCAAAQhAAAIQgMAmEEBWzvkta0ekjndLIJZ2PCqdZaWPbXsI7YT0bsh5d1Zee+2126So846VJelVa11pF+XQD+yUYrVui0Xv6Imld0+W+MRdkvE65owCU9eKi7k8dowbmmfs5+sxGbbubSUpmHdIeg1jInBeWVmK9zgqh+agtjgPScr4byVeZ6Ea8/t6m+hqQFiWxF5JDpYEpHjMKitLUlR9NVaJa4wvzUftQ6KzFF8aY1LXoKwsvZ9ymmS0+JOsHPrBHe9+9G5I93GZRWdJSDq29M7KHK/xJFgV636zlNNE4m606+h3/P+UjNdqmzaHsecB2iAAAQhAAAIQgAAEIFALAWTlDN+UxKQ++rOI1L2vLSDV7ndWSlTO885Kxcedksqpd1xKiHqcLD9nmPoWWWbpVXMpAWgJqJ2KOn5t+RfbdB3fUTm2ZvWPOyuVVz+64z5qj8e8p92r39D4uW+cs8cbKi2+ai0l9Sz28k5FyUAf99Z13oUZ1xzzqF7CcSg+x8Y8Eqga0zsyNa4+jlFez8l1LqPIdN1YOSi8KpeWkn4Wf/mIdWyTBIy7MCUMZz0GbtlpOSlJqr4q1bb/20/0Ozk9h1KsvgO3a/z8ncS8ua1436CslNDTDke/A9LHsC0ZY9uHP/OlLTIwtmUxKOGZd0PGmNh3mth0u3dN5nvlLUnXON7Q9TQRuIp2dlbO8qRDDAQgAAEIQAACEIBAawSQlTN8o/EIuHY5RGlokejdD1k4xvqxXwPPeb7yla9MftRHY+vPOzqdT6UF6tgShsRXrfXeneidbZJ/XksUf7p2TCxjvPupLstKyUn3i6Iy9hlq1xzHjnZLorqv5umc08oxGVZDmwWf1x7FoK4tBnXtmFhadGqtunab+6neEtRtsY/aJSDdFn9YR22Slqpze8yr9vjxWuIaYnu+LsquykWl1mSRaGZRAkZZqVgJRMcN/YiN88U86mvJqP65r8ZxXpUWlWYuCak+jonts8zJebaVjcpKyz/zsqiU4ItSUfWOUak2S8CcI4tKS1D3H+vrmHgkPOe3uPT4mlvM6fpp5Spk5LQxkZVjTzi0QQACEIAABCAAAQi0SgBZuYvfrHZLRtG5G0NPE2C03zOzLFw1qyzAuN8qENeZxzbR1YCo3Pg1NSorpwm9ltunicMa2nfjuYIxIAABCEAAAhCAAAQgsGwCyMplE/5Jfu2C9LHuXRpyMsyqBRvjL06GrrOMY27j4nTjxV6LchZZ2e+kbEVg1iAjp81xN58vGAsCEIAABCAAAQhAAALLIoCsXBJZycl4ZHsVolJLQxYuThaumiVCcFwIrjMfZOU7t70jsnomyEpk5VMnp/7gzTS5uOj2JT3SkBYCEIAABCAAAQhAAAK7SgBZuau4d3+wVQs2xl+cLF1nGcfcxkVq9WKuxZ2RO10TshJZiazc/YcaRoQABCAAAQhAAAIQ2AgCyMrGv2Zk4eJk4apZIgTHheA680FWsrOylaPSLa9j0bscV5Gv8UcalgcBCEAAAhCAAAQgsCEEkJWNf9GrFmyMvzhZus4yjrmNi1RkJbKyZcnXytpWIRcXPWbjjzQsDwIQgAAEIAABCEBgQwggKxv/opGFi5OFq2aJEBwXguvMB1mJrGxF6LW8jkWLw1Xka/yRhuVBAAIQgAAEIAABCGwIAWRl41/0qgUb4y9Olq6zjGNu4yIVWYmsbFnytbK2VcjFRY/Z+CMNy4MABCAAAQhAAAIQ2BACvax89dVXOz7tMfjpd32+49MGg7/9h/d0fOpk8FPv+ETHpy0GrQg61nFl/0NBzx9/uav9syHPriwTAhCAAAQgAAEIQKBxAsjKxiUtorINUanvEVFZp6jU94aobEtU6vtE8p2XfK2wqF1Uav78QQACEIAABCAAAQhAoAUCyEpkJTsvK9l9iqxEViI910d6tiLoWMd56YqsbOGxljVAAAIQgAAEIAABCLRAAFmJrERWIivZtbnkI/ZIxvWRjIv6LpB85yVfKyyQlS081rIGCEAAAhCAAAQgAIEWCCArkZXISmQlshJZyVH1Od8r2oqgYx3npSuysoXHWtYAAQhAAAIQgAAEINACAWQlshJZiaxEViIrkZXIyo1/DyeysoXHWtYAAQhAAAIQgAAEINACAWQlshJZiaxEViIrkZXISmQlvwbewnMta4AABCAAAQhAAAIQaIAAshJZiaxEViIrkZXISmQlshJZ2cBjLUuAAAQgAAEIQAACEGiBALISWYmsRFYiK5GVyEpkJbISWdnCcy1rgAAEIAABCEAAAhBogACy8gJk5fHjx7s9e/Z0d999d/fqBfSPfW6++ebu+uuv33GemDNe/3QlIm7Web75D/Z3h46/2L3yyiuTzx2PHS3K1rd/8r7uxEtn+zj1UV+PM2ue67/8aHfghy9s6ascD3//xGDu2Hbq7MudcnjcWN5w91PdWHuM1fXfXrJQW3b+X//8I92R50/13L5x8LnBNR04drKPO3325W7vvYe3xMZ2Xce5K6//fZT6OvbzDx/pcnvsqxwnT7/c/c7tT07y5/lrLapzvrFyUb9AvW553vT7X+wOPvtCz/uO7xwelZ5q93ejfurvNT18+HjfpmvXq7z+tge6U2de7ttv+PqjW9rH8sa+yqF75377DV/rTrx0ps+bx3VcqWz1h2ku+Y33dQePHOuZ3HHvQ0WJmeP0vT504GAf+7brPtqdOHn+/67eu+8v+zazu+4Tt3anTp/jr1L3blMu/1uJeTUf18dSc9ac3F+l+pXGjTHxel3eWfnNex7ufuZnfra76KKLJp9r3/Pebta5NfBcyhIgAAEIQAACEIAABCDQISt3KBujGLyQa2Tl54siL4s630sE6qN7C0lJP7e7VJ3rLSaj2Jwlj6VjFp3KE+tyrv0HjvXzybGen+e0SbJSUtFiUQJQIlDCMEs+tT3wzIm+XgIxisGYR311b/GZ+yp/FI4ey+Ixy8qYy7EulSvON8/DcaWyJLtaqJPcs+Cz+Msi0etUXBaUsc15VKdri8+cV7JRgtHSUePpXnHu61w5VvdHn3+pj933wNN9HotXj+u5DZVRcrV0LcFnOWjhWBJ+ajt6/MQWwWgOuV8pVjmzoHT/OAfV6X6aNI1zjBI01jv/UDmrEFx23Kc/+WedhKXGefrJI90vXvKW7s+/9PWZhCXPtRCAAAQgAAEIQAACEGiBALISWdmLNYu0dS0lJ48+f2rLTkXJQMvLsXnHuFnyWEBKeEYxqTHUpnwerxTjNu2q1Jw1putUuk9eT4zJ1yUJVkudJOLxF89s2SEpwSjhN20N2lWpvspRyhPbcy5LySgZFaN7CdA8J80nx+acvh8b1zEuh4RXzfWSgxJ/loZai0SfRWFcW5aEsa2UJ8bHa/WzVLQUjWJT7TG+NJ8cH+einENCNcbpekh41VxfkoqShJaXcW2K1W5GlbFe1xKEeadjzONdmSWRWJqD5KPE6CxjKVY7Oj/8mS9N5lAaI8/X98uWkBeaXzsr937sJmRlC0/drAECEIAABCAAAQhAYCYCzchKH832sSntWPRORx3Xdr1KH98e6nPmzJnuqquu6vbt2zc57q0+F198cff4449PcrrdeTSO2hTjcTS+426//fZJPrfFfnFnZbxWTvd3/NB8vc5SmYVXzfcWfPE495AMjOvMcnKePKVY1emIuQVklpdx7FKb56M8myIrLQfjselZZV/c7ViSlaU6S8JSm+s0pygrh8Smc+WytKYc4/ssulq4L4m9KArjGiUNh3YslmRlrLOcdP84RozzeI7X/EqyslTnvmNtjnFpwdVSWZKMQ6JwqF48Snlinfo+eejItmPb6luSlaU6xY5Jz7G2oe/sQmXiMvtph+Xf+7v/YLLDcpZxZnryIwgCEIAABCAAAQhAAAJrTqAZWan3PlpQSvI9+OCDE7Eo0af3S0r0WSqqzeIvisArrrhiIh0tCWM/5ZfAVJvb3VeiUrGWmcotQem4KDpzbBSU8bokK4fWWJKUrovirPbrkjgck5UShXqnWRSLYjBPnlKsc/h9aXGXZW5T/8zdAtPScuidlrmfxVeNZUnsjclKxZuvruOa8/Fr7dDMx7kdn4+Qq97y09JS81C9ZaXHHcoZY3383OMNlRZcLZXzyErtZtSR6/h+SPU3D7Xr43tJw/h+SQvIc/89nz/yPU1WSmzGI+OK130cy2O6Lc7LbaVySHjVXB+FotcxJCVV7/dN6nuJOyklF7W7UfmUx+LQMar3UW//9xZ3b7rNc9CuzNKR8dJ83cdjeg6uHytnkYG7EXP0mRe6//Pt/3jy//mpUvezjrvmz5xMDwIQgAAEIAABCEAAAjMRaEpW5h+qsSy0VLTAU6k6y0fXSxbqU+onySiZKRGZ26NEdC6VOc5tMT4Kynhd6q9+eY3OOVRm4VXzfUkcjslKr1VSUMLSUnGePKXYeKRcY+g+HxX32BKTsS3mQ1aeP949JPlUL7kY31mZpeIjR1/YskPSuSQS8/sqozTNstL9XCq2JCw9vubl2GllSXbVXjevrIzvlcwSMcpIyatvPv3D/oh5FpJRKuY2MXUuS0eVFmKag3JnWemckqSzfi9j0qvWtpL8G5KVeY0SjJaRaosyU6Jx/4OP9e0aR9+JRaLFot9L6Xt/b/c9+t3i+zE1pnPk+TjHUHuO1/2sQnA34/xjO7yzcqZnWoIgAAEIQAACEIAABBoh0IyslKyTyNNRa0tIiUXvlswyT2LQx7JjqRwlyTgkK0uxHmuoTWPro7goKOO12kr98xo91lBpadZCGUWf1yNZWfq1bre7jFJznjw5tiQYdSxdcyjtkPQP6SiP2iVNHVfK5fmWymlCbJ3boyT0PLWj8dBzL039RW3LwbzDMubxOy1V5/gsEzWe5KV3Uk6TlcrlXZhxLAnMobk4LpezCrCa4oZk5YGjJ7b8yrfWJDmYRWCpzuuPR71LR7M1tvoPyUrNQTmcL5Z5XOWKuzhj7Nh1SXbVXiexF4Wj1iPpOHRkO6536Ki2Y+I7K0vjlOrctyRMNZ7mqtJxsWxFVkqMSlTOusOykWdTlgEBCEAAAhCAAAQgsOEEmpKVFnaSfhKWJ06cmJRDOyuHdimWJOGQrNSYymP56DmoLOXJ8VFQxuux/mrzGjWG7oc+JelVa10Ujl5D3uXo+lzGvvHacUN5FikrNYZ3CuVSbZ7LUJkFWE33EoRRKGru2vmYhWJpTZaPQ4Iw5hmLVVzm7nu1lcbW/DxuaQ2lPqW6MelVa1sUil5DSSyqTfXzyMqYJ157HMvKvItS7aV5uV+WmyXh6thpZRRjrVyXpGCUjGPrHJOHWRyWBOiYrCzNQfHx6HieWx4zt5fud3PH5DxjISs3/Emd5UMAAhCAAAQgAIENJNCErJSw+/jHPz6Rg5J28Yi3pF5896SkY+mdlVH2lSTjmKzUePG9lPmdld7p6bnF+URBqTy5Tbs+VT+2xjj3fD0kvmqt17FqfTR/H++WUNR9bNt/4Fj/Azje3eh+OTbniWyyrMx9dS/R6KPeivd83Jbfmen8m7SzUgJP4s9yUrsatcvRIlClj2zr2vXqJ5HotiwC825J9YtHxnN8vM87K3X/lceP9dIyzkn9NPchqRnzlq6nia9a27VLUR/N30epJQB1H9skEOO7I/N9XH9uy/d5HI0Xj5jHcWPePKeS6MzxY/cl2dVCXXxfpARkfPdkbNOvbUs6es2xzXUuJRvjjk2LRNUrJt+7n0qNoTnEsVSv8dw/xvvaOSU1XTetnEcgLitW76f8yIf+qH9P5dNPHul+8ZK38GvgG/iAzpIhAAEIQAACEIDAJhNoQlZK0Pl4tOReFH5qkxD0Ue8oFSUg4y94u21eWakxJBQ9RhSMEpUSqR7HY1gqRlmZ16F+6q/cuS2v0flyaTHWSmnx6B1xUQxGWZl3MUZRKRZjeSKrkqxUu/J5DlFGatfmqbMvF9tiXl1vmqz0rkdzi0IyikEJSB21dlwWlXGHZH6npPK4XywtSaNILMlKjeV+eVzlcFss4zpi/ng9Jr1qbrPwMw+LSq0pS0NJRx23Vmw+dq3dk86R25Qr9lVc3qUZ+1ueqp/FpnPHtjx3x5TGL31H08RXre2WfOYRZV8Ukqp3jEq1ec05RxSVQzFRPOrauUs/rKP8OpqeBaZzq/Qc4vxje+l6WQJy3rzXvue9W54n9n7sppnfp7nJD7SsHQIQgAAEIAABCECgHQLNyMos6dbhviQ9d3teWZBx//mpx63XlVGUX1zf0++ArIFFSXZR94niOyVr4VKSXdRd2QvLGlnMKxXXMb6dx1NWAgEIQAACEIAABCCwyQSQlSPve9ypWERW1isG11FY1iDlmGNZotYi4Jjn7AK1RhnHnMdl6jrKx3nntMkPtKwdAhCAAAQgAAEIQKAdAshKZGW1Ow3XUSguc06IwLIIrIELEnB2CVgLK8TfuPirkc+8YnAd49t5PGUlEIAABCAAAQhAAAKbTABZuURZudOdmYvov0x5Ru7d3Tlag5RjjmWhWouAY56zS9UaZRxzHhes6ygf553TJj/QsnYIQAACEIAABCAAgXYIICuRleysfNfuSscLlbyIwLIIrIELEnB2CVgLK8TfuPirkc+8YnAd49t5PGUlEIAABCAAAQhAAAKbTABZiaxEViIrq/qxmhrkZJ5jLQKOec4uVWuUccx5XLCuo3ycd06b/EDL2iEAAQhAAAIQgAAE2iGArERWIiuRlcjKP1zurk0k4OwSsBZWiL9x8Vcjn3nF4DrGt/N4ykogAAEIQAACEIAABDaZALISWYmsRFYiK5GVXS2ScF3mWaOMY87jgnUd5eO8c9rkB1rWDgEIQAACEIAABCDQDoFeVrazJFYSCfx///m/dnzaYPDXP/7rjk+dDC77k/s7Pm0x+Kkrfq/j0xaDn/7NL3S1f+L//nMNAQhAAAIQgAAEIACBWgkgK2v95macN6KyDVGp7xFRWaeo1PeGqGxLVOr7RFS2JSr1fdYuKjV//iAAAQhAAAIQgAAEINACAWRlC9/iyBqQlchKJOfqJSeyElmJ3Fx/uYmsHHmYoAkCEIAABCAAAQhAAAK7SABZuYuwVzEUshJZiaxEViJLFy9LkY/rLx/n/Y6Qlat4SmFMCEAAAhCAAAQgAAEIbCeArNzOpKkaZCWyElmJrERWIivnFXebGI+sbOrxh8VAAAIQgAAEIAABCFRMAFlZ8Zc3y9SRlchKZCWyElmJrNxE+TjvmpGVszxVEAMBCEAAAhCAAAQgAIHlE0BWLp/xSkdAViIrkZXISmQlsnJecbeJ8cjKlT6uMDgEIAABCEAAAhCAAAR6AsjKHkWbF8hKZCWyElmJrERWbqJ8nHfNyMo2n4NYFQQgAAEIQAACEIBAfQSQlfV9Z3PNGFmJrERWIiuRlcjKecXdJsYjK+d6vCAYAhCAAAQgAAEIQAACSyOArFwa2p0lPnToUHfZZZd1Knfy15qsfOXFl7tff+evdRdddNHk89lPfrobWuM39t/Tx132lku7F449vy1WdcqX2973r3+37/v6i1/fPfXogUlfxSmXx4+lxtNcdtJ3aC2qr106nj15tvu1f3z+u/v0TZ8eXNOJoye6SwPnv/r6X/WxioYZjwAAIABJREFUT37nye71P/v6/jv43ff+bt8mRrr396I4xZtdzpv7Ki7md/88d+dXObYOj9uqLPytLz3eHX3hdPfKK69MPvc/c6KbttabH/h+d+blH3dfeuyHW2KfPv5in0fXpTzq+8yJU53Gje2xr+YT2//N15/uXjzzcp87j+s8qte8NIbrxspWZd6brvt0d/DYiZ7XHd9+qiutNcfp38DDB3/Yx6qf/12ovOEvvjXY5jiNq7waT7lK9Z7L9bfc1Z06c3YSo1L3aov16h/n5L5D5Spk5fVfebw7cOxk9+Y/ursrjf/w9090N9z9dLGtFL+T5wX6QgACEIAABCAAAQhAYF0IICvX5JuQlLzyyiu706dPL3RGY/KrxjaJQH00d4tDS8K4HsnFS9+8p5eMkpqSkpKdjlOdZFMWmcr7J3/8iS1xua9zqNT4bt9J35izdG3xVWspMWg5aGkYJaTXZTFoCSh5uOfNe3rpeNutt/XXOY/ub/jYDb2cVA4JUuVU/tg3j6N2zceC0vMZKjWvX/6Hv9xpzKEY149Jr5rbJAktFi0Fh2Sg12mxGONiHsXpPotP98syUnGxLuayTHUuiUiJyywkHYesPCcJLfje/gdf6E68eHqLaLToU9vREyd7Seh6lRKOdz16qBePEpXKoz4xztcWnxaaEp1ZXHpO6qO4KCidR+W+e5/o5zQ2/9jH1yX5t8w6iUgJ1UM/enGbrJTEPHX2nGRHVi70sYhkEIAABCAAAQhAAAIVEEBWrsmXhKycflxbIvCtV7y1F5ASehKOlpdR8OX63Nfy8jv3PzTJqfbYP15LfGrcUox3epaEqXLspG+cg64tvmosJfQk9uIuR4lEy8u4ppIEVJzlZYzV9VhbKVfsLzlpmWl5WRKosY+vx8Z1jEuLupZKyckfvXRmi/iTFJQsHFqnJKHEovpZVpbyKE4xarO8VF71iWLSbZaRuo8xOU8pPvbJ61Hb0MeCq6WyJCAlDqMo9HoVK6E4JCAdp7KUN7ZLPmY5GXd0xvYsNmOe0rXmHnOVYly3TDGZc0tUetdklpUSlSdOne0+8rUDE5GJrFyTBzWmAQEIQAACEIAABCCwawSQlXOi1s5H7YC8//77u8svv3yyM+8Nb3jDluPar732Wnf11Vf3R1Fz+y233NJde+21kxi13XrrrX2sdvp98IMfnOyw1Dg+Bq5xPZ5ilF/jTPvLwqvm+7iD0esoycAhgSipKUnpvipL/WO7rkv9HFOak9t22jfm0bXFV41llIKe/5BILEnMUn/lGcrhMaYJxTiWcl3zz6/pd2E6R6mcNm7uMyS8aq6PUtDrKMlBt3n34lcPHJ8IxzFZWRKYylMaU3XaLRnFpuVlSZ7mHB5L9ZsuK6MUtMDTsWrtoMxScqje/WI5JDwVU5KPmkfciRmFo8Y98IPj/a7NOE6+nmeO6puF4m7cS0RmWelxdTRcbcjKaU86tEMAAhCAAAQgAAEItEYAWTnnN2ppKHGoa/1ZXOreolLC0X+xXXWSlVlg5p2VyhVlpXLooz/Pwfcep1Rm4VXzfUkMlmTjImSlxpIU1kfXJW5D4+ykb2kc12UBVtN9STYOCb8oEL3G2N87IPXdeFek41Qq1t+drmNbvM5HyBUruamP++s69vH1NAnqOJcWdi2VWfppbWOy0uLQ0lL9zSMe3VadYktHsktjKl71fr+hRaXz5J2eOYfa1cfSUmvwvMbKLMZauJ9XVvqdkWIfd0aKhUSh28d2NpbGVH/V+zuN/VUveamP23Vt/pafpTk5Zqi0JNzNEllZenKhDgIQgAAEIAABCEBg0wkgK+f8F5AlorpbUEoeZumY23UvWRllpupyv9I4ivOf+ivPtD+LrhbK3ZSVkZd2VvqdlLFeovQ9/+K3trwHM7breid9cy6LrxrLKBs9/wuVle6vUjn0jskhKSmpWBKaFpXxaLlySFI6l6VojNGY6qucKuNcxq7HpFetbVn6aR1DsjLWl2Sl6yyfnjh2srjLsTSmJag56t5HxXObYmKOeI2sPCcIS9KxtLMyCz8Jw9zXMZKNcaek61WqnwRkrMs7MXXv3JaY7mM5GYWmc1mYOtb1Q+VuSkqPhayc9hRDOwQgAAEIQAACEIDAJhJAVs75rQ9JRMlD734sHdGOcvFCZKWFqHd8qURWnjvGnYXh0I5HicO8S7K0MzNLwqF8OlKej5Uvsm/ONSbD1r1tSFaWjl0P7awc2uVYym0eFo4WkKrXdelHdEp5huqG5uJxc2mR1lIZRZ/XJSmZf61bElDHtBWvOItJ37tvLKPcjPV5zJJgVH7NQTmGZKV2U6o9/thOKVccO18PCa+a6yX1LAW9jlmPXU97L6WkZBaK6qPx4hHzUh4JSR391lxKcyzVef5jbY5xaYG4myWycs6HMMIhAAEIQAACEIAABDaCALJyzq+5JCstEod2VmoIy0xdzysrY35PN8pP15XKLLxqvi+JRclCSci8LtVFkZh/YMfxpZxuc1mSlaqTJFV/x5XKnfTN+bIAq+m+tIuyJCW1ppIgHDt2XYo3mywrx2I1xyxPS/Gai+o9xixlFl0t3JeE4pAc9I7JXOYj2uZSyqO2eWVljlcOH/vWGHk+vleb5zJUWnC1VEoG5l2UeZfj0HpL4jHGlmSlRKLqY9w0WVmSp2NCcqwtjqvr3ZSUHgtZWXpyoQ4CEIAABCAAAQhAYNMJICvn/BcgWan3VUoW+k/y0bspLRZjuyRmfMflvLIyC1LPYdN2VkreSUJaTkpAXvaWS/vdkrFNEvHSN+/pZaLE5dBR7vxL39p9GXdgqq/Gib8GPiQ5d9I3y8l8P4sUW+cYST7vSPQxbEs/lZe+5dLJ0WoLRh+/lkTc8+Y9kyPfatv70b39j+A4j2OVxznFQvU5b2yPvPK4+V6xGi//qnnMMXQ9JLxqr5f4s3DMOyhjW1zntJ2Vecdj7DskHz0HxUo0+hi4x7J8HMvNzsrfm0hDyUMLRIlDHd+W8JPMi20f+eK9k52OFn6xTUJx371P9BJS/fX+StU73vnybkvXew66V4x3fOZj3/Fe13c9eqj/8R3PvzRGnIevLRB3s0RW+kmKEgIQgAAEIAABCEAAAucJICvPs5jpyuLwxhtv7H+EI4pIJbGw9JHt3F6Sleonwak+Kj2Ofw1cfWI+ydFNlJXeqWgWUSpGWSnRpzbHlUSlYkrSUXWvv/j1fd8sKp3b0jRKxZ30jXlK10MirJZ6yz9/J1Ea6tpSUeuxhFRsPrIt4ekcKi0q1c/vsHR7zJnHd0zMn2NibufPuy9n4R+FW0vXloHekSiZ6PXNIyvjLsfSD+s4Z0lWqk1jeQ7xl8HVZomq9rHcyMpzstLyzzwtKrNEVL1jVEa5aEno9pKo1Dg+2m1ZGEvlc//8vss8xygjYz/1j20xf+l6NyWlx0JWzvToRRAEIAABCEAAAhCAwIYRQFbO+YVniThn910PL0kv6v7r6NHtdeUzixQj5q/nOp69W7ws2yjv72Vm7SxKsou6c8KzVg4WiDWXu/6QwYAQgAAEIAABCEAAAhBYAgFk5ZxQkZV1ir51FZDzzGu3xBrjLF541i7mmP92yVqrkGPew0K1Zknpuc/5SEM4BCAAAQhAAAIQgAAE1pIAsnLOrwVZiaycRzAuMhaJuHiJuFtMkX3bZV/tTJB+w9KvVjYWfjWXcz7SEA4BCEAAAhCAAAQgAIG1JICsXMuvZXGTWqQsI9dqRe1uiTXGWbwUrV3MMf/tsrVWIce8hyVrzZLSc1/c0wOZIAABCEAAAhCAAAQgsDoCyMrVsd+VkRGMqxWMi+SPRFy8RNwtpsi+7bKvdiZIv2HpVysbC7+ay115sGAQCEAAAhCAAAQgAAEILJkAsnLJgFedfpGyjFyrFZ+7JdYYZ/FStHYxx/y3y9ZahRzzHpasNUtKz33VzxyMDwEIQAACEIAABCAAgUUQQFYuguIa50AwrlYwLpI/EnHxEnG3mCL7tsu+2pkg/YalX61sLPxqLtf4cYSpQQACEIAABCAAAQhAYGYCyMqZUdUZuEhZRq7Vis/dEmuMs3gpWruYY/7bZWutQo55D0vWmiWl517nkwqzhgAEIAABCEAAAhCAwFYCvax89dVXOz4NMjj7WvcqnyYY/P//5b91fOpk8NBjz3V82mLwU2/79x2fthj8D7/0213tn62PeNxBAAIQgAAEIAABCECgTgLIytYlLaKyCVEp4YyorFNU6ntDVLYlKvV9IirbEpX6PmsXlZo/fxCAAAQgAAEIQAACEGiBALISWdmMzGt9BymyElmJ9Fwf6YmsRFauo9xs4cGUNUAAAhCAAAQgAAEIQABZiaxEVlay+xRZiaxEViIrkaTLk6TrKB/nnROPtRCAAAQgAAEIQAACEGiBALISWYmsRFZyxHzJ7wNFMq6PZFzUd4E0XJ40XBXbecXgOsa38GDKGiAAAQhAAAIQgAAEIICsRFYiK5GVyEpkJe/VnPNHkFYl1Bh3eZJ0HeXjvHPisRYCEIAABCAAAQhAAAItEEBWIiuRlchKZCWyElmJrNz4Hw2aVwyuY3wLD6asAQIQgAAEIAABCEAAAshKZCWyElmJrERWIiuRlcjKX/rt6n8RnMdaCEAAAhCAAAQgAAEItEAAWYmsRFYiK5GVyEpkJbISWYmsbOG5ljVAAAIQgAAEIAABCDRAAFmJrKxKVp5+/kx31Tuu6i666KLJ51M3fmpw/v/pa3f3cXvevKf70Q+e62Njm3Lp/tWfSEvldP5YalyNr7gYE+tz28U/e3H3xMNP9LnVfv3vXN/n17XHnVbW/mvg//mlH3e//s5f79f+2U9+ZlCSnnz2+e6yPZf2sffedU8x9v3Xva/LbU8/9t3u9Re/vtg351X/yDW3O3eee/x3MbYO517Uj7qsW577HvxB9/f/4a/2rD/wbz5elJ45Tn1U5/Xsv+e73Rt/7pI+zz/5p/9P3+YYlc4T23NffTeledz2pXu7X/2//+mWcWPumz715e5//hs/0yku1g9dt/ruyDe9/9bu4LHnu1deeWXyueOhg0WJmeMU//ChY33sDV99qM+hNt1nZtd//hvdqTNnJ3Eqda+YWJ/zql3jeH6xn9re/rE/7068dLpvj3PK4+f7VRzrvu4zX+2e/P6z3S/+qz/pd3Wqzly0zoe+d6RvmzbHBp5LWQIEIAABCEAAAhCAAAQ6ZCWycmZZNk2m7Ua75J4Fn+SjJGQUjZ6DBOFb3rSnF4WSi5aKEo4f/6O9vXjMsc7h0oLU46iM8jPPae9Hb+iZjsUqv/qOCVfPQaXFV62lxKDloKWgZWBck8WgJaDk46Vv2dOpdFwUkjFHzpv7fvE//Mc+Tx4n3+e+Htul2v/RFW/tNKbrhsoh4VV7vaShxaGloaRfXpfqYn3sp9h/94c395LQQrIkHJVDMtJjqq/k4qWX/71O4+dxfa949cuS1O0eE1l5TgRa8Fn8lUSj2o6eeLEXjFH8SWTe9dgznUrVSz5KIFpGqk45s2h0jn3fPNDH5jnofv9jh3vxKZkqueqxYl8L1SHh6vFcThOBi26XhJSMPPjD57bIyn33PNJJWGq8X/nQLd2JF091e//8vpmEJc+1EIAABCAAAQhAAAIQaIEAshJZ2Yu1KMbW8Vpy8pf/wS/3AlJzlOizvIxzzvWlvjF+TBpKOFp0qk+OlezUvOLOTeeOorM0h7G+zuFySITVUC+hJ7Enwef5SkZaXrpOZUkCKi7Ly0ceeHiyUzPKytzXAjLGxLFUr92eist9FRfHjf2mteVYS7GWSslBScK4E1GCMYrEofVOE4ySklksSihqZ6Q+cQzlGtsxqVh9Sjk9P7fl9bi9VFpwtVSWBKREn+VlXKtiJQlVxvqha+WwNLRELEnQUv/YN7dLgEqaDs1DY0SZmfvH+0XLyLF8EpX6SEJmWZn7Ke6Obx1AVrbw1M0aIAABCEAAAhCAAARmIoCsvABZeffdd3dXXXVVd/vtt/fHFnV/5syZ7tVXX+2mtStGserj46Sx/80339zXq1336hNzX3PNNZMYjeW2YlnJ+xgt5MbKLA0VW5J9URDGfFkyum0oXu25rSQcc4zzqozx8doxpTq35TILsJruoxT0vEtyUG0liVnqXxKRrotic2z3YxwrXnuOpXHVNjR398tlSXbVXmfBJ4notUyTkI4r9XWbypL0dJ1Lx0/LNS3O0lV5Nl1WlsTekAwcqo/yz9dZTqrvgSPP9bshHVcqp40zJjKVb0i2lsbKknA37qfJSu2wPPrcC5MdlrPMZ6YnP4IgAAEIQAACEIAABCCw5gSQlRcoKyURr7/++l4U6tr3Eohj7RaVUULu27dvIjBVt2fPnu748eOT3Cp1bynp3L4vCsq4JmRlv3N0SFbmo9pREmZBWpKLY7IyHj9XXs1BH4+h9tJ7Ld0eyyzAarovSb8h4TerNLSYVO7IwvX6b1DvvRw6pp2PjM86rsYa23EZ5+JrC7OWypIknEVW+si1pGOJR+k4ecxbkpX6rv2Juy5j/tJ81a545bS01Fix39B1SXbVXjevrIzvVRzbvai8Ogbu3Y+6l2TUx++e1LX5WW5OjkiHI95uV3/307Xrc6nxNO5YTOwziwxcdExJVur9ldptWToiPm38NX/mZHoQgAAEIAABCEAAAhCYiQCyMoq9Ga8lCuNOSAnDxx9/vLviiismkvFC2pXDEjOLSAnMKELz2KPCElnZi8GSrJSMHJOF6qMYS8N5ZKVEZHy3pXJYbFqsfOj3P7ztaLvHyqXFV43lbsnKfNw8C0mzc70EpetmlZXqq6PjKt13WjkkvGquL8m/KBVLa7OoHBKKFpVRZLqPxlPOLCvjOI4t5S/NN9YhK8+9RzJLx2k7Gy37JBtzX7VJFOZ3U1o2WiJaTvqYuHOq1Pjq79jYpuuhcS0qSzlzDt9PE4HLaC/JyjiOf2xHcbF+6HqmJz+CIAABCEAAAhCAAAQgsOYEkJUzCsooBEsyUjsgJRFVTmuP8jHmVV8JT4nPWB/zxesYM3i9AbLyX/7mNf2P5UQhGCWj6rN41H18F2WWgxKTalfptiFZqTnoSHocX/ndb6gsHWMfip0mxNa5fUhWvudf/NbkfZFx7kPSML/f0jso487KWfoqXr8Wrp2dFzKu+ue5xDyl6yjUWrmOos9rkqwcen+k2vQDNpaO7uNS9aUfuJF4jPJxTFYq15AwzfNV3P/+c5f079xEVg7LylmObEsO5h/cGRKJEo9ZbJbqLBHH2iw6o8zUdRakzjVWDgnAZdZPk5Uae5YYz3HNnzmZHgQgAAEIQAACEIAABGYigKxckKxc5s5KCUp2VpbfT5l/SMeiT6JQbb7PkjG3Oy6Wkp1ZOHpnZBShUTiW2mPOfD00/xyn+5IEq6WudOS7JBa1npLYLB27vhBZWcpthqW20riqU6z7zVJayLVUlqTgkEgsxUYWWSS6zTstvRM5lm/8uUuKvwCusUrCNI+hucZ88VptnsNQOSa9am0r7aKc9Z2PkpUSkCq1fonKoV2NGicL0DEhOdaWZeVY7LTvxcJvN8tZROQsMZ7zTE9+BEEAAhCAAAQgAAEIQGDNCSArL1BW6v9hK4moHY0+vu13UKp+rN3voXS8cszzzspNPQYuYSd5aIEoAalj1haHsU0C8S1v2tPvdpQU9C7KKBdLUtB1yheFp+s1XjzeHcdVm8dx/FCZ5zgU5/pZpNg6x0jy6aM5+hi2pZ9Kv1/SElIyU7ESnZe+Zc+2nZCOc45SbBynFB95uX1sXOXLv2oecwxdDwmv2uvjrkeLRUlBrSu26XpIAProtvtNY5KF6Mc/cWsvLZ2rNFaWlXkcdlb++14ySjRK7PkotQSgBaTbPvLlByZHtC0AVe+2kvR0nEoLRsvMeK/rux57pv/xHc/BsZqL56Ncqvf7MJ0ntsdxp11b+O1mmUWk3ld513ee7lRqHr/yoVu6Ey+e4tfA1/xhmulBAAIQgAAEIAABCCyWALLyAmWlhKF/kVti0jsfJR59VHuoXTEWlt7NE/tLYro+Ss+YW4JU91M/DR0Dl7TzzkXzsahUW5SGuleb46JAlCTUeyrd5jLGaJx4tNvC0KUkpvtpXNfHMd2u0jGx39i7Mp0vlkMirJZ6y0BziZIxykqtx5JRsaUj24pxvphH9ZKb6uNxLB8d73qXMf+0cZW7dHR92neQxVgr95aDZhmFY5aVjoml4nMOt5eOhItblpW6dx+VJVGpfsjKczJymrCz8Cv9gE0UkhKCjlFpUan8fs9kbNd1PPqdx7GMVH/lin1jW85tUal+OadzzHokfDclpcfKslL1D33vyNb1f+vATO+rVF/+IAABCEAAAhCAAAQg0AIBZOUswi/FWEYOCcNp7VMFYxpvR/GNycoo7zbtepoQo/2/zXU0ezd5tSInWcdz/fHwadKP9tnk6DpxskCsuWzhwZQ1QAACEIAABCAAAQhAAFl5AWJwmoyc1r4j+TjvfJGV/a7H2uXmbso1xlqs+ETynZd8rbBYJ8nGXBYjRmuWlJ47j7UQgAAEIAABCEAAAhBogQCycl75F455s7PytWZEYA0iE4G4WIG4mzxbEXSs47x0RRAuRhCuE0cLv5rLFh5MWQMEIAABCEAAAhCAAASQlRcgK3d1Z+RO58fOymaE6m7KNcZarBhF8p2XfK2wWCfJxlwWI05rlpSeO4+1EIAABCAAAQhAAAIQaIEAsnKnMnDd+yMrkZX/ZbHiDZE5P89WBB3rOC9dEYSLEYTrxNHCr+ayhQdT1gABCEAAAhCAAAQgAAFk5brLxp3OD1mJrERWrvyHd5B85yVfKyzWSbIxl8WI05olpefOYy0EIAABCEAAAhCAAARaIICs3KkMXPf+yEpkJbISWflYe7Jw1dITQbgYQbhOHC38ai5beDBlDRCAAAQgAAEIQAACEEBWrrts3On8kJXISmQlshJZ2S1abq6TZGMuixGnNUtKz53HWghAAAIQgAAEIAABCLRAoJeVLSyGNWwn8D994M6OTxsM/sf3f73jUyeD173xyo5PYwx+4Z3d6/g0xeD/PfNaV/tn+1MANRCAAAQgAAEIQAACEKiPALKyvu9srhkjKtsQlfoeEZV1ikp9b4jKxkSl5DOisjkGtYtKzZ8/CEAAAhCAAAQgAAEItEAAWdnCtziyBmQlshLJuXrJiaxEViI3138nKrJy5GGCJghAAAIQgAAEIAABCOwiAWTlLsJexVDISmQlshJZiSxdgixlZyU7K9fw2PgqnjMYEwIQgAAEIAABCEAAAosmgKxcNNE1y4esRFYiK5GVyEpkJTs7p+/sZGflmj3AMB0IQAACEIAABCAAgY0lgKxs/KtHViIrkZXISmQlshJZiaxs/HGH5UEAAhCAAAQgAAEINEQAWdnQl1laCrISWYmsRFYiK5GVyEpkZekZgToIQAACEIAABCAAAQisIwFk5Tp+KwucE7ISWYmsRFYiK5GVyEpk5QIfLUgFAQhAAAIQgAAEIACBpRJAVi4V7+qTIyuRlchKZCWyElmJrERWrv6JhBlAAAIQgAAEIAABCEBgNgLIygFO999/f3f11Vd3r7322kDE7lbfcsst3UUXXTT5vOENb+gOHTo00wRak5Vv/dSD3TMnTnWvvPLK5LP/qR91pTXmOPVRXYx9922PdS+cPtvn+vQD39/SrljneezoC31b7qe5xHko1vM7ffbl7t/t/17fVzlje2lecY7xunbpeMXN3+qeOfFSz2b/U8e7aWtyHzFz7Lv2Pbrle4ttjvnI/qc7sdf3oFL3bnP56QeeGWxT/NPHX+o0vuNjqbnPMn/3aVUWXvIb7+sOHjnWf6d33PtQN7RWtfm/ixMnX+zedt1H+9jrPnFrd+r0mb79oQMH+zblU6z6uP/efX/Zt0/rm9tj3zhX1WsOio/1g9eN/hr4Je/+t93Bo8/2rO+475Hir37nOH03D333cB/7tvd9ojtx8vx/79PyjPWNbZKu1934hf7fy+Q7u/EL/bhqV7z/reS+Y9J2XX5g5/j3n+v2vHlP/7/51/3O9d2sc5vpwYAgCEAAAhCAAAQgAAEIrDkBZOXAF7RKWSkx+cEPfrCf2enTp7ubbrqpv9fcLr/88k710/6i7GrhWmJKH63F0rAkGVUX62M/9ZVAlMSKMSU+atf/o9djuu+zJ89Mxs99NKdvHHyul5OSmFFI5vs8r5wv3lt81Vp6rZq/haOE4dh61G7+jvvzx4/18tEyM4rDMQnpHO5XEpmap8aUWM2y0vNWexzTeYfKQeH1xiXs+NvFnJKKFosWiiUZqLooKCUuJTklO8Vm353f7CVhzmMhahEqmahclopjfXOu3Nffi8dAVp4TfRZ8Fo57v3DnFhko4ae2oz96fiIOswC0yLSgHMuj3PrvyWMq1767vtXnzbkkKiVBVSpWpeahMXSvPDGXrj2PPM98P6sQXHbcf7jltu7xh56YCMpTJ850V73jqu7mP/3UTMJy2jMB7RCAAAQgAAEIQAACEKiBALJy4FtaJ1mZp6jdntr1qTlO+4uyq/ZriUBJwrhTUfIvisShNapPFIzqE3dDlvppV6V21+kTx1Au1eWdmqUc08aVDI0ys5TDdUMirIZ6Sb5jJ0/3klFzluwT16H5SxRG/kNxkpMWi5aQs0hQ9clz0nz0iTk9rkWl2hSz6bJSIvDo8RO9NJT4k1C0vLQILNVLGqqvcsQ4XytHlJM5Nra7j8vYlsexlMxCVfeSp3k9zlksG9xZWRKQEn1R/lnwKVY7MC0JXa+ylKckDSUinzx8dPIpjeGcEpoaS/Gl+Th3adwsM52zVC5bQl5o/v/01bsnwlLiclqOac8EtEMAAhCAAAQgAAEIQKAGAs3ISok7H5OWyLvxxhv73YnagXjllVdO6hSjXYuWkYpzv7ib0e379+/v2/OxcOXVDkf3z7sdLRWKsWXnAAAY1klEQVTdno9v6yi36tyuMTUH36tUXf7zemY5Cm7R1UJZEntZBg6tM/aV9JQgVDkUr3qLUJeOjblcN1Sek1rnj6qrr46ee+zcPpRH9ZZmNZYl+aej1pKFkoClNVlmuizFqC62Tzu+rXiLU80py0qPUZqv21QiK6/sLPi8O1JCL8tBS768o3FIapZylGJLY5f6Wk6OiU9LV+XcdFkZpaBl3pDsG6p3PwlEC8iSRFScxaNL981lbI/XjnNdaZxSnfvlcpoIXFW7dlXOehQ8Py9wDwEIQAACEIAABCAAgRoJNCErJfSiKLQEtHy0VPS9vij1kQzUkWv9uY/loNtjH1373jndXzl0baFpUel4j+l5ut3jKd/hw4cnc8nHwCeV4f+I44Tq4uWY/KqtrSQJZ5GVfu+kd1J6Z+S9B5+bHD88d+R36zstY96SrFQffySuIkvN0226jm26ju2eU44p3UdZVtt1Sf6NycrYFmVkXnfc7ag2jaPvQx9/B7qO/XSvnJaWGiu2O493a+Y23TtHqa1UZ2nXUlkShkOy0iLR76XMuy8tFfWdxePh6jdNVo71Vf/YHo+i+7vwTkxLS63BbaNlgzsr55WV/j4n39tPdj5GAShZqbbSeyWj7LRsjH19LdmoY9+am+rULx4Dd7vFaJSkilfu0vjOH8tVycixcf3+Su2uHItzW/FBgEoIQAACEIAABCAAAQhURqAJWSkhGKWhvoMo/Eo7ESUJLRb9ncU8pXYJTe3QVL5Sexwnxjp/FJS+zvPOc3dfl4q38HTdWFmSXrXWXYistKiUXPK6JSL1rsIoCtXuGPexaMyy0nlUOtZ9Y5uuVR+Peedcuo/tuX+8L0mwWurmkZX5KPeQrLSoVLs5aBzJEZWqcy7HxHkgK3f2vsx5ZGWO1X1JHEoOShZKLilG99NkZRSKuW8WkLrXuM4d55VjY97i9YbLyij5dC1J6KPafs+kBaPvJQ4V63u3D8lKi0j385jqp//O9ZG4vO+xp/tdnM7tdrUNvVvT+Vxa+K1LaVE56/sqNW/+IAABCEAAAhCAAAQg0AKB6mWlpZ93KPpLWYaslIyU4FQZ83vMOJeSzFRcFKKO1w7PuANzLHeM87hjZZRdtV8Pycqh90daSlo6ev1x12SpLopLtWfB6D4uS/ncZpmpOZTeual2zV853GeotJCrsYyS0PMfOrJt/o4ryUrlK/04Tmkc193y7R9MjuB7JyWycjmy8slDR/ofzpHk885GC0KLP+1ozHVuixJxSFbm3Znz9pXYjD/Ug6x852T3ooWjBZ52Muq9kpKAriuV8bi1ZOJYntLuR++MdG7lmHVHpPpmoek8cQen64bKdZGUmod2Ul78sxf3P7Qz69zGngdogwAEIAABCEAAAhCAQC0EmpGVEnzxT1LPYi/ueHRMSSYq3nlK7XG3ZKld8vHaa6+dHCmPsR5TpcZQ3/wX55tlpaVmqV/Ok++HxFeN9SUpOCQSS7Fec+mdlY6/+f5z75T0rpxYxndNOpdK9R0SpsjKr092OMZj3WMS0rslI3dfi7/aLR+1a9K5XJYEqOO//f3n+91YzunSOy+dx31KYyhGQjX3cd9SaZHWUinZl3/4piQWdyoro7g0Px/d9n0sY3xpPmp3f3//uVS/mLN43eDOypLYG9r1mIWfZKUEpcoxWfn+m7802Q2ZmeteuySH+ufxfB8lqetiOev81WdWIbjsuHl+UCfPJT8DcA8BCEAAAhCAAAQgAIEaCVQvKwVdci8ejZYo1A/X7FRWxh+4sTC0zJQA1Zi+9zx8tNzxnoPaJRs9T/W/6aab+n8zUVDGa/dz3r7DjBdRqrVw7V13WoukowSWd07GtnMy6fwP2+S1x1i15fsYn4Xovu8c7X8gxzJSMeqjuXg+uld9lJx5HLVvwjFwCz6tX9eWkpKCuldpGZllX9xZ6WPd7pdj3W6RmO9jPDsrd7azUgJP0s87HPMR69gm+RffRSlh6GPgkpn7H3ys343pPBaGlp2+jzsip/WNsZqvc2v8LCDZWfnOyc7JuOtRIjC+LzK2ffhzd0zeH2kxGNtyPx/NHtr9GIWiYyU8nXusjOPmuPx+y9ye77P4W8W9fvH7qndcNdlZeSHjz/hoQBgEIAABCEAAAhCAAATWmkATslKEJQUlF/WR2Cv9Grgkpv9KOyOVw/LR7dop6bxRPCqPhaXbs1C0sHS7RaX65rbYN+bVPPRxjljm+XhtsYzSrYVry0HvyoliMIpAXTsmljnebYof4pNlpe7dT6Xu3Ve7LHU82e1RVDomzq3U7rhcRtFW47XFodlE4TivrHQOl/FIeB7H4jIzQ1buXFZaJPp7iBIwykqJQclGx02O94YfslGs21RaTFooWjKqbd6+Epbq4/w5dxxj038NXPLOstC8ojSMYlD1jlGptij/LCwdk9tjbElWup9LHwmflle5cp841tj1hcjBRfexrIz/W6/rWY+Ex//95xoCEIAABCAAAQhAAAK1EmhGVuYvIIrH3LZJ91l4cX9nLxZrY5FlG/fnjpjXwMFCjHLngnRtGDZ4DHxM5G1C26LF4yrybdLzDWuFAAQgAAEIQAACEGiXQJOyUjsRdQw87qRs9yscX1ltQo75DsvUGqQccywL1LURbG9sSBauei3Iyi07KVuQmauQi4sec/yJgFYIQAACEIAABCAAAQjUQaAJWZmPSSMqz//jQ/4Ny7/a2CACyyKwBi7IygYlKbISWXnmtbX5UR5Lz/P/688VBCAAAQhAAAIQgAAE6iXQhKysF//yZ16bkGO+w3K1BinHHMtCFVmJrGxh52Hra7Dwq7lc/lMFI0AAAhCAAAQgAAEIQGD5BJCVy2e80hGQf8PyrzY2iMCyCKyBC7ISWdm66GthfTVLSs99pQ8cDA4BCEAAAhCAAAQgAIEFEUBWLgjkuqapTcgx32G5WoOUY45loYqsRFa2IPNaX4OFX83luj6LMC8IQAACEIAABCAAAQjMQwBZOQ+tCmORf8PyrzY2iMCyCKyBC7ISWdm66GthfTVLSs+9wscUpgwBCEAAAhCAAAQgAIFtBJCV25C0VVGbkGO+w3K1BinHHMtCFVmJrGxB5rW+Bgu/msu2nmBYDQQgAAEIQAACEIDAphLoZeWrr77a8WmPwbv+7NGOTxsM3vHZhzs+dTJ43c/9SsenMQaX/Fr3Oj5NMbj72892tX829WGWdUMAAhCAAAQgAAEItEUAWdm4pEVUtiEq9T0iKusUlfreEJWNiUrJZ0RlcwxqF5WaP38QgAAEIAABCEAAAhBogQCyElnJzstKdp8iK5GVSM81kp7ISmTlGu7EbOHBlDVAAAIQgAAEIAABCEAAWYmsRFYiK9m1ueQj9kjGNZKMizqSj6xEViIreYqGAAQgAAEIQAACEIDAUgggK5GVyEpkJbISWclR9XklJrISWYmsXMqDKUkhAAEIQAACEIAABCCArERWIiuRlchKZCWyElnZnHyc972ivLOSh2IIQAACEIAABCAAAQisBwFkJbISWYmsRFYiK5GVyEpk5RrulJxXoK7HoyWzgAAEIAABCEAAAhCAwM4IICuRlchKZCWyElmJrERWIiuRlTt7oqQ3BCAAAQhAAAIQgAAEFkQAWYmsRFYiK5GVyEpkJbISWYmsXNCjJWkgAAEIQAACEIAABCCwMwLIyhXKyuuvv77T59UZ5qC4iy66aPK5+OKLu8cff3ymfu+qRMTNOs8/+Pr3uuMnz3SvvPLK5PPYkZNF2Zrj1Ed1Hie35zyfvPeZ7qUzL/fj3P3dH/V9nUPl95871Q21eQzFxD7u5zWU2nO87t+xZKG27Py//5dPdc+ePN0z/c4PXhhc0+HnXurjzrz84+62h4/2sbpWnfkpNs5ded2mUt/jDX91aEuM4r9+4NlJnph7bNw8xtj8Y6yuW/018Et+4wPdwSPP9rzvuHd4rWrz93Li5Evd2677WM9F16pz+0MHDvVtsZ/bVWpcjR/Zqt/efV/dUpdz53b1cd44bsxbvG70B3Yu+c0PdQePHu+Z3PHNR4oSM8eJ4UPfPdzHvu39f7rlO815dG/up06f6a676T/2feO7JpVz7xf2b2lTrPqo/1Bf9XP+OK+YO1/Pe+R6WfFfvvOJ7n974yX9/+brf/vf+4GPdbOMt7NHQnpDAAIQgAAEIAABCEBgPQggK2cQhbPIxGXGHD9+vNu7d28vJ2+++ebuqquu6s6cOdPXDY1fkl4110nsWe5ZKJZkoepifeyn9cf7nMeS0QLzy4/8cCK8VJqdrs/+RJjFcdyuUvX6fyx7vqpz7lgX+4xdZwFW271EoMWi5KEkooRhXofaHj96sq+XFJTklOxU7AOHT/TyspRHY0wTiRanUYROG1djezx9r9PGiOsqyq55d/KtYbzkngWfpWCWgVq76qKglICMsnHfnd/srvuTz08kowXokPh0exxHfS2vYr1jnUtxmofHivPXPHXv2KnfWaOyUmLPcs/CMctCST61Hf3R80XJaJFpQZnz6P7Obz/RC0jln/z7eP+f9nVRSMbxVT/5Dn8iN3WveSin5uWxvYYsJMfuZ5GBuxHzmX33dG+69O92kpbzjrcej5bMAgIQgAAEIAABCEAAAjsjgKysQFZmEaldlVdccUUniZnb8v2Y/KqtTVLx+VNnuygNJRRnEX/qo77KMS1PjDUjjZHl5deeeHayy7MkKyUlf/jC6cknzk+xeZenx5hWRvlV27Ukn/jHXYySfZaXY+tRH/VVjlJclpO6L0nQ2FftEqB5TjEmj2tRqb55zNivdD1VfK2hiJw2Z8nJo8dP9OJP8RJ9lpexf66XLFRf5YhxvpZwjDLT9SpzmwXkhz/75UmfKCtL41hIluZfio9jb7luUFaWBKSEY0n8KVY7MC0JowQs5VEOy8sYq2sLRktJC8kPf+4vJmO4XrGl+cTcitW8lDOPM+1+XjG4rHjJyn/0q1d3X733MLJyZ8+49IYABCAAAQhAAAIQqJQAsnKKrJQQ3LNnT3/8et++fVtEoXY3apejj2jHY93aAemj3m5XnYWi231/991393nGjnorZ8zj/qVymgCrqb0k+kpisbSm2DdeOzbmKQnQUh/vklSb87h0Dpeul7gsxbt9rCxJsFrqLAe9O1LzzjJwaC1jYjDn8I7JMVlpcaqYMVk5Nu5YW2kdWyRXhWKyNP8sDRUzJPssFFUqLsvLnH+o3Tslo5B031JbKY/n/f6bbtsmW0sC0/m3lQ3KypLoyzsXLfyG6t0ugWjJWZKXjlM51J4lpmJLsjLWacwoN+M4066XJR/nzfuxm77Y/dLffzuystIHa6YNAQhAAAIQgAAEILBzAsjKEVlpUSmJKBFoMSl5qTbfWxz63vGql6T0vcooIaOsVJvzaizdx6Peurfw1HVJTJbqxuRXbW0lYRgl49B6LBW9M3JaniwYlbfUx3mzfIxzirm82/LbzzzfHyHXUXLFD8091pckWC1188pKxft9c1k8WkiqPR4PF4vYpvZ4zNusLBotLSU83TY2rmNUOkesG7veJroaEJaWfpKEXt+QrFS72nxUu7T70jkkDHXMtyQkS2O637yyUvGaR5yL5ObkHYg/karOXSyRlf33qf/WSrsZJQ7VNvReSctDycZS/5Ks9K5Lleov0al/LxpL8U8ePtrtu+tb/dymje05qJxXKi4rXrLS/3uv8h3/5D0zz23nj4VkgAAEIAABCEAAAhCAwOoJICtHZGUWhpKB8Qh2vLYoVB/vrowyUu0lmenYvFtSsddcc03xh3QUG0Wmxy6VUXbVfl0ShlEMltZnoTjtKHbMEwWjc5bGdu4oK3NdzOW2eAxcffXuRh1N91hD5ZgMW/e2eWVlXI/EYJaSbpdolJDMQtPtqo/CMs6jJCvdT+XYuMjK7cexJfSGZGWWjLqfvKMwHQO3qJQ0LAlCicWSxFTshchK95FQ0+e+R5/attuyNI9J3YbLyij5dC1ZaOGYJaPvJSVzP9VN/i2E91U6xv3yTknd+ztT3/se+14vKzUHz0N5FDuU3+O4XJZ83EleHQXXLstZheXqHyuZAQQgAAEIQAACEIAABHZOAFk5IiuzbJQMjIIy7naMuyAsEnP/IVnp+pjD16VdlI4vtWVhOSS+aqwvCUNJRr0bUiIwr0lt2rkYZaJipuWJgtE51ScKT9VbPsb8iolxMVcpvlTnMXMZRVpt11ESeu4SjUefP//DOa7PpXdLjgnJIZmpXBaLGk9i2Dspp8nKsXGdM8916H5QeFW8wzILSK1RsvLJw0e2/Eq3hWCWjFk8qn1sV6NEpt5jqbLEszTO0DHwuJsy5hqSrTGmv94gWandihKHlnqlMh7lliCMwlDx2gkZ81hESnKW8qnOMVlW5njlkPQsxZfqcn/f70QqLrPvPD+4s/PHQjJAAAIQgAAEIAABCEBg9QSQlVNkpcWjJaAEoY9rS1xq96PkodtjOausVB/tlpxFPip2U2Vl3P1okRdloOtUlmLdXmqLeUoyUwJSMc6hMotG7Y6UDPOOn1h696TyRLmZc8T8+XpIhNVQL0GYfyRn1h/YGZOGWntJhEYmEouK0XjxO4nXpV/2HhsXWVneRVmSgyWJKOEXZWVJfPZS8CdCVzFDklGxpXFKeZVjaOdmaf55Hv19g7Ky9B5KScAxoWjRJ1kpQalymqycVSDOEhclqeaiuUa5OUsOr2GZwnEnuef5wZ3VP1YyAwhAAAIQgAAEIAABCOycALJyRFZKRuodk5aIloSWlb6XlIyS0tfzyMooQd3fpdo8B9Upr+fgmKEyC6/a7+PORctBy7/YVpKLce0xNuexQLSclNyUbFQZczjO48c2X0cJqjrFWlyW7t2vVEYBV+O1BJ8+mrt2NYqDd0uq1L3qde16xUokuk0C8Ykfnpy8mzLmsWxU/3u+99yWd1C6b2aWd1aOjZv7Iit/ZbK7UeLPAtFHuCUIJfRimyRg/HVvxfgYeEky9kIw7Dwdk4yKL+VxneWkdk5qXJV5jLG2HDu5b1BWWvZZTkoEipfln+rdpl/q9nsjp/WzMPQx8JLMtDCMpft5/Njm6zgn1Sk2HvvO9+5XKnciFBfZ9yN/fEv35TufmLyn0sfA3/uBj8303sqdPxaSAQIQgAAEIAABCEAAAqsngKwckZUSgJKEPpItcZl/Ddw/wuMYlRaL88hKS8iYx7s6LU3dNquoVM6S9Kq5zoLQu+KiKIwCUteOiaXjx/KIjwWm+g79CI5zOGeJa5aVilG85ySRprFKfXNdFma13XunotcehaSuLRW1C1PvmXSc671eiUK3qbSoVLslqNtzX+dwbPw18Gnjxr7IynOy0jLQvC0qJfOirNS9hKHj4nHvnGMoRsfLS5LRItF54hzUZomqvHHcsTk552jZqKy0IPT3EEVhFIOqd4xKS0xLQItOx8T23LcUozyeS5zDWF6PHfNHcen2oXKRwnEnuSQm/b/3KmcVlRqTPwhAAAIQgAAEIAABCLRAAFk5RVbmHYsSkZaIuW0d77Pw4v7RmcTgOnKKsozrh/vdkzWwGJVeYfcgceckaBUcGpWVQyJvE+p3IhjXpW8LD6asAQIQgAAEIAABCEAAAsjKOWSld1EOHftGVtYrAtdRTuY51SDlmGNZolYh35Cm246Gj35vyMrBH8apVWyui3DcyTx4rIUABCAAAQhAAAIQgEALBJCVI7LScjIex6pJVEqeZuHFfb1CFRFYFoE1cBmVXkjC+SThuvBCViIrv/3sTO+R3Il8nLdvCw+mrAECEIAABCAAAQhAAALIyhFZuY47JeedE3KyXjmZv7sapBxzLAtVZGVFx7tnlaHISmQlspKnaAhAAAIQgAAEIAABCCyFALISWcnuyz+rQ2giAssisAYuyEpkZa1Hozdp3vPuYlzH+KU8KZIUAhCAAAQgAAEIQAACu0wAWYmsRFYiK6v6sZoa5GSeI7ISWblJ0q/Wta6jfJx3Trv8DMlwEIAABCAAAQhAAAIQWAoBZCWyElmJrERWfna5uzaRlcjKWgXeJs17XjG4jvFLeVIkKQQgAAEIQAACEIAABHaZALISWYmsRFYiK5GVdf7Izazvl1xGHO+s5J2VvLNylx9ZGQ4CEIAABCAAAQhAYFMI9LJyUxbMOiEAAQhAAAIQgAAEIAABCEAAAhCAAAQgAIH1JICsXM/vhVlBAAIQgAAEIAABCEAAAhCAAAQgAAEIQGDjCCArN+4rZ8EQgAAEIAABCEAAAhCAAAQgAAEIQAACEFhPAsjK9fxemBUEIAABCEAAAhCAAAQgAAEIQAACEIAABDaOALJy475yFgwBCEAAAhCAAAQgAAEIQAACEIAABCAAgfUkgKxcz++FWUEAAhCAAAQgAAEIQAACEIAABCAAAQhAYOMIICs37itnwRCAAAQgAAEIQAACEIAABCAAAQhAAAIQWE8CyMr1/F6YFQQgAAEIQAACEIAABCAAAQhAAAIQgAAENo7AfwcVg3dk1ey2DwAAAABJRU5ErkJggg==" - } - }, - "cell_type": "markdown", - "metadata": {}, - "source": [ - "![image.png](attachment:image.png)" - ] } ], "metadata": { diff --git a/scripts/run_grn_evaluation.sh b/scripts/run_grn_evaluation.sh index 821fa2e46..20c060b21 100644 --- a/scripts/run_grn_evaluation.sh +++ b/scripts/run_grn_evaluation.sh @@ -1,15 +1,15 @@ #!/bin/bash # RUN_ID="run_$(date +%Y-%m-%d_%H-%M-%S)" -reg_type="ridge" # viash ns build --parallel -RUN_ID="d0_hvgs" +RUN_ID="d0_hvgs_binarized" resources_dir="s3://openproblems-data/resources/grn" # resources_dir="./resources" publish_dir="${resources_dir}/results/${RUN_ID}" -grn_models_folder="${resources_dir}/grn_models/d0_hvgs" +grn_models_folder="${resources_dir}/grn_models/d0_hvgs/binarized" +reg_type="ridge" subsample=-2 num_workers=10 layer=scgen_pearson @@ -35,12 +35,17 @@ param_file="./params/${RUN_ID}.yaml" grn_names=( "scglue" "celloracle" + "grnboost2" + "genie3" "ppcor" + "scenic" "portia" + "positive_control" "pearson_causal" "pearson_corr" + ) # Start writing to the YAML file diff --git a/src/methods/single_omics/tigress/script.R b/src/methods/single_omics/tigress/script.R index 766c768e7..b706da454 100644 --- a/src/methods/single_omics/tigress/script.R +++ b/src/methods/single_omics/tigress/script.R @@ -4,12 +4,12 @@ library(dplyr) ## VIASH START par <- list( - "multiomics_rna" = 'resources/resources_test/grn-benchmark/multiomics_rna.h5ad', - "tf_all" = 'resources/prior/tf_all.csv', - "prediction" = 'output/tigress/prediction.csv', - "temp_dir": 'output/tigress', - "max_n_links": 50000, - "nsplit": 25 + multiomics_rna = 'resources/grn-benchmark/multiomics_rna_d0_hvg.h5ad', + tf_all = 'resources/prior/tf_all.csv', + prediction = 'output/tigress_d0_hvg.csv', + temp_dir = 'output/tigress', + max_n_links = 50000, + nsplit = 25 ) ## VIASH END @@ -18,18 +18,6 @@ ad <- anndata::read_h5ad(par$multiomics_rna) X <- as.matrix(ad$X) gene_names <- colnames(ad) -# Remove genes with > 90% of zeros -# zero_proportion <- colMeans(X == 0) -# mask <- (zero_proportion <= 0.9) -# X <- X[, mask] -# gene_names <- gene_names[mask] -# colnames(X) <- gene_names - -# # Remove samples with > 90% of zeros -# zero_proportion <- rowMeans(X == 0) -# mask <- (zero_proportion <= 0.9) -# X <- X[mask,] - # Load list of putative TFs dat <- read.csv(par$tf_all, header = FALSE) Tf <- intersect(gene_names, dat$V1) diff --git a/src/metrics/regression_1/config.vsh.yaml b/src/metrics/regression_1/config.vsh.yaml index 7a66c3aab..96b28eeb8 100644 --- a/src/metrics/regression_1/config.vsh.yaml +++ b/src/metrics/regression_1/config.vsh.yaml @@ -14,6 +14,11 @@ functionality: description: calculate the scores for the given min tfs in addition to the default required: false default: false + - name: --binarize + type: boolean + direction: input + description: whether to binarize the weight + default: true resources: - type: python_script path: script.py diff --git a/src/metrics/regression_1/main.py b/src/metrics/regression_1/main.py index c9c2323d3..97ef66ae6 100644 --- a/src/metrics/regression_1/main.py +++ b/src/metrics/regression_1/main.py @@ -187,7 +187,14 @@ def process_net(net, gene_names): net = net[net.index.isin(gene_names)] return net - +def binarize_weight(weight): + if weight > 0: + return 1 + elif weight < 0: + return -1 + else: + return 0 + def main(par): random_state = 42 set_global_seed(random_state) @@ -203,6 +210,8 @@ def main(par): net = pd.read_csv(par['prediction']) # net['weight'] = net.weight.abs() # subset to keep only those links with source as tf + if par['binarize']: + net['weight'] = net['weight'].apply(binarize_weight) if par['apply_tf']: net = net[net.source.isin(tf_all)] # if 'cell_type' in net.columns: