From 7d7f06256cc8c70f7f697610fd898de51b001d33 Mon Sep 17 00:00:00 2001 From: Anton Bushuiev Date: Tue, 4 Jun 2024 21:38:14 +0200 Subject: [PATCH 1/2] Copy ms plotting utils from DreaMS repo --- massspecgym/utils.py | 71 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 71 insertions(+) diff --git a/massspecgym/utils.py b/massspecgym/utils.py index 46a8ab0..163ea53 100644 --- a/massspecgym/utils.py +++ b/massspecgym/utils.py @@ -1,6 +1,10 @@ import numpy as np import seaborn as sns import matplotlib.pyplot as plt +import matplotlib.colors +import matplotlib.cm as cm +import matplotlib.colors as mcolors +import matplotlib.ticker as ticker import pandas as pd import typing as T from rdkit.Chem import AllChem as Chem @@ -150,3 +154,70 @@ def get_smiles_bpe_tokenizer() -> ByteLevelBPETokenizer: ], ) return smiles_tokenizer + + +def parse_spec_array(arr: str) -> np.ndarray: + return list(map(float, arr.split(","))) + + +def plot_spectrum(spec, hue=None, xlim=None, ylim=None, mirror_spec=None, highl_idx=None, + figsize=(6, 2), colors=None, save_pth=None): + + if colors is not None: + assert len(colors) >= 3 + else: + colors = ['blue', 'green', 'red'] + + # Normalize input spectrum + def norm_spec(spec): + assert len(spec.shape) == 2 + if spec.shape[0] != 2: + spec = spec.T + mzs, ins = spec[0], spec[1] + return mzs, ins / max(ins) * 100 + mzs, ins = norm_spec(spec) + + # Initialize plotting + init_plotting(figsize=figsize) + fig, ax = plt.subplots(1, 1) + + # Setup color palette + if hue is not None: + norm = matplotlib.colors.Normalize(vmin=min(hue), vmax=max(hue), clip=True) + mapper = cm.ScalarMappable(norm=norm, cmap=cm.cool) + plt.colorbar(mapper, ax=ax) + + # Plot spectrum + for i in range(len(mzs)): + if hue is not None: + color = mcolors.to_hex(mapper.to_rgba(hue[i])) + else: + color = colors[0] + plt.plot([mzs[i], mzs[i]], [0, ins[i]], color=color, marker='o', markevery=(1, 2), mfc='white', zorder=2) + + # Plot mirror spectrum + if mirror_spec is not None: + mzs_m, ins_m = norm_spec(mirror_spec) + + @ticker.FuncFormatter + def major_formatter(x, pos): + label = str(round(-x)) if x < 0 else str(round(x)) + return label + + for i in range(len(mzs_m)): + plt.plot([mzs_m[i], mzs_m[i]], [0, -ins_m[i]], color=colors[2], marker='o', markevery=(1, 2), mfc='white', + zorder=1) + ax.yaxis.set_major_formatter(major_formatter) + + # Setup axes + if xlim is not None: + plt.xlim(xlim[0], xlim[1]) + else: + plt.xlim(0, max(mzs) + 10) + if ylim is not None: + plt.ylim(ylim[0], ylim[1]) + plt.xlabel('m/z') + plt.ylabel('Intensity [%]') + + if save_pth is not None: + raise NotImplementedError() From e8c285ec8badd1ad1ec40c7105fe8d7c6098323a Mon Sep 17 00:00:00 2001 From: Anton Bushuiev Date: Tue, 4 Jun 2024 21:38:43 +0200 Subject: [PATCH 2/2] Add notebook for leakage analysis --- .../6_analyze_leakage.ipynb | 1269 +++++++++++++++++ 1 file changed, 1269 insertions(+) create mode 100644 notebooks/dataset_construction/6_analyze_leakage.ipynb diff --git a/notebooks/dataset_construction/6_analyze_leakage.ipynb b/notebooks/dataset_construction/6_analyze_leakage.ipynb new file mode 100644 index 0000000..c3ab117 --- /dev/null +++ b/notebooks/dataset_construction/6_analyze_leakage.ipynb @@ -0,0 +1,1269 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import collections\n", + "import random\n", + "import math\n", + "import itertools\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "from pandarallel import pandarallel\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from rdkit import Chem\n", + "from rdkit.Chem import DataStructs\n", + "from tqdm import tqdm\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "import massspecgym.utils as utils" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "INFO: Pandarallel will run on 8 workers.\n", + "INFO: Pandarallel will use standard multiprocessing data transfer (pipe) to transfer data between the main process and workers.\n" + ] + } + ], + "source": [ + "random.seed(0)\n", + "np.random.seed(0)\n", + "\n", + "pandarallel.initialize(nb_workers=8, progress_bar=True)\n", + "\n", + "tqdm.pandas()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read MassSpecGym dataset along with the split" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(utils.hugging_face_download('MassSpecGym.tsv'), sep='\\t')\n", + "df = df.set_index('identifier')" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create baseline splits in the same ratio" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "24299 2432 2198\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 231104/231104 [01:07<00:00, 3405.70it/s]\n" + ] + } + ], + "source": [ + "original_fold_sizes = df['fold'].value_counts().to_dict()\n", + "\n", + "# 2. Random split\n", + "fold_random = []\n", + "for fold, size in original_fold_sizes.items():\n", + " fold_random += [fold] * size\n", + "fold_random = np.random.permutation(fold_random)\n", + "df['fold_random'] = fold_random\n", + "\n", + "# 3. InchiKey split\n", + "inchi_keys = df['inchikey'].unique()\n", + "train_size = int(len(inchi_keys) * (original_fold_sizes['train'] / len(df)))\n", + "val_size = int(len(inchi_keys) * (original_fold_sizes['val'] / len(df)))\n", + "test_size = len(inchi_keys) - train_size - val_size # Ensure the total size matches\n", + "\n", + "# Shuffle the inchi_keys array to ensure random distribution\n", + "np.random.shuffle(inchi_keys)\n", + "\n", + "# Split the array into three parts\n", + "inchi_keys_folds = {\n", + " 'train': inchi_keys[:train_size],\n", + " 'val': inchi_keys[train_size:train_size + val_size],\n", + " 'test': inchi_keys[train_size + val_size:],\n", + "}\n", + "print(train_size, val_size, test_size)\n", + "\n", + "# Assign the fold based on the inchi_key\n", + "def inchi_key_to_fold(inchi_key):\n", + " for fold, inchi_keys in inchi_keys_folds.items():\n", + " if inchi_key in inchi_keys:\n", + " return fold\n", + " return None\n", + "df['fold_inchikey'] = df['inchikey'].progress_apply(inchi_key_to_fold)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fold\n", + "train 194119\n", + "val 19429\n", + "test 17556\n", + "Name: count, dtype: int64\n", + "\n", + "fold_random\n", + "train 194119\n", + "val 19429\n", + "test 17556\n", + "Name: count, dtype: int64\n", + "\n", + "fold_inchikey\n", + "train 194618\n", + "val 19219\n", + "test 17267\n", + "Name: count, dtype: int64\n" + ] + } + ], + "source": [ + "# Assert that all splits are disjoint\n", + "print(df['fold'].value_counts())\n", + "print()\n", + "print(df['fold_random'].value_counts())\n", + "print()\n", + "print(df['fold_inchikey'].value_counts())" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyse leakage (with respect to Tanimoto similarity)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 25046/25046 [00:03<00:00, 7219.51it/s]\n", + "100%|██████████| 3386/3386 [00:00<00:00, 5307.93it/s]\n", + "100%|██████████| 3170/3170 [00:00<00:00, 5364.34it/s]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "822d2a35b1ae4aba8740ab3a1056a2f1", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=397), Label(value='0 / 397'))), HB…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 30515/30515 [00:04<00:00, 6551.67it/s]\n", + "100%|██████████| 9944/9944 [00:01<00:00, 6807.96it/s]\n", + "100%|██████████| 9214/9214 [00:01<00:00, 6873.99it/s]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a5ee4b3d699d46248e7baf9f07da1386", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=1152), Label(value='0 / 1152'))), …" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 26587/26587 [00:03<00:00, 6954.65it/s]\n", + "100%|██████████| 2637/2637 [00:00<00:00, 6816.06it/s]\n", + "100%|██████████| 2379/2379 [00:00<00:00, 6947.65it/s]\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "1d29a75073274561af2760e0e2fa2eba", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "VBox(children=(HBox(children=(IntProgress(value=0, description='0.00%', max=298), Label(value='0 / 298'))), HB…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def get_max_train_tanimotos(fold_col):\n", + " mols_and_fps = {}\n", + " for fold in ['train', 'val', 'test']:\n", + " df_fold = df[df[fold_col] == fold]\n", + " df_fold = df_fold.drop_duplicates(subset='smiles')\n", + " mols_and_fps[fold] = df_fold['smiles'].progress_apply(lambda s:\n", + " (mol := Chem.MolFromSmiles(s),\n", + " utils.morgan_fp(mol, to_np=False))\n", + " )\n", + " def max_train_tanimoto(test_mol_and_fp, train_mols_and_fps):\n", + " tanimotos = [\n", + " DataStructs.FingerprintSimilarity(test_mol_and_fp[1], train_mol_and_fp[1])\n", + " for train_mol_and_fp in train_mols_and_fps\n", + " ]\n", + " max_tanimoto = max(tanimotos)\n", + " # === Figure examples\n", + " # for i, tanimoto in enumerate(tanimotos):\n", + " # if math.isclose(tanimoto, max_tanimoto, rel_tol=1e-9, abs_tol=1e-9) and tanimoto > 0.95 and fold_col == 'fold_inchikey':\n", + " # print(\n", + " # tanimoto,\n", + " # Chem.MolToSmiles(train_mols_and_fps.iloc[i][0]),\n", + " # Chem.MolToSmiles(test_mol_and_fp[0])\n", + " # )\n", + " # === End figure examples\n", + " return max_tanimoto\n", + " max_train_tanimotos = mols_and_fps['test'].parallel_apply(lambda f: max_train_tanimoto(\n", + " f,\n", + " pd.concat([mols_and_fps['train'], mols_and_fps['val']]),\n", + " ))\n", + " return max_train_tanimotos.to_numpy()\n", + "\n", + "df_plot = {}\n", + "for fold_col in ['fold', 'fold_random', 'fold_inchikey']:\n", + " df_plot[fold_col] = get_max_train_tanimotos(fold_col)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Splitting methodmax_train_tanimoto
0MCES agglomerative clustering (ours)0.600000
1MCES agglomerative clustering (ours)0.600000
2MCES agglomerative clustering (ours)0.376238
3MCES agglomerative clustering (ours)0.746988
4MCES agglomerative clustering (ours)0.228261
.........
147582D InchiKey disjoint (standard)1.000000
147592D InchiKey disjoint (standard)1.000000
147602D InchiKey disjoint (standard)1.000000
147612D InchiKey disjoint (standard)1.000000
147622D InchiKey disjoint (standard)1.000000
\n", + "

14763 rows × 2 columns

