From 62fa41b1168a219ce27ed76e707f56febf93aeeb Mon Sep 17 00:00:00 2001 From: Logan Ward Date: Wed, 15 Nov 2023 14:20:35 -0500 Subject: [PATCH] First notebook for comparing sampling methods --- .../run-all-methods.sh | 6 +- .../1_fit-forcefield-using-mbtr.ipynb | 50 +- .../run-all-dbs.sh | 4 +- ...ompare-sampling-strategies-with-mbtr.ipynb | 656 ++++++++++++++++++ notebooks/3_consolidate-results/README.md | 0 5 files changed, 692 insertions(+), 24 deletions(-) create mode 100644 notebooks/3_consolidate-results/0_compare-sampling-strategies-with-mbtr.ipynb create mode 100644 notebooks/3_consolidate-results/README.md diff --git a/notebooks/1_explore-sampling-methods/run-all-methods.sh b/notebooks/1_explore-sampling-methods/run-all-methods.sh index a8ed52b..348c81a 100644 --- a/notebooks/1_explore-sampling-methods/run-all-methods.sh +++ b/notebooks/1_explore-sampling-methods/run-all-methods.sh @@ -1,15 +1,15 @@ #! /bin/bash xyz=../data/exact/caffeine_pm7_None.xyz -for step_size in 0.02 0.01 0.005; do +for step_size in 0.04 0.02 0.01 0.005; do # Do the randomized methods for method in 0_random-directions-same-distance.ipynb 1_random-directions-variable-distance.ipynb; do - papermill -p starting_geometry $xyz -p step_size $s $method - > /dev/null + papermill -p starting_geometry $xyz -p step_size $step_size $method last.ipynb done # Test with different reductions for "along axes" notebook=2_displace-along-axes.ipynb for n in 1 2 4; do - papermill -p starting_geometry $xyz -p perturbs_per_evaluation $n $notebook - > /dev/null + papermill -p starting_geometry $xyz -p perturbs_per_evaluation $n -p step_size $step_size $notebook last.ipynb done done diff --git a/notebooks/2_testing-fitting-strategies/1_fit-forcefield-using-mbtr.ipynb b/notebooks/2_testing-fitting-strategies/1_fit-forcefield-using-mbtr.ipynb index 97390e2..cb29ff0 100644 --- a/notebooks/2_testing-fitting-strategies/1_fit-forcefield-using-mbtr.ipynb +++ b/notebooks/2_testing-fitting-strategies/1_fit-forcefield-using-mbtr.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "ebbbc7f5-3007-420f-861a-9f65f84436be", "metadata": { "tags": [] @@ -29,6 +29,7 @@ "from dscribe.descriptors import MBTR\n", "from ase.vibrations import VibrationsData\n", "from ase.db import connect\n", + "from random import sample\n", "from pathlib import Path\n", "from tqdm import tqdm\n", "import numpy as np\n", @@ -47,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "99bd4c92-9a7b-4e88-ac45-dbf30fbfc9e0", "metadata": { "tags": [ @@ -56,8 +57,9 @@ }, "outputs": [], "source": [ - "db_path = '../1_explore-sampling-methods/data/along-axes/caffeine_pm7_None_d=5.00e-03-N=2.db'\n", - "overwrite = False" + "db_path: str = '../1_explore-sampling-methods/data/along-axes/caffeine_pm7_None_d=5.00e-03-N=2.db'\n", + "overwrite: bool = False\n", + "max_size: int = 10000" ] }, { @@ -70,7 +72,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "a8be3c37-bf1f-4ba4-ba8f-afff6d6bed7d", "metadata": { "tags": [] @@ -94,24 +96,12 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "75d22086-f020-40d7-8327-1154491b9821", "metadata": { "tags": [] }, - "outputs": [ - { - "ename": "ValueError", - "evalue": "Already done!", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[12], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m (out_dir \u001b[38;5;241m/\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mout_name\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.json\u001b[39m\u001b[38;5;124m'\u001b[39m)\u001b[38;5;241m.\u001b[39mexists() \u001b[38;5;129;01mand\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m overwrite:\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mAlready done!\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", - "\u001b[0;31mValueError\u001b[0m: Already done!" - ] - } - ], + "outputs": [], "source": [ "if (out_dir / f'{out_name}-full.json').exists() and not overwrite:\n", " raise ValueError('Already done!')" @@ -140,6 +130,28 @@ "print(f'Loaded {len(data)} structures')" ] }, + { + "cell_type": "markdown", + "id": "0c8aae57-1863-4bad-a56b-31f7b8a6062b", + "metadata": {}, + "source": [ + "Downsample if desired" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e2dfe036-a173-41ff-817b-2e92349b9704", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if max_size is not None and len(data) > max_size:\n", + " data = sample(data, max_size)\n", + " print(f'Downselected to {len(data)}')" + ] + }, { "cell_type": "markdown", "id": "cb1a8e03-b045-49a4-95fd-61636a48fbad", diff --git a/notebooks/2_testing-fitting-strategies/run-all-dbs.sh b/notebooks/2_testing-fitting-strategies/run-all-dbs.sh index bf926cf..b39054f 100644 --- a/notebooks/2_testing-fitting-strategies/run-all-dbs.sh +++ b/notebooks/2_testing-fitting-strategies/run-all-dbs.sh @@ -1,8 +1,8 @@ #! /bin/bash notebook=$1 -dbs=$(find ../1_explore-sampling-methods/data/ -name "caffine_pm7_None*.db") +dbs=$(find ../1_explore-sampling-methods/data/ -name "caffeine_pm7_None*.db") for db in $dbs; do echo $db - papermill -p db_path $db $notebook - + papermill -p db_path "$db" -p max_size 5000 $notebook last.html done diff --git a/notebooks/3_consolidate-results/0_compare-sampling-strategies-with-mbtr.ipynb b/notebooks/3_consolidate-results/0_compare-sampling-strategies-with-mbtr.ipynb new file mode 100644 index 0000000..a1380fa --- /dev/null +++ b/notebooks/3_consolidate-results/0_compare-sampling-strategies-with-mbtr.ipynb @@ -0,0 +1,656 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "b592b18c-a459-4563-99fd-2ecd66474ed5", + "metadata": {}, + "source": [ + "# Compare Sampling Strategies using an MBTR Forcefield\n", + "Here, we hold our learning strategy constant and vary the strategies used in sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4f6bfbb4-9d13-45d0-88a6-7470111204fe", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "from matplotlib import pyplot as plt\n", + "from jitterbug.compare import compare_hessians\n", + "from ase.vibrations import VibrationsData\n", + "from dataclasses import asdict\n", + "from pathlib import Path\n", + "from ase.io import read\n", + "from tqdm import tqdm\n", + "import pandas as pd\n", + "import numpy as np\n", + "import json\n", + "import re" + ] + }, + { + "cell_type": "markdown", + "id": "f4e97ce7-31c1-4542-9aff-b06c83bbefd8", + "metadata": {}, + "source": [ + "Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "02e04cef-054c-47ad-9334-d1cf6d4412e0", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "target_mol = '../data/exact/caffeine_pm7_None.xyz'\n", + "target_method = '../2_testing-fitting-strategies/data/mbtr/'" + ] + }, + { + "cell_type": "markdown", + "id": "8874ea91-b4f3-432a-bd28-0d33b50e24ee", + "metadata": {}, + "source": [ + "## Load the Exact Result\n", + "The target molecule filename determines which molecule we'll look for. The name includes both the molecule name and method used to evaluate the hessian" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "db22a33d-e70a-4e7b-aad7-39aa4e552804", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "target_mol = Path(target_mol)\n", + "mol_name = target_mol.name[:-4]\n", + "atoms = read(target_mol)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "11895c35-43e9-4880-af59-be157df37b55", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "exact_hess = VibrationsData.read(target_mol.parent / f'{mol_name}-ase.json')\n", + "exact_hess" + ] + }, + { + "cell_type": "markdown", + "id": "16c37359-0d6e-4299-8f40-8fc78708e691", + "metadata": {}, + "source": [ + "## Find All Fittings\n", + "Find the approximate hessians produced using each method" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "20b2213c-d98f-47d2-a2ed-b628f00e7cf7", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "all_hessians = list(Path(target_method).glob(f\"{mol_name}_*-increment.json\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "2056b382-8566-4f2e-a574-961a3268d3c3", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + " 0%| | 0/7 [00:00 list[dict[str, object], str]:\n", + " \"\"\"Load the Hessian and parse the metadata from the filename\n", + " \n", + " Args:\n", + " path: Path to the run path\n", + " Returns:\n", + " Dictionary the includes the metadata:\n", + " \"\"\"\n", + " \n", + " # Get some of the basic information\n", + " _, sampling_method, sampling_options_str = path.name[:-15].rsplit(\"_\", 2)\n", + " sampling_options = dict(x.split(\"=\") for x in re.split(\"-([^\\d]+=.*)\", sampling_options_str) if len(x) > 0)\n", + " \n", + " # For each, load the Hessian on the full dataset and compare to exact answer\n", + " output = []\n", + " with path.open() as fp:\n", + " for line in fp:\n", + " record = json.loads(line)\n", + " compare = compare_hessians(exact_hess.get_atoms(), exact_hess.get_hessian_2d(), record['hessian'])\n", + " output.append({\n", + " 'sampling_method': sampling_method,\n", + " 'options': sampling_options_str,\n", + " 'size': record['count'],\n", + " **sampling_options,\n", + " **asdict(compare)\n", + " }) \n", + " return output\n", + "all_results = pd.DataFrame(sum([load_hessian(path) for path in tqdm(all_hessians)], []))\n", + "print(f'Loaded {len(all_results)} approximate hessians')" + ] + }, + { + "cell_type": "markdown", + "id": "0f243a23-ed89-4f5e-aeac-f23722ef10af", + "metadata": {}, + "source": [ + "Coerce columns I know should be numeric" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2d315d44-7564-468f-bd03-8bbedf8b424c", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "for col in ['d', 'N']:\n", + " all_results[col] = pd.to_numeric(all_results[col])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "eee03c3a-4a53-4e84-995a-c2191e6f6332", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
sampling_methodoptionssizedNzpezpe_errorcpcp_errortempsvib_freqsvib_errorsvib_mae
0along-axesd=2.00e-02-N=150.021.08.166528-101.299323[0.02782000372114755, 0.027820795543396722, 0....[-0.023739034722974034, -0.022232380301253324,...[1.0, 3.9291338582677167, 6.858267716535433, 9...[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ...[959.3636402803901, 759.1406554041445, 727.367...1152.794974
1along-axesd=2.00e-02-N=13380.021.0113.1229553.657105[8.747323012163849e-24, 3.328426105222898e-07,...[0.004080968998173518, 0.005588082399532877, 0...[1.0, 3.9291338582677167, 6.858267716535433, 9...[0.0, 0.0, 0.0, 0.0, 38.14534786742302, 75.405...[158.15829496434714, 122.16363911128738, 43.50...132.903641
2along-axesd=2.00e-02-N=16710.021.0116.0311576.565306[3.0712303813292223e-16, 1.5313382400470627e-0...[0.004080968998173211, 0.005573101859742928, 0...[1.0, 3.9291338582677167, 6.858267716535433, 9...[0.0, 0.0, 0.0, 25.510569349848872, 41.9066764...[184.25231094566078, 60.03568562880327, 40.696...133.313623
3along-axesd=2.00e-02-N=110040.021.0114.4546814.988830[7.78084200688863e-16, 1.850814964639692e-05, ...[0.00408096899817274, 0.005569907092497002, 0....[1.0, 3.9291338582677167, 6.858267716535433, 9...[0.0, 0.0, 0.0, 0.0, 0.0, 24.826702285067725, ...[207.89494720921027, 114.98856149662046, 102.3...129.924251
4along-axesd=2.00e-02-N=113370.021.0114.8798165.413966[2.819788555592938e-14, 3.901144610726155e-05,...[0.00408096899814532, 0.005549403796036138, 0....[1.0, 3.9291338582677167, 6.858267716535433, 9...[0.0, 0.0, 0.0, 22.174357227376618, 91.8111295...[107.28128928601775, 50.929564712133065, 33.04...119.199241
\n", + "
" + ], + "text/plain": [ + " sampling_method options size d N zpe zpe_error \\\n", + "0 along-axes d=2.00e-02-N=1 5 0.02 1.0 8.166528 -101.299323 \n", + "1 along-axes d=2.00e-02-N=1 338 0.02 1.0 113.122955 3.657105 \n", + "2 along-axes d=2.00e-02-N=1 671 0.02 1.0 116.031157 6.565306 \n", + "3 along-axes d=2.00e-02-N=1 1004 0.02 1.0 114.454681 4.988830 \n", + "4 along-axes d=2.00e-02-N=1 1337 0.02 1.0 114.879816 5.413966 \n", + "\n", + " cp \\\n", + "0 [0.02782000372114755, 0.027820795543396722, 0.... \n", + "1 [8.747323012163849e-24, 3.328426105222898e-07,... \n", + "2 [3.0712303813292223e-16, 1.5313382400470627e-0... \n", + "3 [7.78084200688863e-16, 1.850814964639692e-05, ... \n", + "4 [2.819788555592938e-14, 3.901144610726155e-05,... \n", + "\n", + " cp_error \\\n", + "0 [-0.023739034722974034, -0.022232380301253324,... \n", + "1 [0.004080968998173518, 0.005588082399532877, 0... \n", + "2 [0.004080968998173211, 0.005573101859742928, 0... \n", + "3 [0.00408096899817274, 0.005569907092497002, 0.... \n", + "4 [0.00408096899814532, 0.005549403796036138, 0.... \n", + "\n", + " temps \\\n", + "0 [1.0, 3.9291338582677167, 6.858267716535433, 9... \n", + "1 [1.0, 3.9291338582677167, 6.858267716535433, 9... \n", + "2 [1.0, 3.9291338582677167, 6.858267716535433, 9... \n", + "3 [1.0, 3.9291338582677167, 6.858267716535433, 9... \n", + "4 [1.0, 3.9291338582677167, 6.858267716535433, 9... \n", + "\n", + " vib_freqs \\\n", + "0 [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, ... \n", + "1 [0.0, 0.0, 0.0, 0.0, 38.14534786742302, 75.405... \n", + "2 [0.0, 0.0, 0.0, 25.510569349848872, 41.9066764... \n", + "3 [0.0, 0.0, 0.0, 0.0, 0.0, 24.826702285067725, ... \n", + "4 [0.0, 0.0, 0.0, 22.174357227376618, 91.8111295... \n", + "\n", + " vib_errors vib_mae \n", + "0 [959.3636402803901, 759.1406554041445, 727.367... 1152.794974 \n", + "1 [158.15829496434714, 122.16363911128738, 43.50... 132.903641 \n", + "2 [184.25231094566078, 60.03568562880327, 40.696... 133.313623 \n", + "3 [207.89494720921027, 114.98856149662046, 102.3... 129.924251 \n", + "4 [107.28128928601775, 50.929564712133065, 33.04... 119.199241 " + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_results.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a238ef1e-eae0-4195-a254-7c34fc63cc8d", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "random-dir-same-dist 48\n", + "random-dir-variable-dist 48\n", + "along-axes 16\n", + "Name: sampling_method, dtype: int64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "all_results['sampling_method'].value_counts()" + ] + }, + { + "cell_type": "markdown", + "id": "c04c6df3-882c-4ab8-954b-ff316ff1134c", + "metadata": {}, + "source": [ + "## Compute Performance Metrics\n", + "Get things like the error in ZPE or vibrational frequencies" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "16cdf7cf-4d09-415e-8996-3222ee33307b", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(3.5, 2.5))\n", + "\n", + "for gid, group in all_results.query('d==0.02').groupby('sampling_method'):\n", + " ax.plot(group['size'], group['vib_mae'], '--o', label=gid)\n", + " \n", + "ax.legend()\n", + "\n", + "ax.set_yscale('log')\n", + "\n", + "ax.set_xlabel('Training Size')\n", + "ax.set_ylabel('Vibration MAE (cm$^{-1}$)')\n", + "\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "7dc273cc-6b8e-47a9-8f58-31bd385368da", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAVQAAADwCAYAAABfaJz5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABoeklEQVR4nO2dd3wU1fbAv9vSG0lIgwAhoYXQEoo0AekoRX2KShXUh6AIQUBEBCugD+RZQAVRVH4CT4ooSFMgID0QBUMnFCEhBUivu/P7Y9klm+xudjebyv3y2U+YmTt3zmw5c+49554jkyRJQiAQCATlRl7VAggEAkFtQShUgUAgsBNCoQoEAoGdEApVIBAI7IRQqAKBQGAnhEIVCAQCOyEUqkAgENgJoVAFAoHATiirWoDqjEaj4caNG7i7uyOTyapaHIFAUMFIkkRmZiZBQUHI5dbbm0KhmuHGjRsEBwdXtRgCgaCSuXbtGvXr17f6PKFQzeDu7g5o31wPD48qlkYgEFQ0GRkZBAcH63/71lLrFeq1a9cYNWoUycnJKJVK5syZwxNPPGHRubphvoeHh1CoAsF9hK1TfLVeoSqVSpYsWULbtm1JTk4mMjKSQYMG4erqatfrqDUSRxJukZyZh5+7Ex1DvFHIxbyrQHA/UesVamBgIIGBgQD4+fnh7e3NrVu37KpQt51K5O3Nf+Kj3omLMpWcIl/SFH15c0gbBkQE2u06AoGgelPtw6ZiYmIYPHgwQUFByGQyNm3aVKrN0qVLCQkJwcnJiaioKPbt22e0r2PHjqHRaOzqaNp2KpGvNs/B0X8alxvsID7oOJcb7MDRfxpfbZ7DtlOJdruWQCCo3lR7hZqdnU2bNm349NNPjR5fu3YtU6ZMYfbs2Zw4cYLu3bszcOBArl69atAuLS2N0aNH8+WXX9pNNrVG4oftb3E26BCpCsPhfZpCxtmgQ/yw/S3UGpFyViC4H5DVpATTMpmMjRs3MmzYMP2+Tp06ERkZybJly/T7WrRowbBhw5g/fz4A+fn59O3bl+eff55Ro0aZ7D8/P5/8/Hz9ts7jl56ebtQp9ce5RN7Y10erTI1MYsskCV+1xDvdd9G1qRj6CwTVnYyMDDw9PU3+5sui2luo5igoKCA2NpZ+/foZ7O/Xrx8HDhwAtIG6Y8eO5aGHHjKrTAHmz5+Pp6en/lXW1MDZcz+QqpQbVaYAkkxGilLO2XM/WHFXAoGgplKjFWpqaipqtRp/f3+D/f7+/iQlJQHwxx9/sHbtWjZt2kTbtm1p27YtJ0+eNNrfrFmzSE9P17+uXbtm9vqS5qZFclraTiAQ1GxqhZe/ZMyYJEn6fd26dUOj0VjUj6OjI46Ojnz22Wd89tlnqNVqs+1b1m8Ct8vut2X9JhZdXyAQ1GxqtIXq6+uLQqHQW6M6kpOTS1mt1jBp0iTi4+M5evSo2XYdWo/GTy0hMzENLZMk/NUSHVqPtlkWgUBQc6jRCtXBwYGoqCh27txpsH/nzp106dLF5n4/++wzwsPD6dChg9l2CqUDs5qOACilVHXbrzUdgULpYLMsAoGg5lDth/xZWVlcuHBBv52QkEBcXBze3t40aNCA6OhoRo0aRfv27encuTNffvklV69eZcKECTZfc9KkSUyaNEnv8TNHn26zWAwsOLeam4p7++uqYVazEfTpNstmOQQCQQ1Dqubs3r1bAkq9xowZo2/z2WefSQ0bNpQcHBykyMhIae/eveW65qeffiq1aNFCatq0qQRI6enpZZ5TVJgvHdr7rhS1MlyK+CZCevizVeWSQSAQVD7p6ekW/+aNUaPiUCsbq2PS1EU8tyKcw06OPBMwmln9p1e8kAKBwG6UNw612g/5axQKJU8rfBiYeZvODzSvamkEAkElIxSqESwNmzJG79G7wMG+mawEAkHNQAz5zWCr+a/WSMRdu03slds8372xKJ8iENQQxJC/GnIyJZ4Ra3+gICuUfuEBNPIVFqtAcD9Qo+NQKwpL41CNolHz9fbnUPn/hLvbn+w7n2J/AQUCQbXEaoV69uxZ5s2bR+/evQkNDSUwMJDWrVszZswY/u///s8gW1NNxdKVUkaRK2iVmwOAu/MFYs6n2lk6gUBQXbFYoZ44cYK+ffvSpk0bYmJi6NChA1OmTOGdd95h5MiRSJLE7NmzCQoKYuHChbVCsdpKhEdjAIqckjh4MY1CtWW5BAQCQc3G4jnUYcOGMX36dNauXYu3t7fJdgcPHuSjjz5i0aJFvP7663YRsqbRMrA9XLlAtkM+2UV3iLt2hw6NTL9nAoGgdmCxQj1//jwODmWvSe/cuTOdO3emoKCgXIJVJeUJmwJwD2pPyPnvSHBQIXf6h33nUoRCFQjuAywe8luiTMvTvjpRrjlUgIBWtLo75eHofJnYqxbk+BMIBDUeiy3Ujz/+2OJOJ0+ebJMwtQb3QCIkFZuB9iHJrBzWsaolEggElYDFCvWjjz6yqJ1MJhMKVSbjId+2hOWmEB45EaVCRKcJBPcDFivUhISEipSj1uH/9DpsT3FtAo0arhyArJvg5g8Nu4BcUfZ5AoGgUij3SindytXatLyyvE6p4qRk5rN45zkupWSx5oUHbH+f4jfDtpmQcePePo8gGLAQwoeUW06BQFB+bB6Lfvvtt7Rq1QpnZ2ecnZ1p3bo13333nT1lqzLK7ZS6y9+pf7P8rw/YdGEthxNucTktx7aO4jfDutGGyhQgI1G7P35zueQUCAT2wSaFunjxYl588UUGDRrEunXrWLt2LQMGDGDChAkWz7XWeiSJixvG8sOFdfj4ngCwbRmqRq21TDGWw+buvm2vadsJBIIqxaYh/yeffMKyZcsYPfpe8bmhQ4fSsmVL5s2bx9SpU+0mYI1FJiMCRyCPHMUNQE3MuVRGd25kXT9XDpS2TA2QIOO6tl1Id9vlFQgE5cYmCzUxMdFoEbwuXbqQmJhYbqFqC4382uCm0VBIEXLHmxy8mGr9MtSsm/ZtJxAIKgybFGpYWBjr1q0rtX/t2rU0aSJq0OuQB7ahZb52xZiHZxLZBWpOXL1jXSduFsYKWNpOIBBUGDYN+d966y2GDx9OTEwMXbt2RSaTsX//fn777TejiramYTcvf2BrIg7lc9jZCb+6ydxJ1s6jdgyxYhlqwy5ab77JYb9Me7yh7WWzBQKBfbDJQn388cc5fPgwvr6+bNq0iQ0bNuDr68uRI0d49NFH7S1jpWMvLz/+LWl110KVlJdo7OuKp7PKuj7kCmj1hImDd0OwBiwQ8agCQTXA5jjUqKgovv/+e3vKUvtwdCfCOQBQoyGD7dFdUcmtVKigHc7LlaB0goKse/s9grTKVMShCgTVgnIF9icnJ5OcnIxGY+hoad26dbmEqk34Nx/Czszr+HeahMwWZQrQeRKEDwWVC1w5CJd2g4ML9J4rLFOBoBphk0KNjY1lzJgxnD59mpI1/mQymV1WGNUa+r5NQLHNgiIN1+/kEmJtnSnP+tq/Lt5wdDl41IO+b9tNTIFAUH5sUqjPPvssTZs25auvvsLf379WLTutSE7+k87wLw9Sx8WB/TN7lf2+ndkK7v5QL+rePv+W2r8Z1yHnllbBCgSCaoFNCjUhIYENGzYQFhZmb3kqhEcffZQ9e/bQu3dvfvzxx0q//o30K8w/MJdUdT5F6tFcv5PLpdRsQuu6mT4pPwt+ngzZKTDiR2jSV7vfyQO8GsKdK3DzbxHMLxBUI2zy8vfu3Zs///zT3rJUGJMnT+bbb7+tsuu7fzWAPcmxnEo7RbsQ7TNs37kylqEeXqZVpnVCoHFPw2P+Edq/N0/ZX1iBQGAzNlmoK1asYMyYMZw6dYqIiAhUKkNny5Ah1cvr3KtXL/bs2VNl13f3aUKjgnNcdlDh4BOD4kZd9l3wZWzXEOMn5NyCPz7R/r/XbFCUcGYFRMDZLUKhCgTVDJsU6oEDB9i/fz+//vprqWP2dkrFxMTw4YcfEhsbS2JiIhs3bmTYsGEGbZYuXcqHH35IYmIiLVu2ZMmSJXTvXn2Gwru8fEi6pfXGx2VswqUhHC5ax7ZLbzKgcT9to+K5Ts9uhfx0rSUa8XjpDnXzqElCoQoE1QmbhvyTJ09m1KhRJCYmotFoDF729vBnZ2fTpk0bPv30U6PH165dy5QpU5g9ezYnTpyge/fuDBw4kKtXr9pVDlvZdWUX0XeOkVfSAaVIZ/q+aey6skubfm9JBKx6BNaPh1PrtW2a9AO5kY9IN+RPPg3qooq9AYEBao3EwYtp/BR3nYMX01BrjGUBE9yvyKSScU8W4O7uTlxcHKGhoRUhk0lkMlkpC7VTp05ERkaybNky/b4WLVowbNgw5s+fr9+3Z88ePv30U7NOqfz8fPLvFtcDyMjIIDg4mPT0dDw8PKyWV61R0399f27mmE5cEuDgybazp1AYTc8ngye/LR24r9HAuW3aob9nMIgoC6tQaySOJNwiOTMPP3cnOoZ4o5CX/R5uO5XIWz/Hk5iep98X6OnE3MHhDIgIrEiRBZVERkYGnp6eNv/mbbJQH3vsMXbv3m3LqXaloKCA2NhY+vXrZ7C/X79+HDhwwOr+5s+fj6enp/4VHBxcLvmOJx83q0wBkgrSOe5kpkKssVyncjk0HwReDYQytZJtpxLptvB3nl5+iFfWxPH08kN0W/g7206Zz5K27VQiL35/3ECZAiSl5/Hi98fLPF9wf2DTHGrTpk2ZNWsW+/fvp1WrVqWcUpVVpC81NRW1Wo2/v2GmJX9/f5KSkvTb/fv35/jx42RnZ1O/fn02btxIhw4dSvU3a9YsoqOj9ds6C9VWUnIsSyidojC12qmSc53W8ppVOqVYciygU4rLRkYatTSL1Brmbf7bZIpvGfDWz/H0DQ+wyNIVWI6to4mqwmYvv5ubG3v37mXv3r0Gx6qi6mnJAHlJkgz2bd++3aJ+HB0dcXR0tFu2qboudS1rV9Z1jOU6vX0Z/lyLRqbgcP1ny/+Fq+U1q9Qaibd+jjdX94DodX8Se+U2sx8O1x97+stDHL18iyIzc6USkJiex5GEW3QO9bGr3PczNXGKxebA/uqAr68vCoXCwBoFbY6BklarNUyaNIlJkybp51NsJdIvEn+VB8kF6UjGhuaShJMk0SovHzVw3MmRFIWCumo1kXn56G1DY7lOM5Ngz/uk4MPTeS30u81+4UxZoLqaVSXVja5mVfF53BpqxR5JuFVquF6SnAI1a49eM1Coakkyq0yLk5xpvv/7FVusTFtHE1WNVQq1c+fODBs2jKFDh9K8efOKksliHBwciIqKYufOnQZpA3fu3MnQoUNt7tdeFqoCeO3WbaLd5MgkyVCp3vUF5snljAzy57ZCQbLy3sfhX1TEa2l36KOsYzTX6c40H/oC/qThSRbpaFddmfzCmbJA+82HHbMwXbNKpp3Hbf4wnNlSI63Y3AK1xcqudwvDh9eiJ9pw4tptJv8QV+a5fu5OtohXq7HFyixrNFGdp1isckpNmDCBI0eO0KFDB5o2bcr06dPZt29fqQQp9iQrK4u4uDji4uIArXUcFxenD4uKjo5mxYoVrFy5ktOnTzN16lSuXr3KhAkTbL6m3fKhXjlAn9TrLE5Oxa+Ecg5Qq3n+TgYOGg1nHR1JLjGPmqxQEO3nw66Oo0pZgGqNxJvbrnJVo51SaCG/FyKm+yTe+jn+XkiPuaqpP46xrGbVhheM9iFlJCKtG83Z3asrNYTIkvCly6nZzNv8Nx3e20VBkWWlZ55sbzhnHuztwsOtggj0dMLUT1cGuDsquZKWbeVdVB5VEe5lrSPvdnYBRxJu8f7WeLOjieJTLNUNqyzUMWPGMGbMGPLz8/ntt9/46aefGD58OIWFhTz88MMMHTqU/v374+LiYjcBjx07Rq9evfTbOqfRmDFj+Oabbxg+fDhpaWm8/fbbJCYmEhERwdatW2nYsKHN17Rbxv67c599cnLplZNbakgPsN7djVsySnnrJZkMGbAw8Xd6aWagKKZUdcPXM6oGNCCFFrIrHOLeMNVgTi/Eq+yqqZZwyni4mQwJjQTue+bw4MG6zBnSqsKHYttO/sPmzetRZieTjBdHNM3x93Rh7uBw+rcM4OClNFbuv8xvZ27qBgIkpGYT6OlEUnqeqQA1AjydjFZTUMhlzB0czovfH0eG4bum287ML+K1DSf585905g0Jx1FZfaZBqmIu0pI565nr/6JPC3+UCq1dN/3HP9l1Otniaxy6lEanEG/kJqzUqnBo2RSHWpLDhw+zefNmNm/ezMWLF3nooYeYNWsWXbt2tYeMVUZ5Y9JI2KcN1jfBUSdHxgWWPde7sv9KOgTci0r4Ke46r6yJY6ryR15RbmBdUQ9mFP271HmDWwcxs3ky9Tc/ab3sNvBUwRsc1oRX6PzWie2r8D8wjyDZPevkhuTN24Wj2abpSD0vJ67fuac4ejary7iuIXRv4sv2v5N48fvjQGmlCJQptynFNOfhcC6mZLF41zkkCdoEe7FsRCRBXs52uefyYGou0tJ7BtsU08GLaTy9/FCZ8n1e7PoLt53h5z9v4OPmwJ/X0ss8F7Tv/6BWgTzSOpC2wV56Z7StD5Hy/ubLlWBaR6dOnejUqRPvvfceFy9eZPPmzaL6KRSrB5WIMWswWWHZ218y/EpXRiVe0wCA5nLjq8J+/usGslMH+NhMmKsOSTIV0ioDZy/IvV1mH37cASpufkv990+0PTi51DsZwC2WqpbwYuEUtt/piJNSzhPtgxnTpRFhfvcyeg2ICGTZyMhSP7QAC621ARGB9A0PMKlcWtX35JU1cfx57Q6DP9nPJ0+3o0uYr93u31rsMRdpjWK6lV3Aiau36Rrma/GcdWKxh9+M/s2YOaA5ao1Et4W/mx1NOKkUyGXakdhX+xP4an8C9es483DrQOq6O/LeL6erxKFlF4VanNDQUKZOnWrvbisVuw355Qqtw2bdaDAyWCwzXOouxcOvYs6lMHvjSQDOSFqF2lB2ExkapGJT4p7OKtrU9+RWQh2LxdVIYPi70m6oO0xAETPf6DnFScar4kKINGqKtsxAVUpG7bZGgrmq79iZ355Pn2lPn3Djln9ZSrEsFHKZyfvq2cyPX17uxoTvY/n7RgYjvzrMGw+HM66biSQ4FUxZkQ3FP6v2jerwz+1cAj2dcFJppyvK8rTPGtgcZwcFx6/e4cTV21xOywHgxwmdLXbQNQ+8ZwXqrMuyplgAPhrehp7N/Nh7LoVf/krkt9M3+ed2Ll/svYSrg/F1h5Xh0LJYodapU8fiRNK3blW/yWJrsFfYFKD1fj/5rVHveFT/93E89hF50i2j1qEMGf4u/kT6RXI7u4B3tsSz4fh1ALxdHLia40ff/A+4JAXqlamum4WPa+cys3LbkvvxcpxybyIz8jXTSJCED+8UjmSO6juCuPfZSR5B5Dz0Hq3WKNnv6E0At0ops+J9HNHci/xIvJNr9m2xdhiZf3E/jjlJmPIMyWUQRBod5WfILog0e21zSrG8BHu7sP7FLryx6RQ/xv5jUJSxsuf0LLUSkzPzuJKWTZ/FMQD4uDoQ6OnE+eQss3Og7/96ptSxMD83svKL6N6krs1z1mD5aKJ/ywD6twwgt0DN7rPJrDqQwOEE06Opio4ZtlihLlmyxO4Xv28IH6INOyoRv6mQK5gmKXk/dhYyZEglvnoSEjM7zuRiSg7PLD9EalYBMhmM7dKIV/s1Y9/5FK0338wXzs3ZEQZ/COtGlRJL5+h9q3AU2zUd2Z7fgY7yM/hxh2S8eGXwGB4Iq4vyf9t4p2gMS1UfocEwNKR4H5piR2ZvOsn+i6kMigikWxNfvdUD1g0j429k8PFv53E9v5NFFsSk+HGnysOXnFQKPvxXa55sH6xXGNtOJTJvczxJGZXnGPJxtWCuB224163sQlwcFOQUqEnLLiAtu8Cic1vV8+Ch5v5ENqxD2/peeLrce4CUZWXOHRxu9oFizWjC2UHBoFaBFKo1ZhWqjoqKGbZYoY4ZM6ZCBKiO2G3IXxy5wujy0acjHsHHzZF3D87ndsG9uVKdgvV09CTE15W67k7UcXFgweOtiWqoHcZb/IULHwJNB8I5w3SLSfjolSmABjmHNMVWCWUXIpPJOPx6bzydByA7E1nK0i7ZB2itxdxCDRuOX2fD8eu4OSp5qLkf/+7RmGu3cswOIxf+qzWdG/sQ7H0vUmTb30k8IPcEC/RDkaufSaunMpHJZAbKdMJdZ1hxKnpOr3OoLx5OSjLyjGckK24lKuQy/n6rPxm5RdxIz2Xj8X/4cl/ZC3ie696YoW3rGT1W3jlrsH40YenDtKIeuuX28ufm5lJYWGiwzyaPeDWk3F5+C7hnreWgcElApsykjoMPgfXOkFDwGyGeIawfvJ7kzCJ83RxKh+MknYQDn4KTJwz6wPhFNGpYHA5ZSdDrDc4V+vLm76kc0TQ3sCpL8sPzD5T+MmvUHNnzM9t+24Uvd1iufpjbaN8bnRr/7JlI6no4svVkIttOJel/TGteeICpa+PKXLE0rG0QS55qB2iXEX8Rc4lujevQ8n9dISPR7NTFX/+KYUCr+mb7r0x0DhZT96xTavtnPlTu4X9eoZpPf79AVMM69GruB8DWvxKZ9H/WRzZY6qU3+h0pQWVOdVji0DL3fleJlz87O5uZM2eybt060tLSSh0XVU8tw3DSX446R5sOMQVIueWDd7OjJKQn8M3f3/B86+eNd1KQDX+t0VZBNaVQE2K0ytTJC7q+QqhcxZWjvyOV8SM3aunJFXR8aBgt4t7FPeM8cVIYOzTakK6SlkeHRt7MeTicuH/usOdMMhqNVKYyBbiQnHVPFpmMCT3upom86+DTORd0aO5GKNzsPLfylKmFS3CtcQyVZ05v3/kU3th0iitpOdTzcua3aT1wUikY1DqQZXLrrcSOId7lmgMtTkXOWRu7VnmnGsqDTQp1xowZ7N69m6VLlzJ69Gg+++wzrl+/zhdffMGCBQvsLWOlUyFD/hKYC2kBQONCYcojUPf/+OKvLxgQMoBgdyOZr/zuDtHNVUE9+T/t35aPgtIBBeWf33Jv0hVizzO3bTYPN21r0vKQy2VENqhDZIM6/BR33WR/xXn+wcbGD4QPgUe/QLbxBYPdha6BKB9eSLuWti83tgorEslY4xgqC2OW3u2cAt79JZ5NcVpZAjycmPNIOI7KeyMPWyIbqloxlQd7TDXYik0K9eeff+bbb7+lZ8+ejBs3ju7duxMWFkbDhg1ZvXo1I0aMsLeclYpdvfwmsCRZR2ZqKzqERXIm/TjvHX6PZb2XlY60MKiCegpCHjQ8rlHDhV3a/7e+F+Bf7i9dcCeI/YZ6mX9Sz8QcWknsMr9Vt6nhdvgwHP+10roELeVJ8GJNIhmsv+f8IjUjVxyme5O69G8ZQFN/N2QymVFHnqezikK1hpwCNTIZjOnciGn9muLupCrVvy1WYlUqpvJS3vA4W7FJod66dYuQEG1snYeHhz5Mqlu3brz44ov2k64WY5nlIqN/wItczJzIH9f/YNeVXXg5eZGSk0Jdl7pE+kVql6QGtCpWVrqEQpUr4OVYOLcdgh8wOFSuL11wJ+3fGyegKB+UjmWeYpdhZNpFw+2CbOuUaXnSFGrUZSzjLZZI5q5M1t7zgQtpHL18m6OXb7N45zka+bjQxN+dnfGlUzim52p9F8F1nPn0mUjaBHuVdfdWU1WKyR5U5lSDDpsUauPGjbl8+TINGzYkPDycdevW0bFjR37++We8vLzsLGLtxFLLpWXdJrzg/ALxafEsOLqA5Jx7a539Xfx5reNr9PFvCWd+MV20z9EdWv3L6CGbv3TejcHFF3JS4UYcNOhU5il2GUamntf+9QmDtAuQetZyma20Lktx5YBliWSKJQS39p7bNfDig8dbs/3vJPZdSOVyWo4+YN4URRqJiHoVM5KCqlFMNRWbSqA8++yz/Pnnn4A2y/3SpUtxdHRk6tSpTJ8+3a4C1lZ0lou5DEaBdy2XMK8w9lzbY6BMAZJzkoneE80u1d1ebp407ERjWYYlm5DJoMFdi/faYYtP0w0jAzwNHygBnk6WhQ+lXdD+DR8Gj3wEj35h2YXLtC4xXm6mOMYSfVvQzpp79nJx4MkOwXw1tgPH5/Tlld5Nyrxcdc28dD9ik4VafGlpr169OHPmDMeOHSM0NJQ2bdrYTbiqojKcUpZaLqBhwZEFpYL+QRv4L0PGwus76CWTo5A0hovyj38DR7+CLpOhzXD730RwR61lbIVChXIOI3UKtV6kdmhtKTZYl6Uwlujbwna23LObo5LGdV0tuqRIbl09sMta/gYNGtCgQQN7dFUtqAynFFg26X806ajZQn8SEkl5qRwf/zMd6nczPPjXOq2jylLLylpaDAHvUK1itRKbh5HNHwGvYPBrUXbb4thoXRrQsAu4B0GmKcUs087HGkkIDrbdc1UHqguswyaFOnnyZMLCwkrVjvr000+5cOGCWKZqBWVZLhYX+ivIMNxx+wpcPQjITM6flhvvEO2rMulRbErp1iW4/Ae4B0KTPubPK4d1qUeugAcmws43jBy8a2kOWGDXkjD2jAcVVDw2zaGuX7/eaK7TLl26mK17LzCOznIZ2rYenUN9DIaBFhf6K9lOF3sa0l1rNdVGzm6DzS9ppzbKQpdK0dystUc9k9alnq4vw9ClWodccTyCynZq2YBuauiuhAZU93jQ+xGbLNS0tDSjQ2EPDw9SU1PLLZTgHpF+kfi7+JOck2x0HhUgwCWAyNw8WNEXPOvBv77WDvcBWlVwcunU83BqPTjXgU6lk1zblcwkkDRai1QmuxeTmnKu7HMNUimWxErrst0IaPNUpRUrrMnxoPcbNinUsLAwtm3bxksvvWSw/9dff6VxYxOrXAQ2oZAreK3ja0TviTaakQogun00CoUD/HME0oMg6S9tOJHCseKL56WcgT3zwa9lxSvUg5/CgU/ggUkw4H2oezdd4K2LoC4ERemAdgN0qRQ3TdDGr+rwCIJOE8wP9+9cg+TT0KSvVpmbSHZTUdTkeND7CZsUanR0NC+99BIpKSk89NBDAPz2228sWrRIzJ9WAH0a9mFxz8UsOLLAwEGlU7B/pfzFwDYTtTszb8C2Wdr/N+mnTZpSkegC/JPjIfeONrt/RaEL6tfN23rUAwc3KMjSzqfWbVZ2H8ZSKebc1hYr9GoIEw+Cykjpkt/e0k6jdJsKfebZ7ZasQcSDVn9sUqjjxo0jPz+f9957j3feeQeARo0asWzZMkaPNjakqllURtiUtfRp2Idewb04nnxcv1IqtyiXT058wpPNnoSLu0GmAEkNV/7QnnT1gDaYvSKtVDc/qBMCtxPg+jEIK8M5VB50IVM+d5OlyGTg20S7WivlrGUKFUpbl3kZ4BagvYe9H0CfuYbt/4m9Oyct0+ZDEAhMUO70fSkpKTg7O+Pm5lZ24xpGZaTvKy9qjRrFmS2wbjRqpBKVVQtQQIU4SwzY8G9txqseM6HX6xVzDXURvBcAmkKYchK8Ghhe+6E34EELFpXkZWitWnkJf+zpX2DtCJAr4d8x4N9Su1+S4OuB2oiJNs/Ao8vse1+CakV5f/M2efm///57/f/r1q1roEzFSqnKRQGwbSa7XJx4qEE9xgX6M9PPl3GB/vQPDmSXi3PZK4DKiy4O9WrZ+TNt5s4VrTJVOoFHsRR91jimAH6aCAsbaR1pxWnxiDbGVVMEm1+BSzFw8keI+UCrTJXOWqUtEJjBJoX60ksv8csvv5TaP3XqVANlK6gErhxgV9Ftpvr5cquE1ZWsUBDt58OuolvaOcOKQrcE9Xqs1pI0h0atLa998kftX0sVvX7+NNTQumz5KIzaBP3etayfG39Cfjq4GglHG/iBVmFfPwrfDob142H3+9pjTftpIygEAjPYNIe6Zs0annrqKTZv3syDD2qzG7388sts2LCB3bt321VAgXnUmYks8Llb2bREaj9JJkMmSSz0qUOvzEQqJqgHrbfd0UM7PE6/qk2cYozyZHoqOX+qw7ux6euVJOeWVj6AQCNLpK/HQpGJJZzxmyt+PlpQ47HJQh0wYACff/45w4YN49ixY0ycOFGvTJs3b152BwK7cVydyU2lspQy1SHJZCQplRxXZ1acEHIFTNgHr10xr0zXjS69nl6X6Sl+s/lr1IvU5iRo/ojtct44of3r3bh09IM+eYoZKnrqRFDjsXkt/1NPPcXt27fp1q0bdevWZe/evYSFhdlTNrvwyy+/MG3aNDQaDTNnzuS5556rapHsSoqHZUsqLW1nM3UamT5mQx7RUjR44N7UQknObdfO34YPhaC2puVIjNP+DTTSxh7JUwT3PRYr1OjoaKP7/fz8aNeuHUuXLtXvW7x4cfklswNFRUVER0eze/duPDw8iIyM5LHHHsPbu/ase67rapmitLRdhVDRyipuNcT/BC4+5hXqjTjt36B2pY/ZI3mK4L7HYoV64sQJo/tDQ0PJyMjQHy9VoqMKOXLkCC1btqRePa0zYdCgQWzfvp2nn366iiWzH/eWpt40mTzD3yWASL/IihVEkuCnl7QxsM9uNcwfUEwJqaFEaFf+vbldU8qqKF87v+kTpnUmlfyO1W0O/FR2smmdhWpM6dojeYrgvsdihVoVzqaYmBg+/PBDYmNjSUxMZOPGjQwbNsygzdKlS/nwww9JTEykZcuWLFmyhO7dtVbOjRs39MoUoH79+ly/blmhuJqC4dJUjCxNlTGz40xtqZSKRCaDpD+1wfHXjkDLYfeO3VVCu1ycWeBTRzvnexf/oiJeS7tNn5xc08oq9bw2FtS5Dsy8XPq4rwWhUxoNtHpCO48a0Lr0cV3ylIxEjE9NmE/NJxCAjU6pyiI7O5s2bdrw6aefGj2+du1apkyZwuzZszlx4gTdu3dn4MCBXL2q9eQaW7NQnSxoe6Fbmurn4mewP8AlgMU9F9OnYQWuXiqObhlqyYTTHvXY5epCtJ8vNxWGil0b2uXLLl8zmZ70Hn4Tc/S6FVIpZ7SWsjHkcuj9JozaaHx5rC55CmAyr5OdU/MJah8WW6gTJkxg9uzZBAcbKWVcgrVr11JUVFTu6qcDBw5k4MCBJo8vXryY8ePH6x1NS5YsYfv27Sxbtoz58+dTr149A4v0n3/+oVMn07WP8vPzyc/P129nZGSYbFvdMLY0VV/Er7IIfgCOrjBUqFkpqFc/xgJvL63dZzK0y5teYDy0qyyF6hMGyCDvDmSnaJfD2oIueYrR0K4FImRKUCYWK9S6desSERFBly5dGDJkCO3btycoKAgnJydu375NfHw8+/fvZ82aNdSrV48vv/yyIuWmoKCA2NhYXnvtNYP9/fr148ABbRB7x44dOXXqFNevX8fDw4OtW7fy5ptvmuxz/vz5vPXWWxUqd0WikCvoENBBv63WqNl9dTftA9rj7uBe8QLoVkzdOAEnVmtzhv7+DsdzbnDT0/TcoySTkVSQzvHk4wby69EF9ZeMQdWhcoY6DeH2Ze2afmMKNfEvrWJ09S19rDjGkqdUYGo+Qe3CYoX6zjvv8PLLL/PVV1/x+eefc+qUYYVNd3d3+vTpw4oVK+jXr5/dBS1JamoqarUaf3/DH6q/vz9JSUkAKJVKFi1aRK9evdBoNMyYMQMfH9PZembNmmUQzZCRkWGRRV5deWX3K+z9Zy/T209ndMtKSFqTGIdaJue4o4qUXa/qnU4pnpZFVZisTpCmq3RqpmCdbzOtQk09azxSYO0IuHMVnv217HnQSk7NJ6g9WBWH6ufnx6xZs5g1axZ37tzhypUr5Obm4uvrS2hoaJXMT5a8piRJBvuGDBnCkCGWDdUcHR1xdHSsltmmbKFHcA/2/rOX/zvzf4xoMaJih//xm9n1ywQW1A8wcDrVLSoiqLCM5ai6tqaqE5Q15Aft0tNBH4CnkdpmObe0yhTAL9wiWQQCW7DZKeXl5UWbNm144IEHCAsLq3Rl6uvri0Kh0FujOpKTk0tZrdYyadIk4uPjOXr0aLn6qWoeafwIno6eXM+6zp5reyruQho1u35/jWg/n1JOpxSFgj+dnXCUtBVajSHjbtUBY6FdObcg97b2/+aWmNZtql1cUDKLFNwLl6oTUrH5WgX3PdXay28OBwcHoqKi2Llzp8H+nTt30qVL+UJbPvvsM8LDw+nQwch8Xg3CWenME02fAOC7099V2HXUl/ezwFky6nRCJgNJQqXRAKaVqsnQLrkSHl4MPV4DBxfbBDQX0C8Q2JFqrVCzsrKIi4sjLi4OgISEBOLi4vRhUdHR0axYsYKVK1dy+vRppk6dytWrV5kwYUK5rltbLFSA4c2Go5Qpib0ZS3xafIVc43jSUbP5BJDJyFIomBjYs1RoVx3HOizu+ZHp0C4nD+gwHnrNMi+ERgO758P/xkJeuuEx3Rp+c6uoBAI7UK0V6rFjx2jXrh3t2mkti+joaNq1a6f31A8fPpwlS5bw9ttv07ZtW2JiYti6dSsNGzYs13Vri4UKEOAaQN9GfQFYfXp1hVwjRWHZ16iBZwjbH9/Oyv4r9cP7x5o8ZnWcrFqj5mjSUbZe2srRpKOoNWrtUP/4Kvh7o3YhQHHMreEXCOyI1Rn7JUni6tWr+Pn54exspPZOLaImZOy3hJMpJ3lm6zO0qduGVQNW2d05dfTGIcbtfL7Mdiv7LqdDkDbByZ5reziceJjeLsG0T70KYX2hflTpkxJitMUG/VuCoxu7ruwqVVvL38Wf1zq+Rp89H0PCXm2Z53Z3Y6BzbsEHd2tQzbwi5lAFZinvb97qbFOSJNGkSRP+/vtvmjQxE8ZSg6ktXn4dreq2Yu0ja2nq1bRCAv8jAzrgr/IguSAdyciwXyZJ+Dt6EVksxrRncE96BveETZMg7nsozDGuUH99DZL/hmf+xy5HOdF7okstr03OSSZ6TzSLPdrQB7QrpnQoVDDkU23Gf6FMBRWM1QpVLpfTpEkT0tLSaq1CnTRpEpMmTdI/rWoDN7JuMPn3ycYtu3IuTVXIFbzW9S2i90xFJkkGSlUmSSCTMbPLPOPKO+RBrUJN2Ff6mEajLRENqL0bsWD3RKNltKW7zq6FORe0q61Si63pd3SHyFEG7dUadbkfLPboQ1D7sCkf6gcffMD06dNZtmwZERER9pZJYGd2Xdll3rIr53r/E8knuJ51nQ96fMh/jv7HUGm7BjDThNLOLcrlLzd3FE6OtE+MK12GOuO6NoO+XMXx/FsG/ZZEQiKpKIvjTo50SDGddcrslIGF74E9+hDUTmxSqCNHjiQnJ4c2bdrg4OBQai711q1bdhGuqqhNQ361Rs2CIwvMW3ZHFtIruJdNFpZao+a9Q+9x9vZZXmj9Atsf326x5bbpwibeP/w+XeoG0P7aFe1yz+aD7jXQBfR7h5CSb9l3KkWh0A7vC3O1S1JPfK/NRhXUjl3/7C33g6WiH06Cmo1NCnXJkiV2FqN6UZuG/MeTj5dt2eUkmV5HXwb/O/c/zt4+i4eDByNbjCyVT8AcOk//CaWcIkCZEGNcofqEmV5FVYK6CieQFcKda9p1+z9NAkA9/VK5HywV/XAS1HxsUqhjxoyxtxyCCsLk+ngb2xXndt5tPjnxCQAvtXuJOk51rDq/SZ0muDu4k1mQyRkHByISYgwbFCvMp0ukberhIEOGv4s/kUNXgHs9UCjh4u/ag3VCOJ55qdwPlop+OAlqPjbXlFKr1WzatInTp08jk8kIDw9nyJAhKBTiyVydsNiys7BdcT458QkZBRk0rdNUvyLLGuQyOVF+Uez5Zw+xTo5EZPwD+ZlaRxIYWKi6RNpT90wt1Y9u9dXMjjNReBWLQdavkGprlwdLRT6cBLUDmxTqhQsXGDRoENevX6dZs2ZIksS5c+cIDg5my5YthIaaSLNWQ6hNc6j3SqQkGx2q6i07C0uk6Lzbcclx/O/c/wCY1XEWSrltz+Yof61CPdaiD2P6f2WYJq/7q9CkPzTsBkDvBr3xdvLmVp7hfKq/iz8zO84sPXdZLKDfHg+Winw4CWoHNv0KJk+eTGhoKIcOHdIXvEtLS2PkyJFMnjyZLVu22FXIysbaOVS1Wk1hYWElSGYbr0e+zoIjC0wefy3yNQoLCinE/D0cuH6A5SeXk5abBkCgQyAOCgcysjPIyzNRz74M2nm3I9AhkH+y08nJz0cuK7bqyr+d9gWQl8e5W+dw1DjSyLkRTzV/ih2Xd+Dt7M27Xd9FIVdoZbjzDxz5EjSFcDsJ3ILBP5Jwj3AiPCP0shvD19mXcI9wk/dijz4ElqNSqWrciNfqlVIArq6uHDp0iFatWhns//PPP+natStZWVl2E7AqKWvVhCRJJCUlcefOncoXzkryivJIz09HLd2zumXIqONUByelk0Xnl7QMi+Pt5G1RPyWRJO28oyRJ1HWpi0quMt0WiUJ1IUWaIpRyJam5qchlcgJcA+410hSVrrDqWR9kcrvcQ0W9DwLjeHl5ERAQUGnZ7Cp9pRRo84ZmZmaW2p+VlYWDg4MtXdZIdMrUz88PFxeXal+vSpIkcotyyVfnU6guxMvRCwdl2Z+XJElcTr+Mn2S6tIhSpqSRZyOb3gO/Aj+UMiWOubeQFWSDV0NtbaiiXFA6gaq0gtJIGuR3tNZsfY/6qBQqnbCQogY02m2ZEnwb6xO3ZBVkkZidWEr2ui51cXNws0jezIJMkrIN00Za24fAPJIkkZOTQ3JyMgCBgYFVLJFl2KRQH3nkEV544QW++uorOnbUlr04fPgwEyZMsDiZc01HrVbrlam5KgDVDWesz7+QXZiNRqlBbiaXjgYNGqUGV5Wr1f07Od1VmHk3QV6kfWkKITcRnOqAeyOj5znnO5NflI+klHByvNtH7p2732qdYldD+kWtlershVwl52bBPU+9Sq6iSZ0mVj0IHB0dcXZyJrswG0eFIyqFChdl9X+g1jR08e3Jycn4+fnViOG/TdmmPv74Y0JDQ+ncuTNOTk44OTnRtWtXwsLC+O9//2tvGSsdS7JN6eZMXVxszNFZgyjSWJZx39J2JnG8a93lZ0LR3WKJSkcAbmbf5EbWDfKL7hVRdFZof3B56rvzlbl3tGWsSzrfNIXa/bl3yC3KBdDP1aoltdWKUCaT4ebghr+rP15OXriqXIUyrSB0v6/q7KMojk3JUdLT0/nhhx+4ceMGp0+fRpIkwsPDCQszU6KiBmGNU6qm/pA0kob0/HRyCnMIcgsyex+WevBt9fQD3Mm/Q7ZUSF3AoSBLm9QEQOmIRtJwK+8WGkmDp6MnjmiVrJPSCfK1S1iRJEj/x/xF0v8h111bpM/DwYM7+XfQSBrUGrUIxK+m1LTfV7mzTdUWJXo/kpSdhEbS4O3sjbPy3lTA5cuXCQkJ4cSJE7Rt2xYXpQtKudKsBaqSa4e9tnI77zY5hTm4yBU4qAtAXaA9oHQiqyALjaRBKVcaXEMnc15RHlJBFjJNGVaMppDcAq3D1FXlSh2nOijlSsPIAgvILswmX52Pi9JFOKAEBlg95C+ebUpgH9QaiYMX0/gp7joHL6ah1lgdeGE1cplcP9+ZWVDawVgcmUxWKtN+SQJcy+eJ1SnKHGUJL7/CgYyCDAA8HT0NruGkdEIlV+GsdEbSKWAzaIDcu+2clc64qFxwUDhYLXd6fjqJWYmkF6SX3VhwXyGyTVUx204l8tbP8SSm34tbDPR0Yu7gcAZEVKxnU7fsM7Mgs0yFqbNOZTIZxSPtVHIVAa4BeDiWLwG3q8qV1NxUsiXDxRTqlDNkqrTPfU8Hw+kXuUxOU++m2o188w8F0LqpGrn4kSuT4aCwPRql8K4lbC7ES3B/YpNTauTIkRw5coQ2bdrg7OyMt7e3wUtgGdtOJfLi98cNlClAUnoeL35/nG2nEk2caYdrb9vGI30eoXNoZ6IaR/Hwww9z8eJFo20lSWLH7zt4qt9TtAtqR+9WvVmxcAX1XevTpE4TPBw96NmzJ5MnT2bGjBl4e3sTEBDAvHnzDPo5c+YM3bp1w8nJifDwcHbt2oVMJmPTpk04F2ktx0KZzGB5Qbq6gNmT32BAVH+8Pbxp1qyZgeMzLy+Pli1b8sJL0XBXwSVcvY5n8wdZvnqDXv4Pln5DaOfB+PgE89ADD7F+/XpyCnO4mX2TK0lXGDFiBHXr1sXZ2ZkmTZrw9ddfm3zvdArVQX7/hAgKLENkm6oAcgpMzzXKZTKcVArUGom3fo43shhU66OWAfN+jqdveAAKucxsvy4O1n+M2dnZTIuehmdDT+5k3GHFohU8+uij+oKIxTl/+TzPD3+eYU8NY833azh/7jzPP/88nq6eBkpz1apVREdHc/jwYQ4ePMjYsWPp2rUrffv2RaPRMGzYMBo0aMDhw4fJzMxk2rRpd29YQpFxAyeFRJ5MTo5cjqdGG0d6G/AP8mf5l/+hWZOOHDh4kBdeeIHAwECefPJJnJyc+P7773nggQcY1Kcng7s0Y9TkOfTq0p7nRzwGwBsLP2PDr7+z7JP/0iSiHTExMYwcOZJ1m9cRGhnKh29+SHx8PL/++iu+vr5cuHCB3Nxco++bJGkXF4CwUAWlsfqXWFhYyJ49e5gzZw6NG5upk16DKe9a/vA3t5s81qtZXb5+tiNHEm6VskyLI6G1VI8k3KJzqDbOtdvC3dzKLj1XeHnBw1bL+PjjjwPaRB7JOcm8//H7RIZGEh8fj5ubYXD6yuUrqVe/Hh99/BH+rv60DG/JjRs3mDlzJm+++SZyuXag07p1a+bOnQtAkyZN+PTTT/ntt9/o27cvO3bs4OLFi+zZs4eAAO3Kpvfee4++fftqk0hrCnGVKchTQLZMhm5w76ZUMnXGJBoUFeHkXZeQESM4cOAA69at48knnyS/KB/nhs688vorPP/SFJ5+4jEuXvmHTSsXAZCdk8vi5av5/dfNhHZsi0quYtToUezfv5/vvvqOeZHz+OfaP7Rr14727dsD0KhRI5Pvm1pSo5G0yl6/mEAguIvVQ36VSsXGjRsrQpZqQ2WUkU7OtGytt6XtrOXixYs888wzdIzoSKeQTnRrrU1AoivRXZxzZ87RrUs3/F399ft0S4z/+edeqFLr1q0NzgsMDNSvdDl79izBwcF6ZQroF4Vwd3521NMT6dCwA00aP0DLXv8CwF+t5revfqDbgGeoWz8ENzc3li9frpdTpVCh1qgZ9eIomjZtyifLvuTrb77Ft0kH8GpI/M0C8vLy6fvIYzSq24h6PvXw9PDk22+/5XLCZQCGPzucNWvW0LZtW2bMmMGBAwdMvm+6uWSFXGF1dICg9mPTkP/RRx9l06ZNREdH21ueWkH82/1NHpPf9Sj7uVsWblO83f6ZvconWDEGDx5McHAwy79cjn+gP3LkREREUFBQ2gKWJKmUJ1znmCq+X6UytNhkMhmau0N3Y33ouRu/uvLDOWTn5aEEVCrtvnWbdxD91iIWzZlK594P4+4TwIcffsjhw4e1p8rkOCoduX79OmfPnUWhUHD+wgUGDBwIgOZuaNWPm35E8pBQKpSEeGqroCpUCnLIoctDXUi4nMCvW39l165d9O7dm0mTJvGf//ynlKgFd6MExHBfYAybFGpYWBjvvPMOBw4cICoqCldXw+WGkydPtotwNRVL5jQ7hngT6OlEUnqe0XlUGRDg6UTHkHtOPlvmSo2RlpbG6dOn+eKLL+jevTsA+/fvL9VOkiSuZ14ntGkov/z0i4FSPHDgAO7u7tSrV8+iazZv3pyrV69y8+ZN/P21lq5+BKB0ArmK4EA/JCBHJiNfJiNFBjFHTtAlqjUTx43QlpKWyUo5z5wVzsx5ZQ7Nwpsx6d+TGD9+PL179yY8PJzw8HAcHR25ePkiPYf1xMPRg2D3YP39nbl1Bo2kwcvHi7FjxzJ27Fi6d+/O9OnTjSpUV5UrjTwbWXTPgvsPm36hK1aswMvLi9jYWGJjYw2OyWSy+16hWoJCLmPu4HBe/P44MgwXS+rsuLmDw/UOKXtSp04dfHx8+PLLLwkMDOTq1au89tprAAYhUblFudzJv8Mjox5h2afLePnll3nppZc4e/Ysc+fOJTo6Wj9/WhZ9+/YlNDSUMWPG8MEHH5CZmcns2bMBkMnl4FmfjPQrJCoUFBWzZN1DG3Hsxy1sP3KWkOYOfPfddxw9epSQkBB9m9UrVvPnsT/ZfmA7D4Q/wK+//sqIESM4fPgw7u7uvPrqq8yZOYdX816lb6++pBakcuDAAdzc3Og6pCuL3ltEjwd60L5te/Lz8/nll19o0aKF0ftQyBW4yq3PVyC4P7BpEighIcHk69KlS/aWsdw8+uij1KlTh3/9619VLYoBAyICWTYykgBPw+F/gKcTy0ZGVlgcqlwuZ82aNcTGxhIREcHUqVOZNk/rcS/Q3Bvy6wLqmzZqytatW/WhchMmTGD8+PG88cYbFl9ToVCwadMmsrKy6NChA88995z+fCcnJzLkcq4plQbKFODJscN56OE+DB89nk6dOpGWlsbEiRP1x8+cOcO82fN444M3qBOgLcHy2WefcefOHebMmQPA22+/zYuvvsiK/66ga7uu9O/fn59//pmQkBBUChUqlYq5c+bSunVrHnzwQRQKBWvWrLHhnRXc79iUD7WmsXv3brKysli1ahU//vijxeeZy42Yl5dHQkICISEh97Il2YhaI3Ek4RbJmXn4uWuH+RVhmZrjasZVMgsyqetSFz8XPwo1hZy/dR4JiVCv0ApZYvnHH3/QrVs3zp8/j9pbXebSVlNZodQaNWdunQGgqXfTUvObhepCzt0+B0ALnxYGzqR8dT4yZBYvQb2Vewtk2kURYh614rHn78wSypsP1SoLNTw83KBE9AsvvEBKyr36OcnJydUy+1KvXr1wd3evajFMopDL6Bzqw9C29egc6lPpyhS0CgK0+UIB7uTdQULCWelsN2W6ceNGdu7cyeXLl9m1axcvvPACXbt2JbBhYJmZqgo1heQU5Rg9ppAr8HL0wsfZp1SiKbiXjcpJ6VRKaToqHHFQOFjssU/JTSExK7H8mbUEtRKrFOqZM2coKrr3RVqzZo1BomlJkqwu/RATE8PgwYMJCgrSr5opydKlS/VPqKioKPbt22fVNQRl46bSxp7mFuVyK/eWPiu9tZVMzZGZmcnEiRNp3rw5Y8eOpUOHDvz00092SQ9Yz70eAa4BRmND3R3caebdjHpuljnQTKGRNHoZhHUqMEa53MbGZgusTTSRnZ1NmzZtePbZZ/XB5sVZu3YtU6ZMYenSpXTt2pUvvviCgQMHEh8fT4MGDQCIiooiPz+/1Lk7duwgKCjIKnnuV3KLcvXr9ItntLdn+rTRo0czevToUvuzC7MtOr886QGVcqXR8ws1hdzKvYUGDYGu5uesdUtO5TI5CplI9ycojX3icMrBwIEDGXg3ZtAYixcvZvz48Tz33HOAdtnr9u3bWbZsGfPnzwcoFWkgsI6M/AyuZV4zeux65nXkyMud/MQc9koPqNaoyVPnWVc1QILU3FRkyAhwMZ8xq/iS05qWp1NQOVg15JfJZKW+SBX5xSooKCA2NpZ+/foZ7O/Xr5/Z1Sy2kp+fT0ZGhsGrtlPSIjVGUnaS0dGIvZDJZGVah2WlB9RIGs7cOsPl9Mt6SxK0uVKvZFwhJSfF6HlKuRIZMiQki+ZxQSw5FZjGKgtVkiR69+6NUqk9LTc3l8GDB+sL8xWfX7UHqampqNVqfSC4Dn9/f5KSkkycVZr+/ftz/PhxsrOzqV+/Phs3bjRa3mT+/Pm89dZb5Za7JpFTlGOxQ8iWelGW4uHoQTDBJGYbOnwsTQ8ol8lxVDiSr84nrygPlYNW6eUU5ZBVkKWtqkrdUufJZDKUCiWF6kIKNYVmlaVI2ycoC6sUqi7xhY6hQ4eWamNsHrS8GFv2aI1lvH276WQlxZk1axbR0dEsX76c5cuXo1aruXDhglWy1jQqrV6UBXg4euDu4K5X8roM/ZZ+1k5KJ/LV+eQW5eqjFvKKtE7S4hUJSqKSq/QK1Rwiy5SgLMqlUCsaX19fFApFKWs0OTm5lNVqDxwdHXF0dGTatGlMmzbNoppSNZ3KqBdlDTKZzGZL2FnpTHp+ul6JAvpQq7IUKtxbp28KPxc/vJy8hEIVmKRap8txcHAgKiqKnTt3GuzfuXMnXbp0qbDrWlL1tLagcwiZo7z1oioLXbysrrKpWqPWV0k1q1DvDvPLslBVChWuKtdyZfsX1G6qXKFmZWURFxenT2yckJBAXFycPj1bdHQ0K1asYOXKlZw+fZqpU6dy9epVJkyYUGEyVUb6vuqCPRxC5hg7dizDhg2z6VxrcVJoFWqRpogiTZE+oF8lV+mVZqNGjQwSpMtkMnb+on1gl6VQaws9e/ZkypQp+u2S74nAdqo8bOrYsWP06nUvLZ0uJeCYMWP45ptvGD58OGlpabz99tskJiYSERHB1q1badiwYVWJbH80arhyALJugps/NOwClVjWuLwOoeqCQq7AQeFAgbqA3KJc8tV3rVOVaes0MTERd093VA4qs5Z6kaaItNw0HBQOdl3sUB04evRoqYxxpmjUqBFTpkwxUMiCe1S5Qu3Zs2eZITkTJ040SIhR0ZQ3Y79VxG+GbTMh48a9fR5BMGAhhA+p+OujDU8rr0OouuDr7IskSTgpnMgtykUuk5sd7hdPeG2MwsJCVCoVBeoCUnNTUclVtU6h1q1bOvpBYBtVPuSvjlTakD9+M6wbbahMATIStfvjN1fIZXv27MlLL71EdHQ0vr6+9O3bl8WLF9O6dWv8vPyICItg+ivTyc6+t4Lpm2++wcvLi+3bt9OiRQvc3NwYMGAAiYn3YljVajXR0dF4eXnh4+PDjBkzSj0s8/PzmTx5Mn5+fjg5OdGtWzeD93nPnj3IZDK2b99Ou3btcHZ25qGHHiI5OZlff/2VFi1a4OHhwdNPP01OTum1/XWc6uDt7K0d4mfBjLEzCPYOJiQkhNWrV5dqX3y58+XLl5HJZKxbt46ePXvq61WBYQzqlStXGDx4MHXq1MHV1ZWWLVuydetW/Xswfvx4QkJCcHZ2LlVUEO5Ng7z//vv4+/vj5eXFW2+9RVFREdOnT8fb25v69euzcuVKg/OuX7/O8OHD9ekXhw4dyuXLl81+1tnZ2YwePRo3NzcCAwNZtGhRqTYlh/zz5s2jQYMGODo6EhQUpE/H2bNnT65cucLUqVONxqQLrFSogwYNIj39Xi3y9957jzt37ui309LSCA8Pt5twVUW5nVIF2aZfhXc90Bq11jI1WaYP7XFNMSvZVJ82sGrVKpRKJX/88QdffPEFcrmcjz/+mFOnTrFq1Sp+//13ZsyYYXBOTk4O//nPf/juu++IiYnh6tWrvPrqq/rjixYtYuXKlXz11Vfs37+fW7dulSqXM2PGDNavX8+qVas4fvw4YWFh9O/f3yDpDmh/1J9++ikHDhzg2rVrPPnkkyxZsoT/+7//Y8uWLezcuZNPPvnE7D2OHTuWy5cv8/vvv/Pjjz+ydOlSfUmWkqTmppKYpX04zJw5k8mTJ3P69Gn699dWXyieqX/SpEnk5+cTExPDyZMnWbhwob4Ol0ajoX79+qxbt474+HjefPNNXn/9ddatW2dwvd9//50bN24QExPD4sWLmTdvHo888gh16tTh8OHDTJgwgQkTJnDt2jX9e9+rVy/c3NyIiYlh//79+oeasSoLOqZPn87u3bvZuHEjO3bsYM+ePWZXFv7444989NFHfPHFF5w/f55NmzbRqlUrADZs2ED9+vX102/FH6aCu0hWIJfLpZs3b+q33d3dpYsXL+q3k5KSJLlcbk2X1Zr09HQJkNLT00sdy83NleLj46Xc3NzSJ871MP36/l/aNpdizLfTvS7F3Ot3YYjxNlbSo0cPqW3btmbbrFu3TvLx8dFvf/311xIgXbhwQb/vs88+k/z9/fXbgYGB0oIFC/TbhYWFUv369aWhQ4dKkiRJWVlZkkqlklavXq1vU1BQIAUFBUkffPCBJEmStHv3bgmQdu3apW8zf/58CTD4rv373/+W+vfvb1T2nIIcaf+J/RIg7d6/W9JoNJIkSdLp06clQProo4/0bQFp48aN0sXbF6XtsdslQFqyZEmpPq9nXpdOpZySkrKSpFatWknz5s0z+/4VZ+LEidLjjz+u3x4zZozUsGFDSa1W6/c1a9ZM6t69u367qKhIcnV1lX744QdJkiTpq6++kpo1a6a/F0mSpPz8fMnZ2Vnavn270etmZmZKDg4O0po1a/T70tLSJGdnZ+mVV17R72vYsKH+PVm0aJHUtGlTqaCgwGifxdtWBmZ/ZxWAud+8JVhloUolhm8ltwVWkHXTvu2sRFfhU8fu3bvp27cv9erVw93dndGjR5OWlmYw7HdxcSE0NFS/XbwIX3p6OomJiXTu3Fl/XKlUGlzn4sWLFBYW0rVrV/0+lUpFx44dOX36tIE8xQv++fv74+LiYlBl19/fX3/t1atX4+bmpn/9b9v/OH7yOEqlEu8wb87dPkdGfgbNmzfHy8vL6PtRfIVUcZlbtmyJm5sbTQKaMGH4BFQKFZMnT+bdd9+la9euzJ07l7/++sugr88//5z27dtTt27dUkUFi/dbvNqBv7+/3hIEbUJuHx8f/T3GxsZy4cIF3N3d9ffp7e1NXl4eFy9eZN++fQbvwerVq7l48SIFBQUGn4m3tzfNmjUz+h4APPHEE+Tm5tK4cWOef/55Nm7caPcVkLWZKndKVUfK7ZR6/YbpY7osRW4WLkwo3m7KSdvkMUJxr+6VK1cYNGgQEyZM4J133sHb25v9+/czfvx4CgvvhRIZK8JnzUNVMlLYT7e/5L7i15LJZGYLAA4ZMoROnTqRWZBJUlYSfoF+/LH7D327Ik0R1zKvEUywSdmKB+sXf2+2bt1KYWEhVzKuIFPJUMlVPPfcc/Tv358tW7awY8cO5s+fz6JFi3j55ZdZt24dU6dOZdGiRXTu3Bl3d3eDooLG7s+Se9RoNERFRRmdB65bty4ODg760EPQKuiStbcsITg4mLNnz7Jz50527drFxIkT+fDDD9m7d28p+QSlqdbJUaqKcjulHFxNv1R3kzU37KL15mPq/ZOBRz1tu7L6LSfHjh2jqKiIRYsW8cADD9C0aVNu3DDzUDCCp6cngYGBHDp0SL+vqKjIYL4uLCwMBwcHg4KAhYWFHDt2zGQNJ0twd3cnNDQUlwAXGjRugJOzE42bNqaoqIi/4/7WtzsQd8Bgzr84plY/NWzYkLCwMIIaBuEf6I+DXBvUHxwczIQJE9iwYQPTpk1j+fLlAOzbt48uXbowceJE2rVrR1hYmE2KrSSRkZGcP38ePz8/wsLCDF6enp44Ozsb7HN3dycsLAyVSmXwmdy+fZtz586ZvZazszNDhgzh448/Zs+ePRw8eJCTJ7UPcwcHh8qJfqmhWJ0cZezYsTg6OgLa8gQTJkzQP9GN5SQVmECu0IZGrRsNpsr0DVhQKfGooaGhFBUV8cknnzB48GD++OMPPv/8c6v7eeWVV1iwYAFNmjShRYsWLF682ECBubq68uKLL+o92Q0aNOCDDz4gJyeH8ePHl+seSiZ5CQkLodtD3ZgbPZd5i+ahUCpYOHshzs7GQ6jMLSeVJG0ZmEK1NnnKlClTGDhwIE2bNuX27dv8/vvv+gdCWFgY3377Ldu3byckJMRoUUFbGDFiBB9++CFDhw7l7bffpn79+ly9epUNGzYwffp06tevX+ocNzc3xo8fz/Tp0/Hx8cHf35/Zs2ebLaz4zTffoFar6dSpEy4uLnz33Xc4Ozvr474bNWpETEwMTz31FI6Ojvj6+pbrvmobVlmoY8aMwc/PD09PTzw9PRk5ciRBQUH6bT8/P6MJhAUmCB8CT34LHiVWKnkEafdXUhxq27ZtWbx4MQsXLiQiIoLVq1frc81aw7Rp0xg9ejRjx47VD3cfffRRgzYLFizg8ccfZ9SoUURGRnLhwgW2b99OnTrli+00lrzl3Y/fJSAogLFDxzJl7BT+Nfpf+NY1rgDMZZmSyWQ4KBxwdXBFLpOjVquZNGkSLVq0YMCAATRr1oylS5cCMGHCBB577DGGDx9utKigrbi4uBATE0ODBg147LHHaNGiBePGjSM3N9ds7aMPP/yQBx98kCFDhtCnTx+6detGVFSUyfZeXl4sX76crl270rp1a3777Td+/vlnfHx8AG3Bw8uXLxMaGiriV41wXxTps5bic6jnzp2r8CJ9Vb1SqjaQXZjN5fTLZbZr5NnIaPKVIk0RZ2+dBUoX8hNUHTWtSJ/VTqkrV66wY8cOCgsL6dmzZ62IOy3JpEmTmDRpUuVlm5IrIKR7xV+nFlPerP8KmYImdZoYrX6aVZBFdmE2ripX3Bzc7Cq3oHZhlUKNiYlh0KBB+hUqSqWSVatW8fTTT1eIcAKBpeiSvJgq5QLmk7zohvXGyCrMIi03DQ0aoVAFZrFqXDNnzhx69erFP//8Q1paGuPGjSu1mkYgqCo8HD0Idg8uleREJVcR7B5sc5IXkalfYClWWagnT54kJiZGX0l00aJFLF++nNu3b5fbqSAQ2IPyJHnJyM8goyADV5WrQQIUXaZ+XciUQGAKqyzUO3fu4Ofnp992dXXFxcXFZGxfTeV+SjBdG9Fl/fd09MRV5WpxrHS+Op/0/PRSZa1FcT6BpVjtlIqPjzcoSSJJEqdPnyYzM1O/r/iywZpIpTulBNUC3Rxq8UTTGkmjd3SJIb+gLKxWqL179y613PCRRx7RL0OUyWRiJYWgRqJTmLohPtxTrjKZDIVMhLIJzGOVQk1ISKgoOQSCKkevUDWFeuOgeKXT2rjMWmBfrFKotarsiEBQAqVciQwZEhJFmiJUChUuKhea1GmCRtJUtXiCGoBVTqnevXuzYcMGk8dTU1MNUqwJBJVZpM8SjBXp02Xsl8lkKBVaG6NAo03aLJfJcVA46CuqViS6igHFs0aVhSXvb8mifPZi3rx5tG3b1ipZajtWWai7d+9m7969zJ49m7feeqvUcbVazZUrV+wm3P2CWqPmePJxUnJSqOtSl0i/SBRi6WmlkJiYaBDy5yB3oFBdiFpT+X6A4OBgEhMTa2zCkf/+978Wp3McO3Ysd+7c0T/MagtWO6WWLVvG9OnT+euvv/juu+/0pR9qE5VZpG/XlV0sOLKAmzn3Ekn7u/jzWsfX6NOwT4VfH7RF+hwc7s8Yy5JF+uq710cuk+uXn95Iv4FCqcDLyQtHhWOFyaH7DMoqGlidERExNhTpGzp0KAcPHiQ+Pp7OnTtz6dKlipCrSqmsIn27ruwiek+0gTIFSM5JJnpPNLuu7KqQ65oq0teqVStcXV0JDg5m4sSJZGVl6c+pKUX6ipOcnMzgwYNxdna2uEifSqHix//9qC/S9+1335Kam6oPnfriiy+oV6+ePvGzjiFDhjBmzBhAW5lg6NCh+Pv74+bmRocOHdi1y/CzbNSoEe+++y5jx47F09OT559/vtSQ35KCfzreeust/Pz88PDw4N///rfZOlMFBQXMmDGDevXq4erqSqdOndizZ4/Z9xK0mcL8/f1xd3dn/Pjx5OXlGRwvOeT/8ccfadWqFc7Ozvj4+NCnTx+ys7OZN28eq1at4qefftLnWLbk+jUBm1LqtGjRgiNHjhAcHGz0y3K/k1OYY/KlqxWv1qhZcGQBkpEifdLdfwuOLDAYeprq0xZEkT7T6Ir0xcfH80DPB4B7EQBPPPEEqamp7N69W9/+9u3bbN++nREjRgCQlZXFoEGD2LVrFydOnKB///4MHjy4VBmUDz/8kIiICGJjY5kzZ04pOSwt+Pfbb79x+vRpdu/ezQ8//MDGjRuNTsnpePbZZ/njjz9Ys2YNf/31F0888QQDBgzg/PnzJs9Zt24dc+fO5b333uPYsWMEBgbqUxYaIzExkaeffppx48Zx+vRp9uzZw2OPPYYkSbz66qs8+eST+gdyYmIiXbp0MdlXjcKaAlQymcygSJ9Go5FmzpwpqVQqafHixaJI310ivokw+Xpx54uSJEnSkcQjZtvpXkcSj+j77f5Dd6NtrKW2F+mTJEk6e/asBEiHDh3S7zNXpE+SJCkhIUECpHkL5knXMq5JBUUF0qmUU9KplFOSWnOvoN6QIUOkcePG6be/+OILKSAgQCoqKjIpT3h4uPTJJ5/otxs2bCgNGzbMoI3u+idOnDDZj7GCf97e3lJ2drZ+37JlyyQ3Nzd9EcAePXroi/JduHBBkslk0vXr1w367d27tzRr1iyT1+3cubM0YcIEg32dOnWS2rRpYyCL7rOOjY2VAOny5ctG+yve1hy1ukifsfInCxYs4LvvvmPOnDk899xz5dfw9wkpOSl2bWcttblI3759+zh9+nSp65sr0lecxhGNySzIpFBTyNBuQ+nYqCMe7h4MHDgQ0GbPX79+vb5CxerVq3nqqadQKLSOxOzsbGbMmEF4eDheXl64ublx5syZUhZqyc/AGJYU/GvTpg0uLvfSEnbu3JmsrCx9CeriHD9+HEmSaNq0qcF7tnfvXn2pluL7J0yYAMDp06cNPlvddUzRpk0bevfuTatWrXjiiSf0OT9qO1aXQDHG8OHDadasWbUMmbh27RqjRo0iOTkZpVLJnDlzeOKJJyr0moefOWzymM57X9fFsmznxdtte3xb+QQrRm0s0qejXr16bN++3ei1LMHFxQWNpCGvKI9lPyxDiZJg92B9+ZTBgwej0WjYsmULHTp0YN++fSxevFh//vTp09m+fTv/+c9/CAsLw9nZmX/961+l5jWLfwbGsLTgnymM3btGo0GhUBAbG6t/AOjQOZiLh23ZkmQZtFVbd+7cyYEDB9ixYweffPIJs2fP5vDhw+UuB1OdsTpsytvb2+ixtm3bEhsby5YtW+wimL1QKpUsWbKEtm3bkpycTGRkJIMGDSrzy1weXFTGkxgXJ9IvEn8Xf5Jzko3Oo8qQ4e/iT6RfpFX92kLxIn26ekMl5+nKoniRvgcffBC4V6QvMlJ7D8WL9D3zzDPAvSJ95YmTdHd3x93d3WBfixYtKCoq4tixY3Ts2BGAs2fPWpTIR/fQyynKISg4CE9HT+q736vZ5OzszGOPPcbq1au5cOECTZs2NSgrsm/fPsaOHasv/5KVlcXly5etvq/iBf90GCv49+eff5Kbm6tX+IcOHcLNzc1onal27dqhVqtJTk6me3fjSc3DwsJK7WvRogWHDh0yKHFUvPifMWQyGV27dqVr1668+eabNGzYkI0bNxIdHV1ri/1ZNeTv0aMHSqVpHezj41PtakoFBgbqg4/9/Pzw9vYu5QCpChRyBa91fA3QKs/i6LZndpxZKfGoxYv0Xbp0ie+++65cRfo2btzImTNnmDhxoskifdu2bSM+Pp7nn3/eLkX6StKsWTMGDBjA888/z+HDh4mNjeW5554zWaSvOLp8qrqsU8aSoowYMYItW7awcuVKRo4caXAsLCyMDRs2EBcXx59//skzzzxTKirAEsLCwjh27Bjbt2/n3LlzzJkzx2jkSUFBAePHjyc+Pp5ff/2VuXPn8tJLLxktxte0aVNGjBjB6NGj2bBhAwkJCRw9epSFCxeydetWk7K88sorrFy5kpUrV3Lu3Dnmzp3L33//bbL94cOHef/99zl27Ji+mGBKSoq+mGGjRo3466+/OHv2LKmpqQYjoZpMlRfOiYmJYfDgwQQFBRmEsBRn6dKl+poyUVFR7Nu3z6ZrHTt2DI1GQ3Cw6frslUmfhn1Y3HMxfi5+Bvv9XfxZ3HNxpcWh1oYifcb4+uuvCQ4OpkePHjz22GO88MILBuknTaFTqD7OPjSp0wRvp9Kjsoceeghvb2/Onj2rt7Z1fPTRR9SpU4cuXbowePBg+vfvr7fSrcHSgn+9e/emSZMmPPjggzz55JMMHjyYefPmmez366+/ZvTo0UybNo1mzZoxZMgQDh8+bPZ3MXz4cN58801mzpxJVFQUV65c4cUXXzTZ3sPDQ1/ho2nTprzxxhssWrRIPw/9/PPP06xZM/388B9//GH5G1ONqfIifb/++it//PEHkZGRPP7442zcuNFgLnbt2rWMGjWKpUuX0rVrV7744gtWrFhBfHw8DRo0ACAqKspoCesdO3bok2GnpaXRvXt3VqxYYXGIhrmCXfYsHiZWSlUvkrKTSMtNw9vZm0DXwLJPEFQYNa1IX5Ur1OLIZLJSCrVTp05ERkaybNky/b4WLVowbNgwi62o/Px8+vbty/PPP8+oUaPMtiuumDMyMggODq74qqeCakVabhpJ2Ul4OXlRz61eVYtzX1PTFGqVD/nNUVBQQGxsLP369TPY369fPw4cOGBRH5IkMXbsWB566CGzyhRg/vz5eHp66l/VZWpAULnUcapDM+9mSJLEzZybVkUyCO5vqrVCTU1NRa1W4+/vb7Df39/foGqAOf744w/Wrl3Lpk2baNu2LW3btuXkyZNG286aNYv09HT9y1gcn6D2I0NGZkEm6fnp3MqtegemoOZgdXKUqsCSuEVTdOvWzWIPq6OjI46OjpWaHEVQvcjIzyAxO1G/dl8jaTh3+xyBroE2V00V3D9UawvV19cXhUJRyhpNTk4uZbXak8pKjiKoXmTkZ3At85pemeoo0hRxLfMaGfkZVSSZoKZQrRWqg4MDUVFR7Ny502D/zp07KzSZgjVVT8X8Wu1AkiQSsxPNtknKThKfdyVT097vKh/yZ2VlceHCBf12QkICcXFxeHt706BBA6Kjoxk1ahTt27enc+fOfPnll1y9elW/xrgisKTqqW4pZE5OjkXB4oLqTU5RTinLtCSFmkJyinJwVVXcKjuBIboUjSWXHldXqlyhHjt2jF69eum3o6OjARgzZgzffPMNw4cPJy0tjbfffpvExEQiIiLYunVrhda3smQOVaFQ4OXlpU/Q4eLiIoq41WByCnLQFJY9156Tm4NCLWKEKxpJksjJySE5ORkvL69SeQeqK9UqDrW6UVZMmiRJJCUlWbQ+XFC9yVfnk5abVmY7H2efCs3cLzDEy8uLgICASjNWyhuHWuUWak1GJpMRGBiIn59frVmLfL+i1qhZuGOhWaXq6+zL8n7LxSq2SkKlUtUYy1SHUKhGsDZsSqFQ1LgPXlCa8e3GE71HO+VUPAOYLlnNjC4zcHUR86cC04ghvxnKa/4Lah7GiiYGuAQws+PMSktWI6g6xJBfILAjfRr2oVdwL5GsRmATQqEaQayUur9RyBV0CCg7BlkgKIkY8pshPT0dLy8vrl27Job8AsF9gC7D3J07d0zGoJtDWKhmyMzMBBBZpwSC+4zMzEybFKqwUM2g0Wi4ceMG7u7uFsXB6Z5uNc2irYly10SZQchd2VgrtyRJZGZmEhQUZLSETFkIC9UMcrncaKGzsvDw8KhRXzodNVHumigzCLkrG2vktsUy1VGtk6MIBAJBTUIoVIFAILATQqHaEUdHR+bOnYujY81a610T5a6JMoOQu7KpbLmFU0ogEAjshLBQBQKBwE4IhSoQCAR2QihUgUAgsBNCodqJpUuXEhISgpOTE1FRUezbt6/Srh0TE8PgwYMJCgpCJpOxadMmg+OSJDFv3jyCgoJwdnamZ8+e/P333wZt8vPzefnll/H19cXV1ZUhQ4bwzz//GLS5ffs2o0aNwtPTE09PT0aNGlWu5Nrz58+nQ4cOuLu74+fnx7Bhwzh79my1l33ZsmW0bt1aH9vYuXNnfv3112otc0nmz5+PTCZjypQp1VruefPmIZPJDF4BAQHVV2ZJUG7WrFkjqVQqafny5VJ8fLz0yiuvSK6urtKVK1cq5fpbt26VZs+eLa1fv14CpI0bNxocX7BggeTu7i6tX79eOnnypDR8+HApMDBQysjI0LeZMGGCVK9ePWnnzp3S8ePHpV69eklt2rSRioqK9G0GDBggRURESAcOHJAOHDggRURESI888ojNcvfv31/6+uuvpVOnTklxcXHSww8/LDVo0EDKysqq1rJv3rxZ2rJli3T27Fnp7Nmz0uuvvy6pVCrp1KlT1Vbm4hw5ckRq1KiR1Lp1a+mVV17R76+Ocs+dO1dq2bKllJiYqH8lJydXW5mFQrUDHTt2lCZMmGCwr3nz5tJrr71W6bKUVKgajUYKCAiQFixYoN+Xl5cneXp6Sp9//rkkSZJ0584dSaVSSWvWrNG3uX79uiSXy6Vt27ZJkiRJ8fHxEiAdOnRI3+bgwYMSIJ05c8YusicnJ0uAtHfv3hone506daQVK1ZUe5kzMzOlJk2aSDt37pR69OihV6jVVe65c+dKbdq0MXqsOsoshvzlpKCggNjYWPr162ewv1+/fhw4cKCKpLpHQkICSUlJBvI5OjrSo0cPvXyxsbEUFhYatAkKCiIiIkLf5uDBg3h6etKpUyd9mwceeABPT0+73Wd6ejoA3t7eNUZ2tVrNmjVryM7OpnPnztVe5kmTJvHwww/Tp49hsuzqLPf58+cJCgoiJCSEp556ikuXLlVbmcVa/nKSmpqKWq3G39/fYL+/vz9JSUlVJNU9dDIYk+/KlSv6Ng4ODtSpU6dUG935SUlJ+Pn5lerfz8/PLvcpSRLR0dF069aNiIiIai/7yZMn6dy5M3l5ebi5ubFx40bCw8P1P8DqKPOaNWs4fvw4R48eLXWsur7XnTp14ttvv6Vp06bcvHmTd999ly5duvD3339XS5mFQrUTJbNRSZJUrcpK2yJfyTbG2tvrPl966SX++usv9u/fX+pYdZS9WbNmxMXFcefOHdavX8+YMWPYu3dvtZX52rVrvPLKK+zYsQMnJyeT7aqb3AMHDtT/v1WrVnTu3JnQ0FBWrVrFAw88UO1kFkP+cuLr64tCoSj1JEtOTi715KwKdB5Rc/IFBARQUFDA7du3zba5efMmJUlJSSn3fb788sts3ryZ3bt3G2T3qs6yOzg4EBYWRvv27Zk/fz5t2rThv//9b7WVOTY2luTkZKKiolAqlSiVSvbu3cvHH3+MUqnU91nd5C6Jq6srrVq14vz589XyvRYKtZw4ODgQFRXFzp07Dfbv3LmTLl26VJFU9wgJCSEgIMBAvoKCAvbu3auXLyoqCpVKZdAmMTGRU6dO6dt07tyZ9PR0jhw5om9z+PBh0tPTbb5PSZJ46aWX2LBhA7///jshISE1RnZj95Kfn19tZe7duzcnT54kLi5O/2rfvj0jRowgLi6Oxo0bV0u5S5Kfn8/p06cJDAysnu+1VS4sgVF0YVNfffWVFB8fL02ZMkVydXWVLl++XCnXz8zMlE6cOCGdOHFCAqTFixdLJ06c0IdtLViwQPL09JQ2bNggnTx5Unr66aeNhpbUr19f2rVrl3T8+HHpoYceMhpa0rp1a+ngwYPSwYMHpVatWpUrjOfFF1+UPD09pT179hiExeTk5OjbVEfZZ82aJcXExEgJCQnSX3/9Jb3++uuSXC6XduzYUW1lNkZxL391lXvatGnSnj17pEuXLkmHDh2SHnnkEcnd3V3/26puMguFaic+++wzqWHDhpKDg4MUGRmpD/2pDHbv3i0BpV5jxoyRJEkbXjJ37lwpICBAcnR0lB588EHp5MmTBn3k5uZKL730kuTt7S05OztLjzzyiHT16lWDNmlpadKIESMkd3d3yd3dXRoxYoR0+/Ztm+U2JjMgff311/o21VH2cePG6T/runXrSr1799Yr0+oqszFKKtTqKLcurlSlUklBQUHSY489Jv3999/VVmaRbUogEAjshJhDFQgEAjshFKpAIBDYCaFQBQKBwE4IhSoQCAR2QihUgUAgsBNCoQoEAoGdEApVIBAI7IRQqAKBQGAnhEIV1Hh69uxpUMqjLC5fvoxMJiMuLq7CZLKUefPm0bZt26oWQ2AnxEopQaVRViq0MWPG8M0331jd761bt1CpVLi7u1vUXq1Wk5KSgq+vL0plxWawXL9+PR988AFnzpxBo9HQoEEDBgwYwKJFiwDIysoiPz8fHx+fCpVDUDmIfKiCSiMxMVH//7Vr1/Lmm28aFOVzdnY2aF9YWIhKpSqzX12Gf0tRKBQGhd4qil27dvHUU0/x/vvvM2TIEGQyGfHx8fz222/6Nm5ubri5uVW4LILKQQz5BZVGQECA/uXp6amvYBkQEEBeXh5eXl6sW7eOnj174uTkxPfff09aWhpPP/009evXx8XFhVatWvHDDz8Y9FtyyN+oUSPef/99xo0bh7u7Ow0aNODLL7/UHy855N+zZw8ymYzffvuN9u3b4+LiQpcuXUpVYH333Xfx8/PD3d2d5557jtdee83scP2XX36hW7duTJ8+nWbNmtG0aVOGDRvGJ598om9TcshfssKnTCajUaNG+uPx8fEMGjQINzc3/P39GTVqFKmpqZZ/CIIKRShUQbVi5syZTJ48mdOnT9O/f3/y8vKIioril19+4dSpU7zwwguMGjWKw4cPm+1n0aJFtG/fnhMnTjBx4kRefPFFzpw5Y/ac2bNns2jRIo4dO4ZSqWTcuHH6Y6tXr+a9995j4cKFxMbG0qBBA5YtW2a2v4CAAP7++29OnTpl8f0nJibqXxcuXCAsLIwHH3xQf6xHjx60bduWY8eOsW3bNm7evMmTTz5pcf+CCsbq/FQCgR34+uuvJU9PT/12QkKCBEhLliwp89xBgwZJ06ZN02+XTEPXsGFDaeTIkfptjUYj+fn5ScuWLTO41okTJyRJupf+cNeuXfpztmzZIgFSbm6uJEmS1KlTJ2nSpEkGcnTt2tVkRU5JkqSsrCxp0KBBEiA1bNhQGj58uPTVV19JeXl5+jamqnpqNBrp0UcflaKiovT5YefMmSP169fPoN21a9ckQDp79qxJOQSVh7BQBdWK9u3bG2yr1Wree+89WrdujY+PD25ubuzYsYOrV6+a7ad169b6/+umFpKTky0+JzAwEEB/ztmzZ+nYsaNB+5LbJXF1dWXLli1cuHCBN954Azc3N6ZNm0bHjh3Jyckxe+7rr7/OwYMH2bRpk35uOTY2lt27d+vnXd3c3GjevDkAFy9eNNufoHIQTilBtcLV1dVge9GiRXz00UcsWbKEVq1a4erqypQpUygoKDDbT0lnlkwmQ6PRWHyOLiKh+DnGisFZQmhoKKGhoTz33HPMnj2bpk2bsnbtWp599lmj7b///ns++ugj9uzZY1BjS6PRMHjwYBYuXFjqHN0DQFC1CIUqqNbs27ePoUOHMnLkSECrVM6fP0+LFi0qVY5mzZpx5MgRRo0apd937Ngxq/tp1KgRLi4uZGdnGz1+8OBBnnvuOb744gt9VU8dkZGRrF+/nkaNGlV4uJfANsSQX1CtCQsLY+fOnRw4cIDTp0/z73//2+a69OXh5Zdf5quvvmLVqlWcP3+ed999l7/++stsbO28efOYMWMGe/bsISEhgRMnTjBu3DgKCwvp27dvqfZJSUk8+uijPPXUU/Tv35+kpCSSkpJISUkBYNKkSdy6dYunn36aI0eOcOnSJXbs2MG4ceNQq9UVdu8CyxEKVVCtmTNnDpGRkfTv35+ePXsSEBDAsGHDKl2OESNGMGvWLF599VUiIyNJSEhg7NixZmvc9+jRg0uXLjF69GiaN2/OwIEDSUpKYseOHTRr1qxU+zNnznDz5k1WrVpFYGCg/tWhQwcAgoKC+OOPP1Cr1fTv35+IiAheeeUVPD09kcvFT7k6IFZKCQQ20rdvXwICAvjuu++qWhRBNUFMxAgEFpCTk8Pnn39O//79USgU/PDDD+zatcug3rtAICxUgcACcnNzGTx4MMePHyc/P59mzZrxxhtv8Nhjj1W1aIJqhFCoAoFAYCfETLZAIBDYCaFQBQKBwE4IhSoQCAR2QihUgUAgsBNCoQoEAoGdEApVIBAI7IRQqAKBQGAnhEIVCAQCOyEUqkAgENiJ/weEawGLdQuisQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(3.5, 2.5))\n", + "\n", + "for gid, group in all_results.query('d==0.02').groupby('sampling_method'):\n", + " ax.plot(group['size'], group['zpe_error'].abs(), '--o', label=gid)\n", + " \n", + "ax.legend()\n", + "\n", + "ax.set_yscale('log')\n", + "\n", + "ax.set_xlabel('Training Size')\n", + "ax.set_ylabel('ZPE Error (kcal/mol)')\n", + "\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "3d1cd9a6-ec4d-4dbe-9e92-188c401dd548", + "metadata": {}, + "source": [ + "It seems like random sampling is preferred, and it is especially stable if we sample random directions" + ] + }, + { + "cell_type": "markdown", + "id": "9704b823-18f4-4195-884d-12fadd602993", + "metadata": {}, + "source": [ + "## Explore Effect of Sampling Size\n", + "What is the best magnitude?" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "edbf9938-54b0-4182-b9e2-8de6ec96404e", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "best_strategy = all_results.query('sampling_method==\"random-dir-variable-dist\"')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "b0e1309b-a6dd-4728-9583-e8ec5d8a765e", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(3, 1, figsize=(3.5, 3.8), sharex=True)\n", + "\n", + "for gid, group in best_strategy.groupby('d'):\n", + " axs[0].plot(group['size'], group['vib_mae'], '--o', label=f'd={gid}')\n", + " axs[1].plot(group['size'], group['zpe_error'].abs(), '--o', label=f'd={gid}')\n", + " axs[2].plot(group['size'], group['cp_error'].apply(np.array).apply(np.abs).apply(np.mean), '--o', label=f'd={gid}')\n", + " \n", + " \n", + "# Labels\n", + "axs[0].legend()\n", + "axs[0].set_ylabel('Vibration MAE\\n(cm$^{-1}$)')\n", + "axs[1].set_ylabel('ZPE Error\\n(kcal/mol)')\n", + "axs[2].set_ylabel('$C_p$ Error\\n(kcal/mol/K)')\n", + "\n", + "for ax in axs:\n", + " ax.set_yscale('log')\n", + "\n", + "axs[-1].set_xlabel('Training Size')\n", + "\n", + "fig.tight_layout()" + ] + }, + { + "cell_type": "markdown", + "id": "0ee09462-b4e4-4a3a-9f14-dea85668da0b", + "metadata": {}, + "source": [ + "Heat capacity does not seem affected much by choice of sampling? " + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bc042000-02a6-4b07-ade7-849c74a4fadf", + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "best_model = best_strategy.query('d==0.02').sort_values('size').tail().iloc[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "137b0999-98fe-414b-ae6c-c7c39f37314a", + "metadata": { + "tags": [] + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, '$C_p$ (kcal/mol/K)')" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(3.5, 2.5))\n", + "\n", + "ax.plot(best_model['temps'], best_model['cp'], 'r', label='Approx')\n", + "ax.plot(best_model['temps'], np.add(best_model['cp'], best_model['cp_error']), '--k', label='True')\n", + "\n", + "ax.set_xlabel('Temp (K)')\n", + "ax.set_ylabel('$C_p$ (kcal/mol/K)')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "006aa472-9383-4127-a934-2b5377d65c3c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.18" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/3_consolidate-results/README.md b/notebooks/3_consolidate-results/README.md new file mode 100644 index 0000000..e69de29