\n", + "
" + ], + "text/plain": [ + " Splitting method max_train_tanimoto\n", + "0 MCES agglomerative clustering (ours) 0.600000\n", + "1 MCES agglomerative clustering (ours) 0.600000\n", + "2 MCES agglomerative clustering (ours) 0.376238\n", + "3 MCES agglomerative clustering (ours) 0.746988\n", + "4 MCES agglomerative clustering (ours) 0.228261\n", + "... ... ...\n", + "14758 2D InchiKey disjoint (standard) 1.000000\n", + "14759 2D InchiKey disjoint (standard) 1.000000\n", + "14760 2D InchiKey disjoint (standard) 1.000000\n", + "14761 2D InchiKey disjoint (standard) 1.000000\n", + "14762 2D InchiKey disjoint (standard) 1.000000\n", + "\n", + "[14763 rows x 2 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_plot = pd.DataFrame({\n", + " 'Splitting method': ['MCES agglomerative clustering (ours)'] * len(df_plot['fold']) + ['Random'] * len(df_plot['fold_random']) + ['2D InChiKey disjoint (standard)'] * len(df_plot['fold_inchikey']),\n", + " 'max_train_tanimoto': np.concatenate([df_plot['fold'], df_plot['fold_random'], df_plot['fold_inchikey']]),\n", + "})\n", + "df_plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "utils.init_plotting(figsize=(3, 2))\n", + "ax = sns.histplot(df_plot[df_plot['Splitting method'] != 'Random'], x='max_train_tanimoto', hue='Splitting method', element=\"step\", binwidth=0.01)\n", + "sns.move_legend(\n", + " ax, \"lower center\",\n", + " bbox_to_anchor=(.5, 1), frameon=True#ncol=3, title=None, frameon=False,\n", + ")\n", + "plt.xlabel('Tanimoto similarity to training and validation sets')\n", + "ax.xaxis.set_label_coords(0.4, -0.2)\n", + "plt.ylabel('Number of test molecules')\n", + "plt.savefig('splits.svg', bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Leakage examples" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "df_0 = df[df['smiles'] == 'CCCCCCCC(=O)CC(=O)NC1CCOC1=O']\n", + "df_1 = df[df['smiles'] == 'CCCCCC(=O)CC(=O)NC1CCOC1=O']" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063023 MassSpecGymID0062601\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063023 MassSpecGymID0062602\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063023 MassSpecGymID0062603\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063023 MassSpecGymID0062604\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063023 MassSpecGymID0062605\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063023 MassSpecGymID0062606\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063024 MassSpecGymID0062601\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAggAAADmCAYAAACwLX24AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABDLklEQVR4nO3deVgTV9sH4F8SNhFFQQVxYdGiVRFQFBHFBcWKgkJF0WoVd31bbbUiLqit9dPXfd93inWrWvStdQNcEK1YrLjVBcWFVVk0soQk5/tjmikxggEJAfLc1+XVZiaZec5hMvPknDNnBIwxBkIIIYSQIoTaDoAQQgghlQ8lCIQQQghRQQkCIYQQQlRQgkAIIYQQFZQgEEIIIUQFJQiEEEIIUUEJAiGEEEJUUIJACCGEEBWUIBBCCCFEBSUIOuz58+do0aIFvL29VdZdvnwZLVq0wLp16zSyb7FYjHnz5sHd3R3Ozs7o06cPtm/frpF9FXX58mWMHj0arq6ucHZ2ho+PD8LCwsp1H4p6lUqlAICePXuibdu2cHZ2hpOTEzp37ozZs2cjMzOT/0xmZibGjRsHZ2dn9O7dG9HR0WqtKygowLx58+Dq6gpXV1f897//hWJy1OfPn2P06NFo3749unbtio0bN/Kfy8/Px/Tp0+Hi4gIPDw8cPnxYaX/ffvstXF1d4e7ujh9//BESiUSpjIwxjBgxAqtWrVKrTkaMGIEWLVrgr7/+UtlO9+7d0bNnT7W2UxZHjx5F//794ezsjE6dOmH69OlIS0vT2P4A4OXLl5g/fz569OgBZ2dndOnSBbNnz8bLly/LdT8jRozAoUOHAADr1q1D69at4ezszP8bNmwYrly5ovSZrVu3onPnznBxccGPP/4ImUym1rrffvsNXl5ecHZ2xogRI/Ds2TN+3d69e9GzZ0+0b98eI0aMwMOHD/l1sbGx8PHxgbOzM/z9/XHr1i1+3fnz59GnTx84OTlh3LhxePXqlUoZd+7cie++++7jK4uUHiM669mzZ8ze3p517NiR3bt3T2ndrFmzmJOTE1u7dq1G9h0cHMy++eYblpWVxRhj7O7du6xHjx7sp59+0sj+GGPs+PHjrH379uzgwYMsPz+fSSQSduPGDdanTx+2bdu2ctuPol4LCwsZY4z16NGDxcTE8OtTU1PZxIkTmb+/P5PJZIwxxiZPnsxCQ0NZQUEBu3DhAmvXrh1LTU394LoffviBjRkzhr1584alp6ezvn37sqNHjzLGGAsMDGSrVq1iUqmUvXjxgrm7u7MLFy4wxhhbtGgRmzBhAnv79i27efMm69ixI7t16xZjjLGpU6ey4OBglpubyzIyMlhAQABbv369Uhl37drFWrZsyVauXKlWnQwfPpx17NiRLV68WGn5tWvXmJOTE+vRo0dpqlhtsbGxzN3dnd26dYvJ5XKWk5PDQkJCmL+/v0b2xxhjr169Yh4eHmzGjBn83yklJYWFhoay/v3783/z8jB8+HB28OBBxhhja9euZdOnT+fX5efns59//pm1bduW3bx5kzHG2JkzZ1jPnj3Zs2fP2MuXL5mfnx/btWvXB9f99ddfrGPHjuyvv/5iUqmULVmyhH355ZeMMcaio6OZh4cHe/ToEZNKpWzDhg2sV69ejDHGXrx4wdq3b8+io6OZTCZje/fuZZ6enowxxtLT05mzszO7fPkyy8/PZ3PnzmUTJ07k4y8sLGSbNm1iLVq0UCoXqTjUgkDQu3dvnDx5kn8tkUgQExMDd3d3ftmrV68wZcoUdO/eHW3btsWIESP4X2G3b9+Gv78/XFxc0L9/f/z666/8doKDg+Hq6opu3bph1qxZKCgoAAAkJCSgZ8+eqFOnDgCgZcuWCAkJgVDIHZLr1q3D9OnTERgYCGdnZ4wdO1bp19fu3bvh6ekJNzc3zJ49G2/fvgUAyOVyrF69Gu7u7nB1dcXs2bMhkUhQWFiIH3/8EbNnz0ZAQAAMDQ2hr68PR0dHLFu2DLVq1QLA/do/ffo0v59Tp05hyJAhAIAWLVpg//796NKlC1xdXfHLL79g7dq16NixI3r27ImrV6+qVd8WFhZYsWIFnjx5gujoaLx9+xZRUVH4+uuvYWBggK5du6JDhw44depUieskEgmOHDmC+fPnw8TEBPXr18e2bdvQuXNnvo6++uoriEQivH79Gowx1K5dGwBw4sQJTJw4EcbGxnBwcED//v0RERHBxzh58mTUqFED9erVg4+PD+Lj4/l1jx8/xsGDB9G7d2+1yqvQu3dvnDp1im/hUMTRq1cvpfdt27YN3t7ecHZ2Rs+ePfHbb78BKPl4+vXXX9GrVy907NgRQ4cO5X+lJiQkwN7eHq1bt4ZAIEDt2rUxY8YM2NvbQyKR4Pnz53B1dcWKFSvQrl079O7dG1FRUXwst2/fRmBgIFxcXBAQEKD06zc2NhYDBgyAs7MzBg0ahLt37wIANm7ciKZNm2Lp0qWwsLAAAFhaWmLBggXo0aMHcnJysG7dOkycOJHfVmFhIVxdXZGYmIiQkBCsWLEC/v7+cHJywldffYWrV6+ib9++aNeuHZYsWaJWfRsaGiIwMBD9+/fH1q1b+foeMmQIGjduDHNzc0yYMIH/vpa07tChQxg2bBjatm0LkUiEKVOmYPbs2QCAjIwMjB8/HnZ2dhCJRPjyyy/x9OlTvHz5EhEREejZsye6desGoVCIYcOGYfXq1ZDL5Thz5gycnZ3h5uYGQ0NDTJs2DefPn0dOTg4AYMaMGfjrr7/47x+peJQgEPTr1w+///47//rChQtwcXGBkZERv2zZsmWoXbs2Tp8+jcuXLwPgLkAAsGjRIgwaNAhxcXGYP38+fvjhB+Tl5eHXX39FSkoKzp8/jxMnTuDvv//mExEvLy8sXLgQ//d//4eoqCjk5OTAy8sLQ4cO5ff5+++/Y9KkSbhy5Qrq1KmD0NBQAMDx48cRHh6OnTt34ty5c8jPz8fSpUsBAPv27cPp06dx4MABnDt3Ds+ePcP27dsRHx+Pt2/fon///irld3Bw4E9C/fr1w6lTp/h1v/32m1IXTFxcHCIjIzFjxgyEhoZCLpcjJiYG/fv3V7u5HQCMjY3Rrl07XL9+HUlJSTA2Nkb9+vX59ba2tkhMTPzgOj09PVy6dAmenp7o3r07IiIi0KBBAwDcBUJPTw9+fn4YMGAAPDw84OjoiJycHLx69Qp2dnYq2wSA1atXw9raml8XFRUFe3t7AIBMJsOsWbMQGhoKY2NjtcsLAI6OjhAKhbhx4wYAQCqV4vz58/Dy8uLfc/XqVfz000/YsWMH/vzzT4wZMwYLFy4EgGKPp7y8PMydOxebN2/G1atX0bVrVyxbtgwA0K1bN1y/fh0TJ07EoUOH8PjxY5iZmWHx4sUwMDAAAGRnZ+Ply5eIjY3FrFmz8O233yItLQ1v3rzB2LFjERgYiCtXrmDs2LGYOHEixGIxMjIyMHnyZEycOBFxcXEYOHAgpk6dCgCIjIyEn5+fSvmFQiGmTZuGunXrol+/foiJiYFYLAbAdX01bNiQ/5scPXoUq1atQmRkJK5du4b//ve/CA8Px88//4ywsDA8efJE7Xp3d3fH9evXAQCJiYnF/t1LWnfnzh0YGhpi2LBh6NSpE6ZNm8Yn94MGDcIXX3zBfy4yMhLm5uYwNzfHnTt3YG5ujvHjx8PV1RVBQUGoUaMGhEKhyv7q1q2LWrVqISkpCQAwa9YsbNq0CfXq1VO7rKR8UYJA0L59e7x9+xb37t0DwF0UfXx8lN4zffp0hISEgDGGlJQU1KlTh/9FX7NmTURGRuLSpUtwdHTEtWvXUKNGDdSsWROJiYk4fvw48vLycPjwYQwcOBAA8M0332DBggV48uQJpk2bBjc3N4wfPx7Jycn8Pj08PNCtWzcYGhpi6tSpuHDhAvLy8nDs2DEEBQXB2toaxsbGmDp1Ko4dOwbGGE6ePImRI0eicePGMDExwbJly+Dj44OMjAzUqVOHvygAwLBhw+Di4oL27dvDwcEBAJcgREVFQSKRIDc3FxcuXEDfvn35z4wYMQIGBgbo2LEjZDIZRo4cCX19fbi5uSE1NbVU9V67dm3k5OQgNzdXKRkDACMjI+Tn55e4LicnB2/fvkVcXBx+/fVX7N69G4cPH8axY8eU3r9//36cOnUKf/zxB8LDw5GXl8dv591tvmvx4sV48uQJxo4dCwDYsWMH7O3t4ebmVqqyKnh7e/NJYmxsLBwcHFCzZk1+fdu2bXHw4EFYWloiLS0NhoaGyMzMhEwmK/Z40tPTg4GBAQ4cOIBbt25hwoQJ2LNnDwDA3t4eR44cgYWFBTZt2oTPPvsMvXr1UkoCAWDmzJkwNDREz5490bp1a0RHR+P8+fNo3Lgxv48+ffqgSZMmuHDhAs6fP48WLVqgb9++EIlEGDp0KJYuXQq5XI6MjAy+5QDgklYXFxe4uLjA0dERx44dg52dHZo3b863VrybiHp6esLa2hpmZmZo1qwZ+vfvDzMzM7Ro0QL169dHSkqK2nVuamrK/yrPy8tT+rvXqFED+fn5YIyVuO7169fYv38/5s2bh+joaNSrVw8zZsxQ2df169exYMECzJ07FwKBAK9fv8bBgwcxbtw4XLx4Ea6urpg8eTKkUiny8vJQo0YNpc/XqFGDPz4ViS7RHkoQCIRCIT777DOcPHkSubm5iI+PV+peAICUlBQEBQWhe/fu+PHHH5GRkcE3FS9evBgNGjTAzJkz4erqimXLlkEqlcLb2xsTJkxAeHg4unXrhhEjRvC/DgDuYrF161bExcVh3759KCgowDfffMOvb9KkCf//FhYWkEqlyM7ORkpKCpYtW8afdD///HPI5XK8evUKL1++VDo5W1paokmTJjAzM0N2djYKCwv5dfv27UNcXByOHDnCD8Jr2bIlLC0tcfHiRURHR6NNmzZKJypTU1O+zgDwXRNCoRByubxU9Z6dnY26deuiRo0afFO5Qn5+PoyNjUtcZ2BgAJlMhm+++QYmJiawsbHBkCFDEBkZqfR+Q0ND2NjY4IsvvkBUVBR/ESi6XcU2FSQSCaZPn47o6Gjs2bMHZmZmePDgAX755RcEBweXqpxFeXt7890M//vf/1RadAQCAVavXo1OnTph4sSJfGsVY6zY40lfXx+7du3Cs2fP8OWXX6J79+44evQov81mzZrh+++/R2RkJKKiouDv749vv/2WH0hXu3Zt/tcwwB1rL1++REpKCu7evcsfZy4uLrh79y5SUlLw6tUrpeNCJBLByckJQqEQ5ubmyMjI4NcNGzYMcXFxiIuLQ6tWrfjjRFEXEokEkZGRSglC0XhEIhF/nAHcsVa0m+ZDsrKyULduXQCqiWBeXh6MjY0hEAhKXGdgYAA/Pz+0bNkSRkZGmDp1Kq5evcq3gABci9+4ceMwd+5cviwGBgbw9PREhw4dYGBggEmTJiE9PR2JiYl8AlKUYp+kcqAEgQDgfjmfPHkSkZGR6Nq1K/T19ZXWz5gxA35+foiNjcWePXv4X9yMMTx48ADz58/HpUuXsHv3bkRERCAqKgqPHz9G165dcezYMVy4cAENGjTAkiVLkJqaCkdHR/5XkOLkGhISgvv37/P7LHqSTU5Ohr6+PszMzFCvXj388MMP/En38uXLiIiIgLm5OSwsLJCens5/7ubNm9i/fz/atWuHGjVq8P3ZH6qLc+fO4cyZM+jXr5/SOoFAUPrKfQ+xWIz4+Hh06NAB1tbWePv2rdJdDY8fP4atre0H1wmFQqWTtFwuB2MMMpkM/fr1w+PHj/l1EomEvxiamZkprVNsEwByc3MxZswYpKamYv/+/XyidvbsWaSnp6N79+5wcXHBiRMnsHPnTkyYMEHtcn/66acwNjbGlStXcPXqVXTv3l1p/e7du/H8+XNERUXh2LFjGDdunFKM7zuexGIxJBIJ38UQHByM2bNnIysrC+PHj8emTZv4bVhZWWHy5Mn45JNP8ODBA/5vofjVCnDHmoWFBerXr4+OHTvyx1lcXByOHz+OwMBAleOMMYb//ve/eP36Nbp378733ZdE0c1w4cIF2NnZoXHjxmrXY2lcunQJHTp0AADY2dkpdU8U/buXtM7GxkbpOJPJZErfhb179yI0NBTr1q2Dv78/v/zdzymOTcYYbG1tlfaXmZmJ169fw8bGpjyKTcoBJQgEAODk5ASpVIqNGzeqdC8AwOvXr/nM/s8//0RERASkUikEAgEWLVqEXbt2gTHG/6oyNTVFZGQkgoODkZmZiTp16sDQ0BB16tSBpaUlHBwcMG/ePL5FIS0tDdu3b0ePHj34fZ47dw5//vkn8vPzsXbtWnh5ecHQ0BA+Pj7YuXMnkpOTUVhYiFWrVuHrr78GwJ109+7di9TUVIjFYqxatQqZmZkwNDTE/Pnz8eOPP+LQoUN4+/Yt5HI54uPjMXfuXKV+zv79++PixYu4du0a+vTpU+51nZycjO+++w4tW7ZEly5dYGJiAg8PD6xcuRIFBQW4ePEi/vjjD3h5eZW4ztTUFD169MDGjRshFouRlJSE/fv3883ezZs3x9q1a1FQUIAHDx5g3759fBdPv379sH79eojFYty6dQsnTpzgk6GQkBDo6elh165d/C9PAJg0aRLi4+P5i2X//v0xevRobNmypVTl9/b2xsKFC9GpUyelLh+AO84UYycyMzOxZs0aANx4heKOJ0VCc+XKFRgYGMDMzAxGRkYwNDREnz59sGfPHkRHR0MqlSI3NxfHjx9Hamoqf9GUy+VYu3YtCgsLcebMGTx48IAfWHfnzh2cPXsWcrkc169fh6+vLx49egQPDw88fPgQZ86cgVwux4EDBxAZGYlatWphypQpSEpKQkhICH8rYFpaGlatWoWEhASYmZkB4JKVli1bYs2aNe+91fhj5efnIzw8HKdPn+aTuH79+mHfvn1ISkrCq1evsGXLFv77XtI6Pz8/HD9+HPfu3YNEIsHq1av5YzcqKgqrV69GWFiYSsujr68vLl++jNjYWEilUqxfvx6NGzeGvb09evXqhevXr+PChQsoKCjAqlWr0K1bN6XWEqJdetoOgFQe3t7eOHHiBFxcXFTWLViwAEuWLMHChQthY2ODgIAAnD9/HgCwfPlyLFiwAFu3boWxsTFGjhyJjh07wsnJCY8fP0bfvn1RWFiIjh07YtGiRQCADRs2YM2aNRg5ciSys7NhYmKCzz77DN9++y2/T0dHRyxfvhx///03fz8+wA2KysrKwvDhw5GTk4M2bdpg3bp1EAgEGDRoENLT0xEYGIi8vDx4e3tj/PjxALgToKWlJbZv344VK1agoKAAlpaW8PLywtq1a/n9Wltbo379+jAzM1O6QH6MiRMnQiQSAeAGY/Xs2RPffPMN31WxaNEihIaGwt3dHWZmZli5ciXfVVLSuqVLl2LRokXo06cPPzeB4mKzYMECfP/99+jatStMTU0xdepUeHh4AACmTZuGhQsXwtPTE0ZGRggODoaDgwOeP3+OU6dOwdDQEK6urnz8zs7O2LlzZ4ll3Lx5M+Li4j44n4W3tzfWr1+PuXPnqqwbNWoUpk2bBldXV5iamiIgIADx8fF49OgRRowY8d7jydzcHIsXL8b8+fORnp4OS0tLrF69GsbGxvj8888hEAiwdu1aTJs2DYwxODk5YceOHahXrx6eP38OgPtF3KVLF9SvXx8bN27kL+KbN2/G4sWLMXPmTNStWxehoaFo27YtAGDTpk1YvHgxQkJCYG9vjw0bNkAgEMDMzAxHjx7Fpk2bEBQUhFevXqFGjRro0KEDwsPD4ejoyJe3X79+WLRokdI4l49x8uRJnDt3DgDXndCqVSvs3LkTLVu2BMANDn769Cm+/PJL5OXlwdfXFyNHjvzgul69eiEnJwdTp05FRkYGXFxcsHjxYgDcPAX5+flKA4wBICIiAm3atMGaNWuwePFiPHv2DJ9++inWr18PgUAACwsLrF69GkuWLEFycjLat2/PDzYmlYOAlaYzi5AKsm7dOiQlJWH58uVa2f9XX32FXr168b+4yYdJpVIEBwdj5cqV2g5Fbc+fP4enpydu374NPb2K/7107tw57N27lx9USUhlQl0MhBSRlpaGCxcu4M8//1S6/Y582NmzZ997ex9RlZubi7///hs7duxQ6rMnpDKhLgZCivj111+xZcuWMt3nr+s+++wzbYdQZWRmZiIwMBBubm7vnZuDkMqAuhgIIYQQooK6GAghhBCighIEQgghhKigBIEQQgghKqrkIEWpVIqcnBwYGhry95ETQggh5MPkcjkKCgpgampa4u29VTJByMnJKdXTzAghhBCizMbGBubm5sWur5IJgqGhIQCgadOmSk+C0yUymQz379+Hvb09P0OfLtH18gNUB7pefoDqQNfLD5StDvLy8vDkyRP+WlqcKpkgKLoVjIyMdPZedZlMBgAwNjbWyS+GrpcfoDrQ9fIDVAe6Xn7g4+rgQ130WuvAl0gkGDVqFP88dEJIycRiYOdOYO5cYNcu7jUhhGiKVhKE27dvY+jQoYiPj9fG7gmpcmJiABsbYNw4YO9eYOxYoFkzIf76Sze72AghmqeVBGHfvn2YMmUK/1Q0QkjxxGJgwACgdWvg8WPg6VMgMRFo1QqYPr05tSQQQjRCK2MQFI/8/dBjYT9ELpfz/S+6RlFuKn/1L//+/QJkZQkQFiZA06bcMmtrICxMAFtbEQ4elGH06OpfD+/SpWOgOLpeB7pefqBsdaDue6vkIEWFhw8fajsErUtISNB2CFqlC+WPjbWClZUFmjYVKC23tgasrBiuXs1Au3bJWopO+3ThGPgQXa8DXS8/oJk6qNIJQvPmzWFiYqLtMLRCJpMhISEBDg4OOjl6V5fK7+YmwO7dAjx9Cr4FAQCSkoDkZAFcXevDyamB9gLUEl06Boqj63Wg6+UHylYHubm5uH///gffV6UTBKFQqLMHhYJIJNLpOtCF8gcGAiEhwPDhQFgY13KQlASMGMFgairD4MGCal8HJdGFY+BDdL0OdL38QOnqQN330TzFhFRyJiZARARw5w5gZwc0bAjY2nKvV6x4CB1tRCOEaJhWWxDCwsK0uXtCqozOnYEnT4AWLQCJBNixA/D3l+Phw7faDo0QUk1V6S4GQnSJiQlQpw73/0FBgA4P3CaEVADqYiCEEEKICkoQCCGEEKKCEgRCCCGEqKAEgRBCCCEqKEEghBBCiApKEAghhBCighIEQgghhKigBIEQQgghKihBIIQQQogKShAIIYQQooISBEIIIYSooASBEEIIISooQSCEEEKICkoQCCGEEKKCEgRCqgixGMjOBtLTgV27uNeEEKIplCAQUgXExAA2NkByMpckjB0LNGsmxF9/1dR2aISQaooSBEIqObEYGDAAaN0a+OQTwN4eSEwEWrUCpk9vTi0JhBCNoASBkEru4EEgKwsICwP09bll1tZAWJgAOTkiHD4s0G6AhJBqiRIEQiq5xESgUSOgaVPl5dbWgJUVQ2KiduIihFRvlCAQUsnZ2QEvXgBPnyovT0oCkpMFsLPTTlyEkOqNEgRCKrnBg4G6dYHhw4HCQm5ZUhIwYgSDqakMgwYx7QZICKmW9LQdACGkZCYmQEQE4OsLvHoF6OkBtraAmRmwYsVDmJh8ou0QCSHVELUgEFIFdO4MPHnCJQeMATt2AI8eyeHo+FbboRFCqilqQSCkijAxAUQi7v+DggCZTLvxEEKqN2pBIIQQQogKrSQIZ8+eRf/+/eHl5YV58+ahUDHyihBCCCGVQoUnCBkZGViwYAG2bduGU6dOITc3F+Hh4RUdBiGEEEJKUOEJQkxMDNq1a4eGDRtCIBBg8ODBOHHiREWHQQghhJASVPggxfT0dFhYWPCvLSwskJqaWqZtyeVyyHR0pJai3FR+XSs/l9PLZHIdrgOOrpcfoDrQ9fIDZasDdd9b4QmCXC5XWSYUlq0h4+HDhx8bTpWXkJCg7RC0StfKL5c7AwBu3LjBL9O1OniXrpcfoDrQ9fIDmqmDCk8QLC0tce/ePf51eno6LC0ty7St5s2bw8TEpLxCq1JkMhkSEhLg4OAAkeLeNx2iq+UXCrkHMzk5OelsHSjoevkBqgNdLz9QtjrIzc3F/fv3P/g+tRKE2NhYtXaq4ObmVuy6Ll26YPny5Xjx4gWsrKxw+PBh9OjRo1TbVxAKhTp7UCiIRCKdrgNdLX/RMutqHSjoevkBqgNdLz9QujpQ931qJQijR4+GlZUVGPvwnO9paWm4fft2sevr1auH77//HhMnToREIoGjoyPGjBmjVrCEEEIIqRhqJQhGRkY4d+6cWht0dnb+4Hs8PT3h6emp1vYIIYQQUvHUGh24d+9etTdYmvcSQgghpHJSqwXBwcFB6XVmZia2bNmCx48fo3Hjxhg3bhwaNmz43vcSQgghpOop0/2Fs2fPRsOGDTFy5EhYWlriq6++Ku+4CCGEEKJFaiUIK1asgFgs5l+np6fD19cX7u7u8PHxQXJyssYCJIQQQkjFU6uL4dNPP0VQUBAGDhyIwMBATJo0Cb6+vhCJRMjPz8fMmTM1HSch1Z5YDBw8CCQmAs2aAQEB3COeCSFEG9RKELy9vdGrVy/89NNPGDZsGMaNG4fz588jKysLdevW1fn7Twn5WDExwIABQFYW0KgR8OIFMGMGEBEBdO6s7egIIbpI7TEIBgYGGD16NLZu3Yo//vgDY8eORUpKCiUHhHwksZhLDlq3Bh4/Bp4+5VoRWrUCfH259YQQUtHUShBiY2MREBCAwMBAPHr0CLNnz+Yf2Tx9+nS8ePFC03ESUm0dPMi1HISFAU2bcsusrbnXmZnAoUPajY8QopvUShDmzJmDr776CuPHj8ecOXMAANbW1li7di2GDRuGkJAQjQZJSHWWmMh1KyiSAwVra255YqJ24iKE6Da1xiDk5uaicePGYIwhLy9PaV379u0RFhamkeAI0QV2dtyYg6dPlZOEpCRuuZ2d9mKrSmiQJyHlS60WhODgYHzxxRcICgpCcHCwpmMiRKcMHgzUrQsMH84lBQD33xEjADMz7kJHShYTA9jYAOPGAXv3AmPHcq8vX9Z2ZIRUXWolCF27dsWVK1dw8eJFeHt7l/jejIyMcgmMEF1hYsLdrXDnDtda0LAhYGvLvY6IoF/BH0KDPAnRDLUShD59+qi9wdK8lxDC6dwZePIEsLQEpFJgxw7utTZucRSLgZ07gblzgV27Kv8F9tAhAQ3yJEQD1BqDkJ+fjy+++OKD72OMoaCg4KODIkQXmZgAdepw/x8UpJ0YquJ8DDTIkxDNUCtBWLRokdobDKAOU0KqpKJN9Ypf44qxEL6+XItGZezuoEGehGiGWgmCn5+fpuMghGhZSfMx2NpyTfXaatkoSUAAQ0gIN8gzLIyLmQZ5EvLx1EoQCCHVX1VtqlcM8vT15VoLGjQA0tK45IAGeRJSdmV63DMhpPop2lRfVFVoqq9MgzwJqS4oQSCEAKj68zEoBnk2aMB1hVDLASEfp1QJgoeHB5YsWYKbN29qKh5CiJbQfAyEkKJKNQZh48aNOHnyJL755huIRCJ4e3vD29sbLVq00FR8hFRLlXVaYEVTfYsWgETCNdVXltgIqY4q67kAKGWC0KZNG7Rp0wYzZszAzZs3cebMGXz77bcQCoXo168fBg4ciIYNG2oqVkKqhZLmGqgIHzohVYb5GAjRBZV93pEyjUFIT0/HzZs3kZCQgIyMDNjZ2SEnJweDBw/G9u3byztGQqqND00LLJdrdv+leWaBXF61ZlQkpCqpClOElypB2L17NwIDA9GrVy9cvHgRfn5+iI6Oxtq1axESEoI1a9Zgw4YNmoqVkCqvpLkGMjOB1681t+/SnJByc7l19PAjQjTjQ+eCyjBFeKm6GM6dOwc/Pz9s3rwZdRRtkEXY2Njgxx9/LK/YCKl2FHMNmJlxv86LNvM3bMglCBIJ94u9vPsiSzoh2dgAU6YAVlZcfMnJQMeOQHh45ZpRsWj3iK2tAPb2dCMWqZqqwrwjpUoQbGxsMGTIEJXl3377LVatWgUzMzP069ev3IIjpKJpesCQnR3w/Dl3UsjJ+bffcepU7lc7Y0CtWtwv9vLuiyzuhPT8OaCvD+zZw80jkJLCLQ8PV05kfHyAixcrfkZFxd/k/Hng6FHg7VtFvQlQu7YDIiKArl01s88PHQeVeYAZqdzenSJccSzFx3PfSSsrbUeoRoKQkpKCgwcPAgCOHTuGevXqKa0Xi8W4XMp2x7Nnz2L16tWQSCTo1KkTQkNDoa+vX6ptEFLeNDZgqMhVxNukGUSiUWjdGggPF6BpU+42wnbtGDp1AvbtE2jsF/v7nlmQmgp4eXGtBfv2ccu//ho4fBh49gxo1065PvT1uQt1uSQI/9SL+GYiDsbZIVFmjWafGiDg/5xhYmkCiMWIWRSNAes8kZlrBD09oGNHAR9nUpIAw4eL4OdXvq0a6h4HlXGAmThVjIOz4pH4QIZm9qJ/65JUOoMHA8HB3LwjU6cCEyZwx5KFBSAQAKGhgOMnuej8dL/2MlCmhiVLlrCQkBDWunVrFhISovQvNDSUXbp0SZ3NMMYYS09PZ+7u7iw5OZnJ5XI2ffp0tmvXLrU/zxhjb9++ZXFxcez169el+lx1IpVKWVxcHJNKpdoORSvKu/xv3jBmbs6YhwdjSUncsidPGOvalVv+5k0ZN3zpErcBoZCxBg3YDsEYJhTI+X0wxtiOHdzqossU+xcIGNu5899lhobcP8ZKXwcpKYzp6cmZu7ucPXnChVajBmOC98QjEDBWt65qfXTuzFitWh9RHwr/1MsluDNzURYTCmSsiWUBEwpkzFwvi8V8d4S9MWvKzEWZzMNdypYuLamO5HwdtWrF/SsrdY8DjR0vpVT0GLi08S9mrqeoS8m/dbn5ZsUE8yFv3nAH15w53EFdDpVU1c+DMTGMmZkxJhIx5u7+zrHURc7M9bLYG0Etxpo04b4A5ubch4ooSx0orqFv374t8X1qJQgK4eHhpXn7ex09epR9/fXX/OurV6+yzz//vFTboASh6n8xPlZ5l780F2m1Fb2K3LnDmLk5m9EwjFlaypXeNmcO9/1/n8aNGZs799/XH5Mg7FiZzQSQsbp1uTLp63NJgKWlatgiEWNCobx866PoDszN2ZtOvZi5Xhbz6CJVPjG6S5m5KJNtaL6Cj6HkOpLzdfSxCYK6x4FGjpcyUBwD2c+zi69LvSz2JqWCMpbiFE2US7jYlVZ1OA9u2PCB5HfZy38XvCcD1WSCoNYYhE2bNmHSpElIT0/HmjVr3vueqVOnqtVikZ6eDgsLC/61hYUFUlNT1frsu+RyOWQyWZk+W9Upyk3lL5/yP3woQKNGAjRtKlBazg0YYnj4kEEmY6XapmD/fgiysiAICwPOngWyspDRtBHSkpSb+Ut+XDGDjU2RfUsU5RaVug4e7TqPxpaf4c4DAzRpwo2BcHYGoqOV921iAhgbAzVrFjeAqmz18W69HGwyDVlXayMsXKg8aDJcBFvbOjhpPRGNCrgulw890tnGRs7Fk/HqnzoxL1Ns6h4HmjheykLxtz84+wayZF2LqUtTHJh1EaO2u2s8nvcRhIZCsHYt0L499134pw+N/dOHJn/0qMzN5tXhPPj8uQAWFsUdS0Bijvm/C8LCwGxtwQ4cABs1CkDZ6kDd96qVICgu4GlpaWoHUBz5e270FgrLNhL54cOHHxtOlZeQkKDtELSqvMqvp2eOFy+si70A6ek9xY0br0q1TavYWFhYWUHQtCk/QrC+JBl6esqPJu7UievbHzqUGwfAP674CzlMTeWwt0/AjRvc98YN3H2QN27U5vejbh00yrqOF+k+yMwE2rYFHj4EPv+cG1Pw7qOS9fW5JyKWZ328Wy+JyTXQyEKGpk2Vv//W1kCjBlKghjGfFBTtry0a5/DhDKamMr6O/KUX/qkfjzLFpu5xoInj5WPc/utNiXV560YObty4UWHxFOWwbRv08/L+TQ7+CUzwz8Xu2cqVeOXr+1H7qMrnQT09c6SlFXcsCZQfkmZtDWZlhbTYWCQ7OSltRyN1oHabRDk5evQomzp1Kv/6jz/+YAEBAaXahqJ5JDs7m0mlUp38V1BQwOLi4lhBQYHWY6kO5c/OljJzcznr2pXrn2dM0aInZ+bmcpadXfptyrZtY3JF2+E/bdI7XDbyzfxCIdeFIBBw/fpcsz7XZC4QyJl5rXx24UKRbWZnM7meHpOLREy2fTsrePWqVHWQM2w8Mxdlsq5d5Xyf/p07jNWuzXVbFI3HwEDO9PS4Fk2l+ugsZeY1c8tUH+/Wy46A35hQICu2aXXjjy+Zufm/McTEsH/qTc4sLLg6qlOnkEVHS/hty1u1YvJWrTR+HGjiePmY78HWL6NLrMvto85r7bsqr1ePyRs2fO+5XN64MZPNnv3R5a/K58Fij6XOUmZeV6Y8VOPJEyYXCJhs+/aPqoPXr1+X/xiEZ8+esTlz5jDGGDt//jxzcXFhnp6eLCEhQe1tZGRkMHd3d/b8+XMml8tZcHAw27hxY2nCoDEIrHr0vX0MTZQ/JubfblLFhfKjukkVYxC6dmXs9m2u392lOzMXZbLOnbiBd3PnMrZ0KWOdO8uZmRljG398yeY22c121vxKud9Y0YcLMKanx5hQyOTm5uzujh3q10FKCosRdWXmhq+ZQCBn+vrcfn/5hRsoJRAwVrOmnAFyZibMYpsXvXynPuTMXJTJYmafKGOFKNfLG1dPZq6Xxbq6S5VPjP+MQXjT2YvF/JLCzM3lTCiQs8YWBQyQs5qiXDbS9Ajbvl3GLlz4U7n8HzsIgal/HJT78VIGiu+BYgzCe+tS22MQGjbU2ICN6nIeVD2WuAGKMY6T3snQK3YMQqkShNGjR7N58+YxuVzOvLy82Pbt29mBAwdKPcjw7NmzrH///szLy4vNmDGDFRQUlOrzlCBUny9GWWmq/G/ecOeruXPLaaB10W9+/fqMiUQsBm7MXJTJhAIZa2xR8O+Ft57v+68yRQc7fvIJdwF88oTJu3ZlhXXqMGl2tvrxbN7M3ohM2U4EsZFG+1gtkZgJBTJmZSllgJzVEOSy2eMz2Buzpox17cre3E7i6uPrLLbzk//jlpfHEP1/6iUGnfm7GBpbSP49Mc44ypVZIGBv9OqwnQhic2uuZDsFo9kbYW3GbGzefwyUQ4LAmPrHQbkfL6VUtA5iNt/k72JQqktt38XQsiVjBgbvaY76+Fs+qtN5UOVYOhOrVgaqyQRBwBhTeyRN586dcenSJTx+/Bh+fn74448/YGRkBGdnZ8THx5d//0cxcnNzcffuXdjb26NWrVoVtt/KRCaT4caNG3BycoJIJNJ2OBWuSpVfLOZmF0pM5Gc/Ed96gkNn6iAx1xJ2TQsRMKAQJuJUbjTeu/c679zJzXn8+DHQty+37PZtbqCXrS3Ytm0QjhmjfjypqcDs2cCDBxDbtMGh9kuQ+MoUdjeOICB+Nkye3+PmVPb15W7MtrLiOtaNjYHTp8vvJv9/6kV8MxGH4myRKLOGXcsi8yCkpgL29oCjo/KUjq1aAQUFkL16hRsPHyofA61b/1s/OuDd74E4VYxDs7l5EOw+qSTzILRuzc0C9uaN8vFkZvbRk0ZUqfNAWRQ9d7zv3ICy1YHiGvrpp5/C2Ni42PeVaiZFfX19ZGZm4vfff0f79u1hZGSE+/fvv3faZULIP0xMVGYWMgGg9lxDJczJyqysSj8nq6Ull3S8G8fObOC3B9yoQMVznw8d4qZ2W7cOWLasfGcA+qdeiq2L337jpk1UJAfAv0O7HzyA4PBh4J2BWrrOxNIEQTvLeVrJ8mBsDCQkfPBiR97xnnNHRSpVgjBy5Eh4e3sjPz8fmzZtws2bNzF27Fi1b3EkhJRB0Xv8ikpKgiA5GUxpmPNHeN+tAj17cg+GMDfnpnasSMUlRvr6gJ4et54ShKpDyxc7UnqlShBGjx6NXr16wcjICA0aNEBmZiZ27NgBBwcHTcVHCCl64S4s5C6Q/9xHLjM1hWDQoPLZj4kJ1+Tr68slJe82BVf0r73iJj8oLASkUqC8EiNCyHuVegICQ0NDPH36FNeuXcOjR4+Qn5+Pa9euaSI2Qgjw74X7zh3gwQPg/n3A1ha4cwcPV6wo3wu3omth+3Zg1Chgxw7utTYeLjB4MFC3LpcYJSVxyxQTDYhEYOWVGBHNEYu5cQfp6VxLVNFnipNKr1QtCFu2bMGaNWtQt25d6On9+1GBQIDo6Ojyjo0QoqC4cLdowT0PeulSyP398VYTk4VVlqbg4lo0hEKgSRPqv67sij7NysJCM48oJRpVqgQhPDwcW7ZsQdfyfrYqIeTDTEwAxYDgoCCgCk8vq7aigyUVg9uWLuWSBFJ5icVcctC6NTeeRVOPKCUaVapvWWFhIdzc3DQVCyGEqFK0aCxcyP2XkoPK7+BBruXgnemVERYGZGZyCR+p9Er1Tfviiy+wfPlyvHr1CnK5XOkfIYQQAqDEW3O5JxCV8tZcohWl6mLYv38/Xr58iT179vDLGGMQCAS4e/duuQdHCCGkCvrQ4zfpDpQqoVQJwoEDBzQVByGEkOqiuMdvjhjB3TYbEKDtCIkaStXF0KhRI9StWxc3b97E6dOnYWZmhszMTDRq1EhT8RFCCKlqit6aa2fH3XXyz625WplTg5RJqVoQbt++jQkTJqBp06a4e/cuevXqhS+//BLz58/HwIEDNRQiIYSQKud9d6DQ9MpVSqkShB9++AHz589H79690aFDBzRp0gTbt2/HrFmzKEEghBCirLLMqUHKpFRdDImJifD09ATATY4EAO3atUNmZmb5R0YIIYQQrSlVgtC8eXOcOHFCaVlkZCSaN29erkERQgghRLtK1cUwd+5cjBs3DuHh4cjNzcWYMWNw9+5dbN68WVPxEUIIIUQLSpUgtG7dGqdPn8b58+eRkpKCevXqYcWKFaijmP6VEEIIIdVCqRKEMWPGYMeOHejXr5/S8iFDhtAcCYQQQkg18sEE4cWLF1izZg0A4OrVqwgODlZaLxaL8eLFC81ERwghhBCt+GCC0KhRI7Rt2xbZ2dkAgKbvzK1tYGCAqVOnaiQ4QgghhGiHWl0Mw4cPBwC0adMG3bt312Q8hBBCCKkESjUGoV27dti6dSuSkpJUnuC4ePHicg2MEEIIIdpTqgThu+++Q0pKCrp16wY9vVJ9lBBCCCFVSKmu8n/++SfOnTsHU1NTTcVDCCGEkEqgVDMpWlpaIj8/X1OxEEIIIaSSKFULQp8+fRAUFISBAwfCzMxMad2gQYPKNTBCCCGEaE+pEoQ//vgD5ubmuHjxotJygUBQqgTh7NmzWL16NSQSCTp16oTQ0FDo6+uXJhRCCCGEaFCpEoSwsLCP3mFGRgYWLFiAQ4cOwdLSEjNmzEB4eDhGjRr10dsmhBBCSPlQK0GIjY394Hvc3NzU2mFMTAzatWuHhg0bAgAGDx6MpUuXUoJACCGEVCJqJQhz5swpcb1AIMC5c+fU2mF6ejosLCz41xYWFkhNTVXrs++Sy+WQyWRl+mxVpyg3lV+3yq8YVSyXyXS+Dt5X/qL1owt09RhQ0PXyA2WrA3Xfq1aCEBkZqfaOP+TdCZYAQCgs1c0UvIcPH35sOFVeQkKCtkPQKl0rf6t/7iK6c+MGv0xn6+Cfchct//vqRxfo2jHwLl0vP6CZOqjw2Y4sLS1x7949/nV6ejosLS3LtK3mzZvDxMSkvEKrUmQyGRISEuDg4ACRSKTtcCqcrpZfaGQEAHByctL5OnBwcFApf9H60QW6egwo6Hr5gbLVQW5uLu7fv//B91V4gtClSxcsX74cL168gJWVFQ4fPowePXqUaVtCoVBnDwoFkUik03Wgq+UvWmZdr4P3lV/X6kNXjwEFXS8/ULo6UPd9FZ4g1KtXD99//z0mTpwIiUQCR0dHjBkzpqLDIIQQQkgJtPJABU9PT3h6empj14QQQghRQ9lGBxJCCCGkWqMEgRBCCCEqKEEghBBCiApKEAghhBCighIEQkjVIRYDWVlAejoEu3dDmJur7YgIqbYoQSCEVA0xMYCNDZCWBujrQzB+PBx8fYHLl7UdGSHVEiUIhJDKTywGBgwAWrcGHj8GkpMhSEyEqE0bCP38uPWEkHJFCQIhpPI7eJDrWggLA5o25ZZZW0Pw009AZiZw6JB24yOkGqIEgRBS+SUmAo0a/ZscKFhbc8sTE7UTFyHVGCUIhJDKz84OePECePpUeXlSErfczk47cRFSjVGCQAip/AYPBurWBYYP55ICAEhKAhs+HDAzAwICtBsfIdWQVp7FQAghpWJiAkREAL6+XGuBlRXYixeQmZpCEBEBkY4+9p0QTaIEgZCqQjEHQGEhsGsX4O+v7YgqVufOwJMn3IDExEQwGxsk2NujbefO2o6MkGqJuhgIqQremQMAY8dC2KwZav71l7Yjq1gmJkBQELBwIdioUZAbG2s7IkKqLUoQCKns3jMHABITgVat0Hz6dJoDgBCiEZQgEFLZFTcHQFgYRDk5EBw+rN34CCHVEiUIhFR2JcwBwKysaA4AQohGUIJASGVXwhwAguRkmgOAEKIRlCAQUtkVNwfAiBGQmZqCDRqk3fgIIdUSJQiEVHaKOQDu3OFaC5o0AWxtgTt38HDFCm49IYSUM5oHgZCq4J05AGBnB7m/P94+fKjtyAgh1RQlCIRUFYo5ABRkMu3FQgip9qiLgRBCCCEqKEEghBBCiApKEAghhBCighIEQgghhKjQWoIgkUgwatQoREVFaSsEQkh1onjaZXo697RLekYFIR9FKwnC7du3MXToUMTHx2tj94SQ6uY9T7uEjQ1w+bK2IyOkytJKgrBv3z5MmTIFbdu21cbuCSHVSQlPu4SvL7UkEFJGWpkHYdGiRQCA7du3f9R25HI5ZDp6L7ii3FR+3Sw/QHWgKDc7cAAsKwuCd552ibAwMFtbbv2oUdoLVIPoGNDt8gNlqwN131ulJ0p6SLPIISEhQdshaJWulx+gOsi4ehUWVlYQFPO0y7TYWCQ7OWkltoqi68eArpcf0EwdVOkEoXnz5jDR0XnoZTIZEhIS4ODgAJFIpO1wKpyulx+gOlCUv76rKwS7d3NPuyyaJPzztEsLNzc0qKYJAh0Dul1+oGx1kJubi/v373/wfVU6QRAKhTp7UCiIRCKdrgNdLz9AdSAYMgSC2bO5p12GhXHdC0lJwIgREJiZQTBkCFDN60fXjwFdLz9QujpQ9300DwIhpGor4WmXiIigp10SUkZabUEICwvT5u4JIdXFe552iYAASg4I+QhVuouBEEJ47z7tkhDyUapkgiCXywEA+fn5OtvvpLhNJTc3VyfrQNfLD1Ad6Hr5AaoDXS8/ULY6yMvLA/DvtbQ4AsYY+7jwKt6rV6/w5MkTbYdBCCGEVFk2NjYwNzcvdn2VTBCkUilycnJgaGgIoZDGWRJCCCHqksvlKCgogKmpKfT0iu9IqJIJAiGEEEI0i35+E0IIIUQFJQiEEEIIUUEJAiGEEEJUUIJACCGEEBWUIBBCCCFEBSUIhBBCCFFBCQIhhBBCVFCCQAghhBAVlCAQQgghREWVe1jT2bNnsXr1akgkEnTq1AmhoaHQ19fXdlgatXv3bhw6dAhCoRDW1tZYuHAhbty4gZCQEFhaWgIAateuXa0fnz1lyhT8/fffMDIyAgD4+fmhX79+CA4ORlpaGoyMjLB8+XLY2dlpOVLN+O2337Blyxb+dWZmJoRCIbZt24bAwEA0adKEX3fgwAG+nqoDiUSC8ePHY+TIkejRowcyMjKK/bvv378fe/bsgVQqhY+PD6ZMmaLl6D/eu+W/ffs2Fi5ciLy8PAiFQnz33Xdwd3cHALi5uaFBgwb8Z0NDQ+Hi4qKt0MvNu3UQFRVV7Plv3bp1+N///geZTIagoCAMGzZMm6GXi6Lld3Nzw5AhQ/h1crkc9+/fx+7du+Hm5gZ/f39IJBL+wU0TJkyAt7d32XbMqpD09HTm7u7OkpOTmVwuZ9OnT2e7du3Sdlgade3aNdavXz8mFosZY4wtX76czZkzh61cuZLt3LlTy9FVHA8PD5aZmam0bPLkyWzPnj2MMcYuXbrEfH19tRFahROLxaxv374sNjaWHThwgC1cuFDbIWnMrVu3mL+/P2vbti2LjIxkjBX/d79z5w7z9PRkOTk5rKCggA0fPpydPn1aa7GXh/eV39PTk8XGxjLGGPv7779Zx44dWV5eHnv8+DHr37+/NsPViPfVQXHnvzNnzrDBgwezgoIC9vr1a9a3b192+/btig65XL2v/EWtXLmShYSEMMYYy83NZZ06dWIymaxc9l2luhhiYmLQrl07NGzYEAKBAIMHD8aJEye0HZZG1a1bF/PmzUPNmjUBAK1atcKLFy8QHx+PCxcuwM/PD0FBQbh//76WI9Wc5ORk5ObmYubMmfDx8cGiRYsgFotx8eJF+Pv7AwDc3d3x5s0bPHz4UMvRat769evRuXNndOrUCfHx8bh37x78/f0RGBiIuLg4bYdXrvbt24cpU6agbdu2AIDCwsJi/+6RkZHo3bs3ateuDQMDA/j7+1f588O75ZdIJJgwYQI6deoEAGjWrBn/8LobN25ALpdj+PDhGDBgAPbt26fN0MvNu3UAoNjzX2RkJHx8fGBgYIBatWrB29u72h0DRd27dw/Hjx/HnDlzAAC3bt2CkZERRo8eDR8fH6xfv/6Dj3QuSZVKENLT02FhYcG/trCwQGpqqhYj0rxmzZqhY8eOAACxWIyNGzeid+/eqFOnDoKCgnD06FEMHToUEydORH5+vpaj1YyXL1/Czc0NS5YswS+//IL09HQsWbIEBgYGMDEx4d+nC8dDWloajh49iq+++goAYGxsDD8/Pxw5cgQzZ87E119/jYyMDC1HWX4WLVqEbt268a+zs7OL/bunpaWpnB/S0tIqNN7y9m75DQwMEBAQwL/esGEDmjVrBgsLCxQWFsLDwwO7du3Ctm3bsHfvXkRHR2sh6vL1bh0AKPb8l5aWxnc7ANXzGChq9erVmDRpEv99EIvF6NSpEzZt2oSff/4Zly9fxs8//1zmfVepBOF9mZCuPO45LS0NX375JZycnDB06FCsXbsWHh4eAAAvLy/UrFkTd+7c0XKUmtG2bVusXbsWZmZmMDAwwPjx43Ht2rX3vre6Hw8HDhyAr68v6tSpA4DrY/78888BAM7OznB0dMSVK1e0GKFmFfdrSCgUgr3nwbQCgUDTIWkFYwwrVqxAREQEVq9eDQAICAjAzJkzoa+vjwYNGmDIkCE4d+6cdgPVkOLOf7p0DDx9+hQJCQkYOHAgv6xHjx5YvHgxatSoARMTE4waNeqjjoEqdTa1tLRU+nWUnp6ulC1WV/fu3cPgwYPh6emJhQsXQiwWKw1YUyjpud5VWVxcHKKiovjXjDHo6elBIpEgNzeXX/5uC1N19Pvvv2PAgAEAuHrYvHmzUh0A1fc4AABzc/Ni/+66cn6QSCSYMmUKrl27hgMHDsDKygoAEBERodTVqPieVDdv3rwp9vxnaWmJ9PR0ftm7LQrVyalTp9C3b1+lQfrR0dFK3YwfewxUqQShS5cuiIuLw4sXL8AYw+HDh9GjRw9th6VR6enpCAoKQnBwMP7zn/8AAGrWrIl9+/bxF81Lly4hLy8Pn376qTZD1Zj8/HwsWrQIb968gVwux549e9C7d294eHjg0KFDAIDY2Fjo6elV27sYAK55PT09Ha1atQLA/TKKjo7GkSNHAHCJ5M2bN+Hm5qbNMDVKT0+v2L97z549cebMGWRnZ6OwsBBHjx6tlueHWbNmgTGGvXv3wtzcnF/+6NEjbNiwAXK5HK9fv8Yvv/wCLy8vLUaqGSWd/zw9PREREYGCggKIxWL8/vvv6N69u3YD1pDr16/z3c8K6enpWL58OSQSCSQSCcLDw9G7d+8y76NKpZf16tXD999/j4kTJ0IikcDR0RFjxozRdlgatXXrVuTm5mLr1q3YunUrAMDW1hbr16/HwoULsXz5chgbG2P9+vXV9nbPLl26IDAwEEOGDIFUKkWHDh0wefJkZGdnY/bs2Th06BAMDAywatWqatucCHBNipaWlkplXLp0KebOnYsDBw4AAFasWMF3P1RX8+bNe+/f/dNPP8WYMWPwxRdfQCqVomfPnvDx8dF2uOXq9u3bOHHiBGxtbZXGIqxatQqTJk3CggUL4OPjA6lUiqFDh1bLZFEoFBZ7/vP09MTdu3fh7+8PqVSKwYMHV4vbPN/n2bNnaNiwodKyQYMGITExEQMHDoRUKoWXlxcGDRpU5n0I2Ps6bQghhBCi06pUFwMhhBBCKgYlCIQQQghRQQkCIYQQQlRQgkAIIYQQFZQgEEIIIUQFJQiEEEIIUUEJAiFEo/r06YOCggJth0EIKSVKEAghGnP37l3Y2trC0NBQ26EQQkqJJkoihJTK8+fPMWzYMAwZMgR79uyBoaEhfvjhB0RFReHEiRNo2LAhVq1aBXt7e2zatAmmpqYwMTHB/Pnz+W0UFhbCxMSkWj9YipCqjloQCCGllpaWhry8PMTGxiIgIAD/+c9/0KZNG1y5cgWtWrXiH6Zz/vx5dO/eHb6+voiPj0d8fDyio6NhZWWF7777TsulIISUhBIEQkiZjBo1CiKRCB06dIChoSEGDx4MAwMDuLq6IjU1FVlZWcjLy+OfNghwj2uePn06OnXq9FFzxBNCNK9KPayJEFJ5mJqaAuAenlOrVi1+uVAohFwux8WLF9GlSxelz6xcuRKvX7/Gxo0bKzRWQkjpUYJACCmTDz058/z58wgMDORfnzx5EkePHsWRI0dgYGCg6fAIIR+JuhgIIeVOLpfj5s2bcHZ2BgDcu3cP8+bNw6pVq2BhYaHl6Agh6qAWBEJIubtx4wb69u0LPT3uFLNnzx7k5eXh66+/hkQi4d/3v//9T2mMAiGk8qDbHAkhhBCigroYCCGEEKKCEgRCCCGEqKAEgRBCCCEqKEEghBBCiApKEAghhBCighIEQgghhKigBIEQQgghKihBIIQQQogKShAIIYQQooISBEIIIYSooASBEEIIISooQSCEEEKIiv8HXMn1c+WRHQwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063024 MassSpecGymID0062602\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063024 MassSpecGymID0062603\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063024 MassSpecGymID0062604\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063024 MassSpecGymID0062605\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAggAAADmCAYAAACwLX24AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABDr0lEQVR4nO3deVxUVf/A8c8AgiKKggmaCy6PmoqKGyLuuCQuKbmgae5LPaWVaWZuZf70MXfNfefR3Moyn8pUxBVNSpNcUkNxBxRFkWVg5vz+mJgYEQVkHGC+79fLV829M/d+z+HOvd8559xzNUophRBCCCFEOjaWDkAIIYQQeY8kCEIIIYTIQBIEIYQQQmQgCYIQQgghMpAEQQghhBAZSIIghBBCiAwkQRBCCCFEBpIgCCGEECIDSRCEEEIIkYEkCFbu+vXrVK9eHX9//wzrjh49SvXq1Vm0aJFZ9h0fH8/kyZPx9fXFy8uLDh06sGrVKrPsK72jR48yePBgvL298fLyokuXLgQFBeXqPtLqNTU1FYA2bdpQp04dvLy8qFevHk2bNmXChAnExsYaPxMbG8uwYcPw8vKiXbt2hISEZGldcnIykydPxtvbG29vb/7zn/+QNkHq9evXGTx4MA0aNKB58+YsWbLE+LmkpCTGjBlDw4YNadGiBdu3bzfZ3/vvv4+3tze+vr58/vnnaLVakzIqpejfvz/z5s3LUp3079+f6tWr8/vvv2fYTqtWrWjTpk2WtpMTO3bsoHPnznh5edGkSRPGjBlDVFSU2fYHcOfOHaZMmULr1q3x8vKiWbNmTJgwgTt37uTqfvr378+2bdsAWLRoEbVq1cLLy8v4r2/fvhw7dszkMytWrKBp06Y0bNiQzz//HJ1Ol6V1P/zwA+3bt8fLy4v+/ftz7do147oNGzbQpk0bGjRoQP/+/bl06ZJxXWhoKF26dMHLy4uAgAD++OMP47oDBw7QoUMH6tWrx7Bhw7h7965x3WeffYanp6exLA0bNsy9ihPPpoRVu3btmqpWrZpq3LixOn/+vMm6jz/+WNWrV08tXLjQLPseN26ceu+999S9e/eUUkqdO3dOtW7dWv33v/81y/6UUur7779XDRo0UFu3blVJSUlKq9WqU6dOqQ4dOqiVK1fm2n7S6jUlJUUppVTr1q3VkSNHjOtv376tRo4cqQICApROp1NKKfX222+rSZMmqeTkZHXw4EFVv359dfv27Weu++yzz9SQIUPUw4cPVXR0tOrYsaPasWOHUkqpwMBANW/ePJWamqpu3LihfH191cGDB5VSSk2fPl2NGDFCPXr0SJ0+fVo1btxY/fHHH0oppUaPHq3GjRunEhISVExMjOrZs6davHixSRnXrl2ratSooebOnZulOunXr59q3LixmjFjhsnyEydOqHr16qnWrVtnp4qzLDQ0VPn6+qo//vhD6fV6FRcXp8aPH68CAgLMsj+llLp7965q0aKFGjt2rPHvdOvWLTVp0iTVuXNn4988N/Tr109t3bpVKaXUwoUL1ZgxY4zrkpKS1FdffaXq1KmjTp8+rZRSas+ePapNmzbq2rVr6s6dO6p79+5q7dq1z1z3+++/q8aNG6vff/9dpaamqpkzZ6o333xTKaVUSEiIatGihfrrr79Uamqq+vLLL1Xbtm2VUkrduHFDNWjQQIWEhCidTqc2bNig/Pz8lFJKRUdHKy8vL3X06FGVlJSkJk6cqEaOHGmMPzAwUIWEhORaXYnskRYEAUC7du348ccfja+1Wi1HjhzB19fXuOzu3buMGjWKVq1aUadOHfr372/8FXbmzBkCAgJo2LAhnTt35rvvvjNuZ9y4cXh7e9OyZUs+/vhjkpOTAQgPD6dNmzaUKFECgBo1ajB+/HhsbAyH5aJFixgzZgyBgYF4eXkxdOhQk19f69atw8/PDx8fHyZMmMCjR48A0Ov1zJ8/H19fX7y9vZkwYQJarZaUlBQ+//xzJkyYQM+ePXFwcKBQoULUrVuXL774gmLFigGGX/s///yzcT+7d++md+/eAFSvXp3NmzfTrFkzvL29+frrr1m4cCGNGzemTZs2HD9+PEv17ebmxpw5c7hy5QohISE8evSI/fv38+6772Jvb0/z5s1p1KgRu3fvfuo6rVbLN998w5QpU3BycuKll15i5cqVNG3a1FhH77zzDra2tjx48AClFMWLFwdg165djBw5EkdHRzw9PencuTM7d+40xvj2229TpEgRSpUqRZcuXTh58qRx3eXLl9m6dSvt2rXLUnnTtGvXjt27dxtbONLiaNu2rcn7Vq5cib+/P15eXrRp04YffvgBePrx9N1339G2bVsaN25Mnz59jL9Sw8PDqVatGrVq1UKj0VC8eHHGjh1LtWrV0Gq1XL9+HW9vb+bMmUP9+vVp164d+/fvN8Zy5swZAgMDadiwIT179jT59RsaGsprr72Gl5cXPXr04Ny5cwAsWbKEChUqMGvWLNzc3ABwd3dn6tSptG7dmri4OBYtWsTIkSON20pJScHb25uIiAjGjx/PnDlzCAgIoF69erzzzjscP36cjh07Ur9+fWbOnJml+nZwcCAwMJDOnTuzYsUKY3337t2bcuXK4erqyogRI4zf16et27ZtG3379qVOnTrY2toyatQoJkyYAEBMTAzDhw+ncuXK2Nra8uabb3L16lXu3LnDzp07adOmDS1btsTGxoa+ffsyf/589Ho9e/bswcvLCx8fHxwcHPjggw84cOAAcXFxKKX4888/qVGjRpbKKnKfJAgCgE6dOvHTTz8ZXx88eJCGDRtSuHBh47IvvviC4sWL8/PPP3P06FHAcAECmD59Oj169CAsLIwpU6bw2WefkZiYyHfffcetW7c4cOAAu3bt4s8//zQmIu3bt2fatGn83//9H/v37ycuLo727dvTp08f4z5/+ukn3nrrLY4dO0aJEiWYNGkSAN9//z0bN25kzZo17Nu3j6SkJGbNmgXApk2b+Pnnn9myZQv79u3j2rVrrFq1ipMnT/Lo0SM6d+6cofyenp7GJKBTp07s3r3buO6HH34w6YIJCwsjODiYsWPHMmnSJPR6PUeOHKFz585Zbm4HcHR0pH79+vz6669ERkbi6OjISy+9ZFxfqVIlIiIinrnOzs6Ow4cP4+fnR6tWrdi5cyelS5cGDBcIOzs7unfvzmuvvUaLFi2oW7cucXFx3L17l8qVK2fYJsD8+fOpWLGicd3+/fupVq0aADqdjo8//phJkybh6OiY5fIC1K1bFxsbG06dOgVAamoqBw4coH379sb3HD9+nP/+97+sXr2a3377jSFDhjBt2jSATI+nxMREJk6cyLJlyzh+/DjNmzfniy++AKBly5b8+uuvjBw5km3btnH58mVcXFyYMWMG9vb2ANy/f587d+4QGhrKxx9/zPvvv09UVBQPHz5k6NChBAYGcuzYMYYOHcrIkSOJj48nJiaGt99+m5EjRxIWFka3bt0YPXo0AMHBwXTv3j1D+W1sbPjggw8oWbIknTp14siRI8THxwOGrq8yZcoY/yY7duxg3rx5BAcHc+LECf7zn/+wceNGvvrqK4KCgrhy5UqW693X15dff/0VgIiIiEz/7k9bd/bsWRwcHOjbty9NmjThgw8+MCb3PXr04I033jB+Ljg4GFdXV1xdXTl79iyurq4MHz4cb29vBg0aRJEiRbCxscmwv5IlS1KsWDEiIyO5evUqWq2WKVOm0KRJE3r37m08bsSLIQmCAKBBgwY8evSI8+fPA4aLYpcuXUzeM2bMGMaPH49Silu3blGiRAnjL/qiRYsSHBzM4cOHqVu3LidOnKBIkSIULVqUiIgIvv/+exITE9m+fTvdunUD4L333mPq1KlcuXKFDz74AB8fH4YPH87NmzeN+2zRogUtW7bEwcGB0aNHc/DgQRITE/n2228ZNGgQFStWxNHRkdGjR/Ptt9+ilOLHH39kwIABlCtXDicnJ7744gu6dOlCTEwMJUqUMF4UAPr27UvDhg1p0KABnp6egCFB2L9/P1qtloSEBA4ePEjHjh2Nn+nfvz/29vY0btwYnU7HgAEDKFSoED4+Pty+fTtb9V68eHHi4uJISEgwScYAChcuTFJS0lPXxcXF8ejRI8LCwvjuu+9Yt24d27dv59tvvzV5/+bNm9m9eze//PILGzduJDEx0bidx7f5uBkzZnDlyhWGDh0KwOrVq6lWrRo+Pj7ZKmsaf39/Y5IYGhqKp6cnRYsWNa6vU6cOW7duxd3dnaioKBwcHIiNjUWn02V6PNnZ2WFvb8+WLVv4448/GDFiBOvXrwegWrVqfPPNN7i5ubF06VJeffVV2rZta5IEAnz00Uc4ODjQpk0batWqRUhICAcOHKBcuXLGfXTo0IHy5ctz8OBBDhw4QPXq1enYsSO2trb06dOHWbNmodfriYmJMbYcgCFpbdiwIQ0bNqRu3bp8++23VK5cmapVqxpbKx5PRP38/KhYsSIuLi5UqVKFzp074+LiQvXq1XnppZe4detWluvc2dmZuLg4ABITE03+7kWKFCEpKQml1FPXPXjwgM2bNzN58mRCQkIoVaoUY8eOzbCvX3/9lalTpzJx4kQ0Gg0PHjxg69atDBs2jEOHDuHt7c3bb79NamoqiYmJFClSxOTzRYoUITExkbi4OBo1asS///1vDh48yOuvv86IESNMxu0I85IEQQCGXzavvvoqP/74IwkJCZw8edKkewHg1q1bDBo0iFatWvH5558TExNjbCqeMWMGpUuX5qOPPsLb25svvviC1NRU/P39GTFiBBs3bqRly5b079+fyMhI4zb9/f1ZsWIFYWFhbNq0ieTkZN577z3j+vLlyxv/383NjdTUVO7fv8+tW7f44osvjCfd119/Hb1ez927d7lz547Jydnd3Z3y5cvj4uLC/fv3SUlJMa7btGkTYWFhfPPNN8ZBeDVq1MDd3Z1Dhw4REhJC7dq1jb/IwXCyTaszwNg1YWNjg16vz1a9379/n5IlS1KkSBFjU3mapKQkHB0dn7rO3t4enU7He++9h5OTEx4eHvTu3Zvg4GCT9zs4OODh4cEbb7zB/v37jReB9NtN22YarVbLmDFjCAkJYf369bi4uHDx4kW+/vprxo0bl61ypufv72/sZvjf//6XoUVHo9Ewf/58mjRpwsiRI42tVUqpTI+nQoUKsXbtWq5du8abb75Jq1at2LFjh3GbVapU4dNPPyU4OJj9+/cTEBDA+++/bxxIV7x4ceOvYTAca3fu3OHWrVucO3fOeJw1bNiQc+fOcevWLe7evWtyXNja2lKvXj1sbGxwdXUlJibGuK5v376EhYURFhZGzZo1jcdJWl1otVqCg4NNEoT08dja2hqPMzAca+m7aZ7l3r17lCxZEsiYCCYmJuLo6IhGo3nqOnt7e7p3706NGjUoXLgwo0eP5vjx48YWEDC0+A0bNoyJEycay2Jvb4+fnx+NGjXC3t6et956i+joaCIiIowJSHpp+6xTpw5r167F09MTe3t7evXqRenSpY0tIcL8JEEQRp06deLHH38kODiY5s2bU6hQIZP1Y8eOpXv37oSGhrJ+/XrjL26lFBcvXmTKlCkcPnyYdevWsXPnTvbv38/ly5dp3rw53377LQcPHqR06dLMnDmT27dvU7duXeOvoLST6/jx47lw4YJxn+lPsjdv3qRQoUK4uLhQqlQpPvvsM+NJ9+jRo+zcuRNXV1fc3NyIjo42fu706dNs3ryZ+vXrU6RIEWN/9rPqYt++fezZs4dOnTqZrNNoNNmv3CeIj4/n5MmTNGrUiIoVK/Lo0SOTX0eXL1+mUqVKz1xnY2NjcpLW6/UopdDpdHTq1InLly8b12m1WuPF0MXFxWRd2jYBEhISGDJkCLdv32bz5s3GRG3v3r1ER0fTqlUrGjZsyK5du1izZg0jRozIcrlfeeUVHB0dOXbsGMePH6dVq1Ym69etW8f169fZv38/3377LcOGDTOJ8UnHU3x8PFqt1tjFMG7cOCZMmMC9e/cYPnw4S5cuNW6jbNmyvP322/zrX//i4sWLxr9FWqsKGI41Nzc3XnrpJRo3bmw8zsLCwvj+++8JDAzMcJwppfjPf/7DgwcPaNWqlbHv/mnSuhkOHjxI5cqVKVeuXJbrMTsOHz5Mo0aNAKhcubJJ90T6v/vT1nl4eJgcZzqdzuS7sGHDBiZNmsSiRYsICAgwLn/8c2nHplKKSpUqmewvNjaWBw8e4OHhwbFjx9i6datJObRarUkLoDAvSRCEUb169UhNTWXJkiUZuhcAHjx4YPyF+dtvv7Fz505SU1PRaDRMnz6dtWvXopQy/qpydnYmODiYcePGERsbS4kSJXBwcKBEiRK4u7vj6enJ5MmTjS0KUVFRrFq1itatWxv3uW/fPn777TeSkpJYuHAh7du3x8HBgS5durBmzRpu3rxJSkoK8+bN49133wUMJ90NGzZw+/Zt4uPjmTdvHrGxsTg4ODBlyhQ+//xztm3bxqNHj9Dr9Zw8eZKJEydSqlQp4347d+7MoUOHOHHiBB06dMj1ur558yYffvghNWrUoFmzZjg5OdGiRQvmzp1LcnIyhw4d4pdffqF9+/ZPXefs7Ezr1q1ZsmQJ8fHxREZGsnnzZmOzd9WqVVm4cCHJyclcvHiRTZs2Gbt4OnXqxOLFi4mPj+ePP/5g165dxmRo/Pjx2NnZsXbtWuMvT4C33nqLkydPGi+WnTt3ZvDgwSxfvjxb5ff392fatGk0adIkwwn/wYMHxrETsbGxLFiwADCMV8jseEpLaI4dO4a9vT0uLi4ULlwYBwcHOnTowPr16wkJCSE1NZWEhAS+//57bt++bbxo6vV6Fi5cSEpKCnv27OHixYvGgXVnz55l79696PV6fv31V7p27cpff/1FixYtuHTpEnv27EGv17NlyxaCg4MpVqwYo0aNIjIykvHjxxtvBYyKimLevHmEh4fj4uICGJKVGjVqsGDBgifeavy8kpKS2LhxIz///LMxievUqRObNm0iMjKSu3fvsnz5cuP3/Wnrunfvzvfff8/58+fRarXMnz/feOzu37+f+fPnExQUlKHlsWvXrhw9epTQ0FBSU1NZvHgx5cqVo1q1arRt25Zff/2VgwcPkpyczLx582jZsiXFihXD1taWmTNn8vvvv5Oamsq6detISkrC29s71+tJPJmdpQMQeYu/vz+7du164v3GU6dOZebMmUybNg0PDw969uzJgQMHAJg9ezZTp05lxYoVODo6MmDAABo3bky9evW4fPkyHTt2JCUlhcaNGzN9+nQAvvzySxYsWMCAAQO4f/8+Tk5OvPrqq7z//vvGfdatW5fZs2fz559/Gu/HB8OgqHv37tGvXz/i4uKoXbs2ixYtQqPR0KNHD6KjowkMDCQxMRF/f3+GDx8OGE6A7u7urFq1ijlz5pCcnIy7uzvt27dn4cKFxv1WrFiRl156CRcXF5ML5PMYOXIktra2gGEwVps2bXjvvfeMXRXTp09n0qRJ+Pr64uLiwty5c41dJU9bN2vWLKZPn06HDh2McxOkXWymTp3Kp59+SvPmzXF2dmb06NG0aNECgA8++IBp06bh5+dH4cKFGTduHJ6enly/fp3du3fj4OBgcjL28vJizZo1Ty3jsmXLCAsLe+Z8Fv7+/ixevJiJEydmWDdw4EA++OADvL29cXZ2pmfPnpw8eZK//vqL/v37P/F4cnV1ZcaMGUyZMoXo6Gjc3d2ZP38+jo6OvP7662g0GhYuXMgHH3yAUop69eqxevVqSpUqxfXr1wHDL+JmzZrx0ksvsWTJEuNFfNmyZcyYMYOPPvqIkiVLMmnSJOrUqQPA0qVLmTFjBuPHj6datWp8+eWXaDQaXFxc2LFjB0uXLmXQoEHcvXuXIkWK0KhRIzZu3EjdunWN5e3UqRPTp083GefyPH788Uf27dsHGLoTatasyZo1a4x3A7Rv356rV6/y5ptvkpiYSNeuXRkwYMAz17Vt25a4uDhGjx5NTEwMDRs2ZMaMGQCsWbOGpKQkkwHGADt37qR27dosWLCAGTNmcO3aNV555RUWL16MRqPBzc2N+fPnM3PmTG7evEmDBg2Mg40bNWrExx9/zJgxY7hz5w6vvPIKy5cvzzAeR5iPRmWnI0uIF2jRokVERkYye/Zsi+z/nXfeoW3btsZf3OLZUlNTGTduHHPnzrV0KFl2/fp1/Pz8OHPmDHZ2L/430759+9iwYYNxUKUQeYV0MQjxmKioKA4ePMhvv/1mcvudeLa9e/c+8fY+kVFCQgJ//vknq1evNumzFyKvkC4GIR7z3XffsXz58hzd52/tXn31VUuHkG/ExsYSGBiIj4/PE+fmEMLSpItBCCGEEBlIF4MQQgghMpAEQQghhBAZSIIghBBCiAzy5SDF1NRU4uLicHBwMN5DLoQQQohn0+v1JCcn4+zs/NRbe/NlghAXF5etJ5kJIYQQwpSHhweurq6Zrs+XCYKDgwMAFSpUMHkKnDXR6XRcuHCBatWqGWfnsybWXn6QOrD28oPUgbWXH3JWB4mJiVy5csV4Lc1MvkwQ0roVChcubLX3qet0OgAcHR2t8oth7eUHqQNrLz9IHVh7+eH56uBZXfQW68DXarUMHDjQ+Cx0IcTTxcfDmjUwcSKsXWt4LYQQ5mKRBOHMmTP06dOHkydPWmL3QuQ7R46AhwcMGwYbNsDQoVClig2//26dXWxCCPOzSIKwadMmRo0aZXwimhAic/Hx8NprUKsWXL4MV69CRATUrAljxlSVlgQhhFlYZAxC2uN+n/VI2GfR6/XG/hdrk1ZuKX/BL//mzRru3dMQFKShQgXDsooVIShIQ6VKtmzdqmPw4IJfD4+zpmMgM9ZeB9ZefshZHWT1vflykGKaS5cuWToEiwsPD7d0CBZlDeUPDS1L2bJuVKigMVlesSKULas4fjyG+vVvWig6y7OGY+BZrL0OrL38YJ46yNcJQtWqVXFycrJ0GBah0+kIDw/H09PTKkfvWlP5fXw0rFun4epVjC0IAJGRcPOmBm/vl6hXr7TlArQQazoGMmPtdWDt5Yec1UFCQgIXLlx45vvydYJgY2NjtQdFGltbW6uuA2sof2AgjB8P/fpBUJCh5SAyEvr3Vzg76+jVS1Pg6+BprOEYeBZrrwNrLz9krw6y+j6Zp1iIPM7JCXbuhLNnoXJlKFMGKlUyvJ4z5xJW2ogmhDAzi7YgBAUFWXL3QuQbTZvClStQvTpotbB6NQQE6Ll06ZGlQxNCFFD5uotBCGvi5AQlShj+f9AgsOKB20KIF0C6GIQQQgiRgSQIQgghhMhAEgQhhBBCZCAJghBCCCEykARBCCGEEBlIgiCEEEKIDCRBEEIIIUQGkiAIIYQQIgNJEIQQQgiRgSQIQgghhMhAEgQhhBBCZCAJghBCCCEykARBCCGEEBlIgiCEEEKIDCRBECKfiI+H+/chOhrWrjW8FkIIc5EEQYh84MgR8PCAmzcNScLQoVClig2//17U0qEJIQooSRCEyOPi4+G116BWLfjXv6BaNYiIgJo1YcyYqtKSIIQwC0kQhMjjtm6Fe/cgKAgKFTIsq1gRgoI0xMXZsn27xrIBCiEKJEkQhMjjIiLg5ZehQgXT5RUrQtmyiogIy8QlhCjYJEEQIo+rXBlu3ICrV02XR0bCzZsaKle2TFxCiIJNEgQh8rhevaBkSejXD1JSDMsiI6F/f4Wzs44ePZRlAxRCFEh2lg5ACPF0Tk6wcyd07Qp374KdHVSqBC4uMGfOJZyc/mXpEIUQBZC0IAiRDzRtCleuGJIDpWD1avjrLz116z6ydGhCiAJKWhCEyCecnMDW1vD/gwaBTmfZeIQQBZu0IAghhBAiA4skCHv37qVz5860b9+eyZMnk5I28koIIYQQecILTxBiYmKYOnUqK1euZPfu3SQkJLBx48YXHYYQQgghnuKFJwhHjhyhfv36lClTBo1GQ69evdi1a9eLDkMIIYQQT/HCBylGR0fj5uZmfO3m5sbt27dztC29Xo/OSkdqpZVbym9t5Tfk9Dqd3orrwMDayw9SB9ZefshZHWT1vS88QdDr9RmW2djkrCHj0qVLzxtOvhceHm7pECzK2sqv13sBcOrUKeMya6uDx1l7+UHqwNrLD+apgxeeILi7u3P+/Hnj6+joaNzd3XO0rapVq+Lk5JRboeUrOp2O8PBwPD09sU27982KWGv5bWwMD2aqV6+e1dZBGmsvP0gdWHv5IWd1kJCQwIULF575viwlCKGhoVnaaRofH59M1zVr1ozZs2dz48YNypYty/bt22ndunW2tp/GxsbGag+KNLa2tlZdB9Za/vRlttY6SGPt5QepA2svP2SvDrL6viwlCIMHD6Zs2bIo9ew536Oiojhz5kym60uVKsWnn37KyJEj0Wq11K1blyFDhmQpWCGEEEK8GFlKEAoXLsy+ffuytEEvL69nvsfPzw8/P78sbU8IIYQQL16WRgdu2LAhyxvMznuFEEIIkTdlqQXB09PT5HVsbCzLly/n8uXLlCtXjmHDhlGmTJknvlcIIYQQ+U+O7i+cMGECZcqUYcCAAbi7u/POO+/kdlxCCCGEsKAsJQhz5swhPj7e+Do6OpquXbvi6+tLly5duHnzptkCFEIIIcSLl6UuhldeeYVBgwbRrVs3AgMDeeutt+jatSu2trYkJSXx0UcfmTtOIQq8+HjYuhUiIqBKFejZ0/CIZyGEsIQsJQj+/v60bduW//73v/Tt25dhw4Zx4MAB7t27R8mSJa3+/lMhnteRI/Daa3DvHrz8Mty4AWPHws6d0LSppaMTQlijLI9BsLe3Z/DgwaxYsYJffvmFoUOHcuvWLUkOhHhO8fGG5KBWLbh8Ga5eNbQi1KwJXbsa1gshxIuWpQQhNDSUnj17EhgYyF9//cWECROMj2weM2YMN27cMHecQhRYW7caWg6CgqBCBcOyihUNr2NjYds2y8YnhLBOWUoQPvnkE9555x2GDx/OJ598AkDFihVZuHAhffv2Zfz48WYNUoiCLCLC0K2QlhykqVjRsDwiwjJxCSGsW5bGICQkJFCuXDmUUiQmJpqsa9CgAUFBQWYJTghrULmyYczB1aumSUJkpGF55cqWiy0/kUGeQuSuLLUgjBs3jjfeeINBgwYxbtw4c8ckhFXp1QtKloR+/QxJARj+278/uLgYLnTi6Y4cAQ8PGDYMNmyAoUMNr48etXRkQuRfWUoQmjdvzrFjxzh06BD+/v5PfW9MTEyuBCaEtXByMtytcPasobWgTBmoVMnweudO+RX8LDLIUwjzyFKC0KFDhyxvMDvvFUIYNG0KV66AuzukpsLq1YbXlrjFMT4e1qyBiRNh7dq8f4Hdtk0jgzyFMIMsjUFISkrijTfeeOb7lFIkJyc/d1BCWCMnJyhRwvD/gwZZJob8OB+DDPIUwjyylCBMnz49yxvsKR2mQuRL6Zvq036Np42F6NrV0KKRF7s7ZJCnEOaRpQShe/fu5o5DCGFhT5uPoVIlQ1O9pVo2nqZnT8X48YZBnkFBhphlkKcQzy9LCYIQouDLr031aYM8u3Y1tBaULg1RUYbkQAZ5CpFzOXrcsxCi4EnfVJ9efmiqz0uDPIUoKCRBEEIA+X8+hrRBnqVLG7pCpOVAiOeTrQShRYsWzJw5k9OnT5srHiGEhch8DEKI9LI1BmHJkiX8+OOPvPfee9ja2uLv74+/vz/Vq1c3V3xCFEh5dVrgtKb66tVBqzU01eeV2IQoiPLquQCymSDUrl2b2rVrM3bsWE6fPs2ePXt4//33sbGxoVOnTnTr1o0yZcqYK1YhCoSnzTXwIjzrhJQX5mMQwhrk9XlHcjQGITo6mtOnTxMeHk5MTAyVK1cmLi6OXr16sWrVqtyOUYgC41nTAuv15t1/dp5ZoNfnrxkVhchP8sMU4dlKENatW0dgYCBt27bl0KFDdO/enZCQEBYuXMj48eNZsGABX375pbliFSLfe9pcA7Gx8OCB+fadnRNSQoJhnTz8SAjzeNa5IC9MEZ6tLoZ9+/bRvXt3li1bRom0Nsh0PDw8+Pzzz3MrNiEKnLS5BlxcDL/O0zfzlyljSBC0WsMv9tzui3zaCcnDA0aNgrJlDfHdvAmNG8PGjXlrRsX03SOVKmmoVk1uxBL5U36YdyRbCYKHhwe9e/fOsPz9999n3rx5uLi40KlTp1wLTogXzdwDhipXhuvXDSeFuLh/+h1Hjzb8alcKihUz/GLP7b7IzE5I169DoUKwfr1hHoFbtwzLN240TWS6dIFDh178jIppf5MDB2DHDnj0KK3eNBQv7snOndC8uXn2+azjIC8PMBN52+NThKcdSydPGr6TZctaOsIsJAi3bt1i69atAHz77beUKlXKZH18fDxHs9nuuHfvXubPn49Wq6VJkyZMmjSJQoUKZWsbQuQ2sw0YSncV8Xeqgq3tQGrVgo0bNVSoYLiNsH59RZMmsGmTxmy/2J/0zILbt6F9e0NrwaZNhuXvvgvbt8O1a1C/vml9FCpkuFDnSoLwd73En45ga1hlInQVqfKKPT3/zwsndyeIj+fI9BBeW+RHbEJh7OygcWONMc7ISA39+tnSvXvutmpk9TjIiwPM4m/Hs/Xjk0Rc1FGlmu0/dSnynF69YNw4w7wjo0fDiBGGY8nNDTQamDQJ6v4rgaZXN1suA1VZMHPmTDV+/HhVq1YtNX78eJN/kyZNUocPH87KZpRSSkVHRytfX1918+ZNpdfr1ZgxY9TatWuz/HmllHr06JEKCwtTDx48yNbnCpLU1FQVFhamUlNTLR2KReR2+R8+VMrVVakWLZSKjDQsu3JFqebNDcsfPszhhg8fNmzAxkap0qXVas0QZaPRG/ehlFKrVxtWp1+Wtn+NRqk1a/5Z5uBg+KdU9uvg1i2l7Oz0ytdXr65cMYRWpIhSmifEo9EoVbJkxvpo2lSpYsWeoz7S/F0vh/FVrrb3lI1Gp8q7JysbjU652t1TRz78Rj10qaBcbWNVC99UNWvW0+pIb6yjmjUN/3Iqq8eB2Y6XbEp/DBxe8rtytUurS+0/dbns9IsJ5lkePjQcXJ98Yjioc6GS8vt58MgRpVxclLK1VcrX97FjqZleudrdUw81xZQqX97wBXB1NXwonZzUQdo19NGjR099X5YShDQbN27MztufaMeOHerdd981vj5+/Lh6/fXXs7UNSRDy/xfjeeV2+bNzkc6y9FeRs2eVcnVVY8sEKXd3vcnbPvnE8P1/knLllJo48Z/Xz5MgrJ57X2nQqZIlDWUqVMiQBLi7Zwzb1lYpGxt97tZH+h24uqqHTdoqV7t7qkWzVNMTo2+qcrWNVV9WnWOM4el1pDfW0fMmCFk9DsxyvORA2jFw//r9zOvS7p56eOsFZSyZSZ8oP+Vil10F4Tz45ZfPSH6/uPPPgidkoOZMELI0BmHp0qW89dZbREdHs2DBgie+Z/To0VlqsYiOjsbNzc342s3Njdu3b2fps4/T6/XodLocfTa/Syu3lD93yn/pkoaXX9ZQoYLGZLlhwJDi0iWFTqeytU3N5s1o7t1DExQEe/fCvXvEVHiZqEjTZv6nP65Y4eGRbt/atHLbZrsO/lp7gHLur3L2oj3lyxvGQHh5QUiI6b6dnMDREYoWzWwAVc7q4/F62Vr+A+4dL07QRhvTQZMbbalUqQQ/VhzJy8mGLpdnPdLZw0NviCfm7t914pqj2LJ6HJjjeMmJtL/91gmnuKdrnkldOrPl40MMXOVr9nieRDNpEpqFC6FBA8N34e8+NPV3H5r+r79y3GxeEM6D169rcHPL7FiCiDjXfxYEBaEqVUJt2YIaOBDIWR1k9b1ZShDSLuBRUVFZDiAz+ifc6G1jk7ORyJcuXXrecPK98PBwS4dgUblVfjs7V27cqJjpBcjO7iqnTt3N1jbLhobiVrYsmgoVjCMEX9LexM7O9NHETZoY+vb79DGMAzA+rvgNPc7OeqpVC+fUKcP3xgfDfZCnThU37ierdfDyvV+5Ed2F2FioUwcuXYLXXzeMKXj8UcmFChmeiJib9fF4vUTcLMLLbjoqVDD9/lesCC+XToUijsakIH1/bfo4+/VTODvrjHUUkHrw7/ppkaPYsnocmON4eR5nfn/41Lr841Qcp06demHxpOe5ciWFEhP/SQ7+Dkzz98Xu2ty53O3a9bn2kZ/Pg3Z2rkRFZXYsaUwfklaxIqpsWaJCQ7lZr57JdsxSB1luk8glO3bsUKNHjza+/uWXX1TPnj2ztY205pH79++r1NRUq/yXnJyswsLCVHJyssVjKQjlv38/Vbm66lXz5ob+eaXSWvT0ytVVr+7fz/42dStXKn1a2+HfbdKrGy4xNvPb2Bi6EDQaQ7++oVnf0GSu0eiVa7EkdfBgum3ev6/0dnZKb2urdKtWqeS7d7NVB3F9hytX21jVvLne2Kd/9qxSxYsbui3Sx2Nvr1d2doYWTZP6aJqqXIsm5Kg+Hq+X1T1/UDYaXaZNq0s+v6NcXf+J4cgR9Xe96ZWbm6GOSpRIUSEhWuO29TVrKn3NmmY/DsxxvDzP92DFmyFPrctVAw9Y7LuqL1VK6cuUeeK5XF+unNJNmPDc5c/P58FMj6Wmqcq1pM50qMaVK0qv0SjdqlXPVQcPHjzI/TEI165dU5988olSSqkDBw6ohg0bKj8/PxUeHp7lbcTExChfX191/fp1pdfr1bhx49SSJUuyE4aMQVAFo+/teZij/EeO/NNNmnahfK5u0rQxCM2bK3XmjKHfvWEr5Wobq5o2MQy8mzhRqVmzlGraVK9cXJRa8vkdNbH8OrWm6Dum/cZpfbiglJ2dUjY2Su/qqs6tXp31Orh1Sx2xba5cHR4ojUavChUy7Pfrrw0DpTQapYoW1SvQKxebe2rZ9DuP1YdeudrGqiMTduWwQkzr5aG3n3K1u6ea+6aanhj/HoPwsGl7deTrW8rVVa9sNHpVzi1ZgV4VtU1QA5y/UatW6dTBg7+Zlv95ByGorB8HuX685EDa9yBtDMIT69LSYxDKlDHbgI2Cch7MeCwZBigeqfvWYxn6ix2DkK0EYfDgwWry5MlKr9er9u3bq1WrVqktW7Zke5Dh3r17VefOnVX79u3V2LFjVXJycrY+LwlCwfli5JS5yv/woeF8NXFiLg20Tv/Nf+klpWxt1RF8lKttrLLR6FQ5t+R/Lryluj75KpN+sOO//mW4AF65ovTNm6uUEiVU6v37WY9n2TL10NZZrWGQGlB4kypmG69sNDpV1j1VgV4V0SSoCcNj1EOXCko1b64enok01Me799Saf/2fYXluDNH/u16O0NR4F0M5N+0/J8axOwxl1mjUQ7sSag2D1MSic9UazWD10Ka4Uh4eTz4GciFBUCrrx0GuHy/ZlL4Ojiw7bbyLwaQuLX0XQ40aStnbP6E56vlv+ShI58EMx9Ke0CxloOZMEDRKqSyPpGnatCmHDx/m8uXLdO/enV9++YXChQvj5eXFyZMnc7//IxMJCQmcO3eOatWqUaxYsRe237xEp9Nx6tQp6tWrh62traXDeeHyVfnj4w2zC0VEGGc/if/jCtv2lCAiwZ3KFVLo+VoKTvG3DaPxHr/Xec0aw5zHly9Dx46GZWfOGAZ6VaqEWrkSmyFDsh7P7dswYQJcvEi8R222NZhJxF1nKp/6hp4nJ+B0/bxhTuWuXQ03Zpcta+hYd3SEn3/OvZv8/66X+NMRbAurRISuIpVrpJsH4fZtqFYN6tY1ndKxZk1ITkZ39y6nLl0yPQZq1fqnfqzA49+D+NvxbJtgmAeh8r/yyDwItWoZZgF7+ND0eHJxee5JI/LVeSAn0p87nnRuIGd1kHYNfeWVV3B0dMz0fdmaSbFQoULExsby008/0aBBAwoXLsyFCxeeOO2yEOJvTk4ZZhZyArI819BT5mRVZctmf05Wd3dD0vF4HGvuww8XDaMC0577vG2bYWq3RYvgiy9ydwagv+sl07r44QfDtIlpyQH8M7T74kU027fDYwO1rJ2TuxOD1uTytJK5wdERwsOfebETj3nCueNFylaCMGDAAPz9/UlKSmLp0qWcPn2aoUOHZvkWRyFEDqS/xy+9yEg0N2+iTIY5P4cn3SrQpo3hwRCuroapHV+kzBKjQoXAzs6wXhKE/MPCFzuRfdlKEAYPHkzbtm0pXLgwpUuXJjY2ltWrV+Pp6Wmu+IQQ6S/cKSmGC+Tf95HrnJ3R9OiRO/txcjI0+XbtakhKHm8KftG/9jKb/CAlBVJTIbcSIyHEE2V7AgIHBweuXr3KiRMn+Ouvv0hKSuLEiRPmiE0IAf9cuM+ehYsX4cIFqFQJzp7l0pw5uXvhTutaWLUKBg6E1asNry3xcIFevaBkSUNiFBlpWJY20YCtLSq3EiNhPvHxhnEH0dGGlqj0zxQXeV62WhCWL1/OggULKFmyJHZ2/3xUo9EQEhKS27EJIdKkXbirVzc8D3rWLPQBATwyx2RheaUpOLMWDRsbKF9e+q/zuvRPs3JzM88jSoVZZStB2LhxI8uXL6d5bj9bVQjxbE5OkDYgeNAgyMfTy2ZZ+sGSaYPbZs0yJAki74qPNyQHtWoZxrOY6xGlwqyy9S1LSUnBx8fHXLEIIURGaS0a06YZ/ivJQd63dauh5eCx6ZUJCoLYWEPCJ/K8bH3T3njjDWbPns3du3fR6/Um/4QQQgjgqbfmGp5AlM1bc4VFZKuLYfPmzdy5c4f169cblyml0Gg0nDt3LteDE0IIkQ896/GbcgdKvpCtBGHLli3mikMIIURBkdnjN/v3N9w227OnpSMUWZCtLoaXX36ZkiVLcvr0aX7++WdcXFyIjY3l5ZdfNld8Qggh8pv0t+ZWrmy46+TvW3MtMqeGyJFstSCcOXOGESNGUKFCBc6dO0fbtm158803mTJlCt26dTNTiEIIIfKdJ92BItMr5yvZShA+++wzpkyZQrt27WjUqBHly5dn1apVfPzxx5IgCCGEMJVX5tQQOZKtLoaIiAj8/PwAw+RIAPXr1yc2Njb3IxNCCCGExWQrQahatSq7du0yWRYcHEzVqlVzNSghhBBCWFa2uhgmTpzIsGHD2LhxIwkJCQwZMoRz586xbNkyc8UnhBBCCAvIVoJQq1Ytfv75Zw4cOMCtW7coVaoUc+bMoUTa9K9CCCGEKBCylSAMGTKE1atX06lTJ5PlvXv3ljkShBBCiALkmQnCjRs3WLBgAQDHjx9n3LhxJuvj4+O5ceOGeaITQgghhEU8M0F4+eWXqVOnDvfv3wegwmNza9vb2zN69GizBCeEEEIIy8hSF0O/fv0AqF27Nq1atTJnPEIIIYTIA7I1BqF+/fqsWLGCyMjIDE9wnDFjRq4GJoQQQgjLyVaC8OGHH3Lr1i1atmyJnV22PiqEEEKIfCRbV/nffvuNffv24ezsbK54hBBCCJEHZGsmRXd3d5KSkswVixBCCCHyiGy1IHTo0IFBgwbRrVs3XFxcTNb16NEjVwMTQgghhOVkK0H45ZdfcHV15dChQybLNRpNthKEvXv3Mn/+fLRaLU2aNGHSpEkUKlQoO6EIIYQQwoyylSAEBQU99w5jYmKYOnUq27Ztw93dnbFjx7Jx40YGDhz43NsWQgghRO7IUoIQGhr6zPf4+PhkaYdHjhyhfv36lClTBoBevXoxa9YsSRCEEEKIPCRLCcInn3zy1PUajYZ9+/ZlaYfR0dG4ubkZX7u5uXH79u0sffZxer0enU6Xo8/md2nllvJbV/nTRhXrdTqrr4MnlT99/VgDaz0G0lh7+SFndZDV92YpQQgODs7yjp/l8QmWAGxssnUzhdGlS5eeN5x8Lzw83NIhWJS1lb/m33cRnT11yrjMauvg73KnL/+T6scaWNsx8DhrLz+Ypw5e+GxH7u7unD9/3vg6Ojoad3f3HG2ratWqODk55VZo+YpOpyM8PBxPT09sbW0tHc4LZ63ltylcGIB69epZfR14enpmKH/6+rEG1noMpLH28kPO6iAhIYELFy48830vPEFo1qwZs2fP5saNG5QtW5bt27fTunXrHG3LxsbGag+KNLa2tlZdB9Za/vRltvY6eFL5ra0+rPUYSGPt5Yfs1UFW3/fCE4RSpUrx6aefMnLkSLRaLXXr1mXIkCEvOgwhhBBCPIVFHqjg5+eHn5+fJXYthBBCiCzI2ehAIYQQQhRokiAIIYQQIgNJEIQQQgiRgSQIQgghhMhAEgQhRP4RHw/37kF0NJp167BJSLB0REIUWJIgCCHyhyNHwMMDoqKgUCE0w4fj2bUrHD1q6ciEKJAkQRBC5H3x8fDaa1CrFly+DDdvoomIwLZ2bWy6dzesF0LkKkkQhBB539athq6FoCCoUMGwrGJFNP/9L8TGwrZtlo1PiAJIEgQhRN4XEQEvv/xPcpCmYkXD8ogIy8QlRAEmCYIQIu+rXBlu3ICrV02XR0YalleubJm4hCjAJEEQQuR9vXpByZLQr58hKQCIjET16wcuLtCzp2XjE6IAssizGIQQIlucnGDnTuja1dBaULYs6sYNdM7OaHbuxNZKH/suhDlJgiBEfpE2B0BKCqxdCwEBlo7oxWraFK5cMQxIjIhAeXgQXq0adZo2tXRkQhRI0sUgRH7w2BwADB2KTZUqFP39d0tH9mI5OcGgQTBtGmrgQPSOjpaOSIgCSxIEIfK6J8wBQEQE1KxJ1TFjZA4AIYRZSIIgRF6X2RwAQUHYxsWh2b7dsvEJIQokSRCEyOueMgeAKltW5gAQQpiFJAhC5HVPmQNAc/OmzAEghDALSRCEyOsymwOgf390zs6oHj0sG58QokCSBEGIvC5tDoCzZw2tBeXLQ6VKcPYsl+bMMawXQohcJvMgCJEfPDYHAJUrow8I4NGlS5aOTAhRQEmCIER+kTYHQBqdznKxCCEKPOliEEIIIUQGkiAIIYQQIgNJEIQQQgiRgSQIQgghhMjAYgmCVqtl4MCB7N+/31IhCCEKkrSnXUZHG552Kc+oEOK5WCRBOHPmDH369OHkyZOW2L0QoqB5wtMu8fCAo0ctHZkQ+ZZFEoRNmzYxatQo6tSpY4ndCyEKkqc87ZKuXaUlQYgcssg8CNOnTwdg1apVz7UdvV6PzkrvBU8rt5TfOssPUgdp5VZbtqDu3UPz2NMuCQpCVapkWD9woOUCNSM5Bqy7/JCzOsjqe/P1REmXZBY5wsPDLR2CRVl7+UHqIOb4cdzKlkWTydMuo0JDuVmvnkVie1Gs/Riw9vKDeeogXycIVatWxclK56HX6XSEh4fj6emJra2tpcN54ay9/CB1kFb+l7y90axbZ3jaZfok4e+nXbr5+FC6gCYIcgxYd/khZ3WQkJDAhQsXnvm+fJ0g2NjYWO1BkcbW1taq68Dayw9SB5revdFMmGB42mVQkKF7ITIS+vdH4+KCpndvKOD1Y+3HgLWXH7JXB1l9n8yDIITI357ytEt27pSnXQqRQxZtQQgKCrLk7oUQBcUTnnZJz56SHAjxHPJ1F4MQQhg9/rRLIcRzyZcJgl6vByApKclq+53SblNJSEiwyjqw9vKD1IG1lx+kDqy9/JCzOkhMTAT+uZZmRqOUUs8X3ot39+5drly5YukwhBBCiHzLw8MDV1fXTNfnywQhNTWVuLg4HBwcsLGRcZZCCCFEVun1epKTk3F2dsbOLvOOhHyZIAghhBDCvOTntxBCCCEykARBCCGEEBlIgiCEEEKIDCRBEEIIIUQGkiAIIYQQIgNJEIQQQgiRgSQIQgghhMhAEgQhhBBCZCAJghBCCCEyyHcPa9q7dy/z589Hq9XSpEkTJk2aRKFChSwdllmtW7eObdu2YWNjQ8WKFZk2bRqnTp1i/PjxuLu7A1C8ePEC/fjsUaNG8eeff1K4cGEAunfvTqdOnRg3bhxRUVEULlyY2bNnU7lyZQtHah4//PADy5cvN76OjY3FxsaGlStXEhgYSPny5Y3rtmzZYqyngkCr1TJ8+HAGDBhA69atiYmJyfTvvnnzZtavX09qaipdunRh1KhRFo7++T1e/jNnzjBt2jQSExOxsbHhww8/xNfXFwAfHx9Kly5t/OykSZNo2LChpULPNY/Xwf79+zM9/y1atIj//e9/6HQ6Bg0aRN++fS0Zeq5IX34fHx969+5tXKfX67lw4QLr1q3Dx8eHgIAAtFqt8cFNI0aMwN/fP2c7VvlIdHS08vX1VTdv3lR6vV6NGTNGrV271tJhmdWJEydUp06dVHx8vFJKqdmzZ6tPPvlEzZ07V61Zs8bC0b04LVq0ULGxsSbL3n77bbV+/XqllFKHDx9WXbt2tURoL1x8fLzq2LGjCg0NVVu2bFHTpk2zdEhm88cff6iAgABVp04dFRwcrJTK/O9+9uxZ5efnp+Li4lRycrLq16+f+vnnny0We254Uvn9/PxUaGioUkqpP//8UzVu3FglJiaqy5cvq86dO1syXLN4Uh1kdv7bs2eP6tWrl0pOTlYPHjxQHTt2VGfOnHnRIeeqJ5U/vblz56rx48crpZRKSEhQTZo0UTqdLlf2na+6GI4cOUL9+vUpU6YMGo2GXr16sWvXLkuHZVYlS5Zk8uTJFC1aFICaNWty48YNTp48ycGDB+nevTuDBg3iwoULFo7UfG7evElCQgIfffQRXbp0Yfr06cTHx3Po0CECAgIA8PX15eHDh1y6dMnC0Zrf4sWLadq0KU2aNOHkyZOcP3+egIAAAgMDCQsLs3R4uWrTpk2MGjWKOnXqAJCSkpLp3z04OJh27dpRvHhx7O3tCQgIyPfnh8fLr9VqGTFiBE2aNAGgSpUqxofXnTp1Cr1eT79+/XjttdfYtGmTJUPPNY/XAZDp+S84OJguXbpgb29PsWLF8Pf3L3DHQHrnz5/n+++/55NPPgHgjz/+oHDhwgwePJguXbqwePHiZz7S+WnyVYIQHR2Nm5ub8bWbmxu3b9+2YETmV6VKFRo3bgxAfHw8S5YsoV27dpQoUYJBgwaxY8cO+vTpw8iRI0lKSrJwtOZx584dfHx8mDlzJl9//TXR0dHMnDkTe3t7nJycjO+zhuMhKiqKHTt28M477wDg6OhI9+7d+eabb/joo4949913iYmJsXCUuWf69Om0bNnS+Pr+/fuZ/t2joqIynB+ioqJeaLy57fHy29vb07NnT+PrL7/8kipVquDm5kZKSgotWrRg7dq1rFy5kg0bNhASEmKBqHPX43UAZHr+i4qKMnY7QME8BtKbP38+b731lvH7EB8fT5MmTVi6dClfffUVR48e5auvvsrxvvNVgvCkTMhaHvccFRXFm2++Sb169ejTpw8LFy6kRYsWALRv356iRYty9uxZC0dpHnXq1GHhwoW4uLhgb2/P8OHDOXHixBPfW9CPhy1bttC1a1dKlCgBGPqYX3/9dQC8vLyoW7cux44ds2CE5pXZryEbGxvUEx5Mq9FozB2SRSilmDNnDjt37mT+/PkA9OzZk48++ohChQpRunRpevfuzb59+ywbqJlkdv6zpmPg6tWrhIeH061bN+Oy1q1bM2PGDIoUKYKTkxMDBw58rmMgX51N3d3dTX4dRUdHm2SLBdX58+fp1asXfn5+TJs2jfj4eJMBa2me9lzv/CwsLIz9+/cbXyulsLOzQ6vVkpCQYFz+eAtTQfTTTz/x2muvAYZ6WLZsmUkdQME9DgBcXV0z/btby/lBq9UyatQoTpw4wZYtWyhbtiwAO3fuNOlqTPueFDQPHz7M9Pzn7u5OdHS0cdnjLQoFye7du+nYsaPJIP2QkBCTbsbnPQbyVYLQrFkzwsLCuHHjBkoptm/fTuvWrS0dlllFR0czaNAgxo0bx7///W8AihYtyqZNm4wXzcOHD5OYmMgrr7xiyVDNJikpienTp/Pw4UP0ej3r16+nXbt2tGjRgm3btgEQGhqKnZ1dgb2LAQzN69HR0dSsWRMw/DIKCQnhm2++AQyJ5OnTp/Hx8bFkmGZlZ2eX6d+9TZs27Nmzh/v375OSksKOHTsK5Pnh448/RinFhg0bcHV1NS7/66+/+PLLL9Hr9Tx48ICvv/6a9u3bWzBS83ja+c/Pz4+dO3eSnJxMfHw8P/30E61atbJswGby66+/Gruf00RHRzN79my0Wi1arZaNGzfSrl27HO8jX6WXpUqV4tNPP2XkyJFotVrq1q3LkCFDLB2WWa1YsYKEhARWrFjBihUrAKhUqRKLFy9m2rRpzJ49G0dHRxYvXlxgb/ds1qwZgYGB9O7dm9TUVBo1asTbb7/N/fv3mTBhAtu2bcPe3p558+YV2OZEMDQpuru7m5Rx1qxZTJw4kS1btgAwZ84cY/dDQTV58uQn/t1feeUVhgwZwhtvvEFqaipt2rShS5culg43V505c4Zdu3ZRqVIlk7EI8+bN46233mLq1Kl06dKF1NRU+vTpUyCTRRsbm0zPf35+fpw7d46AgABSU1Pp1atXgbjN80muXbtGmTJlTJb16NGDiIgIunXrRmpqKu3bt6dHjx453odGPanTRgghhBBWLV91MQghhBDixZAEQQghhBAZSIIghBBCiAwkQRBCCCFEBpIgCCGEECIDSRCEEEIIkYEkCEIIs+rQoQPJycmWDkMIkU2SIAghzObcuXNUqlQJBwcHS4cihMgmmShJCJEt169fp2/fvvTu3Zv169fj4ODAZ599xv79+9m1axdlypRh3rx5VKtWjaVLl+Ls7IyTkxNTpkwxbiMlJQUnJ6cC/WApIfI7aUEQQmRbVFQUiYmJhIaG0rNnT/79739Tu3Ztjh07Rs2aNY0P0zlw4ACtWrWia9eunDx5kpMnTxISEkLZsmX58MMPLVwKIcTTSIIghMiRgQMHYmtrS6NGjXBwcKBXr17Y29vj7e3N7du3uXfvHomJicanDYLhcc1jxoyhSZMmzzVHvBDC/PLVw5qEEHmHs7MzYHh4TrFixYzLbWxs0Ov1HDp0iGbNmpl8Zu7cuTx48IAlS5a80FiFENknCYIQIkee9eTMAwcOEBgYaHz9448/smPHDr755hvs7e3NHZ4Q4jlJF4MQItfp9XpOnz6Nl5cXAOfPn2fy5MnMmzcPNzc3C0cnhMgKaUEQQuS6U6dO0bFjR+zsDKeY9evXk5iYyLvvvotWqzW+73//+5/JGAUhRN4htzkKIYQQIgPpYhBCCCFEBpIgCCGEECIDSRCEEEIIkYEkCEIIIYTIQBIEIYQQQmQgCYIQQgghMpAEQQghhBAZSIIghBBCiAwkQRBCCCFEBpIgCCGEECIDSRCEEEIIkYEkCEIIIYTI4P8B500wbgvIbwsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063024 MassSpecGymID0062606\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063025 MassSpecGymID0062601\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063025 MassSpecGymID0062602\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063025 MassSpecGymID0062603\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063025 MassSpecGymID0062604\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063025 MassSpecGymID0062605\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063025 MassSpecGymID0062606\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063026 MassSpecGymID0062601\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063026 MassSpecGymID0062602\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063026 MassSpecGymID0062603\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063026 MassSpecGymID0062604\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063026 MassSpecGymID0062605\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAggAAADmCAYAAACwLX24AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABHKUlEQVR4nO3deVwU9f8H8NfucnigIJggXmiGZaKAgAKiIoqJimJ5W3nkkZlm5n2UmWVpWuaVmmf49TbJsxRPwG+i8pM88msIJiCLcshyrbv7/v0x7chy7iKwLL6fjwcP3f3szuf9npmdfe/MZ2YkRERgjDHGGCtAauwAGGOMMVb9cIHAGGOMsSK4QGCMMcZYEVwgMMYYY6wILhAYY4wxVgQXCIwxxhgrggsExhhjjBXBBQJjjDHGiuACgTHGGGNFcIHwAnvw4AHatGmDoKCgIm2RkZFo06YNfvjhh0rpW6FQYNGiRfD19YWbmxt69+6NzZs3V0pfBUVGRmLs2LHo1KkT3Nzc0L9/f+zcubNC+9DOV5VKBQDo0aMH2rdvDzc3N7i6usLHxwfz5s1DWlqa+J60tDSMHz8ebm5u6NWrF86ePatXW35+PhYtWoROnTqhU6dO+Prrr6G9OOqDBw8wduxYdOzYEX5+fli3bp34vry8PMyYMQMeHh7o2rUr9u/fr9Pf9OnT0alTJ/j6+uKLL76AUqkEAGg0GqxatQo+Pj7w9PTE7NmzkZ+fX+Y8mTNnDtq0aYNjx44VaRs+fDjatGmj38wth3PnzuHNN9+Em5sbPD09MWnSJPz999+V1h8AZGdnY/ny5QgMDISbmxs6d+6MadOmIT4+vkL7mTNnDlatWgUAOHjwIF577TW4ubmJ69qgQYNw/PhxnfccPHgQ3bt3h5ubG2bMmIHc3Fy92qKiotC/f3+4ublh0KBB+PPPP8W2Y8eO4Y033oC7uzvefPNNXLlyRWy7desWhg0bBjc3N/Tp0wcXLlwQ2/7v//4PAwcOhKurK4YNG6Yzf3766Se0a9dOzMfNzQ0pKSkVNu+YHoi9sP755x9ydnYmLy8vun37tk7b3LlzydXVlVavXl0pfc+aNYs++ugjSk9PJyKiW7dukb+/P/3888+V0h8R0a+//kodO3akvXv3Ul5eHimVSoqJiaHevXvTpk2bKqwf7Xx9+vQpERH5+/tTRESE2P7w4UOaNGkSDRo0iNRqNRERTZ48mRYuXEj5+fl0/vx5cnd3p4cPH5bZ9vnnn9O4ceMoKyuL5HI59enThw4dOkRERMOGDaNVq1aRSqWixMRE8vX1pfPnzxMR0dKlS2nixImUnZ1N169fJy8vL/rzzz+JiGjatGk0a9YsysnJodTUVBo8eDCtWbOGiIh++uknGjhwIMnlcnry5AmNGjVKbCvN7NmzycvLi6ZMmaLzfGJiIrm7u5Ozs3N5Z3ep7t27R+7u7hQZGUlqtZpycnJo5cqV5OfnR/n5+ZXSZ15eHg0YMIDGjRtHcXFxRET06NEj+uGHH8jX15eysrIqrK/Zs2fTypUriYjowIEDNGzYMLFNqVTSyZMnydXVlU6dOkVERDdv3iQvLy+6desWZWVl0fjx42nJkiVltiUmJlLHjh3p7NmzpFaraceOHRQQEEBERLdv3yYPDw+KiYkhtVpNhw4dIk9PT3ry5AkpFAry9fWlPXv2kEajod9//53c3NwoJyeH8vLyyNfXlw4dOkRKpZJ++OEHCg4OFuOfMWMGhYaGVti8YobjAuEFpv0imz9/Pq1atUp8Pj8/n7p27UoffPCBWCA8evSIPvzwQ+rWrRu5uLjQqFGjxC+pP//8k0JCQqhjx47Ut29f+uWXX8TpzJw5k7y8vKhr1640Z84cysvLIyKiPn36UFhYmE48J0+epF27dhER0erVq+njjz+moUOHkqurK40bN45SU1PF127dupV69OhBnTt3prlz55JCoSAiIrVaTatWrSIfHx/y8vKiuXPnUn5+PimVSurUqRMdOHCgyHy4fv067d69m4iEL/OTJ0+KbSdOnKAhQ4YQEZGzszP95z//IV9fX/Ly8qL9+/fT999/T56enuTv70+XLl3Sma8lFQhERNnZ2eTu7k6nT58mhUJBr732GsnlcrF94sSJtH379lLb8vPzydXVle7fvy+2PXjwgFJSUohI+KLSxnDr1i3y8fGhmJgYIiLy9vama9euie/7/PPP6csvvyQioUCIj48X23bs2EHjxo0jIqLAwECKjIwU2+RyOT148KDIPC1s9uzZYtGpXVZERBs3bqRPPvlEp0A4ePAg9e/fn9zd3cnX15e2bdtGREQajYaWLVtG3t7e5OPjQ1OmTKG0tDQiIrpw4QIFBQVRx44dKSQkRCyEjh49SoGBgTqxqFQqmjdvnrj+Ojs704YNG8jLy4u6dOlCe/fuFV97//59Gjt2LHl4eFC/fv3E6RIJX6ja9TMoKEicL1u3bqXAwMBiC5ANGzbQ/fv36cCBA9SvXz+dNu30V69eTQsXLqR33nmHXF1dadSoUXT16lUKCQkhV1dXmj59ulhYllYgaK1du5ZCQkKIiOibb76hhQsXim2xsbHk5eVVZtv69etp5syZOvMwNjaW1Go1hYeH0/fff6/Tp5eXF8XExFBYWBiNGDFCp+3mzZuUn59PZ8+epd69e+tM08PDg27dukVERH379qUrV64UyYdVHT7EwNC3b1+cOHFCfHz+/Hl4eHigVq1a4nPLly9H/fr18dtvvyEyMhIAsG3bNgDA0qVL8dZbbyE6OhqffvopPv/8c+Tm5uLw4cNITk7GuXPncOTIEfz111/i7s7AwEAsWbIEX375Jc6cOYPMzEwEBgZi+PDhYp8nTpzA+++/j0uXLsHGxgYLFy4EAPz6668IDQ3Fli1bcPr0aeTl5eGbb74BAOzatQu//fYb9uzZg9OnT+Off/7B5s2bce3aNWRnZ6Nfv35F8ndxccHQoUPFeXHy5Emx7dixYzqHYKKjoxEeHo6ZM2di4cKF0Gg0iIiIQL9+/cRdvfqoU6cO3N3dceXKFSQkJKBOnTp46aWXxPaWLVsiLi6uzDYzMzNcvHgRAQEB6N69O8LCwtCoUSMAgKWlJczMzBASEoIBAwaga9eu6NChAzIzM/H48WO0atWqyDQB4LvvvkOLFi3EtjNnzsDZ2RnZ2dmIj49HUlIS+vTpgy5dumDTpk06sZXmpZdeQrt27XDmzBmd+Vtwmdy/fx9ffPEFli9fjitXrmDJkiVYvnw5njx5gkuXLiE8PBwnT55EeHg4lEoldu3aBQCYP38+Zs2ahejoaLzzzjtYvHgxAMDT0xOZmZl4++23ERoair/++gtSqRRLly6Fvb292O/ly5dx+vRprF27Fl9++SVu3LgBlUqFiRMnwsPDA5GRkVi0aBE++eQTJCUlQalUYuLEiejduzcuX76MGTNmYMqUKcjJycHp06fRr18/WFhYFJkHEydORLNmzdCrVy/Ex8eLu9Tv3r2LR48ewdvbGwBw+PBhzJgxAxEREXj06BE+/vhjfP/99zh+/DgiIiIQFRWl1zwHgC5duuDmzZvIyclBXFxckeWekZGBx48fl9p28+ZN2NnZYcKECejUqRPGjBmD2rVrQyqVwt/fH1OnThXfd+XKFWRnZ8PJyQk3b95E8+bNMWPGDHTq1AlvvfUW8vLyYGFhgXv37un0J5PJ0KxZM8TFxSE/Px/37t3Dxo0b4e3tjeDgYJ1Da6xqcIHA0LFjR2RnZ+P27dsAhI12//79dV4zY8YMzJkzB0SE5ORk2NjY4NGjRwCAunXrIjw8HBcvXkSHDh1w+fJl1K5dG3Xr1kVcXBx+/fVX5ObmYv/+/Rg4cCAA4KOPPsJnn32G+Ph4fPzxx/D29saECROQlJQk9tm1a1d069YNlpaWmDZtGs6fP4/c3Fz88ssvGDNmDFq0aIE6depg2rRp+OWXX0BEOH78ON599100bdoUVlZWWL58Ofr374/U1FTY2NjobLRHjBgBDw8PdOzYES4uLgCEAuHMmTNQKpXIycnB+fPn0adPH/E9b7/9NiwsLODl5QW1Wo13330X5ubm8Pb2xsOHDw2a7/Xr10dmZiZycnJ0ijEAqFWrFvLy8kpty8zMRHZ2NqKjo3H48GFs27YN+/fvxy+//KLz+t27d+PkyZP4448/EBoaKh5XLjhd7TQL++qrrxAfH4/33nsPWVlZAICjR48iNDQUBw8exNWrV7Fx40a9c+7bt69YJMbFxUEqlcLJyUlsd3BwwK+//oo2bdogNTUVMpkMT58+RUZGBurWrQu5XI4DBw5ALpdj/fr1+OCDDwAI62BYWBiio6PRr18//P777wCEouSXX35Bu3bt8PPPPyM4OBh+fn4IDQ3Vievjjz+GlZUV2rdvj169euHkyZOIjY3FkydPMGnSJJibm8PT0xN+fn44cuQIrly5AiLC6NGjYWZmhh49emDr1q0wMzNDamqqTvFx9uxZeHh4wMPDA66urli3bh3q1auHbt26iYX5sWPHEBgYCDMzMwBCYdO+fXvUqVMH7dq1Q48ePdCsWTM4ODigdevWSE5O1nue169fH0SErKws5Obmonbt2mKb9v+5ubmltj158gR79+7F+PHjceHCBXTq1AmTJ08Wx9loxcXFYdq0afjoo49gbW2NJ0+e4Ndff0VgYCAuXryIESNGYNKkSeJ6X7A/bZ95eXl4/Pgx3N3d8fbbb+PcuXOYPn06pk+fXuljR5guLhAYpFIp3njjDRw/fhw5OTm4du0afH19dV6TnJyMMWPGoHv37vjiiy+QmpoqDob76quv0KhRI8yePRudOnXC8uXLoVKpEBQUhIkTJyI0NBTdunXD22+/jYSEBHGaQUFB2LhxI6Kjo7Fr1y7k5+fjo48+EtubNWsm/t/e3h4qlQoZGRlITk7G8uXLxY3um2++CY1Gg8ePH+PRo0c6G2cHBwc0a9YMtra2yMjIwNOnT8W2Xbt2ITo6GgcPHhQH4b366qtwcHDAhQsXcPbsWbRr1078RQ4A1tbW4jwDgHr16omPNRqNQfM9IyMDDRo0QO3atYsM9MvLy0OdOnVKbbOwsIBarcZHH30EKysrODk5YejQoQgPD9d5vaWlJZycnDBy5EicOXNGLAwKTlc7TS2lUokZM2bg7Nmz2L59O2xtbcXiavz48bC1tUWjRo0wduzYIv2VJjAwEJGRkVAoFDh69GiRPTpmZmbYuXMnvL29MXr0aLGYICK0b98en3/+OU6cOIHevXsjJCQE169fBwCsW7cOGo0GkydPhq+vLzZt2iRO08HBAbNnz8bx48cRGRmJ999/H19//TXOnz8vvqbwuvbo0SMkJycjLS0Nnp6e4rp2+vRppKSk4PHjx2jUqBEkEon4vvbt28PCwgJ2dnaQy+Xi8927d0d0dDSio6PRs2dPqNVqAML6r91bdfz4cfTt21d8j3Y9A4Rf1lZWVuJjqVQqfvb0kZ6eDqlUivr16xcpBLXFYp06dUpts7CwQEBAADw9PWFhYYH3338fcrlc3OsECHthhg8fjhEjRuC9994DAFhYWKBDhw7o3bs3zM3NMWjQINja2uLq1atiMVBQbm4u6tSpA0dHR+zcuRO+vr6wsLCAv78/OnXqpDPAkVU+LhAYgGe/7MLDw+Hn5wdzc3Od9pkzZyIkJARRUVHYvn27+IubiPC///0Pn376KS5evIht27YhLCwMZ86cwb179+Dn54dffvkF58+fR6NGjbBs2TI8fPgQHTp0EH8FyWQyuLq6Ys6cObhz547YZ2pqqvj/pKQkmJubw9bWFg0bNsTnn38ubnQjIyMRFhYGOzs72Nvb62ycr1+/jt27d8Pd3R21a9cudhR9cfPi9OnT+P3333U22gB0vhCeh0KhwLVr1+Dp6YkWLVogOztb56yGe/fuoWXLlmW2SaVSKBQKsU2j0YCIoFar0bdvX9y7d09sUyqVqF+/PmxsbGBra6vTpp0mAOTk5GDcuHF4+PAhdu/eLX552trawtraGtnZ2eL7tF92+rK1tYW7uzvCw8Nx/PjxImfQHD16FOfOncOxY8dw9OhRzJ07V2xLTk7GK6+8gt27dyMqKgqdOnXCggULoFQqkZSUhFWrViEqKgrffvst1qxZg5s3b2Lx4sVYsGCBOA07OzuMHDkSXbp00VnXCq4zSUlJsLe3x0svvYRmzZqJ61l0dDSOHTuGadOmwd7eXmf9BIQi5cGDB+jevTuOHTsmFp0l6dGjB+Lj43Hx4kUoFAp4eHiIbRW1ngHAxYsX4eLigtq1a6NVq1Y6Zwrcu3dPXB9Ka3NyctJZz7TrmLZQOXnyJCZOnIi5c+di8uTJ4usKvw94to4W7k+tVuP+/fto2bIlbt26pVPkAcL6W3i7xCoXFwgMAODq6gqVSoV169YVObwAAE+ePBF/YV69ehVhYWFQqVSQSCRYunQptm7dCiISf21bW1sjPDwcs2bNQlpaGmxsbGBpaQkbGxs4ODjAxcUFixYtEvcopKSkYPPmzfD39xf7PH36NK5evYq8vDysXr0agYGBsLS0RP/+/bFlyxYkJSXh6dOnWLVqFT788EMAwpf7jh078PDhQygUCqxatQppaWmwtLTEp59+ii+++AL79u1DdnY2NBoNrl27hgULFqBhw4Ziv/369cOFCxdw+fJl9O7du8LndVJSEj755BO8+uqr6NKlC6ysrNC1a1esXLkS+fn5uHDhAv744w8EBgaW2mZtbQ1/f3+sW7cOCoUCCQkJ2L17N/r06QOZTIbWrVtj9erVyM/Px//+9z/s2rVLPMTTt29frFmzBgqFAn/++SeOHDkiFkNz5syBmZkZtm7digYNGujEPmDAAGzevBlpaWlITU3Fli1b8MYbbxiUf9++fbFhwwY0bNhQZ28PIKxn5ubmMDc3R3Z2NlasWAEAUKlU+L//+z9MnjwZSUlJqFevHurUqSP+0p4+fToOHz4MqVSKl156CRKJBPXq1UNgYCCOHj2Kw4cPQ6lUQqlU4sKFC7hy5Qr8/PzEftesWYO8vDxcvXoV4eHhCAoKQocOHaDRaLBr1y6oVCr8/fffeOuttxAREYEOHTrAzMwMO3bsgFqtxrlz57B9+3bY2Njg7bffRq1atTBlyhTcuXMHRISMjAxs2bIFv//+O+zs7AAIh3UCAgLw9ddfo0+fPuJeqYry9OlTHDt2DNu2bcOUKVMACHstjh07htjYWCgUCqxevVr8vJfWFhwcjMjISERFRUGlUmHNmjVo2rQpnJ2dcfPmTcyaNQurV68W1y+tN954A/fv30dYWBg0Gg327duHzMxM8bTcjIwMHDhwAEqlEuvXr4ejoyOcnZ1Rp04drFmzBuHh4dBoNDh+/DhiYmLQq1evCp1HrAzGGBnJqofCo+2XL19O3bp1I41GQ0TCaUbasxhOnDhB3bt3J3d3dxo0aBAtX75cHIV969YtGjp0KLm5uZGvry/9+OOPRCScxTB//nzy8vIiNzc3mjhxIj169IiIiDIyMmjx4sXUrVs36tChA/n6+tKSJUvEEe6rV6+mUaNG0fDhw8nd3Z0+/PBDyszMJCJhNPuPP/5I/v7+5O7uTu+88454OplKpaLVq1dTt27dyMvLiz777DMxPyKi6OhomjRpEnXq1IlcXV3pjTfeoJUrV4qj4bVCQkLEkftazs7O4uj+wvPu0qVL5OfnV2ybv78/ubi4kKurK7m6upK/vz8tWbJE53S3R48e0fvvv08dO3akXr160ZkzZ/Rqy8rKojlz5pCPjw95e3vTunXrxLa0tDSaNm0aeXp6Us+ePWn//v1iW3Z2Ns2ZM0c8w0Tbpo29YLyurq40ZswYcZkuW7aM/Pz8yNPTk5YsWUJKpZKIiA4fPkxBQUGFVzMi0h1t/+TJE2rXrp14tkB8fLx4FkN2djZNmjRJXJe++OIL6tevn3hmycqVK8nHx0cc3X/v3j0iIoqMjKT+/fuL87fg2Srh4eE0bNgwcnd3J1dXVxoyZAhdvHhRZ7kuXryYfHx8qEePHnTs2DGx7e7duzR69Gjy8PAgPz8/cd0mEk7vGzlyJLm7u1NwcDBdvnxZbMvNzaUffviB+vTpQ25ubuTp6UkTJkzQOQtCG5uzs7N4dgmRsO7PmDGj2HlHRDRq1Chx3hU+i+HVV18Vl5mXlxcNHz6czp49q9PnoUOHKCAggNzd3enjjz+mnJwcvdrOnj0rzuPhw4fT33//LcZQsF/tn/asnpiYGBo8eDC5ubnRgAED6OrVq+I0Y2NjadCgQeTq6krDhg0TlycR0alTpygoKIg6dOhAwcHB4vRY1ZEQGXAwi7Eq8sMPPyAhIUH8BVnVpkyZgp49exb5RcRKN3XqVKxevdrYYRikTZs2+O2333TO3Kgqt2/fxpQpU3Dq1Kkq75uxsvAhBsYKSElJwfnz53H16lUEBgYaOxyTEh0drXOIiJVMpVLhzp07WLduHQYNGmTscBgrFhcIjBVw+PBhTJ8+HbNmzdIZ1c/K5uHhgZCQEGOHYRKICCNHjoRcLse7775r7HAYKxYfYmCMMcZYEbwHgTHGGGNFcIHAGGOMsSK4QGCMMcZYEWbGDqA8VCoVMjMzYWlpWeEXF2GMMcZqMo1Gg/z8fFhbW4v3/yiOSRYImZmZOpfoZIwxxphhnJycxCt7FsckCwRLS0sAQPPmzVG3bl0jR1Mx1Go17ty5A2dnZ8hkMmOHUyFqWk41LR+AczIVnFP1Z0r55ObmIj4+XvwuLYlJFgjawwq1atWqMeeqa296U6dOnWq/cumrpuVU0/IBOCdTwTlVf6aYT1mH6I12AF+pVGL06NE4c+aMsUJgrEwKBbBlC7BgAbBtmwQ5OTzmhTH2YjDK1u7GjRsYPnw4rl27ZozuGdNLRATg5ASMHw/s2AFMmCBBcLALIiONHRljjFU+oxQIu3btwtSpU9G+fXtjdM9YmRQKYMAA4PXXgXv3gPv3gbg4Cdq1kyEkRIpCt7hnjLEaxyhjEJYuXQoA2Lx583NNR6PRiMd9TJ02j5qSD2DaOe3eLUF6ugQ7d0rQvLnwXIsWwM8/S9CyJWHPHg1Gjzb9q5Sb8jIqCedkGmpaTqaUj74xmuQgRa27d+8aO4QKFxsba+wQKpwp5hQV5QhHR3s0by7Reb5FC8DRkRAVlQJX1yQjRVfxTHEZlYVzMg01LaealI9JFwitW7eGlZWVscOoEGq1GrGxsXBxcTGZEbBlMeWcvL0l2LZNgvv3Ie5BAICEBCApSQJvb3u4ujYyXoAVxJSXUUk4J9NQ03IypXxycnJw586dMl9n0gWCVCqt9gvCUDKZjHOqBoYNA+bMAUaNAnbuFPYcJCQAo0YRbG2BoUOlMLGUSmWKy6gsnJNpqGk5mUI++sZn0gUCY5XFygoICwOCg4FWrYBGjYCUFIK1tRphYRJYWVXvDQBjjD0voxYIO3fuNGb3jJXKxweIjwfatAGUSmDTJoKzcyx8fPjsG8ZYzcdXfWGsFFZWgI2NsAdh9GhCnToaY4fEGGNVggsExhhjjBXBBQJjjDHGiuACgTHGGGNFcIHAGGOMsSK4QGCMMcZYEVwgMMYYY6wILhAYY4wxVgQXCIwxxhgrggsExhhjjBXBBQJjjDHGiuACgTHGGGNFcIHAGGOMsSK4QGCMMcZYEVwgMMYYY6wILhAYK4VCAWRkAHI5sG2bBDk5/JFhjL0YeGvHWAkiIgAnJyApSSgSJkyQIDjYBZGRxo6MMcYqHxcIjBVDoQAGDABefx145RXA2RmIi5OgXTsZQkKkUCiMHSFjjFUuLhAYK8bevUB6OrBzJ2BuLjzXogXw888SpKUB+/YZNz7GGKtsXCAwVoy4OKBJE6B5c93nW7QQno+LM05cjDFWVbhAYKwYrVoBiYnA/fu6zyckCM+3amWcuBhjrKpwgcBYMYYMARo0AEaNAp4+FZ5LSABGjSLY2gKDBxs3PsYYq2xmxg6AserIygoICwOCg4HHjwEzM6BlS4K1tRphYRJYWcmMHSJjjFUqLhAYK4GPDxAfL+xJIAI2bSI4O8fCx6e9sUNjjLFKx4cYGCuFlRUgkwl7EEaPJtSpozF2SIwxViW4QGCMMcZYEUYpEE6dOoV+/fohMDAQixYtwlPtKDDGGGOMVQtVXiCkpqbis88+w6ZNm3Dy5Enk5OQgNDS0qsNgjDHGWCmqvECIiIiAu7s7GjduDIlEgiFDhuDIkSNVHQZjjDHGSlHlZzHI5XLY29uLj+3t7fHw4cNyTUuj0UCtVldUaEalzaOm5APUpJyEOrrm5PMM52QaOKfqz5Ty0TfGKi8QNJqio8Cl0vLtyLh79+7zhlPtxMbGGjuECmfqOWk0bgCe5WHq+RSHczINnFP1V5PyqfICwcHBAbdv3xYfy+VyODg4lGtarVu3hpWVVUWFZlRqtRqxsbFwcXGBTFYzLsJTU3KSSiUAABcXlxqRT0E1ZRkVxDmZhpqWkynlk5OTgzt37pT5Or0KhKioKIM69/b2LrGtS5cuWLFiBRITE+Ho6Ij9+/fD39/foOlrSaXSar8gDCWTyTinakqbQ03JpyDOyTRwTtWfKeSjb3x6FQhjx46Fo6MjiKjM16akpODGjRsltjds2BCLFy/GpEmToFQq0aFDB4wbN06vYBljjDFWNfQqEGrVqoXTp0/rNUE3N7cyXxMQEICAgAC9pscYY4yxqqfX6MAdO3boPUFDXssYY4yx6kmvPQguLi46j9PS0vDjjz/i3r17aNq0KcaPH4/GjRsX+1rGGGOMmZ5ynV84b948NG7cGO+++y4cHBwwZcqUio6LMcYYY0akV4Hw7bffQqFQiI/lcjmCg4Ph6+uL/v37IykpqdICZIwxxljV0+sQw2uvvYYxY8Zg4MCBGDZsGN5//30EBwdDJpMhLy8Ps2fPruw4GatUCgWwdy8QFwe8/DIweLBwq2fGGHtR6VUgBAUFoWfPnvj5558xYsQIjB8/HufOnUN6ejoaNGhQ7c/5ZKw0ERHAgAFAejrQpAmQmAjMnAmEhQE+PsaOjjHGjEPvMQgWFhYYO3YsNm7ciD/++APvvfcekpOTuThgJk2hEIqD118H7t0D7t8X9iK0bQsEBwvtjDH2ItL7SoorV66ETCbDrFmzMG/ePCQkJODbb7+Fubk5Pv74YzRp0qSyY2Wswu3dK+w52LkTaN5ceK5FC+Fxy5bAvn3GjY8xxoxFrz0I8+fPx5QpUzBhwgTMnz8fANCiRQusXr0aI0aMwJw5cyo1SMYqS1yccFhBWxxotWghPB8XZ5y4GGPM2PTag5CTk4OmTZuCiJCbm6vT1rFjR+zcubNSgmOssrVqJYw5uH9ft0hISBCeb9XKeLEZAw/WZIxp6bUHYdasWRg5ciTGjBmDWbNmVXZMjFWZIUOABg2AUaOEogAQ/n37bcDWVviCfFFERABOTsD48cCOHcB77wmPIyONHRljzBj0KhD8/Pxw6dIlXLhwAUFBQaW+NjU1tUICY6wqWFkJZyvcvCnsLWjcWBh7cPOm8PyL8uuZB2syxgrTq0Do3bu33hM05LWMVQc+PkB8PODgAKhUwE8/CY8r6xRHhQLYsgVYsADYurV6fPnu2ycpcbBmWhoP1mTsRaTXGIS8vDyMHDmyzNcREfLz8587KMaqmpUVYGMj/H/MmMrrp7pec4EHazLGCtOrQFi6dKneExz8Ih20ZcwABXfja3+pa8c7BAcLey2MdUiDB2syxgrTq0AICQmp7DgYq/H0ueZCZe69KM3gwYQ5c4TBmjt3CnG9qIM1GWMCvQoExtjzq8678bWDNYODhb0FjRoBKSlCcfAiDdZkjD1Trts9M8YMV3A3fkHVZTd+VQ/WZIxVb1wgMFZFTOGaC9rBmo0aCYc7eM8BYy8ugwqErl27YtmyZbh+/XplxcNYjcXXXGCMmRKDxiCsW7cOx48fx0cffQSZTIagoCAEBQWhTZs2lRUfY5WiuEsKVwXtbvw2bQClUtiNz5czZqaML89dcxlUILRr1w7t2rXDzJkzcf36dfz++++YPn06pFIp+vbti4EDB6Jx48aVFStjFaKkaxHUqwfUqVNx/ZS04ayqay4wVtmq63U9WMUo1xgEuVyO69evIzY2FqmpqWjVqhUyMzMxZMgQbN68uaJjZKzClHZJ4X/+ATSaiulH3/saVMerKjKmD748d81n0B6Ebdu24cSJE7h58ya8vb0REhKCtWvXom7dugCAwMBAjBs3Du+9916lBMvY8yrtWgROTsCTJ8/fhz4XRAKAnByhT/71xUxRdb6uB6sYBhUIp0+fRkhICDZs2AAb7T7SApycnPDFF19UVGyMVTjttQhsbYVf7trd/336AFKpsMHbuvX5jqOWtOHcsEEoGoYPF+5vkJYGdO5c9VdVLHjoo2VLCZydn/9kJj4O/eKpztf1YBXDoALByckJQ4cOLfL89OnTsWrVKtja2qJv374VFhxjQMV++bRqBTx4IGzUMjOFc/6TkwGZDCACrK2FwwHP80u+uA2n9litRAJcuQI8fCj8f8MG4NSpZ7lt2AC0a1c5v74UCmDpUuCHH4DcXO1eCwnq13dBWBjg51e+6ep7HJqLiJql8OW5tcv32jXhM+boaOwI2fMqs0BITk7G3r17AQC//PILGjZsqNOuUCgQaeAN40+dOoXvvvsOSqUSnTt3xsKFC2Fubm7QNFjVq4gNvKHTqLBBUP92HBT9ADLpQrRtC+zaJYGtrbBxe/11QmiopMTDAYYovOH8+2+gZ0+gY0dg1y7hOVtboUDw89PNrUEDoGHDkn99lTr//m1UXI/D3uhWiFO3wMuvWaDrhFfx4YRcnL7VBGqSwtMTGDRIgsxMwNpagkOHZAgJKX6vhba/27eBR4+E2F577Vm/xR1OuXkTGDgQ6NEDcHMTpmNrC1y6BGRkVO3hFMVDBfbOvYa4/6nxsrMMg790g5UDVyUVYcgQYNYs4boe06YBEycK67K9vbBuL1wIdHglBz73d1dNVVgVFWhpfTx8iBaLF0P6+LFwmtKXXwq/QCqpuypBeli2bBnNmTOHXn/9dZozZ47O38KFC+nixYv6TIaIiORyOfn6+lJSUhJpNBqaMWMGbd26Ve/3ExFlZ2dTdHQ0PXnyxKD3VWcqlYqio6NJpVIZO5RiXbxIZGdHJJUSNWsm/GtnRxQRUfJ7Cudk6DSysoT2rl2JEhKE5+Ljifz8hOezsgwMXiKhtdIPSCLRiNP76SchDu1jrfh4IomEaMsWIktL4U/fZZScTGRmpiFfXw198YUwHYlEtw97eyKZrPjcZDKidetKTqPY+fdv40X4kp0snaQSNTVzyCdATVKphmQyDbVurSGJhKhBA91pNGhABGhoyxahn7Zthb8Cs43MzYV/HRx0+y08/7TvAYQ8JBKiRo2E//v6Pudy1JN2OZ1bc43szLTzQklSiZrszNIpYsP1iu2wNFlZwkyaP19YmcqZbHXdPkREENnalrB8u2jIziydsiT1iv3Alzun4uZpeTZQhiqtj3XrSGNmRhqJhDQODsKKb2ZGtGFDpXQnKuf6pf0Ozc7OLvV1ehUIWqGhoYa8vFiHDh2iDz/8UHz83//+l958802DpsEFQtUq7xd1wZzKMw19vrz1Dt7Xl6hBA+prc4EcHDRi8/z5woevOE2bEi1YYHiB8NPKDJJATdbWwoazQQPhi7Ug7Tak+Nw0RQqE0uefhrJsm1NW555kZ5ZOXbuoKCFBW6gQtW6tIamUaMIE4Yu+uGmYm2to1izhubZtiV59VWe2lbjcZs58Nv+0MXbuLPTbpYvwngpZjgZQqVR08cRFnXkhxu2rEr60kiu4KilOBX5pVeftw9q1pS1fDW1Z/ujZEwU+8OXKqbh5amtLZGNTAb8kSpGcTFSv3rOVumAfDRoQmZmRpnCbr6/wQUhONrg7vbaXz7F+6Vsg6DU6af369QCE0xu///77Yv/0JZfLYW9vLz62t7fHw4cPDdzvIdBoNFCr1TXmD4DRYyjub/duDdLTqdjRymlphD17Sl4O2pzKM427dzVo0oRKGARFuHu37OWv2b0blJ4u7AfPzARq14Jc/ux+CKXfH4Hg5KQRrmikVOq9jP7eeg5NHVTo1084bdLNDTp9AsK9Duztix/g5dhIjQdxeQYsA2Bvek/sbfYx0tX1sTNUhubNgblzAbUaeOMNCZo0EdJQqYofda5SAXK5MD+RKkfmgydITydxtpW03FJTNUhMJNy//2xwZrNmQr+hocJ7Sh/Mpt9yNPQvYq1cZ16IcYfKkKa2xp65Vyv3c5OZCerdG9S2rc45gNS2LSg4GOrMzBqzfXjwQAN7+5I+p0Bcpp3OikNpadDs2WN4TpmZoAEDQIXOqyQ7O1AJK2nBvsr9d/48qHVrkELxbKUu2Ed6OkithqRwW2goSK2GZu5cg/ssc3u5Paf4eWHA+qUPvQYpar/AU1JS9JpoaTTFnGgulZZvFPXdu3efN5xqJzY21tghFBEV5QhHR3s0by7Reb5FC8DRkRAVlQJX16QS3x8bG1uuaZiZ2SExsYV4LF9Le3MjM7P7iIl5XGrsjlFRsHd0hCQzE2jSBEHmZ3FC0lG8rfGQIcAnnwAjRgifffE2xyM1sLbWwNk5Ft7I+DeP+mI+pWmSfgWJ8v746y+hCHjzTeDcOd1bKbu5AadPo9jckuQy2Nz5FTExzxpKm39NHNSIU7QHkmqjib0azZsLn6f//U/o380NWLcOsLQsuShp1AjQaOSIiUnEINV5nFH5QOboicxMSYlf7o6OBI1Gjvr1G2LkSBlcXYXXJiXp9lN4TEZ5lqOhku6b68wLnfnVSIU/YzIRExNToX0WZHf4MFrk5kLy8886W3jJzp2gli3xz8qVeBwcbPB0q+P2wczMDikpJX1OJbo3IWvRAuToiJSoKCS5ugLQPye7w4fRIj0dkkLfmhJ/f1BWVrEraeG+DCXNyYHLgAGArS0k2gFLhfqAhQVQUlujRsiOicEdA9e1sraXMbv/AIqbF8+5fhVh8L6P53To0CGaNm2a+PiPP/6gwYMHGzQN7e6RjIwMUqlUNeIvPz+foqOjKT8/3+ixFP7btEk4jl3SLsTNm9Vl5lSeaWRkqMjOTkN+fhqKj3/2ej8/DdnZaSgjo+zY1Zs2kUYqJfrmGyKplLJCRlF9aSZZWgq73Zs21T1e3rSJhiQSDdnVy6Pz51WkysgQji3KZPR040a6ev58mcsoc8QEspOlUaNGwjH/mzeJ6tcXDlPo9qkhHx8qlBuRnXkGZX7ymUHL4CfJWPpp8DGSStTia0aPJrF/OzuiV14pfVewdhlo2ralzY3nk1Sq0c62Ut9z/rywnCQSDUmlGho8WPfwiXZ3qZ9f4Vz1X46Gfpa+7n9QZ14UiXv0uUr9zKjnziVN48bFbr80TZuSet68GrN9KPFz6qMiuwZq3T388fGkkUhIvXmzwTmp584lTeHjgRcvEtWtS5oSjtdp+yr3ciy0/Si2D6D0/kePNrjfMreXffcVnRcGrF9Pnjyp+DEI//zzD82fP5+IiM6dO0ceHh4UEBBAsbGxek8jNTWVfH196cGDB6TRaGjWrFm0rrgRWaXgMQhVq+QNvOFjEAydRkTEs8NsTZsKXzwGHcbVduzjIxwr7NSJImR+ZGvxhCRQU726KgI01KAB0bwPMmhBs220pe4U4Rh1wRF3ZmakkUrpqY0Nqc6fL73P5GSKkPlRA/MnJJNpyNeX6MAB4VCpREJUt66GAA3Vk2SRTX21bm4NVBQBnyIH5kuff/+OQegUQHZm6eTnq6L4+GdjEHx9NWL/MhmRj4/uhrxLF+GLWlwGbdtS1qseOrOtrOWWlSUMrKxbl8jLS9vvs/ccOCAUSBJJOZejAVSqZ2MQtPNCjLuqxiBU8MCL6rx9ICrucyoMUIzo8H6JK47BORWep4XGFxm8cdGHdpBSSR9Abd9mZqQpuMJX0BiEElNau/251q9KGaQ4duxYWrRoEWk0GgoMDKTNmzfTnj17DB5keOrUKerXrx8FBgbSzJkzKT8/36D3c4FQ9crzRV04p/J+2WdlCev7ggXlHAiu7Vg7HB+gLGl92oLRtEDyBW3BGMp6qaVuQAVHCb3yijByLz6eNF26kEafjc6GDZQls6Z3sJXMZMKv65deEgoDiURD7wxXCl/qPoG05ZtUIbdvUinLJ7DEjVqp8+/fxgj4iGcxNLVXEiCcwVCwf5lMQ1KJhpra55NEoiEbm6d0/nyB9e7f0xgKzzaJRDj7orTlpn1Pwb0y2vfIZETvvPMcy1FP2vXu/NpnZzE0tVc++9KqirMYsrKILCx0q6Tn+NKq7tsHomI+p79HlfqBNzinwt+aBQuG4j4c9eo9fwWqbx8bNjw7i0G7wj/nWQylft7L+4vrX/oWCBIiIn0PR/j4+ODixYu4d+8eQkJC8Mcff6BWrVpwc3PDtWvXnv94h55ycnJw69YtODs7o169elXWb2VSq9WIiYmBq6srZDKZscMplkIhXMAnLk44rlzWObnF5WToNCo8+Nu3gdRUoHZt4Pp1YeSehQXg4QG0b/8soC1bhBsp3LsnXGYRAG7cABISQC1bQvLTT2VfyejhQ2DePDy88Qjz0mfif9mOeCXjMr78e5hwenRkpHCxhfR04KWXhJGMtralXhyg1Pn3b6Piehz2RbdEnLoFWr1qga6jmmFp7/P4X50OeOWNlzH/Syuc95mDuDQbtLRMRJsDw9C5Z+dn693rr4v5Fp5tL70EvPpq6ctN+57r14HoaGHA4quvVshp4XopuN7lpuZi3zzhOgitXqni6yC0bCkMyFCphKsGJSaWuXxLYgrbh2KVssKWK6eCn5m6dYW/5OSifa1dK3x+v/76+eN3chJuMLFzJ2BnB6xfL1xtLC0NuHtXXKnViYlInzwZdo8fQ+LsXGHXQSjx815wXhi4fmm/Q1977TXUKe0OdYZUNF27dqXU1FRas2YNjR49moiI/vrrL+revbshk3luvAfBNJh0TgXPf9ReGOBfGu35j4YqbrdzVpZwfBMgGjOmcn5WF9dv27ZEr7xCGomE7i1apLuMCuVraqrNeqc9X/S5dn8Jqk1OFajcOWl3VfTrVzXnz+q569Moy6icu1f13YNg0KWW3333XQQFBSEvLw/r16/H9evX8d5772HatGmGTIax6q/08x+hOzRbTwUvPac9neHxY+DXX4VfJqtXV87ulJLOMzQ3B5o0gWViYsX3yQRSKd+xqKJZWQnzdPBg4dd9wc+T9jKotrZCe0Xw8REuM2qUXZ9l0M6LSmJQgTB27Fj07NkTtWrVQqNGjZCWloaffvoJLi4ulRUfY8ZR8Mv86VPhyzQhATRqVPk3PlZWwu6/4GBhI1N4t2BlbXBKOs/w6VMgMRH5TZpUTr+MVaaq/DxV8hdxdWVQgQAAlpaWuH//PhISEsTnLl++DE9PzwoNjDGjKrjxefwYMDMDtWwJtbU1JGFhkJV342OMXyPF7bn4tziArS3Se/ZEs8rr/cWkUAjHhp8+ff7bg7KSVedf9zWAQQXCjz/+iO+//x4NGjSAmdmzt0okEpw9e7aiY2PMuLQbnzZtAKUStGwZYp2d0f557y5U1b9Givul9eABIJNBc+IENKUNUmKGK3iHMXv75789KCvdC/rrvioYVCCEhobixx9/hF957wvLmKmxsgJsbAAANHo0NJV49b1KVfiX1pYtQP36wvOmmlN1VNztLQvfHpR/3TITYdA1jp8+fQpvb+/KioUxVpm0v7SWLBGKnnJe4pyVQntDipJumrFvn3HjY8wABm0hRo4ciRUrVuDx48fQaDQ6f4wx9sIr/c5UQjtjJsKgQwy7d+/Go0ePsH37dvE5IoJEIsGtW7cqPDjGGDMpZd2ZqjynxzJmJAYVCHv27KmsOBhjzPQVd8ZIZZybz1gVMOgQQ5MmTdCgQQNcv34dv/32G2xtbZGWloYmfB41Y4w9O2Pk5k1hb0GzZsIll2/erNxrXTBWCQzag3Djxg1MnDgRzZs3x61bt9CzZ0+88847+PTTTzFw4MBKCpExxkwIn5vPagiDCoTPP/8cn376KXr16gVPT080a9YMmzdvxty5c7lAYIwxLT43n9UABh1iiIuLQ0BAAADh4kgA4O7ujrS0tIqPjDHGGGNGY1CB0Lp1axw5ckTnufDwcLRu3bpCg2KMMcaYcRl0iGHBggUYP348QkNDkZOTg3HjxuHWrVvYsGFDZcXHGGOMMSMwqEB4/fXX8dtvv+HcuXNITk5Gw4YN8e2338Lm30vRMsYYY6xmMKhAGDduHH766Sf07dtX5/mhQ4fyNRIYY4yxGqTMAiExMRHff/89AOC///0vZs2apdOuUCiQmJhYOdExxhhjzCjKLBCaNGmC9u3bIyMjAwDQvNA1xi0sLDBt2rRKCY4xxhhjxqHXIYZRo0YBANq1a4fu3btXZjyMMcYYqwYMGoPg7u6OjRs3IiEhocgdHL/66qsKDYwxxhhjxmNQgfDJJ58gOTkZ3bp1g5mZQW9ljDHGmAkx6Fv+6tWrOH36NKytrSsrHsYYY4xVAwZdSdHBwQF5eXmVFQtjjDHGqgmD9iD07t0bY8aMwcCBA2Fra6vT9tZbb1VoYIwxxhgzHoMKhD/++AN2dna4cOGCzvMSicSgAuHUqVP47rvvoFQq0blzZyxcuBDm5uaGhMIYY4yxSmRQgbBz587n7jA1NRWfffYZ9u3bBwcHB8ycOROhoaEYPXr0c0+bMcYYYxVDrwIhKiqqzNd4e3vr1WFERATc3d3RuHFjAMCQIUPwzTffcIHAGGOMVSN6FQjz588vtV0ikeD06dN6dSiXy2Fvby8+tre3x8OHD/V6b2EajQZqtbpc761utHnUlHyAmpOTdiRvTckHKD0nbZvGRPOsSctJi3Oq/kwpH31j1KtACA8Pf65gCip8gSUAkEoNOplCdPfu3ecNp9qJjY01dggVztRzavvvmTs3/83D1PMBSs9JbIuJqfK4KlJNWE6FcU7VX03Kp8qvduTg4IDbt2+Lj+VyORwcHMo1rdatW8PKyqqiQjMqtVqN2NhYuLi4QCaTGTucClFTcpLWqgUAcHFxqRH5AKXnpG1zdXU1VnjPpaasdwVxTtWfKeWTk5ODO3fulPm6Ki8QunTpghUrViAxMRGOjo7Yv38//P39yzUtqVRa7ReEoWQyGedUTWlzqCn5AKXnZOo51qTlpMU5VX+mkI++8VV5gdCwYUMsXrwYkyZNglKpRIcOHTBu3LiqDoMxxhhjpTDKDRUCAgIQEBBgjK4ZY4wxpofyjQ5kjDHGWI3GBQJjjDHGiuACgTHGGGNFcIHAGGOMsSK4QGDsRaNQAOnpgFwOybZtkObkGDsixlg1xAUCYy+SiAjAyQlISQHMzSGZMAEuwcFAZKSxI2OMVTNcIDD2olAogAEDgNdfB+7dA5KSIImLg6xdO0hDQoR2xhj7FxcIjL0o9u4VDi3s3Ak0by4816IFJD//DKSlAfv2GTc+xli1wgUCYy+KuDigSZNnxYFWixbC83FxxomLMVYtcYHA2IuiVSsgMRG4f1/3+YQE4flWrYwTF2OsWuICgbEXxZAhQIMGwKhRQlEAAAkJoFGjAFtbYPBg48bHGKtWjHIvBsaYEVhZAWFhQHCwsLfA0RGUmAi1tTUkYWGQ1ZBbpzPGKgYXCIyVRnvNgKdPhWsGODsbO6Ln4+MDxMcLAxLj4kBOToh1dkZ7Hx9jR8YYq2a4QGCsJBERwmmB6emAvb1wzYD69YVf4X5+xo6u/KysgDFjAACkVkMTE2PceBhj1RKPQWCsOHzNAMbYC44LBMaKw9cMYIy94LhAYKw4fM0AxtgLjgsExorD1wxgjL3guEBgrDh8zQDG2AuOz2JgrDh8zQDG2AuOCwTGSsLXDGCMvcC4QGCsNHzNAMbYC4rHIDDGGGOsCC4QGGOMMVYEFwiMMcYYK4ILBMYYY4wVYbQCQalUYvTo0Thz5oyxQmCMFaa9e6VcDmzdyvecYOwFZpQC4caNGxg+fDiuXbtmjO4ZY8WJiACcnICUFMDcHHjvPeFxZKSxI2OMGYFRCoRdu3Zh6tSpaN++vTG6Z4wVVszdKxEXB7RtK1wsivckMPbCMcp1EJYuXQoA2Lx583NNR6PRQK1WV0RIRqfNo6bkA9S8nGpaPsCzXGjPHlB6OiSF7l6JnTtBLVsK7aNHGy9QA9Tk5cQ5VV+mlI++MZr0hZLu3r1r7BAqXGxsrLFDqHA1Laealg8ApP73v7B3dISkmLtXkqMjUqKikOTqapTYyqsmLifOqfqrSfmYdIHQunVrWNWQa+Kr1WrExsbCxcUFMpnM2OFUiJqWU03LB3iW00udOkGybZtw98qCRUJCAiRJSbD39kYjEykQavJy4pyqL1PKJycnB3fu3CnzdSZdIEil0mq/IAwlk8k4p2qupuUDAJKhQyGZN0+4e+XOncLhhYQE4O23IbG1hWToUMDEcq6Jy4lzqv5MIR994+PrIDDGnt298uZN4e6VzZoBLVsKj8PChHbG2AvFqHsQdu7caczuGWMFFbp7JVq1AgYP5uKAsReUSR9iYIxVsAJ3r2SMvdhMskDQaDQAgLy8vGp/rEdf2tNOcnJyOKdqqqblA3BOpoJzqv5MKZ/c3FwAz75LSyIhIqqKgCrS48ePER8fb+wwGGOMMZPl5OQEOzu7EttNskBQqVTIzMyEpaUlpFIeZ8kYY4zpS6PRID8/H9bW1jAzK/lAgkkWCIwxxhirXPzzmzHGGGNFcIHAGGOMsSK4QGCMMcZYEVwgMMYYY6wILhAYY4wxVgQXCIwxxhgrggsExhhjjBXBBQJjjDHGiuACgTHGGGNFmNzNmk6dOoXvvvsOSqUSnTt3xsKFC2Fubm7ssAy2bds27Nu3D1KpFC1atMCSJUsQExODOXPmwMHBAQBQv359k7ol9tSpU/HXX3+hVq1aAICQkBD07dsXs2bNQkpKCmrVqoUVK1agVatWRo5UP8eOHcOPP/4oPk5LS4NUKsWmTZswbNgwNGvWTGzbs2ePmHd1pFQqMWHCBLz77rvw9/dHampqictl9+7d2L59O1QqFfr374+pU6caOfriFc7pxo0bWLJkCXJzcyGVSvHJJ5/A19cXAODt7Y1GjRqJ7124cCE8PDyMFXqxCudz5syZErcHP/zwA44ePQq1Wo0xY8ZgxIgRxgy9RAVz8vb2xtChQ8U2jUaDO3fuYNu2bfD29sagQYOgVCrFGx1NnDgRQUFBxgq9WMVtt1Uqlcl/lkpEJkQul5Ovry8lJSWRRqOhGTNm0NatW40dlsEuX75Mffv2JYVCQUREK1asoPnz59PKlStpy5YtRo6u/Lp27UppaWk6z02ePJm2b99OREQXL16k4OBgY4T23BQKBfXp04eioqJoz549tGTJEmOHpLc///yTBg0aRO3bt6fw8HAiKnm53Lx5kwICAigzM5Py8/Np1KhR9Ntvvxkt9pIUl1NAQABFRUUREdFff/1FXl5elJubS/fu3aN+/foZM9wyFZdPSduD33//nYYMGUL5+fn05MkT6tOnD924caOqQy5TcTkVtHLlSpozZw4REeXk5FDnzp1JrVZXdZh6K2m7beqfpdKY1CGGiIgIuLu7o3HjxpBIJBgyZAiOHDli7LAM1qBBAyxatAh169YFALRt2xaJiYm4du0azp8/j5CQEIwZMwZ37twxcqT6S0pKQk5ODmbPno3+/ftj6dKlUCgUuHDhAgYNGgQA8PX1RVZWFu7evWvkaA23Zs0a+Pj4oHPnzrh27Rpu376NQYMGYdiwYYiOjjZ2eKXatWsXpk6divbt2wMAnj59WuJyCQ8PR69evVC/fn1YWFhg0KBB1fIzVjgnpVKJiRMnonPnzgCAl19+WbypW0xMDDQaDUaNGoUBAwZg165dxgy9WIXzAVDi9iA8PBz9+/eHhYUF6tWrh6CgIJNYRgXdvn0bv/76K+bPnw8A+PPPP1GrVi2MHTsW/fv3x5o1a8q8FXFVK267nZCQYPKfpdKYVIEgl8thb28vPra3t8fDhw+NGFH5vPzyy/Dy8gIAKBQKrFu3Dr169YKNjQ3GjBmDQ4cOYfjw4Zg0aRLy8vKMHK1+Hj16BG9vbyxbtgwHDhyAXC7HsmXLYGFhASsrK/F1prjMUlJScOjQIUyZMgUAUKdOHYSEhODgwYOYPXs2PvzwQ6Smpho5ypItXboU3bp1Ex9nZGSUuFxSUlKKfMZSUlKqNF59FM7JwsICgwcPFh+vXbsWL7/8Muzt7fH06VN07doVW7duxaZNm7Bjxw6cPXvWCFGXrHA+AErcHqSkpIiHHQDTWUYFfffdd3j//ffFdVChUKBz585Yv349/vOf/yAyMhL/+c9/qjLcMhW33e7SpYvJf5ZKY1IFQnEVpSnf7jklJQXvvPMOXF1dMXz4cKxevRpdu3YFAAQGBqJu3bq4efOmkaPUT/v27bF69WrY2trCwsICEyZMwOXLl4t9raktsz179iA4OBg2NjYAhOPXb775JgDAzc0NHTp0wKVLl4wYoWFK+mUmlUpBxdzcVSKRVHZIFYaI8O233yIsLAzfffcdAGDw4MGYPXs2zM3N0ahRIwwdOhSnT582bqB6KGl7YOrL6P79+4iNjcXAgQPF5/z9/fHVV1+hdu3asLKywujRo6vtMiq43S6YQ0E14bMEmFiB4ODgoPNLTS6X61TSpuT27dsYMmQIAgICsGTJEigUCp0BcVql3au7OomOjsaZM2fEx0QEMzMzKJVK5OTkiM8X3gtkCk6cOIEBAwYAEPLasGGDTk6A6SwnALCzsytxuZjyZ0ypVGLq1Km4fPky9uzZA0dHRwBAWFiYzuE67bpZnWVlZZW4PXBwcIBcLhefK7xHobo7efIk+vTpozO4/OzZszqH6qrrMiq83a6pnyUtkyoQunTpgujoaCQmJoKIsH//fvj7+xs7LIPJ5XKMGTMGs2bNwgcffAAAqFu3Lnbt2iV+yV68eBG5ubl47bXXjBmq3vLy8rB06VJkZWVBo9Fg+/bt6NWrF7p27Yp9+/YBAKKiomBmZmYyZzEAwu54uVyOtm3bAhB+AZw9exYHDx4EIGwwrl+/Dm9vb2OGaRAzM7MSl0uPHj3w+++/IyMjA0+fPsWhQ4dM5jM2d+5cEBF27NgBOzs78fm///4ba9euhUajwZMnT3DgwAEEBgYaMdKylbY9CAgIQFhYGPLz86FQKHDixAl0797duAEb4MqVK+Kuei25XI4VK1ZAqVRCqVQiNDQUvXr1MlKExStuu11TP0ta1a9EK0XDhg2xePFiTJo0CUqlEh06dMC4ceOMHZbBNm7ciJycHGzcuBEbN24EALRs2RJr1qzBkiVLsGLFCtSpUwdr1qwxmVM4u3TpgmHDhmHo0KFQqVTw9PTE5MmTkZGRgXnz5mHfvn2wsLDAqlWrTGo32/379+Hg4KAT8zfffIMFCxZgz549AIBvv/1WPPxgKhYtWlTscnnttdcwbtw4jBw5EiqVCj169ED//v2NHW6Zbty4gSNHjqBly5Y6YxFWrVqF999/H5999hn69+8PlUqF4cOHV/uCTiqVlrg9CAgIwK1btzBo0CCoVCoMGTKk2p2yWZp//vkHjRs31nnurbfeQlxcHAYOHAiVSoXAwEC89dZbRoqweCVtt2vaZ6kgCRV3oIQxxhhjLzSTOsTAGGOMsarBBQJjjDHGiuACgTHGGGNFcIHAGGOMsSK4QGCMMcZYEVwgMMYYY6wILhAYY5Wqd+/eyM/PN3YYjDEDcYHAGKs0t27dQsuWLWFpaWnsUBhjBuILJTHGDPLgwQOMGDECQ4cOxfbt22FpaYnPP/8cZ86cwZEjR9C4cWOsWrUKzs7OWL9+PaytrWFlZYVPP/1UnMbTp09hZWVlUje5YuxFw3sQGGMGS0lJQW5uLqKiojB48GB88MEHaNeuHS5duoS2bduKNxo6d+4cunfvjuDgYFy7dg3Xrl3D2bNn4ejoiE8++cTIWTDGSsMFAmOsXEaPHg2ZTAZPT09YWlpiyJAhsLCwQKdOnfDw4UOkp6cjNzdXvKsiINxqesaMGejcuXO1u9Y+Y0yXSd2siTFWfVhbWwMQbixUr1498XmpVAqNRoMLFy6gS5cuOu9ZuXIlnjx5gnXr1lVprIwxw3GBwBgrl7Luynnu3DkMGzZMfHz8+HEcOnQIBw8ehIWFRWWHxxh7TnyIgTFW4TQaDa5fvw43NzcAwO3bt7Fo0SKsWrUK9vb2Ro6OMaYP3oPAGKtwMTEx6NOnD8zMhE3M9u3bkZubiw8//BBKpVJ83dGjR3XGKDDGqg8+zZExxhhjRfAhBsYYY4wVwQUCY4wxxorgAoExxhhjRXCBwBhjjLEiuEBgjDHGWBFcIDDGGGOsCC4QGGOMMVYEFwiMMcYYK4ILBMYYY4wVwQUCY4wxxorgAoExxhhjRXCBwBhjjLEi/h89DHvmOUpTmwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063026 MassSpecGymID0062606\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063027 MassSpecGymID0062601\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063027 MassSpecGymID0062602\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063027 MassSpecGymID0062603\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063027 MassSpecGymID0062604\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063027 MassSpecGymID0062605\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063027 MassSpecGymID0062606\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063028 MassSpecGymID0062601\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063028 MassSpecGymID0062602\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063028 MassSpecGymID0062603\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063028 MassSpecGymID0062604\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063028 MassSpecGymID0062605\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063028 MassSpecGymID0062606\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063029 MassSpecGymID0062601\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063029 MassSpecGymID0062602\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063029 MassSpecGymID0062603\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063029 MassSpecGymID0062604\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063029 MassSpecGymID0062605\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MassSpecGymID0063029 MassSpecGymID0062606\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for (i, row_0), (j, row_1) in itertools.product(df_0.iterrows(), df_1.iterrows()):\n", + " print(i, j)\n", + " spec_0 = np.stack([utils.parse_spec_array(row_0['mzs']), utils.parse_spec_array(row_0['intensities'])])\n", + " spec_1 = np.stack([utils.parse_spec_array(row_1['mzs']), utils.parse_spec_array(row_1['intensities'])])\n", + " utils.plot_spectrum(spec_0, mirror_spec=spec_1)\n", + " plt.title(f'{i}, {j}')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "row_0 = df_0.loc['MassSpecGymID0063024']\n", + "row_1 = df_1.loc['MassSpecGymID0062602']\n", + "spec_0 = np.stack([utils.parse_spec_array(row_0['mzs']), utils.parse_spec_array(row_0['intensities'])])\n", + "spec_1 = np.stack([utils.parse_spec_array(row_1['mzs']), utils.parse_spec_array(row_1['intensities'])])\n", + "utils.plot_spectrum(spec_0, mirror_spec=spec_1, colors=[\"#5A5B9F\", 'red', \"#D94F70\"], figsize=(3, 1.5))\n", + "plt.savefig('spectrum_example.svg', bbox_inches='tight')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CCCCCCCC(=O)CC(=O)NC1CCOC1=O\n", + "CCCCCC(=O)CC(=O)NC1CCOC1=O\n" + ] + } + ], + "source": [ + "smiles_0 = row_0['smiles']\n", + "print(smiles_0)\n", + "smiles_1 = row_1['smiles']\n", + "print(smiles_1)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "massspecgym", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +}