diff --git a/.buildinfo b/.buildinfo new file mode 100644 index 0000000..220653e --- /dev/null +++ b/.buildinfo @@ -0,0 +1,4 @@ +# Sphinx build info version 1 +# This file hashes the configuration used when building these files. When it is not found, a full rebuild will be done. +config: d6ed9ec3a6d4790c2a7793a8cd446acf +tags: 645f666f9bcd5a90fca523b33c5a78b7 diff --git a/.nojekyll b/.nojekyll new file mode 100644 index 0000000..e69de29 diff --git a/_images/envelope_reconstruction.png b/_images/envelope_reconstruction.png new file mode 100644 index 0000000..0528f98 Binary files /dev/null and b/_images/envelope_reconstruction.png differ diff --git a/_images/pigeon_feather.png b/_images/pigeon_feather.png new file mode 100644 index 0000000..65a7600 Binary files /dev/null and b/_images/pigeon_feather.png differ diff --git a/_images/tutorials_00_ecdhfr_showcase_14_1.png b/_images/tutorials_00_ecdhfr_showcase_14_1.png new file mode 100644 index 0000000..e00b02d Binary files /dev/null and b/_images/tutorials_00_ecdhfr_showcase_14_1.png differ diff --git a/_images/tutorials_00_ecdhfr_showcase_41_1.png b/_images/tutorials_00_ecdhfr_showcase_41_1.png new file mode 100644 index 0000000..04be665 Binary files /dev/null and b/_images/tutorials_00_ecdhfr_showcase_41_1.png differ diff --git a/_images/tutorials_00_ecdhfr_showcase_42_1.png b/_images/tutorials_00_ecdhfr_showcase_42_1.png new file mode 100644 index 0000000..6e6c211 Binary files /dev/null and b/_images/tutorials_00_ecdhfr_showcase_42_1.png differ diff --git a/_images/tutorials_00_ecdhfr_showcase_47_0.png b/_images/tutorials_00_ecdhfr_showcase_47_0.png new file mode 100644 index 0000000..82ed7ae Binary files /dev/null and b/_images/tutorials_00_ecdhfr_showcase_47_0.png differ diff --git a/_images/tutorials_00_ecdhfr_showcase_53_0.png b/_images/tutorials_00_ecdhfr_showcase_53_0.png new file mode 100644 index 0000000..ee34f9d Binary files /dev/null and b/_images/tutorials_00_ecdhfr_showcase_53_0.png differ diff --git a/_images/tutorials_02_peptide_level_analysis_19_0.png b/_images/tutorials_02_peptide_level_analysis_19_0.png new file mode 100644 index 0000000..793900d Binary files /dev/null and b/_images/tutorials_02_peptide_level_analysis_19_0.png differ diff --git a/_images/tutorials_04_check_the_fitting_10_1.png b/_images/tutorials_04_check_the_fitting_10_1.png new file mode 100644 index 0000000..56cdef5 Binary files /dev/null and b/_images/tutorials_04_check_the_fitting_10_1.png differ diff --git a/_images/tutorials_04_check_the_fitting_11_1.png b/_images/tutorials_04_check_the_fitting_11_1.png new file mode 100644 index 0000000..77d4a7a Binary files /dev/null and b/_images/tutorials_04_check_the_fitting_11_1.png differ diff --git a/_images/tutorials_04_check_the_fitting_16_0.png b/_images/tutorials_04_check_the_fitting_16_0.png new file mode 100644 index 0000000..15768b1 Binary files /dev/null and b/_images/tutorials_04_check_the_fitting_16_0.png differ diff --git a/_images/tutorials_05_plot_the_results_8_0.png b/_images/tutorials_05_plot_the_results_8_0.png new file mode 100644 index 0000000..d7b1bd7 Binary files /dev/null and b/_images/tutorials_05_plot_the_results_8_0.png differ diff --git a/_sources/classes.rst.txt b/_sources/classes.rst.txt new file mode 100644 index 0000000..f572f5d --- /dev/null +++ b/_sources/classes.rst.txt @@ -0,0 +1,252 @@ +pigeon_feather.data.RangeList +----------------------------- + +.. currentmodule:: pigeon_feather.data +.. autoclass:: RangeList + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~RangeList.to_set + ~RangeList.to_dataframe + ~RangeList.to_csv + ~RangeList.union + ~RangeList.intersection + ~RangeList.difference + + +pigeon_feather.data.HDXMSDataCollection +--------------------------------------- + +.. currentmodule:: pigeon_feather.data +.. autoclass:: HDXMSDataCollection + + .. automethod:: __init__ + + + +pigeon_feather.data.HDXMSData +----------------------------- + +.. currentmodule:: pigeon_feather.data +.. autoclass:: HDXMSData + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~HDXMSData.add_state + ~HDXMSData.load_protein_sequence + ~HDXMSData.get_state + ~HDXMSData.plot_res_coverage + ~HDXMSData.reindex_peptide_from_pdb + ~HDXMSData.to_dataframe + ~HDXMSData.to_bayesianhdx_format + + .. rubric:: Attributes + + .. autosummary:: + + ~HDXMSData.num_states + + +pigeon_feather.data.ProteinState +-------------------------------- + +.. currentmodule:: pigeon_feather.data + +.. autoclass:: ProteinState + + + .. automethod:: __init__ + + + .. rubric:: Methods + + .. autosummary:: + + + ~ProteinState.add_peptide + ~ProteinState.num_peptides + ~ProteinState.get_peptide + ~ProteinState.add_new_peptides_by_subtract + ~ProteinState.add_all_subtract + + + +pigeon_feather.data.Peptide +---------------------------- + +.. currentmodule:: pigeon_feather.data + +.. autoclass:: Peptide + + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~Peptide.add_timepoint + ~Peptide.get_deut + ~Peptide.get_deut_percent + ~Peptide.get_timepoint + + + +pigeon_feather.data.Timepoint +----------------------------- + +.. currentmodule:: pigeon_feather.data + +.. autoclass:: Timepoint + + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~Timepoint.load_raw_ms_csv + + + +pigeon_feather.HDXStatePeptideCompares +--------------------------------------- + +.. currentmodule:: pigeon_feather.data + +.. autoclass:: HDXStatePeptideCompares + + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~HDXStatePeptideCompares.add_all_compare + ~HDXStatePeptideCompares.to_dataframe + + + + +pigeon_feather.PeptideCompare +----------------------------- + +.. currentmodule:: pigeon_feather.data + +.. autoclass:: PeptideCompare + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~PeptideCompare.get_deut_diff + + + + +pigeon_feather.HDXStateResidueCompares +-------------------------------------- + +.. currentmodule:: pigeon_feather.data +.. autoclass:: HDXStateResidueCompares + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~HDXStateResidueCompares.add_all_compare + ~HDXStateResidueCompares.get_residue_compare + + + +pigeon_feather.ResidueCompare +----------------------------- + +.. currentmodule:: pigeon_feather.data +.. autoclass:: ResidueCompare + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~ResidueCompare.find_peptides_containing_res + ~ResidueCompare.get_deut_diff + + + +pigeon_feather.SimulatedData +---------------------------- + +.. currentmodule:: pigeon_feather.data +.. autoclass:: SimulatedData + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~SimulatedData.gen_seq + ~SimulatedData.gen_logP + ~SimulatedData.cal_k_init + ~SimulatedData.cal_k_ex + ~SimulatedData.calculate_incorporation + ~SimulatedData.gen_peptides + ~SimulatedData.convert_to_hdxms_data + + + + +pigeon_feather.plot.UptakePlotsCollection +----------------------------------------- + +.. currentmodule:: pigeon_feather.plot +.. autoclass:: UptakePlotsCollection + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~UptakePlotsCollection.add_plot + ~UptakePlotsCollection.add_plot_all + ~UptakePlotsCollection.save_plots + + +pigeon_feather.plot.UptakePlot +------------------------------ + +.. currentmodule:: pigeon_feather.plot +.. autoclass:: UptakePlot + + .. automethod:: __init__ + + .. rubric:: Methods + + .. autosummary:: + + ~UptakePlot.make_uptakeplot + ~UptakePlot.get_average_peptide + ~UptakePlot.make_title + ~UptakePlot.make_color_dict + + + + diff --git a/_sources/documentation.rst.txt b/_sources/documentation.rst.txt new file mode 100644 index 0000000..65e73a1 --- /dev/null +++ b/_sources/documentation.rst.txt @@ -0,0 +1,10 @@ +Documentation +============= + +.. toctree:: + :maxdepth: 1 + + hdx + pigeon + feather + diff --git a/_sources/feather.rst.txt b/_sources/feather.rst.txt new file mode 100644 index 0000000..dd74f92 --- /dev/null +++ b/_sources/feather.rst.txt @@ -0,0 +1,21 @@ + +FEATHER +======= + +**FEATHER** (Free Energy Assignment Through Hydrogen Exchange Rates) is a +is a Bayesian method that combines peptide subtraction, isotopic mass +envelope reconstruction, and Monte Carlo (MC) sampling to assign PFs for each individual residue. + + +.. figure:: ../image/envelope_reconstruction.png + :alt: FEATHER + :width: 800px + :figclass: align-center + +classes +------- + +.. toctree:: + :maxdepth: 1 + + classes \ No newline at end of file diff --git a/_sources/hdx.rst.txt b/_sources/hdx.rst.txt new file mode 100644 index 0000000..3b7e5c1 --- /dev/null +++ b/_sources/hdx.rst.txt @@ -0,0 +1,18 @@ +HDX/MS +====== + +Hydrogen exchange with mass spectrometry (HX/MS) measures +the rate of exchange of labile hydrogen atoms with deuterium +in a protein's backbone amide groups to report on structural +changes in protein ensembles but at the peptide level, not individual amino acids. +With the advent of integrated robotics for automated sample preparation +and accurate protein structure prediction methods +for improved data interpretation, HX/MS is an increasingly +powerful method for probing solution-state protein ensembles. +However, the technique is not used to its full potential due to +its peptide resolution. + +To address this problem, we developed **PIGEON-FEATHER** (Peptide ID Generation +for Exchange Of Nuclei-Free Energy Assignment Through Hydrogen Exchange Rates): +an HX/MS analysis method to calculate the absolute free energy of opening (∆Gop) +for almost all the amino acids in a protein ensemble. diff --git a/_sources/index.rst.txt b/_sources/index.rst.txt new file mode 100644 index 0000000..8217340 --- /dev/null +++ b/_sources/index.rst.txt @@ -0,0 +1,34 @@ + +=========================================== +Welcome to PIGEON-FEATHER's documentation! +=========================================== + +.. figure:: ../image/pigeon_feather.png + :alt: PIGEON-FEATHER + :width: 800px + :figclass: align-center + +**PIGEON-FEATHER** (*Peptide ID Generation for Exchange Of Nuclei-Free +Energy Assignment Through Hydrogen Exchange Rates*): a method +for calculating free energies of opening (∆Gop) at single- or +near-single-amino acid resolution for protein ensembles of all +sizes from hydrogen exchange/mass spectrometry (HX/MS) data. + + + + +.. toctree:: + :maxdepth: 2 + + installation + documentation + tutorial + + + +Indices and tables +================== + +* :ref:`genindex` +* :ref:`modindex` +* :ref:`search` diff --git a/_sources/installation.rst.txt b/_sources/installation.rst.txt new file mode 100644 index 0000000..869a71f --- /dev/null +++ b/_sources/installation.rst.txt @@ -0,0 +1,52 @@ +Installation +============ + +Conda +----- + +.. code-block:: bash + + # install mamba + wget "https://github.com/conda-forge/miniforge/releases/latest/download/Mambaforge-$(uname)-$(uname -m).sh" + bash Mambaforge-$(uname)-$(uname -m).sh + + # create a conda environment and install the required packages + conda create --name pigeon_feather python=3.11 + conda activate pigeon_feather + + conda install jupyterlab mdanalysis numba + conda install pymol-open-source + + pip install pyopenms hdxrate + + # clone the PIGEON-FEATHER repo + git clone https://github.com/glasgowlab/PIGEON-FEATHER.git + + # clone the bayesian hdx iso repo + git clone https://github.com/lucl13/bayesian_hdx.git + + cd PIGEON-FEATHER + pip install . + + cd ../bayesian_hdx + pip install . + + + +Docker +------ + +.. code-block:: bash + + docker build -f docker/Dockerfile -t pigeon_feather:0.9 . + docker run -it -v $(pwd):/work -p 8889:8889 --rm pigeon_feather:0.9 jupyter-lab --port 8889 + +To open the Jupyter notebook, please click the link displayed in the terminal. +For users operating on Apple Silicon machines, it may be necessary to append +`--platform amd64` when building the image, as `pyopenms` is not supported on +the linux/arm64 architecture. It is advisable to avoid running the Docker container +on Apple Silicon machines due to the significant performance degradation +caused by the emulation of the x86_64 architecture. + +Note: ``bayesian_hdx`` at the above link is a fork of the `original repo `_ , +which has been modified for compatibility with the PIGEON-FEATHER workflow and support for isotopic envelope fitting. \ No newline at end of file diff --git a/_sources/pigeon.rst.txt b/_sources/pigeon.rst.txt new file mode 100644 index 0000000..cd6892e --- /dev/null +++ b/_sources/pigeon.rst.txt @@ -0,0 +1,73 @@ + +PIGEON +====== + +**pigeon** is a stand-only program that takes in a list of peptide pool csv +and outputs a cleaned csv of pooled data. It also outputs a rangeslist table for merge in FEATHER. + +CMD Options +----------- + +Type ``pigeon --help`` to see the following options: + +| ``--t``, ``--table``: Path(s) to input csv. Required +| ``--o``, ``--out``: path to output csv, if any. +| ``--p``, ``--plots``: directory for output plots. Default: './csvplots' +| ``--ov``, ``--overlap``: flag specifying how to treat overlapping duplicates. Options: 'keep', 'drop', 'select' (or any other). Default: 'select' +| ``--r``, ``--rangeslist``: path to output rangeslist, if any. +| ``--RTC``: RT cutoff for duplicate peptides. Default: 0.5 +| ``--MZC``: m/z cutoff for duplicate peptides. Default: 0.1 +| ``--scoreC``: Score threshold for provisional cut for trendline fit. Default: 150 +| ``--ppmC``: m/z deviation cutoff (in ppm) for cut about trendline. Default: 7 +| ``--maxfev``: maxfev for curve_fit for trendline. + +Default inputs + +| ``--t`` (list of peptide pool csvs) + +Default outputs + +| ``--o`` (batched and cleaned peptide pool csv) +| ``--r`` (rangeslist table for merge in post-PIGEON) + +In the plot directory, the following files are generated: + +score histograms: + + | `hist-scores-all.png`: Histogram of score for all pooled data. + | `hist-scores-cut.png`: Histogram of score for high scoring data used for curve fit. + | `hist-scores-ppm.png`: Histogram of score after cut at ppmC from trendline. + | `hist-scores-topscores.png`: Histogram of score after dropping all but best match for each charge state. + | `hist-scores-flagged.png`: Histogram of score for non-overlapping duplicates. + | `hist-scores-yellow.png`: Histogram of score for overlapping duplicates. + | `hist-scores-clean.png`: Histogram of score for final cleaned data. + +scatterplots: + + | `scatter-30ppm.png`: All data before cuts, ppm m/z deviation vs m/z measured, colorbar Score. + | `scatter-hscoring.png`: High scoring data used for curve fit. + | `scatter-7ppm.png`: All data after cut at ppmC from trendline. + | `scatter-topscore.png`: Data after dropping all but best match for each charge state. + | `scatter-flagged.png`: Data dropped for being duplicates, non-overlapping. + | `scatter-yellow.png`: Data dropped for being duplicates, overlapping. + | `scatter-clean.png`: Final cleaned data. + +ppm histogram: + + `hist-ppms.png`: Histogram of abs(distance from trendline) for all data, showing location of cut. + + +Example Usage +------------- + +Below are examples of how to use the ``pigeon`` program with various arguments: + +.. code-block:: bash + + pigeon --t pool-1.csv pool-2.csv pool-3.csv --p csvplots --ov keep --o keep-pooled.csv --r rangeslist.csv --MZC 0.05 --RTC 0.25 --scoreC 200 --ppmC 5 --maxfev 2000 + +Alternative usage example: + +.. code-block:: bash + + pigeon --t pool-1.csv --o select-pooled.csv --r rangeslist.csv diff --git a/_sources/tutorial.rst.txt b/_sources/tutorial.rst.txt new file mode 100644 index 0000000..45ee4f1 --- /dev/null +++ b/_sources/tutorial.rst.txt @@ -0,0 +1,16 @@ +Tutorials +========= + +.. Jupyter notebook tutorials +.. -------------------------- + +.. toctree:: + :maxdepth: 1 + + tutorials/00_ecdhfr_showcase + tutorials/01_load_data + tutorials/02_peptide_level_analysis + tutorials/03_calculate_PFs + tutorials/04_check_the_fitting + tutorials/05_plot_the_results + diff --git a/_sources/tutorials/00_ecdhfr_showcase.ipynb.txt b/_sources/tutorials/00_ecdhfr_showcase.ipynb.txt new file mode 100644 index 0000000..6ac552f --- /dev/null +++ b/_sources/tutorials/00_ecdhfr_showcase.ipynb.txt @@ -0,0 +1,1395 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 00_Showcase ecDHFR: a FEATHER walkthrough" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tutorial dataset can be downloaded from [this link](https://figshare.com/ndownloader/files/48153751)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "import datetime\n", + "import os\n", + "\n", + "out_path = \"./data/bayesian_hdx_input_20240722\"\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = os.path.join(out_path, f\"ecDHFR_results_{today_date}\")\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## load the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "./data/ecDHFR_tutorial.csv\n", + "rangeslist included !\n", + "Removed 0 peptides from state APO due to missing raw MS data.\n", + "Removed 70 peptides from state APO due to high back exchange.\n", + "Removed 2 peptides from state TRI due to missing raw MS data.\n", + "Removed 70 peptides from state TRI due to high back exchange.\n", + "Done loading raw MS data.\n" + ] + } + ], + "source": [ + "tables = ['./data/ecDHFR_tutorial.csv']\n", + "\n", + "ranges = ['./data/rangeslist.csv']\n", + "\n", + "\n", + "raw_spectra_paths = [\n", + " f\"./data/SpecExport/\",\n", + "]\n", + "\n", + "protein_sequence = \"MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR\"\n", + "\n", + "# load the data\n", + "hdxms_data_list = []\n", + "for i in range(len(tables)):\n", + " # for i in [4]:\n", + " print(tables[i])\n", + "\n", + " \n", + " # read the data and clean it\n", + " cleaned = read_hdx_tables([tables[i]], [ranges[i]], exclude=False, states_subset=['APO','TRI'])\n", + " \n", + " # convert the cleaned data to hdxms data object\n", + " hdxms_data = load_dataframe_to_hdxmsdata(\n", + " cleaned,\n", + " n_fastamides=2,\n", + " protein_sequence=protein_sequence,\n", + " fulld_approx=False,\n", + " saturation=0.9,\n", + " )\n", + "\n", + " # load the raw ms data to the hdxms data object\n", + " load_raw_ms_to_hdxms_data(\n", + " hdxms_data,\n", + " raw_spectra_paths[i],\n", + " )\n", + "\n", + " hdxms_data_list.append(hdxms_data)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hdxms_data_list" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# save the raw data as a pickle file\n", + "import pickle\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "# with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"wb\") as f:\n", + "# pickle.dump(hdxms_data_list, f)\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + " HDX-MS Data Statistics\n", + "============================================================\n", + "States names: ['APO', 'TRI']\n", + "Time course (s): [46.0, 373.5, 572.5, 2011.0, 7772.0, 30811.5, 43292.0]\n", + "Number of time points: 7\n", + "Protein sequence length: 174\n", + "Average coverage: 0.93\n", + "Number of unique peptides: 186\n", + "Average peptide length: 9.4\n", + "Redundancy (based on average coverage): 10.0\n", + "Average peptide length to redundancy ratio: 0.9\n", + "Backexchange average, IQR: 0.19, 0.15\n", + "============================================================\n" + ] + } + ], + "source": [ + "from pigeon_feather.hxio import get_all_statics_info\n", + "\n", + "get_all_statics_info(hdxms_data_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## back exchange correction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "back exchange correction for peptides with experimental full deuteration data based its closest match in the database" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "186" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# grab all the peptides\n", + "\n", + "all_peps = [\n", + " pep\n", + " for data in hdxms_data_list[:]\n", + " for state in data.states\n", + " for pep in state.peptides\n", + "]\n", + "\n", + "len(set([pep.identifier for pep in all_peps]))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([18., 16., 10., 20., 30., 20., 42., 20., 24., 40., 38., 28., 20.,\n", + " 14., 8., 6., 4., 2., 2., 8.]),\n", + " array([0.60127572, 0.62628601, 0.6512963 , 0.67630658, 0.70131687,\n", + " 0.72632716, 0.75133745, 0.77634774, 0.80135802, 0.82636831,\n", + " 0.8513786 , 0.87638889, 0.90139918, 0.92640947, 0.95141975,\n", + " 0.97643004, 1.00144033, 1.02645062, 1.05146091, 1.07647119,\n", + " 1.10148148]),\n", + " )" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "max_d = [pep.max_d / pep.theo_max_d for pep in all_peps]\n", + "plt.hist(max_d, bins=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## plot uptake plots" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# option 1\n", + "from matplotlib.ticker import MultipleLocator, FormatStrFormatter\n", + "import matplotlib.ticker as ticker\n", + "import matplotlib.lines as mlines\n", + "from pigeon_feather.analysis import get_index_offset\n", + "from matplotlib.ticker import LogLocator\n", + "\n", + "\n", + "font = {\"family\": \"Arial\", \"weight\": \"normal\", \"size\": 36}\n", + "axes = {\"titlesize\": 36, \"titleweight\": \"bold\", \"labelsize\": 36, \"linewidth\": 5}\n", + "plt.rc(\"font\", **font)\n", + "plt.rc(\"axes\", **axes)\n", + "plt.rc(\"lines\", lw=5)\n", + "\n", + "colors = [\"k\", \"red\", \"blue\", \"purple\", \"gray\", \"orange\", \"yellow\", \"green\", \"brown\"]\n", + "\n", + "\n", + "all_peps = [\n", + " peptide\n", + " for hdxms_data in hdxms_data_list\n", + " for state in hdxms_data.states\n", + " for peptide in state.peptides\n", + " if peptide.note is None and state.state_name != \"RAT\"\n", + "]\n", + "all_idfs = [pep for pep in all_peps if pep.unique_num_timepoints > 5]\n", + "all_idfs = list(set([peptide.identifier for peptide in all_peps]))[:]\n", + "all_idfs.sort(key=lambda x: int(re.search(r\"(-?\\d+)\", x).group()))\n", + "\n", + "\n", + "\n", + "def idf_to_pep(idf):\n", + " return [pep for pep in all_peps if pep.identifier == idf][0]\n", + "\n", + "# num_subplots_per_figure = 100\n", + "num_subplots_per_figure = 250\n", + "num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)\n", + "\n", + "\n", + "all_idfs_subset = all_idfs[:]\n", + "\n", + "for fig_index in range(num_figures):\n", + " # Select the subset of errors for the current figure\n", + " selected_idf = all_idfs_subset[\n", + " fig_index * num_subplots_per_figure : (fig_index + 1) * num_subplots_per_figure\n", + " ]\n", + " num_col = math.ceil(len(selected_idf) / 5)\n", + "\n", + " fig, axs = plt.subplots(\n", + " num_col, 5, figsize=(9 * 5, 8 * num_col)\n", + " ) # Adjust subplot size as needed\n", + "\n", + " for i, idf in enumerate(selected_idf):\n", + " ax = axs[i // 5, i % 5]\n", + "\n", + "\n", + " pep = idf_to_pep(idf)\n", + " ax.axhline(y=pep.max_d, color='lightgray', linestyle='--', linewidth=5)\n", + "\n", + "\n", + " uptake = UptakePlot(\n", + " hdxms_data_list,\n", + " idf,\n", + " states_subset=[\"APO\", \"TRI\"],\n", + " if_plot_fit=False,\n", + " figure=fig,\n", + " ax=ax,\n", + " )\n", + "\n", + " ax.set_xlim(1e1, 1e5)\n", + " ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))\n", + "\n", + "\n", + " y_max = pep.theo_max_d/hdxms_data_list[0].saturation\n", + " ax.set_ylim(-0.5, y_max + 0.5)\n", + "\n", + "\n", + " #Custom legend\n", + " handles, labels = ax.get_legend_handles_labels()\n", + " new_labels = [label for label in labels if label in [\"APO\", \"TRI\"]]\n", + " new_handles = [\n", + " handle\n", + " for handle, label in zip(handles, labels)\n", + " if label in [\"APO\", \"TRI\"] \n", + " ]\n", + " ax.legend(new_handles, new_labels, title=\"state\", title_fontsize=\"small\",loc='best')\n", + "\n", + "\n", + " # Layout adjustment and save\n", + " fig.tight_layout()\n", + " fig.savefig(f\"{results_path}/DHFR_exp_uptake_{fig_index}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## peptide subtraction" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "117 new peptides added to the APO state.\n", + "126 new peptides added to the TRI state.\n" + ] + } + ], + "source": [ + "# [state.add_all_subtract() for data in hdxms_data_list for state in data.states]\n", + "# add_new_peptides_by_subtract()\n", + "for i in range(1):\n", + " [\n", + " state.add_new_peptides_by_subtract()\n", + " for data in hdxms_data_list[:]\n", + " for state in data.states\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[117, 126]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[state.num_subtracted_added for data in hdxms_data_list for state in data.states]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "save the data as a pickle file for later use, and write to files used for bayesian sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "out_path = f\"./data/bayesian_hdx_input_{today}\"\n", + "if not os.path.exists(out_path):\n", + " os.makedirs(out_path)\n", + "\n", + "\n", + "import pickle\n", + "\n", + "with open(f\"{out_path}/hdxms_data_list.pkl\", \"wb\") as f:\n", + " pickle.dump(hdxms_data_list, f)\n", + "\n", + "# with open(f\"{out_path}/hdxms_data_list.pkl\", \"rb\") as f:\n", + "# hdxms_data_list = pickle.load(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## inputs for MCMC sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Isotope files saved to ./data/bayesian_hdx_input_20240722/spectra_dhfr_tutorial_dataset\n", + "Reminder: sequence contains fastamides !!!\n", + "Reminder: sequence contains fastamides !!!\n", + "Data saved to ./data/bayesian_hdx_input_20240722\n", + "dhfr_tutorial_dataset\n" + ] + } + ], + "source": [ + "exp_names = [\n", + " \"dhfr_tutorial_dataset\",\n", + "]\n", + "\n", + "for i in range(len(hdxms_data_list)):\n", + " # exp_name = raw_spectra_paths[i].split('/')[-2].split('SpecExport_')[-1]\n", + " exp_name = exp_names[i]\n", + " export_iso_files(\n", + " hdxms_data_list[i], outdir=f\"{out_path}/spectra_{exp_name}\", overwrite=True\n", + " )\n", + " df = revert_hdxmsdata_to_dataframe(hdxms_data_list[i])\n", + " convert_dataframe_to_bayesianhdx_format(\n", + " df, protein_name=exp_name, OUTPATH=f\"{out_path}\"\n", + " )\n", + "\n", + " print(exp_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# write ready to run script for each state\n", + "\n", + "protein_sequence = \"MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR\"\n", + "\n", + "state_names = list(\n", + " set([state.state_name for data in hdxms_data_list for state in data.states])\n", + ")\n", + "for protein_state in state_names:\n", + " script = tools.generate_bayesian_hdx_script(\n", + " exp_names,\n", + " protein_sequence,\n", + " protein_state,\n", + " base_directory=\".\",\n", + " making_chunks=True,\n", + " pH=7.0,\n", + " temperature=293.0,\n", + " saturation=0.9,\n", + " rerun_num=3,\n", + " extreme_value_prior=False,\n", + " structural_prior=False,\n", + " )\n", + "\n", + " with open(f\"{out_path}/run_bayesian_hdx_{protein_state}_chunks.py\", \"w\") as f:\n", + " f.write(script)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "two priors" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# uptake prior\n", + "#tools.generate_extreme_value_prior(hdxms_data_list, out_path)\n", + "\n", + "\n", + "# structural prior\n", + "\n", + "# solvated_pdbs = [\n", + "# \"./data/5DFR_APO_relaxed_best_solvated.pdb\",\n", + "# \"./data/6XG5_TRI_relaxed_best_solvated.pdb\",\n", + "# \"./data/1RG7_MTX_relaxed_best_solvated.pdb\",\n", + "# ]\n", + "\n", + "# for i, state_name in enumerate([\"APO\", \"TRI\", \"MTX\"]):\n", + "\n", + "\n", + "# tools.generate_structural_prior(\n", + "# protein_sequence, solvated_pdbs[i], out_path, state_name\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## run the sampling" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can run the script in the terminal with the following command:\n", + "\n", + "```sh\n", + "cd ./data/bayesian_hdx_input_20240722\n", + "python run_bayesian_hdx_APO_chunks.py\n", + "```\n", + "\n", + "The simulations usually take several hours, but the duration varies based on the size of the dataset (number of peptides, time points, and replicates).\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "class CustomUnpickler(pickle.Unpickler):\n", + " def find_class(self, module, name):\n", + " if name == \"ProteinState\":\n", + " from pigeon_feather.data import ProteinState\n", + "\n", + " return ProteinState\n", + " if name == \"HDXMSData\":\n", + " from pigeon_feather.data import HDXMSData\n", + "\n", + " return HDXMSData\n", + " if name == \"Peptide\":\n", + " from pigeon_feather.data import Peptide\n", + "\n", + " return Peptide\n", + " if name == \"Timepoint\":\n", + " from pigeon_feather.data import Timepoint\n", + "\n", + " return Timepoint\n", + " return super().find_class(module, name)\n", + "\n", + "\n", + "# read pcikle\n", + "with open(f\"{out_path}/hdxms_data_list.pkl\", \"rb\") as f:\n", + " hdxms_data_list = CustomUnpickler(f).load()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hdxms_data_list" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "for data in hdxms_data_list:\n", + " for state in data.states:\n", + " state.peptides = [pep for pep in state.peptides if pep.note is None]\n", + " for pep in state.peptides:\n", + " pep.timepoints = [tp for tp in pep.timepoints if tp.note is None]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "create an Analysis object and load the results, note: the temperature and pH are crucial to calculate the instrisic exchange rates. make sure to input the correct ones. The chunk size and chunk number can be altered by user. in this tutorial it was automaticaly determined by a help function." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import Analysis, get_index_offset\n", + "from pigeon_feather.tools import optimal_chunks\n", + "import matplotlib.pyplot as plt\n", + "\n", + "RUN_NUM = 3\n", + "\n", + "apo_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"APO\"\n", + "]\n", + "\n", + "tri_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"TRI\"\n", + "]\n", + "\n", + "ana_apo_1 = Analysis(apo_states, temperature=293.0, pH=7.0)\n", + "\n", + "chunk_num, chunk_size = optimal_chunks(len(ana_apo_1.protein_sequence))\n", + "ana_apo_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"APO\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")\n", + "\n", + "\n", + "ana_tri_1 = Analysis(tri_states, temperature=293.0, pH=7.0)\n", + "\n", + "ana_tri_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"TRI\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# for mini in ana_apo_1.results_obj.mini_peps:\n", + "# print(mini.std_within_clusters_log_kex)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fitting check" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "two fitting check functions are available: 1. centroid level fitting check 2. isotopic mass envelope fitting check. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import (\n", + " check_fitted_isotope_envelope,\n", + " check_fitted_peptide_uptake,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### envelope check" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "check_state_name = \"APO\"\n", + "check_ana_obj = ana_apo_1\n", + "\n", + "\n", + "all_peps = [\n", + " pep\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " for pep in state.peptides\n", + " if state.state_name == check_state_name and pep.note is None\n", + "]\n", + "all_tps = [\n", + " tp\n", + " for pep in all_peps\n", + " for tp in pep.timepoints\n", + " if pep.get_timepoint(0) is not None and tp.deut_time != np.inf and tp.deut_time != 0\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.18086398727111275" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7kAAAMJCAYAAADGbfG1AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gUxf8H8PfdpXdSCFUSQgshtIB0AkiTJr1EqgUsIIKKIiIIIkX9KUURBWkSkC4QkBp67y0gkACGQIAEUki/298fZ+6bzW6Sq6nv1/PcAzs3O/O5TbvPzeyMQhAEAURERERERESlgLKoAyAiIiIiIiIyFya5REREREREVGowySUiIiIiIqJSg0kuERERERERlRpMcomIiIiIiKjUYJJLREREREREpQaTXCIiIiIiIio1mOQSERERERFRqcEkl4iIiIiomElNTS3qEIhKLCa5RAQA0Gg0qFq1KhQKhejx3nvvGdTO9OnTJW3kfCiVSlhbW8PBwQGenp6oXbs2unbtih9//BFJSUkGx33lyhXMnTsXnTp1Qu3ateHu7g5bW1tUqlQJDRo0wNtvv40///wTL168MLhtczt8+DDGjBmDOnXqwMXFBQ4ODqhVqxbefvttXLx40eh2Y2Nj4eXlJbrOd+/eNSnWkSNH5vt1LOiR7e7duya1M336dJNeBwBcvHgRM2bMQHBwMKpXrw4XFxfY2NjAy8sLgYGBGD58OP74448C31DKvZZ27drpHceFCxcwdepUdOjQAVWrVoWjoyOsrKzg5uaG6tWro0ePHvjqq69w/fp1vdoz5Gtka2uLcuXKoUaNGujcuTOmTp2KyMhIk9rP/ll2dHRE+fLlUbduXbz22mtYunQp0tPT82x3xYoVZv066/M9ZmVlBVtbW7i5uaFatWpo0aIFPvzwQ1y5csXg/jQaDf7++2+MHTsWzZs3h7e3N+zs7GBjYwNPT08EBARg0KBB+OmnnxAbG6tXmz4+Pnp9HZVKJezs7ODl5YWAgAD06dMHP/74IxITE/Ntv127dpK29Pkd8c4778jGERQUhISEBF09ue+V3377rcD25b52K1asMCp+ub89cm3lruPj41NgnIUtIyMDc+fOxcCBA4s6FJ1ly5YZ/LsvLi4O33//PYKDg1GpUiXY2trCy8sLbdq0wezZs/H8+XO9+z927BhGjx6NgIAAuLq6wsbGBhUqVECHDh0wb948vdu6c+cOJk6ciPr168PNzQ0ODg6oUaMGRo0ahYMHD+odj5zOnTuLrpGp7ZGJBCIiQRB27twpAJA8XFxchBcvXujdzrRp02Tb0efh7e0tHDx4UK9+Lly4ILzyyit6t+3l5SV8++23Qnp6urGXyGjx8fFC//79841PqVQK06ZNM6r91157TdJeVFSUSTGPGDHC6K9jzj8tUVFRJrVj7DURBEGIjo4WBg4cqHdfHh4ewurVq/NsT+61BAcHFxjHlStXhA4dOhj0urt37y78888/+bZr6tfIxsZGmD59ukXar1GjhnDlyhXZdpcvX27Wr7Mp32NKpVL49NNPBY1Go1dff/31l1CjRg2927e2thbGjx8vJCQk5NtutWrVTPpali9fXti6dWue7QcHB0vOKeh3xBdffCHbV7169YSnT5+K6sp9r7i7uwtPnjzJtw+5r93y5cuNil/ub49cW7nrVKtWLd8YC9uOHTuEmjVr6v37pTDcu3dPcHFxMeh337p16wQPD498v2/LlSsn7Ny5M992njx5IvTs2bPAnwE3Nzdhy5Yt+bb19ddfC9bW1vm2M3DgQCEpKcnAKyQI+/btk7QVHh5ucDtkPkxyiUgQBEHo169fnr/0ly1bpnc7piS5AAR7e3vh1KlT+faxZs0awc7Ozqj2W7VqJTx69MjUy6W3p0+fCg0bNtQ7vu+++86g9lesWCHbTmlJcvNLwvLz8OFDwc/Pz6g+Z8yYIdumMUnu4sWLC3xTldfD1dVV2L9/v8W+RtmP2bNnW6R9T09P4c6dO5J2i1OSm/2YOHFivn2kp6cLb731ltHtBwQECPfv38+zfVOTXED7oUVeHxIamuQuXLhQto9atWrJ/v7M63tl1KhR+V5XJrliISEhBv1+KQwajUb2Q7r8Ytu4caOgVCr1+r5VKpXCjh07ZNtJTEwUAgMD9f4ZUCqVwubNm2XbmjBhgt7ttGjRwqBE9/79+0KlSpUk7TDJLVpWIKIy78mTJ9i2bVuez//666944403jG7fx8cHHh4eALRT/TIyMvDs2TM8fPgQgiCI6qampmLEiBG4evUqVCqVpK1169bh9ddfl+1HpVKhSpUqcHFxQWxsLB4/fiypc+zYMbRs2RKnT5/WxWRJclORVSoVateujSdPnuDJkyei57744gsMHToU3t7eBbYdHR2NDz/80IzR/o+vry+CgoIKrJeQkIDbt2+LyiZNmqT7v62trV7tAEBERARSUlJ0x97e3hgxYoSeEYsNGDAAd+7ckZTb2tqiSpUqcHBwQHR0NJ49eyap8+WXX6JVq1bo0KGDUX1n+/bbb0XXIidra2tUrlwZjo6O+Pfff2WnmyYkJKBPnz44deoU6tSpo1eftWrVgrOzs+5YEARoNBpkZWXh8ePHsj8TX3zxBXr37q1XHznbV6vVSE9PR1xcnGy7T58+xTvvvIM9e/boFbs5OTk5oXbt2gC01yArKwvJycl48OCB7FTqH374AX379kWrVq0kz6nVagwYMCDP35GOjo6oVKkSlEol7t69K9v+tWvX0LNnTxw/fhwODg56vYbcPzfZX8uMjAzcv38fycnJouczMjIwcuRI/PPPP7C2ttarDznr1q3DBx98ICn39fXF/v379frdlG3FihV48803Za8rSR07dqyoQ5D46aefcODAAb3rp6SkYOzYsdBoNKJyZ2dnVK5cGXfv3kVaWpquXKPRYNSoUbh9+zZcXFxE50ybNk32loLy5cvDxcUFUVFRUKvVorbeeOMNBAcHw93dXVf+119/4YcffpC0U6VKFSiVSty/f19UfuLECXz++edYsGBBga83IiIC3bt3R0xMTIF1qZAVbY5NRMXB999/X+Anm5cuXdKrLX0/TRcE7af4eU0n3b59u6T+xYsXZUdwvby8hJ9++kmIi4sT1b9x44bw3nvvCSqVSnJOp06dBLVabfC1MkRYWJik3+bNmwv37t0TBEH7Cfm8efMkdebNm6dX+126dMnz62XqSK6+unXrJur31Vdf1XvqZ07Hjh0TfZ1UKpVw5MgRo2I6ePCg5HrUrl1b2LJli+RrHh4eLjuK1rp1a0m7hozk7ty5U1AoFLJxrFmzRkhMTBTVv3HjhjBy5EjZr+Urr7wi24fc6Fl+IwcajUbYsWOH4ObmJjnvo48+Mqn9a9euCe3atZONP/e05cIYyc3r65KSkiIsXrxYsLW1lZzTr18/2XM+/fRT2dfVuXNn4cCBA0JmZqaurkajEfbv3y+0adNG9pyZM2fK9iH3PZiftLQ0Yd68ebLfY3K/O/Udyd29e7fszIMqVark+zslv1H/wMBA0TXKiSO5Yrm/D4p6JPfWrVuCg4OD7Nc1r9h+++03Sd3PP/9cyMjIEARBEOLi4oSuXbtK6ixdulTUTnJysqRvb29v4cCBA7o6Dx48kB1lnjNnjqit3KPBnp6eot9lu3btElxdXUV1lEqlcP369Xyvz9KlSwVHR8c8v/c5klu0mOQSkVC3bl3RL+aKFStKflmPHTtWr7YMSXIFQfumsEWLFpJzPvzwQ0lduTeO/v7+QnR0dL4xbdu2TfZNbX73X5pD7ntlnZycZKf6BQQECAAEOzs7wdfXV5g0aVKBbS9evDjPP6x5vYE1t59++knUp5eXl/D48WOD20lMTBSqV68uasvYacqCIAhTpkyRXI/83qxcuXJFMrVOqVRKPjTRN5lKTU0VqlSpIqnbt29fITU1Nd/YFyxYIPv1PH/+vKSuoUlutkWLFknOa9Gihcntp6amCj4+PpJzfvzxR1G9okxys/3yyy+Sc8qVKyf5gObixYuyH5LNnTs33/azsrJkP8Bzd3eXTfgMTXKzyd3rP3nyZEk9fZLEU6dOyb5hr1ChgnDz5s184yhoavv3338vex6TXLHilOSq1WqhVatWeX5N84ot99+99u3bS+rcvn1b0t77778vqrNp0yZJnVWrVknaevjwoeTve8eOHXXP37hxQ9LOb7/9Jmln/fr1ev0saTQaYffu3ULLli3z/Z7X9/cxWQ5XVyYq406cOCFZzXXatGmoW7euqEyf1WeNoVAo8NZbb0nKc6/8unfvXhw5ckRU5uDggK1bt6Jy5cr59tGzZ0988803kvLZs2dLpkubS2JiInbt2iUq69Onj+xUvz179iAuLg6pqamIjIzE3Llz8207KioKn3zyiVnjNdSDBw8kU3EXLFgALy8vg9vKvdJvvXr18Pnnnxsdm9zUWVdX1zzr16tXTzKdUqPR4N69e0b1v3z5ckRHR4vK6tevj9DQUNjZ2eV77rhx4/Dqq6/qjlUqFfz9/REVFWVULHLatm0rKcs9bd4YdnZ2GDZsmKS8oFWci8KoUaMkt0M8e/ZMskLrN998I5oOCQCjR4/Ocxp6NpVKheXLl8PT01NXZm9vDz8/P5NXPs/JXF/Lmzdvonv37pJV6D09PbFv3z7UqlXL6BgB7d+UBw8emNRGaZa9Gm/u3zmHDh2SXQVablXq7NtiLl68iDfeeAN+fn6ws7NDxYoV0adPH4SFhRkU03fffWfU9OnffvsNhw4dwpIlSzBhwgSMHz9eUsfNzU1SZm9vLzqW23Ggc+fOkrIKFSpIvj9z/v49efKk5JyuXbtKyvr3748KFSqIyjZu3Cipt23bNnTp0gXHjx8XlTs6OkrqUtHiPblEZdyyZctEx7a2thg0aBASExNFb+SeP3+O9evXG32PZH4qVqwoKct9X9sff/whqfP222/r/ebrgw8+wHfffYeHDx/qyq5fv46zZ8+iadOmBkZcsIsXLyIjI0NUJveGFAAqVaqkd7uCIGDkyJGi+/H69euHTZs2GReokT7++GPRG+L27dtj8ODBBrdz7do1/PTTT6KyRYsWmXRPYc7EItuIESOwevVqyZuYbNu2bZPc41i+fHmj+s/9MwVokyVbW1u9zp87dy769++PBg0aICAgoMDE2FByH1blvI/XFPr8LBcHNjY28PDwkHwgkjPW58+fY/PmzaLn7ezsMGvWLL36cHBwwMqVK5GcnIwGDRqgZs2aUCrNO7Zgjq9ldHQ0OnfujKdPn4rK3dzcsGfPHgQEBJgUIwAkJyfjww8/xIYNG0xui/I2d+5cTJkyRfTBzKNHj7B161Zs3boV/fv3x+rVqwv8nXL9+nV8+eWXumNXV1c0adIE+/fvLzAGLy8veHl55fn3DtDe953byy+/LDp+44030Lx5c8TExOgeeX2ImpmZKTrO+frktvGS+zugUCgQEBCAR48e6cpu376N5ORkODk56crkPhgfNGgQgoODDd5ykSyLI7lEZdiLFy/w559/isp69eoFNzc3DBs2DFZW4s/Bfv31V4vEERERISnLPeIZHh4uqTN8+HC9+7CyspJNwiy1j93ly5clZQEBAbh16xaGDx+OihUrws7ODtWrV8eYMWNw8+ZNvdr98ccfcfjwYd1xcHAw3n//fbPFrY8TJ06I3qQoFArZRT30MXHiRGRlZemO+/Tpg+DgYJPikzt/3759qFatGvr06YMVK1ZIFhpxc3NDlSpVRA8bGxuD+3706BHOnTsnKvPy8hKNzhYkMDAQb7zxBoKCgsye4ALAmjVrJGUNGjQwS9v6/CwXB0+fPpWMeCqVStEHJLt37xZ9bwJA9+7dZT9EyUu3bt0wcOBA1K5d2+wJblZWluT3N2DY1zI+Ph5dunSR/Dw4OTlh165daNSokVGxlStXTjJat3HjRuzevduo9qhgixYtwmeffSaZeZDTxo0b8dprr0kWhcopKysLw4cPF33g88MPP6BKlSomxZeamoobN27giy++wMSJE0XP1a1bF3379hWV+fj4oFu3bnjrrbfw5Zdf4pdffpH9GYqNjZUsflitWjXd/+WS0txJcV4EQcC1a9fyfN7LywurV6/GunXrJCPRVPSY5BKVYX/++adk9Co7caxQoYJkSs/x48fz/YVvjPj4eNkVDHOu9JqQkIB///1X9Ly9vb3Bb8xzf1IMAKdOnTKoDX3JTdGMiIhAo0aNsHr1ajx69Ajp6emIiorCr7/+isDAQMyfPz/fNm/evIkpU6bojh0dHfH7779DoVCYPf78TJ8+XXTco0cPo5KkkydPSlbezfn6jNWxY0fZeDIyMrB161aMGjUK1apVQ/Xq1TFq1Cj8+eefSEhIMLlfALhw4YKkrHnz5mZPcPQlCAIyMjIQFxeHS5cu4aOPPpL9eQsJCTG5r6ioKKxatUpSru/K0IVpxowZkje/NWrUEH2wd/78ecl5LVu2tHhsedFoNEhNTcWjR49w5MgR9OzZUxKjk5MTevbsqVd7KSkp6N69u+R2FUA7Jbt58+ZGx+ri4iI74j127NhiObJf1IKCghAUFCT5YM3JyUn3XP369fNtI+cMkgoVKqBevXqys0f27NmDH3/8Mc92Zs2aJfqg7tVXX8WoUaP0fCV58/f3h7+/P2bNmiWa5VSlShWEhYXJ7qagj7lz50o+jOrYsaPu/3IzcuQ+jAMgSZYByK6aXK1aNcyePRuRkZEYOnSooSFTIWGSS1SG5Z5WWb58eVFiO3LkSMk5po7majQapKSk4O7du1i/fj1atmwpe+/joEGDdP/PPcoAaD/lNfSPop+fn6RM7v5Nc0hKSpKUvf/++5J73rJlZmbiww8/zDPRVavVGDFihGh64ty5c1G9enXzBKyn06dPSxJTY+8PnjFjhui4Q4cOem83lB+VSoVVq1bJ3veVU1RUFFasWIHBgwfD29sbgwcPlr0PzBByH27kHFWwtPbt24vu01MqlbC1tYWnpycaNmyI//u//5Oc89prr6FTp04G96XRaJCcnIzbt29j2bJlaN26teTDAgcHB72TLkvKyMjA48ePcezYMQwbNgwLFy6U1Mk906Oov5a577lUqVRwcHBAxYoV0bZtW/z999+Sc2bOnCnaOiU/w4YNk71fEQAWL14s+4bfEO+8847kVpDbt29jzpw5JrVbGp09exZnz56VTPcPCgrSPZffNn/ZPDw8sHPnTjx8+BBXrlxBbGys7N/xefPmSW6nAbQf0uX8cMLV1RW//fab4S8oF7VaLXtPds+ePXHp0iXR/caG2Llzp+RDOycnJwwZMkR3LPdhjdz7mLCwMNn3Irn/lnfq1AmRkZH47LPPRNOYqfhhkktURkVEREgWTggJCRGNZPTs2VOyl+zq1atFe9zpY9SoUaI3ao6OjvD19cWgQYNkp+m+8cYbouRNLmEsKIGRI7f4UFxcnMHt6EMu5uzrZmVlhTp16sjG88knn8iOrMydO1c06tyuXbsiuf8n9xuKZs2aoU2bNga3c+vWLcmb9IIW8zFE/fr1ER4ervcoYnp6Ov788080bdoUU6dONXpBMrn9bvNb9Oqzzz6TJDNyD2PfBBaka9eusve75yVnEq1SqeDs7IyaNWvirbfekh3xKKo3gjkX7FEoFLC1tYW3tzdat24t+3rLly+PcePGicoM/Vo2b95cr6+lXNJhKoVCgSlTphi0b7bcSHW21NRUjB492qSF+ZRKJX755RfJh5Fz5swxOYEmeZs3bxbdGuHq6orly5fjlVdeEdWLjY3F3r17RWUZGRkYPny4aCrvjz/+WODCjvp48OCBZLQV0Cap2Xs7G+rQoUMYMGCAZHr2+PHjRe9b/P39ERgYKKqzZMkSfPbZZ3j06BGePXuGNWvW5Hn7U+6/5Y6OjkU2M4cMw68SURkltzhO7kWlbGxs8Prrr4vKnj17JrvioLm8/PLLkvs75abjGvPmS+5eJUutrpzXfVG9evXC48ePERERgcePH+Pjjz8WPZ+ZmSlZXfny5cv46quvdMdFNU05Li5O8rWfMGGCUW39+uuvomvv7++PLl26mBRfbg0bNsSVK1ewfPlyNGvWTK9zsrKy8PXXX2Py5MlG9Sn3NSlu0zOVSiXatGmDdevWYdeuXRZLQnv06GH0dSxMDg4OCA0NldxrWxK+lvb29ujfvz9OnjyJr7/+2uh2bGxsJFNbw8PDsXTpUpPia9y4sWTNgLS0NMkHCmS65s2b57nYU+6/MwAkH3J/+eWXuHr1qu64W7duZvtA5t69e3BxcUFAQADKlSunK1er1di+fTuaNGmC06dP691eeHg4unfvjpSUFFF5QEAApk6dKqkv97Mxd+5cVKxYEe7u7hg6dCji4+Nl+zJlEUQqWkxyicqgzMxMrF69WlQWGBiIhg0bSurK3YtjiQWoVCoV3nnnHRw4cAAuLi6i53KPJgOQbPWhD7n7LuXaNge5xKFChQpYs2aN7o+8jY0Nvv32W7Ru3VpUb/v27bqFQTIzMzFixAjR1LJ58+bB19fX4JgOHjxY4ChTu3bt8jz/jz/+EL3Jt7OzQ48ePQyOIysrCytXrhSV9e/f3+B29GFlZYWRI0fi5MmTuHv3LpYsWYIBAwYUuBjS3LlzDXrTlU1uhsGzZ88MbsdYtWrVQsOGDeHj4yObpHl5eeHkyZM4fPiw6JYAc7Kzs8OUKVOwZcsWyeJ1xU1QUBAOHz4sGekCiv5rGRQUhHr16uW5InjTpk1x7949bNiwQXa9AX1ZW1tjw4YNksWAAO3MErkRekPMnDlTsoL833//bdEPS8ui3Nug5SR3L3nO6fgnT57Ed999pzt2c3Mz69/5l19+Gc+fP8fVq1cRHx+PlStXihbVS0pKwsCBA/WaJbZz505069ZNcuuPq6sr/vzzT9n7kHv16qXXbTVy9+9ySnLJVbz/+hCRRWzfvl1yL+rDhw/RpEkT2fpKpVK0GuORI0dw48YNvaeC+vj46JLJ7PsE7ezs4OrqiooVK6JevXro3bs3qlatKnu+3LYBUVFRyMjIMGgF3Bs3bujVtjnI/WHs1auXbPngwYNx9OhR3fGzZ88QFRUFPz8/zJgxQ3SfaPv27fHuu+9aJOaC5H5T2rlzZ6P2Bjx06JBkZds+ffqYFJs+qlWrhtGjR2P06NEAtNsX7d69G7///rvsgmqLFi2SXUgpP3JbWuW3WFuVKlVk70POvUKzvpYsWaL7oOLJkyeYNGkSVqxYoXv+yZMnaNu2Lf744w/069fP4PZr1aql26Ime8qynZ0d3NzcULlyZTRq1AivvfaaxX6u9OXk5ITatWvrjpVKJaytreHs7AxPT0/4+fmhY8eOaN26dZ4zIgz9Wvr7+0umZCYlJRk1FRPQ3qeZ7erVq3jzzTdFH7ycOXMGTZo0wd9//w1/f3+j+lCpVAgNDUWvXr3wyiuvYOXKlaKkNiEhAe+99x62bt1qVPuAdhGqH374QfKhyoQJEyR7iZPx8lv128XFBfb29qI1HbI/sElNTcWIESNEs4/MNU05W+7Ec/jw4bh3755om6J79+5h48aN+S7ktGXLFgwePFhyP7GjoyO2b9+e73ZX8+bNg6enJ6ZNmyabTHfp0gU9evSQzDIw1/ZqVPiY5BKVQXJTlZ8+fSrZJzE/v/76q+wiNnKmTZtm0rSncuXKwdfXF1FRUbqy9PR0nD171qDVTk+cOCEps8QeuYD83rd53Vcpt3jUkydP4OfnJ1mk5e7du5KY5e7/7dWrl+4DgO3bt8vuX2qI2NhYyfQ2YxPT3HuPVqtWzeitSvKSmJiIR48e4dGjRwgICJAdsQ8ICEBAQAAmTJiAzz//XHKtjRnJDQoKgpWVlSjZuXjxIpKSkmTfLI0dOxZjx46VlJtjKrqXlxeWL18OAKJENy0tDYMGDcL69esl23YUJGcSXZwFBQWZvD2Y3BT3nNt35ZZ9rXM6ePAg2rdvb1IcAFCvXj3s378fLVq0EE0pvX//Ptq2bYsTJ06gRo0aBrWpVCqxevVq3SwKR0dHzJ07F8OGDRPV++uvv7BhwwYMGDDA6PgHDhyI33//XbSFUHR0tGSldjKe3EJSOeW+NSf7XunNmzeLPohRKBRYuHChZHG2u3fvio7PnTun+2A8KCgIS5YsMSjeIUOGiJJcADh69GieSe6GDRsQEhIi+SDJ2dkZYWFheq0NMWnSJAwePBgrV67EyZMnkZCQgCpVqqB///7o168fZs6cKTmnsBd3JPPhdGWiMubBgwdm2atw1apVhXp/mtwbxd9//13v81NTU7F+/XpJuaXesOde6AKA7MIbAGSndGbfB5T7nKioKJw7d070kBspunLliu55c3yd9uzZIxrNVygURq+am3vBqddee82k2HJat24dHBwc4Orqitq1ayM4OFi0p68chUKBr7/+WjLKnnvbKn24urpKpp+npaXJ7k1bWH766SfRqCbwv9W6uQBQ3tq3bw8HBwdR2fHjx/PcfsTSnJyc8Oeff0r2Tn769Cn69+9v8M/5L7/8IlqFFgBef/112Q8Ox40bl+c9i/r66aefJLFv2rTJpDbpf+R2IciWmJgoGb3Mno6fe89YQRAkf2POnTsnWaQxOTlZ91xe+7wnJSXlOQVZ7oPgvG4H2LlzJ15//XXJ38Ny5cph3759Bi1++NJLL2Hq1KkICwvD0aNHsW7dOvTv3x8KhUL0ARKgvaUo9+9OKjmY5BKVMcuXL893s3h9xcXFSUbkLEluH89Vq1bpPa1zxowZkvt4a9asadK9bPmRG5m8dOmSbF25e97yug+vqBw7dkx0XLduXaPuZ3706JFkaxZjVmfOS61atURT8gBI7j/PS+4VM429n/Ttt9+WlE2fPt2gmRLm5ODggJUrV0pWuU1OTsaIESNEH17Q/zg4OEgW3gOADz74wGIL1hWkbt26sqNNly5dMnhUVG7bKIVCgQULFkh+FmJjY2Xv2TWEn58fPv/8c5PaKO1MmcERHh6e5/el3KwUuen4pnr69Cl69+6NRo0awd3dHS4uLqJZJDnJbdEl9zfl/PnzGDBggCQZ9/LywsGDBw36G/706VNcunQJ0dHRkuc0Gg0OHTokKmvcuHGxX1eA8sYkl6gMEQRBMqWuQoUKUKvVEAQh38eZM2ck7VliAaq8vPLKK5L97jIzM9G3b98C73lbsWIF5s2bJyn/7LPPjN6AviCVK1eWTHfcsWOHZMoXoN2fL6eqVaua9X6obO3atSvw65zXFM/cU5VbtGhhVAy52zGlLTkNGzZElSpVRGWnTp0qcJXY5cuXS7aMqV+/vlExDBgwQHK/emxsLHr27FngaFhiYiLeeOMNo/rNT7NmzWRXwj5+/Dh+/vlns/dXWnz66aeS+wn37duH9957r8APB27dumWR1aUnTJggO5X6u+++y/ODNEMEBQXJLji4cuVKyR7Zhvr00085MpaP3B8u5E7s8hMZGZnnjBG5faENudVHX+7u7ti/fz8uXryoG5VdtWqV7M+K3P67uW/FefbsGV577TXJKsru7u44cOCA3r+jGzVqBDs7O3h5eaFhw4ayHxRt3rxZslZJ7r2zqWRhkktUhoSHh0s+Pe3bt69ee741adIENWvWFJUdPHjQ6EVVjLFw4ULJG8779++jadOm+PbbbyWLGV29ehXDhw/HqFGjJH9k27Rpk+e+eOaS+z7k9PR09OjRQze1SxAE/N///Z9kQaec974VlJQKgoDw8HBJ31FRUbrnTd1jVa1WSxbtMjYBzL1wj7u7u1kTeqVSiTFjxkjK33nnHUyZMkXyJiY+Ph6zZs2SXcxLbvaAPqytrbF48WLJBygnT55E/fr1sXTpUsmsgn/++QdfffUVfH19Ze/tNIcZM2bI3rc5ZcoUPHz40CJ9lnR+fn744osvJOW//PILmjdvjl27donuhdRoNDh+/DjefvttBAQE4OTJk2aPSaVSYdmyZZJF97KysjB69GizjMx/8803snsCjxkzRrKqrSFsbGz4oUo+ck/nvnPnDpKTkwHIz/jJ7e233xYllSkpKRg/fjy2bdsmqlelShXdLUAjR47U6+9M7i0Gg4ODJR+OKpVKyYJ2J06cwOjRo3VrR2g0Gvz666/46aefRPWcnZ0lt658+OGHsqOuq1evRr169Qq8HtkqVaokms6/YsUK0Qc2hw8flvzdcHR0lEznpxJGIKIyIyQkRAAgehw4cEDv87/44gvJ+R9//LGozrRp0yR1li9fbrbX8Pvvv0vaz34olUqhWrVqQmBgoFC+fPk861WuXFl4+PCh2WLKS2ZmptCwYUPZOP39/QU3NzfJcy4uLkJMTIxB/YSHh0vaiYqKMtvriIyMlLS/d+9eo9oaPny4qJ1WrVqZLc5sqampQo0aNWS/9gqFQvD19RUaNmwo+Pr6CkqlUrZe3bp1hfT0dFG7UVFRknrBwcF5xrFo0aI8vwetrKwEHx8fITAwUPDy8sqzXn7XacSIEZJ64eHh+V6b8PBwQaFQSM4bNGiQWdrXx/LlyyXtVqxYUQgKCtL7ERoaqmvP0K+LoTQajTBo0KA8vzYODg5CrVq1BH9/f8HZ2bnAr+WUKVMkfVSrVk1SryDTp0+XbX/x4sWSusHBwQb/jvj+++9l2x8/frykbu7vlWrVquXb9uuvv57n9ZH7e6FP/Pr+7cldx8bGxqDvvZCQkHxfmynkXme5cuUEX19fwdXVVVdP7ns+58PT01MIDAwUHB0dZZ//6aefDI4t99c4r5+xmzdvCnZ2drLX2d/fX/D09JSN6dtvvxW1c/XqVdnfVba2tgV+jXr27Clqa/PmzbJ9VqtWTfDz85N97scffzTo+sj9XjPH70syHpNcojLi2bNnkj88Xl5eQlZWlt5tXLt2TfJL3MvLS5QMWDrJFQRBWLduneDg4FDgm0m5R1BQkPDvv/+aNZ78XLt2Ld+EO+dDqVQKW7ZsMbgPSye5cu3fvHnTqLZyv4kbMmSI2eLM6Z9//hEqVqxo1PdIlSpVhPv370vaNCaZWrVqVZ5vNPV5WFlZCR988IGQlJQkadvYJHTMmDGyfe3evdss7RdE7s2goY8ffvhB156lk1xBEISsrCxh/Pjxsm+69X2UK1dO+Pnnn2XbNybJzcjIEAIDAyXnubm5CbGxsaK6xiS5GRkZQp06dWR/T504cUJU19AkNzY2VvZDPqDwk1xDHw0aNMj3tZni888/z7fvxMREQRDkv+cbN26c54d2OR89e/YUNBqNwbHpm+QKgiCsWLHCoJ+VoUOHSmIaO3as0V8jue+/Dh06GBSPWq026PowyS1+OF2ZqIxYs2aNZJXDPn36GHRPat26dSXTVJ88eYItW7aYJUZ9DRo0CGfOnEHfvn31XqijXLlymDFjBo4cOSK5Z9OS6tati0OHDqFhw4b51nN3d8e2bdvQu3fvQonLEAkJCZIyYxfGyt2WpRbYqlmzJs6dO2fw9RwyZAhOnjyZ557Nhho2bBiuXLmCwYMHG/Sz5u7ujg8//BC3bt3C/PnzZfdXNta8efNkfwbef//9PFdCLetUKhV+/PFHhIeHG3wvY82aNTFv3jzcu3fPrHtcW1tbY9myZZLvq+fPn+Ojjz4yS/s//PCDpFyj0eDNN98scMua/JQvXx7ffPONKeGVSu+99x7Kly+f5/NyU3ez9ezZE6tXr5asCJ5TSEgINm7caJYtyvIzYsQIbNy4Ee7u7vnWs7a2xldffYVVq1ZJYso9xdpUmzZtQtu2bfOtY2Njgy+++AIrV67U6zYuKt74FSQqI+T2xs3eH9EQcveoFOYCVNnq1q2LTZs24fr165g3bx66du0KPz8/uLq6wtraGuXLl0dAQACGDx+O1atX4+7du5g6dSrs7e0LPdY6derg7NmzWLlyJbp164ZKlSrB2toaHh4eaNmyJWbPno3IyEh079690GPTh9w9ePm9kTKkLWPb0UfFihWxZcsW3LhxA19++SU6d+6MqlWrwsnJCUqlEvb29qhatSo6dOiAKVOm4OLFiwgNDTX7ol++vr5Yu3YtoqKiMH/+fPTp0we1atWCi4sLVCoV7OzsULVqVbRv3x6ffPIJ9uzZg0ePHuGHH34w+X5qOS4uLvjll18k5bdv38bs2bPN3l9pEhwcjGPHjuH8+fOYNm2a7nvK0dERSqUSjo6OqFGjBnr06IFZs2bptvj65JNPZPdJNlXTpk1lFxT7448/ZO/VN1TXrl3Ro0cPSfn169cxa9Ysk9oeM2aM7AJaZVnlypVx5swZjB49Gi+99JLu70TDhg3xySefwNPTM9/zQ0JCcPHiRbz55puoWrUqbGxsULFiRfTt2xe7d+/GmjVrJPdyW0rfvn0RGRmJ77//Hu3bt4eXlxesra1Rrlw5BAUF4bPPPsOtW7fw5ZdfShLcuLi4fLdEMoabmxvCw8MRGhqKbt26wdvbG9bW1nB3d0ejRo0wefJkXLt2DTNnzmSCW0ooBKGI1sEnIiIiIiKD3L17F76+vqKyadOmGbyNFFFpxo8qiIiIiIiIqNRgkktERERERESlBpNcIiIiIiIiKjWY5BIRAVAoFGZ7EBFR6bVixQqz/b0YOXJkUb8colKJC09RsZRfolBYKwNS2WLKdhi58XuUiKj0UqvVUKvVZmlLqVTCysrKoHMEQUBmZqbJ7RCVJPm9T5NLZ5nkUrHE0TAiIiIiIiqIXDrL6cpERERERERUajDJJSIiIiIiolKDSS4RERERERGVGkxyiYiIiIiIqNTgMmxU4nDlWiIiIiKissPQXTCY5FKxZGNjI/vNbGNjg/T09CKIiIiIiIiIioKtrW2euYEcTlcmIiIiIiKiUoNJLhEREREREZUaTHKJiIiIiIio1GCSS0RERERERKUGk1wiIiIiIiIqNZjkEhERERERUanBJJeIiIiIiIhKDSa5REREREREVGpYFXUARERERCWWIABJSUBGBmBjAzg7AwpFUUdFRFSmMcklIiIiMsTVq0BoKHDqFHD2LJCY+L/nXFyAJk2AZs2AkBCgXr2ii5OIqIxSCIIgFHUQRLnZ2toiIyNDUm5jY4P09PQiiIiIiMq8sDBg9mzg2DHAygpQq7UjubkpFIBKBWRlAa1aAZ9/DnTrVvjxUokgCAIyMzOh0WiKOhQii1AqlbC2tobChFkuhuYGTHKpWGKSS0RExUZcHDBuHLB2LaBUAoYkI9n1Q0KAhQsBd3fLxUklSkpKChISEpCUlAS1Wl3U4RBZlEqlgrOzM1xdXeHg4GDw+UxyqVRgkktERMXC5ctAp07aRNeURESlAjw8gH37gMBA88VHJVJSUhKio6NhbW0NFxcXODo6QqlUmjTSRVQcCYIAjUaDFy9eIDExEZmZmahSpQqcnZ0NaodJLpUKTHKJiKjIXb4MtGkDvHhhWoKbTaUCHB2Bo0eZ6JZhKSkpuHfvHlxcXFCpUiUmtlRmCIKAmJgYJCYmolq1agaN6BqaG3ALISIiIqLc4uK0I7jmSnABbTsvXgAdOwLx8eZpk0qchIQEWFtbM8GlMkehUKBSpUqwtrZGQkKCRftikktERESU27hxpk9RlqNW/+8eXypzBEFAUlISXFxcmOBSmaRQKODi4oKkpCRYckIxk1wiIiKinMLCtItMWWoxILVauwXRzp2WaZ+KrczMTKjVajg6OhZ1KERFxsHBAWq1GpmZmRbrg0kuERERUU6zZ2tXRbYklUrbD5Up2dsEKS39/UVUjKlUKgCw6LZZ/AkjIiIiynb1qnYfXEvvWapWaxegunbNsv1QscSpylSWFcb3P5NcIiIiomyhoYCVVeH0ZWWl7Y+IiMyKSS4RERFRtlOngKyswulLrdb2R0REZsUkl4iIiAgABAE4e7Zw+ztzRvsvERGZDZNcIiIiIgBISgISEwu3z8REIDm5cPskIirlmOQSERERAUBGRtnql4hKnRUrVkChUEChUODgwYNmb3/69Om69vft22f29s2FSS4RERERANjYlK1+iYhKqUJaPpCIiIiomHN2BlxcCnfKsosL4ORUeP0R6UOtBo4cAR4+BCpWBNq00e7tTFRCcCSXiIiICAAUCqBJk8Ltr2lT7b9ExcXmzYCPD9C+PRASov3Xx0dbTlRCMMklIiIiytasWeHtk6tSafsjKi42bwb69weio8XlDx5oy5noUgnBJJeIiIgoW0hI4e2Tm5Wl7Y+oOFCrgfHj5be0yi778ENtPaJijkkuERERUbZ69YBWrQClhd8iqVRA69ZAQIBl+yHS15Ej0hHcnAQB+Pdfbb1SJHul4Dlz5gAAtmzZgi5dusDb2xsODg6oWbMmPvroI8TGxurOuXv3LsaNGwc/Pz/Y2dnBw8MD3bp1Q3h4eIH9HTp0CMOHD4efnx/s7e3h7OyMOnXq4J133sHFixcLPD8jIwOrVq1C+/btUalSJTg4OKBu3br48ssvkZSUpPfrvnTpEt555x3Url0bTk5OcHR0RK1atfD222/j/PnzerdTbAlExZCNjY0AQPKwsbEp6tCIiKi027FDELRv6S37CAsr6ldKhSw1NVW4fv26kJqaWtShSIWG6vd9Gxpa1JGaVfZ7zK+//loICQmRff8JQKhWrZrw4MEDYefOnYKLi4tsHYVCIaxYsUK2n4SEBKFfv355tp99/tixY4XMzEzZNmJiYoTGjRvneb6Pj48wbdo03XF4eLikDbVaLXz00UeCQqHIN5YPPvhANo6c7e/du9eoa27Mz4GhuQFHcomIiIhy6t4dGDLEcqvJqlTaacrdulmmfSJjVKxo3nolzPz58xEaGoqAgAAsXboUx44dQ2hoKGrVqgUAuHfvHoYOHYr+/fsD0O4Xe/jwYRw8eBDvv/8+FAoFBEHA+PHjJSOq6enp6NWrFzZt2gQAqF69OhYsWICjR4/i0KFD+Oabb+Dl5QVBELBo0SKMHDlSEl96ejrat2+vG2Xt0KED1q9fj5MnT2LdunVo27Yt7t69i5kzZ+b7Ot999118//33EAQBgYGB+Pnnn3Hs2DEcO3YMP//8MwL+m12yYMECvP/++yZd0yJlVPpNZGEcySUioiL19KkglC8vCCqVeUdvVSptu3FxRf0KqQgU65HcrCxBqFIl/+/fqlW19UqRnO8zmzdvLrx48UL0/P379wUrKytdHWdnZ+Hq1auSdiZOnKir89dff4memzt3ru65jh07SvoQBEF49OiRUK9ePV29tWvXip6fOXOm7rkxY8ZIztdoNMLbb78tej25R3K3b9+ue2748OGyI7UZGRlC37598xyt5UguERERUUnl4QHs2wc4OppvRFel0ra3bx/g7m6eNonMRaUC5s/Pv86PP5bq/XK//fZbODg4iMqqVq2K5s2b647HjRunG+3MqXfv3rr/3759W/d/jUaD7777DgDg4uKCtWvXSvoAAG9vb/z5559Q/rceQPY9wgAgCAJ++eUXAEDlypUxX+brpFAosHDhQvj4+OT5+ubOnQsAKF++PH755RdYyawkb21tjV9//VUX4w8//JBne8UZk1wiIiIiOYGBwNGj2oTX1Df2KpW2naNHte0SFUd9++a9hZaVlfb5UsrJyQktWrSQfa5KlSq6/3fs2FG2Tvny5XX/zzld+ezZs3jy5AkAYODAgfD09Mwzhrp166J9+/YAtAtDxcTEAADOnz+PBw8eAAAGDBgAW1tb2fNtbW0xfPhw2eeeP3+O48ePAwBat24Ne3v7POPw8PBAs/+2Nzt06BCyCmvFeTNikktERESUl8BAICICGDTItHYGD9a2wwSXiru8Vha39IrjRaxq1apQ5fFhVs6ksmIe9yTnrCPk2Ibp6tWruv/nlUTn1LJlS8m5169f15U1atQo3/Nffvll2fILFy5Ao9EAADZv3qxbVTqvR/ZK0S9evBCtLF1SlO7vViIiIiJTubsDa9YA+Yx85EmpBMLCgD/+4BRlomLMxcVFr3pyU3zz8/TpU93/vb29C6yfs05cXBwAiJLM/EaCAaBChQoFxmGo+Ph4o88tKoZ9lYiIiIjKKgPf3ALQ3oPLVZSJij1Dk1d9ZY+eGlNfacTouY2NjWx5zinH48ePl13BOS81atQwOI6ixiSXiIiIiIjIAjw8PHT/12fa76NHjyTnVqpUSVf2+PHjfM/Pa9TVPcdMkszMTDRs2LDAWEoyTlcmIiIiIiKygPr16+v+f+LEiQLr56xTp04dABCt5nzq1Kl8z79w4YJseWCO9QAOHDhQYBw///wzfvrpJ4SFhXHhKSIiIiIiItIKCgqCl5cXAGD9+vW6+2zlXL9+HQcPHgQA+Pv761Z1btCgAWrVqqVrIyEhQfZ8QRCwevVq2ecqVaqkS3Rv3LiBv//+O884IiIiMHbsWIwdOxYffPCBxaZyWxKTXCIiIiIiIguwsrLC+PHjAQCJiYkICQlBamqqpN6TJ08wZMgQ3crMn376qej5CRMmANBORx45ciQyMzMlbcyYMQPnz5/PM5aPP/5Y9/8333wTt27dktRJTk7G0KFDdXF8+OGHBbzC4qnkpeVERERERKWZszOQkVE0fefVb0YGkMf+rBZnYwPk2Hu2pJk0aRJ27tyJ48ePY8+ePahfvz7Gjx+Pxo0bQ61W4/jx4/jhhx909+wOHjwYI0aMELUxZswYbNiwAQcOHMDWrVvx8ssvY8KECahTpw4ePnyIZcuWYfv27XB0dMSLFy9k4xg+fDi2bt2KLVu2ICYmBkFBQRg3bhw6duwIa2trXL58Gd9//z0iIyMBaLczevfddy17cSyESS4RERERUXGSkVF0SW5+imNMJYC1tTV27dqFoUOHYvv27bh9+zbGjRsnqadQKPDxxx9j1qxZss9t27YNISEh2LZtGy5evChJhL28vPDdd99JynNau3Yt3n33XSxfvhxJSUn45ptv8M0330jqdejQAZs2bSqRU5UBTlcmIiIiIiKyKBcXF2zbtg179+7F66+/Dh8fH9jZ2cHV1RX169fHhAkTcOXKFcybNw/W1taybTg6OmLr1q3YsWMHunfvjqpVq8LW1ha+vr4YN24cLl++jLp16+Ybh62tLX7//XecOnUKb7/9NmrXrg0nJydYW1ujUqVKeO2117Bx40bs27cPbm5uFrgShUMhZE+4JipGbG1tkSHzaaGNjQ3S09OLICIiIirzXFwMnzLp7AwkJlomHipx0tLSEBUVBV9fX9jZ2eVd0daWo6Y52dgAfP9Xauj9c5CDobkBR3KJiIiIiIio1GCSS0RERERERKVGybyTmIiIiIiotLKxKeoIihdeDzIQk9x8REREYNWqVTh69Chu3bqFZ8+eQaVSwdvbG4GBgXj11VcREhICV1fXIonv/v372LRpE44dO4YrV64gLi4OCQkJcHZ2hqenJ2rXro127dqhV69eqFmzplF9HDx4EIsWLTI51hEjRqBnz54mt0NERERU6pXg7XKIigMuPCUjNjYWY8eOxcaNGwus6+zsjC+//BITJ06EUlk4s7/v3buHSZMmYdOmTVCr1QXWVyqV6N+/P2bPno3q1asb1Nenn36KefPmGRuqzrfffivagLogXHiKiIiKHS48RSYyZsEdotKGC08VgcuXL6NBgwZ6JbgAkJSUhE8++QQ9e/ZEamqqhaMDNm/ejAYNGmD9+vV6JbgAoNFosH79egQFBWH79u0G9XfhwgVjwiQiIiIiIioSTHJziIyMRPv27REbGyt5rl69eujWrRtatWolu2fUzp07MXDgQFhyYHz79u0YNGgQEhISJM95eXkhODgYvXr1QnBwMNzd3SV1nj9/jj59+mDXrl1693np0iWTYiYiIiIiIipMTHL/k5WVhf79+yM+Pl5U3rt3b9y6dQtXrlxBWFgYjh49iocPH2Lp0qWSe3F37NiB+fPnWyS++/fvY/DgwcjKyhKVt2/fHkeOHEFsbCwOHjyIv/76CwcPHsSTJ0+wd+9eNGnSRFRfrVZj0KBBiIqKKrDPmJgYPH78WFQWHR0NQRAMfhgyVZmIiIiIiMhYTHL/s3jxYsnU3AkTJmDLli2oUaOGqNzOzg5vvvkmzp07h4oVK4qemzlzpuxIq6kmTZqElJQUUdlHH32E/fv3o3Xr1lAoFKLnlEolOnbsiOPHj2Po0KGi55KSkjB58uQC+8x9Pby8vFC5cmUjXwEREREREZHlMckFkJ6ejpkzZ4rK2rZti++//z7f8/z8/LBjxw5YW1vryuLj4ws8z1DR0dFYv369qKxnz5749ttvJcltbtbW1li+fDmaNWsmKv/zzz9x//79fM+9ePGi6LhRo0b6B01ERERERFQEmOQC2LRpE548eSIqmzNnToEJJAA0btwY77zzjqhsyZIl0Gg0Zotvw4YNont9FQoF5s6dq1d8AGBlZYU5c+ZIynfs2JHveblHcpnkEhERERFRccckF8C6detEx/Xq1UOLFi30Pv+9994THT9+/BiHDx82S2wAcODAAdFxYGAg/P39DWqjbdu2ksWoClo5mSO5RERERERU0pT5JDczMxPh4eGisp49exrURp06dST37W7atMnk2LJdv35ddPzyyy8b3IZSqYSPj4+o7NGjR3nWT0pKQmRkpKiMSS4RERERERV3VkUdQFG7ePEikpOTRWWtW7c2uJ2WLVvi9u3buuODBw+aGprO8OHDER0djZiYGMTExMDPz8+odtLS0vSue/HiRdEUaScnJ0kiT0RERGQUQQCSkoCMDMDGBnB2BvS8DYuIqCBlPsm9du2apKxBgwYGtxMYGCg6vn79OlJTU2Fvb290bNmmTZtmchupqamSkdlKlSrlWT/3VOYGDRpAqSzzA/9ERERkrKtXgdBQ4NQp4OxZIDHxf8+5uABNmgDNmgEhIUC9ekUXJxGVeGU+a4mIiBAdOzg4GLVNTu5RTo1Go9detIVl165dkpHcevn8Acnrfty4uDgsXLgQffr0gY+PDxwdHXWjvN26dcOiRYvw4MEDs8dPREREJVRYGNC6NRAYCHz7LRAeLk5wAe1xeLj2+cBAbf2dO4smXiIq8cp8khsTEyM6NnYf2Nz75QLAvXv3jGrLEubNmycp69WrV571cye5L730EsaNG4fKlSvjgw8+wNatW3Hv3j2kpKTgxYsXuHPnDnbt2oVx48ahRo0amDRpkkX2CyYiIqISIi5OOyrbowdw4oS2LCtLO1VZjiBonwe09bt3B15/HYiPL5x4iajUKPNJbu7Fl7y9vY1qx8vLS1L29OlTo9oyt+XLl+PUqVOislatWqFatWqy9TMzMyXTuCdPnoxFixYhPT29wP7S0tLw7bffolmzZqL7lImIiKiMuHwZqFsXWL9ee2zo1orZ9f/8E/D3B65cMW98RFSqlfkkNz7Xp4MuLi5GtePs7Cwpe/bsmVFtmdM///yDiRMnSsqnT5+e5znXr19HRkaGqEytVuv+b21tDX9/f3Tt2hUdO3ZEnTp1ZNu5efMmmjVrhps3bxoXPBEREZU8ly8DbdpoR3JzvH8wilqtbad1aya6RKS3Mp/k5h6ZdHBwMKodufMMWc3YEuLj49GzZ088f/5cVD5kyBB07Ngxz/Py2j/Xw8MD8+bNQ0xMDK5fv45du3Zh7969iIiIwIMHD/D5559LrkN8fDx69+6NxNz33uQhPT1d77pERERUzMTFAZ06AS9emJ7gZlOrte117Mipy0SkFya5uZJcKyvjFpxWqVSSsszMTKPaMoeEhAR07twZ//zzj6jc19cXP//8c77n5r4fFwCaN2+OCxcu4JNPPoGnp6fk+UqVKmHWrFk4ceIEqlSpInruxo0b+Y4c5zR79my4urpKRpKJiIioBBg3zjwjuLllj+iOG2fedomoVCrzSa461y9huWRVH3LnaQy9/8RMnj17hi5duuDcuXOichcXF2zbtg1ubm75nu/s7IyAgADdqGzNmjWxa9cuVK1atcC+69evj7CwMMnWSYsXL5Ys8iVn8uTJSEhIgI2NTYF1iYiIqBgJCwPWrjV/gptNrdZuQcRVl4moAGU+ybW2thYdZ2Wv6mcguVFbW1tbo9oyRUxMDNq2bStZaMre3h7bt2/Pd9ugbDNnzsTVq1fx4sULPHz4EMePHy8wMc6pfv36mDRpkqgsLS0NoaGhBZ5ra2tr9H3RREREVIRmzwaUFn5rqVJp+yGLUqvVOHjwINauXYuDBw9KBoWIirsyn+TmTkSNnSZbHJLcGzduoFWrVrh69aqo3MHBATt27EDbtm0NbrNChQqy05MLMm7cOMnU7z179hjcDhEREZUAV68Cx44ZvoqyodRq4OhRINcuEGQ+mzdvho+PD9q3b4+QkBC0b98ePj4+2Lx5c1GHRqS3Mp/kurq6io6Tk5ONaicpKUlS5ujoaFRbxti/fz9atGiBu3fvispdXV3x999/o0OHDoUWC6BdpKpx48aistOnTxdqDERERFRIQkMBI9c1MZiVlbY/MrvNmzejf//+iI6OFpU/ePAA/fv3Z6JLJUaZT3I9PDxEx7lXItaX3HnG7rlrqKVLl6Jr166SGCpUqIBDhw6hTZs2hRJHbvXr1xcdJyQk6LXPLhEREZUwp04BRt7yZTC1WtsfmZVarcb48eMhCILkueyyDz/8kFOXqUQo80lupUqVRMexsbFGtSN3nqWTXI1Gg48//hhvv/225F7iOnXq4MSJE2jQoIFFY8hP7g8QACAuLq4IIiEiIiKLEQTg7NnC7e/MGe2/ZDZHjhyRjODmJAgC/v33Xxw5cqQQoyo86enp+Pnnn9GxY0d4e3vDxsYG5cuXR4cOHbBw4UKkpqaK6j9+/Bje3t5QKBRQKBRYv369bLuJiYnw9fWFQqGAUqnE7t27dc+1a9cOCoUCrVu3BgCcPHkSffv2RYUKFWBjY4OqVati6NChOFuYP1+lRJlPcv38/ETHMTExRi0+de/ePUlZ9erVjY6rIGlpaejXrx++//57yXPBwcE4fvw4fHx8LNa/PuQ+6SvMKdxERERUCJKSgMLe4z4xETDyFjOS9/DhQ7PWK0kuXboEf39/vP/++9i/fz8eP36MzMxMPHnyBOHh4fjggw/g7+8v2rmkfPnyWLp0qe543LhxsoM5Y8eO1d1OOHHiRHTp0kU2hmXLlqFNmzbYsmULYmNjkZmZiejoaKxZswYvv/wyfvzxR7O+5tKuzCe5AQEBouOsrCxERkYa3M7NmzdFx+XLlzdqwSZ9JCQkoFOnTti6davkuWHDhmHPnj0oV66cWfoydrVpQDpqa2VlJbkHmoiIiEq4otrbvqj6LaUqVqxo1nolxc2bN9G2bVtERUXBxsYG7777Lnbs2IHTp09jx44dGDNmDGxsbHDv3j106NABN27c0J3bs2dPvP322wC0I7sffvihqO0NGzZg9erVAIAmTZpgdh4rg9+8eRPvvPMONBoN3nnnHezbtw9HjhzBl19+CUdHRwiCgAkTJoiSaiqAUMY9efJEACB6rFmzxuB2OnToIGqja9euFohWEJ49eya8/PLLkpgBCDNmzDC5/TVr1ght2rQRateuLZQrV05QKBTCtWvXjGorKChIFF9AQIDe59rY2Mi+RhsbG6NiISIiMpmzsyBoJ8nq/3B2LuqoLS8hwfDrYo5HYmJRv3KDpaamCtevXxdSU1OLOhSJrKwsoUqVKrLvv7IfVatWFbKysoo6VLNq0qSJAEBwdXUVTp8+LVvn2LFjgq2trQBAaNWqlei55ORkwc/PT3eNwsLCBEEQhOjoaKFcuXICAMHJyUm4deuWpN3g4GDdeSqVSti6daukzvnz5wVnZ2cBgODu7i7ExcWZ4VUXLWN+DgzNDcr8SK6np6dk79j9+/cb1EZKSgqOHz8uKuvYsaPJseWWmpqKHj16SFYptra2xsqVKzF16lST+9BoNDhy5Ahu3ryJZ8+eQRAEyWvTR3x8PC5evCgqK6oFsIiIiMiCnJ2Bwt7j3sUFcHIq3D5LOZVKhfnz5+db58cff4RKpSqkiCxv//79uvtdp06diqZNm8rWa9mypW6U9tixYzhz5ozuOUdHR/zxxx+66/L+++/jxYsXGDVqFJ49ewYA+Pnnn1GjRo18Yxk3bhxee+01SXmjRo3w1VdfAdC+v163bp1hL7KMKvNJLgB0795ddLx161akpaXpff6WLVsk9bt162aW2HIaOXIkjh07JipzcHDAtm3bMHz4cLP0ERQUJCkz5odp8eLFkntye/bsaXRcREREVEwpFECTJoXbX9Om2n/JrPr27QurPLaCsrKyQt++fQs5IsvasWOH7v+dO3fOt27O9/a5B8SaN2+OyZMnAwDu3r2LNm3aYO/evQC0txIOGzaswFjGjh2b53MjR46EUqlN27Zt21ZgW8QkFwAkCWJ8fDwWL16s17lZWVmS+fWtWrWCv7+/2eIDgAULFkhWbbOzs8POnTvRtWtXs/Xj7++PwMBAUdn+/ftx8uRJvdu4f/8+vvvuO1FZjRo18Oqrr5olRiIiIipmmjUrvH1yVSptf2QR2cmUvuUl2fnz53X/r1+/vm6lZLlHcHCwru6dO3ckbU2bNg1N/vuw58KFCwC0739//vnnAuOoUKGCZDHcnMqVK6db0Pb69ev6vbgyrvR9txqhbt26kunFn3/+OU6cOFHguePGjcO1a9dEZRMnTjRrfFFRUfjss88k5StWrBD9wJnL6NGjJWVvvPGGXnsIJyQkYMCAAZK6X375JRT8xJWIiKh0CgkpvH1ys7K0/RGZ6OnTp0adFx8fLymzsrKSLAz1zTffwEmPafW5tzSV4+XlBcD47U7LGia5/5k9e7boE6q0tDT06NEDf//9t2z9jIwMjBs3Dr/88ouovGXLlgVO5cjeEyvn4+DBg3nWnzx5smRvrjFjxmDQoEEFvCrjvPPOO5JVpyMiItC+fXvcvn07z/OuXLmCtm3bSu4Z7tatm17TNIiIiKiEqlcPaNUKsPRon0oFtG4N5HqfQmSM7F1EbG1tceHCBb0fuWcsZlu1apXoePbs2cjMzCwwjrymiOeUfRugtbV1gXUJKKR5JcVfkyZNMGnSJMyZM0dXFh8fj27duqFHjx4YMmQI/Pz88OLFC5w7dw5LliyRJHwuLi5YuXKlWeOKiorChg0bJOVLlizBkiVLTGo7ODhYNrm2srLCypUr0a5dOyTn2IPu4sWLqFu3LkJCQtC9e3f4+voiIyMDkZGR2L59OzZv3izZcsjHxwe///67SXESERFRCTB5MtCjh2X7UKu1/RCZgbu7OwAgPT0dlStX1o2WGiM8PBw//PADAMDNzQ3Pnz/HhQsXMG3aNHzzzTf5nis3Mpzb48ePAeg36ktMckVmzZqFR48eYcWKFboyQRCwfft2bN++Pd9z7ezssH79+gJXTjPUunXroNFozNqmPoKCgrB582b07t0bKSkpuvLMzEysXLlSr2Te19cXe/bsgbe3tyVDJSIiouKge3dgyBBg/XptMmpuKhUwaBBggcU9qWwKDAzUrTtz4MCBfGdJRkREYPPmzfDx8cHLL7+MmjVr6p57/vw5RowYAUEQYG9vj+PHj2PQoEG4cuUK5s2bh+7du6NVq1Z5th0ZGYmEhAS4urrKPv/kyRPcvXsXANCwYUPDX2gZxOnKOSiVSixbtgyffvqpXtMGslWpUgW7d+9Gly5dzB7ToUOHzN6mvjp16oQzZ85IFqLSR+/evXH69GmzJ/1ERERUjC1cCHh4aBNSc1KptO0uXGjedqlMy7l46/z58yEIQp51v/rqK3zxxRcYOnSoZEHW999/H//++y8A4Ouvv4a/vz+WLVsGlUoFtVqN4cOHi2ZH5qbRaLBmzZo8n1+2bJnu//369SvwdRGTXAmlUok5c+bg/Pnz6N+/PxwcHPKs6+3tjalTp+Lq1ato27atReKJjo62SLv6qlu3Li5cuIDQ0FA0a9Ys35X1rK2t0bNnT+zfvx9btmyBp6dnIUZKRERERc7DA9i3D3B0NF+iq1Jp29u3D/hveimRObz22mu6EdkTJ07ILvQKAGvWrNHtclKpUiUMGDBA99yff/6J0NBQAECLFi10++k2bdpUtxhtZGSkrjwvX3zxhWQxWwA4deoUZs6cCUC7WrPcXrokpRDy+8iCkJqaiqNHjyI6OhqxsbGwsrKCp6cnGjVqhMDAwFK5nHp+nj17hhMnTuDBgweIi4uDRqOBu7s7atWqhZdfflmvFeT0YWtri4yMDEm5jY0N0tPTzdIHERGRQVxcgKQkw85xdgYSEy0TT3F25QrQsSMQF2fa1OXsEdx9+wAjZpYVN2lpaYiKioKvry/s7OzyrOfs7Cz7Pqgw5NevjY1NIUYi7jfJ0J89PZ0+fRpt27bVvb9s27YtRo8ejRo1aiA2NhZbtmzB6tWroVaroVAosH37dnTv3h0A8ODBAwQGBuLZs2ewtbXFxYsXUadOHV3bqampaNCgAW7dugUA+Ouvv9CrVy/d8+3atRPN2nR2dsZHH32EV155BWq1Grt27cL8+fORlpYGlUqFPXv2oEOHDha5DoVJ35+DnAzNDZjkUrHEJJeIiIodJrmGiY8Hxo0D/hvlMsrrrwMLFpSaEVx939zn9T6orLL0+78jR45g4MCBePToUZ51HB0d8euvvyLkv+2rBEFAly5dsHfvXgDalZTlRoKPHDmC4OBgCIKA8uXL48qVKyhfvjwAcZI7ZcoUzJo1S7ZvFxcXrF+/3iK3RhaFwkhyy9YwJBEREREVDnd3YM0awN7e8HOVSiAsDPjjj1KT4FLx1aZNG9y+fRs//vgjOnToAG9vb1hbW8PZ2RmNGjXCZ599hoiICF2CCwALFizQJbhBQUH45JNP8mz7vffeA6BdIfmtt96SrTd9+nTs3bsXXbt2Rbly5eDs7IyGDRti+vTpuHXrVqlJcAsLR3KpWOJILhERFTscyTUOr5sOR3KNU1rf/+Ucyc3MzDRo4duSjCO5RERERERERAZgkktERERERESlRtkYEyciIiIiKiGKahXj4orXgwzFJJeIiIiIqBix1HY5RGUFpysTERERERFRqcGRXCIiIiIiokJ28ODBog6h1OJILhEREREREZUaTHKJiIiIiIio1GCSS0RERERERKUGk1wiIiIiIiIqNZjkEhERERERUanBJJeIiIiIqBAJglDUIRAVmcL4/meSS0RERERUCJRK7VtvjUZTxJEQFR21Wg3gfz8PlsAkl4iIiIioEFhbW0OlUuHFixdFHQpRkUlJSYFKpYK1tbXF+mCSS0RERERUCBQKBZydnZGYmMgpy1QmCYKAxMREODs7Q6FQWKwfJrlERERERIXE1dUVmZmZiImJYaJLZYogCIiJiUFmZiZcXV0t2peVRVsnIiIiIiIdBwcHVKlSBdHR0UhNTYWLiwscHBygUqksOrJFVBQEQYBarUZKSgoSExORmZmJKlWqwMHBwaL9MsklIiIiMpIAIA5AMgAnAB4AmKZQQZydnVGtWjUkJCTg+fPniIuLK+qQiCxKpVLB2dkZrq6uFk9wASa5RERERAZ7DmAlgIUA7uQo9wMwDsAIAG6FHhWVJA4ODnBwcECFChWQmZnJFZep1FIqlbC2ti7UmQpMcomIiIgMsBtAPwApMs9FApgAYAqATQC6FGJcVDIpFArY2NgUdRhEpQoXniIiIiLS024A3QGkQjtVOfeyQdllqf/V252VVajxERERk1wiIiIivTwXBPSDNoktaGKp5r96/VJT8fz5c0uHRkREOTDJJSIiItLDysxMpKDgBDebBtopzatWrbJcUEREJMEkl4iIiKgAgiBgYUaGUecuWLCA+6ESERUiJrlEREREBYiLi8MdQZDcg1sQAcCdO3cQHx9vibCIiEgGk1wiIiKiAiQnJ5t0flJSkpkiISKigjDJJSIiIiqAk5OTSec7OzubKRIiIioIk1wiIiKiAnh4eMBPoYDCwPMUAPz8/ODu7m6JsIiISAaTXCIiIqICKBQKjLOxMercDz74AAqFoekxEREZi0kuERERkR5GWFvDAfq/eVICcAAwfPhwywVFREQSTHKJiIiI9OCmUGATtFOQC3oDpfyv3mZ7e7i5uVk6NCIiyoFJLhEREZGeugAIA2BfQD17ADsBdLaysnhMREQkxt+8RERERAboAiAagCcAtczzKgAPALgWZlBERKTDkVwiIiIiA7lBm8zKUYEJLhFRUWKSS0RERERERKUGk1wiIiIiIiIqNZjkEhERERERUanBJJeIiIiIiIhKDSa5REREREREVGowySUiIiIiIqJSg0kuERERERERlRpMcomIiIiIiKjUYJJLREREREREpQaTXCIiIiIiIio1mOQSERERERFRqcEkl4iIiIiIiEoNq6IOgIiIiIjKFgFAHIBkAE4APAAoijQiIipNOJJLRERERIXiOYD5AGoC8ALg+9+/Nf8rf15UgRFRqcIkl4iIiIgsbjeAKgAmAIjM9Vzkf+VV/qtHRGQKJrlEREREZFG7AXQHkArtVGUh1/PZZan/1dudlVWo8RFR6cIkl4iIiIgs5rkgoB+0SaymgLqa/+r1S03F8+fPLR0aEZVSTHKJiIiIyGJWZmYiBQUnuNk0AFIArFq1ynJBEVGpxiSXiIiIiCxCEAQszMgw6twFCxZAEHJPbCYiKhiTXCIiIiKyiLi4ONwRBMk9uAURANy5cwfx8fGWCIuISjkmuURERERkEcnJySadn5SUZKZIiKgsYZJLRERERBbh5ORk0vnOzs5mioSIyhImuURERERkER4eHvBTKKAw8DwFAD8/P7i7u1siLCIq5ZjkEhEREZFFKBQKjLOxMercDz74AAqFoekxERGTXCIiIiKyoBHW1nCA/m86lQAcAAwfPtxyQRFRqcYkl4iIiIgsxk2hwCZopyAX9MZT+V+9zfb2cHNzs3RoRFRKMcklIiIiIovqAiAMgH0B9ewB7ATQ2crK4jERUenF3yBEREREZHFdAEQD8ASglnleBeABANfCDIqISiWO5BIRERFRoXCDNpmVowITXCIyD47k5iMiIgKrVq3C0aNHcevWLTx79gwqlQre3t4IDAzEq6++ipCQELi6Fs2v5Pv372PTpk04duwYrly5gri4OCQkJMDZ2Rmenp6oXbs22rVrh169eqFmzZom95eUlIQ//vgD+/btw/nz5/H06VOkp6fD1dUVNWvWRHBwMEJCQhAYGGiGV0dERERERGQ4hSAIQlEHUdzExsZi7Nix2LhxY4F1nZ2d8eWXX2LixIlQKgtnYPzevXuYNGkSNm3aBLVabsKPmFKpRP/+/TF79mxUr17d4P4EQcDChQsxdepUJCYmFli/T58+WLhwISpXrmxwX9lsbW2RkZEhKbexsUF6errR7RIRERnNxQVIStId2gKQ/qUCbADo/lI5OwN6/O0s1XjdiMhEhuYGTHJzuXz5Mjp37ozY2FiDzuvWrRs2btwIe/uCllQwzebNm/HGG28gISHB4HPd3NywatUq9OzZU+9z0tPTMWjQIPz1118G9VW+fHns2LEDTZs2NTRMAExyiYioGGKyZhxeNyIyEZNcE0RGRqJp06aIj4+XPFevXj289NJLSEhIwLVr1/D8+XNJnR49emDbtm0W27h8+/bt6Nu3L7KysiTPeXl5oW7dunB1dUVCQgKuXLki+zpUKhW2b9+OV199tcD+BEFA3759sXXrVslz3t7e8Pf3h62tLW7fvo07d+5I6pQrVw4nT55ErVq19HuBOTDJJSKiYofJmnF43YjIRIbmBlx46j9ZWVno37+/JDHs3bs3bt26hStXriAsLAxHjx7Fw4cPsXTpUsm9uDt27MD8+fMtEt/9+/cxePBgSYLbvn17HDlyBLGxsTh48CD++usvHDx4EE+ePMHevXvRpEkTUX21Wo1BgwYhKiqqwD7/7//+T5LgVq1aFX/99RdiYmIQHh6Ov//+G7dv38bp06fRokULUd1nz55h8ODB0Gg0xr1oIiIiIiIiAzHJ/c/ixYtx4cIFUdmECROwZcsW1KhRQ1RuZ2eHN998E+fOnUPFihVFz82cOdOoqcQFmTRpElJSUkRlH330Efbv34/WrVtLRo+VSiU6duyI48ePY+jQoaLnkpKSMHny5Hz7e/jwIaZNmyYqq1mzJs6fP49evXpJ7j9u2rQpDh8+jJCQEFH5hQsXsGbNGr1eIxERERERkak4XRna+06rVq2KJ0+e6Mratm2LgwcPFjj1+Pz582jevDkyMzN1ZVOnTsWMGTPMFl90dDReeukl5PxS9ezZE3/99ZdeU6OzsrLQunVrnDp1SlR+7949vPTSS7LnjB8/HgsWLNAdW1tb49KlS/D398+3r4yMDLRr1w4nTpzQlVWvXh03btyAtbV1gbFm43RlIiIqdjjt1ji8bkRkIk5XNsKmTZtECS4AzJkzR68EsnHjxnjnnXdEZUuWLDHrFN0NGzaIElyFQoG5c+fqfe+vlZUV5syZIynfsWOHbP2UlBSsWrVKVDZq1KgCE1xA+422aNEiUVlkZCR2796tV6xERERERESmYJILYN26daLjevXqSe4vzc97770nOn78+DEOHz5sltgA4MCBA6LjwMBAvRLOnNq2bQt3d3dRWe7p2dn+/vtvycJao0eP1ruvxo0bo1mzZqIyfbZjIiIiIiIiMlWZT3IzMzMRHh4uKjNkix0AqFOnjuS+3U2bNpkcW7br16+Ljl9++WWD21AqlfDx8RGVPXr0SLZu7lHXSpUqISgoyKD+cl/Dbdu2iaZ0ExERERERWYJVUQdQ1C5evIjk5GRRWevWrQ1up2XLlrh9+7bu+ODBg6aGpjN8+HBER0cjJiYGMTEx8PPzM6qdtLQ0veodPXpUdNyqVSuD+2rZsqXo+NmzZ7h8+bLByTIREREREZEhynySe+3aNUlZgwYNDG4nMDBQdHz9+nWkpqbC3t7e6Niy5V7l2BipqamIjIwUlVWqVElSLzMzE7du3RKVmeN6AMC5c+eY5BIRERERkUWV+enKERERomMHBwdUrlzZ4HZyT1fWaDR67UVbWHbt2iUZya1Xr56k3u3btyXTimvVqmVwf56enpJ9hHOOdBMREREREVlCmU9yY2JiRMfGJLgAJPvlAtoteoqLefPmScp69eolKct9PQDzXZPidD2IiIiIiKh0KvNJbu7Fl7y9vY1qx8vLS1L29OlTo9oyt+XLl0v2yG3VqhWqVasmqSu3GJW5rklxuR5ERERERFR6lfkkNz4+XnTs4uJiVDvOzs6SsmfPnhnVljn9888/mDhxoqR8+vTpsvVzXw/AfNekOFwPIiIiIiIq3cp8kpueni46dnBwMKodufP0Xc3YUuLj49GzZ0/JnrdDhgxBx44dZc/JfT0A812Tor4eRERERERU+pX51ZVzJ3VWVsZdEpVKJSkryn1hExIS0LlzZ/zzzz+icl9fX/z88895nieX5JrrmuhzPdLT02VjICIiIiIi0keZH8lVq9WiY7lkVR9y52k0GqPaMtWzZ8/QpUsXnDt3TlTu4uKCbdu2wc3NLc9zc18PwHzXRJ/rMXv2bLi6uiIjI8OoPomIiIiIqGwr80mutbW16DgrK8uoduRGKW1tbY1qyxQxMTFo27atZKEpe3t7bN++XXbboJxyXw/AfNdEn+sxefJkJCQkwMbGxqg+iYiIiIiobCvzSW7uxMvYEcTikOTeuHEDrVq1wtWrV0XlDg4O2LFjB9q2bVtgG3Ixm+ua6HM9bG1tjV7oioiIiIiIqMwnua6urqLj5ORko9pJSkqSlDk6OhrVljH279+PFi1a4O7du6JyV1dX/P333+jQoYNe7eS+HoD5rklhXg8iIiIiIiqbynyS6+HhITrOvRKxvuTOM3Z/WUMtXboUXbt2lcRQoUIFHDp0CG3atNG7rdzXAzDfNSms60FERERERGVXmU9yK1WqJDqOjY01qh258yyd1Gk0Gnz88cd4++23JffN1qlTBydOnECDBg0MajP39QDMd02Y5BIRERERkaWV+S2E/Pz8RMcxMTHIysoyeNuce/fuScqqV69uUmz5SUtLw5AhQ7B161bJc8HBwdiyZQvKlStncLu5rwcA3L9/3+B2MjMz8fDhQ1GZJa8HERERERERwJFcBAQEiI6zsrIQGRlpcDs3b94UHZcvXx6enp4mxZaXhIQEdOrUSTbBHTZsGPbs2WNUggtopyvnHnHN/dr0cfv2bcl2RLmvNRERERERkbmV+SS3SZMmkrKzZ88a3E7ucxo3bmx0TPl5/vw5OnfujKNHj0qemzFjBlatWmXy9jtNmzYVHZvjegBAo0aNjI6JiIiIiIhIH2U+yfX09JTsHbt//36D2khJScHx48dFZR07djQ5ttxSU1PRo0cPnD59WlRubW2NlStXYurUqWbpp127dqLjY8eOIS0tzaA29u7dKzquV68eKlSoYGpoRERERERE+SrzSS4AdO/eXXS8detWg5K6LVu2SOp369bNLLHlNHLkSBw7dkxU5uDggG3btmH48OFm6yf39UhJScH27dv1Pv/FixfYtm1bvm0SERERERFZApNcQJIgxsfHY/HixXqdm5WVhdmzZ4vKWrVqBX9/f7PFBwALFizA+vXrRWV2dnbYuXMnunbtata+6tSpI5myPHv2bGg0Gr3OX7hwIRISEnTHCoUCb775plljJCIiIiIiksMkF0DdunUl04s///xznDhxosBzx40bh2vXronKJk6caNb4oqKi8Nlnn0nKV6xYgeDgYLP2lW38+PGi4wsXLuj1ug4fPoxp06aJynr06IGaNWuaNT4iIiIiIiI5THL/M3v2bCiV/7scaWlp6NGjB/7++2/Z+hkZGRg3bhx++eUXUXnLli3Rt2/ffPtq164dFAqF6HHw4ME860+ePBmpqamisjFjxmDQoEEFvCrjDRkyRLLH7vz58zFhwgRkZmbKnhMWFobXXnsNGRkZujIrKyvMmTPHYnESERERERHlpBAEQSjqIIqLyZMnSxIyhUKBHj16YMiQIfDz88OLFy9w7tw5LFmyBLdv3xbVdXFxwblz51CjRo18+2nXrh0OHTokKgsPD5cs+ARoR3Fr1Kih91RhQwQHB+ebXF+6dAnNmzeX3G9cs2ZNjB49GkFBQXB0dMSdO3cQGhqKsLAw5P52mjt3LiZNmmRwbLa2tqJkOZuNjQ3S09MNbo+IiMhkLi5AUpLu0BaA9C8VYANA95fK2RlITLR8bMUZrxsRmcjQ3MCqMIIqKWbNmoVHjx5hxYoVujJBELB9+/YCF16ys7PD+vXrC0xwDbVu3TqLJLj6aNCgATZv3ow+ffqIvnlu3bqFTz75pMDz33jjDb3qERERERERmQunK+egVCqxbNkyfPrpp7Cy0j//r1KlCnbv3o0uXbqYPabcI76F7dVXX0VYWBiqVq2q9zkqlQpTpkzB0qVLoVAoLBgdERERERGRGJPcXJRKJebMmYPz58+jf//+cHBwyLOut7c3pk6diqtXr6Jt27YWiSc6Otoi7RrilVdeQUREBKZOnYpq1arlWc/Kygr9+/fHqVOn8PXXXzPBJSIiIiKiQsd7cguQmpqKo0ePIjo6GrGxsbCysoKnpycaNWqEwMBA0WJVZcXFixdx48YNPHr0CKmpqXBzc0ONGjXQvHlzODs7m6UP3pNLRETFDu8tNQ6vGxGZyNDcgEkuFUtMcomIqNhhsmYcXjciMpGhuUHZG4YkIiIiIiKiUotJLhEREREREZUaTHKJiIiIiIio1GCSS0RERERERKWGRZPc1NRUSzZPREREREREJGLRJNfb2xtvvvkmDh8+bMluiIiIiIiIiABYOMlNTk7GihUr0L59e/j5+WHGjBmIioqyZJdERERkKEHQbtfy9Kn2X+4uSEREJVih3JMrCAKioqLw1VdfoUaNGmjXrh1WrlyJFy9eFEb3RERElNvVq8DnnwOvvAK4uQGuroCXl/ZfNzdt+eefa+sRERGVIApBsNzHtUqlEgqFQnec3VV2mYODA/r164fhw4ejQ4cOlgqDSiBDN3wmIiI9hYUBs2cDx44BVlaAWi0/cqtQACoVkJUFtGqlTXi7dSv8eIsTFxcgKUl3aAtA+pcKsAGg+0vl7KwdHS/LeN2IyESG5gYWHcn97bff0LZtWwDaBFehUOgSXEEQ8OLFC6xevRqdOnWCj48Ppk2bhtu3b1syJCIiorIpLg4ICQF69ABOnNCWZWXlPTVZELTPA9r63bsDr78OxMcXTrxERERGsuhIbrZ///0Xq1evxpo1axAREaHtOJ8R3pYtW2LkyJEYOHAgnJ2dLR0eFUMcySUiMqPLl4FOnbSJrlptfDsqFeDhAezbBwQGmi++koIjksbhdSMiExmaGxRKkpvTuXPnsGrVKvz55594/PixNogco7s5j+3s7NCnTx+MGDECnTp1KswwqYgxySUiMpPLl4E2bYAXL0xLcLOpVICjI3D0aNlLdJmsGYfXjYhMVOyT3GxqtRq7d+/G6tWrsW3bNt2eunklvJUqVcLw4cMxYsQI1KpVqyhCpkLEJJeIyAzi4oC6dU0fwc0te0Q3IgJwdzdfu8UdkzXj8LoRkYlKTJKbU1JSEjZs2IA//vgDhw4d0t2/my13wvvyyy9j1KhRGDRoEFxdXYskZrIsJrlERGYQEgKsX2/eBDebSgUMGgSsWWP+tosrJmvG4XUjIhOVyCQ3p+joaKxevRpr167F1f+2LchrdNfW1havvfYaRowYgS5duogSYyrZmOQSEZkoLEy7yFRh9FNWVl1msmYcXjciMlGJT3JzunnzJtavX4+//voLFy5c0I3w5gw553TmUaNG4a233sJLL71UVCGTmTDJJSIyUevW2lWRNRrL9aFSAS1aAEeOWK6P4oTJmnF43YjIRKUqyc3p0aNHmDlzJn799VdocvzBzp3wKpVK9OjRAx999BFat25dFKGSGTDJJSIywdWrhbso1NWrQEBA4fVXVJisGYfXjYhMVKz2yTVVamoqNmzYgJCQENSrVw+//PILNBqNJLHNfgiCALVajW3btiE4OBhdu3blvrtERFT2hIYCVlaF05eVlbY/IiKiYqKQ/gLqLzMzE2FhYQgNDcXOnTt1qy7nvB8355RlBwcHVK5cGbdu3dI9n11/z549aNy4MUJDQ9GjMO5LIiIiKg5OnQKysgqnL7Va2x8REVExUWxGcg8dOoTRo0fD29sb/fr1w6ZNm5CSkiKb3AqCgNatW2Pp0qV49OgRbt68ifPnz+PDDz+Ep6enaHXm5ORk9OvXD8ePHy/Kl0dERFQ4BAE4e7Zw+ztzRvsvERFRMVCk9+RevnwZa9aswdq1a/HgwQMA0ntsc5ZVq1YNw4YNw8iRI1G9enXZNjMyMvDrr79i0qRJuvnZgiCgbt26utWaqfjjPblEREZKTASKYnu9xETtfZSlGe8tNQ6vGxGZyNDcoNCnK9+/fx+hoaFYs2YNrl+/DiDvxFYQBDg6OqJv374YOXIk2rdvX2D7NjY2GDt2LHx8fNCrVy9dexERETh58iSaN29ugVdFRERUTMi8CSjV/RIREeVSKElufHw8NmzYgDVr1uD48eO6BDZbzv1ts6cat2nTBiNHjsTAgQPh6OhocJ89evRAy5YtRdOUz549yySXiIhKNxubstUvERFRLhZNctevX481a9Zg9+7dyMzMBCBeQCpbzunIw4cPx8iRI+Hr62ty/02aNBEluUk5psoQERGVSs7O2umhhTnV08UFcHIqvP6IiIjyYdEkd/DgwaKVkAHpfbaOjo7o168fRowYodd0ZENkjwBn91m+fHmztk9ERFTsKBRAkybAgQOF11/Tptp/iYiIioFCma4sNx25bdu2GDlyJAYMGGDUdGR9xMTEiPoMCgqySD9ERETFSrNmwOHDhbONkEql7Y+IiKiYKJQkN3vU1sfHB8OHD8eIESPMMh25IK6urnj33Xfh6+sLX19fNGzY0OJ9EhERFbmQEGD27MLpKytL2x8REVExYfEk18HBAf369cPIkSPRrl07S3cn8uOPPxZqf0RERMVCvXpAq1bAiROARmO5flQqoEULICDAcn0QEREZyKJJ7u+//27R6chERESUh8mTgR49LNuHWq3th4iIqBhRWrLxkSNHWjzBjYyMRGpqqkX7ICIiKnG6dweGDNGOtlqCSqWdptytm2XaJyIiMpJFk9w33nhD91i8eLHZ2j1//jxatWoFV1dX1KxZU7RNEBEREf1n4ULAw8P8ia5KpW134ULztktERGQGFp2uvGLFCt3KysnJyXj33XfN0m5WVhZOnDgBQLtyc2RkJF555RWztE1ERFRqeHgA+/YBrVsDL15opxebSqUCHB217bq7m94eERGRmVl0JNdSrK2tAfxva6L4+PiiDIeIiKj4CgwEjh41z4hu9gju0aPadomIiIqhEpnknjt3TnSsseTKkURERCVdYCAQEQEMGmRaO4MHa9thgktERMWYUdOV09LScPr0aYPOefLkCQ4fPmxMdzopKSm4du0avv76aygUCgiCAIVCAU9PT5PaJSIiKvXc3YE1a4AtWwBDF2xUKoHt27nIFBERlQgKQRAEY05s164djhw5km+dnE1nTy02h+zkNvvfkydPomnTpmZrn4qera0tMjIyJOU2NjZIT08vgoiIiEoJFxcgKcmwc5ydgcREy8RTkuS6drYApH+pABsAur9UvHa8bkRkMkNzA6OnK//888+wsrKCIAh5PnLKr56hj+yEWaFQwN/fnwkuERERERERATAhya1bty4mTpwIQJtsyj1yyquOMQ9AmzTb29tjzZo1Jrx8IiIiIiIiKk1MWnjqyy+/RLVq1Qp9JLdChQoYMGAALl68iAYNGph0AYiIiIiIiKj0MGmfXHt7e5w/fx6JMvdMCIKA6tWr60ZeX331Vfz0009G9aNQKKBSqWBraws3NzdYWVl0e18iIqIyRQAQByAZgBMADwDmW0mDiIiocJmcLZYrVw7lypUrsJ6DgwOqVatmandERERkJs8BrASwEMCdHOV+AMYBGAHArdCjIiIiMo3F98mVm7pMRERERWs3gCoAJgCIzPVc5H/lVf6rR0REVJJYdN7v8uXLdf/38fGxZFdERESkp90AukM7TVnuY+jsstT/6oVlZaFLIcVGRERkKosmuSNGjLBk80RERGSg54KAftAmspoC6mqgnfLVLzUV0c+fw83NzdLhERERmczi05WJiIio+FiZmYkUFJzgZtMASAGwatUqywVFRERkRkxyiYiIyghBELAwI8OocxcsWMA1NoiIqEQwarqy3Ke5w4cP16ueJcj1TURERGJxcXG4Y0SiKgC4c+cO4uPj4eHhYf7AiIiIzEghGPGxrFKp1O1/m02tVutVzxLk+qaSzdbWFhkyow02NjZIT08vgoiIiEq+u3fvwtfX1+jzo6KiyvZCki4uQFKS7tAWgNy4uA0A3V8qZ2cgMdHysRVnvG5EZCJDcwOTFp7Kzo8LSmQtOb2pMJJoIiKi0sDJycmk852dnc0UCRERkeWYlOQqFAq9ElhLJaK8N4iIiEh/Hh4e8FMoECkIslsH5UUBoLqfH9zd3S0VGhERkdkYvfCUIAh6JZnZ9SzxICIiIv0pFAqMs7Ex6twPPviAs6eIiKhEMGokV6PRb+MBfesRERFR4RhhbY0p6elIhX7bCCkB2IOLPBIRUcnBLYSIiIjKEDeFApugnYJc0JsA5X/1Ntvbw83NzdKhERERmQWTXCIiojKmC4AwaEdo82MPYCeAzlYmLeFBRERUqPhXi4iIqAzqAiAagCcAuY34VAAeAHAtzKCIiIjMgCO5REREZZQbtMmsHBWY4BIRUcnEJJeIiIiIiIhKDaOmK9+/f9/ccZjkpZdeKuoQiIiIiIiIqBgwKsn18fEpNnvlKRQKZGVlFXUYREREREREVAwYvfCUIAjmjIOIiIiIiIjIZEYnucVhJJeJNhEREREREeXEkVwiIiIiIiIqNYxKcsPDw80dBxEREREREZHJjEpyg4ODzR0HERERERERkcm4Ty4RERERERGVGkxyiYiIiIiIqNQweuGpsiAiIgKrVq3C0aNHcevWLTx79gwqlQre3t4IDAzEq6++ipCQELi6uhZ1qCJZWVlo0KABrl+/DkB7D3W7du2MauvgwYNYtGiRyTGNGDECPXv2NLkdIiIiIiKi/DDJlREbG4uxY8di48aNss/fvXsXd+/exfbt2/Hpp5/iyy+/xMSJE6FUFo+B8Tlz5ugSXFPt2rULmzZtMrmd5s2bM8klIiIiIiKLMyrJvX//vqTspZde0queJcj1bazLly+jc+fOiI2N1at+UlISPvnkE4SHh2Pjxo2wt7c3WyzG2LdvH6ZPn2629i5cuGC2toiIiIiIiCzNqCTXx8cHCoVCd6xQKJCVlVVgPUvIq29jREZGon379oiPj5c8V69ePbz00ktISEjAtWvX8Pz5c9HzO3fuxMCBA7Ft2zaLv+a8nDt3Dv369YNarTZbm5cuXTJbW0RERERERJZm9PxaQRBED33rWeJhDllZWejfv78kwe3duzdu3bqFK1euICwsDEePHsXDhw+xdOlSyb24O3bswPz5880Sj6GOHz+OV155BYmJiWZrMyYmBo8fPxaVRUdHG/U1+vjjj80WFxERERERUV6MTnIVCoVeI5bZ9SzxMKfFixdLpuZOmDABW7ZsQY0aNUTldnZ2ePPNN3Hu3DlUrFhR9NzMmTORkJBg1tgKsnjxYnTo0MHs/ea+Hl5eXqhcubJZ+yAiIiIiIjInk0dy9a1XXEdwASA9PR0zZ84UlbVt2xbff/99vuf5+flhx44dsLa21pXFx8cXeJ65JCcnIyQkBO+99x7S09PN3v7FixdFx40aNTJ7H0REREREROZk1D254eHhZq1X1DZt2oQnT56IyubMmaPXaHHjxo3xzjvvYOHChbqyJUuWYPr06RZbbVkQBKxfvx6TJ09GVFSURfoApCO5THKJiIiIiKi4MyrJDQ4ONmu9orZu3TrRcb169dCiRQu9z3/vvfdESe7jx49x+PBho/emzc+RI0fw8ccf4/Tp05Ln3NzcMHfuXIwZM8YsfXEkl4iIiIiISprisbFrEcrMzJSMOBu6n2udOnUk9+2aY29ZOT179pRNcIOCgnDq1Cl07tzZLP0kJSUhMjJSVMYkl4iIiIiIirsyn+RevHgRycnJorLWrVsb3E7Lli1FxwcPHjQlLL3Z2dlh9uzZOHXqFGrVqmW2di9evCi679nJyUmSyBMRERERERU3Rk1XLk2uXbsmKWvQoIHB7QQGBoqOr1+/jtTUVNjb2xsdW36USiVCQkLw9ddfo1q1amZvP/f9uA0aNLDYPcZERERERETmUuRJ7tOnTxEZGYm4uDgkJCTAwcEB5cqVg7u7O2rXrg0rK8uGGBERITp2cHAwapuc3KOcGo0GUVFRqFu3rknx5WZnZ4devXrh448/Rv369c3adk553Y8bFxeH0NBQHDhwABcuXMCTJ0+gUChQoUIF1KpVC926dUOfPn241RARERERERWJIklyjx07hhUrVuDIkSO4detWnvVsbW0RFBSEdu3aYfTo0ahatarZY4mJiREdG5uc5d4vFwDu3btn9iT3+vXrcHd3N2ubcnInuS+99BLGjRuH3377TXa7ojt37uDOnTvYtWsXPvnkE4wbNw5TpkyBq6urxWMlIiIiIiLKVqjzT3fv3o369eujbdu2+P333/HPP//kuw9uWloajh8/jm+++QZ+fn4YPHgw/v33X7PG9OjRI9Gxt7e3Ue14eXlJyp4+fWpUW/kpjAQ3MzNTMo178uTJWLRokV778aalpeHbb79Fs2bNcPv2bUuFSUREREREJFEoSW5GRgZGjBiBbt264dq1a7okVqFQFPgAtPvCZmVlYcOGDWjYsCE2b95sttji4+NFxy4uLka14+zsLCl79uyZUW0VtevXryMjI0NUplardf+3traGv78/unbtio4dO6JOnTqy7dy8eRPNmjXDzZs3LRovERERERFRNosnuRkZGejduzf++OMPSXKb3yhuzkfO+s+ePcOAAQOwfPlys8SXe2TSwcHBqHbkzktLSzOqraKWe9GpbB4eHpg3bx5iYmJw/fp17Nq1C3v37kVERAQePHiAzz//XHId4uPj0bt3byQmJurVd3p6ut51iYiIiIiIcrP4PbkTJkzA33//LRmZtba2RpcuXdC8eXPUr18fnp6ecHV1hUajQUJCAmJjY3H+/HkcOnQIR48eBQDR+WPGjIG3tze6detmUny5k1xjF7pSqVSSsszMTKPaKmq578cFgObNm2P9+vV53hddqVIlzJo1C4MGDUL37t0RHR2te+7GjRuYPn06/u///q/AvmfPno2vvvrK6NiJiIiIiKhss2iSe+nSJSxZskSXnALarW/Gjx+Pzz77DJ6envme36dPHwDArVu38Omnn2Lr1q26ZDkrKwtvv/02bt68CScnJ6NjzDkNF5BPVvUhd55GozGqraLm7OyMgIAAREVFISUlBTVr1sSuXbvg5uZW4Ln169dHWFgYmjdvjtTUVF354sWL8fHHH6NSpUr5nj958mRMnDgRXl5ekinTREREREREBbHodOXZs2frEj1BEGBvb4+///4b3333XYEJbk41a9bE5s2bsWjRIlH5o0ePMGfOHJNitLa2Fh1nZWUZ1Y7cqK2tra1RbRW1mTNn4urVq3jx4gUePnyI48eP65XgZqtfvz4mTZokKktLS0NoaGiB59ra2hp9XzQREREREZHFkty0tDSEhYXp7qVVKBRYtmwZXnnlFaPbfO+99zBz5kxde4IgYOXKlSbFmTsRNXb0sDQluTlVqFDBoA8kso0bN04y9XvPnj3mCouIiIiIiEiWxZLcY8eO4cWLFwC099IGBwdj0KBBJrf72WefISAgQHccExODM2fOGN1e7n1ck5OTjWonKSlJUubo6GhUW6WBh4cHGjduLCo7ffp0EUVDRERERERlhcWS3Oz9bAVBAAAMHTrULO0qlUq88cYbunYB4J9//jG6PQ8PD9Hx8+fPjWpH7jxj99wtLerXry86TkhI0GufXSIiIiIiImNZLMmNjY0VHfv7+5ut7ewRwuwFrR4+fGh0W7kXQsodt77kzivrSW7uDxAAIC4urggiISIiIiKissJiqyuXK1dOdKxUmi+fzr0Xq52dndFt+fn5iY5jYmKQlZVl8FZC9+7dk5RVr17d6LhKg9wrVwNlewo3ERERkSkEQUBcXBySk5Ph5OQEDw8P0S4mRKRlsZHcl156SXR848YNs7V9//59AP+bCp3X3q36yHl/L6BdXTkyMtLgdm7evCk6Ll++vFELNhU3xq42DUhHba2srCT3QBMRERFR/p4/f4758+ejZs2a8PLygq+vL7y8vFCzZk3Mnz/f6NvtiEoriyW5wcHBcHJy0n26tHbtWrO1vX37dt3/rays0KJFC6PbatKkiaTs7NmzBreT+5zciy6VFKGhoWjbti3q1KkDd3d32NjY4Pr160a1dfnyZdFx7dq1zREiERERUZmxe/duVKlSBRMmTJAMxERGRmLChAmoUqUKdu/eXUQREhU/Fkty7e3tMWjQIAiCAEEQsHfvXuzcudPkdm/duoU///wTCoUCCoUCXbt2Rfny5Y1uz9PTE/Xq1ROV7d+/36A2UlJScPz4cVFZx44djY6pKGk0Ghw5cgQ3b97Es2fPIAiC5LXpIz4+HhcvXhSVtWnTxkxREhEREZV+u3fvRvfu3ZGamqp7T51Tdllqaiq6d+/ORJfoPxZLcgFg9uzZ8PT01O1pO3ToUJw/f97o9p4/f44+ffogPT0dgiDA3t4ec+bMMTnO7t27i463bt2KtLQ0vc/fsmWLpH63bt1MjqsoBAUFScrWrVtncDuLFy+W3JPbs2dPo+MiIiIiKkueP3+Ofv36QRAEaDSafOtqNBoIgoB+/fpx6jIRLJzkenp64o8//oCtrS0UCgWeP3+Odu3a4ZdffjG4rTNnzqBx48aIiIgAoF1ZeeHChWZZtXn48OGi4/j4eCxevFivc7OysjB79mxRWatWrcy6mnRh8vf3R2BgoKhs//79OHnypN5t3L9/H999952orEaNGnj11VfNEiMRERFRabdy5UqkpKQUmOBm02g0SElJwapVqywcGVHxpxByz3vQw+HDhw2qv3//fsycOVM3oqtQKODj44NRo0ahXbt2aNSokWTV3bS0NERGRuLEiRPYunUrdu3apfshd3R0xKpVq9CnTx9DQ89Tp06dsG/fPt2xnZ0dDhw4UOD9vu+++64kad+0aRP69u1rttgMcffuXfj6+orKwsPD0a5dO73bWLRoEcaNGycq8/f3x/Hjx+Hm5pbvuQkJCejcuTNOnz4tKl+1ahWGDRumdwy2trbIyMiQlNvY2HCvXSIiU7i4AElJukNbANLftoANAN1vW2dnIDHR8rEVd7x2xuF1M5ggCKhZsyYiIyMlU5Tzo1AoUL16ddy6dYurLlOpYmhuYFSSq1QqDf7ByU5us/8PQNSGnZ0dXF1dodFokJqaiuTk5DzPt7a21m0jpFAozLL36tmzZ9GsWTPRp2Xu7u5Ys2YNunbtKqmfkZGBjz76CIsWLRKVt2zZEseOHcu3r3bt2uHQoUOiMkMT0byYI8nNyspCw4YNce3aNVF5w4YNsWHDBtSoUUP2vCtXrmDo0KGSBae6deuGsLAwvfsHmOQSEVkMEw7j8doZh9fNYE+fPoWXl5dJ53t4eJgxIqKiZWhuYNI+uYbmx9mJau5kFwBSU1ORmpqa57k5z8nMzNTdb2CuT6maNGmCSZMmie7xjY+PR7du3dCjRw8MGTIEfn5+ePHiBc6dO4clS5bg9u3bojZcXFywcuVKs8RTlKysrLBy5Uq0a9dO9GHDxYsXUbduXYSEhKB79+7w9fVFRkYGIiMjsX37dmzevFmy5ZCPjw9+//33wn4JRERERCVTXByS33jDpCaS3ngDHsuXA+7uZgqKqGQxKck1NcE05vzsc7KnPpvTrFmz8OjRI6xYsUJXJggCtm/fLtq2SI6dnR3Wr1+f5yhnSRMUFITNmzejd+/eSElJ0ZVnZmZi5cqVeiXzvr6+2LNnD7y9vS0ZKhEREVHpcPky0KkTnJ4+NakZ5x07AH9/YN8+INdaK0RlgdELT2UvWV6UD3NTKpVYtmwZPv30U1hZ6Z//Z+9N1qVLF7PHVJQ6deqEM2fOSBai0kfv3r1x+vTpUpP0ExEREVnU5ctAmzZAXBw8NBr4ATB0OEgBwA+Au0YDxMUBrVsDV66YP1aiYs6okdyoqChzx1FsKJVKzJkzB6+//jpmzJiBnTt3ikYyc/L29sbo0aPx0UcfwdXVtZAjLRx169bFhQsXsH79esyfPx9nzpzJc5U/a2trdO3aFR9++CE6dOhQyJESERERlVBxcUCnTsCLF4BaDQWAcQAmGNHUB/gvOVarte117AhERHDqMpUpRi08VZakpqbi6NGjiI6ORmxsLKysrODp6YlGjRohMDAQSqVFd2Eqdp49e4YTJ07gwYMHiIuLg0ajgbu7O2rVqoWXX34ZTk5OZumHC08REVkIFwEyHq+dcXjdChYSAqxfr01M//McQBUAqQD02URICcAeQDQAt5xPqFTAoEHAmjXmipao0BXK6spElsYkl4jIQphwGI/Xzji8bvkLCwN69JB9ajeA7gAE5J/oKqEdvd0JoHN+/XTrZnycREXI0NygbA1DEhEREREVJ7NnA3nMDOwCIAzaEdr82KOABFel0vZDVEYwySUiIiIiKgpXrwLHjgF5rHcCaBPdaACqPJ5XAXiAfBJcQDsN+uhR4No1YyMlKlFKfJIbFhZW1CEQERERERkuNBTQY0cPN+Sf5Oq1/KmVlbY/ojLApH1yjZWUlITk5GRkZGRAo9Hkux2QRqNBVlYWMjIykJqaisTERDx69AhnzpzBrl27EBkZCXWOm/SJiIiIiEqEU6eArKzC6Uut1vZHVAYUWpIbFhaG5cuXY+/evUhOTjZLm4IgQKEwdAcxIiIiIqIiJgjA2bOF29+ZM9p/+f6ZSjmLJ7kpKSl4/fXXsW3bNgDId9SWiIiIiKhMSEoq/BWkExOB5GTt6tVEpZjFk9zhw4fjr7/+0h2bc+SVCTMRERERlUgy26GU6n6JCpFFk9z9+/dj8+bNksTW0OQ05/mCIEClUqF69epo2rQphgwZYpZYiYiIiIgKjY1N2eqXqBBZNMmdP3++6FgQBHh4eKB///6oW7cunJ2dsXfvXqxduxYAYGdnh59++gkKhQKpqal4/Pgxrly5gr179yIpKUmX7NrY2GDdunVo1KiRJcMnIiIiIrIMZ2fAxaVwpyy7uABOToXXH1ERsViSm5qair1790KhUOgWiOrQoQO2bNkC5xz3AdSvX1+X5Kanp6NGjRpo06aNqK2UlBTMmDED3377rS4B7t+/Py5dugQn/qASERERUUmjUABNmgAHDhRef02bctEpKhMstk/uxYsXkZ6erjt2dHTEmjVrRAkuADRq1AjOzs66Udpdu3ZJ2nJwcMCcOXOwYsUKANrpy3fv3sWkSZMsFT4RERERkWU1a6bXPrlmoVJp+yMqAyyW5N65c0f3f4VCgYEDB8Lb21tST6FQoGnTprr7dA8dOpRnm8OGDcPYsWMhCAIEQcBvv/2GGzdumD94IiIiIiJLCwkpvH1ys7K0/RGVARZLch8/fgzgf4tMBQcH51k3MDBQV/fixYvQaDR51v3qq690I78ajQYLFiwwY9RERERERIWkXj2gVStAabG35FoqFdC6NRAQYNl+iIoJi/1Epaamio79/PzyrBuQ4wcuLS0NN2/ezLOum5sb+vXrpxvN3b59u+nBEhEREREVhcmTgXwGeMxCrdb2Q1RGWCzJtbOzEx3nvhc3pxo1aoiOr1+/nm/bHTp00P0/JiYm36SYiIiIiKjY6t4dGDJEO9pqCSqVdppyt26WaZ+oGLJYkuvu7i46zj2ym1P16tUB/G8/3IKS1txJ8ZUrV4wJkYiIiIio6C1cCHh4mD/RVam07S5caN52iYo5iyW5Hh4eouOYmJg861apUgXW1ta644JGch0cHAD8Lyl+8uSJsWESERERERUtDw9g3z7A0dF8ia5KpW1v3z4g1+ATUWlnsSS3Vq1aAP6XiJ4+fTrvIJRK+Pr6AtAuPnXhwoV8205ISBAdP3/+3IRIiYiIiIiKWGAgcPSoeUZ0s0dwjx7VtktUxlgsya1Tpw7Kly8PQJu4hoaGIiMjI9/62Ssx37hxQ7c6s5xLly7p2gW0e/ASEREREZVogYFARAQwaJBp7QwerG2HCS6VURZdr7xdu3a6RPTff//V7XErp2HDhqLjpUuX5tnuypUrRcdeXl6mBUpEREREVBy4uwNr1gD29oafq1QCYWHAH39wijKVaRZNcocPHw5AO2VZEAQsW7YMbdq0wcGDByV1u3btKqo7e/ZsHDt2TFLv888/x7lz53TToAGgcePGlnkBRERERERFwcrK8HMcHbmKMhEAhZDX0KqZNGvWDGfPngWgnV6cnZxWr14dt27dEtWtU6eOrkwQBFhbW2PgwIFo0aIFUlNTsXHjRtG9vYIgoFq1aoiKirLkS6AiYGtrKzu93cbGBunp6UUQERFRKeHiAiQl6Q5tAcjdTGQDQPfb1tkZSEy0fGzFHa+dcXjdjMPrRqRjaG5gxEdEhvn999/RokULvHjxQjdKCwAqmRvqp0+fjpCQECgUCigUCmRmZiI0NBShoaG6OtmJcva/7733nqVfAhEREREREZUQFp2uDAABAQHYtWsXPD09dYmpQqHQ7Y2b0+DBg9GrVy9dIpydzOZ85JymXL9+fXz44YeWfglERERERERUQlg8yQWAVq1a4erVqxgzZgxsbW0hCIJskgsAa9euRefOnUWJbs4HoB3NrV27NrZt2ybaX5eIiIiIiIjKtkJJcgHtCsiLFy/Go0ePsHr1avTp00e2nr29Pf7++28sWrQI1atXl4zkOjk54aOPPsKpU6dQtWrVwgqfiIiIiIiISgCLLzxlqitXriAqKgrp6emoXLkymjZtytHbMoALTxERWQgXszEer51xeN2Mw+tGpFPsFp4yVWBgIAK5kTURERERERHpodCmKxMRERERERFZGpNcIiIiIiIiKjWKbLrygwcPcOTIERw7dgx37txBXFwcEhIS4ODggHLlysHd3R3169dHy5Yt0bx5czg6OhZVqERERERERFRCFHqSu3nzZixevBgHDhwQledc/yp7q6DNmzcDAOzs7DB06FB88MEHCAgIKLxgiYiIiIiIqEQptOnKN27cQKtWrTBgwAAcOHBAsjWQ3F642Y/U1FQsXboUDRo0wCeffIKsrKzCCpuIiIiIiIhKkEJJcnfv3o3GjRvj5MmTeiW1uZ9XKBQQBAEajQb/93//hxYtWiAuLq4wQiciIiIiIqISxOLTlQ8fPow+ffogLS0NAERJLaCdily3bl14enrC1dUVGo0GCQkJiI2NRUREhG7UNud5586dQ/fu3bF//37eq0tEREREREQ6Fk1yMzIy8NZbbyEtLU2UpLq4uGDUqFEYNmwYGjZsCKVSfkA5PT0dx44dw7Jly7Bhwwao1WrdqO6ZM2cwZswY/PHHH5Z8CURERERERFSCWHS68sKFC3H79m1dYioIAjp16oTr16/jhx9+QOPGjfNMcAHA1tYWHTp0wJo1a3Dy5EnUrl1bN5VZEASsXbsWhw4dsuRLICIiIiIiohLEoknuihUrdAmpQqFA165dsWPHDlSqVMngtho3bozDhw/rVlfObnfWrFnmDpuIiIiIiIhKKIsluf/88w+uXbumOy5XrhxWrVoFa2tro9v09PTE+vXrRW0cPHiQi1ARERERERERAAsmuVeuXNH9X6FQYOTIkfD09DS5XX9/fwwZMkS3cJVarcbx48dNbpeIiIiIiIhKPosluQ8ePADwv1WUO3bsaLa2X3vtNdm+iIiIiIiIqGyzWJKbmZkpOvb29jZb21WrVgXwv22FEhMTzdY2ERERERERlVwWS3IrV64sOn7y5InZ2n7+/DmA/40SV6xY0WxtExERERERUcllsSS3QYMGAP432nrgwAGztZ3zfl8AqFmzptnaJiIiIiIiopLLYkmuv7+/LtEVBAErVqzQjcCa6rffftMlzy+99BKaN29ulnaJiIiIiIioZLPoPrlTpkzR7ZH75MkTjBkzxuQ2v/76a0RERADQjhKPHTvW5DaJiIiIiIiodLBoktu/f38MGDAAgiBAEARs3LgRw4YNQ0pKilHt/fjjj5g+fToUCgUEQUCbNm0wceJEM0dNREREREREJZVFk1wAWL16NXr06AFAO205NDQUgYGBWLVqFdLS0vRq49y5c+jZsyc++ugjaDQaCIKA5s2bY+PGjbppy0RERERERERWxpzUoUMHg+pnbyeUPQIbFRWFUaNGYdy4cWjatCkaNWqE8uXLw9XVFRqNBqmpqYiNjUVkZCROnDiBmJgYAP9bTblcuXLo3bs3QkNDAQAffPCBMS+DiIiIiIiIShmFkJ05GkCpVBo8gprdTfZ5uY8LOi+/umq12qBYqPiztbVFRkaGpNzGxgbp6elFEBERUSnh4gIkJekObQFIf9sCNgB0v22dnQHuSc9rZyxeN+PwuhHpGJobGDWSa4zcCWrO47zybIVCkWdiq2+STERERERERGWH0UmuEQPAxbIPIiIiIiIiKj2MSnJHjBhh7jiIiIiIiIiITGZUkrt8+XJzx0FERERERERkMotvIURERERERERUWJjkEhERERERUanBJJeIiIiIiIhKjULbQigvarUajx8/Rnx8POLj42FlZQUHBwd4e3ujQoUKRR0eERERERERlSBFkuT++++/WL58OQ4dOoSTJ08iLS1Ntp6dnR0aNGiA9u3bY8iQIahXr14hR0pEREREREQliUIoxM1oHzx4gClTpmDt2rXIysoCUPBeuAqFQvf/Tp06YeHChahZs6ZF46SiZ2tri4yMDEm5jY0N0tPTiyAiIqJSwsUFSErSHdoCkP62BWwA6H7bOjsDiYmWj62447UzDq+bcXjdiHQMzQ0K7Z7c/fv3o3Hjxli9ejUyMzMhCAIEQYBCocj3AUBXd8+ePWjQoAHWrl1bWGETERERERFRCVIo05W3bNmCgQMHQq1WAxCPzuozkpsz2U1LS8PQoUORnp6OkSNHWixmIiIiIiIiKnksnuReuHABw4YNg1qtFiWrAODr64vg4GA0adIE5cuXh6urK7KyspCQkICHDx/i3LlzOHz4MKKjoyXJ7pgxY1CvXj00adLE0i+BiIiIiIiISgiLJ7mjRo1CSkqKKEFt1KgR5syZg06dOhV4viAI2LVrF6ZMmYJLly7pkt3MzEy89dZbuHDhgmhkmIiIiIiIiMoui96TGxoaisuXL0OhUOhGb8eMGYNTp07pleAC2unK3bp1w5kzZzBmzBjR9OYrV65g48aNFomdiIiIiIiISh6LJrm//PILAOgWmBo4cCAWL14MKyvDB5CtrKywePFiDBw4UNceACxevNisMecUERGByZMno02bNqhQoQJsbW3h4OAAX19f9OrVC4sXL0ZCQoLF+jdWVlYWAgICdKPeBw8eNEu7SUlJWLx4Mfr16wdfX184OzvDxsYGXl5eaNmyJSZPnowrV66YpS8iIiIiIiJjWGwLoYSEBHh6ekKj0UAQBJQrVw63bt2Cu7u7Se3GxcWhVq1aeP78OQRBgJWVFR4/fgw3NzfzBA4gNjYWY8eO1WuU2NnZGV9++SUmTpwIpbLQFqvO19dff42pU6fqjsPDw9GuXTuj2xMEAQsXLsTUqVORqMey9H369MHChQtRuXJlo/vkFkJERBbCbUmMx2tnHF434/C6EekUmy2ETpw4IVpNefDgwSYnuADg4eGBkJAQ3bRltVqNs2fPmtxutsuXL6NBgwZ6T4NOSkrCJ598gp49eyI1NdVscRhr3759mD59utnaS09PR58+fTB+/Hi9ElxAu5p248aN8f/t3XlcVFX/B/DPMMMui6xqqCBiLuCCmhpmWCoFWpqWS1qm5mOWlbY92lNaWvpUVqZllpaaqZnmikpqmqK4objvuIQoyiYgO3N/f/CDhzt3GGYus8DM5/168apz5ixfroPynXPuuUeOHDFaHERERERERPowWZJ769YtAP87SVnfe3D10adPH1H50qVLRhk3OTkZvXv3RlpamuS10NBQREdHIyIiQuuq8datWyu3UltKYmIiBg8eXPnhQm0JgoBhw4Zh48aNktf8/f0RGRmJqKgoBAcHS16/c+cOoqKicPHiRaPEQkREREREpA+TJbl3794VlQMCAow2dsU22Ir7co1xX2xpaSmGDBmCzMxMUf3AgQNx6dIlnDp1CrGxsYiPj8etW7ewePFieHh4iNpu2bIF8+bNq3Uschw4cACPP/643qut+vjyyy+xYcMGUV3Tpk2xceNGpKamYvfu3di+fTsuX76Mw4cPo0ePHqK2WVlZGDZsGNRqtdFiIiIiIiIi0sVkSa7m4VLa9lDLpTmWo6NjrcdcuHAhjh8/LqqbPHky1q9fj5YtW4rqnZycMHbsWCQmJqJx48ai12bOnGn2w6gWLlyIxx57zKjz3rp1C9OnTxfVhYSE4NixY3jqqack9x937doVe/fuxYgRI0T1x48fx6+//mq0uIiIiIiIiHQxWZLr4+MjKicnJxtt7IqxKrYG+/n51Wq8oqIizJw5U1TXq1cvzJ07V2e/4OBgbNmyBfb29pV1mZmZNfYzlry8PIwYMQITJ040+mFMc+bMwf379yvL9vb22Lhxo+TPtSqVSoWff/5ZsqI7Y8YMlJSUGDU+IiIiIiIibUyW5FasflZsKd60aZPRxtYcq2nTprUab926dZLt1XPmzKmMXZfw8HBMmDBBVLdo0SKTbtEVBAG//fYb2rdvj1WrVhl9/Pz8fCxfvlxU99JLL6FNmzY19nVwcMCCBQtEdcnJyYiLizNqjERERERERNqYLMl96KGH4OLiAqA8KduwYQPOnj1b63HPnDmDDRs2VCagLi4ukpVDQ61evVpUDg0NNWjMiRMnisp37tzB3r17axVTdfbt24fu3btj2LBhuHr1qug1T09PLFq0qNZzbN++HdnZ2aK68ePH690/PDwc3bp1E9Xpe1o1ERERERFRbZj0ntyoqCgIggCFQoHS0lKMGjUKuVWe92WonJwcjBo1CqWlpZXj9u7dW7Rd2FAlJSXYvXu3qG7AgAEGjdG6dWvJfbvr1q2THZMuAwYMwOHDhyX1nTt3xqFDh9CvX79az6G56tqkSRN07tzZoDE0r+GmTZu4ZZmIiIiIiEzOZEkuALz99tuiclJSEqKionDjxg2Dx7p+/TqioqKQlJQk2kb81ltv1SrGpKQk5OXliep69uxp8DgPP/ywqLxnz57ahKU3JycnzJ49G4cOHUKrVq2MMmZ8fLyoHBERYfAYmtcjKysLJ0+erFVcRERERERENTFpktujRw889dRTlauugiDg4MGDaN++Pd5//329DqO6cuUKpk6dig4dOuDw4cOV4ygUCvTt2xePPvporWI8c+aMpK5Dhw4GjxMWFiYqnz17FgUFBbLjqomdnR1GjhyJ8+fP49///jeUSqVRxi0pKZE8d9gY1wMof44vERERERGRKalqblI7S5YsQVhYGNLS0ioT1JycHMyZMwdz5sxBQEAAwsPD0ahRI3h4eFS+fvv2bSQmJuLmzZsA/neScsUqbpMmTfDzzz/XOr5z586Jyi4uLpXP4TWE5nZltVqNq1evom3btrWKT5OTkxOeeuopvP3222jfvr1RxwaAy5cvS7YVy1kh9vHxgYeHh+ixRpcvX651fERERERERLqYPMn19vbGn3/+iSeffBKpqamVSWpF0vrPP/8gJSVFa9+KNgBE/Ro2bIhNmzZJnlErR2pqqqgsJ8EFoDWW69evGz3JPXv2LLy8vIw6ZlWa1wOo3TWpmuRev35ddlxERERERET6MOl25QqhoaE4cOAAOnToIFqRrfgSBEHrl7Y2Xbt2xbFjx9CpUyejxHb79m1R2d/fX9Y4vr6+krr09HRZY+liygQXkF4PwHjXxBTXg4iIiIiIqCqzJLlA+bNsExMTsWLFCrRs2VKUzALipFdb8tumTRv8+OOPiI+PR/PmzY0WV2Zmpqjs7u4uaxw3NzdJXVZWlqyxLEnzegDGuyb18XoQEREREVH9YvLtylUpFAqMGDECw4cPR1JSEv766y/8/fff+Oeff5CRkYGMjIzK7cgNGzZEcHAwIiIi0KtXL3Tv3t0kMRUVFYnKFc/2NZS2foWFhbLGsiTN6wEY75rUx+tBRERERET1i1mT3AoKhQKdOnVCp06dav0IoNrSTOpUKnmXRNvpxvXxubDaklxjXRN9rkdRUZHWGIiIiIiIiPRh0u3Kv/zyC1q2bIlp06YhKSnJlFPJVlZWJirLfRSPtn5qtVrWWJakeT0A410Tfa7H7Nmz4eHhgeLiYllzEhERERGRbTNpkjtr1iwkJyfjv//9Lzp37owHH3wQx44dM+WUBrO3txeVS0tLZY2jbZXS0dFR1liWpHk9AONdE32ux9SpU3Hv3j04ODjImpOIiIiIiGybyZLcxMREXLp0SXSAVHp6Otq0aWOqKWXRTLzkriBaS5KrLWZjXRN9roejo6Psg66IiIiIiIhMluQeOXJEVFYoFHj88cfh7Oxsqill8fDwEJXz8vJkjZObmyupc3V1lTWWJWleD8B416Q+Xg8iIiIiIqpfTJbk5uTkSOqCgoJMNZ1s3t7eonJ2drascbT1k/t8WUvSvB6A8a5JfbweRERERERUv5gsyW3ZsqWkLi0tzVTTydakSRNRWW6M2vrVx6RO83oAxrsm9fF6EBERERFR/WKyJPeJJ55A48aNAaDyvty4uDgUFBSYakpZgoODReXU1FRZBy1dv35dUteiRQvZcVmK5vUAgBs3bhg8TklJCW7duiWqq4/Xg4iIiIiI6heTJbkuLi747rvvYGdXPoVCocCdO3fw5ptvmmpKWdq1aycql5aWIjk52eBxLly4ICr7+fnBx8enVrFZgre3t2TFVfN708fly5cljyPSvNZERERERETGZtJHCD399NPYvn07GjVqVHnC8uLFixETE4OjR4+acmq9denSRVInJzbNPuHh4bJjsrSuXbuKysa4HgDQqVMn2TERERERERHpQ2XqCR5//HGcP38eM2fOxIIFC1BYWIjt27dj+/bt8PHxQY8ePdCuXTt4eXmhYcOGUKkMD+mFF16QHZ+Pjw9CQ0Nx+vTpyrpdu3ZhxIgReo+Rn5+PAwcOiOr69OkjOyZLi4yMxJYtWyrL+/fvR2FhIZycnPQeY8eOHaJyaGgoGjVqZLQYiYiIiIiItDFpkuvl5SUqq9XqyvtzAeDu3bvYvHkzNm/eXKt5apPkAkBMTIwoyd2wYQO+/fZbvZO69evXo7CwUFQXHR1dq5gsKSYmBm+//XZlOT8/H5s3b8azzz6rV//79+9j06ZNkjGJiIiIiIhMzaTblbOzs0VfJSUlEAQBCoWi8qtiG7PcL2PQTJIzMzOxcOFCvfqWlpZi9uzZorqIiAi0adPGKLFZQuvWrSVblmfPng21Wq1X//nz5+PevXuVZYVCgbFjxxo1RiIiIiIiIm1MmuQCECW0FeXqXjf0y1jatm0r2V48bdo0JCQk1Nh30qRJOHPmjKhuypQpRovNUt544w1R+fjx43p9X3v37sX06dNFdf3790dISIhR4yMiIiIiItLG5ElubVdqTb2KW2H27NmVJ0EDQGFhIfr374/t27drbV9cXIxJkybh+++/F9U//PDDeOaZZ3TOFRkZKUnY9+zZU+vvwZiGDx+ODh06iOrmzZuHyZMno6SkRGuf2NhYPP300yguLq6sU6lUmDNnjkljJSIiIiIiqmDSe3L13d5aF3Tp0gXvvvuuKCHLzMxEdHQ0+vfvj+HDhyM4OBj3799HYmIiFi1ahMuXL4vGcHd3x7Jly8wduknY2dlh2bJl6N69u+h+46+//hqxsbEYP348OnfuDFdXV1y5cgUrV65EbGys5MOHTz75BG3btjV3+EREREREZKNMfrpyffLJJ5/g9u3bWLp0aWWdIAh6HY7l5OSENWvWoGXLliaO0nw6dOiAP/74A4MGDUJRUVFl/aVLl/DOO+/U2H/MmDF6tSMiIiIiIjIWk29Xrk/s7OywZMkSvPfeewY9yiggIABxcXGIiooyYXSW8eSTTyI2NhZNmzbVu49SqcT777+PxYsXG/XeaSIiIiIiopowydVgZ2eHOXPm4NixYxgyZAhcXFyqbevv748PPvgAp0+fRq9evcwYpXk9/vjjOHfuHD744AM0b9682nYqlQpDhgzBoUOHMGvWLCa4RERERERkdgrB2Cc46amoqAgHDx7EoUOHcOnSJaSlpeH+/ftQqVRwc3NDs2bN0Lp1a/Tq1QutW7e2RIgAgIKCAsTHxyMlJQVpaWlQqVTw8fFBp06dEBYWJjqsylYkJSXh/PnzuH37NgoKCuDp6YmWLVuie/fucHNzM8ocjo6OogOsKjg4OIi2ThMRkYHc3YHc3MqiIwDp37aAA4DKv23d3ICcHNPHVtfx2snD6yYPrxtRJUNzA7Pfk3v06FHMnz8f69evx/379/Xq07x5c7z00kt45ZVX4OPjY+IIxZydndG3b1+zzlnXdezYER07drR0GERERERERBJmW4a8c+cOnnnmGXTr1g0rVqxAXl5etY8E0qy/du0aZsyYgeDgYHz22WfmCpmIiIiIiIjqGbMkuceOHUNYWBg2btxYmbhqPidWoVDU+Fpubi6mTp2Kvn37Ii8vzxyhExERERERUT1i8u3KFy5cwGOPPYac/78/oOIwoqort/7+/vDx8YGHhwdKS0tx79493LlzB1lZWZVtqvb766+/8OSTT+Kvv/6Cvb29qb8FIiIiIiIiqidMmuSWlZVhyJAhyMnJESWpSqUS0dHRePHFF9GzZ0/4+flp7X/jxg3Ex8dj6dKl2LVrFwBUruoeOHAA7777Lr766itTfgtERERERERUj5h0u/KiRYtw5swZ0Vbk1q1b48CBA9i4cSOeeeaZahNcAGjWrBlGjBiBP//8E7t27UJgYGDldmZBELBgwQKcPn3alN8CERERERER1SMmTXIXLFhQuYKrUCjQvn177Nu3D127djV4rMjISMTHxyM4OLiyTq1WY/bs2UaLl4iIiIiIiOo3kyW5Fy9exPnz5wGUb1F2cnLC77//Dm9vb9ljNm7cGGvWrIGdnV3laq4hjyIiIiIiIiIi62ayJDcxMbHy/xUKBUaOHImQkJBaj9upUyc8++yzlQdXFRUVISEhodbjEhERERERUf1nsiT39u3bAP53inL//v2NNvagQYNE5QsXLhhtbCIiIiIiIqq/THa6ckFBgaj8wAMPGG3swMBAAP97rFBubq7RxiYiovpLEARkZGQgLy8PDRo0gLe3d+W/FURERGQbTLaS6+XlJSpnZmYabezi4mJR2dfX12hjExFR/ZOdnY158+YhJCQEvr6+CAoKgq+vL0JCQjBv3jxkZ2dbOkQiIiIyE5MluaGhoQD+t9q6b98+o4196tQpAP/bCt2iRQujjU1ERPVLXFwcAgICMHnyZCQnJ4teS05OxuTJkxEQEIC4uDgLRUhERETmZLIkt0ePHvDx8QFQnowuWbLEaNuKly9fXvn/Pj4+6NWrl1HGJSKi+iUuLg4xMTEoKCiofB57VRV1BQUFiImJYaJLRERkA0yW5CqVSrz11lsQBAEKhQK3bt3CK6+8Uutxly1bhoMHD0KhUEChUODll1+GUqk0QsRERFSfZGdnY/DgwRAEAWq1WmdbtVoNQRAwePBgbl0mIiKyciZLcgHg7bffxsMPP1z5SfqqVaswduxYyT21+tq6dSv+9a9/VT4jNyQkBB988IGRoyYiovpg2bJlyM/PrzHBraBWq5Gfny/aDURERETWx6RJrlKpxKZNmxAeHg6gfNvY0qVL0bFjR2zZskXvX0xSU1MxadIkPPXUUyguLoYgCGjcuDE2bNgAR0dHU34LRERUBwmCgPnz58vq+80330i2NRMREZH1UAgm/Jf+wIEDAIC8vDy89dZbOHPmzP8mVijQqFEj9OnTB126dEGzZs3g4eEBBwcH5ObmIjMzE6dPn8ahQ4fw999/V241q+jbs2dPBAcH6x2LQqHAkiVLjPsNksk4OjpqXfF3cHBAUVGRBSIiorokPT29Vifrp6enw9vb24gR1SPu7kCVMzIcAWjbX+UAoPJvWzc3ICfH9LHVdbx28vC6ycPrRlTJ0NzApEmunZ2d6PmEFffnVp1Sn+cXVk1uq46jr4r2ZWVlevchy2KSS0S6XLt2DUFBQbL7X716tfKZ6zaHvzjLx2snD6+bPLxuRJUMzQ1U5ghKM0nVTHx1qThgSrNO39zckGSYiIjqhwYNGtSqv5ubm5EiISIiorrGpPfkaqo4gKrql5w+hiw+874rIiLr4+3tjeDgYIM/yFQoFAgODoaXl5eJIiMiIiJLM+lKbq9evbiSSkRERqdQKDBp0iRMnjzZ4L6vv/46/20iIiKyYia9J5dILt6TS0Q1yc7ORkBAAAry86HW458yOzs7ODs7IyUlBZ6enqYPsK7ifX7y8drJw+smD68bUSVDcwOzblcmIiIyFs/9+7GueXMoBKHGf8zsACjUavzRvDk8///kfyIiIrJOTHKJiKh+ycgARowA+vdH1PnziAXgXEMXZwBbAfQ7fx6IiQGefx7IzDR9rERERGR2THKJiKj+OHkSaNsWWLOmvKxWIwpACgBlNV2UAG4C6Pf/7QEAv/0GtGkDnDpl4oCJiIjI3JjkEhFR/XDyJPDII+UruRrPPfeE7iTXQ7OyrKx8nJ49megSERFZGSa5RERU92VkAH37AvfvSxJc2crKysfr04dbl4mIiKwIk1wiIqr7Jk3SuoJbaxUrupMmGXdcIiKqMwRBQHp6Oq5du4b09HTw4TLWj0kuERHVbbGxwKpVxk9wK5SVAStXAlu3mmZ8IiKyiOzsbMybNw8hISHw9fVFUFAQfH19ERISgnnz5iE7O9vSIZKJMMklIqK6bfZswM7E/1wpleXzEBGRVYiLi0NAQAAmT56M5ORk0WvJycmYPHkyAgICEBcXZ6EIyZSY5BIRUd11+jSwf///TkU2lbIyID4eOHPGtPMQEZHJxcXFISYmBgUFBRAEQbI9uaKuoKAAMTExTHStEJNcIiKqu1auBFQq88ylUpXPR0RE9VZ2djYGDx4MQRCgruEDUrVaDUEQMHjwYG5dtjJMcomIqO46dAgoLTXPXGVl5fMREVG9tWzZMuTn59eY4FZQq9XIz8/H8uXLTRwZmROTXCIiqpsEATh61LzzHTlS/l8iIqp3BEHA/PnzZfX95ptveOqyFWGSS0REdVNuLpCTY945c3KAvDzzzklEREaRkZGBK1euGJysCoKAK1euIJPPTLcaTHKJiKhuKi62rXmJiKhW8mr5IWVubq6RIiFLY5JLRER1k4ODbc1LRES10qBBg1r1d3NzM1IkZGlMcomIqG5ycwPc3c07p7s7UMtfkoiIyDK8vb0RHBwMhUJhUD+FQoHg4GB4eXmZKDIyNya5RERUNykUQJcu5p2va9fy/xIRUb2jUCgwadIkWX1ff/11g5NjqruY5BIRUd3VrZv5npOrVJbPR0RE9daLL74IFxcX2Nnpl+bY2dnBxcUFL7zwgokjI3NikktERHXXiBHme05uaWn5fEREVG95enpi3bp1UCgUNSa6dnZ2UCgU+OOPP+Dp6WmeAMksmOQSEVHdFRoKREQAen4iL5tSCfTsCbRrZ9p5iIjI5KKiohAbGwtnZ2ed7ZydnbF161b069fPTJGRuTDJJSKium3qVECtNu0cZWXl8xARkVWIiopCSkoKlEql1teVSiVu3rzJBNdKMcklIqK6LSYGGD68fLXVFJTK8m3K0dGmGZ+IiCzC09NTZ5Lr4eFh5ojIXJjkEhFR3Td/PuDtbfxEV6ksH3f+fOOOS0RERBbDJJeIiOo+b29g507A1dV4ia5SWT7ezp0An41IRERkNZjkEhFR/RAWBsTHG2dFt2IFNz6+fFwiIiKyGkxyiYio/ggLA86dA4YOrd04w4aVj8MEl4iIyOowySUiovrFywv49VeghkdDaGVnB8TGAitWcIsyERGRlWKSS0RE9ZNKZXgfV1eeokxERGTlmOQSERERERGR1WCSS0RERERERFaDSS4RERERERFZDSa5REREREREZDWY5BIREREREZHVYJJLREREREREVoNJLhEREREREVkNJrlERERERERkNZjkEhERERERkdVgkktERERERERWg0kuERERERERWQ0muURERERERGQ1mOQSEREREZF1OX0amDYNKCnR/npJSfnrp0+bNy4yCya5RERERERkHWJjgZ49gbAw4PPPAUHQ3k4Qyl8PCytvv3WreeMkk2KSS0RERERE9VtGBjBiBNC/P5CQUF5XWqq7T8XrCQlATAzw/PNAZqZp4ySzYJJLRERERET118mTQNu2wJo15WW12rD+Fe1/+w1o0wY4dcq48ZHZqSwdQF127tw5LF++HPHx8bh06RKysrKgVCrh7++PsLAwPPnkkxgxYgQ8PDwsEl9ZWRk2b96MTZs24dChQ7h16xZycnLg6uqKwMBAdOvWDYMHD0a/fv2gUChkzbFnzx4sWLCg1rG++OKLGDBgQK3HISIiIiKqdPIk8MgjwP37QFlZ7cYqKytfEe7ZE4iPL9/KTPWSQhCq26huu9LS0vDaa69h7dq1NbZ1c3PDhx9+iClTpsDOznwL4zt27MCECROQnJxcY9sOHTrg+++/R/fu3Q2e57333sNnn30mJ0SRzz//HG+//bbe7R0dHVFcXCypd3BwQFFRUa3jISIr4O4O5OZWFh0BSP/WABwAVP6t4eYG5OSYPra6jNdNPl47eXjd5OF1q1lGRvkKbkZGtQmuXtdNk1IJeHsD584BXl7GiZVqxdDcgNuVNZw8eRIdOnTQK8EFgNzcXLzzzjsYMGAACgoKTBxduTlz5qBfv356JbgAcOLECfTq1QtLliwxeK7jx48b3IeIiIiIyOQmTdKZ4MpWsaI7aZJxxyWzYZJbRXJyMnr37o20tDTJa6GhoYiOjkZERAQ8PT0lr2/duhXPPfccTL0w/vXXX2Pq1KmSeldXV/To0QMxMTHo0KGDZFW5pKQEL7/8MtZU3KugpxMnTtQqXiIiIiIio4uNBVatMn6CW6GsDFi5kqcu11NMcv9faWkphgwZgkyNE9UGDhyIS5cu4dSpU4iNjUV8fDxu3bqFxYsXS+7F3bJlC+bNm2eyGA8ePIh33nlHVOfs7Iwvv/wSaWlpOHDgALZs2YKkpCQkJydjzJgxoraCIGDcuHG4ceOGXvOlpqbizp07orqUlBQIgmDwlyFblYmIiIiIdJo9GzD1rYJKZfk8VO8wyf1/CxculGzNnTx5MtavX4+WLVuK6p2cnDB27FgkJiaicePGotdmzpyJe/fuGT0+QRAwadIklFY5Ct3Z2Rl//fUXJk+eDFdXV1H75s2bY8mSJfj2229F9bm5ufjoo4/0mlPzevj6+uKBBx6Q+R0QERERERnB6dPA/v2Gn6JsqLKy8gOozpwx7TxkdExyARQVFWHmzJmiul69emHu3Lk6+wUHB2PLli2wt7evrMvMzKyxnxwbNmzA0aNHRXULFiyo8TCpiRMnYsqUKaK6ZcuW4eLFizXOmZSUJCp36tRJv2CJiIiIiExl5UpAZaaHxKhU5fNRvcIkF8C6detw9+5dUd2cOXP0euxOeHg4JkyYIKpbtGgR1Eb+ZGnhwoWicuvWrfHSSy/p1XfWrFnw9/evLJeVleGHH36osZ/mSi6TXCIiIiKyuEOHgCq7G02qrKx8PqpXmOQCWL16tagcGhqKHj166N1/4sSJovKdO3ewd+9eo8QGAOnp6di5c6eobty4cXo/+9bZ2RmjR48W1a1bt67GflzJJSIiIqI6RRAAjd2NJp/vyJHy/1K9YfNJbklJCXbv3i2qGzBggEFjtG7dWnLfrj5JpL527NghObXZ0Bg121+7dg2JiYnVts/NzZU8oohJLhERERFZVG6u+Z8FnJMD5OWZd06qFZtPcpOSkpCn8abt2bOnweM8/PDDovKePXtqE5ZIfHy8qOzr64tWrVoZNEaXLl3g4OAgqtMVY1JSkiixbtCggSSRJyIiIiIyq+Ji25qXZLH5JPeMltPSOnToYPA4YWFhovLZs2dRUFAgO66qNGOUE5+joyNCQkJEdbpWcjXvx9X27F0iIiIiIrPSWLSx+nlJFpvPWs6dOycqu7i4yHpMjuYqp1qtxtWrV2sVWwXNGA1dxa2gGePly5erbVvd/bgZGRmYP38+Bg0ahMDAQLi6ulau8kZHR2PBggW4efOmrPiIiIiIiHRycwPc3c07p7s70KCBeeekWrH5JDc1NVVUlvscWM3n5QLA9evXZY1VVWlpqeTkZ2PFqCs+zSS3WbNmmDRpEh544AG8/vrr2LBhA65fv478/Hzcv38fV65cwbZt2zBp0iS0bNkS7777rkmeF0xERERENkyhALp0Me98XbuW/5fqDZtPcm/fvi0qV33UjiF8fX0ldenp6bLGqiotLU1y6JSxYszIyJCMDZQfxqW5RXrq1KlYsGABioqKapynsLAQn3/+Obp166ZztZiIiIiIyGDdupnvOblKZfl8VK/YfJKbmZkpKrvL3P7g5uYmqcvKypI1VlWa8QHGi7GsrAy5ubmSdmfPnkWxxs31ZWVllf9vb2+PNm3a4IknnkCfPn3QunVrrfNduHAB3bp1w4ULF2TFS0REREQkMWKE+Z6TW1paPh/VKzaf5GquTLq4uMgaR1u/wsJCWWNVpW3l1NQxah46VcHb2xufffYZUlNTcfbsWWzbtg07duzAuXPncPPmTUybNk0yR2ZmJgYOHIgcPY96Lyoq0rstEREREdmg0FAgIgIw9aGoSiXQsyfQrp1p5yGjY5KrkUSqZG59UCqVkrqSkhJZY1WlLck1dYya9+MCQPfu3XH8+HG888478PHxkbzepEkTfPLJJ0hISEBAQIDotfPnz2PGjBl6xTh79mx4eHhIVpKJiIiIiCpNnQqo1aado6ysfB6qd2w+ya26DRfQngjqQ1s/tRF+8DTjq24ufegbo5ubG9q1a1e5KhsSEoJt27ahadOmNc7Rvn17xMbGwtnZWVS/cOFCySFf2kydOhX37t2TPNOXiIiIiKhSTAwwfHj5aqspKJXl25Sjo00zPpmUzSe59vb2onKpzP392lZEHR0dZY1VlWZ8gOljnDlzJk6fPo379+/j1q1bOHDgADw9PfWep3379nj33XdFdYWFhVi5cmWNfR0dHWXfc0xERERENmT+fMDb2/iJrlJZPu78+cYdl8zG5pNczSRP7jZZUyW52sYwZ4yNGjXSuj25JpMmTZJsq/7zzz8NHoeIiIiISCtvb2DnTsDV1XiJrlJZPt7OnYCXl3HGJLOz+STXw8NDVM7Ly5M1jrZTil1dXWWNVZVmfIBxY5R7iFVNvL29ER4eLqo7fPiwSeYiIiIiIhsVFgbExxtnRbdiBTc+vnxcqrdsPsn19vYWlbOzs2WNo62f3OfZVqUZX3Vz6UOzn5eXl9bt0MbSvn17UfnevXt6PWeXiIiIiEhvYWHAuXPA0KG1G2fYsPJxmODWezaf5DZp0kRUTktLkzWOtn7GSHI9PT0lK8LGitEY8emiLUHPyMgw6ZxEREREZIO8vIBffwU0Dj/Vi50dEBsLrFjBLcpWwuaT3ODgYFE5NTVV1sFO169fl9S1aNFCdlxVBQUFico3btyQNY5mjMaKrzraToY2xhZuIiIiIiKt5Dxq09WVpyhbGZtPcttpPNy5tLQUycnJBo9z4cIFUdnPz0/WgU3aaMaoOZe+NPtpjquN3JOcAemqrUql0nqPMRERERERkbHYfJLbpUsXSd3Ro0cNHkezj+ahS7XRtWtXUTkpKcng5POff/7BnTt3RHXaYly5ciV69eqF1q1bw8vLCw4ODjh79qzhQQM4efKkqPzggw/KGoeIiIiIiEhfNp/k+vj4IDQ0VFS3a9cug8bIz8/HgQMHRHV9+vSpdWwVIiMjReWCggIkJCQYNMaOHTtEZYVCgccee0zSTq1WY9++fbhw4QKysrIgCILke9NHZmYmkpKSRHWPPPKIweMQEREREREZwuaTXACIiYkRlTds2IDCwkK9+69fv17SPtqI+/rDw8PRuHFjUd3q1asNGmPVqlWi8kMPPQRfX19Ju86dO0vqDJ0LABYuXCi5J3fAgAEGj0NERERERGQIJrkAXnjhBVE5MzMTCxcu1KtvaWkpZs+eLaqLiIhAmzZtjBafQqHAyJEjRXVLly5FSkqKXv0TEhKwc+dOUd24ceO0tm3Tpg3CNI5N37VrFw4ePKh3vDdu3MAXX3whqmvZsiWefPJJvccgIiIiIiKSg0kugLZt20q2F0+bNk2vLcGTJk3CmTNnRHVTpkwxanwAMHHiRNEzbfPz8/Hss8/WuOKclpaGESNGiOr8/f0xfPjwavuMHz9eUjdmzBi9ns977949PPvss5K2H374IRQKRY39iYiIiIiIaoNJ7v+bPXs27Oz+dzkKCwvRv39/bN++XWv74uJiTJo0Cd9//72o/uGHH8Yzzzyjc67IyEgoFArR1549e3T2CQwMxIQJE0R1Bw8eRHR0dLXPzb1w4QL69OmDa9euiepnzpyp81E+EyZMkJy8fO7cOfTu3RuXL1+utt+pU6fQq1cvHD58WFQfHR2NUaNGVduPiIiIiIjIWGQ8SMo6denSBe+++y7mzJlTWZeZmYno6Gj0798fw4cPR3BwMO7fv4/ExEQsWrRIkvC5u7tj2bJlJovx008/xbZt20Tz7t69G23btsWYMWPw2GOPwc/PD6mpqdiyZQtWrFiB/Px80RjR0dHVblWuoFKpsGzZMkRGRiIvL6+yPikpCW3btsWIESMQExODoKAgFBcXIzk5GZs3b8Yff/whOfU5MDAQP/30kxG+eyIiIiIiopopBEEQLB1EXaFWqzF27FgsXbrU4L5OTk7YsGEDoqKiamwbGRmJv//+W1S3e/duySnK2ly7dg2RkZG4fv26wTGGh4dj586daNiwoV7td+zYgYEDB0oSZX0FBQXhzz//RMuWLQ3u6+joiOLiYkm9g4MDioqKZMVDRFbG3R3Iza0sOgKQ/q0BOACo/FvDzQ3IyTF9bHUZr5t8vHby8LrJw+smD6+bVTI0N+B25Srs7OywZMkSvPfee1Cp9F/kDggIQFxcnF4Jbm0FBgZiz5496NGjh0H9nnrqKfz11196J7gA0LdvXxw5ckRyEJU+Bg4ciMOHD8tKcImIiIiIiORikqvBzs4Oc+bMwbFjxzBkyBC4uLhU29bf3x8ffPABTp8+jV69epktxsDAQOzfvx8//fST1kf+VNWjRw/8/vvv2LhxIzw8PAyeq23btjh+/DhWrlyJbt26ie5b1mRvb48BAwZg165dWL9+PXx8fAyej4iIiIiIqDa4XbkGBQUFiI+PR0pKCtLS0qBSqeDj44NOnTohLCxMZ9JnLjdu3MDRo0dx+/ZtZGVlwc3NDQEBAejRo4fk+bq1lZWVhYSEBNy8eRMZGRlQq9Xw8vJCq1at8NBDD6FBgwZGmYfblYmoRtySJg+vm3y8dvLwusnD6yYPr5tVMjQ34MFTNXB2dkbfvn0tHYZOzZo1Q7NmzcwyV8OGDREdHW2WuYiIiIiIiAxl+WVIIiIiIiIiIiNhkktERERERERWg0kuERERERERWQ0muURERERERGQ1mOQSERERERGR1WCSS0RERERERFaDSS4RERERERFZDSa5REREREREZDWY5BIREREREZHVYJJLREREREREVoNJLhEREREREVkNlaUDICIiKUEQkJGRgby8PDRo0ADe3t5QKBSWDouIiIiozuNKLhFRHZKdnY158+YhJCQEvr6+CAoKgq+vL0JCQjBv3jxkZ2dbOkQiIiKiOo1JLhFRHREXF4eAgABMnjwZycnJoteSk5MxefJkBAQEIC4uzkIREhERkS0RBAHp6em4du0a0tPTIQiCpUPSC5NcIqI6IC4uDjExMSgoKIAgCJJ/RCrqCgoKEBMTw0SXiIiITKa+7yxjkktEZGHZ2dkYPHgwBEGAWq3W2VatVkMQBAwePLjO/wNDRERE9Y817CxjkktEZGHLli1Dfn5+jQluBbVajfz8fCxfvtzEkREREZEtsZadZUxyiYgsSBAEzJ8/X1bfb775pt7cG0NERER1mzXtLGOSS0RkQRkZGbhy5YrByaogCLhy5QoyMzNNFBkRERHZEmvaWcYkl4jIgvLy8mrVPzc310iREBERka2ytp1lTHKJiCyoQYMGterv5uZmpEiIiIjIVlnbzjImuUREFuTt7Y3g4GAoFAqD+ikUCgQHB8PLy8tEkREREZGtsLadZUxyiYgsSKFQYNKkSbL6vv766wYnx0RERESarG1nGZNcIiILe/HFF+Hi4gI7O/3+Srazs4OLiwteeOEFE0dGREREtsDadpYxySUisjBPT0+sW7cOCoWixkTXzs4OCoUCf/zxBzw9Pc0TIBEREVk1a9tZxiSXiKgOiIqKQmxsLJydnXW2c3Z2xtatW9GvXz8zRUZERES2wJp2ljHJJSKqI6KiopCSkgKlUqn1daVSiZs3bzLBJSIiIqOzpp1lTHKJiOoQT09PnUmuh4eHmSMiIiIiW2EtO8tUlg6AiIiIiIiI6oaKnWU+Pj4oKyuTvF6xs6wuf/DOlVwiIiIiIiKqVN93ljHJJSIiIiIiIqvBJJeIiIiIiIisBpNcIqK64vRpYNo0oKRE++slJeWvnz5t3riIiIiI6hEmuURElhYbC/TsCYSFAZ9/DgiC9naCUP56WFh5+61bzRsnERERUT3AJJeIyFIyMoARI4D+/YGEhPK60lLdfSpeT0gAYmKA558HMjNNGycRERFRPcIkl4jIEk6eBNq2BdasKS+r1Yb1r2j/229AmzbAqVPGjY+IiIionmKSS0RkbidPAo88Ur6Sq+X5cwYpKysfp2dPJrpERERUe1ZwRgiTXCIic8rIAPr2Be7fr32CW6GsrHy8Pn24dZmIiIjksaIzQpjkEhGZ06RJxlnB1VSxojtpknHHJSIiIutmhWeEMMklIjKX2Fhg1SrjJ7gVysqAlSvr5CeqREREVAdZ6RkhTHKJiMxl9mzAzsR/7SqV5fMQERER6WLFZ4QwySUiMofTp4H9+w3/hNRQZWVAfDxw5oxp5yEiIqL6y8rPCGGSS0RkDitXAiqVeeZSqcrnIyIiItLGys8IYZJLRGQOhw7VfIiDsZSVlc9HREREpMkGzghhkktEZGqCABw9at75jhyp/uh/IiIisl02cEYIk1wiIlPLzQVycsw7Z04OkJdn3jmJiIiobrORM0KY5BKRyQiCgPT0dFy7dg3p6ekQbHVlsbjYtuYlIiKiuslGzghhkktERpednY158+YhJCQEvr6+CAoKgq+vL0JCQjBv3jxkZ2dbOkTzcnCwrXmJiIiobrKRM0KY5BKRUcXFxSEgIACTJ09GcnKy6LXk5GRMnjwZAQEBiIuLs1CEFuDmBri7m3dOd3egQQPzzklERER1lw2dEcIkl4iMJi4uDjExMSgoKIAgCJLtyRV1BQUFiImJsZ1EV6EAunQx73xdu5b/l4iIiAiwqTNCmOQSkVFkZ2dj8ODBEAQB6hoOM1Cr1RAEAYMHD7adrcvdupnvHhilsnw+IiIiogo2dEYIk1wiMoply5YhPz+/xgS3glqtRn5+PpYvX27iyOqIESPMdw9MaWn5fEREREQVbOiMECa5RHrgKcG6CYKA+fPny+r7zTff2Mb1DA0FIiLM81y6nj2Bdu1MOw8RERHVLzZ0RgiTXCIdeEqwfjIyMnDlyhWDk1VBEHDlyhVkZmaaKLI6ZupU8zyXbupU085BRERE9Y8NnRHCJJeoGjwlWH95tTxQIDc310iR1HExMcDw4eWrraagVJZvU46ONs34REREVL/ZyBkhTHKJtOApwYZpUMttKG5ubkaKpB6YPx/w9jZ+oqtUlo8rc9s4ERER2QAbOSOESS6RBp4SbDhvb28EBwdDYeB2FIVCgeDgYHh5eZkosjrI2xvYuRNwdTVeoqtUlo+3cydgS9eSiIiIDGMjZ4QwySXSwFOCDadQKDBp0iRZfV9//XWDk+N6LywMiI83zopuxQpufHz5uERERES62MAZIUxyiargKcHyvfjii3BxcYGdnp8M2tnZwcXFBS+88IKJI6ujwsKAc+eAoUNrN86wYeXjMMElIiIifdjAGSFMcomq4CnB8nl6emLdunVQKBQ1Jrp2dnZQKBT4448/4OnpaZ4A6yIvL+DXXwFnZ8P72tkBsbHAihXcokxERESGsfIzQpjkElXBU4JrJyoqCrGxsXCuIWlzdnbG1q1b0a9fPzNFVsfJOeXQ1ZWnKBMREZE8Vn5GCJNcoip4SnDtRUVFISUlBcpq/sJUKpW4efMmE1wiIiIiS7LiM0KY5BJVwVOCjcPT01Nnkuvh4WHmiIiIiIhIwkrPCGGSS1QFTwk2gtOngWnTgJIS7a+XlJS/fvq0eeMiIiIiIikrPCOESS6RBp4SLFNsbPnz0MLCgM8/B6o7vEsQyl8PCytvv3WreeMkIiIiIikrOiOESa4O586dw9SpU/HII4+gUaNGcHR0hIuLC4KCgvDUU09h4cKFuHfvnsXiKysrw4YNGzBmzBi0a9cOXl5eUKlU8PDwQIcOHTB+/HjExcUZ7bE2ubm5WLhwIQYPHoygoCC4ubnBwcEBvr6+ePjhhzF16lScOnXKKHNZEk8JNlBGRvkx8f37AwkJ5XWlpbr7VLyekFB+jP3zzwM2fDI1ERERERmRQBK3b98WhgwZIgCo8cvNzU34/PPPhbKyMrPG+OeffwotWrTQK8YOHToICQkJsudSq9XCvHnzBHd3d73mGzRokJCSklKr78/BwUHr2A4ODrUa1xDbt28XXF1ddX6vrq6uQlxcnNliqnNOnBAEPz9BUCoFoXyNtvLLoZpr5qDRTgDK+/v5CcLJk5b+jizDzc3wa+fmZumoLY/XTR5eN/l47eThdZOH100eXjf56vC1MzQ34EquhpMnT6JDhw5Yu3atXu1zc3PxzjvvYMCAASgoKDBxdOXmzJmDfv36ITk5Wa/2J06cQK9evbBkyRKD5yoqKsKgQYPwxhtvICcnR68+69evR3h4OI4cOWLwfHUJTwmuwcmTwCOPlK/klpXVbqyysvJxevYErGA3ABERERFZDpPcKpKTk9G7d2+kpaVJXgsNDUV0dDQiIiK0bkvdunUrnnvuOaNtDa7O119/jalTp0rqXV1d0aNHD8TExKBDhw6SbbYlJSV4+eWXsWbNGr3nEgQBw4YNw8aNGyWv+fv7IzIyElFRUQgODpa8fufOHURFReHixYt6z1fnnD4Nz88+g1Kt1vqyUq2Gx3//a5sHKGVkAH37Avfv1z7BrVBWVj5enz7cukxERERE8pllfbkeKCkpETp16iRZAh84cKBw6dIlUduCggJh8eLFgoeHh6T9V199ZbIYExISBJVKJZrP2dlZ+PLLL4W8vDxR22vXrgljxoyRxOfm5iZcv35dr/m++OILSf+mTZsKGzdulGzPPnz4sNCjRw9J+06dOsnaym3R7cpbtghCRET5FgyVSvdWDZWqvF1EhCDExpo+trpi+HCtW5QN3uKi7UupFIQRIyz9HZpXHd4eVKfxusnD6yYfr508vG7y8LrJw+smXx2+dobmBkxy/98333wjuWiTJ0/W2efy5ctC48aNRX28vLyE7Oxso8enVquFLl26iOZydnau8V7bb7/9VvJ9jRkzpsb5UlNTJfejhoSECHfv3q22T0lJiTBixAjJfMuXLzf4+7VIkpueXp68AYJgZ2fYD3hF+xEjBCEjw3Qx1gVbtuhOUg25brq+bOlDgzr8j0qdxusmD6+bfLx28vC6ycPrJg+vm3x1+NrxnlwZioqKMHPmTFFdr169MHfuXJ39goODsWXLFtjb21fWZWZm1thPjg0bNuDo0aOiugULFqB79+46+02cOBFTpkwR1S1btqzGbcRz5szB/fv3K8v29vbYuHEjfHx8qu2jUqnw888/o0ePHqL6GTNmoKS6Z6bWFSdPAm3bAhXbuavZolytiva//Qa0aWPd95XOnl3+TDRTUirL5yEiIiIiMhCTXADr1q3D3bt3RXVz5syBQqGosW94eDgmTJggqlu0aBHUhiZJNVi4cKGo3Lp1a7z00kt69Z01axb8/f0ry2VlZfjhhx+qbZ+fn4/ly5eL6l566SW0adOmxrkcHBywYMECUV1ycjLi4uL0itUieICS/k6fBvbvN/xDAEOVlQHx8cCZM6adh4iIiIisDpNcAKtXrxaVQ0NDJauRukycOFFUvnPnDvbu3WuU2AAgPT0dO3fuFNWNGzdOryQcAJydnTF69GhR3bp166ptv337dmRnZ4vqxo8fr9dcQHni361bN1GdvqdVmx0PUDLMypXyHhQuh0pVPh8RERERkQFsPsktKSnB7t27RXUDBgwwaIzWrVujZcuWojpdSaShduzYITm12dAYNdtfu3YNiYmJWttqrro2adIEnTt3rtV8mzZtqptblidNMs4KrqaKFd1Jk4w7rqUdOgSUlppnrrKy8vmIiIiIiAxg80luUlIS8vLyRHU9e/Y0eJyHH35YVN6zZ09twhKJj48XlX19fdGqVSuDxujSpQscHBxEddXFqDlfRESEQXMB0uuRlZWFkydPGjyOScXGAqtWGT/BrVBWVr4SuXWracY3N0EANO4LN/l8R46U/5eIiIiISE82n+Se0XLPX4cOHQweJywsTFQ+e/YsCgoKZMdVlWaMcuJzdHRESEiIqE7bSm5JSQkuXbpU6/k0r0d181kUD1AyTG4ukJNj3jlzcgCND6GIiIiIiHSx+ST33LlzorKLiwseeOABg8fR3K6sVqtx9erVWsVWQTNGQ1dxK2jGePnyZUmby5cvS7YVy5nPx8cHHh4eNc5nMTxAyXDFxbY1LxERERHVSzaf5KamporKchJcAGjcuLGk7vr167LGqqq0tFRy8rOxYtQWn+b1MPV8FsMDlAynsd3d6uclIiIionrJ5pPc27dvi8pVH7VjCF9fX0ldenq6rLGqSktLkxw6ZawYMzIyJGNrXg9jzmeM62E0PEDJcG5ugLu7eed0dwcaNDDvnERERERUr5lpKavuytR4xIu7zF/i3dzcJHVZWVmyxqpKMz7AeDGWlZUhNzdXNJ4p5zPG9TAKSxygdPhw+b2lej72qc7q1An4+2/zzRceDuTnm28+S5FzuJYglD+qypbxusnD6yYfr508vG7y8LrJw+smnxUd9mnzSW5RUZGo7OLiImscbf0KCwtljVWVZnzVzaWP6mKsmsSacj59rkdRUZHWGIzKSAcoqQEcM2ROLR+EWLPq7nY26Lrt2WOTK7l6Xbu8PJu8NrrwusnD6yYfr508vG7y8LrJw+smn4lPrjEpJrkaCZVK5n2aSqVSUmeM58JqS/hMGaMp59PnesyePRsfffSRrPn0ZuBBRv8BUAbgFoAfqtSXAjDs6cEE8LrVBq+dPLxu8vC6ycdrJw+vmzy8bvLwuhlu/EsvoXGzZuW/43/wgaXD0cnmk9wyjWekaksE9aGtn9oIJ/dqxlfdXPrQJ0ZTzqfP9Zg6dSqmTJkCX19fFJvqVF0DDzKq+BHOB/Cv2swbFwe4utZmhLrhlVeAU6dMO4dCAYSGAgsXmnYeIiIiItJL644d4VJPfpe1+STX3t5eVC6VeRiRtlVKR0dHWWNVpRkfYNoYq5tPzmqu5nz6XA9HR0ejXDedKg5QMnDLsguAcLlzursDffvW/3tygfLn/vbvb9o5BAGYMweIiDDtPERERERkdWz+dGXNhEru6qGpklxtY5gyRlPOZ/LkVV8KBdCli3nn69rVOhJcAIiJAYYPB2Su8NdIqQRGjACio00zPhERERFZNZtPcj08PETlvLw8WePk5uZK6lyNsJyvGR9g3Bg1D4cy5XzGuB5G062b+Z6Tq1SWz2dN5s8HvL2Nn+gqleXjzp9v3HGJiIiIyGbYfJLr7e0tKmdnZ8saR1s/uc+XrUozvurm0odmPy8vL8n2ZFPOZ4zrYTQjRpjvObmlpeXzWRNvb2DnzvJ7jI2V6CqV5ePt3Al4eRlnTCIiIiKyOTaf5DZp0kRUTktLkzWOtn7GSOo8PT0lK6DGilFbfJrXw9TzWUxoaPn9nnYm/hFQKoGePYF27Uw7jyWEhQHx8cZZ0a1YwY2PLx+XiIiIiEgmm09yg4ODReXU1FRZBztdv35dUteiRQvZcVUVFBQkKt+4cUPWOJoxaotP83rIna+kpAS3bt2qcT6LmjoVMMIJ2DqVlZXPY63CwoBz54ChQ8vLhia7Fe2HDSsfhwkuEREREdWSzSe57TRW2EpLS5GcnGzwOBcuXBCV/fz84OPjU6vYKmjGqDmXvjT7aY4LlG9X1lxxlTPf5cuXJY8j0jafRfEAJePw8gJ+/RWIjQV69CivU6mqP2hLofjf/dA9epT3W7GCW5SJiIiIyChsPsntouWU3aNHjxo8jmaf8HDZD5uR6Nq1q6iclJRk8GrzP//8gzt37ojqqotRcz5jXA8A6NSpk8HjmBwPUDKe6Ghg3z7g9Gng3XeBxx4rf3RSVe7u5fXvvlvebt8+6/8QgIiIiIjMyuaTXB8fH4SGhorqdu3aZdAY+fn5OHDggKiuT58+tY6tQmRkpKhcUFCAhIQEg8bYsWOHqKxQKPDYY4/pNd/+/ftRWFhYq/lCQ0PRqFEjg8YwCx6gZHzt2gGffFL+/Wdnlz+POD29/L/Z2eX1n3xinfcpExEREZHF2XySCwAxMTGi8oYNGwxK6tavXy9pH23E1anw8HA0btxYVLd69WqDxli1apWo/NBDD8HX11drW83rkZ+fj82bN+s91/3797Fp0yadY9YpPEDJdBQKwM2t/Jq4uVnPs4KJiIiIqM5ikgvghRdeEJUzMzOxcOFCvfqWlpZi9uzZorqIiAi0adPGaPEpFAqMHDlSVLd06VKkpKTo1T8hIQE7d+4U1Y0bN67a9q1bt5ZsWZ49ezbUeh7SNH/+fNy7d6+yrFAoMHbsWL36WgwPUCIiIiIisgpMcgG0bdtWsr142rRpem0JnjRpEs6cOSOqmzJlilHjA4CJEyeKnmmbn5+PZ599tsYV57S0NIzQeEarv78/hg8frrPfG2+8ISofP35cr+9r7969mD59uqiuf//+CAkJqbGvxfEAJSIiIiKieo9J7v+bPXs27Ko8M7WwsBD9+/fH9u3btbYvLi7GpEmT8P3334vqH374YTzzzDM654qMjIRCoRB97dmzR2efwMBATJgwQVR38OBBREdHV/sc2wsXLqBPnz64du2aqH7mzJmSZ+9qGj58ODp06CCqmzdvHiZPnoySkhKtfWJjY/H000+juLi4sk6lUmHOnDk656pzeIASEREREVG9pRAEQbB0EHXF1KlTJQmZQqFA//79MXz4cAQHB+P+/ftITEzEokWLcPnyZVFbd3d3JCYmomXLljrniYyMxN9//y2q2717t+TAJ015eXno1KmTZF4vLy+MGTMGjz32GPz8/JCamootW7ZgxYoVyM/PF7WNjo7Gli1boNDj3sgTJ06ge/fuktXikJAQjB8/Hp07d4arqyuuXLmClStXIjY2Fppvp//+97949913a5xLk6OjoyhZruDg4ICioiKDx6s1QQDy8oDiYsDBAWjQgPeXEhERERGZgaG5AZPcKtRqNcaOHYulS5ca3NfJyQkbNmxAVFRUjW3lJrkAcO3aNURGRuL69esGxxgeHo6dO3eiYcOGevfZtm0bBg0aJCuxHDNmDBYvXqxXQq2pziW5RERERERkEYbmBtyuXIWdnR2WLFmC9957D6qKey31EBAQgLi4OL0S3NoKDAzEnj170KPinlE9PfXUU/jrr78MSnAB4Mknn0RsbCyaNm2qdx+lUon3339fdoJLREREREQkF5NcDXZ2dpgzZw6OHTuGIUOGwMXFpdq2/v7++OCDD3D69Gn06tXLbDEGBgZi//79+Omnn9C5c2edbXv06IHff/8dGzduhIeHh6z5Hn/8cZw7dw4ffPABmjdvXm07lUqFIUOG4NChQ5g1axYTXCIiIiIiMjtuV65BQUEB4uPjkZKSgrS0NKhUKvj4+KBTp04ICwsTHVZlKTdu3MDRo0dx+/ZtZGVlwc3NDQEBAejRo4fk+brGkJSUhPPnz+P27dsoKCiAp6cnWrZsie7du8PNzc0oc3C7MhERERERAbwnl6wEk1wiIiIiIgJ4Ty4RERERERHZMCa5REREREREZDWY5BIREREREZHVYJJLREREREREVoMHT1GdpOvxQw4ODmaMhIiIiIiILEnboVMVtKWzTHKpTuIzdomIiIiIqCba0lluVyYiIiIiIiKrwSSXiIiIiIiIrAaTXCIiIiIiIrIaTHKJiIiIiIjIaqgsHQCRoSx5unJxcTFPdyaz4nuOzInvNzI3vufInPh+q790na6sDU9XJtJTTk4OPDw8cO/ePbi7u1s6HLIBfM+ROfH9RubG9xyZE99vtoXblYn05OjoiOnTp8PR0dHSoZCN4HuOzInvNzI3vufInPh+sy1cySUiIiIiIiKrwZVcIiIiIiIishpMcomIiIiIiMhqMMklIiIiIiIiq8Ekl4ioDigqKsJvv/2GiRMnonPnznjggQfg7OwMV1dXNGvWDD169MA777yDuLg48CgFModvvvkGCoWi8mvGjBmWDomIiEgvPHiKqBrnzp3D8uXLER8fj0uXLiErKwtKpRL+/v4ICwvDk08+iREjRsDDw8PSoVI9Vlpairlz5+LLL7/EnTt39OrTtm1bfPzxxxg8eLCJoyNbde7cOXTu3BkFBQWVddOnT2eiS7VWWlqKrVu3YvPmzTh69CiuXbuGvLw8uLi4wMfHB507d8Zjjz2G559/Hm5ubpYOl+qxsrIybNq0CX/++ScSEhJw+/ZtZGZmwtXVFd7e3ggNDUVkZCSGDRuGRo0aWTpcMjImuUQa0tLS8Nprr2Ht2rU1tnVzc8OHH36IKVOmwM6OGyPIMDdv3sSQIUNw8OBBWf0nTJiAefPm8cH2ZFQlJSXo3r07jh07Jqpnkku19euvv2LatGm4ceNGjW3d3d0xbdo0vPPOO/z3lQz222+/Ydq0aUhOTq6xraOjI8aOHYs5c+bwgxUrwiSXqIqTJ0+iX79+SEtLM6hfdHQ01q5dC2dnZxNFRtYmMzMTPXv2xLlz5ySv2dvbo0OHDmjUqBGKi4tx7do1XLx4Ues4zz//PFasWGHqcMmGTJs2DbNnz5bUM8kluQoLC/HSSy9h9erVBvd97LHHsHnzZri4uJggMrI2arUar732GhYuXGhw31atWmHDhg1o06aNCSIjc2OSS/T/kpOT0bVrV2RmZkpeCw0NRbNmzXDv3j2cOXMG2dnZkjb9+/fHpk2boFAozBAt1Xf9+/dHbGysqM7f3x8zZszAqFGj4OrqKnrt+vXr+Oyzz7Bw4ULJPbmff/453n77bZPHTNYvPj4ejz76KNRqteQ1JrkkR3FxMfr3748dO3ZIXvPw8ECnTp3g7u6OO3fu4NixYyguLpa069evH7Zt28YVXarRG2+8gW+++UZSr1Kp0KFDBzRp0gT5+fk4deqU1luEHnjgARw4cADNmjUzR7hkSgIRCSUlJUKnTp0EAKKvgQMHCpcuXRK1LSgoEBYvXix4eHhI2n/11VeW+QaoXtm2bZvkvRMaGiqkpKTU2Hfjxo2Cvb29qK+bm5uQlpZmhsjJmuXk5AhBQUGS92bF1/Tp0y0dItVDEydOlLyXGjduLPzyyy9CcXGxqG1OTo4wa9YswdHRUdJn/vz5FvoOqL7YuHGj5H2jVCqFf//730J6erqorVqtFmJjY4WQkBBJn4iICAt9B2RMTHKJBEH45ptvJH/JTZ48WWefy5cvC40bNxb18fLyErKzs80UNdVXffr0kSSpycnJevfX9n79+OOPTRgx2YLRo0dXm+AyySU5du7cKXkfde7cWbh165bOfvHx8YKLi4uon7e3t1BYWGimyKm+UavVwoMPPih6z6hUKmHTpk06+927d0/o0qWL5H26Zs0aM0VOpsJ9H2TzioqKMHPmTFFdr169MHfuXJ39goODsWXLFtjb21fWZWZm1tiPbNvdu3exe/duUd3EiRMRFBSk9xgTJ05EixYtRHWbN282Snxkm9avX4+lS5dWltu3b48mTZpYLiCyCu+8846oHBQUhO3bt9d4km1ERITk3+WMjAxs2LDB2CGSlTh69CguXLggqnv33XcxYMAAnf3c3d2xdu1aODk5ieqXL19u9BjJvJjkks1bt24d7t69K6qbM2eOXvfWhoeHY8KECaK6RYsWab2fjQgA9u7di7KyMlHd0KFDDRpDqVTiqaeeEtUlJSXx+bkky+3btzF+/PjKsoODA3755RfRB3hEhvrrr79w/PhxUd3SpUvh4+OjV/8JEybA3d1dVLdz506jxUfWZdeuXaKyQqHAa6+9plff5s2bY+DAgaK6v/76y1ihkYUwySWbp3naY2hoKHr06KF3/4kTJ4rKd+7cwd69e40SG1mfs2fPisoODg7o0KGDweNoruSWlJRoPTSNqCZjxoxBenp6Zfnjjz9G+/btLRgRWYMlS5aIygMGDECvXr307u/i4oKoqCi4uLigWbNm6NSpExwdHY0dJlmJlJQUUdnX1xeNGzfWu3+XLl1E5fz8fGRlZRklNrIMlaUDILKkkpISydbRmra2aGrdujVatmyJy5cvV9atW7cOkZGRxgiRrEx4eDgmTZqEW7duITU1FWVlZbJODC0sLDRBdGRrvvvuO2zbtq2yHBERIdliSmSo0tJSyenxkyZNMnic3377jU8sIL3k5+eLyqWlpQb117ZzpaioqFYxkWUxySWblpSUhLy8PFFdz549DR7n4YcfFiW5e/bsqW1oZKViYmIQExNT63HOnDkjKjs6OsLb27vW45LtuHDhgiihbdCgAZYvX87HtFCtHT58GPfu3assN2zYEL179zZ4HCa4pC8/Pz9ROTMzEzdu3ND7UUCnTp0SlZ2dnfXeWk91E/8lI5ummSgAkLV1NCwsTFQ+e/YsCgoKZMdFpEtRUZFklaRdu3YWiobqo9LSUowcOVK0+jF37lzJNngiOQ4dOiQqd+3aFSoV11XIdLp27Sqp++677/Tqm56ejt9//11U16tXL75n6zn+6ZFNO3funKjs4uKCBx54wOBxWrZsKSqr1WpcvXoVbdu2rVV8RNr8/PPPonsoAUgOoiLS5eOPP8bRo0cry9HR0aLDp4hqIykpSVTW9uHx7du3ERcXhxMnTuDOnTtwdHRE48aN0alTJzzxxBNwdXU1U7RkDaKjo+Hl5SU6m+LLL79EZGQknnjiiWr7FRUVYcSIEaKdBwDwxhtvmCxWMg8muWTTUlNTRWU5CS4ArYcbXL9+nUkuGd3du3fxwQcfiOrs7OwwfPhwC0VE9c3Bgwfx6aefVpa9vb0lhwQR1UbV23cAoGnTppX/f+rUKUyfPh2bNm2SnDRfwcnJCePHj8eMGTPQsGFDk8ZK1sHZ2Rmffvqp6IkXJSUlGDBgAKZNm4Y333xT8l6Kj4/HG2+8gWPHjonqR48ejSeffNIscZPpcLsy2bTbt2+Lyv7+/rLG8fX1ldRprrQR1ZZarZachAsAI0aMQKtWrSwUFdUn9+/fx8iRI0XJxcKFC2t8bimRIa5duyYqV7y/PvnkE3Tq1Anr16+vNsEFyg/W++abb9CqVSvEx8ebMlSyIv/617/w5ptviupKS0vx8ccfw8/PD127dsVTTz2FqKgoBAQE4JFHHpEkuOPGjcMPP/xgxqjJVLiSSzZN85Erms/k05ebm5ukjkfPk7G999572LJli6jOy8sLn332mYUiovrmzTffxJUrVyrLzz//PJ599lkLRkTWSPODOBcXF7z66qt63yNZdZy+fftizZo1Bj/5gGzTV199hfDwcLz99tu4c+dOZX1paanoFg1NERERmD59Ovr27WuOMMkMuJJLNk3zeHgXFxdZ42jrx0e8kDHNmjULX3zxhahOoVDgp59+MuhZgGS7Nm3ahMWLF1eWAwICsGDBAgtGRNYoLy8PxcXForoffvhBlOA2bNgQM2bMwLFjx3Dv3j3k5eXh1KlTmDNnjuSU3MLCQjz//PO4cOGCWeKn+m/UqFFISEiQPPu2OnZ2dvD19YWDg4OJIyNzYpJLNk0zyZV7kp5SqZTUlZSUyBqLSNPs2bMl9+ECwEcffYSnn37aAhFRfXPnzh2MGzeusqxQKPDzzz/D09PTckGRVdJ8XilQ/gFLhb59++Ly5cuYPn06OnXqBHd3d7i6uiI0NBTvvfceLl68KLkfMjc3F8OGDYMgCCaPn+q327dvY9y4cWjVqpXOlduq1Go1NmzYgMjISDz33HOSQ6iofmKSSzZN854gbcmqPrT1U6vVssYiqiAIAt5++21MmzZN8tqrr76qNfEl0mbcuHG4e/duZfnVV19Fnz59LBgRWSvNVdyqevfujdjYWHh5eVXbxsPDAxs3bsQjjzwiqk9KSsKGDRuMFSZZoUOHDqFTp05YsmSJ6Pe7fv36YdWqVbhx4waKioqQkZGBhIQEvP/++5IP+n7//Xf06NFDtNWZ6icmuWTT7O3tReXS0lJZ42hbtXV0dJQ1FhFQ/p4aPXo05s6dK3ntlVdewfz58y0QFdVHP/zwAzZv3lxZfvDBB3kfN5lMdR/wurm5YdWqVZJ/d7Wxt7fHL7/8Itk++tVXXxklRrI+ly5dQnR0tOhAUVdXV6xbtw5xcXEYNmwYmjZtCgcHB3h5eaF79+6YNWsWrly5Itk5cO7cOQwcOFDn4WhU9zHJJZummYjq+gRaFya5ZEyZmZno27cvli9fLnntrbfewnfffQeFQmGByKi+uXz5MqZMmVJZVqlUWL58OZydnS0YFVmz6pLYf/3rXwY9waB58+YYOnSoqC4hIQF5eXm1io+s08svvyw6TFSlUmHz5s145plndPbz8vLCli1b0L9/f1F9QkICFi5caJJYyTyY5JJN8/DwEJXl/uOZm5srqeOD7EmOS5cuoXv37vj7778lr82ZM0dy+BRRdcrKyjBy5Ejcv3+/sm7atGl46KGHLBgVWbvqPkAZNGiQwWNpJh6lpaU4cOCArLjIeu3du1fyb+a7776L3r1769Xfzs4Ov/76q+TQs88//5y3ntVjfIQQ2TRvb29ROTs7W9Y42vrJfeYu2a49e/Zg8ODBkkdb2dvbY/HixXjhhRcsFBnVR+vWrcOhQ4dEdSdOnMCQIUP06l/1Hl4AWLNmDU6fPi2qe+211xAZGVmrOMm6eHh4QKVSSW7/0fek25r6/PPPP7JjI+u0atUqUdnR0RHvvPOOQWO4u7tjypQp+Pe//11Zd+PGDSQkJCAiIsIocZJ5Mcklm9akSRNROS0tTdY42voxySVDLF++HOPGjZNsfff09MQff/yh9yfSRBW0nXK7ceNG2eOdO3cO586dE9VprrQRKRQK+Pr64tatW5V1Hh4esh7P4uvrK6nTfAYvUUJCgqjcs2dPWSfHDxo0SJTkAuWHWTHJrZ+4XZlsWnBwsKicmpoq6/Cp69evS+patGghOy6yLXPnzsXo0aMlCW5QUBAOHDjABJeI6hXNf//kPlLPyclJUqf56D8izd/BHnzwQVnjtGrVSvJhDHcO1F9McsmmtWvXTlQuLS1FcnKyweNoPqTez88PPj4+tYqNbMPs2bPx9ttvS57/2L17dxw6dAht2rSxUGRERPK0bt1aVM7Pz5d1O1BWVpakTvMsDSLN81RcXFxkj6W5Alz1TAOqX5jkkk3Tdr+Pvg8P19UnPDxcdkxkO+bPn6/1GbgDBw7EX3/9pXWrHpG+Ro8eDUEQZH81b95cNN706dMlbUaPHm2Zb47qtG7duknqzpw5Y/A4V69eldRp7sAiatiwoah88+ZN2WNpfhjDBYv6i0ku2TQfHx+EhoaK6nbt2mXQGPn5+ZLTHvv06VPr2Mi6bdmyBW+++aak/uWXX8a6dev4iBciqre03WKxbt06g8fRdpJyx44d5YREVqxRo0ai8vHjx2WNc+HCBcmjJBs3biw7LrIsJrlk82JiYkTlDRs2oLCwUO/+69evl7SPjo42SmxknW7cuIGRI0dKHk3wyiuv4IcffoCdHf9qJqL6q2XLlpLbgdasWWPws+hXrFghKoeFhSEgIKDW8ZF10TwY6vz580hMTDR4nD/++ENSx9Pj6y/+JkU2T/OxLJmZmXo/ALy0tBSzZ88W1UVERPA+StLpX//6F+7duyeqi4mJwYIFCywUERGRcY0bN05UvnnzJubPn693/82bN+PYsWOiulGjRhklNrIuTz31lKTuww8/NGiMrKwsfPnll6K6wMBAhIWF1So2shwmuWTz2rZtK9lePG3aNMmR9NpMmjRJcp/RlClTjBofWZft27dj+/btorrGjRtj+fLlXMElIqsxduxY+Pn5ieref/997N+/v8a+N27cwMsvvyyq8/DwwNixY40aI1mHqKgoSTK6detWfPXVV3r1LykpwbBhwySPp5o6darRYiTz429URCg/4bZqglFYWIj+/ftLkpEKxcXFmDRpEr7//ntR/cMPP4xnnnnGpLFS/fbf//5XUnfr1i14e3tDoVDU6uvatWvm/4aIiLRwc3PD559/LqorKirCE088gV9//bXafomJiXjkkUckz5//8MMP4eXlZZJYqX6zs7OTvNeA8kWHiRMnan1meIXr16/j8ccfx59//imqDw0NxZgxY4weK5mPQtB8bgWRjZo6dSrmzJkjqlMoFOjfvz+GDx+O4OBg3L9/H4mJiVi0aBEuX74sauvu7o7ExES0bNnSnGFTPXLr1i00adLEZONfvXoVgYGBJhufbEtgYKDo+ZPTp0/HjBkzLBcQ1UuvvPKK5ANhAOjatSteeOEFhIeHw8HBAVevXsX69euxZs0alJWVidr26dMHcXFx3O1COs2YMQMfffSRpN7DwwOjRo1Cz549ERgYiLKyMly7dg1xcXFYvXq15F5xb29vHD58WPK8Z6pfmOQS/T+1Wo2xY8di6dKlBvd1cnLChg0bEBUVZfzAyGqsXr0aw4cPN9n4THLJmJjkkjEIgoA333wT33zzjaz+Dz30EOLi4iTPLyXSZvLkyfj6669l92/UqBE2btyIhx56yHhBkUXwIzGi/2dnZ4clS5bgvffeg0ql0rtfQEAA4uLimOBSjVJSUiwdAhGRWSkUCsybNw/ff/+9wduNR48ejV27djHBJb199dVX+PXXXyXPztVH7969kZiYyATXSnAll0iLU6dO4eOPP8bWrVurvZfD398f48ePx1tvvQUPDw8zR0hERFS/ZGRk4LPPPsPvv/+Oq1evam2jUqkQFRWFqVOnSh4NQ6Sv3NxcfPvtt1i6dCkuXLhQbTsnJydERkbi7bffxuOPP27GCMnUmOQS6VBQUID4+HikpKQgLS0NKpUKPj4+6NSpE8LCwnh/EBERkQwnT57ExYsXcevWLeTk5MDd3R0hISHo1q2brFU4ouqkpqbi8OHDuHPnDjIyMuDg4ABfX180b94c3bt3h6Ojo6VDJBNgkktERERERERWg8tQREREREREZDWY5BIREREREZHVYJJLREREREREVoNJLhEREREREVkNJrlERERERERkNZjkEhERERERkdVgkktERERERERWg0kuERERERERWQ0muURERERERGQ1mOQSERERERGR1WCSS0RERERERFaDSS4RERERERFZDZWlAyAiIsvJyclBREQEBEEAAAwdOhQffPBBte3HjRuHgwcPAgAaNGhQ+f9EREREdQVXcomIbNjx48dx+vRpnDlzBmfOnIGPj4/O9ps2bapsq1Qqq22nUChEX0uXLjVy5GQrRo8eLXovRUZGWjoki8vPz7d0CEREdRqTXCIiG3bs2DFRuXPnztW2/eeff3D37l292hKR8aWkpOCZZ57B77//bulQiIjqNCa5REQ2LDExsfL/VSoV2rdvr1dbAAgPDzdZXET0P6WlpZg7dy7atGmD9evXV95eQERE2vGeXCIiG1Z1JbdNmzZwcnLSqy3AJJfIXMLDw3Hq1ClLh0FEVG9wJZeIyEbl5+fjwoULleWaktaqSa6TkxPatm1rstiI6H+Y4BIRGYZJLhGRjUpKSoJara4s13SPbdUkt3379lCpuBmITG/p0qUQBKHya8+ePZYOiYiI6jgmuURENsqQe2xv376NW7du6dWWiIiIyJKY5BIR2aiqK7N2dnbo2LFjtW156BQRERHVF0xyiYhsVNUkt1WrVnB1ddWrLcAkl4iIiOou3lBFRGSDioqKcPbs2cqyIYdO2dvbIywsrNYxXLhwASdOnMCtW7dw//59eHp6olWrVujevTsaNGhQ6/ErXLx4EadOncKdO3eQlZUFLy8v+Pv7o3PnzmjWrJnR5gGA3NxcHDlyBGlpacjMzER2djaUSiXc3d0REBCAsLAwBAUFGXVO0u3evXs4cuQIrly5gqysLKhUKvj4+MDPzw9du3aFr6+vUedKSEhASkoKMjIyYG9vDz8/PzRr1gzdu3eHg4OD0eaqjStXriAxMRF3797FvXv34OnpCT8/P4SFheHBBx80yZwpKSk4cOAArl+/jpKSEnh6eqJ169bo2rUr3NzcjDaPWq3G0aNHkZycjLS0NBQUFMDPzw+NGzdGjx494OnpaZR5zPm+IiIZBCIiskrTp08XAJjl6+rVq6K5NV//+eefBUEQhNLSUmHBggVCmzZtqh3L0dFRGD58uHDmzBnZ33tWVpbw/vvvCy1bttQZd2hoqPDFF18IhYWFsudKTU0VZsyYIXTt2lVQKpU1XqugoCBh+vTpQkZGRrVjZmRkCI6OjqJ+EydOlBXf+fPnJTGsWLFCUKvVQmBgoKj+wQcflDWHWq0WmjVrJhprxowZssbS9OKLL4rGffTRR/WK59dffxV69+4t2NnZVftnoVAohI4dOwofffSRcPfuXVnxlZaWCr/99psQERGh88+/QYMGwsCBA4UDBw7UOObu3bsN+vnT55qkpaUJ//nPf4SmTZvqHCswMFB49913DboemvE+/vjjla+dOHFC6Nevn6BQKLTO5+TkJAwfPlw4e/as3vNpc+HCBWH06NGCt7d3td+bSqUSHn30UeGPP/6QNYc531dEVDtMcomIrFRdS3LPnTsnhIWF6T2mvb298PXXXxv8ff/www+Cl5eXQfE3b95c+PPPPw2ap6ysTJg1a5bg7Ows65p5eXkJW7ZsqXb8Z599VtTex8dHKC4uNvh6vP/++6Jx3N3dhfz8fEEQBOHDDz+UxHX06FGD59BMchQKhZCcnGzwONoYmuTeunVL6N69u8F/Hh4eHsLSpUsNii0pKUlo166dwXMNHDhQZ/Jj7CT3m2++Mfh96u7uLnz55Zd6XYfqktxly5YJDg4Oes2nUqmEGTNmCGq1Wu/rLwiCUFRUJLz++uuCSqUy6PuLiIgw6D1qzvcVEdUek1wiIitVl5LciRMn6lxh0fX1/fff6/X9lpWVCZMnT5b9PahUKuGHH37Qa67S0lJhyJAhtb5u9vb2wqFDh7TOsXXrVkn7zZs36xVfBW2rtePHj698/cqVK5IVtsmTJxs0hyAIwpgxY0Rj6LOyqC9Dktz09HQhKCioVn8m3377rV5x/frrr3oncNq+WrRoUe3qpbGS3JKSEmHQoEG1uh4vvviiUFRUpPNaaEtyV65cWe3qra6vkSNH6p3oZmVlCY8++qjs783Pz6/an7+qzPm+IiLjUAiCIICIiKzOmjVrsGbNGq2vbdu2Dfn5+QAALy8v9O7du9pxTp8+jQsXLlSWn3jiCckhVQsXLhTdg6ZQKHTG9thjj+HZZ59FWFgYnJ2dcfv2bezevRs//vgj7t27J2rr6uqKK1euwN/fX+eYb731Fr788ktJ/UMPPYQhQ4agc+fO8PT0RGZmJk6ePInffvsNhw8flrRfu3YtBg8erHOu6dOn4+OPPxbVKRQK9O/fH9HR0XjwwQfh6emJ0tJSpKenIykpCWvWrEFSUpJkrPDwcMnp1QBQVlaGZs2aITU1tbJu6NChWL16tc7Yqtq7dy8effRRUV1CQgK6d+9eWX700Uexd+/eynLjxo3xzz//QKlU6jVHYWEh/P39kZOTU1n3008/4aWXXtI7Tl1Gjx6NZcuWieKt7lm5zz77LNauXSuqa9euHUaMGIFOnTrB19cXSqUS6enpOHr0KH7++WdcunRJ1N7JyQnnzp1DYGBgtTH9+eef6N+/P0pKSkT1np6eGDZsGPr27YuAgAAUFxcjOTkZmzdvxvr161FWViZq7+/vj2PHjqFJkyai+jNnzmD69OmV5XXr1ole79KlC5o3by76Hj/66CNJnJrXrkL79u0xfPhwhIeHw8fHB+np6Th+/DhWrlyJkydPStqPGjUKy5cvr/Z67NmzR/R3SFBQEG7fvo2CgoLKuujoaAwfPhwhISEoLCxEUlISfvrpJ63z/ec//8HMmTOrnQ8ASkpK8Mgjj+DQoUOiejs7Ozz11FPo378/QkJC4OrqirS0NMTHx2PlypW4fv26qL2HhweOHTuGFi1aVDuXud5XRGREls6yiYjIvIqKigR7e/vKFYbhw4frbF9126y9vb1e96+imtUMb29vnduCb968KbRv317Sb86cOTrn27Rpk6SPp6ensHbtWp39fvvtN8HNzU3Uz8PDQ7hy5Uq1fW7cuCFZwfP29tbrXsvly5drXf07ceKE1vb//ve/Re2cnZ2FnJycGuepMG7cOFF/bffc/vTTT5J4duzYofccq1evFvV1cXERcnNz9e5fE31Xci9fviz5Pt544w2htLS02rGLioqE8ePHS/rpWs2+ceOG0KBBA0mf5557TucW5BMnTmh9b0dERAglJSU6r4Fmn4p73HX56quvJP2cnJyEH3/8sdqVUrVaLfzwww+Ck5OTpO93331X7Vy6Vp69vLyErVu3au1XVlYmzJ49W7Liq1Qqa9w2P2XKFMlcbdu2rfZnSRAEobCwUPjggw8k/bp06VLtarW53ldEZFxMcomIbExiYqLoF6/PPvtMZ/vg4ODKth06dNBrDm2/7DZs2FCve+AuX74sSsIB8UE2moqKioQmTZpIEtVTp07pFevhw4cFV1dXUX9dib9m4glAiI2N1WsuQRCETz75RNL/iy++0Nr2woULkrb63t9XWFgoeHh41PhhQW5uruT7Hz16tN7fT0xMjKjvqFGj9O6rD32T3Llz50oS+rKyshrHLysrEx566CFR32bNmlXb/uWXX5b8mfzrX//Sa4ttdna2ZC4AwpIlS3T2MzTJzcnJkdwe4OjoKOzevbvGGAWhPGnVPPjM3d1dyMrKqra9tp95Dw8P4dixYzXOt2DBAknfJ598str2J0+elCTGHTt21PsDoO+++04y36JFi7S2Ndf7ioiMi8/JJSKyMZrPvO3UqVO1be/du4fk5OTKcm2ej/vZZ5/p9fic4OBgDBgwQFR34sSJatuvWrVKtKUXABYtWoTQ0FC94uratSs+/fRTUd3vv/+OGzduaG3/+++/i8o9e/ZEdHS0XnMBwJgxYyR1KSkpWtu2atUKDz/8sKju119/1WueTZs2ibZ+K5VKjBo1StKuQYMGku3Zf/zxBwoLC2uc4+7du4iLixPVjR49Wq/4jO3q1auicocOHWBnV/OvOXZ2dnjzzTcrywqFAmq1GpmZmZK2165dw88//yyq69ixI+bPn1/jFn2gfGvs6tWrJY/M+e9//wu1Wl1jf33NmzcPGRkZorpZs2YhMjJSr/6RkZH45JNPRHU5OTn49ttvDYrjq6++0vn3S4VXX30V/fv3F9Vt27YNly9f1tr+yy+/hFDlbjsnJyesX79e70cRvfLKKxg0aJDOMSuY431FRMbHJJeIyMYcP35cVNb1S+jx48dFv/h17txZ1px+fn4G3aOpeR9penp6tUnXwoULReUOHTpg6NChBsX38ssvi56fWVpaqvUexJKSEgwbNgzDhg3DQw89BB8fH7zwwgsGzdWoUSM0bNhQVJeXl1dte83r9tdff+HWrVs1zvPLL7+IylFRUZJ7PytoJqY5OTnYvHlzjXOsWrUKpaWlleVmzZrpvL/blDSfQXvkyBFRbLo8+eST2LJlC86dO4eCggL8888/8PLykrT7448/JGPOnj0b9vb2escZFBSE1157TVR38eJF0X3RtaV5L/4DDzyAyZMnGzTGm2++iaZNm4rqfvzxR737d+zY0aCfeW33FK9atUpSd+/ePUn9+PHjDb7X9d133xWVL1y4gP3790vameN9RUTGxySXiMjGVE1ymzVrBm9v72rbah6IJHcl99FHH9X7ICMAokN1KlQ92KhCXl4ejh49KqozNMEFAGdnZzz++OOiOm1Jh729PWbNmoVVq1bh0KFDuHv3Ll5++WWD59NccSouLq627dChQ+Hi4lJZLisrq/HwqfT0dGzfvl1Up2uFNTIyUpIk6LNirJlIv/DCC3qtaJpCSEiIqHz16lU8//zzyMrKqrGvp6cnYmJi0Lp1azg6Olbb7q+//hKVmzZtin79+hkc6/jx4yV1f//9t8HjaHP37l2cPn1aVDd69GiDfv6A8pX/sWPHiuquX78uObipOob+XISHhyMsLExUt3PnTkm7AwcOoKioSFQ3bNgwg+YCgG7duokOywO0/8yb431FRMbHJJeIyIao1WrRaaY1bSWsurVZqVSiQ4cOsuZt06aNQe3d3d0lddpWchMSEiQn1spdbda8FgcPHjTqFlIAyMjIwOrVqyUnSOuax83NTbKdeMWKFTrnWb16tejkXy8vLzz11FPVtlcoFJIV6W3btuncWnn+/HnJBwwvvviizrhMafDgwZJEYs2aNQgKCsLYsWOxfv16rR+U6EsQBEkS9Oijj+q1dVVTYGCg5EOFffv2yY6tqr1790q23cpdXde2vVnfOKOiogyeT3Nr/pEjRyTfS3x8vKisUCj02hKtSaFQSP4+07aSa+r3FRGZhsrSARARkflcuHAB9+/fryzXtDJbNcl98MEHRSuKhqjp8T+atK0GaksEz5w5I6n7/PPP8cMPPxg0H1B+v2VVubm5SE9Ph5+fn8Fj5eTkIDk5GcnJyTh//jzOnDmDxMREXLx4Uet9f9rqqnrppZdEq6bHjh3D+fPn0bp1a63tNVdYR4wYUeNK0osvvoiZM2dWxlJcXIy1a9dqXXXUNkdERARatmypcw5T8vX1xRtvvIHPPvtMVH/v3j389NNP+Omnn6BSqdC9e3c88cQTiIqKQufOnfVeeb537x5yc3NFdbW5R71Lly6i95y+K6Q1+eeffyR1cuPU9oGRPnF6enoiODjY4Pk6duwoKhcUFCAlJUW0bVrzZ16lUmHkyJEGzwWUbxOvSvP+W8D07ysiMg0muURENsSQ+3Hv378v+iWwNr/QOzs7y+6ri7aVRm1bHGszfk1JblZWFtavX4+DBw/i9OnTuHTpEtLT040WA1C+ohYUFCT6JXzFihWYNWuWpO3Fixclz//V597IFi1aoGfPnqKVul9//VVrkisIgmQ7s6UOnKpq9uzZuHTpEtavX6/19dLSUsTHxyM+Ph7/+c9/4O/vj5iYGAwePBh9+/bVeW+t5kFOQPn91XJpvq+MdSCRZpwODg6Se8D11aBBA7i4uFQ+UxvQL85mzZrJms/Hx0dSl5aWJkpyNecvKSmRPEdYruq+N1O+r4jINLhdmYjIhhiS5CYlJYlWT2uT5JpqVcPUJ5Xquu8uNTUVY8aMQePGjTF27Fj8+OOPSEhIqDHBVSqVBt8fqVAoJFuBV65cqbWt5gpr+/bt9f6z00xU9+3bp/WU6b1794pW9JydnfHcc8/pNYcp2dnZYd26dVi4cKFeB/ykpaXhp59+QkxMDB544AF8/PHHKCgo0NpWW5Lr4eEhO1bNvllZWTWu6OtDM87axKitvz4/c3Ln1Nav6s4TfeeXq7qfd1O+r4jINJjkEhFZqRkzZkChUIi+vvjiC1Gbpk2bStpUfPXs2VPUdsqUKdW21dzqay66DmwyBs0DbirExcWhdevW+Pnnn6ttU1XTpk3x3HPPYdGiRbh58yYCAgIMjmX06NGiDwuuXr0quYdQEATJ/bqGrLA+99xzcHV1FY2n7YRbzUR60KBBWu+jtgSFQoEJEyYgJSUFv/zyCwYMGAAnJ6ca+929exfTp09H27ZttT66Rtt2+dokpZon9CqVSqN8GKQZZ20TZ804VaqaNwFqnkgsdy5t85nyZ17X2KZ6XxGRaTDJJSKieqvqY3+A8l+u1Wo1BEEwype2g3f27t2L/v37S+7PBMoPzHrsscfw+uuvY+HChfjrr79w9+5d3LhxA7/99hvGjx8Pf39/WYlH8+bN8dhjj4nqNLcM79u3T/SBg729vUH3KzZo0ADPPPOMzjkKCwuxdu1aUV1d2KqsydnZGSNHjsSmTZuQkZGBLVu24PXXX0e7du109rt27Rr69OmDu3fviuq1reDV5sAhzcPH5N7vrkkzztoeiiQnTm0/G3LmAqQnkWv+zPft29doP+/6/Fwa+31FRKbBJJeIiOotzV/oi4uLcfv2bZPNV1BQgBdeeEGy4vTwww9j165dyMzMxK5duzBv3jxMmDABvXv31nqfodyti5r31q5Zs0YUi+YqbkxMjOQxKTXRTFhPnToleiRNbGysKBkJCAiQPH6prnFxcUFMTAzmzZuH06dP49atW1ixYgWGDh0qWrmucP36dcn9ztrua63Ne03zWceGHs5WHc04i4uL9XrcjTaZmZmS1U194pS7pTgtLU1Sp3l/r+bPvLEO7JLDGO8rIjINHjxFRGSl2rZtK3r0THJysuie3EcffVRrAgaUr9bFxsZWloODgyUnn1al7Rc6c9B8DAtQft9x48aNTTLf2rVrJb9UR0dHY9OmTXrfZ1tWViY7CXjmmWfg4eFRmWRmZGTg77//xuOPP155GnJV+hw4pal3795o3ry56Pv8/fffERoaCqA8sa5q1KhRsh6jY0mNGjXC888/j+effx65ubmYMWMGvvzyS1Gb3377DfPmzasse3t7i649IH2OtCE0+7Zo0UL2WFVpO9U4MTERffr0MXgsbd+fPnEmJycjPz/f4NXppKQkUdnf31+ycqv5M5+cnIycnJw6sV1ezvuKiEyDSS4RkZV67rnnRIcBvfPOO6Ikd8WKFdXeG3rgwAFRkvvqq69i8uTJpgtWJs37hoHy+2Wjo6MNHmvv3r24dOlS5TNMmzVrJjkVVdvpql9//bVBB0mdPXtW8mxffZ/H6+zsjKFDh4oekbR+/Xo8/vjj2L59u2jFzs/PT9Z1qHhm7syZMyvr1qxZg48++ggFBQXYunWrqL0ln41blSAIuHHjBs6fP49z587h1Vdf1etUWzc3N8ydOxeXL1/Gpk2bKuvT0tKQnp5e+UGQnZ0devToge3bt1e2+fvvv6FWqw1O8i9evIjU1FRRna4PkQwREREhqdu9e7esJHf37t2SOn3iVKvVOHr0KHr16mXQfJr3mGvr37NnTyxatKiyXFpail27dmHQoEEGzQWUH94mCELlz3zjxo0lf5amfl8RkWnUr49eiYhItqNHj1b+v5+fn87DjzRXcLp06WKyuGojICAAQUFBorpffvnF4HsCBUHAq6++inHjxqFPnz5o2bIl/Pz8JFs1NZ+j6e3tjZCQEIPm0pYoaztwpzqaq7MbN26EIAhYvXq1qH7kyJF6HRKkzYsvvig6BOn8+fM4f/48du7ciby8vMr67t2748EHH5Q1hzElJCSgQYMGCAwMxBNPPIHJkydLThKvyRNPPCGpq/roHECadKWkpCAuLs7geBcvXiyp6927t8HjaOPv749WrVqJ6pYuXSr5YKUmpaWlWLp0qaiuUaNG1T6bWZPm1vma7N+/H5cuXRLVafuQRlvi+9133xk0F1B+Ovro0aMxcuRI9OzZEwEBARgwYICojbneV0RkfExyiYhsgCAIOHbsWGW5pqS1apJrZ2en81FDljZmzBhROSsrC59++qlBY6xcuVJ03ykADBgwQHJKrOZJysXFxXqvwgLl92F+9dVXknpDTozt3r072rRpU1lOSUmRrLwDtTsMKjg4WLJKvm3bNtEqZm3nMKawsDDJNVy+fLlBY2geCGRnZydZbRs1apRkFW/atGkoKSnRe57k5GRJUtaoUSPJoWJVGfrIKc2fidTUVK3vO13mzp0ruW94xIgRevdfuXKl3qeuC4KADz/8UFTXoEEDDBkyRNK2WbNmknvAd+7cqlUeTQAACnNJREFUafCHDdOnT5f8uVW9vQMw3/uKiExAICIiq3f+/HkBQOXXhx9+qLN9aGhoZds2bdoYPF/VuQAIP//8s0H9d+/eLRnj6tWrWttmZGQIrq6uorYKhUJYu3atXnMlJycLXl5ekv6JiYmStn369JHEtXXrVr3myczMFB566CFJfwBCv3799Bqjwn//+19R/y5dukjKtbVkyRLRmH379hWCg4Mry05OTkJWVlat56nJiy++KIrj0Ucf1douOjpa1M7e3l5ISkrSa478/HyhRYsWov5du3bV2vb555+X/PlNmDBBUKvVNc6TnZ2t9T0wa9Ysnf1cXFxE7b/99lud7bOysoQGDRqI+jg6Ogq7d++uMUZBKP/5c3R0FPV3cHAQrly5Um17be/rRx55RCgoKKhxvtmzZ0v6vvvuu9W23759u6S9j4+PcOHCBb2+v/Xr1wsKhULUv1GjRsL9+/clbc31viIi42KSS0RkA1asWCH6RWvTpk3Vtr1//76gVCor244cOdLg+cyZ5AqCIMydO1fSXqlUCrNnzxaKi4ur7Xfw4EEhICBA0nf48OFa23/66aeStgEBATX+cr1jxw5Rgqj51b17d72uS4XU1FTRn5Hm14IFCwwaT5ucnBxRcqVSqURzDB06tNZz6EPfJDcuLk5yHRo1aiTs27dP5/hZWVnCk08+Kem7ePFire2Tk5MFT09PSfuhQ4cKd+/erXaeU6dOCR07dpT0a9WqlVBYWKgzxgceeEDUZ+LEiTrbC4IgfPnll5K5nJychMWLF1ebkKvVamHx4sWCk5OTpO/06dOrnau6JBeAEBkZKaSkpGjtV1RUJEydOlXSx9/fX8jMzNT5/Q0YMEDSz9vbW+ffbYIgCD/99JMkgQcgLFq0SGt7c72viMi4mOQSEdmAyZMni37RSk1Nrbbt/v37RW2//vprg+czd5IrCILw9NNPa/0lOygoSHj//feFrVu3ComJiUJCQoLw888/C08//bRgZ2entX11K5S3bt2SrJABEFxcXIRXXnlF+OOPP4SjR48KiYmJwvbt24VPPvlE6Ny5s6S95spzYGCgQddHEAQhJiZG6/fr6OgoZGRkGDyeNiNHjqw2edF3Bbu29E1yBUEQBg0aJIlToVAIUVFRwrfffivs2bNHOH78uHDo0CFh3bp1wpQpUwRfX19Jn86dOwulpaXVzrN+/Xqt18TT07PyfXD48GFh//79wi+//CI8++yzkg8JAAju7u7C6dOna7wGPXr0EPVzcHAQPv/8c+HIkSPC4cOHhfj4eK39Bg4cqDXO9u3bC3PmzBF27NghJCYmCjt27BA+++wzoUOHDlrbR0VF6bweupJcAIKbm5vw2muvCZs3bxaOHj0q7Nq1S/j000+Fli1bStoqlUrhzz//rPGaZGZmCoGBgVrn69Gjh/Dll18Ku3btEo4fPy7s2bNH+Oqrr7T+LAIQBg0apHMuc72viMh4mOQSEdmARx55pPIXrcaNG+ts+80334h+MatpxUIbSyS59+/f1/rLqCFfzZs3r3FV9vvvv6/VHG+88YawbNkyyS/Md+7cMegarV27Vuv4zz33nEHj6LJz506tczRu3Nhsv6wbkuTevXtXtNVe7nvg2rVrNca1dOlSwcHBQfY8/v7+wuHDh/W6Bu+8847OsRo1aqS1nzF+Jvr37y/k5eXpjE/bz+uzzz5r8FwqlUpYuXKlXtdEEAThypUrQps2bWr1/fXp00fIzc3VOY8531dEZBxMcomIrFxZWZlo9XHAgAE621dNKuzs7Gr8BVcbzV/wzJHkCkL5dsuPP/5Ycg+jPl8xMTHCzZs39Yrv888/17oyp+srODhY2L59uyAIgnDx4kXJ68uWLTPoGhUVFQne3t6ScbZt22bQOLqo1WqhefPmkjl03S9pbIYkuYJQnpBo3kep71e/fv107nLQtG/fPqFVq1YGz/P000/r/V4TBEFIT08XGjVqpHPM6j4kUavVwkcffSQ4OzsbFKOLi4vwxRdfCGVlZTXGV93P69SpU7XultD21aJFC+HAgQN6X5MK2dnZwvDhwyX32Nb0pVKphLfeeksoKirSax5zvq+IqPaY5BIRWbkzZ86IfuH66KOPdLavumLRtm1bWXNq/pJnriS3wu3bt4W3335bcuiLtl90BwwYICsxPHz4sDBw4ECd98aqVCohIiJC+PHHHyW/TGtunQwPDzc4htdff100RpMmTYy+wvqf//xH8n2dOXPGqHPoYmiSW2HLli3CgAEDBHt7e53vAXt7eyEmJkb2hwOlpaXCkiVLhG7duulM6FxdXYXnnntOViInCOX3AmtuW676tWPHDp39U1NThTfeeENo2rSpzusRFBQk/Oc//zFoZ4Gun9d9+/YJjz76aLVJ6IMPPih8/fXXNd6XXJMTJ04II0aMkBwip/nl7u4ujB8/Xq9t4tqY631FRLWjEARBABERWa3ly5fjxRdfrCzHxsZqff4kABQUFMDNza3ymZqjRo0y+JEZdc3ly5dx8uRJ3L17FxkZGXBwcEDDhg3x4IMPonPnznB2dq7V+Dk5OTh8+DAuX76M7OxsKJVK+Pj4ICAgAD169ECDBg2M9J1YxsqVK/H8889Xlrt27YrDhw9bMCLDFBQU4NSpUzh37hyysrKQl5cHlUoFHx8ftGrVCl26dIGLi4tR5srMzERCQgJu376N9PR0AOXPUm7bti3Cw8Ph5ORU6zlOnjyJI0eOIC0tDQDg6emJwMBA9OjRAw0bNtRrjLNnz+LMmTO4c+cOsrOz4eLigiZNmqBjx46ynnu8Z88eyXN+r169isDAQFH5yJEj+Oeff1BWVobGjRujS5cuosdhGYNarcaxY8dw+fJlpKen4969e3B1dYW3tzfat2+P0NBQgx/JpI0531dEZDgmuUREVu7u3buVvxADQEhICBwdHbW2LS4uxsWLFyvLfn5+8PPzM3mMVHc9/fTT2LRpU2V54cKFmDBhggUjorpGnySXiMicVJYOgIiITMvX1xe+vr56tXVwcEBoaKiJI6L6IiMjA9u2bassu7i4YPjw4RaMiIiIqGZ2lg6AiIiI6qbly5ejpKSksjx06FB4eHhYMCIiIqKaMcklIiIiifv372PevHmiuldffdVC0RAREemPSS4RERGJ5OTk4LnnnsP169cr6yIjI9G5c2cLRkVERKQf3pNLRERkw06dOoW3334bbdu2hZOTE1JSUrB161ZkZmaK2s2cOdNCERIRERmGSS4REZEN8/f3x59//ok///yz2jbjx49Hz549zRgVERGRfNyuTEREZMP8/Pzg6upa7eu9evXC119/bb6AiIiIaolJLhERkY3T9jxTe3t7vP7664iLi4Ozs7P5gyIiIpJJIQiCYOkgiIiIyHIyMjKwb98+XLlyBcXFxQgMDESfPn30fr4yERFRXcIkl4iIiIiIiKwGtysTERERERGR1WCSS0RERERERFaDSS4RERERERFZDSa5REREREREZDWY5BIREREREZHVYJJLREREREREVoNJLhEREREREVkNJrlERERERERkNZjkEhERERERkdX4Py5nnIdySg6VAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "envelope_errors = [(check_fitted_isotope_envelope(ana_apo_1, tp), tp) for tp in all_tps]\n", + "envelope_errors = sorted(envelope_errors, key=lambda x: x[0], reverse=False)\n", + "\n", + "# you can plot the fitted isotope envelope and the experimental data\n", + "check_fitted_isotope_envelope(check_ana_obj, envelope_errors[300][1], if_plot=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Count')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(\n", + " np.array(envelope_errors)[:, 0],\n", + ")\n", + "plt.xlabel(\"Sum AE\")\n", + "plt.ylabel(\"Count\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3646019382844139\n", + "0.39348193324578395\n" + ] + } + ], + "source": [ + "\n", + "print(np.nanmedian(np.array(envelope_errors)[:, 0]))\n", + "print(np.nanmean(np.array(envelope_errors)[:, 0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### uptake check" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import check_fitted_peptide_uptake\n", + "\n", + "\n", + "all_idfs = list(set([pep.identifier for pep in all_peps]))\n", + "\n", + "\n", + "def extract_numbers(s):\n", + " numbers = re.findall(r\"(-?\\d+)-(-?\\d+)\", s)\n", + " return tuple(map(int, numbers[0]))\n", + "\n", + "\n", + "all_idfs.sort(key=extract_numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "uptake_errors = []\n", + "\n", + "all_peps_grouped = tools.group_by_attributes(\n", + " all_peps, [\"protein_state.state_name\", \"identifier\"]\n", + ")\n", + "\n", + "for idf in all_idfs:\n", + " try:\n", + " idf_peps = all_peps_grouped[(check_state_name, idf)]\n", + " avg_pep = tools.average_peptides(idf_peps)\n", + "\n", + " result = check_fitted_peptide_uptake(\n", + " check_ana_obj, hdxms_data_list, avg_pep, state_name=check_state_name\n", + " )\n", + " uptake_errors.append((result, avg_pep))\n", + " except Exception as e:\n", + " print(idf, e)\n", + "\n", + "\n", + "uptake_errors_array = np.array([i[0] for i in uptake_errors])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5.5))\n", + "\n", + "# # Plotting with complementary colors\n", + "# sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=\"#FF6347\")\n", + "# sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=\"#4682B4\")\n", + "\n", + "\n", + "color_1 = \"#53b1b1\" # A standard blue color\n", + "color_2 = \"#f6c624\" # A teal color\n", + "\n", + "# Plotting with chosen colors\n", + "sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=color_1)\n", + "sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=color_2)\n", + "\n", + "axes[1].set_ylabel(\"\")\n", + "axes[0].set_xlabel(\"Sum AE\")\n", + "axes[1].set_xlabel(\"Da/peptide length\")\n", + "fig.subplots_adjust(wspace=0.2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import get_index_offset\n", + "from matplotlib.ticker import LogLocator\n", + "\n", + "\n", + "check_ana_obj = ana_apo_1\n", + "index_offset = get_index_offset(check_ana_obj, './data/6XG5_TRI.pdb')\n", + "\n", + "uptake_errors = sorted(uptake_errors, key=lambda x: x[1].start, reverse=False)\n", + "\n", + "num_subplots_per_figure = math.ceil(len(uptake_errors) / 2)\n", + "# num_subplots_per_figure = 250\n", + "num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)\n", + "\n", + "\n", + "for fig_index in range(num_figures):\n", + " # Select the subset of errors for the current figure\n", + " selected_uptake_errors = uptake_errors[fig_index * num_subplots_per_figure:(fig_index + 1) * num_subplots_per_figure]\n", + " num_col = math.ceil(len(selected_uptake_errors) / 5)\n", + "\n", + " fig, axs = plt.subplots(num_col, 5, figsize=(9 * 5, 8 * num_col)) # Adjust subplot size as needed\n", + "\n", + " for i, error_tuple in enumerate(selected_uptake_errors):\n", + "\n", + "\n", + " ax = axs[i // 5, i % 5]\n", + "\n", + "\n", + " # Unpack error information\n", + " peptide_data = error_tuple[1]\n", + "\n", + "\n", + " ax.axhline(y=peptide_data.max_d, color='lightgray', linestyle='--', linewidth=5)\n", + "\n", + " check_fitted_peptide_uptake(\n", + " check_ana_obj,\n", + " hdxms_data_list,\n", + " peptide_data,\n", + " if_plot=True,\n", + " state_name=check_state_name,\n", + " figure=fig,\n", + " ax=ax\n", + " )\n", + "\n", + " #Retrieve and format the peptide identifier\n", + " idf = peptide_data.identifier\n", + " idf_start, idf_end = map(int, re.match(r\"(-?\\d+)-(-?\\d+)\", idf).groups())\n", + " idf_seq = idf.split(\" \")[1]\n", + " ax.set_title(f\"{idf_start - index_offset}-{idf_end - index_offset} {idf_seq}\")\n", + "\n", + " ax.set_xlim(1e1, 1e5)\n", + " ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))\n", + "\n", + " # y_max = ax.get_ylim()[1]\n", + " # ax.set_ylim(-0.5, y_max + 1)\n", + " pep = error_tuple[1]\n", + " y_max = pep.theo_max_d/check_ana_obj.saturation\n", + " ax.set_ylim(-0.5, y_max + 0.5)\n", + "\n", + " # light gray dotted line at max deuteration\n", + "\n", + "\n", + " handles, labels = ax.get_legend_handles_labels()\n", + " new_labels = [label for label in labels if label.isdigit()]\n", + " new_handles = [handle for handle, label in zip(handles, labels) if label.isdigit()]\n", + " ax.legend(new_handles, new_labels, title='replicate', title_fontsize='small')\n", + "\n", + " # Layout adjustment and save\n", + " fig.tight_layout()\n", + " fig.savefig(f\"{results_path}/ecDHFR_uptake_errors_{check_state_name}_{fig_index}.pdf\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "if the fitting is bad, one should not move forward, need to check the parameters in the sampling, make sure they agree with the experimental conditions. one may also remove the outlier peptides and run the all the cells above again. a ourliter may be a peptide exchange a lot while its neighbours barely exchange (examples in the turtorial dataset: 78-92 VDEAIAACGDVPEIM, 75-78 VKSV)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "once you're satisfied with the fitting results, you can make the final results plots" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## barplot of the kex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "barplot showing the FEATHER derived exchange rates. index_offset is determined by comparison to the sequence in HX/MS and the pdb file provided." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# APO state only\n", + "\n", + "import numpy as np\n", + "\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(40, 10), sharey=True, sharex=True)\n", + "\n", + "ana_apo_1.plot_kex_bar(\n", + " ax=axes[0], resolution_indicator_pos=15, label=\"APO\", show_seq=False, color=\"k\"\n", + ")\n", + "\n", + "ana_tri_1.plot_kex_bar(\n", + " ax=axes[1], resolution_indicator_pos=15, label=\"TRI\", show_seq=False, color=\"red\"\n", + ")\n", + "\n", + "from matplotlib.pyplot import step\n", + "from matplotlib.ticker import FuncFormatter, MultipleLocator\n", + "\n", + "from pigeon_feather.analysis import get_index_offset\n", + "\n", + "pdb_file = \"./data/6XG5_TRI.pdb\"\n", + "index_offset = get_index_offset(ana_apo_1, pdb_file)\n", + "\n", + "# # ax.xaxis.set_major_locator(plt.MultipleLocator(2))\n", + "axes[0].set_xticks(axes[0].get_xticks()[::2])\n", + "axes[0].set_xticklabels(axes[0].get_xticklabels(), fontdict={\"fontsize\": 24})\n", + "\n", + "\n", + "def format_func(value, tick_number):\n", + " return f\"{int(value - index_offset +1)}\"\n", + "\n", + "\n", + "axes[0].xaxis.set_major_formatter(FuncFormatter(format_func))\n", + "\n", + "seq_pos = 17\n", + "for ii in range(0, len(ana_apo_1.protein_sequence[:]), 2):\n", + " axes[0].text(\n", + " ii,\n", + " seq_pos,\n", + " ana_apo_1.protein_sequence[ii],\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " fontsize=22,\n", + " )\n", + "\n", + "\n", + "for ax in axes:\n", + " ax.set_ylabel(\"-log(k$_{ex}$)\")\n", + " #ax.legend(loc=\"lower left\")\n", + " ax.yaxis.set_major_locator(plt.MultipleLocator(5))\n", + "\n", + " ax.plot(\n", + " [-3, len(ana_apo_1.protein_sequence) + 3],\n", + " [5, 5],\n", + " color=\"gray\",\n", + " lw=1,\n", + " linestyle=\"--\",\n", + " alpha=0.5,\n", + " )\n", + " ax.plot(\n", + " [-3, len(ana_apo_1.protein_sequence) + 3],\n", + " [10, 10],\n", + " color=\"gray\",\n", + " lw=1,\n", + " linestyle=\"--\",\n", + " alpha=0.5,\n", + " )\n", + "\n", + "\n", + "plt.subplots_adjust(hspace=0.08)\n", + "fig.savefig(f\"{results_path}/ecDHFR_kex_bar_APO_TRI_{today_date}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "logP projection to a pdb structure" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import BFactorPlot" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "bfactor_plot = BFactorPlot(\n", + " ana_apo_1,\n", + " pdb_file=\"./data/6XG5_TRI.pdb\",\n", + " plot_deltaG=True,\n", + " temperature=293.15,\n", + " logP_threshold=10,\n", + ")\n", + "bfactor_plot.plot(f\"{results_path}/6XG5_APO_deltaG.pdb\")\n", + "\n", + "# bfactor_plot = BFactorPlot(\n", + "# ana_apo_1,\n", + "# pdb_file=\"./data/6XG5_APO_relaxed_best_solvated.pdb\",\n", + "# plot_deltaG=True,\n", + "# temperature=293.15,\n", + "# )\n", + "# bfactor_plot.plot(f\"{out_path}/6XG5_APO_deltaG.pdb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "delta logP" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "if there are mutiple states availble, one can map the difference to the pdb strutcure" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "bfactor_plot = BFactorPlot(\n", + " ana_apo_1,\n", + " ana_tri_1, \n", + " pdb_file=\"./data/6XG5_TRI.pdb\",\n", + " plot_deltaG=True,\n", + " temperature=293.15,\n", + " logP_threshold=10,\n", + ")\n", + "bfactor_plot.plot(f\"{results_path}/6XG5_deltaG_APO-TRI.pdb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "export logPFs to a csv" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import MDAnalysis\n", + "from pigeon_feather.analysis import get_res_avg_logP, get_res_avg_logP_std\n", + "\n", + "pdb_file = \"./data/6XG5_TRI.pdb\"\n", + "index_offset = get_index_offset(ana_apo_1, pdb_file)\n", + "\n", + "\n", + "def logPF_to_deltaG(ana_obj, logPF):\n", + " \"\"\"\n", + " :param logPF: logP value\n", + " :return: deltaG in kJ/mol, local unfolding energy\n", + " \"\"\"\n", + "\n", + " return 8.3145 * ana_obj.temperature * np.log(10) * logPF / 1000\n", + "\n", + "\n", + "def create_logP_df(ana_obj, index_offset):\n", + " df_logPF = pd.DataFrame()\n", + "\n", + " for res_i, _ in enumerate(ana_obj.results_obj.protein_sequence):\n", + " res_obj_i = ana_obj.results_obj.get_residue_by_resindex(res_i)\n", + "\n", + " avg_logP, std_logP = get_res_avg_logP(res_obj_i)\n", + " #std_logP = get_res_avg_logP_std(res_obj_i)\n", + "\n", + " df_i = pd.DataFrame(\n", + " {\n", + " \"resid\": [res_obj_i.resid - index_offset],\n", + " #\"resname\": [res_obj_i.resname],\n", + " \"resname\": [MDAnalysis.lib.util.convert_aa_code(res_obj_i.resname)],\n", + " 'avg_dG': [logPF_to_deltaG(ana_obj, avg_logP)],\n", + " 'std_dG': [logPF_to_deltaG(ana_obj, std_logP)],\n", + " \"avg_logP\": [avg_logP],\n", + " \"std_logP\": [max(std_logP, 0.35)],\n", + " \"is_nan\": [res_obj_i.is_nan()],\n", + " }\n", + " )\n", + "\n", + " if res_obj_i.is_nan():\n", + " df_i[\"single resloved\"] = [np.nan]\n", + " df_i[\"min_pep logPs\"] = [np.nan]\n", + "\n", + " else:\n", + " df_i[\"single resloved\"] = [res_obj_i.mini_pep.if_single_residue()]\n", + " df_i[\"min_pep logPs\"] = [res_obj_i.clustering_results_logP]\n", + "\n", + " df_logPF = pd.concat([df_logPF, df_i])\n", + "\n", + " df_logPF = df_logPF.reset_index(drop=True)\n", + "\n", + " return df_logPF\n", + "\n", + "\n", + "df = create_logP_df(ana_apo_1, index_offset)\n", + "df.to_csv(f\"{results_path}/logP_APO_{today_date}.csv\", index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# fecth two df and merge\n", + "df_apo = create_logP_df(ana_apo_1, index_offset)\n", + "df_tri = create_logP_df(ana_tri_1, index_offset)\n", + "\n", + "df = pd.merge(df_apo, df_tri, on=\"resid\", suffixes=(\"_APO\", \"_TRI\"))\n", + "\n", + "df.to_csv(f\"{results_path}/logP_APO_TRI_{today_date}.csv\", index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/_sources/tutorials/01_load_data.ipynb.txt b/_sources/tutorials/01_load_data.ipynb.txt new file mode 100644 index 0000000..c2f9901 --- /dev/null +++ b/_sources/tutorials/01_load_data.ipynb.txt @@ -0,0 +1,227 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 01_load_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In principle, FEATHER can accept the output from any HX/MS software.\n", + "\n", + "There are two types of input files:\n", + "1. Peptide pools with centroid deuteration values\n", + "2. Raw mass spectra (deconvoluted)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read the centroid data " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **Table:** The peptide pool.\n", + "* **Range List:** A file that defines the peptides to include or exclude.\n", + "* **n_fastamides:** In an HDX experiment, the first two residues of a peptide at the N-terminus do not contribute to deuterium uptake due to rapid back exchange.\n", + "* **Saturation:** The percentage of deuterium in the D2O buffer.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "./data/ecDHFR_tutorial.csv\n", + "rangeslist included !\n" + ] + } + ], + "source": [ + "tables = ['./data/ecDHFR_tutorial.csv']\n", + "\n", + "ranges = ['./data/rangeslist.csv']\n", + "\n", + "\n", + "raw_spectra_paths = [\n", + " f\"./data/SpecExport/\",\n", + "]\n", + "\n", + "protein_sequence = \"MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR\"\n", + "\n", + "# load the data\n", + "hdxms_data_list = []\n", + "for i in range(len(tables)):\n", + " # for i in [4]:\n", + " print(tables[i])\n", + "\n", + " # read the data and clean it\n", + " cleaned = read_hdx_tables([tables[i]], [ranges[i]], exclude=False, states_subset=['APO','TRI'])\n", + " \n", + " # convert the cleaned data to hdxms data object\n", + " hdxms_data = load_dataframe_to_hdxmsdata(\n", + " cleaned,\n", + " n_fastamides=2,\n", + " protein_sequence=protein_sequence,\n", + " fulld_approx=False,\n", + " saturation=0.9,\n", + " )\n", + "\n", + " hdxms_data_list.append(hdxms_data)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "check the basic statics_info of the hdxms_data_list" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + " HDX-MS Data Statistics\n", + "============================================================\n", + "States names: ['APO', 'TRI']\n", + "Time course (s): [46.0, 373.5, 572.5, 2011.0, 7772.0, 30811.5, 43292.0]\n", + "Number of time points: 7\n", + "Protein sequence length: 174\n", + "Average coverage: 0.97\n", + "Number of unique peptides: 261\n", + "Average peptide length: 9.8\n", + "Redundancy (based on average coverage): 14.7\n", + "Average peptide length to redundancy ratio: 0.7\n", + "Backexchange average, IQR: 0.27, 0.26\n", + "============================================================\n" + ] + } + ], + "source": [ + "from pigeon_feather.hxio import get_all_statics_info\n", + "\n", + "get_all_statics_info(hdxms_data_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load the raw spectrum" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Removed 0 peptides from state APO due to missing raw MS data.\n", + "Removed 70 peptides from state APO due to high back exchange.\n", + "Removed 2 peptides from state TRI due to missing raw MS data.\n", + "Removed 70 peptides from state TRI due to high back exchange.\n", + "Done loading raw MS data.\n" + ] + } + ], + "source": [ + "# spectrum could be easily loaded to the hdxms_data object\n", + "for i in range(len(tables)):\n", + " load_raw_ms_to_hdxms_data(\n", + " hdxms_data,\n", + " raw_spectra_paths[i],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** One common error is that the correct spectra file cannot be found. Please ensure that the `protein_state.state_name` corresponds to the files in the spectrum folder, with the correct time points and charge states." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# save the raw data as a pickle file\n", + "import pickle\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"wb\") as f:\n", + " pickle.dump(hdxms_data_list, f)\n", + "\n", + "# with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + "# hdxms_data_list = pickle.load(f)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/tutorials/02_peptide_level_analysis.ipynb.txt b/_sources/tutorials/02_peptide_level_analysis.ipynb.txt new file mode 100644 index 0000000..9bd3d0e --- /dev/null +++ b/_sources/tutorials/02_peptide_level_analysis.ipynb.txt @@ -0,0 +1,524 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 02_peptide_level_analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Determination of memory status is not supported on this \n", + " platform, measuring for memoryleaks will never fail\n" + ] + } + ], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "# load the pickle file we saved in the previous notebook\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)\n", + "\n", + "\n", + "# back exchange correction for peptides with experimental full deuteration data based its closest match in the database\n", + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "out_path = \"./data/PF_input_20240722\"\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = f\"ecDHFR_results_{today_date}\"\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## uptake plots" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# option 1\n", + "from matplotlib.ticker import MultipleLocator, FormatStrFormatter\n", + "import matplotlib.ticker as ticker\n", + "import matplotlib.lines as mlines\n", + "from pigeon_feather.analysis import get_index_offset\n", + "from matplotlib.ticker import LogLocator\n", + "\n", + "\n", + "font = {\"family\": \"Arial\", \"weight\": \"normal\", \"size\": 36}\n", + "axes = {\"titlesize\": 36, \"titleweight\": \"bold\", \"labelsize\": 36, \"linewidth\": 5}\n", + "plt.rc(\"font\", **font)\n", + "plt.rc(\"axes\", **axes)\n", + "plt.rc(\"lines\", lw=5)\n", + "\n", + "colors = [\"k\", \"red\", \"blue\", \"purple\", \"gray\", \"orange\", \"yellow\", \"green\", \"brown\"]\n", + "\n", + "\n", + "all_peps = [\n", + " peptide\n", + " for hdxms_data in hdxms_data_list\n", + " for state in hdxms_data.states\n", + " for peptide in state.peptides\n", + " if peptide.note is None and state.state_name != \"RAT\"\n", + "]\n", + "all_idfs = [pep for pep in all_peps if pep.unique_num_timepoints > 5]\n", + "all_idfs = list(set([peptide.identifier for peptide in all_peps]))[:]\n", + "all_idfs.sort(key=lambda x: int(re.search(r\"(-?\\d+)\", x).group()))\n", + "\n", + "\n", + "\n", + "def idf_to_pep(idf):\n", + " return [pep for pep in all_peps if pep.identifier == idf][0]\n", + "\n", + "# num_subplots_per_figure = 100\n", + "num_subplots_per_figure = 250\n", + "num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)\n", + "\n", + "\n", + "all_idfs_subset = all_idfs[:]\n", + "\n", + "for fig_index in range(num_figures):\n", + " # Select the subset of errors for the current figure\n", + " selected_idf = all_idfs_subset[\n", + " fig_index * num_subplots_per_figure : (fig_index + 1) * num_subplots_per_figure\n", + " ]\n", + " num_col = math.ceil(len(selected_idf) / 5)\n", + "\n", + " fig, axs = plt.subplots(\n", + " num_col, 5, figsize=(9 * 5, 8 * num_col)\n", + " ) # Adjust subplot size as needed\n", + "\n", + " for i, idf in enumerate(selected_idf):\n", + " ax = axs[i // 5, i % 5]\n", + "\n", + "\n", + " pep = idf_to_pep(idf)\n", + " ax.axhline(y=pep.max_d, color='lightgray', linestyle='--', linewidth=5)\n", + "\n", + "\n", + " uptake = UptakePlot(\n", + " hdxms_data_list,\n", + " idf,\n", + " states_subset=[\"APO\", \"TRI\"],\n", + " if_plot_fit=False,\n", + " figure=fig,\n", + " ax=ax,\n", + " )\n", + "\n", + " ax.set_xlim(1e1, 1e5)\n", + " ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))\n", + "\n", + "\n", + " y_max = pep.theo_max_d/hdxms_data_list[0].saturation\n", + " ax.set_ylim(-0.5, y_max + 0.5)\n", + "\n", + "\n", + " #Custom legend\n", + " handles, labels = ax.get_legend_handles_labels()\n", + " new_labels = [label for label in labels if label in [\"APO\", \"TRI\"]]\n", + " new_handles = [\n", + " handle\n", + " for handle, label in zip(handles, labels)\n", + " if label in [\"APO\", \"TRI\"] \n", + " ]\n", + " ax.legend(new_handles, new_labels, title=\"state\", title_fontsize=\"small\",loc='best')\n", + "\n", + "\n", + " # Layout adjustment and save\n", + " fig.tight_layout()\n", + " fig.savefig(f\"{results_path}/DHFR_exp_uptake_{fig_index}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## pipetide comparison" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the peptide-level comparison can only happen at the same time point between different states, let's group timepoints within 50 seconds as the same timepoint.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "all_peptides = [\n", + " peptide\n", + " for hdxms_data in hdxms_data_list\n", + " for state in hdxms_data.states\n", + " for peptide in state.peptides\n", + "]\n", + "\n", + "\n", + "all_tps = [\n", + " tp\n", + " for pep in all_peptides\n", + " for tp in pep.timepoints\n", + " if tp.deut_time != np.inf and tp.deut_time != 0\n", + "]\n", + "\n", + "tps_range = list(set([tp.deut_time for tp in all_tps]))\n", + "\n", + "\n", + "# Step 1: Sort the values\n", + "sorted_values = sorted(tps_range)\n", + "\n", + "# Step 2: Group values with offsets less than 50\n", + "groups = []\n", + "current_group = []\n", + "\n", + "for value in sorted_values:\n", + " if current_group and value - current_group[-1] > 50:\n", + " groups.append(current_group)\n", + " current_group = []\n", + " current_group.append(value)\n", + "\n", + "# Add the last group if not empty\n", + "if current_group:\n", + " groups.append(current_group)\n", + "\n", + "# Step 3: Calculate average and map values to the average integer\n", + "result_mapping = {}\n", + "for group in groups:\n", + " average = int(round(sum(group) / len(group)))\n", + " for value in group:\n", + " result_mapping[value] = average\n", + "\n", + "result_mapping\n", + "\n", + "\n", + "for tp in all_tps:\n", + " tp.deut_time = result_mapping[tp.deut_time]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`HDXStatePeptideCompares` can be created between two different states for comparison. It is a collection of all possible `HDXStatePeptideCompare`, where the same peptides are in both Proteinstate. HDXStatePeptideCompare\n", + "will find all the common timepoints and get the difference in D uptake. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "state1 = 'APO'\n", + "state2 = 'TRI'\n", + "\n", + "# first get the states\n", + "state1_list = [i.get_state(state1) for i in hdxms_data_list]\n", + "state2_list = [i.get_state(state2) for i in hdxms_data_list]\n", + "\n", + "pep_compres = HDXStatePeptideCompares(state1_list, state2_list)\n", + "pep_compres.add_all_compare()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------\n", + "APO-TRI: 12-19 LYFQSISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -4.73 -1.3 -0.29 5.06 9.5 18.34 17.01 0. ]\n", + "-----------------\n", + "APO-TRI: 13-19 YFQSISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -2.57 -2.44 1.23 4.42 11.45 19.75 17.73 0. ]\n", + "-----------------\n", + "APO-TRI: 14-19 FQSISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -1.09 -1.89 0.65 3.5 12.59 24.48 21.75 0. ]\n", + "-----------------\n", + "APO-TRI: 15-19 QSISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -0.61 -1.31 2.52 5.73 16.05 27.09 24.22 0. ]\n", + "-----------------\n", + "APO-TRI: 15-20 QSISLI\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -1.09 -1.89 0.65 3.5 14.26 24.48 21.75 0. ]\n", + "-----------------\n", + "APO-TRI: 15-16 QS\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -0.76 -11.12 3.54 -1.2 -0.19 -0.25 -2.84 0. ]\n", + "-----------------\n", + "APO-TRI: 16-19 SISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. 0.51 -0.38 2.61 6.68 18.21 31.39 29.12 0. ]\n", + "-----------------\n", + "APO-TRI: 22-27 ALAVDR\n", + "[ 0. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. 28.87 37.37 35.11 11.44 2.48 -0.88 0. ]\n", + "-----------------\n", + "APO-TRI: 22-31 ALAVDRVIGM\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. 14.41 30.25 38.46 28.2 8.77 -0.53 -4.59 0. ]\n", + "-----------------\n", + "APO-TRI: 22-26 ALAVD\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. 10.6 30.79 36.83 29.21 14.64 4.28 1.39 0. ]\n" + ] + } + ], + "source": [ + "# check the results\n", + "for i in pep_compres.peptide_compares[:10]:\n", + " print('-----------------')\n", + " print(i.compare_info)\n", + " print(i.common_timepoints)\n", + " print(i.deut_diff)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## pseudo residue compare" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "pseudo residue compare is a comparison of the average D uptake between two different `Proteinstate` of all the peptides that cover this residue. D here is the normalized values based on the full-D experiments (0-100)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "res_compares = HDXStateResidueCompares([i for i in range(1, 320)], state1_list, state2_list)\n", + "res_compares.add_all_compare()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------\n", + "APO-TRI: 12\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -4.73 -1.3 -0.29 5.06 9.5 18.34 17.01 0. ]\n", + "-----------------\n", + "APO-TRI: 13\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -3.65 -1.87 0.47 4.74 10.475 19.045 17.37 0. ]\n", + "-----------------\n", + "APO-TRI: 14\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -2.79666667 -1.87666667 0.53 4.32666667 11.18\n", + " 20.85666667 18.83 0. ]\n", + "-----------------\n", + "APO-TRI: 15\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -1.80833333 -3.325 1.38333333 3.50166667 10.61\n", + " 18.98166667 16.60333333 0. ]\n", + "-----------------\n", + "APO-TRI: 16\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -1.47714286 -2.90428571 1.55857143 3.95571429 11.69571429\n", + " 20.75428571 18.39142857 0. ]\n" + ] + } + ], + "source": [ + "# check the results\n", + "# deut_diff is the average deuteration difference of all peptides covering the residue\n", + "for i in res_compares.residue_compares[:5]:\n", + " print('-----------------')\n", + " print(i.compare_info)\n", + " print(i.common_timepoints)\n", + " print(i.deut_diff)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## visualization on pymol structure" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both comparison objects can be projected to a pdb structure for Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# both of the compare objects can be exported as a pymol pse file for visualization\n", + "pdb_file = 'data/6XG5_TRI.pdb'\n", + "\n", + "create_compare_pymol_plot(pep_compres, colorbar_max=20, pdb_file=pdb_file, path=f'{results_path}')\n", + "create_compare_pymol_plot(res_compares, colorbar_max=20, pdb_file=pdb_file, path=f'{results_path}')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# it can be visualized as a heatmap\n", + "create_heatmap_compare_tp(pep_compres, 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# make all the plots and save them\n", + "\n", + "from itertools import product\n", + "\n", + "items =[state.state_name for hdxms_data in hdxms_data_list for state in hdxms_data.states]\n", + "combinations = product(['APO'], [x for x in items if x != 'APO'])\n", + "\n", + "for state1_name, state2_name in combinations:\n", + "\n", + " state1_list = [i.get_state(state1_name) for i in hdxms_data_list]\n", + " state2_list = [i.get_state(state2_name) for i in hdxms_data_list]\n", + "\n", + " compare = HDXStatePeptideCompares(state1_list, state2_list)\n", + " compare.add_all_compare()\n", + "\n", + " heatmap_compare_tp = create_heatmap_compare_tp(compare, 20)\n", + " heatmap_compare_tp.savefig(f'{results_path}/{state1}-{state2}-heatmap-tp.png')\n", + "\n", + " heatmap_compare = create_heatmap_compare(compare, 20)\n", + " heatmap_compare.savefig(f'{results_path}/{state1}-{state2}-heatmap.png')\n", + "\n", + " create_compare_pymol_plot(compare, colorbar_max=20, pdb_file=pdb_file, path=results_path)\n", + "\n", + "\n", + "\n", + " res_compares = HDXStateResidueCompares([i for i in range(1, 320)], state1_list, state2_list)\n", + " res_compares.add_all_compare()\n", + "\n", + " create_compare_pymol_plot(res_compares, 20, pdb_file=pdb_file, path=results_path)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/tutorials/03_calculate_PFs.ipynb.txt b/_sources/tutorials/03_calculate_PFs.ipynb.txt new file mode 100644 index 0000000..8907aef --- /dev/null +++ b/_sources/tutorials/03_calculate_PFs.ipynb.txt @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 03_calculate_PFs" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Determination of memory status is not supported on this \n", + " platform, measuring for memoryleaks will never fail\n" + ] + } + ], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "# load the pickle file we saved in the previous notebook\n", + "\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)\n", + "\n", + "\n", + "# back exchange correction for peptides with experimental full deuteration data based its closest match in the database\n", + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = f\"ecDHFR_results_{today_date}\"\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)\n", + "\n", + "\n", + "out_path = \"./data/PF_input_20240722\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## peptide subtraction" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "117 new peptides added to the APO state.\n", + "127 new peptides added to the TRI state.\n" + ] + } + ], + "source": [ + "# [state.add_all_subtract() for data in hdxms_data_list for state in data.states]\n", + "# add_new_peptides_by_subtract()\n", + "for i in range(1):\n", + " [\n", + " state.add_new_peptides_by_subtract()\n", + " for data in hdxms_data_list[:]\n", + " for state in data.states\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[117, 127]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[state.num_subtracted_added for data in hdxms_data_list for state in data.states]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "save the data as a pickle file for later use, and write to files used for bayesian sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "with open(f\"{out_path}/hdxms_data_list.pkl\", \"wb\") as f:\n", + " pickle.dump(hdxms_data_list, f)\n", + "\n", + "# with open(f\"{out_path}/hdxms_data_list.pkl\", \"rb\") as f:\n", + "# hdxms_data_list = pickle.load(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## inputs for MCMC sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Isotope files saved to ./data/PF_input_20240722/spectra_dhfr_tutorial_dataset\n", + "Reminder: sequence contains fastamides !!!\n", + "Reminder: sequence contains fastamides !!!\n", + "Data saved to ./data/PF_input_20240722\n", + "dhfr_tutorial_dataset\n" + ] + } + ], + "source": [ + "exp_names = [\n", + " \"dhfr_tutorial_dataset\",\n", + "]\n", + "\n", + "for i in range(len(hdxms_data_list)):\n", + " # exp_name = raw_spectra_paths[i].split('/')[-2].split('SpecExport_')[-1]\n", + " exp_name = exp_names[i]\n", + " export_iso_files(\n", + " hdxms_data_list[i], outdir=f\"{out_path}/spectra_{exp_name}\", overwrite=True\n", + " )\n", + " df = revert_hdxmsdata_to_dataframe(hdxms_data_list[i])\n", + " convert_dataframe_to_bayesianhdx_format(\n", + " df, protein_name=exp_name, OUTPATH=f\"{out_path}\"\n", + " )\n", + "\n", + " print(exp_name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "write ready to run script for each state" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "protein_sequence = \"MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR\"\n", + "\n", + "state_names = list(\n", + " set([state.state_name for data in hdxms_data_list for state in data.states])\n", + ")\n", + "for protein_state in state_names:\n", + " script = tools.generate_bayesian_hdx_script(\n", + " exp_names,\n", + " protein_sequence,\n", + " protein_state,\n", + " base_directory=\".\",\n", + " making_chunks=True,\n", + " pH=7.0,\n", + " temperature=293.0,\n", + " saturation=0.9,\n", + " rerun_num=3,\n", + " extreme_value_prior=False,\n", + " structural_prior=False,\n", + " )\n", + "\n", + " with open(f\"{out_path}/run_bayesian_hdx_{protein_state}_chunks.py\", \"w\") as f:\n", + " f.write(script)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## two priors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make sure you generate the priors if you enable twp priors in `tools.generate_bayesian_hdx_script`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# uptake prior\n", + "#tools.generate_extreme_value_prior(hdxms_data_list, out_path)\n", + "\n", + "\n", + "# structural prior\n", + "\n", + "# solvated_pdbs = [\n", + "# \"./data/5DFR_APO_relaxed_best_solvated.pdb\",\n", + "# \"./data/6XG5_TRI_relaxed_best_solvated.pdb\",\n", + "# \"./data/1RG7_MTX_relaxed_best_solvated.pdb\",\n", + "# ]\n", + "\n", + "# for i, state_name in enumerate([\"APO\", \"TRI\", \"MTX\"]):\n", + "\n", + "\n", + "# tools.generate_structural_prior(\n", + "# protein_sequence, solvated_pdbs[i], out_path, state_name\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can run the script in the terminal with the following command:\n", + "\n", + "```sh\n", + "cd ./data/bayesian_hdx_input_20240722\n", + "python run_bayesian_hdx_APO_chunks.py\n", + "```\n", + "\n", + "The simulations usually take several hours, but the duration varies based on the size of the dataset (number of peptides, time points, and replicates).\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pigeon_feather", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/tutorials/04_check_the_fitting.ipynb.txt b/_sources/tutorials/04_check_the_fitting.ipynb.txt new file mode 100644 index 0000000..7ffabb1 --- /dev/null +++ b/_sources/tutorials/04_check_the_fitting.ipynb.txt @@ -0,0 +1,486 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 04_check_the_fitting" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Determination of memory status is not supported on this \n", + " platform, measuring for memoryleaks will never fail\n" + ] + } + ], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "# load the pickle file we saved in the previous notebook\n", + "\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)\n", + "\n", + "\n", + "# back exchange correction for peptides with experimental full deuteration data based its closest match in the database\n", + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = f\"ecDHFR_results_{today_date}\"\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)\n", + "\n", + "\n", + "out_path = \"./data/PF_input_20240722\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create an `Analysis` object and load the results. **Note:** The temperature and pH are crucial for calculating the intrinsic exchange rates, so make sure to input the correct values. The chunk size and chunk number can be altered by the user. In this tutorial, they were automatically determined by a helper function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import Analysis, get_index_offset\n", + "from pigeon_feather.tools import optimal_chunks\n", + "import matplotlib.pyplot as plt\n", + "\n", + "RUN_NUM = 3\n", + "\n", + "apo_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"APO\"\n", + "]\n", + "\n", + "tri_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"TRI\"\n", + "]\n", + "\n", + "ana_apo_1 = Analysis(apo_states, temperature=293.0, pH=7.0)\n", + "\n", + "chunk_num, chunk_size = optimal_chunks(len(ana_apo_1.protein_sequence))\n", + "ana_apo_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"APO\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")\n", + "\n", + "\n", + "ana_tri_1 = Analysis(tri_states, temperature=293.0, pH=7.0)\n", + "\n", + "ana_tri_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"TRI\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "two fitting check functions are available: 1. centroid level fitting check 2. isotopic mass envelope fitting check. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import (\n", + " check_fitted_isotope_envelope,\n", + " check_fitted_peptide_uptake,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## envelope check" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "check_state_name = \"APO\"\n", + "check_ana_obj = ana_apo_1\n", + "\n", + "\n", + "all_peps = [\n", + " pep\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " for pep in state.peptides\n", + " if state.state_name == check_state_name and pep.note is None\n", + "]\n", + "all_tps = [\n", + " tp\n", + " for pep in all_peps\n", + " for tp in pep.timepoints\n", + " if pep.get_timepoint(0) is not None and tp.deut_time != np.inf and tp.deut_time != 0\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.18336607065124264" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "envelope_errors = [(check_fitted_isotope_envelope(ana_apo_1, tp), tp) for tp in all_tps]\n", + "envelope_errors = sorted(envelope_errors, key=lambda x: x[0], reverse=False)\n", + "\n", + "# you can plot the fitted isotope envelope and the experimental data\n", + "check_fitted_isotope_envelope(check_ana_obj, envelope_errors[300][1], if_plot=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Count')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(\n", + " np.array(envelope_errors)[:, 0],\n", + ")\n", + "plt.xlabel(\"Sum AE\")\n", + "plt.ylabel(\"Count\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3669856716168908\n", + "0.39744791298433696\n" + ] + } + ], + "source": [ + "\n", + "print(np.nanmedian(np.array(envelope_errors)[:, 0]))\n", + "print(np.nanmean(np.array(envelope_errors)[:, 0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## uptake check" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import check_fitted_peptide_uptake\n", + "\n", + "\n", + "all_idfs = list(set([pep.identifier for pep in all_peps]))\n", + "\n", + "\n", + "def extract_numbers(s):\n", + " numbers = re.findall(r\"(-?\\d+)-(-?\\d+)\", s)\n", + " return tuple(map(int, numbers[0]))\n", + "\n", + "\n", + "all_idfs.sort(key=extract_numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "uptake_errors = []\n", + "\n", + "all_peps_grouped = tools.group_by_attributes(\n", + " all_peps, [\"protein_state.state_name\", \"identifier\"]\n", + ")\n", + "\n", + "for idf in all_idfs:\n", + " try:\n", + " idf_peps = all_peps_grouped[(check_state_name, idf)]\n", + " avg_pep = tools.average_peptides(idf_peps)\n", + "\n", + " result = check_fitted_peptide_uptake(\n", + " check_ana_obj, hdxms_data_list, avg_pep, state_name=check_state_name\n", + " )\n", + " uptake_errors.append((result, avg_pep))\n", + " except Exception as e:\n", + " print(idf, e)\n", + "\n", + "\n", + "uptake_errors_array = np.array([i[0] for i in uptake_errors])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5.5))\n", + "\n", + "# # Plotting with complementary colors\n", + "# sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=\"#FF6347\")\n", + "# sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=\"#4682B4\")\n", + "\n", + "\n", + "color_1 = \"#53b1b1\" # A standard blue color\n", + "color_2 = \"#f6c624\" # A teal color\n", + "\n", + "# Plotting with chosen colors\n", + "sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=color_1)\n", + "sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=color_2)\n", + "\n", + "axes[1].set_ylabel(\"\")\n", + "axes[0].set_xlabel(\"Sum AE\")\n", + "axes[1].set_xlabel(\"Da/peptide length\")\n", + "fig.subplots_adjust(wspace=0.2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import get_index_offset\n", + "from matplotlib.ticker import LogLocator\n", + "\n", + "\n", + "check_ana_obj = ana_apo_1\n", + "index_offset = get_index_offset(check_ana_obj, './data/6XG5_TRI.pdb')\n", + "\n", + "uptake_errors = sorted(uptake_errors, key=lambda x: x[1].start, reverse=False)\n", + "\n", + "num_subplots_per_figure = math.ceil(len(uptake_errors) / 2)\n", + "# num_subplots_per_figure = 250\n", + "num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)\n", + "\n", + "\n", + "for fig_index in range(num_figures):\n", + " # Select the subset of errors for the current figure\n", + " selected_uptake_errors = uptake_errors[fig_index * num_subplots_per_figure:(fig_index + 1) * num_subplots_per_figure]\n", + " num_col = math.ceil(len(selected_uptake_errors) / 5)\n", + "\n", + " fig, axs = plt.subplots(num_col, 5, figsize=(9 * 5, 8 * num_col)) # Adjust subplot size as needed\n", + "\n", + " for i, error_tuple in enumerate(selected_uptake_errors):\n", + "\n", + "\n", + " ax = axs[i // 5, i % 5]\n", + "\n", + "\n", + " # Unpack error information\n", + " peptide_data = error_tuple[1]\n", + "\n", + "\n", + " ax.axhline(y=peptide_data.max_d, color='lightgray', linestyle='--', linewidth=5)\n", + "\n", + " check_fitted_peptide_uptake(\n", + " check_ana_obj,\n", + " hdxms_data_list,\n", + " peptide_data,\n", + " if_plot=True,\n", + " state_name=check_state_name,\n", + " figure=fig,\n", + " ax=ax\n", + " )\n", + "\n", + " #Retrieve and format the peptide identifier\n", + " idf = peptide_data.identifier\n", + " idf_start, idf_end = map(int, re.match(r\"(-?\\d+)-(-?\\d+)\", idf).groups())\n", + " idf_seq = idf.split(\" \")[1]\n", + " ax.set_title(f\"{idf_start - index_offset}-{idf_end - index_offset} {idf_seq}\")\n", + "\n", + " ax.set_xlim(1e1, 1e5)\n", + " ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))\n", + "\n", + " # y_max = ax.get_ylim()[1]\n", + " # ax.set_ylim(-0.5, y_max + 1)\n", + " pep = error_tuple[1]\n", + " y_max = pep.theo_max_d/check_ana_obj.saturation\n", + " ax.set_ylim(-0.5, y_max + 0.5)\n", + "\n", + " # light gray dotted line at max deuteration\n", + "\n", + "\n", + " handles, labels = ax.get_legend_handles_labels()\n", + " new_labels = [label for label in labels if label.isdigit()]\n", + " new_handles = [handle for handle, label in zip(handles, labels) if label.isdigit()]\n", + " ax.legend(new_handles, new_labels, title='replicate', title_fontsize='small')\n", + "\n", + " # Layout adjustment and save\n", + " fig.tight_layout()\n", + " fig.savefig(f\"{results_path}/ecDHFR_uptake_errors_{check_state_name}_{fig_index}.pdf\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the fitting is poor, do not proceed. Check the parameters in the sampling to ensure they agree with the experimental conditions. You may also need to remove outlier peptides and rerun the sampling. An outlier might be a peptide that exchanges a lot while its neighbors barely exchange (examples in the tutorial dataset: 78-92 VDEAIAACGDVPEIM, 75-78 VKSV).\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pigeon_feather", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_sources/tutorials/05_plot_the_results.ipynb.txt b/_sources/tutorials/05_plot_the_results.ipynb.txt new file mode 100644 index 0000000..791aafb --- /dev/null +++ b/_sources/tutorials/05_plot_the_results.ipynb.txt @@ -0,0 +1,448 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 05_plot_the_results" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Determination of memory status is not supported on this \n", + " platform, measuring for memoryleaks will never fail\n" + ] + } + ], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "# load the pickle file we saved in the previous notebook\n", + "\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)\n", + "\n", + "\n", + "# back exchange correction for peptides with experimental full deuteration data based its closest match in the database\n", + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = f\"ecDHFR_results_{today_date}\"\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)\n", + "\n", + "\n", + "out_path = \"./data/PF_input_20240722\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create an `Analysis` object and load the results. **Note:** The temperature and pH are crucial for calculating the intrinsic exchange rates, so make sure to input the correct values. The chunk size and chunk number can be altered by the user. In this tutorial, they were automatically determined by a helper function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import Analysis, get_index_offset\n", + "from pigeon_feather.tools import optimal_chunks\n", + "import matplotlib.pyplot as plt\n", + "\n", + "RUN_NUM = 3\n", + "\n", + "apo_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"APO\"\n", + "]\n", + "\n", + "tri_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"TRI\"\n", + "]\n", + "\n", + "ana_apo_1 = Analysis(apo_states, temperature=293.0, pH=7.0)\n", + "\n", + "chunk_num, chunk_size = optimal_chunks(len(ana_apo_1.protein_sequence))\n", + "ana_apo_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"APO\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")\n", + "\n", + "\n", + "ana_tri_1 = Analysis(tri_states, temperature=293.0, pH=7.0)\n", + "\n", + "ana_tri_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"TRI\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## barplot of the kex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "barplot showing the FEATHER derived exchange rates. index_offset is determined by comparison to the sequence in HX/MS and the pdb file provided." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# APO state only\n", + "\n", + "import numpy as np\n", + "\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(40, 10), sharey=True, sharex=True)\n", + "\n", + "ana_apo_1.plot_kex_bar(\n", + " ax=axes[0], resolution_indicator_pos=15, label=\"APO\", show_seq=False, color=\"k\"\n", + ")\n", + "\n", + "ana_tri_1.plot_kex_bar(\n", + " ax=axes[1], resolution_indicator_pos=15, label=\"TRI\", show_seq=False, color=\"red\"\n", + ")\n", + "\n", + "from matplotlib.pyplot import step\n", + "from matplotlib.ticker import FuncFormatter, MultipleLocator\n", + "\n", + "from pigeon_feather.analysis import get_index_offset\n", + "\n", + "pdb_file = \"./data/6XG5_TRI.pdb\"\n", + "index_offset = get_index_offset(ana_apo_1, pdb_file)\n", + "\n", + "# # ax.xaxis.set_major_locator(plt.MultipleLocator(2))\n", + "axes[0].set_xticks(axes[0].get_xticks()[::2])\n", + "axes[0].set_xticklabels(axes[0].get_xticklabels(), fontdict={\"fontsize\": 24})\n", + "\n", + "\n", + "def format_func(value, tick_number):\n", + " return f\"{int(value - index_offset +1)}\"\n", + "\n", + "\n", + "axes[0].xaxis.set_major_formatter(FuncFormatter(format_func))\n", + "\n", + "seq_pos = 17\n", + "for ii in range(0, len(ana_apo_1.protein_sequence[:]), 2):\n", + " axes[0].text(\n", + " ii,\n", + " seq_pos,\n", + " ana_apo_1.protein_sequence[ii],\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " fontsize=22,\n", + " )\n", + "\n", + "\n", + "for ax in axes:\n", + " ax.set_ylabel(\"-log(k$_{ex}$)\")\n", + " #ax.legend(loc=\"lower left\")\n", + " ax.yaxis.set_major_locator(plt.MultipleLocator(5))\n", + "\n", + " ax.plot(\n", + " [-3, len(ana_apo_1.protein_sequence) + 3],\n", + " [5, 5],\n", + " color=\"gray\",\n", + " lw=1,\n", + " linestyle=\"--\",\n", + " alpha=0.5,\n", + " )\n", + " ax.plot(\n", + " [-3, len(ana_apo_1.protein_sequence) + 3],\n", + " [10, 10],\n", + " color=\"gray\",\n", + " lw=1,\n", + " linestyle=\"--\",\n", + " alpha=0.5,\n", + " )\n", + "\n", + "\n", + "plt.subplots_adjust(hspace=0.08)\n", + "fig.savefig(f\"{results_path}/ecDHFR_kex_bar_APO_TRI_{today_date}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "logP projection to a pdb structure" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import BFactorPlot" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "bfactor_plot = BFactorPlot(\n", + " ana_apo_1,\n", + " pdb_file=\"./data/6XG5_TRI.pdb\",\n", + " plot_deltaG=True,\n", + " temperature=293.15,\n", + " logP_threshold=10,\n", + ")\n", + "bfactor_plot.plot(f\"{results_path}/6XG5_APO_deltaG.pdb\")\n", + "\n", + "# bfactor_plot = BFactorPlot(\n", + "# ana_apo_1,\n", + "# pdb_file=\"./data/6XG5_APO_relaxed_best_solvated.pdb\",\n", + "# plot_deltaG=True,\n", + "# temperature=293.15,\n", + "# )\n", + "# bfactor_plot.plot(f\"{out_path}/6XG5_APO_deltaG.pdb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## delta log(PF)s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "if there are mutiple states availble, you can map the difference to the pdb strutcure" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "bfactor_plot = BFactorPlot(\n", + " ana_apo_1,\n", + " ana_tri_1, \n", + " pdb_file=\"./data/6XG5_TRI.pdb\",\n", + " plot_deltaG=True,\n", + " temperature=293.15,\n", + " logP_threshold=10,\n", + ")\n", + "bfactor_plot.plot(f\"{results_path}/6XG5_deltaG_APO-TRI.pdb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can visualize the results in PyMOL by running the following commands:\n", + "\n", + "```bash\n", + "spectrum b, green_white_magenta, minimum=-20, maximum=20; select nans, not (b=0 or b>0 or b<0); color grey20, nans;\n", + "```\n", + "\n", + "`nans` are Prolines and residues with no coverage." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "export logPFs to a csv" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import MDAnalysis\n", + "from pigeon_feather.analysis import get_res_avg_logP, get_res_avg_logP_std\n", + "\n", + "pdb_file = \"./data/6XG5_TRI.pdb\"\n", + "index_offset = get_index_offset(ana_apo_1, pdb_file)\n", + "\n", + "\n", + "def logPF_to_deltaG(ana_obj, logPF):\n", + " \"\"\"\n", + " :param logPF: logP value\n", + " :return: deltaG in kJ/mol, local unfolding energy\n", + " \"\"\"\n", + "\n", + " return 8.3145 * ana_obj.temperature * np.log(10) * logPF / 1000\n", + "\n", + "\n", + "def create_logP_df(ana_obj, index_offset):\n", + " df_logPF = pd.DataFrame()\n", + "\n", + " for res_i, _ in enumerate(ana_obj.results_obj.protein_sequence):\n", + " res_obj_i = ana_obj.results_obj.get_residue_by_resindex(res_i)\n", + "\n", + " avg_logP, std_logP = get_res_avg_logP(res_obj_i)\n", + " #std_logP = get_res_avg_logP_std(res_obj_i)\n", + "\n", + " df_i = pd.DataFrame(\n", + " {\n", + " \"resid\": [res_obj_i.resid - index_offset],\n", + " #\"resname\": [res_obj_i.resname],\n", + " \"resname\": [MDAnalysis.lib.util.convert_aa_code(res_obj_i.resname)],\n", + " 'avg_dG': [logPF_to_deltaG(ana_obj, avg_logP)],\n", + " 'std_dG': [logPF_to_deltaG(ana_obj, std_logP)],\n", + " \"avg_logP\": [avg_logP],\n", + " \"std_logP\": [max(std_logP, 0.35)],\n", + " \"is_nan\": [res_obj_i.is_nan()],\n", + " }\n", + " )\n", + "\n", + " if res_obj_i.is_nan():\n", + " df_i[\"single resloved\"] = [np.nan]\n", + " df_i[\"min_pep logPs\"] = [np.nan]\n", + "\n", + " else:\n", + " df_i[\"single resloved\"] = [res_obj_i.mini_pep.if_single_residue()]\n", + " df_i[\"min_pep logPs\"] = [res_obj_i.clustering_results_logP]\n", + "\n", + " df_logPF = pd.concat([df_logPF, df_i])\n", + "\n", + " df_logPF = df_logPF.reset_index(drop=True)\n", + "\n", + " return df_logPF\n", + "\n", + "\n", + "df = create_logP_df(ana_apo_1, index_offset)\n", + "df.to_csv(f\"{results_path}/logP_APO_{today_date}.csv\", index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# fecth two df and merge\n", + "df_apo = create_logP_df(ana_apo_1, index_offset)\n", + "df_tri = create_logP_df(ana_tri_1, index_offset)\n", + "\n", + "df = pd.merge(df_apo, df_tri, on=\"resid\", suffixes=(\"_APO\", \"_TRI\"))\n", + "\n", + "df.to_csv(f\"{results_path}/logP_APO_TRI_{today_date}.csv\", index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pigeon_feather", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/_static/_sphinx_javascript_frameworks_compat.js b/_static/_sphinx_javascript_frameworks_compat.js new file mode 100644 index 0000000..8141580 --- /dev/null +++ b/_static/_sphinx_javascript_frameworks_compat.js @@ -0,0 +1,123 @@ +/* Compatability shim for jQuery and underscores.js. + * + * Copyright Sphinx contributors + * Released under the two clause BSD licence + */ + +/** + * small helper function to urldecode strings + * + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/decodeURIComponent#Decoding_query_parameters_from_a_URL + */ +jQuery.urldecode = function(x) { + if (!x) { + return x + } + return decodeURIComponent(x.replace(/\+/g, ' ')); +}; + +/** + * small helper function to urlencode strings + */ +jQuery.urlencode = encodeURIComponent; + +/** + * This function returns the parsed url parameters of the + * current request. Multiple values per key are supported, + * it will always return arrays of strings for the value parts. + */ +jQuery.getQueryParameters = function(s) { + if (typeof s === 'undefined') + s = document.location.search; + var parts = s.substr(s.indexOf('?') + 1).split('&'); + var result = {}; + for (var i = 0; i < parts.length; i++) { + var tmp = parts[i].split('=', 2); + var key = jQuery.urldecode(tmp[0]); + var value = jQuery.urldecode(tmp[1]); + if (key in result) + result[key].push(value); + else + result[key] = [value]; + } + return result; +}; + +/** + * highlight a given string on a jquery object by wrapping it in + * span elements with the given class name. + */ +jQuery.fn.highlightText = function(text, className) { + function highlight(node, addItems) { + if (node.nodeType === 3) { + var val = node.nodeValue; + var pos = val.toLowerCase().indexOf(text); + if (pos >= 0 && + !jQuery(node.parentNode).hasClass(className) && + !jQuery(node.parentNode).hasClass("nohighlight")) { + var span; + var isInSVG = jQuery(node).closest("body, svg, foreignObject").is("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.className = className; + } + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + node.parentNode.insertBefore(span, node.parentNode.insertBefore( + document.createTextNode(val.substr(pos + text.length)), + node.nextSibling)); + node.nodeValue = val.substr(0, pos); + if (isInSVG) { + var rect = document.createElementNS("http://www.w3.org/2000/svg", "rect"); + var bbox = node.parentElement.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute('class', className); + addItems.push({ + "parent": node.parentNode, + "target": rect}); + } + } + } + else if (!jQuery(node).is("button, select, textarea")) { + jQuery.each(node.childNodes, function() { + highlight(this, addItems); + }); + } + } + var addItems = []; + var result = this.each(function() { + highlight(this, addItems); + }); + for (var i = 0; i < addItems.length; ++i) { + jQuery(addItems[i].parent).before(addItems[i].target); + } + return result; +}; + +/* + * backward compatibility for jQuery.browser + * This will be supported until firefox bug is fixed. + */ +if (!jQuery.browser) { + jQuery.uaMatch = function(ua) { + ua = ua.toLowerCase(); + + var match = /(chrome)[ \/]([\w.]+)/.exec(ua) || + /(webkit)[ \/]([\w.]+)/.exec(ua) || + /(opera)(?:.*version|)[ \/]([\w.]+)/.exec(ua) || + /(msie) ([\w.]+)/.exec(ua) || + ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec(ua) || + []; + + return { + browser: match[ 1 ] || "", + version: match[ 2 ] || "0" + }; + }; + jQuery.browser = {}; + jQuery.browser[jQuery.uaMatch(navigator.userAgent).browser] = true; +} diff --git a/_static/basic.css b/_static/basic.css new file mode 100644 index 0000000..f316efc --- /dev/null +++ b/_static/basic.css @@ -0,0 +1,925 @@ +/* + * basic.css + * ~~~~~~~~~ + * + * Sphinx stylesheet -- basic theme. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ + +/* -- main layout ----------------------------------------------------------- */ + +div.clearer { + clear: both; +} + +div.section::after { + display: block; + content: ''; + clear: left; +} + +/* -- relbar ---------------------------------------------------------------- */ + +div.related { + width: 100%; + font-size: 90%; +} + +div.related h3 { + display: none; +} + +div.related ul { + margin: 0; + padding: 0 0 0 10px; + list-style: none; +} + +div.related li { + display: inline; +} + +div.related li.right { + float: right; + margin-right: 5px; +} + +/* -- sidebar --------------------------------------------------------------- */ + +div.sphinxsidebarwrapper { + padding: 10px 5px 0 10px; +} + +div.sphinxsidebar { + float: left; + width: 230px; + margin-left: -100%; + font-size: 90%; + word-wrap: break-word; + overflow-wrap : break-word; +} + +div.sphinxsidebar ul { + list-style: none; +} + +div.sphinxsidebar ul ul, +div.sphinxsidebar ul.want-points { + margin-left: 20px; + list-style: square; +} + +div.sphinxsidebar ul ul { + margin-top: 0; + margin-bottom: 0; +} + +div.sphinxsidebar form { + margin-top: 10px; +} + +div.sphinxsidebar input { + border: 1px solid #98dbcc; + font-family: sans-serif; + font-size: 1em; +} + +div.sphinxsidebar #searchbox form.search { + overflow: hidden; +} + +div.sphinxsidebar #searchbox input[type="text"] { + float: left; + width: 80%; + padding: 0.25em; + box-sizing: border-box; +} + +div.sphinxsidebar #searchbox input[type="submit"] { + float: left; + width: 20%; + border-left: none; + padding: 0.25em; + box-sizing: border-box; +} + + +img { + border: 0; + max-width: 100%; +} + +/* -- search page ----------------------------------------------------------- */ + +ul.search { + margin: 10px 0 0 20px; + padding: 0; +} + +ul.search li { + padding: 5px 0 5px 20px; + background-image: url(file.png); + background-repeat: no-repeat; + background-position: 0 7px; +} + +ul.search li a { + font-weight: bold; +} + +ul.search li p.context { + color: #888; + margin: 2px 0 0 30px; + text-align: left; +} + +ul.keywordmatches li.goodmatch a { + font-weight: bold; +} + +/* -- index page ------------------------------------------------------------ */ + +table.contentstable { + width: 90%; + margin-left: auto; + margin-right: auto; +} + +table.contentstable p.biglink { + line-height: 150%; +} + +a.biglink { + font-size: 1.3em; +} + +span.linkdescr { + font-style: italic; + padding-top: 5px; + font-size: 90%; +} + +/* -- general index --------------------------------------------------------- */ + +table.indextable { + width: 100%; +} + +table.indextable td { + text-align: left; + vertical-align: top; +} + +table.indextable ul { + margin-top: 0; + margin-bottom: 0; + list-style-type: none; +} + +table.indextable > tbody > tr > td > ul { + padding-left: 0em; +} + +table.indextable tr.pcap { + height: 10px; +} + +table.indextable tr.cap { + margin-top: 10px; + background-color: #f2f2f2; +} + +img.toggler { + margin-right: 3px; + margin-top: 3px; + cursor: pointer; +} + +div.modindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +div.genindex-jumpbox { + border-top: 1px solid #ddd; + border-bottom: 1px solid #ddd; + margin: 1em 0 1em 0; + padding: 0.4em; +} + +/* -- domain module index --------------------------------------------------- */ + +table.modindextable td { + padding: 2px; + border-collapse: collapse; +} + +/* -- general body styles --------------------------------------------------- */ + +div.body { + min-width: 360px; + max-width: 800px; +} + +div.body p, div.body dd, div.body li, div.body blockquote { + -moz-hyphens: auto; + -ms-hyphens: auto; + -webkit-hyphens: auto; + hyphens: auto; +} + +a.headerlink { + visibility: hidden; +} + +a:visited { + color: #551A8B; +} + +h1:hover > a.headerlink, +h2:hover > a.headerlink, +h3:hover > a.headerlink, +h4:hover > a.headerlink, +h5:hover > a.headerlink, +h6:hover > a.headerlink, +dt:hover > a.headerlink, +caption:hover > a.headerlink, +p.caption:hover > a.headerlink, +div.code-block-caption:hover > a.headerlink { + visibility: visible; +} + +div.body p.caption { + text-align: inherit; +} + +div.body td { + text-align: left; +} + +.first { + margin-top: 0 !important; +} + +p.rubric { + margin-top: 30px; + font-weight: bold; +} + +img.align-left, figure.align-left, .figure.align-left, object.align-left { + clear: left; + float: left; + margin-right: 1em; +} + +img.align-right, figure.align-right, .figure.align-right, object.align-right { + clear: right; + float: right; + margin-left: 1em; +} + +img.align-center, figure.align-center, .figure.align-center, object.align-center { + display: block; + margin-left: auto; + margin-right: auto; +} + +img.align-default, figure.align-default, .figure.align-default { + display: block; + margin-left: auto; + margin-right: auto; +} + +.align-left { + text-align: left; +} + +.align-center { + text-align: center; +} + +.align-default { + text-align: center; +} + +.align-right { + text-align: right; +} + +/* -- sidebars -------------------------------------------------------------- */ + +div.sidebar, +aside.sidebar { + margin: 0 0 0.5em 1em; + border: 1px solid #ddb; + padding: 7px; + background-color: #ffe; + width: 40%; + float: right; + clear: right; + overflow-x: auto; +} + +p.sidebar-title { + font-weight: bold; +} + +nav.contents, +aside.topic, +div.admonition, div.topic, blockquote { + clear: left; +} + +/* -- topics ---------------------------------------------------------------- */ + +nav.contents, +aside.topic, +div.topic { + border: 1px solid #ccc; + padding: 7px; + margin: 10px 0 10px 0; +} + +p.topic-title { + font-size: 1.1em; + font-weight: bold; + margin-top: 10px; +} + +/* -- admonitions ----------------------------------------------------------- */ + +div.admonition { + margin-top: 10px; + margin-bottom: 10px; + padding: 7px; +} + +div.admonition dt { + font-weight: bold; +} + +p.admonition-title { + margin: 0px 10px 5px 0px; + font-weight: bold; +} + +div.body p.centered { + text-align: center; + margin-top: 25px; +} + +/* -- content of sidebars/topics/admonitions -------------------------------- */ + +div.sidebar > :last-child, +aside.sidebar > :last-child, +nav.contents > :last-child, +aside.topic > :last-child, +div.topic > :last-child, +div.admonition > :last-child { + margin-bottom: 0; +} + +div.sidebar::after, +aside.sidebar::after, +nav.contents::after, +aside.topic::after, +div.topic::after, +div.admonition::after, +blockquote::after { + display: block; + content: ''; + clear: both; +} + +/* -- tables ---------------------------------------------------------------- */ + +table.docutils { + margin-top: 10px; + margin-bottom: 10px; + border: 0; + border-collapse: collapse; +} + +table.align-center { + margin-left: auto; + margin-right: auto; +} + +table.align-default { + margin-left: auto; + margin-right: auto; +} + +table caption span.caption-number { + font-style: italic; +} + +table caption span.caption-text { +} + +table.docutils td, table.docutils th { + padding: 1px 8px 1px 5px; + border-top: 0; + border-left: 0; + border-right: 0; + border-bottom: 1px solid #aaa; +} + +th { + text-align: left; + padding-right: 5px; +} + +table.citation { + border-left: solid 1px gray; + margin-left: 1px; +} + +table.citation td { + border-bottom: none; +} + +th > :first-child, +td > :first-child { + margin-top: 0px; +} + +th > :last-child, +td > :last-child { + margin-bottom: 0px; +} + +/* -- figures --------------------------------------------------------------- */ + +div.figure, figure { + margin: 0.5em; + padding: 0.5em; +} + +div.figure p.caption, figcaption { + padding: 0.3em; +} + +div.figure p.caption span.caption-number, +figcaption span.caption-number { + font-style: italic; +} + +div.figure p.caption span.caption-text, +figcaption span.caption-text { +} + +/* -- field list styles ----------------------------------------------------- */ + +table.field-list td, table.field-list th { + border: 0 !important; +} + +.field-list ul { + margin: 0; + padding-left: 1em; +} + +.field-list p { + margin: 0; +} + +.field-name { + -moz-hyphens: manual; + -ms-hyphens: manual; + -webkit-hyphens: manual; + hyphens: manual; +} + +/* -- hlist styles ---------------------------------------------------------- */ + +table.hlist { + margin: 1em 0; +} + +table.hlist td { + vertical-align: top; +} + +/* -- object description styles --------------------------------------------- */ + +.sig { + font-family: 'Consolas', 'Menlo', 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', monospace; +} + +.sig-name, code.descname { + background-color: transparent; + font-weight: bold; +} + +.sig-name { + font-size: 1.1em; +} + +code.descname { + font-size: 1.2em; +} + +.sig-prename, code.descclassname { + background-color: transparent; +} + +.optional { + font-size: 1.3em; +} + +.sig-paren { + font-size: larger; +} + +.sig-param.n { + font-style: italic; +} + +/* C++ specific styling */ + +.sig-inline.c-texpr, +.sig-inline.cpp-texpr { + font-family: unset; +} + +.sig.c .k, .sig.c .kt, +.sig.cpp .k, .sig.cpp .kt { + color: #0033B3; +} + +.sig.c .m, +.sig.cpp .m { + color: #1750EB; +} + +.sig.c .s, .sig.c .sc, +.sig.cpp .s, .sig.cpp .sc { + color: #067D17; +} + + +/* -- other body styles ----------------------------------------------------- */ + +ol.arabic { + list-style: decimal; +} + +ol.loweralpha { + list-style: lower-alpha; +} + +ol.upperalpha { + list-style: upper-alpha; +} + +ol.lowerroman { + list-style: lower-roman; +} + +ol.upperroman { + list-style: upper-roman; +} + +:not(li) > ol > li:first-child > :first-child, +:not(li) > ul > li:first-child > :first-child { + margin-top: 0px; +} + +:not(li) > ol > li:last-child > :last-child, +:not(li) > ul > li:last-child > :last-child { + margin-bottom: 0px; +} + +ol.simple ol p, +ol.simple ul p, +ul.simple ol p, +ul.simple ul p { + margin-top: 0; +} + +ol.simple > li:not(:first-child) > p, +ul.simple > li:not(:first-child) > p { + margin-top: 0; +} + +ol.simple p, +ul.simple p { + margin-bottom: 0; +} + +aside.footnote > span, +div.citation > span { + float: left; +} +aside.footnote > span:last-of-type, +div.citation > span:last-of-type { + padding-right: 0.5em; +} +aside.footnote > p { + margin-left: 2em; +} +div.citation > p { + margin-left: 4em; +} +aside.footnote > p:last-of-type, +div.citation > p:last-of-type { + margin-bottom: 0em; +} +aside.footnote > p:last-of-type:after, +div.citation > p:last-of-type:after { + content: ""; + clear: both; +} + +dl.field-list { + display: grid; + grid-template-columns: fit-content(30%) auto; +} + +dl.field-list > dt { + font-weight: bold; + word-break: break-word; + padding-left: 0.5em; + padding-right: 5px; +} + +dl.field-list > dd { + padding-left: 0.5em; + margin-top: 0em; + margin-left: 0em; + margin-bottom: 0em; +} + +dl { + margin-bottom: 15px; +} + +dd > :first-child { + margin-top: 0px; +} + +dd ul, dd table { + margin-bottom: 10px; +} + +dd { + margin-top: 3px; + margin-bottom: 10px; + margin-left: 30px; +} + +.sig dd { + margin-top: 0px; + margin-bottom: 0px; +} + +.sig dl { + margin-top: 0px; + margin-bottom: 0px; +} + +dl > dd:last-child, +dl > dd:last-child > :last-child { + margin-bottom: 0; +} + +dt:target, span.highlighted { + background-color: #fbe54e; +} + +rect.highlighted { + fill: #fbe54e; +} + +dl.glossary dt { + font-weight: bold; + font-size: 1.1em; +} + +.versionmodified { + font-style: italic; +} + +.system-message { + background-color: #fda; + padding: 5px; + border: 3px solid red; +} + +.footnote:target { + background-color: #ffa; +} + +.line-block { + display: block; + margin-top: 1em; + margin-bottom: 1em; +} + +.line-block .line-block { + margin-top: 0; + margin-bottom: 0; + margin-left: 1.5em; +} + +.guilabel, .menuselection { + font-family: sans-serif; +} + +.accelerator { + text-decoration: underline; +} + +.classifier { + font-style: oblique; +} + +.classifier:before { + font-style: normal; + margin: 0 0.5em; + content: ":"; + display: inline-block; +} + +abbr, acronym { + border-bottom: dotted 1px; + cursor: help; +} + +.translated { + background-color: rgba(207, 255, 207, 0.2) +} + +.untranslated { + background-color: rgba(255, 207, 207, 0.2) +} + +/* -- code displays --------------------------------------------------------- */ + +pre { + overflow: auto; + overflow-y: hidden; /* fixes display issues on Chrome browsers */ +} + +pre, div[class*="highlight-"] { + clear: both; +} + +span.pre { + -moz-hyphens: none; + -ms-hyphens: none; + -webkit-hyphens: none; + hyphens: none; + white-space: nowrap; +} + +div[class*="highlight-"] { + margin: 1em 0; +} + +td.linenos pre { + border: 0; + background-color: transparent; + color: #aaa; +} + +table.highlighttable { + display: block; +} + +table.highlighttable tbody { + display: block; +} + +table.highlighttable tr { + display: flex; +} + +table.highlighttable td { + margin: 0; + padding: 0; +} + +table.highlighttable td.linenos { + padding-right: 0.5em; +} + +table.highlighttable td.code { + flex: 1; + overflow: hidden; +} + +.highlight .hll { + display: block; +} + +div.highlight pre, +table.highlighttable pre { + margin: 0; +} + +div.code-block-caption + div { + margin-top: 0; +} + +div.code-block-caption { + margin-top: 1em; + padding: 2px 5px; + font-size: small; +} + +div.code-block-caption code { + background-color: transparent; +} + +table.highlighttable td.linenos, +span.linenos, +div.highlight span.gp { /* gp: Generic.Prompt */ + user-select: none; + -webkit-user-select: text; /* Safari fallback only */ + -webkit-user-select: none; /* Chrome/Safari */ + -moz-user-select: none; /* Firefox */ + -ms-user-select: none; /* IE10+ */ +} + +div.code-block-caption span.caption-number { + padding: 0.1em 0.3em; + font-style: italic; +} + +div.code-block-caption span.caption-text { +} + +div.literal-block-wrapper { + margin: 1em 0; +} + +code.xref, a code { + background-color: transparent; + font-weight: bold; +} + +h1 code, h2 code, h3 code, h4 code, h5 code, h6 code { + background-color: transparent; +} + +.viewcode-link { + float: right; +} + +.viewcode-back { + float: right; + font-family: sans-serif; +} + +div.viewcode-block:target { + margin: -1px -10px; + padding: 0 10px; +} + +/* -- math display ---------------------------------------------------------- */ + +img.math { + vertical-align: middle; +} + +div.body div.math p { + text-align: center; +} + +span.eqno { + float: right; +} + +span.eqno a.headerlink { + position: absolute; + z-index: 1; +} + +div.math:hover a.headerlink { + visibility: visible; +} + +/* -- printout stylesheet --------------------------------------------------- */ + +@media print { + div.document, + div.documentwrapper, + div.bodywrapper { + margin: 0 !important; + width: 100%; + } + + div.sphinxsidebar, + div.related, + div.footer, + #top-link { + display: none; + } +} \ No newline at end of file diff --git a/_static/check-solid.svg b/_static/check-solid.svg new file mode 100644 index 0000000..92fad4b --- /dev/null +++ b/_static/check-solid.svg @@ -0,0 +1,4 @@ + + + + diff --git a/_static/clipboard.min.js b/_static/clipboard.min.js new file mode 100644 index 0000000..54b3c46 --- /dev/null +++ b/_static/clipboard.min.js @@ -0,0 +1,7 @@ +/*! + * clipboard.js v2.0.8 + * https://clipboardjs.com/ + * + * Licensed MIT © Zeno Rocha + */ +!function(t,e){"object"==typeof exports&&"object"==typeof module?module.exports=e():"function"==typeof define&&define.amd?define([],e):"object"==typeof exports?exports.ClipboardJS=e():t.ClipboardJS=e()}(this,function(){return n={686:function(t,e,n){"use strict";n.d(e,{default:function(){return o}});var e=n(279),i=n.n(e),e=n(370),u=n.n(e),e=n(817),c=n.n(e);function a(t){try{return document.execCommand(t)}catch(t){return}}var f=function(t){t=c()(t);return a("cut"),t};var l=function(t){var e,n,o,r=1 + + + + diff --git a/_static/copybutton.css b/_static/copybutton.css new file mode 100644 index 0000000..f1916ec --- /dev/null +++ b/_static/copybutton.css @@ -0,0 +1,94 @@ +/* Copy buttons */ +button.copybtn { + position: absolute; + display: flex; + top: .3em; + right: .3em; + width: 1.7em; + height: 1.7em; + opacity: 0; + transition: opacity 0.3s, border .3s, background-color .3s; + user-select: none; + padding: 0; + border: none; + outline: none; + border-radius: 0.4em; + /* The colors that GitHub uses */ + border: #1b1f2426 1px solid; + background-color: #f6f8fa; + color: #57606a; +} + +button.copybtn.success { + border-color: #22863a; + color: #22863a; +} + +button.copybtn svg { + stroke: currentColor; + width: 1.5em; + height: 1.5em; + padding: 0.1em; +} + +div.highlight { + position: relative; +} + +/* Show the copybutton */ +.highlight:hover button.copybtn, button.copybtn.success { + opacity: 1; +} + +.highlight button.copybtn:hover { + background-color: rgb(235, 235, 235); +} + +.highlight button.copybtn:active { + background-color: rgb(187, 187, 187); +} + +/** + * A minimal CSS-only tooltip copied from: + * https://codepen.io/mildrenben/pen/rVBrpK + * + * To use, write HTML like the following: + * + *

Short

+ */ + .o-tooltip--left { + position: relative; + } + + .o-tooltip--left:after { + opacity: 0; + visibility: hidden; + position: absolute; + content: attr(data-tooltip); + padding: .2em; + font-size: .8em; + left: -.2em; + background: grey; + color: white; + white-space: nowrap; + z-index: 2; + border-radius: 2px; + transform: translateX(-102%) translateY(0); + transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); +} + +.o-tooltip--left:hover:after { + display: block; + opacity: 1; + visibility: visible; + transform: translateX(-100%) translateY(0); + transition: opacity 0.2s cubic-bezier(0.64, 0.09, 0.08, 1), transform 0.2s cubic-bezier(0.64, 0.09, 0.08, 1); + transition-delay: .5s; +} + +/* By default the copy button shouldn't show up when printing a page */ +@media print { + button.copybtn { + display: none; + } +} diff --git a/_static/copybutton.js b/_static/copybutton.js new file mode 100644 index 0000000..2ea7ff3 --- /dev/null +++ b/_static/copybutton.js @@ -0,0 +1,248 @@ +// Localization support +const messages = { + 'en': { + 'copy': 'Copy', + 'copy_to_clipboard': 'Copy to clipboard', + 'copy_success': 'Copied!', + 'copy_failure': 'Failed to copy', + }, + 'es' : { + 'copy': 'Copiar', + 'copy_to_clipboard': 'Copiar al portapapeles', + 'copy_success': '¡Copiado!', + 'copy_failure': 'Error al copiar', + }, + 'de' : { + 'copy': 'Kopieren', + 'copy_to_clipboard': 'In die Zwischenablage kopieren', + 'copy_success': 'Kopiert!', + 'copy_failure': 'Fehler beim Kopieren', + }, + 'fr' : { + 'copy': 'Copier', + 'copy_to_clipboard': 'Copier dans le presse-papier', + 'copy_success': 'Copié !', + 'copy_failure': 'Échec de la copie', + }, + 'ru': { + 'copy': 'Скопировать', + 'copy_to_clipboard': 'Скопировать в буфер', + 'copy_success': 'Скопировано!', + 'copy_failure': 'Не удалось скопировать', + }, + 'zh-CN': { + 'copy': '复制', + 'copy_to_clipboard': '复制到剪贴板', + 'copy_success': '复制成功!', + 'copy_failure': '复制失败', + }, + 'it' : { + 'copy': 'Copiare', + 'copy_to_clipboard': 'Copiato negli appunti', + 'copy_success': 'Copiato!', + 'copy_failure': 'Errore durante la copia', + } +} + +let locale = 'en' +if( document.documentElement.lang !== undefined + && messages[document.documentElement.lang] !== undefined ) { + locale = document.documentElement.lang +} + +let doc_url_root = DOCUMENTATION_OPTIONS.URL_ROOT; +if (doc_url_root == '#') { + doc_url_root = ''; +} + +/** + * SVG files for our copy buttons + */ +let iconCheck = ` + ${messages[locale]['copy_success']} + + +` + +// If the user specified their own SVG use that, otherwise use the default +let iconCopy = ``; +if (!iconCopy) { + iconCopy = ` + ${messages[locale]['copy_to_clipboard']} + + + +` +} + +/** + * Set up copy/paste for code blocks + */ + +const runWhenDOMLoaded = cb => { + if (document.readyState != 'loading') { + cb() + } else if (document.addEventListener) { + document.addEventListener('DOMContentLoaded', cb) + } else { + document.attachEvent('onreadystatechange', function() { + if (document.readyState == 'complete') cb() + }) + } +} + +const codeCellId = index => `codecell${index}` + +// Clears selected text since ClipboardJS will select the text when copying +const clearSelection = () => { + if (window.getSelection) { + window.getSelection().removeAllRanges() + } else if (document.selection) { + document.selection.empty() + } +} + +// Changes tooltip text for a moment, then changes it back +// We want the timeout of our `success` class to be a bit shorter than the +// tooltip and icon change, so that we can hide the icon before changing back. +var timeoutIcon = 2000; +var timeoutSuccessClass = 1500; + +const temporarilyChangeTooltip = (el, oldText, newText) => { + el.setAttribute('data-tooltip', newText) + el.classList.add('success') + // Remove success a little bit sooner than we change the tooltip + // So that we can use CSS to hide the copybutton first + setTimeout(() => el.classList.remove('success'), timeoutSuccessClass) + setTimeout(() => el.setAttribute('data-tooltip', oldText), timeoutIcon) +} + +// Changes the copy button icon for two seconds, then changes it back +const temporarilyChangeIcon = (el) => { + el.innerHTML = iconCheck; + setTimeout(() => {el.innerHTML = iconCopy}, timeoutIcon) +} + +const addCopyButtonToCodeCells = () => { + // If ClipboardJS hasn't loaded, wait a bit and try again. This + // happens because we load ClipboardJS asynchronously. + if (window.ClipboardJS === undefined) { + setTimeout(addCopyButtonToCodeCells, 250) + return + } + + // Add copybuttons to all of our code cells + const COPYBUTTON_SELECTOR = 'div.highlight pre'; + const codeCells = document.querySelectorAll(COPYBUTTON_SELECTOR) + codeCells.forEach((codeCell, index) => { + const id = codeCellId(index) + codeCell.setAttribute('id', id) + + const clipboardButton = id => + `` + codeCell.insertAdjacentHTML('afterend', clipboardButton(id)) + }) + +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string +} + +/** + * Removes excluded text from a Node. + * + * @param {Node} target Node to filter. + * @param {string} exclude CSS selector of nodes to exclude. + * @returns {DOMString} Text from `target` with text removed. + */ +function filterText(target, exclude) { + const clone = target.cloneNode(true); // clone as to not modify the live DOM + if (exclude) { + // remove excluded nodes + clone.querySelectorAll(exclude).forEach(node => node.remove()); + } + return clone.innerText; +} + +// Callback when a copy button is clicked. Will be passed the node that was clicked +// should then grab the text and replace pieces of text that shouldn't be used in output +function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { + var regexp; + var match; + + // Do we check for line continuation characters and "HERE-documents"? + var useLineCont = !!lineContinuationChar + var useHereDoc = !!hereDocDelim + + // create regexp to capture prompt and remaining line + if (isRegexp) { + regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') + } else { + regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') + } + + const outputLines = []; + var promptFound = false; + var gotLineCont = false; + var gotHereDoc = false; + const lineGotPrompt = []; + for (const line of textContent.split('\n')) { + match = line.match(regexp) + if (match || gotLineCont || gotHereDoc) { + promptFound = regexp.test(line) + lineGotPrompt.push(promptFound) + if (removePrompts && promptFound) { + outputLines.push(match[2]) + } else { + outputLines.push(line) + } + gotLineCont = line.endsWith(lineContinuationChar) & useLineCont + if (line.includes(hereDocDelim) & useHereDoc) + gotHereDoc = !gotHereDoc + } else if (!onlyCopyPromptLines) { + outputLines.push(line) + } else if (copyEmptyLines && line.trim() === '') { + outputLines.push(line) + } + } + + // If no lines with the prompt were found then just use original lines + if (lineGotPrompt.some(v => v === true)) { + textContent = outputLines.join('\n'); + } + + // Remove a trailing newline to avoid auto-running when pasting + if (textContent.endsWith("\n")) { + textContent = textContent.slice(0, -1) + } + return textContent +} + + +var copyTargetText = (trigger) => { + var target = document.querySelector(trigger.attributes['data-clipboard-target'].value); + + // get filtered text + let exclude = '.linenos'; + + let text = filterText(target, exclude); + return formatCopyText(text, '', false, true, true, true, '', '') +} + + // Initialize with a callback so we can modify the text before copy + const clipboard = new ClipboardJS('.copybtn', {text: copyTargetText}) + + // Update UI with error/success messages + clipboard.on('success', event => { + clearSelection() + temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_success']) + temporarilyChangeIcon(event.trigger) + }) + + clipboard.on('error', event => { + temporarilyChangeTooltip(event.trigger, messages[locale]['copy'], messages[locale]['copy_failure']) + }) +} + +runWhenDOMLoaded(addCopyButtonToCodeCells) \ No newline at end of file diff --git a/_static/copybutton_funcs.js b/_static/copybutton_funcs.js new file mode 100644 index 0000000..dbe1aaa --- /dev/null +++ b/_static/copybutton_funcs.js @@ -0,0 +1,73 @@ +function escapeRegExp(string) { + return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string +} + +/** + * Removes excluded text from a Node. + * + * @param {Node} target Node to filter. + * @param {string} exclude CSS selector of nodes to exclude. + * @returns {DOMString} Text from `target` with text removed. + */ +export function filterText(target, exclude) { + const clone = target.cloneNode(true); // clone as to not modify the live DOM + if (exclude) { + // remove excluded nodes + clone.querySelectorAll(exclude).forEach(node => node.remove()); + } + return clone.innerText; +} + +// Callback when a copy button is clicked. Will be passed the node that was clicked +// should then grab the text and replace pieces of text that shouldn't be used in output +export function formatCopyText(textContent, copybuttonPromptText, isRegexp = false, onlyCopyPromptLines = true, removePrompts = true, copyEmptyLines = true, lineContinuationChar = "", hereDocDelim = "") { + var regexp; + var match; + + // Do we check for line continuation characters and "HERE-documents"? + var useLineCont = !!lineContinuationChar + var useHereDoc = !!hereDocDelim + + // create regexp to capture prompt and remaining line + if (isRegexp) { + regexp = new RegExp('^(' + copybuttonPromptText + ')(.*)') + } else { + regexp = new RegExp('^(' + escapeRegExp(copybuttonPromptText) + ')(.*)') + } + + const outputLines = []; + var promptFound = false; + var gotLineCont = false; + var gotHereDoc = false; + const lineGotPrompt = []; + for (const line of textContent.split('\n')) { + match = line.match(regexp) + if (match || gotLineCont || gotHereDoc) { + promptFound = regexp.test(line) + lineGotPrompt.push(promptFound) + if (removePrompts && promptFound) { + outputLines.push(match[2]) + } else { + outputLines.push(line) + } + gotLineCont = line.endsWith(lineContinuationChar) & useLineCont + if (line.includes(hereDocDelim) & useHereDoc) + gotHereDoc = !gotHereDoc + } else if (!onlyCopyPromptLines) { + outputLines.push(line) + } else if (copyEmptyLines && line.trim() === '') { + outputLines.push(line) + } + } + + // If no lines with the prompt were found then just use original lines + if (lineGotPrompt.some(v => v === true)) { + textContent = outputLines.join('\n'); + } + + // Remove a trailing newline to avoid auto-running when pasting + if (textContent.endsWith("\n")) { + textContent = textContent.slice(0, -1) + } + return textContent +} diff --git a/_static/css/badge_only.css b/_static/css/badge_only.css new file mode 100644 index 0000000..c718cee --- /dev/null +++ b/_static/css/badge_only.css @@ -0,0 +1 @@ +.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}@font-face{font-family:FontAwesome;font-style:normal;font-weight:400;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#FontAwesome) format("svg")}.fa:before{font-family:FontAwesome;font-style:normal;font-weight:400;line-height:1}.fa:before,a .fa{text-decoration:inherit}.fa:before,a .fa,li .fa{display:inline-block}li .fa-large:before{width:1.875em}ul.fas{list-style-type:none;margin-left:2em;text-indent:-.8em}ul.fas li .fa{width:.8em}ul.fas li .fa-large:before{vertical-align:baseline}.fa-book:before,.icon-book:before{content:"\f02d"}.fa-caret-down:before,.icon-caret-down:before{content:"\f0d7"}.fa-caret-up:before,.icon-caret-up:before{content:"\f0d8"}.fa-caret-left:before,.icon-caret-left:before{content:"\f0d9"}.fa-caret-right:before,.icon-caret-right:before{content:"\f0da"}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60}.rst-versions .rst-current-version:after{clear:both;content:"";display:block}.rst-versions .rst-current-version .fa{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}} \ No newline at end of file diff --git a/_static/css/fonts/Roboto-Slab-Bold.woff b/_static/css/fonts/Roboto-Slab-Bold.woff new file mode 100644 index 0000000..6cb6000 Binary files /dev/null and b/_static/css/fonts/Roboto-Slab-Bold.woff differ diff --git a/_static/css/fonts/Roboto-Slab-Bold.woff2 b/_static/css/fonts/Roboto-Slab-Bold.woff2 new file mode 100644 index 0000000..7059e23 Binary files /dev/null and b/_static/css/fonts/Roboto-Slab-Bold.woff2 differ diff --git a/_static/css/fonts/Roboto-Slab-Regular.woff b/_static/css/fonts/Roboto-Slab-Regular.woff new file mode 100644 index 0000000..f815f63 Binary files /dev/null and b/_static/css/fonts/Roboto-Slab-Regular.woff differ diff --git a/_static/css/fonts/Roboto-Slab-Regular.woff2 b/_static/css/fonts/Roboto-Slab-Regular.woff2 new file mode 100644 index 0000000..f2c76e5 Binary files /dev/null and b/_static/css/fonts/Roboto-Slab-Regular.woff2 differ diff --git a/_static/css/fonts/fontawesome-webfont.eot b/_static/css/fonts/fontawesome-webfont.eot new file mode 100644 index 0000000..e9f60ca Binary files /dev/null and b/_static/css/fonts/fontawesome-webfont.eot differ diff --git a/_static/css/fonts/fontawesome-webfont.svg b/_static/css/fonts/fontawesome-webfont.svg new file mode 100644 index 0000000..855c845 --- /dev/null +++ b/_static/css/fonts/fontawesome-webfont.svg @@ -0,0 +1,2671 @@ + + + + +Created by FontForge 20120731 at Mon Oct 24 17:37:40 2016 + By ,,, +Copyright Dave Gandy 2016. All rights reserved. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/_static/css/fonts/fontawesome-webfont.ttf b/_static/css/fonts/fontawesome-webfont.ttf new file mode 100644 index 0000000..35acda2 Binary files /dev/null and b/_static/css/fonts/fontawesome-webfont.ttf differ diff --git a/_static/css/fonts/fontawesome-webfont.woff b/_static/css/fonts/fontawesome-webfont.woff new file mode 100644 index 0000000..400014a Binary files /dev/null and b/_static/css/fonts/fontawesome-webfont.woff differ diff --git a/_static/css/fonts/fontawesome-webfont.woff2 b/_static/css/fonts/fontawesome-webfont.woff2 new file mode 100644 index 0000000..4d13fc6 Binary files /dev/null and b/_static/css/fonts/fontawesome-webfont.woff2 differ diff --git a/_static/css/fonts/lato-bold-italic.woff b/_static/css/fonts/lato-bold-italic.woff new file mode 100644 index 0000000..88ad05b Binary files /dev/null and b/_static/css/fonts/lato-bold-italic.woff differ diff --git a/_static/css/fonts/lato-bold-italic.woff2 b/_static/css/fonts/lato-bold-italic.woff2 new file mode 100644 index 0000000..c4e3d80 Binary files /dev/null and b/_static/css/fonts/lato-bold-italic.woff2 differ diff --git a/_static/css/fonts/lato-bold.woff b/_static/css/fonts/lato-bold.woff new file mode 100644 index 0000000..c6dff51 Binary files /dev/null and b/_static/css/fonts/lato-bold.woff differ diff --git a/_static/css/fonts/lato-bold.woff2 b/_static/css/fonts/lato-bold.woff2 new file mode 100644 index 0000000..bb19504 Binary files /dev/null and b/_static/css/fonts/lato-bold.woff2 differ diff --git a/_static/css/fonts/lato-normal-italic.woff b/_static/css/fonts/lato-normal-italic.woff new file mode 100644 index 0000000..76114bc Binary files /dev/null and b/_static/css/fonts/lato-normal-italic.woff differ diff --git a/_static/css/fonts/lato-normal-italic.woff2 b/_static/css/fonts/lato-normal-italic.woff2 new file mode 100644 index 0000000..3404f37 Binary files /dev/null and b/_static/css/fonts/lato-normal-italic.woff2 differ diff --git a/_static/css/fonts/lato-normal.woff b/_static/css/fonts/lato-normal.woff new file mode 100644 index 0000000..ae1307f Binary files /dev/null and b/_static/css/fonts/lato-normal.woff differ diff --git a/_static/css/fonts/lato-normal.woff2 b/_static/css/fonts/lato-normal.woff2 new file mode 100644 index 0000000..3bf9843 Binary files /dev/null and b/_static/css/fonts/lato-normal.woff2 differ diff --git a/_static/css/theme.css b/_static/css/theme.css new file mode 100644 index 0000000..19a446a --- /dev/null +++ b/_static/css/theme.css @@ -0,0 +1,4 @@ +html{box-sizing:border-box}*,:after,:before{box-sizing:inherit}article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}[hidden],audio:not([controls]){display:none}*{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}body{margin:0}a:active,a:hover{outline:0}abbr[title]{border-bottom:1px dotted}b,strong{font-weight:700}blockquote{margin:0}dfn{font-style:italic}ins{background:#ff9;text-decoration:none}ins,mark{color:#000}mark{background:#ff0;font-style:italic;font-weight:700}.rst-content code,.rst-content tt,code,kbd,pre,samp{font-family:monospace,serif;_font-family:courier new,monospace;font-size:1em}pre{white-space:pre}q{quotes:none}q:after,q:before{content:"";content:none}small{font-size:85%}sub,sup{font-size:75%;line-height:0;position:relative;vertical-align:baseline}sup{top:-.5em}sub{bottom:-.25em}dl,ol,ul{margin:0;padding:0;list-style:none;list-style-image:none}li{list-style:none}dd{margin:0}img{border:0;-ms-interpolation-mode:bicubic;vertical-align:middle;max-width:100%}svg:not(:root){overflow:hidden}figure,form{margin:0}label{cursor:pointer}button,input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}button,input{line-height:normal}button,input[type=button],input[type=reset],input[type=submit]{cursor:pointer;-webkit-appearance:button;*overflow:visible}button[disabled],input[disabled]{cursor:default}input[type=search]{-webkit-appearance:textfield;-moz-box-sizing:content-box;-webkit-box-sizing:content-box;box-sizing:content-box}textarea{resize:vertical}table{border-collapse:collapse;border-spacing:0}td{vertical-align:top}.chromeframe{margin:.2em 0;background:#ccc;color:#000;padding:.2em 0}.ir{display:block;border:0;text-indent:-999em;overflow:hidden;background-color:transparent;background-repeat:no-repeat;text-align:left;direction:ltr;*line-height:0}.ir br{display:none}.hidden{display:none!important;visibility:hidden}.visuallyhidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px}.visuallyhidden.focusable:active,.visuallyhidden.focusable:focus{clip:auto;height:auto;margin:0;overflow:visible;position:static;width:auto}.invisible{visibility:hidden}.relative{position:relative}big,small{font-size:100%}@media print{body,html,section{background:none!important}*{box-shadow:none!important;text-shadow:none!important;filter:none!important;-ms-filter:none!important}a,a:visited{text-decoration:underline}.ir a:after,a[href^="#"]:after,a[href^="javascript:"]:after{content:""}blockquote,pre{page-break-inside:avoid}thead{display:table-header-group}img,tr{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}.rst-content .toctree-wrapper>p.caption,h2,h3,p{orphans:3;widows:3}.rst-content .toctree-wrapper>p.caption,h2,h3{page-break-after:avoid}}.btn,.fa:before,.icon:before,.rst-content .admonition,.rst-content .admonition-title:before,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .code-block-caption .headerlink:before,.rst-content .danger,.rst-content .eqno .headerlink:before,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-alert,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before,input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week],select,textarea{-webkit-font-smoothing:antialiased}.clearfix{*zoom:1}.clearfix:after,.clearfix:before{display:table;content:""}.clearfix:after{clear:both}/*! + * Font Awesome 4.7.0 by @davegandy - http://fontawesome.io - @fontawesome + * License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License) + */@font-face{font-family:FontAwesome;src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713);src:url(fonts/fontawesome-webfont.eot?674f50d287a8c48dc19ba404d20fe713?#iefix&v=4.7.0) format("embedded-opentype"),url(fonts/fontawesome-webfont.woff2?af7ae505a9eed503f8b8e6982036873e) format("woff2"),url(fonts/fontawesome-webfont.woff?fee66e712a8a08eef5805a46892932ad) format("woff"),url(fonts/fontawesome-webfont.ttf?b06871f281fee6b241d60582ae9369b9) format("truetype"),url(fonts/fontawesome-webfont.svg?912ec66d7572ff821749319396470bde#fontawesomeregular) format("svg");font-weight:400;font-style:normal}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{display:inline-block;font:normal normal normal 14px/1 FontAwesome;font-size:inherit;text-rendering:auto;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.fa-lg{font-size:1.33333em;line-height:.75em;vertical-align:-15%}.fa-2x{font-size:2em}.fa-3x{font-size:3em}.fa-4x{font-size:4em}.fa-5x{font-size:5em}.fa-fw{width:1.28571em;text-align:center}.fa-ul{padding-left:0;margin-left:2.14286em;list-style-type:none}.fa-ul>li{position:relative}.fa-li{position:absolute;left:-2.14286em;width:2.14286em;top:.14286em;text-align:center}.fa-li.fa-lg{left:-1.85714em}.fa-border{padding:.2em .25em .15em;border:.08em solid #eee;border-radius:.1em}.fa-pull-left{float:left}.fa-pull-right{float:right}.fa-pull-left.icon,.fa.fa-pull-left,.rst-content .code-block-caption .fa-pull-left.headerlink,.rst-content .eqno .fa-pull-left.headerlink,.rst-content .fa-pull-left.admonition-title,.rst-content code.download span.fa-pull-left:first-child,.rst-content dl dt .fa-pull-left.headerlink,.rst-content h1 .fa-pull-left.headerlink,.rst-content h2 .fa-pull-left.headerlink,.rst-content h3 .fa-pull-left.headerlink,.rst-content h4 .fa-pull-left.headerlink,.rst-content h5 .fa-pull-left.headerlink,.rst-content h6 .fa-pull-left.headerlink,.rst-content p .fa-pull-left.headerlink,.rst-content table>caption .fa-pull-left.headerlink,.rst-content tt.download span.fa-pull-left:first-child,.wy-menu-vertical li.current>a button.fa-pull-left.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-left.toctree-expand,.wy-menu-vertical li button.fa-pull-left.toctree-expand{margin-right:.3em}.fa-pull-right.icon,.fa.fa-pull-right,.rst-content .code-block-caption .fa-pull-right.headerlink,.rst-content .eqno .fa-pull-right.headerlink,.rst-content .fa-pull-right.admonition-title,.rst-content code.download span.fa-pull-right:first-child,.rst-content dl dt .fa-pull-right.headerlink,.rst-content h1 .fa-pull-right.headerlink,.rst-content h2 .fa-pull-right.headerlink,.rst-content h3 .fa-pull-right.headerlink,.rst-content h4 .fa-pull-right.headerlink,.rst-content h5 .fa-pull-right.headerlink,.rst-content h6 .fa-pull-right.headerlink,.rst-content p .fa-pull-right.headerlink,.rst-content table>caption .fa-pull-right.headerlink,.rst-content tt.download span.fa-pull-right:first-child,.wy-menu-vertical li.current>a button.fa-pull-right.toctree-expand,.wy-menu-vertical li.on a button.fa-pull-right.toctree-expand,.wy-menu-vertical li button.fa-pull-right.toctree-expand{margin-left:.3em}.pull-right{float:right}.pull-left{float:left}.fa.pull-left,.pull-left.icon,.rst-content .code-block-caption .pull-left.headerlink,.rst-content .eqno .pull-left.headerlink,.rst-content .pull-left.admonition-title,.rst-content code.download span.pull-left:first-child,.rst-content dl dt .pull-left.headerlink,.rst-content h1 .pull-left.headerlink,.rst-content h2 .pull-left.headerlink,.rst-content h3 .pull-left.headerlink,.rst-content h4 .pull-left.headerlink,.rst-content h5 .pull-left.headerlink,.rst-content h6 .pull-left.headerlink,.rst-content p .pull-left.headerlink,.rst-content table>caption .pull-left.headerlink,.rst-content tt.download span.pull-left:first-child,.wy-menu-vertical li.current>a button.pull-left.toctree-expand,.wy-menu-vertical li.on a button.pull-left.toctree-expand,.wy-menu-vertical li button.pull-left.toctree-expand{margin-right:.3em}.fa.pull-right,.pull-right.icon,.rst-content .code-block-caption .pull-right.headerlink,.rst-content .eqno .pull-right.headerlink,.rst-content .pull-right.admonition-title,.rst-content code.download span.pull-right:first-child,.rst-content dl dt .pull-right.headerlink,.rst-content h1 .pull-right.headerlink,.rst-content h2 .pull-right.headerlink,.rst-content h3 .pull-right.headerlink,.rst-content h4 .pull-right.headerlink,.rst-content h5 .pull-right.headerlink,.rst-content h6 .pull-right.headerlink,.rst-content p .pull-right.headerlink,.rst-content table>caption .pull-right.headerlink,.rst-content tt.download span.pull-right:first-child,.wy-menu-vertical li.current>a button.pull-right.toctree-expand,.wy-menu-vertical li.on a button.pull-right.toctree-expand,.wy-menu-vertical li button.pull-right.toctree-expand{margin-left:.3em}.fa-spin{-webkit-animation:fa-spin 2s linear infinite;animation:fa-spin 2s linear infinite}.fa-pulse{-webkit-animation:fa-spin 1s steps(8) infinite;animation:fa-spin 1s steps(8) infinite}@-webkit-keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}@keyframes fa-spin{0%{-webkit-transform:rotate(0deg);transform:rotate(0deg)}to{-webkit-transform:rotate(359deg);transform:rotate(359deg)}}.fa-rotate-90{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=1)";-webkit-transform:rotate(90deg);-ms-transform:rotate(90deg);transform:rotate(90deg)}.fa-rotate-180{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2)";-webkit-transform:rotate(180deg);-ms-transform:rotate(180deg);transform:rotate(180deg)}.fa-rotate-270{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=3)";-webkit-transform:rotate(270deg);-ms-transform:rotate(270deg);transform:rotate(270deg)}.fa-flip-horizontal{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1)";-webkit-transform:scaleX(-1);-ms-transform:scaleX(-1);transform:scaleX(-1)}.fa-flip-vertical{-ms-filter:"progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1)";-webkit-transform:scaleY(-1);-ms-transform:scaleY(-1);transform:scaleY(-1)}:root .fa-flip-horizontal,:root .fa-flip-vertical,:root .fa-rotate-90,:root .fa-rotate-180,:root .fa-rotate-270{filter:none}.fa-stack{position:relative;display:inline-block;width:2em;height:2em;line-height:2em;vertical-align:middle}.fa-stack-1x,.fa-stack-2x{position:absolute;left:0;width:100%;text-align:center}.fa-stack-1x{line-height:inherit}.fa-stack-2x{font-size:2em}.fa-inverse{color:#fff}.fa-glass:before{content:""}.fa-music:before{content:""}.fa-search:before,.icon-search:before{content:""}.fa-envelope-o:before{content:""}.fa-heart:before{content:""}.fa-star:before{content:""}.fa-star-o:before{content:""}.fa-user:before{content:""}.fa-film:before{content:""}.fa-th-large:before{content:""}.fa-th:before{content:""}.fa-th-list:before{content:""}.fa-check:before{content:""}.fa-close:before,.fa-remove:before,.fa-times:before{content:""}.fa-search-plus:before{content:""}.fa-search-minus:before{content:""}.fa-power-off:before{content:""}.fa-signal:before{content:""}.fa-cog:before,.fa-gear:before{content:""}.fa-trash-o:before{content:""}.fa-home:before,.icon-home:before{content:""}.fa-file-o:before{content:""}.fa-clock-o:before{content:""}.fa-road:before{content:""}.fa-download:before,.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{content:""}.fa-arrow-circle-o-down:before{content:""}.fa-arrow-circle-o-up:before{content:""}.fa-inbox:before{content:""}.fa-play-circle-o:before{content:""}.fa-repeat:before,.fa-rotate-right:before{content:""}.fa-refresh:before{content:""}.fa-list-alt:before{content:""}.fa-lock:before{content:""}.fa-flag:before{content:""}.fa-headphones:before{content:""}.fa-volume-off:before{content:""}.fa-volume-down:before{content:""}.fa-volume-up:before{content:""}.fa-qrcode:before{content:""}.fa-barcode:before{content:""}.fa-tag:before{content:""}.fa-tags:before{content:""}.fa-book:before,.icon-book:before{content:""}.fa-bookmark:before{content:""}.fa-print:before{content:""}.fa-camera:before{content:""}.fa-font:before{content:""}.fa-bold:before{content:""}.fa-italic:before{content:""}.fa-text-height:before{content:""}.fa-text-width:before{content:""}.fa-align-left:before{content:""}.fa-align-center:before{content:""}.fa-align-right:before{content:""}.fa-align-justify:before{content:""}.fa-list:before{content:""}.fa-dedent:before,.fa-outdent:before{content:""}.fa-indent:before{content:""}.fa-video-camera:before{content:""}.fa-image:before,.fa-photo:before,.fa-picture-o:before{content:""}.fa-pencil:before{content:""}.fa-map-marker:before{content:""}.fa-adjust:before{content:""}.fa-tint:before{content:""}.fa-edit:before,.fa-pencil-square-o:before{content:""}.fa-share-square-o:before{content:""}.fa-check-square-o:before{content:""}.fa-arrows:before{content:""}.fa-step-backward:before{content:""}.fa-fast-backward:before{content:""}.fa-backward:before{content:""}.fa-play:before{content:""}.fa-pause:before{content:""}.fa-stop:before{content:""}.fa-forward:before{content:""}.fa-fast-forward:before{content:""}.fa-step-forward:before{content:""}.fa-eject:before{content:""}.fa-chevron-left:before{content:""}.fa-chevron-right:before{content:""}.fa-plus-circle:before{content:""}.fa-minus-circle:before{content:""}.fa-times-circle:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before{content:""}.fa-check-circle:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before{content:""}.fa-question-circle:before{content:""}.fa-info-circle:before{content:""}.fa-crosshairs:before{content:""}.fa-times-circle-o:before{content:""}.fa-check-circle-o:before{content:""}.fa-ban:before{content:""}.fa-arrow-left:before{content:""}.fa-arrow-right:before{content:""}.fa-arrow-up:before{content:""}.fa-arrow-down:before{content:""}.fa-mail-forward:before,.fa-share:before{content:""}.fa-expand:before{content:""}.fa-compress:before{content:""}.fa-plus:before{content:""}.fa-minus:before{content:""}.fa-asterisk:before{content:""}.fa-exclamation-circle:before,.rst-content .admonition-title:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before{content:""}.fa-gift:before{content:""}.fa-leaf:before{content:""}.fa-fire:before,.icon-fire:before{content:""}.fa-eye:before{content:""}.fa-eye-slash:before{content:""}.fa-exclamation-triangle:before,.fa-warning:before{content:""}.fa-plane:before{content:""}.fa-calendar:before{content:""}.fa-random:before{content:""}.fa-comment:before{content:""}.fa-magnet:before{content:""}.fa-chevron-up:before{content:""}.fa-chevron-down:before{content:""}.fa-retweet:before{content:""}.fa-shopping-cart:before{content:""}.fa-folder:before{content:""}.fa-folder-open:before{content:""}.fa-arrows-v:before{content:""}.fa-arrows-h:before{content:""}.fa-bar-chart-o:before,.fa-bar-chart:before{content:""}.fa-twitter-square:before{content:""}.fa-facebook-square:before{content:""}.fa-camera-retro:before{content:""}.fa-key:before{content:""}.fa-cogs:before,.fa-gears:before{content:""}.fa-comments:before{content:""}.fa-thumbs-o-up:before{content:""}.fa-thumbs-o-down:before{content:""}.fa-star-half:before{content:""}.fa-heart-o:before{content:""}.fa-sign-out:before{content:""}.fa-linkedin-square:before{content:""}.fa-thumb-tack:before{content:""}.fa-external-link:before{content:""}.fa-sign-in:before{content:""}.fa-trophy:before{content:""}.fa-github-square:before{content:""}.fa-upload:before{content:""}.fa-lemon-o:before{content:""}.fa-phone:before{content:""}.fa-square-o:before{content:""}.fa-bookmark-o:before{content:""}.fa-phone-square:before{content:""}.fa-twitter:before{content:""}.fa-facebook-f:before,.fa-facebook:before{content:""}.fa-github:before,.icon-github:before{content:""}.fa-unlock:before{content:""}.fa-credit-card:before{content:""}.fa-feed:before,.fa-rss:before{content:""}.fa-hdd-o:before{content:""}.fa-bullhorn:before{content:""}.fa-bell:before{content:""}.fa-certificate:before{content:""}.fa-hand-o-right:before{content:""}.fa-hand-o-left:before{content:""}.fa-hand-o-up:before{content:""}.fa-hand-o-down:before{content:""}.fa-arrow-circle-left:before,.icon-circle-arrow-left:before{content:""}.fa-arrow-circle-right:before,.icon-circle-arrow-right:before{content:""}.fa-arrow-circle-up:before{content:""}.fa-arrow-circle-down:before{content:""}.fa-globe:before{content:""}.fa-wrench:before{content:""}.fa-tasks:before{content:""}.fa-filter:before{content:""}.fa-briefcase:before{content:""}.fa-arrows-alt:before{content:""}.fa-group:before,.fa-users:before{content:""}.fa-chain:before,.fa-link:before,.icon-link:before{content:""}.fa-cloud:before{content:""}.fa-flask:before{content:""}.fa-cut:before,.fa-scissors:before{content:""}.fa-copy:before,.fa-files-o:before{content:""}.fa-paperclip:before{content:""}.fa-floppy-o:before,.fa-save:before{content:""}.fa-square:before{content:""}.fa-bars:before,.fa-navicon:before,.fa-reorder:before{content:""}.fa-list-ul:before{content:""}.fa-list-ol:before{content:""}.fa-strikethrough:before{content:""}.fa-underline:before{content:""}.fa-table:before{content:""}.fa-magic:before{content:""}.fa-truck:before{content:""}.fa-pinterest:before{content:""}.fa-pinterest-square:before{content:""}.fa-google-plus-square:before{content:""}.fa-google-plus:before{content:""}.fa-money:before{content:""}.fa-caret-down:before,.icon-caret-down:before,.wy-dropdown .caret:before{content:""}.fa-caret-up:before{content:""}.fa-caret-left:before{content:""}.fa-caret-right:before{content:""}.fa-columns:before{content:""}.fa-sort:before,.fa-unsorted:before{content:""}.fa-sort-desc:before,.fa-sort-down:before{content:""}.fa-sort-asc:before,.fa-sort-up:before{content:""}.fa-envelope:before{content:""}.fa-linkedin:before{content:""}.fa-rotate-left:before,.fa-undo:before{content:""}.fa-gavel:before,.fa-legal:before{content:""}.fa-dashboard:before,.fa-tachometer:before{content:""}.fa-comment-o:before{content:""}.fa-comments-o:before{content:""}.fa-bolt:before,.fa-flash:before{content:""}.fa-sitemap:before{content:""}.fa-umbrella:before{content:""}.fa-clipboard:before,.fa-paste:before{content:""}.fa-lightbulb-o:before{content:""}.fa-exchange:before{content:""}.fa-cloud-download:before{content:""}.fa-cloud-upload:before{content:""}.fa-user-md:before{content:""}.fa-stethoscope:before{content:""}.fa-suitcase:before{content:""}.fa-bell-o:before{content:""}.fa-coffee:before{content:""}.fa-cutlery:before{content:""}.fa-file-text-o:before{content:""}.fa-building-o:before{content:""}.fa-hospital-o:before{content:""}.fa-ambulance:before{content:""}.fa-medkit:before{content:""}.fa-fighter-jet:before{content:""}.fa-beer:before{content:""}.fa-h-square:before{content:""}.fa-plus-square:before{content:""}.fa-angle-double-left:before{content:""}.fa-angle-double-right:before{content:""}.fa-angle-double-up:before{content:""}.fa-angle-double-down:before{content:""}.fa-angle-left:before{content:""}.fa-angle-right:before{content:""}.fa-angle-up:before{content:""}.fa-angle-down:before{content:""}.fa-desktop:before{content:""}.fa-laptop:before{content:""}.fa-tablet:before{content:""}.fa-mobile-phone:before,.fa-mobile:before{content:""}.fa-circle-o:before{content:""}.fa-quote-left:before{content:""}.fa-quote-right:before{content:""}.fa-spinner:before{content:""}.fa-circle:before{content:""}.fa-mail-reply:before,.fa-reply:before{content:""}.fa-github-alt:before{content:""}.fa-folder-o:before{content:""}.fa-folder-open-o:before{content:""}.fa-smile-o:before{content:""}.fa-frown-o:before{content:""}.fa-meh-o:before{content:""}.fa-gamepad:before{content:""}.fa-keyboard-o:before{content:""}.fa-flag-o:before{content:""}.fa-flag-checkered:before{content:""}.fa-terminal:before{content:""}.fa-code:before{content:""}.fa-mail-reply-all:before,.fa-reply-all:before{content:""}.fa-star-half-empty:before,.fa-star-half-full:before,.fa-star-half-o:before{content:""}.fa-location-arrow:before{content:""}.fa-crop:before{content:""}.fa-code-fork:before{content:""}.fa-chain-broken:before,.fa-unlink:before{content:""}.fa-question:before{content:""}.fa-info:before{content:""}.fa-exclamation:before{content:""}.fa-superscript:before{content:""}.fa-subscript:before{content:""}.fa-eraser:before{content:""}.fa-puzzle-piece:before{content:""}.fa-microphone:before{content:""}.fa-microphone-slash:before{content:""}.fa-shield:before{content:""}.fa-calendar-o:before{content:""}.fa-fire-extinguisher:before{content:""}.fa-rocket:before{content:""}.fa-maxcdn:before{content:""}.fa-chevron-circle-left:before{content:""}.fa-chevron-circle-right:before{content:""}.fa-chevron-circle-up:before{content:""}.fa-chevron-circle-down:before{content:""}.fa-html5:before{content:""}.fa-css3:before{content:""}.fa-anchor:before{content:""}.fa-unlock-alt:before{content:""}.fa-bullseye:before{content:""}.fa-ellipsis-h:before{content:""}.fa-ellipsis-v:before{content:""}.fa-rss-square:before{content:""}.fa-play-circle:before{content:""}.fa-ticket:before{content:""}.fa-minus-square:before{content:""}.fa-minus-square-o:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before{content:""}.fa-level-up:before{content:""}.fa-level-down:before{content:""}.fa-check-square:before{content:""}.fa-pencil-square:before{content:""}.fa-external-link-square:before{content:""}.fa-share-square:before{content:""}.fa-compass:before{content:""}.fa-caret-square-o-down:before,.fa-toggle-down:before{content:""}.fa-caret-square-o-up:before,.fa-toggle-up:before{content:""}.fa-caret-square-o-right:before,.fa-toggle-right:before{content:""}.fa-eur:before,.fa-euro:before{content:""}.fa-gbp:before{content:""}.fa-dollar:before,.fa-usd:before{content:""}.fa-inr:before,.fa-rupee:before{content:""}.fa-cny:before,.fa-jpy:before,.fa-rmb:before,.fa-yen:before{content:""}.fa-rouble:before,.fa-rub:before,.fa-ruble:before{content:""}.fa-krw:before,.fa-won:before{content:""}.fa-bitcoin:before,.fa-btc:before{content:""}.fa-file:before{content:""}.fa-file-text:before{content:""}.fa-sort-alpha-asc:before{content:""}.fa-sort-alpha-desc:before{content:""}.fa-sort-amount-asc:before{content:""}.fa-sort-amount-desc:before{content:""}.fa-sort-numeric-asc:before{content:""}.fa-sort-numeric-desc:before{content:""}.fa-thumbs-up:before{content:""}.fa-thumbs-down:before{content:""}.fa-youtube-square:before{content:""}.fa-youtube:before{content:""}.fa-xing:before{content:""}.fa-xing-square:before{content:""}.fa-youtube-play:before{content:""}.fa-dropbox:before{content:""}.fa-stack-overflow:before{content:""}.fa-instagram:before{content:""}.fa-flickr:before{content:""}.fa-adn:before{content:""}.fa-bitbucket:before,.icon-bitbucket:before{content:""}.fa-bitbucket-square:before{content:""}.fa-tumblr:before{content:""}.fa-tumblr-square:before{content:""}.fa-long-arrow-down:before{content:""}.fa-long-arrow-up:before{content:""}.fa-long-arrow-left:before{content:""}.fa-long-arrow-right:before{content:""}.fa-apple:before{content:""}.fa-windows:before{content:""}.fa-android:before{content:""}.fa-linux:before{content:""}.fa-dribbble:before{content:""}.fa-skype:before{content:""}.fa-foursquare:before{content:""}.fa-trello:before{content:""}.fa-female:before{content:""}.fa-male:before{content:""}.fa-gittip:before,.fa-gratipay:before{content:""}.fa-sun-o:before{content:""}.fa-moon-o:before{content:""}.fa-archive:before{content:""}.fa-bug:before{content:""}.fa-vk:before{content:""}.fa-weibo:before{content:""}.fa-renren:before{content:""}.fa-pagelines:before{content:""}.fa-stack-exchange:before{content:""}.fa-arrow-circle-o-right:before{content:""}.fa-arrow-circle-o-left:before{content:""}.fa-caret-square-o-left:before,.fa-toggle-left:before{content:""}.fa-dot-circle-o:before{content:""}.fa-wheelchair:before{content:""}.fa-vimeo-square:before{content:""}.fa-try:before,.fa-turkish-lira:before{content:""}.fa-plus-square-o:before,.wy-menu-vertical li button.toctree-expand:before{content:""}.fa-space-shuttle:before{content:""}.fa-slack:before{content:""}.fa-envelope-square:before{content:""}.fa-wordpress:before{content:""}.fa-openid:before{content:""}.fa-bank:before,.fa-institution:before,.fa-university:before{content:""}.fa-graduation-cap:before,.fa-mortar-board:before{content:""}.fa-yahoo:before{content:""}.fa-google:before{content:""}.fa-reddit:before{content:""}.fa-reddit-square:before{content:""}.fa-stumbleupon-circle:before{content:""}.fa-stumbleupon:before{content:""}.fa-delicious:before{content:""}.fa-digg:before{content:""}.fa-pied-piper-pp:before{content:""}.fa-pied-piper-alt:before{content:""}.fa-drupal:before{content:""}.fa-joomla:before{content:""}.fa-language:before{content:""}.fa-fax:before{content:""}.fa-building:before{content:""}.fa-child:before{content:""}.fa-paw:before{content:""}.fa-spoon:before{content:""}.fa-cube:before{content:""}.fa-cubes:before{content:""}.fa-behance:before{content:""}.fa-behance-square:before{content:""}.fa-steam:before{content:""}.fa-steam-square:before{content:""}.fa-recycle:before{content:""}.fa-automobile:before,.fa-car:before{content:""}.fa-cab:before,.fa-taxi:before{content:""}.fa-tree:before{content:""}.fa-spotify:before{content:""}.fa-deviantart:before{content:""}.fa-soundcloud:before{content:""}.fa-database:before{content:""}.fa-file-pdf-o:before{content:""}.fa-file-word-o:before{content:""}.fa-file-excel-o:before{content:""}.fa-file-powerpoint-o:before{content:""}.fa-file-image-o:before,.fa-file-photo-o:before,.fa-file-picture-o:before{content:""}.fa-file-archive-o:before,.fa-file-zip-o:before{content:""}.fa-file-audio-o:before,.fa-file-sound-o:before{content:""}.fa-file-movie-o:before,.fa-file-video-o:before{content:""}.fa-file-code-o:before{content:""}.fa-vine:before{content:""}.fa-codepen:before{content:""}.fa-jsfiddle:before{content:""}.fa-life-bouy:before,.fa-life-buoy:before,.fa-life-ring:before,.fa-life-saver:before,.fa-support:before{content:""}.fa-circle-o-notch:before{content:""}.fa-ra:before,.fa-rebel:before,.fa-resistance:before{content:""}.fa-empire:before,.fa-ge:before{content:""}.fa-git-square:before{content:""}.fa-git:before{content:""}.fa-hacker-news:before,.fa-y-combinator-square:before,.fa-yc-square:before{content:""}.fa-tencent-weibo:before{content:""}.fa-qq:before{content:""}.fa-wechat:before,.fa-weixin:before{content:""}.fa-paper-plane:before,.fa-send:before{content:""}.fa-paper-plane-o:before,.fa-send-o:before{content:""}.fa-history:before{content:""}.fa-circle-thin:before{content:""}.fa-header:before{content:""}.fa-paragraph:before{content:""}.fa-sliders:before{content:""}.fa-share-alt:before{content:""}.fa-share-alt-square:before{content:""}.fa-bomb:before{content:""}.fa-futbol-o:before,.fa-soccer-ball-o:before{content:""}.fa-tty:before{content:""}.fa-binoculars:before{content:""}.fa-plug:before{content:""}.fa-slideshare:before{content:""}.fa-twitch:before{content:""}.fa-yelp:before{content:""}.fa-newspaper-o:before{content:""}.fa-wifi:before{content:""}.fa-calculator:before{content:""}.fa-paypal:before{content:""}.fa-google-wallet:before{content:""}.fa-cc-visa:before{content:""}.fa-cc-mastercard:before{content:""}.fa-cc-discover:before{content:""}.fa-cc-amex:before{content:""}.fa-cc-paypal:before{content:""}.fa-cc-stripe:before{content:""}.fa-bell-slash:before{content:""}.fa-bell-slash-o:before{content:""}.fa-trash:before{content:""}.fa-copyright:before{content:""}.fa-at:before{content:""}.fa-eyedropper:before{content:""}.fa-paint-brush:before{content:""}.fa-birthday-cake:before{content:""}.fa-area-chart:before{content:""}.fa-pie-chart:before{content:""}.fa-line-chart:before{content:""}.fa-lastfm:before{content:""}.fa-lastfm-square:before{content:""}.fa-toggle-off:before{content:""}.fa-toggle-on:before{content:""}.fa-bicycle:before{content:""}.fa-bus:before{content:""}.fa-ioxhost:before{content:""}.fa-angellist:before{content:""}.fa-cc:before{content:""}.fa-ils:before,.fa-shekel:before,.fa-sheqel:before{content:""}.fa-meanpath:before{content:""}.fa-buysellads:before{content:""}.fa-connectdevelop:before{content:""}.fa-dashcube:before{content:""}.fa-forumbee:before{content:""}.fa-leanpub:before{content:""}.fa-sellsy:before{content:""}.fa-shirtsinbulk:before{content:""}.fa-simplybuilt:before{content:""}.fa-skyatlas:before{content:""}.fa-cart-plus:before{content:""}.fa-cart-arrow-down:before{content:""}.fa-diamond:before{content:""}.fa-ship:before{content:""}.fa-user-secret:before{content:""}.fa-motorcycle:before{content:""}.fa-street-view:before{content:""}.fa-heartbeat:before{content:""}.fa-venus:before{content:""}.fa-mars:before{content:""}.fa-mercury:before{content:""}.fa-intersex:before,.fa-transgender:before{content:""}.fa-transgender-alt:before{content:""}.fa-venus-double:before{content:""}.fa-mars-double:before{content:""}.fa-venus-mars:before{content:""}.fa-mars-stroke:before{content:""}.fa-mars-stroke-v:before{content:""}.fa-mars-stroke-h:before{content:""}.fa-neuter:before{content:""}.fa-genderless:before{content:""}.fa-facebook-official:before{content:""}.fa-pinterest-p:before{content:""}.fa-whatsapp:before{content:""}.fa-server:before{content:""}.fa-user-plus:before{content:""}.fa-user-times:before{content:""}.fa-bed:before,.fa-hotel:before{content:""}.fa-viacoin:before{content:""}.fa-train:before{content:""}.fa-subway:before{content:""}.fa-medium:before{content:""}.fa-y-combinator:before,.fa-yc:before{content:""}.fa-optin-monster:before{content:""}.fa-opencart:before{content:""}.fa-expeditedssl:before{content:""}.fa-battery-4:before,.fa-battery-full:before,.fa-battery:before{content:""}.fa-battery-3:before,.fa-battery-three-quarters:before{content:""}.fa-battery-2:before,.fa-battery-half:before{content:""}.fa-battery-1:before,.fa-battery-quarter:before{content:""}.fa-battery-0:before,.fa-battery-empty:before{content:""}.fa-mouse-pointer:before{content:""}.fa-i-cursor:before{content:""}.fa-object-group:before{content:""}.fa-object-ungroup:before{content:""}.fa-sticky-note:before{content:""}.fa-sticky-note-o:before{content:""}.fa-cc-jcb:before{content:""}.fa-cc-diners-club:before{content:""}.fa-clone:before{content:""}.fa-balance-scale:before{content:""}.fa-hourglass-o:before{content:""}.fa-hourglass-1:before,.fa-hourglass-start:before{content:""}.fa-hourglass-2:before,.fa-hourglass-half:before{content:""}.fa-hourglass-3:before,.fa-hourglass-end:before{content:""}.fa-hourglass:before{content:""}.fa-hand-grab-o:before,.fa-hand-rock-o:before{content:""}.fa-hand-paper-o:before,.fa-hand-stop-o:before{content:""}.fa-hand-scissors-o:before{content:""}.fa-hand-lizard-o:before{content:""}.fa-hand-spock-o:before{content:""}.fa-hand-pointer-o:before{content:""}.fa-hand-peace-o:before{content:""}.fa-trademark:before{content:""}.fa-registered:before{content:""}.fa-creative-commons:before{content:""}.fa-gg:before{content:""}.fa-gg-circle:before{content:""}.fa-tripadvisor:before{content:""}.fa-odnoklassniki:before{content:""}.fa-odnoklassniki-square:before{content:""}.fa-get-pocket:before{content:""}.fa-wikipedia-w:before{content:""}.fa-safari:before{content:""}.fa-chrome:before{content:""}.fa-firefox:before{content:""}.fa-opera:before{content:""}.fa-internet-explorer:before{content:""}.fa-television:before,.fa-tv:before{content:""}.fa-contao:before{content:""}.fa-500px:before{content:""}.fa-amazon:before{content:""}.fa-calendar-plus-o:before{content:""}.fa-calendar-minus-o:before{content:""}.fa-calendar-times-o:before{content:""}.fa-calendar-check-o:before{content:""}.fa-industry:before{content:""}.fa-map-pin:before{content:""}.fa-map-signs:before{content:""}.fa-map-o:before{content:""}.fa-map:before{content:""}.fa-commenting:before{content:""}.fa-commenting-o:before{content:""}.fa-houzz:before{content:""}.fa-vimeo:before{content:""}.fa-black-tie:before{content:""}.fa-fonticons:before{content:""}.fa-reddit-alien:before{content:""}.fa-edge:before{content:""}.fa-credit-card-alt:before{content:""}.fa-codiepie:before{content:""}.fa-modx:before{content:""}.fa-fort-awesome:before{content:""}.fa-usb:before{content:""}.fa-product-hunt:before{content:""}.fa-mixcloud:before{content:""}.fa-scribd:before{content:""}.fa-pause-circle:before{content:""}.fa-pause-circle-o:before{content:""}.fa-stop-circle:before{content:""}.fa-stop-circle-o:before{content:""}.fa-shopping-bag:before{content:""}.fa-shopping-basket:before{content:""}.fa-hashtag:before{content:""}.fa-bluetooth:before{content:""}.fa-bluetooth-b:before{content:""}.fa-percent:before{content:""}.fa-gitlab:before,.icon-gitlab:before{content:""}.fa-wpbeginner:before{content:""}.fa-wpforms:before{content:""}.fa-envira:before{content:""}.fa-universal-access:before{content:""}.fa-wheelchair-alt:before{content:""}.fa-question-circle-o:before{content:""}.fa-blind:before{content:""}.fa-audio-description:before{content:""}.fa-volume-control-phone:before{content:""}.fa-braille:before{content:""}.fa-assistive-listening-systems:before{content:""}.fa-american-sign-language-interpreting:before,.fa-asl-interpreting:before{content:""}.fa-deaf:before,.fa-deafness:before,.fa-hard-of-hearing:before{content:""}.fa-glide:before{content:""}.fa-glide-g:before{content:""}.fa-sign-language:before,.fa-signing:before{content:""}.fa-low-vision:before{content:""}.fa-viadeo:before{content:""}.fa-viadeo-square:before{content:""}.fa-snapchat:before{content:""}.fa-snapchat-ghost:before{content:""}.fa-snapchat-square:before{content:""}.fa-pied-piper:before{content:""}.fa-first-order:before{content:""}.fa-yoast:before{content:""}.fa-themeisle:before{content:""}.fa-google-plus-circle:before,.fa-google-plus-official:before{content:""}.fa-fa:before,.fa-font-awesome:before{content:""}.fa-handshake-o:before{content:""}.fa-envelope-open:before{content:""}.fa-envelope-open-o:before{content:""}.fa-linode:before{content:""}.fa-address-book:before{content:""}.fa-address-book-o:before{content:""}.fa-address-card:before,.fa-vcard:before{content:""}.fa-address-card-o:before,.fa-vcard-o:before{content:""}.fa-user-circle:before{content:""}.fa-user-circle-o:before{content:""}.fa-user-o:before{content:""}.fa-id-badge:before{content:""}.fa-drivers-license:before,.fa-id-card:before{content:""}.fa-drivers-license-o:before,.fa-id-card-o:before{content:""}.fa-quora:before{content:""}.fa-free-code-camp:before{content:""}.fa-telegram:before{content:""}.fa-thermometer-4:before,.fa-thermometer-full:before,.fa-thermometer:before{content:""}.fa-thermometer-3:before,.fa-thermometer-three-quarters:before{content:""}.fa-thermometer-2:before,.fa-thermometer-half:before{content:""}.fa-thermometer-1:before,.fa-thermometer-quarter:before{content:""}.fa-thermometer-0:before,.fa-thermometer-empty:before{content:""}.fa-shower:before{content:""}.fa-bath:before,.fa-bathtub:before,.fa-s15:before{content:""}.fa-podcast:before{content:""}.fa-window-maximize:before{content:""}.fa-window-minimize:before{content:""}.fa-window-restore:before{content:""}.fa-times-rectangle:before,.fa-window-close:before{content:""}.fa-times-rectangle-o:before,.fa-window-close-o:before{content:""}.fa-bandcamp:before{content:""}.fa-grav:before{content:""}.fa-etsy:before{content:""}.fa-imdb:before{content:""}.fa-ravelry:before{content:""}.fa-eercast:before{content:""}.fa-microchip:before{content:""}.fa-snowflake-o:before{content:""}.fa-superpowers:before{content:""}.fa-wpexplorer:before{content:""}.fa-meetup:before{content:""}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);border:0}.sr-only-focusable:active,.sr-only-focusable:focus{position:static;width:auto;height:auto;margin:0;overflow:visible;clip:auto}.fa,.icon,.rst-content .admonition-title,.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content code.download span:first-child,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink,.rst-content tt.download span:first-child,.wy-dropdown .caret,.wy-inline-validate.wy-inline-validate-danger .wy-input-context,.wy-inline-validate.wy-inline-validate-info .wy-input-context,.wy-inline-validate.wy-inline-validate-success .wy-input-context,.wy-inline-validate.wy-inline-validate-warning .wy-input-context,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li button.toctree-expand{font-family:inherit}.fa:before,.icon:before,.rst-content .admonition-title:before,.rst-content .code-block-caption .headerlink:before,.rst-content .eqno .headerlink:before,.rst-content code.download span:first-child:before,.rst-content dl dt .headerlink:before,.rst-content h1 .headerlink:before,.rst-content h2 .headerlink:before,.rst-content h3 .headerlink:before,.rst-content h4 .headerlink:before,.rst-content h5 .headerlink:before,.rst-content h6 .headerlink:before,.rst-content p.caption .headerlink:before,.rst-content p .headerlink:before,.rst-content table>caption .headerlink:before,.rst-content tt.download span:first-child:before,.wy-dropdown .caret:before,.wy-inline-validate.wy-inline-validate-danger .wy-input-context:before,.wy-inline-validate.wy-inline-validate-info .wy-input-context:before,.wy-inline-validate.wy-inline-validate-success .wy-input-context:before,.wy-inline-validate.wy-inline-validate-warning .wy-input-context:before,.wy-menu-vertical li.current>a button.toctree-expand:before,.wy-menu-vertical li.on a button.toctree-expand:before,.wy-menu-vertical li button.toctree-expand:before{font-family:FontAwesome;display:inline-block;font-style:normal;font-weight:400;line-height:1;text-decoration:inherit}.rst-content .code-block-caption a .headerlink,.rst-content .eqno a .headerlink,.rst-content a .admonition-title,.rst-content code.download a span:first-child,.rst-content dl dt a .headerlink,.rst-content h1 a .headerlink,.rst-content h2 a .headerlink,.rst-content h3 a .headerlink,.rst-content h4 a .headerlink,.rst-content h5 a .headerlink,.rst-content h6 a .headerlink,.rst-content p.caption a .headerlink,.rst-content p a .headerlink,.rst-content table>caption a .headerlink,.rst-content tt.download a span:first-child,.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand,.wy-menu-vertical li a button.toctree-expand,a .fa,a .icon,a .rst-content .admonition-title,a .rst-content .code-block-caption .headerlink,a .rst-content .eqno .headerlink,a .rst-content code.download span:first-child,a .rst-content dl dt .headerlink,a .rst-content h1 .headerlink,a .rst-content h2 .headerlink,a .rst-content h3 .headerlink,a .rst-content h4 .headerlink,a .rst-content h5 .headerlink,a .rst-content h6 .headerlink,a .rst-content p.caption .headerlink,a .rst-content p .headerlink,a .rst-content table>caption .headerlink,a .rst-content tt.download span:first-child,a .wy-menu-vertical li button.toctree-expand{display:inline-block;text-decoration:inherit}.btn .fa,.btn .icon,.btn .rst-content .admonition-title,.btn .rst-content .code-block-caption .headerlink,.btn .rst-content .eqno .headerlink,.btn .rst-content code.download span:first-child,.btn .rst-content dl dt .headerlink,.btn .rst-content h1 .headerlink,.btn .rst-content h2 .headerlink,.btn .rst-content h3 .headerlink,.btn .rst-content h4 .headerlink,.btn .rst-content h5 .headerlink,.btn .rst-content h6 .headerlink,.btn .rst-content p .headerlink,.btn .rst-content table>caption .headerlink,.btn .rst-content tt.download span:first-child,.btn .wy-menu-vertical li.current>a button.toctree-expand,.btn .wy-menu-vertical li.on a button.toctree-expand,.btn .wy-menu-vertical li button.toctree-expand,.nav .fa,.nav .icon,.nav .rst-content .admonition-title,.nav .rst-content .code-block-caption .headerlink,.nav .rst-content .eqno .headerlink,.nav .rst-content code.download span:first-child,.nav .rst-content dl dt .headerlink,.nav .rst-content h1 .headerlink,.nav .rst-content h2 .headerlink,.nav .rst-content h3 .headerlink,.nav .rst-content h4 .headerlink,.nav .rst-content h5 .headerlink,.nav .rst-content h6 .headerlink,.nav .rst-content p .headerlink,.nav .rst-content table>caption .headerlink,.nav .rst-content tt.download span:first-child,.nav .wy-menu-vertical li.current>a button.toctree-expand,.nav .wy-menu-vertical li.on a button.toctree-expand,.nav .wy-menu-vertical li button.toctree-expand,.rst-content .btn .admonition-title,.rst-content .code-block-caption .btn .headerlink,.rst-content .code-block-caption .nav .headerlink,.rst-content .eqno .btn .headerlink,.rst-content .eqno .nav .headerlink,.rst-content .nav .admonition-title,.rst-content code.download .btn span:first-child,.rst-content code.download .nav span:first-child,.rst-content dl dt .btn .headerlink,.rst-content dl dt .nav .headerlink,.rst-content h1 .btn .headerlink,.rst-content h1 .nav .headerlink,.rst-content h2 .btn .headerlink,.rst-content h2 .nav .headerlink,.rst-content h3 .btn .headerlink,.rst-content h3 .nav .headerlink,.rst-content h4 .btn .headerlink,.rst-content h4 .nav .headerlink,.rst-content h5 .btn .headerlink,.rst-content h5 .nav .headerlink,.rst-content h6 .btn .headerlink,.rst-content h6 .nav .headerlink,.rst-content p .btn .headerlink,.rst-content p .nav .headerlink,.rst-content table>caption .btn .headerlink,.rst-content table>caption .nav .headerlink,.rst-content tt.download .btn span:first-child,.rst-content tt.download .nav span:first-child,.wy-menu-vertical li .btn button.toctree-expand,.wy-menu-vertical li.current>a .btn button.toctree-expand,.wy-menu-vertical li.current>a .nav button.toctree-expand,.wy-menu-vertical li .nav button.toctree-expand,.wy-menu-vertical li.on a .btn button.toctree-expand,.wy-menu-vertical li.on a .nav button.toctree-expand{display:inline}.btn .fa-large.icon,.btn .fa.fa-large,.btn .rst-content .code-block-caption .fa-large.headerlink,.btn .rst-content .eqno .fa-large.headerlink,.btn .rst-content .fa-large.admonition-title,.btn .rst-content code.download span.fa-large:first-child,.btn .rst-content dl dt .fa-large.headerlink,.btn .rst-content h1 .fa-large.headerlink,.btn .rst-content h2 .fa-large.headerlink,.btn .rst-content h3 .fa-large.headerlink,.btn .rst-content h4 .fa-large.headerlink,.btn .rst-content h5 .fa-large.headerlink,.btn .rst-content h6 .fa-large.headerlink,.btn .rst-content p .fa-large.headerlink,.btn .rst-content table>caption .fa-large.headerlink,.btn .rst-content tt.download span.fa-large:first-child,.btn .wy-menu-vertical li button.fa-large.toctree-expand,.nav .fa-large.icon,.nav .fa.fa-large,.nav .rst-content .code-block-caption .fa-large.headerlink,.nav .rst-content .eqno .fa-large.headerlink,.nav .rst-content .fa-large.admonition-title,.nav .rst-content code.download span.fa-large:first-child,.nav .rst-content dl dt .fa-large.headerlink,.nav .rst-content h1 .fa-large.headerlink,.nav .rst-content h2 .fa-large.headerlink,.nav .rst-content h3 .fa-large.headerlink,.nav .rst-content h4 .fa-large.headerlink,.nav .rst-content h5 .fa-large.headerlink,.nav .rst-content h6 .fa-large.headerlink,.nav .rst-content p .fa-large.headerlink,.nav .rst-content table>caption .fa-large.headerlink,.nav .rst-content tt.download span.fa-large:first-child,.nav .wy-menu-vertical li button.fa-large.toctree-expand,.rst-content .btn .fa-large.admonition-title,.rst-content .code-block-caption .btn .fa-large.headerlink,.rst-content .code-block-caption .nav .fa-large.headerlink,.rst-content .eqno .btn .fa-large.headerlink,.rst-content .eqno .nav .fa-large.headerlink,.rst-content .nav .fa-large.admonition-title,.rst-content code.download .btn span.fa-large:first-child,.rst-content code.download .nav span.fa-large:first-child,.rst-content dl dt .btn .fa-large.headerlink,.rst-content dl dt .nav .fa-large.headerlink,.rst-content h1 .btn .fa-large.headerlink,.rst-content h1 .nav .fa-large.headerlink,.rst-content h2 .btn .fa-large.headerlink,.rst-content h2 .nav .fa-large.headerlink,.rst-content h3 .btn .fa-large.headerlink,.rst-content h3 .nav .fa-large.headerlink,.rst-content h4 .btn .fa-large.headerlink,.rst-content h4 .nav .fa-large.headerlink,.rst-content h5 .btn .fa-large.headerlink,.rst-content h5 .nav .fa-large.headerlink,.rst-content h6 .btn .fa-large.headerlink,.rst-content h6 .nav .fa-large.headerlink,.rst-content p .btn .fa-large.headerlink,.rst-content p .nav .fa-large.headerlink,.rst-content table>caption .btn .fa-large.headerlink,.rst-content table>caption .nav .fa-large.headerlink,.rst-content tt.download .btn span.fa-large:first-child,.rst-content tt.download .nav span.fa-large:first-child,.wy-menu-vertical li .btn button.fa-large.toctree-expand,.wy-menu-vertical li .nav button.fa-large.toctree-expand{line-height:.9em}.btn .fa-spin.icon,.btn .fa.fa-spin,.btn .rst-content .code-block-caption .fa-spin.headerlink,.btn .rst-content .eqno .fa-spin.headerlink,.btn .rst-content .fa-spin.admonition-title,.btn .rst-content code.download span.fa-spin:first-child,.btn .rst-content dl dt .fa-spin.headerlink,.btn .rst-content h1 .fa-spin.headerlink,.btn .rst-content h2 .fa-spin.headerlink,.btn .rst-content h3 .fa-spin.headerlink,.btn .rst-content h4 .fa-spin.headerlink,.btn .rst-content h5 .fa-spin.headerlink,.btn .rst-content h6 .fa-spin.headerlink,.btn .rst-content p .fa-spin.headerlink,.btn .rst-content table>caption .fa-spin.headerlink,.btn .rst-content tt.download span.fa-spin:first-child,.btn .wy-menu-vertical li button.fa-spin.toctree-expand,.nav .fa-spin.icon,.nav .fa.fa-spin,.nav .rst-content .code-block-caption .fa-spin.headerlink,.nav .rst-content .eqno .fa-spin.headerlink,.nav .rst-content .fa-spin.admonition-title,.nav .rst-content code.download span.fa-spin:first-child,.nav .rst-content dl dt .fa-spin.headerlink,.nav .rst-content h1 .fa-spin.headerlink,.nav .rst-content h2 .fa-spin.headerlink,.nav .rst-content h3 .fa-spin.headerlink,.nav .rst-content h4 .fa-spin.headerlink,.nav .rst-content h5 .fa-spin.headerlink,.nav .rst-content h6 .fa-spin.headerlink,.nav .rst-content p .fa-spin.headerlink,.nav .rst-content table>caption .fa-spin.headerlink,.nav .rst-content tt.download span.fa-spin:first-child,.nav .wy-menu-vertical li button.fa-spin.toctree-expand,.rst-content .btn .fa-spin.admonition-title,.rst-content .code-block-caption .btn .fa-spin.headerlink,.rst-content .code-block-caption .nav .fa-spin.headerlink,.rst-content .eqno .btn .fa-spin.headerlink,.rst-content .eqno .nav .fa-spin.headerlink,.rst-content .nav .fa-spin.admonition-title,.rst-content code.download .btn span.fa-spin:first-child,.rst-content code.download .nav span.fa-spin:first-child,.rst-content dl dt .btn .fa-spin.headerlink,.rst-content dl dt .nav .fa-spin.headerlink,.rst-content h1 .btn .fa-spin.headerlink,.rst-content h1 .nav .fa-spin.headerlink,.rst-content h2 .btn .fa-spin.headerlink,.rst-content h2 .nav .fa-spin.headerlink,.rst-content h3 .btn .fa-spin.headerlink,.rst-content h3 .nav .fa-spin.headerlink,.rst-content h4 .btn .fa-spin.headerlink,.rst-content h4 .nav .fa-spin.headerlink,.rst-content h5 .btn .fa-spin.headerlink,.rst-content h5 .nav .fa-spin.headerlink,.rst-content h6 .btn .fa-spin.headerlink,.rst-content h6 .nav .fa-spin.headerlink,.rst-content p .btn .fa-spin.headerlink,.rst-content p .nav .fa-spin.headerlink,.rst-content table>caption .btn .fa-spin.headerlink,.rst-content table>caption .nav .fa-spin.headerlink,.rst-content tt.download .btn span.fa-spin:first-child,.rst-content tt.download .nav span.fa-spin:first-child,.wy-menu-vertical li .btn button.fa-spin.toctree-expand,.wy-menu-vertical li .nav button.fa-spin.toctree-expand{display:inline-block}.btn.fa:before,.btn.icon:before,.rst-content .btn.admonition-title:before,.rst-content .code-block-caption .btn.headerlink:before,.rst-content .eqno .btn.headerlink:before,.rst-content code.download span.btn:first-child:before,.rst-content dl dt .btn.headerlink:before,.rst-content h1 .btn.headerlink:before,.rst-content h2 .btn.headerlink:before,.rst-content h3 .btn.headerlink:before,.rst-content h4 .btn.headerlink:before,.rst-content h5 .btn.headerlink:before,.rst-content h6 .btn.headerlink:before,.rst-content p .btn.headerlink:before,.rst-content table>caption .btn.headerlink:before,.rst-content tt.download span.btn:first-child:before,.wy-menu-vertical li button.btn.toctree-expand:before{opacity:.5;-webkit-transition:opacity .05s ease-in;-moz-transition:opacity .05s ease-in;transition:opacity .05s ease-in}.btn.fa:hover:before,.btn.icon:hover:before,.rst-content .btn.admonition-title:hover:before,.rst-content .code-block-caption .btn.headerlink:hover:before,.rst-content .eqno .btn.headerlink:hover:before,.rst-content code.download span.btn:first-child:hover:before,.rst-content dl dt .btn.headerlink:hover:before,.rst-content h1 .btn.headerlink:hover:before,.rst-content h2 .btn.headerlink:hover:before,.rst-content h3 .btn.headerlink:hover:before,.rst-content h4 .btn.headerlink:hover:before,.rst-content h5 .btn.headerlink:hover:before,.rst-content h6 .btn.headerlink:hover:before,.rst-content p .btn.headerlink:hover:before,.rst-content table>caption .btn.headerlink:hover:before,.rst-content tt.download span.btn:first-child:hover:before,.wy-menu-vertical li button.btn.toctree-expand:hover:before{opacity:1}.btn-mini .fa:before,.btn-mini .icon:before,.btn-mini .rst-content .admonition-title:before,.btn-mini .rst-content .code-block-caption .headerlink:before,.btn-mini .rst-content .eqno .headerlink:before,.btn-mini .rst-content code.download span:first-child:before,.btn-mini .rst-content dl dt .headerlink:before,.btn-mini .rst-content h1 .headerlink:before,.btn-mini .rst-content h2 .headerlink:before,.btn-mini .rst-content h3 .headerlink:before,.btn-mini .rst-content h4 .headerlink:before,.btn-mini .rst-content h5 .headerlink:before,.btn-mini .rst-content h6 .headerlink:before,.btn-mini .rst-content p .headerlink:before,.btn-mini .rst-content table>caption .headerlink:before,.btn-mini .rst-content tt.download span:first-child:before,.btn-mini .wy-menu-vertical li button.toctree-expand:before,.rst-content .btn-mini .admonition-title:before,.rst-content .code-block-caption .btn-mini .headerlink:before,.rst-content .eqno .btn-mini .headerlink:before,.rst-content code.download .btn-mini span:first-child:before,.rst-content dl dt .btn-mini .headerlink:before,.rst-content h1 .btn-mini .headerlink:before,.rst-content h2 .btn-mini .headerlink:before,.rst-content h3 .btn-mini .headerlink:before,.rst-content h4 .btn-mini .headerlink:before,.rst-content h5 .btn-mini .headerlink:before,.rst-content h6 .btn-mini .headerlink:before,.rst-content p .btn-mini .headerlink:before,.rst-content table>caption .btn-mini .headerlink:before,.rst-content tt.download .btn-mini span:first-child:before,.wy-menu-vertical li .btn-mini button.toctree-expand:before{font-size:14px;vertical-align:-15%}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning,.wy-alert{padding:12px;line-height:24px;margin-bottom:24px;background:#e7f2fa}.rst-content .admonition-title,.wy-alert-title{font-weight:700;display:block;color:#fff;background:#6ab0de;padding:6px 12px;margin:-12px -12px 12px}.rst-content .danger,.rst-content .error,.rst-content .wy-alert-danger.admonition,.rst-content .wy-alert-danger.admonition-todo,.rst-content .wy-alert-danger.attention,.rst-content .wy-alert-danger.caution,.rst-content .wy-alert-danger.hint,.rst-content .wy-alert-danger.important,.rst-content .wy-alert-danger.note,.rst-content .wy-alert-danger.seealso,.rst-content .wy-alert-danger.tip,.rst-content .wy-alert-danger.warning,.wy-alert.wy-alert-danger{background:#fdf3f2}.rst-content .danger .admonition-title,.rst-content .danger .wy-alert-title,.rst-content .error .admonition-title,.rst-content .error .wy-alert-title,.rst-content .wy-alert-danger.admonition-todo .admonition-title,.rst-content .wy-alert-danger.admonition-todo .wy-alert-title,.rst-content .wy-alert-danger.admonition .admonition-title,.rst-content .wy-alert-danger.admonition .wy-alert-title,.rst-content .wy-alert-danger.attention .admonition-title,.rst-content .wy-alert-danger.attention .wy-alert-title,.rst-content .wy-alert-danger.caution .admonition-title,.rst-content .wy-alert-danger.caution .wy-alert-title,.rst-content .wy-alert-danger.hint .admonition-title,.rst-content .wy-alert-danger.hint .wy-alert-title,.rst-content .wy-alert-danger.important .admonition-title,.rst-content .wy-alert-danger.important .wy-alert-title,.rst-content .wy-alert-danger.note .admonition-title,.rst-content .wy-alert-danger.note .wy-alert-title,.rst-content .wy-alert-danger.seealso .admonition-title,.rst-content .wy-alert-danger.seealso .wy-alert-title,.rst-content .wy-alert-danger.tip .admonition-title,.rst-content .wy-alert-danger.tip .wy-alert-title,.rst-content .wy-alert-danger.warning .admonition-title,.rst-content .wy-alert-danger.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-danger .admonition-title,.wy-alert.wy-alert-danger .rst-content .admonition-title,.wy-alert.wy-alert-danger .wy-alert-title{background:#f29f97}.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .warning,.rst-content .wy-alert-warning.admonition,.rst-content .wy-alert-warning.danger,.rst-content .wy-alert-warning.error,.rst-content .wy-alert-warning.hint,.rst-content .wy-alert-warning.important,.rst-content .wy-alert-warning.note,.rst-content .wy-alert-warning.seealso,.rst-content .wy-alert-warning.tip,.wy-alert.wy-alert-warning{background:#ffedcc}.rst-content .admonition-todo .admonition-title,.rst-content .admonition-todo .wy-alert-title,.rst-content .attention .admonition-title,.rst-content .attention .wy-alert-title,.rst-content .caution .admonition-title,.rst-content .caution .wy-alert-title,.rst-content .warning .admonition-title,.rst-content .warning .wy-alert-title,.rst-content .wy-alert-warning.admonition .admonition-title,.rst-content .wy-alert-warning.admonition .wy-alert-title,.rst-content .wy-alert-warning.danger .admonition-title,.rst-content .wy-alert-warning.danger .wy-alert-title,.rst-content .wy-alert-warning.error .admonition-title,.rst-content .wy-alert-warning.error .wy-alert-title,.rst-content .wy-alert-warning.hint .admonition-title,.rst-content .wy-alert-warning.hint .wy-alert-title,.rst-content .wy-alert-warning.important .admonition-title,.rst-content .wy-alert-warning.important .wy-alert-title,.rst-content .wy-alert-warning.note .admonition-title,.rst-content .wy-alert-warning.note .wy-alert-title,.rst-content .wy-alert-warning.seealso .admonition-title,.rst-content .wy-alert-warning.seealso .wy-alert-title,.rst-content .wy-alert-warning.tip .admonition-title,.rst-content .wy-alert-warning.tip .wy-alert-title,.rst-content .wy-alert.wy-alert-warning .admonition-title,.wy-alert.wy-alert-warning .rst-content .admonition-title,.wy-alert.wy-alert-warning .wy-alert-title{background:#f0b37e}.rst-content .note,.rst-content .seealso,.rst-content .wy-alert-info.admonition,.rst-content .wy-alert-info.admonition-todo,.rst-content .wy-alert-info.attention,.rst-content .wy-alert-info.caution,.rst-content .wy-alert-info.danger,.rst-content .wy-alert-info.error,.rst-content .wy-alert-info.hint,.rst-content .wy-alert-info.important,.rst-content .wy-alert-info.tip,.rst-content .wy-alert-info.warning,.wy-alert.wy-alert-info{background:#e7f2fa}.rst-content .note .admonition-title,.rst-content .note .wy-alert-title,.rst-content .seealso .admonition-title,.rst-content .seealso .wy-alert-title,.rst-content .wy-alert-info.admonition-todo .admonition-title,.rst-content .wy-alert-info.admonition-todo .wy-alert-title,.rst-content .wy-alert-info.admonition .admonition-title,.rst-content .wy-alert-info.admonition .wy-alert-title,.rst-content .wy-alert-info.attention .admonition-title,.rst-content .wy-alert-info.attention .wy-alert-title,.rst-content .wy-alert-info.caution .admonition-title,.rst-content .wy-alert-info.caution .wy-alert-title,.rst-content .wy-alert-info.danger .admonition-title,.rst-content .wy-alert-info.danger .wy-alert-title,.rst-content .wy-alert-info.error .admonition-title,.rst-content .wy-alert-info.error .wy-alert-title,.rst-content .wy-alert-info.hint .admonition-title,.rst-content .wy-alert-info.hint .wy-alert-title,.rst-content .wy-alert-info.important .admonition-title,.rst-content .wy-alert-info.important .wy-alert-title,.rst-content .wy-alert-info.tip .admonition-title,.rst-content .wy-alert-info.tip .wy-alert-title,.rst-content .wy-alert-info.warning .admonition-title,.rst-content .wy-alert-info.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-info .admonition-title,.wy-alert.wy-alert-info .rst-content .admonition-title,.wy-alert.wy-alert-info .wy-alert-title{background:#6ab0de}.rst-content .hint,.rst-content .important,.rst-content .tip,.rst-content .wy-alert-success.admonition,.rst-content .wy-alert-success.admonition-todo,.rst-content .wy-alert-success.attention,.rst-content .wy-alert-success.caution,.rst-content .wy-alert-success.danger,.rst-content .wy-alert-success.error,.rst-content .wy-alert-success.note,.rst-content .wy-alert-success.seealso,.rst-content .wy-alert-success.warning,.wy-alert.wy-alert-success{background:#dbfaf4}.rst-content .hint .admonition-title,.rst-content .hint .wy-alert-title,.rst-content .important .admonition-title,.rst-content .important .wy-alert-title,.rst-content .tip .admonition-title,.rst-content .tip .wy-alert-title,.rst-content .wy-alert-success.admonition-todo .admonition-title,.rst-content .wy-alert-success.admonition-todo .wy-alert-title,.rst-content .wy-alert-success.admonition .admonition-title,.rst-content .wy-alert-success.admonition .wy-alert-title,.rst-content .wy-alert-success.attention .admonition-title,.rst-content .wy-alert-success.attention .wy-alert-title,.rst-content .wy-alert-success.caution .admonition-title,.rst-content .wy-alert-success.caution .wy-alert-title,.rst-content .wy-alert-success.danger .admonition-title,.rst-content .wy-alert-success.danger .wy-alert-title,.rst-content .wy-alert-success.error .admonition-title,.rst-content .wy-alert-success.error .wy-alert-title,.rst-content .wy-alert-success.note .admonition-title,.rst-content .wy-alert-success.note .wy-alert-title,.rst-content .wy-alert-success.seealso .admonition-title,.rst-content .wy-alert-success.seealso .wy-alert-title,.rst-content .wy-alert-success.warning .admonition-title,.rst-content .wy-alert-success.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-success .admonition-title,.wy-alert.wy-alert-success .rst-content .admonition-title,.wy-alert.wy-alert-success .wy-alert-title{background:#1abc9c}.rst-content .wy-alert-neutral.admonition,.rst-content .wy-alert-neutral.admonition-todo,.rst-content .wy-alert-neutral.attention,.rst-content .wy-alert-neutral.caution,.rst-content .wy-alert-neutral.danger,.rst-content .wy-alert-neutral.error,.rst-content .wy-alert-neutral.hint,.rst-content .wy-alert-neutral.important,.rst-content .wy-alert-neutral.note,.rst-content .wy-alert-neutral.seealso,.rst-content .wy-alert-neutral.tip,.rst-content .wy-alert-neutral.warning,.wy-alert.wy-alert-neutral{background:#f3f6f6}.rst-content .wy-alert-neutral.admonition-todo .admonition-title,.rst-content .wy-alert-neutral.admonition-todo .wy-alert-title,.rst-content .wy-alert-neutral.admonition .admonition-title,.rst-content .wy-alert-neutral.admonition .wy-alert-title,.rst-content .wy-alert-neutral.attention .admonition-title,.rst-content .wy-alert-neutral.attention .wy-alert-title,.rst-content .wy-alert-neutral.caution .admonition-title,.rst-content .wy-alert-neutral.caution .wy-alert-title,.rst-content .wy-alert-neutral.danger .admonition-title,.rst-content .wy-alert-neutral.danger .wy-alert-title,.rst-content .wy-alert-neutral.error .admonition-title,.rst-content .wy-alert-neutral.error .wy-alert-title,.rst-content .wy-alert-neutral.hint .admonition-title,.rst-content .wy-alert-neutral.hint .wy-alert-title,.rst-content .wy-alert-neutral.important .admonition-title,.rst-content .wy-alert-neutral.important .wy-alert-title,.rst-content .wy-alert-neutral.note .admonition-title,.rst-content .wy-alert-neutral.note .wy-alert-title,.rst-content .wy-alert-neutral.seealso .admonition-title,.rst-content .wy-alert-neutral.seealso .wy-alert-title,.rst-content .wy-alert-neutral.tip .admonition-title,.rst-content .wy-alert-neutral.tip .wy-alert-title,.rst-content .wy-alert-neutral.warning .admonition-title,.rst-content .wy-alert-neutral.warning .wy-alert-title,.rst-content .wy-alert.wy-alert-neutral .admonition-title,.wy-alert.wy-alert-neutral .rst-content .admonition-title,.wy-alert.wy-alert-neutral .wy-alert-title{color:#404040;background:#e1e4e5}.rst-content .wy-alert-neutral.admonition-todo a,.rst-content .wy-alert-neutral.admonition a,.rst-content .wy-alert-neutral.attention a,.rst-content .wy-alert-neutral.caution a,.rst-content .wy-alert-neutral.danger a,.rst-content .wy-alert-neutral.error a,.rst-content .wy-alert-neutral.hint a,.rst-content .wy-alert-neutral.important a,.rst-content .wy-alert-neutral.note a,.rst-content .wy-alert-neutral.seealso a,.rst-content .wy-alert-neutral.tip a,.rst-content .wy-alert-neutral.warning a,.wy-alert.wy-alert-neutral a{color:#2980b9}.rst-content .admonition-todo p:last-child,.rst-content .admonition p:last-child,.rst-content .attention p:last-child,.rst-content .caution p:last-child,.rst-content .danger p:last-child,.rst-content .error p:last-child,.rst-content .hint p:last-child,.rst-content .important p:last-child,.rst-content .note p:last-child,.rst-content .seealso p:last-child,.rst-content .tip p:last-child,.rst-content .warning p:last-child,.wy-alert p:last-child{margin-bottom:0}.wy-tray-container{position:fixed;bottom:0;left:0;z-index:600}.wy-tray-container li{display:block;width:300px;background:transparent;color:#fff;text-align:center;box-shadow:0 5px 5px 0 rgba(0,0,0,.1);padding:0 24px;min-width:20%;opacity:0;height:0;line-height:56px;overflow:hidden;-webkit-transition:all .3s ease-in;-moz-transition:all .3s ease-in;transition:all .3s ease-in}.wy-tray-container li.wy-tray-item-success{background:#27ae60}.wy-tray-container li.wy-tray-item-info{background:#2980b9}.wy-tray-container li.wy-tray-item-warning{background:#e67e22}.wy-tray-container li.wy-tray-item-danger{background:#e74c3c}.wy-tray-container li.on{opacity:1;height:56px}@media screen and (max-width:768px){.wy-tray-container{bottom:auto;top:0;width:100%}.wy-tray-container li{width:100%}}button{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle;cursor:pointer;line-height:normal;-webkit-appearance:button;*overflow:visible}button::-moz-focus-inner,input::-moz-focus-inner{border:0;padding:0}button[disabled]{cursor:default}.btn{display:inline-block;border-radius:2px;line-height:normal;white-space:nowrap;text-align:center;cursor:pointer;font-size:100%;padding:6px 12px 8px;color:#fff;border:1px solid rgba(0,0,0,.1);background-color:#27ae60;text-decoration:none;font-weight:400;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 2px -1px hsla(0,0%,100%,.5),inset 0 -2px 0 0 rgba(0,0,0,.1);outline-none:false;vertical-align:middle;*display:inline;zoom:1;-webkit-user-drag:none;-webkit-user-select:none;-moz-user-select:none;-ms-user-select:none;user-select:none;-webkit-transition:all .1s linear;-moz-transition:all .1s linear;transition:all .1s linear}.btn-hover{background:#2e8ece;color:#fff}.btn:hover{background:#2cc36b;color:#fff}.btn:focus{background:#2cc36b;outline:0}.btn:active{box-shadow:inset 0 -1px 0 0 rgba(0,0,0,.05),inset 0 2px 0 0 rgba(0,0,0,.1);padding:8px 12px 6px}.btn:visited{color:#fff}.btn-disabled,.btn-disabled:active,.btn-disabled:focus,.btn-disabled:hover,.btn:disabled{background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled = false);filter:alpha(opacity=40);opacity:.4;cursor:not-allowed;box-shadow:none}.btn::-moz-focus-inner{padding:0;border:0}.btn-small{font-size:80%}.btn-info{background-color:#2980b9!important}.btn-info:hover{background-color:#2e8ece!important}.btn-neutral{background-color:#f3f6f6!important;color:#404040!important}.btn-neutral:hover{background-color:#e5ebeb!important;color:#404040}.btn-neutral:visited{color:#404040!important}.btn-success{background-color:#27ae60!important}.btn-success:hover{background-color:#295!important}.btn-danger{background-color:#e74c3c!important}.btn-danger:hover{background-color:#ea6153!important}.btn-warning{background-color:#e67e22!important}.btn-warning:hover{background-color:#e98b39!important}.btn-invert{background-color:#222}.btn-invert:hover{background-color:#2f2f2f!important}.btn-link{background-color:transparent!important;color:#2980b9;box-shadow:none;border-color:transparent!important}.btn-link:active,.btn-link:hover{background-color:transparent!important;color:#409ad5!important;box-shadow:none}.btn-link:visited{color:#9b59b6}.wy-btn-group .btn,.wy-control .btn{vertical-align:middle}.wy-btn-group{margin-bottom:24px;*zoom:1}.wy-btn-group:after,.wy-btn-group:before{display:table;content:""}.wy-btn-group:after{clear:both}.wy-dropdown{position:relative;display:inline-block}.wy-dropdown-active .wy-dropdown-menu{display:block}.wy-dropdown-menu{position:absolute;left:0;display:none;float:left;top:100%;min-width:100%;background:#fcfcfc;z-index:100;border:1px solid #cfd7dd;box-shadow:0 2px 2px 0 rgba(0,0,0,.1);padding:12px}.wy-dropdown-menu>dd>a{display:block;clear:both;color:#404040;white-space:nowrap;font-size:90%;padding:0 12px;cursor:pointer}.wy-dropdown-menu>dd>a:hover{background:#2980b9;color:#fff}.wy-dropdown-menu>dd.divider{border-top:1px solid #cfd7dd;margin:6px 0}.wy-dropdown-menu>dd.search{padding-bottom:12px}.wy-dropdown-menu>dd.search input[type=search]{width:100%}.wy-dropdown-menu>dd.call-to-action{background:#e3e3e3;text-transform:uppercase;font-weight:500;font-size:80%}.wy-dropdown-menu>dd.call-to-action:hover{background:#e3e3e3}.wy-dropdown-menu>dd.call-to-action .btn{color:#fff}.wy-dropdown.wy-dropdown-up .wy-dropdown-menu{bottom:100%;top:auto;left:auto;right:0}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu{background:#fcfcfc;margin-top:2px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a{padding:6px 12px}.wy-dropdown.wy-dropdown-bubble .wy-dropdown-menu a:hover{background:#2980b9;color:#fff}.wy-dropdown.wy-dropdown-left .wy-dropdown-menu{right:0;left:auto;text-align:right}.wy-dropdown-arrow:before{content:" ";border-bottom:5px solid #f5f5f5;border-left:5px solid transparent;border-right:5px solid transparent;position:absolute;display:block;top:-4px;left:50%;margin-left:-3px}.wy-dropdown-arrow.wy-dropdown-arrow-left:before{left:11px}.wy-form-stacked select{display:block}.wy-form-aligned .wy-help-inline,.wy-form-aligned input,.wy-form-aligned label,.wy-form-aligned select,.wy-form-aligned textarea{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-form-aligned .wy-control-group>label{display:inline-block;vertical-align:middle;width:10em;margin:6px 12px 0 0;float:left}.wy-form-aligned .wy-control{float:left}.wy-form-aligned .wy-control label{display:block}.wy-form-aligned .wy-control select{margin-top:6px}fieldset{margin:0}fieldset,legend{border:0;padding:0}legend{width:100%;white-space:normal;margin-bottom:24px;font-size:150%;*margin-left:-7px}label,legend{display:block}label{margin:0 0 .3125em;color:#333;font-size:90%}input,select,textarea{font-size:100%;margin:0;vertical-align:baseline;*vertical-align:middle}.wy-control-group{margin-bottom:24px;max-width:1200px;margin-left:auto;margin-right:auto;*zoom:1}.wy-control-group:after,.wy-control-group:before{display:table;content:""}.wy-control-group:after{clear:both}.wy-control-group.wy-control-group-required>label:after{content:" *";color:#e74c3c}.wy-control-group .wy-form-full,.wy-control-group .wy-form-halves,.wy-control-group .wy-form-thirds{padding-bottom:12px}.wy-control-group .wy-form-full input[type=color],.wy-control-group .wy-form-full input[type=date],.wy-control-group .wy-form-full input[type=datetime-local],.wy-control-group .wy-form-full input[type=datetime],.wy-control-group .wy-form-full input[type=email],.wy-control-group .wy-form-full input[type=month],.wy-control-group .wy-form-full input[type=number],.wy-control-group .wy-form-full input[type=password],.wy-control-group .wy-form-full input[type=search],.wy-control-group .wy-form-full input[type=tel],.wy-control-group .wy-form-full input[type=text],.wy-control-group .wy-form-full input[type=time],.wy-control-group .wy-form-full input[type=url],.wy-control-group .wy-form-full input[type=week],.wy-control-group .wy-form-full select,.wy-control-group .wy-form-halves input[type=color],.wy-control-group .wy-form-halves input[type=date],.wy-control-group .wy-form-halves input[type=datetime-local],.wy-control-group .wy-form-halves input[type=datetime],.wy-control-group .wy-form-halves input[type=email],.wy-control-group .wy-form-halves input[type=month],.wy-control-group .wy-form-halves input[type=number],.wy-control-group .wy-form-halves input[type=password],.wy-control-group .wy-form-halves input[type=search],.wy-control-group .wy-form-halves input[type=tel],.wy-control-group .wy-form-halves input[type=text],.wy-control-group .wy-form-halves input[type=time],.wy-control-group .wy-form-halves input[type=url],.wy-control-group .wy-form-halves input[type=week],.wy-control-group .wy-form-halves select,.wy-control-group .wy-form-thirds input[type=color],.wy-control-group .wy-form-thirds input[type=date],.wy-control-group .wy-form-thirds input[type=datetime-local],.wy-control-group .wy-form-thirds input[type=datetime],.wy-control-group .wy-form-thirds input[type=email],.wy-control-group .wy-form-thirds input[type=month],.wy-control-group .wy-form-thirds input[type=number],.wy-control-group .wy-form-thirds input[type=password],.wy-control-group .wy-form-thirds input[type=search],.wy-control-group .wy-form-thirds input[type=tel],.wy-control-group .wy-form-thirds input[type=text],.wy-control-group .wy-form-thirds input[type=time],.wy-control-group .wy-form-thirds input[type=url],.wy-control-group .wy-form-thirds input[type=week],.wy-control-group .wy-form-thirds select{width:100%}.wy-control-group .wy-form-full{float:left;display:block;width:100%;margin-right:0}.wy-control-group .wy-form-full:last-child{margin-right:0}.wy-control-group .wy-form-halves{float:left;display:block;margin-right:2.35765%;width:48.82117%}.wy-control-group .wy-form-halves:last-child,.wy-control-group .wy-form-halves:nth-of-type(2n){margin-right:0}.wy-control-group .wy-form-halves:nth-of-type(odd){clear:left}.wy-control-group .wy-form-thirds{float:left;display:block;margin-right:2.35765%;width:31.76157%}.wy-control-group .wy-form-thirds:last-child,.wy-control-group .wy-form-thirds:nth-of-type(3n){margin-right:0}.wy-control-group .wy-form-thirds:nth-of-type(3n+1){clear:left}.wy-control-group.wy-control-group-no-input .wy-control,.wy-control-no-input{margin:6px 0 0;font-size:90%}.wy-control-no-input{display:inline-block}.wy-control-group.fluid-input input[type=color],.wy-control-group.fluid-input input[type=date],.wy-control-group.fluid-input input[type=datetime-local],.wy-control-group.fluid-input input[type=datetime],.wy-control-group.fluid-input input[type=email],.wy-control-group.fluid-input input[type=month],.wy-control-group.fluid-input input[type=number],.wy-control-group.fluid-input input[type=password],.wy-control-group.fluid-input input[type=search],.wy-control-group.fluid-input input[type=tel],.wy-control-group.fluid-input input[type=text],.wy-control-group.fluid-input input[type=time],.wy-control-group.fluid-input input[type=url],.wy-control-group.fluid-input input[type=week]{width:100%}.wy-form-message-inline{padding-left:.3em;color:#666;font-size:90%}.wy-form-message{display:block;color:#999;font-size:70%;margin-top:.3125em;font-style:italic}.wy-form-message p{font-size:inherit;font-style:italic;margin-bottom:6px}.wy-form-message p:last-child{margin-bottom:0}input{line-height:normal}input[type=button],input[type=reset],input[type=submit]{-webkit-appearance:button;cursor:pointer;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;*overflow:visible}input[type=color],input[type=date],input[type=datetime-local],input[type=datetime],input[type=email],input[type=month],input[type=number],input[type=password],input[type=search],input[type=tel],input[type=text],input[type=time],input[type=url],input[type=week]{-webkit-appearance:none;padding:6px;display:inline-block;border:1px solid #ccc;font-size:80%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;box-shadow:inset 0 1px 3px #ddd;border-radius:0;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}input[type=datetime-local]{padding:.34375em .625em}input[disabled]{cursor:default}input[type=checkbox],input[type=radio]{padding:0;margin-right:.3125em;*height:13px;*width:13px}input[type=checkbox],input[type=radio],input[type=search]{-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}input[type=search]::-webkit-search-cancel-button,input[type=search]::-webkit-search-decoration{-webkit-appearance:none}input[type=color]:focus,input[type=date]:focus,input[type=datetime-local]:focus,input[type=datetime]:focus,input[type=email]:focus,input[type=month]:focus,input[type=number]:focus,input[type=password]:focus,input[type=search]:focus,input[type=tel]:focus,input[type=text]:focus,input[type=time]:focus,input[type=url]:focus,input[type=week]:focus{outline:0;outline:thin dotted\9;border-color:#333}input.no-focus:focus{border-color:#ccc!important}input[type=checkbox]:focus,input[type=file]:focus,input[type=radio]:focus{outline:thin dotted #333;outline:1px auto #129fea}input[type=color][disabled],input[type=date][disabled],input[type=datetime-local][disabled],input[type=datetime][disabled],input[type=email][disabled],input[type=month][disabled],input[type=number][disabled],input[type=password][disabled],input[type=search][disabled],input[type=tel][disabled],input[type=text][disabled],input[type=time][disabled],input[type=url][disabled],input[type=week][disabled]{cursor:not-allowed;background-color:#fafafa}input:focus:invalid,select:focus:invalid,textarea:focus:invalid{color:#e74c3c;border:1px solid #e74c3c}input:focus:invalid:focus,select:focus:invalid:focus,textarea:focus:invalid:focus{border-color:#e74c3c}input[type=checkbox]:focus:invalid:focus,input[type=file]:focus:invalid:focus,input[type=radio]:focus:invalid:focus{outline-color:#e74c3c}input.wy-input-large{padding:12px;font-size:100%}textarea{overflow:auto;vertical-align:top;width:100%;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif}select,textarea{padding:.5em .625em;display:inline-block;border:1px solid #ccc;font-size:80%;box-shadow:inset 0 1px 3px #ddd;-webkit-transition:border .3s linear;-moz-transition:border .3s linear;transition:border .3s linear}select{border:1px solid #ccc;background-color:#fff}select[multiple]{height:auto}select:focus,textarea:focus{outline:0}input[readonly],select[disabled],select[readonly],textarea[disabled],textarea[readonly]{cursor:not-allowed;background-color:#fafafa}input[type=checkbox][disabled],input[type=radio][disabled]{cursor:not-allowed}.wy-checkbox,.wy-radio{margin:6px 0;color:#404040;display:block}.wy-checkbox input,.wy-radio input{vertical-align:baseline}.wy-form-message-inline{display:inline-block;*display:inline;*zoom:1;vertical-align:middle}.wy-input-prefix,.wy-input-suffix{white-space:nowrap;padding:6px}.wy-input-prefix .wy-input-context,.wy-input-suffix .wy-input-context{line-height:27px;padding:0 8px;display:inline-block;font-size:80%;background-color:#f3f6f6;border:1px solid #ccc;color:#999}.wy-input-suffix .wy-input-context{border-left:0}.wy-input-prefix .wy-input-context{border-right:0}.wy-switch{position:relative;display:block;height:24px;margin-top:12px;cursor:pointer}.wy-switch:before{left:0;top:0;width:36px;height:12px;background:#ccc}.wy-switch:after,.wy-switch:before{position:absolute;content:"";display:block;border-radius:4px;-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;transition:all .2s ease-in-out}.wy-switch:after{width:18px;height:18px;background:#999;left:-3px;top:-3px}.wy-switch span{position:absolute;left:48px;display:block;font-size:12px;color:#ccc;line-height:1}.wy-switch.active:before{background:#1e8449}.wy-switch.active:after{left:24px;background:#27ae60}.wy-switch.disabled{cursor:not-allowed;opacity:.8}.wy-control-group.wy-control-group-error .wy-form-message,.wy-control-group.wy-control-group-error>label{color:#e74c3c}.wy-control-group.wy-control-group-error input[type=color],.wy-control-group.wy-control-group-error input[type=date],.wy-control-group.wy-control-group-error input[type=datetime-local],.wy-control-group.wy-control-group-error input[type=datetime],.wy-control-group.wy-control-group-error input[type=email],.wy-control-group.wy-control-group-error input[type=month],.wy-control-group.wy-control-group-error input[type=number],.wy-control-group.wy-control-group-error input[type=password],.wy-control-group.wy-control-group-error input[type=search],.wy-control-group.wy-control-group-error input[type=tel],.wy-control-group.wy-control-group-error input[type=text],.wy-control-group.wy-control-group-error input[type=time],.wy-control-group.wy-control-group-error input[type=url],.wy-control-group.wy-control-group-error input[type=week],.wy-control-group.wy-control-group-error textarea{border:1px solid #e74c3c}.wy-inline-validate{white-space:nowrap}.wy-inline-validate .wy-input-context{padding:.5em .625em;display:inline-block;font-size:80%}.wy-inline-validate.wy-inline-validate-success .wy-input-context{color:#27ae60}.wy-inline-validate.wy-inline-validate-danger .wy-input-context{color:#e74c3c}.wy-inline-validate.wy-inline-validate-warning .wy-input-context{color:#e67e22}.wy-inline-validate.wy-inline-validate-info .wy-input-context{color:#2980b9}.rotate-90{-webkit-transform:rotate(90deg);-moz-transform:rotate(90deg);-ms-transform:rotate(90deg);-o-transform:rotate(90deg);transform:rotate(90deg)}.rotate-180{-webkit-transform:rotate(180deg);-moz-transform:rotate(180deg);-ms-transform:rotate(180deg);-o-transform:rotate(180deg);transform:rotate(180deg)}.rotate-270{-webkit-transform:rotate(270deg);-moz-transform:rotate(270deg);-ms-transform:rotate(270deg);-o-transform:rotate(270deg);transform:rotate(270deg)}.mirror{-webkit-transform:scaleX(-1);-moz-transform:scaleX(-1);-ms-transform:scaleX(-1);-o-transform:scaleX(-1);transform:scaleX(-1)}.mirror.rotate-90{-webkit-transform:scaleX(-1) rotate(90deg);-moz-transform:scaleX(-1) rotate(90deg);-ms-transform:scaleX(-1) rotate(90deg);-o-transform:scaleX(-1) rotate(90deg);transform:scaleX(-1) rotate(90deg)}.mirror.rotate-180{-webkit-transform:scaleX(-1) rotate(180deg);-moz-transform:scaleX(-1) rotate(180deg);-ms-transform:scaleX(-1) rotate(180deg);-o-transform:scaleX(-1) rotate(180deg);transform:scaleX(-1) rotate(180deg)}.mirror.rotate-270{-webkit-transform:scaleX(-1) rotate(270deg);-moz-transform:scaleX(-1) rotate(270deg);-ms-transform:scaleX(-1) rotate(270deg);-o-transform:scaleX(-1) rotate(270deg);transform:scaleX(-1) rotate(270deg)}@media only screen and (max-width:480px){.wy-form button[type=submit]{margin:.7em 0 0}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=text],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week],.wy-form label{margin-bottom:.3em;display:block}.wy-form input[type=color],.wy-form input[type=date],.wy-form input[type=datetime-local],.wy-form input[type=datetime],.wy-form input[type=email],.wy-form input[type=month],.wy-form input[type=number],.wy-form input[type=password],.wy-form input[type=search],.wy-form input[type=tel],.wy-form input[type=time],.wy-form input[type=url],.wy-form input[type=week]{margin-bottom:0}.wy-form-aligned .wy-control-group label{margin-bottom:.3em;text-align:left;display:block;width:100%}.wy-form-aligned .wy-control{margin:1.5em 0 0}.wy-form-message,.wy-form-message-inline,.wy-form .wy-help-inline{display:block;font-size:80%;padding:6px 0}}@media screen and (max-width:768px){.tablet-hide{display:none}}@media screen and (max-width:480px){.mobile-hide{display:none}}.float-left{float:left}.float-right{float:right}.full-width{width:100%}.rst-content table.docutils,.rst-content table.field-list,.wy-table{border-collapse:collapse;border-spacing:0;empty-cells:show;margin-bottom:24px}.rst-content table.docutils caption,.rst-content table.field-list caption,.wy-table caption{color:#000;font:italic 85%/1 arial,sans-serif;padding:1em 0;text-align:center}.rst-content table.docutils td,.rst-content table.docutils th,.rst-content table.field-list td,.rst-content table.field-list th,.wy-table td,.wy-table th{font-size:90%;margin:0;overflow:visible;padding:8px 16px}.rst-content table.docutils td:first-child,.rst-content table.docutils th:first-child,.rst-content table.field-list td:first-child,.rst-content table.field-list th:first-child,.wy-table td:first-child,.wy-table th:first-child{border-left-width:0}.rst-content table.docutils thead,.rst-content table.field-list thead,.wy-table thead{color:#000;text-align:left;vertical-align:bottom;white-space:nowrap}.rst-content table.docutils thead th,.rst-content table.field-list thead th,.wy-table thead th{font-weight:700;border-bottom:2px solid #e1e4e5}.rst-content table.docutils td,.rst-content table.field-list td,.wy-table td{background-color:transparent;vertical-align:middle}.rst-content table.docutils td p,.rst-content table.field-list td p,.wy-table td p{line-height:18px}.rst-content table.docutils td p:last-child,.rst-content table.field-list td p:last-child,.wy-table td p:last-child{margin-bottom:0}.rst-content table.docutils .wy-table-cell-min,.rst-content table.field-list .wy-table-cell-min,.wy-table .wy-table-cell-min{width:1%;padding-right:0}.rst-content table.docutils .wy-table-cell-min input[type=checkbox],.rst-content table.field-list .wy-table-cell-min input[type=checkbox],.wy-table .wy-table-cell-min input[type=checkbox]{margin:0}.wy-table-secondary{color:grey;font-size:90%}.wy-table-tertiary{color:grey;font-size:80%}.rst-content table.docutils:not(.field-list) tr:nth-child(2n-1) td,.wy-table-backed,.wy-table-odd td,.wy-table-striped tr:nth-child(2n-1) td{background-color:#f3f6f6}.rst-content table.docutils,.wy-table-bordered-all{border:1px solid #e1e4e5}.rst-content table.docutils td,.wy-table-bordered-all td{border-bottom:1px solid #e1e4e5;border-left:1px solid #e1e4e5}.rst-content table.docutils tbody>tr:last-child td,.wy-table-bordered-all tbody>tr:last-child td{border-bottom-width:0}.wy-table-bordered{border:1px solid #e1e4e5}.wy-table-bordered-rows td{border-bottom:1px solid #e1e4e5}.wy-table-bordered-rows tbody>tr:last-child td{border-bottom-width:0}.wy-table-horizontal td,.wy-table-horizontal th{border-width:0 0 1px;border-bottom:1px solid #e1e4e5}.wy-table-horizontal tbody>tr:last-child td{border-bottom-width:0}.wy-table-responsive{margin-bottom:24px;max-width:100%;overflow:auto}.wy-table-responsive table{margin-bottom:0!important}.wy-table-responsive table td,.wy-table-responsive table th{white-space:nowrap}a{color:#2980b9;text-decoration:none;cursor:pointer}a:hover{color:#3091d1}a:visited{color:#9b59b6}html{height:100%}body,html{overflow-x:hidden}body{font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;font-weight:400;color:#404040;min-height:100%;background:#edf0f2}.wy-text-left{text-align:left}.wy-text-center{text-align:center}.wy-text-right{text-align:right}.wy-text-large{font-size:120%}.wy-text-normal{font-size:100%}.wy-text-small,small{font-size:80%}.wy-text-strike{text-decoration:line-through}.wy-text-warning{color:#e67e22!important}a.wy-text-warning:hover{color:#eb9950!important}.wy-text-info{color:#2980b9!important}a.wy-text-info:hover{color:#409ad5!important}.wy-text-success{color:#27ae60!important}a.wy-text-success:hover{color:#36d278!important}.wy-text-danger{color:#e74c3c!important}a.wy-text-danger:hover{color:#ed7669!important}.wy-text-neutral{color:#404040!important}a.wy-text-neutral:hover{color:#595959!important}.rst-content .toctree-wrapper>p.caption,h1,h2,h3,h4,h5,h6,legend{margin-top:0;font-weight:700;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif}p{line-height:24px;font-size:16px;margin:0 0 24px}h1{font-size:175%}.rst-content .toctree-wrapper>p.caption,h2{font-size:150%}h3{font-size:125%}h4{font-size:115%}h5{font-size:110%}h6{font-size:100%}hr{display:block;height:1px;border:0;border-top:1px solid #e1e4e5;margin:24px 0;padding:0}.rst-content code,.rst-content tt,code{white-space:nowrap;max-width:100%;background:#fff;border:1px solid #e1e4e5;font-size:75%;padding:0 5px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#e74c3c;overflow-x:auto}.rst-content tt.code-large,code.code-large{font-size:90%}.rst-content .section ul,.rst-content .toctree-wrapper ul,.rst-content section ul,.wy-plain-list-disc,article ul{list-style:disc;line-height:24px;margin-bottom:24px}.rst-content .section ul li,.rst-content .toctree-wrapper ul li,.rst-content section ul li,.wy-plain-list-disc li,article ul li{list-style:disc;margin-left:24px}.rst-content .section ul li p:last-child,.rst-content .section ul li ul,.rst-content .toctree-wrapper ul li p:last-child,.rst-content .toctree-wrapper ul li ul,.rst-content section ul li p:last-child,.rst-content section ul li ul,.wy-plain-list-disc li p:last-child,.wy-plain-list-disc li ul,article ul li p:last-child,article ul li ul{margin-bottom:0}.rst-content .section ul li li,.rst-content .toctree-wrapper ul li li,.rst-content section ul li li,.wy-plain-list-disc li li,article ul li li{list-style:circle}.rst-content .section ul li li li,.rst-content .toctree-wrapper ul li li li,.rst-content section ul li li li,.wy-plain-list-disc li li li,article ul li li li{list-style:square}.rst-content .section ul li ol li,.rst-content .toctree-wrapper ul li ol li,.rst-content section ul li ol li,.wy-plain-list-disc li ol li,article ul li ol li{list-style:decimal}.rst-content .section ol,.rst-content .section ol.arabic,.rst-content .toctree-wrapper ol,.rst-content .toctree-wrapper ol.arabic,.rst-content section ol,.rst-content section ol.arabic,.wy-plain-list-decimal,article ol{list-style:decimal;line-height:24px;margin-bottom:24px}.rst-content .section ol.arabic li,.rst-content .section ol li,.rst-content .toctree-wrapper ol.arabic li,.rst-content .toctree-wrapper ol li,.rst-content section ol.arabic li,.rst-content section ol li,.wy-plain-list-decimal li,article ol li{list-style:decimal;margin-left:24px}.rst-content .section ol.arabic li ul,.rst-content .section ol li p:last-child,.rst-content .section ol li ul,.rst-content .toctree-wrapper ol.arabic li ul,.rst-content .toctree-wrapper ol li p:last-child,.rst-content .toctree-wrapper ol li ul,.rst-content section ol.arabic li ul,.rst-content section ol li p:last-child,.rst-content section ol li ul,.wy-plain-list-decimal li p:last-child,.wy-plain-list-decimal li ul,article ol li p:last-child,article ol li ul{margin-bottom:0}.rst-content .section ol.arabic li ul li,.rst-content .section ol li ul li,.rst-content .toctree-wrapper ol.arabic li ul li,.rst-content .toctree-wrapper ol li ul li,.rst-content section ol.arabic li ul li,.rst-content section ol li ul li,.wy-plain-list-decimal li ul li,article ol li ul li{list-style:disc}.wy-breadcrumbs{*zoom:1}.wy-breadcrumbs:after,.wy-breadcrumbs:before{display:table;content:""}.wy-breadcrumbs:after{clear:both}.wy-breadcrumbs>li{display:inline-block;padding-top:5px}.wy-breadcrumbs>li.wy-breadcrumbs-aside{float:right}.rst-content .wy-breadcrumbs>li code,.rst-content .wy-breadcrumbs>li tt,.wy-breadcrumbs>li .rst-content tt,.wy-breadcrumbs>li code{all:inherit;color:inherit}.breadcrumb-item:before{content:"/";color:#bbb;font-size:13px;padding:0 6px 0 3px}.wy-breadcrumbs-extra{margin-bottom:0;color:#b3b3b3;font-size:80%;display:inline-block}@media screen and (max-width:480px){.wy-breadcrumbs-extra,.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}@media print{.wy-breadcrumbs li.wy-breadcrumbs-aside{display:none}}html{font-size:16px}.wy-affix{position:fixed;top:1.618em}.wy-menu a:hover{text-decoration:none}.wy-menu-horiz{*zoom:1}.wy-menu-horiz:after,.wy-menu-horiz:before{display:table;content:""}.wy-menu-horiz:after{clear:both}.wy-menu-horiz li,.wy-menu-horiz ul{display:inline-block}.wy-menu-horiz li:hover{background:hsla(0,0%,100%,.1)}.wy-menu-horiz li.divide-left{border-left:1px solid #404040}.wy-menu-horiz li.divide-right{border-right:1px solid #404040}.wy-menu-horiz a{height:32px;display:inline-block;line-height:32px;padding:0 16px}.wy-menu-vertical{width:300px}.wy-menu-vertical header,.wy-menu-vertical p.caption{color:#55a5d9;height:32px;line-height:32px;padding:0 1.618em;margin:12px 0 0;display:block;font-weight:700;text-transform:uppercase;font-size:85%;white-space:nowrap}.wy-menu-vertical ul{margin-bottom:0}.wy-menu-vertical li.divide-top{border-top:1px solid #404040}.wy-menu-vertical li.divide-bottom{border-bottom:1px solid #404040}.wy-menu-vertical li.current{background:#e3e3e3}.wy-menu-vertical li.current a{color:grey;border-right:1px solid #c9c9c9;padding:.4045em 2.427em}.wy-menu-vertical li.current a:hover{background:#d6d6d6}.rst-content .wy-menu-vertical li tt,.wy-menu-vertical li .rst-content tt,.wy-menu-vertical li code{border:none;background:inherit;color:inherit;padding-left:0;padding-right:0}.wy-menu-vertical li button.toctree-expand{display:block;float:left;margin-left:-1.2em;line-height:18px;color:#4d4d4d;border:none;background:none;padding:0}.wy-menu-vertical li.current>a,.wy-menu-vertical li.on a{color:#404040;font-weight:700;position:relative;background:#fcfcfc;border:none;padding:.4045em 1.618em}.wy-menu-vertical li.current>a:hover,.wy-menu-vertical li.on a:hover{background:#fcfcfc}.wy-menu-vertical li.current>a:hover button.toctree-expand,.wy-menu-vertical li.on a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.current>a button.toctree-expand,.wy-menu-vertical li.on a button.toctree-expand{display:block;line-height:18px;color:#333}.wy-menu-vertical li.toctree-l1.current>a{border-bottom:1px solid #c9c9c9;border-top:1px solid #c9c9c9}.wy-menu-vertical .toctree-l1.current .toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .toctree-l11>ul{display:none}.wy-menu-vertical .toctree-l1.current .current.toctree-l2>ul,.wy-menu-vertical .toctree-l2.current .current.toctree-l3>ul,.wy-menu-vertical .toctree-l3.current .current.toctree-l4>ul,.wy-menu-vertical .toctree-l4.current .current.toctree-l5>ul,.wy-menu-vertical .toctree-l5.current .current.toctree-l6>ul,.wy-menu-vertical .toctree-l6.current .current.toctree-l7>ul,.wy-menu-vertical .toctree-l7.current .current.toctree-l8>ul,.wy-menu-vertical .toctree-l8.current .current.toctree-l9>ul,.wy-menu-vertical .toctree-l9.current .current.toctree-l10>ul,.wy-menu-vertical .toctree-l10.current .current.toctree-l11>ul{display:block}.wy-menu-vertical li.toctree-l3,.wy-menu-vertical li.toctree-l4{font-size:.9em}.wy-menu-vertical li.toctree-l2 a,.wy-menu-vertical li.toctree-l3 a,.wy-menu-vertical li.toctree-l4 a,.wy-menu-vertical li.toctree-l5 a,.wy-menu-vertical li.toctree-l6 a,.wy-menu-vertical li.toctree-l7 a,.wy-menu-vertical li.toctree-l8 a,.wy-menu-vertical li.toctree-l9 a,.wy-menu-vertical li.toctree-l10 a{color:#404040}.wy-menu-vertical li.toctree-l2 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l3 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l4 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l5 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l6 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l7 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l8 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l9 a:hover button.toctree-expand,.wy-menu-vertical li.toctree-l10 a:hover button.toctree-expand{color:grey}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a,.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a,.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a,.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a,.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a,.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a,.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a,.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{display:block}.wy-menu-vertical li.toctree-l2.current>a{padding:.4045em 2.427em}.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{padding:.4045em 1.618em .4045em 4.045em}.wy-menu-vertical li.toctree-l3.current>a{padding:.4045em 4.045em}.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{padding:.4045em 1.618em .4045em 5.663em}.wy-menu-vertical li.toctree-l4.current>a{padding:.4045em 5.663em}.wy-menu-vertical li.toctree-l4.current li.toctree-l5>a{padding:.4045em 1.618em .4045em 7.281em}.wy-menu-vertical li.toctree-l5.current>a{padding:.4045em 7.281em}.wy-menu-vertical li.toctree-l5.current li.toctree-l6>a{padding:.4045em 1.618em .4045em 8.899em}.wy-menu-vertical li.toctree-l6.current>a{padding:.4045em 8.899em}.wy-menu-vertical li.toctree-l6.current li.toctree-l7>a{padding:.4045em 1.618em .4045em 10.517em}.wy-menu-vertical li.toctree-l7.current>a{padding:.4045em 10.517em}.wy-menu-vertical li.toctree-l7.current li.toctree-l8>a{padding:.4045em 1.618em .4045em 12.135em}.wy-menu-vertical li.toctree-l8.current>a{padding:.4045em 12.135em}.wy-menu-vertical li.toctree-l8.current li.toctree-l9>a{padding:.4045em 1.618em .4045em 13.753em}.wy-menu-vertical li.toctree-l9.current>a{padding:.4045em 13.753em}.wy-menu-vertical li.toctree-l9.current li.toctree-l10>a{padding:.4045em 1.618em .4045em 15.371em}.wy-menu-vertical li.toctree-l10.current>a{padding:.4045em 15.371em}.wy-menu-vertical li.toctree-l10.current li.toctree-l11>a{padding:.4045em 1.618em .4045em 16.989em}.wy-menu-vertical li.toctree-l2.current>a,.wy-menu-vertical li.toctree-l2.current li.toctree-l3>a{background:#c9c9c9}.wy-menu-vertical li.toctree-l2 button.toctree-expand{color:#a3a3a3}.wy-menu-vertical li.toctree-l3.current>a,.wy-menu-vertical li.toctree-l3.current li.toctree-l4>a{background:#bdbdbd}.wy-menu-vertical li.toctree-l3 button.toctree-expand{color:#969696}.wy-menu-vertical li.current ul{display:block}.wy-menu-vertical li ul{margin-bottom:0;display:none}.wy-menu-vertical li ul li a{margin-bottom:0;color:#d9d9d9;font-weight:400}.wy-menu-vertical a{line-height:18px;padding:.4045em 1.618em;display:block;position:relative;font-size:90%;color:#d9d9d9}.wy-menu-vertical a:hover{background-color:#4e4a4a;cursor:pointer}.wy-menu-vertical a:hover button.toctree-expand{color:#d9d9d9}.wy-menu-vertical a:active{background-color:#2980b9;cursor:pointer;color:#fff}.wy-menu-vertical a:active button.toctree-expand{color:#fff}.wy-side-nav-search{display:block;width:300px;padding:.809em;margin-bottom:.809em;z-index:200;background-color:#2980b9;text-align:center;color:#fcfcfc}.wy-side-nav-search input[type=text]{width:100%;border-radius:50px;padding:6px 12px;border-color:#2472a4}.wy-side-nav-search img{display:block;margin:auto auto .809em;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-side-nav-search .wy-dropdown>a,.wy-side-nav-search>a{color:#fcfcfc;font-size:100%;font-weight:700;display:inline-block;padding:4px 6px;margin-bottom:.809em;max-width:100%}.wy-side-nav-search .wy-dropdown>a:hover,.wy-side-nav-search>a:hover{background:hsla(0,0%,100%,.1)}.wy-side-nav-search .wy-dropdown>a img.logo,.wy-side-nav-search>a img.logo{display:block;margin:0 auto;height:auto;width:auto;border-radius:0;max-width:100%;background:transparent}.wy-side-nav-search .wy-dropdown>a.icon img.logo,.wy-side-nav-search>a.icon img.logo{margin-top:.85em}.wy-side-nav-search>div.version{margin-top:-.4045em;margin-bottom:.809em;font-weight:400;color:hsla(0,0%,100%,.3)}.wy-nav .wy-menu-vertical header{color:#2980b9}.wy-nav .wy-menu-vertical a{color:#b3b3b3}.wy-nav .wy-menu-vertical a:hover{background-color:#2980b9;color:#fff}[data-menu-wrap]{-webkit-transition:all .2s ease-in;-moz-transition:all .2s ease-in;transition:all .2s ease-in;position:absolute;opacity:1;width:100%;opacity:0}[data-menu-wrap].move-center{left:0;right:auto;opacity:1}[data-menu-wrap].move-left{right:auto;left:-100%;opacity:0}[data-menu-wrap].move-right{right:-100%;left:auto;opacity:0}.wy-body-for-nav{background:#fcfcfc}.wy-grid-for-nav{position:absolute;width:100%;height:100%}.wy-nav-side{position:fixed;top:0;bottom:0;left:0;padding-bottom:2em;width:300px;overflow-x:hidden;overflow-y:hidden;min-height:100%;color:#9b9b9b;background:#343131;z-index:200}.wy-side-scroll{width:320px;position:relative;overflow-x:hidden;overflow-y:scroll;height:100%}.wy-nav-top{display:none;background:#2980b9;color:#fff;padding:.4045em .809em;position:relative;line-height:50px;text-align:center;font-size:100%;*zoom:1}.wy-nav-top:after,.wy-nav-top:before{display:table;content:""}.wy-nav-top:after{clear:both}.wy-nav-top a{color:#fff;font-weight:700}.wy-nav-top img{margin-right:12px;height:45px;width:45px;background-color:#2980b9;padding:5px;border-radius:100%}.wy-nav-top i{font-size:30px;float:left;cursor:pointer;padding-top:inherit}.wy-nav-content-wrap{margin-left:300px;background:#fcfcfc;min-height:100%}.wy-nav-content{padding:1.618em 3.236em;height:100%;max-width:800px;margin:auto}.wy-body-mask{position:fixed;width:100%;height:100%;background:rgba(0,0,0,.2);display:none;z-index:499}.wy-body-mask.on{display:block}footer{color:grey}footer p{margin-bottom:12px}.rst-content footer span.commit tt,footer span.commit .rst-content tt,footer span.commit code{padding:0;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:1em;background:none;border:none;color:grey}.rst-footer-buttons{*zoom:1}.rst-footer-buttons:after,.rst-footer-buttons:before{width:100%;display:table;content:""}.rst-footer-buttons:after{clear:both}.rst-breadcrumbs-buttons{margin-top:12px;*zoom:1}.rst-breadcrumbs-buttons:after,.rst-breadcrumbs-buttons:before{display:table;content:""}.rst-breadcrumbs-buttons:after{clear:both}#search-results .search li{margin-bottom:24px;border-bottom:1px solid #e1e4e5;padding-bottom:24px}#search-results .search li:first-child{border-top:1px solid #e1e4e5;padding-top:24px}#search-results .search li a{font-size:120%;margin-bottom:12px;display:inline-block}#search-results .context{color:grey;font-size:90%}.genindextable li>ul{margin-left:24px}@media screen and (max-width:768px){.wy-body-for-nav{background:#fcfcfc}.wy-nav-top{display:block}.wy-nav-side{left:-300px}.wy-nav-side.shift{width:85%;left:0}.wy-menu.wy-menu-vertical,.wy-side-nav-search,.wy-side-scroll{width:auto}.wy-nav-content-wrap{margin-left:0}.wy-nav-content-wrap .wy-nav-content{padding:1.618em}.wy-nav-content-wrap.shift{position:fixed;min-width:100%;left:85%;top:0;height:100%;overflow:hidden}}@media screen and (min-width:1100px){.wy-nav-content-wrap{background:rgba(0,0,0,.05)}.wy-nav-content{margin:0;background:#fcfcfc}}@media print{.rst-versions,.wy-nav-side,footer{display:none}.wy-nav-content-wrap{margin-left:0}}.rst-versions{position:fixed;bottom:0;left:0;width:300px;color:#fcfcfc;background:#1f1d1d;font-family:Lato,proxima-nova,Helvetica Neue,Arial,sans-serif;z-index:400}.rst-versions a{color:#2980b9;text-decoration:none}.rst-versions .rst-badge-small{display:none}.rst-versions .rst-current-version{padding:12px;background-color:#272525;display:block;text-align:right;font-size:90%;cursor:pointer;color:#27ae60;*zoom:1}.rst-versions .rst-current-version:after,.rst-versions .rst-current-version:before{display:table;content:""}.rst-versions .rst-current-version:after{clear:both}.rst-content .code-block-caption .rst-versions .rst-current-version .headerlink,.rst-content .eqno .rst-versions .rst-current-version .headerlink,.rst-content .rst-versions .rst-current-version .admonition-title,.rst-content code.download .rst-versions .rst-current-version span:first-child,.rst-content dl dt .rst-versions .rst-current-version .headerlink,.rst-content h1 .rst-versions .rst-current-version .headerlink,.rst-content h2 .rst-versions .rst-current-version .headerlink,.rst-content h3 .rst-versions .rst-current-version .headerlink,.rst-content h4 .rst-versions .rst-current-version .headerlink,.rst-content h5 .rst-versions .rst-current-version .headerlink,.rst-content h6 .rst-versions .rst-current-version .headerlink,.rst-content p .rst-versions .rst-current-version .headerlink,.rst-content table>caption .rst-versions .rst-current-version .headerlink,.rst-content tt.download .rst-versions .rst-current-version span:first-child,.rst-versions .rst-current-version .fa,.rst-versions .rst-current-version .icon,.rst-versions .rst-current-version .rst-content .admonition-title,.rst-versions .rst-current-version .rst-content .code-block-caption .headerlink,.rst-versions .rst-current-version .rst-content .eqno .headerlink,.rst-versions .rst-current-version .rst-content code.download span:first-child,.rst-versions .rst-current-version .rst-content dl dt .headerlink,.rst-versions .rst-current-version .rst-content h1 .headerlink,.rst-versions .rst-current-version .rst-content h2 .headerlink,.rst-versions .rst-current-version .rst-content h3 .headerlink,.rst-versions .rst-current-version .rst-content h4 .headerlink,.rst-versions .rst-current-version .rst-content h5 .headerlink,.rst-versions .rst-current-version .rst-content h6 .headerlink,.rst-versions .rst-current-version .rst-content p .headerlink,.rst-versions .rst-current-version .rst-content table>caption .headerlink,.rst-versions .rst-current-version .rst-content tt.download span:first-child,.rst-versions .rst-current-version .wy-menu-vertical li button.toctree-expand,.wy-menu-vertical li .rst-versions .rst-current-version button.toctree-expand{color:#fcfcfc}.rst-versions .rst-current-version .fa-book,.rst-versions .rst-current-version .icon-book{float:left}.rst-versions .rst-current-version.rst-out-of-date{background-color:#e74c3c;color:#fff}.rst-versions .rst-current-version.rst-active-old-version{background-color:#f1c40f;color:#000}.rst-versions.shift-up{height:auto;max-height:100%;overflow-y:scroll}.rst-versions.shift-up .rst-other-versions{display:block}.rst-versions .rst-other-versions{font-size:90%;padding:12px;color:grey;display:none}.rst-versions .rst-other-versions hr{display:block;height:1px;border:0;margin:20px 0;padding:0;border-top:1px solid #413d3d}.rst-versions .rst-other-versions dd{display:inline-block;margin:0}.rst-versions .rst-other-versions dd a{display:inline-block;padding:6px;color:#fcfcfc}.rst-versions.rst-badge{width:auto;bottom:20px;right:20px;left:auto;border:none;max-width:300px;max-height:90%}.rst-versions.rst-badge .fa-book,.rst-versions.rst-badge .icon-book{float:none;line-height:30px}.rst-versions.rst-badge.shift-up .rst-current-version{text-align:right}.rst-versions.rst-badge.shift-up .rst-current-version .fa-book,.rst-versions.rst-badge.shift-up .rst-current-version .icon-book{float:left}.rst-versions.rst-badge>.rst-current-version{width:auto;height:30px;line-height:30px;padding:0 6px;display:block;text-align:center}@media screen and (max-width:768px){.rst-versions{width:85%;display:none}.rst-versions.shift{display:block}}.rst-content .toctree-wrapper>p.caption,.rst-content h1,.rst-content h2,.rst-content h3,.rst-content h4,.rst-content h5,.rst-content h6{margin-bottom:24px}.rst-content img{max-width:100%;height:auto}.rst-content div.figure,.rst-content figure{margin-bottom:24px}.rst-content div.figure .caption-text,.rst-content figure .caption-text{font-style:italic}.rst-content div.figure p:last-child.caption,.rst-content figure p:last-child.caption{margin-bottom:0}.rst-content div.figure.align-center,.rst-content figure.align-center{text-align:center}.rst-content .section>a>img,.rst-content .section>img,.rst-content section>a>img,.rst-content section>img{margin-bottom:24px}.rst-content abbr[title]{text-decoration:none}.rst-content.style-external-links a.reference.external:after{font-family:FontAwesome;content:"\f08e";color:#b3b3b3;vertical-align:super;font-size:60%;margin:0 .2em}.rst-content blockquote{margin-left:24px;line-height:24px;margin-bottom:24px}.rst-content pre.literal-block{white-space:pre;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;display:block;overflow:auto}.rst-content div[class^=highlight],.rst-content pre.literal-block{border:1px solid #e1e4e5;overflow-x:auto;margin:1px 0 24px}.rst-content div[class^=highlight] div[class^=highlight],.rst-content pre.literal-block div[class^=highlight]{padding:0;border:none;margin:0}.rst-content div[class^=highlight] td.code{width:100%}.rst-content .linenodiv pre{border-right:1px solid #e6e9ea;margin:0;padding:12px;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;user-select:none;pointer-events:none}.rst-content div[class^=highlight] pre{white-space:pre;margin:0;padding:12px;display:block;overflow:auto}.rst-content div[class^=highlight] pre .hll{display:block;margin:0 -12px;padding:0 12px}.rst-content .linenodiv pre,.rst-content div[class^=highlight] pre,.rst-content pre.literal-block{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;font-size:12px;line-height:1.4}.rst-content div.highlight .gp,.rst-content div.highlight span.linenos{user-select:none;pointer-events:none}.rst-content div.highlight span.linenos{display:inline-block;padding-left:0;padding-right:12px;margin-right:12px;border-right:1px solid #e6e9ea}.rst-content .code-block-caption{font-style:italic;font-size:85%;line-height:1;padding:1em 0;text-align:center}@media print{.rst-content .codeblock,.rst-content div[class^=highlight],.rst-content div[class^=highlight] pre{white-space:pre-wrap}}.rst-content .admonition,.rst-content .admonition-todo,.rst-content .attention,.rst-content .caution,.rst-content .danger,.rst-content .error,.rst-content .hint,.rst-content .important,.rst-content .note,.rst-content .seealso,.rst-content .tip,.rst-content .warning{clear:both}.rst-content .admonition-todo .last,.rst-content .admonition-todo>:last-child,.rst-content .admonition .last,.rst-content .admonition>:last-child,.rst-content .attention .last,.rst-content .attention>:last-child,.rst-content .caution .last,.rst-content .caution>:last-child,.rst-content .danger .last,.rst-content .danger>:last-child,.rst-content .error .last,.rst-content .error>:last-child,.rst-content .hint .last,.rst-content .hint>:last-child,.rst-content .important .last,.rst-content .important>:last-child,.rst-content .note .last,.rst-content .note>:last-child,.rst-content .seealso .last,.rst-content .seealso>:last-child,.rst-content .tip .last,.rst-content .tip>:last-child,.rst-content .warning .last,.rst-content .warning>:last-child{margin-bottom:0}.rst-content .admonition-title:before{margin-right:4px}.rst-content .admonition table{border-color:rgba(0,0,0,.1)}.rst-content .admonition table td,.rst-content .admonition table th{background:transparent!important;border-color:rgba(0,0,0,.1)!important}.rst-content .section ol.loweralpha,.rst-content .section ol.loweralpha>li,.rst-content .toctree-wrapper ol.loweralpha,.rst-content .toctree-wrapper ol.loweralpha>li,.rst-content section ol.loweralpha,.rst-content section ol.loweralpha>li{list-style:lower-alpha}.rst-content .section ol.upperalpha,.rst-content .section ol.upperalpha>li,.rst-content .toctree-wrapper ol.upperalpha,.rst-content .toctree-wrapper ol.upperalpha>li,.rst-content section ol.upperalpha,.rst-content section ol.upperalpha>li{list-style:upper-alpha}.rst-content .section ol li>*,.rst-content .section ul li>*,.rst-content .toctree-wrapper ol li>*,.rst-content .toctree-wrapper ul li>*,.rst-content section ol li>*,.rst-content section ul li>*{margin-top:12px;margin-bottom:12px}.rst-content .section ol li>:first-child,.rst-content .section ul li>:first-child,.rst-content .toctree-wrapper ol li>:first-child,.rst-content .toctree-wrapper ul li>:first-child,.rst-content section ol li>:first-child,.rst-content section ul li>:first-child{margin-top:0}.rst-content .section ol li>p,.rst-content .section ol li>p:last-child,.rst-content .section ul li>p,.rst-content .section ul li>p:last-child,.rst-content .toctree-wrapper ol li>p,.rst-content .toctree-wrapper ol li>p:last-child,.rst-content .toctree-wrapper ul li>p,.rst-content .toctree-wrapper ul li>p:last-child,.rst-content section ol li>p,.rst-content section ol li>p:last-child,.rst-content section ul li>p,.rst-content section ul li>p:last-child{margin-bottom:12px}.rst-content .section ol li>p:only-child,.rst-content .section ol li>p:only-child:last-child,.rst-content .section ul li>p:only-child,.rst-content .section ul li>p:only-child:last-child,.rst-content .toctree-wrapper ol li>p:only-child,.rst-content .toctree-wrapper ol li>p:only-child:last-child,.rst-content .toctree-wrapper ul li>p:only-child,.rst-content .toctree-wrapper ul li>p:only-child:last-child,.rst-content section ol li>p:only-child,.rst-content section ol li>p:only-child:last-child,.rst-content section ul li>p:only-child,.rst-content section ul li>p:only-child:last-child{margin-bottom:0}.rst-content .section ol li>ol,.rst-content .section ol li>ul,.rst-content .section ul li>ol,.rst-content .section ul li>ul,.rst-content .toctree-wrapper ol li>ol,.rst-content .toctree-wrapper ol li>ul,.rst-content .toctree-wrapper ul li>ol,.rst-content .toctree-wrapper ul li>ul,.rst-content section ol li>ol,.rst-content section ol li>ul,.rst-content section ul li>ol,.rst-content section ul li>ul{margin-bottom:12px}.rst-content .section ol.simple li>*,.rst-content .section ol.simple li ol,.rst-content .section ol.simple li ul,.rst-content .section ul.simple li>*,.rst-content .section ul.simple li ol,.rst-content .section ul.simple li ul,.rst-content .toctree-wrapper ol.simple li>*,.rst-content .toctree-wrapper ol.simple li ol,.rst-content .toctree-wrapper ol.simple li ul,.rst-content .toctree-wrapper ul.simple li>*,.rst-content .toctree-wrapper ul.simple li ol,.rst-content .toctree-wrapper ul.simple li ul,.rst-content section ol.simple li>*,.rst-content section ol.simple li ol,.rst-content section ol.simple li ul,.rst-content section ul.simple li>*,.rst-content section ul.simple li ol,.rst-content section ul.simple li ul{margin-top:0;margin-bottom:0}.rst-content .line-block{margin-left:0;margin-bottom:24px;line-height:24px}.rst-content .line-block .line-block{margin-left:24px;margin-bottom:0}.rst-content .topic-title{font-weight:700;margin-bottom:12px}.rst-content .toc-backref{color:#404040}.rst-content .align-right{float:right;margin:0 0 24px 24px}.rst-content .align-left{float:left;margin:0 24px 24px 0}.rst-content .align-center{margin:auto}.rst-content .align-center:not(table){display:block}.rst-content .code-block-caption .headerlink,.rst-content .eqno .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink,.rst-content dl dt .headerlink,.rst-content h1 .headerlink,.rst-content h2 .headerlink,.rst-content h3 .headerlink,.rst-content h4 .headerlink,.rst-content h5 .headerlink,.rst-content h6 .headerlink,.rst-content p.caption .headerlink,.rst-content p .headerlink,.rst-content table>caption .headerlink{opacity:0;font-size:14px;font-family:FontAwesome;margin-left:.5em}.rst-content .code-block-caption .headerlink:focus,.rst-content .code-block-caption:hover .headerlink,.rst-content .eqno .headerlink:focus,.rst-content .eqno:hover .headerlink,.rst-content .toctree-wrapper>p.caption .headerlink:focus,.rst-content .toctree-wrapper>p.caption:hover .headerlink,.rst-content dl dt .headerlink:focus,.rst-content dl dt:hover .headerlink,.rst-content h1 .headerlink:focus,.rst-content h1:hover .headerlink,.rst-content h2 .headerlink:focus,.rst-content h2:hover .headerlink,.rst-content h3 .headerlink:focus,.rst-content h3:hover .headerlink,.rst-content h4 .headerlink:focus,.rst-content h4:hover .headerlink,.rst-content h5 .headerlink:focus,.rst-content h5:hover .headerlink,.rst-content h6 .headerlink:focus,.rst-content h6:hover .headerlink,.rst-content p.caption .headerlink:focus,.rst-content p.caption:hover .headerlink,.rst-content p .headerlink:focus,.rst-content p:hover .headerlink,.rst-content table>caption .headerlink:focus,.rst-content table>caption:hover .headerlink{opacity:1}.rst-content p a{overflow-wrap:anywhere}.rst-content .wy-table td p,.rst-content .wy-table td ul,.rst-content .wy-table th p,.rst-content .wy-table th ul,.rst-content table.docutils td p,.rst-content table.docutils td ul,.rst-content table.docutils th p,.rst-content table.docutils th ul,.rst-content table.field-list td p,.rst-content table.field-list td ul,.rst-content table.field-list th p,.rst-content table.field-list th ul{font-size:inherit}.rst-content .btn:focus{outline:2px solid}.rst-content table>caption .headerlink:after{font-size:12px}.rst-content .centered{text-align:center}.rst-content .sidebar{float:right;width:40%;display:block;margin:0 0 24px 24px;padding:24px;background:#f3f6f6;border:1px solid #e1e4e5}.rst-content .sidebar dl,.rst-content .sidebar p,.rst-content .sidebar ul{font-size:90%}.rst-content .sidebar .last,.rst-content .sidebar>:last-child{margin-bottom:0}.rst-content .sidebar .sidebar-title{display:block;font-family:Roboto Slab,ff-tisa-web-pro,Georgia,Arial,sans-serif;font-weight:700;background:#e1e4e5;padding:6px 12px;margin:-24px -24px 24px;font-size:100%}.rst-content .highlighted{background:#f1c40f;box-shadow:0 0 0 2px #f1c40f;display:inline;font-weight:700}.rst-content .citation-reference,.rst-content .footnote-reference{vertical-align:baseline;position:relative;top:-.4em;line-height:0;font-size:90%}.rst-content .citation-reference>span.fn-bracket,.rst-content .footnote-reference>span.fn-bracket{display:none}.rst-content .hlist{width:100%}.rst-content dl dt span.classifier:before{content:" : "}.rst-content dl dt span.classifier-delimiter{display:none!important}html.writer-html4 .rst-content table.docutils.citation,html.writer-html4 .rst-content table.docutils.footnote{background:none;border:none}html.writer-html4 .rst-content table.docutils.citation td,html.writer-html4 .rst-content table.docutils.citation tr,html.writer-html4 .rst-content table.docutils.footnote td,html.writer-html4 .rst-content table.docutils.footnote tr{border:none;background-color:transparent!important;white-space:normal}html.writer-html4 .rst-content table.docutils.citation td.label,html.writer-html4 .rst-content table.docutils.footnote td.label{padding-left:0;padding-right:0;vertical-align:top}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{display:grid;grid-template-columns:auto minmax(80%,95%)}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{display:inline-grid;grid-template-columns:max-content auto}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{display:grid;grid-template-columns:auto auto minmax(.65rem,auto) minmax(40%,95%)}html.writer-html5 .rst-content aside.citation>span.label,html.writer-html5 .rst-content aside.footnote>span.label,html.writer-html5 .rst-content div.citation>span.label{grid-column-start:1;grid-column-end:2}html.writer-html5 .rst-content aside.citation>span.backrefs,html.writer-html5 .rst-content aside.footnote>span.backrefs,html.writer-html5 .rst-content div.citation>span.backrefs{grid-column-start:2;grid-column-end:3;grid-row-start:1;grid-row-end:3}html.writer-html5 .rst-content aside.citation>p,html.writer-html5 .rst-content aside.footnote>p,html.writer-html5 .rst-content div.citation>p{grid-column-start:4;grid-column-end:5}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.field-list,html.writer-html5 .rst-content dl.footnote{margin-bottom:24px}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dt{padding-left:1rem}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.field-list>dd,html.writer-html5 .rst-content dl.field-list>dt,html.writer-html5 .rst-content dl.footnote>dd,html.writer-html5 .rst-content dl.footnote>dt{margin-bottom:0}html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{font-size:.9rem}html.writer-html5 .rst-content dl.citation>dt,html.writer-html5 .rst-content dl.footnote>dt{margin:0 .5rem .5rem 0;line-height:1.2rem;word-break:break-all;font-weight:400}html.writer-html5 .rst-content dl.citation>dt>span.brackets:before,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:before{content:"["}html.writer-html5 .rst-content dl.citation>dt>span.brackets:after,html.writer-html5 .rst-content dl.footnote>dt>span.brackets:after{content:"]"}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a{word-break:keep-all}html.writer-html5 .rst-content dl.citation>dt>span.fn-backref>a:not(:first-child):before,html.writer-html5 .rst-content dl.footnote>dt>span.fn-backref>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content dl.citation>dd,html.writer-html5 .rst-content dl.footnote>dd{margin:0 0 .5rem;line-height:1.2rem}html.writer-html5 .rst-content dl.citation>dd p,html.writer-html5 .rst-content dl.footnote>dd p{font-size:.9rem}html.writer-html5 .rst-content aside.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content div.citation{padding-left:1rem;padding-right:1rem;font-size:.9rem;line-height:1.2rem}html.writer-html5 .rst-content aside.citation p,html.writer-html5 .rst-content aside.footnote p,html.writer-html5 .rst-content div.citation p{font-size:.9rem;line-height:1.2rem;margin-bottom:12px}html.writer-html5 .rst-content aside.citation span.backrefs,html.writer-html5 .rst-content aside.footnote span.backrefs,html.writer-html5 .rst-content div.citation span.backrefs{text-align:left;font-style:italic;margin-left:.65rem;word-break:break-word;word-spacing:-.1rem;max-width:5rem}html.writer-html5 .rst-content aside.citation span.backrefs>a,html.writer-html5 .rst-content aside.footnote span.backrefs>a,html.writer-html5 .rst-content div.citation span.backrefs>a{word-break:keep-all}html.writer-html5 .rst-content aside.citation span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content aside.footnote span.backrefs>a:not(:first-child):before,html.writer-html5 .rst-content div.citation span.backrefs>a:not(:first-child):before{content:" "}html.writer-html5 .rst-content aside.citation span.label,html.writer-html5 .rst-content aside.footnote span.label,html.writer-html5 .rst-content div.citation span.label{line-height:1.2rem}html.writer-html5 .rst-content aside.citation-list,html.writer-html5 .rst-content aside.footnote-list,html.writer-html5 .rst-content div.citation-list{margin-bottom:24px}html.writer-html5 .rst-content dl.option-list kbd{font-size:.9rem}.rst-content table.docutils.footnote,html.writer-html4 .rst-content table.docutils.citation,html.writer-html5 .rst-content aside.footnote,html.writer-html5 .rst-content aside.footnote-list aside.footnote,html.writer-html5 .rst-content div.citation-list>div.citation,html.writer-html5 .rst-content dl.citation,html.writer-html5 .rst-content dl.footnote{color:grey}.rst-content table.docutils.footnote code,.rst-content table.docutils.footnote tt,html.writer-html4 .rst-content table.docutils.citation code,html.writer-html4 .rst-content table.docutils.citation tt,html.writer-html5 .rst-content aside.footnote-list aside.footnote code,html.writer-html5 .rst-content aside.footnote-list aside.footnote tt,html.writer-html5 .rst-content aside.footnote code,html.writer-html5 .rst-content aside.footnote tt,html.writer-html5 .rst-content div.citation-list>div.citation code,html.writer-html5 .rst-content div.citation-list>div.citation tt,html.writer-html5 .rst-content dl.citation code,html.writer-html5 .rst-content dl.citation tt,html.writer-html5 .rst-content dl.footnote code,html.writer-html5 .rst-content dl.footnote tt{color:#555}.rst-content .wy-table-responsive.citation,.rst-content .wy-table-responsive.footnote{margin-bottom:0}.rst-content .wy-table-responsive.citation+:not(.citation),.rst-content .wy-table-responsive.footnote+:not(.footnote){margin-top:24px}.rst-content .wy-table-responsive.citation:last-child,.rst-content .wy-table-responsive.footnote:last-child{margin-bottom:24px}.rst-content table.docutils th{border-color:#e1e4e5}html.writer-html5 .rst-content table.docutils th{border:1px solid #e1e4e5}html.writer-html5 .rst-content table.docutils td>p,html.writer-html5 .rst-content table.docutils th>p{line-height:1rem;margin-bottom:0;font-size:.9rem}.rst-content table.docutils td .last,.rst-content table.docutils td .last>:last-child{margin-bottom:0}.rst-content table.field-list,.rst-content table.field-list td{border:none}.rst-content table.field-list td p{line-height:inherit}.rst-content table.field-list td>strong{display:inline-block}.rst-content table.field-list .field-name{padding-right:10px;text-align:left;white-space:nowrap}.rst-content table.field-list .field-body{text-align:left}.rst-content code,.rst-content tt{color:#000;font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;padding:2px 5px}.rst-content code big,.rst-content code em,.rst-content tt big,.rst-content tt em{font-size:100%!important;line-height:normal}.rst-content code.literal,.rst-content tt.literal{color:#e74c3c;white-space:normal}.rst-content code.xref,.rst-content tt.xref,a .rst-content code,a .rst-content tt{font-weight:700;color:#404040;overflow-wrap:normal}.rst-content kbd,.rst-content pre,.rst-content samp{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace}.rst-content a code,.rst-content a tt{color:#2980b9}.rst-content dl{margin-bottom:24px}.rst-content dl dt{font-weight:700;margin-bottom:12px}.rst-content dl ol,.rst-content dl p,.rst-content dl table,.rst-content dl ul{margin-bottom:12px}.rst-content dl dd{margin:0 0 12px 24px;line-height:24px}.rst-content dl dd>ol:last-child,.rst-content dl dd>p:last-child,.rst-content dl dd>table:last-child,.rst-content dl dd>ul:last-child{margin-bottom:0}html.writer-html4 .rst-content dl:not(.docutils),html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple){margin-bottom:24px}html.writer-html4 .rst-content dl:not(.docutils)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{display:table;margin:6px 0;font-size:90%;line-height:normal;background:#e7f2fa;color:#2980b9;border-top:3px solid #6ab0de;padding:6px;position:relative}html.writer-html4 .rst-content dl:not(.docutils)>dt:before,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:before{color:#6ab0de}html.writer-html4 .rst-content dl:not(.docutils)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt{margin-bottom:6px;border:none;border-left:3px solid #ccc;background:#f0f0f0;color:#555}html.writer-html4 .rst-content dl:not(.docutils) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) dl:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt .headerlink{color:#404040;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils)>dt:first-child,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple)>dt:first-child{margin-top:0}html.writer-html4 .rst-content dl:not(.docutils) code.descclassname,html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descclassname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{background-color:transparent;border:none;padding:0;font-size:100%!important}html.writer-html4 .rst-content dl:not(.docutils) code.descname,html.writer-html4 .rst-content dl:not(.docutils) tt.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) code.descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) tt.descname{font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .optional,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .optional{display:inline-block;padding:0 4px;color:#000;font-weight:700}html.writer-html4 .rst-content dl:not(.docutils) .property,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .property{display:inline-block;padding-right:8px;max-width:100%}html.writer-html4 .rst-content dl:not(.docutils) .k,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .k{font-style:italic}html.writer-html4 .rst-content dl:not(.docutils) .descclassname,html.writer-html4 .rst-content dl:not(.docutils) .descname,html.writer-html4 .rst-content dl:not(.docutils) .sig-name,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descclassname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .descname,html.writer-html5 .rst-content dl[class]:not(.option-list):not(.field-list):not(.footnote):not(.citation):not(.glossary):not(.simple) .sig-name{font-family:SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,Courier,monospace;color:#000}.rst-content .viewcode-back,.rst-content .viewcode-link{display:inline-block;color:#27ae60;font-size:80%;padding-left:24px}.rst-content .viewcode-back{display:block;float:right}.rst-content p.rubric{margin-bottom:12px;font-weight:700}.rst-content code.download,.rst-content tt.download{background:inherit;padding:inherit;font-weight:400;font-family:inherit;font-size:inherit;color:inherit;border:inherit;white-space:inherit}.rst-content code.download span:first-child,.rst-content tt.download span:first-child{-webkit-font-smoothing:subpixel-antialiased}.rst-content code.download span:first-child:before,.rst-content tt.download span:first-child:before{margin-right:4px}.rst-content .guilabel,.rst-content .menuselection{font-size:80%;font-weight:700;border-radius:4px;padding:2.4px 6px;margin:auto 2px}.rst-content .guilabel,.rst-content .menuselection{border:1px solid #7fbbe3;background:#e7f2fa}.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>.kbd,.rst-content :not(dl.option-list)>:not(dt):not(kbd):not(.kbd)>kbd{color:inherit;font-size:80%;background-color:#fff;border:1px solid #a6a6a6;border-radius:4px;box-shadow:0 2px grey;padding:2.4px 6px;margin:auto 0}.rst-content .versionmodified{font-style:italic}@media screen and (max-width:480px){.rst-content .sidebar{width:100%}}span[id*=MathJax-Span]{color:#404040}.math{text-align:center}@font-face{font-family:Lato;src:url(fonts/lato-normal.woff2?bd03a2cc277bbbc338d464e679fe9942) format("woff2"),url(fonts/lato-normal.woff?27bd77b9162d388cb8d4c4217c7c5e2a) format("woff");font-weight:400;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold.woff2?cccb897485813c7c256901dbca54ecf2) format("woff2"),url(fonts/lato-bold.woff?d878b6c29b10beca227e9eef4246111b) format("woff");font-weight:700;font-style:normal;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-bold-italic.woff2?0b6bb6725576b072c5d0b02ecdd1900d) format("woff2"),url(fonts/lato-bold-italic.woff?9c7e4e9eb485b4a121c760e61bc3707c) format("woff");font-weight:700;font-style:italic;font-display:block}@font-face{font-family:Lato;src:url(fonts/lato-normal-italic.woff2?4eb103b4d12be57cb1d040ed5e162e9d) format("woff2"),url(fonts/lato-normal-italic.woff?f28f2d6482446544ef1ea1ccc6dd5892) format("woff");font-weight:400;font-style:italic;font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:400;src:url(fonts/Roboto-Slab-Regular.woff2?7abf5b8d04d26a2cafea937019bca958) format("woff2"),url(fonts/Roboto-Slab-Regular.woff?c1be9284088d487c5e3ff0a10a92e58c) format("woff");font-display:block}@font-face{font-family:Roboto Slab;font-style:normal;font-weight:700;src:url(fonts/Roboto-Slab-Bold.woff2?9984f4a9bda09be08e83f2506954adbe) format("woff2"),url(fonts/Roboto-Slab-Bold.woff?bed5564a116b05148e3b3bea6fb1162a) format("woff");font-display:block} \ No newline at end of file diff --git a/_static/doctools.js b/_static/doctools.js new file mode 100644 index 0000000..4d67807 --- /dev/null +++ b/_static/doctools.js @@ -0,0 +1,156 @@ +/* + * doctools.js + * ~~~~~~~~~~~ + * + * Base JavaScript utilities for all Sphinx HTML documentation. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ +"use strict"; + +const BLACKLISTED_KEY_CONTROL_ELEMENTS = new Set([ + "TEXTAREA", + "INPUT", + "SELECT", + "BUTTON", +]); + +const _ready = (callback) => { + if (document.readyState !== "loading") { + callback(); + } else { + document.addEventListener("DOMContentLoaded", callback); + } +}; + +/** + * Small JavaScript module for the documentation. + */ +const Documentation = { + init: () => { + Documentation.initDomainIndexTable(); + Documentation.initOnKeyListeners(); + }, + + /** + * i18n support + */ + TRANSLATIONS: {}, + PLURAL_EXPR: (n) => (n === 1 ? 0 : 1), + LOCALE: "unknown", + + // gettext and ngettext don't access this so that the functions + // can safely bound to a different name (_ = Documentation.gettext) + gettext: (string) => { + const translated = Documentation.TRANSLATIONS[string]; + switch (typeof translated) { + case "undefined": + return string; // no translation + case "string": + return translated; // translation exists + default: + return translated[0]; // (singular, plural) translation tuple exists + } + }, + + ngettext: (singular, plural, n) => { + const translated = Documentation.TRANSLATIONS[singular]; + if (typeof translated !== "undefined") + return translated[Documentation.PLURAL_EXPR(n)]; + return n === 1 ? singular : plural; + }, + + addTranslations: (catalog) => { + Object.assign(Documentation.TRANSLATIONS, catalog.messages); + Documentation.PLURAL_EXPR = new Function( + "n", + `return (${catalog.plural_expr})` + ); + Documentation.LOCALE = catalog.locale; + }, + + /** + * helper function to focus on search bar + */ + focusSearchBar: () => { + document.querySelectorAll("input[name=q]")[0]?.focus(); + }, + + /** + * Initialise the domain index toggle buttons + */ + initDomainIndexTable: () => { + const toggler = (el) => { + const idNumber = el.id.substr(7); + const toggledRows = document.querySelectorAll(`tr.cg-${idNumber}`); + if (el.src.substr(-9) === "minus.png") { + el.src = `${el.src.substr(0, el.src.length - 9)}plus.png`; + toggledRows.forEach((el) => (el.style.display = "none")); + } else { + el.src = `${el.src.substr(0, el.src.length - 8)}minus.png`; + toggledRows.forEach((el) => (el.style.display = "")); + } + }; + + const togglerElements = document.querySelectorAll("img.toggler"); + togglerElements.forEach((el) => + el.addEventListener("click", (event) => toggler(event.currentTarget)) + ); + togglerElements.forEach((el) => (el.style.display = "")); + if (DOCUMENTATION_OPTIONS.COLLAPSE_INDEX) togglerElements.forEach(toggler); + }, + + initOnKeyListeners: () => { + // only install a listener if it is really needed + if ( + !DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS && + !DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS + ) + return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.altKey || event.ctrlKey || event.metaKey) return; + + if (!event.shiftKey) { + switch (event.key) { + case "ArrowLeft": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const prevLink = document.querySelector('link[rel="prev"]'); + if (prevLink && prevLink.href) { + window.location.href = prevLink.href; + event.preventDefault(); + } + break; + case "ArrowRight": + if (!DOCUMENTATION_OPTIONS.NAVIGATION_WITH_KEYS) break; + + const nextLink = document.querySelector('link[rel="next"]'); + if (nextLink && nextLink.href) { + window.location.href = nextLink.href; + event.preventDefault(); + } + break; + } + } + + // some keyboard layouts may need Shift to get / + switch (event.key) { + case "/": + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) break; + Documentation.focusSearchBar(); + event.preventDefault(); + } + }); + }, +}; + +// quick alias for translations +const _ = Documentation.gettext; + +_ready(Documentation.init); diff --git a/_static/documentation_options.js b/_static/documentation_options.js new file mode 100644 index 0000000..b7ab14e --- /dev/null +++ b/_static/documentation_options.js @@ -0,0 +1,13 @@ +const DOCUMENTATION_OPTIONS = { + VERSION: '0.9', + LANGUAGE: 'en', + COLLAPSE_INDEX: false, + BUILDER: 'html', + FILE_SUFFIX: '.html', + LINK_SUFFIX: '.html', + HAS_SOURCE: true, + SOURCELINK_SUFFIX: '.txt', + NAVIGATION_WITH_KEYS: false, + SHOW_SEARCH_SUMMARY: true, + ENABLE_SEARCH_SHORTCUTS: true, +}; \ No newline at end of file diff --git a/_static/file.png b/_static/file.png new file mode 100644 index 0000000..a858a41 Binary files /dev/null and b/_static/file.png differ diff --git a/_static/jquery.js b/_static/jquery.js new file mode 100644 index 0000000..c4c6022 --- /dev/null +++ b/_static/jquery.js @@ -0,0 +1,2 @@ +/*! jQuery v3.6.0 | (c) OpenJS Foundation and other contributors | jquery.org/license */ +!function(e,t){"use strict";"object"==typeof module&&"object"==typeof module.exports?module.exports=e.document?t(e,!0):function(e){if(!e.document)throw new Error("jQuery requires a window with a document");return t(e)}:t(e)}("undefined"!=typeof window?window:this,function(C,e){"use strict";var t=[],r=Object.getPrototypeOf,s=t.slice,g=t.flat?function(e){return t.flat.call(e)}:function(e){return t.concat.apply([],e)},u=t.push,i=t.indexOf,n={},o=n.toString,v=n.hasOwnProperty,a=v.toString,l=a.call(Object),y={},m=function(e){return"function"==typeof e&&"number"!=typeof e.nodeType&&"function"!=typeof e.item},x=function(e){return null!=e&&e===e.window},E=C.document,c={type:!0,src:!0,nonce:!0,noModule:!0};function b(e,t,n){var r,i,o=(n=n||E).createElement("script");if(o.text=e,t)for(r in c)(i=t[r]||t.getAttribute&&t.getAttribute(r))&&o.setAttribute(r,i);n.head.appendChild(o).parentNode.removeChild(o)}function w(e){return null==e?e+"":"object"==typeof e||"function"==typeof e?n[o.call(e)]||"object":typeof e}var f="3.6.0",S=function(e,t){return new S.fn.init(e,t)};function p(e){var t=!!e&&"length"in e&&e.length,n=w(e);return!m(e)&&!x(e)&&("array"===n||0===t||"number"==typeof t&&0+~]|"+M+")"+M+"*"),U=new RegExp(M+"|>"),X=new RegExp(F),V=new RegExp("^"+I+"$"),G={ID:new RegExp("^#("+I+")"),CLASS:new RegExp("^\\.("+I+")"),TAG:new RegExp("^("+I+"|[*])"),ATTR:new RegExp("^"+W),PSEUDO:new RegExp("^"+F),CHILD:new RegExp("^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\("+M+"*(even|odd|(([+-]|)(\\d*)n|)"+M+"*(?:([+-]|)"+M+"*(\\d+)|))"+M+"*\\)|)","i"),bool:new RegExp("^(?:"+R+")$","i"),needsContext:new RegExp("^"+M+"*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\("+M+"*((?:-\\d)?\\d*)"+M+"*\\)|)(?=[^-]|$)","i")},Y=/HTML$/i,Q=/^(?:input|select|textarea|button)$/i,J=/^h\d$/i,K=/^[^{]+\{\s*\[native \w/,Z=/^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,ee=/[+~]/,te=new RegExp("\\\\[\\da-fA-F]{1,6}"+M+"?|\\\\([^\\r\\n\\f])","g"),ne=function(e,t){var n="0x"+e.slice(1)-65536;return t||(n<0?String.fromCharCode(n+65536):String.fromCharCode(n>>10|55296,1023&n|56320))},re=/([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,ie=function(e,t){return t?"\0"===e?"\ufffd":e.slice(0,-1)+"\\"+e.charCodeAt(e.length-1).toString(16)+" ":"\\"+e},oe=function(){T()},ae=be(function(e){return!0===e.disabled&&"fieldset"===e.nodeName.toLowerCase()},{dir:"parentNode",next:"legend"});try{H.apply(t=O.call(p.childNodes),p.childNodes),t[p.childNodes.length].nodeType}catch(e){H={apply:t.length?function(e,t){L.apply(e,O.call(t))}:function(e,t){var n=e.length,r=0;while(e[n++]=t[r++]);e.length=n-1}}}function se(t,e,n,r){var i,o,a,s,u,l,c,f=e&&e.ownerDocument,p=e?e.nodeType:9;if(n=n||[],"string"!=typeof t||!t||1!==p&&9!==p&&11!==p)return n;if(!r&&(T(e),e=e||C,E)){if(11!==p&&(u=Z.exec(t)))if(i=u[1]){if(9===p){if(!(a=e.getElementById(i)))return n;if(a.id===i)return n.push(a),n}else if(f&&(a=f.getElementById(i))&&y(e,a)&&a.id===i)return n.push(a),n}else{if(u[2])return H.apply(n,e.getElementsByTagName(t)),n;if((i=u[3])&&d.getElementsByClassName&&e.getElementsByClassName)return H.apply(n,e.getElementsByClassName(i)),n}if(d.qsa&&!N[t+" "]&&(!v||!v.test(t))&&(1!==p||"object"!==e.nodeName.toLowerCase())){if(c=t,f=e,1===p&&(U.test(t)||z.test(t))){(f=ee.test(t)&&ye(e.parentNode)||e)===e&&d.scope||((s=e.getAttribute("id"))?s=s.replace(re,ie):e.setAttribute("id",s=S)),o=(l=h(t)).length;while(o--)l[o]=(s?"#"+s:":scope")+" "+xe(l[o]);c=l.join(",")}try{return H.apply(n,f.querySelectorAll(c)),n}catch(e){N(t,!0)}finally{s===S&&e.removeAttribute("id")}}}return g(t.replace($,"$1"),e,n,r)}function ue(){var r=[];return function e(t,n){return r.push(t+" ")>b.cacheLength&&delete e[r.shift()],e[t+" "]=n}}function le(e){return e[S]=!0,e}function ce(e){var t=C.createElement("fieldset");try{return!!e(t)}catch(e){return!1}finally{t.parentNode&&t.parentNode.removeChild(t),t=null}}function fe(e,t){var n=e.split("|"),r=n.length;while(r--)b.attrHandle[n[r]]=t}function pe(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&e.sourceIndex-t.sourceIndex;if(r)return r;if(n)while(n=n.nextSibling)if(n===t)return-1;return e?1:-1}function de(t){return function(e){return"input"===e.nodeName.toLowerCase()&&e.type===t}}function he(n){return function(e){var t=e.nodeName.toLowerCase();return("input"===t||"button"===t)&&e.type===n}}function ge(t){return function(e){return"form"in e?e.parentNode&&!1===e.disabled?"label"in e?"label"in e.parentNode?e.parentNode.disabled===t:e.disabled===t:e.isDisabled===t||e.isDisabled!==!t&&ae(e)===t:e.disabled===t:"label"in e&&e.disabled===t}}function ve(a){return le(function(o){return o=+o,le(function(e,t){var n,r=a([],e.length,o),i=r.length;while(i--)e[n=r[i]]&&(e[n]=!(t[n]=e[n]))})})}function ye(e){return e&&"undefined"!=typeof e.getElementsByTagName&&e}for(e in d=se.support={},i=se.isXML=function(e){var t=e&&e.namespaceURI,n=e&&(e.ownerDocument||e).documentElement;return!Y.test(t||n&&n.nodeName||"HTML")},T=se.setDocument=function(e){var t,n,r=e?e.ownerDocument||e:p;return r!=C&&9===r.nodeType&&r.documentElement&&(a=(C=r).documentElement,E=!i(C),p!=C&&(n=C.defaultView)&&n.top!==n&&(n.addEventListener?n.addEventListener("unload",oe,!1):n.attachEvent&&n.attachEvent("onunload",oe)),d.scope=ce(function(e){return a.appendChild(e).appendChild(C.createElement("div")),"undefined"!=typeof e.querySelectorAll&&!e.querySelectorAll(":scope fieldset div").length}),d.attributes=ce(function(e){return e.className="i",!e.getAttribute("className")}),d.getElementsByTagName=ce(function(e){return e.appendChild(C.createComment("")),!e.getElementsByTagName("*").length}),d.getElementsByClassName=K.test(C.getElementsByClassName),d.getById=ce(function(e){return a.appendChild(e).id=S,!C.getElementsByName||!C.getElementsByName(S).length}),d.getById?(b.filter.ID=function(e){var t=e.replace(te,ne);return function(e){return e.getAttribute("id")===t}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n=t.getElementById(e);return n?[n]:[]}}):(b.filter.ID=function(e){var n=e.replace(te,ne);return function(e){var t="undefined"!=typeof e.getAttributeNode&&e.getAttributeNode("id");return t&&t.value===n}},b.find.ID=function(e,t){if("undefined"!=typeof t.getElementById&&E){var n,r,i,o=t.getElementById(e);if(o){if((n=o.getAttributeNode("id"))&&n.value===e)return[o];i=t.getElementsByName(e),r=0;while(o=i[r++])if((n=o.getAttributeNode("id"))&&n.value===e)return[o]}return[]}}),b.find.TAG=d.getElementsByTagName?function(e,t){return"undefined"!=typeof t.getElementsByTagName?t.getElementsByTagName(e):d.qsa?t.querySelectorAll(e):void 0}:function(e,t){var n,r=[],i=0,o=t.getElementsByTagName(e);if("*"===e){while(n=o[i++])1===n.nodeType&&r.push(n);return r}return o},b.find.CLASS=d.getElementsByClassName&&function(e,t){if("undefined"!=typeof t.getElementsByClassName&&E)return t.getElementsByClassName(e)},s=[],v=[],(d.qsa=K.test(C.querySelectorAll))&&(ce(function(e){var t;a.appendChild(e).innerHTML="",e.querySelectorAll("[msallowcapture^='']").length&&v.push("[*^$]="+M+"*(?:''|\"\")"),e.querySelectorAll("[selected]").length||v.push("\\["+M+"*(?:value|"+R+")"),e.querySelectorAll("[id~="+S+"-]").length||v.push("~="),(t=C.createElement("input")).setAttribute("name",""),e.appendChild(t),e.querySelectorAll("[name='']").length||v.push("\\["+M+"*name"+M+"*="+M+"*(?:''|\"\")"),e.querySelectorAll(":checked").length||v.push(":checked"),e.querySelectorAll("a#"+S+"+*").length||v.push(".#.+[+~]"),e.querySelectorAll("\\\f"),v.push("[\\r\\n\\f]")}),ce(function(e){e.innerHTML="";var t=C.createElement("input");t.setAttribute("type","hidden"),e.appendChild(t).setAttribute("name","D"),e.querySelectorAll("[name=d]").length&&v.push("name"+M+"*[*^$|!~]?="),2!==e.querySelectorAll(":enabled").length&&v.push(":enabled",":disabled"),a.appendChild(e).disabled=!0,2!==e.querySelectorAll(":disabled").length&&v.push(":enabled",":disabled"),e.querySelectorAll("*,:x"),v.push(",.*:")})),(d.matchesSelector=K.test(c=a.matches||a.webkitMatchesSelector||a.mozMatchesSelector||a.oMatchesSelector||a.msMatchesSelector))&&ce(function(e){d.disconnectedMatch=c.call(e,"*"),c.call(e,"[s!='']:x"),s.push("!=",F)}),v=v.length&&new RegExp(v.join("|")),s=s.length&&new RegExp(s.join("|")),t=K.test(a.compareDocumentPosition),y=t||K.test(a.contains)?function(e,t){var n=9===e.nodeType?e.documentElement:e,r=t&&t.parentNode;return e===r||!(!r||1!==r.nodeType||!(n.contains?n.contains(r):e.compareDocumentPosition&&16&e.compareDocumentPosition(r)))}:function(e,t){if(t)while(t=t.parentNode)if(t===e)return!0;return!1},j=t?function(e,t){if(e===t)return l=!0,0;var n=!e.compareDocumentPosition-!t.compareDocumentPosition;return n||(1&(n=(e.ownerDocument||e)==(t.ownerDocument||t)?e.compareDocumentPosition(t):1)||!d.sortDetached&&t.compareDocumentPosition(e)===n?e==C||e.ownerDocument==p&&y(p,e)?-1:t==C||t.ownerDocument==p&&y(p,t)?1:u?P(u,e)-P(u,t):0:4&n?-1:1)}:function(e,t){if(e===t)return l=!0,0;var n,r=0,i=e.parentNode,o=t.parentNode,a=[e],s=[t];if(!i||!o)return e==C?-1:t==C?1:i?-1:o?1:u?P(u,e)-P(u,t):0;if(i===o)return pe(e,t);n=e;while(n=n.parentNode)a.unshift(n);n=t;while(n=n.parentNode)s.unshift(n);while(a[r]===s[r])r++;return r?pe(a[r],s[r]):a[r]==p?-1:s[r]==p?1:0}),C},se.matches=function(e,t){return se(e,null,null,t)},se.matchesSelector=function(e,t){if(T(e),d.matchesSelector&&E&&!N[t+" "]&&(!s||!s.test(t))&&(!v||!v.test(t)))try{var n=c.call(e,t);if(n||d.disconnectedMatch||e.document&&11!==e.document.nodeType)return n}catch(e){N(t,!0)}return 0":{dir:"parentNode",first:!0}," ":{dir:"parentNode"},"+":{dir:"previousSibling",first:!0},"~":{dir:"previousSibling"}},preFilter:{ATTR:function(e){return e[1]=e[1].replace(te,ne),e[3]=(e[3]||e[4]||e[5]||"").replace(te,ne),"~="===e[2]&&(e[3]=" "+e[3]+" "),e.slice(0,4)},CHILD:function(e){return e[1]=e[1].toLowerCase(),"nth"===e[1].slice(0,3)?(e[3]||se.error(e[0]),e[4]=+(e[4]?e[5]+(e[6]||1):2*("even"===e[3]||"odd"===e[3])),e[5]=+(e[7]+e[8]||"odd"===e[3])):e[3]&&se.error(e[0]),e},PSEUDO:function(e){var t,n=!e[6]&&e[2];return G.CHILD.test(e[0])?null:(e[3]?e[2]=e[4]||e[5]||"":n&&X.test(n)&&(t=h(n,!0))&&(t=n.indexOf(")",n.length-t)-n.length)&&(e[0]=e[0].slice(0,t),e[2]=n.slice(0,t)),e.slice(0,3))}},filter:{TAG:function(e){var t=e.replace(te,ne).toLowerCase();return"*"===e?function(){return!0}:function(e){return e.nodeName&&e.nodeName.toLowerCase()===t}},CLASS:function(e){var t=m[e+" "];return t||(t=new RegExp("(^|"+M+")"+e+"("+M+"|$)"))&&m(e,function(e){return t.test("string"==typeof e.className&&e.className||"undefined"!=typeof e.getAttribute&&e.getAttribute("class")||"")})},ATTR:function(n,r,i){return function(e){var t=se.attr(e,n);return null==t?"!="===r:!r||(t+="","="===r?t===i:"!="===r?t!==i:"^="===r?i&&0===t.indexOf(i):"*="===r?i&&-1:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i;function j(e,n,r){return m(n)?S.grep(e,function(e,t){return!!n.call(e,t,e)!==r}):n.nodeType?S.grep(e,function(e){return e===n!==r}):"string"!=typeof n?S.grep(e,function(e){return-1)[^>]*|#([\w-]+))$/;(S.fn.init=function(e,t,n){var r,i;if(!e)return this;if(n=n||D,"string"==typeof e){if(!(r="<"===e[0]&&">"===e[e.length-1]&&3<=e.length?[null,e,null]:q.exec(e))||!r[1]&&t)return!t||t.jquery?(t||n).find(e):this.constructor(t).find(e);if(r[1]){if(t=t instanceof S?t[0]:t,S.merge(this,S.parseHTML(r[1],t&&t.nodeType?t.ownerDocument||t:E,!0)),N.test(r[1])&&S.isPlainObject(t))for(r in t)m(this[r])?this[r](t[r]):this.attr(r,t[r]);return this}return(i=E.getElementById(r[2]))&&(this[0]=i,this.length=1),this}return e.nodeType?(this[0]=e,this.length=1,this):m(e)?void 0!==n.ready?n.ready(e):e(S):S.makeArray(e,this)}).prototype=S.fn,D=S(E);var L=/^(?:parents|prev(?:Until|All))/,H={children:!0,contents:!0,next:!0,prev:!0};function O(e,t){while((e=e[t])&&1!==e.nodeType);return e}S.fn.extend({has:function(e){var t=S(e,this),n=t.length;return this.filter(function(){for(var e=0;e\x20\t\r\n\f]*)/i,he=/^$|^module$|\/(?:java|ecma)script/i;ce=E.createDocumentFragment().appendChild(E.createElement("div")),(fe=E.createElement("input")).setAttribute("type","radio"),fe.setAttribute("checked","checked"),fe.setAttribute("name","t"),ce.appendChild(fe),y.checkClone=ce.cloneNode(!0).cloneNode(!0).lastChild.checked,ce.innerHTML="",y.noCloneChecked=!!ce.cloneNode(!0).lastChild.defaultValue,ce.innerHTML="",y.option=!!ce.lastChild;var ge={thead:[1,"","
"],col:[2,"","
"],tr:[2,"","
"],td:[3,"","
"],_default:[0,"",""]};function ve(e,t){var n;return n="undefined"!=typeof e.getElementsByTagName?e.getElementsByTagName(t||"*"):"undefined"!=typeof e.querySelectorAll?e.querySelectorAll(t||"*"):[],void 0===t||t&&A(e,t)?S.merge([e],n):n}function ye(e,t){for(var n=0,r=e.length;n",""]);var me=/<|&#?\w+;/;function xe(e,t,n,r,i){for(var o,a,s,u,l,c,f=t.createDocumentFragment(),p=[],d=0,h=e.length;d\s*$/g;function je(e,t){return A(e,"table")&&A(11!==t.nodeType?t:t.firstChild,"tr")&&S(e).children("tbody")[0]||e}function De(e){return e.type=(null!==e.getAttribute("type"))+"/"+e.type,e}function qe(e){return"true/"===(e.type||"").slice(0,5)?e.type=e.type.slice(5):e.removeAttribute("type"),e}function Le(e,t){var n,r,i,o,a,s;if(1===t.nodeType){if(Y.hasData(e)&&(s=Y.get(e).events))for(i in Y.remove(t,"handle events"),s)for(n=0,r=s[i].length;n").attr(n.scriptAttrs||{}).prop({charset:n.scriptCharset,src:n.url}).on("load error",i=function(e){r.remove(),i=null,e&&t("error"===e.type?404:200,e.type)}),E.head.appendChild(r[0])},abort:function(){i&&i()}}});var _t,zt=[],Ut=/(=)\?(?=&|$)|\?\?/;S.ajaxSetup({jsonp:"callback",jsonpCallback:function(){var e=zt.pop()||S.expando+"_"+wt.guid++;return this[e]=!0,e}}),S.ajaxPrefilter("json jsonp",function(e,t,n){var r,i,o,a=!1!==e.jsonp&&(Ut.test(e.url)?"url":"string"==typeof e.data&&0===(e.contentType||"").indexOf("application/x-www-form-urlencoded")&&Ut.test(e.data)&&"data");if(a||"jsonp"===e.dataTypes[0])return r=e.jsonpCallback=m(e.jsonpCallback)?e.jsonpCallback():e.jsonpCallback,a?e[a]=e[a].replace(Ut,"$1"+r):!1!==e.jsonp&&(e.url+=(Tt.test(e.url)?"&":"?")+e.jsonp+"="+r),e.converters["script json"]=function(){return o||S.error(r+" was not called"),o[0]},e.dataTypes[0]="json",i=C[r],C[r]=function(){o=arguments},n.always(function(){void 0===i?S(C).removeProp(r):C[r]=i,e[r]&&(e.jsonpCallback=t.jsonpCallback,zt.push(r)),o&&m(i)&&i(o[0]),o=i=void 0}),"script"}),y.createHTMLDocument=((_t=E.implementation.createHTMLDocument("").body).innerHTML="
",2===_t.childNodes.length),S.parseHTML=function(e,t,n){return"string"!=typeof e?[]:("boolean"==typeof t&&(n=t,t=!1),t||(y.createHTMLDocument?((r=(t=E.implementation.createHTMLDocument("")).createElement("base")).href=E.location.href,t.head.appendChild(r)):t=E),o=!n&&[],(i=N.exec(e))?[t.createElement(i[1])]:(i=xe([e],t,o),o&&o.length&&S(o).remove(),S.merge([],i.childNodes)));var r,i,o},S.fn.load=function(e,t,n){var r,i,o,a=this,s=e.indexOf(" ");return-1").append(S.parseHTML(e)).find(r):e)}).always(n&&function(e,t){a.each(function(){n.apply(this,o||[e.responseText,t,e])})}),this},S.expr.pseudos.animated=function(t){return S.grep(S.timers,function(e){return t===e.elem}).length},S.offset={setOffset:function(e,t,n){var r,i,o,a,s,u,l=S.css(e,"position"),c=S(e),f={};"static"===l&&(e.style.position="relative"),s=c.offset(),o=S.css(e,"top"),u=S.css(e,"left"),("absolute"===l||"fixed"===l)&&-1<(o+u).indexOf("auto")?(a=(r=c.position()).top,i=r.left):(a=parseFloat(o)||0,i=parseFloat(u)||0),m(t)&&(t=t.call(e,n,S.extend({},s))),null!=t.top&&(f.top=t.top-s.top+a),null!=t.left&&(f.left=t.left-s.left+i),"using"in t?t.using.call(e,f):c.css(f)}},S.fn.extend({offset:function(t){if(arguments.length)return void 0===t?this:this.each(function(e){S.offset.setOffset(this,t,e)});var e,n,r=this[0];return r?r.getClientRects().length?(e=r.getBoundingClientRect(),n=r.ownerDocument.defaultView,{top:e.top+n.pageYOffset,left:e.left+n.pageXOffset}):{top:0,left:0}:void 0},position:function(){if(this[0]){var e,t,n,r=this[0],i={top:0,left:0};if("fixed"===S.css(r,"position"))t=r.getBoundingClientRect();else{t=this.offset(),n=r.ownerDocument,e=r.offsetParent||n.documentElement;while(e&&(e===n.body||e===n.documentElement)&&"static"===S.css(e,"position"))e=e.parentNode;e&&e!==r&&1===e.nodeType&&((i=S(e).offset()).top+=S.css(e,"borderTopWidth",!0),i.left+=S.css(e,"borderLeftWidth",!0))}return{top:t.top-i.top-S.css(r,"marginTop",!0),left:t.left-i.left-S.css(r,"marginLeft",!0)}}},offsetParent:function(){return this.map(function(){var e=this.offsetParent;while(e&&"static"===S.css(e,"position"))e=e.offsetParent;return e||re})}}),S.each({scrollLeft:"pageXOffset",scrollTop:"pageYOffset"},function(t,i){var o="pageYOffset"===i;S.fn[t]=function(e){return $(this,function(e,t,n){var r;if(x(e)?r=e:9===e.nodeType&&(r=e.defaultView),void 0===n)return r?r[i]:e[t];r?r.scrollTo(o?r.pageXOffset:n,o?n:r.pageYOffset):e[t]=n},t,e,arguments.length)}}),S.each(["top","left"],function(e,n){S.cssHooks[n]=Fe(y.pixelPosition,function(e,t){if(t)return t=We(e,n),Pe.test(t)?S(e).position()[n]+"px":t})}),S.each({Height:"height",Width:"width"},function(a,s){S.each({padding:"inner"+a,content:s,"":"outer"+a},function(r,o){S.fn[o]=function(e,t){var n=arguments.length&&(r||"boolean"!=typeof e),i=r||(!0===e||!0===t?"margin":"border");return $(this,function(e,t,n){var r;return x(e)?0===o.indexOf("outer")?e["inner"+a]:e.document.documentElement["client"+a]:9===e.nodeType?(r=e.documentElement,Math.max(e.body["scroll"+a],r["scroll"+a],e.body["offset"+a],r["offset"+a],r["client"+a])):void 0===n?S.css(e,t,i):S.style(e,t,n,i)},s,n?e:void 0,n)}})}),S.each(["ajaxStart","ajaxStop","ajaxComplete","ajaxError","ajaxSuccess","ajaxSend"],function(e,t){S.fn[t]=function(e){return this.on(t,e)}}),S.fn.extend({bind:function(e,t,n){return this.on(e,null,t,n)},unbind:function(e,t){return this.off(e,null,t)},delegate:function(e,t,n,r){return this.on(t,e,n,r)},undelegate:function(e,t,n){return 1===arguments.length?this.off(e,"**"):this.off(t,e||"**",n)},hover:function(e,t){return this.mouseenter(e).mouseleave(t||e)}}),S.each("blur focus focusin focusout resize scroll click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup contextmenu".split(" "),function(e,n){S.fn[n]=function(e,t){return 0",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=y.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=y.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),y.elements=c+" "+a,j(b)}function f(a){var b=x[a[v]];return b||(b={},w++,a[v]=w,x[w]=b),b}function g(a,c,d){if(c||(c=b),q)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():u.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||t.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),q)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return y.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(y,b.frag)}function j(a){a||(a=b);var d=f(a);return!y.shivCSS||p||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),q||i(a,d),a}function k(a){for(var b,c=a.getElementsByTagName("*"),e=c.length,f=RegExp("^(?:"+d().join("|")+")$","i"),g=[];e--;)b=c[e],f.test(b.nodeName)&&g.push(b.applyElement(l(b)));return g}function l(a){for(var b,c=a.attributes,d=c.length,e=a.ownerDocument.createElement(A+":"+a.nodeName);d--;)b=c[d],b.specified&&e.setAttribute(b.nodeName,b.nodeValue);return e.style.cssText=a.style.cssText,e}function m(a){for(var b,c=a.split("{"),e=c.length,f=RegExp("(^|[\\s,>+~])("+d().join("|")+")(?=[[\\s,>+~#.:]|$)","gi"),g="$1"+A+"\\:$2";e--;)b=c[e]=c[e].split("}"),b[b.length-1]=b[b.length-1].replace(f,g),c[e]=b.join("}");return c.join("{")}function n(a){for(var b=a.length;b--;)a[b].removeNode()}function o(a){function b(){clearTimeout(g._removeSheetTimer),d&&d.removeNode(!0),d=null}var d,e,g=f(a),h=a.namespaces,i=a.parentWindow;return!B||a.printShived?a:("undefined"==typeof h[A]&&h.add(A),i.attachEvent("onbeforeprint",function(){b();for(var f,g,h,i=a.styleSheets,j=[],l=i.length,n=Array(l);l--;)n[l]=i[l];for(;h=n.pop();)if(!h.disabled&&z.test(h.media)){try{f=h.imports,g=f.length}catch(o){g=0}for(l=0;g>l;l++)n.push(f[l]);try{j.push(h.cssText)}catch(o){}}j=m(j.reverse().join("")),e=k(a),d=c(a,j)}),i.attachEvent("onafterprint",function(){n(e),clearTimeout(g._removeSheetTimer),g._removeSheetTimer=setTimeout(b,500)}),a.printShived=!0,a)}var p,q,r="3.7.3",s=a.html5||{},t=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,u=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,v="_html5shiv",w=0,x={};!function(){try{var a=b.createElement("a");a.innerHTML="",p="hidden"in a,q=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){p=!0,q=!0}}();var y={elements:s.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:r,shivCSS:s.shivCSS!==!1,supportsUnknownElements:q,shivMethods:s.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=y,j(b);var z=/^$|\b(?:all|print)\b/,A="html5shiv",B=!q&&function(){var c=b.documentElement;return!("undefined"==typeof b.namespaces||"undefined"==typeof b.parentWindow||"undefined"==typeof c.applyElement||"undefined"==typeof c.removeNode||"undefined"==typeof a.attachEvent)}();y.type+=" print",y.shivPrint=o,o(b),"object"==typeof module&&module.exports&&(module.exports=y)}("undefined"!=typeof window?window:this,document); \ No newline at end of file diff --git a/_static/js/html5shiv.min.js b/_static/js/html5shiv.min.js new file mode 100644 index 0000000..cd1c674 --- /dev/null +++ b/_static/js/html5shiv.min.js @@ -0,0 +1,4 @@ +/** +* @preserve HTML5 Shiv 3.7.3 | @afarkas @jdalton @jon_neal @rem | MIT/GPL2 Licensed +*/ +!function(a,b){function c(a,b){var c=a.createElement("p"),d=a.getElementsByTagName("head")[0]||a.documentElement;return c.innerHTML="x",d.insertBefore(c.lastChild,d.firstChild)}function d(){var a=t.elements;return"string"==typeof a?a.split(" "):a}function e(a,b){var c=t.elements;"string"!=typeof c&&(c=c.join(" ")),"string"!=typeof a&&(a=a.join(" ")),t.elements=c+" "+a,j(b)}function f(a){var b=s[a[q]];return b||(b={},r++,a[q]=r,s[r]=b),b}function g(a,c,d){if(c||(c=b),l)return c.createElement(a);d||(d=f(c));var e;return e=d.cache[a]?d.cache[a].cloneNode():p.test(a)?(d.cache[a]=d.createElem(a)).cloneNode():d.createElem(a),!e.canHaveChildren||o.test(a)||e.tagUrn?e:d.frag.appendChild(e)}function h(a,c){if(a||(a=b),l)return a.createDocumentFragment();c=c||f(a);for(var e=c.frag.cloneNode(),g=0,h=d(),i=h.length;i>g;g++)e.createElement(h[g]);return e}function i(a,b){b.cache||(b.cache={},b.createElem=a.createElement,b.createFrag=a.createDocumentFragment,b.frag=b.createFrag()),a.createElement=function(c){return t.shivMethods?g(c,a,b):b.createElem(c)},a.createDocumentFragment=Function("h,f","return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&("+d().join().replace(/[\w\-:]+/g,function(a){return b.createElem(a),b.frag.createElement(a),'c("'+a+'")'})+");return n}")(t,b.frag)}function j(a){a||(a=b);var d=f(a);return!t.shivCSS||k||d.hasCSS||(d.hasCSS=!!c(a,"article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")),l||i(a,d),a}var k,l,m="3.7.3-pre",n=a.html5||{},o=/^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i,p=/^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i,q="_html5shiv",r=0,s={};!function(){try{var a=b.createElement("a");a.innerHTML="",k="hidden"in a,l=1==a.childNodes.length||function(){b.createElement("a");var a=b.createDocumentFragment();return"undefined"==typeof a.cloneNode||"undefined"==typeof a.createDocumentFragment||"undefined"==typeof a.createElement}()}catch(c){k=!0,l=!0}}();var t={elements:n.elements||"abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video",version:m,shivCSS:n.shivCSS!==!1,supportsUnknownElements:l,shivMethods:n.shivMethods!==!1,type:"default",shivDocument:j,createElement:g,createDocumentFragment:h,addElements:e};a.html5=t,j(b),"object"==typeof module&&module.exports&&(module.exports=t)}("undefined"!=typeof window?window:this,document); \ No newline at end of file diff --git a/_static/js/theme.js b/_static/js/theme.js new file mode 100644 index 0000000..1fddb6e --- /dev/null +++ b/_static/js/theme.js @@ -0,0 +1 @@ +!function(n){var e={};function t(i){if(e[i])return e[i].exports;var o=e[i]={i:i,l:!1,exports:{}};return n[i].call(o.exports,o,o.exports,t),o.l=!0,o.exports}t.m=n,t.c=e,t.d=function(n,e,i){t.o(n,e)||Object.defineProperty(n,e,{enumerable:!0,get:i})},t.r=function(n){"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(n,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(n,"__esModule",{value:!0})},t.t=function(n,e){if(1&e&&(n=t(n)),8&e)return n;if(4&e&&"object"==typeof n&&n&&n.__esModule)return n;var i=Object.create(null);if(t.r(i),Object.defineProperty(i,"default",{enumerable:!0,value:n}),2&e&&"string"!=typeof n)for(var o in n)t.d(i,o,function(e){return n[e]}.bind(null,o));return i},t.n=function(n){var e=n&&n.__esModule?function(){return n.default}:function(){return n};return t.d(e,"a",e),e},t.o=function(n,e){return Object.prototype.hasOwnProperty.call(n,e)},t.p="",t(t.s=0)}([function(n,e,t){t(1),n.exports=t(3)},function(n,e,t){(function(){var e="undefined"!=typeof window?window.jQuery:t(2);n.exports.ThemeNav={navBar:null,win:null,winScroll:!1,winResize:!1,linkScroll:!1,winPosition:0,winHeight:null,docHeight:null,isRunning:!1,enable:function(n){var t=this;void 0===n&&(n=!0),t.isRunning||(t.isRunning=!0,e((function(e){t.init(e),t.reset(),t.win.on("hashchange",t.reset),n&&t.win.on("scroll",(function(){t.linkScroll||t.winScroll||(t.winScroll=!0,requestAnimationFrame((function(){t.onScroll()})))})),t.win.on("resize",(function(){t.winResize||(t.winResize=!0,requestAnimationFrame((function(){t.onResize()})))})),t.onResize()})))},enableSticky:function(){this.enable(!0)},init:function(n){n(document);var e=this;this.navBar=n("div.wy-side-scroll:first"),this.win=n(window),n(document).on("click","[data-toggle='wy-nav-top']",(function(){n("[data-toggle='wy-nav-shift']").toggleClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift")})).on("click",".wy-menu-vertical .current ul li a",(function(){var t=n(this);n("[data-toggle='wy-nav-shift']").removeClass("shift"),n("[data-toggle='rst-versions']").toggleClass("shift"),e.toggleCurrent(t),e.hashChange()})).on("click","[data-toggle='rst-current-version']",(function(){n("[data-toggle='rst-versions']").toggleClass("shift-up")})),n("table.docutils:not(.field-list,.footnote,.citation)").wrap("
"),n("table.docutils.footnote").wrap("
"),n("table.docutils.citation").wrap("
"),n(".wy-menu-vertical ul").not(".simple").siblings("a").each((function(){var t=n(this);expand=n(''),expand.on("click",(function(n){return e.toggleCurrent(t),n.stopPropagation(),!1})),t.prepend(expand)}))},reset:function(){var n=encodeURI(window.location.hash)||"#";try{var e=$(".wy-menu-vertical"),t=e.find('[href="'+n+'"]');if(0===t.length){var i=$('.document [id="'+n.substring(1)+'"]').closest("div.section");0===(t=e.find('[href="#'+i.attr("id")+'"]')).length&&(t=e.find('[href="#"]'))}if(t.length>0){$(".wy-menu-vertical .current").removeClass("current").attr("aria-expanded","false"),t.addClass("current").attr("aria-expanded","true"),t.closest("li.toctree-l1").parent().addClass("current").attr("aria-expanded","true");for(let n=1;n<=10;n++)t.closest("li.toctree-l"+n).addClass("current").attr("aria-expanded","true");t[0].scrollIntoView()}}catch(n){console.log("Error expanding nav for anchor",n)}},onScroll:function(){this.winScroll=!1;var n=this.win.scrollTop(),e=n+this.winHeight,t=this.navBar.scrollTop()+(n-this.winPosition);n<0||e>this.docHeight||(this.navBar.scrollTop(t),this.winPosition=n)},onResize:function(){this.winResize=!1,this.winHeight=this.win.height(),this.docHeight=$(document).height()},hashChange:function(){this.linkScroll=!0,this.win.one("hashchange",(function(){this.linkScroll=!1}))},toggleCurrent:function(n){var e=n.closest("li");e.siblings("li.current").removeClass("current").attr("aria-expanded","false"),e.siblings().find("li.current").removeClass("current").attr("aria-expanded","false");var t=e.find("> ul li");t.length&&(t.removeClass("current").attr("aria-expanded","false"),e.toggleClass("current").attr("aria-expanded",(function(n,e){return"true"==e?"false":"true"})))}},"undefined"!=typeof window&&(window.SphinxRtdTheme={Navigation:n.exports.ThemeNav,StickyNav:n.exports.ThemeNav}),function(){for(var n=0,e=["ms","moz","webkit","o"],t=0;t0 + var meq1 = "^(" + C + ")?" + V + C + "(" + V + ")?$"; // [C]VC[V] is m=1 + var mgr1 = "^(" + C + ")?" + V + C + V + C; // [C]VCVC... is m>1 + var s_v = "^(" + C + ")?" + v; // vowel in stem + + this.stemWord = function (w) { + var stem; + var suffix; + var firstch; + var origword = w; + + if (w.length < 3) + return w; + + var re; + var re2; + var re3; + var re4; + + firstch = w.substr(0,1); + if (firstch == "y") + w = firstch.toUpperCase() + w.substr(1); + + // Step 1a + re = /^(.+?)(ss|i)es$/; + re2 = /^(.+?)([^s])s$/; + + if (re.test(w)) + w = w.replace(re,"$1$2"); + else if (re2.test(w)) + w = w.replace(re2,"$1$2"); + + // Step 1b + re = /^(.+?)eed$/; + re2 = /^(.+?)(ed|ing)$/; + if (re.test(w)) { + var fp = re.exec(w); + re = new RegExp(mgr0); + if (re.test(fp[1])) { + re = /.$/; + w = w.replace(re,""); + } + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1]; + re2 = new RegExp(s_v); + if (re2.test(stem)) { + w = stem; + re2 = /(at|bl|iz)$/; + re3 = new RegExp("([^aeiouylsz])\\1$"); + re4 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re2.test(w)) + w = w + "e"; + else if (re3.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + else if (re4.test(w)) + w = w + "e"; + } + } + + // Step 1c + re = /^(.+?)y$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(s_v); + if (re.test(stem)) + w = stem + "i"; + } + + // Step 2 + re = /^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step2list[suffix]; + } + + // Step 3 + re = /^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + suffix = fp[2]; + re = new RegExp(mgr0); + if (re.test(stem)) + w = stem + step3list[suffix]; + } + + // Step 4 + re = /^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/; + re2 = /^(.+?)(s|t)(ion)$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + if (re.test(stem)) + w = stem; + } + else if (re2.test(w)) { + var fp = re2.exec(w); + stem = fp[1] + fp[2]; + re2 = new RegExp(mgr1); + if (re2.test(stem)) + w = stem; + } + + // Step 5 + re = /^(.+?)e$/; + if (re.test(w)) { + var fp = re.exec(w); + stem = fp[1]; + re = new RegExp(mgr1); + re2 = new RegExp(meq1); + re3 = new RegExp("^" + C + v + "[^aeiouwxy]$"); + if (re.test(stem) || (re2.test(stem) && !(re3.test(stem)))) + w = stem; + } + re = /ll$/; + re2 = new RegExp(mgr1); + if (re.test(w) && re2.test(w)) { + re = /.$/; + w = w.replace(re,""); + } + + // and turn initial Y back to y + if (firstch == "y") + w = firstch.toLowerCase() + w.substr(1); + return w; + } +} + diff --git a/_static/minus.png b/_static/minus.png new file mode 100644 index 0000000..d96755f Binary files /dev/null and b/_static/minus.png differ diff --git a/_static/nbsphinx-broken-thumbnail.svg b/_static/nbsphinx-broken-thumbnail.svg new file mode 100644 index 0000000..4919ca8 --- /dev/null +++ b/_static/nbsphinx-broken-thumbnail.svg @@ -0,0 +1,9 @@ + + + + diff --git a/_static/nbsphinx-code-cells.css b/_static/nbsphinx-code-cells.css new file mode 100644 index 0000000..a3fb27c --- /dev/null +++ b/_static/nbsphinx-code-cells.css @@ -0,0 +1,259 @@ +/* remove conflicting styling from Sphinx themes */ +div.nbinput.container div.prompt *, +div.nboutput.container div.prompt *, +div.nbinput.container div.input_area pre, +div.nboutput.container div.output_area pre, +div.nbinput.container div.input_area .highlight, +div.nboutput.container div.output_area .highlight { + border: none; + padding: 0; + margin: 0; + box-shadow: none; +} + +div.nbinput.container > div[class*=highlight], +div.nboutput.container > div[class*=highlight] { + margin: 0; +} + +div.nbinput.container div.prompt *, +div.nboutput.container div.prompt * { + background: none; +} + +div.nboutput.container div.output_area .highlight, +div.nboutput.container div.output_area pre { + background: unset; +} + +div.nboutput.container div.output_area div.highlight { + color: unset; /* override Pygments text color */ +} + +/* avoid gaps between output lines */ +div.nboutput.container div[class*=highlight] pre { + line-height: normal; +} + +/* input/output containers */ +div.nbinput.container, +div.nboutput.container { + display: -webkit-flex; + display: flex; + align-items: flex-start; + margin: 0; + width: 100%; +} +@media (max-width: 540px) { + div.nbinput.container, + div.nboutput.container { + flex-direction: column; + } +} + +/* input container */ +div.nbinput.container { + padding-top: 5px; +} + +/* last container */ +div.nblast.container { + padding-bottom: 5px; +} + +/* input prompt */ +div.nbinput.container div.prompt pre, +/* for sphinx_immaterial theme: */ +div.nbinput.container div.prompt pre > code { + color: #307FC1; +} + +/* output prompt */ +div.nboutput.container div.prompt pre, +/* for sphinx_immaterial theme: */ +div.nboutput.container div.prompt pre > code { + color: #BF5B3D; +} + +/* all prompts */ +div.nbinput.container div.prompt, +div.nboutput.container div.prompt { + width: 4.5ex; + padding-top: 5px; + position: relative; + user-select: none; +} + +div.nbinput.container div.prompt > div, +div.nboutput.container div.prompt > div { + position: absolute; + right: 0; + margin-right: 0.3ex; +} + +@media (max-width: 540px) { + div.nbinput.container div.prompt, + div.nboutput.container div.prompt { + width: unset; + text-align: left; + padding: 0.4em; + } + div.nboutput.container div.prompt.empty { + padding: 0; + } + + div.nbinput.container div.prompt > div, + div.nboutput.container div.prompt > div { + position: unset; + } +} + +/* disable scrollbars and line breaks on prompts */ +div.nbinput.container div.prompt pre, +div.nboutput.container div.prompt pre { + overflow: hidden; + white-space: pre; +} + +/* input/output area */ +div.nbinput.container div.input_area, +div.nboutput.container div.output_area { + -webkit-flex: 1; + flex: 1; + overflow: auto; +} +@media (max-width: 540px) { + div.nbinput.container div.input_area, + div.nboutput.container div.output_area { + width: 100%; + } +} + +/* input area */ +div.nbinput.container div.input_area { + border: 1px solid #e0e0e0; + border-radius: 2px; + /*background: #f5f5f5;*/ +} + +/* override MathJax center alignment in output cells */ +div.nboutput.container div[class*=MathJax] { + text-align: left !important; +} + +/* override sphinx.ext.imgmath center alignment in output cells */ +div.nboutput.container div.math p { + text-align: left; +} + +/* standard error */ +div.nboutput.container div.output_area.stderr { + background: #fdd; +} + +/* ANSI colors */ +.ansi-black-fg { color: #3E424D; } +.ansi-black-bg { background-color: #3E424D; } +.ansi-black-intense-fg { color: #282C36; } +.ansi-black-intense-bg { background-color: #282C36; } +.ansi-red-fg { color: #E75C58; } +.ansi-red-bg { background-color: #E75C58; } +.ansi-red-intense-fg { color: #B22B31; } +.ansi-red-intense-bg { background-color: #B22B31; } +.ansi-green-fg { color: #00A250; } +.ansi-green-bg { background-color: #00A250; } +.ansi-green-intense-fg { color: #007427; } +.ansi-green-intense-bg { background-color: #007427; } +.ansi-yellow-fg { color: #DDB62B; } +.ansi-yellow-bg { background-color: #DDB62B; } +.ansi-yellow-intense-fg { color: #B27D12; } +.ansi-yellow-intense-bg { background-color: #B27D12; } +.ansi-blue-fg { color: #208FFB; } +.ansi-blue-bg { background-color: #208FFB; } +.ansi-blue-intense-fg { color: #0065CA; } +.ansi-blue-intense-bg { background-color: #0065CA; } +.ansi-magenta-fg { color: #D160C4; } +.ansi-magenta-bg { background-color: #D160C4; } +.ansi-magenta-intense-fg { color: #A03196; } +.ansi-magenta-intense-bg { background-color: #A03196; } +.ansi-cyan-fg { color: #60C6C8; } +.ansi-cyan-bg { background-color: #60C6C8; } +.ansi-cyan-intense-fg { color: #258F8F; } +.ansi-cyan-intense-bg { background-color: #258F8F; } +.ansi-white-fg { color: #C5C1B4; } +.ansi-white-bg { background-color: #C5C1B4; } +.ansi-white-intense-fg { color: #A1A6B2; } +.ansi-white-intense-bg { background-color: #A1A6B2; } + +.ansi-default-inverse-fg { color: #FFFFFF; } +.ansi-default-inverse-bg { background-color: #000000; } + +.ansi-bold { font-weight: bold; } +.ansi-underline { text-decoration: underline; } + + +div.nbinput.container div.input_area div[class*=highlight] > pre, +div.nboutput.container div.output_area div[class*=highlight] > pre, +div.nboutput.container div.output_area div[class*=highlight].math, +div.nboutput.container div.output_area.rendered_html, +div.nboutput.container div.output_area > div.output_javascript, +div.nboutput.container div.output_area:not(.rendered_html) > img{ + padding: 5px; + margin: 0; +} + +/* fix copybtn overflow problem in chromium (needed for 'sphinx_copybutton') */ +div.nbinput.container div.input_area > div[class^='highlight'], +div.nboutput.container div.output_area > div[class^='highlight']{ + overflow-y: hidden; +} + +/* hide copy button on prompts for 'sphinx_copybutton' extension ... */ +.prompt .copybtn, +/* ... and 'sphinx_immaterial' theme */ +.prompt .md-clipboard.md-icon { + display: none; +} + +/* Some additional styling taken form the Jupyter notebook CSS */ +.jp-RenderedHTMLCommon table, +div.rendered_html table { + border: none; + border-collapse: collapse; + border-spacing: 0; + color: black; + font-size: 12px; + table-layout: fixed; +} +.jp-RenderedHTMLCommon thead, +div.rendered_html thead { + border-bottom: 1px solid black; + vertical-align: bottom; +} +.jp-RenderedHTMLCommon tr, +.jp-RenderedHTMLCommon th, +.jp-RenderedHTMLCommon td, +div.rendered_html tr, +div.rendered_html th, +div.rendered_html td { + text-align: right; + vertical-align: middle; + padding: 0.5em 0.5em; + line-height: normal; + white-space: normal; + max-width: none; + border: none; +} +.jp-RenderedHTMLCommon th, +div.rendered_html th { + font-weight: bold; +} +.jp-RenderedHTMLCommon tbody tr:nth-child(odd), +div.rendered_html tbody tr:nth-child(odd) { + background: #f5f5f5; +} +.jp-RenderedHTMLCommon tbody tr:hover, +div.rendered_html tbody tr:hover { + background: rgba(66, 165, 245, 0.2); +} + diff --git a/_static/nbsphinx-gallery.css b/_static/nbsphinx-gallery.css new file mode 100644 index 0000000..365c27a --- /dev/null +++ b/_static/nbsphinx-gallery.css @@ -0,0 +1,31 @@ +.nbsphinx-gallery { + display: grid; + grid-template-columns: repeat(auto-fill, minmax(160px, 1fr)); + gap: 5px; + margin-top: 1em; + margin-bottom: 1em; +} + +.nbsphinx-gallery > a { + padding: 5px; + border: 1px dotted currentColor; + border-radius: 2px; + text-align: center; +} + +.nbsphinx-gallery > a:hover { + border-style: solid; +} + +.nbsphinx-gallery img { + max-width: 100%; + max-height: 100%; +} + +.nbsphinx-gallery > a > div:first-child { + display: flex; + align-items: start; + justify-content: center; + height: 120px; + margin-bottom: 5px; +} diff --git a/_static/nbsphinx-no-thumbnail.svg b/_static/nbsphinx-no-thumbnail.svg new file mode 100644 index 0000000..9dca758 --- /dev/null +++ b/_static/nbsphinx-no-thumbnail.svg @@ -0,0 +1,9 @@ + + + + diff --git a/_static/plus.png b/_static/plus.png new file mode 100644 index 0000000..7107cec Binary files /dev/null and b/_static/plus.png differ diff --git a/_static/pygments.css b/_static/pygments.css new file mode 100644 index 0000000..84ab303 --- /dev/null +++ b/_static/pygments.css @@ -0,0 +1,75 @@ +pre { line-height: 125%; } +td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; } +td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; } +.highlight .hll { background-color: #ffffcc } +.highlight { background: #f8f8f8; } +.highlight .c { color: #3D7B7B; font-style: italic } /* Comment */ +.highlight .err { border: 1px solid #FF0000 } /* Error */ +.highlight .k { color: #008000; font-weight: bold } /* Keyword */ +.highlight .o { color: #666666 } /* Operator */ +.highlight .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */ +.highlight .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */ +.highlight .cp { color: #9C6500 } /* Comment.Preproc */ +.highlight .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */ +.highlight .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */ +.highlight .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */ +.highlight .gd { color: #A00000 } /* Generic.Deleted */ +.highlight .ge { font-style: italic } /* Generic.Emph */ +.highlight .ges { font-weight: bold; font-style: italic } /* Generic.EmphStrong */ +.highlight .gr { color: #E40000 } /* Generic.Error */ +.highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */ +.highlight .gi { color: #008400 } /* Generic.Inserted */ +.highlight .go { color: #717171 } /* Generic.Output */ +.highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */ +.highlight .gs { font-weight: bold } /* Generic.Strong */ +.highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */ +.highlight .gt { color: #0044DD } /* Generic.Traceback */ +.highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */ +.highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */ +.highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */ +.highlight .kp { color: #008000 } /* Keyword.Pseudo */ +.highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */ +.highlight .kt { color: #B00040 } /* Keyword.Type */ +.highlight .m { color: #666666 } /* Literal.Number */ +.highlight .s { color: #BA2121 } /* Literal.String */ +.highlight .na { color: #687822 } /* Name.Attribute */ +.highlight .nb { color: #008000 } /* Name.Builtin */ +.highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */ +.highlight .no { color: #880000 } /* Name.Constant */ +.highlight .nd { color: #AA22FF } /* Name.Decorator */ +.highlight .ni { color: #717171; font-weight: bold } /* Name.Entity */ +.highlight .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */ +.highlight .nf { color: #0000FF } /* Name.Function */ +.highlight .nl { color: #767600 } /* Name.Label */ +.highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */ +.highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */ +.highlight .nv { color: #19177C } /* Name.Variable */ +.highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */ +.highlight .w { color: #bbbbbb } /* Text.Whitespace */ +.highlight .mb { color: #666666 } /* Literal.Number.Bin */ +.highlight .mf { color: #666666 } /* Literal.Number.Float */ +.highlight .mh { color: #666666 } /* Literal.Number.Hex */ +.highlight .mi { color: #666666 } /* Literal.Number.Integer */ +.highlight .mo { color: #666666 } /* Literal.Number.Oct */ +.highlight .sa { color: #BA2121 } /* Literal.String.Affix */ +.highlight .sb { color: #BA2121 } /* Literal.String.Backtick */ +.highlight .sc { color: #BA2121 } /* Literal.String.Char */ +.highlight .dl { color: #BA2121 } /* Literal.String.Delimiter */ +.highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */ +.highlight .s2 { color: #BA2121 } /* Literal.String.Double */ +.highlight .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */ +.highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */ +.highlight .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */ +.highlight .sx { color: #008000 } /* Literal.String.Other */ +.highlight .sr { color: #A45A77 } /* Literal.String.Regex */ +.highlight .s1 { color: #BA2121 } /* Literal.String.Single */ +.highlight .ss { color: #19177C } /* Literal.String.Symbol */ +.highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */ +.highlight .fm { color: #0000FF } /* Name.Function.Magic */ +.highlight .vc { color: #19177C } /* Name.Variable.Class */ +.highlight .vg { color: #19177C } /* Name.Variable.Global */ +.highlight .vi { color: #19177C } /* Name.Variable.Instance */ +.highlight .vm { color: #19177C } /* Name.Variable.Magic */ +.highlight .il { color: #666666 } /* Literal.Number.Integer.Long */ \ No newline at end of file diff --git a/_static/searchtools.js b/_static/searchtools.js new file mode 100644 index 0000000..b08d58c --- /dev/null +++ b/_static/searchtools.js @@ -0,0 +1,620 @@ +/* + * searchtools.js + * ~~~~~~~~~~~~~~~~ + * + * Sphinx JavaScript utilities for the full-text search. + * + * :copyright: Copyright 2007-2024 by the Sphinx team, see AUTHORS. + * :license: BSD, see LICENSE for details. + * + */ +"use strict"; + +/** + * Simple result scoring code. + */ +if (typeof Scorer === "undefined") { + var Scorer = { + // Implement the following function to further tweak the score for each result + // The function takes a result array [docname, title, anchor, descr, score, filename] + // and returns the new score. + /* + score: result => { + const [docname, title, anchor, descr, score, filename] = result + return score + }, + */ + + // query matches the full name of an object + objNameMatch: 11, + // or matches in the last dotted part of the object name + objPartialMatch: 6, + // Additive scores depending on the priority of the object + objPrio: { + 0: 15, // used to be importantResults + 1: 5, // used to be objectResults + 2: -5, // used to be unimportantResults + }, + // Used when the priority is not in the mapping. + objPrioDefault: 0, + + // query found in title + title: 15, + partialTitle: 7, + // query found in terms + term: 5, + partialTerm: 2, + }; +} + +const _removeChildren = (element) => { + while (element && element.lastChild) element.removeChild(element.lastChild); +}; + +/** + * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#escaping + */ +const _escapeRegExp = (string) => + string.replace(/[.*+\-?^${}()|[\]\\]/g, "\\$&"); // $& means the whole matched string + +const _displayItem = (item, searchTerms, highlightTerms) => { + const docBuilder = DOCUMENTATION_OPTIONS.BUILDER; + const docFileSuffix = DOCUMENTATION_OPTIONS.FILE_SUFFIX; + const docLinkSuffix = DOCUMENTATION_OPTIONS.LINK_SUFFIX; + const showSearchSummary = DOCUMENTATION_OPTIONS.SHOW_SEARCH_SUMMARY; + const contentRoot = document.documentElement.dataset.content_root; + + const [docName, title, anchor, descr, score, _filename] = item; + + let listItem = document.createElement("li"); + let requestUrl; + let linkUrl; + if (docBuilder === "dirhtml") { + // dirhtml builder + let dirname = docName + "/"; + if (dirname.match(/\/index\/$/)) + dirname = dirname.substring(0, dirname.length - 6); + else if (dirname === "index/") dirname = ""; + requestUrl = contentRoot + dirname; + linkUrl = requestUrl; + } else { + // normal html builders + requestUrl = contentRoot + docName + docFileSuffix; + linkUrl = docName + docLinkSuffix; + } + let linkEl = listItem.appendChild(document.createElement("a")); + linkEl.href = linkUrl + anchor; + linkEl.dataset.score = score; + linkEl.innerHTML = title; + if (descr) { + listItem.appendChild(document.createElement("span")).innerHTML = + " (" + descr + ")"; + // highlight search terms in the description + if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js + highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted")); + } + else if (showSearchSummary) + fetch(requestUrl) + .then((responseData) => responseData.text()) + .then((data) => { + if (data) + listItem.appendChild( + Search.makeSearchSummary(data, searchTerms, anchor) + ); + // highlight search terms in the summary + if (SPHINX_HIGHLIGHT_ENABLED) // set in sphinx_highlight.js + highlightTerms.forEach((term) => _highlightText(listItem, term, "highlighted")); + }); + Search.output.appendChild(listItem); +}; +const _finishSearch = (resultCount) => { + Search.stopPulse(); + Search.title.innerText = _("Search Results"); + if (!resultCount) + Search.status.innerText = Documentation.gettext( + "Your search did not match any documents. Please make sure that all words are spelled correctly and that you've selected enough categories." + ); + else + Search.status.innerText = _( + "Search finished, found ${resultCount} page(s) matching the search query." + ).replace('${resultCount}', resultCount); +}; +const _displayNextItem = ( + results, + resultCount, + searchTerms, + highlightTerms, +) => { + // results left, load the summary and display it + // this is intended to be dynamic (don't sub resultsCount) + if (results.length) { + _displayItem(results.pop(), searchTerms, highlightTerms); + setTimeout( + () => _displayNextItem(results, resultCount, searchTerms, highlightTerms), + 5 + ); + } + // search finished, update title and status message + else _finishSearch(resultCount); +}; +// Helper function used by query() to order search results. +// Each input is an array of [docname, title, anchor, descr, score, filename]. +// Order the results by score (in opposite order of appearance, since the +// `_displayNextItem` function uses pop() to retrieve items) and then alphabetically. +const _orderResultsByScoreThenName = (a, b) => { + const leftScore = a[4]; + const rightScore = b[4]; + if (leftScore === rightScore) { + // same score: sort alphabetically + const leftTitle = a[1].toLowerCase(); + const rightTitle = b[1].toLowerCase(); + if (leftTitle === rightTitle) return 0; + return leftTitle > rightTitle ? -1 : 1; // inverted is intentional + } + return leftScore > rightScore ? 1 : -1; +}; + +/** + * Default splitQuery function. Can be overridden in ``sphinx.search`` with a + * custom function per language. + * + * The regular expression works by splitting the string on consecutive characters + * that are not Unicode letters, numbers, underscores, or emoji characters. + * This is the same as ``\W+`` in Python, preserving the surrogate pair area. + */ +if (typeof splitQuery === "undefined") { + var splitQuery = (query) => query + .split(/[^\p{Letter}\p{Number}_\p{Emoji_Presentation}]+/gu) + .filter(term => term) // remove remaining empty strings +} + +/** + * Search Module + */ +const Search = { + _index: null, + _queued_query: null, + _pulse_status: -1, + + htmlToText: (htmlString, anchor) => { + const htmlElement = new DOMParser().parseFromString(htmlString, 'text/html'); + for (const removalQuery of [".headerlink", "script", "style"]) { + htmlElement.querySelectorAll(removalQuery).forEach((el) => { el.remove() }); + } + if (anchor) { + const anchorContent = htmlElement.querySelector(`[role="main"] ${anchor}`); + if (anchorContent) return anchorContent.textContent; + + console.warn( + `Anchored content block not found. Sphinx search tries to obtain it via DOM query '[role=main] ${anchor}'. Check your theme or template.` + ); + } + + // if anchor not specified or not found, fall back to main content + const docContent = htmlElement.querySelector('[role="main"]'); + if (docContent) return docContent.textContent; + + console.warn( + "Content block not found. Sphinx search tries to obtain it via DOM query '[role=main]'. Check your theme or template." + ); + return ""; + }, + + init: () => { + const query = new URLSearchParams(window.location.search).get("q"); + document + .querySelectorAll('input[name="q"]') + .forEach((el) => (el.value = query)); + if (query) Search.performSearch(query); + }, + + loadIndex: (url) => + (document.body.appendChild(document.createElement("script")).src = url), + + setIndex: (index) => { + Search._index = index; + if (Search._queued_query !== null) { + const query = Search._queued_query; + Search._queued_query = null; + Search.query(query); + } + }, + + hasIndex: () => Search._index !== null, + + deferQuery: (query) => (Search._queued_query = query), + + stopPulse: () => (Search._pulse_status = -1), + + startPulse: () => { + if (Search._pulse_status >= 0) return; + + const pulse = () => { + Search._pulse_status = (Search._pulse_status + 1) % 4; + Search.dots.innerText = ".".repeat(Search._pulse_status); + if (Search._pulse_status >= 0) window.setTimeout(pulse, 500); + }; + pulse(); + }, + + /** + * perform a search for something (or wait until index is loaded) + */ + performSearch: (query) => { + // create the required interface elements + const searchText = document.createElement("h2"); + searchText.textContent = _("Searching"); + const searchSummary = document.createElement("p"); + searchSummary.classList.add("search-summary"); + searchSummary.innerText = ""; + const searchList = document.createElement("ul"); + searchList.classList.add("search"); + + const out = document.getElementById("search-results"); + Search.title = out.appendChild(searchText); + Search.dots = Search.title.appendChild(document.createElement("span")); + Search.status = out.appendChild(searchSummary); + Search.output = out.appendChild(searchList); + + const searchProgress = document.getElementById("search-progress"); + // Some themes don't use the search progress node + if (searchProgress) { + searchProgress.innerText = _("Preparing search..."); + } + Search.startPulse(); + + // index already loaded, the browser was quick! + if (Search.hasIndex()) Search.query(query); + else Search.deferQuery(query); + }, + + _parseQuery: (query) => { + // stem the search terms and add them to the correct list + const stemmer = new Stemmer(); + const searchTerms = new Set(); + const excludedTerms = new Set(); + const highlightTerms = new Set(); + const objectTerms = new Set(splitQuery(query.toLowerCase().trim())); + splitQuery(query.trim()).forEach((queryTerm) => { + const queryTermLower = queryTerm.toLowerCase(); + + // maybe skip this "word" + // stopwords array is from language_data.js + if ( + stopwords.indexOf(queryTermLower) !== -1 || + queryTerm.match(/^\d+$/) + ) + return; + + // stem the word + let word = stemmer.stemWord(queryTermLower); + // select the correct list + if (word[0] === "-") excludedTerms.add(word.substr(1)); + else { + searchTerms.add(word); + highlightTerms.add(queryTermLower); + } + }); + + if (SPHINX_HIGHLIGHT_ENABLED) { // set in sphinx_highlight.js + localStorage.setItem("sphinx_highlight_terms", [...highlightTerms].join(" ")) + } + + // console.debug("SEARCH: searching for:"); + // console.info("required: ", [...searchTerms]); + // console.info("excluded: ", [...excludedTerms]); + + return [query, searchTerms, excludedTerms, highlightTerms, objectTerms]; + }, + + /** + * execute search (requires search index to be loaded) + */ + _performSearch: (query, searchTerms, excludedTerms, highlightTerms, objectTerms) => { + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const titles = Search._index.titles; + const allTitles = Search._index.alltitles; + const indexEntries = Search._index.indexentries; + + // Collect multiple result groups to be sorted separately and then ordered. + // Each is an array of [docname, title, anchor, descr, score, filename]. + const normalResults = []; + const nonMainIndexResults = []; + + _removeChildren(document.getElementById("search-progress")); + + const queryLower = query.toLowerCase().trim(); + for (const [title, foundTitles] of Object.entries(allTitles)) { + if (title.toLowerCase().trim().includes(queryLower) && (queryLower.length >= title.length/2)) { + for (const [file, id] of foundTitles) { + const score = Math.round(Scorer.title * queryLower.length / title.length); + const boost = titles[file] === title ? 1 : 0; // add a boost for document titles + normalResults.push([ + docNames[file], + titles[file] !== title ? `${titles[file]} > ${title}` : title, + id !== null ? "#" + id : "", + null, + score + boost, + filenames[file], + ]); + } + } + } + + // search for explicit entries in index directives + for (const [entry, foundEntries] of Object.entries(indexEntries)) { + if (entry.includes(queryLower) && (queryLower.length >= entry.length/2)) { + for (const [file, id, isMain] of foundEntries) { + const score = Math.round(100 * queryLower.length / entry.length); + const result = [ + docNames[file], + titles[file], + id ? "#" + id : "", + null, + score, + filenames[file], + ]; + if (isMain) { + normalResults.push(result); + } else { + nonMainIndexResults.push(result); + } + } + } + } + + // lookup as object + objectTerms.forEach((term) => + normalResults.push(...Search.performObjectSearch(term, objectTerms)) + ); + + // lookup as search terms in fulltext + normalResults.push(...Search.performTermsSearch(searchTerms, excludedTerms)); + + // let the scorer override scores with a custom scoring function + if (Scorer.score) { + normalResults.forEach((item) => (item[4] = Scorer.score(item))); + nonMainIndexResults.forEach((item) => (item[4] = Scorer.score(item))); + } + + // Sort each group of results by score and then alphabetically by name. + normalResults.sort(_orderResultsByScoreThenName); + nonMainIndexResults.sort(_orderResultsByScoreThenName); + + // Combine the result groups in (reverse) order. + // Non-main index entries are typically arbitrary cross-references, + // so display them after other results. + let results = [...nonMainIndexResults, ...normalResults]; + + // remove duplicate search results + // note the reversing of results, so that in the case of duplicates, the highest-scoring entry is kept + let seen = new Set(); + results = results.reverse().reduce((acc, result) => { + let resultStr = result.slice(0, 4).concat([result[5]]).map(v => String(v)).join(','); + if (!seen.has(resultStr)) { + acc.push(result); + seen.add(resultStr); + } + return acc; + }, []); + + return results.reverse(); + }, + + query: (query) => { + const [searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms] = Search._parseQuery(query); + const results = Search._performSearch(searchQuery, searchTerms, excludedTerms, highlightTerms, objectTerms); + + // for debugging + //Search.lastresults = results.slice(); // a copy + // console.info("search results:", Search.lastresults); + + // print the results + _displayNextItem(results, results.length, searchTerms, highlightTerms); + }, + + /** + * search for object names + */ + performObjectSearch: (object, objectTerms) => { + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const objects = Search._index.objects; + const objNames = Search._index.objnames; + const titles = Search._index.titles; + + const results = []; + + const objectSearchCallback = (prefix, match) => { + const name = match[4] + const fullname = (prefix ? prefix + "." : "") + name; + const fullnameLower = fullname.toLowerCase(); + if (fullnameLower.indexOf(object) < 0) return; + + let score = 0; + const parts = fullnameLower.split("."); + + // check for different match types: exact matches of full name or + // "last name" (i.e. last dotted part) + if (fullnameLower === object || parts.slice(-1)[0] === object) + score += Scorer.objNameMatch; + else if (parts.slice(-1)[0].indexOf(object) > -1) + score += Scorer.objPartialMatch; // matches in last name + + const objName = objNames[match[1]][2]; + const title = titles[match[0]]; + + // If more than one term searched for, we require other words to be + // found in the name/title/description + const otherTerms = new Set(objectTerms); + otherTerms.delete(object); + if (otherTerms.size > 0) { + const haystack = `${prefix} ${name} ${objName} ${title}`.toLowerCase(); + if ( + [...otherTerms].some((otherTerm) => haystack.indexOf(otherTerm) < 0) + ) + return; + } + + let anchor = match[3]; + if (anchor === "") anchor = fullname; + else if (anchor === "-") anchor = objNames[match[1]][1] + "-" + fullname; + + const descr = objName + _(", in ") + title; + + // add custom score for some objects according to scorer + if (Scorer.objPrio.hasOwnProperty(match[2])) + score += Scorer.objPrio[match[2]]; + else score += Scorer.objPrioDefault; + + results.push([ + docNames[match[0]], + fullname, + "#" + anchor, + descr, + score, + filenames[match[0]], + ]); + }; + Object.keys(objects).forEach((prefix) => + objects[prefix].forEach((array) => + objectSearchCallback(prefix, array) + ) + ); + return results; + }, + + /** + * search for full-text terms in the index + */ + performTermsSearch: (searchTerms, excludedTerms) => { + // prepare search + const terms = Search._index.terms; + const titleTerms = Search._index.titleterms; + const filenames = Search._index.filenames; + const docNames = Search._index.docnames; + const titles = Search._index.titles; + + const scoreMap = new Map(); + const fileMap = new Map(); + + // perform the search on the required terms + searchTerms.forEach((word) => { + const files = []; + const arr = [ + { files: terms[word], score: Scorer.term }, + { files: titleTerms[word], score: Scorer.title }, + ]; + // add support for partial matches + if (word.length > 2) { + const escapedWord = _escapeRegExp(word); + if (!terms.hasOwnProperty(word)) { + Object.keys(terms).forEach((term) => { + if (term.match(escapedWord)) + arr.push({ files: terms[term], score: Scorer.partialTerm }); + }); + } + if (!titleTerms.hasOwnProperty(word)) { + Object.keys(titleTerms).forEach((term) => { + if (term.match(escapedWord)) + arr.push({ files: titleTerms[term], score: Scorer.partialTitle }); + }); + } + } + + // no match but word was a required one + if (arr.every((record) => record.files === undefined)) return; + + // found search word in contents + arr.forEach((record) => { + if (record.files === undefined) return; + + let recordFiles = record.files; + if (recordFiles.length === undefined) recordFiles = [recordFiles]; + files.push(...recordFiles); + + // set score for the word in each file + recordFiles.forEach((file) => { + if (!scoreMap.has(file)) scoreMap.set(file, {}); + scoreMap.get(file)[word] = record.score; + }); + }); + + // create the mapping + files.forEach((file) => { + if (!fileMap.has(file)) fileMap.set(file, [word]); + else if (fileMap.get(file).indexOf(word) === -1) fileMap.get(file).push(word); + }); + }); + + // now check if the files don't contain excluded terms + const results = []; + for (const [file, wordList] of fileMap) { + // check if all requirements are matched + + // as search terms with length < 3 are discarded + const filteredTermCount = [...searchTerms].filter( + (term) => term.length > 2 + ).length; + if ( + wordList.length !== searchTerms.size && + wordList.length !== filteredTermCount + ) + continue; + + // ensure that none of the excluded terms is in the search result + if ( + [...excludedTerms].some( + (term) => + terms[term] === file || + titleTerms[term] === file || + (terms[term] || []).includes(file) || + (titleTerms[term] || []).includes(file) + ) + ) + break; + + // select one (max) score for the file. + const score = Math.max(...wordList.map((w) => scoreMap.get(file)[w])); + // add result to the result list + results.push([ + docNames[file], + titles[file], + "", + null, + score, + filenames[file], + ]); + } + return results; + }, + + /** + * helper function to return a node containing the + * search summary for a given text. keywords is a list + * of stemmed words. + */ + makeSearchSummary: (htmlText, keywords, anchor) => { + const text = Search.htmlToText(htmlText, anchor); + if (text === "") return null; + + const textLower = text.toLowerCase(); + const actualStartPosition = [...keywords] + .map((k) => textLower.indexOf(k.toLowerCase())) + .filter((i) => i > -1) + .slice(-1)[0]; + const startWithContext = Math.max(actualStartPosition - 120, 0); + + const top = startWithContext === 0 ? "" : "..."; + const tail = startWithContext + 240 < text.length ? "..." : ""; + + let summary = document.createElement("p"); + summary.classList.add("context"); + summary.textContent = top + text.substr(startWithContext, 240).trim() + tail; + + return summary; + }, +}; + +_ready(Search.init); diff --git a/_static/sphinx_highlight.js b/_static/sphinx_highlight.js new file mode 100644 index 0000000..8a96c69 --- /dev/null +++ b/_static/sphinx_highlight.js @@ -0,0 +1,154 @@ +/* Highlighting utilities for Sphinx HTML documentation. */ +"use strict"; + +const SPHINX_HIGHLIGHT_ENABLED = true + +/** + * highlight a given string on a node by wrapping it in + * span elements with the given class name. + */ +const _highlight = (node, addItems, text, className) => { + if (node.nodeType === Node.TEXT_NODE) { + const val = node.nodeValue; + const parent = node.parentNode; + const pos = val.toLowerCase().indexOf(text); + if ( + pos >= 0 && + !parent.classList.contains(className) && + !parent.classList.contains("nohighlight") + ) { + let span; + + const closestNode = parent.closest("body, svg, foreignObject"); + const isInSVG = closestNode && closestNode.matches("svg"); + if (isInSVG) { + span = document.createElementNS("http://www.w3.org/2000/svg", "tspan"); + } else { + span = document.createElement("span"); + span.classList.add(className); + } + + span.appendChild(document.createTextNode(val.substr(pos, text.length))); + const rest = document.createTextNode(val.substr(pos + text.length)); + parent.insertBefore( + span, + parent.insertBefore( + rest, + node.nextSibling + ) + ); + node.nodeValue = val.substr(0, pos); + /* There may be more occurrences of search term in this node. So call this + * function recursively on the remaining fragment. + */ + _highlight(rest, addItems, text, className); + + if (isInSVG) { + const rect = document.createElementNS( + "http://www.w3.org/2000/svg", + "rect" + ); + const bbox = parent.getBBox(); + rect.x.baseVal.value = bbox.x; + rect.y.baseVal.value = bbox.y; + rect.width.baseVal.value = bbox.width; + rect.height.baseVal.value = bbox.height; + rect.setAttribute("class", className); + addItems.push({ parent: parent, target: rect }); + } + } + } else if (node.matches && !node.matches("button, select, textarea")) { + node.childNodes.forEach((el) => _highlight(el, addItems, text, className)); + } +}; +const _highlightText = (thisNode, text, className) => { + let addItems = []; + _highlight(thisNode, addItems, text, className); + addItems.forEach((obj) => + obj.parent.insertAdjacentElement("beforebegin", obj.target) + ); +}; + +/** + * Small JavaScript module for the documentation. + */ +const SphinxHighlight = { + + /** + * highlight the search words provided in localstorage in the text + */ + highlightSearchWords: () => { + if (!SPHINX_HIGHLIGHT_ENABLED) return; // bail if no highlight + + // get and clear terms from localstorage + const url = new URL(window.location); + const highlight = + localStorage.getItem("sphinx_highlight_terms") + || url.searchParams.get("highlight") + || ""; + localStorage.removeItem("sphinx_highlight_terms") + url.searchParams.delete("highlight"); + window.history.replaceState({}, "", url); + + // get individual terms from highlight string + const terms = highlight.toLowerCase().split(/\s+/).filter(x => x); + if (terms.length === 0) return; // nothing to do + + // There should never be more than one element matching "div.body" + const divBody = document.querySelectorAll("div.body"); + const body = divBody.length ? divBody[0] : document.querySelector("body"); + window.setTimeout(() => { + terms.forEach((term) => _highlightText(body, term, "highlighted")); + }, 10); + + const searchBox = document.getElementById("searchbox"); + if (searchBox === null) return; + searchBox.appendChild( + document + .createRange() + .createContextualFragment( + '

' + + '' + + _("Hide Search Matches") + + "

" + ) + ); + }, + + /** + * helper function to hide the search marks again + */ + hideSearchWords: () => { + document + .querySelectorAll("#searchbox .highlight-link") + .forEach((el) => el.remove()); + document + .querySelectorAll("span.highlighted") + .forEach((el) => el.classList.remove("highlighted")); + localStorage.removeItem("sphinx_highlight_terms") + }, + + initEscapeListener: () => { + // only install a listener if it is really needed + if (!DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS) return; + + document.addEventListener("keydown", (event) => { + // bail for input elements + if (BLACKLISTED_KEY_CONTROL_ELEMENTS.has(document.activeElement.tagName)) return; + // bail with special keys + if (event.shiftKey || event.altKey || event.ctrlKey || event.metaKey) return; + if (DOCUMENTATION_OPTIONS.ENABLE_SEARCH_SHORTCUTS && (event.key === "Escape")) { + SphinxHighlight.hideSearchWords(); + event.preventDefault(); + } + }); + }, +}; + +_ready(() => { + /* Do not call highlightSearchWords() when we are on the search page. + * It will highlight words from the *previous* search query. + */ + if (typeof Search === "undefined") SphinxHighlight.highlightSearchWords(); + SphinxHighlight.initEscapeListener(); +}); diff --git a/classes.html b/classes.html new file mode 100644 index 0000000..adad718 --- /dev/null +++ b/classes.html @@ -0,0 +1,669 @@ + + + + + + + pigeon_feather.data.RangeList — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

pigeon_feather.data.RangeList

+
+
+class pigeon_feather.data.RangeList(range_list_file=None, range_df=None)
+
+
+__init__(range_list_file=None, range_df=None)
+

A class to handle a list of peptides.

+
+
Parameters:
+
    +

  • range_list_file – csv file with Start, End columns

    • +

  • range_df – a dataframe

    • +
+
+
Variables:
+
    +

  • range_list – a dataframe with Start, End columns

    • +

  • range_set – a set of tuples (Start, End)

    • +
+
+
+
+ +

Methods

+ + + + + + + + + + + + + + + + + + + + + +

to_set()

convert the range list to a set of tuples (Start, End)

to_dataframe()

return the range list as a dataframe

to_csv(path)

save the range list to a csv file

union(other)

return the union of two range lists

intersection(other)

return the intersection of two range lists

difference(other)

return the difference of two range lists

+
+ +
+
+

pigeon_feather.data.HDXMSDataCollection

+
+
+class pigeon_feather.data.HDXMSDataCollection(hdxms_data_list)
+
+
+__init__(hdxms_data_list)
+

A cloolection of HDXMSData objects

+
+
Parameters:
+

hdxms_data_list – a list of HDXMSData objects

+
+
+
+ +
+ +
+
+

pigeon_feather.data.HDXMSData

+
+
+class pigeon_feather.data.HDXMSData(protein_name, n_fastamides=2, protein_sequence=None, saturation=1)
+
+
+__init__(protein_name, n_fastamides=2, protein_sequence=None, saturation=1)
+

A class to store one HDX-MS replicate data. It can contain multiple states.

+
+
Parameters:
+
    +

  • protein_name – string, name of the protein

    • +

  • n_fastamides – int, defaults to 2

    • +

  • protein_sequence – string

    • +

  • saturation – D saturation, defaults to 1

    • +
+
+
Variables:
+

states – a list of ProteinState objects

+
+
+
+ +

Methods

+ + + + + + + + + + + + + + + + + + + + + + + + +

add_state(state)

add a state to the HDXMSData object

load_protein_sequence(sequence)

load protein sequence to the HDXMSData object

get_state(state_name)

return a state by name

plot_res_coverage()

plot residue coverage of the protein

reindex_peptide_from_pdb(pdb_file[, ...])

reindex peptides based on the pdb file, aften there is a index offset.

to_dataframe([if_percent])

convert the HDXMSData object to a dataframe

to_bayesianhdx_format([OUTPATH])

convert the HDXMSData object to BayesianHDX format and save to a file

+

Attributes

+ + + + + + +

num_states

return the number of states in the HDXMSData object

+
+ +
+
+

pigeon_feather.data.ProteinState

+
+
+class pigeon_feather.data.ProteinState(state_name, hdxms_data=None)
+
+
+__init__(state_name, hdxms_data=None)
+

A class to store one state of a protein. It can contain multiple peptides.

+
+
Parameters:
+
    +

  • state_name – name of the state

    • +

  • hdxms_data – HDXMSData object

    • +
+
+
Variables:
+
    +

  • peptides – a list of Peptide objects

    • +

  • if_subtracted – if subtracted peptides have been added

    • +

  • num_subtracted_added – number of subtracted peptides added

    • +
+
+
+
+ +

Methods

+ + + + + + + + + + + + + + + + + + +

add_peptide(peptide)

add a peptide to the ProteinState object

num_peptides

return the number of peptides in the ProteinState

get_peptide(identifier)

return a peptide by identifier

add_new_peptides_by_subtract()

add new peptides to the protein state by subtracting the overlapped peptides

add_all_subtract()

add all possible subtracted peptides to the protein state

+
+ +
+
+

pigeon_feather.data.Peptide

+
+
+class pigeon_feather.data.Peptide(raw_sequence, raw_start, raw_end, protein_state=None, n_fastamides=0, RT=None)
+
+
+__init__(raw_sequence, raw_start, raw_end, protein_state=None, n_fastamides=0, RT=None)
+

A class to store one peptide. It can contain multiple timepoints.

+
+
Parameters:
+
    +

  • raw_sequence – peptide sequence

    • +

  • raw_start – peptide start residue number, including fastamides, 1-based

    • +

  • raw_end – peptide end residue number, including fastamides, 1-based

    • +

  • protein_state – ProteinState it belongs to

    • +

  • n_fastamides – number of fastamides

    • +
+
+
Variables:
+
    +

  • identifier – used for peptide identification, raw sequence including fastamides, e.g. “1-10 ABCDEFGHIJ”

    • +

  • sequence – peptide sequence excluding fastamides, 1-based

    • +

  • start – peptide start residue number excluding fastamides, 1-based

    • +

  • end – peptide end residue number, 1-based

    • +

  • timepoints – a list of Timepoint objects

    • +

  • note – a note for the peptide

    • +
+
+
+
+ +

Methods

+ + + + + + + + + + + + + + + +

add_timepoint(timepoint)

add a timepoint to the peptide

get_deut(deut_time)

return deuterium num at a specific deuteration time

get_deut_percent(deut_time)

return normalized deuterium incorporation at a specific deuteration time

get_timepoint(deut_time[, charge_state])

return a timepoint by deuteration time and charge state

+
+ +
+
+

pigeon_feather.data.Timepoint

+
+
+class pigeon_feather.data.Timepoint(peptide, deut_time, num_d, stddev, charge_state=None)
+
+
+__init__(peptide, deut_time, num_d, stddev, charge_state=None)
+

A class to store one timepoint of a peptide.

+
+
Parameters:
+
    +

  • peptide – Peptide object it belongs to

    • +

  • deut_time – deuteration time

    • +

  • num_d – number of deuterium incorporated

    • +

  • stddev – standard deviation of the number of deuterium incorporated

    • +

  • charge_state – charge state

    • +
+
+
+
+ +

Methods

+ + + + + + +

load_raw_ms_csv(csv_file)

load raw mass spec data from a HDExaminer csv file

+
+ +
+
+

pigeon_feather.HDXStatePeptideCompares

+
+
+class pigeon_feather.data.HDXStatePeptideCompares(state1_list, state2_list)
+
+
+__init__(state1_list, state2_list)
+

A class to compare peptides between two states.

+
+
Parameters:
+
    +

  • state1_list – a list of ProteinState objects

    • +

  • state2_list – a list of ProteinState objects

    • +
+
+
+
+ +

Methods

+ + + + + + + + + +

add_all_compare()

add all possible peptide compares between two states

to_dataframe()

convert the HDXStatePeptideCompares object to a dataframe

+
+ +
+
+

pigeon_feather.PeptideCompare

+
+
+class pigeon_feather.data.PeptideCompare(peptide1_list, peptide2_list)
+
+
+__init__(peptide1_list, peptide2_list)
+

A class to compare one peptide between two states.

+
+
Parameters:
+
    +

  • peptide1_list – a list of Peptide objects

    • +

  • peptide2_list – a list of Peptide objects

    • +
+
+
Raises:
+

ValueError – if peptides have different sequences

+
+
+
+ +

Methods

+ + + + + + +

get_deut_diff(timepoint)

deuterium difference between two peptides at a specific timepoint

+
+ +
+
+

pigeon_feather.HDXStateResidueCompares

+
+
+class pigeon_feather.data.HDXStateResidueCompares(resids, state1_list, state2_list)
+
+
+__init__(resids, state1_list, state2_list)
+

A class to compare pseudo residues between two states.

+
+
Parameters:
+
    +

  • resids – a list of residue numbers

    • +

  • state1_list – a list of ProteinState objects

    • +

  • state2_list – a list of ProteinState objects

    • +
+
+
+
+ +

Methods

+ + + + + + + + + +

add_all_compare()

add all possible residue compares between two states

get_residue_compare(resid)

return a residue compare by residue number

+
+ +
+
+

pigeon_feather.ResidueCompare

+
+
+class pigeon_feather.data.ResidueCompare(resid, state1_list, state2_list)
+
+
+__init__(resid, state1_list, state2_list)
+

A class to compare one pseudo residue between two states.

+
+
Parameters:
+
    +

  • resid – residue number, 1-based

    • +

  • state1_list – a list of ProteinState objects

    • +

  • state2_list – a list of ProteinState objects

    • +
+
+
+
+ +

Methods

+ + + + + + + + + +

find_peptides_containing_res(state_list)

find peptides containing the residue in a state list

get_deut_diff(timepoint)

deuterium difference between two residues at a specific timepoint

+
+ +
+
+

pigeon_feather.SimulatedData

+
+
+class pigeon_feather.data.SimulatedData(length=100, seed=42, noise_level=0, saturation=1.0, random_backexchange=False)
+
+
+__init__(length=100, seed=42, noise_level=0, saturation=1.0, random_backexchange=False)
+

A class to generate simulated HDX-MS data.

+
+
Parameters:
+
    +

  • length – protein length, defaults to 100

    • +

  • seed – random seeds, defaults to 42

    • +

  • noise_level – noise add to the isotopic envelope

    • +
+
+
+
+ +

Methods

+ + + + + + + + + + + + + + + + + + + + + + + + +

gen_seq()

generate a random protein sequence of the given length

gen_logP()

generate a random logP values for each residue in the sequence

cal_k_init()

calculate intrinsic exchange rate for each residue

cal_k_ex()

calculate exchange rate for each residue

calculate_incorporation()

calculate deuterium incorporation for each residue

gen_peptides([min_len, max_len, ...])

generate random peptides from the protein sequence

convert_to_hdxms_data()

convert the simulated data to a HDXMSData object

+
+ +
+
+

pigeon_feather.plot.UptakePlotsCollection

+
+
+class pigeon_feather.plot.UptakePlotsCollection(color_dict=None, if_plot_fit=True, pdb_file=None)
+
+
+__init__(color_dict=None, if_plot_fit=True, pdb_file=None)
+

A class to store multiple UptakePlot objects

+
+
Parameters:
+
    +

  • color_dict – a dictionary of colors for each state, e.g. {‘state1’: ‘red’, ‘state2’: ‘blue’}

    • +

  • if_plot_fit – if True, plot the fit line

    • +
+
+
+
+ +

Methods

+ + + + + + + + + + + + +

add_plot(hdxms_datas, idf[, ...])

add a UptakePlot of a peptide to the collection

add_plot_all(hdxms_datas)

add UptakePlot objects of all peptides to the collection

save_plots(path)

save all plots to a folder

+
+ +
+
+

pigeon_feather.plot.UptakePlot

+
+
+class pigeon_feather.plot.UptakePlot(hdxms_datas, identifier: str, states_subset=None, color_dict=None, if_plot_fit=True, figure=None, ax=None, if_d_percent=False, exp_only=False)
+
+
+__init__(hdxms_datas, identifier: str, states_subset=None, color_dict=None, if_plot_fit=True, figure=None, ax=None, if_d_percent=False, exp_only=False)
+

hdxms_datas: list of class HDXMSData objects

+
+
Parameters:
+
    +

  • hdxms_datas – list of HDXMSData objects

    • +

  • identifier – peptide identifier

    • +

  • states_subset – list of states to plot

    • +

  • color_dict – dictionary of colors for each state

    • +

  • if_plot_fit – if True, plot the fit line

    • +

  • figure – figure object

    • +

  • ax – axis object

    • +
+
+
Variables:
+

hdxms_datas_df – pandas DataFrame of the HDX-MS data of the peptide

+
+
+
+ +

Methods

+ + + + + + + + + + + + + + + +

make_uptakeplot()

make a uptakeplot for a peptide

get_average_peptide(state_name)

return an averaged peptide for a state

make_title()

make a title for the plot

make_color_dict([color_dict])

make a color dictionary for the states in the plot

+
+ +
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/documentation.html b/documentation.html new file mode 100644 index 0000000..765dbb5 --- /dev/null +++ b/documentation.html @@ -0,0 +1,128 @@ + + + + + + + Documentation — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Documentation

+
+ +
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/feather.html b/feather.html new file mode 100644 index 0000000..c195b19 --- /dev/null +++ b/feather.html @@ -0,0 +1,166 @@ + + + + + + + FEATHER — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

FEATHER

+

FEATHER (Free Energy Assignment Through Hydrogen Exchange Rates) is a +is a Bayesian method that combines peptide subtraction, isotopic mass +envelope reconstruction, and Monte Carlo (MC) sampling to assign PFs for each individual residue.

+
+FEATHER +
+
+

classes

+
+ +
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/genindex.html b/genindex.html new file mode 100644 index 0000000..52ce69a --- /dev/null +++ b/genindex.html @@ -0,0 +1,223 @@ + + + + + + Index — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Index
    • +
  • +
    • +
+
+
+
+
+ + +

Index

+ +
+ _ + | H + | P + | R + | S + | T + | U + +
+

_

+ + +
+ +

H

+ + + +
+ +

P

+ + + +
+ +

R

+ + + +
+ +

S

+ + +
+ +

T

+ + +
+ +

U

+ + + +
+ + + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/hdx.html b/hdx.html new file mode 100644 index 0000000..9bae1e6 --- /dev/null +++ b/hdx.html @@ -0,0 +1,136 @@ + + + + + + + HDX/MS — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

HDX/MS

+

Hydrogen exchange with mass spectrometry (HX/MS) measures +the rate of exchange of labile hydrogen atoms with deuterium +in a protein’s backbone amide groups to report on structural +changes in protein ensembles but at the peptide level, not individual amino acids. +With the advent of integrated robotics for automated sample preparation +and accurate protein structure prediction methods +for improved data interpretation, HX/MS is an increasingly +powerful method for probing solution-state protein ensembles. +However, the technique is not used to its full potential due to +its peptide resolution.

+

To address this problem, we developed PIGEON-FEATHER (Peptide ID Generation +for Exchange Of Nuclei-Free Energy Assignment Through Hydrogen Exchange Rates): +an HX/MS analysis method to calculate the absolute free energy of opening (∆Gop) +for almost all the amino acids in a protein ensemble.

+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/index.html b/index.html new file mode 100644 index 0000000..2759c22 --- /dev/null +++ b/index.html @@ -0,0 +1,156 @@ + + + + + + + Welcome to PIGEON-FEATHER’s documentation! — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Welcome to PIGEON-FEATHER’s documentation!

+
+PIGEON-FEATHER +
+

PIGEON-FEATHER (Peptide ID Generation for Exchange Of Nuclei-Free +Energy Assignment Through Hydrogen Exchange Rates): a method +for calculating free energies of opening (∆Gop) at single- or +near-single-amino acid resolution for protein ensembles of all +sizes from hydrogen exchange/mass spectrometry (HX/MS) data.

+
+ +
+
+

Indices and tables

+ +
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/installation.html b/installation.html new file mode 100644 index 0000000..b364724 --- /dev/null +++ b/installation.html @@ -0,0 +1,164 @@ + + + + + + + Installation — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

Installation

+
+

Conda

+
# install mamba
+wget "https://github.com/conda-forge/miniforge/releases/latest/download/Mambaforge-$(uname)-$(uname -m).sh"
+bash Mambaforge-$(uname)-$(uname -m).sh
+
+# create a conda environment and install the required packages
+conda create --name pigeon_feather python=3.11
+conda activate pigeon_feather
+
+conda install jupyterlab mdanalysis numba
+conda install pymol-open-source
+
+pip install pyopenms hdxrate
+
+# clone the PIGEON-FEATHER repo
+git clone https://github.com/glasgowlab/PIGEON-FEATHER.git
+
+# clone the bayesian hdx iso repo
+git clone https://github.com/lucl13/bayesian_hdx.git
+
+cd PIGEON-FEATHER
+pip install .
+
+cd ../bayesian_hdx
+pip install .
+
+
+
+
+

Docker

+
docker build -f docker/Dockerfile -t pigeon_feather:0.9 .
+docker run -it -v $(pwd):/work -p 8889:8889 --rm pigeon_feather:0.9 jupyter-lab --port 8889
+
+
+

To open the Jupyter notebook, please click the link displayed in the terminal. +For users operating on Apple Silicon machines, it may be necessary to append +–platform amd64 when building the image, as pyopenms is not supported on +the linux/arm64 architecture. It is advisable to avoid running the Docker container +on Apple Silicon machines due to the significant performance degradation +caused by the emulation of the x86_64 architecture.

+

Note: bayesian_hdx at the above link is a fork of the original repo , +which has been modified for compatibility with the PIGEON-FEATHER workflow and support for isotopic envelope fitting.

+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/objects.inv b/objects.inv new file mode 100644 index 0000000..96baa47 Binary files /dev/null and b/objects.inv differ diff --git a/pigeon.html b/pigeon.html new file mode 100644 index 0000000..e4ad87c --- /dev/null +++ b/pigeon.html @@ -0,0 +1,193 @@ + + + + + + + PIGEON — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

PIGEON

+

pigeon is a stand-only program that takes in a list of peptide pool csv +and outputs a cleaned csv of pooled data. It also outputs a rangeslist table for merge in FEATHER.

+
+

CMD Options

+

Type pigeon --help to see the following options:

+
+
--t, --table: Path(s) to input csv. Required
+
--o, --out: path to output csv, if any.
+
--p, --plots: directory for output plots. Default: ‘./csvplots’
+
--ov, --overlap: flag specifying how to treat overlapping duplicates. Options: ‘keep’, ‘drop’, ‘select’ (or any other). Default: ‘select’
+
--r, --rangeslist: path to output rangeslist, if any.
+
--RTC: RT cutoff for duplicate peptides. Default: 0.5
+
--MZC: m/z cutoff for duplicate peptides. Default: 0.1
+
--scoreC: Score threshold for provisional cut for trendline fit. Default: 150
+
--ppmC: m/z deviation cutoff (in ppm) for cut about trendline. Default: 7
+
--maxfev: maxfev for curve_fit for trendline.
+
+

Default inputs

+
+
--t (list of peptide pool csvs)
+
+

Default outputs

+
+
--o (batched and cleaned peptide pool csv)
+
--r (rangeslist table for merge in post-PIGEON)
+
+

In the plot directory, the following files are generated:

+

score histograms:

+
+
+
hist-scores-all.png: Histogram of score for all pooled data.
+
hist-scores-cut.png: Histogram of score for high scoring data used for curve fit.
+
hist-scores-ppm.png: Histogram of score after cut at ppmC from trendline.
+
hist-scores-topscores.png: Histogram of score after dropping all but best match for each charge state.
+
hist-scores-flagged.png: Histogram of score for non-overlapping duplicates.
+
hist-scores-yellow.png: Histogram of score for overlapping duplicates.
+
hist-scores-clean.png: Histogram of score for final cleaned data.
+
+
+

scatterplots:

+
+
+
scatter-30ppm.png: All data before cuts, ppm m/z deviation vs m/z measured, colorbar Score.
+
scatter-hscoring.png: High scoring data used for curve fit.
+
scatter-7ppm.png: All data after cut at ppmC from trendline.
+
scatter-topscore.png: Data after dropping all but best match for each charge state.
+
scatter-flagged.png: Data dropped for being duplicates, non-overlapping.
+
scatter-yellow.png: Data dropped for being duplicates, overlapping.
+
scatter-clean.png: Final cleaned data.
+
+
+

ppm histogram:

+
+

hist-ppms.png: Histogram of abs(distance from trendline) for all data, showing location of cut.

+
+
+
+

Example Usage

+

Below are examples of how to use the pigeon program with various arguments:

+
pigeon --t pool-1.csv pool-2.csv pool-3.csv --p csvplots --ov keep --o keep-pooled.csv --r rangeslist.csv --MZC 0.05 --RTC 0.25 --scoreC 200 --ppmC 5 --maxfev 2000
+
+
+

Alternative usage example:

+
pigeon --t pool-1.csv --o select-pooled.csv --r rangeslist.csv
+
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/search.html b/search.html new file mode 100644 index 0000000..831c28e --- /dev/null +++ b/search.html @@ -0,0 +1,127 @@ + + + + + + Search — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+
    +
    • +
  • Search
    • +
  • +
    • +
+
+
+
+
+ + + + +
+ +
+ +
+
+ +
+
+
+
+ + + + + + + + + \ No newline at end of file diff --git a/searchindex.js b/searchindex.js new file mode 100644 index 0000000..9d825b9 --- /dev/null +++ b/searchindex.js @@ -0,0 +1 @@ +Search.setIndex({"alltitles": {"00_Showcase ecDHFR: a FEATHER walkthrough": [[8, null]], "01_load_data": [[9, null]], "02_peptide_level_analysis": [[10, null]], "03_calculate_PFs": [[11, null]], "04_check_the_fitting": [[12, null]], "05_plot_the_results": [[13, null]], "Analysis": [[8, "Analysis"]], "CMD Options": [[6, "cmd-options"]], "Conda": [[5, "conda"]], "Docker": [[5, "docker"]], "Documentation": [[1, null]], "Example Usage": [[6, "example-usage"]], "FEATHER": [[2, null]], "Fitting check": [[8, "Fitting-check"]], "HDX/MS": [[3, null]], "Indices and tables": [[4, "indices-and-tables"]], "Installation": [[5, null]], "Load the raw spectrum": [[9, "Load-the-raw-spectrum"]], "PIGEON": [[6, null]], "Read the centroid data": [[9, "Read-the-centroid-data"]], "Tutorials": [[7, null]], "Welcome to PIGEON-FEATHER\u2019s documentation!": [[4, null]], "back exchange correction": [[8, "back-exchange-correction"]], "barplot of the kex": [[8, "barplot-of-the-kex"], [13, "barplot-of-the-kex"]], "classes": [[2, "classes"]], "delta log(PF)s": [[13, "delta-log(PF)s"]], "envelope check": [[8, "envelope-check"], [12, "envelope-check"]], "import": [[8, "import"]], "inputs for MCMC sampling": [[8, "inputs-for-MCMC-sampling"], [11, "inputs-for-MCMC-sampling"]], "load the data": [[8, "load-the-data"]], "peptide subtraction": [[8, "peptide-subtraction"], [11, "peptide-subtraction"]], "pigeon_feather.HDXStatePeptideCompares": [[0, "pigeon-feather-hdxstatepeptidecompares"]], "pigeon_feather.HDXStateResidueCompares": [[0, "pigeon-feather-hdxstateresiduecompares"]], "pigeon_feather.PeptideCompare": [[0, "pigeon-feather-peptidecompare"]], "pigeon_feather.ResidueCompare": [[0, "pigeon-feather-residuecompare"]], "pigeon_feather.SimulatedData": [[0, "pigeon-feather-simulateddata"]], "pigeon_feather.data.HDXMSData": [[0, "pigeon-feather-data-hdxmsdata"]], "pigeon_feather.data.HDXMSDataCollection": [[0, "pigeon-feather-data-hdxmsdatacollection"]], "pigeon_feather.data.Peptide": [[0, "pigeon-feather-data-peptide"]], "pigeon_feather.data.ProteinState": [[0, "pigeon-feather-data-proteinstate"]], "pigeon_feather.data.RangeList": [[0, null]], "pigeon_feather.data.Timepoint": [[0, "pigeon-feather-data-timepoint"]], "pigeon_feather.plot.UptakePlot": [[0, "pigeon-feather-plot-uptakeplot"]], "pigeon_feather.plot.UptakePlotsCollection": [[0, "pigeon-feather-plot-uptakeplotscollection"]], "pipetide comparison": [[10, "pipetide-comparison"]], "plot uptake plots": [[8, "plot-uptake-plots"]], "pseudo residue compare": [[10, "pseudo-residue-compare"]], "run the sampling": [[8, "run-the-sampling"]], "two priors": [[11, "two-priors"]], "uptake check": [[8, "uptake-check"], [12, "uptake-check"]], "uptake plots": [[10, "uptake-plots"]], "visualization on pymol structure": [[10, "visualization-on-pymol-structure"]]}, "docnames": ["classes", "documentation", "feather", "hdx", "index", "installation", "pigeon", "tutorial", "tutorials/00_ecdhfr_showcase", "tutorials/01_load_data", "tutorials/02_peptide_level_analysis", "tutorials/03_calculate_PFs", "tutorials/04_check_the_fitting", "tutorials/05_plot_the_results"], "envversion": {"nbsphinx": 4, "sphinx": 62, "sphinx.domains.c": 3, "sphinx.domains.changeset": 1, "sphinx.domains.citation": 1, "sphinx.domains.cpp": 9, "sphinx.domains.index": 1, "sphinx.domains.javascript": 3, "sphinx.domains.math": 2, "sphinx.domains.python": 4, "sphinx.domains.rst": 2, "sphinx.domains.std": 2}, "filenames": ["classes.rst", "documentation.rst", "feather.rst", "hdx.rst", "index.rst", "installation.rst", "pigeon.rst", "tutorial.rst", "tutorials/00_ecdhfr_showcase.ipynb", "tutorials/01_load_data.ipynb", "tutorials/02_peptide_level_analysis.ipynb", "tutorials/03_calculate_PFs.ipynb", "tutorials/04_check_the_fitting.ipynb", "tutorials/05_plot_the_results.ipynb"], "indexentries": {"__init__() (pigeon_feather.data.hdxmsdata method)": [[0, "pigeon_feather.data.HDXMSData.__init__", false]], "__init__() (pigeon_feather.data.hdxmsdatacollection method)": [[0, "pigeon_feather.data.HDXMSDataCollection.__init__", false]], "__init__() (pigeon_feather.data.hdxstatepeptidecompares method)": [[0, "pigeon_feather.data.HDXStatePeptideCompares.__init__", false]], "__init__() (pigeon_feather.data.hdxstateresiduecompares method)": [[0, "pigeon_feather.data.HDXStateResidueCompares.__init__", false]], "__init__() (pigeon_feather.data.peptide method)": [[0, "pigeon_feather.data.Peptide.__init__", false]], "__init__() (pigeon_feather.data.peptidecompare method)": [[0, "pigeon_feather.data.PeptideCompare.__init__", false]], "__init__() (pigeon_feather.data.proteinstate method)": [[0, "pigeon_feather.data.ProteinState.__init__", false]], "__init__() (pigeon_feather.data.rangelist method)": [[0, "pigeon_feather.data.RangeList.__init__", false]], "__init__() (pigeon_feather.data.residuecompare method)": [[0, "pigeon_feather.data.ResidueCompare.__init__", false]], "__init__() (pigeon_feather.data.simulateddata method)": [[0, "pigeon_feather.data.SimulatedData.__init__", false]], "__init__() (pigeon_feather.data.timepoint method)": [[0, "pigeon_feather.data.Timepoint.__init__", false]], "__init__() (pigeon_feather.plot.uptakeplot method)": [[0, "pigeon_feather.plot.UptakePlot.__init__", false]], "__init__() (pigeon_feather.plot.uptakeplotscollection method)": [[0, "pigeon_feather.plot.UptakePlotsCollection.__init__", false]], "hdxmsdata (class in pigeon_feather.data)": [[0, "pigeon_feather.data.HDXMSData", false]], "hdxmsdatacollection (class in pigeon_feather.data)": [[0, "pigeon_feather.data.HDXMSDataCollection", false]], "hdxstatepeptidecompares (class in pigeon_feather.data)": [[0, "pigeon_feather.data.HDXStatePeptideCompares", false]], "hdxstateresiduecompares (class in pigeon_feather.data)": [[0, "pigeon_feather.data.HDXStateResidueCompares", false]], "peptide (class in pigeon_feather.data)": [[0, "pigeon_feather.data.Peptide", false]], "peptidecompare (class in pigeon_feather.data)": [[0, "pigeon_feather.data.PeptideCompare", false]], "proteinstate (class in pigeon_feather.data)": [[0, "pigeon_feather.data.ProteinState", false]], "rangelist (class in pigeon_feather.data)": [[0, "pigeon_feather.data.RangeList", false]], "residuecompare (class in pigeon_feather.data)": [[0, "pigeon_feather.data.ResidueCompare", false]], "simulateddata (class in pigeon_feather.data)": [[0, "pigeon_feather.data.SimulatedData", false]], "timepoint (class in pigeon_feather.data)": [[0, "pigeon_feather.data.Timepoint", false]], "uptakeplot (class in pigeon_feather.plot)": [[0, "pigeon_feather.plot.UptakePlot", false]], "uptakeplotscollection (class in pigeon_feather.plot)": [[0, "pigeon_feather.plot.UptakePlotsCollection", false]]}, "objects": {"pigeon_feather.data": [[0, 0, 1, "", "HDXMSData"], [0, 0, 1, "", "HDXMSDataCollection"], [0, 0, 1, "", "HDXStatePeptideCompares"], [0, 0, 1, "", "HDXStateResidueCompares"], [0, 0, 1, "", "Peptide"], [0, 0, 1, "", "PeptideCompare"], [0, 0, 1, "", "ProteinState"], [0, 0, 1, "", "RangeList"], [0, 0, 1, "", "ResidueCompare"], [0, 0, 1, "", "SimulatedData"], [0, 0, 1, "", "Timepoint"]], "pigeon_feather.data.HDXMSData": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.HDXMSDataCollection": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.HDXStatePeptideCompares": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.HDXStateResidueCompares": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.Peptide": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.PeptideCompare": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.ProteinState": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.RangeList": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.ResidueCompare": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.SimulatedData": [[0, 1, 1, "", "__init__"]], "pigeon_feather.data.Timepoint": [[0, 1, 1, "", "__init__"]], "pigeon_feather.plot": [[0, 0, 1, "", "UptakePlot"], [0, 0, 1, "", "UptakePlotsCollection"]], "pigeon_feather.plot.UptakePlot": [[0, 1, 1, "", "__init__"]], "pigeon_feather.plot.UptakePlotsCollection": [[0, 1, 1, "", "__init__"]]}, "objnames": {"0": ["py", "class", "Python class"], "1": ["py", "method", "Python method"]}, "objtypes": {"0": "py:class", "1": "py:method"}, "terms": {"": [3, 6, 8, 9, 10, 12], "0": [0, 5, 6, 8, 9, 10, 11, 12, 13], "00144033": 8, "00_showcas": [4, 7], "01": 10, "01_load_data": [4, 7], "02645062": 8, "02_peptide_level_analysi": [4, 7], "03_calculate_pf": [4, 7], "045": 10, "04_check_the_fit": [4, 7], "05": [6, 10], "05146091": 8, "05_plot_the_result": [4, 7], "06": 10, "07647119": 8, "08": [8, 13], "09": 10, "0x7f095a02d150": 8, "0x7f6ccdb68fd0": 8, "1": [0, 6, 8, 9, 10, 11, 12, 13], "10": [0, 8, 10, 11, 12, 13], "100": [0, 8, 10], "1000": [8, 13], "10148148": 8, "11": [5, 8, 10, 11, 12], "117": [8, 11], "12": [8, 10, 11, 12, 13], "126": 8, "127": 11, "13": [8, 10, 11, 12], "14": [8, 9, 10], "15": [8, 10, 13], "150": 6, "16": [8, 10], "17": [8, 10, 13], "174": [8, 9], "18": [8, 10], "18086398727111275": 8, "18336607065124264": 12, "186": 8, "19": [8, 10], "1e1": [8, 10, 12], "1e5": [8, 10, 12], "1rg7_mtx_relaxed_best_solv": [8, 11], "2": [0, 6, 8, 9, 10, 11, 12, 13], "20": [8, 10, 12, 13], "200": [6, 8, 12, 13], "2000": 6, "2011": [8, 9, 10], "20240722": [8, 9, 10, 11, 12, 13], "21": [8, 10], "22": [8, 10, 13], "23": [8, 10], "24": [8, 10, 13], "25": [6, 8, 10], "250": [8, 10, 12], "26": [8, 9, 10], "261": 9, "27": [8, 9, 10], "28": [8, 10], "29": [8, 10], "293": [8, 11, 12, 13], "3": [5, 6, 8, 9, 10, 11, 12, 13], "30": [8, 10], "300": [8, 12], "30811": [8, 9], "30812": 10, "30ppm": 6, "31": [8, 10], "3145": [8, 13], "32": 8, "320": 10, "325": 10, "32666667": 10, "33": 8, "34": 10, "35": [8, 10, 13], "358": [8, 10, 11, 12, 13], "36": [8, 10], "3646019382844139": 8, "3669856716168908": 12, "37": 10, "373": [8, 9], "374": 10, "38": [8, 10], "38333333": 10, "39": [8, 9, 10, 12], "39142857": 10, "39348193324578395": 8, "39744791298433696": 12, "4": [8, 9, 10, 11, 12, 13], "40": [8, 13], "41": 10, "42": [0, 8, 10], "43292": [8, 9, 10], "44": 10, "45": 10, "46": [8, 9, 10], "4682b4": [8, 12], "47": 10, "475": 10, "47714286": 10, "48": 10, "5": [6, 8, 9, 10, 12, 13], "50": 10, "50166667": 10, "51": 10, "52": 10, "53": 10, "53b1b1": [8, 12], "54": 10, "55857143": 10, "57": 10, "572": [8, 9, 10], "59": 10, "5dfr_apo_relaxed_best_solv": [8, 11], "6": [8, 9, 10, 12, 13], "60127572": 8, "60333333": 10, "61": 10, "62628601": 8, "64": 10, "65": 10, "6512963": 8, "67630658": 8, "68": 10, "69571429": 10, "6xg5_apo_deltag": [8, 13], "6xg5_apo_relaxed_best_solv": [8, 13], "6xg5_deltag_apo": [8, 13], "6xg5_tri": [8, 10, 12, 13], "6xg5_tri_relaxed_best_solv": [8, 11], "7": [6, 8, 9, 10, 11, 12, 13], "70": [8, 9], "70131687": 8, "72632716": 8, "73": 10, "74": 10, "75": [8, 10, 12], "75133745": 8, "75428571": 10, "76": 10, "77": 10, "77634774": 8, "7772": [8, 9, 10], "78": [8, 12], "79": 10, "79666667": 10, "7ppm": 6, "8": [8, 9, 10, 12, 13], "80135802": 8, "80833333": 10, "82636831": 8, "83": 10, "84": 10, "8513786": 8, "85666667": 10, "87": 10, "87638889": 8, "87666667": 10, "88": 10, "8889": 5, "89": 10, "9": [5, 8, 9, 10, 11, 12, 13], "90139918": 8, "90428571": 10, "92": [8, 12], "92640947": 8, "93": 8, "95141975": 8, "95571429": 10, "97": 9, "97643004": 8, "98166667": 10, "A": [0, 8, 9, 12], "For": 5, "If": 12, "In": [6, 9, 12, 13], "It": [0, 5, 6, 10], "Of": [3, 4], "One": 9, "The": [8, 9, 11, 12, 13], "There": 9, "To": [3, 5], "With": 3, "_": [8, 12, 13], "__init__": 0, "_apo": [8, 13], "_chunk": [8, 11], "_tri": [8, 13], "ab": 6, "abcdefghij": 0, "about": 6, "abov": [5, 8], "absolut": 3, "accept": 9, "accur": 3, "acid": [3, 4], "activ": 5, "ad": [0, 8, 11], "add": [0, 10], "add_all_compar": 10, "add_all_subtract": [8, 11], "add_new_peptides_by_subtract": [8, 11], "address": 3, "adjust": [8, 10, 12], "advent": 3, "advis": 5, "ae": [8, 12], "after": 6, "again": 8, "agre": [8, 12], "alavd": 10, "alavdr": 10, "alavdrvigm": 10, "all": [3, 4, 6, 8, 10], "all_idf": [8, 10, 12], "all_idfs_subset": [8, 10], "all_pep": [8, 10, 12], "all_peps_group": [8, 12], "all_peptid": 10, "all_tp": [8, 10, 12], "almost": 3, "alpha": [8, 13], "also": [6, 8, 12], "alter": [8, 12, 13], "altern": 6, "amd64": 5, "amid": 3, "amino": [3, 4], "an": [3, 8, 9, 12, 13], "ana_apo_1": [8, 12, 13], "ana_obj": [8, 13], "ana_tri_1": [8, 12, 13], "analysi": [3, 10, 12, 13], "ani": [6, 9], "apo": [8, 9, 10, 11, 12, 13], "apo_st": [8, 12, 13], "append": [5, 8, 9, 10, 12], "appl": 5, "ar": [6, 8, 9, 10, 12, 13], "architectur": 5, "argument": 6, "arial": [8, 10], "arm64": 5, "arrai": [8, 12], "artist": 8, "assign": [2, 3, 4], "atom": 3, "attribut": 0, "autom": 3, "automat": [12, 13], "automaticali": 8, "avail": [8, 12], "availbl": [8, 13], "averag": [8, 9, 10], "average_peptid": [8, 12], "avg_dg": [8, 13], "avg_logp": [8, 13], "avg_pep": [8, 12], "avoid": 5, "ax": [0, 8, 10, 12, 13], "axhlin": [8, 10, 12], "axi": 0, "b": 13, "back": [9, 10, 11, 12, 13], "backbon": 3, "backexchang": [8, 9], "backexchange_correct": [8, 10, 11, 12, 13], "bad": 8, "barcontain": 8, "bare": [8, 12], "base": [0, 8, 9, 10, 11, 12, 13], "base_directori": [8, 11], "bash": 5, "basic": 9, "batch": 6, "bayesian": [2, 5, 8, 11], "bayesian_hdx": 5, "bayesian_hdx_data_fold": [8, 12, 13], "bayesian_hdx_input_": 8, "bayesian_hdx_input_20240722": [8, 11], "bayesian_hdx_output_chunk": [8, 12, 13], "been": [0, 5], "befor": 6, "being": 6, "belong": 0, "below": 6, "best": [6, 8, 10], "between": [0, 10], "bfactor_plot": [8, 13], "bfactorplot": [8, 13], "bin": [8, 12], "blue": [0, 8, 10, 12], "bold": [8, 10], "both": 10, "brown": [8, 10], "buffer": 9, "build": 5, "calcul": [3, 4, 8, 10, 12, 13], "can": [0, 8, 9, 10, 11, 12, 13], "cannot": 9, "carlo": 2, "caus": 5, "cd": [5, 8, 11], "ceil": [8, 10, 12], "cell": 8, "center": [8, 13], "centroid": [8, 12], "chang": 3, "charg": [0, 6, 9], "charge_st": 0, "check": [9, 10], "check_ana_obj": [8, 12], "check_fitted_isotope_envelop": [8, 12], "check_fitted_peptide_uptak": [8, 12], "check_state_nam": [8, 12], "chosen": [8, 12], "chunk": [8, 12, 13], "chunk_num": [8, 12, 13], "chunk_siz": [8, 12, 13], "class": [0, 8], "clean": [6, 8, 9], "click": 5, "clone": 5, "cloolect": 0, "closest": [8, 10, 11, 12, 13], "clustering_results_logp": [8, 13], "collect": 10, "color": [0, 8, 10, 12, 13], "color_1": [8, 12], "color_2": [8, 12], "color_dict": 0, "colorbar": 6, "colorbar_max": 10, "column": 0, "com": 5, "combin": [2, 10], "command": [8, 11, 13], "common": [9, 10], "common_timepoint": 10, "compar": 0, "compare_info": 10, "comparison": [8, 13], "compat": 5, "complementari": [8, 12], "concat": [8, 13], "conda": 4, "condit": [8, 12], "contain": [0, 5, 8, 11], "contribut": 9, "convert": [8, 9], "convert_aa_cod": [8, 13], "convert_dataframe_to_bayesianhdx_format": [8, 11], "correct": [9, 10, 11, 12, 13], "correspond": 9, "could": 9, "count": [8, 12], "cours": [8, 9], "cover": 10, "coverag": [8, 9, 13], "creat": [5, 8, 10, 12, 13], "create_compare_pymol_plot": 10, "create_heatmap_compar": 10, "create_heatmap_compare_tp": 10, "create_logp_df": [8, 13], "crucial": [8, 12, 13], "csv": [0, 6, 8, 9, 13], "csvplot": 6, "current": [8, 10, 12], "current_group": 10, "curv": 6, "curve_fit": 6, "custom": [8, 10], "customunpickl": 8, "cut": 6, "cutoff": 6, "d": [0, 8, 9, 10, 11, 12, 13], "d2o": 9, "da": [8, 12], "data": [2, 3, 4, 6, 10, 11, 12, 13], "databas": [8, 10, 11, 12, 13], "datafram": [0, 8, 13], "dataset": [8, 11, 12], "date": [8, 9, 10, 11, 12, 13], "datetim": [8, 9, 10, 11, 12, 13], "deconvolut": 9, "def": [8, 10, 12, 13], "default": [0, 6], "defin": 9, "degrad": 5, "delta": 8, "deltag": [8, 13], "deriv": [8, 13], "determin": [8, 10, 11, 12, 13], "deut_diff": 10, "deut_tim": [0, 8, 10, 12], "deuter": [0, 8, 9, 10, 11, 12, 13], "deuterium": [0, 3, 9], "develop": 3, "deviat": [0, 6], "df": [8, 11, 13], "df_apo": [8, 13], "df_i": [8, 13], "df_logpf": [8, 13], "df_tri": [8, 13], "dhfr_exp_uptake_": [8, 10], "dhfr_tutorial_dataset": [8, 11], "dictionari": 0, "differ": [0, 8, 10, 13], "directori": 6, "displai": 5, "distanc": 6, "do": [9, 12], "docker": 4, "dockerfil": 5, "done": [8, 9], "dot": [8, 12], "download": [5, 8], "drop": [6, 8, 13], "due": [3, 5, 8, 9], "dump": [8, 9, 11], "duplic": 6, "durat": [8, 11], "e": [0, 8, 12], "each": [0, 2, 6, 8, 11], "easili": 9, "ecdhfr": [4, 7], "ecdhfr_kex_bar_apo_tri_": [8, 13], "ecdhfr_results_": [8, 10, 11, 12, 13], "ecdhfr_tutori": [8, 9], "ecdhfr_uptake_errors_": [8, 12], "els": [8, 13], "empti": 10, "emul": 5, "enabl": 11, "end": 0, "energi": [2, 3, 4, 8, 13], "ensembl": [3, 4], "ensur": [9, 12], "enumer": [8, 10, 11, 12, 13], "envelop": [0, 2, 5], "envelope_error": [8, 12], "environ": 5, "error": [8, 9, 10, 12], "error_tupl": [8, 12], "ex": [8, 13], "exampl": [8, 12], "except": [8, 12], "exchang": [2, 3, 4, 9, 10, 11, 12, 13], "exclud": [0, 8, 9], "exist": [8, 10, 11, 12, 13], "exp_nam": [8, 11], "exp_onli": 0, "experi": [9, 10], "experiment": [8, 10, 11, 12, 13], "export": [8, 10, 13], "export_iso_fil": [8, 11], "extract_numb": [8, 12], "extreme_value_prior": [8, 11], "f": [5, 8, 9, 10, 11, 12, 13], "f6c624": [8, 12], "fail": [10, 11, 12, 13], "fals": [0, 8, 9, 10, 11, 12, 13], "famili": [8, 10], "fastamid": [0, 8, 11], "feather": [1, 3, 5, 6, 7, 9, 13], "fecth": [8, 13], "ff6347": [8, 12], "fig": [8, 10, 12, 13], "fig_index": [8, 10, 12], "figsiz": [8, 10, 12, 13], "figur": [0, 8, 10, 12], "file": [0, 6, 8, 9, 10, 11, 12, 13], "final": [6, 8], "find": 10, "find_class": 8, "findal": [8, 12], "first": [9, 10], "fit": [0, 5, 6, 12], "flag": 6, "folder": [8, 9, 10, 11, 12, 13], "follow": [6, 8, 11, 13], "font": [8, 10], "fontdict": [8, 13], "fontsiz": [8, 13], "forg": 5, "fork": 5, "format": [8, 12], "format_func": [8, 13], "formatstrformatt": [8, 10], "forward": 8, "found": 9, "fqsisl": 10, "free": [2, 3, 4], "from": [4, 6, 8, 9, 10, 11, 12, 13], "full": [3, 8, 10, 11, 12, 13], "fulld_approx": [8, 9], "funcformatt": [8, 13], "function": [8, 12, 13], "g": 0, "gener": [0, 3, 4, 6, 11], "generate_bayesian_hdx_script": [8, 11], "generate_extreme_value_prior": [8, 11], "generate_structural_prior": [8, 11], "get": 10, "get_all_statics_info": [8, 9], "get_index_offset": [8, 10, 12, 13], "get_legend_handles_label": [8, 10, 12], "get_res_avg_logp": [8, 13], "get_res_avg_logp_std": [8, 13], "get_residue_by_resindex": [8, 13], "get_stat": 10, "get_timepoint": [8, 12], "get_xtick": [8, 13], "get_xticklabel": [8, 13], "get_ylim": [8, 12], "git": 5, "github": 5, "glasgowlab": 5, "gop": [3, 4], "grab": 8, "grai": [8, 10, 12, 13], "green": [8, 10], "green_white_magenta": 13, "grey20": 13, "group": [3, 8, 10, 12], "group_by_attribut": [8, 12], "gt": 8, "ha": [5, 8, 13], "handl": [0, 8, 10, 12], "happen": 10, "have": 0, "hdx": [0, 1, 4, 5, 8, 9], "hdxm": [8, 9], "hdxms_data": [0, 8, 9, 10], "hdxms_data_list": [0, 8, 9, 10, 11, 12, 13], "hdxms_data_raw_": [8, 9, 10, 11, 12, 13], "hdxms_datas_df": 0, "hdxmsdata": [2, 8], "hdxmsdatacollect": 2, "hdxrate": 5, "hdxstatepeptidecompar": [2, 10], "hdxstateresiduecompar": [2, 10], "heatmap": 10, "heatmap_compar": 10, "heatmap_compare_tp": 10, "help": [6, 8], "helper": [12, 13], "here": 10, "high": [6, 8, 9], "hist": [6, 8, 12], "histogram": 6, "histplot": [8, 12], "hour": [8, 11], "how": 6, "howev": 3, "hscore": 6, "hspace": [8, 13], "http": 5, "hx": [3, 4, 8, 9, 13], "hxio": [8, 9, 10, 11, 12, 13], "hydrogen": [2, 3, 4], "i": [2, 3, 5, 6, 8, 9, 10, 11, 12, 13], "id": [3, 4], "identif": 0, "identifi": [0, 8, 10, 12], "idf": [8, 10, 12], "idf_end": [8, 12], "idf_pep": [8, 12], "idf_seq": [8, 12], "idf_start": [8, 12], "idf_to_pep": [8, 10], "if_d_perc": 0, "if_plot": [8, 12], "if_plot_fit": [0, 8, 10], "if_single_residu": [8, 13], "if_subtract": 0, "ii": [8, 13], "imag": 5, "import": [9, 10, 11, 12, 13], "improv": 3, "includ": [0, 8, 9], "incorpor": 0, "increasingli": 3, "index": [4, 8, 13], "index_offset": [8, 12, 13], "individu": [2, 3], "inf": [8, 10, 12], "inform": [8, 12], "input": [6, 9, 12, 13], "instal": 4, "instris": 8, "int": [0, 8, 10, 12, 13], "integ": 10, "integr": 3, "interpret": 3, "intrins": [12, 13], "iqr": [8, 9], "is_nan": [8, 13], "isdigit": [8, 12], "iso": 5, "isotop": [0, 2, 5, 8, 11, 12], "item": 10, "itertool": 10, "its": [3, 8, 10, 11, 12, 13], "join": 8, "jupyt": 5, "jupyterlab": 5, "k": [8, 10, 13], "kde": [8, 12], "keep": 6, "kei": [8, 10, 12], "kj": [8, 13], "lab": 5, "label": [8, 10, 12, 13], "labels": [8, 10], "labil": 3, "lambda": [8, 10, 12], "last": 10, "later": [8, 11], "latest": 5, "layout": [8, 10, 12], "left": [8, 13], "legend": [8, 10, 12, 13], "len": [8, 9, 10, 11, 12, 13], "length": [0, 8, 9, 12], "less": 10, "let": 10, "level": [3, 8, 10, 12], "lib": [8, 13], "light": [8, 12], "lightgrai": [8, 10, 12], "line": [0, 8, 10, 12], "linestyl": [8, 10, 12, 13], "linewidth": [8, 10, 12], "link": [5, 8], "linux": 5, "list": [0, 6, 8, 9, 10, 11, 12], "load": [10, 11, 12, 13], "load_bayesian_hdx_oupt_chunk": [8, 12, 13], "load_dataframe_to_hdxmsdata": [8, 9], "load_raw_ms_to_hdxms_data": [8, 9], "loc": [8, 10, 13], "local": [8, 13], "locat": 6, "log": 8, "logloc": [8, 10, 12], "logp": [8, 13], "logp_apo_": [8, 13], "logp_apo_tri_": [8, 13], "logp_threshold": [8, 13], "logpf": [8, 13], "logpf_to_deltag": [8, 13], "lot": [8, 12], "lower": [8, 13], "lt": 8, "lucl13": 5, "lw": [8, 10, 13], "lyfqsisl": 10, "m": [0, 1, 4, 5, 6, 8, 9, 10, 11, 12, 13], "machin": 5, "mai": [5, 8, 12], "make": [8, 10, 11, 12, 13], "makedir": [8, 10, 11, 12, 13], "making_chunk": [8, 11], "mamba": 5, "mambaforg": 5, "map": [8, 10, 12, 13], "mass": [2, 3, 4, 8, 9, 12], "match": [6, 8, 10, 11, 12, 13], "math": [8, 10, 12], "matplotlib": [8, 10, 12, 13], "max": [8, 12, 13], "max_d": [8, 10, 11, 12, 13], "maxfev": 6, "maximum": 13, "mc": 2, "mdanalysi": [5, 8, 13], "measur": [3, 6, 10, 11, 12, 13], "memori": [10, 11, 12, 13], "memoryleak": [10, 11, 12, 13], "merg": [6, 8, 13], "method": [0, 2, 3, 4], "might": 12, "min_pep": [8, 13], "mini": 8, "mini_pep": [8, 13], "miniforg": 5, "minimum": 13, "miss": [8, 9], "mline": [8, 10], "modifi": 5, "modul": [4, 8], "mol": [8, 13], "mont": 2, "move": 8, "mtghhhhhhenlyfqsisliaalavdrvigmenampwnlpadlawfkrntldkpvimgrhtwesigrplpgrkniilssqpgtddrvtwvksvdeaiaacgdvpeimvigggrvyeqflpkaqklylthidaevegdthfpdyepddwesvfsefhdadaqnshsycfeilerr": [8, 9, 11], "mtx": [8, 11], "multipl": 0, "multipleloc": [8, 10, 13], "mutipl": [8, 13], "mzc": 6, "n": [8, 9, 12, 13], "n_fastamid": [0, 8, 9], "name": [0, 5, 8, 9], "nan": [8, 13], "nanmean": [8, 12], "nanmedian": [8, 12], "necessari": 5, "need": [8, 10, 12], "neighbor": 12, "neighbour": 8, "never": [10, 11, 12, 13], "new": [8, 11], "new_handl": [8, 10, 12], "new_label": [8, 10, 12], "nois": 0, "noise_level": 0, "non": 6, "none": [0, 8, 10, 12], "normal": [8, 10], "note": [0, 5, 8, 9, 10, 12, 13], "notebook": [5, 10, 11, 12, 13], "np": [8, 9, 10, 11, 12, 13], "nuclei": [3, 4], "num_col": [8, 10, 12], "num_d": 0, "num_figur": [8, 10, 12], "num_subplots_per_figur": [8, 10, 12], "num_subtracted_ad": [0, 8, 11], "numba": 5, "number": [0, 8, 9, 10, 11, 12, 13], "numpi": [8, 9, 10, 11, 12, 13], "numtick": [8, 10, 12], "o": [6, 8, 9, 10, 11, 12, 13], "object": [0, 8, 9, 10, 12, 13], "offset": 10, "onc": 8, "one": [0, 8], "ones": 8, "onli": [6, 8, 10, 13], "open": [3, 4, 5, 8, 9, 10, 11, 12, 13], "oper": 5, "optimal_chunk": [8, 12, 13], "option": [8, 10], "orang": [8, 10], "origin": 5, "other": 6, "ourlit": 8, "out": 6, "out_path": [8, 10, 11, 12, 13], "outdir": [8, 11], "outlier": [8, 12], "outpath": [8, 11], "output": [6, 9], "ov": 6, "overlap": 6, "overwrit": [8, 11], "p": [5, 6], "packag": 5, "page": 4, "panda": [0, 8, 9, 10, 11, 12, 13], "param": [8, 13], "paramet": [0, 8, 12], "path": [6, 8, 10, 11, 12, 13], "pcikl": 8, "pd": [8, 9, 10, 11, 12, 13], "pdb": [8, 10, 11, 12, 13], "pdb_file": [0, 8, 10, 13], "pdf": [8, 10, 12, 13], "pep": [8, 10, 12], "pep_compr": 10, "peptid": [2, 3, 4, 6, 9, 10, 12, 13], "peptide1_list": 0, "peptide2_list": 0, "peptide_compar": 10, "peptide_data": [8, 12], "peptidecompar": 2, "percentag": 9, "perform": 5, "pf": 2, "pf_input_20240722": [10, 11, 12, 13], "ph": [8, 11, 12, 13], "pickl": [8, 9, 10, 11, 12, 13], "pigeon": [1, 3, 5], "pigeon_feath": [2, 5, 8, 9, 10, 11, 12, 13], "pip": 5, "pkl": [8, 9, 10, 11, 12, 13], "platform": [5, 10, 11, 12, 13], "pleas": [5, 9], "plot": [2, 6, 9, 11, 12, 13], "plot_deltag": [8, 13], "plot_kex_bar": [8, 13], "plt": [8, 10, 12, 13], "png": [6, 10], "point": [8, 9, 10, 11], "pool": [6, 9], "poor": 12, "port": 5, "possibl": 10, "post": 6, "potenti": 3, "power": 3, "ppm": 6, "ppmc": 6, "predict": 3, "prepar": 3, "previou": [10, 11, 12, 13], "principl": 9, "print": [8, 9, 10, 11, 12], "prior": 8, "probe": 3, "problem": 3, "proce": 12, "product": 10, "program": 6, "project": [8, 10, 13], "prolin": 13, "protein": [0, 3, 4, 8, 9], "protein_nam": [0, 8, 11], "protein_sequ": [0, 8, 9, 11, 12, 13], "protein_st": [0, 8, 9, 11, 12], "proteinst": [2, 8, 10], "provid": [8, 13], "provision": 6, "pse": 10, "pseudo": 0, "purpl": [8, 10], "pwd": 5, "py": [8, 11], "pymol": [5, 13], "pyopenm": 5, "pyplot": [8, 12, 13], "python": [5, 8, 11], "q": 10, "qsisl": 10, "qsisli": 10, "r": [6, 8, 10, 12], "rais": 0, "random": 0, "random_backexchang": 0, "rang": [8, 9, 10, 11, 12, 13], "range_df": 0, "range_list": 0, "range_list_fil": 0, "range_set": 0, "rangelist": 2, "rangeslist": [6, 8, 9], "rapid": 9, "rat": [8, 10], "rate": [2, 3, 4, 8, 12, 13], "ratio": [8, 9], "raw": [0, 8], "raw_end": 0, "raw_sequ": 0, "raw_spectra_path": [8, 9, 11], "raw_start": 0, "rb": [8, 9, 10, 11, 12, 13], "rc": [8, 10], "re": [8, 10, 12], "read": 8, "read_hdx_tabl": [8, 9], "readi": [8, 11], "reconstruct": 2, "red": [0, 8, 10, 13], "redund": [8, 9], "releas": 5, "remind": [8, 11], "remov": [8, 9, 12], "replic": [0, 8, 11, 12], "repo": 5, "report": 3, "requir": [5, 6], "rerun": 12, "rerun_num": [8, 11], "res_compar": 10, "res_i": [8, 13], "res_obj_i": [8, 13], "reset_index": [8, 13], "resid": [0, 8, 13], "residu": [0, 2, 9, 13], "residue_compar": 10, "residuecompar": 2, "reslov": [8, 13], "resnam": [8, 13], "resolut": [3, 4], "resolution_indicator_po": [8, 13], "result": [8, 10, 11, 12, 13], "result_map": 10, "results_obj": [8, 13], "results_path": [8, 10, 11, 12, 13], "retriev": [8, 12], "return": [8, 10, 12, 13], "revers": [8, 12], "revert_hdxmsdata_to_datafram": [8, 11], "rm": 5, "robot": 3, "round": 10, "rt": [0, 6], "rtc": 6, "run": [5, 11, 13], "run_bayesian_hdx_": [8, 11], "run_bayesian_hdx_apo_chunk": [8, 11], "run_num": [8, 12, 13], "same": 10, "sampl": [2, 3, 12], "satisfi": 8, "satur": [0, 8, 9, 10, 11, 12], "save": [8, 9, 10, 11, 12, 13], "savefig": [8, 10, 12, 13], "scatter": 6, "scatterplot": 6, "score": 6, "scorec": 6, "script": [8, 11], "seaborn": [8, 12], "search": [4, 8, 10], "second": 10, "see": 6, "seed": 0, "select": [6, 8, 10, 12, 13], "selected_idf": [8, 10], "selected_uptake_error": [8, 12], "self": 8, "seq_po": [8, 13], "sequenc": [0, 8, 9, 11, 13], "set": [0, 8, 10, 11, 12], "set_major_formatt": [8, 13], "set_major_loc": [8, 10, 12, 13], "set_titl": [8, 12], "set_xlabel": [8, 12], "set_xlim": [8, 10, 12], "set_xtick": [8, 13], "set_xticklabel": [8, 13], "set_ylabel": [8, 12, 13], "set_ylim": [8, 10, 12], "sever": [8, 11], "sh": 5, "sharei": [8, 13], "sharex": [8, 13], "should": 8, "show": [6, 8, 13], "show_seq": [8, 13], "signific": 5, "silicon": 5, "simul": [0, 8, 11], "simulateddata": 2, "sinc": 10, "singl": [4, 8, 13], "sisl": 10, "size": [4, 8, 10, 11, 12, 13], "small": [8, 10, 12], "sn": [8, 12], "so": [12, 13], "softwar": 9, "solut": 3, "solvated_pdb": [8, 11], "sort": [8, 10, 12], "sorted_valu": 10, "sourc": 5, "specexport": [8, 9], "specexport_": [8, 11], "specifi": 6, "spectra": [8, 9, 10, 11, 12, 13], "spectra_": [8, 11], "spectra_dhfr_tutorial_dataset": [8, 11], "spectrometri": [3, 4], "spectrum": 13, "split": [8, 11, 12], "stand": 6, "standard": [0, 8, 12], "start": [0, 8, 12], "state": [0, 3, 6, 8, 9, 10, 11, 12, 13], "state1": [0, 10], "state1_list": [0, 10], "state1_nam": 10, "state2": [0, 10], "state2_list": [0, 10], "state2_nam": 10, "state_nam": [0, 8, 9, 10, 11, 12, 13], "states_subset": [0, 8, 9, 10], "statics_info": 9, "statist": [8, 9], "statu": [10, 11, 12, 13], "std_dg": [8, 13], "std_logp": [8, 13], "std_within_clusters_log_kex": 8, "stddev": 0, "step": [8, 10, 13], "store": 0, "str": 0, "strftime": [8, 9, 10, 11, 12, 13], "string": 0, "structur": [3, 8, 11, 13], "structural_prior": [8, 11], "strutcur": [8, 13], "subplot": [8, 10, 12, 13], "subplots_adjust": [8, 12, 13], "subset": [8, 10, 12], "subtract": [0, 2], "suffix": [8, 13], "sum": [8, 10, 12], "super": 8, "support": [5, 10, 11, 12, 13], "sure": [8, 11, 12, 13], "t": [5, 6], "tabl": [6, 8, 9], "take": [6, 8, 11], "teal": [8, 12], "techniqu": 3, "temperatur": [8, 11, 12, 13], "termin": [5, 8, 11], "terminu": 9, "text": [8, 12, 13], "than": 10, "thei": [8, 12, 13], "them": 10, "theo_max_d": [8, 10, 12], "thi": [3, 8, 10, 11, 12, 13], "threshold": 6, "through": [2, 3, 4], "tick_numb": [8, 13], "ticker": [8, 10, 12, 13], "tight_layout": [8, 10, 12], "time": [0, 8, 9, 10, 11], "timepoint": [2, 8, 10, 12], "titl": [8, 10, 12], "title_fonts": [8, 10, 12], "titles": [8, 10], "titleweight": [8, 10], "to_csv": [8, 13], "todai": [8, 9, 10, 11, 12, 13], "today_d": [8, 10, 11, 12, 13], "tool": [8, 10, 11, 12, 13], "topscor": 6, "tp": [8, 10, 12], "tps_rang": 10, "treat": 6, "trendlin": 6, "tri": [8, 9, 10, 11, 12, 13], "tri_stat": [8, 12, 13], "true": [0, 8, 11, 12, 13], "try": [8, 12], "tupl": [0, 8, 12], "turtori": 8, "tutori": [4, 8, 12, 13], "two": [0, 8, 9, 10, 12, 13], "twp": 11, "type": [6, 9], "unam": 5, "unfold": [8, 13], "uniqu": [8, 9], "unique_num_timepoint": [8, 10], "unpack": [8, 12], "unpickl": 8, "uptak": [9, 11], "uptake_error": [8, 12], "uptake_errors_arrai": [8, 12], "uptakeplot": [2, 8, 10], "uptakeplotscollect": 2, "us": [0, 3, 6, 8, 11], "user": [5, 8, 12, 13], "usual": [8, 11], "util": [8, 13], "v": [5, 6], "va": [8, 13], "valu": [8, 9, 10, 12, 13], "valueerror": 0, "vari": [8, 11], "variabl": 0, "variou": 6, "vdeaiaacgdvpeim": [8, 12], "visual": 13, "vksv": [8, 12], "w": [8, 11], "wa": 8, "walkthrough": [4, 7], "wb": [8, 9, 11], "we": [3, 10, 11, 12, 13], "weight": [8, 10], "were": [12, 13], "wget": 5, "when": 5, "where": 10, "which": 5, "while": [8, 12], "within": 10, "work": 5, "workflow": 5, "write": [8, 11], "wspace": [8, 12], "x": [8, 10, 12], "x86_64": 5, "xaxi": [8, 10, 12, 13], "xlabel": [8, 12], "y": [8, 9, 10, 11, 12, 13], "y_max": [8, 10, 12], "yaxi": [8, 13], "yellow": [6, 8, 10], "yfqsisl": 10, "ylabel": [8, 12], "you": [8, 11, 12, 13], "z": 6, "zip": [8, 10, 12]}, "titles": ["pigeon_feather.data.RangeList", "Documentation", "FEATHER", "HDX/MS", "Welcome to PIGEON-FEATHER\u2019s documentation!", "Installation", "PIGEON", "Tutorials", "00_Showcase ecDHFR: a FEATHER walkthrough", "01_load_data", "02_peptide_level_analysis", "03_calculate_PFs", "04_check_the_fitting", "05_plot_the_results"], "titleterms": {"": [4, 13], "00_showcas": 8, "01_load_data": 9, "02_peptide_level_analysi": 10, "03_calculate_pf": 11, "04_check_the_fit": 12, "05_plot_the_result": 13, "analysi": 8, "back": 8, "barplot": [8, 13], "centroid": 9, "check": [8, 12], "class": 2, "cmd": 6, "compar": 10, "comparison": 10, "conda": 5, "correct": 8, "data": [0, 8, 9], "delta": 13, "docker": 5, "document": [1, 4], "ecdhfr": 8, "envelop": [8, 12], "exampl": 6, "exchang": 8, "feather": [2, 4, 8], "fit": 8, "hdx": 3, "hdxmsdata": 0, "hdxmsdatacollect": 0, "hdxstatepeptidecompar": 0, "hdxstateresiduecompar": 0, "import": 8, "indic": 4, "input": [8, 11], "instal": 5, "kex": [8, 13], "load": [8, 9], "log": 13, "m": 3, "mcmc": [8, 11], "option": 6, "peptid": [0, 8, 11], "peptidecompar": 0, "pf": 13, "pigeon": [4, 6], "pigeon_feath": 0, "pipetid": 10, "plot": [0, 8, 10], "prior": 11, "proteinst": 0, "pseudo": 10, "pymol": 10, "rangelist": 0, "raw": 9, "read": 9, "residu": 10, "residuecompar": 0, "run": 8, "sampl": [8, 11], "simulateddata": 0, "spectrum": 9, "structur": 10, "subtract": [8, 11], "tabl": 4, "timepoint": 0, "tutori": 7, "two": 11, "uptak": [8, 10, 12], "uptakeplot": 0, "uptakeplotscollect": 0, "usag": 6, "visual": 10, "walkthrough": 8, "welcom": 4}}) \ No newline at end of file diff --git a/tutorial.html b/tutorial.html new file mode 100644 index 0000000..5cf59b3 --- /dev/null +++ b/tutorial.html @@ -0,0 +1,136 @@ + + + + + + + Tutorials — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+ +
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/tutorials/00_ecdhfr_showcase.html b/tutorials/00_ecdhfr_showcase.html new file mode 100644 index 0000000..d78321d --- /dev/null +++ b/tutorials/00_ecdhfr_showcase.html @@ -0,0 +1,1286 @@ + + + + + + + 00_Showcase ecDHFR: a FEATHER walkthrough — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

00_Showcase ecDHFR: a FEATHER walkthrough

+

The tutorial dataset can be downloaded from this link.

+
+

import

+
+
[1]:
+
+
+
from pigeon_feather.data import *
+from pigeon_feather.plot import *
+from pigeon_feather.hxio import *
+from pigeon_feather.spectra import *
+
+
+import numpy as np
+import pandas as pd
+
+
+
+
+
[3]:
+
+
+
# make folders for results
+
+import datetime
+import os
+
+out_path = "./data/bayesian_hdx_input_20240722"
+
+today_date = datetime.date.today().strftime("%Y%m%d")
+# today_date = '20240722'
+results_path = os.path.join(out_path, f"ecDHFR_results_{today_date}")
+
+if not os.path.exists(results_path):
+    os.makedirs(results_path)
+
+
+
+
+
+

load the data

+
+
[2]:
+
+
+
tables = ['./data/ecDHFR_tutorial.csv']
+
+ranges = ['./data/rangeslist.csv']
+
+
+raw_spectra_paths = [
+    f"./data/SpecExport/",
+]
+
+protein_sequence = "MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR"
+
+# load the data
+hdxms_data_list = []
+for i in range(len(tables)):
+    # for i in [4]:
+    print(tables[i])
+
+
+    # read the data and clean it
+    cleaned = read_hdx_tables([tables[i]], [ranges[i]], exclude=False, states_subset=['APO','TRI'])
+
+    # convert the cleaned data to hdxms data object
+    hdxms_data = load_dataframe_to_hdxmsdata(
+        cleaned,
+        n_fastamides=2,
+        protein_sequence=protein_sequence,
+        fulld_approx=False,
+        saturation=0.9,
+    )
+
+    # load the raw ms data to the hdxms data object
+    load_raw_ms_to_hdxms_data(
+        hdxms_data,
+        raw_spectra_paths[i],
+    )
+
+    hdxms_data_list.append(hdxms_data)
+

+
+
+
+
+
+
+
+./data/ecDHFR_tutorial.csv
+rangeslist included !
+Removed 0 peptides from state APO due to missing raw MS data.
+Removed 70 peptides from state APO due to high back exchange.
+Removed 2 peptides from state TRI due to missing raw MS data.
+Removed 70 peptides from state TRI due to high back exchange.
+Done loading raw MS data.
+
+
+
+
[3]:
+
+
+
hdxms_data_list
+
+
+
+
+
[3]:
+
+
+
+
+[<pigeon_feather.data.HDXMSData at 0x7f6ccdb68fd0>]
+
+
+
+
[4]:
+
+
+
# save the raw data as a pickle file
+import pickle
+
+today = datetime.date.today().strftime("%Y%m%d")
+today = "20240722"
+
+# with open(f"./data/hdxms_data_raw_{today}.pkl", "wb") as f:
+#     pickle.dump(hdxms_data_list, f)
+
+with open(f"./data/hdxms_data_raw_{today}.pkl", "rb") as f:
+    hdxms_data_list = pickle.load(f)
+
+
+
+
+
[5]:
+
+
+
from pigeon_feather.hxio import get_all_statics_info
+
+get_all_statics_info(hdxms_data_list)
+
+
+
+
+
+
+
+
+============================================================
+                    HDX-MS Data Statistics
+============================================================
+States names: ['APO', 'TRI']
+Time course (s): [46.0, 373.5, 572.5, 2011.0, 7772.0, 30811.5, 43292.0]
+Number of time points: 7
+Protein sequence length: 174
+Average coverage: 0.93
+Number of unique peptides: 186
+Average peptide length: 9.4
+Redundancy (based on average coverage): 10.0
+Average peptide length to redundancy ratio: 0.9
+Backexchange average, IQR: 0.19, 0.15
+============================================================
+
+
+
+
+

back exchange correction

+

back exchange correction for peptides with experimental full deuteration data based its closest match in the database

+
+
[6]:
+
+
+
tools.backexchange_correction(hdxms_data_list)
+
+
+
+
+
+
+
+
+Number of peptides with experimental max_d: 358
+Number of peptides with no experimental max_d: 12
+
+
+
+
[7]:
+
+
+
# grab all the peptides
+
+all_peps = [
+    pep
+    for data in hdxms_data_list[:]
+    for state in data.states
+    for pep in state.peptides
+]
+
+len(set([pep.identifier for pep in all_peps]))
+
+
+
+
+
[7]:
+
+
+
+
+186
+
+
+
+
[8]:
+
+
+
max_d = [pep.max_d / pep.theo_max_d for pep in all_peps]
+plt.hist(max_d, bins=20)
+
+
+
+
+
[8]:
+
+
+
+
+(array([18., 16., 10., 20., 30., 20., 42., 20., 24., 40., 38., 28., 20.,
+        14.,  8.,  6.,  4.,  2.,  2.,  8.]),
+ array([0.60127572, 0.62628601, 0.6512963 , 0.67630658, 0.70131687,
+        0.72632716, 0.75133745, 0.77634774, 0.80135802, 0.82636831,
+        0.8513786 , 0.87638889, 0.90139918, 0.92640947, 0.95141975,
+        0.97643004, 1.00144033, 1.02645062, 1.05146091, 1.07647119,
+        1.10148148]),
+ <BarContainer object of 20 artists>)
+
+
+
+
+
+
+../_images/tutorials_00_ecdhfr_showcase_14_1.png +
+
+
+
+

plot uptake plots

+
+
[11]:
+
+
+
# option 1
+from matplotlib.ticker import MultipleLocator, FormatStrFormatter
+import matplotlib.ticker as ticker
+import matplotlib.lines as mlines
+from pigeon_feather.analysis import get_index_offset
+from matplotlib.ticker import LogLocator
+
+
+font = {"family": "Arial", "weight": "normal", "size": 36}
+axes = {"titlesize": 36, "titleweight": "bold", "labelsize": 36, "linewidth": 5}
+plt.rc("font", **font)
+plt.rc("axes", **axes)
+plt.rc("lines", lw=5)
+
+colors = ["k", "red", "blue", "purple", "gray", "orange", "yellow", "green", "brown"]
+
+
+all_peps = [
+    peptide
+    for hdxms_data in hdxms_data_list
+    for state in hdxms_data.states
+    for peptide in state.peptides
+    if peptide.note is None and state.state_name != "RAT"
+]
+all_idfs = [pep for pep in all_peps if pep.unique_num_timepoints > 5]
+all_idfs = list(set([peptide.identifier for peptide in all_peps]))[:]
+all_idfs.sort(key=lambda x: int(re.search(r"(-?\d+)", x).group()))
+
+
+
+def idf_to_pep(idf):
+    return [pep for pep in all_peps if pep.identifier == idf][0]
+
+# num_subplots_per_figure = 100
+num_subplots_per_figure = 250
+num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)
+
+
+all_idfs_subset = all_idfs[:]
+
+for fig_index in range(num_figures):
+    # Select the subset of errors for the current figure
+    selected_idf = all_idfs_subset[
+        fig_index * num_subplots_per_figure : (fig_index + 1) * num_subplots_per_figure
+    ]
+    num_col = math.ceil(len(selected_idf) / 5)
+
+    fig, axs = plt.subplots(
+        num_col, 5, figsize=(9 * 5, 8 * num_col)
+    )  # Adjust subplot size as needed
+
+    for i, idf in enumerate(selected_idf):
+        ax = axs[i // 5, i % 5]
+
+
+        pep = idf_to_pep(idf)
+        ax.axhline(y=pep.max_d, color='lightgray', linestyle='--', linewidth=5)
+
+
+        uptake = UptakePlot(
+            hdxms_data_list,
+            idf,
+            states_subset=["APO", "TRI"],
+            if_plot_fit=False,
+            figure=fig,
+            ax=ax,
+        )
+
+        ax.set_xlim(1e1, 1e5)
+        ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))
+
+
+        y_max = pep.theo_max_d/hdxms_data_list[0].saturation
+        ax.set_ylim(-0.5, y_max + 0.5)
+
+
+        #Custom legend
+        handles, labels = ax.get_legend_handles_labels()
+        new_labels = [label for label in labels if label in ["APO", "TRI"]]
+        new_handles = [
+            handle
+            for handle, label in zip(handles, labels)
+            if label in ["APO", "TRI"]
+        ]
+        ax.legend(new_handles, new_labels, title="state", title_fontsize="small",loc='best')
+
+
+    # Layout adjustment and save
+    fig.tight_layout()
+    fig.savefig(f"{results_path}/DHFR_exp_uptake_{fig_index}.pdf")
+
+
+
+
+
+

peptide subtraction

+
+
[9]:
+
+
+
# [state.add_all_subtract() for data in hdxms_data_list for state in data.states]
+# add_new_peptides_by_subtract()
+for i in range(1):
+    [
+        state.add_new_peptides_by_subtract()
+        for data in hdxms_data_list[:]
+        for state in data.states
+    ]
+
+
+
+
+
+
+
+
+117 new peptides added to the APO state.
+126 new peptides added to the TRI state.
+
+
+
+
[10]:
+
+
+
[state.num_subtracted_added for data in hdxms_data_list for state in data.states]
+
+
+
+
+
[10]:
+
+
+
+
+[117, 126]
+
+
+

save the data as a pickle file for later use, and write to files used for bayesian sampling

+
+
[11]:
+
+
+
import os
+
+out_path = f"./data/bayesian_hdx_input_{today}"
+if not os.path.exists(out_path):
+    os.makedirs(out_path)
+
+
+import pickle
+
+with open(f"{out_path}/hdxms_data_list.pkl", "wb") as f:
+    pickle.dump(hdxms_data_list, f)
+
+# with open(f"{out_path}/hdxms_data_list.pkl", "rb") as f:
+#     hdxms_data_list = pickle.load(f)
+
+
+
+
+
+

inputs for MCMC sampling

+
+
[12]:
+
+
+
exp_names = [
+    "dhfr_tutorial_dataset",
+]
+
+for i in range(len(hdxms_data_list)):
+    # exp_name = raw_spectra_paths[i].split('/')[-2].split('SpecExport_')[-1]
+    exp_name = exp_names[i]
+    export_iso_files(
+        hdxms_data_list[i], outdir=f"{out_path}/spectra_{exp_name}", overwrite=True
+    )
+    df = revert_hdxmsdata_to_dataframe(hdxms_data_list[i])
+    convert_dataframe_to_bayesianhdx_format(
+        df, protein_name=exp_name, OUTPATH=f"{out_path}"
+    )
+
+    print(exp_name)
+
+
+
+
+
+
+
+
+Isotope files saved to ./data/bayesian_hdx_input_20240722/spectra_dhfr_tutorial_dataset
+Reminder: sequence contains fastamides !!!
+Reminder: sequence contains fastamides !!!
+Data saved to ./data/bayesian_hdx_input_20240722
+dhfr_tutorial_dataset
+
+
+
+
[15]:
+
+
+
# write ready to run script for each state
+
+protein_sequence = "MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR"
+
+state_names = list(
+    set([state.state_name for data in hdxms_data_list for state in data.states])
+)
+for protein_state in state_names:
+    script = tools.generate_bayesian_hdx_script(
+        exp_names,
+        protein_sequence,
+        protein_state,
+        base_directory=".",
+        making_chunks=True,
+        pH=7.0,
+        temperature=293.0,
+        saturation=0.9,
+        rerun_num=3,
+        extreme_value_prior=False,
+        structural_prior=False,
+    )
+
+    with open(f"{out_path}/run_bayesian_hdx_{protein_state}_chunks.py", "w") as f:
+        f.write(script)
+


+
+
+

two priors

+
+
[14]:
+
+
+
# uptake prior
+#tools.generate_extreme_value_prior(hdxms_data_list, out_path)
+
+
+# structural prior
+
+# solvated_pdbs = [
+#     "./data/5DFR_APO_relaxed_best_solvated.pdb",
+#     "./data/6XG5_TRI_relaxed_best_solvated.pdb",
+#     "./data/1RG7_MTX_relaxed_best_solvated.pdb",
+# ]
+
+# for i, state_name in enumerate(["APO", "TRI", "MTX"]):
+
+
+#     tools.generate_structural_prior(
+#         protein_sequence, solvated_pdbs[i], out_path, state_name
+#     )
+
+
+
+
+
+

run the sampling

+

You can run the script in the terminal with the following command:

+
cd ./data/bayesian_hdx_input_20240722
+python run_bayesian_hdx_APO_chunks.py
+
+
+

The simulations usually take several hours, but the duration varies based on the size of the dataset (number of peptides, time points, and replicates).

+
+
+

Analysis

+
+
[13]:
+
+
+
import pickle
+
+class CustomUnpickler(pickle.Unpickler):
+    def find_class(self, module, name):
+        if name == "ProteinState":
+            from pigeon_feather.data import ProteinState
+
+            return ProteinState
+        if name == "HDXMSData":
+            from pigeon_feather.data import HDXMSData
+
+            return HDXMSData
+        if name == "Peptide":
+            from pigeon_feather.data import Peptide
+
+            return Peptide
+        if name == "Timepoint":
+            from pigeon_feather.data import Timepoint
+
+            return Timepoint
+        return super().find_class(module, name)
+
+
+# read pcikle
+with open(f"{out_path}/hdxms_data_list.pkl", "rb") as f:
+    hdxms_data_list = CustomUnpickler(f).load()
+
+
+
+
+
[15]:
+
+
+
hdxms_data_list
+
+
+
+
+
[15]:
+
+
+
+
+[<pigeon_feather.data.HDXMSData at 0x7f095a02d150>]
+
+
+
+
[16]:
+
+
+
for data in hdxms_data_list:
+    for state in data.states:
+        state.peptides = [pep for pep in state.peptides if pep.note is None]
+        for pep in state.peptides:
+            pep.timepoints = [tp for tp in pep.timepoints if tp.note is None]
+
+
+
+

create an Analysis object and load the results, note: the temperature and pH are crucial to calculate the instrisic exchange rates. make sure to input the correct ones. The chunk size and chunk number can be altered by user. in this tutorial it was automaticaly determined by a help function.

+
+
[17]:
+
+
+
from pigeon_feather.analysis import Analysis, get_index_offset
+from pigeon_feather.tools import optimal_chunks
+import matplotlib.pyplot as plt
+
+RUN_NUM = 3
+
+apo_states = [
+    state
+    for data in hdxms_data_list
+    for state in data.states
+    if state.state_name == "APO"
+]
+
+tri_states = [
+    state
+    for data in hdxms_data_list
+    for state in data.states
+    if state.state_name == "TRI"
+]
+
+ana_apo_1 = Analysis(apo_states, temperature=293.0, pH=7.0)
+
+chunk_num, chunk_size = optimal_chunks(len(ana_apo_1.protein_sequence))
+ana_apo_1.load_bayesian_hdx_oupt_chunks(
+    chunk_size=chunk_size,
+    chunk_num=chunk_num,
+    state_name="APO",
+    run_num=RUN_NUM,
+    N=200,
+    bayesian_hdx_data_folder=f"{out_path}/bayesian_hdx_output_chunks",
+)
+
+
+ana_tri_1 = Analysis(tri_states, temperature=293.0, pH=7.0)
+
+ana_tri_1.load_bayesian_hdx_oupt_chunks(
+    chunk_size=chunk_size,
+    chunk_num=chunk_num,
+    state_name="TRI",
+    run_num=RUN_NUM,
+    N=200,
+    bayesian_hdx_data_folder=f"{out_path}/bayesian_hdx_output_chunks",
+)
+
+
+
+
+
[18]:
+
+
+
# for mini in ana_apo_1.results_obj.mini_peps:
+#     print(mini.std_within_clusters_log_kex)
+
+
+
+
+
+

Fitting check

+

two fitting check functions are available: 1. centroid level fitting check 2. isotopic mass envelope fitting check.

+
+
[19]:
+
+
+
from pigeon_feather.analysis import (
+    check_fitted_isotope_envelope,
+    check_fitted_peptide_uptake,
+)
+
+
+
+
+

envelope check

+
+
[20]:
+
+
+
check_state_name = "APO"
+check_ana_obj = ana_apo_1
+
+
+all_peps = [
+    pep
+    for data in hdxms_data_list
+    for state in data.states
+    for pep in state.peptides
+    if state.state_name == check_state_name and pep.note is None
+]
+all_tps = [
+    tp
+    for pep in all_peps
+    for tp in pep.timepoints
+    if pep.get_timepoint(0) is not None and tp.deut_time != np.inf and tp.deut_time != 0
+]
+
+
+
+
+
[21]:
+
+
+
envelope_errors = [(check_fitted_isotope_envelope(ana_apo_1, tp), tp) for tp in all_tps]
+envelope_errors = sorted(envelope_errors, key=lambda x: x[0], reverse=False)
+
+# you can plot the fitted isotope envelope and the experimental data
+check_fitted_isotope_envelope(check_ana_obj, envelope_errors[300][1], if_plot=True)
+
+
+
+
+
[21]:
+
+
+
+
+0.18086398727111275
+
+
+
+
+
+
+../_images/tutorials_00_ecdhfr_showcase_41_1.png +
+
+
+
[22]:
+
+
+
plt.hist(
+    np.array(envelope_errors)[:, 0],
+)
+plt.xlabel("Sum AE")
+plt.ylabel("Count")
+
+
+
+
+
[22]:
+
+
+
+
+Text(0, 0.5, 'Count')
+
+
+
+
+
+
+../_images/tutorials_00_ecdhfr_showcase_42_1.png +
+
+
+
[23]:
+
+
+

print(np.nanmedian(np.array(envelope_errors)[:, 0]))
+print(np.nanmean(np.array(envelope_errors)[:, 0]))
+
+
+
+
+
+
+
+
+0.3646019382844139
+0.39348193324578395
+
+
+
+
+

uptake check

+
+
[24]:
+
+
+
from pigeon_feather.analysis import check_fitted_peptide_uptake
+
+
+all_idfs = list(set([pep.identifier for pep in all_peps]))
+
+
+def extract_numbers(s):
+    numbers = re.findall(r"(-?\d+)-(-?\d+)", s)
+    return tuple(map(int, numbers[0]))
+
+
+all_idfs.sort(key=extract_numbers)
+
+
+
+
+
[25]:
+
+
+
uptake_errors = []
+
+all_peps_grouped = tools.group_by_attributes(
+    all_peps, ["protein_state.state_name", "identifier"]
+)
+
+for idf in all_idfs:
+    try:
+        idf_peps = all_peps_grouped[(check_state_name, idf)]
+        avg_pep = tools.average_peptides(idf_peps)
+
+        result = check_fitted_peptide_uptake(
+            check_ana_obj, hdxms_data_list, avg_pep, state_name=check_state_name
+        )
+        uptake_errors.append((result, avg_pep))
+    except Exception as e:
+        print(idf, e)
+
+
+uptake_errors_array = np.array([i[0] for i in uptake_errors])
+
+
+
+
+
[26]:
+
+
+
import seaborn as sns
+
+
+fig, axes = plt.subplots(1, 2, figsize=(12, 5.5))
+
+# # Plotting with complementary colors
+# sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color="#FF6347")
+# sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color="#4682B4")
+
+
+color_1 = "#53b1b1"  # A standard blue color
+color_2 = "#f6c624"  # A teal color
+
+# Plotting with chosen colors
+sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=color_1)
+sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=color_2)
+
+axes[1].set_ylabel("")
+axes[0].set_xlabel("Sum AE")
+axes[1].set_xlabel("Da/peptide length")
+fig.subplots_adjust(wspace=0.2)
+
+
+
+
+
+
+
+../_images/tutorials_00_ecdhfr_showcase_47_0.png +
+
+
+
[27]:
+
+
+
from pigeon_feather.analysis import get_index_offset
+from matplotlib.ticker import LogLocator
+
+
+check_ana_obj = ana_apo_1
+index_offset = get_index_offset(check_ana_obj, './data/6XG5_TRI.pdb')
+
+uptake_errors = sorted(uptake_errors, key=lambda x: x[1].start, reverse=False)
+
+num_subplots_per_figure = math.ceil(len(uptake_errors) / 2)
+# num_subplots_per_figure = 250
+num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)
+
+
+for fig_index in range(num_figures):
+    # Select the subset of errors for the current figure
+    selected_uptake_errors = uptake_errors[fig_index * num_subplots_per_figure:(fig_index + 1) * num_subplots_per_figure]
+    num_col = math.ceil(len(selected_uptake_errors) / 5)
+
+    fig, axs = plt.subplots(num_col, 5, figsize=(9 * 5, 8 * num_col))  # Adjust subplot size as needed
+
+    for i, error_tuple in enumerate(selected_uptake_errors):
+
+
+        ax = axs[i // 5, i % 5]
+
+
+        # Unpack error information
+        peptide_data = error_tuple[1]
+
+
+        ax.axhline(y=peptide_data.max_d, color='lightgray', linestyle='--', linewidth=5)
+
+        check_fitted_peptide_uptake(
+            check_ana_obj,
+            hdxms_data_list,
+            peptide_data,
+            if_plot=True,
+            state_name=check_state_name,
+            figure=fig,
+            ax=ax
+        )
+
+        #Retrieve and format the peptide identifier
+        idf = peptide_data.identifier
+        idf_start, idf_end = map(int, re.match(r"(-?\d+)-(-?\d+)", idf).groups())
+        idf_seq = idf.split(" ")[1]
+        ax.set_title(f"{idf_start - index_offset}-{idf_end - index_offset} {idf_seq}")
+
+        ax.set_xlim(1e1, 1e5)
+        ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))
+
+        # y_max = ax.get_ylim()[1]
+        # ax.set_ylim(-0.5, y_max + 1)
+        pep = error_tuple[1]
+        y_max = pep.theo_max_d/check_ana_obj.saturation
+        ax.set_ylim(-0.5, y_max + 0.5)
+
+        # light gray dotted line at max deuteration
+
+
+        handles, labels = ax.get_legend_handles_labels()
+        new_labels = [label for label in labels if label.isdigit()]
+        new_handles = [handle for handle, label in zip(handles, labels) if label.isdigit()]
+        ax.legend(new_handles, new_labels, title='replicate', title_fontsize='small')
+
+    # Layout adjustment and save
+    fig.tight_layout()
+    fig.savefig(f"{results_path}/ecDHFR_uptake_errors_{check_state_name}_{fig_index}.pdf")
+
+
+
+

if the fitting is bad, one should not move forward, need to check the parameters in the sampling, make sure they agree with the experimental conditions. one may also remove the outlier peptides and run the all the cells above again. a ourliter may be a peptide exchange a lot while its neighbours barely exchange (examples in the turtorial dataset: 78-92 VDEAIAACGDVPEIM, 75-78 VKSV)

+

once you’re satisfied with the fitting results, you can make the final results plots

+
+
+
+

barplot of the kex

+

barplot showing the FEATHER derived exchange rates. index_offset is determined by comparison to the sequence in HX/MS and the pdb file provided.

+
+
[28]:
+
+
+
# APO state only
+
+import numpy as np
+
+
+fig, axes = plt.subplots(2, 1, figsize=(40, 10), sharey=True, sharex=True)
+
+ana_apo_1.plot_kex_bar(
+    ax=axes[0], resolution_indicator_pos=15, label="APO", show_seq=False, color="k"
+)
+
+ana_tri_1.plot_kex_bar(
+    ax=axes[1], resolution_indicator_pos=15, label="TRI", show_seq=False, color="red"
+)
+
+from matplotlib.pyplot import step
+from matplotlib.ticker import FuncFormatter, MultipleLocator
+
+from pigeon_feather.analysis import get_index_offset
+
+pdb_file = "./data/6XG5_TRI.pdb"
+index_offset = get_index_offset(ana_apo_1, pdb_file)
+
+# # ax.xaxis.set_major_locator(plt.MultipleLocator(2))
+axes[0].set_xticks(axes[0].get_xticks()[::2])
+axes[0].set_xticklabels(axes[0].get_xticklabels(), fontdict={"fontsize": 24})
+
+
+def format_func(value, tick_number):
+    return f"{int(value - index_offset +1)}"
+
+
+axes[0].xaxis.set_major_formatter(FuncFormatter(format_func))
+
+seq_pos = 17
+for ii in range(0, len(ana_apo_1.protein_sequence[:]), 2):
+    axes[0].text(
+        ii,
+        seq_pos,
+        ana_apo_1.protein_sequence[ii],
+        ha="center",
+        va="center",
+        fontsize=22,
+    )
+
+
+for ax in axes:
+    ax.set_ylabel("-log(k$_{ex}$)")
+    #ax.legend(loc="lower left")
+    ax.yaxis.set_major_locator(plt.MultipleLocator(5))
+
+    ax.plot(
+        [-3, len(ana_apo_1.protein_sequence) + 3],
+        [5, 5],
+        color="gray",
+        lw=1,
+        linestyle="--",
+        alpha=0.5,
+    )
+    ax.plot(
+        [-3, len(ana_apo_1.protein_sequence) + 3],
+        [10, 10],
+        color="gray",
+        lw=1,
+        linestyle="--",
+        alpha=0.5,
+    )
+
+
+plt.subplots_adjust(hspace=0.08)
+fig.savefig(f"{results_path}/ecDHFR_kex_bar_APO_TRI_{today_date}.pdf")
+
+
+
+
+
+
+
+../_images/tutorials_00_ecdhfr_showcase_53_0.png +
+
+

logP projection to a pdb structure

+
+
[29]:
+
+
+
from pigeon_feather.analysis import BFactorPlot
+
+
+
+
+
[30]:
+
+
+
bfactor_plot = BFactorPlot(
+    ana_apo_1,
+    pdb_file="./data/6XG5_TRI.pdb",
+    plot_deltaG=True,
+    temperature=293.15,
+    logP_threshold=10,
+)
+bfactor_plot.plot(f"{results_path}/6XG5_APO_deltaG.pdb")
+
+# bfactor_plot = BFactorPlot(
+#     ana_apo_1,
+#     pdb_file="./data/6XG5_APO_relaxed_best_solvated.pdb",
+#     plot_deltaG=True,
+#     temperature=293.15,
+# )
+# bfactor_plot.plot(f"{out_path}/6XG5_APO_deltaG.pdb")
+
+
+
+

delta logP

+

if there are mutiple states availble, one can map the difference to the pdb strutcure

+
+
[31]:
+
+
+
bfactor_plot = BFactorPlot(
+    ana_apo_1,
+    ana_tri_1,
+    pdb_file="./data/6XG5_TRI.pdb",
+    plot_deltaG=True,
+    temperature=293.15,
+    logP_threshold=10,
+)
+bfactor_plot.plot(f"{results_path}/6XG5_deltaG_APO-TRI.pdb")
+
+
+
+

export logPFs to a csv

+
+
[32]:
+
+
+
import MDAnalysis
+from pigeon_feather.analysis import get_res_avg_logP, get_res_avg_logP_std
+
+pdb_file = "./data/6XG5_TRI.pdb"
+index_offset = get_index_offset(ana_apo_1, pdb_file)
+
+
+def logPF_to_deltaG(ana_obj, logPF):
+    """
+    :param logPF: logP value
+    :return: deltaG in kJ/mol, local unfolding energy
+    """
+
+    return 8.3145 * ana_obj.temperature * np.log(10) * logPF / 1000
+
+
+def create_logP_df(ana_obj, index_offset):
+    df_logPF = pd.DataFrame()
+
+    for res_i, _ in enumerate(ana_obj.results_obj.protein_sequence):
+        res_obj_i = ana_obj.results_obj.get_residue_by_resindex(res_i)
+
+        avg_logP, std_logP = get_res_avg_logP(res_obj_i)
+        #std_logP = get_res_avg_logP_std(res_obj_i)
+
+        df_i = pd.DataFrame(
+            {
+                "resid": [res_obj_i.resid - index_offset],
+                #"resname": [res_obj_i.resname],
+                "resname": [MDAnalysis.lib.util.convert_aa_code(res_obj_i.resname)],
+                'avg_dG': [logPF_to_deltaG(ana_obj, avg_logP)],
+                'std_dG': [logPF_to_deltaG(ana_obj, std_logP)],
+                "avg_logP": [avg_logP],
+                "std_logP": [max(std_logP, 0.35)],
+                "is_nan": [res_obj_i.is_nan()],
+            }
+        )
+
+        if res_obj_i.is_nan():
+            df_i["single resloved"] = [np.nan]
+            df_i["min_pep logPs"] = [np.nan]
+
+        else:
+            df_i["single resloved"] = [res_obj_i.mini_pep.if_single_residue()]
+            df_i["min_pep logPs"] = [res_obj_i.clustering_results_logP]
+
+        df_logPF = pd.concat([df_logPF, df_i])
+
+    df_logPF = df_logPF.reset_index(drop=True)
+
+    return df_logPF
+
+
+df = create_logP_df(ana_apo_1, index_offset)
+df.to_csv(f"{results_path}/logP_APO_{today_date}.csv", index=False)
+
+
+
+
+
[33]:
+
+
+
# fecth two df and merge
+df_apo = create_logP_df(ana_apo_1, index_offset)
+df_tri = create_logP_df(ana_tri_1, index_offset)
+
+df = pd.merge(df_apo, df_tri, on="resid", suffixes=("_APO", "_TRI"))
+
+df.to_csv(f"{results_path}/logP_APO_TRI_{today_date}.csv", index=False)
+
+
+
+
+
[ ]:
+
+
+

+
+
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/tutorials/00_ecdhfr_showcase.ipynb b/tutorials/00_ecdhfr_showcase.ipynb new file mode 100644 index 0000000..6ac552f --- /dev/null +++ b/tutorials/00_ecdhfr_showcase.ipynb @@ -0,0 +1,1395 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 00_Showcase ecDHFR: a FEATHER walkthrough" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The tutorial dataset can be downloaded from [this link](https://figshare.com/ndownloader/files/48153751)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "import datetime\n", + "import os\n", + "\n", + "out_path = \"./data/bayesian_hdx_input_20240722\"\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = os.path.join(out_path, f\"ecDHFR_results_{today_date}\")\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## load the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "./data/ecDHFR_tutorial.csv\n", + "rangeslist included !\n", + "Removed 0 peptides from state APO due to missing raw MS data.\n", + "Removed 70 peptides from state APO due to high back exchange.\n", + "Removed 2 peptides from state TRI due to missing raw MS data.\n", + "Removed 70 peptides from state TRI due to high back exchange.\n", + "Done loading raw MS data.\n" + ] + } + ], + "source": [ + "tables = ['./data/ecDHFR_tutorial.csv']\n", + "\n", + "ranges = ['./data/rangeslist.csv']\n", + "\n", + "\n", + "raw_spectra_paths = [\n", + " f\"./data/SpecExport/\",\n", + "]\n", + "\n", + "protein_sequence = \"MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR\"\n", + "\n", + "# load the data\n", + "hdxms_data_list = []\n", + "for i in range(len(tables)):\n", + " # for i in [4]:\n", + " print(tables[i])\n", + "\n", + " \n", + " # read the data and clean it\n", + " cleaned = read_hdx_tables([tables[i]], [ranges[i]], exclude=False, states_subset=['APO','TRI'])\n", + " \n", + " # convert the cleaned data to hdxms data object\n", + " hdxms_data = load_dataframe_to_hdxmsdata(\n", + " cleaned,\n", + " n_fastamides=2,\n", + " protein_sequence=protein_sequence,\n", + " fulld_approx=False,\n", + " saturation=0.9,\n", + " )\n", + "\n", + " # load the raw ms data to the hdxms data object\n", + " load_raw_ms_to_hdxms_data(\n", + " hdxms_data,\n", + " raw_spectra_paths[i],\n", + " )\n", + "\n", + " hdxms_data_list.append(hdxms_data)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hdxms_data_list" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# save the raw data as a pickle file\n", + "import pickle\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "# with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"wb\") as f:\n", + "# pickle.dump(hdxms_data_list, f)\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + " HDX-MS Data Statistics\n", + "============================================================\n", + "States names: ['APO', 'TRI']\n", + "Time course (s): [46.0, 373.5, 572.5, 2011.0, 7772.0, 30811.5, 43292.0]\n", + "Number of time points: 7\n", + "Protein sequence length: 174\n", + "Average coverage: 0.93\n", + "Number of unique peptides: 186\n", + "Average peptide length: 9.4\n", + "Redundancy (based on average coverage): 10.0\n", + "Average peptide length to redundancy ratio: 0.9\n", + "Backexchange average, IQR: 0.19, 0.15\n", + "============================================================\n" + ] + } + ], + "source": [ + "from pigeon_feather.hxio import get_all_statics_info\n", + "\n", + "get_all_statics_info(hdxms_data_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## back exchange correction" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "back exchange correction for peptides with experimental full deuteration data based its closest match in the database" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "186" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# grab all the peptides\n", + "\n", + "all_peps = [\n", + " pep\n", + " for data in hdxms_data_list[:]\n", + " for state in data.states\n", + " for pep in state.peptides\n", + "]\n", + "\n", + "len(set([pep.identifier for pep in all_peps]))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([18., 16., 10., 20., 30., 20., 42., 20., 24., 40., 38., 28., 20.,\n", + " 14., 8., 6., 4., 2., 2., 8.]),\n", + " array([0.60127572, 0.62628601, 0.6512963 , 0.67630658, 0.70131687,\n", + " 0.72632716, 0.75133745, 0.77634774, 0.80135802, 0.82636831,\n", + " 0.8513786 , 0.87638889, 0.90139918, 0.92640947, 0.95141975,\n", + " 0.97643004, 1.00144033, 1.02645062, 1.05146091, 1.07647119,\n", + " 1.10148148]),\n", + " )" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "max_d = [pep.max_d / pep.theo_max_d for pep in all_peps]\n", + "plt.hist(max_d, bins=20)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## plot uptake plots" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# option 1\n", + "from matplotlib.ticker import MultipleLocator, FormatStrFormatter\n", + "import matplotlib.ticker as ticker\n", + "import matplotlib.lines as mlines\n", + "from pigeon_feather.analysis import get_index_offset\n", + "from matplotlib.ticker import LogLocator\n", + "\n", + "\n", + "font = {\"family\": \"Arial\", \"weight\": \"normal\", \"size\": 36}\n", + "axes = {\"titlesize\": 36, \"titleweight\": \"bold\", \"labelsize\": 36, \"linewidth\": 5}\n", + "plt.rc(\"font\", **font)\n", + "plt.rc(\"axes\", **axes)\n", + "plt.rc(\"lines\", lw=5)\n", + "\n", + "colors = [\"k\", \"red\", \"blue\", \"purple\", \"gray\", \"orange\", \"yellow\", \"green\", \"brown\"]\n", + "\n", + "\n", + "all_peps = [\n", + " peptide\n", + " for hdxms_data in hdxms_data_list\n", + " for state in hdxms_data.states\n", + " for peptide in state.peptides\n", + " if peptide.note is None and state.state_name != \"RAT\"\n", + "]\n", + "all_idfs = [pep for pep in all_peps if pep.unique_num_timepoints > 5]\n", + "all_idfs = list(set([peptide.identifier for peptide in all_peps]))[:]\n", + "all_idfs.sort(key=lambda x: int(re.search(r\"(-?\\d+)\", x).group()))\n", + "\n", + "\n", + "\n", + "def idf_to_pep(idf):\n", + " return [pep for pep in all_peps if pep.identifier == idf][0]\n", + "\n", + "# num_subplots_per_figure = 100\n", + "num_subplots_per_figure = 250\n", + "num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)\n", + "\n", + "\n", + "all_idfs_subset = all_idfs[:]\n", + "\n", + "for fig_index in range(num_figures):\n", + " # Select the subset of errors for the current figure\n", + " selected_idf = all_idfs_subset[\n", + " fig_index * num_subplots_per_figure : (fig_index + 1) * num_subplots_per_figure\n", + " ]\n", + " num_col = math.ceil(len(selected_idf) / 5)\n", + "\n", + " fig, axs = plt.subplots(\n", + " num_col, 5, figsize=(9 * 5, 8 * num_col)\n", + " ) # Adjust subplot size as needed\n", + "\n", + " for i, idf in enumerate(selected_idf):\n", + " ax = axs[i // 5, i % 5]\n", + "\n", + "\n", + " pep = idf_to_pep(idf)\n", + " ax.axhline(y=pep.max_d, color='lightgray', linestyle='--', linewidth=5)\n", + "\n", + "\n", + " uptake = UptakePlot(\n", + " hdxms_data_list,\n", + " idf,\n", + " states_subset=[\"APO\", \"TRI\"],\n", + " if_plot_fit=False,\n", + " figure=fig,\n", + " ax=ax,\n", + " )\n", + "\n", + " ax.set_xlim(1e1, 1e5)\n", + " ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))\n", + "\n", + "\n", + " y_max = pep.theo_max_d/hdxms_data_list[0].saturation\n", + " ax.set_ylim(-0.5, y_max + 0.5)\n", + "\n", + "\n", + " #Custom legend\n", + " handles, labels = ax.get_legend_handles_labels()\n", + " new_labels = [label for label in labels if label in [\"APO\", \"TRI\"]]\n", + " new_handles = [\n", + " handle\n", + " for handle, label in zip(handles, labels)\n", + " if label in [\"APO\", \"TRI\"] \n", + " ]\n", + " ax.legend(new_handles, new_labels, title=\"state\", title_fontsize=\"small\",loc='best')\n", + "\n", + "\n", + " # Layout adjustment and save\n", + " fig.tight_layout()\n", + " fig.savefig(f\"{results_path}/DHFR_exp_uptake_{fig_index}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## peptide subtraction" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "117 new peptides added to the APO state.\n", + "126 new peptides added to the TRI state.\n" + ] + } + ], + "source": [ + "# [state.add_all_subtract() for data in hdxms_data_list for state in data.states]\n", + "# add_new_peptides_by_subtract()\n", + "for i in range(1):\n", + " [\n", + " state.add_new_peptides_by_subtract()\n", + " for data in hdxms_data_list[:]\n", + " for state in data.states\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[117, 126]" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[state.num_subtracted_added for data in hdxms_data_list for state in data.states]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "save the data as a pickle file for later use, and write to files used for bayesian sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "import os\n", + "\n", + "out_path = f\"./data/bayesian_hdx_input_{today}\"\n", + "if not os.path.exists(out_path):\n", + " os.makedirs(out_path)\n", + "\n", + "\n", + "import pickle\n", + "\n", + "with open(f\"{out_path}/hdxms_data_list.pkl\", \"wb\") as f:\n", + " pickle.dump(hdxms_data_list, f)\n", + "\n", + "# with open(f\"{out_path}/hdxms_data_list.pkl\", \"rb\") as f:\n", + "# hdxms_data_list = pickle.load(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## inputs for MCMC sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "metadata": {} + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Isotope files saved to ./data/bayesian_hdx_input_20240722/spectra_dhfr_tutorial_dataset\n", + "Reminder: sequence contains fastamides !!!\n", + "Reminder: sequence contains fastamides !!!\n", + "Data saved to ./data/bayesian_hdx_input_20240722\n", + "dhfr_tutorial_dataset\n" + ] + } + ], + "source": [ + "exp_names = [\n", + " \"dhfr_tutorial_dataset\",\n", + "]\n", + "\n", + "for i in range(len(hdxms_data_list)):\n", + " # exp_name = raw_spectra_paths[i].split('/')[-2].split('SpecExport_')[-1]\n", + " exp_name = exp_names[i]\n", + " export_iso_files(\n", + " hdxms_data_list[i], outdir=f\"{out_path}/spectra_{exp_name}\", overwrite=True\n", + " )\n", + " df = revert_hdxmsdata_to_dataframe(hdxms_data_list[i])\n", + " convert_dataframe_to_bayesianhdx_format(\n", + " df, protein_name=exp_name, OUTPATH=f\"{out_path}\"\n", + " )\n", + "\n", + " print(exp_name)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# write ready to run script for each state\n", + "\n", + "protein_sequence = \"MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR\"\n", + "\n", + "state_names = list(\n", + " set([state.state_name for data in hdxms_data_list for state in data.states])\n", + ")\n", + "for protein_state in state_names:\n", + " script = tools.generate_bayesian_hdx_script(\n", + " exp_names,\n", + " protein_sequence,\n", + " protein_state,\n", + " base_directory=\".\",\n", + " making_chunks=True,\n", + " pH=7.0,\n", + " temperature=293.0,\n", + " saturation=0.9,\n", + " rerun_num=3,\n", + " extreme_value_prior=False,\n", + " structural_prior=False,\n", + " )\n", + "\n", + " with open(f\"{out_path}/run_bayesian_hdx_{protein_state}_chunks.py\", \"w\") as f:\n", + " f.write(script)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "two priors" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# uptake prior\n", + "#tools.generate_extreme_value_prior(hdxms_data_list, out_path)\n", + "\n", + "\n", + "# structural prior\n", + "\n", + "# solvated_pdbs = [\n", + "# \"./data/5DFR_APO_relaxed_best_solvated.pdb\",\n", + "# \"./data/6XG5_TRI_relaxed_best_solvated.pdb\",\n", + "# \"./data/1RG7_MTX_relaxed_best_solvated.pdb\",\n", + "# ]\n", + "\n", + "# for i, state_name in enumerate([\"APO\", \"TRI\", \"MTX\"]):\n", + "\n", + "\n", + "# tools.generate_structural_prior(\n", + "# protein_sequence, solvated_pdbs[i], out_path, state_name\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## run the sampling" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can run the script in the terminal with the following command:\n", + "\n", + "```sh\n", + "cd ./data/bayesian_hdx_input_20240722\n", + "python run_bayesian_hdx_APO_chunks.py\n", + "```\n", + "\n", + "The simulations usually take several hours, but the duration varies based on the size of the dataset (number of peptides, time points, and replicates).\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "import pickle\n", + "\n", + "class CustomUnpickler(pickle.Unpickler):\n", + " def find_class(self, module, name):\n", + " if name == \"ProteinState\":\n", + " from pigeon_feather.data import ProteinState\n", + "\n", + " return ProteinState\n", + " if name == \"HDXMSData\":\n", + " from pigeon_feather.data import HDXMSData\n", + "\n", + " return HDXMSData\n", + " if name == \"Peptide\":\n", + " from pigeon_feather.data import Peptide\n", + "\n", + " return Peptide\n", + " if name == \"Timepoint\":\n", + " from pigeon_feather.data import Timepoint\n", + "\n", + " return Timepoint\n", + " return super().find_class(module, name)\n", + "\n", + "\n", + "# read pcikle\n", + "with open(f\"{out_path}/hdxms_data_list.pkl\", \"rb\") as f:\n", + " hdxms_data_list = CustomUnpickler(f).load()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hdxms_data_list" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "for data in hdxms_data_list:\n", + " for state in data.states:\n", + " state.peptides = [pep for pep in state.peptides if pep.note is None]\n", + " for pep in state.peptides:\n", + " pep.timepoints = [tp for tp in pep.timepoints if tp.note is None]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "create an Analysis object and load the results, note: the temperature and pH are crucial to calculate the instrisic exchange rates. make sure to input the correct ones. The chunk size and chunk number can be altered by user. in this tutorial it was automaticaly determined by a help function." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import Analysis, get_index_offset\n", + "from pigeon_feather.tools import optimal_chunks\n", + "import matplotlib.pyplot as plt\n", + "\n", + "RUN_NUM = 3\n", + "\n", + "apo_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"APO\"\n", + "]\n", + "\n", + "tri_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"TRI\"\n", + "]\n", + "\n", + "ana_apo_1 = Analysis(apo_states, temperature=293.0, pH=7.0)\n", + "\n", + "chunk_num, chunk_size = optimal_chunks(len(ana_apo_1.protein_sequence))\n", + "ana_apo_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"APO\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")\n", + "\n", + "\n", + "ana_tri_1 = Analysis(tri_states, temperature=293.0, pH=7.0)\n", + "\n", + "ana_tri_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"TRI\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# for mini in ana_apo_1.results_obj.mini_peps:\n", + "# print(mini.std_within_clusters_log_kex)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fitting check" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "two fitting check functions are available: 1. centroid level fitting check 2. isotopic mass envelope fitting check. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import (\n", + " check_fitted_isotope_envelope,\n", + " check_fitted_peptide_uptake,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### envelope check" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "check_state_name = \"APO\"\n", + "check_ana_obj = ana_apo_1\n", + "\n", + "\n", + "all_peps = [\n", + " pep\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " for pep in state.peptides\n", + " if state.state_name == check_state_name and pep.note is None\n", + "]\n", + "all_tps = [\n", + " tp\n", + " for pep in all_peps\n", + " for tp in pep.timepoints\n", + " if pep.get_timepoint(0) is not None and tp.deut_time != np.inf and tp.deut_time != 0\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.18086398727111275" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "envelope_errors = [(check_fitted_isotope_envelope(ana_apo_1, tp), tp) for tp in all_tps]\n", + "envelope_errors = sorted(envelope_errors, key=lambda x: x[0], reverse=False)\n", + "\n", + "# you can plot the fitted isotope envelope and the experimental data\n", + "check_fitted_isotope_envelope(check_ana_obj, envelope_errors[300][1], if_plot=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Count')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(\n", + " np.array(envelope_errors)[:, 0],\n", + ")\n", + "plt.xlabel(\"Sum AE\")\n", + "plt.ylabel(\"Count\")" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3646019382844139\n", + "0.39348193324578395\n" + ] + } + ], + "source": [ + "\n", + "print(np.nanmedian(np.array(envelope_errors)[:, 0]))\n", + "print(np.nanmean(np.array(envelope_errors)[:, 0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### uptake check" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import check_fitted_peptide_uptake\n", + "\n", + "\n", + "all_idfs = list(set([pep.identifier for pep in all_peps]))\n", + "\n", + "\n", + "def extract_numbers(s):\n", + " numbers = re.findall(r\"(-?\\d+)-(-?\\d+)\", s)\n", + " return tuple(map(int, numbers[0]))\n", + "\n", + "\n", + "all_idfs.sort(key=extract_numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "uptake_errors = []\n", + "\n", + "all_peps_grouped = tools.group_by_attributes(\n", + " all_peps, [\"protein_state.state_name\", \"identifier\"]\n", + ")\n", + "\n", + "for idf in all_idfs:\n", + " try:\n", + " idf_peps = all_peps_grouped[(check_state_name, idf)]\n", + " avg_pep = tools.average_peptides(idf_peps)\n", + "\n", + " result = check_fitted_peptide_uptake(\n", + " check_ana_obj, hdxms_data_list, avg_pep, state_name=check_state_name\n", + " )\n", + " uptake_errors.append((result, avg_pep))\n", + " except Exception as e:\n", + " print(idf, e)\n", + "\n", + "\n", + "uptake_errors_array = np.array([i[0] for i in uptake_errors])" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5.5))\n", + "\n", + "# # Plotting with complementary colors\n", + "# sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=\"#FF6347\")\n", + "# sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=\"#4682B4\")\n", + "\n", + "\n", + "color_1 = \"#53b1b1\" # A standard blue color\n", + "color_2 = \"#f6c624\" # A teal color\n", + "\n", + "# Plotting with chosen colors\n", + "sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=color_1)\n", + "sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=color_2)\n", + "\n", + "axes[1].set_ylabel(\"\")\n", + "axes[0].set_xlabel(\"Sum AE\")\n", + "axes[1].set_xlabel(\"Da/peptide length\")\n", + "fig.subplots_adjust(wspace=0.2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import get_index_offset\n", + "from matplotlib.ticker import LogLocator\n", + "\n", + "\n", + "check_ana_obj = ana_apo_1\n", + "index_offset = get_index_offset(check_ana_obj, './data/6XG5_TRI.pdb')\n", + "\n", + "uptake_errors = sorted(uptake_errors, key=lambda x: x[1].start, reverse=False)\n", + "\n", + "num_subplots_per_figure = math.ceil(len(uptake_errors) / 2)\n", + "# num_subplots_per_figure = 250\n", + "num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)\n", + "\n", + "\n", + "for fig_index in range(num_figures):\n", + " # Select the subset of errors for the current figure\n", + " selected_uptake_errors = uptake_errors[fig_index * num_subplots_per_figure:(fig_index + 1) * num_subplots_per_figure]\n", + " num_col = math.ceil(len(selected_uptake_errors) / 5)\n", + "\n", + " fig, axs = plt.subplots(num_col, 5, figsize=(9 * 5, 8 * num_col)) # Adjust subplot size as needed\n", + "\n", + " for i, error_tuple in enumerate(selected_uptake_errors):\n", + "\n", + "\n", + " ax = axs[i // 5, i % 5]\n", + "\n", + "\n", + " # Unpack error information\n", + " peptide_data = error_tuple[1]\n", + "\n", + "\n", + " ax.axhline(y=peptide_data.max_d, color='lightgray', linestyle='--', linewidth=5)\n", + "\n", + " check_fitted_peptide_uptake(\n", + " check_ana_obj,\n", + " hdxms_data_list,\n", + " peptide_data,\n", + " if_plot=True,\n", + " state_name=check_state_name,\n", + " figure=fig,\n", + " ax=ax\n", + " )\n", + "\n", + " #Retrieve and format the peptide identifier\n", + " idf = peptide_data.identifier\n", + " idf_start, idf_end = map(int, re.match(r\"(-?\\d+)-(-?\\d+)\", idf).groups())\n", + " idf_seq = idf.split(\" \")[1]\n", + " ax.set_title(f\"{idf_start - index_offset}-{idf_end - index_offset} {idf_seq}\")\n", + "\n", + " ax.set_xlim(1e1, 1e5)\n", + " ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))\n", + "\n", + " # y_max = ax.get_ylim()[1]\n", + " # ax.set_ylim(-0.5, y_max + 1)\n", + " pep = error_tuple[1]\n", + " y_max = pep.theo_max_d/check_ana_obj.saturation\n", + " ax.set_ylim(-0.5, y_max + 0.5)\n", + "\n", + " # light gray dotted line at max deuteration\n", + "\n", + "\n", + " handles, labels = ax.get_legend_handles_labels()\n", + " new_labels = [label for label in labels if label.isdigit()]\n", + " new_handles = [handle for handle, label in zip(handles, labels) if label.isdigit()]\n", + " ax.legend(new_handles, new_labels, title='replicate', title_fontsize='small')\n", + "\n", + " # Layout adjustment and save\n", + " fig.tight_layout()\n", + " fig.savefig(f\"{results_path}/ecDHFR_uptake_errors_{check_state_name}_{fig_index}.pdf\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "if the fitting is bad, one should not move forward, need to check the parameters in the sampling, make sure they agree with the experimental conditions. one may also remove the outlier peptides and run the all the cells above again. a ourliter may be a peptide exchange a lot while its neighbours barely exchange (examples in the turtorial dataset: 78-92 VDEAIAACGDVPEIM, 75-78 VKSV)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "once you're satisfied with the fitting results, you can make the final results plots" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## barplot of the kex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "barplot showing the FEATHER derived exchange rates. index_offset is determined by comparison to the sequence in HX/MS and the pdb file provided." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAD0EAAAOPCAYAAAAHBVjaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd5wURf7/8ffMRhYWEEmCJFE4BMmgYgCRIKgHSBBOEMF86n2Nd4aTYADMp54Rj6DgKUFQTyUIAiKKiARBQCRKkKTEZWd3Z/r3x/623WF3YUP1TPfO6/l4zOMxobvmM11d1VU1Xd0+y7IsAQAAAAAAAAAAAAAAAAAAAAAAAAAAAIBL+KMdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADkxiRoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK7CJGgAAAAAAAAAAAAAAAAAAAAAAAAAAAAArsIkaAAAAAAAAAAAAAAAAAAAAAAAAAAAAACuwiRoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAK4SH+0A4A4+n6/AzxITEyMYCQAAAAAAAAAAAAAAAAAAAAAAAAAAAEqTjIyMAj+zLCvf931WQZ8gppxsEjQAAAAAAAAAAAAAAAAAAAAAAAAAAADghIKmOvsjHAcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAnBSToAEAAAAAAAAAAAAAAAAAAAAAAAAAAAC4CpOgAQAAAAAAAAAAAAAAAAAAAAAAAAAAALgKk6ABAAAAAAAAAAAAAAAAAAAAAAAAAAAAuEp8tAOA+yUmJkY7BAAAAAAAAAAAAAAAAAAAAAAAAAAAAHhURkZGkddhEjQkZU90zm8HSkxMVCAQiEJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAKA2SkpIKnMdaEL+TAQEAAAAAAAAAAAAAAAAAAAAAAAAAAABAUTEJGgAAAAAAAAAAAAAAAAAAAAAAAAAAAICrMAkapV6HDh3k8/nsR8eOHYu0fjAYVPXq1cPS2Lp1qzPB5uPIkSOaMGGCBgwYoMaNG6tChQpKSEhQ5cqV1ahRIw0aNEhvv/220tLSIhaTJI0YMcLeHhMmTCj0egsWLLDXu+GGGxyLT/JGjJJ34rzhhhvs7+vfv3+h1/v5558jEudtt91mf89ZZ52lY8eOFXv99u3bKxQKORRp/r799lvdf//9uuCCC1S5cmUlJCQoNTVVf/rTn3TddddpypQpysjIiGhMp7J161Z7m3Xo0CHa4UgKr/MjWVeXVOPGje24+/btG+1wJLl3W/bt29eO64UXXijy+seOHVO5cuXk8/lUpUoVR8tV7nrzZI/4+Hilpqbq7LPPVs+ePTV+/HgFg0HH4ioKN5Rzr7Xl3H68dOv2HDlypJ3eM888c8rlX3/99bAYJk6ceMp1HnzwQXv5SZMmlTjm/Li17jwVjkMF8/q+WZzt+Oijj9rr+P1+jR071mhMJ3J7vXkit+ybJ+PmfPdKW86tx8v8eKXNmXsMoySPSJS7wm7Tgh4rV650PMaTcUMbPodX9s8cXqjjc3PruLGbj0OF4aYylMNL++a+ffv00ksvqVu3bqpXr55SUlKUmpqqs846S126dNFzzz2nX375JSqxFaZOio+PV4UKFdSwYUMNHDhQ//3vfzle5uNU2zIuLk5ly5ZV7dq11bFjRz3//PPavXu3ozHl5tY2J/1LZ+t3t+Z7QWhzRoYbx7xyuK0tRxkyp4OHxhROxc1l3W1lSHJ/H5jzKZzl9n6b29ty+SHPzXB7nF44Z87tfeCixOqWfoYX4vRKvnuhDEnuH5fzWjvJ7duzMDG6pQy5vT7yWl89Nzf/VyCF159FfSxYsMDx+EpLGXJLnCdye19Dcn8Z8lqckrRu3ToNHz5c7du3V7Vq1ZSYmKhy5crprLPOUp8+fTR58mSlp6dHPC63H4ty6+Di/qXbx+VgkAVYlpWYmGhJyvNITEyMdmgl1r59+7DfFBcXZ/3666+FXn/u3Ll5tsuWLVucC/j/S09Pt0aMGGGVL18+37w58VGtWjXrtddeczyuHMOHD7e/e/z48YVe74svvrDXGzx4sGPxWZY3YrQs78Q5ePDgsH1u2rRphVpv48aNEYnz8OHDVp06dezv+r//+79Cr/vFF19YPp/PkmSlpqZGpIznWLt2bZ56qqBHrVq1rHfffTdisZ3Kli1b7Njat28f7XAsywqv8yOZjyXxzTffhOVzfHy8tXv37miH5dpt+dlnn9lxtWrVqsjrT5w40V7/nnvucSDCP5xYbxbl0bJlS2vv3r2OxlcYbijnXmvLuf146dbtuXjxYju9Hj16nHL5Hj16hMXQv3//U65z4YUX2ss7Vc+6te48GY5DJ+f1fbOo23HYsGH28n6/35owYYLRePLj9nrzRG7ZN0/GzfnulbacW4+X+fFKmzP3GEZJHpEodyXZppKsFStWOB7jybihDZ/DK/tnDi/U8Zbl/nFjNx+HCsNNZSiHV/bNf//731aFChVOuU8mJydbDz74oJWZmRnR+IpbJzVp0sTaunVrRGL0yvGyONsyOTnZeuqpp6xgMOhobJbl3jYn/Utn63e35ntBaHM6z61jXm5ty1GGzPHSmMKpuLGsu7UMWZb7+8CcT+Est/fb3N6Wy408N8vtcXrhnDm394FLGms0+hleiNMr+e6FMmRZ7h+X81o7ye3bs7gxRqMMub0+8lpfPYfb/yuwrPD6s6iPL774wvH4SnMZilY7ybK809fwQhnyUpxbt261evbsaR+vT/aoU6eONWvWrIjG5/ZjUW5u7l+6fVwO+SvOPNZ4ATEmGAzqgw8+0O23316o5d977z2HI8rr119/1VVXXaXly5dLkvx+v7p06aLu3bvrnHPOUaVKlXT48GH99NNPmjlzpubOnas9e/bo9ttv17p16/Tiiy9GPGbEnttvv13t27dX5cqVox2KJCk1NVVvvfWWOnfuLEl6+eWX1b9/f11wwQUnXe/48eO66aabZFmWJOmFF15Q3bp1nQ5XkjRt2jQNHDhQgUBAklS3bl31799f7dq1U7Vq1ZSenq61a9dq+vTpmjdvnn755Rf95S9/0eeff64333xTcXFxEYkTzho3bpyk7Pzftm2bsrKy9NZbb+mf//xnlCNzpy5duujMM8/Ujh07tHz5cm3YsEENGzYs9Pq575hy0003ORFivsaOHavWrVvn+1lmZqZ+/fVXffHFFxo7dqyOHj2q77//Xr1799bChQvl8/kiFqcXeKEtl5vbjpcncsv2PP/885WamqojR45oyZIlJ102MzNT8+fPlyQlJSUpEAho7ty5CoVC8vv9+a5z/Phxu23dtGlTVa9e3ewP8DCOQycXS/vm8OHD9dhjj0mS4uLi9M4772jAgAERj8Pt9WZpE+l892pbzi3Hy1Nxc5uzdevWWrFiRYGft2jRQpJ0xhln6NNPPy1wuRo1ahiP7WROtk0LUpR9Opa4ef/0ktI2buyW9gdK7l//+pfuueceSVL16tU1dOhQXXDBBapataokaffu3Vq4cKHGjx+vQ4cOacyYMdqxY4fefvvtqJTxguqkYDCoY8eOaf369Xr22We1ceNGrVmzRpdffrlWr16tlJQUR+Py4vEyv22ZlZWlI0eOaNu2bZo/f77++9//Kj09Xf/4xz+0ZcsWvfbaa47G5NY2J/1LZ+t3t+Z7YdDmdIYbx7zc3JajDDnHK2MKXuDmMnQiN/aBOZ8ChRXNvjp5DrdzYx+4KLGeSjT6GV6I00v57gVuHJfzYjsphxu3Z2FidGMZcmN95MW+utf+K5CkkSNH6s9//nOhlz/77LMdjCYvL5chN8Xplb6GV8qQV+KcP3++rrnmGh06dEiSdNZZZ2ngwIFq27atqlatqvT0dP3444+aPHmyvvzyS23btk3du3fX2LFjNXTo0IjFmcONxyIvcuO4HAyK1AxtuFus3Am6WrVqliSrQ4cOhVo3IyPDqlSpkiXJSkpKisiVK44ePWo1a9bM/q7WrVtbq1atOuk6ixcvtmrUqGGvE4krz3jhKnJeiNGyvBNnfldI6dev3ynXi/Qd2m6++Wb7+xo3bmwFAoGTLn/vvffay1999dWOx5djzpw5VlxcnCVlXzn3ySefPGms8+bNs04//XQ71qFDh0Ys1oK48erfbr7KUH7S0tLsK2H93//9n3X++edbkqzatWtH5Upnubl5W/7zn/+0Y3v00UcLvd727dstv99vSbIuuOACByPMlrveLOwVAH/88Ue77SHJ+uijj5wN8hTcUM691pZz+/HSzdvzyiuvtNPcsGFDgcstWLDAXu7222+3n3/zzTcFrjNv3jx7ufvvv99IvPlxc92ZH45DhePlfbOw2zF3nyQhIcGaOnWq8VgK4vZ680Ru2jcL4vZ890Jbzs3HyxOVhjanZVl2LHXq1Il2KMXapm7ihjZ8Dq/tn26v470ybuz249CpuKkM5XD7vrlt2zYrISHB3i9///33ApfdsWOH1bBhQ/v3TJkyJWJxFrVOOnTokHXeeefZ6zzxxBPOB3kKbjleFnVbrlixwqpZs6a9ztNPP+14jG5tc9K/dJZb8z0/tDmd5cYxLy+05ShDZnhpTOFU3FTWvVCGvNIH5nwKZ7i93+aFthx57gy3x+mFc+a80AfO4eY2Um5eiNMr+e6FMmRZ3hmX80o7yQvb0ytlyAv1kZf66l75r8Cyil9/RkppLUPRitMrfQ2vlCGvxPndd99ZKSkp9ncPGzbspHejHjdunBUfH29JsuLj463FixdHJE4vHItyuLl/6ZVxOYQrzjzW/C8VDZRSvXv3liQtWrRIe/bsOeXys2fP1m+//abExERdfvnlTocnSXrwwQe1atUqSdLFF1+shQsXqmnTpidd56KLLtK8efOUlJQkSbrvvvuUlZXleKyIXYmJiZKkKVOmaNq0aVGOJtxzzz2n2rVrS5LWrl2rJ598ssBlly5dqn/961+SpMqVK2vs2LGRCFGHDh3SwIEDFQwGJUnvvvuuHn74YXu75qdjx476+uuv7bt4jBs3jiuBlwLTpk2zrzDVoUMH9e3bV5K0ffv2k97NJdYNGTLEvtrS5MmTC73eO++8o1AoJCnydyIorEaNGoXdiWLSpElRjMZ9vNCWy83Nx0vJfdszd5pfffVVgcvNmjVLklS+fHk98MADed7Pz6JFi+znXbp0KUmYpQrHocIp7fvmyJEjNXLkSEnZ9da0adPUp0+fqMTi9nqzNIlmvnutLee246UJtDnhZuyfBStN48Zuan+g5N566y1lZmZKkl599VVVrFixwGVr1qwZVq5feOEFp8MrtvLly+uZZ56xX+e+awaKpnnz5vrkk0/s9v7IkSO1d+9eR7/TrW1O+pfOcmu+I/LcOOblhbYcZci80jimEC1eKEPFEY0+MOdToCDRbMuR5yhNotEHRvSR72ZFa1zOC+2k4vDCOCdlqGBe6quX1v8KvMArZSgacXqpr+GVMuSFOAOBgK677jqlpaVJkp555hmNHDlS8fHxBa4zZMgQjR49WlL2XczvuOMOWZYVkXgRHZyb4k1MgkZMufbaayVJoVBI06dPP+XyOQ2Wrl276rTTTnM0NknatGmTXnvtNUlSamqq3n//faWkpBRq3T/96U+66667JEm7d+8+6YkQQEkNGzbMfv7Xv/5V+/bti2I04VJTU8MGlUaPHq01a9bkWS4jI0M33nij3dF/4403VK1atYjE+NRTT9kdtzvvvNOum07lnHPO0csvv2y/fuCBB+yOBLxp/PjxkqSUlBR16dJFAwYMkN+f3Tx7/fXXoxmaq5111lnq0KGDJGnz5s365ptvCrXeO++8I0kqV65coctdNHTq1Ml+vnHjxihG4j5ub8udyM3HS8l92zP3vl+YE4E7dOigevXqqVGjRmHv52fhwoWSpOTkZF1yySUmwi0VOA4VTmneNx977DGNGDHCjmHmzJn685//HPE4cri93iwtop3vXmvLue14aQptTrgZ+2depWncONrHIZiXe+y1YcOGp1y+devWatKkiSRp9erVjsVlQufOnZWQkCApuz46fvx4lCPyrmbNmumee+6RJB07dizsxEsnuLXNSf/SWW7Nd0Se28a8vNKWowyZV1rHFCLNK2WouCLdB+Z8CuQn2m058hylTaT7wHAH8t2saIzLeaGdVFxeGOekDOXPS3310vxfgRd4pQxFOk4v9TW8Uoa8EOe4ceO0YcMGSVK7du10//33F2q9u+++W/Xr15ckrVq1Sl988YVjMcIdODfFe5gEjZhy4YUXqlatWpKy7yx1Munp6froo48kSQMGDHA8Nin7aig5V5q544477CvIFNYtt9yi888/X8OGDVODBg2cCBGQlP2Hbc6Vq/ft26c77rgjyhGF69Kli2688UZJUmZmZtigU44nnnhCa9eulSQNGjRI11xzTURiCwQCeuONNyRlXz33kUceKdL611xzjX0C044dOzRz5kzTISJCtmzZogULFkiSunXrppSUFNWoUUMdO3aUJH322Wfatm1bFCN0t6FDh9rPC3OVw6VLl2r9+vWSsuuwcuXKORZbSeW0BaTsOgN/cHtb7kRuP166bXs2adLE/mOooBOB9+zZY9/toWvXrpL+uLvRsmXL9Ntvv+VZJyMjQ0uXLpUkXXLJJUpOTjYeuxdxHCq80rpvPv744xo+fLik7JOC//e//6lbt24RjeFEbq83SwO35LuX2nJuO16aQpsTbsb+mVdpGTd2y3EIzvnyyy8Ltdzzzz+vKVOm6H//+1+ecVs38fv9qly5sv364MGD0QumFMiZgCRJM2bMcPz73NjmpH/pPDfmOyLLjWNeXmrLUYbMKq1jCpHmpTJUHNHoA3M+BXKLdluOPEdpFek+MNyBfDcnWuNybm4nlYRXxjkpQ/nzYl+9tP1X4BVeKUORitPLfQ2vlCG3xpn7Qpg5/d3CiI+P16OPPqr77rtPM2bMUMuWLZ0IDy7CuSnewyRoxBSfz6e+fftKyj7o/vrrrwUu+8knn+jIkSNKSUmJ2NUtczfk+vXrV+T1zznnHH3zzTcaOXKkK/+8Qeny6quv2gMjU6dO1dSpU6McUbjnn39eZ555piTp22+/1VtvvWV/tnbtWj311FOSpFq1aoVdrclpCxcutE9S6tSpk6pXr17kNHLXDx988IGx2BBZ48ePl2VZkrIHRHNcf/31krKvCv/mm29GJTYv6N27typUqCBJev/995WVlXXS5SdOnGg/v+mmmxyNraRyTtCSZN/lBdnc3pbLj5uPl27bnj6fzz4Zcf369Tpw4ECeZWbPnm3XnSeeCBwMBjV37tw86yxbtsy+im3OsuA4VBSlcd984okn7LsulytXTp999pkuv/zyiMZQEDfXm17npnz3UlvObcdLU2hzws3YP/MqDePGbjoOwaxWrVrZz2+++WbNmTPnlOt07txZffv2VYcOHew7c7pRZmamPZbr9/t1+umnRzkib6tZs6Z9tf9NmzZp69atjn6fG9uc9C+d58Z8R2S5cczLS205ypBZpXVMIdK8VIaKI1p9YM6ngOSOthx5jtIq0n1guAP5bk40x+Xc2k4qCa+Mc1KG8ueVvnpp/q/AK7xShiIVp9f6Gl4pQ26Pc8eOHfYdp8uVK2f/J1NYgwcP1rPPPquePXuqYsWKDkQIN+HcFO+htYCYc+2110rK/oNz+vTpBS733nvvSZKuvvpqlS1b1vG4duzYoS1btkiSzjjjDLVo0cLx7wRKomrVqnrllVfs13fccYf27dsXxYjClS9fXmPHjrVfP/zww/rtt99kWZZuueUWZWRkyOfzafz48fYAQSQsXrzYft6uXbtipdG9e3f7eUF3i4C7hUIhe7CpSpUqYXnau3dvpaamSpLGjRunzMzMqMTodmXKlLGvhL9v3758T/7LkZGRoffff1+S1LhxY11wwQURibE4tm/frjFjxtiv//KXv0QxGndya1uuIG4/Xrpte+Y+sWLJkiV5Pp81a5Yk6ayzzlL9+vUlSR06dFBSUlLY57ktWrTIfs4k6Gwch4quNO2bTz75pB599FFJUmpqqubMmaNLL700Yt9/Km6vN73Kbfnutbac246XJUWbE27G/plXaRg3dttxCGbdfPPNKl++vCRp9+7d6tq1qxo0aKC///3vmjVrlo4cORLlCItv7ty59lW/W7VqpcTExChH5H3nnnuu/XzlypWOfpdb25z0L53l1nxHZLhxzMtrbTnKkHmlbUwh0rxWhooqmn1gzqeAW9py5DlKs0j2geEe5LsZ0RyXc2s7qSS8NM5JGcrLK3310vxfgZd4pQxFIk6v9TW8UobcHuf3339vP7/wwgsVHx8fxWjgZpyb4k2UaMSctm3bqm7dutq6daumTp2qO+64I88yR48e1SeffCJJdsfBaevWrbOfn3322RH5TlO2b99e6Abozz//7GwwBfBCjJJ34szRr18/TZ06VdOmTdO+ffv017/+1VV3arviiis0ZMgQjR8/XgcOHNDDDz+s888/3z6x6K677or4VWx/+ukn+3nOCUxFVbt2bfl8PlmWpV9++UXp6elKTk42FSIi4PPPP9f27dslZTeaExIS7M9SUlLUp08fjR8/Xr/++qtmzpxpXyUe4W688Ua9/vrrkqTJkyerW7du+S738ccf21d0u/HGGyMWX2GEQiEdPnxYv/zyi+bOnasxY8bYE72uvPJK9erVK8oRuo9b23In4+bjpdu2Z6dOneznX331la6++mr7tWVZ9kB+zp2QpOx686KLLtL8+fM1e/bsPGkuXLhQklS9enU1bdrUqdA9heNQ0ZWWfXP06NH65z//ab/OyMhQSkpKRL67KNxcb3qRW/PdS205tx0vi4o2Z/H9/PPPRbq6b+3atVWpUiXnAiqF2D9PzcvjxpJ7j0Mwp2rVqpo2bZp69Ohh34l248aNeuaZZ/TMM88oLi5OTZs21WWXXaauXbvqsssuC+uDuNXu3bt19913269vueWW6AVTitSoUcN+vn//fse/z41tTvqXznNjvp8MbU5z3Djm5cW2HGXILK+PKUSbF8vQybitD8z5FLHLTW058hw5vHbOXGFEug+cm9vbSDm8EmdRRCvfS1MZcsO4nBvbScXlhu1ZFNEqQ26vj7zQV/fqfwWFrT8rVKigevXqOR9QCUWz/VEUkYjTa30Nr5Qht8eZ+87idevWjdj3muD2Y5HXuW1cDsXDJGjEpH79+unpp5/Wl19+qV9//VXVq1cP+/zDDz/U8ePHVaFCBV1xxRURienAgQP282rVqp102YMHD4YdoPOTmJgYdpUcJw0fPlzDhw+PyHcVlxdilLwTZ26vvvqqFixYoP3792vatGmaMmWK+vXrF+2wbC+88ILmzJmjnTt3auzYsZoyZYokqWHDhmFXb4mU33//3X5elIZqbvHx8apUqZJdbxw8eDBPPQZ3GzdunP188ODBeT4fPHiwxo8fL0l6/fXXmXxWgNatW6tp06ZavXq1Zs6cqWPHjuV7dfy3335bUvaxcdCgQZEOU5J02WWXFWn56667TmPHjpXP53MoIm9zY1vuVNx8vHTT9qxTp47q16+vTZs25bl64nfffWcPeuY+ETjn9fz587V7926tWrVKzZo1kyQFg0H7T6jOnTs7GruXcBwqutKwbz711FP2n2Lx8fHKyspSIBDQtddeq+XLl7vuDjNurje9xM357qW2nOSu42VBaHOad/PNNxdp+fHjx+uGG25wJhiPY/8sPi+PG7v5OASzOnfurBUrVuj222/XF198EfZZMBjUihUrtGLFCj3//POqXLmyHnjgAd1zzz1RO8GpoJMIAoGAfv31Vy1evFjjxo2zTxa7+OKLqd8NyV3uc9dvTnFjm5P+pfPcmO8nQ5vTHDeOeXmxLUcZMs8LYwpu5cUyJHmrD8z5FLHHbW058hw5vHjO3KlEug+cmxfaSJJ34iyKaOW7V8qQl8bl3NZOyo+XtmdhRasMub0+8kpf3Wv/FUiFrz979OihmTNnOh9QCUWz/VEUkYjTi30Nr5QhN8eZ+07UlStXdvz7THL7scgrvDQuh6LzRzsAIBquvfZaSdlXc5g2bVqez9977z1J0jXXXKOkpKSIxBQKhezniYmJJ1121qxZatGixUkf3bt3dzpkQJJUpUoVvfLKK/brO+64Q3v37o1iROEqVKigN998U1J2Ofv9998VHx+vd955R2XKlIl4PJZl2c9L0ljy+/84hMfFxZUoJkTW77//bg+GnHfeeWrRokWeZS699FL7qnFffPFF2BXJEG7o0KGSpGPHjuU7yLRv3z599tlnkqSePXu6tlMbFxenxo0b64477tDSpUs1adKkqNRRXuHGttypuPl46bbtmXO13GXLlikjI8N+f9asWZKkhIQEdezYMWydLl262M8///xz+/mKFSvsga3cy8QyjkPF5/V9M+ekpho1amj58uU677zzJEkbNmzQnXfeGZEYisLN9aaXuD3fvdSWc9vxsjhoc8LN2D8L5uVxY7cfh2BWw4YNNX/+fP3444967LHHdNFFF+V7MsP+/fv1j3/8Q61bt7avrh1pN998c77l44ILLlDPnj317LPP2icGdu7cWTNnzlR8PNeVNiEQCNjPc49xO8mNbU76l85zY77DWW4d8/JqW44yZFZpGFOIFq+WoVNxUx+Y8ylij9vacuQ5SrNo9IERfeT7yXlpXM5t7aT8eGl7FhZlqGBe6at76b+C0sgrZSgScXq1r+GVMuTWOHPnUe79DMjhpnE5FJ17j2yAg1q2bKmzzz5bkjR16tSwzw4ePKg5c+ZIkgYMGBCxmHJfYebgwYMR+14Txo8fL8uyCvU48WovxOjNOE/Ur18/9enTR1J2Y/Wvf/1rlCMK1717d/vPZUm699571aZNm6jEctppp9nPc19lqqhy1vX7/Tr99NNLHBci591337U7VvndiUDK7nBff/31krI74jl/RCKvgQMH2ic9TJ48Oc/n7777rjIzMyVJN954Y0Rjy23s2LH21c1WrFihr7/+Wm+++aYaNGggKbssd+rUSU8//bTatm0btTi9wo1tucJw6/HSbduzU6dOkrIHoZYvX26/P3v2bEnShRdeqNTU1LB1mjVrZt8FIncbadGiRXnSjXUch4qvNOybZ555phYuXKimTZtq8uTJ9kmVEyZM0LvvvhuxOArLrfWm17g5373SlpPcd7zMD21O87744otCj9NYlsVVdk+C/bP4vDxuLLn7OARnNGrUSI8++qgWL16sgwcPau7cuXr44YfVtm3bsJNMVq9erW7duoVNbIm2pKQkValSRW3atNHtt9+uhQsXas6cOYy/GnTo0CH7eXHvvFBUbmxz0r90nhvzvSC0Oc1w65iXV9tylCGzvDCm4FZeLUNe6wNzPkXscVNbjjxHDq+eM3cy0egD5/BCG8lLcRZFtPLd62XIreNybmonFYVbt2dhRKsMeaE+8lJfXfLOfwWFrT+9cBdoKbrtj6KIRJxe72t4pQy5Lc5KlSrZz/fv3+/od5nmhWORF3htXA5FwyRoxKx+/fpJkhYvXqzdu3fb70+fPl0ZGRmqWrVqnqusOymnUpWkjRs3nnTZ/v37F3gwq1mzptOhAvl69dVXVaVKFUnZ5ej999+PckTh/vSnP9nPGzVqFLU4ilLWC7J9+3ZlZWVJkqpXr+7qq3Uhr3HjxtnP77//fvl8vnwfI0eOtJebOHGi0tPToxGu651++unq0aOHJGnu3Ll5rhT29ttvS5Lq1KkT1QmQZ599tpo3b24/LrjgAt188836/vvv1blzZ2VmZurFF19Ux44ddfTo0ajF6SVua8sVlluPl27anh07drQHwBYvXiwpe+Bz6dKlkqSuXbvmWcfn86lz586SpC+//FLBYFCStHDhQklS06ZNVb16dcdj9wKOQ8Xn9X2zdu3aWrhwoX3C5Xnnnacnn3zS/vy2227Tpk2bIhJLUbi13vQKt+e7V9pyOdx0vMwPbU64Gftn8Xl53NjtxyE4LyUlRZ06ddKTTz6ppUuXatOmTfbkM0lavnx5nolAkVDQSQTp6enau3evvv32W7366qu69NJLIx5babdr1y77eaTqJTe2OelfOs+N+Q5nuXXMy6ttOcqQeW4fU3Arr5YhL/aBOZ8idritLUeeozSLRh8Y0Ue+n5wXx+Xc0k7Kjxe356lQhgrm5b66W/8rKI28UoYiEWdp6mt4pQy5Ic7c+b5jxw5Hvwvu5MVxORQeIz6IWTlX5wqFQpo+fbr9fs4J1X379lVcXFzE4qlfv759BfeNGzeG/fEFeEGVKlX0yiuv2K/vvPNO7d27N4oRudNFF11kP//qq6+KlcaCBQvs5x06dChhRIik1atX6/vvvy/yer/99pumTJniQESlQ86VC7OyssImRq1du9be3kOGDHHln51ly5bVtGnT1LBhQ0nS0qVL1bt3b1fdBcmt3NaWKyy3Hi/dtD1PP/10NW/eXJK0ZMkSSdLnn39uDyjmdyKwJHXp0kWSdPjwYS1fvlyWZdnH2pzPYh3HoZLx+r45Y8YMnXXWWWHv3XvvvbrsssskSUeOHFH//v3tKwO7hVvrTa/wQr57qS3npuNlUdDmhJuxf56al8eNvXAcQskEAgFt27ZNy5YtK9SfxPXq1dPEiRN1zz332O/l3PkWsWHZsmX280jeNcdtbU76l5HhtnyHc9w85uXlthxlyCyvjilEm5fLUH7oA58a51M4z21tOfIcpVm0+sCILvIdKBnK0Mm5ta/OfwXu4ZUyFIk4vdTX8EoZ8kKcrVu3Vnx8vCTp66+/ViAQKNL6O3bs0K233qr//ve/YZP14X2My5UO/BuBmNW0aVP7Cl05f27u27dP8+fPlyQNGDAgovH4fD716tXLfj1p0qSIfj9gQt++fdW3b19J0v79+3X77bdHOSL36dChg0477TRJ0rx58056laGcOzmcaPLkyfbzbt26mQ0QjvrPf/5jP3/ggQc0derUkz4eeughe/nXX389GiF7QufOnVWrVi1J4eVj4sSJkiS/368hQ4ZEJbbCKF++vN577z0lJiZKkubMmaOnn346ylG5n9vackXhxuOl27bn5ZdfLumPAc958+ZJyp4M2bJly3zX6dKli30XpSVLlujHH3/UgQMH7M/AccgEL++blSpVyvOez+fTxIkTVbFiRUnSd999pwcffDBiMRWWG+tNr/BCvnupLee242VR0OaEm7F/npyXx429cBxCyYwcOVJ169ZV27ZtNXfu3EKvd99999nPuQp77Pjhhx/sCxo1btxYVapUidh3u7HNSf/SeW7MdzjDzWNeXm7LUYbM8vKYQjR5uQwVhD7wyXE+hfPc1pYjz1FaRbMPjOgh34GSoQydmlv76vxX4A5eKUORitNLfQ2vlCEvxFmuXDl7wvrx48e1aNGiIq3/0Ucf6c0339Rf/vIX3XnnnQ5EiGhiXM77mASNmNavXz9J2Vd32bNnj6ZPn65gMKhatWqpXbt2EY/nrrvusq++NGrUKG3fvj3iMQAl9corr9gdkg8++EDvvfdelCNyl+TkZN12222Ssq/G9thjjxW47NVXX62rrrpKM2bMsN9bvHix5syZI0mqVauWPRkE7peRkWF3iMuUKaNHH31Uffr0Oenj0UcfVYUKFSRlX5Fq9erV0fwJruX3+3XDDTdIkr755htt375dlmXZ9U+XLl1Uu3btKEZ4as2bN9ejjz5qvx42bJjWrFkTxYi8wW1tuaJw4/HSTduzU6dOkqSdO3fq119/1ZdffikpezA/52TfE1WrVk1NmzaVJK1atcpeJzk5WZdcckkEonY3jkNmlMZ9s1atWnr11Vft1y+88II+++yzKEaUPzfWm17mpnz3WlvOTcfLoqLNCTdj/zy50jZu7KbjEEqmQYMG9vNPP/200OuVK1fOfn7mmWcajQnulbvcDxo0KKLf7cY2J/1L57kx32GeF8a8vNqWowyZ5+UxhWjyahk6GfrABeN8iuiJVluOPEdpFc0+MKKHfAdKhjJ0am7tq/NfgTt4pQxFKk4v9TW8Uoa8EufQoUPt5y+++GKh1wsGg3rllVfs1wMHDjQaF9yBcTlvYxI0Ytq1114rSQqFQpoxY4Z9xd3+/fsXeIKBk84991z7jlYHDx7UgAEDdOTIkUKvv3z5ch08eNCh6IDCqVKlSlgD8PHHH49iNO704IMPqnr16pKksWPH6p133smzzIEDBzR37lx98sknuuaaa3T55Zdr0aJFdr0lZV9RKSkpKWJxo2Q++ugj+64cPXr0UGpq6inXKVOmjPr372+/fu211xyLz+uGDBliH7tnzpyppUuX6pdffpEk3XjjjdEMrdAefPBBtWjRQpKUmZmpm266SaFQKMpRuZvb2nJF4cbjpZu25yWXXGJfbW327Nlau3atJKlr164nXS/n89WrV+vrr7+200pOTnYwWm/gOGRGad03BwwYYN9txrIsDR48WLt3745yVOHcWG96nZvy3UttOTcdL4uDNifcjP2zYKVx3NhNxyEU35VXXmm3j9955x398MMPhVrv448/tp/nXI0dpduyZcvsO7VWrFgxKm08t7U56V9GhtvyHeZ5YczLy205ypBZXh9TiBYvl6GToQ9cMM6niJ5oteXIc5Q2bugDI/LId6BkKEOF58a+Ov8VRJ9XylCk4/RKX8MrZcgrcfbr10+NGjWSJH3yyScaP358odYbPXq0fvzxR0lSkyZN1LNnT6dCRJQxLuddTIJGTDv33HPVuHFjSdJ//vMfLVq0SJLsAd1oeOaZZ3T++edLkpYsWaIWLVpoyZIlJ11n//79+sc//qF27drp2LFjksSfZIiqvn372lc8ysjIiHI07lO+fHm99957SkhIkCQNHjxYTzzxRNi2qlSpkhYsWKDrr79efr9f8+fPV/v27bVr1y5J2VcpGjJkSFTiR/GMGzfOfl6Uq5flviLV5MmTdfToUaNxlRb16tXTZZddJin77pBTp06VlD1hqkePHtEMrdDi4+P15ptvKi4uTpK0dOlS/fvf/45yVO7mxrZcUbjteOmm7ZmSkqILL7xQkvSvf/1LlmVJyr5i6cnkfL527Vp99dVXhVonVnAcMqM075uvvvqqatWqJUnat2+fBg4c6LrBPbfVm6WBW/LdS205Nx0vi4M2J9yM/fPkSuO4sVuOQyi+KlWq6L777pMkBQIBde7cWbNmzTrpOl999ZX+9re/ScpuA3jlGIriW758ua655hplZmZKyj6JpHLlyhGPw21tTvqXkeG2fId5Xhnz8mpbjjJkltfHFKLJq2XoZOgDF4zzKaIrGm058hyliVv6wIgs8h0oGcpQ0bixr85/BdHllTIUjTi90tfwShnySpxxcXEaP3684uPjJUk333yznnvuOQWDwXyXD4VCGjVqlH134MTERL311lvy+5luWVoxLudd8dEOAIi2a6+9VsOGDdN3330nSWrQoIF9VYdoKFOmjGbNmqVrr71Wc+bM0aZNm3TRRRepefPm6tevnxo2bKgaNWro6NGj2rJliz799FPNnj1bx48ft9M4//zzuUsbou6VV17RggULtG/fvmiH4krt27fXzJkz1a9fPx07dkyPPvqo/vOf/2jAgAFq166dqlatqkAgoDZt2ujbb7/V+vXr7XUTExPtq12jYKNGjVL58uVPuVyZMmUcv5Pgrl27NGfOHEnZncCinJTWtm1bNW7cWGvXrtWRI0c0efJk3XrrrU6Fmi83bcuTGTp0qObPn6/Fixdrw4YNkqTrr7/eHsDwgtatW+vOO+/Uiy++KEl65JFH1LNnT9WuXTvKkbmX29pyReW246Wbtufll1+uhQsXauXKlZKkZs2a2VdmLMjFF1+slJQUpaWladOmTZKidyKwm+pOjkNmeX3fLEjFihU1YcIEderUSZZlaf78+Ro9erQeeeSRaIcWxk31ptv2zeJwU757qS3npuNlcdDmLLyff/5ZFStWLNI6FSpUUL169ZwJKAa4Zf90Yx1fGseN3XQc8go37ptPPPGENm3apClTpmjPnj3q1q2bLrzwQl1zzTVq3LixKleurCNHjmjjxo363//+p08++USWZalChQr68MMPXXmsR+Hld6wMBAI6fPiw1q9fb989IWfSxJ133qnbbrstCpFmc1ubk/5lZLgt309Em7P4vDTm5eW2HGXILK+PKUSLl8vQybilD+xGXj6fwo39tqKIVluOPHeeV+J0My/1gb3SRvJCnF7Kd8CNvFKGvFAf5ebGvjr/FTjDy2XILXF6pa/hlTLklTjPP/98TZo0SQMHDlRWVpbuv/9+vfbaaxo0aJAuvPBCVapUSYcOHdJ3332niRMnat26dZKkhIQETZw40b4YXyR56VhUGvqXjMt5lAVYlpWYmGhJyvNITEyMdmgl1r59e/v3ZGZm5vl8w4YNYb95+PDh+aZz3XXX2cts2bLF2aAtywqFQtbYsWOtWrVq5Zs3+T1at25tvfPOO1YwGHQ8vuHDh9vfO378+EKv98UXX9jrDR482LH4LMsbMVqWd+IcPHiw/X0bN24s1DpTp04N20cjEWdBirudnfbzzz9bXbt2LVQZT01NtZKSkixJVlxcnHXXXXdZu3btilrsW7ZssWNr37591OLILXedX9hHhQoVHI/rySeftL/vrrvuKvL6zz77rL1+8+bNHYgwL7duy5M5fvy4VbFixbCYfvzxx6jFk7ve/OKLLwq93pEjR8KO/927d3cuyFNwQzn3WlvO7cdLL23PJUuWhMXy97//vVDrdevWzV6nevXqjsRWELfWnRyHzPLSvpl7Oxa2rN577732OvHx8dZXX33laIxurzdP5OZ9M78Y3Zrv+XFTW85Lx8vS0Oa0LMuOo06dOlGNw7LCt2lxHj169Ihq/G5ow+fw2v7phTrestw/buzV41AON5WhHF7YNzMyMqzRo0db5cqVK1R87dq1s3744YeIxljcOslN3HK8LM6xskKFCtZLL70U1bgty11tTsuifxkpbst3y6LNaYoXx7zc3pbLD2WoaLw0pnAqbinrubm5DHmtD3wizqcoGbf327zUliPPYytOL5wz56U+sJvbSF6L0yv57oUyZFneH5dzWzvJC9vTK2XIC/VRQdzYV7csb/xXYFnuK9cnKs1lKJr/FXihr+GVMuSVOC3LshYvXmw1atSoUHE2aNDA+vLLLyMan5eORW7uX3p9XC5WFWceK/dnR8xr0KCBmjdvbr/u379/9ILJxefz6aabbtLmzZv10Ucf6dZbb1WrVq102mmnKT4+XqmpqTrrrLPUpUsXPfHEE/ruu++0bNkyDRw4UH4/RRvu0KdPH/Xr1y/aYbha/fr1NWvWLH333Xe677771LZtW5122mmKi4tTSkqKzjnnHPXp00dvvfWWdu7cqVWrVunSSy9VMBjUyy+/rLp162rmzJnR/hk4hQkTJtjPBw4cWOT1Bw0aZF/9auXKlVq6dKmp0EqV5ORk/eUvf7Fft2vXTo0aNYpiRMVTrlw5vfLKK/brTz/9VO+++24UI3I3t7blisJNx0s3bc82bdqEXS2usHdy6dq1q/28c+fOxuPyIo5DZpX2fXPUqFE677zzJElZWVn6y1/+ot9//z3KUYVzU71ZWrgh373UlnPT8bK4aHPCzdg/T640jhu74TiEkklISNCDDz6ozZs366233lLfvn3VqFEjVa1aVQkJCapUqZIaN26sm2++WbNmzdLixYvVpEmTaIcNh8TFxal8+fJq0KCBrrnmGr3++uvasmWL7rrrrmiH5ro2J/3LyHBbvsMcL455ebEtRxkyqzSMKUSTF8vQqdAHPjnOp4ieaLXlyHN4jZv7wHAO+Q6UDGWo5NzaV+e/gsjwShlyW5xe6Gt4pQx5JU5Juuiii7RmzRp99NFHGjp0qJo1a6aKFSsqPj5eZcuWVf369TVgwABNmzZNa9eu1cUXXxyVOBEdjMt5j8+yLCvaQSD6kpKSlJGRkef9xMREBQKBKERkjmVlXw7AbKKSfKTp2jS9EGOMp+nEoSc7TbOBhixLPp/ZNIOhkEr68y3L0tQp7+ulF/+lH9eu0fqfNqtKtapmAsz1HX6Dv91yYFs6kWacz6e4ONOFSOb3o6ClkOGjWzBomS/rIUs+v9lE0zODChquQ46kZykrZHh7WpaS4uKMpXcsPUs+w3meHshUvOF9M5B+XIk+s3EGskJKSko0mmam/CpTJslomsGQpaTEeKNpZmQFlRBn9qSc4+mZijdcLjOzQkpMMLe/S1JGVkiJ8eZ+eyAzaDQ9SbJ8PqWUSTCaZmbQUoLh41BGVkgJhvM8IxhSouF90x/nU1nDZSgp3q8Uw/umFbIkw9tTluQ3nGbICslnum0csiSDx42Q4fZmjjjD29KJNmcwFJITHTfT29OJ3256P5Kc2ZecSNPnM7t/Wg7sRk7UHV7pC8qS8b6Lz2cpzmf2eOnWcYoTOXG8dKJ/aTpNL8QY62k60e5yok7KCAZleJhCsmS8f2lZltHtGcgy/7uDoZDiDE92ieU0LctSvOn9KGS+DZ+WFcxudxoUCIYUZ7isp2cF5TfY9gqGLCUlmM0fJ8Yp0jNDxrvVWSHL+DhFRlZI8YZ/e8iSkg3nkc8n42MfIctSvOH643hmUKY7MMGQ+f3Tktl9KStkGR+LdSJNv8+nJMNlyIkhtKyQ+f+xQiGz7RnJmWNbnF9KjDdc1kOW8fNo0rOyFAyZSy8zGDK+LTND5sd8vNOWCxmv330+nxJN/3YrVOI+lmVZmj71fb360ota9+NafffjRp1euYqhCHO+w/z2dGL/PJ6RJcsyl2ZmKKQEw787Ixgq8bHNsiz9b8ZUjX/93/pp/Y+at+xHVTN8Dk1mMGS8X50Y51Nqstn/xixLxvdNS5bx/lBm0JIMn1cQtMzHaTpNJ2KUZLxcBkMOjEM78Nv9fifGu4z/jeWZNH0y346VzJ8zZ/q8U0uW+f/GYjlNB87h9cp/jU78h+dEnFlBw2edOnG+SyhkvJLLCpr/c92JNpLlyPlDDvSDLUumLzPmxLiPiTGanP7lv1/6l9b9uFar1/+sKlUN9jUsGR/rc2JczpHT5Rz639Z0mj7J+H9jcuKY4dB5Y16YmxMy3T50oK0d5/MZ/8+pNCjOPFYmQUNS6Z0EbVlSIBjtKADkZlmWsoKmGxuWMg2f1JQdp9EkFQpZOnQ802ia27duVvUz6xpNU5IS4nzmTyp3uTi/T9UrJBn/3fGGt2UwZGn/kbzH7JIIhSwdNrxvOiE9K6jluw8aHYhLywhq9pq9Rk+y9fukCmUTjeV7RkZQP27cb3RiQjArqP2/7jd6pRgrM6DQtjUyGqjPL5U73WiP0p+QoNMa/Ek+g38E+v0+nV65nNGyblmWMjLMHoiysoLau+s341cISkxKMN/rN8iyLGUGzNZxCYlxanTema69c0QOy7IUCGRFO4xTSkrwq13DqkYHIVMS4nR1w6pmJxxaVvZJGQb5JJVJijNef5hub4csS2mG6yTTfD6pQpkE17dhnegT+CSlJJrdj5zghf3IKX6fdHo5c30Ny7KMX8THibrDS0z327LrpHgH6ndjyUlypk5y4ngJmOBEu8sJmcGQNu0/arTb5vdJVVLMj3kl+M3VnRnBkH7cf8j8BW1hjF9SxSRz4105kuL8RtNMzwrpu52HZHD+lYIhSwfSzB4vs4Ih/XrwuLH0/D6pYlnz5dy0rGBIe34/brSs+yQlJZrdj0KWpUCGyb3o////cFoZo3EmxvnUrGY5oyc2+SSVSTDbNs4IhrRhb7rxfC+TYDbf/T6pSlmzbXgvSPD71Oj0VEcuVGdS0LJ0yPAYr1NMH9sS4nxqUNVsHjkxRpOeFdTynb8ZK+shy9LxTPNjnMczzdbvXuFEvRnv96luhRTjF1YPmJxJL+mXbVt0rGwV1x+HnNg/A1khrd55xPjF70wKWZYCmWbro7R9O5VSpabRNJ1QNjFOvZpVN/o/lk9ShUSz/5P4JCUbPrZlhULac9y756O6SZzPp2plzPYFQ5aldMN1sRPi/T7VPb2s69uxXuF34D8Nyfx/L7H+X5bbOXEOr1c48R+eE7LPOzV3DHbif5eQZem44YkfwZClA8fNnm/rRBtJ8sZ52078F+zUuI/pMZpd27eoUo3axtLzS6qQ5P7znJzixP5u8r9LKbuNVDnViXkF5i8UY/q3e2VujmVZyvBI+7BmxUQmQp+gOPNY3X3GNlBC3qjOAJSUV8q66SvNSNKZdeoZT9Mn841rL/D7nPndbr9ikVNpOiHLgavSB7JCxu8y5POZ7UxmBc3fmS0UCpmvPINZZidAS9mToE3fhTEu3ugEaCl7ErT5q3kaTU6SFAqaz3efz+fqCdCS+SsBS1J8fJzrJ0BLzuxHTkiM9xu/CmNSvN/8HYGNppbN51D7wzQv7Et+w8dfpzjR7mI/cj+v7J+xzHT+ONW/NM2JOimGizpczivHSyfGPpw4DpkeP8wKGb77BIwzPd4lOTMOnRkMGZ0ALXljPNaJ/HFCyDJfx8mJ+t2BCsmJujg+zmf8hH8njpdZDgxFOxGnV9rwpsX7ze9HTvDKvR2cOLbFOZBHTmxO03cTcyJGj+xGjnCi3ozzObBvGk0tW+WatT1xHHKmXFru3+8diM8LE6AlZ/7Hcmoc2vw5L0aTi2mx2oaVnGkjxTKnxk5jdf+MVVTv7md+TNIb7WKnzo31wni5E5zYmk6M+zixPavXqms0Pa+M6zvBifxxIk2v9LGc+O1eOa57JU4p+4IPKDn3n7UNAAAAAAAAAAAAAAAAAAAAAAAAAAAAIKYwCRoAAAAAAAAAAAAAAAAAAAAAAAAAAACAqzAJGgAAAAAAAAAAAAAAAAAAAAAAAAAAAICrMAkaAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKswCRoAAAAAAAAAAAAAAAAAAAAAAAAAAACAqzAJGgAAAAAAAAAAAAAAAAAAAAAAAAAAAICrMAkaAAAAAAAAAAAAAAAAAAAAAAAAAAAAgKswCRoAAAAAAAAAAAAAAAAAAAAAAAAAAACAqzAJGqWaL9oBAIgIr5R1v898pE78dkuSZVkOpOxuIcuZ3206TSf2IyfSdEK832d8n0+K98tvOFHLsozme3ycX6azyO/3m69A4uJlPFArJBkuQ1YwS1YoZDTNUMhsnkvmN6Uk+ePM57tlWcbzyDSfAxszKyuokOH9yAkeqd6VkRVSKGR2PwpkhRQ0nKYj7S6H2h+meWFfChk+/jrFiXYX+5H7eWX/jGWm88ep/qVpXhmnAEzwyvHSibEPJ45DpscP4/1+6g+XMz3eJTkzDp0Q5zf+57cXxmOdyB8n+H3m6zg5Ub87UCE5URdnBS2FTJdLB7ZnvAND0U7E6ZU2vGlZIfP7kROcGON1ghPHtqADeeTE5oyPM9uecyJGj+xGjnCi3gxaDuybRlPLFu9A+8OJ7elMufS5f793e3wOcuJ/LKfGoc2f82I0uZgWq21YyZk2Uixzauw0VvfPWEX17n7mxyS90S526txYL4yXO8GJrenEuI8T29N839Ib4/pOcCJ/nEjTK30sL+zvTvFKnJIU5/pBGm/wWbFacyJMUlKSMjIy8ryfmJioQCAQhYjMsazsit1sonKgJUOark2PNJ2ZMGVYdppmAw1ZlvHOVTAUMj5XzApZxv8lsCzLaOffcmBbOpFmnM+nuDgHTgI3vR8FLYUMH92CQct8WQ9Z8hneN9MzgwoaLkRH0rOUZfgPxqBlKSkuzlh6x9Kz5DOc5+mBTMUb3jcD6ceV6DM/kTEpKdFompnyq0yZJKNpBkOWkhLjjaaZkRVUQpzZU3ePp2cq3nC5zMwKKTHB3P4uZU+KTYw399sDmUGj6UmS5fMppUyC0TQzg5YSDB+HMrJCSjCc5xnBkBIN75v+OJ/KGi5DSfF+pRjeN51od8mS/IbTDFkhmT61KxSyjP7jFDLc3swR50C72Ik+gRMdNycmUpj+7ab3I8mZfcmJNH0+s/un5cBu5ETd4ZW+oCwZ77v4fJbifGaPlzE9TuFA/9J0ml6IMdbTdKLd5USdlBEMyvAwhWTJeP/Ssiyj2zOQZf53B0MhxfnN/u5YTtOyLMWb3o9C5tvwaVlB8xfaCoaMn5yQnhWUyeliwZClpASz+ePEOEV6Zsh4tzorZBkfp8jICine8G8PWVKy4Tzy+WR87CNkWYo3XH8czwzKdAcmGDK/f1oyuy9lhSzjY7FOpOn3+ZRkuAw5MYSWFTL/P1YoZLY9IzlzbIvzS4nxhst6yDJ+Hk16VpaCBq8dmhkMGd+WmSHzYz7eacuFjNfvPp9PiaZ/uxUy3scKZJn+Z92Z7enE/nk8I0uWZS7NzFBICYZ/d0YwZP6/y2DIeB/YiTQT43xKTTb735hlyfi+acky3h/KDFqS4fMKgpb5OE2n6USMkoyXy2DIgXFoB3673+/EeJcD1/73SJo+mW/HSubPmTM/acgy/99YLKfpwDm8Xvmv0Yn/8JyIMytouG3sxPkuoZDxSi4raP7PdSfaSJYj5w850A+2LOMXI3Vi3MeJMRrjfVZLxvtDTozLOXK6nEP/25pO0ycZ/29MThwzHDpvzAtzc5y4WKzptnacz2f8P6fSoDjzWJkEDUmlexI0AAAAAAAAAAAAAAAAAAAAAAAAAAAAoqc481jNXkouxo0aNUqPPPKIJGnw4MGaMGFCkdMIhUIaMGCAgsFgiWKpXbu2nn/++RKlAQAAAAAAAAAAAAAAAAAAAAAAAAAAAEQDk6AN2bBhg0aNGmUknSlTppQ4ncaNG5c4DQAAAAAAAAAAAAAAAAAAAAAAAAAAACAa/NEOoDQ4cuSI+vbtq2PHjpU4rRUrVhiICAAAAAAAAAAAAAAAAAAAAAAAAAAAAPAuJkGXUHp6unr16qUffvjBSHorV640kg4AAAAAAAAAAAAAAAAAAAAAAAAAAADgVUyCLoGjR4/qyiuv1Lx584yleeIk6CeeeEKWZRX5sWbNGmMxAQAAAAAAAAAAAAAAAAAAAAAAAAAAAJHEJOhiWrt2rdq0aaP58+cbTffESdAtWrQwmj4AAAAAAAAAAAAAAAAAAAAAAAAAAADgdvHRDsCL3n77bd1+++1KS0szmu7OnTu1b9++sPeYBA0AcLPt27dr//790Q7jlCpXrqzatWtHO4xSwYk8J3+A2BDL9YdXfrtX4gRMiNX93Su/m36G+5FHMMEr+xHczSvHIeojs6g/zGL/jD3Uc0DJeOU4FMvtJNNxUsfFplgu64g9sVq/S5ShWMR+ZJZXtqdXjuumsW/GXp47xfS+5JX88Up9FMtlHYgl1B9AyVCGSgkLhbZ+/XqrR48elqRTPgYPHlzk9D/++OOwNKpVq2b+RxQgMTEx39+RmJgYsRgAILddu3ZZw4cPt3bt2kWaLk1z27ZtVkpKSqGOi9F+pKSkWNu2bTP2253YnqZ5Kc+9kD+kSZpuTM9LacZy/eGV3+6FOL2yv5Om+9P0wv5uWeZ/u1d+N/2M2C1DsZhHXsnzWN+PeLj74ZXjkNvrIy+lSf3h7nLklf0oltOknnN3ml6IMdbT9NJxKFbbSU7ESR0Xe2nGclnn2BZ7acZy/U4Zir00Y3U/cipNr2xPLx3X3b4tvXC+nGXFdp57YV/yUv54pT7yQlknTXen6YUYYz1N6g93p+mFGGM9Ta+UoVhTnHmsPsuyLOGk9u7dq5EjR+rNN99UVlZWns/vuusurVixQosXL7bfGzx4sCZMmFCk73niiSf06KOP2q+vuOIKffbZZ8WOuyiSkpKUkZGR5/3ExEQFAoGIxAAAuX3//fdq1aqVli9frpYtW5Kmi9McPXq0zjrrLCNpOmHz5s166KGHXL89TfNKnnslf0iTNE2k6YUYnU4zlusPr/x2N8fptf2dNN2fppv3d8m545BXfjf9DPenSR5xbDORptv3I7ibV45DXqiPvJgm9YcZ9NtiN03qOXem6YUYSdMbxyHaSebipI6L7TRjuaxzbIu9NGOtfpcoQ7GcZqztR06n6ZXt6fbjumle2TedEKt57hSnxg/dnj9eqY+8UtZJ091peiFG0qT+cHOaXoiRNL1RhmJNceaxxjsdVGkwatQovfrqq3neT01N1YsvvqghQ4aoQ4cOJf6eFStWhL1u0aJFidMEAMBpZ511ls4999xoh4EIIs8BFFcs1x9e+e1eiRMwIVb3d6/8bq/EGcvII5jAfgS3Yt90P/IIKBnKEFAysVyGvPLbvRIn3I39CLHEK/u7V+KEu7EfmeWV7emVOGEOee5usZw/sfzbAZQM9QdQMpQh72MSdDF1795dr7/+umrVqmUszZUrV4a9ZhI0AAAAAAAAAAAAAAAAAAAAAAAAAAAAYpE/2gF4TZMmTfTxxx/rk08+MToB+vDhw9qyZUvYe0yCBgAAAAAAAAAAAAAAAAAAAAAAAAAAQCziTtCF1Lp1a919990aMGCA/H7zc8dXrlwpy7Ls16mpqapfv75CoZA+++wzffTRR/r666+1Y8cOHTt2TJUrV1bNmjV12WWXqUePHmrXrp3xmAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBoYBJ0IQwbNkyVKlVy9DtWrlwZ9rpZs2aaNGmSHn30UW3bti3P8rt27dKuXbu0bNkyPf3007rsssv07LPPqmXLlo7GCQAAAAAAAAAAAAAAAAAAAAAAAAAAADjN/C2NSyGnJ0BL0ooVK8Jef/3117r++uvznQCdny+++EIXXHCBxo0b50R4AAAAAAAAAAAAAAAAAAAAAAAAAAAAQMRwJ2iXOPFO0MFgMOz1mWeeqbp166pixYrat2+fVq9erePHj4ctk5mZqRtvvFG//fab7r//fqdDBgAAAAAAAAAAAAAAAAAAAAAAAAAAABzBJGgXyMzM1I8//pjvZwMHDtTf/vY3tWnTJuz99PR0ffzxxxo2bJjWr18f9tk//vEPNWnSRFdcccUpvzsQCCgQCBQ/eABAzNu8eXO0Qzgpt8fnRSa3KfkDxJZYrj+88tu9EidgQqzu71753W7fpm6PLxLcvg3cHh+ykU8oCa8ch9jPncF2NYPtGLuo54CScft+TzvJXNpuz2s4y+357/b44C2xVr+bTgvewn5klle2Z6zlVaz93vywDcxwaju6PX+8Uh+5fTsCMIv6AygZypD3MQnaBdauXauMjIyw91JTUzVx4kT16tUr33WSk5PVt29fXX311Ro8eLCmTJlifxYKhTR06FBt3rxZycnJJ/3u0aNHa+TIkSX/EQBg2BlnnKHhw4frjDPOIE2Xplm5cmWlpKTooYceMpamU1JSUlS5cmVj6TmxPU3zUp57IX9IkzTdmJ6X0ozl+sMrv90LcXplfydN96fphf1dMv/bvfK76WfEbhlygtvzyCt5Huv7EdzNK8cht9dHXkqT+sM8+m2xlSb1nLvT9EKMsZ6ml45DsdpOciJO6rjYSzOWyzrHtthLM5brd4kyFGtpxup+5FSaXtmeXjqum+aFfdMJsZznTjG5L3kpf7xSH3mhrJOmu9P0Qoyxnib1h7vT9EKMsZ6mV8oQTs1nWZYV7SBKgw4dOmjhwoX268GDB2vChAmFWnfx4sV64IEHtHnzZu3du1d+v18ffvihrrrqqkKtHwwG1bFjRy1atCjs/eeff1733HPPSdfNuRN0lSpV8kzElqTExETuFA0AKND27du1f//+aIdxSpUrV1bt2rWjHUap4ESekz9AbIjl+sMrv90rcQImxOr+7pXfTT/D/cgjmOCV/Qju5pXjEPWRWdQfZrF/xh7qOaBkvHIciuV2kuk4qeNiUyyXdcSeWK3fJcpQLGI/Mssr29Mrx3XT2DdjL8+dYnpf8kr+eKU+iuWyDsQS6g+gZChD7pOUlFTkeaxMgjakJJOgczt27Jj27t2revXqFWm9TZs2qWHDhgoGg/Z7jRs31po1awq1fnF2HgAAAAAAAAAAAAAAAAAAAAAAAAAAAOBUijOP1e90UCiasmXLFnkCtCTVr19fV199ddh7a9eu1a5du0yFBgAAAAAAAAAAAAAAAAAAAAAAAAAAAEQEk6BLkS5duuR579tvv41CJAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDxMQm6FGnatGme9/bs2ROFSAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDiYxJ0KXL66afnee/AgQNRiAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAoPiZBlyLBYDDPe2XLlo1CJAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDxMQnahbKysoq1Xn53fa5cuXJJwwEAAAAAAAAAAAAAAAAAAAAAAAAAAAAiiknQUbZ371516dJFzZs3V40aNZSYmKiHH364WGmtXr06z3sNGzYsaYgAAAAAAAAAAAAAAAAAAAAAAAAAAABARMVHO4BYd/rpp2vRokUKBAL2e0uWLClWWvPnzw97Xa5cObVo0aJE8QEAAAAAAAAAAAAAAAAAAAAAAAAAAACRxp2goywuLk7NmjULe2/JkiXavn17kdLZtm2bPv7447D3unXrpri4uBLHCAAAAAAAAAAAAAAAAAAAAAAAAAAAAEQSk6Bd4Nprrw17bVmWRo0aVaQ07r33XmVlZYW997e//a3EsQEAAAAAAAAAAAAAAAAAAAAAAAAAAACRxiRoF7juuuuUkpIS9t5bb72lTz75pFDrjx49Wh988EHYex07dtTFF19sLEYAAAAAAAAAAAAAAAAAAAAAAAAAAAAgUpgE7QLVqlXTI488EvZeMBhUv3799Pbbbxe43rFjx/S3v/1NDz/8cNj7ZcuW1VtvveVIrAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDT4qMdALLdf//9mjNnjhYuXGi/l5aWpsGDB+uVV17RwIED1aJFC6WkpOjXX3/VggULNGnSJO3evTssHZ/Pp7feekv16tWL9E8AAAAAAAAAAAAAAAAAAAAAAAAAAAAAjGAStEskJibqww8/VKdOnfTdd9+Fffbtt9/q22+/PWUafr9fr732mvr37+9UmAAAAAAAAAAAAAAAAAAAAAAAAAAAAIDj/NEOAH+oUKGCvvzyS91xxx1FXrdWrVqaO3eubrnlFgciAwAAAAAAAAAAAAAAAAAAAAAAAAAAACKHSdAuk5ycrH//+99avXq1Bg0apNTU1JMu36hRI73wwgv66aef1LFjxwhFCQAAAAAAAAAAAAAAAAAAAAAAAAAAADjHZ1mWFe0gULCsrCx9//33Wr9+vQ4cOKBjx46pbNmyqlOnjlq1aqU6deoY+Z6kpCRlZGTkeT8xMVGBQMDIdwAAAAAAAAAAAAAAAAAAAAAAAAAAACD2FGceK5OgIYlJ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAHBGceax+p0OCgAAAAAAAAAAAAAAAAAAAAAAAAAAAACKIj7aAQAAAAAAAAAAAACliWVZea5QnJSUJJ/PF6WIAAAAAAAAAAAAAAAAvIdJ0AAAAAAAAAAAAIBBgUBAM2bMCHuvV69eSk5OjlJEAAAAAAAAAAAAAAAA3sMkaAAAAAAAAAAAAAAAAACIcZZlKRAIhL2XlJQkn88XpYgAAAAAAAAAALGOSdAAAAAAAAAAAAAAAAAAEOMCgYBmzJgR9l6vXr2UnJwcpYgAAAAAAAAAALHOH+0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA3JkEDAAAAAAAAAAAAAAAAAAAAAAAAAAAAcJX4aAcAAAAAAAAAAAAAAAAAAG5gWZYCgUDYe0lJSfL5fFGKCAAAAAAAAACA2MUkaAAAAAAAAAAAAAAAAACQFAgENGPGjLD3evXqpeTk5ChFBAAAAAAAAABA7IroJOjffvtNy5Yt0w8//KBt27Zp69at2rdvn9LS0nTs2DH5/X6VK1dOqampqlSpkurXr69zzjlHDRs2VNu2bVW2bNlIhgsAAAAAAAAAAAC4AnckBAAAAAAAAAAAAAAAscbRSdAZGRn64osv9L///U+zZs3S5s2b8yxjWVae9/I7WSMuLk4tW7ZU+/bt1bNnT1144YWOxAwAAAAAAAAA+WHyGQAgmrgjIQAAAHJjnAIAAAAAAAAAEAscmQT9ww8/aOzYsZo0aZIOHTokKf/JzlL+E57zWz4rK0vLli3TsmXL9Oyzz6p27doaMGCAhgwZonPOOcfsDwAAAAAAAACAEzD5DAAAAAAAuAXjFAAAAAAAAACAWOA3mdgnn3yiiy66SM2bN9crr7yigwcPyrIsWZYln8+X5yHJ/vzEh6STLr9t2zY99dRTatSoka6++mrNmzfP5E8BAAAAAAAAAAAAAAAAAAAAAAAAAAAAECVG7gT94Ycf6rHHHtPKlSslKWzSc87r3Hd2jo+PV82aNVW1alVVqVJFKSkpSkpKkmVZSktLU1pamg4cOKBffvlF+/bty3NX6BPT/fTTT/Xpp5+qVatWevzxx9W1a1cTPwsAAAAAAAAAAAAAAAAAAAAAAAAAAABAFJRoEvTatWt11113aeHChZLCJz/nTFwuU6aMLrnkErVt21atWrVS48aNVa9ePcXFxRXqOzIyMvTTTz9pxYoVWrlypZYsWaLvvvtOwWBQUviE6O+++07du3dXu3bt9MILL6h169Yl+XkAAAAAAAAAAAAAAAAAAAAAAAAxwbIsBQKBsPeSkpLseRsAvI9yDgDwmmJNgj527JgefvhhvfbaawoGg/bkZyn7YHj22Werd+/e6ty5sy6++GIlJiYWO8DExEQ1adJETZo00aBBgyRJhw8f1vz58/Xxxx9rxowZOnjwoCTZk6+/+uorXXDBBbrllls0atQoVaxYsdjfDwAAAAAAAAAAAAAAAAAAAAAAUNoFAgHNmDEj7L1evXopOTk5ShEBMI1yDgDwmiJPgl60aJGGDBmirVu3hk1+Llu2rPr27ashQ4bo4osvNh5obuXLl1fPnj3Vs2dPvf7665o1a5bGjRun//3vfwoGg/L5fAqFQnrjjTc0Y8YMTZgwQV27dnU0JgAAAAAAAAAAAMSeESNGFGq5MWPGlDgNAAAAAAAAAAAAAACAWOIvysL33XefOnbsqK1bt9rvVa1aVU8//bR27typ//znP45PgD5RQkKCrr76as2YMUNbtmzRQw89pEqVKtmf79mzR927d9fdd98d0bgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFE+RJkG/8MILsixLlmWpYsWKevrpp7V582bdf//9Sk1NdSrGQjvzzDP15JNPauvWrRo1apROP/10SZJlWXr55ZejHB0AAAAAAAAAAAAAAAAAAAAAAAAAAACAwijSJGhJSkpK0t///nd78nOZMmWciKtEypYtqwcffFBbt27V8OHDlZKSEu2QAAAAAAAAAAAAAAAAAAAAAAAAAAAAABRSkSZB/+Uvf9H69es1ZswYVahQwamYjElJSdHw4cO1fv16XXfdddEOBwAAAAAAAAAAAAAAAAAAAAAAAAAAAEAhxBdl4UmTJjkVh6POPPNMvf3229EOAwAAAAAAAAAAAAAAAAAAAAAAAAAAAEAhFOlO0AAAAAAAAAAAAAAAAAAAAAAAAAAAAADgNCZBAwAAAAAAAAAAAAAAAAAAAAAAAAAAAHCV+GgHAAAAAAAAAAAAAAAAAAAAAAAAAMD7LMtSIBAIey8pKUk+ny9KEQEAAC9z3STov//973r66aejHQYAAAAAAAAAAAAAAAAAAAAAAECpM2LEiEIvO2bMmBKngdgSCAQ0Y8aMsPd69eql5OTkKEUEAAC8zB/tAE707LPPatCgQcrKyop2KAAAAAAAAAAAAAAAAAAAAAAAAAAAAACiwHWToCXp3Xff1ZVXXqljx45FOxQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEea6SdAJCQmSpM8//1zt27fX3r17i53WBx98YCosAAAAAAAAAAAAAAAAAAAAAAAAAAAAABHiuknQH3/8scqVKydJ+v7773XRRRdp06ZNRUrj888/V9u2bdW3b18nQgQAAAAAAAAAAAAAAAAAAAAAAAAAAADgINdNgu7SpYsWLFig6tWry+fzadOmTWrXrp2+++67U667dOlSXX755eratWuhlgcAAAAAAAAAAAAAAAAAAAAAAAAAAADgPq6bBC1JLVq00JIlS9SgQQNJ0r59+3TZZZdp1qxZ+S6/du1a9erVS+3atdOCBQsiGCkAAAAAAAAAAAAAAAAAAAAAAAAAAAAA01w5CVqS6tSpoyVLluiiiy6SJB07dkw9evTQxIkT7WW2bt2q66+/Xs2bN9dHH30ky7LsxwUXXKDZs2dHK3wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxRQf7QBO5rTTTtPnn3+u6667Th988IEyMzM1dOhQbd68WQcOHNBbb72lzMxMWZZlr9OyZUs99thj6t69exQjBwAAAAAAAAAAAAAApY1lWQoEAmHvJSUlyefzRSkiAAAAAAAAAAAAoPRy9SRoKfvPwqlTp+ruu+/Wyy+/LMuy9MQTT0hS2OTnpk2basSIEerZs2eUIgUAAAAAAAAAAABKbsSIEYVabsyYMSVOAwBQNIFAQDNmzAh7r1evXkpOTo5SRABiAe1DAAAAAAAAAECscv0kaEkKhUI699xzVaZMGaWnp9uTn30+nxo1aqThw4erb9++UY4SAAAAAAAAABBN3JUPAAAAAAAAAAAAAAAAAEoPV0+CDoVCmjBhgp544glt27Yt7LOck9Y6d+7MBGgAAAAAAAAARpX0DkvcXSk6uCsfAAAAAAAAAAAAAAAAAJQe/mgHkB/LsvT222+rYcOGuvnmm7V161ZZliXLslS+fHn17NnTvhv0Sy+9pAEDBigzMzPKUQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAwwXWToN999101atRIQ4YM0ebNm+33y5QpowceeECbN2/WBx98oJdeesm+G/SUKVPUtWtXHTp0KFphAwAAAAAAAAAAAAAAAAAAAAAAAAAAADDEdZOgBw4cqI0bN0rKviN0XFycbrnlFv3888966qmndNppp0mS7rzzTr3//vtKSkqSJC1cuFCXXHKJdu3aFbXYAQAAAAAAAAAAAAAAAAAAAAAAAAAAAJSc6yZBS9mTnyWpf//+WrdunV5//XWdccYZeZbr3bu3Zs+erYoVK0qS1qxZowsuuEBr166NZLgAAAAAAAAAAADwKMuylJ6eHvbI+a8KAAAAAAAAAAATGIsGAAAAiic+2gHkp3v37nryySfVrFmzUy57ySWX6Msvv9QVV1yhnTt3aseOHbr44os1c+ZMtW/fPgLRAgAAAAAAAAAAwKsCgYBmzJgR9l6vXr2UnJwcpYgAAAAAAAAAAKUNY9EAAABA8bhuEvSiRYt08cUXF2mdc889V19//bWuuOIKrV27VocOHdIVV1yhCRMm6Nprr3UoUgAAAAAAAAAAAAAAAAAAAAAAACA2jRgxolDLjRkzpkTrAwCA2OWPdgAnKuoE6Bw1a9bUV199pUsvvVRS9pWSrrvuOpOhAQAAAAAAAAAAAAAAAAAAAAAAAAAAAIgA102CLony5ctrzpw56tOnjyTJsqwoRwQAAAAAAAAAAAAAAAAAAAAAAAAAAACgqErVJGhJSkxM1Pvvv6+//e1v0Q4FAAAAAAAAAAAAAAAAAAAAAAAAAAAAQDHERzsAJ/h8Pv3rX/9SzZo1ox0KAAAAAAAAAAAAAAAAAAAAAAAAAAAAgCIqlZOgczzwwAPRDgEAAAAAAAAAAAAAAACAC40YMaJQy40ZM6bEaQAAAAAAAAAAgKJz9SToHTt26PXXX9f8+fO1bds2HT16VBUqVFDNmjXVsGFDTZgwIdohAgAAAAAAAAAAAAAAAAAAAAAAFOlCSQVdcImLLQEAAAB/cO0k6H/961968MEHlZmZab9nWZaOHDmiHTt26Ntvv2USNAAAAAAAAAAAAAAAAAAAAAAAAAAAAFAKuXIS9NNPP62HHnpIlmUVed3nnntOdevWVfPmzVW/fn0HogMAAAAAAAAAAAAAAAAAAAAAAAAAAADgJH+0AzjRxo0b9cgjj9ivmzZtqsmTJ2vTpk3auXOnLr744pOuf/jwYfXr108NGjTQJ5984nS4AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAxz3STol19+WcFgUJJ02WWXaenSpRowYIDq1aunM844Q2XLlj3p+rfeeqv9/L///a+jsQIAAAAAAAAAAAAAAAAAAAAAAAAAAAAwz3WToOfPny9J8vl8euONN5SUlFSk9WvUqKHzzz9flmXp888/dyJEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA5y3SToX375RT6fTw0bNtTZZ59drDQuuugiSdK+ffv0888/mwwPAAAAAAAAAAAAAAAAAAAAAAAAAAAAgMNcNwk6MzNTUvYdnYuradOm9vP169eXOCYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAkeO6SdDVqlWTJB06dKjYaVStWtV+/ssvv5Q4JgAAAAAAAAAAAAAAAAAAAAAAAAAAAACR47pJ0H/6059kWZbWrFmjQCBQrDRSU1Pt54cPHzYVGgAAAAAAAAAAAAAAAAAAAAAAAAAAAIAIiI92ACfq2rWrZs+erUAgoMmTJ2vo0KFFTuPYsWMORAYAAAAAAAAAAAAvGzFiRKGWGzNmTInTAAAAAAAAAAAAAAAAQMm47k7Q/fv3V3JysiTp4Ycf1r59+4qcxvr16+3nFSpUMBYbAAAAAAAAAAAAAAAAAAAAAAAovSzLUnp6etjDsqxohwUAAADEJNdNgq5evbpuvfVWWZalffv26YorrtDevXuLlMb06dPt5+ecc47pEAEAAAAAAAAAAAAAAAAAAAAAQCkUCAQ0Y8aMsEcgEIh2WAAAAEBMct0kaEkaPXq0mjZtKsuytHLlSrVs2VLTpk0r1LpTpkzRokWLJEkJCQk6//zznQwVAAAAAAAAAAAAAAAAAAAAAAAAAAAAgGHx0Q4gP8nJyfr444/VqVMnbdy4Ubt27dK1116rhg0bKi0tLd91jh07pldeeUXDhg2TJPl8PvXu3VvlypWLWNyjRo3SI488IkkaPHiwJkyYUOI0582bp2nTpunrr7/Wjh07dOjQISUnJ6tWrVpq1aqVevbsqR49eig+3pVZCQAAAAAAAADGjRgxotDLjhkzpsRpAAAAAAAAAAAgSZZl5bkbbFJSknw+X5QiAgAAAACgdHPtzNlatWrp66+/1sCBAzVr1ixZlqUNGzaELXPOOeeoatWqOnr0qDZs2KDMzExZliVJKlu2rB577LGIxbthwwaNGjXKWHrLly/XTTfdpJUrV+b57OjRo1q3bp3WrVunSZMmqV69evr3v/+t7t27G/t+AAAAAAAAAAAAAAAAAAAAAH8IBAKaMWNG2Hu9evVScnJylCICAAAAAKB080c7gJOpVKmSPv30U/3nP/9RjRo1ZFmWLMuyr5a2efNmffPNN1qzZo0yMjLs9cqUKaN3331X9evXj0icR44cUd++fXXs2DEj6U2ePFkXXHBBvhOg87NlyxZdeeWVGjlypJHvBwAAAAAAAAAAAAAAAAAAAAAAAAAAAKLJ1ZOgcwwZMkRbtmzRxIkTdcUVV6hMmTL2hOichyT5/X5dddVVWrp0qa666qqIxJaenq5evXrphx9+MJLeBx98oOuvv15ZWVlh7ycmJqpt27a66qqr1Lp1ayUmJuZZd8SIEXr22WeNxAEAAAAAAAAAAAAAAAAAAAAAAAAAAABES3y0AyishIQEDRo0SIMGDVJWVpbWrVunLVu26NChQ4qPj1eVKlXUpk0bVahQIWIxHT16VD169ND8+fONpLdlyxYNGTJEoVDIfi8uLk4PPvig7r33XlWqVMl+f9++fXruuef0zDPPhC3/0EMPqUOHDmrdurWRmAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBI88wk6Nzi4+N13nnn6bzzzotaDGvXrlWfPn20fv16Y2nef//9Onz4sP3a7/dr6tSp6tWrV55lq1SpojFjxqhdu3bq3bu3feforKws/eMf/9C8efOMxQUAAAAAAAAAAAAAAAAAAAAAAAAAAABEkj/aARRXMBjUiBEjovLdb7/9ttq2bWt0AvSKFSv0wQcfhL33yCOP5DsBOrc///nPev7558Pemz9/vrG7UwMAAAAAAAAAAAAAAAAAAAAAAAAAAACR5tgk6ClTpjiVtFatWqVWrVrp8ccfd+w78rNhwwb17NlTgwcPVlpamtG0X3vttbDXp512mh588MFCrXvnnXeqWbNmYe+9+uqrxmIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAIsmxSdCDBg3Shx9+aDTNYDCokSNHqm3btlq9erXRtE9m7969uuOOO9SkSZN8f9Ndd92liy++uNjpB4NBTZ06Ney96667TikpKYVa3+fz6bbbbgt777PPPjM+URsAAAAAAAAAAAAAAAAAAAAAAAAAAACIhHinEs7MzNS1116rGTNmqFu3biVOb/Xq1brhhhu0atUqWZZlIMLCGzVqVL53Vk5NTdWLL76oIUOGqEOHDsVO/9tvv9XBgwfD3rv66quLlMbVV1+t22+/3X6dlpamzz77TL179y52XAAAAAAAAAAAAAAAAAAAAAAAlEYjRowo9LJjxowpcRoAAAAAis6xO0FLUkZGhnr37q3PP/+82GkEg0E99thjatu2rT0B2ufzGYyyeLp37661a9dqyJAhJU5r8eLFYa/9fr8uvPDCIqVRs2ZN1a5dO+y9BQsWlDQ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAIOIcnQTt8/mUnp6unj17atGiRUVef/Xq1WrTpo1GjhypjIyMPBOg69evbzLcQmnSpIk+/vhjffLJJ6pVq5aRNNeuXRv2+qyzzlJqamqR0znvvPPCXi9fvrxEcQEAAAAAAAAAAAAAAAAAAAAAAAAAAADR4Ngk6Li4OEnZE6HT0tJ01VVX6euvvy7UusFgUI8//nieuz/7fD5ZliW/36/7779fq1evdir8PFq3bq1JkyZp1apVuuqqq4ymvW7durDXDRo0KFY6Z599dtjrn3/+udgxAQAAAAAAAAAAAAAAAAAAAAAAAAAAANES71TCb7/9tq6//nqFQiH5fD4dPXpU3bp10+eff67WrVsXuN4PP/ygG264QStXrpRlWZJk3/3Zsiw1a9ZM//nPf9SyZUunQs9j2LBhqlSpkmPp79q1K+x1zZo1i5XOGWecEfZ63759SktLU0pKSrFjAwAAAAAAAAAAAAAAAAAAAAAAAAAAACLNsTtBDxgwQO+++27YHaEPHz6srl27atWqVXmWz7n7c5s2bewJ0Lnv/pyYmKgnn3xS3333XUQnQEtydAK0JO3duzfsdbVq1YqVTpUqVfK8d+DAgWKlBQAAAAAAAAAAAAAAAAAAAAAAAAAAAESLY5OgJalv37567733FB+ffcNpn8+n33//XZ06ddLatWvt5X744Qe1bdtWI0aMUEZGhj0BWsq++/Mll1yiVatW6aGHHrInVZcWR44cUUZGRth75cuXL1Zaqamped77/fffi5UWAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC3xTn/BNddco6lTp6pfv37KzMyUz+fTgQMH1KlTJ82dO1czZ87UE088oczMzDyTn8uXL6+nnnpKt956q9NhRk0gEMjzXkpKSrHSym+99PT0U35/fjHkduTIEcXHx6tMmTIKhUI6duxYnmVyJmCnpaUpGAyGfZacnKyEhARlZGTk+a64uDilpKTIsiwdPXo0T7ply5aV3+/X8ePHlZWVFfZZUlKSEhMTlZmZmed3+v1+lS1b1o7/RCkpKYqLi1N6eroyMzPDPktMTFRSUpKysrJ0/PjxsM98Pp/KlSsnSTp69Kgsywr7vEyZMoqPj1cgEMgzuT0hIUHJyckKBoNKS0vLE1PONjx27JhCoVDYZyfbhqfKm3Llysnn8+WbNyfbhjl5I+W/DU+WNyfbhrnzJr9tmJM3Rd2GufMmv22Ykzemt2FO3pxsG5Zk/y7JNjzZ/l2SbZhf3lBHZKOO+AN1RDbqiGzUEdmoI/5AHZGNOiIbdUQ26og/UEdko47IRh2RjTriD9GoI4rryJEj1BH/n1N1hAnUEdQREu2I3EpTHXGqbVhSBW3D4jp27NhJ64jiOHLkCHVELtQR2agjstHXyEYd8Yei1BGBQCBsmZyLwlNHUEdI1BE5vFZHmBDJdkRxFeb8n5w6LRgM2vEePXpUmZmZ1BG5thF1RGzVEfQ1/kA7Iht1RLZYriNy9wl8Pp99cyfqCOoIiToih9fqCBNM9zUCgYDjdYQJOfsGdUS2WK0jSip3HePGOqI09jWk8L5/zrI524J2BHVEDtoR2WKtjqCvQR2Rw6k6ojgcnwQtSX/+8581ffp09enTRxkZGfL5fNqzZ4+aN28uy7LszM49Afrqq6/Wa6+9pho1akQixKjJrxOV84dCUeV3l+wTC8uJRo8erZEjRxb4uWVZWr58uapVq6ZGjRopEAho+fLleZbr0KGDJGn9+vU6fPhw2GeNGjVStWrVtG/fPm3cuDHss9NOO03NmjVTMBjMN9127dopMTFRP//8sw4cOBD2Wf369VWrVi39/vvv+vHHH8M+K1eunFq3bi1J+v777/NUKG3atFHZsmW1bds27d69O+yz2rVr66yzztLRo0e1cuXKsM+SkpJ04YUXSsq+g/mJ+de8eXNVrFhRO3fu1Pbt28M+O+OMM9SwYUOlp6fn+a0+n0/t27eXJK1bty5PxXDuueeqatWq2rNnjzZt2hT22emnn67zzjtPWVlZ+W7Diy++WPHx8dq4cWOeO4Ofc845qlmzpn777TetW7cu7LPy5curZcuWkpRvuueff77KlCmjrVu3as+ePWGf1a1bV3Xr1tXhw4e1evXqsM/KlCmj888/X5K0atWqPPtoixYtVKFCBf3yyy/asWNH2Gc1atRQgwYNlJaWliemuLg4XXLJJZKktWvX5jkYNGnSRJUrV9bu3bu1ZcuWsM+qVKmixo0bKzMzM9/feumll8rn8+mnn37SwYMHwz5r2LChzjjjDO3fv18bNmwI+6xixYp2PZdfuhdeeKGSkpK0efNm7du3L+yzevXqqU6dOjp48KDWrFkT9llKSoratm0rSVqxYkWeA1CrVq2Umpqq7du3a9euXWGfnXnmmTr77LN19OhRrVixIuyzhIQEXXTRRZKkNWvW5DlQN23aVJUqVdLu3bu1devWsM+oI7JRR/yBOiIbdUQ26ohs1BF/oI7IRh2RjToiG3XEH6gjslFHZKOOyEYd8Ydo1BHFtXz5cuqI/8+pOsIE6gjqCIl2RG6lqY44VTuipAqqI4pr3bp1YXWECcuXL6eOyIU6Iht1RDb6GtmoI/5QlDoiKyvLLltxcXE67bTTJFFHUEdko47I5rU6woRItiOKa/ny5aesI3LKY87EZ0lauXKl4uPjqSP+P+qIbLFUR9DX+APtiGzUEdliuY7I3SdISEhQhQoVJFFHUEdko47I5rU6wgTTfY3du3c7XkeYkJMP1BHZYrWOKKnccbmxjiiNfY2kpCSlp6eH7aMrV65U7dq1aUeIOiI32hHZYq2OoK9BHZHDqTrixDqhMHxWcdYqplmzZumaa66xK5n8Jj9XrVpVL730kvr16xepsIzo0KGDFi5caL8ePHiwJkyYcMr1tm/frjp16oS9N3bsWN10001FjmHu3Lnq0qVL2HuLFi2yK5H85NwJukqVKvneSSUxMVH79+/33BUBuGrIH7hqSDauGpKNq4Zko474A3VENuqIbNQR2agj/kAdkY06Iht1RDbqiD9QR2SjjshGHZGNOuIPpaGOeO655/J8f1Hcd9991BH/nxN1REnzR5JGjBhBHUEdIYl2RG6lpY6QCt6GpuqP3NvQRJoPPPBAWB1hIs377ruPOiIX6ohs1BHZ6Gtko474Q1HvBP3ZZ5+FxdyrVy9lZWVRR1BHUEf8f16qI0y1D51uR5hqH+beho899liJ08tBHfEH6ohspaWOkOhr5EY7Iht1RLZYriNy9wly7gTdq1evfG9aRB2RjToiG3VENrfVEab6BLm3oYk0H3roIcfriMcff7zEceb0C6gjssVqHTFixIg86RZF7v6l2+oIqXT2NTIzMzVt2rSwz7p166Zy5crRjhB1RG60I7LFWh1BX4M6IodTdUTlypULnMea3w2HpQhPgpayJ+r27NkzLHjLsuTz+TRo0CC98MIL9pWSvaS4k6B3796d527Xr732mm677bYix/Dpp5/qyiuvDHtv6dKl9tUFTiYpKanIOw8AAAAAAABQWpX0j9qSro+TM7F9ySMgNjlRf3glTQCAGenp6ZoxY0bYe7169VJycnKUIgJQEl5pd7mxzUl7EwAQq+gTAKWLG9vaptKIxHfQL4BE/9KLaM8AAKKpOPNY/U4HdaLOnTvr448/VpkyZcLer1Spkh599FFPToAuiaSkpDzv5ZeJhZHfVeTySx8AAAAAAAAAAAAAAAAAAAAAAAAAAABws4hPgpakjh076pNPPrFvy+7z+fTbb7+pU6dO2rFjRzRCipry5cvL5/OFvZff7cELo6Db2wMAAAAAAAAAAAAAAAAAAAAAAAAAAABeEpVJ0JLUvn17zZo1S+XKlZMkWZalbdu26fLLL9eePXuiFVbExcfHq3z58mHvHTx4sFhp5bdetWrVipUWAAAAAAAAAAAAAAAAAAAAAAAAAAAAEC3xRV2hY8eORgOoUKGCjhw5Ip/PJ8uy9PPPP6tNmzY6++yzT7muz+fTvHnzjMYTDTVq1NChQ4fs18WdBH7iesnJyUpNTS1RbAAAAAAAAAAAAAAAAAAAAAAAAAAAAECkFXkS9IIFC+Tz+YwHYlmWPRF6x44d2rlzZ6GWLw3q16+vdevW2a+3b99erHS2bduWJ10AAAAAAAAAAAAAAAAAAAAAAAAAAADAa/zRDkDKvqNzzoTm3M9jRePGjcNeb9iwoVjpnLjeiekCAAAAAPKyLEvp6elhD8uyoh0WAAAAAAAAAAAAAAAAAAAAAMS0It8JWhIngxvWpk2bsNe7d+/Wrl27VKNGjUKnkZmZqVWrVoW917JlSyPxAQAAAHAXy7IUCATC3ktKSoq5C0qZEggENGPGjLD3evXqpeTk5ChFBAAAAAAAAAAAAAAAAAAAAAAo8iTowYMHOxFHTLv00kvl9/sVCoXs9+bNm6dBgwYVOo0vv/wyzySITp06GYsRAAAAgHswaRcAAAAAAAAAAAAAAAAAAAAAUNoVeRL0+PHjnYgjplWpUkVt2rTR0qVL7ffee++9Ik2C/u9//xv2+owzzlCLFi2MxQgAAAAAAAAAAAAAAAAAAAAAAAAAAABEij/aASDb9ddfH/b6s88+0/Llywu17pYtWzRp0qSw94YOHSq/n+wFAAAAAAAAAAAAAAAAAAAAAAAAAACA9zBL1iUGDRqkSpUq2a8ty1L//v21f//+k66Xlpamvn37Kj093X6vTJkyuu222xyLFQAAAAAAAAAAAAAAAAAAAAAAAAAAAHASk6BdIjU1VY888kjYez///LM6deqkn3/+Od91du/erW7duuW5Y/Q999yjM88807FYAQAAAAAAAAAAAAAAAAAAAAAAAAAAACfFRzsA/OH//u//NGPGDC1evNh+b9WqVWrWrJkGDRqkK6+8UjVq1NDevXs1b948jRs3Tr///ntYGi1atNCwYcMiHToAAAAAAAAAAAAAAAAAAAAAAAAAlxgxYkShlhszZkyJ0wAAwClFuhP0I488oqNHjzoVi2PS0tL0z3/+M9phnFJcXJw+/PBDtWjRIuz9tLQ0vfHGG/rzn/+s1q1bq3v37nruuefyTICuW7euZsyYoaSkpEiGDQAAAAAAAAAAAAAAAAAAAAAAAAAAABhVpEnQo0eP1jnnnKM33nhDoVDIqZiMmjBhgs455xyNHj062qEUSqVKlfT555/rqquuKtJ67dq105dffqk6deo4FBkAAAAAAAAAAAAAAAAAAAAAAAAAAAAQGUWaBC1Je/fu1V//+lede+65mj59uhMxGfHee++pcePGuvHGG7V79+5oh1MklSpV0scff6yZM2fqkksukd9fcDY1adJEY8eO1ZdffqkzzzwzglECAAAAAAAAAAAAAAAAAAAAAAAAAAAAzogvysK9e/fW9OnT5fP59NNPP6lfv35q2rSphg0bpl69ejkVY6EdP35ckyZN0vPPP6+ffvpJkmRZliSpZ8+ejn73ggULjKfZo0cP9ejRQ3v37tU333yj3bt368CBA0pJSdEZZ5yhtm3bql69esa/FwAAAAAAAAAAAAAAAAAAAAAAAAAAAIimIk2Cnjp1qiZPnqy77rpLBw8elGVZWrVqlfr06aN69eppyJAhuv7661WrVi2n4s3X6tWrNX78eE2cOFGHDh2yJz5LUpkyZfT888/r1ltvjWhMJlWtWlV//vOfox0GAAAAAAAAAAAAAAAAAAAAAAAAAAAAEBH+oq5w3XXXac2aNfakXJ/PJ8uytHnzZg0bNkz16tVT586d9dprr2nz5s3GA87x/fffa+TIkTr33HPVokULvfTSS/bEbJ/PJ0nq2rWrVq9e7ekJ0AAAAAAAAAAAAAAAAAAAAAAAAAAAAECsKdKdoHPUqFFDM2fO1OzZs3X33Xdrw4YN9sTjUCik+fPna/78+ZJkT4o+//zz1bJlS/3pT39SYmJikb7v8OHDWrlypVauXKmvvvpK8+fP12+//SZJ9l2ffT6fPSG7du3aeuaZZ9SnT5/i/DwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUVSsSdA5unbtqh9++EGvvfaannrqKe3atcueDJ0zOXnz5s1688039eabb0rKnqx85plnqm7duqpataqqVKmilJQUJSYmyrIspaWl6fjx4zpw4IB++eUX/fLLL9qzZ0/Y9+aknZNezns1atTQww8/rJtvvlkJCQkl+WkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoqREk6AlKT4+XnfddZduvfVWjR07Vs8884y2b98uSXkmROc83759u3755ZdTpp17vRw5d3zO+dyyLJ177rn629/+puuvv17Jyckl/UkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoshvKqHExETdcccd2rx5sz766CNdffXV8vv99kTmnMnL+U1iLuhx4jo+n8/+LDk5WX379tXs2bO1Zs0a3XLLLUyABgAAAAAAAAAAAAAAAAAAAAAAAAAAAEqBEt8J+kR+v19XXXWVrrrqKu3Zs0cfffSR/ve//2nevHlKS0sLWzZnMnR+ciY751a1alVdeuml6tmzp3r06KGyZcuaDh8AAAAAAAAAAAAAAAAAAAAAAAAAAABAlBmfBJ1btWrVdPPNN+vmm29WMBjUmjVr9O2332rNmjXaunWrtm7dqv379+vYsWNKS0uTz+dTuXLlVK5cOVWqVEn169fXOeeco4YNG+rCCy9Uw4YNnQwXAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAs4Ogk6t7i4ODVr1kzNmjWL1FcCAAAAAAAAAAAAAAAAAIACWJalQCAQ9l5SUpJ8Pl+UIgIAAAAAAACAP0RsEjQAAAAAAAAAAAAAAAAAAHCPQCCgGTNmhL3Xq1cvJScnRykiAACAouGiLgAAAEDpxiRoAAAAAAAAAAAAAAAAAAAAAADgOVzUBQAAACjd/NEOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABy407QAAAAAAAAAEody7IUCATC3ktKSpLP54tSRAAAAAAAAAAAAAAAAAAAoCiYBA0AAAAAAACg1AkEApoxY0bYe7169VJycnKUIgIAAAAAAAAAAAAAAAAAAEXh2CToxx57zJF0/X6/kpKSlJSUpLJly+qMM85QzZo11ahRIyUmJjrynQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAix7FJ0CNGjJDP53Mq+Tzi4+PVvHlz9e/fX0OHDlWFChUi9t0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAzPE7/QWWZUXkkZmZqWXLlun+++9XgwYNNH36dKd/GgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHODoJ2rIs+7nP58v3kZ+Cli3Mw7Is7du3T/369dNLL73k5M8DAAAAAAAAAAAAAAAAAAAAAAAAAAAA4IB4pxK+4447JElZWVmaMGGCMjIy7M9yJkeXLVtW5513nipXrqzy5csrEAjo8OHD2r59uzZu3KhQKCRJeSZL555cnVvuidWWZenee+9VgwYNdMUVVxj/fQAAAAAAAAAAAAAAAAAAAAAAAAAAAACc4dgk6JdffllZWVnq37+/AoGAfZfmlJQU3XDDDbrxxhvVvHnzAu8GnZaWptmzZ+uNN97QnDlz7PWrVq2qBQsWqGHDhkpLS9OhQ4e0c+dOffXVV3rrrbf0448/2pOhQ6GQbrnlFm3YsEFlypRx6qcCAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMjvZOJ33nmnZsyYYU9gbt26tVauXKl///vfatGiRYEToCUpJSVFvXr10qxZszR16lSlpqbK5/Np79696tSpk3799VeVLVtWNWrUUJs2bXT33Xdr9erVeuKJJ8LS2blzp8aNG+fkzwQAAAAAAAAAAAAAAAAAAAAAAAAAAABgkGN3gp43b57efPNNe6Jzq1atNG/ePKWmphY5rd69e6ty5crq2rWrMjMztWvXLt15552aPn162HJ+v18PP/ywsrKyNGLECHvy9bhx43THHXcY+V0AAAAAAAAAAAAAAKB0GzFiRKGXHTNmTInTAAAAAAAAAAAAAJCXY3eCfvzxxyVJlmUpKSlJ//3vf4s1ATpH+/btde+998qyLEnSzJkz9fXXX+e77MMPP6x69erZr1euXKm9e/cW+7sBAAAAAAAAAAAAAAAAAAAAAAAAAAAARI4jk6B37NihL7/8Uj6fTz6fT/3799fZZ59d4nTvuecexcXF2XeXfvfdd/NdLj4+Xv3797cnTEvSqlWrSvz9AAAAAAAAAAAAAAAAAAAAAAAAAAAAAJwX70Siy5Ytsycg+3w+XXXVVUbSrVKlipo2baoVK1ZIkhYuXFjgsm3btg17vXnzZiMxAAAAAAAAAAAAAAAAAAAAACjdRowYUajlxowZU6L1AQAAAABAwRy7E3RuderUMZZ2zZo17ec7d+4scLkaNWpIkn3X6EOHDhmLAQAAAAAAAAAAAAAAAAAAAAAAAAAAAIBzHJkEfezYsbDXx48fdyTt9PT0ApdLSkoKex0MBo3FAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA5jkyCPu2008Jer1mzxki6lmXpxx9/tO/uXK1atQKXPfHOz+XLlzcSAwAAAAAAAAAAAAAAAAAAAAAAAAAAAABnOTIJ+txzz5Uke7LyO++8YyTd+fPna8+ePXbaNWvWLHDZtWvXSsqeOC1JVatWNRIDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGfFO5Foq1atVKZMGaWnp8uyLH3zzTd65513NGjQoGKnmZmZqfvvv19S9sRmn8+nzp07F7j8Rx99FPa6adOmxf5uAAAAAAAAAO41YsSIQi03ZsyYEqcBAAAAAAAAAAAAAAAAAAAiw5E7QaekpOiaa66xJytblqVbb71Vc+fOLVZ6wWBQ1113nVatWmXfXVqS+vbtm+/yX331lWbPnm0vW7lyZTVs2LBY3w0AAAAAAAAAAAAAAAAAAAAAAAAAAAAgshyZBC1J//znPxUfn32jaZ/Pp/T0dHXv3l0PPfSQDh48WOh0lixZojZt2mj69On2hGqfz6c+ffqoUaNGeZb/9NNP1adPH0l/3DH62muvNfKbAAAA8P/Yu/M4Oco6cfyfnqsnE0KAJAQQUTkFQS5FBDxQUVFYnVVcL2TV70/3UGSXQwGFiEqyrvexoKuACrrrsgyKAq4o4AGrEokgpxoIC4EAIffRc3T9/ogzpjM55nhqumv6/X69eJF+uvsznzr6qaqn6lMFAAAAAAAAAAAAAAAA+WvLK/B+++0X5557bnz0ox+NUqkUpVIpBgYG4pOf/GR84QtfiBNOOCFe+MIXxkEHHRQ77bRTbLfddrFu3bpYtWpVPPDAA7FgwYK47rrr4t57742IvxQ0R0TssMMO8YUvfKHm7916663xpje9KRYvXlzz2fb29nj/+9+f12QCAAAAAAAAAAAAAAAAAACJ5VYEHRFx/vnnx/333x/f+c53hgqhsyyLdevWxZVXXhlXXnnlVr+fZVlERM13d9xxx/jRj34Us2fPrvns/Pnz45FHHhn6/OD/Tz/99Nhnn31ymDoAAAAAAAAAAICty7IsKpVKTVu5XB66xgkAAAAAANi8XIugIyIuv/zy2GOPPeJf//Vfo1qtDg3eDxY4b83GA/1ZlsUBBxwQ//Ef/xEHHnjgsM/ef//9Nd/Jsize/OY3xyc+8YkUkwEAAAAAAAAAADBqlUolenp6atq6u7ujs7OzThkBAAAAAEAxtOT9B0qlUsydOzd+8YtfxEte8pLIsiyyLBt6uvPW/hv87LRp0+KCCy6I22+/fbMF0BERf/jDHyJiQ/HzrFmz4qKLLoorrrgi78kDAAAAAAAAAAAAAAAAAAASy/1J0IOOPPLIuPHGG2PBggXxrW99K370ox/FPffcs8UnQm+33Xbxghe8IN70pjfF2972tujq6tpq/BNOOCFe+9rXxsEHHxxHH310tLTkXt8NAAAAAAAAAAAAAAAAAADkYMKKoAcdcsghccghh8SnP/3pWLlyZdx///2xePHiWL16dbS3t8dOO+0Us2fPjgMOOGBUhcz/+I//mGPWAAAAAAAAAAAAAAAAAADARJnwIuiNbb/99vG85z2vnikAAAAAAAAAAAAAAAAAAAANZuSPWgYAAAAAAAAAAAAAAAAAAJgAiqABAAAAAAAAAAAAAAAAAICG0laPP/rQQw/FzTffHD//+c9j0aJF8dRTT8VTTz0VbW1t0dXVFbNnz44999wzDjnkkDj22GNjn332qUeaAAAAAAAAAAAAAAAAAABAHUxoEfRNN90Uc+fOjRtuuKGmPcuymtelUqnm9WGHHRann356vPnNb849RwAAAAAAAAAAAAAAAAAAoL5aJuKPrF27Nt761rfGy1/+8rjhhhsiy7Kh/yI2FD1v/N/G72dZFvPnz4+3ve1t8fKXvzyWLFkyESkDAAAAAAAAAAAAAAAAAAB1knsR9KOPPhpHHHFE/Od//udQUfPWCp43fX/wqdBZlsWNN94YRx55ZDz44IN5pw0AAAAAAAAAAAAAAAAAANRJW57B161bF3/1V38Vd999d0RETUFzRES5XI6DDjoodt5555g+fXr09/fHihUr4tFHH4177rkn+vv7h31v0aJFcfzxx8evf/3rmDZtWp7pAwAAAAAAAAAAAAAAAAAAdZBrEfSpp54a8+fPrylibm1tjTe96U3x3ve+N174whdGe3v7Zr+7fv36+PnPfx7//u//Hj09PVGtVoeeHH3//ffHmWeeGRdffHGe6QMAAAAAAABMKlmWRaVSqWkrl8tD53QBAAAAAAAAoFHkVgR99913x6WXXlpTAL3nnnvGt7/97TjiiCO2+f3Ozs447rjj4rjjjotbb701Tj755HjggQeGCqG/9rWvxQc+8IHYf//985oEAAAAAAAAgEmlUqlET09PTVt3d3d0dnbWKSOgCNxAAQAAAAAAgHrIrQh67ty5NU9vfuYznxk333xzPO1pTxt1rBe+8IVx8803xzHHHBMPPfRQRGw4wfbZz342vvrVr6ZOHQAAAAAAAACAP3MDBQAAAAAAAOqhJY+g1Wo1rr322qEC6FKpFN/61rfGVAA96GlPe1p861vfGoqXZVlcddVVMTAwkDBzAAAAAAAAAAAAAAAAAACg3nIpgr7tttti2bJlERFRKpXi1a9+dRx99NHjjnvMMcfE8ccfH1mWRUTEsmXL4ne/+9244wIAAAAAAAAAQFFlWRbr16+v+W/w+hoAAGDyc0wAAABMVm15BF24cGFExNBTm//6r/86Wey//uu/juuuu27o9e9///s47LDDksUHAAAAAAAAAIAiqVQq0dPTU9PW3d0dnZ2ddcoIAACYSI4JAACAySqXJ0E//vjjNa/33XffZLH322+/iNjwhOmIiCeeeCJZbAAAAAAAAAAAAAAAAAAAoP5yKYJeu3ZtzeupU6cmi93V1VXzur+/P1lsAAAAAAAAAAAAAAAAAACg/tryCDpjxoya148++miy2I899lhERGRZFqVSKWbOnJksNgAAAAAAAAAAwFjNmTNnRJ+bN2/euGMAAAAAAMBkl8uToHfdddeIiCiVShERcdNNNyWLvWmsnXfeOVlsAAAAAAAAAAAAAAAAAACg/nIpgj7yyCOHCqCzLIvvfOc7sXbt2nHHXbt2bVxxxRVDsSMijjjiiHHHBQAAAAAAAAAAAAAAAAAAGkcuRdAzZ86Mgw8+eOj1o48+Gueee+6445577rnx6KOPDr1+7nOfG7Nnzx53XAAAAAAAAAAAAAAAAAAAoHG05RX47//+7+O9731vlEqlyLIsvvCFL8Suu+4aZ5111pji/cu//Et8/vOfH4pXKpXilFNOSZw1AAAAAAAAAAAAAADQaObMmTOiz82bN29c3wcAABpHbkXQp5xySnzsYx+LRx55ZKhw+eyzz45f/vKX8alPfSr22WefEcW577774swzz4wf/vCHNe1Pe9rT4h/+4R/ySB0AAAAAtinLsqhUKjVt5XI5SqVSnTICgMnP9hcAaHajuWDfRf8AAADAtjj3AgA0utyKoDs6OuIb3/hGHHfccUNPbs6yLH7wgx/ED37wgzj66KPj2GOPjcMOOyx22WWXmD59emRZFitXrozHHnss5s+fHzfeeGPccsstERE1MVpaWuKLX/xidHR05JU+AAAAAGxVpVKJnp6emrbu7u7o7OysU0YAMPnZ/gI0BhdGAkDxuIkCAACwOc69AACNLrci6IiIY489NubOnRsf/OAHo1QqDRUxR0T88pe/jF/+8pfbjDH4+Y1Pln784x+P173udfkkDQAAAAAAAABskQsjAQAAAAAAgImQaxF0RMSZZ54ZM2fOjPe+973R399fU8w8WOC8JYOF04OfbW9vj09+8pPxgQ98INec6+3888+Pu+66a9xxLr300pg2bVqCjAAAAAAAAIAi8aQ/AAAAAAAAAIou9yLoiIh3vvOdcdBBB8U555wTN9xwQ0TUFjhvzWCh9NFHHx2f+cxn4vnPf36uuTaCr3zlK7FkyZJxx7n44osVQQMAAABAk8myLCqVSk1buVwe0XgsAM3FNgMAmAzs0wAAAAAAwOQ1IUXQERHPe97z4n/+53/illtuif/8z/+Mn/70p1t92nGpVIr99tsvXvziF8e73vWuOOKIIyYq1bpavHhxkgJoAAAAAKA5VSqV6OnpqWnr7u6Ozs7OOmUEQKOyzQAAJgP7NAAAAAAAMHlNWBH0oKOOOiqOOuqoiIhYunRpPPzww7F06dJYunRpVKvV2GmnnWLHHXeMPffcM3baaaeJTq/uFixYUO8UAAAAAAAAAAAAAAAAAACgria8CHpjM2bMiBkzZtQzhYazaRH0K17xivjxj39cn2QAAAAAiDlz5oz4s/PmzRt3DABgg5FuP7e0/R1NDAA2z/EQAI0oy7KoVCo1beVyOUqlUp0yAgAAKIbxnnsx1gcA1ENdi6AZ7vbbb695feihh9YpEwAAAAAAAAAAgMZSqVSip6enpq27uzs6OzvrlBEAAAAAAHlpqXcC1Nr0SdCKoAEAAAAAAAAAAAAAAAAAaDaeBN1AVq1aFX/6059q2hRBAwAAQFpZlkWlUqlpK5fLUSqV6pQRAAAAAAAAAAAAALCpURdBv+td78ojjzEplUrx9a9/vd5pJPO73/0usiwbej116tTYd99965gRAAAATD6VSiV6enpq2rq7u6Ozs7NOGQEAAAAAAAAAAAAAmxp1EfRll13WEE9GyrJs0hVB33777TWvn/vc50ZLS0udsgGAYvOER2CymDNnzog+N2/evHHHAAAAAAAAAAAAAACARjHqIuhBGz+xeKJN1uKlBQsW1Lw+9NBD65MIAEwCnvAIAAAAAAA0IzeKBQAAmNzcUB8AgG1xroDJZMxF0PVUzwLsPG36JGhF0AAAAAAAAADj50IPmokbxQIAAAAAQHNzroDJZNRF0C9+8YudCM5Bf39/3H333TVtg0XQt99+e/zHf/xH/OIXv4g//vGPsWzZspg+fXrssssu8YIXvCBOOOGEeO1rXxvt7e31SB0AAAAAAACgobnQAwAAAAAAxm/OnDkNEQOA5jHqIuibbrophzS4++67a+483tbWFitXroyjjz46brnllmGff/LJJ+PJJ5+M3//+9/H1r3899tprr5g7d26cdNJJE5k2AAAAAAAAAAAANL0sy2quAYyIKJfLHjoDAAAAAOMw6iJo8nH77bfXvK5Wq/Gyl71sxN//05/+FG9605vive99b3zpS1+KtjaLFgAAAAAAAACg0SiSA5icKpVK9PT01LR1d3dHZ2dnnTICAAAAgOJTKdsgFixYUPO6Wq3WvN5xxx1jr732il133TWWLVsW9913XzzxxBPD4nzlK1+JxYsXx9VXXx0tLS15pgwAADDhXBwIAAAAAJNDM4/1KZIDgPpo5v0PAAAAgKKqexH0Qw89NKxtjz32qEMm9bXpk6AHHXXUUXHWWWfFCSecEK2trUPtWZbFrbfeGhdccEH86Ec/qvnONddcEx/5yEfiE5/4RK45AzQzJ0Uax5w5c0b82Xnz5o07BgD15eJAAAAAAEbK+ZzGZqwPAJho9j8AAACotxS1C5vGGGnMLdVTjCZGas7lMBJ1L4J+5jOfWbNSlkql6O/vr2NG9fG73/1uWNt5550X559//maf6FwqleKoo46K66+/Pj71qU/FWWedFVmWDb0/d+7cOOmkk+KQQw7Z6t+tVCrDOopNrVq1Ktra2mLKlClRrVZjzZo1wz4zbdq0iIhYu3ZtDAwM1LzX2dkZ7e3t0dvbO+xvtba2RldXV2RZFqtXrx4Wd+rUqdHS0hLr1q0btl6Uy+Xo6OiIvr6+WL9+fc17LS0tMXXq1KH8N9XV1RWtra2xfv366Ovrq3mvo6MjyuVy9Pf3x7p162reK5VKsd1220VExOrVq2vmeUTElClToq2tLSqVSvT29ta8197eHp2dnTEwMBBr164dltPgPFyzZs2wJ4FvbR5ua9lst912USqVNrtstjYPB5dNxObn4daWzdbm4cbLZnPzcHDZjHYebrxsNjcPB5dN6nk4uGy2Ng/Hs36PZx5ubf0ezzzc3LJpxj5izZo1w06KvOY1r4kZM2ZEhD6iHn3EePT39+sjQh8xyH7EX0ymPqLI+xEpDC6HydBHVCqVofWmpaUlWlpaore3d1i+o+kj1qxZU7MuDh6D6SMmbx+xevXqmtiD4xJF7CPsR0z8fsRYrVq1Sh/xZ3n1ESmkPNZYtWrViPqIgYGBWLZsWc17HR0dMW3atDH3ES0tLZFlWc33Vq9eHX19fZOqj0jBscaW+4gsy6KjoyMiNvSz1Wo1Ojo6hrabResjHGtsULT9iBS2NA/Ha0vzcKzWrFmz1T5iLFatWrXNPmLjfeHB9wa3Gc20HzFZ+4gUNp6XjdZHjHY/YuMxhVKpFK2trVGtVje7vhiz3GDKlCnD/tZYbJrzRPYRlUolrrvuuqFlHhFx3HHHRblcrvluXscaAwMDdekjSqXSFo8JxrofMThfNo47GDNibH3E4O+yra1t6G9sHDNi6+v3pz/96RiPOXPm1HU8YtP5NLict9VHpDD4u5ws4xGD61Jra2uUSqUYGBgYti5trZ9NYXPzcDzWr1+/1Xk4Fpte/5Mi3qCJPtYYyTJvpjHLke5HpDC43IvURwyaiGONLZ1zmmzHGkUejxjsPwb3Dwdz2rj/aNY+oghjlhH16SPGo1qtNt14RJH7iEFF248Yq1WrVhWyjxivlPNwY6mPNSqVSu59RAqD64Y+YoNG7CO2NQ9Ha3PXoaWKGTH59iMa4bxGCpuec0oVc5A+YoNG7CMca2xQtGONsdr4+raJPNYYGBiI6667rub8w/HHHz90LkcfUTsPJ0MfMRZ1L4KOiGQX9hfV8uXL45BDDomFCxfGI488EgMDA3HmmWfGRz/60RF9/4wzzohly5bFhRdeONSWZVmcf/758b3vfW+r3507d+5W/06WZTF//vyYPXt27L///lGpVGL+/PnDPvfSl740IiLuvffeWLlyZc17+++/f8yePTueeOKJ+MMf/lDz3o477hgHH3xwDAwMbDbuUUcdFR0dHfHHP/4xli5dWvPeXnvtFU9/+tNj2bJlcffdd9e8t91228Xznve8iIj47W9/O2wde/7znx9Tp06NRYsWxaOPPlrz3h577BF77rlnrF69OhYsWFDzXrlcjhe+8IUREXHnnXcO+3EfcsghscMOO8Qjjzwy7Cnnu+66a+y3336xfv36YdNaKpXiJS95SURE3HPPPcM6hgMOOCB23nnnWLJkSfzpT3+qeW/GjBlx0EEHRX9//2bn4THHHBNtbW3xhz/8YdgFtfvss0887WlPi6eeeiruueeemve23377OOywwyIiNhv3BS94QUyZMiUefPDBWLJkSc17z3zmM+OZz3xmrFy5Mu64446a96ZMmRIveMELImJD8f+mHfqhhx4a06dPj//7v/+Lhx9+uOa93XbbLfbdd99Yu3btsJxaW1vjRS96UURE3HXXXcM2BgceeGDMnDkzHn300XjggQdq3ps1a1Y85znPib6+vs1O64tf/OIolUpx//33x/Lly2ve22+//WLXXXeNJ598Mu67776a93bYYYc45JBDhn5Hm3rhC18Y5XI5Fi5cGE888UTNe8961rPiGc94Rixfvjx+//vf17zX1dUVRxxxRERseIr8phugww8/PKZNmxYPPfRQLF68uOa93XffPfbee+9YvXr1sCfQt7e3x9FHHx0REb///e+Hbaif+9znxk477RSPPvpoPPjggzXvNWMfsWbNmmHrw1133RUvfvGLI0IfUY8+YjyWL1+ujwh9xCD7EX8xmfqIIu9HpDCY22ToI/r7+4fm5bRp06JcLseTTz457Hczmj5iyZIlNctncHBCHzF5+4gHH3ywZpkP3t2/iH2E/YiXRsTE7keM1fz58/URf5ZXH5FCymON+fPnj6iPWL16dXznO9+peW///fePl73sZWPuI5797GdHRNR8b8GCBdHW1jap+ogUHGtsuY8YGBiIxx9/PCI2rEv9/f2x//77DxWoFK2PcKyxQdH2I1LY0n7EeG2pjxire+65p6aPSGH+/Pnb7CP233//iNhQZDPYBw9uM5ppP2Ky9hEpbBy/0fqI0e5HbDymUC6XY9q0aVGpVDZ7s+qRHmvcf//9NdOzww47xOGHHz6p9iNS2HReTGQfMbjc29vbY/r06RHxl35uY3kda6xevboufcRee+0V1Wp1s8cEY92P2Pii1sHvbTwvx9JHDBY977DDDhERsXLlymHLZ2t9RAr1Go9YsGDBsPk/eIHQtvqIFAana7KMRwz+1nfaaacolUqxZs2aYevS1vYjUtjcfsR4PPTQQ1vsI8Zq/vz5NfsRKeINmuhjjcFlvsMOO0RbW1usW7du2DJvpjHLke5HpDCYW5H6iEETcazxyCOP1PTvgwUNk+1Yo8jjEYP9x5QpU2Lq1KnR398/rP9o1j6iCGOW9eojxqNSqTTdeESR+4hBRduPGKv58+cXso8Yr831ESmkPtZ49NFHc+8jUhhcl/URGzRiH7Gt/YjRGoyR8lhj47wm235EI5zXSGH+/Pk1+xGpYg7SR2zQiH3EZDnWyLIsZs6cGfvss0+sWbMmbr/99qGb60VMvmONsZo/f/429yP22WefWLZsWc2yaW1tjba2tjEfawyev9n4vMbGx+r6iA0mUx8xluvjS1mdK5BbWlqGOo0sy4buztms+vr6YtGiRbHnnntu9gnQWzIwMBD77rtvLFy4cKitVCrFY489FjvvvPMWvzf4JOhZs2Zt9kkqHR0d8eSTTxbujgDuGvIXjX5nIXcodNeQovYRq1ev9iToBukjxnuX/4iID3/4w/qI0EcMsh/xF5OhjxhU5P2Ikd4caWtOP/30iJgcfcTg03sGp6elpSVe+9rXDru4e7RPgh6MORj3DW94w9C82Jg+4i+K3EesWrWqZpmXSqV44xvfGO3t7YXrI+xHTMx+RIp9ztNPP10f8Wd59BEpltGmTwAbb8zTTz99RH3E2rVr47//+79r3jv++ONjxowZ43oS9FVXXVXzvcE7pE6WPiLVMnesseU+olKpxI9//OOI+EsxxsZ32i1SHxHhWGNQ0fYjUvzWzzvvvJp5mKr/2Hgepoh55pln1vQRqfY/RvIk6GuuuabmSdCDv/Vm2Y+ImLx9xJw5c4a9N1qDYwoRjddHjOVJ0IPHgoNPfXvd61632XPTIz3WWLly5WaPLwfPI2yqiPsRH//4x4f9vdHaeD2KKM6ToFP0xR/5yEfq9iToLR0TjOdJ0Ndff/0Wn8Qw1idBX3fddTVPgt44ZsTkfRL00qVLa/qPiIg3vOEN0dXVtc0+4hOf+MSYp3nQ4O9ysoxHDK5LGz8V+NWvfnXNurSlfjbV/uHG8zBFzA996EM18zDV/uHG8/CCCy4Yd7xB9XgS9LaW+WQfs9zcPNzWfkTK/cMi9RGDJupJ0Js75zRYrL+xIh9rFGE8IlX/3kx9RBHGLCMmvo8Y77p03nnnNd14RBH6iIjin/tMtX9YxD5i3rx5Y5vgPzvnnHNq1u9U24yN52GKmGeffXbufcTHPvaxcec5uH+oj9igUfqIjW06D1OcB49Ie6yx8fHlZNqPiGiM8xqf+tSnhsUerU3POaU+/6CP2KAR+ohNTZZjjUqlEtdff320trYOjXFvOhY9kX1EqvPgeV7ftqV+NiI2e/6hs7PTk6D/TB+xwdb6iJkzZ26xjnXTHIamcbOt1E17e3vsvffeo/5ea2trnHrqqXHaaacNtWVZFjfccEO89a1v3eL3yuXysBO8mxpc0SM2/FA3fr2pwZ2wzeno6IiOjo7NvlcqlbYad8qUKVt8r729fagj3Zytxe3s7Bx64tem2tratvrdwY5lc7Y2X1tbW7cad+M7aG9qa/NwPMtmPPNwa8vGPNxgPOv3eObh1tbv8czDrS2bZusjNn1KwMbzrVnW74jG6yPGYnBZ6iM2SN1HpBjsmDNnTuH6CNvADRqtjyjaPEz11KbN5dYofcSgkc7D9vb2Ydvgjo6OLeY7kj6iVCoNizn4t/QRk7OPyLJss8u8aPOwGfYjBjXiscZobfx38uoj5s6dO/YE/2xz+25F6yPGI+Wxxsb5b2sebtonDQ7eR2x7Ho704vcvfelLm23f3DIvWh8xHkUcj5io/YiN8x9cR7fbbrthuRWtj7AvtkER9yPGalvzcKy2NQ9Ha+N1JFXcTeNsbtkMnmwcLAwc/NzGy6lo63eEPiKlzcVvxD5iJPsRmxtTaGlp2eq6tq1jje22226zx5eTbT9ivLb0dyeij9jcct/cPs2g1Mcag/3rRPcR69evHzbmtel0j7afHdxmbBx3c/NyNH3Epsunra1ti8tna+v3eNRrPGJz/cfgjfK31UeksOl0FX0buOm61NrausV1aVv97Fhtax6O1mDuKfeTN73+J2W8QRN1rDGaZd5MY5Z5rd8bG+05p0boIzaV57HGls45Fb2f3VTRxiPGo5n6iCKMWW6sHuv3WIxkH6+Z5mEj9hGT6dznaG26T12kPmI8Us7DjaXeFxuc9jz7iBQ2zU0f8ReN1kekOq+Rx5j0lmI2yzYwoj7nNUZjopa7PmKDRuwjin6s0d7ePrTtGzx239JY0mQ61hitjfPf0no4kvMPo52HIz3/oI/YYLL1ESOlCHoSeeUrXzms7de//vVWi6ABAAAAAAAAAAAAGkmWZcOe/lMul5PdSBoAgMaU6sE7AMDkoQh6Etl///2HHuE+aMmSJXXMCAAAAAAAAAAAABqLAtvGV6lUoqenp6atu7t7i09RAgAAABrbSG9SMW/evHF9n8lHEfQks9NOO9UUPi9durSO2QAAAAAAAAAARTLei5BGEwMA6kWBLQBA8/KkYQCAYlEEPckMDAzUvJ46dWqdMgGAkXOHZRpVUdbNouQJAAAAAAAwVqO5wNyTQoC8uWkIAAAAAEwMRdANqK+vL9rb20f9vSzLYtmyZTVtM2fOTJUWAOTGHZZpVEVZN4uSJwAAAAAAAAAAAAAAjc0N4GgkiqAbwN/+7d/GXXfdFU888UQ8/vjjceCBB8avf/3rUce56667hj0Jer/99kuVJgAAAAAAAAAAozDeC8VcJAYAjFeWZVGpVGrayuVylEqlOmUEAACQ3mjGUo3HQrEogm4ADz/8cNx2221Dr3/3u9/FmjVrYurUqaOK89Of/nRY24te9KJx5wcAAAAAAAAAADDR3EgAYPwqlUr09PTUtHV3d0dnZ2edMgJgskqx/71pjDxiAgBQLIqgG8Dhhx8eP/nJT4Ze9/b2Rk9PT7z97W8fcYwsy+LLX/5yTduuu+4ahx9+eLI8AQAAAAAAAAAAoEjGW0w/mhgAAAAAQFoNUQSdZVm9U6irv/mbv4lPfvKTNW3z5s2Lt7zlLdHa2jqiGF/84hfj/vvvr2n7h3/4h2hra4hFDAAAAAAAAAA0KcVnAMCWjGYbP9me+l7kJ1tmWRaVSqWmrVwuR6lUaqiYAAAAQPHVvUL20ksvrXcKdXfYYYfF4YcfHvPnzx9qu+uuu+Lcc8/d6gm+QTfeeGOcddZZNW2zZs2Kv//7v0+eK0DeDGZPbs184goAAIBaxgAAAAAAAIqpUqlET09PTVt3d3d0dnY2VEwAAIDxKPLNqxi78S4zyzy9uhdBn3LKKfVOoSF8/vOfjxe96EU1T8X+l3/5l+jt7Y158+ZFR0fHsO9kWRZf//rX433ve9+wiwW//OUvx4wZM3LPGyA1g9kAAADQHIwBAAB58cRZAAAAAAAAgMmh7kXQbHD00UfHhz70oZg7d25N+2c/+9m48sor493vfnccffTRMWPGjHjqqafit7/9bVxxxRXxu9/9blisv/u7v4uTTjppolIHAACAhuXCdwAAAAAAAAAAAAAoJkXQDeTCCy+MpUuXxle/+tWa9v/7v/8b8QXXf/u3fxtf+tKXcsgOAAAAKLosy6JSqdS0lcvlKJVKdcoIAAAAAACAVNwgGAAmN9d9AADNSBF0g/nKV74Shx9+eJx22mmxbt26EX+vq6sr5s6dG6eeemqO2QEAAABFVqlUoqenp6atu7s7Ojs765QRAAAAAAAAAAAj4boPAKAZtdQ7AYZ7z3veEw888ECcffbZsdtuu231szvvvHOcfvrp8cc//lEBNAAAAAAAAAAAADChsiyL9evX1/yXZVm905oQzTztAAAAABPBk6Ab1OzZs+PCCy+MCy+8MO677764/fbb48knn4zly5dHZ2dn7LrrrnHQQQfFQQcdFKVSqd7pAgAAAAAAAAAAAE2omZ9I2AzTPmfOnBF9bt68eeOOAQAAALApRdAFsN9++8V+++1X7zQAAAAAAAAAmtJ4L/p3wT8AAAAAMBrGJAEANlAEDQAAAAAAAAAAAIxblmVRqVRq2srlcpRKpTplBAAAAAAUmSJoAAAAmoY7pAIAAADNpiiFSEXJEwDYukqlEj09PTVt3d3d0dnZWaeMgEY03vO2o4kBAAAAFJsiaABgi8Z7ssDJBgCAsXPxNwAAACkUpRCpKHkCABPPeDkAAAAANC9F0AAAAAANyMXfAAAAAABgvBwAAAAakZuWARNFETQAAAAAALmZM2fOiD87b968cccAACaWC1wAAAAAAACaj5uWARNFETQAAAAAAAAAY+ICFwAAaC4jvWGhGx4CAAAAkEJLvRMAAAAAAAAAAAAAAAAAAADYmCdBAwAAAAAAADSgLMuiUqnUtJXL5SiVSnXKCAAAAAAAAAAmjiJoAAAAgElozpw5I/rcvHnzxvV9AAAgP5VKJXp6emrauru7o7Ozs04ZAQBAvsY7tj2aGAAAAEB9pDh2d/wPzUMRNAAAMCE8uQgAaHZuTgAAAKSmUAwAAAAAAIDJTBE0AGyDi0cA0vDkIgAAAAAAAACKaDTX/rjRJQAAAEA6iqDJVZZl0dfXF9Vqtd6pwJCWlpZob2/31EmAEfL0XgBGw3YDAAAa03hv9uhCbSAVxSMAAAAAAADASCmCJhdr166NFStWxKpVq2JgYKDe6cAwra2tMW3atJg+fXp0dXXVOx2AhubpvY3FBctAo7PdAACA5ubGSKRgPQIAAAAAAGgMbm4K1JsiaJJbtWpVPPzww9He3h477LBDTJ06NVpaWlyUQEPIsiyq1WqsWbMmVq5cGcuXL4/dd989pk2bVu/UAJJwcSAAAAAA9eTGSJPbeG/QN9IY1iNGywVYAFAfE7V/SFquKwAAAAAmi/GOLRmbKgZF0CS1du3aePjhh2P77beP3XbbzcAoDWvq1Kkxa9asWLx4cTz88MPxjGc8wxOhgUnBxYEAAAAAAMU13oKU8RYiudADAGDyc10BAADkx02HACA9RdAktWLFimhvb1cATSGUSqXYbbfdYt26dbFixQpF0ABQQAYMgcnC0zIYZNsGAADNTUEKALA1xg8BmGxs2wCYbIzxAkB6iqBJJsuyWLVqVeywww4GHyiMUqkU22+/fSxfvjx22WUX6y4AFIwBQwAmG9s2AAAAAGBLjB8CMNnYtgEAALAtiqBJpq+vLwYGBmLq1Kn1TgVGpaurK5YuXRp9fX3R0dFR73QAqJPxPoHT0zcBAAAAAAAAaCTOgwMAAABQdIqgSaZarUZEREtLS50zgdFpbW2NiL+swwCQpyzLolKp1LSVy+UolUp1yggAAAAAAAAAAAAAAKDxKIImOQU8FI11FhipZiheHe9doEcTo1lVKpXo6empaevu7o7Ozs46ZQRACs2wn1B0lhEAAAAAAAAAAABAsSiCBgAYIcWrNBOFYjA+fkPNx35C47OMgMkixY2n3LwKAAAAAAAAYOxGc851Sw8ect4WAEZGETQAAJOCgsO0FIrB+PgNAQBFMtKT61s6OT+aGAAAAAAANB+FYgAAAIyVImgAmMQUhU5uLlKvpeAQAAAAAAAAmAwUigEwXq4bAwAAYLJQBA0ADSKPgWdFoQBAXlyABQDASLjYEgAAAAAmnuvGAAAAmCwUQVNXzXjBezNOMzAyBp4BAIZTNAPQGPTHwFgZ84KRcaMpAAAASM/YNgAAABSfImhoUs95znPi7rvvjoiIN77xjfFf//Vf2/zOTTfdFMcee+xWP1MqlaJcLseMGTPi2c9+drzsZS+Ld7/73TF79uwR53b33XfHlVdeGT/+8Y9j0aJF8cQTT0RLS0vssssuccghh8SJJ54Yb3zjG2O77bYbcUwAAIpnpBdvu/h7clM0w2SlyIWiaYb+OMVvaiQxXHQHAAAAADAxmmFsGwAARsK1CkCRKYKGJvSrX/1qqAA6IuLqq6+Oxx57LHbZZZdxx86yLNavXx+PPPJIPPLII/GTn/wkPvGJT8TFF18cJ5988la/+8gjj8RZZ50V3/nOdyLLsmHvL1y4MBYuXBhXXXVVnHHGGXH++efH+973PjtdAADUjSJGms1411frO4CL7pi87BsDAAAAwLY53wYAQD24VgEoMkXQ0IQuueSSiIh45jOfGYsWLYr+/v742te+Fh/+8IdHHOPEE0+MCy64YFj74N1hHnvssbjiiiviyiuvjLVr18Ypp5wSs2bNile/+tWbjXfbbbfFX/3VX8Wjjz4aEREzZ86Mt7zlLfHSl740dttttxgYGIj77rsvrrnmmvj+978fS5cujVNPPTWuv/76+O53vxtTp04dw5yg3sb7dMfRxACoh2Z9iq0L3wEAAAAAAAAAAAAAgPFSBA1NZt26dfGf//mfERHxute9Lv73f/83fvWrX8W///u/xznnnBMtLS0jirPTTjvFIYccstXPvP71r485c+bERz/60ciyLE499dS47777hj25+f7774+Xv/zlsXLlyoiIeP/73x+f+MQnYtq0aTWfO/roo+Nd73pX/O53v4vu7u544IEH4tprr43u7u647rrrorW1dYRzAQAAYOzczKexuRkHAAAAAAAAwOikOEfqPCsAAJCHkVU7ApPGlVdeGStWrIiIiJe+9KVx0kknRUTEQw89FNdee23yv/fhD384nv70p0dExB/+8Ie49dZba97v7e2Nv/7rvx4qgP7sZz8bX/jCF4YVQG/s4IMPjv/93/+N5zznORER8eMf/zj+9V//NXnuAAAAAAAAAAAAAAAAAEB9eBI0NJlLL700IiK6urrila98ZSxfvjzOOuusqFarcfHFF8cJJ5yQ9O+1tbXFcccdF5dccklERNxxxx1x1FFHDb3/zW9+M+66666IiHjDG94Qp5122oji7rzzznHppZfGkUceGdVqNT7+8Y/H//f//X8xY8aMpPkDAI3BUz0BAAAAAAAokizLolKp1LSVy+UolUp1yggAAAAAoHgUQUMTeeCBB+Kmm26KiIjjjz8+urq6oqurK172spfFDTfcENddd10sWrQonvGMZyT9u7Nnzx7697Jly2re+/SnPz307w9/+MOjivv85z8/3vrWt8bll18ea9asiUsuuSTOPPPM8SULAAAAAImM9EY8W7qRz2hiAAAAAI2lUqlET09PTVt3d3d0dnbWKSMAAAAoDjcXA2CQImhoIpdeemlkWRYRESeffPJQ+zve8Y644YYbolqtxle/+tX4xCc+kfTvLlmyZOjfs2bNGvr3Aw88EPfee29ERDz72c+OQw45ZNSx3/SmN8Xll18eERFXXXWVImiAJqGQAAAAAAAAAAAAAAAmJzcXG5vRXB+9peusXWMNNBpF0NAkqtVqfOMb34iIDYXIr3nNa4bee8Mb3hD/+I//GKtWrYpLLrkk5syZE+3t7Un+bl9fX/zoRz8aen3UUUcN/ftnP/vZ0L9f8IIXjCn+cccdF+3t7dHX1xe33XZb9Pb2RkdHx9gTBoAmY7ADaCRucgEAAAAAAAAAAAAADFIEDU3ihhtuiIceeigiIt761rfWFDl3dXXFG9/4xrj00kvjsccei6uvvjpOOumkcf/NLMvi9NNPj0ceeSQiIo4++ug44IADht5/4IEHhv69zz77jOlvdHZ2xs477xyPPPJI9Pf3x8KFC+PZz372+BIHAACgrrIsi0qlUtNWLpejVCrVKSNoHm6SAwAAAAAAAAAAQKNQBA1N4pJLLhn69ymnnDLs/VNOOSUuvfTSiIi4+OKLt1kE/dRTT8WCBQuGtQ8MDMSKFSvijjvuiMsvvzzmz58fERuKlb/0pS8NizFo+vTpI56WTe2yyy5DhdbLly8fcxwAAAAaQ6VSiZ6enpq27u7u6OzsrFNGAAAAAMBYuOEhAAAAAADjoQgamsCyZcvi6quvjoiIgw46KA499NBhn3nxi18cz3rWs+KBBx6IG2+8Me6///7Yd999txjzmmuuiWuuuWZEf3/WrFnxne98Jw455JCa9nXr1g39ezwXsre1/aUry7JszHEABnnyGQAAAABs20jHwIyhAQA0Lzc8BAAAAABgPBRBQxP49re/PXRX3c09BToiolQqxTve8Y746Ec/GlmWxcUXXxyf+cxnRv23WltbY9q0aTFr1qw45JBD4rjjjou3vvWtMXXq1GGf3fjpz+N5gvOyZcuG/r3DDjuMOQ4UnQsOAQAAAAAAAAAAmsdEPuwhy7Kha1EHlcvlKJVKI86BDcxLaA5+6wAAaSiChiZwySWXDP37jDPOiDPOOGOb3/nGN74RF1544RbvvHvKKafEZZddNq689tlnn6F/P/jgg2OK0dvbGw899FBEbCjA3nPPPceVEwAAAAAAAAAAAFAsHiCRv0qlEj09PTVt3d3dW7zOlC0zL6E5+K0DAKShCBomuTvuuCN++9vfjvp7Tz31VHz3u9+Nd7zjHTlktcGLXvSioX///Oc/H1OM2267LdavXx8REYcddliUy+UkuQEAzcsdOAEAAAAAAAAAAIBG0AzXNI73hjajiQFA8SiChknu61//+tC/zzzzzDjiiCO2+vnf/va3MXfu3IiIuPjii3Mtgj7ggANi//33j3vuuSfuuOOOuP322+PQQw8dVYxLL7106N/d3d2pU4TcOFADaFzuwAkAAAAAQDNJcd7RuUsAAACAfLimsfk0Q+E7wGgogoZJrLe3N6644oqIiJgyZUp85CMfiWnTpm31O6997Wvj3/7t32LFihVx6623xh133BHPfe5zc8vxAx/4QPzd3/1dRESce+65ce211474u/fdd19cfvnlEbFh+v7f//t/ueQIAABAfsZ7gyAX2AIAQLG5aSjNzsVsAMU3mn0R45wAADA5GecEUlL4DlBLETRMYt///vdj6dKlERHxute9bpsF0BEbionf/OY3x1e+8pWIiLjooovioosuyi3Hd7/73fHlL3857rzzzrjuuuvi4x//eHz4wx/e5veWL18ef/M3fxPr16+PiIizzz47Zs2alVueAAAAAACTnSIsAJh4LmZrLOO92NjFygAATAZu8AEAAEAjUQQNk9gll1wy9O+TTz55xN9717veNVQEfcUVV8S//uu/xnbbbZc8v4iItra2+O53vxtHHnlkrFixIj7ykY/Eo48+GvPmzdti0fbvfve7eNvb3hZ33XVXRES89KUvjQ996EO55AcAAAAA0CwUYQEAAOMx3iefKZYCACYjT4cFAAAYn5Z6JwDkY/HixfE///M/ERExa9aseOUrXzni7x5xxBHxnOc8JyIiVq1aFVdccUUuOQ569rOfHT/5yU9i9uzZERHxb//2b7H33nvHaaedFldffXX86le/iptvvjkuueSS6O7ujsMOO2yoAPrlL395XH311dHe3p5rjgAAAAAAAAAAAAA0lyzLYv369TX/ZVlW77QASEAfDwDF4EnQMElddtllMTAwEBERb37zm6OtbXQ/93e+851xxhlnRETExRdfHO9973uT57ixww8/PO688874p3/6p/jOd74Tjz/+eHz+85+Pz3/+85v9/IwZM+Lcc8+NU089NVpbW3PNDQAAAAAAAAAAAIDmU6lUoqenp6atu7s7Ojs765QRAKno4wGgGBRBU1dz5sypdwqT1mWXXTb077e//e2j/v7JJ58cZ599dvT19cWCBQviV7/6VcLsNm/WrFlx+eWXx3nnnRff/va348Ybb4x77rknli9fHm1tbbHrrrvGYYcdFieccEKcdNJJ0dXVlXtOAMDkNZp90Xnz5o07BgAAAAAAAAAAAAAMGul1qK5jBZqZImiYpO6///5xfX/nnXeO3t7eYe1Zlo0r7kjsu+++MWfOHDtjAAAAAAA5cFMoAAAAAAAAAACKQBE0AAAAAAAAAEwwT3doPuNd5qOJAQAAAAAAAJOBImgAJr0sy6JSqdS0lcvlKJVKdcoIAAAAAMbHmBcAAAAAAAAAAJOdImgAJr1KpRI9PT01bd3d3dHZ2VmnjACYrFI8hcWTXAAAgJEw5gUAAAAAAAAAwGSnCBoAAAAAAABgnDyhHQAAAKDYRnrj+nnz5o07BgAAACOjCBoAAAAAAABgnDyhHQAAAAAAAADSaql3AgAAAAAAAAAAAAAAAAAAABvzJGgAAAAAAIAGNWfOnBF/dt68eeOOAQAAAAAAAAAAjcKToAEAAAAAAAAAAAAAAAAAgIaiCBoAAAAAAAAAAAAAAAAAAGgobfVOAAAAAAAAAAAAAAAAACC1OXPmjPiz8+bNG3cMACAtT4ImuSzL6p0CjIp1FgAAAAAAAAAAAAAAAAAaiydBk0xLy4aa+mq1WudMYHQGBgYi4i/rMAAANIssy6JSqdS0lcvlKJVKdcoIAAAAAAAmnvFyAAAAAIDGpAiaZNrb26O1tTXWrFkTU6dOrXc6MGJr166N1tbWaG9vr3cqAAAwoSqVSvT09NS0dXd3R2dnZ50yAgAAAACAiWe8HAAAAACgMSmCJplSqRTTpk2LlStXxqxZs9wJlULIsixWrlwZ06ZNs84CAAAAAJ7+BWzTnDlzRvzZefPmjTsGAAAAAAAw+Tn/AACbpwiapKZPnx7Lly+PxYsXx2677eaiMBpalmWxePHi6Ovri+nTp9c7HQCAulLoAQAAG3j6FwAAAAAAAAAANAZF0A3unnvuiW9+85vxi1/8Iv7whz/EsmXLorW1NWbPnh0HHXRQHH/88fHWt761YQo4u7q6Yvfdd4+HH3441q1bF9tvv310dXVFa2ur4gkaQpZlMTAwEGvXro2VK1dGX19f7L777tHV1VXv1EhkpHev2tLdr0YTAwAmE4UeAAAAAAAAAAAAAAA0EkXQDWrJkiXxvve9L6688srNvv/ggw/Ggw8+GNdcc0188IMfjPPOOy/++Z//OVpaWiY40+GmTZsWz3jGM2LFihWxfPnyWLp0ab1TgmFaW1tj2rRpMX36dAXQAAAAAAAAAAAAAAAAANBgFEE3oDvuuCNe+cpXxpIlS0b0+VWrVsWZZ54ZN954Y1x55ZUxZcqUnDPctq6urujq6opddtkl+vr6olqt1jslGNLS0hLt7e2eTg4AAAAAAAAAAAAAANAEsiyLSqVS01Yul9WWADQ4RdANZuHChXHsscfGU089Ney9Aw88MPbYY49YsWJF3HXXXbF8+fKa96+99tp405veFN///vcbZgNcKpWio6Oj3mkAAAAAAAAAAAAAAAAATapSqURPT09NW3d3d3R2dtYpIwBGoqXeCfAX/f398cY3vnFYAfTrX//6+MMf/hB33nln/PCHP4xf/OIX8eijj8bXvva1mD59es1nf/CDH8TnP//5iUwbAAAAAAAAAAAAAAAAoKlkWRbr16+v+S/LsnqnBTCpKIJuIBdddFHcfvvtNW3/9E//FD09PbH33nvXtHd2dsa73/3umD9/fuy66641733sYx+LFStW5J4vAAAAAAAAAAAAAAAAQDMafLr0xv9VKpV6pwUwqbTVOwE2qFQq8bGPfaym7cUvfnF8+tOf3ur39tprr/jBD34QRx55ZPT19UVExFNPPRWf/vSn44ILLsgtXwAAAAAAKLo5c+aM6HPz5s0b1/cBAAAAAAAAAIDRUwTdIP77v/87nnjiiZq2efPmRalU2uZ3DzvssPi7v/u7+OIXvzjU9pWvfCXmzJkTLS0e9g0AANDsRlOco8AHAAAAAAAAgKLKsmzY0xfL5fKIrskGAACg8aiQbRD/8R//UfP6wAMPjBe+8IUj/v4//MM/1Lx+/PHH42c/+1mS3AAAAAAAAAAAAAAAGl2lUomenp6a/zYtigYAAKA4FEE3gL6+vrjxxhtr2k488cRRxXj2s58de++9d03bf//3f487NwAAAADIW5ZlsX79+pr/siyrd1oAAAAAAAAAAABAHbXVOwEiFixYEKtXr65pO+aYY0Yd56ijjoo//vGPQ69vuumm8aYGAABMQnPmzBnR5+bNmzfuGAAwEoN35N9Yd3d3dHZ21ikjAKCRZFk27Gk95XI5SqVSnTICAKCoRnN+Y0vnSZwjAQAAAACYOIqgG8Bdd901rO3ggw8edZyDDjqo5vXdd98d69atiylTpow5NwAAAAAAAKgnN0wBAAAAAAAAgOakCLoB3HPPPTWvu7q64mlPe9qo4+y99941r6vVajzwwANxwAEHjCs/AAAAAEhlpE/K2dKTdkYTAwAAAAAAAAAAACiuUpZlWb2TaHYnn3xyXH755UOv99lnn7j//vtHHedXv/pVHHnkkTVt1157bRx//PHb/G6pVNriex0dHaPOBWAkBgYGxh2jtbVVzEQxN42XR8xGnO6JipmHokx7s8SciN9QHjEbcV6KWcyYeWjW31AeirIeidlYMW3bxMxLUaa9COt7HjEbcV6KWcyYRZHH7zK1oixzMSd/zInatm1JtVqted3S0jKuvz0ejbh8xGz8mPYPxRSz8WL6XeYbMw9FmfZmiek3JKaYzdF3+l2K2UwxbduKF3NrxjqWVJRpL0rMPDTrbygPRZl2MdPFK0rMRpyXYhYz5pbkcc5pPDH9hsQUc+zxihSTv+jt7d3ie1sqdVYE3QCOO+64uOGGG4ZeH3PMMfHzn/981HEWLlwYe+21V03bN7/5zTj55JO3+d2tFUEDAAAAAAAAAAAAAAAAAEAetlTq3DbBebAZTz31VM3r7bfffkxxpk2bNqxt2bJlW/1OpVKJSqUypr8HAAAAAAAAAAAAAAAAAAB5aKl3AsSwIuSurq4xxdnc99avX7/V78ydOzemT58+pr8HAAAAAAAAAAAAAAAAAAB5UATdADYtgm5rG9sDultbW4e19fX1bfU7Z599dqxYsWJMfw8AAAAAAAAAAAAAAAAAAPIwtmpbkhoYGKh5vbli5pHY3Peq1epWv1Mul6NcLo/p7wEAAAAAAAAAAAAAAAAAQB4UQTeA9vb2mtf9/f1jirO5pz6nKHDu6OgYd4wi6O3tLcS0yjMteaZVhDyLkGOEPFOTZzpFyDFCnqnJM50i5Bghz9TkmU4RcoyQZ2ryTKcIOUbIMzV5plWEPIuQY4Q8U5NnOkXIMUKeqckznSLkGCHP1OSZThFyjJBnavJMqwh5FiHHCHmmJs90ipBjhDxTk2c6RcgxQp6pyTOdIuQYIc/U5JlOEXKMkGdq8kyrCHkWIccIeaYmz3SKkGOEPBm73t7eUX+nlGVZlkMujMJzn/vcuPPOO4ded3d3x1VXXTXqOCtWrIgddtihpu1zn/tcfOADHxhvipPeypUrY/r06bFixYrYfvvt653OFskzLXmmVYQ8i5BjhDxTk2c6RcgxQp6pyTOdIuQYIc/U5JlOEXKMkGdq8kynCDlGyDM1eaZVhDyLkGOEPFOTZzpFyDFCnqnJM50i5Bghz9TkmU4RcoyQZ2ryTKsIeRYhxwh5pibPdIqQY4Q8U5NnOkXIMUKeqckznSLkGCHP1OSZThFyjJBnavJMqwh5FiHHCHmmJs90ipBjhDyZeC31ToCI6dOn17xevXr1mOKsWrVqWNvUqVPHFKvZlMvlOP/885M8OTtP8kxLnmkVIc8i5Bghz9TkmU4RcoyQZ2ryTKcIOUbIMzV5plOEHCPkmZo80ylCjhHyTE2eaRUhzyLkGCHP1OSZThFyjJBnavJMpwg5RsgzNXmmU4QcI+SZmjzTKkKeRcgxQp6pyTOdIuQYIc/U5JlOEXKMkGdq8kynCDlGyDM1eaZThBwj5JmaPNMqQp5FyDFCnqnJM50i5BghTyaeJ0E3gNe//vXxve99b+j185///Pj1r3896ji///3v46CDDqpp+/73vx8nnnjiuHMEAAAAAAAAAAAAAAAAAICJ4knQDWC33Xareb1kyZIxxdnc92bPnj2mWAAAAAAAAAAAAAAAAAAAUC+KoBvAXnvtVfN68eLF0d/fP+o4ixYtGta25557jjkvAAAAAAAAAAAAAAAAAACoB0XQDeA5z3lOzev+/v5YuHDhqOPcd999Na933nnnmDlz5rhyAwAAAAAAAAAAAAAAAACAiaYIugE873nPG9Z22223jTrOpt857LDDxpwTAAAAAAAAAAAAAAAAAADUiyLoBjBz5sw48MADa9p+8pOfjCrG2rVr45Zbbqlpe8UrXjHu3AAAAAAAAAAAAAAAAAAAYKIpgm4Qr33ta2teX3311bF+/foRf7+np2fY51/zmtckyQ0AAAAAAAAAAAAAAAAAACaSIugG8Y53vKPm9VNPPRUXXXTRiL7b398fc+fOrWk7+uijY//990+WHwAAAAAAAAAAAAAAAAAATBRF0A3igAMOiFe84hU1beecc07ceuut2/zu+9///rjrrrtq2v75n/85aX4AAAAAAAAAAAAAAAAAADBRSlmWZfVOgg1uu+22eMELXhDVanWobaeddoorrrgiXv3qVw/7fG9vb5x++unxpS99qab9qKOOil/+8pe55wsAAAAAAAAAAAAAAAAAAHlQBN1gzj777Jg3b15NW6lUihNOOCHe8pa3xF577RVr1qyJ+fPnx1e+8pX44x//WPPZ7bffPubPnx977733RKYNAAAAAAAAAAAAAAAAAADJKIJuMNVqNd797nfHZZddNurvdnZ2xtVXXx2vetWr0icGAAAAAAAAAAAAAAAAAAATpKXeCVCrpaUlvv71r8cHP/jBaGtrG/H3dt999/jRj36kABoAAAAAAAAAAAAAAAAAgMLzJOgGduedd8YFF1wQ1157baxdu3azn5k9e3a85z3vidNPPz2mT58+wRkCAAAAAAAAAAAAAAAAAEB6iqALYN26dfGLX/wiHn744ViyZEm0tbXFzJkz49BDD42DDjooWlo80BsAAAAAAAAAAAAAAAAAgMlDETQAAAAAAAAAAAAAAAAAANBQPEIYAAAAAAAAAAAAAAAAAABoKIqgAQAAAAAAAAAAAAAAAACAhqIIGgAAAAAAAAAAAAAAAAAAaCiKoAEAAAAAAAAAAAAAAAAAgIbSVu8EaAylUmmL73V0dExgJgAAAAAAAAAAAAAAAAAATCa9vb1bfC/Lss22l7ItvUNT2VoRNAAAAAAAAAAAAAAAAAAA5GFLpc4tE5wHAAAAAAAAAAAAAAAAAADAVimCBgAAAAAAAAAAAAAAAAAAGooiaAAAAAAAAAAAAAAAAAAAoKEoggYAAAAAAAAAAAAAAAAAABpKW70ToPF1dHTUOwUAAAAAAAAAAAAAAAAAAAqqt7d31N9RBE1EbCh03twK1NHREZVKpQ4ZAQAAAAAAAAAAAAAAAAAwGZTL5S3WsW5JS54JAQAAAAAAAAAAAAAAAAAAjJYiaAAAAAAAAAAAAAAAAAAAoKEoggYAAAAAAAAAAAAAAAAAABqKImgAAAAAAAAAAAAAAAAAAKChKIIGAAAAAAAAAAAAAAAAAAAaiiJoAAAAAAAAAAAAAAAAAACgoSiCBgAAAAAAAAAAAAAAAAAAGooiaAAAAAAAAAAAAAAAAAAAoKEoggYAAAAAAAAAAAAAAAAAABqKImgAAAAAAAAAAAAAAAAAAKChKIIGAAAAAAAAAAAAAAAAAAAaiiJoAAAAAAAAAAAAAAAAAACgoSiCBgAAAAAAAAAAAAAAAAAAGooiaAAAAAAAAAAAAAAAAAAAoKEoggYAAAAAAAAAAAAAAAAAABqKImgAAAAAAAAAAAAAAAAAAKChKIIGAAAAAAAAAAAAAAAAAAAaiiJoAAAAAAAAAAAAAAAAAACgoSiCBgAAAAAAAAAAAAAAAAAAGooiaAAAAAAAAAAAAAAAAAAAoKEoggYAAAAAAAAAAAAAAAAAABqKImgAAAAAAAAAAAAAAAAAAKChKIIGAAAAAAAAAAAAAAAAAAAaiiJoAAAAAAAAAAAAAAAAAACgobTVOwHIW5ZFZMmDRkRJzIaNWYQcmzxmliX/Vf45ZtpEq1kWpVLamAPVaqSe/KyaRbSkzTPLsmhJOO1ZDvMyj5itpVK0tqb+EUX69Wggi2rirdvAQJb+t17NopR43VzfNxADiX9Eq9b3R3818fzMsii3tiaLt7bSn/pnHuvW9UZr4nWzsn5ddJTSzstKfzXK5Y6kMfuiJaZMKSeN2T+QRbkj3TKPiOjrH4j2trQx163vi7bEK1NffzU62tPm2dtfjY62dPfsqvQNJI0XEZGVStE1pT1pzL6BLNoTb4d6+6vRnniZ9w5Uo6M17fxsaS3F1I60QxTltpboSrxu5rHfFVlES+KY1awapdT7xtUsIuF2o5p4f3NQaw77xXkcE+Rx4JZ6fuYx7anXo4h81qU8YpZKadfPLIfVKI++oyjHgpFF8mOXUimL1lLa7WVTj1PkcHyZOmYRcmz2mHnsd+XRJ/UODETiYYqILKI98T58lmVJ52elP/10D1Sr0dqSdrqbOWaWZdGWej2qpt+HX9s/sGG/M6HKQDX5ONr6/oFoSbjvNVDNotyedvnkMU6xvq+a/LC6v5olH6fo7a9GW+Jpr2YRnYmXUakUycc+qlkWbYn7j3V9A5H6AGagmn79zCLtutRfzZKPxeYRs6VUinLi31AeQ2j91fTnsarVtPszEfls21pbIjoSnyuoVrPk19Gs7++PgWq6eH0D1eTzsq+afsynOPty1eT9e6lUio7U055Vkx9jVfpTn1nPZ37msX6u6+2PLEsXs69ajfbE0907UE1/7nKgmvwYOI+YHa2lmNaZ9txYlkXydTOLLPnxUN9AFpH4uoKBLH2eqWPmkWNEJP9dDlRzGIfOYdpbWvIY70p+GqswMUuRfj82Iv01c6mvO80iS39urJlj5nANb1HONeZxDi+PPPsHEu8b53G9S7WavJPrH0h/cj2PfaQsl+uHcjgOzrLkT+LMY9wnjzGa5MesWSQ/HspjXC6Xy+VyOm+bOmYpIvm5schjm5HTdWNFqM2ppt4/zGFfu7VUSn7OqVkpgmZSy7KIykC9swA2lmVZ9A+k3tnIoi/xRU0b8kwaMqrVLFas60saM8uyDScHEmtvLaW/qLzBtbaUYpfp5SglXu5traWkO8MD1SyeXNWbLmBsWDdXJl4387C+fyDmP7o86UDc2t6B+NHvH096kW1LKWL61I5kv6G+voFY+H/LkxYm9Pf1xyMPLkkaM+urRHXR7yNp0FJLxHYzkh5RtrS3x477PjtKCU8ElkqlmLZ9Z8P3m/39A/H44qeS3yGoo9ye/qg/oSzLoq+Sto9r72iN/Q/aPVoSn1BOLcuyqFT6653GNpXbW+Ko/XZOOgjZ1d4aJ+63c9qCwxz2u0oRMaXcmrT/yGN/u5plsba3sQ+uS6WI6VPaG74vzuOYoBQRXR1p16M8FGE9yktLKWLGduVkyyjLsuQ38cmj7yiStsTHwBv6pLYoJbyQr9nHKWC88tjvykPfQDX+9OTqpIdtLaWIWV3ptkOD2lvS9Z29A9W4+8kV6W9oSzItEbFDOd1416Bya0vSmOv7q3HbIysiYf1VDFSzWLo27fayf6Aajy1flyxeSylih6npf+ep9Q9UY8mydUl/66WIKHekXY+qWRaV3pRr0Z/PP+w4JWmeHa2lOPhp2yW9sKkUEVPa0+4b9w5U477H1ydf7lPa0y73llLErKltDf87Sq29pRT7z5iWy43qUhrIsliReIw3L6m3be2tpdh352nRkvD4Mo8xmvX9AzH/kaeS/darWRbr+tKPca7rS9u/F0Ue/WZbSymeOb0r+Y3VKykr6ePPx1jL1jb8diiP9bPSX407HlmV/OZ3KVWzLCp9zTlmPLWjNboP3iXpeaxSREzvSHuepBQRnYm3bf3VaixZV0kWr5m1lkoxe0raY8FqlsX6xH1xHtpaSvHMGVMbfj+2KFqGzmmkjZv6mrn8zmWJmSRSDtfwFkUe5/DysOG603Tb4DzOu1SzLNYlLvwYqGaxdF3a623z2EeKKMZ123mcC85r3Cf1GE3qY9aWiJhebvzrnPKSx/qe8txlxIZ9pJnTylEqpd0/bmtNf6OYDdOeLl5RanOyLIveglyf8rQdOhRCJ9DYV2zDOBWjOwPGqyi/9dR3monIZ9pLkX7nughaSvlMd6PfsSivmHnoz+Gu9JX+avKnDJVKaQ+kB6pZ8pPTAwPpn/YWA/1pC6AjNhRBp34KY2tb0gLoiME0G7/frA5Uk284SqVSQxdAR6S/E3BERFtba8MXQEek/0nmpaOtJfldGMttLemfCJw02galnPY/UivCutSSePublzz2u6xHja8o62czS7188jq+TK0o4xSQQlG2l3mMfeSxHUo9fthfTf9kNtJKPd4Vkc84dN9ANWkBdEQxxmPzWD55qGbp+7jIo3/PoUPKoy9uay0lv+A/j+1lf/ohyVzyLMo+fGptLenXozzkMcabhzy2ba05LKM8Zmfqp4nlkWNBVqNc5NFvtpZyWDeTRtugP4f9jzzmZz6/y/TnmJNr9PxylMd5rLzGodNf85I0XFNr1n3YiHz2kZpZXmOnzbp+Nivde+NLPyZZjP3ivK6NLcJ4eR5yuR1DHtfRRA7rZ9JoxRnXz0MeyyePmEU5xirC+p6XouQZseGGD4xf41+1DQAAAAAAAAAAAAAAAAAANBVF0AAAAAAAAAAAAAAAAAAAQENRBA0AAAAAAAAAAAAAAAAAADQURdAAAAAAAAAAAAAAAAAAAEBDUQQNAAAAAAAAAAAAAAAAAAA0FEXQAAAAAAAAAAAAAAAAAABAQ1EEDQAAAAAAAAAAAAAAAAAANBRF0AAAAAAAAAAAAAAAAAAAQENRBM2kVqp3AsCEKMpvvaWUPtM8pj2LiCzLcojc2KpZPtOdOmYe61EeMfPQ1lJKvs6X21qiJXHQLMuSLvfWllKkXkStrS3JY0ZrWyQPmlUjEv+GsoH+yKrVtDGrxeg3W1pbkm84sixLvoxSK+XQx/X3D0Q18XqUh4J079HbX41qNe16VOmvxkDimLnsd+W0/5FaEdalauLtb17y2O+yHjW+oqyfzSz18snr+DK1ooxTQApF2V7mMfaRx3Yo9fhhW0uL/qPBpR7vishnHLq9tSX5ye8ijMfmsXzy0FJK38dFHv17Dh1SHn1x/0AW1dS/yxzmZ1v6Iclc8izKPnxq/dX061Ee8hjjzUMe27aBHJZRHrOzrTXt/lweORZkNcpFHv3mQJbDupk02gZtOex/5DE/8/ldpj/HnFyj55ejPM5j5TUOnf6al6Thmlqz7sNG5LOP1MzyGjtt1vWzWeneG1/6Mcli7BfndW1sEcbL85DH3Mxj3CeP+Zn+2LIY4/p5yGP55BGzKMdYRVjf81KUPCMiWht+kKYYSlmz9pzUKJfL0dvbO6y9o6MjKpVKHTJKJ8s2dOxpg0YOezJiNmw8MfMpmEpsQ8y0iVazLPnB1UC1mrxWLKtmyc8SZFmW9OA/y2Fe5hGztVSK1tYcLgJPvR4NZFFNvHUbGMjS/9arWZQSr5vr+wZiIPGPaNX6/uhPfIJxIMui3NqaLN7aSn/yk4Hr1vUmP6iqrF8XHaX0hYzlckfSmH3RElOmlJPG7B/IotyRbplHRPT1D0R7W9qY69b3RVvilamvvxod7Wnz7O2vRkdbusuWK30DSeNFRGSlUnRNaU8as28gi/bE26He/mq0J17mvQPV6GhNOz9bWksxtaMtacxyW0t0JV4389jviiyiJXHMalaN1Jd2VatZ0jNO1cT7m4Nac9gvzuOYII8DtzwKKVJPe+r1KCKfdSmPmKVS2vUzy2E1yqPvKMqxYGSR/NilVMqitZR2e9nU4xQ5HF+mjlmEHJs9Zh77XXn0Sb0DA5F4mCIi21AcmjRkliWdn5X+9NM9UK1Ga0va6W7mmFmWRVvq9aiafh9+bf9A+httDVSTj6Ot7x+IlOViA9Usyu1pl08e4xTr+6rJD6v7q1nycYre/mq0JZ72ahbRmXgZlUqRfOyjmmXRlrj/WNc3EKkPYAaq6dfPLNKuS/3VLPlYbB4xW0qlKCf+DeUxhNZfTX8eq1pNuz8Tkc+2rbUloiPxuYJqNUt+Hc36/v4YSHjv0L6BavJ52VdNP+ZTnH25avL+vVQqRUfqac+qyY+xKv2pz6znMz/zWD/X9fZHlqWL2VetRnvi6e4dqKY/dzlQTX4MnEfMjtZSTOtMe24syyL5uplFlvx4qG8gi0h8XcFAlj7P1DHzyDEikv8uB6o5jEPnMO0tLXmMd+Vw7/+CxCxF+v3YiPTXzKUvGsrSnxtr5pg5XMNblHONeZzDyyPP/oHE+8Z5XO9SrSbv5PoH0p9cz2MfKcvl+qEcjoOzLPnNSPMY98ljjCb5MWsWyY+H8hiXy+VyuZzO26aOWYpIfm4s8thm5HTdWBFqc/K4WWzyB5eVSsnPOU0GY6ljVQRNREzuImgAAAAAAAAAAAAAAAAAAOpnLHWsqW/CAQAAAAAAAAAAAAAAAAAAMC5t9U5gMrnwwgvj3HPPjYiIU045JS677LJRx6hWq/GWt7wlBgYGxpXLHnvsEZ/5zGfGFQMAAAAAAAAAAAAAAAAAAOpBEXQi9913X1x44YVJ4nz3u98dd5znPOc5444BAAAAAAAAAAAAAAAAAAD10FLvBCaDVatWxUknnRRr1qwZd6zbb789QUYAAAAAAAAAAAAAAAAAAFBciqDHaf369dHd3R133nlnkngLFixIEgcAAAAAAAAAAAAAAAAAAIpKEfQ4rF69Ol772tfGT37yk2QxNy2C/vjHPx5Zlo36v9///vfJcgIAAAAAAAAAAAAAAAAAgInUVu8Eiuquu+6KN77xjXHvvfcmjbtpEfShhx6aND4ApPTQQw/Fk08+We80tmnmzJmxxx571DuNSSGPZW75QHNo5v6jKNNelDwhhWZd34sy3Y4zGp9lRApFWY9obEXZDumP0tJ/pGX9bD76ORifomyHmnk/KXWe+rjm1My/dZpPs/bvEX5Dzch6lFZR5mdRtuupWTebb5nnJfW6VJTlU5T+qJl/69BM9B8wPn5Dk0TGqH3jG9/Iurq6sojY4n+nnHLKqOM+/PDDw+IsXrw4/QRsRkdHx2ano6OjY0L+PsCmFi9enJ1//vlJ+0Ex08ZctGjRNreHjfJfV1dXtmjRomTTnsf8TK1Iy7wIy0dMMRsxXpFiNnP/UZRpL0KeRVnfxWz8mEVY37Ms/bQXZbodZzTvb6gZl1FRlnmzr0f+a+z/irIdavT+qEgx9R+N/TsqynrUzDH1c40dswg5NnvMIm2HmnU/KY889XHNF7OZf+u2bc0Xs5n7d7+h5ovZrOtRXjGLMj+LtF1v9HlZhOvlsqy5l3kR1qUiLZ+i9EdF+K2L2dgxi5Bjs8fUfzR2zCLk2Owxi/IbajZjqWMtZVmWBSNy3333xQc/+MH43ve+t83PnnLKKXHZZZeNKv4PfvCDOPHEE4dez549Ox577LHRpjkm5XI5ent7h7V3dHREpVKZkBwANvbb3/42Dj/88Jg/f34cdthhYjZwzLlz58aee+6ZJGYeFi5cGGeffXbDz8/UirLMi7J8xBQzRcwi5Jh3zGbuP4oy7Y2cZ9HWdzEbP2Yjr+8R+W2HijLdjjMaP6ZlZNuWImajr0c0tqJsh4rQHxUxpv4jDcdtzRtTP9eYMYuQo5jF2A7ZT0qXpz6uuWM282/dtq35YjZb/x7hN9TMMZttPco7ZlHmZ6Nv11MryrqZh2Zd5nnJa/yw0ZdPUfqjovzWxWzsmEXIUUz9RyPHLEKOYhbjN9RsxlLH2pZ3UpPB448/Hh/96Efjq1/9avT39w97//3vf3/cfvvt8Ytf/GJcf2fBggU1rw899NBxxQOAibDnnnvGAQccUO80mECWOTBWzdx/FGXai5InpNCs63tRprsoeTYzy4gUrEc0Kutm47OMYHz8hmB8mvk3VJRpL0qeNDbrEc2kKOt7UfKksVmP0irK/CxKnqRjmTe2Zl4+zTztwPjoP2B8/IaKr6XeCRTBhRdeGP/2b/82rAB62rRpcckll8QXvvCFaG1tHfffuf3222teK4IGAAAAAAAAAAAAAAAAAKAZeRL0GL3mNa+Jiy++OJ7+9Kcni+lJ0AAAAAAAAAAAAAAAAAAA4EnQo3bggQfGNddcEz/84Q+TFkCvXLkyHnjggZo2RdAAAAAAAAAAAAAAAAAAADQjT4Ieoec973lx2mmnxVve8pZoaUlfO75gwYLIsmzo9bRp02KvvfaKarUa1113XXz/+9+PW2+9NR5++OFYs2ZNzJw5M572tKfFscceG6973eviqKOOSp4TAAAAAAAAAAAAAAAAAADUgyLoETjvvPNip512yvVvLFiwoOb1wQcfHJdffnl85CMfiUWLFg37/OLFi2Px4sXxm9/8Jj75yU/GscceG5/61KfisMMOyzVPAAAAAAAAAAAAAAAAAADIW/pHGk9CeRdAR0TcfvvtNa9vvfXWeMc73rHZAujNufHGG+PII4+MSy65JI/0AAAAAAAAAAAAAAAAAABgwngSdIPY9EnQAwMDNa933333eOYznxk77LBDPPHEE3HHHXfEunXraj7T19cX7373u+Opp56KM844Y0R/t1KpRKVSGVfuADS3hQsX1juFrWr0/Ioo5Ty1fKC5NHP/UZRpL0qekEKzru9Fme5Gn6eNnt9EaPR50Oj5sYHlxHgUZTtkPc+H+ZqG+di89HMwPo2+3ttPShe70Zc1+Wr05d/o+VEszda/p45FsViP0irK/Gy2ZdVs07s55kEaec3HRl8+RemPGn0+AmnpP2B8/IaKTxF0A+jr64u77757s++9/e1vj1NPPTWe//zn17SvX78+rrnmmjjvvPPi3nvvrXnvgx/8YBx44IHx6le/ept/e+7cufHRj3507MkD5GTXXXeN888/P3bddVcxGzTmzJkzo6urK84+++xkMfPS1dUVM2fOTBYvj/mZWpGWeRGWj5hiNmK8IsVs5v6jKNNehDyLsr6L2fgxi7C+R6Sf9qJMt+OM5v0N5aHRl1FRlnmzr0c0tqJshxq9PypSTP1Heo7bmiumfq6xYxYhx2aPWaTtULPuJ+WRpz6u+WI282/dtq35YjZz/x7hN9RsMZt1PcorZlHmZ5G266kVYd3MQzMv87ykXJeKtHyK0h8V4bcuZmPHLEKOzR5T/9HYMYuQY7PHLMpviG0rZVmW1TuJyeClL31p3HzzzUOvTznllLjssstG9N0FCxbEoYceWtM2bdq0+MY3vhHd3d1b/e769evjlFNOie9+97s17bvuumssXLgwOjs7t/r9wSdBz5o1K3p7e4e939HR4UnRAGzRQw89FE8++WS909immTNnxh577FHvNCaFPJa55QPNoZn7j6JMe1HyhBSadX0vynQ7zmh8lhEpFGU9orEVZTukP0pL/5GW9bP56OdgfIqyHWrm/aTUeerjmlMz/9ZpPs3av0f4DTUj61FaRZmfRdmup2bdbL5lnpfU61JRlk9R+qNm/q1DM9F/wPj4DTWecrk86jpWRdCJjKcI+he/+EWceeaZsXDhwnj88cejpaUlvve978UJJ5wwou8PDAzEy172svjZz35W0/6Zz3wm/umf/mlEMcay8gAAAAAAAAAAAAAAAAAAwLaMpY61Je+k2LZjjjkmbr311liyZEmsXr06/vjHP464ADoiorW1NS655JJobW2taf/617+eOlUAAAAAAAAAAAAAAAAAAMidIugGM3Xq1HjWs5416u/ttddeceKJJ9a03XXXXbF48eJUqQEAAAAAAAAAAAAAAAAAwIRQBD2JvPKVrxzW9utf/7oOmQAAAAAAAAAAAAAAAAAAwNgpgp5Envvc5w5rW7JkSR0yAQAAAAAAAAAAAAAAAACAsVMEPYnMmDFjWNvSpUvrkAkAAAAAAAAAAAAAAAAAAIydIuhJZGBgYFjb1KlT65AJAAAAAAAAAAAAAAAAAACMnSLoBtTf3z+m723uqc8zZ84cbzoAAAAAAAAAAAAAAAAAADChFEHX2eOPPx6vfOUr45BDDonddtstOjo64pxzzhlTrDvuuGNY23777TfeFAEAAAAAAAAAAAAAAAAAYEK11TuBZjdjxoz42c9+FpVKZajtlltuGVOsn/70pzWvt9tuuzj00EPHlR8AAAAAAAAAAAAAAAAAAEw0T4Kus9bW1jj44INr2m655ZZ46KGHRhVn0aJFcc0119S0HX/88dHa2jruHAEAAAAAAAAAAAAAAAAAYCIpgm4Af/M3f1PzOsuyuPDCC0cV45//+Z+jv7+/pu3UU08dd24AAAAAAAAAAAAAAAAAADDRFEE3gLe97W3R1dVV0/a1r30tfvjDH47o+3Pnzo2rrrqqpu1lL3tZHHPMMclyBAAAAAAAAAAAAAAAAACAiaIIugHMnj07zj333Jq2gYGBeNOb3hTf/OY3t/i9NWvWxKmnnhrnnHNOTfvUqVPja1/7Wi65AgAAAAAAAAAAAAAAAABA3trqnQAbnHHGGfE///M/cfPNNw+1rV27Nk455ZT48pe/HG9/+9vj0EMPja6urnjsscfipptuissvvzweffTRmjilUim+9rWvxbOe9ayJngQAAAAAAAAAAAAAAAAAAEhCEXSD6OjoiO9973vxile8Im677baa937961/Hr3/9623GaGlpiYsuuije/OY355UmAAAAAAAAAAAAAAAAAADkrqXeCfAX06dPj5///Ofxj//4j6P+7tOf/vT48Y9/HO95z3tyyAwAAAAAAAAAAAAAAAAAACaOIugG09nZGV/60pfijjvuiJNPPjmmTZu21c/vv//+8dnPfjbuv//+eNnLXjZBWQIAAAAAAAAAAAAAAAAAQH5KWZZl9U6CLevv74/f/va3ce+998bSpUtjzZo1MXXq1HjGM54Rhx9+eDzjGc9I8nfK5XL09vYOa+/o6IhKpZLkbwAAAAAAADSDLMuGnV8pl8tRKpXqlBEAAAAAAAAAQH2NpY5VETQRoQgaAAAAAAAglfXr10dPT09NW3d3d3R2dtYpIwAAAAAAAACA+hpLHWtL3kkBAAAAAAAAAAAAAAAAAACMRlu9EwAAAAAAKIIsy4bdbbJcLkepVKpTRgAAAAAAAAAAADB5KYIGAAAAABiBSqUSPT09NW3d3d3R2dlZp4wAAAAAAAAAAABg8lIEDQAAAAAAAA0uy7KoVCo1beVyOUqlUp0yAgAAAAAAAADIlyJoAAAAAAAAaHCVSiV6enpq2rq7u6Ozs7NOGQEAAAAAAAAA5EsRNAAAAAAAAAAAAAAAQJPLsiwqlUpNW7lcjlKpVKeMAABodoqgAQAAAAAAAAAAAAAAmlylUomenp6atu7u7ujs7KxTRgAANDtF0AAAAAAAAAAAAAAAAAAAk0CWZVGpVGrayuVylEqlOmUEYzehRdBPPfVU/OY3v4k777wzFi1aFA8++GA88cQTsXbt2lizZk20tLTEdtttF9OmTYuddtop9tprr9hnn31iv/32iyOOOCKmTp06kekCAAAAAAAAAAAAAAAAABRGpVKJnp6emrbu7u7o7OysU0YwdrkWQff29saNN94YP/jBD+L666+PhQsXDvtMlmXD2jZ3R4HW1tY47LDD4iUveUm8/vWvjxe+8IW55AwAAAAAAAAAAAAAAAAAANRXLkXQd955Z/z7v/97XH755bFixYqI2Hyxc8TmC5439/n+/v74zW9+E7/5zW/iU5/6VOyxxx7xlre8Jd75znfGPvvsk3YCAAAAAAAAAAAAAAAAACaRLMuiUqnUtJXL5S3WdwFAvSUtgv7hD38YF154Yfzv//5vRNQWMm9uY5hl2RaLo7f2nYiIRYsWxb/8y7/EJz/5yTj++OPjtNNOi5e//OXjnQQAAAAAAAAYsWWf+9ywtkqWRe/atTVtyy+6KMpbuHhkx9NOyyEzAAAmMxcsAwAAAGNRqVSip6enpq27uzs6OzvrlBEAbF2SIujvfe97ccEFF8SCBQsiYsMge6lUGhpU37TYua2tLZ72tKfFzjvvHLNmzYqurq4ol8uRZVmsXbs21q5dG0uXLo3/+7//iyeeeGJYofSmca+99tq49tpr4/DDD4+Pfexj8apXvSrFZAEAAAAAAAAAADQcFywDAAAAANAMxlUEfdddd8X73//+uPnmmyOitvh5sHB5ypQp8aIXvSiOOOKIOPzww+M5z3lOPOtZz4rW1tYR/Y3e3t64//774/bbb48FCxbELbfcErfddlsMDAxERG1B9G233Ravec1r4qijjorPfvaz8bznPW88kwcAAAAAAAAAAAAAADCpLPvc5zbbXsmy6F27tqZt+UUXRfnPdRsb2/G003LIrD6yLItKpVLTVi6Xh+pVAAConzEVQa9ZsybOOeecuOiii2JgYGCo+Dliw87f3nvvHW94wxviuOOOi2OOOSY6OjrGnGBHR0cceOCBceCBB8bJJ58cERErV66Mn/70p3HNNddET09PLF++PCJiqPj6l7/8ZRx55JHxnve8Jy688MLYYYcdxvz3AQAAAAAAAAAAAAAAmJwqlUr09PTUtHV3d0dnZ2edMgIAYNCoi6B/9rOfxTvf+c548MEHa4qfp06dGieddFK8853vjGOOOSZ5ohvbfvvt4/Wvf328/vWvj4svvjiuv/76uOSSS+IHP/hBDAwMRKlUimq1Gl/5yleip6cnLrvssnjVq16Va04AQGNxVz4AAGA8Nnfn82a96zkAAAAwPs5dAgAAAADA2IyqCPr000+Pz3/+85Fl2VDbzjvvHKeffnq8973vjWnTpiVPcFva29vjxBNPjBNPPDEefvjhuOiii+KrX/1qLF26NCIilixZEq95zWvi/e9/f3xuMxcuAgCTk7vyAQCAC2wBAAAAGoFzlwAAAAAAMDYto/nwZz/72ciyLLIsix122CE++clPxsKFC+OMM86oSwH0pnbffff4xCc+EQ8++GBceOGFMWPGjIjYcLHnF7/4xTpnBwAAAAATa/AC243/27QoGgAAAAAAAAAAAKARjaoIOmLDk2LOOuusoeLnKVOm5JHXuEydOjU+9KEPxYMPPhjnn39+dHV11TslAAAAAAAAAAAAAAAAAABghEZVBP3Wt7417r333pg3b15Mnz49r5yS6erqivPPPz/uvffeeNvb3lbvdAAAAAAAAAAAAAAAAAAAgBFoG82HL7/88rzyyNXuu+8e3/zmN+udBgAAAAAAAAAAAAAAQEPqiIhXdXUNawMAgHoZVRE0AAAAAAAAAAAAAAAAI5dlWVQqlZq2crkcpVKpThltXqlUinK9kwCAJlOU/QSoF0XQAAAAAAAAAAAAAAAAOalUKtHT01PT1t3dHZ2dnXXKCABoFPYTYOsUQQMAAAAAAEBCHRHxqq6uYW0AAAAAAAAAAIxcwxVBn3XWWfHJT36y3mkAAAAAAADAmJRKpSiP4/vLPve5YW2VLIvetWtr2pZfdFGUS6XNxtjxtNPGkQEAAAAAAAAAQP211DuBTX3qU5+Kk08+Ofr7++udCgAAAAAAAAAAAAAAAAAAUAcNVwQdEfHtb387Xvva18aaNWvqnQoAAAAAAAAAAAAAAAAAADDBGq4Iur29PSIibrjhhnjJS14Sjz/++JhjXXXVVanSAgAAAACaXEdEvKqrq+a/jnonBQAAAAAAAAAAAJNUW70T2NQ111wTJ510UqxevTp++9vfxtFHHx3XX3997LXXXiOOccMNN8Q555wT8+fPj4GBgRyzBQAAAACaRalUinK9k2CrsiyLSqVS01Yul6NUKtUpIwAAAAAAAJrJss99brPtlSyL3rVra9qWX3RRlDdzHmvH007LITOYOM7bAgApNVwR9Ctf+cq46aab4oQTTojHHnss/vSnP8VRRx0VP/zhD+N5z3veVr/7q1/9Ks4555y46aabIssyO0gAAAAAAE2kUqlET09PTVt3d3d0dnbWKSMAAAAAAACA5uK8bePY3I0ZRnNThgg3ZgCg/lrqncDmHHrooXHLLbfEvvvuGxERTzzxRBx77LFx/fXXb/bzd911V3R3d8dRRx0VN9100wRmCgAAAAAAAAAAAAAAAAAApNZwT4Ie9IxnPCNuueWW+Ku/+qv45S9/GWvWrInXve518dWvfjVOOeWUiIh48MEH47zzzovvfOc7Ua1WI8uyoe8feeSRccEFF9QrfQAAAAAAAAAAgHHz1CYAAAAAAJpVwxZBR0TsuOOOccMNN8Tb3va2uOqqq6Kvry/e9a53xcKFC2Pp0qXxta99Lfr6+mqKnw877LC44IIL4jWveU0dMwcAAAAAAKAIsiyLSqVS01Yul6O0heIRAAAAoJiMAQAAAAAUT0MXQUdsGGD6r//6rzjttNPii1/8YmRZFh//+McjImqKn5/73OfGnDlz4vWvf32dMgUAAAAAAKBoKpVK9PT01LR1d3dHZ2dnnTICAKCeFMgBTF7GAACop46IeFVX17A2AABg6xq+CDoiolqtxgEHHBBTpkyJ9evXDxU/l0ql2H///eP888+Pk046qc5ZAgAAAAAAAAAARaZADgAAyEOpVIpyvZMAAIACaugi6Gq1Gpdddll8/OMfj0WLFtW8N3h31eOOO04BNAAAAAAAAAAAAAAAMG5ZlkWlUqlpK5fLQzUMAADAxGnIIugsy+Jb3/pWfOxjH4uFCxcOPfk5ImL69Olx7LHHxtVXXx2lUim+8IUvxGOPPRbf/OY3o729vY5ZAwAAAAAAAAAAAAAARVapVKKnp6emrbu7Ozo7O+uUEQDAli373OeGtVWyLHrXrq1pW37RRVHewk1ddjzttBwygzQargj629/+dlxwwQXxhz/8oaZ9ypQp8b73vS8+9KEPxY477hhf+tKX4rTTTossy+K73/1uLFmyJHp6emL69Ol1yhwAAAAAaBTuzg4AAADUgwsOAQAAGpvjNgCAYmm4Iui3v/3tQxciZlkWbW1t8a53vSvOP//82HXXXYc+9773vS923XXXOPnkk6NSqcTNN98cL3rRi+L666+P3XbbrV7pAwAAAAANwN3ZAQAAAAAAAAAAoNha6p3A5mRZFhER/z97dx4mV1kmCvw9vVV3ZyMhi0mQHSLIEvYddQYHEVxaBPE6gBuDu8FtZuRecRtx9IJxm6jo6Ki4jGCrOCAzgLjPcI0EDEQWWUMia/ZOqrdz/+hU01Vd3emlqquq+/d7nn6S+qrqq7fOqXrrO8t7vvPOOy/WrFkTX/rSl/IKoHPOPvvsuPHGG2O33XaLiIjVq1fH8ccfH3fddddEhgsAAAAAAAAAAAAAAAAAAJRQVRZBv/SlL40//OEP8Z3vfCf222+/YR97yimnxK9+9atYvHhxJEkSa9eujZNPPjl+8YtfTFC0AAAAAAAAAAAAAAAAAABAKVVdEfQvf/nL+OlPfxqHH374iJ9z8MEHx+9+97s4+OCDIyJi06ZN8ZKXvCS+//3vlytMAAAAAAAAAAAAAAAAAACgTBoqHUChk08+eUzPW7x4cfzmN7+Jl7/85fHLX/4ystlsvO51r4vXvOY1JY4QAAAAAAAAAAAAAACoZRuWLy/ank3T6OzoyGvbuGJFZJJk0GNnL1tWhsgAgMmq2PhjNGOPCOMPpp6qK4Iej5kzZ8Z//ud/xt/+7d/GNddcE2maVjokAKDM7IQEAAAAAAAAAAAAAACAyWdSFUFHRDQ1NcX3v//9uOSSS+Lzn/98pcMBAAAAAACgSriqNgAAAFDN0jSNbDab15bJZCIZYj8FAECljffYi+MuAMCuTLoi6IiIJEli+fLlsXjx4kqHAgAAAAAAAOPWFBGnt7YOagMAAAAmj2w2G+3t7XltbW1t0dzcXKGIAAAAACprUhZB57z//e+vdAgAAAAAAAAwbkmSRKbSQQAAAAAAAAAATKCqLoJeu3ZtfOlLX4pbbrklHn744di6dWvMmjUrFi9eHEuWLIlvfOMblQ4RAAAAAAAAAAAAAACYJJoi4vTW1kFtAJOBHAdAranaIujly5fHP/zDP0RXV1d/W5qmsWXLlli7dm3cdtttiqABAAAAAAAAAACAikvTNLLZbF5bJpOJJEkqFBEATA3l+A1OkiQy4w0MoErJcQDUmqosgv7Upz4V//iP/xhpmo76uVdccUXsvffesXTp0thvv/3KEB0AAAAAAJW0Yfnyou3ZNI3Ojo68to0rVkSmyEkus5ctK0NkAAAAAExV2Ww22tvb89ra2tqiubm5QhEBwNTgNxgAACa3ukoHUOi+++6LSy+9tP/2YYcdFldffXX8+c9/jsceeyxOPvnkYZ+/efPmOPfcc+PAAw+M//iP/yh3uAAAAAAAAAAAABOqKSJOb23N+2uqdFAAAAAAAFBiVTcT9Oc///no6emJJEniRS96UVx//fWRyWT67582bdqwz7/44ovj4x//eEREfPe7340zzzyzrPECAAAAAAAAAABMpCRJIrPrhwFMSRuWLy/ank3T6OzoyGvbuGJFZJJk0GNnL1tWhsgAAAAAGK2qmwn6lltuiYi+HfVf/vKX8wqgR2LRokVx3HHHRZqmcdNNN5UjRAAAAAAAAAAAAAAAAAAAoIyqrgj60UcfjSRJYsmSJbH//vuPqY+TTjopIiKefPLJuP/++0sZHgAAAAAAAAAAAAAAAAAAUGZVVwTd1dUVEX0zOo/VYYcd1v//P/3pT+OOCQAAAAAAAAAAAAAAAAAAmDgNlQ6g0IIFC+KRRx6JTZs2jbmP+fPn9///0UcfLUVYAAAAAAAATEJNEXF6a+ugNgAAAAAAAAAAKqvqZoJ+3vOeF2maxurVqyObzY6pjxkzZvT/f/PmzaUKDQAAAAAAgEkmSZLIFPwlSVLpsAAAAAAAAAAApryqmwn69NNPjxtvvDGy2WxcffXV8cY3vnHUfWzbtq0MkQEAAAAA1WjD8uWD2rJpGp0dHXltG1esiMwQRW2zly0rQ2QAAAAAEU0RcXpr66C2apOm6aBJKzKZjIsEAdQ4+R0AAACoZVVXBH3eeefFBz/4wchms/HBD34wXvayl8W8efNG1cef/vSn/v/PmjWr1CECAAAAAAAAAACMSJIkkal0ECOQzWajvb09r62trS2am5srFBEApSC/AwAAALWsrtIBFHrOc54TF198caRpGk8++WS85CUviSeeeGJUfVx77bX9/z/ggANKHSIAAAAAQNVK0zR27NiR95emaaXDAgAAAAAAAAAAgFGpupmgIyIuv/zy+PnPfx533nlnrFq1Ko488shYvnx5vPrVr97lc//93/89fvnLX0ZERGNjYxx33HHlDhcAAAAAoGqY1QMAAAAAAIDJaMPy5YPasmkanR0deW0bV6yITJIMeuzsZcvKFBm1rikiTm9tHdTG2FieAEApVd1M0BERzc3Ncd1118UBBxwQaZrGunXr4jWveU0cfPDBsWbNmqLP2bZtW3zqU5+KCy64ICIikiSJs88+O6ZPnz5hcX/iE5+IJEkiSZJ4/etfX5I+b7755njrW98aS5cujblz50ZjY2PMmDEjDj744Dj//PPj2muvje7u7pK8FgAAAAAAAAAAAAAAwFSSJElkCv6SIoX0jIzlCQCUUlXOBB0R8dznPjd+97vfxd/+7d/Gz372s0jTNO655568xxxwwAExf/782Lp1a9xzzz3R1dUVaZpGRMS0adPiox/96ITFe88998QnPvGJkvW3cuXKePOb3xyrVq0adN/WrVtjzZo1sWbNmvj2t78d++yzT3zhC1+Il770pSV7fQAAAAAAAAAAAAAAAACgfJoi4vTW1kFtQJ+qnAk6Z86cOXH99dfH1772tVi0aFGkaRppmvZfAeaBBx6I//7v/47Vq1dHZ2dn//NaWlriO9/5Tuy3334TEueWLVvinHPOiW3btpWkv6uvvjqOP/74ogXQxTz44INx5plnxkc+8pGSvD4AAAAAAAAAAAAAAAAAUF5JkkSm4C9XPwlUeRF0zhve8IZ48MEH49/+7d/iJS95SbS0tPQXROf+IiLq6urirLPOiv/5n/+Js846a0Ji27FjR7S1tcUf//jHkvT3wx/+MC644ILo7u7Oa29qaopjjz02zjrrrDj66KOjqWnw9Rw+/OEPx//9v/+3JHEAAAAAAAAAAAAAAAAAALUlN7v0wD+zS1OrGiodwEg1NjbG+eefH+eff350d3fHmjVr4sEHH4xNmzZFQ0NDzJs3L4455piYNWvWhMW0devWeMUrXhG33HJLSfp78MEH4w1veEP09vb2t9XX18c//MM/xHve856YM2dOf/uTTz4ZV1xxRXz605/Oe/w//uM/xgtf+MI4+uijSxITAAAAAAAAAAAAAAAAAFAbkiSJTKWDgBKpmSLogRoaGuLQQw+NQw89tGIx3HXXXfHqV786/vSnP5Wsz/e9732xefPm/tt1dXXxgx/8INra2gY9dt68efHJT34yTjzxxDj77LP7Z47u7u6Ov//7v4+bb765ZHEBAAAAAAAAAAAAAAAAAMBEqqt0AGPV09MTH/7whyvy2t/85jfj2GOPLWkB9O233x4//OEP89ouvfTSogXQA7385S+PK6+8Mq/tlltuKdns1AAAAAAAAAAAAAAAAAAAMNHKVgT97//+7+XqOu6444446qij4mMf+1jZXqOYe+65J175ylfGhRdeGB0dHSXte8WKFXm3Z8+eHf/wD/8woue+4x3viMMPPzyv7V/+5V9KFhsAAAAAQC1oiojTW1vz/poqHRQAAAAAAAAAAABjUrYi6PPPPz9+/OMfl7TPnp6e+MhHPhLHHnts3HnnnSXtezhPPPFEvP3tb49DDjmk6Ht65zvfGSeffPKY++/p6Ykf/OAHeW2ve93rorW1dUTPT5Ik3vKWt+S13XDDDSUv1AYAAAAAqGZJkkSm4C9JkkqHBQAAAAAAAAAAwBiUrQi6q6srXvOa18QNN9xQkv7uvPPOOOaYY+KjH/1odHV1laTPkfrEJz4R//Iv/xLd3d157TNmzIh//dd/jc997nNRX18/5v5vu+222LhxY17by172slH1Ufj4jo6Oki17AKhFZv8CAAAAAAAAACDHuSQAk5P8DgAAk1vZiqAjIjo7O+Pss8+Om266acx99PT0xEc/+tE49thj44477og0Tati5o6XvvSlcdddd8Ub3vCGcff161//Ou92XV1dnHDCCaPqY/HixbHnnnvmtd16663jDQ0AapbZvwAAAAAAAAAAyHEuCcDkJL8DAMDkVtYi6CRJYseOHfHKV74yfvnLX476+bnZnz/ykY9EZ2fnoALo/fbbr5ThjsghhxwS1113XfzHf/xHPPe5zy1Jn3fddVfe7X333TdmzJgx6n4OPfTQvNsrV64cV1wAAAAAAAAAAAAAAAAAAFAJZSuCrq+vj4i+QuiOjo4466yz4ne/+92IntvT0xMf+9jHBs3+nCRJpGkadXV18b73vS/uvPPOcoU/yNFHHx3f/va344477oizzjqrpH2vWbMm7/aBBx44pn7233//vNv333//mGMCAAAAAAAAAAAAAAAAAIBKaShXx9/85jfjggsuiN7e3kiSJLZu3RpnnHFG3HTTTXH00UcP+bw//vGP8frXvz5WrVoVaZpGRPTP/pymaRx++OHxta99LY488shyhT7Ihz70oZgzZ07Z+l+3bl3e7cWLF4+pn4ULF+bdfvLJJ6OjoyNaW1vHHBsAAAAAAAAAAAAAAAAAAEy0ss0E/drXvja+853v5M0IvXnz5jj99NPjjjvuGPT43OzPxxxzTH8B9MDZn5uamuKf/umf4ve///2EFkBHRFkLoCMinnjiibzbCxYsGFM/8+bNG9T29NNPj6kvAAAAAAAAAAAAAAAAAAColLLNBB0Rcc4550R9fX289rWvje7u7kiSJDZs2BCnnXZa3HrrrfH85z8/InY9+/Mpp5wSV111VRx44IHlDLcitmzZEp2dnXltM2fOHFNfM2bMGNS2YcOGeO5znzum/gAAAACgVjVFxOmtrYPaAAAAAAAAAAAAgNpQ1iLoiIhXvepV8YMf/CDOPffc6OrqiiRJ4umnn47TTjst/uu//it+9KMfxcc//vHo6urqn/05oq/4eebMmfHP//zPcfHFF5c7zIrJZrOD2loLTs4cqWLP27Fjxy5fv1gMA23ZsiUaGhqipaUlent7Y9u2bYMekyvA7ujoiJ6enrz7mpubo7GxMTo7Owe9Vn19fbS2tkaaprF169ZB/U6bNi3q6upi+/bt0d3dnXdfJpOJpqam6OrqGvQ+6+rqYtq0af3xF2ptbY36+vrYsWNHdHV15d3X1NQUmUwmuru7Y/v27Xn3JUkS06dPj4iIrVu39hft57S0tERDQ0Nks9lBxe2NjY3R3NwcPT090dHRMSim3DLctm1b9Pb25t033DLc1bqZPn16JElSdN0Mtwxz6yai+DIcbt0MtwwHrptiyzC3bka7DAeum2LLMLduSr0Mc+tmuGU4ns/3eJbhcJ/v8SzDYutGjugjRzxrInPEtp3LoyFJIpMk0ZOmsaPgeRER0+rqIiKio7c3Cu+d0d0tR4QckSNHPGsy5Igc44g+csSz5Ig+ckQfOaKPHPGsyZQjcsslTdP+/2/durX/9SdLjtjW2xuNSRJNSRLdaRrZgmWURETrMNsEzTv3SZZyW6Nhy5aK5Yi6urq8dR7x7HqfLDliW29v1CdJNCdJ9KZpbB9m3Wzv7Y3egvsyO9f5VM8RxhF9jCOeNVlyRMTQyzCX33eVIxqSJLrSNDoL3ktdRMyOyFuG2wbE1ZIkUZcksaO3N/LXTAz7W9W0bVtejthW+J1LkqhPksimaXQXPDf3W1XYb8OWLXLEAHJEHzmij22NPnLEs+SIPnJEHzmiz1TOEdlsNm8d1NfXR0SMOEfkxnIj2R8x1BivZceOvGVYOD4c7thnbjzbmabRVTA+3NUybGjoO5Wsp6enf53n9inIEc8uIzliaueIQgPXzbZt2/LWT93O76pxxMTniG29vSPali6233dg/q5UjihcDtu3b4/m5uYxL8OIiN7e3rz3snXr1ujp6ZEjdrKt0Weq5IgI44icWhxHRMSYzhHsHycXLMNtvb1RHxHNdXVDHnNqTZJIkqTo/uSmncecBi7D3Pi9LiJacr8pvYXPHLA/OU2jp/Azms2WPUcUi2m02xoNOz8btZYjOnp7n/29L7IcRjSOkCP6P4djXYa54xoNA3KMccSzSjWOGMsxp8I8W3jMyTjCOCKiNscR1ZIjct/LpiSJxiGOH+9qHDGrtzdv3Qx8zFjPoWrYssW2xk5yRJ9y5YixKHsRdETEy1/+8rj22mvj1a9+dXR2dkaSJPH444/H0qVLI03TorM/v+xlL4sVK1bEokWLJiLEiilWgJw7oDBauYMuAxV+WQpdfvnl8ZGPfGTI+9M0jZUrV8aCBQvioIMOimw2GytXrhz0uBe+8IUREfGnP/0pNm/enHffQQcdFAsWLIgnn3wy7rvvvrz7Zs+eHYcffnj09PQU7ffEE0+MpqamuP/+++Ppp5/Ou2+//faL5z73ubFhw4a4++678+6bPn16HH300RER8Yc//GFQQjnmmGNi2rRp8fDDD8f69evz7ttzzz1j3333ja1bt8aqVavy7stkMnHCCSdERN8M5oXrb+nSpbHbbrvFY489Fo888kjefQsXLowlS5bEjh07Br3XJEniBS94QURErFmzZlBiOPjgg2P+/Pnx+OOPx5///Oe8+3bfffc49NBDo7u7u+gyPPnkk6OhoSHuu+++2LBhQ959BxxwQCxevDieeeaZWLNmTd59M2fOjCOPPDIiomi/xx13XLS0tMRDDz0Ujz/+eN59e++9d+y9996xefPmuPPOO/Pua2lpieOOOy4iIu64445Bn9EjjjgiZs2aFY8++misXbs2775FixbFgQceGB0dHYNiqq+vj1NOOSUiIu66665BPwaHHHJIzJ07N9avXx8PPvhg3n3z5s2L5z//+dHV1VX0vZ566qmRJEnce++9sXHjxrz7FRa/BgABAABJREFUlixZEgsXLoynnnoq7rnnnrz7dtttt/48V6zfE044ITKZTDzwwAPx5JNP5t23zz77xF577RUbN26M1atX593X2toaxx57bERE3H777YN+gI466qiYMWNGPPLII7Fu3bq8+/bYY4/Yf//9Y+vWrXH77bfn3dfY2BgnnXRSRESsXr160A/1YYcdFnPmzIn169fHQw89lHefHNFHjnjWROaI7TsHcAvq62OfxsbYkabxx4JBXX1EHNPcHBER93V1DdpR2bxxoxwRckSOHPGsyZAjcowj+sgRz5Ij+sgRfeSIPnLEsyZTjth9990jou/E1dznbNWqVdHQ0DCpcsT2zs7Yo6Eh9mhoiK29vfGnghzQnCSxdOeJXmu6uvJOAI6IeH5T3xzRpdzWaFm5smI54nnPe15ERN7zcut9suSI7Z2dMbe+PvZvbIzOIusmIuL4nevmz93dsbXgwMD+jY0xL2LK5wjjiD7GEc+aLDkiYuhxRC6/7ypHzK2vj6d7euKhggN1s+rqYlFEXo7YPiAHHZXJRF1EPNzdHRsK+t2roSEWNjTEpt7euK/gczZvzZq8HNFRkNcOa2qK1iSJx7q744mC5buooSH2bGiIjjSNuwc8r2XlSjliADmijxzRx7ZGHzniWXJEHzmijxzRZyrniO7u7rzvx+zZsyMiRpwjcuPDkeyPmJEk8Zfu7lhf8Nnf75FH8nLEwDHnro59LmlsjNn19fFkT088OmA827Jy5S5zRO77OPAierl9CnJEHzmiz1TOEYUGjiMee+yxvPyRK2gwjpj4HLG9szMObWqKaUkS67q74/GC/LGwvj72amyMjjSNuwpP6k6SOGpn/q5EjnjqqacGLd8///nPcfTRR485R8ybNy+6urryig9WrVoVu+22mxyxk22NPlMlR0QYR+TU4jhifkRkixwbqouIY3P7fbu6YltBvAc0Nsbu9fWDcsT2zs6YXVcXS5qaoiei6DGnozOZaIiIh7q7Y1PBft+9GxpifkRejsiN36fX1cUhO49DFut3aVNTNCdJrO3ujqcKPqMHrV9f9hwx2vMsi21rtOz8zNVajoiurjh85+/93Z2dgy5qOpJxhBzxbI64q7Nz0AUCRnNco2VAXMYRzyrVOGJzwXd9uP0RQ50f0bJypXHEAMYRfWpxHFEtOSI3Vti7oSGe09AQG3t74/6C3/NdjSN2z2bzcsTA/YdjPYeqZeVK2xo7yRF9ypUjCnPCSCTpWJ41Rj/72c/iVa96VX+SKVb8PH/+/Pjc5z4X55577kSFVRIvfOEL4xe/+EX/7QsvvDC+8Y1v7PJ5jzzySOy11155bVdddVW8+c1vHnUM//Vf/xV/8zd/k9f2y1/+sj+JFJObCXrevHmDrgIQ0XeFgaeeeqrmrgjgqiHPqvYrC7lCoauGyBF95Ig+Y8kRm666qu+9DnOV3ojhr1D4nHe9S44IOSJHjnjWZMgROcYRfeSIZ8kRfeSIPnJEHzniWZMpR/T09MQNN9yQNyvwGWec0T/zw2TJEZuuumrcM0HPveSSkm5rzLrooorOBP3DH/4w73m59T5ZcsSmq64a90zQ8y65ZMrnCOOIPsYRz5osOSJi6GWYy+/jmQl60Xvek7cMc31GjH0m6NkXX5yXIwb2GTG2maBnXXSRHDGAHNFHjuhjW6OPHPEsOaKPHNFHjugzlXNENpuNG264Ie/+V73qVZGm6YhyRG4sN56ZoOe+7W15y7BwfDiWmaBnXXTRiGaC/tGPfpQ3E3Run4Ic8ewykiOmdo4oVDgT9MD8UVdXF2effXY0NDQYR0xwjth01VXjngl69rJlFckRmzdvjh//+Md595111lkxe/bsMS/D3t7euPbaa/PeyxlnnBEtLS1yxE62NfpMlRwRYRyRU4vjiO1f+tK4ZoKe9ra35S3DTVddNe6ZoOdfckneMsyN38czE/S8t7+97Dli/Wc/Oyim0W5rzLroooiovRyx+aqrxj0T9Mx3vlOO2Pk5XHvllYP6Hc1xjdznKMI4YqBSjSM2fuUr+e91DOPkwmNOxhHGERG1OY6olhyRGyuMZyboRcuW5a2bgfsPx3oO1ayLLrKtsZMc0adcOWLu3LlD1rEWm3A4YoKLoCP6CnVf+cpX5gWfpmkkSRLnn39+fOYzn+m/gmotGWsR9Pr16wfNdr1ixYp4y1veMuoYrr/++jjzzDPz2v7nf/6n/+oCw8lkMqP+8ABANdiwfPm4+5i9bNm4+wAAgGq0Y8eOaG9vz2tra2uL5p1X8J4syrFdMN4+K7mdMRXWu21BYKyq8TdjovoEAGBkxrtdXcvjw6mwTwHKyXeoetTydnU5Pkc+m8BkUupjeLU8fh+vWomzHKbyey+HWj62PhX4vEP1mcrjD4gYWx1rXbmDKvTiF784rrvuumhpaclrnzNnTvyf//N/arIAejxys+4MVGwljkTh1QGG6h8AAAAAAAAAAAAAAAAAAKrZhBdBR0T81V/9VfzHf/xHtLa2RkTfdN3PPPNMnHbaabF27dpKhFQxM2fOjCRJ8tqKTQ8+Elu2bBnUlpteHQAAAAAAAAAAAAAAAAAAakVFiqAjIl7wghfEz372s5g+fXpERKRpGg8//HD89V//dTz++OOVCmvCNTQ0xMyZM/PaNm7cOKa+ij1vwYIFY+oLAAAAAAAAAAAAAAAAAAAqpWG0T/irv/qrkgYwa9as2LJlSyRJEmmaxv333x/HHHNM7L///rt8bpIkcfPNN5c0nkpYtGhRbNq0qf/2WIvAC5/X3NwcM2bMGFdsAAAAAAAAAAAAAAAAAAAw0UZdBH3rrbdGkiQlDyRN0/5C6LVr18Zjjz02osdPBvvtt1+sWbOm//Yjjzwypn4efvjhQf0CAAAAAAAAAAAAAAAAAECtqat0ABF9MzrnCpoH/n+qeP7zn593+5577hlTP4XPK+wXAAAAAAAAAAAAAAAAAABqwahngo7om4WZ0jnmmGPybq9fvz7WrVsXixYtGnEfXV1dcccdd+S1HXnkkSWJDwAAAAAAAAAAAAAAAAAAJtKoi6AvvPDCcsQxpZ166qlRV1cXvb29/W0333xznH/++SPu41e/+lVks9m8ttNOO61kMQIAAAAAAAAAAAAAAAAAwEQZdRH017/+9XLEMaXNmzcvjjnmmPif//mf/rbvfe97oyqC/u53v5t3e+HChXHEEUeULEYAAAAAAAAAAAAAAAAAAJgodZUOgD4XXHBB3u0bbrghVq5cOaLnPvjgg/Htb387r+2Nb3xj1NVZvQAAAAAAAAAAAAAAAAAA1B5VslXi/PPPjzlz5vTfTtM0zjvvvHjqqaeGfV5HR0ecc845sWPHjv62lpaWeMtb3lK2WAEAAAAAAAAAAAAAAAAAoJwaKh0AfWbMmBGXXnppvPe97+1vu//+++O0006La665Jvbff/9Bz1m/fn2cd955g2aMvuSSS2KPPfYoe8wAAAAAVI8Ny5cPasumaXR2dOS1bVyxIjJJUrSP2cuWlSEyAAAAAAAAAAAAgNFTBF1F3v3ud0d7e3v8+te/7m+744474vDDD4/zzz8/zjzzzFi0aFE88cQTcfPNN8e//uu/xoYNG/L6OOKII+JDH/rQRIcOAAAAAAAAAAA1xUXlAAAAAACgutWN5sGXXnppbN26tVyxlE1HR0f87//9vysdxi7V19fHj3/84zjiiCPy2js6OuLLX/5yvPzlL4+jjz46XvrSl8YVV1wxqAB67733jvb29shkMhMZNgAAAAAAAAAAAAAAAAAAlNSoZoK+/PLL41//9V/jwx/+cFx00UVRVzeqGuqK+MY3vhGXXnpp/OUvf4mPf/zjlQ5nl+bMmRM33XRTXHjhhfHTn/50xM878cQT4/vf/37sscceZYwOAAAAAAAAAAAAgPHasHz5oLZsmkZnR0de28YVKyKTJEX7mL1sWRkiAwAAAKgeo65ifuKJJ+Jtb3tbHHzwwXHttdeWI6aS+N73vhfPf/7z401velOsX7++0uGMypw5c+K6666LH/3oR3HKKacMW2x+yCGHxFVXXRW/+tWvFEADAAAAAAAAAAAAAAAAADApjGom6LPPPjuuvfbaSJIk7r333jj33HPjsMMOiw996EPR1tZWrhhHbPv27fHtb387rrzyyrj33nsjIiJN04iIeOUrX1nW17711ltL3ucrXvGKeMUrXhFPPPFE/Pd//3esX78+nn766WhtbY2FCxfGscceG/vss0/JXxcAAAAAAAAAAAAAAAAAACppVEXQP/jBD+Lqq6+Od77znbFx48ZI0zTuuOOOePWrXx377LNPvOENb4gLLrggnvvc55Yr3qLuvPPO+PrXvx7/9m//Fps2beovfI6IaGlpiSuvvDIuvvjiCY2plObPnx8vf/nLKx0GAAAAAAAAAAAAAAAAAABMiLrRPuF1r3tdrF69ur8oN0mSSNM0HnjggfjQhz4U++yzT7z4xS+OFStWxAMPPFDygHP+8Ic/xEc+8pE4+OCD44gjjojPfe5z/YXZSZJERMTpp58ed955Z00XQAMAAAAAAADAZJemaezYsSPvb+AF0AEAAAAAAICpZ1QzQecsWrQofvSjH8WNN94Yy5Yti3vuuae/8Li3tzduueWWuOWWWyIi+ouijzvuuDjyyCPjec97XjQ1NY3q9TZv3hyrVq2KVatWxW9+85u45ZZb4plnnomI6D/omSRJf0H2nnvuGZ/+9Kfj1a9+9VjeHgAAAAAAAAAwgbLZbLS3t+e1tbW1RXNzc4UiAgAAAAAAACptTEXQOaeffnr88Y9/jBUrVsQ///M/x7p16/qLoXPFyQ888EB85Stfia985SsR0VesvMcee8Tee+8d8+fPj3nz5kVra2s0NTVFmqbR0dER27dvj6effjoeffTRePTRR+Pxxx/Pe92BV3se+HqLFi2KD37wg3HRRRdFY2PjeN4aAAAAAAAAAAAAAAAAAABQIeMqgo6IaGhoiHe+851x8cUXx1VXXRWf/vSn45FHHomIGFQQnfv/I488Eo8++ugu+x74vJzcjM+5+9M0jYMPPjje9a53xQUXXOAq0AAAAAAAAAAAAAAAAAAAUOPqStVRU1NTvP3tb48HHnggfvKTn8TLXvayqKur6y9kzhUvFytiHuqv8DlJkvTf19zcHOecc07ceOONsXr16vi7v/s7BdAAAAAAAAAAAAAAAAAAADAJjHsm6EJ1dXVx1llnxVlnnRWPP/54/OQnP4mf/vSncfPNN0dHR0feY3PF0MXkip0Hmj9/fpx66qnxyle+Ml7xilfEtGnTSh0+AAAAAAAAAAAAAAAAAABQYSUvgh5owYIFcdFFF8VFF10UPT09sXr16rjtttti9erV8dBDD8VDDz0UTz31VGzbti06OjoiSZKYPn16TJ8+PebMmRP77bdfHHDAAbFkyZI44YQTYsmSJeUMFwAAAAAAAAAAAAAAAAAAqAJlLYIeqL6+Pg4//PA4/PDDJ+olAQAAAAAAAAAAAAAAAACAGlRX6QAAAAAAAAAAAAAAAAAAAAAGmrCZoAEAAAAAAAAAAABq3Yblywe1ZdM0Ojs68to2rlgRmSQp2sfsZcvKEBkAAAAATC5mggYAAAAAAAAAAAAAAAAAAKqKImgAAAAAAAAAAAAAAAAAAKCqKIIGAAAAAAAAAAAAAAAAAACqSkO5Ov7oRz9aln7r6uoik8lEJpOJadOmxcKFC2Px4sVx0EEHRVNTU1leEwAAAAAAAAAAAACq2Yblywe1ZdM0Ojs68to2rlgRmSQp2sfsZcvKEBkAAADA2JStCPrDH/5wJEPsICmHhoaGWLp0aZx33nnxxje+MWbNmjVhrw0AAAAAAAAAAAAAAAAAAJROXblfIE3TCfnr6uqK//f//l+8733viwMPPDCuvfbacr81AAAAAAAAAAAAAAAAAACgDMpaBJ2maf//kyQp+lfMUI8dyV+apvHkk0/GueeeG5/73OfK+fYAAAAAAAAAAAAAAAAAAIAyaChXx29/+9sjIqK7uzu+8Y1vRGdnZ/99ueLoadOmxaGHHhpz586NmTNnRjabjc2bN8cjjzwS9913X/T29kZEDCqWHlhcPdDAwuo0TeM973lPHHjggfGSl7yk5O8PAAAAAAAAAAAAAAAAAAAoj7IVQX/+85+P7u7uOO+88yKbzfbP0tza2hqvf/3r401velMsXbp0yNmgOzo64sYbb4wvf/nL8Z//+Z/9z58/f37ceuutsWTJkujo6IhNmzbFY489Fr/5zW/iq1/9atx99939xdC9vb3xd3/3d3HPPfdES0tLud4qAAAAAAAAAAAAAAAAAABQQnXl7Pwd73hHtLe39xcwH3300bFq1ar4whe+EEccccSQBdAREa2trdHW1hY/+9nP4gc/+EHMmDEjkiSJJ554Ik477bT4y1/+EtOmTYtFixbFMcccE8uWLYs777wzPv7xj+f189hjj8W//uu/lvNtAgAAAAAAAAAAAAAAAAAAJVS2Iuibb745vvKVr/TfPuqoo+Lmm2+O/ffff9R9nX322fHjH/84GhsbI0mSWLduXbzjHe8Y9Li6urr44Ac/GJdddlmkadpffK0IGgAAAAAAAAAAAAAAAAAAakfZiqA/9rGPRUREmqaRyWTiu9/9bsyYMWPM/b3gBS+I97znPZGmaURE/OhHP4rf/e53RR/7wQ9+MPbZZ5/+26tWrYonnnhizK8NAAAAAAAAAAAAAAAAAABMnLIUQa9duzZ+9atfRZIkkSRJnHfeeWOaAbrQJZdcEvX19ZEkSUREfOc73yn6uIaGhjjvvPP6C6YjIu64445xvz4AAAAAAAAAAAAAAAAAAFB+ZSmC/n//7/9Fmqb9RchnnXVWSfqdN29eHHbYYf19/+IXvxjysccee2ze7QceeKAkMQAAAAAAAAAAQDVJ0zR27NiR9zdw8gAAAAAAAIBa1FCOTteuXZt3e6+99ipZ34sXL47bb789IiIee+yxIR+3aNGiiIj+WaM3bdpUshgAAAAAAAAAAKBaZLPZaG9vz2tra2uL5ubmCkUEAAAAAAAwfmWZCXrbtm15t7dv316Wvnfs2DHk4zKZTN7tnp6eksUAAAAAAAAAAAAAAAAAAACUT1mKoGfPnp13e/Xq1SXpN03TuPvuu/tnd16wYMGQjy2c+XnmzJkliQEAKL00TWPHjh15f2maVjosAAAAAAAAAAAAAAAAoEIaytHpwQcfHBHRX6z8rW99K97ylreMu99bbrklHn/88UiSJJIkicWLFw/52Lvuuisi+oqqkiSJ+fPnj/v1AYDyyGaz0d7entfW1tYWzc3NFYoIAAAAAAAAAAAAAAAAqKSyzAR91FFHRUtLS0T0FSH/93//d3zrW98aV59dXV3xvve9r7/PiIgXv/jFQz7+Jz/5Sd7tww47bFyvDwAAAAAAAAAAAAAAAAAATIyyFEG3trbGq171qv5ZmNM0jYsvvjj+67/+a0z99fT0xOte97q44447+meXjog455xzij7+N7/5Tdx44439j507d24sWbJkTK8NAAAAAAAAAAAAAAAAAABMrIZydfy///f/ju9///vR09MTSZLEjh074qUvfWm8733vi7//+7+P3XbbbUT9/Pa3v413vOMd/QXQucLqV7/61XHQQQcNevz1118fb3rTmyIi+h/7mte8ppRvDQAAAAAAAAAYgw3Llxdtz6ZpdHZ05LVtXLEiMgMulJ4ze9myMkQGAAAAAAAAVJuyFUEvWbIkLr300vjIRz4SSZJEkiTR09MTn/rUp+Jzn/tcnHXWWXHCCSfEoYceGnPmzInp06fH9u3bY8uWLfHggw/GqlWr4oYbbog//elPEfFsQXNExG677Raf+9zn8l7vd7/7XZx77rmxbt26vMc2NjbGO9/5znK9TQAAAABgnNI0jWw2m9eWyWT69/EBAAAAAAAAAAAAU0/ZiqAjIi677LK4995747vf/W5/IXSaprF9+/a45ppr4pprrhn2+WmaRkTkPXf27Nlx4403xoIFC/Ieu3Llynjsscf6H5/7973vfW8ccMABZXh3AAAAAEApZLPZaG9vz2tra2uL5ubmCkUEAAAAAAAAAAAAVFpZi6AjIr797W/HnnvuGZ/+9Kejt7e3v0A5V+A8nIEzvaRpGgcffHB873vfi0MOOWTQY++9996856RpGuedd1780z/9UyneBgAAAAAAAAAAwKSwYfnyQW3ZNI3Ojo68to0rVkRmwDlcObOXLStTZAB90jSNbDab15bJZPLOKwUAAABg8qsr9wskSRKXX355/PrXv44XvOAFkaZppGnaP7vzcH+5x86YMSM++tGPxu233160ADoi4r777ouIvh1f8+bNixUrVsTVV19d7rcHAAAAAAAAAAAAQAlls9lob2/P+yssigYAAABg8iv7TNA5xx9/fPz85z+PVatWxbe+9a248cYbY82aNUPOCD19+vQ47rjj4txzz43Xve510draOmz/Z511Vpx55plx+OGHx0knnRR1dWWv7wYAAAAAAAAAAAAAAAAAAMpgwoqgc5YuXRpLly6NK664IjZv3hz33ntvrFu3LrZu3RqNjY0xZ86cWLBgQRx88MGjKmR++9vfXsaoAQAAAAAAAAAAAAAAAACAiTLhRdADzZw5M44++uhKhgAAAAAAAAAAAAAAAAAAAFSZkU+1DAAAAAAAAAAAAAAAAAAAMAEqOhM0AAAAAAAAAAAwMhuWLy/ank3T6OzoyGvbuGJFZJJk0GNnL1tWhsgAAAAAAABKryJF0I888kj84he/iF/96lfx8MMPxzPPPBPPPPNMNDQ0RGtrayxYsCD23XffWLp0abzoRS+KAw44oBJhAgAAAAAAAAAAAAAAAAAAFTChRdC33nprXH755XHTTTfltadpmnc7KbgK7ZFHHhnvfe9747zzzit7jAAAAAAAAACTVZqmkc1m89oymcygY7QAAAAAAAAAUGkTUgTd0dERb37zm+P73/9+ROQXPSdJMuiAemFR9MqVK+N1r3tdXHXVVfGd73wnFixYUP6gAQAAAAAAACaZbDYb7e3teW1tbW3R3NxcoYgAAAAAAAAAoLi6cr/A+vXr49hjj43vf//7kaZppGnaX/icJEl/28C/gffnCqTTNI2f//zncfzxx8dDDz1U7rABAABgzNI0jR07duT9FV7wCwAAAAAAAAAAAACAoZV1Jujt27fHy1/+8rj77rsjIvIKmiMiMplMHHrooTF//vyYNWtWdHd3x6ZNm2L9+vWxZs2a6O7uHvS8hx9+OM4444y47bbbYsaMGeUMHwAAAMbErFoAAAAAAAAAAAAAAONT1iLod73rXbFy5cq8Iub6+vo499xz4+KLL44TTjghGhsbiz53x44d8atf/SquuuqqaG9vj97e3v6Zo++99954//vfH1/60pfKGT4AAAAAAAAAAAAAAAAAAFABdeXq+O67746vf/3reQXQ++67b/zmN7+Jq6++Ok499dQhC6AjIpqbm+PFL35x/Pu//3v88pe/jH322Scior8Q+qtf/WqsWbOmXOEDAAAAAAAAAAAAAAAAAAAVUrYi6Msvvzx6e3sjoq8Aeu+9945f/OIXceyxx466rxNOOCF+8YtfxJ577tnflqZpfOYznylZvAAAAAAAAAAAAABQKU0RcXpra95fU6WDAgAAAKigshRB9/b2xvXXX98/a3OSJPGtb30rFi9ePOY+Fy9eHN/61rf6+0vTNH74wx9GT09PCSMHAAAAAAAAAAAAgImXJElkCv6SJKl0WAAAAAAVU5Yi6N///vexYcOGiOjbIfOSl7wkTjrppHH3e/LJJ8cZZ5wRaZpGRMSGDRvijjvuGHe/AAAAAAAAAAAAAAAAAABA9ShLEfQDDzwQEdFfrPyqV72qZH0X9rV69eqS9Q0AAAAAI5WmaezYsSPvL7c/DAAAAAAAAAAAAIDxaShHp0888UTe7QMPPLBkfS9ZsiQi+maYjoh48sknS9Y3AFBeG5YvL9qeTdPo7OjIa9u4YkVkdv7eDzR72bIyRAYAAKOXzWajvb09r62trS2am5srFBEAAAAAAAAAAADA5FGWIuiOgiKmadOmlazv1tbWvNvd3d0l6xsAAAAAAAAAoJalaRrZbDavLZPJ9F9sHhheU0ScXnB+UlNlQgEAAAAAgCmvLEXQu+++e97t9evXl6zvv/zlLxHRd9AuSZKYO3duyfoGAAAAAAAAAKhl2Ww22tvb89ra2tqiubm5QhFBbUmSJDKVDgIAAAAAAIiIMhVBL1y4MCKi/yrCt956a5x55pkl6fvWW2/Nuz1//vyS9AsAAAAAAAAAALXI7MUA1KoNy5cXbc+maXR2dOS1bVyxIjI7z0sdaPayZWWIDAAAAIBqUFeOTo8//vj+Aug0TeO73/1udBTsjBqLjo6OuPrqq/v7jog49thjx90vAAAAAAAAAADUqiRJIlPwlxQpEgMAAAAAAKglZSmCnjt3bhx++OH9t9evXx+XXnrpuPu99NJLY/369f23DzvssFiwYMG4+wUAAAAAAAAAAAAAAKC6pWkaO3bsyPtL07TSYQEAUCYN5er4rW99a1x88cWRJEmkaRqf+9znYuHChfGBD3xgTP398z//c3z2s5/t7y9JkrjwwgtLHDUAAAAAAAAAAAAAAADVKJvNRnt7e15bW1tbNDc3Vyii2pamaWSz2by2TCYTSZJUKCIAgHxlmQk6IuLCCy+MPfbYIyKiv3D5H//xH+MVr3hF3HfffSPu55577omXv/zl8cEPfjCvffHixfG2t72tpDEDAAAAAAAAAAAAAADAVJArKh/4V1gUDQBQSWWbCbqpqSn+7d/+LV784hf3z9ycpmn89Kc/jZ/+9Kdx0kknxYte9KI48sgj4znPeU7MmjUr0jSNzZs3x1/+8pdYuXJl/PznP4/f/va3ERF5fdTV1cXnP//5aGpqKlf4AAAAAAAAAMAEaYqI01tbB7UBAAAAAAAAU1fZiqAjIl70ohfF5ZdfHn//938fSZL0FzFHRPzmN7+J3/zmN7vsI/f4JEn62z7+8Y/HK17xivIEDQAAAAAAAABMqCRJIlPpIAAAgBFJ03TQDJGZTCbvXF8AAACAUihrEXRExPvf//6YO3duXHzxxdHd3Z23gyNX4DyUXOF07rGNjY3xqU99Kt797neXNeZKu+yyy+Kuu+4adz9f//rXY8aMGSWICAAAAAAoh/GeKLZh+fJBbdk0jc6Ojry2jStWRKZIn7OXLRtxrAAAQPUZ7zZBhO0CAABGL5vNRnt7e15bW1tbNDc3VygiAACA4lzECWpf2YugIyLe8IY3xKGHHhof/OAH46abboqI/ALn4eQKpU866aS48sor45hjjilrrNXgy1/+cjz++OPj7udLX/qSImgAAAAAqGJOFAMAAAAAAAAAgPJwbg7Uvgkpgo6IOProo+M///M/47e//W18//vfj1tuuWXY2Y6TJIklS5bEqaeeGm984xvj2GOPnahQK2rdunUlKYAGAAAAAAAAACiFWpkpo1biBGBibVi+fNx9zF62bNx9AAAAALXFPgWoDhNWBJ1z4oknxoknnhgREU8//XSsXbs2nn766Xj66aejt7c35syZE7Nnz45999035syZM9HhVdyqVasqHQIAI+AECgAAAAAAAKaKWpkpo1biBABgMOdjAQAATG7jLSpXUD51TXgR9EC777577L777pUMoeoUFkGfdtpp8V//9V+VCQaAITmBAgAApo6hdr5m0zQ6Ozry2jauWBGZIifj2AELAAAAAAAwNOdjAUD5FTv/oVbOfXDBFACYuipaBM1gt99+e97tI444okKRAAAAAAAAAAAAAAAAQGW5YAoATF2KoKtM4UzQiqABAAAAGKumiDi9tXVQGwAAAAAAMDU4VgBALRvvzMURlZ29GACA8VMEXUW2bNkSf/7zn/PaFEEDMB5pmkY2m81ry2QykQyxowcAAJhckiSJTKWDAAAAJh3HHwAAoHY4VgAAAADUslEXQb/xjW8sRxxjkiRJfO1rX6t0GCVzxx13RJqm/benTZsWBx54YAUjAqDWZbPZaG9vz2tra2uL5ubmCkUEAAAAfRTOAFSeXAyMleMP1c1MfwBQGX6DAagk+/oAACilDcuXj7uP2cuWjbsPiBhDEfQ3vvGNqtgYStN00hVB33777Xm3DzvssKirq6tQNAAAAOzKUDt5smkanR0deW0bV6yITJHtaTt5AJiqFM4AVJ5cDDA5mekPACrDbzCTVbFjoqM5HhrhmChMBPv6AICpzvmcMHmNugg6Z+CMxROtGoqwy2HVqlV5t4844ojKBAIAAAAAAAAAAAAAZaCwGgAYiiJGAKDQmIugK6mSBdjlVDgTtCJoAKguaZpGNpvNa8tkMpP2Ai0AAAAAAAAAAAzNuSQAQK1riojTW1sHtQEAVItRF0Gfeuqpds6UQXd3d9x99915bbki6Ntvvz2+973vxa9//eu4//77Y8OGDTFr1qx4znOeE8cdd1ycddZZceaZZ0ZjY2MlQgeAKSObzUZ7e3teW1tbWzQ3N1coIgAAAACA4syWAQAA1LJaKcZxLgkAUOuSJIlMpYMAABjGqIugb7311jKEwd133513NcCGhobYvHlznHTSSfHb3/520OOfeuqpeOqpp2L16tXxta99Lfbbb7+4/PLL45xzzpnIsAEAAACAESpWiKQICQCAgcwiBwD5hrqwy0jZnwK1SzEOAAAAABFjKIKmPG6//fa82729vfFXf/VXI37+n//85zj33HPj4osvji984QvR0GDVAlA7auXqvQAAAAAAlN9ULgQ2ixzVYLwXcIpQdAgAAAAAAEBpqJStEqtWrcq73dvbm3d79uzZsd9++8XChQtjw4YNcc8998STTz45qJ8vf/nLsW7duvjRj34UdXV15QwZAErG1XsBAAAAAMhRCAwAAAAAAABARBUUQT/yyCOD2vbcc88KRFJZhTNB55x44onxgQ98IM4666yor6/vb0/TNH73u9/FRz/60bjxxhvznnPdddfF//k//yf+6Z/+qawxAwCM1VSeyQUAAAAYO/sUAGDy8LsOAAAAjEVTRJze2jqojcmtVta7fV4wPr5DVIMNy5eP6/mzly0rSRw8q+JF0HvvvXdeIkqSJLq7uysYUWXccccdg9o+9KEPxWWXXVZ0RuckSeLEE0+Mn/3sZ/F//+//jQ984AORpmn//Zdffnmcc845sXTp0mFfN5vNDvpxKLRly5ZoaGiIlpaW6O3tjW3btg16zIwZMyIioqOjI3p6evLua25ujsbGxujs7Bz0WvX19dHa2hppmsbWrVsH9Ttt2rSoq6uL7du3D/pcZDKZaGpqiq6urtixY0fefXV1dTFt2rT++Au1trZGfX197NixI7q6uvLua2pqikwmE93d3bF9+/a8+5IkienTp0dExNatW/OWeURES0tLNDQ0RDabjc7Ozrz7Ghsbo7m5OXp6eqKjo2NQTLlluG3btkEzgQ+3DHe1bqZPnx5JkhRdN8Mtw9y6iSi+DIdbN8Mtw4HrptgyzK2b0S7Dgeum2DLMrZtSL8PcuhluGY7n8z2eZTjc53s8y7DYupmqOaLwNbdt29Y/C0W15IhcjGma9i/7rVu39r+vic4R23p7ozFJoilJojtNI1uwjJKIaN35u9fR2xv590Y07xwzDFyG23Yuj4YkiUySRE+axo608JkR04bpd0Z394hyxNatWwet99x6liNGlyOy2WzccMMN/fdHRJx++unR2NiY99xazhHGEcYREcYROZN5HLGt8DuXJFGfJJFN0+guWL6daRqZIr+BDVu2yBEDyBF95Ig+1ZIjBn7XB45nt/X25n3XB+5qL8wPDVu2lH8cUST3jHac3DDgezmROSKbzUZ3d3ckSdJ/IcCB2y798dbQtkbDli2DcsTAz0V9kkRzkkRvkfW2rbc3murqIkmS2N7bG70D+ozIzxGFn7W6iKhLkr7twII+u5MkWpIk6pIkdqRp9KRp3jqf6ByRW++5bYLu7u5B632oHLGttzdvGW4fZt0MXIb973XnOretYRwRYRwxUC2MIwbuU6irq4u6urp46UtfOuhYylDLMJc3d5UjGpIkutI0OgveS11EzI7IW4YDc3F/nu3tjfw1E8P+VjVt2zbmbY3cb9VYtjVyx+h6enr678vlYjmiTy3niGKf76ad67w3TfPu29bbG71JEi11dZGmaXTsfJ8DxwoTmSMKx4e579zAHDIZtjWKLcOurq5B93V0dPQff6iWcURuuQx1/GG4HNGdptGQJNGZptFV8Jr1EdFcVzfkGK81SeSIyM8Rhb8Zuxon55bhsNsaRX4Dc78/A7c1ctsZETGmbY3c7/rAbYIzzjgjMpnMoGU40nFELn9EPHv8Ydu2bYOeW+kcsWXLlkGvO3v27Kivr99ljihc5wO3eQvviyg+jsitH9safcusLiJahlmGhZ/vvPe68zswcBnm+hjJ/oihxngtO3bkLcPCuIY79pkbzxbm2YbC83+KvNfc9Aw9adrfb+673pQk0ThgnDzwe17ObY2ckX6++99vbp/OJN1nOZD9EX2GWzfbenuL/gb2v9edn+9i22sDc8TAZZj7TO4qRwy3z3L2zv/X2rZGqfdH9KbpmJdhLs8WLsNtvb0jyxFF9vvm/bYOWIabrroqIgbn2WyaRsfO70gSfeOxZ/7lXwZ9ziIi9njPeyLi2RwxMLftan9E4fZa/3vZsiUvRxTmy5Euw4HPy+X4/s9hkWWYe3Sx8WGx38CBvxstLS0REYP6TdM0XtjSkrduugaMOSPyfwMbCvKa/RF9JluOqIV9lgNVehxRuIy2bt0aTU1Nk2ocERFjOkewP38XLMNtvb0j3h8x3P62gcswl1PHs63Rms2WPUcUi2m02xq5XFzOHBERRX8DI/KXYUeaRgx4zMDfwMLPcEdv76i3pXNqfVuj8P2O9rhGbp0P/ByOdRnm+h34mz6wtmi4z2Gu3+6I/vU+cIxXLG9N1P6IYseyzjrrrEHPm6hxxFiOORXm2cJjTsYRk3McUS37I3p7e+P666+P3t7e/mWU22+8q3FE7vjDeLY1CtfNtt7eIfe3RYzsuEZE/rrJfS9Huj+iWJ6d1ds7ovPbRnMO1cDz2wrPc4oY2zlUuRzfnyOKLcNRHNcYajuw1DmiM01HvS3dH9POdS5HDJ0jxqLiRdARMSjpTDUbN26MpUuXxgMPPBCPPfZY9PT0xPvf//74yEc+MqLnv+9974sNGzbEJz7xif62NE3jsssuix//+MfDPvfyyy8f9nXSNI2VK1fGggUL4qCDDopsNhsrV64c9LgXvvCFERHxpz/9KTZv3px330EHHRQLFiyIJ598Mu677768+2bPnh2HH3549PT0FO33xBNPjKamprj//vvj6aefzrtvv/32i+c+97mxYcOGuPvuu/Pumz59ehx99NEREfGHP/xh0GfsmGOOiWnTpsXDDz8c69evz7tvzz33jH333Te2bt0aq1atyrsvk8nECSecEBERf/zjHwd9uZcuXRq77bZbPPbYY4NmOV+4cGEsWbIkduzYMei9JkkSL3jBCyIiYs2aNYMSw8EHHxzz58+Pxx9/PP785z/n3bf77rvHoYceGt3d3UWX4cknnxwNDQ1x3333xYYNG/LuO+CAA2Lx4sXxzDPPxJo1a/LumzlzZhx55JEREUX7Pe6446KlpSUeeuihePzxx/Pu23vvvWPvvfeOzZs3x5133pl3X0tLSxx33HER0Vf8X5jQjzjiiJg1a1Y8+uijsXbt2rz7Fi1aFAceeGB0dHQMiqm+vj5OOeWUiIi46667Bv0YHHLIITF37txYv359PPjgg3n3zZs3L57//OdHV1dX0fd66qmnRpIkce+998bGjRvz7luyZEksXLgwnnrqqbjnnnvy7tttt91i6dKl/d+jQieccEJkMpl44IEH4sknn8y7b5999om99torNm7cGKtXr867r7W1NY499tiI6JtFvvAH6KijjooZM2bEI488EuvWrcu7b4899oj9998/tm7dOmgG+sbGxjjppJMiImL16tWDBvOHHXZYzJkzJ9avXx8PPfRQ3n3VniPuuuuuvOU0ffr0OO644yJJkjHniG3btg36PNx1111x6qmnRkT15IiZM2dGRF8+z8W7atWq/pM+JjpHbO/sjD0aGmKPhobY2tsbfyrIAc1JEkt3ntiypqtr0AD3+U1912wbmCO27xzALaivj30aG2NHmsYfCwZ19RFxzM4TxO7r6ho0OG7euHFEOWLVqlWD1nvu8yNHjC5HdHd39y+vuXPnRkTEfffdN6hf44g+xhF9jCOedfzxx0dE329r7vNdX18fSZJMihwxUKXHEbvKER0FvzmHNTVFa5LE+u7u2FKwA+KJnp6YUVcXHWkadw94XsvKlXLEAHJEH+OIPtWSI7YP+M7u1dAQCxsaYlNvb9zX2RkL6uv772utq+u/yvBdnZ15B8BbVq4s+zji8Z6eWFewM3F+fX3s29gY2SLj5LqIOHbnOPnPXV2xLU2jZcDymMgckRsfNjY2xqxZsyIif9slp5a2NVpWrhyUIwZ+lubU1cWBTU3RHTHoN2NNZ2ec0NwcSUQ82N0dm3MnVO5c1gNzRGFMM+vqYr+dJ4AM7HdNZ2fUJ0kckclEJiIe6eqKZ3p789b5ROeI7u7u2Lx5c8yZM6cv3i1bBq33oXLE9s7OmFtfH/s3NkZnkXUTEXF87vPd3R1bC5bx/o2NMS/CtoZxREQYRwxUC+OIgfsUZs6cGU1NTfH4448P6neocUQuF+8qR8ytr4+ne3rioYLf1ll1dbEoIi9HDMzvR2UyURcRD3d3x4aCfvPGEQWfs3lr1oxoW+Ox7u54omD5LmpoiD0bGsa0rXHQQQdFRN8B2Nw4LZeL5Yg+tZwjBo4jcvZtbIxZdXXRFX0nIOSs6eyM2fX1cXBTU6QR/b+tA8cKE5kjct/1lpaWmDZtWnR3dw8aJ0yGbY2BcuOIjRs3Dsrt9957b//+oGoZR+y+++4R0ZcPC48/7CpH7NHbG7vvzLMPF+TZ2XV1saSpKXoiio7xjs5koiFCjhiQI+4uWE65bY2uKL4Mj81kdrmtsaG3Nx4oeC+5E7Uint3WyG1nRMSYtjVyF0LabbfdIiJi8+bNg77rox1H5PJHXV1d/7bGmjVrBp18U+kccdtttw36nF544YUxc+bMXW5rFK7XaUkSh+7c5i3cHxFRfByRWz+7yhHHH398ZLPZ+MMf/tB/UlVuX/Rk2dbY3tkZ0+vq4pCd+waKfW+WNjVFc5LE2u7ueKrgd2yPhoZYEJGXI3Ljw5Hsj5iRJPGX7u5YX9Dvfo88kpcjBo45d3Xsc0ljY8yur48ne3ri0QGf/ZaVK/PGEcXe6+E7l0PHgBNFc9/1fRsbY359fX+OGPg9L+e2xgE7/393Z+egE/IPbWqKaUkS67q74/GCZbiwvj72amyctPssB7I/os9wOWJ7Z2f/OOKh7u7YVDBO3ruhIZ7T0BAbe3vj/oLfwIE5otj25a5yxHD7LBfv/H+tbWuUen/E8yLyxhEDPbehIRY3NMSW3t64p/CiJkkSh+/Ms4XbGts7O0eUIzrSNO4qLA5LkjhqZ78Dc0RunT+vsTF2q6+PJ3p6Ym13d1+RzYAT2KclSXRGX/4stMfOf3M5YmB+39X+iIOGGCe3rFyZlyPWFtw/3P6IocYRuRyfyxHF9kcsrK+P01tb+9bNzte8t7MzYufJ9kfu7PdPXV3RWXD8ITe5z3DHNTrSNO4tiLfwuEZvwedposYRAy8GNWPGjDj88MMjk8lMum2NaskRtbDPcqBKjyMKl/2qVavi1FNPnVTjiPkRIz72OdABjY2xe339oByxvbNzxPsjhhpHzI/I29bI5ffxbGsctH592XPEaM+zLLatkcvv5cwRe0Xk7bPMe68F+yMGGjiOuKswpq6u/nHEVNvW2F6wHEd7XCO3zgfmiJHuj8gpPK4xcJyQyWTieTv/nxtHDHRwU1PMTJJdnh+xuoL7IwYey5o2bVq0tLTEhg0b4oEHHsh73kTts9xcsM6H2x8x1PkRLStXGkcMMFnHEdWyP+I5z3lORPQdf9i0aVNEPHv8YVfjiH3SdJc5YlfbGoU5YntnZ/84YqzHNSLyj2vkcvFI90cU63f3bDYvRwzM72M9h6pl5cq8ccR9Ba87lnOocjk+lyMK91lGjO64RlfB57RcOWJuT8+I9kcMNY6ICDlimBwxllriJK1wBXLdzhlNIvreQLLzqjhTVVdXVzz88MOx7777Fp0Beig9PT1x4IEH5g2MkiSJv/zlLzF//vwhn5ebCXrevHmDrgIQ0XeFgaeeeqrmrghQrVcfq5UrHUe4QuFArizUp5avGrJp06b+K2rlnHPOOdHc3DzmHLF169Zob2/Pu++lL31p/0k/1ZIjuru742c/+1nezveBV9Cf6Byx6aqrxj0729xLLslbhrkr7Y5nJujnvOtdI8oRzzzzzKDP0qtf/epoaWmRI6pgJug0TfNeu7W1NVpaWmLHjh3GEcYRk24cUV9fHz/+8Y/zZurK5ffJkCMGKhxHDPyuZzKZaGxsjCRJBvU7Udsaud+hnNyVMjf39sZNBcvpxa2tMaOubtBv4KyLLpIjBpAj+hhH9KmWbY2B3/WxzJgQ0fddL/c44i+f+cy4Z4KeddFF/fdN9EzQN9xwQ95M0C9+8YvzZv+KqK1tjVkXXTQoRwz8LOWuYrq9tzduKPjevLClJWYXmQk6t34G5ojHP//5vOfmZoL+2bZteTvZc1e0Lbyi/MB1XomZoHc169tQOWLTVVeNeyboeZdcYp+lcUREGEcMVAvjiPHOBJ3LxeOZCXrRe96TtwwH5vexzgQ9++KLR7StMZqZoEeyrZEkSVx33XVFty/liD61nCPWXXll0ZlpeiPihm3b8u57YUtLtCSDZ4IeOFaY6JmgB44P0zSNv/mbv8kbJ0yGbY1iy3DLli3xox/9KO++M888M+/CMYUqNRP0DTfcMOTxh+FyxI6vfnXcM0Fn/u7v5IidOeKJL3wh/73uYpxcbPaqwm2NJz7zmaIzQf9ix468mf5y2xkRg2evGsm2xnhngt721a8O2l7Lpmncun17/yyMERGnNjf3z9bbH9PObYJK5Yinn3560DGns88+O1pbW3e5rVG4HTiWmaBz62dXOaKhoSHa29vz4smto8myrbHpqqvGPRP0gksuyVuGubHceGaCnvu2t+Utw8Lx4Vhmgp510UV5y3Dd8uWD3mt9RPzn9u15M0HnvuuFM0EP/J6Xc1ujc+d7H+vMYjPf+c5Juc9yIPsj+gy3bjZdddW4Z4KevWxZ3jLMfS/HMxP04p2zAtfatkap90d0fvWr454JuvHNb85bhpuuumrcM0HPXrZsxDNB31owE/SLW1pGNBP0wPw+1pmgZ110UV6OeHrFijEtw4F5Npfjc5/D4Y4/jHSf/MDfjZaWltjyhS+Met1E5P8GzhzQZ8TEjSMG7p/Kbbe2tbUNyqMRtb2tUS05ohb2WQ5UyXHE9u3b45prrsm774wzzog5c+ZMqnHE9i99aVwzQU9729vyluGmq64a90zQ8y+5JG8Z5vL7eLY15r397WXPEes/+9lBMY12WyOX38uZI7Jf+cqIZoIebhzR/OY35923+aqrxj0TdK1uaxRuX472uEZunQ/8HK698spB8Y7muMbAcUKSJNH11a/2vddhPoe7GkdkCtZ5xNSdCXrjV76S/17HME4uPOZkHDH5xhHVtD9iPDNB544/jGdbo+mii/LWzaarrhr3TNBzLrkkb93kcvF4ZoJetGzZuM9vK3au08BxxJNf/GLec8dyDlUux+c+349/5jPjmgl6xhDbgaXOER1f/eq4ZoKee8klcsQwOWLu3LlD1rEWxtD/Hou2UjGNjY2x//77j/p59fX18a53vSuWLVvW35amadx0003xv/7X/xryebkiieHkPugRfT9EA28Xyg3Cimlqaoqmpqai9yVJMmy/LS0tQ97X2Ng4qGBqoOH6bW5ujuadV5oo1NDQMOxzc4mlmOGWa319/bD95n7oixluGY5n3YxnGQ63bizDPuP5fI9nGQ73+R7PMhxu3VRrjpg+ffqg2cNyxpMjCvscuNyq5fOdGyzkTlLIxVb4viYqR3QPOBm1YefGwFBa6+qGvG/gMuwueFx90ndV3dH0m1s2u8oRxT5LuYu5yBF9RpojGhsbBy3L1tbWIWMaSY7YsWNH/Md//EfefW1tbcYROxlH9Km1ZThUjsjl91yRWMTg/F7LOaKY3DIc6rs+1HPLva1R+DuUkynyO9e083bhb2BhfFPl8x0hR+QYR/Sp5m2NYt/1XY1npxU8Z+DrlG0csXNHczEjHScXe+1Sf743LF8ehbtau9M0enfu2M3tZu3+1rf6T1jP2bTz39kD9oFFVOe2xsDlkluGxT5LdUXinTbgwpEtA55TuKwbGxsHfdYi+k76T5Ikb+fvtLq6vM9Hc5JEDPEdmKgcUbhd0NDQUHSbNWJwjhi4LOt2sW5ahlnn9ln2qbXfwAjjiJypOI4otk8hk8kM2W/hMizMxcPliMadB52LGbgMi+X35mH6LfZbNfAzsqttjaF+78eyrTGS7cta+3xHyBE5Q32+s2kadUkSA+8dOFZIBvy2Fut/InJE4Xc9d9B/qO96rW5rFDPUvtOcahlHjPT4Q7F1073z89W08yScYnY1xpMj+jQ1NRXdJogY3Th50LZGkd/A3Ek+A7c1CrczIka3rTGabYJin+/cZ2ng9lpDmg76nW0pEmdOpXJEsWNOuYu67CpHDLXOIwbvjxho4Dii8H0N9fnOfdcHxlq4jqrxN3A0OaJw3DXcMsx9vosZuAyLjeWG3R9RZIyXW8a5ZTjU+HC4fgvzbOH5P0PtU4iIvH0yhd/1XI4otg7Ksa2ROxVupJ/vQpN1n2Ux9kf0KbZuBn6HhtsO3NW+xeG2L4fNEbvotxaW4UCl3h+xYeeyKeUyHLh+xrPvfOAyLFznuTxbbPxRl/RdkHIouWVYLL/van9EYbwDl2lLS8uQ+XI0xzUK19No9kcUGu74w3iPawz1OS3357vYdlvE5NvWqJYckVPN+yyLqdQ4ovCzOX369BFva9TKOGJ7jO0cwZzCZViqY04Dl2Gx/D7abY3cey9njhguppFuaxTGVo4ckY3iv4ED7WocMdz4sNa2NVpaWooWmEaMbFtjqO3LkR7XKBbbWJdhrt/CPjfs/He029I59bv4TSn3b2CxsULuAgRDKedvYNcYjjkV5tnC1zCO6DPZxhHVsj8it08ydxGBiOLHH4qtm9w+41JtB0bk/2aU6rhGYS4e7XloEYP3J4/l/LbhznXKZDJD5vfRjMUK1/94lmHLMJ//UueI3GdpLOsmR47os6scMVKKoCeRv/mbvxnUdttttw1bBA0AAAAAAAAAAAAAAEB1y2az0d7entfW1tY2bIEtAECtUwQ9iRx00EH9U7jnPP744xWMCAAAAMYnTdNBV7DNZDL9M6QyOpYnAAAAUAkbli8f1JZN0+js6Mhr27hixZAzdMxetqwMkQEAAADA6BXb3xUxun1e9ncxlfkOAaOhCHqSmTNnTl7h89NPP13BaAAAAGB8pvIVbMtRsDyVlycAAACj5yQkAGA4Q40VRsNYgVrXFBGnt7YOamNyGO/FfOQ4AAAAGD9F0JNMT09P3u1p06ZVKBIAAMhn9lFgMlOwDABQemaMBAAAAKpdkiSRqXQQwJRj3ykAADCVKIKuQl1dXdHY2Djq56VpGhs2bMhrmzt3bqnCAgCAcVHMB0xmchwAAAAwmZnhEAAAAAAAgEpQBF0FXv/618ddd90VTz75ZDzxxBNxyCGHxG233Tbqfu66665BM0EvWbKkVGECAIyJK48CAMDQFBIAAAC1wAyHVLM0TSObzea1ZTKZSIY47gQAAAAAANQORdBVYO3atfH73/++//Ydd9wR27Zti2nTpo2qn1tuuWVQ2ymnnDLu+AAAAACA8lBIAAAATFUuCkWpZLPZaG9vz2tra2uL5ubmCkUEAAAA4zfeCWhMPgMATBaKoKvAUUcdFTfffHP/7c7Ozmhvb4+//du/HXEfaZrGF7/4xby2hQsXxlFHHVWyOAEAqE7lmOHArAkAAAAAAJSTi0IBAFCLXMwHABiOsQKTUbGLMozWSC/M4DsEFFMVRdBpmlY6hIp6zWteE5/61Kfy2j75yU/Ga1/72qivrx9RH5///Ofj3nvvzWt729veFg0NVbGKAQAoo3LMcGDWBICJNd6r90YM3lHsisAAAAAAlWcfDQDA5OJiPgDAcIwVYHx8h4BiKl4h+/Wvf73SIVTckUceGUcddVSsXLmyv+2uu+6KSy+9ND75yU/u8vk///nP4wMf+EBe27x58+Ktb31ryWMFAAAAAAAAAACAcpjI2aUAAAAAgOpX8SLoCy+8sNIhVIXPfvazccopp+TNiv3P//zP0dnZGZ/85Cejqalp0HPSNI2vfe1r8Y53vCOy2WzefV/84hdj9913L3vcAAAAAAAAE6UpIk5vbR3UBgAAAAAAAADA5FPxImj6nHTSSfEP//APcfnll+e1f+Yzn4lrrrkm3vSmN8VJJ50Uu+++ezzzzDPxhz/8Ia6++uq44447BvX1lre8Jc4555yJCh2AKSZN00EX38hkMpEkSYUiAgAmi2KzO2TTNDo7OvLaNq5YEZkhxh5mdwAAmNySJIlMpYMAAAAAAAAAAGBCKIKuIp/4xCfi6aefjq985St57Y8++mh8+MMfHlEfr3/96+MLX/hCGaIDgD7ZbDba29vz2tra2qK5ublCEQEATCzF2gAAAAAAAECpmJQCmMzkuNJqiojTW1sHtQEATGaKoKvMl7/85TjqqKNi2bJlsX379hE/r7W1NS6//PJ417veVcboAMrPzg5gJBSfAcDYOBgGAAAAAAAA1cWkFMBkJseVVpIkkal0EAAAE0wRdBX6u7/7u3jFK14Rn/3sZ+Pf/u3fYt26dUM+dv78+XH++efHe9/73li4cOEERglQHnZ2wNSgAAuY7OQ5SqEcnyMHwwAAAErHhV0BAAAAAAAAyksRdJVasGBBfOITn4hPfOITcc8998Ttt98eTz31VGzcuDGam5tj4cKFceihh8ahhx7qIDoAUHMUYAGTnTxHKfgcAQBQShuWLx/Ulk3T6OzoyGvbuGJFZIoce5q9bFmZIoPaNd4Lu/peQum5OCEAAAAAAMDkogi6BixZsiSWLFlS6TAAAGBEip28GeEETgAAAAAAystF5QAAAAAAACYXRdAAAAwrTdPIZrN5bZlMJpIihasAAKVg/AGTi4vkAABMPmbbBQAAAAAAACaCImgAgBo1VCHBaIykkCCbzUZ7e3teW1tbWzQ3N4/79Rm9Yutd8QgAk43xBwAAQHUz2y4AAABUFxcsAwAAJitF0AAAAAAAUMPSNI1sNpvXlslkIilyYSQAAKDyFCcAAExdLn5PubhgGQAAMFkpggYAAAAYJyeuAlBJ2Ww22tvb89ra2tqiubm5QhEBQPVx0RCgmihOAAAAAACA8nBccPJRBA0AAABUrVopLnbiKgAAQHVz0RAAAAAAAACY/BwXnHwUQQMAAABVS3ExAFSGq+ICAMDUsWH58qLt2TSNzo6OvLaNK1ZEpsh2wexly8oQGQAAAAAAMNUpggYAoF+xk1xGc4JLhJNcAIDqpJgPYHRcFRdg8mqKiNNbWwe1VYp9kgAAAAAAAAAMRRE0AABMYWZ3qH5OBAYoDcV8wFi5iAIAk02SJJGpdBA1aLz7aOyfAQAqbajjgqNhTANQHtV2wTIAAACoJoqgAQAKKAoFAJg4CgmAauciCgAAAAAAlJMLlgEAAMDQFEEDAMAEMoscAAAAAJTXeC+2FOGCSwBMTWahBAAAAABqiUlYpgZF0AAATAq1clLGVJ5FrlbWEQCj4wIfAAAAADA5mIUSGIliJxePhpOLYWoab+6IkD8AAACmKkXQlFWaptHV1RW9vb2VDoVJpK6uLhobG51QD0AeJ2VUP+sIqAQH08tvKl/gAwAAAABgIrkoJQAAAAAw1SiCpiw6Ojpi06ZNsWXLlujp6al0OExC9fX1MWPGjJg1a1a0FswoCUBpmb23+llHAAAAAACDKRQDYLJxUUoAAAAAYKpRBE3JbdmyJdauXRuNjY2x2267xbRp06Kurs6BZEoiTdPo7e2Nbdu2xebNm2Pjxo2xxx57xIwZMyodGsCkZfbe6mcdAQAAAAAMplAMAAAAAAAAapsiaEqqo6Mj1q5dGzNnzoxFixYpfKZspk2bFvPmzYt169bF2rVrY6+99jIjNFPehuXLB7Vl0zQ6Ozry2jauWBGZIvl59rJlZYoMAAAAql+x7eoI29YAAAAAAAAAAACVogiaktq0aVM0NjYqgGZCJEkSixYtiu3bt8emTZsUQQNQdVycAAAYrTRNI5vN5rVlMhn7WYB+493OiLCtAcDU1BQRpxccS2qqwj4BAAAoHcddAAAAph7H8CYfRdCUTJqmsWXLlthtt93sIGLCJEkSM2fOjI0bN8ZznvMcnz0AAIBJYCrvhMxms9He3p7X1tbWFs3NzRWKCAAAJockSSJTA30CAABQOo67AAAATD2O4U0+iqApma6urujp6Ylp06ZVOhSmmNbW1nj66aejq6srmpqmymnxAABQnVxNfXIb7+yjI5151E5IAAAAAGAqK7YvNqI8+2MBAAAAAKqZImhKpre3NyIi6urqKhwJU019fX1EPPsZBEpnoopcAKAYv0O1ydXUAQAAAAAAgInm+DIAAABMToqgKTmzezHRfOYAAAAAKJemiDi9tXVQGwAA1cNsmQAAAFB6aZpGNpvNa8tkMs7bBWAQvxkAlJMiaAAAAAAmDSe+A6WWJElkKh0EADBluAALAAAAUC2y2Wy0t7fntbW1tUVzc3OFIgKYmmqhwNhvBgDlpAgaAAAmkJMYAQBgaquFA9QAQOW4AAsAAEDpOEcDAJgMFBhTCs5VAGqZImgA2IViM8mNZha5CDPJAc9yEuPUY8cRMNk5eQRgdBygBgAAAMbK/liA0XGOBgAA9HGuAlDLFEEDAACUkR1HwGTn5BEAAAAAgIlhfywAAAAAMNUoggYAAAZxFXkAAAAAoNbZzwkATHUbli8f1/NnL1tWkjgAAAAAYKwUQVNR493JWosmasfwrbfeGi960YvG3c+DDz4Ye++9d+y9997x8MMP7/LxjY2NMX369Fi8eHEceeSRccEFF8Rf//VfD/n4b3zjG/GGN7whIiIuu+yy+PCHPzzumAGA8XMVeQAAAEohTdPIZrN5bZlMJpIkqVBEAEwl9nPC5DLUOSbZNI3Ojo68to0rVkSmyJhTMR8AAAAAANQWRdBASXV1dcWGDRtiw4YNsXr16vjmN78ZF1xwQXz961+Purq6SofHFFDswPdoDnpHOPANADASTjgEAGAkstlstLe357W1tbVFc3NzhSJiIDOkAgAAAAARzr0EAACqlyJomKSOPvrouP3224e8/4gjjoiIiIULF8b1118/5OMWLVo0qG24frdv3x4PPfRQ/PjHP45///d/jzRN45vf/GY897nPjY9//OOjeAcAAAAAwEgoYgTGygypAAAAAAAAAEA1UwQNk9T06dNj6dKlu3xcU1PTiB430K4ef8IJJ8RrX/vaaGtri9e+9rWRpmlcccUV8e53vzvmzZs3qtcCAIByS9M0stlsXlsmk4lkiCsXA5SC2dSBUlLECAAAlIMLLgEAAAAAAJWmCBoom9e85jXxne98J37yk5/Ejh074pprrom3vvWtlQ4LAADyZLPZaG9vz2tra2uL5ubmCkUEAAAAAFB5LrgEAADAaBS7GPhoLgQe4WLgAONlYgZgMlIEDZTVaaedFj/5yU8iIuK+++6rcDQAAABANTKz1NRkvQMAAAAAAAAAADAcRdBAWfX09PT/P5vNVjASAAAAoFqZWWpqst4BAAAAAAAAAAAYjiJooKxuvfXW/v8fdNBBlQsEAGACbFi+fFBbNk2js6Mjr23jihWRSZKifcxetqwMkQFgxlkAKK9i20MRo9smsj0EAAAAAFA9HGMFmFi1crzNeZIATDRF0EDZ3HDDDXHddddFREQmk4lXvepVFY4IAGBycJCJaubzSbUy4yxQCQ7+AgAAAAAAtcoxVgAAoBooggZKpru7OzZt2hR/+tOf4tprr40vfvGL0dvbGxERH/vYx2LRokUVjhAAYHJwkGnsxluINNmKkNI0jWw2m9eWyWQiGaIIayR8PgEAAAAAyCnHfmgAAAAAAKYORdDAqI3mQFQmk4mPfexj8f73v7+MEQEAAGORzWajvb09r62trS2am5srFBEAAABENEXE6a2tg9oAgNpjPzQAAAAAAOOhCBoouZaWljj88MPj9NNPjze+8Y2x5557VjokAAAAAAAAakSSJJGpdBBMeRuWLx93H7OXLRt3HwAAAAAAMF4uQAvUMkXQwKjdfvvt/f9P0zS2bt0av/jFL+KKK66IjRs3xrRp0+LCCy+Mt7zlLRWMEgAAAAAAoLalaRrZbDavLZPJRJIkFYoIAAAAAACAWuMCtEAtUwQNjNrSpUsHtZ1yyinx2te+Nl70ohfFo48+Gm9961tj9erV8YUvfGHiA6RmFLuCfjZNo7OjI69t44oVkRnihC5X0AcAAACA0ihHsaUrisP4ZLPZaG9vz2tra2uL5ubmCkVELVJMDwAAAAATz345AIDSUAQNlMx+++0X1113XRx//PGxY8eO+OIXvxgLFy6MSy+9tNKhAQAAAACwC+UotnRFcZj8nMhX/RTTA0B5FbsA/Gi5ADwAAEw+9ssBAJSGImigpA4//PC48sor421ve1tERFx22WXxghe8IE4++eQKRwaUitl7gEqo5ZNH5M3qZx0B1UROAgCg1jiRD5jsXOwBAAAAAMqrls8RLQf7JAHyKYIGSu6tb31r/PCHP4ybbropenp64sILL4zVq1dHS0tLpUMDSsDsPQCjI29WP+sIqCZyElAJxQ4oZ9M0Ojs68to2rlgRmSEOqk6mA8oAADCQiz3AyI13+3Iiti2dVA0AAABUO/skAfIpggbK4qtf/Wo8//nPj23btsUDDzwQl112WXzqU5+qdFgA42JWPgAAAAAAAAAAAAAGctFhAIDyUQQNlMVee+0VH/vYx+I973lPRERceeWVcd5558WRRx5Z4cgAxs6sfJPbeK/6bgckAAAAAAAAAAAAAKVUC5M41UKMANQuRdBA2bzrXe+Kq6++OlauXBk9PT3x5je/OW677bZoaJB6AACqTZqmkc1m89oymUwkQ1x5lNoy1IUeRnPFWRd7AIDScPCXamB8CAAAAAAAALWhFiZxqoUYAahdKhGBsqmvr4+vfOUrceyxx0ZPT0/cfvvtceWVV8YHPvCBSocGAECBbDYb7e3teW1tbW3R3NxcoYgAACYnB38BKKZWLk5QLM7RxBjhIgoAAAAAwNTg4sgwNZiABqD8FEFTUU5ymPyOPPLIePe73x1XXnllRER8+MMfjrPPPjv222+/CkcGlTXUCW2jIYcCAAAAAAAAUM2c9A8AAExVLo4MU8N4J6AZ7wVo1RQAU4EiaJii0jQd1eMfeuihMb/WFVdcEVdccUXR+17/+tfH61//+jH3DQAAAAAAAFCrzBICTHZO+gcAAAAAYDwUQQMAAAAAAAAAVMB4ZwkBAAAotWKzEY6WGQkBAAAoFUXQAAAAAAAANaYcs0Y2RcTpra2D2gAApopixR7ZNI3Ojo68to0rVkSmyLhLoQcAABNNwTIAAACTnSJoAAAAAACAGlOOWSOTJInMeAMDAAAAAAAAAIASUQQNAAAAAAAAUIVqYYb2WogRAAAAAACgVjj2ApBPETQAAABMUXaWAgAAVLdamKG9FmIEAAAAqCZpmkY2m81ry2QykSRJhSICAKqJYy8A+RRBAwAAwBRlZykAQPXbsHx50fZsmkZnR0de28YVKyJT5CS52cuWlSEyAKpRsd8NvxkAAABQXbLZbLS3t+e1tbW1RXNzc4UiAgAAqF6KoAEAAKgZZi4GAAAAAAAAAAAAAJgaFEEDAABQM8xcDAAAAAAAAAAAAAAwNSiCBgAAAAAAqDFNEXF6a+ugNgAAAAAAAAAAmCwUQQMAAAAAANSYJEkiU+kgAIBR2bB8+aC2bJpGZ0dHXtvGFSsikyRF+5i9bFkZImM4Lj4DAAAAAABQOYqgKbk0TSsdAlOMzxwAAAAAAFSHNE0jm83mtWUymUiGKOYDgGrn4jMAAMB4uCAWAADA+CiCpmTq6uoiIqK3t7fCkTDV9PT0RMSzn0HgWa5MDwAAAABMpGw2G+3t7XltbW1t0dzcXKGIAAAAAAAAAIBapQiakmlsbIz6+vrYtm1bTJs2rdLhMIV0dHREfX19NDY2VjoUqDquTA9AMa4yDAAAQzOLLQAAAAAAAAAAVAdF0JRMkiQxY8aM2Lx5c8ybN88JYUyINE1j8+bNMWPGDJ85AAAAAGDczGILAAC1pSkiTm9tHdQGAABA5dlmo5q5OPLUY50D1CZF0JTUrFmzYuPGjbFu3bpYtGiRgQBllaZprFu3Lrq6umLWrFmVDgcAAAAAAJjCnDgDAJWRJElkKh0EAACMgqJQphLbbFQzF0eeeqxzgNqkCLrKrVmzJr75zW/Gr3/967jvvvtiw4YNUV9fHwsWLIhDDz00zjjjjPhf/+t/VU0BaGtra+yxxx6xdu3a2L59e8ycOTNaW1ujvr7eCR6URJqm0dPTEx0dHbF58+bo6uqKPfbYI1oLdgYBAIyVE5YBgFrnxBkAqAwnzgAAAAAwEopCAQAARk4RdJV6/PHH4x3veEdcc801Re9/6KGH4qGHHorrrrsu/v7v/z4+9KEPxXve856oq6ub4EgHmzFjRuy1116xadOm2LhxYzz99NOVDolJqL6+PmbMmBGzZs1SAA0AlJQTlgGAWufEGQAAAAAAAAAAACYDRdBV6M4774y/+Zu/iccff3xEj9+yZUu8//3vj5///OdxzTXXREtLS5kj3LXW1tZobW2N5zznOdHV1RW9vb2VDolJpK6uLhobG83GCAAAAAAAAAAAAAAAAACTlCLoKvPAAw/Ei170onjmmWcG3XfIIYfEnnvuGZs2bYq77rorNm7cmHf/9ddfH+eee2785Cc/qZri0CRJoqmpqdJhAAAAAAAAAAAAAAAAAABQQxRBV5Hu7u549atfPagA+pWvfGV8+tOfjv3337+/bceOHXH11VfHe9/73ti0aVN/+09/+tP47Gc/G8uWLZuosAEAAAAAoCZtWL58UFs2TaOzoyOvbeOKFZEpcvHR2fbFAwDj1BQRp7e2DmoDAACgOqRpGtlsNq8tk8lUzYRVAMDEcXwZoDIUQVeRFStWxO23357Xdskll8SVV1456LHNzc3xpje9KV74whfGKaecEuvXr++/72Mf+1i84Q1viFmzZpU9ZgAAAAAAAJhKip3gEuEkF6qXItvqliRJZCodBAAAAEPKZrPR3t6e19bW1hbNzc0ViggAAGBqqat0APTJZrPxsY99LK/t1FNPjSuuuGLY5+23337x05/+NBobG/vbnnnmmV0+DwAAAAAAAIDJL0mSyBT8ma0KAAAAAAAAqAVmgq4S1157bTz55JN5bZ/85CdHdPD5yCOPjLe85S3x+c9/vr/ty1/+cnz4wx+Oujp17gBmOAAAAAAAAAAAAAAAmHo2LF9etD2bptHZ0ZHXtnHFisgUqeOZvWxZGSIDAEZChWyV+N73vpd3+5BDDokTTjhhxM9/29velnf7iSeeiF/+8pcliQ2g1pnhAAAAAAAAAAAAAAAAAKC2KIKuAl1dXfHzn/88r+1lL3vZqPp43vOeF/vvv39e27XXXjvu2AAAAAAAAAAAAAAAAAAAYKI1VDoAIlatWhVbt27Nazv55JNH3c+JJ54Y999/f//tW2+9dbyhAQAAAADAlNIUEae3tg5qA9gV+QMAAAAAAAAASksRdBW46667BrUdfvjho+7n0EMPzbt99913x/bt26OlpWXMsQEAwGS1Yfnyou3ZNI3Ojo68to0rVkQmSQY9dvayZWWIDAAAqKQkSSJT6SCAmiR/AAAAAAAAAEBpKYKuAmvWrMm73draGosXLx51P/vvv3/e7d7e3njwwQfj4IMPHld8AADA5Ge2KgAABjI+BAAAAABgqil2Qf3RXEw/wgX1AQAASi1J0zStdBBT3fnnnx/f/va3+28fcMABce+99466n//5n/+J448/Pq/t+uuvjzPOOGOXz02G2BCPiGhqcmobUCY9PUWbewtu1w3XR339iPoclRH2WStxjrm/cvRZje97ovosh1p571Olz4n4DpWjz2pcllXQ54hz/CR872Pusxym6neoHGrlc6TP6urTb5s+y6VW3nstfN7L1WepVeP60Wf5+6wVvkP61OfY+xtGb2/+lnVd3bB7T2tPNa4ffVZ/n7U6PqzGZalPfZaqT9/L8vZZDrXy3qdKn75D+tRn6fssB99Lfepz7P3VSp/VuCwnqs9ymCrnCk5Un+UwVb9D5VAr712fpeuvVvp0rqA+y9znmNf5BPc5YpNs/ehTn6Pqr5b6pF9nZ+eQ9w1V6mwm6Crwl7/8Je/2ggULxtTPvHnzBrU99dRTY+proOE+WAAVV4qBlT7L058+S99nOdTKe6+FPmshRn3qs9r7LLVaed+1sCwjaue967N6+9Pn1O2zHGrhvddCjOXqsxxq5b3rc+qplfddK+tcn9XdZ6183mtFLaxzfVZ3f/rUpz6rrz99lr7PcqiV914LfdZCjPrU51Tss9Rq5X3rU5/V2J8+a6PPcqiV914rfZZarbzvWliWEbXz3qdqn7UQoz71Wc191kKM+tTnVOuzFmIsV59TnCLoKvDMM8/k3Z45c+aY+pkxY8agtg0bNgz7nGw2G9lsdkyvBwAAAAAAAAAAAAAAAAAA5VBX6QCIQUXIra2tY+qn2PN27Ngx7HMuv/zymDVr1pheDwAAAAAAAAAAAAAAAAAAykERdBUoLIJuaBjbBN319fWD2rq6uoZ9zj/+4z/Gpk2bxvR6AAAAAAAAAAAAAAAAAABQDmOrtqWkenp68m4XK2YeiWLP6+3tHfY5mUwmMpnMmF4PAAAAAAAAAAAAAAAAAADKQRF0FWhsbMy73d3dPaZ+is36XIoC56ampnH3UQs6Oztr4r2Ks7TEWVq1EGctxBghzlITZ+nUQowR4iw1cZZOLcQYIc5SE2fp1EKMEeIsNXGWTi3EGCHOUhNnadVCnLUQY4Q4S02cpVMLMUaIs9TEWTq1EGOEOEtNnKVTCzFGiLPUxFlatRBnLcQYIc5SE2fp1EKMEeIsNXGWTi3EGCHOUhNn6dRCjBHiLDVxlk4txBghzlITZ2nVQpy1EGOEOEtNnKVTCzFGiJOx6+zsHPVzkjRN0zLEwigcdthh8cc//rH/dltbW/zwhz8cdT+bNm2K3XbbLa9t+fLl8e53v3u8IU56mzdvjlmzZsWmTZti5syZlQ5nSOIsLXGWVi3EWQsxRoiz1MRZOrUQY4Q4S02cpVMLMUaIs9TEWTq1EGOEOEtNnKVTCzFGiLPUxFlatRBnLcQYIc5SE2fp1EKMEeIsNXGWTi3EGCHOUhNn6dRCjBHiLDVxllYtxFkLMUaIs9TEWTq1EGOEOEtNnKVTCzFGiLPUxFk6tRBjhDhLTZylUwsxRoiz1MRZWrUQZy3EGCHOUhNn6dRCjBHiZOLVVToAImbNmpV3e+vWrWPqZ8uWLYPapk2bNqa+pppMJhOXXXZZSWbOLidxlpY4S6sW4qyFGCPEWWriLJ1aiDFCnKUmztKphRgjxFlq4iydWogxQpylJs7SqYUYI8RZauIsrVqIsxZijBBnqYmzdGohxghxlpo4S6cWYowQZ6mJs3RqIcYIcZaaOEurFuKshRgjxFlq4iydWogxQpylJs7SqYUYI8RZauIsnVqIMUKcpSbO0qmFGCPEWWriLK1aiLMWYowQZ6mJs3RqIcYIcTLxzARdBV75ylfGj3/84/7bxxxzTNx2222j7mf16tVx6KGH5rX95Cc/iZe97GXjjhEAAAAAAAAAAAAAAAAAACaKmaCrwKJFi/JuP/7442Pqp9jzFixYMKa+AAAAAAAAAAAAAAAAAACgUhRBV4H99tsv7/a6deuiu7t71P08/PDDg9r23XffMccFAAAAAAAAAAAAAAAAAACVoAi6Cjz/+c/Pu93d3R0PPPDAqPu555578m7Pnz8/5s6dO67YAAAAAAAAAAAAAAAAAABgoimCrgJHH330oLbf//73o+6n8DlHHnnkmGMCAAAAAAAAAAAAAAAAAIBKUQRdBebOnRuHHHJIXtvNN988qj46Ojrit7/9bV7baaedNu7YAAAAAAAAAAAAAAAAAABgoimCrhJnnnlm3u0f/ehHsWPHjhE/v729fdDjX/rSl5YkNgAAAAAAAAAAAAAAAAAAmEiKoKvEBRdckHf7mWeeiRUrVozoud3d3XH55ZfntZ100klx0EEHlSw+AAAAAAAAAAAAAAAAAACYKEmapmmlg6DPi1/84rjpppv6bzc3N8ctt9wSJ5xwwrDPe+tb3xpf+tKX8tquvfbaeNWrXlWWOAGglvzyl7+Mhx56qP924YVHAAAAAAAAAAAAAAAAgOqjCLqK/P73v4/jjjsuent7+9vmzJkTV199dbzkJS8Z9PjOzs5473vfG1/4whfy2k888cT4zW9+U/Z4AZg8NmzYEBERs2fPLnnfjzzySN7tPffcs+SvMZxzzjknfvjDH/bf7unpmdDXH4mOjo747W9/G48++mg89dRTkc1mY9asWbHffvvF0qVLY9Gi/8/eeYdHUX1/+OymJ5AACYRu6EgPXbpKJ/QiiCCCfikiiIqISFERRJoIgihNQEEEBCIggqFXAelVSmgBQg+E9PP7g9+OOzuzu7O7k2Rv9vM+zz5JNnfufaecOXNn7swUzm5FAAAAAAAAXCYpKYnu3r1L9+/fp6SkJEpNTaWMjAzy8/MjPz8/CgoKovDwcAoKCspu1RzF3bt36cmTJ9LfWd0ns0dSUhLFxcXJ+kIlS5Z0y+0gPT2djh8/TlevXqUnT55QWFgYFSpUiCpWrJjdagAAAAAAAAAAAAAAAAAAAAAAAAAAAACQI8FN0G7GyJEj6csvv5R9ZzAYKCoqinr06EGlSpWiJ0+e0KFDh2ju3Ln077//ysoGBwfToUOHqHTp0lmpnWN4++23aePGjUT0bLlfuHBB9zZSUlIoJiaG/vnnH7p58yYRERUuXJgqVapETZs2JT8/P13a6du3r/S7wWCg+fPnO13XnTt3aOfOnXTo0CH6999/KTY2lu7cuWN30HJ4eDiVLFmSKlasSNWrV6eaNWuSwWDQY/Z0Q4TBqyINBnb3gdXuQHJyMl26dMnhOMqXL5+uHnfu3KG5c+dSdHQ0HTlyhFJTU4mIyM/PjypWrEjt2rWjHj166JJPjEajFPsGg4HS0tJcrtMRunbtSqtWrZLaz6yboFNTU2nNmjW0ZcsW8vPzo2+++cbuNGvXrqXp06fT3r17bS6XypUrU+/evalv376UJ08eHa2dY+/evbR//37FvrNJkyZutf8EAKiDG9CyHhGOkUQ55hTh+B0A8IykpCTauHEjbdu2TTqfEB8fr2laf39/KlWqlHQ+oWnTphQZGamr3+7duyk6Olr1/Ey7du2oQYMGupzDKFmypPR7Zp1rsof5g6Eyq0928+ZN2rp1KyUlJdEbb7xht/ytW7dozpw59Oeff9LBgwdV+2mlS5emVq1aUa9evahGjRq6OzvC8ePHafLkybR69Wp6+vSp4v/58+enqKgoGj58OJUrVy4bDAEAjoA+Udbj7n0iUfpDROgTAZATQB7KHtw5FyEPAQAAAAAAAAAAAAAAAAAA2AY3QbsZGRkZ1K9fP1q0aJHD0/r7+9OaNWuoRYsW+ot5CJl5o1xCQgJNnDiRZs2aJbvAak5gYCB16tSJPv74Y5cHTJpuOmRmp+blwYMH9PPPP9PKlStp586dsjeUExFp2XVYDhYOCQmhli1b0ptvvkkvvfSSQz56k9WDV3P6YGATWTGwWsSB6jt27KBVq1bRtm3b6NSpU4p40kKBAgWkwf+tW7d2abucNm0affbZZ5SQkEBE6vFsMBjIaDRSz549adKkSRQeHu50e67uj1wlK26Cnj17No0bN47u3r1LRESRkZF08OBBq+XPnz9P3bt3pyNHjhCR9n1qSEgIjR07loYOHaqL98OHDyk5OZnCwsLIaDTaLMvMNGfOHJo8ebLi7d7mRERE0Mcff0xvvPGG3ToBAJkPbkB7RnbfgJYVx0hEOfuY091uPsOA5azHnQcrE2HAsjnbtm2j2bNn08aNGykxMVH63plTkOY5oFChQtSvXz/q378/FS5c2Gm/AwcO0LBhw2jfvn0KN/P2ihcvTmPHjqU+ffo43RZR9veHiDK3T3Ts2DH65JNP6I8//qD09HSqXbs27d2712r55ORkGjlyJH333XeUnJxMRLa3DdM6adSoEU2bNs2lY5Hr16/TihUrKCYmhq5du0bJyclUrFgxevnll+mNN96g/Pnzq043cuRImjp1KqWnp9t19fLyov79+9O0adPIx8fHaVd7IA9lD+6ci5CHrIM+0TM8oU+Uk/tDRO7VJ0IeynrcOQeZQC5SB3noGdmdh4gyPxchDyEP5XTcPReJkofwIAEAAAAAAAAAAAAAAABwEgZuR3p6Oo8YMYK9vb2ZiDR9ihYtytu3b89udeHp0qULGwwGNhgMbDQadav3yJEjXLRoUTYajVL91j5Go5H9/Pz4k08+4bS0NKfbNNXl6Lw8efKEx48fz3nz5mWj0ajqbPpey8fatJGRkbxlyxan54+Z+dq1azxt2jSOioriatWq8fPPP8/NmzfnSZMm8e3bt61O99FHH7GPj4/d9WE0GtnHx4cHDx7MKSkpTjkePXqU27ZtK7VXt25dm+WTkpJ42LBhHBAQYHUZqi3PJk2a8OHDh51y1JPMiiFm5v3793O9evVUty/z7yIiInjhwoUut+dsDJl49OgRjx07lgsWLKhpXWr5mM9no0aNeM2aNQ45paSkcK9evawuO2vLNiwsjKOjox1eBiZcXZaukpnb5dOnT7lly5aK9RsREWF1mt9//51DQkI0rQdr66RFixb88OFDp5xXrlzJ7dq141y5ckl1BwUFcevWrXnTpk2q08THx3P9+vU1b8dGo5GrVq3Kly9fdsoRAOA6W7du5a5du8pi3dlcZD59kSJFeMyYMXz9+nWX/ETL666SmbmIWZxjThGO39V4+vQpr169mocMGcL169fn8PBwzf2hwMBArly5Mnfv3p2/+uqrTDlm37VrF48YMYKbN2/OVapU4SpVqnDLli35gw8+4B07dnBGRoYu7ZQoUUL6lCxZUpc6HaFLly7ScvXy8sqUNuLi4vjnn3/mBQsWaCp/8+ZNHjt2LL/wwgvSNmr5KVu2LA8dOpQPHjyYKc6OcOzYMe7VqxcHBQWpuoaHh3O/fv34zJkzTtV/6NAhbtq0qep+xZHzCPbOKQQFBfHo0aOdivN58+axr6+v1byj1l6jRo34ypUrTi0T5uzPQcyZl4cmTJigWJ6lS5e2Wv7ixYscGRnpUF/IfH14e3vz+PHjHfZMTU3lTz75RDXvmf4OCQnhJUuWKKZ95ZVXNPual2nQoAHHx8c77KoG8tAzsjsPMWd+LkIeci0PWYI+kZzszkeZ2ScSpT/ELGafCHnoGdmdh7KiP8SMXKRnLkIekpPdeYg583IR8hDykCfkIWacm3OVrO4PAQAAAAAAAAAAAAAAQE4DN0G7MceOHeMuXbpwYGCg1Zufw8PDefTo0fzgwYPs1s0RZMbFz71793Lu3LkdHtxpNBq5Xr16fPPmTafadeZi8u7du7lYsWJWL3Q7c4He1rRGo9Gpi6CiDF4VZTCwnmTWAALRBqrPmDGDw8LCVLd5Vz+W9TVs2JAvXryoyWvgwIGal5/l/7y8vPiLL75wZlFqWpaffvpppn0qVKggmzct02ghIyODX375ZcVyMxgMnCtXLtVpdu3axQEBAarTaN2fmn5/4YUX+MmTJ5rXw9WrV7lhw4Z213u/fv1kD+F4+PAhV6hQQda21u00f/782T6oAABPAzegqZPdAy0zc8C/CMecohy/W4IBy3JychxhwLLrA5anTp3q0L7d2fgx/65mzZoO5YYffvhB1c9WrjR9HxYWxtu2bdPcljnZHTvMmRM/I0eOVCxPg8HAefPmVS0fFxfHzz33nGq/Qms/yPT3oEGDNHsmJCRws2bNrK5ry+/mzZsnTfvZZ5857Wo0Pjuvl5qa6vQyRh6Sk1NjiRl5SI88ZA76ROpkdwzhgRzi9YmQh+Tk1BgygVykXy5CHlInu2OIOXPiCHkIechT8hAzzs0xu38OAsCTefToEcfFxSF2AAAAZAvIQwC4BmIIANdADAHgGoghsTAwM2f9+6eBIzx9+pR27dpF165do1u3bpG3tzeFhYVRZGQkVa5cmYxGY3Yr5hi6du1Kq1atIiIig8FA6enpLtV3584dioyMpOvXr5PBYJC+Z2YyGAyUN29eSk5OpidPnkhtmpchIipevDj9+eefVLZsWYfaNhqNZDAYpLbszcvGjRupc+fOlJSUJHMx30XkypWLSpUqRYUKFaL8+fNT7ty5KTAwkLy8vMjLy4tSU1MpNTWVEhIS6MGDB3Tr1i2KjY2la9euSfWoLYdWrVrRmjVryNvb2+58PX78mDp16kR//fWXzE3N12Aw0Pfff0/9+vUjIqLPP/+cxo4dq7qc1TCv02AwUN26dWn79u2aPD/++GOaNGmSbL6ZmfLkyUP37t1TlL958ybVrVuXrl69KrXnqKPp7wEDBtC3335r1zEz0DuGiIjmzZtH/fv3V2xDauvfhOl/oaGhtHLlSmrcuLHD7ToaQ0RESUlJ9Morr9Dvv/9udZt3FbX6QkJC6Ndff6WmTZtanW716tXUpUsXxfQlS5akdu3aUcmSJSkpKYlOnjxJ69evpzt37qjG6+DBg2nGjBkOOWtZlqYymYWt7UUNLev7q6++oo8++kixnIKDg6lFixb0yy+/yMo/ePCAypYtK1u2zEy+vr70yiuvUFRUFNWsWZPy589P/v7+dP/+fbp06RLt2bOHli5dSocPH1bsl9544w2aN2+eXdczZ85Q8+bN6fr166rbpqlO0/dvvfUWfffdd0RE9Morr9Cvv/6quu35+vpSnjx56MGDB5SSkqKol5mpcOHCdPDgQSpYsKBdT2dJSkqiu3fv0v379ykpKYlSU1MpIyOD/Pz8yM/Pj4KCgig8PJyCgoIyzcHTuHv3rnT8QvTseMXdSEpKori4OLpz5w4lJydTSEgIlSxZ0u22g/T0dDp+/DhdvXqVnjx5QmFhYVSoUCGqWLGiw3VNmzaNRo4cSWlpabrnIbV6DAYDVa9enVavXk3FihXTVI9IeV1PMuMYiUiMY05Rjt/NOXz4MI0YMYJiYmJUHZ3B0ttgMFBAQAC99957NHr0aPLx8XGovvnz59OgQYM0x7vBYKAGDRrQ0qVLNcerJTk1jiZOnEjjxo2TLctSpUrR+fPnVctfunSJOnfuTEePHrV6XGWJ+frw8vKicePG0ahRoxzyTEtLo08//ZSmTp1KycnJsnpN7efOnZtmzZpFr732mmza7t2706+//qrJ17xMvXr16LfffqOwsDCbbp999hl9+umnVvftxYsXp8qVK1Pp0qUdPp9w9uxZOnr0qDTPlnWXLFmSduzYQYULF7bpePToUapbty4lJycr9hVVq1aV9YdiY2MVy8l03L506VLq0qWLzbYs0Ro7O3bscKheRxgzZoxUv8FgoG3bttk9LmjUqJHV/61fv57atm2rut8pVKgQXb9+XVY+PT2d6tSpI+vTmKaJiIigVq1aWe0Lbdq0SXW9TZ8+nYYMGWJ33qOiomjDhg3SvFv6Wn7n5+dHJ06cIIPBQBUrVpT6OabyLVu2pI4dO1KlSpUob968dP/+fTp+/DitXr2a/vzzT4Xn22+/Td98841dT3OQh9TJ7jxElDm5CHlI3dWRPGQO+kTWye4Yyoz4EaE/RCRenwh5SJ2cGEMmkIvUXZ3JRchD1snuGCLSP46Qh2y7Ig/J2xM9DxF59rk5EXKQVu7cuUM7d+6kQ4cO0b///kuxsbF0584du9dYw8PDqWTJklSxYkWqXr061axZU/dr+ykpKRQTE0P//PMP3bx5k4iIChcuTJUqVaKmTZuSn5+fLu307dtX+t1gMND8+fN1qdcR3n77bdq4caPkcOHChUxpJy4ujuLi4qh69eqaym/bto3+/PNP2rFjB129epXu3LlDKSkpFBwcTKVKlaLIyEhq1aoVtW7dmnx9fTPFWStJSUn0888/0y+//EIHDhygR48eSf/Lly8fNWnShNq1a0c9evRw+BqRMy4Yq5C1uPtYBVHGKRDpO1ZBK+6ai5CH9Ad5KHPyEGIIMWQNxJA2EEOIIWsghrSBGEIMWQMxBLIK3AQNhMPLyytT63fkQprBYKC0tDSr/+/fvz/98MMPsgt+ERERNHbsWOrQoQOFhIQQEVFsbCytWrWKZsyYQVevXlVcdMyfPz/FxMQ4dILJkQthZ8+epVq1atHjx49lbfv5+VGHDh2obdu2VK9ePYqIiNDcvjmJiYl0+PBh2rx5My1fvpzOnz+vuAhqfsOdLUQYvOrug4FFGlgtwkB187batm2r2D5N81+6dGmqV6+eS4P/Dx48SHv27KGkpCTFfAYEBNCff/5J9evXV/WrVKkSnTp1SponHx8fmjp1Kg0aNEjxMI2UlBRasGABjRkzRnHDrsFgoEGDBtHMmTN1XZbmZbIbLev78ePHVLRoUUpISCCiZ8smMDCQPv/8cxowYAAFBAQopnn33Xfpm2++kc1nw4YNacmSJZouykRHR9P//vc/un37ttSmwWCg3bt3U926dW261qxZk86dO2d3EIZ5vZs3byZvb29q0qSJ7H8FChSg9957jzp27EhlypSRpj937hytWrWKpk+fLm03pjZefvll2rx5s9151EJSUhJt3LiRtm3bJnWk4+PjNU3r7+9PpUqVkjrSTZs2pcjISF28iIh2795N0dHRqh3pdu3aUYMGDXTpuJcsWVL6PTM7sbbo2rUrrV69WnKwdTzkCjdv3qStW7dSUlISvfHGG3bL37p1i+bMmUN//vknHTx4UDWWS5cuTa1ataJevXpRjRo1MkNbE8ePH6fJkyfT6tWr6enTp4r/58+fn6Kiomj48OFUrlw5u/XhBjTbaMlFIh0jEbn/MacJEY7fzcGAZetk92BL3DjjngOWN27cSG3atFHUX7VqVRowYAC1bdvWbn6wR1paGu3cuZN+/vln+umnnxSDTRs0aGB3H96yZUtpH2GarnPnzjR58mTFuY5//vmHJk2aRCtWrFDMl5eXFy1ZsoS6d++u2V9r7LjTg6FsHd9lZGRQ6dKl6fLly7LtpW3btvThhx+q9km//fZbeuedd2Tlw8LC6JtvvqFu3brZfMDjnTt3aOLEiTRjxgxpHpiZ/P396cyZMzb7UjNmzKBhw4Yp1mPhwoWpevXq5OPjQydOnJDOU5nW0SuvvEKhoaH07bffSt8/99xztHz5cqpTp47V9nbt2kU9evSgGzduSG15e3vTqVOnqHTp0lanMwd5yDrZnYeIcOOMO+Yhc9Ansk1O6xOJ0h8iEqtPhDxknezOQ578cDUiMXIR8pBtctrDoZCHkIc8LQ8Ree65ORFykD0ePHhAP//8M61cuZJ27txJGRkZsv9riS3L7TokJIRatmxJb775Jr300ksu+SUkJNDEiRNp1qxZspsazQkMDKROnTrRxx9/rOmamS1yajyZePr0Kc2ZM4fmz59PZ86cofr169vNr+vWraNx48bR0aNHpe/UtgvTdhAaGkpvv/02DR8+nAIDA13y/eeffygmJoauXbtGycnJVKxYMXr55Zepdu3aVqfZuHEjDRw4kK5evWrXNSIigiZNmuTwsYs1MFbBc8Yq5ORxCkT6j1WwhzvnIuQh5CER8hBi6D8QQ0oQQ/ZBDP0HYkgJYsg+iKH/QAwpQQyBLIcBEAyDweA2H6PRaNXzxo0b7Ofnx0ajUSrbvHlzfvTokdVpUlJSeMyYMezr68tGo1H6GAwGDg8P57Nnzzq0nMzbtkWTJk2kcqZpunbtynFxcZrbc4Rly5Zxvnz5ZO0ZjUbeunWrzem+/vprmadp2iJFinDbtm25U6dOXLZsWcW89+jRgwcPHiz7PiIigvft22ezvZ07d3LRokVlbfn4+PD58+etTpOens4lSpRQLM927drxrl27VKeZNWuWonz+/Pl52bJlnJ6ebtMxPj6e33vvPfby8pJNHxAQwLGxsarTWC5DvT+WMWLr4+XlZXP+WrRoIVtvBoOBu3TpwpcuXVKUPXz4ML/yyiuq24i3tzcvW7bMZlvWlpOWGGJmnjJlimI9+vr68pAhQ/jMmTMOtW2LxMREXrp0KVeqVEnR3nPPPae6j9m0aZNsfry8vDg6OtpuW/Hx8RwVFaVox2g08ocffqjZWcuytLW96LHNat0uta7v7777TjZfAQEBvHv3bqvlnzx5wgEBAbI22rRpw6mpqZqXIzNzbGwsP/fcc7J62rVrZ3Oat99+W7EOAwICuEePHjx16lT+5ptv+K233uI8efLIyjVs2JA7deokm8+2bdvazGPMzPfv3+fmzZsr1ru9fbw9tm7dyl27duVcuXJZXbeO5G/Tp0iRIjxmzBi+fv2602779+/nevXqqXqZfxcREcELFy50aTkwO75/ygy6dOmi6XjIWY4ePcpt27ZlHx8fNhqNXLduXZvlk5KSeNiwYVKc2ds2TGWaNGnChw8fdtrz2rVrPG3aNI6KiuJq1arx888/z82bN+dJkybx7du3rU730UcfSfNmz9PHx4cHDx7MKSkpVuvbsGGDav6rVq0af/fddy5t3yZSU1M5JiaG33zzTdXl3LBhQ7t1uHteF+kYSYRjTmYxjt/N+fTTT1X34aa/n3vuOY6KiuJ3332XJ02axAsWLOBff/2V169fz3/88Qdv3ryZN2zYwGvXruWlS5fyrFmzePTo0dy7d2+uU6cO+/v7W627VKlSmmL1yJEjUj2Wxy+RkZHcuXNnbtOmDUdERKhubwaDgf38/PjXX3/VtEzM0RJH27dvz7RP48aNZfO0Y8cOu9PY4vfff1ddPgaDgQsXLqwon5aWxjVq1FCdpkSJEjxo0CBesGABR0dH8+bNm3nFihU8adIkbt++vdV1NmPGDE3Lvk2bNlbXp9p3/v7+/O+///KFCxfY399fUb5Vq1b8/fff8549e/j06dO8Z88enjt3rmw/be75zjvvqHqlpaVxyZIlZduGj48Pz5w5U9N8OcPFixdl68H0c8GCBVanOXLkiKL8xx9/bLetmJgYKZYs9yurV6/W7Kz12M0yR2bnx5bnb7/9ppin6dOnWy2fnp7O4eHhsmVYunRph49PNmzYIG3PpnYHDBhgtfzTp08V7ebLl49/+eUXRdnNmzdzsWLFpLK+vr4cHBwstVOmTBmOj4/X5Hnt2jUpF5mmf/PNNzVNizxkG62xJEouQh5yPQ+Zgz6RfbTEkGVben8sc42tj60+kSj9IWax+kTIQ7bREkOi5CATyEX65SLkIftoPZYTIRchD1kHeQj9oZx4bs7dc5Atnjx5wuPHj+e8efOq7gcd3edamzYyMpK3bNnilOORI0dk51FsfYxGI/v5+fEnn3zCaWlpTi8XrfGUmWTWddZt27ZxiRIlZMvz+eeft1o+JSWF+/fvb3O7tpVHixUrpum4U40tW7Zw5cqVrbb1wgsv8KlTpxTTffPNN+zt7W13O7b8/wcffOCUpwmMVfiPnBxDzOKMU2B2n7EKtnD3XIQ8hDzk7nkIMaQEMfQfiCH7IIaUIIb+AzFkH8SQEsTQfyCGQHaBm6CBcDiaMB39aE3M9hLHt99+K0t05cuX58ePH2uax507d3KBAgUU7RUvXpyvXbvm0HKy57lnzx5F2REjRmhqwxVOnz7NxYsXl7XbqlUrq+VFGbwqwmBgc7/s/tjaNkUZqM7M/PDhQw4ODpa1V7hwYZdPWNsiLS2NBwwYoPAcN26couzw4cNly2Pw4MGa28nIyOAPPvhAsTyNRiNPnjxZUx1aluWMGTM4MDBQdT9bpEgRjoiIcPoTFBQk2+a0TGOPbt26yeqcMGGCzfKrVq2SLYeCBQvavZnYGgcPHmRvb2+pLl9fX37w4IFq2Zs3byr2DbVq1VIdGBMfH8/NmjWTrWvTwb7R+Oymba2kpqZyw4YNZXU5Mr05hw4d4qZNmzqcp7XmelM9QUFBPHr0aIcv3sybN096eImal1pbjRo14itXrji1PJhzdkeamXnChAmKZVq6dGmr5S9evMiRkZFW14G9bcDb25vHjx/vkGNqaip/8sknqhczTX+HhITwkiVLFNO+8sorml3NyzRo0ED1+AU3oGlDS9yIcozELMYxpyjH7+bzprYPx4Dl/3AkjjLr48hxAG6cyfwBy5bHuN7e3rxu3Tqb9etBYmIiN2rUSNZ2lSpVrJb/4osvZMuwRYsWmtuKj4/nBg0aKNa9v7+/5of8aD12c5f4sef51ltvyero06ePzfnfvn27bBn4+/s79JA/c5YsWSKrK0+ePFaP3xcvXiwrGxISwidOnLBad2xsrHQuzvK46uTJkw557tixQ1ZH/vz57U6DPGQf0WLJVi5CHrKOMzfOoE+kDUeO5bKzL2QeX9YQoT/ELFafCHnIPo7EkDvnIBPIRdZxNBchD2nD0WO57M5DtjyRh2yDPPQM9Idyxrk5d89Btti9e7cU17bWmaP7RVvbg6M3ye3du5dz586teZsyL1evXj2+efOmw8uFOedeZ/3tt98UecJgMHCBAgVUy6empnKzZs2sbiP2tgHTdz4+PvzTTz855Dp27FhN22BISAjv379fmm7NmjWy+XPE1Wg0cv/+/R1erhiroCSnxhCzGOMUmN1rrIIt3D0XIQ8hD7l7HkIMqYMYegZiyD6IIXUQQ89ADNkHMaQOYugZiCGQneAmaCAcahdas+tjK3F07dpVVs6RC8HMz06UmZ6mYT6vFStW5Hv37tmdXmuSHTp0qGx5tm/f3iFPV9i3b5/syYJeXl58//591bKiDF4VYTCwloM9Vz62DljVDgqsIcpAdWbmOXPmyMrnzZuXL168qNnXFSwvoBYqVEhR5oUXXpCtE2cuaHz++eeK5Wk0Gnnp0qV2p9W6LE+dOsXVq1dXbDvVqlXj48ePO+xsIjMO+EuVKiXbruw95OKTTz6ROXz11Vcutd+jRw9ZfZs2bVItZ35x3mAwcLly5TghIcFqvcnJybJ1YGojX758VvfP1rh8+TL7+flJ9QQGBjp80W7q1KkOXbRzNIerdXBr1qypOUZ++OEHVTdb+0HT92FhYbxt2zaHlocJR/ZPmUVmXVgcOXKkYpma9qtqxMXFKd6OrmX7UFv3gwYN0uSYkJCg6MDbWv/z5s2Tpv3ss8+c9jQan52AsXyDPG5A26qpDi1xI8oxErMYx5yiHL8zY8CyVhyJI1dytF4fW3GEAcu20TpguVevXrLlPXLkSO0Lw0Vu3LjB+fLlkzlevnxZtWzz5s1lngcOHHCoraSkJG7durUihkJCQvjo0aN2p9d67NapUyerxxTuFD+VKlWS/Ly8vOweO1v2Jd999127y8wWpuMPU5179uxRLdenTx9ZudmzZ9ute+nSpYr11bdvX6c8Lbe7I0eOWC2LPKQNrbEkQi5CHrKNozfOoE+0VVMdWmLIvH537hOJ0B9iFqdPhDykDUdiKLvzj70YYkYusocjuQh5aKumOhw9lnPnXIQ8ZB/kof9Af0gdEfKQCDnI1nwGBAQo9nfm6yd37txcrVo1btWqFffu3ZvffvttHj58OH/00Uc8atQo/vDDD3nYsGH85ptvcpcuXbhhw4aylxxY7kdNf7dp00ZxHUuN+Ph4Llq0qNV6QkNDOVeuXFbbMhievSHemf2p1njKTPS+znrmzBkODAxUXVY+Pj6q07z++uuq24jRaOQKFSpw7969+f333+dRo0bxoEGDuFWrVpwvXz7VaXx8fDgmJkaTq/m4CS35uGjRovzo0SN+9OgRFyxYUNF2aGgov/rqqzxhwgSeM2cOT5gwgXv06CG5Ws7bDz/8oHm5YqyCOjkxhpjFGKfA7H5jFazh7rkIeQh5yN3zEGLIOoihZyCGbIMYsg5i6BmIIdsghqyDGHoGYghkJ7gJGgjHo0ePpB2n5Y6ldevWvGjRIqc/tWrVku0UtUxjjfLly0tuwcHBdp8+q8aVK1e4dOnSivls1KiR3RvJtCbZWrVqycqdOXPGYU9XsLyRb/369arlRBm8KsJgYFEGVosyUJ2ZuV27djJXWxfJ9SYlJYXLlCkjcz127JisjHnHoXz58k63NWHCBMXy9PPz4+3bt9uczpFlmZqayiNHjpQ9idtoNLK/v7/mN09bkhkXQEJCQiS3evXq2S3fr18/mYOjA0Ys+fXXX2X1zZo1S7Vchw4dZOU2btxot+6dO3cq1tno0aOd8rTs6OzYsUPztJ9++qlqh9e8ExoVFcXvvvsuT5o0iRcsWMC//vorr1+/nv/44w/evHkzb9iwgdeuXctLly7lWbNm8ejRo7l3795cp04d9vf3t1p3qVKl7A6cOHLkiFSHZZ6OjIzkzp07c5s2baTBLWodRD8/P/71118dXq5aY2r79u2Z9mncuLFi3dqbxh6///671ZMOhQsXVpRPS0uTDVQyn6ZEiRI8aNAgXrBgAUdHR/PmzZt5xYoVPGnSJG7fvr3VdTdjxgy7nm3atLF5gsTyO39/f/7333/5woUL0uAa8/KtWrXi77//nvfs2cOnT5/mPXv28Ny5c2VvlTB3fOedd2Q+uAFNv7wuyjESsxjHnKIcvzNjwDJunMGAZTW0DFiuUKGCbJncuXPHoTZc5f3335dtDytWrFAtZ/4AoyJFijjVVkpKitTvM9/OihYtave4UeuxGzPzwoULZYNkTT9bt27Np06d4suXLzv1MeVQ83xt72ONsLAwTfssEwMHDrSbMxxh3rx5svq+//571XIVK1aUPHPlyqXpgUxpaWlSX89U/x9//OGUp+lhaaZ6li9fbrUs8tBWTXVojSURchHykH0cuXEGfSLP6xOJ0B9iFqdPhDy0VVMdOak/xIxcpAWtuQh5yPMeDoU8pA3kof9Af0iJCHlIhBykxpkzZ6Q3IVlub927d+effvpJ9e3lWnny5Anv3LmTx4wZI3sLtvl8a3kzzv/+9z/FtCVKlOBFixbxgwcPpHKXL1/mqVOncvHixVXzQ4ECBWyuFzW0xlNmxpIj8WQ02n6zOjNzw4YNFcuncOHCPH78eD516pSi/B9//KHabv/+/fnff/+12k5GRgavXbuW69Spo2ivaNGidh8cv2nTJqvLIXfu3IoB0aafI0aM4IkTJ8q+9/Pz4y+//JKfPn2q2lZiYiJ//vnn0os5zGPZfBuzBsYqWEdrDIk0VkGUcQrM7jdWQQ0RchHyEPKQO+chxJBtEEOIIcQQYsgSxJASxNAzEEOIoeyIIZD54CZoICwrV67ksLAwxY6qZ8+eTu9c9LxRLn/+/NJOr2HDhk7XExsbKz3p1Xw+e/ToYXM6rUnW/OJ4xYoVnfZ0FtOFTZOntQuwogxeFWUwsAgDq0UaqG56a7vB8OwJ0MnJyU75OsuUKVNky/3HH3+U/T8oKEia/5YtW7rUlulGA/PlmS9fPpsXmh1ZliZ27tzJJUqUUEzbqFEjhztQmXETtPmBbYcOHeyWf+2112QOiYmJLrV/8OBB2XqYMGGCajnTgzQMBgMXLFhQc/2WTxjfv3+/U54///yzbL6XLFmiaboNGzYoOkkGg4GrVavG3333ncNPdlcjNTWVY2Ji+M033+SAgABFp8he7ja/6GOapkuXLqrb5+HDh/mVV15RnSdvb29etmyZQ+5aY0pLB9ddOtLp6emymDfV365dO961a5fqNLNmzVKUz58/Py9btszuw2fi4+P5vffekz1wwWAwcEBAAMfGxlqdzvzt6ubTFSlShNu2bcudOnWSnZwxP24bPHiw7PuIiAjet2+fTc+dO3cqjgN9fHz4/PnzUhncgKZvXhfhGIlZjGNOUY7fmTFgGTfOYMCyNewNWM6dO7fUTu3atZ1qwxU2btwoWy/WBgnlyZNHKvPyyy873V5ycjI3adJEsY1XrVqVExISrE7naH/o0qVLisHRRqORy5Yta/fYwRp69onM+0Jt27a1W/7VV1+VtX3//n2X2t+zZ49s2Xz55Zeq5czPyzVq1Ehz/S+++KLM9/bt2055mg/QNhqtP7iKGXkIN84gD1lD640z6BN5Xp9IhP4Qszh9IuQhz+sPMSMXaUVLLkIe8ryHQyEPaQN5SA76Q3JEyEMi5CA11M5dde3alePi4pzysMeyZcukODKfb1s3+N+4cYP9/Pxk5Zs3b86PHj2yOk1KSgqPGTNGeiuveXvh4eEO3RSvNZ6yM34ciad9+/Yp5qlr16785MkTq9NUqVJFNk1QUJBD+/v09HT+6KOPFO1aG7NgonLlyoppBg4cKFt/169f51GjRsnWdb58+fi5556Tlkfu3LmtXj+2ZMuWLYo3wI8bN87mNBirYBtHYsi8Pb0/ljFi62NrrIIo4xSY3XOsghrunouQh5CH3D0PIYZsgxhCDCGGEEPmIIZsgxh6BmIIMZSVMQQyH9wEDYQmLi5OcWLPaDRysWLF+M8//3S4Pj0HhZrvPLXcIGeLkydPcmhoqCLBjxo1yuo0WpOs+eDVqKgolzydwfJGvokTJ6qWE2XwqiiDgZndf2C1SAPVAwMDpbpdeeiBs2zdulU2f1OnTpX93/yiSbt27Vxur3fv3orlWbp0aauDexxZluYkJCRIF5hN0xsMBg4ODuZ58+ZpriczboLOmzevNP8vvfSS3fLvvfeezMHWtqcFy1i3tk8y92zWrJnm+k251dV9k6XntGnT7E6TlpbGJUuWlK13Hx8fnjlzplMOWrh48aLsSb2mn9be6n7kyBFF2Y8//thuOzExMdLTls3jx8fHh1evXq3Z15GOtHnsuGtHmpn5t99+U8zX9OnTrZZPT0/n8PBwxX7I0YvOGzZsUHRSBwwYoFr26dOnijbz5cvHv/zyi6Ls5s2buVixYlJZX19f2cC9MmXKcHx8vCbHa9euKR5M8Oabb0r/xw1o+ud1dz9GYhbjmFOU43dmDFg2GHDjjD0wYPlZPZYDls33RXr0Mxzl0KFDms4n6Hl+5tGjRxwZGanYvlu1amV1cJMz/aGMjAyeMGGCzN103PjJJ59wamqqQ9565iHTsYdpvu0xaNAgWduuPjTM8jyStT6Gs+u9Q4cOMl9Hl7UJy+3T1gUb5CHcOGMP5CH1PGQCfSLP6xOJ0B9iFqdPhDzkef0hZuQirWjJRchD+uchZvfORchD2kAeUoL+0H+IkIdEyEGWmO8fTD9HjBjhVPuOcPr0aS5evLjiXJk1vv32W5ln+fLl7b7tx8TOnTulN26bx1Hx4sX52rVrmurQGk+WOUjvj2n92mvHnucHH3wgq6NevXo2z2edPHlSsQzWrVunadlZMmzYMFldERERVsuavynKYHj2AISlS5faLG/KuZa+q1atcshz7ty5sjpKly5ttSzGKtjH0Rgy39az62PLU4RxCszuO1bBEhFyEfIQ8pA75yHEkH0QQ4ghxBBiyBzEkH0QQ/+BGFKCGLKPIzEEsgbcBA1yBDNnzpTdhGja0QwePNiht23qORDH/KkkrlxMNrFr1y7p5Jf5PC5atEi1vNYka7oIYzQauXHjxi57OsrmzZtlydPaBVBRBq+KMhjYhDsPrBZpoLrpqUJGY/Y8TODAgQOy9T5p0iTZ/4sUKSL9T49BOKmpqdy4cWPZMjIYDFy/fn1OSkpSlHdkWaqxevVqzp8/v6Ketm3b8q1bt+xOnxk3QUdGRkouefPm5bS0NJvlf/zxR5mD1qd1W8P0ZFl7B+XmcdS+fXvN9ZsGYbi679y/f79s27T1YAYTq1atkq1rb29vpztJjpCYmCg9+d3UtrWBF1988YVsvlq0aKG5nfj4eMXgLYPh2eAeW09FNyendaSZmd966y1ZPX369LFZ3nwAlWn5OfJENnOWLFkiqytPnjyqg1kWL14sKxcSEsInTpywWm9sbKx00sR8Oh8fHz558qRDjjt27JDVkT9/ful/uAFN/7zO7N7HSMxiHHOKcvzOjAHLpnnHjTPWwYBl9f66acCq0WjkunXrOtWGK0RHR8vm09qNE+YXMRxZjta4ceOG4u0HRuOzJ4yq4Up/6PDhw1yhQgVFHdWrV3foeELP+ClXrpzkUrx4cbvlZ86cKWv7woULLrX/008/yeqz9qYS84cJOnK+y9TXNdWvdTCYJWvXrpXVY+uNUchDuHHGHshDts8bo0/keX0iEfpDzOL0iZCHPK8/xIxcpBUtuQh5KHPyELP75iLkIW0gD6mD/tAzRMhDIuQgS4YOHSqbxpFrw66yb98+2eBSLy8vq+upa9eusmXkyM2XzM9uGC1RooRs2zYYDFyxYkW+d++e3em1xpPazaLZ9bHlWbduXVk5ezE+bdo02Xx17NjR7jKzRnJyMpcpU0a2PI8fP65a9t1335V5anmj+7hx4xTrq2nTpg57ZmRkyN5AbzQarb5xF2MV7KM1hixzkN4fyxixVc6WpwjjFJjdd6yCJSLkIuQh5CF3zkOIIcQQYkgJYkgOYkgOYsg+iCE5iCE5iCH7OBJDIGswEgA5gMGDB9OhQ4coMjKSmJkMBgMxM82ePZsiIyPpwIEDWe6UL18+IiJiZjp//rzL9dWvX5/mz59PzExEJM3j//73P/rrr7+crjc8PFzyPHHiBKWlpbns6gh79uyR2iciKliwoGq53LlzS7/fv39fc/2WZR88eOCg4TOuXbtGRP955smTR7Vc4cKFpXInT560W+/zzz+v2o6znD17VmqfiKhQoUI2yxsMBho5ciTt27ePypcvL8VPWloaTZgwgerUqUOnTp1yyclZzJfxvXv3XKord+7ctH79eipSpAgR/Rc/mzZtosGDB7tUNxFR3rx5iejZcr9y5YrL9TnKhQsXpPaJ/otrE6a4YmY6evQoPX361KX2vL296bfffqPSpUsT0bPlSUS0d+9e6tmzp0t1q9GxY0c6fvw4tWzZUraPX79+PVWqVIlWr16te5v2qFmzprS8Hz58SCtWrLBZvkWLFuTl5SUtq+joaJfaX7x4sezvsmXLqpYz5SIiohs3bmiuPy4uTnIlIrp165aDhs+4fPkyEf23bYaGhtqdZs2aNdI0BoOBhg8fTm3btnWqfUcICAig5cuXS/FMRHTixAmKjY1VlN2+fbvkSET0+eefa24nLCyMtmzZQq1atZLl9OTkZOrQoQMdO3bMldmQ0bFjR6kNk6+eH3O0lrPG3r17pdg2GAz02Wef2Sy/Y8cO6XeDwUADBgywGgf2eO2116hhw4aS66NHj+jgwYOKcjExMUT037Y5ceJEqlixotV6ixcvTtOmTZPttwwGA/Xq1YsqVKjgkGPDhg2pWbNmkuPdu3fp6NGjREQUEhIilbt9+7ZD9eqBad9iL85FyuumOt31GIlIjGNOUY7fiYiSkpKI6Nl6t9YfyUwKFCgg+zsxMVG1nPn35svXUXx9fWndunVUrVo12X76+PHj1K1bN8rIyHC6bhMRERG0Y8cO+uKLL8jb21v6/vz589SwYUMaPXp0lvc9zfH395d+1+Jhuf0EBga61L6vr6/Nv008fPhQ+t38uM4e5rmBiGTHN46QK1cu2d+PHj2S/V20aFEiehZnR44ccTpenWX9+vWyv631f8PCwojomefx48c1H59Yo1ChQvT7779TUFAQEf2Xh+bOnUtfffWVS3VbEhkZSYcPH6Z33nlH1tY///xDNWvWpGnTpunanhaqVq0qLcNr167R3r17bZZv2rQpEf3Xb3TlHBYR0apVq2R/Fy9eXLWc+Xr/559/NMV6WloaHT58WNYXcvb43HI6k48ayEPP0DMPEbl3LkIe0oa9PKTWHvpEntEnEqE/RCROnwh56Bme1B8iQi7SipZchDyUOXnIVK875iLkIW0gD6mD/tAzRMhDIuQgS/bs2SPtk4mIJk2a5FTbzlCnTh3q0qWL1DYzS2OBLDl+/Lh07iVXrlzUvn17h9oqUaIEbd++nUqWLCn7/vTp09ShQwdKTU11Yg6UHDt2jHr37i27nmv62apVK1q4cKHTn5o1a0rtGAwGu+UXLFhg1TM2NlZyK168ONWpU8fmfJnGs5jmq2/fvk4vI19fX+rXr59sf3bkyBHVsrt375Y8vby8aNSoUXbrHzZsGPn4+Mi+c8bXYDBQjx49ZJ6HDh1SLYuxCp43VkGEcQpE7jtWwRIRchHyEPKQO+chxBBiCDGkBDEkBzEkBzFkH8SQHMSQHMSQfRyJIZBFMAA5iNTUVB41ahR7e3vLnpzh4+PDo0ePtvumTj2fXtu2bVtZXceOHXOpPhPmT6Uwf7qf5VtFLZ9cYY2ePXvKPJcsWaKLpxYSEhKkN9Sa2j937pxqWfM3DQUHB2t66nRqaqrs6dFGo5H/+usvp1w///xz2XJasWKFarlu3brJyu3Zs8dmvadPn5atT2tvrtJKp06dZO3v3r1b87RJSUk8ZMgQxVNnAgICeOrUqZrq0DOGKlSoIHnkzZuXMzIyXKqPmfnIkSOyJ7SbPC3fnMzs2BO1GzZsKJtvV99s5SiWb+3dsmWL7P+WT5l3dTszce7cOdnbtUz1DxgwQFbOkWVpj2+//ZaDgoIUbfbu3ZsfPnyoOk1mvAl63bp1svkqUqSI3Sd5d+zYUfIIDQ11+inlpjefmdouVaqU1bLVqlWTyvn6+mp6UtX9+/dlT9QyGo38yy+/OOX6zjvvyJb92rVr7U5jHvv+/v58584dp9p2lvfff9/u/r5UqVKyde8MKSkpUuyab89Fixbl69ev25zWkZhauHAhBwcHK6Zp3bo1nzp1ii9fvuzUp3Xr1rLlpGUaW5jeJGkwWH+qtTkDBw50KN/aY968eXb3kxUrVpQcc+XKZfUpzOakpaVxSEiIbNn/8ccfTjnOmTNH5rh8+XJmlse5v7+/y29AcJQBAwbIvKKjo1XLiZTXLXG3YyRmMY45RTl+Z8bbbC1jSO+32eJNtkpyyptsLfPxmDFjnGrHGf7991+pX2AwPHsjh7X5tDzvsWnTJl0coqOj2cvLSxFDixcvlpXTqz/0559/cpEiRRT1NWnSxO5TRvWMH9Nxk8mhbt26ds+31apVSypfoUIFq2+Hs8fBgwelZW7qV1mrq0ePHrJ5Xrhwod36Ld+mYTQauX///k65lixZUlbPqVOnrJZFHvK8t6ojD2lD6xvV0SfyvD6RCP0hZnH6RMhDntcfYkYu0oqWXIQ8lPl5iNm9chHykDaQh2zjyf0hZjHykAg5yJJ8+fJJy7VixYpOtesKpjfo2nM2f8t2w4YNnW4vNjZWNY569OhhczpH42nlypUcFhammK5nz5784MEDp9z1jCc/Pz9pGbRs2dJuecs3q9+6dcul9rdu3SrLc5MnT1YtV7hwYWn51axZU3P9lm+lunLlilOemzdvlnnOnTtXtRzGKnjeWAURxikwu+9YBUtEyEXIQ8hD7pyHEEOIIXsghhBDJhBDz0AMaQMxpAQx9AzEkDa0xhDIGvAmaJCj8Pb2pvHjx9P27dspIiJC9kToL774gurUqUOnT5/OEpf69esT0X9P7hg/frwu9Y4dO5a6d+8uezLIo0ePqEWLFnTmzBmH62vZsqVUDzPTu+++S5cuXdLF1R5vvfWW7M2kzz//PJUpU0a1bPXq1aV5fvz4MS1dutRu/cuWLaPHjx/LvrP3tlZrLFy4UPYmoEqVKqmWa968ORH9tzzfe+89Sk9Pt1pv+fLlpSeyMDN9/fXXTj/h+dChQ7R27VrJM2/evFS3bl3N0/v5+dGMGTPojz/+kJ4abjAYKCkpiYYPH04vvvhilr7l2PRmd6JnT1revHmzy3VWrVqVfv75Z9kTdZiZRo4cSUuWLHG63gYNGkj1ERF9+OGHLrtqZdOmTfT7779LbQcGBko+Jho3biz5MTONHTuWbt686XLbZcqUoZUrV0pPEDfV//3330tvKtObQYMG0aFDh6R9gqnNpUuXUpUqVWjr1q2Z0q4lrVu3lt44ZjAY6MaNGxQVFWXzDQqffvqp9Dbo+/fvU48ePWzuH9TYu3cvDRgwQPak1q5du1ot/8ILL0hxlJaWRlOnTrXbxtdffy09dd20XS1atMghTyKip0+f0pIlS2T7ztq1a9ud7urVq9LvVapU0fT2aD2xfFNdXFycoszdu3elMuXLl3eqHR8fH/r111+pcePGspx+/fp1at26tSJ/OUufPn3o6NGjVL9+fWmbISL6448/qEOHDnTz5k167rnnHP5YPmVfyzS2MD1R32Aw2C1rXt6E5ds0HMX0tGPT8lGLZdObXAwGA1WvXl3xlDA1vLy8ZMcwRM+OafRwvHPnDhHJ4zwlJYWmT5/uVP3OcOHCBVmcG41Gq8ceIuV1S9ztGIlIjGNOUY7fifA228x+my3eZKskp7zJtkuXLkT03zqdOHEirVu3zqm2HOHevXvUpUsX6S1MBoOB6tevb/VNu+b9NWamUaNG6fL01qioKJo8ebLsWI6ZqV+/fk7vu2zRrFkzOn78OHXt2lXWF9q+fTtVrlyZFi5cqHubanTt2lXabxARHThwgPr3729zmtGjR0vOZ86coU8++cThduPj46lHjx6UkZEh1dW2bVsyGtVPb7/44otE9N96+eCDD1TfnGLi6tWr9MEHHyiOKxYuXOjw+bYffvhBdm4tPDzc5vEq8pDnvVUdeUgbWt+ojj6R5/WJROgPEYnTJ0Ie8rz+EBFykVa05CLkoczPQ0TulYuQh7SBPGQbT+4PEYmRh0TIQZYkJCQQ0bPlVKJECafadQXT9T3T/FteyzNh/r0r14GLFy9OmzZtkt6ca9q2f/nlF6fOPVmjc+fOdPz4cWrevLnsnNyyZcuocuXKuuRUVzA/N6b2VnNLLK/xOvKmczUs39RuLceZX18vUqSI5vrDw8NlfxcsWNAxwf/HcluzNq4DYxU8b6yCCOMUiNx3rIIlIuQi5CF9QR7ShtY8hBhCDNkDMfQMxBBiyARiSBuIISWIoWcghrShNYZAFqHxZmkAhOPx48fct29f2ZMzDIZnT4SePn266jR6Phnj9OnTiqeDzJw506U6TSQlJfELL7ygeCJj/vz5pac9Wz4xxBrJyckcHh4uqyc8PJy3bt2qi6saT548kZa1uaO19cLM/P3338vKh4aG2nxS45UrV2RPZDZN5+vry6dPn3bI17LtQoUKWS378OFDzpUrl2y++vXrZ7N+8zfKGo1GHjlypEN+zMy3b9/mMmXKyLbfPn36OFyPiXv37klPMjePn+DgYF6wYIHV6fSMIdNTJM2f3KLlSZZamDZtmiJ+fHx8ZG+71RpDzPKnuJt+fvDBB7q42mLfvn3SU6hN7Xbr1k1RTi3Oq1atavdtYVr58ccfFbFmNBq5Xbt2fP/+fYeffKSFtLQ0Hj16NHt7e8va9fLy4qFDh3JSUpJUNjPeBM3MvHTpUkWMlC5dmnft2mV1mvHjx8u2vaZNm9p9gzTzs6fvT5s2jQMCAmRthoWF2Xy782+//SYr7+Pjw+vXr7da/o8//pDeAm0+X0ajkdesWWPX0xzTG8hN9Tz//POapjNvv127dg61qQeHDh2SraOJEycqyvj6+kr/79Chg0vtPXr0iCMjIxVx0qpVK6tvtXMmpjIyMnjChAkyd9M28cknn2h6C4Q5eseV+RtDWrVqZbe85Rvuk5OTXWr/4MGDsvU+bdo0RRln13uHDh1kro4uaxOW2+aECROYmfmvv/5SxLmWt667yt27d7latWoyJ1tvQxApr9vCHY6RmMU45hTl+J0Zb7PNyrfZ4k22Oe9Ntqa3nplvw+PGjeOnT5861aY9Dh8+zGXLllVsr+vWrbM6TXx8PAcEBMjK9+zZ0+mcbIlpH2LZL5kyZQoz65eDzFm8eDHnyZNHUXf79u1V+xd656ExY8Yo2u7UqZPNvomlw9ixYzW3d/DgQSn/mOcHW2+sevjwIefJk0e2XooWLar6FrNNmzZxsWLFZH4FCxaU/i5btqymfhsz8/79+xXb2+DBg21OgzzkeW9VRx7ShtY3qqNP5Hl9IhH6Q8zi9ImQhzyvP8SMXKQVLbkIeShr8xBz9uci5CH7IA9pxxP7Q8xi5CERcpAlprd92ssJmYXlW3FmzZqlWs70Zimj0cgvv/yyy+3u2rWL/f39FXG0aNEi1fKuxNPMmTM5MDBQ0dbgwYM5MTFRcz16xlPx4sUll8qVK9stP3HiRFnbcXFxLrUfHR0tq+/HH39ULRccHCwtt+bNm2uuv3nz5rL6Hz586JTnpk2bZNvnjBkzVMthrILnjVUQYZwCs/uOVbBEhFyEPIQ85M55CDGEGLIHYggxZAliCDGkBcSQdRBDiCEtaI0hkDXgJmiQ41mzZg0XKFBAkXRefPFFxSvt9R5E0KJFC0W7Q4cOtTkoVCv37t3j559/XtqZmtrw9/fnSZMmOZRkf/75Z9mO2fyk5urVqx1KrLa4du0aT5kyhYsWLSprx2g0cqVKlWxe2BJp8KoIg4G1kp0Dq0UbqK52Y/+LL77I+/fv18XXnOTkZP766685MDBQsd5PnDihOs2XX36pmN+QkBD++OOP+ciRIy47TZkyRXU/onYhXU/27t3LpUqVUrRRoUIFPnjwIDNn3k3QzMzdu3eXtW36vUOHDrxlyxbVC0PmNwcbjUYOCQnhESNG8N69e2Xb98OHD3nPnj38/vvvc7FixWTzZ/r5/fff2/RLT0/nUqVKydaLr68vjx49mm/evCmVu3r1Ko8cOZL9/Pxk81GrVi3p79y5c/P27ds1LZfp06crXCdNmqRp2rCwMMm3bt26mqbRE8tOldoyNh8I1KhRI5fbvHHjhpQbzZfZwIEDVcu7ElOHDx/mChUqKOqoXr26Q3lD77gqV66c5FO8eHG75WfOnClr/8KFCy61/9NPP8nqW7ZsmaKM6aETjp7kady4saxua4Oo7LF27VpZPbNnz5b+hxvQsv4GtOy++YzZ/Y85RTp+x4Bl3DhjNGLAsr22rQ1YPnjwoOIhOkajkUNDQ3nIkCG8efNmfvz4sUNtWxIXF8dLly7lqKgo9vLyki0/o1HbYLS33npLsQ3XqlWL//zzT5fcmJ8N4OrcubNqf6h169aZ1h+KjY2VjjPM6y9QoAD/9ttvsrJ656Hk5GSuUqWKYn7Dw8P566+/5oSEBMU0CQkJXLduXZlHvXr1eOPGjarng1JSUjg6Opq7desmrXfztoYNG2bXc9y4carrpUKFCty9e3fu0qWL1F8yr9/f35+3bNki+65YsWKqOcxEamoqT548mf39/RW50vL8oyXIQ7hxBnnIftv2HmqDPpHn9YncvT/ELE6fCHnI8/pDzMhFWnAkFyEPed7DoZCHrIM85Die1h9iFiMPiZKDzDHlBpOvXvt4rXz66aeyZbty5UrVcqVLl5Y8tVwT1ILpOp/lst+yZYuirKvxdPr0aa5Ro4ainnLlymkeG6JnPJnGpZly76VLl2yW37Vrl6b1pJW3335bVt/mzZtVy5UoUcLhbZqZuXDhwrLlfOjQIac8Z82aJfNcunSpajmMVfC8sQoijFNgdu+xCuaIkIuQh5CH3DkPIYYQQ4ghdRBDtkEMIYbsgRiyDWIIMWQPrTEEsgbcBA08glu3bnGbNm1kCcNgeHYDoPmTOvQeRHDs2DHVp4Pkzp2bO3TowBMmTOCffvrJ6fqvXr0qu7nNvA1Hk6zlTXnmv/v5+XGdOnX4f//7H0+ZMoWXLVvGMTExfPDgQT516hSfO3eOL1y4wGfPnuXjx4/z3r17eePGjbxo0SL+7LPPuGfPntJJQ/Plb36gpOUmTFEGr4oyGFgr2TmwWqSB6rdu3VK8bdn0e5UqVXjUqFG8ceNGvnHjhsOu6enpfP78eV62bBm/+eab0oUXS0dbF3vT0tKkbcwyDo1GI/v7+3O9evUcdjNnwoQJiuVpGe96bBeWPHnyhN98803FvPn6+vK4ceMUTzbVk6SkJG7WrJnV/WdoaCi3bNmSR4wYwbNmzeKVK1fyhg0buH379orlYvrkzZtXuvCvtt80fd59911NjsuXL1f18/Ly4oIFC8ou5Jk7FSxYkC9evCi9bdu0TEePHm31aUiHDx/mqKgoRV2hoaGab34xDRgz7b/v37+vdXXowoABA2TLOzo6WlGmQoUKkmPevHk5IyPD5XaPHDkie8qwqX21m8ddjamkpCQeMmSIYvsKCAjgqVOnaqpD7/29acCNqb49e/bYLH/69GnZdm3vgQD26NSpk6z93bt3K8qYXwANDg7WdJInNTVVWq+mum0df9ji888/lzmuWLFC+h9uQMueG9Cy8xiJWYxjTlGO35kxYJkZN84YjRiwbMLRActLly5VvLXIfFvy9vbmsmXLclRUFPfv35/HjBnDU6ZM4dmzZ/P333/P8+fP57lz5/LMmTN54sSJPGLECO7Tpw+/9NJLXKRIEcVxsfnvNWrU0HS8ePfuXVld5o758uXj5s2b85AhQzQtHzVSUlI4KipKdZ+Xmf2hjIwM/uqrr9jPz0/Rbp8+ffjRo0fMnDl5KDY2VjE4zlR/YGAgt2/fnr/88kveuHEjnzhxgu/cucM3b96U+kLmyypXrlzcoEED7tixI0dFRXFkZKTqsbHp90aNGmnaP6elpXGDBg1U+6lqf5t+jho1ipmZX3zxRcX/6taty1988YXUt/vhhx944MCBVvvpH330kabliTyEG2eQh/7DmYfaoE/keX0iEfpDzOL0iZCHPK8/xIxcZAtHcxHykOc9HAp5SAnykGt4Wn+I2f3zkCg5yBzLN5YvWbJE03R6kJCQIJ17M7V/7tw51bJt27aVeR47dkwXB7V9XkhIiGIskh7xlJqayqNGjZKuo5vq8/Hx4dGjR9t9s7me8WT5MPzevXvbLJ+eni696cmUp53l5s2bsuug/v7+qjmQmblVq1ayed66davd+rdt26ZYX5999plTrvXq1ZO1v3fvXtVyGKvgeWMVRBinwOzeYxXMESEXIQ8hD7lzHkIMIYYQQ+oghuyDGEIM2QIxZB/EEGLIFlpjCGQNuAkaeBRz5szhoKAgxUm7Dh068O3btzNlEMG3336rSIrmf1etWtWl+q9cucJly5a12oYj8zJ06FDVeiydnfmo1WMwGDgsLIwPHz6syU+kwasiDAZ2hOwaWC3aQPWjR4/Knr5pLX5y5crF5cqV40aNGnFUVBR369aNX331Ve7Vqxf36NGDO3fuzC1atOA6depwREQE+/r6qsaT+d99+/a163f9+nV+/vnnrcZ5gwYNnF6WJr755hvZDRDOLktnWLt2LRcoUEDRnqWH3qSkpCgeJKG2ntT2i9b2t7b2vwaDgQcNGuSQo9rgCWvtmH6anlTUr18/xf8CAgK4WbNmPHjwYP7www+5Z8+e0sU2tXVu7Wm1tlxN044ZM8aheXWFf//9VzpOMBieDbRRexKuZWd/06ZNurQfHR2tuIHIaDTy4sWLZeX0iqk///xT9W3tTZo04djYWJvT6r2/nzdvnsyjbt26djvztWrVkspXqFBB9c3rWjh48KC03A2GZzftq9XVo0cP2TwvXLjQbt2LFy9WLN/+/fs75VmyZElZPadOnZL9HzegZc8NaNl58xmz+x9zinT8jgHLuHHGVC8GLDs3YHnVqlUcEhJi85jT2nGxrY+1OgwGAzds2NDmwFhLduzYodivmddbu3ZtzXWpkZKSIm2ntvZxmcHRo0e5UqVKirYiIiI4JiYm0/LQlStXODIy0uZ+3tp6VVsHWtZ77dq1rV74UOPOnTuyB4LZ8jRtV6YBZIcOHVLN8ba2VfO/X3rpJc2DEJGHcOMM8pDrD7VBn8jz+kTu3h9iFqdPhDzkef0hZuQiNVzJRchDnvdwKOQh5CHR8xAzzs3lpId8MjMvWbJENm1oaChfvHhR07Su0r17d1nbFStWtFrWcoBtt27ddPMwXcszX2fh4eGyt3HrGU+7d+/mkiVLKuqsUaOG4jqeOXrG0+XLlxXb6Lx582xOM336dFn7v/76q8PtpqenS4OQTe23adPGavlJkybJllPVqlU5KSnJavnk5GSuXr26Yn2GhYVZfWC7NXbu3ClrO3fu3FavQ2OsgueNVRBhnAKz+49VMCFCLkIeQh5y5zyEGEIMIYaUIIa0gxhCDKmBGNIOYggxpIYjMQSyBtwEDTyOc+fOce3atRUJIzw8nMuVK6dbUjBn9uzZqjcFGgwGbtWqlcv137lzh+vXr6/YUTuTZFeuXCk9pdbc19zZmY9aPe3atXP4rbiiDF5lFmMwsKNkx8Bq0QaqX7hwQbHercWPre3AVsyZ/9/Ly4tHjhypedu8d+8et2nTRtVBr85AdHS07Mnhltt2ZnL79m3pSU+urktH2bJli7Tutax/rduBZYfK8iKTFjIyMnjIkCGat7v33ntPmvbmzZtcqFAhu/sxa9uoeV1a+Ouvv2TrzMfHh9euXevwPDvK3bt3uVq1ajL/xo0bq5adM2eOzLFmzZqckpKii8e0adMUy9DHx4d/+eUXqYye2/S9e/ekpxubr8fg4GBesGCB1en03t8/fPhQegO6qc5+/frZnGbdunWyZTVy5EiH2719+7b05H9TXX369FEt+/3338uWU2hoKF++fNlq3VeuXOECBQoo4sTX11d2YkQLlm0XKlRItRxuQMu+G9Cy6+YzZvc/5hTp+B0DlnHjjHn9GLD830+tDxO4dOmS4q0FtvYr9j7Wpg8NDeVp06Y5NbDowIEDXKhQIdX627dv73B9lmRkZPDw4cOt+mdGDjKRnJzMw4YNU7Tp5eXF+fLly7Q8lJKSwqNHj+agoCC7ucTWOtay7vv27ctPnjxx2PHp06c8bNgw9vX1tRo/BoOBe/Tooaj/+++/17QtW/6/WbNmDl88QR7CjTPIQ67lIWb0iZg9r0/k7v0hZnH6RMhDntcfYkYu0jsXIQ953sOhkIeQh0TPQ8w4N2cLkXIQ87NzQ+Hh4TK38PBwTW/HcZYnT57I9vumn9OnT7c6zenTpxXrZebMmbr4JCUl8QsvvKBYR/nz55ferqp3PD1+/Jj79u2r2LcHBARYXQ56x9Orr74qa9/Ly4u//vprq+VTU1O5cuXKUvnAwEDesmWL5vYePXoknQc2X5br16+3Os2lS5ekt1yZyr/88st8584dRdn4+Hhu3ry5bD2azusZjUaOiorSnF/i4+O5WLFisnY7depktTzGKnjeWAURxikwizFWgVmMXIQ8hDzkznkIMYQYQgwp60IMaQcxhBhSqwsxpB3EEGJIrS5HYghkDbgJGngkaWlpPGbMGNUnCuuZmMzZv3+/7Km0Wk+caSU1NZWHDRtm9Q2sjvD06VOeNm2a7KZw8+Xj6Me8Dj8/P+7WrZt0MOAMogxeZRZjMLCjZMfAatEGqqelpfE333wjvZXYVvxoWf/WpmnWrBkfPHjQqXneuHEjN23alL29vaX6hg4d6lRdaly5coVbtmwpm5/M2LdaY+7cudKFiszct6sRExPDPXv2lG4Ed2Y/ajldpUqVrD713BHWrl3L5cuXt7rdhYaG8ty5cxXT7du3j0NDQzXvm0zfffrpp055VqtWTVaXt7c3jxs3Tve33Js4fPgwly1bVrGtrFu3TrV8fHw8BwQEyMr27NlTGhjkKmpv7vby8uIpU6Yws/4daeZnTwE2f3iB6Wf79u359u3bivKZMdhlzJgxivY7depkcxCfpcfYsWM1t3fw4EHpwqKpTV9fXz558qRq+YcPH3KePHlk66Vo0aKqT+7ftGmT9FAZU/0FCxaU/i5btqzqclVj//79iu1t8ODBVsvjBrTsuwEtu24+Y3b/Y06Rjt8xYBk3zljOr611quV4SG2d59QByyb++ecffuuttzhv3rwuxY/5dF5eXly3bl2ePXu2y8fECQkJPGLECA4ODpZ5DRw40KV6zVmzZo2U+7MiB5nz119/cfHixRXbaGY7xMXF8ejRo7lo0aIu7zPNvb29vblDhw68f/9+lx1jY2N58uTJ3LJlS65UqRKXLFmS69aty++8847N+lesWKHaH1JzDggI4I8//tjpJ78iD+HGGeQh1/MQ+kSe1ydy9/4Qszh9IuQhz+sPMSMX6Z2LkIc87+FQyEPIQzkhDzHj3Jw1RMpBzMw///yzoh6j0citWrXi1atXc2JiosPrSI1r167xlClTpJvYzdusVKmS3fMiLVq0UGxrQ4cOdSgerXHv3j1+/vnnFcvX399f8eYgPbflNWvWSONDzOt/8cUXFW/z1jue4uLiODQ0VLHemzVrxkeOHFGd5ty5c5w/f37Jw9vbmz/66CO+e/eu1Xbu3bvHs2fPlg0ANrUVFRVl1/O1115TLJ+8efPyoEGD+LvvvuNZs2Zxv379OCQkRDEvM2bMkG1nrVq1sunK/GyMg+W1YKPRyHv37rU5HcYqeN5YBXcfp8AszlgFZjFyEfIQ8pA75yHEEGIIMfQMxJBzIIYQQyYQQ86BGEIMmXA2hkDmg5uggUdjuXOy3OFlBrt37+ahQ4dy5cqV2c/Pjz/55BNd69+zZw/XqVNHSgyuzsvhw4d54sSJ3KZNG46IiJAlHS2f4OBgaUDpqlWrpCcF64EIg1dNiDAY2FGyemC1iAPVk5OT+eeff+Z27dpx7ty5rcaJrXVs+alcuTJ/9NFHfOrUKV3mOT4+nletWsWff/65zafoOMvGjRu5SZMmuh5wa+X8+fO67g8dJS0tjffs2cPTp0/n119/nevXr89FihRhPz8/q+vXx8eHCxcuzA0aNOA333yTf/jhB/733391d/v777/5yy+/5MGDB3Pfvn35o48+4lWrVtm8cHfu3Dlu3LixzW3X9H2VKlV406ZNTvsdPHhQ9UEloaGhPGTIEN68eTM/fvzY6fqZn+2Xly5dylFRUezl5aWYp3bt2tmc/q233lLs82rVqsV//vmnS17MzwaJde7cWXVf1Lp160zb18bGxkrr2Lz+AgUK8G+//SYrmxmDXZKTk7lKlSqKeQ4PD7f6EICEhATZQ2aMRiPXq1ePN27cqJq7U1JSODo6mrt16yatd/O2hg0bZtNx3LhxquulQoUK3L17d+7SpQuXKlVK9j/TSZAtW7bIvitWrJjqRUkTqampPHnyZPb395dN5+vrqzixoQZuQMu+G9Cy6+YzZvc/5hTl+B0DlnHjjCPr21pZa+s9pw9YNic9PZ337t3LkydP5j59+nCdOnW4WLFiNo+HjUYj58mThytUqMBt27aVjlPj4+Od9rBGUlIS//bbb/zOO+/wyy+/zLNmzdK1/ocPH6rmuqzgwYMH3KNHD9X1mhUOf//9N0+YMIHbt2/Pzz33nOx4297Hy8uLS5cuzT179uR58+bxzZs3M91XC3fv3uVPP/2Un3/+eVXv559/nkeMGMFXr151uS3kIdw4gzykTx5Cn8jz+kTu3h9iFqNPhDzkef0hZuSizMhFyEOe93Ao5CHkIdHzEDPOzVlDtBw0aNAg1X2v0WhkPz8/rlOnDv/vf//jKVOm8LJlyzgmJoYPHjzIp06d4nPnzvGFCxf47NmzfPz4cd67dy9v3LiRFy1axJ999hn37NmTy5Urp5gX0++hoaFWB8iac+zYMfb391c45s6dmzt06MATJkzgn376yan5Z2a+evWqdL3Oso3MzAe3bt3iNm3aKPJPSEgIL1q0SCqXGddZ//rrL6s33Tdo0ICnT5/O+/btk40HOHnyJJcsWVJWPjAwkFu0aMGffPIJz5gxg6dMmcLDhg3j5s2bs6+vr+p6L1y4MMfGxtp1vHPnjtW3v9uK5S5dunBGRgaXLl1a5ponTx4eOXIk7969m+/cucOJiYl8/vx5/uWXX7hdu3bs4+OjWN9t27a164mxCp43VkGEcQrMYo1VcPdchDyEPOTOeYgZMYQYQgwhhhBDjoIYQgwhhlwDMaRvDIHMBTdBA4/nyZMn/L///U81WWc26enpLp8Ytcb27du5f//+XL58ec6VK5du9SYmJvKFCxd49+7dHB0dzStXruSffvqJFy9ezMuWLePVq1fzX3/9xUeOHNH81MDsICsHr1qSkwYDZ8fAalEHqqempvLff//NixYt4hEjRnCvXr24WbNmXKNGDa5UqRKXKVOGS5YsyeXKleMqVapww4YNuUOHDjxo0CCeOnUq//HHH3znzh0d5jB7iIuL4+XLl0tPh80q0tPTecWKFbxo0SLp4w48fvyYb9++zdeuXeMrV65wXFwcP3jwILu1NLFjxw4eOHAgV6tWjfPmzcs+Pj5coEABrlKlCg8cOJA3btzo8FPJ1Vi6dCl7eXlZ7bB4e3tz2bJlOSoqivv3789jxozhKVOm8OzZs/n777/n+fPn89y5c3nmzJk8ceJEHjFiBPfp04dfeuklLlKkiOo+y/R7jRo1+P79+zb97t69K6vH3C9fvnzcvHlzHjJkiNPzn5KSwlFRUarHJ5nZkc7IyOCvvvpKtUPbp08f6WEmmfXE/9jYWKsd1cDAQG7fvj1/+eWXvHHjRj5x4gTfuXOHb968ye3bt1dsI7ly5eIGDRpwx44dOSoqiiMjIxVvaDD/vVGjRnaf4J2WlsYNGjRQTGvtb9PPUaNGMTPziy++qPhf3bp1+YsvvuCVK1fyhg0b+IcffuCBAwdyWFiY6vr+6KOPHFqmuAEte25Ay+6bz5hz1jEnc/Ycv2PAMm6ccWZ9q617TxuwrIWEhAS+c+cOX79+XToevnfvXqa2mV0kJCTwsmXLeMCAAZqeXqonP//8s2IfllV5yJzk5GQ+f/4879mzh3///XdesWIFL126VDqXtGbNGt65cyefO3eOU1JSstzPUe7fv89Hjx7l3bt386lTp3R5orAayEO4cQZ5SJ+cgD6RZ/aJclp/iDnr+0TIQ57XH2JGLsqMXIQ85JkPh0Iech3kIc/rDzG7fx4SKQcNHTpUse3osUwt6zL/LiwsjA8fPqzZ8dtvv1V1NP1dtWpVl5bBlStXuGzZslbbyMxtec6cORwUFKSI3Q4dOvDt27cz7TrrH3/8wcHBwap5z/wTFhbGlSpV4tq1a3PlypVVY93Wujf/O3/+/A49wP/vv//m/PnzW92mLOsvUqSIlAtXrFih2dVy3g0GA0dERNh905MJjFXwvLEK7j5OgVm8sQrunouQh5CH3DkPMSOGEEOIIcRQVc3zqgZiCDGEGKqqeV7VQAwhhlyNIZB54CZoAP6f6OhorlChAkdEREgf4Blk1eBVa+SEwcDuMrBaT7JzoDoA4BmrVq3ikJAQ3TvTtjo9DRs21JwHduzYobhYZV5n7dq1XZr/lJQUqcOa1R3po0ePcqVKlRRtRUREcExMTKZ1pJmfnUCIjIy0eZLCVqfT2vZha73Xrl1b86CnO3fuSE91ttVJN9+mUlNTmZn50KFDVp+YpqXT/9JLL+nykAETuAEt83GnY6SccMxpIquP3zFgGTfOYMAyEJlr167xoEGDuE+fPtIHiAXyEG6cQR7KPNAnynzcpU+Uk/pDzFnbJ0Ie8sz+EDNyUVaAPJQ1uEMuQh5yHuQhz+wPMee8PJQdOWjlypVcrFgx1WtRWpeltRizrKddu3Z848YNhx1nz54tu9HUvM5WrVq5vAzu3LnD9evXl3mbfs/sbfncuXNcu3ZtRXvh4eFcrly5TIvpCxcucMOGDRXry9b6tLZe7a37ChUqODRY2XzZ1KhRQ7Ve8/ZLlSqlqL9fv36a5suyTNGiRfn48eMOeWKsgueNVXD3cQrM4o1VcPdchDyEPOTOeYgZMYQYQgwhhlwDMYQYQgy5BmIIMeRqDIHMATdBAwAA0AUMrAYAZAaXLl3iTp062e2wONOBNp8+NDSUp02bxunp6Q75HThwgAsVKqRad/v27V2e/4yMDB4+fLhV98zsSCcnJ/OwYcMUbXp5eXG+fPkyrSPN/Oyi6ujRozkoKEhzJ9nWSRJb675v37785MkTh/yePn3Kw4YNY19fX5sd/h49eijq/v777zVtx5b/b9asGT98+FDPxQyyCBwj5WwwYDnzcYfByswYsAwAcE+Qh7IGd8hFyENAZNAnyrkgD2U+7pCDTCAXAZFBLsqZIA9lDe6Si3JSHsrKHPT06VOeNm2abICs2jUzrR/zOvz8/Lhbt268e/dulxz3798v3dBn7tevXz9dlkFqaioPGzZMdWB0Zm/LaWlpPGbMGPbx8VG0m9kOa9askQ1cdmW9W67/8PBw/uqrrzg5Odklx59++onbtGnDgYGBMsfKlSvzV199xYmJiYpp0tPTefDgwZrmyVSmfv36fP36daccMVbB88YquPs4BWbxxiq4ey5CHkIecuc8xIwYQgwhhhBDroEYQgwhhlwDMYQYcjWGgP4YmJkJAAA8jCtXrii+K168eDaY2EYETxEcicTxBACoc+TIEZo9ezatXLmSHjx4IPufwWDQXI/5oa/RaKRatWpR7969qVevXpQrVy6n3B4/fkzjx4+nOXPmUEJCguTUv39/mj17tlN1WrJ27VoaMGAA3bp1S5pfZiaDwUDp6em6tGGNmJgYeuONN+jq1atkMBikZWj6PTMdbt68SbNnz6aFCxfS9evXpe8dWefmmNy9vLwoKiqKRo4cSbVr13ba78qVK7RixQr666+/6Nq1a5SYmEgFChSgWrVq0WuvvWa17l9//ZUGDhxI9+7dszkvzEz+/v40bNgw+uyzz8jLy8tpVwAAEJnr16/ThAkTKDExUfpu4cKF2WgEMpsdO3bQ5cuXpb979+6dfTI2gKe+wBO4M9euXaMJEybQ06dPpe+QiwAAAGQF6A8BAADIbpCLcgb//PMPbdq0iXbt2kUnT56kK1eukCNDBnPnzk0VKlSgWrVqUZMmTahZs2aUO3du3fz27NlDK1asoJiYGDp37hwNHz6cPv/8c93q37t3Lw0bNowOHDggfZcV11mJiPbv30+9evWif//9V3ZdMCuu9Z4/f57Wrl1Lmzdvpr///ltxnV0rhQsXphdffJE6dOhA7dq1Ix8fH1097969S4mJiRQWFkYBAQF2y2/dupU+//xz2r59u+p2bDAYqFatWvTBBx9Qly5dXPbDWAXPG6vg7uMUiMQcq+DOuQh5KHNAHtInD5lADCGGEEOugRhCDCGGXAMxhBhCDAF3ADdBAwA8EqPRKDsQMBgMlJaWlo1G6ojgKYIjkTieAADbZGRk0IEDB6SO9OnTp+nGjRt0+/ZtSklJUZ3GYDBQcHAwFS5cmEqVKkUVK1akWrVqUaNGjSgsLEw3t+TkZNq4cSPFxMTQqVOnqGPHjvT222/rVv+jR49owoQJiguYWdGRfvjwIQ0cOJCWL1+e5R1pEwcPHqTNmzfT/v376ciRI3Tt2jXKyMjQNK3RaKQSJUpQnTp16MUXX6SoqCgKDw/PZGPb3Lt3j2bNmkXLly+nM2fOKP5fvnx5ateuHQ0ePJiKFi3qUlv3798nIqK8efO6VI8alg8ZceUBIyJ4iuBoQgRXERwBANlD165dafXq1dLfWXGs4Qzw1Bd4AgDcgcTERNqzZw9dvXqV7ty5Q8nJyRQSEkKlSpWiatWqUeHChbNbkYjE8BTBkQieAAAAAADAM3n69CnFxcXRzZs36d69e5ScnEzJycmUnp5OPj4+5OfnRyEhIRQaGkqFCxem/PnzZ5lbRkYGPX36lIKCgnSve8eOHfTzzz/T9u3b6dq1a9I118wmMTGRhg0bRj/88EOW30RqzuXLl+nff/+ly5cvU3x8PN27d48SExMpJSWFMjIyyMfHhwICAig0NJTCw8OpZMmSVL58eSpSpEiWOTrCzZs3af/+/RQbG0uPHz+mvHnzUsGCBalevXqZci0YYxU8c6xCThunQJS1YxVs4a65CHko80Ae0hfEEGIIMeQaiCHEEGLINRBDiCHEEMgOcBM0AMAjMRqNsr+z+iBAKyJ4iuBIJI4nAMB5Hj9+rNqRDg4OzlFv0H38+DH9/vvvUkc6Ojo6y9petmwZvf3227InemXX/jQlJYWuXLmiqTMdERGh+9PD9OTBgwd05coVWUfalZtC79y5Q3PnzqXo6Gg6cuQIpaamEhGRn58fVaxYkdq1a0c9evSg0qVLu+xu/pARRx8wIoKnCI4iuYrgqBfJycl06NAhOnnyJN2/f598fX2pYMGCVKZMGapRo0aWuthCBE8RHIngqTddu3alVatWEZF7993gqS/wdJ07d+7Qli1b6MCBA3Tr1i26e/cuBQUFUVhYGJUrV44aNmxINWrUUJwjgae4niI4ZodnamoqrVmzhrZs2UJ+fn70zTff2J1m7dq1NH36dNq7d6/NY8fKlStT7969qW/fvpQnT54c7ymCIzxd8/zss8+k3xs0aEAvvfSS5mmzEhE8RXA0IYqrKJ6Zwd69e2n//v109epVevLkCYWFhVGhQoWoSZMmVLFixezWk4CnfojgSJR9no8fP6ajR4/S1atX6fr163Tnzh16+vQpJScnU1paGvn5+ZGfnx8FBARQgQIFqFChQlS0aFGqWLEiBQcHZ5oXPOEpgiNwL37//XcaMWKE7M3qly5dykYjoBcYq5D5uMtYhZw0ToFI/7EKwL1BHgLANRBDALgGYggA10AMAUBEDAAAHojBYGCj0chGo1H63R0RwVMER2ZxPAEAwN25du0aDxo0iPv06SN9gPswdepUDgkJkeU8y4/RaGRvb29+/fXX+ebNmy61Z6rP0dwqgqcIjiK5iuCoBzdu3OD+/ftzcHCwNK+Wn0KFCvG7777Lt27dyjIvET1FcIRn5tGlSxfZvsFdgae+eKrn48eP+e7du9LHGY4ePcodOnRgLy8vqzFu+hQpUoQnTJjA9+7dg2c2eYrgKJKnJd9++y3nz59fqrdGjRo2y587d46rV69u8zhV7bg1b968/PXXX+doTxEc4em6p/l5cx8fH545c6bT85iZiOApgqMJUVxF8bTFgwcP+NatW5yenm63bEZGBn/77bccERFhM2eWLFmS582bp6lOeGa9pwiOongePHiQP/jgA37++ec1HU9a+0RERHDv3r35l19+4YSEBF3c4OnZniI4AgBATgVjFQAAAAAAAAAAAM8FN0EDADwSUW6IFcFTBEdmcTwBAAAAZ0hJSeFevXpJec4871l+zP8fFhbG0dHRTrfr6I2mIniK4CiSqwiOajx+/Jh//PFH7tu3Lzdr1oxbtWrF7777Lm/dutXqNKtWrZJuMNVyc0Lu3Ll5xowZTs+jKJ4iOMJTf09X8dSbYTMLeOqL3p5dunSRcqGXl5fD03/yySfSoGstN8iZvMPDw3nVqlXwzAZPERxF8jTx9OlTbtmypaK9iIgIq9P8/vvv0oN67B2rWjtubdGiBT98+DBHeYrgCE/9PE3lzaft27cvJyYmap7HrEAETxEcTYjiKoqnJStXruR27dpxrly5pPgMCgri1q1b86ZNm1SniY+P5/r162vOm0ajkatWrcqXL1+Gpxt4iuAokueBAwf4pZdeUuQ3Vz6muoKDg/ndd9/l69evO+0HT8/1FMERAAAAAAAAAAAAAAAAcioGZubsfhs1AABkNUajkQwGAxERMTMZDAZKT0/PZislIniK4EgkjicAAADgDIMGDaLvvvuOiEjKd0TPcp45av8zGo302Wef0ccff+xwu6b8qjW3iuApgqNIriI4WvLNN9/Qp59+Sg8ePFD9f4MGDejHH3+kiIgI6bvVq1fTK6+8IrVjPj9qmObRYDBQ37596bvvviMvLy/NjqJ4iuAIT+c9P/vsM4f8HeGXX36h06dPSy5jx461O82YMWNUv4cnPPVGT08ioq5du9KqVauk+rTmrPT0dOrcuTNFR0fLYlcL5uUHDhxIM2fOtDstPPXzFMFRJE/TdM2aNaOYmBhZe8xMQUFBlJCQoJhm9+7d1KxZM0pKSlJMYw/Lc4x16tShLVu2UGBgoPCeIjjCU19P8/Pm5tOWLVuWli9fTlWrVrXbblYggqcIjiZEcRXF08S1a9fo1Vdfpd27dxOR9XMfb7zxBs2dO1fqaz169IheeOEFOnPmjDSP9jDVHRYWRhs3bqQaNWrAMxs8RXAUyZPoWd/pyy+/pPT0dJeOJa39z/T/oKAg+uyzz+jdd991yA+enuspgqMzJCUl0d27d+n+/fuUlJREqamplJGRQX5+fuTn50dBQUEUHh5OQUFBWeIDT3iK6AkAAAC4O+np6XTx4kW6f/8++fr6UsGCBSk8PFzz8WxWIIIjETz1RhRPIqK7d+/SkydPpL+LFy+ejTbqiOBIBE+9cWfPmzdv0oEDB+jWrVt09+5dCgoKorCwMCpXrhxFRka6RayL4EgET70RxRNYQePN0gAAkKMwmD1V1/S7OyKCpwiOzOJ4AgAAAI6yatUqWZ4z5bpSpUrxsGHDeObMmTx58mTu06cP58+fX7Ws0WjkIUOGONy2aVotuVUETxEcRXIVwdGc5ORk7tChg+ItHmpv9ShQoACfPn2amZlv3LjBwcHBqv5qH7V5/N///qd53kTwFMERnq57Wk6j98eam7UPPOEpoiez82+WHjBggNX4NRgM7OvrywULFuT8+fOzt7e3zVjv16+f3fbgqZ+nCI4ieTIzT5o0SbWOkJAQ7tatm6L8/fv3FcefBoOB/fz8uHfv3rxixQq+ePEiJyQkcGpqKt++fZv379/P06dP5xo1aiim0+oqgqcIjvDU19P8uFItXj/55BNOTk62O6+ZjQieIjiaEMVVFE9m5tOnT3OxYsVkjtaOIY1GI/fv31+atlu3blbzpp+fH4eHh7Ofn5/VnFmkSBGOi4uDZxZ7iuAokmd6ejr36tXLasyrfSxzXsWKFblWrVpcpkwZDgsLs1ne9He3bt04KSlJkyM8PdNTBEetPH36lFevXs1Dhgzh+vXrc3h4uGJ/YO0TGBjIlStX5u7du/NXX33Fhw8f1tUNnvAUxRMA4By7du3iESNGcPPmzblKlSpcpUoVbtmyJX/wwQe8Y8cOzsjI0KWdEiVKSJ+SJUvmOEd4eq6nsyxbtoybNm3KgYGBivyZJ08efuWVV/i3337LMh9RHeHpuZ7mdOnSRXL08vLKbh1VRHBkhqfeuJtncnIyf/3111y5cmWb/bjg4GDu3r077969G47whCdwCNwEDQDwSNQuPrkjIniK4MgsjicAAADgKBUrVpRym8HwbBDozJkzOT09XVE2OTmZ58yZozqo2mg08uDBgx1q27xde7lVBE8RHEVyFcHRnJ49e1odtGn5t8Fg4HLlynFiYiIPGTJE4Zw7d24ePHgwr1u3jo8dO8Znzpzhbdu28RdffCFbLub1z507N8d4iuAIT9c9zeMsuz+24hye8Mzuj7085MyNpr/++qtU3jxmS5UqxTNmzJAehmDOiRMneMaMGVyuXDnZtKbfZ82aBc8s8hTBUSTPhIQEDgkJkU0XFBTE06ZN48TERNVphg4dqthPNGrUiGNjYzXN57p167hgwYIK17179wrtKYIjPPX3VMuZltM///zzvHXrVk0OmYUIniI4iuYqimdCQoIij6kdi1q6//XXX7x9+3bF/8LDw3nSpEl87tw5WTtnz57lCRMmyM6dmOpu2rQpPLPQUwRHkTyZmUeMGCHzMf1eu3ZtHjlyJP/888+8adMmXr9+PS9evJjfe+89rlChgqx8qVKl+MyZM1Kdd+/e5S1btvDEiRO5cePG7OXlpTq/HTt21OQIT8/0FMHRHlu3buWuXbtyrly5bO4LtHzMpy9SpAiPGTOGr1+/Dk945nhPAIBz7N+/n+vVq6ca3+bfRURE8MKFC11uzzz/Go3azmeK4AhPz/U0cfnyZV68eDF/8cUXPGnSJF6zZg0nJCRYLX/+/HmuVauW3bxq+n+dOnX4wIEDrsyiEI7w9FxPPXD2wcFZiQiOzPDUGz0933vvPa5cuTJXrlyZq1Sp4vD0mzZt4iJFimju05livVmzZpqvg4ngCE/P9QRZA26CBsLx448/utUHnlnjqTfmCcqdD1BF8BTBkVkcTwAAAMARNm3aJLtg4uXlxdHR0Xani4+P56ioKNX8+OGHH2puX+vFGhE8RXAUyVUER3Os3bATGhrKderU4cqVK3NAQICi3tGjR3NYWJjsJFnr1q05Pj7ealsZGRk8d+5cDggIkLWVN29efvjwofCeIjjCUx9PSy9LR2v/0/pRO8Fsqy1rwBOe7uzJ7PiFydTUVC5durQi7keNGqX6oBE1ZsyYwf7+/jLPXLly8c2bN+GZBZ4iOIrk+d1338naDAgIsPlk5idPnki5zjRdmzZtODU1VZOjidjYWH7uuedk9bRr105oTxEc4am/p2XMjhw5UtEfM/3dqVMnvnDhgkM+eiGCpwiOormK4vn2228rvAICArhHjx48depU/uabb/itt97iPHnyyMo1bNiQO3XqJJvPtm3b8qNHj2y2d//+fW7evLli+di7GRye+nmK4CiS5/bt2xX9qMjISN63b5/N6ZiZ169fz8WLF5emzZcvH589e1a17LVr1/ijjz7ioKAgRZ/t888/t9sWPD3PUwRHWxw6dIibNm2qyJuunBcxr8NUT1BQEI8ePZpTUlLgCc8c5wkAcJ558+axr6+vLD7txWyjRo34ypUrTrdpeRyaExzh6bmezM/yZbNmzVTzXu7cuXnMmDGKHHfixAkuUKCA1fmzNq/+/v68dOlSh+dNBEd4eq6nnohwQ6wIjszw1Bs9PV2pa+rUqezt7e1Q3868bO7cuXnFihU5whGenusJsgbcBA2Ew5UTnpnxgWfWeOqN+Xy78wGqCJ4iODKL4wkAAAA4wvDhw2U5zpG35WZkZPAHH3ygmiMnT56sqQ6tF2tE8BTBUSRXERzNKVOmjGyaAgUK8IoVK2Q37Dx8+JDHjh3L3t7ekpePj4+snU6dOnFGRoYmxz179nBgYKBs+nHjxgnvKYIjPPXxnDFjhlTOMlaLFCnCERERTn+CgoJkJ5+1TGMNeMLTnT2ZHb9gs2bNGkWemzp1qt3pLImJiZFuNjXVY+uBI/DUz1MER5E8u3XrJvOcMGGCzfpXrVol8yxYsKDdG3qscfDgQSn/GgwG9vX15QcPHgjrKYIjPPX3VOs7rVy5koODg1XzqL+/Pw8bNszmwwkyAxE8RXAUzVUEz5s3byryVq1atVTfDhAfH8/NmjWTne8wDb4xGp89+EArqamp3LBhQ1ldtqaHp36eIjiK5MnMXLNmTVn5Ll26OHSz2p07d7hSpUpS3q1Zs6bNh4icP3+eK1asKNvHBAQE8MWLF+EJT+EcrTF16lSHbu5x5KNWj9Fo5Jo1azp8cxA84enOngAA5/nhhx9UY9xavJr/LywsjLdt2+ZUu+Y51NSHFNkRnp7rycw8ffp0Rb5Uy3v169eX3rz79OlTLlu2rM35sJU3jUYj//DDD5rnSwRHeHqup96IcEOsCI7M8NQbd7gJesGCBTb7ZLb2FeblvLy8eN68ecI7wtNzPUHWYGBmJgAEwmg0ksFgIHfYdA0GA6Wnp6v+D56OY8tTb0zzTUTEzFnatiOI4CmCI5E4ngAAAIAj1KtXj/bt20dEz46lLl++TMWKFXOojvHjx9OYMWMUeXLx4sXUs2dPm9OaH0vayq0ieIrgKJKrCI4mNm/eTC1atJDK582bl/bt20dlypRRLf/dd9/RoEGDZPUzM4WHh9O///5LQUFBmudx0aJF1LdvX6mO0qVL07lz54T1FMERnvp6nj59ml577TX6559/pFglIqpSpQotWbKEKlWqpLlNc7p27UqrVq0iIn3OFcATnu7s6Wh9b731Fs2fP1+apxYtWtCGDRucanvevHn0v//9T7a/iIuLg2cme4rgKJJn6dKl6dKlS8TM5OfnR3fu3LGZ80aPHk1ffPGFNF9ffvklDR8+3ClPIqJXX32Vli9fLtW3ceNGat68uZCeIjjCU39Pa32nS5cuUa9evWjPnj2yPpmpvoCAABo4cCANHz6cChQo4LSnVkTwFMFRNFcRPGfMmEHDhg2TPMuWLUsHDx6kXLlyqZZPSUmhF154QTpGNXnnzZuXLly4QHny5NHcdmxsLJUrV45SU1OJmSkgIIAePHhAPj4+8MxETxEcRfLcu3cv1a9fX2ozMjKS9u3bp1rWXpsVK1akp0+fEtGz84ojR460Wj4hIYHq1KlDZ8+elfYxgwcPphkzZqiWh6fneYrgaI3PPvuMPv30U1luJPovVxYvXpwqV65MpUuXpkKFClH+/Pkpd+7cFBgYSF5eXuTl5UWpqamUmppKCQkJ9ODBA7p16xbFxsbS2bNn6ejRo5ScnKxad8mSJWnHjh1UuHBheMJTaE8AgPMcPXqU6tatS8nJyYprvFWrVqWSJUtSUlISnTx5kmJjY4nov3g1lfX19aWlS5dSly5dHGpb6/VhERzh6bmeRP/150yYe5hjqq9ly5a0fv16mjp1Kg0fPlzhXbFiRWrevDlFRESQr68v3bx5k3bv3k07duyglJQU2fLw9fWlmJgYqlevnvCO8PQ8zx07dtidB2cZM2aMVL/BYKBt27bZve+iUaNGiu9EcCSCJ5FnejozDuKff/6hunXrUlpamvQdM5OXlxe1bduWmjdvTlWqVKHQ0FBKT0+nu3fv0rFjxygmJoaio6MpLS1NFuteXl60ZcsWaty4sbCO8PRcT5BFMACCYfkU4uz6GOw8SQKe+nrqjcHiKR1Z2bYjiOApgiOzOJ4AAACAIxQvXlzKbeXLl3e6ngkTJihypZ+fH2/fvt3mdKZp7OVWETxFcBTJVQRHE2+//bbsSX5aniBr/kYb08+JEyc6NG8mqlWrJqvH2ps9RPAUwRGe+numpqbyyJEj2cvLS9bP9/f31/z2dksy46m68ISnu3o6Wl/lypVlsbl3716X2reM9ePHj8Mzkz1FcBTJMyQkRIrtevXq2a23X79+svk6efKkS56//vqrrL5Zs2YJ6ymCIzz197TVd8rIyOBJkyZxUFCQ6pPPjUYjBwQEcL9+/fjYsWMu+dpDBE8RHEVzFcGzQ4cOsjY3btxod5qdO3cq5m306NFOtf/666/L2t+xYwc8M9lTBEeRPN99911ZOXvn/GzxwQcfSHWFhYXZfWPvyZMn2dvbW5rfvHnzcnp6OjzhKYyjGhs2bJDlRVMd1apV4++++46vX7/u9HyYSE1N5ZiYGH7zzTc5ICBAkYMbNmwIT3gK7QkAcI0WLVrIjikNBgN36dKFL126pCh7+PBhfuWVV1T3Dd7e3rxs2TKH2rbVhxTNEZ6e63n48GH28fFRtKv2Ma9zyZIlXKZMGdn3xYsXt9kXvHLlCr/66quK8yrlypWzefwpgiM8PdPTMmb1/ljOo62Pl5eXsI7w9FxPZ8ZBvPTSS4r82rhxY75w4YLdaWNjY7lTp06KWI+IiODk5GRhHeHpuZ4ga8BN0EBIlixZwsHBwarJOys/9nai8NTXU08sk1JWtu0IIniK4MgsjicAns4bb7zhNp++ffsK6yiSpyiu2e1lzTEoKEjKby1bttQQZdZ5//33FfkyX758fPbsWavTmJ8osJVbRfAUwVEkVxEcTdSqVUsqmytXLruD0JiZ16xZo2jj6NGjDs8bM/NXX30l6xOtWrVKWE8RHOGpv6eJnTt3cokSJRTtN2rUSHUAgS0y42ZYeMLTXT0drS9//vzSPISHh7vc/uTJk2Xt//zzz/DMZE8RHEXyNB9006FDB7v1vvbaa7J6ExMTXfI8ePCg7Fh1woQJwnqK4AhP/T219J1iY2M5KipKVp/5tSTT302aNOHFixfzkydPXHIX1VMER9FcRfAsXbq01F7BggU1T1e0aFHZvO3fv9+p9n/++WfZvC5ZsgSemewpgqNInnXq1JHKFStWzKm2TOzfv1/W5h9//GF3GtNgNtM0hw8fhic8hXG0JC0tjUuWLCnLnz4+Pjxz5kyX/G1x8eJFrlGjhiJnL1iwAJ7wFNITAOAaR44cUcTcxx9/bHe6mJgYjoiIkPXhTPuJ1atXa25fSx9SBEd4eq4nM/OLL74oK+/l5cWDBg3if/75h58+fcp3797lTZs2yW7sMRqNHBYWJvu7QoUKfPv2bU1+06ZNUzguXLhQaEd4eqanedns/liLdREc4em5no5eG96zZ49s3oxGI3fv3l3zg9xMmL8gxfTzm2++EdYRnp7rCbIG7+x+EzUAzvDaa69R1apVqXXr1nTjxg0yGAzEzGQwGGjx4sXUs2fP7FYkIni6O8yc3QqaEMFTBEcicTwB8GQWLVpEBoMhuzWkPDh//nzF/0RwJBLHk0gMV3d1zMjIkP7n6+vrUt1Tpkyh+Ph4WrJkCRkMBjIYDHT//n1q06YN7du3j0JDQ52uWwRPERxFchXB0cTFixeJiMhgMFBkZCT5+PjYnaZVq1bk7+9PycnJ0nclSpRwqv0aNWpI7RMR3b59W1hPERzhqb+niQYNGtCxY8fonXfeoR9//FE6t7Bz506qWrUqTZs2jfr16+eUi57AE57u7KmFhw8fEtGz2CxXrpzL9VWvXl2qj4goLi7O5TqJ4KmnpwiORNnnmStXLqntR48e2a23QIECsr/T09Nd0aSUlBTZ38HBwarlRPAUwZEInlrR6qmF4sWLU3R0NG3atIk+/PBDOn78uNQ3I/rvvPuOHTtox44d9Pbbb1Pnzp2pc+fO1KxZM/Lz83N+RnKYpwiOorlmt+fdu3eJ6Fm+qly5subpKlasSNevX5f+Llu2rFPtR0RESO0TEcXHx8Mzkz1FcBTJ8+LFi1KZ8uXLO9WWCdMxqKm+ffv2UYsWLWxO07FjR/rtt9+kv48dO0aRkZHwhKcQjpasXbuWLl26JJ3z8PLyolWrVlHbtm1d8rdFiRIlaOfOndSyZUvauXOn1PbXX39Nb7zxBjzhKZxn3759M83HUaxdsxbBkQiezpATPNevXy8r16xZM/riiy/s1vniiy/S33//TR07dqTdu3dLfbq0tDR69dVXaePGjdSkSRNd/EVwhKfneh4/fpy2bdsmy5e//PILderUSSrj7+9PzZs3p+bNm1O/fv1o4cKFZDAY6O7du9J0/v7+tG7dOsqfP7+mdocNG0bXrl2j6dOnS3V899131KdPHyEd4em5niYya3yf+fhzW21oGacugqO9OlwBnvqit6dW1q5dK/u7fPny9OOPP5LRaHSonpEjR1JcXBzNmjVLivW5c+fSO++84xGO8PRcT+AketxJDUB2cenSJS5WrJjsKVsBAQH8999/Z7eaDHi6H4sWLVJ83BERPEVwZBbHEwBPx+AGTz2z9/RNERxF8hTF1V0dixQpIh271a5dW0OU2SY1NZUbN26smN/69etzUlKSzeViaz2L4CmCo0iuIjiacPQNbSbM39JrNBo5OTnZ4fliZv7nn3+kOoxGI0+cOFFYTxEc4am/pxqrV6/m/PnzK2Kxbdu2fOvWLbvTZ+YbgeEJT3fzdLS+8PBwKS7bt2/vcvuWsf7FF1/AM5M9RXAUyTMyMlKK5bx583JaWprNen/88UfZfB05csQlz1mzZsnqW7VqlbCeIjjCU39PR/pOzMwZGRm8aNEiLlOmjCxGLc+ZmL7LlSsXd+rUiWfNmsWHDh2yuxysIYKnCI6iuYrg6evr61T+a9euncwnNTXV4baZ/3u7qMnhyy+/hGcme4rgKKpn69atnWrLRHJysqzNPn362J1m586dsmmmTp0KT3gK42hJr169ZPE7cuRIl7wd4caNG5wvXz5Z3r58+TI84Smcp+UxZHZ9bB3/iuAIT8/1bN68uSzWDxw4YLWsGklJSdy6dWvZ/BoMBg4JCeGjR4/anV5LH1IER3h6rufo0aNlbXz44Yc2601OTuaSJUsqYvSdd95xaP6YmRMTE7lw4cJSPd7e3nz37l0hHeHpuZ6dOnVSxGl2fazFugiO8PRcT0evDdeuXVsW4ytXrrQ7jTWePHkii3Wj0chXrlwR0hGenusJsgbHbmUHwM2IiIigzZs3S0+wNxgMlJSURD179pS99Si7gaf78frrrys+7ogIniI4EonjCYCnM378eAoMDJSenmn5yQrYzhPPRHAkEseTSAxXd3UsWLCg9L+jR4/S06dPXWrD29ubfvvtNypdujQR/fd0wL1791LPnj2drlcETxEcRXIVwdFEUFCQ9HtCQoLm6cLDw6W3sxMR3bhxw6n279+/L/s7d+7cquVE8BTBkQieWtHqqUbHjh3p+PHj1LJlS8mFmWn9+vVUqVIlWr16tVNOegNPfYFn1lC6dGnpuFCPN/ia3hBnIk+ePC7XSQRPE3p4iuBIlH2eNWvWlNp9+PAhrVixwma9LVq0IC8vLylPRkdHu+S5ePFi2d/W3pYogqcIjvDU39NRDAYDvf7663TmzBlasmQJVahQgZhZyqmmj+m7J0+e0Jo1a2jIkCFUq1YtCgkJoSZNmtDIkSNp/vz5tHnzZjp79iwlJibq4ieSpwiOorlmh2e+fPmk3x3pe8XFxcnOKd66dcupeb58+TIR/XfeMDQ0VLUcPLWhxVMERyJxPENCQqRyFy5ccKotE5bHoGlpaXanCQwMlP2dmpqqWg6enucpgqMlhw4dkuLX19eX3n//fQcsXaNQoUL0xhtvyK5jHThwQLUsPO0DT31xxNOE6XgxOz5aEcERnp7neeHCBSnWCxUqRLVq1XJo/vz8/GjNmjXUtm1bqU2DwUCPHj2iNm3aOH29SzRHeHqu544dO4joWax7eXnRhx9+aLO8r68vDR8+XBGjXbp0cbjtgIAA6tWrl1RXRkYG7d27V0hHeHqu56pVq2jBggWUK1cuYv5vvITBYKBWrVrRyZMn6dKlS059WrVqJbVjMBjslr948aKwjvD0XE9HuX79uvR7QEAAtW3b1um6AgMD6bXXXpPtNw4dOuSSH5EYjkTwNOFpnsBJGIAcwKpVq6QnK5h+Dh8+PLu1FMATAAAAsM+ZM2e4cuXKiqefGY1GbtiwITdp0iTLPiI7iuQpiqs7Og4aNEj2lLPvv//e7rLWwrlz5zg0NFQxnwMGDJCVszxmtIYIniI4iuQqgqOJ0qVLS2Xz58+v2eX999/nIkWKsJeXFxsMBv7111+dmqcJEybIltUvv/wirKcIjvDU39Me3377LQcFBSnitnfv3vzw4UPVabLqjcDwhKc7eDpa34gRI6TyoaGhnJGR4VL7n376qaZYh6d+niI4iuS5bt062bFfkSJF+Pbt2zbr7tixo8z1/v37Tjn+9NNPsrZLlSpltawIniI4wlN/T0f6TtbYsmULd+zYkb29vWVxa55fzT/m/zP/hIWFCe0pgqNoriJ4VqtWTarH19eX7927Z9fp/v377OPjI5s3Z/tb77zzjsx97dq18MxkTxEcRfKsVKmSrL3Tp0871R4z84IFC2RxPGzYMLvTrFy5UuY5d+5ceMJTGEdLcufOLTnXrl3baV9n2bhxo2w+Z8yYoVoOntqAp75o9fziiy84V65cVo8JLY8dM/Nj7fhXBEd4eq5nnjx5JKeXX37Zajl7JCcnc5MmTaT2TPNYtWpVTkhIsDqdqbwtTxEc4em5noUKFZLKVa9eXZPTvXv32MvLS1a/tbfk2mP9+vWyWJ83b56QjvD0XE8Tly5d4gYNGshi1Wg0ctmyZXnfvn1OOeh9fVgER3h6nqejdfn5+Unz8MILL7jUNjPzhg0bZMvm66+/FtIRnp7rCbIG3AQNcgzDhg2TdRZ9fHz41KlT2a2lAJ4AAACAfRISEvjll19WnAgeOnRodqtJiODILI4nsxiu7ub4yy+/yFwKFSrEcXFxutS9detW9vX1lV28MRqNPHjwYKmM1os1IniK4CiSqwiOJixPlP3xxx8O+aSmpvLFixf5xo0bDs9LWlqa7EZXo9HIFy5cENZTBEd46u+phTNnznDNmjUVsfncc89xTEyMonx23AwLT3hml6ej9f3zzz+y8tHR0U63nZKSwsWLF5fN97lz5+CZyZ4iOIrkmZaWxs8995zs2LB27do2B9McO3aMvb29pWlatmzJaWlpDjnu2bNHNojbaDTyRx99ZLW8CJ4iOMJTf09H+k72iIuL46lTp3KNGjWk/YH5oADzZaH2sdW+CJ4iOIrmKoLnwIEDZWVGjRpl12Xs2LGKtlu1auXwPCUmJkoDuU31WTv3Ak/9PEVwFMnz9ddfl7XZqVMnh9szUb16dVmbM2fOtDtNr169ZMtp8+bN8ISnMI6WmB5iYDQauV27dk77OsuhQ4dky2zixImq5eCpDXjqi1ZPZvd8KLaIjvD0TE/z67cdOnSwOT/2ePToEUdGRir6ha1ateL09HTVabT0IUVwhKfneprfsONIvqxQoYKs/tTUVIfni1mZL7/88kshHeHpuZ7mZGRk8IQJExRji3x8fPiTTz5x2CUzrmOL4AhPz/J0tK58+fLp2s87fPiwLNa/+OILIR3h6bmeIGvATdAgx5CamspVqlSRHTBnx4lTe8ATAAAA0EZSUhK/9NJLipPBP/74Y3arSYjgyCyOJ7MYru7kmJyczOHh4bKTYlWrVuXY2Fhd6v/xxx+lui2PC+/fv6/5Yo0IniI4iuQqgqOJmTNnyspXrFiRnz59qounPcaMGSNru0SJEkJ7iuAIT/09tZKWlsajR4+W3dhjMBjYy8uLhw4dyklJSVLZ7LoZFp7wzA5PU32mdps3b84jRozg5cuX89mzZ1WnqVevnjRNw4YNnW77vffek8V60aJF4ZkFniI4iuTJzLx06VJZeYPBwKVLl+Zdu3ZZnWb8+PGy+WvatKndt/QyPztvPm3aNA4ICJC1GRYWZvcNiyJ4iuAIT309Hek7OcK///7LX3/9NTdv3pz9/f2l+TefN7U+ncieIjiK5iqC52+//Sbz9PHx4fXr11tt+48//pDdBGTe7po1axyaj0GDBsnafv75562Whad+niI4iuS5YsUKRaxbezunLSZPnqyo599//7U5zcGDB2Vvvvb19eUnT57AE57COFoSFhYmxXDdunUddnWV6Oho2b7j+++/Vy0HT23AU1+0eppwt4diqyGCIzM89cbdPQsUKCDFeqNGjVyu78aNG1y0aFFF32zgwIGq5bX0IUVwhKfnegYFBUl1tmzZUrNPq1atZPU7+3D63bt3y86NTJ8+XUhHeHqupxqHDx/mChUqKOKwevXqfPLkSc31ZOZ1bBEc4ekZno7WVaVKFamsHvl1165dsljX403Q2eEIT8/1BFkDboIGOYpNmzYpDgb27NmT3VoK4AkAAABo4/Hjx1y+fHnZieOQkBC+du1adqtJiODILI4nsxiu7uT45ZdfyjrZJpePP/6Yjxw54nL9U6ZMUdRvNBq5SJEimi/WiOIpgqNIriI4MjPfu3dPumhjKv/iiy9yfHy8y462+OyzzxSetp5YK4KnCI7w1N/TUfbu3culSpVStFGhQgU+ePAgM2fvzbDwhGdWe5rfaGqe10yf3Llzc/369Xnw4ME8f/58Pnz4MG/dulVW9tNPP3WozYyMDB45cqSiXVtvh4Onfp4iOIrkaaJ79+6y6Uy/d+jQgbds2aL6Fg7zG3SMRiOHhITwiBEjeO/evbInrT98+JD37NnD77//PhcrVkzmZvppbwC1SJ4iOMJTP09H+6LO8PTpU966dSt//vnn3KpVKy5UqJC0LMw/ttoXwVMER9FcRfBMT0/nUqVKSfFqMDy7WW306NF88+ZNqdzVq1d55MiR7OfnJ6uzVq1a0t+5c+fm7du3a/KePn26YvlMmjTJanl46ucpgqNInk+fPuUiRYrIPL28vPjzzz/X1B4z87fffsteXl6yNmvXrm1zmm3btkkPcDRN07lzZ3jCUyhHS6pVqyZN5+/vz/fv39fsqgcDBgyQ7Ueio6PhCU/hPM1xp4diW0MER2Z46o07e5q/8TNv3ryckZHhcp1Hjhzh3Llzy3KytWNMLX1IERzh6bmexYsXl8qVKlVKs0v79u1leW7Tpk1OzdN3330nq2fJkiVCOsLTcz2tkZSUxEOGDJHFq8Fg4ICAAJ46daqmOjL7OrYIjvDM+Z6O1tW/f3+pfPHixV1qm/m/F0XYinURHOHpuZ4ga8BN0CDH0aJFC9lOplOnTtmtpAo8AQAAAG2cOHFCcQNQ27Zts1tLhgiOzOJ4Movh6i6OaWlpXLduXdmFE9PvRqOR/f39uV69ei61MWHCBFmdpja0XqwRxVMER5FcRXA0MXz4cMU0+fLl4zFjxvCJEydccjQnJSWFV6xYIRvwY/qZP39+TkhIEN5TBEd46u/pKE+ePOE333xTsX/w9fXlcePGcYcOHTL9ghI84ekunpZv27XMZ5b/MxqN7OvrqxhI/dFHH9ltKzExkX/66SeuXLmyItaDgoJsvmkUnvp5iuAokqeJpKQkbtasmeLY0PR7aGgot2zZkkeMGMGzZs3ilStX8oYNG6RBOJbljUYj582bl3PlyqW6DMy/e/fdd+36ieQpgiM89fN0tO+kF/Hx8bx9+3ZevHgxjx8/nj/44AOrb8sRxVMERxOiuIriuXz5ctUY9/Ly4oIFC8refGg+TwULFuSLFy+yt7e39J3pJtWHDx+qtnX48GGOiopS1BUaGsqPHz+2OV/w1M9TBEeRPOfNm6fqWbNmTV65ciU/ffpUdbp9+/aptmk0Gnnbtm2K8jdv3uTly5dzmzZtFNN4e3vz33//DU94CudozsCBA2XHhGPGjNE0nR78+++/sutl3t7eVh/kCE94urOnJe70UGxriODIDE+9cVfPnj17ymLd2ZvdLImOjpbOOZrnysWLF8vKaelDiuAIT8/1NJ1DNJXTei04OTmZz58/z1u2bOEFCxZID/V1lMaNG8vaV6tHBEd4eq6nPf7880/Vlyo0adKEY2NjbU6bVQ/zFsERnjnX09G61q9fr0tsmqhTp46sPrXzISI4wtNzPUHWgJugQY7j2LFjXK1aNelTo0aNLH+CpBbgCQAAAGjnxx9/VHTyN2zYkN1aMkRwZBbHk1kMV3dxvH79Oj///POSg8nH9GnQoIHLbXzzzTeyCzhqA3hygqcIjiK5iuDI/OzGBMvBAubOH3/8sUuO//zzD7dr147z5MmjqN9gePYWkfXr1+cITxEc4am/p7OsXbuWCxQooIhZy1jObuAJz8z0HDt2LBcsWFCWHy3bssyflk6mnxcuXFBtIzU1levUqcP+/v6qsW40GvmHH36AZxZ5iuAokqc5KSkpijfoquVPtXmwNj+25t9gMPCgQYM0+4nkKYIjPPXxtIw5d0UETxEcTYjiKoon83839tiLWfP5Wbp0KTMz9+vXT/G/gIAAbtasGQ8ePJg//PBD7tmzp/TmKrVcu2zZMnhmsacIjiJ5durUSdXTaHz2IMU6depw+/btuXv37tysWTMuWLCgar40Go08YMAA1TYiIyOtTqP1/Ao8Pc9TBEcTf/31lywGfXx8eO3atZqnd5a7d+9ytWrVZO6NGzeGJzyF9FTDXR6KbQsRHJnhqTfu6DlnzhxZrNesWZNTUlJ0qXvatGmKnOzj48O//PKLVEZLH1IER3h6ruenn34qq6tdu3a6OGph1apVMs/Q0FBhHeHpuZ5auHfvHnfr1k1Wp8Fg4ODgYF6wYIHV6bLyhlgRHOGZMz0t65o4cSJv3LiRb968qVo+IyODn3vuOan866+/7nTbixcvls17SEgIp6enC+kIT8/1BFkDboIGAAAAAABCYPkGnKpVq2a3kgIRHJnF8WQWw9VdHO/du8dt2rSRdfhNn27duunSRnR0NOfJk0dRvyMn0kTwFMFRJFcRHJmZY2NjOSIiQnGR0mg08qJFi1zy27p1qzT/lsvBYDDw5MmTNdclgqcIjvDU39NZbt++zW3btlVczHFmn5iZwFNf4Knkxo0bvGHDBp4wYQJ37dqVy5QpI2vTMsdZ5jsfHx9OS0uzWn9gYKDVWLc2EBuemespgqNInuZs2bKFIyMjVf0s856W+VCbr/DwcMUbPXKipwiO8HTN0x3zrxoieIrgaEIUV1E8mZ8NqhkyZIimmDUYDPzee+9J0968eZMLFSqk2B+oTaeWL83rgmfWeYrgKJJnYmIi16tXT1GHtXxorc3WrVtbHYTWunVr1Xr69evHGRkZ8ISnsI7mVKtWTVaHt7c3jxs3zupbq13l8OHDXLZsWVmbRqOR161bB094Cuuphrs8FNsWIjgyw1Nv3M0zPj6eAwICZD49e/bk1NRUXepXe8CPl5cXT5kyhZm19SFFcISn53qeP39ekbdGjBihi6MtYmJiODg4WNautQcsiuAIT8/1dITFixfLxhiZfrZv355v376tKJ/VN8SK4gjPnOVpqsu8XdOnUKFC3Lp1ax41ahSvXLlSegD2kiVLZO0787CrDRs2KB7uY+2mVREc4em5niBrwE3QAAAAAABACM6cOcM+Pj6yDoXWtwhkFSI4MovjySyGq7s5bty4kZs2bcre3t5SR37o0KG61X/lyhVu2bKl7CSBMyfSRPAUwVEkVxEc4+LipDrMpz9w4IDLbpYn4QwGA/v7+/P8+fMdrk8ETxEc4am/pyvMnTuXc+XKpXDJygtKWoCnvsDTNgkJCbxr1y6eOXMm9+vXj6tXr87+/v5SrjPPeRERETbrioiIUPV39Y3y8NTXUwRHkTxjYmK4Z8+e0mABSzctH8vpKlWqxF9//TUnJCS47CeSpwiO8HTO09W+aFYhgqcIjiZEcRXF05y1a9dy+fLlFTFq+oSGhvLcuXMV0+3bt49DQ0NV+2dq+wfTd59++ik8s9lTBEdRPJOTk/nNN9+0mhPtfT906FCbNzFYvtk6JCSEv/nmG3jCM0c4mjh48KB0vco8h4aGhvKQIUN48+bN/PjxY6fqNhEXF8dLly7lqKgo9vLyUsy/lrfCwROe7uxpDXd5KLYtRHBkhqfeuJvnW2+9pejL1apVi//880+X687IyODOnTvL4tr0u/lDRUw/RXaEp+d6duzYUVG+UaNGHBMT47KnJTdu3OB33nmHfX19ZW36+vry5cuXhXaEp+d6OkJsbCw3btxYMV8FChTg3377TVY2u26IFcERnjnH0/xGU/PzGtbOe4SEhHCjRo3Y29tbdk5D60N5rl69ygMHDmQfHx/FvJ44cUJYR3h6rifIGnATNAAAAAAAEIZBgwbJOi+1a9fObiUFIjgyi+PJLIarOzrGx8fzqlWr+PPPP+f169frXv/GjRu5SZMmLp9IE8FTBEcTIriK4Lh69Wpu2LChNL2rA28yMjLYz89PdlKsffv20tMHnUUETxEc4am/p7OcP3+e69SpozhZ7W7AU1/g6RhpaWl87Ngx/vHHH3nYsGHcpEkTzps3L7/00ks2p6tVq5bMvWbNmrx79254CuApgqO7e6alpfGePXt4+vTp/Prrr3P9+vW5SJEi7Ofnp7hIavr4+Phw4cKFuUGDBvzmm2/yDz/8wP/++6+uXiJ6iuAIT8ewvHjvrojgKYKjCVFcRfFU4++//+Yvv/ySBw8ezH379uWPPvqIV61aZfNNh+fOnZMGt1kbvGP6vkqVKrxp0yZ4upGnCI6ieP7555/SuQ+1Ni2/b9y4saZB16NGjWJvb2+OjIzkyZMnc3x8PDzhmeMcmZmXLl3KXl5eCi/T397e3ly2bFmOiori/v3785gxY3jKlCk8e/Zs/v7773n+/Pk8d+5cnjlzJk+cOJFHjBjBffr04ZdeeomLFCmiiH3z32vUqMH379+HJzyF91TD3R6KrYYIjszw1Bt387x7964sHs3jPF++fNy8eXMeMmSI0/WnpKRwVFSUIsbVforsCE/P9bx27RrnyZNHNZ8VKFCA58yZ47QjM/P169d52rRp3LJlS8W+w/Tziy++EN4Rnp7r6SgZGRn81VdfSWMmzNvr06cPP3r0iJmz94ZYERzhmTM8u3XrZvWch2X+tPV/b29vqw8sSEtL4xEjRnDDhg2lvqFlrL/zzjtCO8LTcz1B1mBgZiYAAAAAAAAEID4+niZMmCD7buzYsZQnT57sEVJBBEcicTyJxHAVwTGzuHnzJm3fvp2uXbtG77//fnbrWEUETxEcTYjgqodjXFwc7dmzhzp37uyyT8uWLSkoKIjq1KlDPXr0oGLFirlcpwkRPEVwJIKn3p7OkJGRQatWraLExETpu9dffz0bjdSBp77A03UePnxIISEhVv//xhtv0LVr16hGjRr0yiuvUGRkZBba/Qc89UMERyL393zy5AklJiZSSkoKZWRkkI+PDwUEBNh0zg5E8BTBkQielrzxxhuyvxcuXKhr/XohgqcIjiZEcRXFU2927txJy5Yto71791JsbCw9fvyY8ubNSwULFqT69etTu3btqEWLFmQwGOCZQzxFcMwOz9OnT9OWLVto9+7dFBcXR3fu3CEiotDQUCpUqBDVr1+fmjZtShUqVNBU3927dykwMJACAgJ08YOn53qK4Lh69Wrq27cvPXr0SIpJy+GBzsSqtTqYmRo0aEBr166lvHnzwhOeOcJTjbfffpvmzJkj/V2rVi3av3+/S3XqjQiORPDUG3fz3LlzJ7Vp04aePHlCRPL4NBgMVLNmTZf8UlNT6dVXX6VVq1Yp9iMGg4GYmQwGA6WnpwvtCE/P9dy8eTO1b9+ekpOTpe9M086aNYsGDhzotOPGjRupTZs2ko/JzdRGhw4daPXq1XbrEcERnp7r6QzHjh2jnj170smTJ2XxWrx4cVqwYAHNnj2bVq1aJXnZi2NPdYSn2J7MTGfPnqV//vmHjhw5In3i4+Nl5Wz110x+jx8/tnqew8/Pj9LS0lRjvVatWrRz507y9fUV1hGenusJsgbcBA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOQALl++TO+//z799ttvRKQcCOrocEFr0+fLl49GjRpFQ4cOJaPRCE945ihPS0R4KLYIjkTw1Bt39Pz777+pffv2dPPmTUWMtm3bltasWeNS/cxMI0aMoClTpqjuA7TcBCSCIzw913Pr1q302muvUVxcnOymt5iYGGrcuLHTfufOnaPy5curuvXq1Yvmz59P3t7emuoSwRGenuvpDCkpKfTRRx/RjBkzZO0bjUYKCQmh+/fvE1H23hArgiMRPPUmuz1v3Lgh3Xxq+nnp0iWrD6IqUKAAxcXFWa2vSJEidPPmTdl3zEyNGzemtWvXUnBwcI50hKfnegJ9wU3QwOO5cuWK4rvixYtng4lt4AkAAAAAAAAAAAAAAAAAAAAAAAAAAADQwpEjR2j27Nm0cuVKevDggex/jrxt13x4odFopFq1alHv3r2pV69elCtXLnjCM0d7AgCc4/HjxzR+/HiaM2cOJSQkENGz2O7fvz/Nnj1blzbWrl1LAwYMoFu3bsne1Kb1JiARHOHpuZ7379+ncePG0cKFC+nx48dkMBgoLi6OChQo4LRXSkoKBQYGEjNL+bNgwYI0efJk6tmzp8P1ieAIT8/1dJaYmBh644036OrVq4o3Uzsax57sSARPvXEnz4SEBOltvKabT0+dOkUpKSn0wgsv0O7du61OGxkZSceOHSOiZ7kxMDCQRo0aRR988AH5+Ph4lCM8PdcTOA9uggYej9FolJ04NRgMlJaWlo1G6sATAAAAAAAAAAAAAAAAAAAAAAAAAAAA4AgZGRl04MAB2rVrF508eZJOnz5NN27coNu3b1NKSorqNAaDgYKDg6lw4cJUqlQpqlixItWqVYsaNWpEYWFh8ISnx3kCAJwjOTmZNm7cSDExMXTq1Cnq2LEjvf3227rV/+jRI5owYYLihlZHbgISwRGenuv58OFDWr9+Pe3bt4+++eYbl72KFy9OiYmJVLt2bXr11Vepc+fOFBAQ4FKdIjjC03M9neHhw4c0cOBAWr58ueyeCHe6IVYERyJ46o07e6alpdHJkyfp8ePHVL9+favlmjdvTjt37qSqVavSK6+8Qj179nTpIQo5zRGenusJtIGboIHHYzQaZX9n9wGANeAJAAAAAAAAAAAAAAAAAAAAAAAAAAAA0IvHjx9TcnIyJScnU3p6Ovn4+JCfnx8FBweTl5dXdutJwFNf4AkAyGk8fvyYfv/9d9q+fTtdu3aNoqOjs1tJgQiORPDUG3fzvH//PuXNmzdbHewhgiMRPPXGHT2XLVtGb7/9Nj148ED6zt3uixDBkQieeiOKpxrx8fEUGhqquOfInRDBkQieeiOKp6eDm6CBx2P+5mJ3eAqKNeAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQuVy/fp0mTJhAiYmJ0ncLFy7MRiMlIjgSwVNvRPEEAAA9wU3QwOMR5aZdeAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAU8B7ugEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABuBW6CBgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAALgVuAkaAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4FbgJmgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAW+Gd3QIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGQHffv2zW4FCYPBQPPnz1d8L4IjETydISd4AgAAAAAAAAAAmYmBmTm7JQDIToxGIxkMBiIiYmYyGAyUnp6ezVZK4AkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOiL+Zi37MTWeDsRHIng6Sg5xRMAAAAAAAAAAMhM8CZoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAODRZOc7hbTe6CqCIxE8tZATPQEAAAAAAAAAgMwAN0EDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAC0rdv3+xWkDAYDDR//nzV/8HTceCpL7Y8x48fTxMnTqTExETV/2fFDaj22hDBkQiejpCTPEWIdREcieDpDPDUF8SQfsBTX0T3FMGRCJ7OAE99QQzpBzz1xZYnyBoMnJ2PBwPADTAajbK/DQYDpaenZzRz/pQAABrgSURBVJONdeAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAMMdoNLrFWzqZ2eY4IXg6Bjz1xZ4nEdHZs2epa9eudOLECcnZNF39+vXJy8srq3Rp69atwjoSwdMZRPcUIdZFcCSCp6PAU18QQ/oBT33JCZ4iOBLB01HgqS+IIf2Ap75oOacAMh+8CRp4PAsXLsxuBU3AEwAAAAAAAAAAAAAAAAAAAAAAAAAAAKBGdr4LxZEBqfC0Dzz1RatnuXLlaM+ePdShQweKiYmRTVe9enX6+uuvM8lQOyI4EsFTb0TxJBIj1kVwJIKnFuCpL4gh/YCnvuQ0TxEcieCpBXjqC2JIP+CpL+5wEzZ4htF+EQByNq+//rri447AEwAAAAAAAAAAAAAAAAAAAAAAAAAAAGDO+PHjKTAwkAwGg+onK9AyGBWe2oGnvjgyWDpXrly0fv16evHFF6U3PTEzzZw5kxYvXpyJltoRwZEInnrj7p4ixLoIjkTwdAR46gtiSD/gqS85xVMERyJ4OgI89QUxpB/w1JfsvAEbyDEw1gYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAkZ8+epa5du9KJEyekQaCmm+Tq169PXl5eWeaydetWq/+Dp+PAU19seZrz5MkTqlmzJp07d46InvkGBwfTyZMnqUiRIpmpqBkRHIngqTfu7ClCrIvgSARPZ4CnviCG9AOe+iK6pwiORPB0BnjqC2JIP+CpL1rPKYBMggEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAsCQkJ/PLLL7PBYGCj0Sj9HDp0aHaryYCnvsAz8zhx4gQHBQXJfNu2bZvdWjJEcGSGp964s6cIsS6CIzM89Qae+iGCIzM89Qae+iGCIzM89Qae+iGCIzM89UYUT5C54E3QAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA4CQnJ1Pr1q1p69atZDAYpDfjLFy4kHr37p3dehLw1Bd4Zh6LFy+mPn36yHx///13atWqVXarSYjgSARPvXFnTxFiXQRHInjqDTz1QwRHInjqDTz1QwRHInjqDTz1QwRHInjqjSieIPPATdAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAO4MmTJ1SzZk06d+4cERExMwUHB9PJkyepSJEi2Wz3H/DUF3hmHh06dKB169ZJg6yrVKlCR44cyW4tGSI4EsFTb9zZU4RYF8GRCJ56A0/9EMGRCJ56A0/9EMGRCJ56A0/9EMGRCJ56I4onyByM2S0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA1wkKCqKVK1dSQECA9F1CQgINHDgwG62UwFNf4Jl5TJo0iby9vaW/jx8/TsuXL89GIyUiOBLBU2/c2VOEWBfBkQieegNP/RDBkQieegNP/RDBkQieegNP/RDBkQieeiOKJ8gccBM0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAACQQ6hYsSLNnj2bmFl6Q+j69etp48aN2a0mA576As/MoVy5cvTWW28RMxPRszdNTZ8+PZut5IjgSARPvXF3TxFiXQRHInjqDTz1QwRHInjqDTz1QwRHInjqDTz1QwRHInjqjSieQH8MbOr9AgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIEfQoUMHWrdunTQotEqVKnTkyJHs1lIAT32Bp/7Ex8fThAkTZN+NHTuW8uTJkz1CKojgSARPvRHBU4RYF8GRCJ56A0/9EMGRCJ56A0/9EMGRCJ56A0/9EMGRCJ56I4on0A/cBA0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOQwzp49S5UrV6b09HTpDTk//fQTde/ePbvVZMBTX+AJAHAnRIh1ERyJ4Kk38NQPERyJ4Kk38NQPERyJ4Kk38NQPERyJ4Kk3ongC/TBmtwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAD0pVy5cvTWW2+R6T0pzEzTp0/PZisl8NQXeAIA3AkRYl0ERyJ46g089UMERyJ46g089UMERyJ46g089UMERyJ46o0onkA/vLNbAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAPozbtw48vX1lX334MEDypMnT/YIWQGe+gJPAIA7IUKsi+BIBE+9gad+iOBIBE+9gad+iOBIBE+9gad+iOBIBE+9EcUT6IOBTbe8AwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAbYMxuAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwBzdBAwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANwK3AQNAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAcCtwEzQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADArfi/9u41Nuvy/AP41YOVg7XMALIhIGplHjAUykAEKVM5jIEaETeUDQLKIkEwMpywNyKHmqDJNuIJJ0WYgscMdI4RGW4CWxUBN9QOmAUE5Wgbzqf1/+IfiY9PKX1KWcvy+STPi/v63fd9Xc/Dy+bLTwgaAAAAAAAAgFpVWloaaWlpp/XJysqK7OzsaNWqVXTq1CnuuOOOmD59eqxataquv16dGzZsWMJvVVBQcEb7ffPfpqio6Iz2AwAAAAAAAIgQggYAAAAAAACgHjp69Gjs27cvPvvss/jggw/ipZdeiokTJ0Z+fn7k5eXF22+/XdcjAgAAAAAAAHAGCUEDAAAAAAAAcFZZs2ZN3HTTTTF9+vS6HgUAAAAAAACAMySzrgcAAAAAAAAA4H9fmzZtIj8/v9r7Dx06FGVlZVFSUhK7du1Kel5RURETJ06MZs2axciRI2tzVAAAAAAAAADqASFoAAAAAAAAAM64goKCKCoqqtHZkpKSePrpp2PmzJlx9OjRhGdjx46N3r17R+vWrWthSgAAAAAAAADqi/S6HgAAAAAAAAAAqtKuXbt4/PHHY/ny5ZGTk5Pw7MCBAzFlypQ6mqxuFBUVRUVFxYnPsmXL6nokAAAAAAAAgFonBA0AAAAAAADAWaFz587x/PPPJ9VffPHFOHDgQB1MBAAAAAAAAMCZIgQNAAAAAAAAwFlj4MCBkZ+fn1Dbt29fFBcX19FEAAAAAAAAAJwJQtAAAAAAAAAAnFX69euXVFu3bl0dTAIAAAAAAADAmZJZ1wMAAAAAAAAAQCpatmyZVCsvL0/5nqNHj8bf/va32Lx5c2zfvj2OHTsWF154YbRs2TK6desWjRo1qo1xY+fOnVFcXBybN2+OsrKyaNCgQTRt2jQuvPDC6NKlS+Tk5NRKn1QcPnw4Vq1aFf/4xz9iz549kZ2dHa1atYouXbpEixYt/uvzAAAAAAAAAHyTEDQAAAAAAAAAZ5Vdu3Yl1bKzs6t9ftWqVVFYWBiLFy+OvXv3VrqnQYMG0atXr5gwYUIUFBSkPOPRo0fj2WefjdmzZ8d777130n0ZGRnxve99LwYPHhwjR46M884775R3Dxs2LObMmXNi3bNnz1i2bFm15tq2bVtMnTo1XnjhhSgrK0t6npmZGf369YvJkydHhw4dqnUnAAAAAAAAwJmQXtcDAAAAAAAAAEAq1q5dm1Rr1arVKc+Vl5fHnXfeGZ07d45XXnnlpAHoiIhDhw7FW2+9Fb169YqBAwdWGrw+mZKSkmjfvn3ce++9VQagIyKOHz8eK1eujPvvvz8uv/zyeOutt6rdJ1XPPvts5ObmxhNPPFFpADoi4tixY7Fo0aLo0qVLzJgx44zNAgAAAAAAAHAq3gQNAAAAAAAAwFnj888/j9///vcJtfT09Lj++uurPLdly5b4wQ9+EP/85z9T7rlo0aK49tpr4w9/+EPk5uZWuXf9+vVx3XXXxe7du1Pu8/nnn8eAAQPi9ddfjwEDBqR8viqTJk2KadOmVXv/kSNH4uc//3lUVFTU6hwAAAAAAAAA1SUEDQAAAAAAAMBZ4fjx43HPPffEkSNHEur9+/ePCy644KTnysvLo6CgIP79738n1LOysmLw4MHRp0+faNu2bWRlZcXnn38eS5cujRdffDF27NhxYu+GDRvixhtvjDVr1sS3vvWtSvtUVFTEXXfdlRSA7tq1awwePDiuvvrquOCCCyItLS22b98eK1asiOeeey62bduW8B1HjBgRGzdujOzs7Gr/NlX57W9/W2kAun379jF8+PDIy8uL8847L7Zs2RJvvvlmvPjii3HgwIGIiHjwwQdrZQYAAAAAAACAVAlBAwAAAAAAAFDvffHFFzFmzJh44403EuoZGRnx8MMPV3l2xIgRSQHo7t27x7x586JNmzZJ+wcOHBiTJ0+O8ePHx6xZs07UN2/eHMOGDUt6E/VXli5dGsXFxQm1GTNmxAMPPFDp/n79+sWECRNiyJAhCd9r586dMXv27Ljvvvuq/F7VsXXr1hg3blxCLS0tLaZOnRoTJkyIjIyME/X8/Py49dZbY+LEifHjH/84iouLvQkaAAAAAAAAqDPpdT0AAAAAAAAAAHzdsWPHory8PD755JN47bXXYvTo0ZGbmxuvvPJK0t5HH3008vLyTnrXG2+8Ea+++mpCrU+fPrF06dJKA9BfOf/88+OZZ56JCRMmJNQXLlwYf/rTnyo9881w9I033njSAPRXsrOzY/78+UmzvPbaa1Weq67p06fHvn37EmqPPfZYPPTQQwkB6K+75JJLYsmSJdGpU6damQEAAAAAAACgJoSgAQAAAAAAADjj5syZE2lpadX6nHPOOdGkSZO44oor4rbbbosnnngiKciblpYWU6ZMOWXI+LHHHktYX3jhhbFgwYI455xzqjX39OnTIz8/P6E2Y8aMSvd++umnCeuOHTtWq0fjxo1j1KhRJ9YZGRmxY8eO034L8/79+6OoqCihVlBQEPfff/8pz55//vnx/PPPR1ZW1mnNAAAAAAAAAFBTQtAAAAAAAAAAnFWuueaaWLx4cUyaNKnKfZ988kksW7Ysofbggw9GTk5OtXulp6cnBa2XLFkSW7ZsSdr7zcDwihUrqt3nJz/5SSxevDjWr18fBw8ejI8++ijS0tKqfb4yixYtiv379yfUHnrooWqfv/LKK+POO+88rRkAAAAAAAAAakoIGgAAAAAAAIB6r2nTpjF06NB48803Y/Xq1XHTTTed8syf//znpNodd9yRcu9+/fpFRkZGQu2vf/1r0r7c3NyE9bvvvhtjx46NgwcPnrJHy5Yto3fv3nHZZZdV+y3Vp/L2228nrJs2bRo33HBDSncMHTq0VmYBAAAAAAAASFVmXQ8AAAAAAAAAwP++Nm3aRH5+flK9oqIiDh06FFu3bo0PP/wwKioqEp5ffPHF8bvf/S66deuWcs933303Yf3tb387vvOd76R8T05OTrRt2zY2bNhworZ8+fIYMmRIwr4hQ4bEo48+mlD79a9/HQsWLIjbb789+vfvHz179oyGDRumPENNFBcXJ6zz8/OTwtyncu2110ZmZmYcO3asNkcDAAAAAAAAOCUhaAAAAAAAAADOuIKCgigqKqpyz+bNm2PatGkxa9as+M9//hMREaWlpXHjjTdGYWFh3HfffSn1XLduXcL64MGDMWjQoJTu+EpZWVnC+tNPP03ac80118TgwYPjpZdeSqhv3749Zs6cGTNnzowGDRpEjx49ok+fPtG3b9+46qqrajRPdXw9tB0RcfXVV6d8R4MGDeLyyy+Pjz76qLbGAgAAAAAAAKgWIWgAAAAAAAAA6oXWrVvHU089Ff3794/bb789Dh8+HBH/H14eO3ZsfPzxx/Hkk09W+749e/YkrMvKyuLVV1+tlVm/efdXZs+eHVu2bImVK1dW+vzQoUOxZMmSWLJkSYwfPz7atGkTAwYMiEGDBkWPHj0iPT29VuYrKyuLAwcOJNSaNm1ao7suuugiIWgAAAAAAADgv652/noKAAAAAAAAALVkwIABMW/evEhLS0uoP/XUUzFp0qRq33OyoHJt+PLLLyutN2rUKN5555145JFHolGjRqe8Z9OmTTFz5swoKCiItm3bxsyZM+P48eOnPd/+/fuTatnZ2TW6q6bnAAAAAAAAAE6HEDQAAAAAAAAA9c6gQYPiF7/4RVJ92rRp8cwzz1TrjiNHjtT2WCd89Zbqypxzzjnxy1/+MrZt2xZPPfVUfP/734/MzMxT3rl58+YYM2ZMdO7cOXbt2nVa830zQH46GjRoUGt3AQAAAAAAAFSXEDQAAAAAAAAA9dLkyZOjS5cuSfVx48bFxx9/fMrzTZo0SVjffffdUVFRUSuf0tLSU/bPycmJUaNGxdtvvx27du2Kl156Ke6555649NJLqzy3evXq6NOnTxw6dOiUPU6mcePGSbXy8vIa3bV3794azwEAAAAAAABQU0LQAAAAAAAAANRLmZmZMXfu3GjYsGFC/eDBgzFkyJBTvun5ggsuSFhv2rSp1mesrpycnLj99tvj6aefjg0bNkRpaWk888wzMWDAgMjKykra/8EHH8STTz55Wv2+GYTesWNHje4qKyur8RwAAAAAAAAANSUEDQAAAAAAAEC9lZubG4888khSfc2aNTF16tQqz1588cVJZyoqKmpzvBpr06ZN3H333bFw4cL47LPPYsiQIUl75s+ff1o9Lr/88oT16tWra3TPunXrTmsOAAAAAAAAgJoQggYAAAAAAACgXhs3blx06tQpqV5YWBglJSUnPde9e/eE9Y4dO2LNmjU1muHpp5+OBQsWxN///vfYvn17pXuOHz8eGzZsiDfeeCOltzg3a9Ys5s6dG3l5eQn10w0fd+vWLWG9atWqOHDgQEp3bNy4MXbv3n1acwAAAAAAAADUhBA0AAAAAAAAAPVaRkZGzJo1KzIyMhLqR44ciVGjRp303PXXX59Ue+KJJ1Lu//7778fPfvaz+NGPfhRdu3aNFi1axOjRoxP2vPzyy9G4cePIzc2NAQMGxL333nvSsHRl0tPT46abbkqoHTx4MOVZv65v374J63379sUrr7yS0h3z5s07rRkAAAAAAAAAakoIGgAAAAAAAIB6Ly8vL8aMGZNUf+edd6KoqKjSM927d4/c3NyE2vPPPx8ffvhhSr0nTpyYVLvtttsS1u3bt4/Dhw8n1ObOnZtSn507dyasmzdvntL5b+rbt2+0aNEioTZlypRqh6v37NmT0hutAQAAAAAAAGqTEDQAAAAAAAAAZ4VHHnkkLrrooqT6+PHjY9euXUn19PT0eOCBBxJqR44ciUGDBlX7Lc2/+tWvYsmSJQm1Dh06RK9evRJq3/3ud+PKK69MqE2bNi22bt1arT7bt2+P119/PaHWo0ePap09mczMzKTvv379+hg9enRUVFRUefb48eNxzz33pPQ2awAAAAAAAIDaJAQNAAAAAAAAwFnhvPPOi9/85jdJ9d27d8f48eMrPTN8+PDo1KlTQm39+vXRtWvXWL58+Ul7HT9+PAoLC+P+++9PelZYWBhpaWlJ9bFjxyasv/zyy7jhhhti3bp1J+0TEbFt27b44Q9/GGVlZQn1UaNGVXmuOsaMGZP0NuzZs2fHXXfdFeXl5ZWe2bNnTwwePDheffXV0+4PAAAAAAAAUFOZdT0AAAAAAAAAAFTXLbfcEgMHDoyFCxcm1OfMmRPDhg2LgoKChHpWVla8/PLL0bFjx4SQcWlpaXTv3j169+4dt956a1xxxRWRk5MTu3fvjuLi4pgzZ06UlJQk9R83blz06dOn0tlGjBgRzz77bLz33nsnaiUlJZGXlxc333xz9O3bN9q1axfZ2dlx8ODBKC0tjWXLlsULL7wQe/fuTfqeN9xwQ4q/TrJzzz035s+fH9ddd10cOnToRP2FF16IpUuXxvDhw6OgoCCaNm0aO3bsiKVLl8bs2bMT3qzdpEmTpIA2AAAAAAAAwJmWVlFRUVHXQwAAAAAAAADwv6O0tDTatm2bUPvpT38aRUVFtXL/5s2b48orr4z9+/cn1Nu1axdr166Nc889N+nMqlWrYuDAgbFt27Ya9x06dGg899xzkZl58v9vfOPGjdGzZ8/YunVrjfvk5eXF0qVLo0mTJpU+HzZsWMyZM+fEumfPnrFs2bIq7/zjH/8Yt9xySxw+fDilWcaOHRsbNmyIN99880Rt9uzZMWzYsJTuAQAAAAAAAEhVel0PAAAAAAAAAACpaN26dTz88MNJ9ZKSkpg+fXqlZzp16hTFxcXRu3fvlPs1bNgwCgsLY86cOVUGoCMiLr300vjLX/4SXbt2TblPRMSdd94Zy5YtO2kAuqb69u0bK1asiMsuu6zaZ0aOHBkzZsyo1TkAAAAAAAAAqksIGgAAAAAAAICzztixY6NDhw5J9cLCwigpKan0TMuWLWPx4sXxzjvvxM033xzZ2dlV9mjevHk88MAD8fHHH8eDDz4YaWlp1ZrtkksuiRUrVsS8efOiV69ekZ5e9Z/mGzVqFHfccUesXLky5s2bF+eff361+qSqY8eOsW7dunj88cerDEN36NAhXn755Zg1a9YpQ98AAAAAAAAAZ0paRUVFRV0PAQAAAAAAAAD/bUePHo3i4uLYtGlT7Ny5M/bt2xfZ2dnRrFmzyMvLi3bt2lU7+FyVvXv3xtq1a+Nf//pXlJeXx/79+yMrKyuaN28e7dq1i06dOkVWVlYtfKPUrFu3Lt5///344osvIjMzM1q2bBnt27ePq6666r8+CwAAAAAAAMA3CUEDAAAAAAAAAAAAAAAAAAD1SnpdDwAAAAAAAAAAAAAAAAAAAPB1QtAAAAAAAAAAAAAAAAAAAEC9IgQNAAAAAAAAAAAAAAAAAADUK0LQAAAAAAAAAAAAAAAAAABAvSIEDQAAAAAAAAAAAAAAAAAA1CtC0AAAAAAAAAAAAAAAAAAAQL0iBA0AAAAAAAAAAAAAAAAAANQrQtAAAAAAAAAAAAAAAAAAAEC9IgQNAAAAAAAAAAAAAAAAAADUK0LQAAAAAAAAAAAAAAAAAABAvSIEDQAAAAAAAAAAAAAAAAAA1CtC0AAAAAAAAAAAAAAAAAAAQL0iBA0AAAAAAAAAAAAAAAAAANQrQtAAAAAAAAAAAAAAAAAAAEC9IgQNAAAAAAAAAAAAAAAAAADUK0LQAAAAAAAAAAAAAAAAAABAvSIEDQAAAAAAAAAAAAAAAAAA1Cv/B8ntsG4GD7JlAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# APO state only\n", + "\n", + "import numpy as np\n", + "\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(40, 10), sharey=True, sharex=True)\n", + "\n", + "ana_apo_1.plot_kex_bar(\n", + " ax=axes[0], resolution_indicator_pos=15, label=\"APO\", show_seq=False, color=\"k\"\n", + ")\n", + "\n", + "ana_tri_1.plot_kex_bar(\n", + " ax=axes[1], resolution_indicator_pos=15, label=\"TRI\", show_seq=False, color=\"red\"\n", + ")\n", + "\n", + "from matplotlib.pyplot import step\n", + "from matplotlib.ticker import FuncFormatter, MultipleLocator\n", + "\n", + "from pigeon_feather.analysis import get_index_offset\n", + "\n", + "pdb_file = \"./data/6XG5_TRI.pdb\"\n", + "index_offset = get_index_offset(ana_apo_1, pdb_file)\n", + "\n", + "# # ax.xaxis.set_major_locator(plt.MultipleLocator(2))\n", + "axes[0].set_xticks(axes[0].get_xticks()[::2])\n", + "axes[0].set_xticklabels(axes[0].get_xticklabels(), fontdict={\"fontsize\": 24})\n", + "\n", + "\n", + "def format_func(value, tick_number):\n", + " return f\"{int(value - index_offset +1)}\"\n", + "\n", + "\n", + "axes[0].xaxis.set_major_formatter(FuncFormatter(format_func))\n", + "\n", + "seq_pos = 17\n", + "for ii in range(0, len(ana_apo_1.protein_sequence[:]), 2):\n", + " axes[0].text(\n", + " ii,\n", + " seq_pos,\n", + " ana_apo_1.protein_sequence[ii],\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " fontsize=22,\n", + " )\n", + "\n", + "\n", + "for ax in axes:\n", + " ax.set_ylabel(\"-log(k$_{ex}$)\")\n", + " #ax.legend(loc=\"lower left\")\n", + " ax.yaxis.set_major_locator(plt.MultipleLocator(5))\n", + "\n", + " ax.plot(\n", + " [-3, len(ana_apo_1.protein_sequence) + 3],\n", + " [5, 5],\n", + " color=\"gray\",\n", + " lw=1,\n", + " linestyle=\"--\",\n", + " alpha=0.5,\n", + " )\n", + " ax.plot(\n", + " [-3, len(ana_apo_1.protein_sequence) + 3],\n", + " [10, 10],\n", + " color=\"gray\",\n", + " lw=1,\n", + " linestyle=\"--\",\n", + " alpha=0.5,\n", + " )\n", + "\n", + "\n", + "plt.subplots_adjust(hspace=0.08)\n", + "fig.savefig(f\"{results_path}/ecDHFR_kex_bar_APO_TRI_{today_date}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "logP projection to a pdb structure" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import BFactorPlot" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "bfactor_plot = BFactorPlot(\n", + " ana_apo_1,\n", + " pdb_file=\"./data/6XG5_TRI.pdb\",\n", + " plot_deltaG=True,\n", + " temperature=293.15,\n", + " logP_threshold=10,\n", + ")\n", + "bfactor_plot.plot(f\"{results_path}/6XG5_APO_deltaG.pdb\")\n", + "\n", + "# bfactor_plot = BFactorPlot(\n", + "# ana_apo_1,\n", + "# pdb_file=\"./data/6XG5_APO_relaxed_best_solvated.pdb\",\n", + "# plot_deltaG=True,\n", + "# temperature=293.15,\n", + "# )\n", + "# bfactor_plot.plot(f\"{out_path}/6XG5_APO_deltaG.pdb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "delta logP" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "if there are mutiple states availble, one can map the difference to the pdb strutcure" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "bfactor_plot = BFactorPlot(\n", + " ana_apo_1,\n", + " ana_tri_1, \n", + " pdb_file=\"./data/6XG5_TRI.pdb\",\n", + " plot_deltaG=True,\n", + " temperature=293.15,\n", + " logP_threshold=10,\n", + ")\n", + "bfactor_plot.plot(f\"{results_path}/6XG5_deltaG_APO-TRI.pdb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "export logPFs to a csv" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "import MDAnalysis\n", + "from pigeon_feather.analysis import get_res_avg_logP, get_res_avg_logP_std\n", + "\n", + "pdb_file = \"./data/6XG5_TRI.pdb\"\n", + "index_offset = get_index_offset(ana_apo_1, pdb_file)\n", + "\n", + "\n", + "def logPF_to_deltaG(ana_obj, logPF):\n", + " \"\"\"\n", + " :param logPF: logP value\n", + " :return: deltaG in kJ/mol, local unfolding energy\n", + " \"\"\"\n", + "\n", + " return 8.3145 * ana_obj.temperature * np.log(10) * logPF / 1000\n", + "\n", + "\n", + "def create_logP_df(ana_obj, index_offset):\n", + " df_logPF = pd.DataFrame()\n", + "\n", + " for res_i, _ in enumerate(ana_obj.results_obj.protein_sequence):\n", + " res_obj_i = ana_obj.results_obj.get_residue_by_resindex(res_i)\n", + "\n", + " avg_logP, std_logP = get_res_avg_logP(res_obj_i)\n", + " #std_logP = get_res_avg_logP_std(res_obj_i)\n", + "\n", + " df_i = pd.DataFrame(\n", + " {\n", + " \"resid\": [res_obj_i.resid - index_offset],\n", + " #\"resname\": [res_obj_i.resname],\n", + " \"resname\": [MDAnalysis.lib.util.convert_aa_code(res_obj_i.resname)],\n", + " 'avg_dG': [logPF_to_deltaG(ana_obj, avg_logP)],\n", + " 'std_dG': [logPF_to_deltaG(ana_obj, std_logP)],\n", + " \"avg_logP\": [avg_logP],\n", + " \"std_logP\": [max(std_logP, 0.35)],\n", + " \"is_nan\": [res_obj_i.is_nan()],\n", + " }\n", + " )\n", + "\n", + " if res_obj_i.is_nan():\n", + " df_i[\"single resloved\"] = [np.nan]\n", + " df_i[\"min_pep logPs\"] = [np.nan]\n", + "\n", + " else:\n", + " df_i[\"single resloved\"] = [res_obj_i.mini_pep.if_single_residue()]\n", + " df_i[\"min_pep logPs\"] = [res_obj_i.clustering_results_logP]\n", + "\n", + " df_logPF = pd.concat([df_logPF, df_i])\n", + "\n", + " df_logPF = df_logPF.reset_index(drop=True)\n", + "\n", + " return df_logPF\n", + "\n", + "\n", + "df = create_logP_df(ana_apo_1, index_offset)\n", + "df.to_csv(f\"{results_path}/logP_APO_{today_date}.csv\", index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "# fecth two df and merge\n", + "df_apo = create_logP_df(ana_apo_1, index_offset)\n", + "df_tri = create_logP_df(ana_tri_1, index_offset)\n", + "\n", + "df = pd.merge(df_apo, df_tri, on=\"resid\", suffixes=(\"_APO\", \"_TRI\"))\n", + "\n", + "df.to_csv(f\"{results_path}/logP_APO_TRI_{today_date}.csv\", index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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.11.8" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/01_load_data.html b/tutorials/01_load_data.html new file mode 100644 index 0000000..4630822 --- /dev/null +++ b/tutorials/01_load_data.html @@ -0,0 +1,288 @@ + + + + + + + 01_load_data — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

01_load_data

+

In principle, FEATHER can accept the output from any HX/MS software.

+

There are two types of input files: 1. Peptide pools with centroid deuteration values 2. Raw mass spectra (deconvoluted)

+
+

Read the centroid data

+
    +

  • Table: The peptide pool.

    • +

  • Range List: A file that defines the peptides to include or exclude.

    • +

  • n_fastamides: In an HDX experiment, the first two residues of a peptide at the N-terminus do not contribute to deuterium uptake due to rapid back exchange.

    • +

  • Saturation: The percentage of deuterium in the D2O buffer.

    • +
+
+
[6]:
+
+
+
from pigeon_feather.data import *
+from pigeon_feather.plot import *
+from pigeon_feather.hxio import *
+from pigeon_feather.spectra import *
+
+
+import numpy as np
+import pandas as pd
+
+import datetime
+import os
+import pickle
+import datetime
+
+
+
+
+
[2]:
+
+
+
tables = ['./data/ecDHFR_tutorial.csv']
+
+ranges = ['./data/rangeslist.csv']
+
+
+raw_spectra_paths = [
+    f"./data/SpecExport/",
+]
+
+protein_sequence = "MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR"
+
+# load the data
+hdxms_data_list = []
+for i in range(len(tables)):
+    # for i in [4]:
+    print(tables[i])
+
+    # read the data and clean it
+    cleaned = read_hdx_tables([tables[i]], [ranges[i]], exclude=False, states_subset=['APO','TRI'])
+
+    # convert the cleaned data to hdxms data object
+    hdxms_data = load_dataframe_to_hdxmsdata(
+        cleaned,
+        n_fastamides=2,
+        protein_sequence=protein_sequence,
+        fulld_approx=False,
+        saturation=0.9,
+    )
+
+    hdxms_data_list.append(hdxms_data)
+

+
+
+
+
+
+
+
+./data/ecDHFR_tutorial.csv
+rangeslist included !
+
+
+

check the basic statics_info of the hdxms_data_list

+
+
[3]:
+
+
+
from pigeon_feather.hxio import get_all_statics_info
+
+get_all_statics_info(hdxms_data_list)
+
+
+
+
+
+
+
+
+============================================================
+                    HDX-MS Data Statistics
+============================================================
+States names: ['APO', 'TRI']
+Time course (s): [46.0, 373.5, 572.5, 2011.0, 7772.0, 30811.5, 43292.0]
+Number of time points: 7
+Protein sequence length: 174
+Average coverage: 0.97
+Number of unique peptides: 261
+Average peptide length: 9.8
+Redundancy (based on average coverage): 14.7
+Average peptide length to redundancy ratio: 0.7
+Backexchange average, IQR: 0.27, 0.26
+============================================================
+
+
+
+
+

Load the raw spectrum

+
+
[4]:
+
+
+
# spectrum could be easily loaded to the hdxms_data object
+for i in range(len(tables)):
+    load_raw_ms_to_hdxms_data(
+        hdxms_data,
+        raw_spectra_paths[i],
+    )
+
+
+
+
+
+
+
+
+Removed 0 peptides from state APO due to missing raw MS data.
+Removed 70 peptides from state APO due to high back exchange.
+Removed 2 peptides from state TRI due to missing raw MS data.
+Removed 70 peptides from state TRI due to high back exchange.
+Done loading raw MS data.
+
+
+

Note: One common error is that the correct spectra file cannot be found. Please ensure that the protein_state.state_name corresponds to the files in the spectrum folder, with the correct time points and charge states.

+
+
[7]:
+
+
+
# save the raw data as a pickle file
+import pickle
+
+today = datetime.date.today().strftime("%Y%m%d")
+today = "20240722"
+
+with open(f"./data/hdxms_data_raw_{today}.pkl", "wb") as f:
+    pickle.dump(hdxms_data_list, f)
+
+# with open(f"./data/hdxms_data_raw_{today}.pkl", "rb") as f:
+#     hdxms_data_list = pickle.load(f)
+
+
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/tutorials/01_load_data.ipynb b/tutorials/01_load_data.ipynb new file mode 100644 index 0000000..c2f9901 --- /dev/null +++ b/tutorials/01_load_data.ipynb @@ -0,0 +1,227 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 01_load_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In principle, FEATHER can accept the output from any HX/MS software.\n", + "\n", + "There are two types of input files:\n", + "1. Peptide pools with centroid deuteration values\n", + "2. Raw mass spectra (deconvoluted)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Read the centroid data " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* **Table:** The peptide pool.\n", + "* **Range List:** A file that defines the peptides to include or exclude.\n", + "* **n_fastamides:** In an HDX experiment, the first two residues of a peptide at the N-terminus do not contribute to deuterium uptake due to rapid back exchange.\n", + "* **Saturation:** The percentage of deuterium in the D2O buffer.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "./data/ecDHFR_tutorial.csv\n", + "rangeslist included !\n" + ] + } + ], + "source": [ + "tables = ['./data/ecDHFR_tutorial.csv']\n", + "\n", + "ranges = ['./data/rangeslist.csv']\n", + "\n", + "\n", + "raw_spectra_paths = [\n", + " f\"./data/SpecExport/\",\n", + "]\n", + "\n", + "protein_sequence = \"MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR\"\n", + "\n", + "# load the data\n", + "hdxms_data_list = []\n", + "for i in range(len(tables)):\n", + " # for i in [4]:\n", + " print(tables[i])\n", + "\n", + " # read the data and clean it\n", + " cleaned = read_hdx_tables([tables[i]], [ranges[i]], exclude=False, states_subset=['APO','TRI'])\n", + " \n", + " # convert the cleaned data to hdxms data object\n", + " hdxms_data = load_dataframe_to_hdxmsdata(\n", + " cleaned,\n", + " n_fastamides=2,\n", + " protein_sequence=protein_sequence,\n", + " fulld_approx=False,\n", + " saturation=0.9,\n", + " )\n", + "\n", + " hdxms_data_list.append(hdxms_data)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "check the basic statics_info of the hdxms_data_list" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "============================================================\n", + " HDX-MS Data Statistics\n", + "============================================================\n", + "States names: ['APO', 'TRI']\n", + "Time course (s): [46.0, 373.5, 572.5, 2011.0, 7772.0, 30811.5, 43292.0]\n", + "Number of time points: 7\n", + "Protein sequence length: 174\n", + "Average coverage: 0.97\n", + "Number of unique peptides: 261\n", + "Average peptide length: 9.8\n", + "Redundancy (based on average coverage): 14.7\n", + "Average peptide length to redundancy ratio: 0.7\n", + "Backexchange average, IQR: 0.27, 0.26\n", + "============================================================\n" + ] + } + ], + "source": [ + "from pigeon_feather.hxio import get_all_statics_info\n", + "\n", + "get_all_statics_info(hdxms_data_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load the raw spectrum" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Removed 0 peptides from state APO due to missing raw MS data.\n", + "Removed 70 peptides from state APO due to high back exchange.\n", + "Removed 2 peptides from state TRI due to missing raw MS data.\n", + "Removed 70 peptides from state TRI due to high back exchange.\n", + "Done loading raw MS data.\n" + ] + } + ], + "source": [ + "# spectrum could be easily loaded to the hdxms_data object\n", + "for i in range(len(tables)):\n", + " load_raw_ms_to_hdxms_data(\n", + " hdxms_data,\n", + " raw_spectra_paths[i],\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** One common error is that the correct spectra file cannot be found. Please ensure that the `protein_state.state_name` corresponds to the files in the spectrum folder, with the correct time points and charge states." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# save the raw data as a pickle file\n", + "import pickle\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"wb\") as f:\n", + " pickle.dump(hdxms_data_list, f)\n", + "\n", + "# with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + "# hdxms_data_list = pickle.load(f)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/02_peptide_level_analysis.html b/tutorials/02_peptide_level_analysis.html new file mode 100644 index 0000000..444ee8e --- /dev/null +++ b/tutorials/02_peptide_level_analysis.html @@ -0,0 +1,567 @@ + + + + + + + 02_peptide_level_analysis — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

02_peptide_level_analysis

+
+
[1]:
+
+
+
from pigeon_feather.data import *
+from pigeon_feather.plot import *
+from pigeon_feather.hxio import *
+from pigeon_feather.spectra import *
+
+
+import numpy as np
+import pandas as pd
+
+import datetime
+import os
+import pickle
+import datetime
+
+
+
+
+
+
+
+
+Determination of memory status is not supported on this
+ platform, measuring for memoryleaks will never fail
+
+
+
+
[2]:
+
+
+
# load the pickle file we saved in the previous notebook
+today = datetime.date.today().strftime("%Y%m%d")
+today = "20240722"
+
+with open(f"./data/hdxms_data_raw_{today}.pkl", "rb") as f:
+    hdxms_data_list = pickle.load(f)
+
+
+# back exchange correction for peptides with experimental full deuteration data based its closest match in the database
+tools.backexchange_correction(hdxms_data_list)
+
+
+
+
+
+
+
+
+Number of peptides with experimental max_d: 358
+Number of peptides with no experimental max_d: 12
+
+
+
+
[3]:
+
+
+
# make folders for results
+
+out_path = "./data/PF_input_20240722"
+
+today_date = datetime.date.today().strftime("%Y%m%d")
+# today_date = '20240722'
+results_path = f"ecDHFR_results_{today_date}"
+
+if not os.path.exists(results_path):
+    os.makedirs(results_path)
+
+
+
+
+

uptake plots

+
+
[4]:
+
+
+
# option 1
+from matplotlib.ticker import MultipleLocator, FormatStrFormatter
+import matplotlib.ticker as ticker
+import matplotlib.lines as mlines
+from pigeon_feather.analysis import get_index_offset
+from matplotlib.ticker import LogLocator
+
+
+font = {"family": "Arial", "weight": "normal", "size": 36}
+axes = {"titlesize": 36, "titleweight": "bold", "labelsize": 36, "linewidth": 5}
+plt.rc("font", **font)
+plt.rc("axes", **axes)
+plt.rc("lines", lw=5)
+
+colors = ["k", "red", "blue", "purple", "gray", "orange", "yellow", "green", "brown"]
+
+
+all_peps = [
+    peptide
+    for hdxms_data in hdxms_data_list
+    for state in hdxms_data.states
+    for peptide in state.peptides
+    if peptide.note is None and state.state_name != "RAT"
+]
+all_idfs = [pep for pep in all_peps if pep.unique_num_timepoints > 5]
+all_idfs = list(set([peptide.identifier for peptide in all_peps]))[:]
+all_idfs.sort(key=lambda x: int(re.search(r"(-?\d+)", x).group()))
+
+
+
+def idf_to_pep(idf):
+    return [pep for pep in all_peps if pep.identifier == idf][0]
+
+# num_subplots_per_figure = 100
+num_subplots_per_figure = 250
+num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)
+
+
+all_idfs_subset = all_idfs[:]
+
+for fig_index in range(num_figures):
+    # Select the subset of errors for the current figure
+    selected_idf = all_idfs_subset[
+        fig_index * num_subplots_per_figure : (fig_index + 1) * num_subplots_per_figure
+    ]
+    num_col = math.ceil(len(selected_idf) / 5)
+
+    fig, axs = plt.subplots(
+        num_col, 5, figsize=(9 * 5, 8 * num_col)
+    )  # Adjust subplot size as needed
+
+    for i, idf in enumerate(selected_idf):
+        ax = axs[i // 5, i % 5]
+
+
+        pep = idf_to_pep(idf)
+        ax.axhline(y=pep.max_d, color='lightgray', linestyle='--', linewidth=5)
+
+
+        uptake = UptakePlot(
+            hdxms_data_list,
+            idf,
+            states_subset=["APO", "TRI"],
+            if_plot_fit=False,
+            figure=fig,
+            ax=ax,
+        )
+
+        ax.set_xlim(1e1, 1e5)
+        ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))
+
+
+        y_max = pep.theo_max_d/hdxms_data_list[0].saturation
+        ax.set_ylim(-0.5, y_max + 0.5)
+
+
+        #Custom legend
+        handles, labels = ax.get_legend_handles_labels()
+        new_labels = [label for label in labels if label in ["APO", "TRI"]]
+        new_handles = [
+            handle
+            for handle, label in zip(handles, labels)
+            if label in ["APO", "TRI"]
+        ]
+        ax.legend(new_handles, new_labels, title="state", title_fontsize="small",loc='best')
+
+
+    # Layout adjustment and save
+    fig.tight_layout()
+    fig.savefig(f"{results_path}/DHFR_exp_uptake_{fig_index}.pdf")
+
+
+
+
+
+

pipetide comparison

+

Since the peptide-level comparison can only happen at the same time point between different states, let’s group timepoints within 50 seconds as the same timepoint.

+
+
[5]:
+
+
+
all_peptides = [
+    peptide
+    for hdxms_data in hdxms_data_list
+    for state in hdxms_data.states
+    for peptide in state.peptides
+]
+
+
+all_tps = [
+    tp
+    for pep in all_peptides
+    for tp in pep.timepoints
+    if tp.deut_time != np.inf and tp.deut_time != 0
+]
+
+tps_range = list(set([tp.deut_time for tp in all_tps]))
+
+
+# Step 1: Sort the values
+sorted_values = sorted(tps_range)
+
+# Step 2: Group values with offsets less than 50
+groups = []
+current_group = []
+
+for value in sorted_values:
+    if current_group and value - current_group[-1] > 50:
+        groups.append(current_group)
+        current_group = []
+    current_group.append(value)
+
+# Add the last group if not empty
+if current_group:
+    groups.append(current_group)
+
+# Step 3: Calculate average and map values to the average integer
+result_mapping = {}
+for group in groups:
+    average = int(round(sum(group) / len(group)))
+    for value in group:
+        result_mapping[value] = average
+
+result_mapping
+
+
+for tp in all_tps:
+    tp.deut_time = result_mapping[tp.deut_time]
+
+
+
+

HDXStatePeptideCompares can be created between two different states for comparison. It is a collection of all possible HDXStatePeptideCompare, where the same peptides are in both Proteinstate. HDXStatePeptideCompare will find all the common timepoints and get the difference in D uptake.

+
+
[6]:
+
+
+
state1 = 'APO'
+state2 = 'TRI'
+
+# first get the states
+state1_list = [i.get_state(state1) for i in hdxms_data_list]
+state2_list = [i.get_state(state2) for i in hdxms_data_list]
+
+pep_compres = HDXStatePeptideCompares(state1_list, state2_list)
+pep_compres.add_all_compare()
+
+
+
+
+
[7]:
+
+
+
# check the results
+for i in pep_compres.peptide_compares[:10]:
+    print('-----------------')
+    print(i.compare_info)
+    print(i.common_timepoints)
+    print(i.deut_diff)
+
+
+
+
+
+
+
+
+-----------------
+APO-TRI: 12-19 LYFQSISL
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.   -4.73 -1.3  -0.29  5.06  9.5  18.34 17.01  0.  ]
+-----------------
+APO-TRI: 13-19 YFQSISL
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.   -2.57 -2.44  1.23  4.42 11.45 19.75 17.73  0.  ]
+-----------------
+APO-TRI: 14-19 FQSISL
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.   -1.09 -1.89  0.65  3.5  12.59 24.48 21.75  0.  ]
+-----------------
+APO-TRI: 15-19 QSISL
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.   -0.61 -1.31  2.52  5.73 16.05 27.09 24.22  0.  ]
+-----------------
+APO-TRI: 15-20 QSISLI
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.   -1.09 -1.89  0.65  3.5  14.26 24.48 21.75  0.  ]
+-----------------
+APO-TRI: 15-16 QS
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[  0.    -0.76 -11.12   3.54  -1.2   -0.19  -0.25  -2.84   0.  ]
+-----------------
+APO-TRI: 16-19 SISL
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.    0.51 -0.38  2.61  6.68 18.21 31.39 29.12  0.  ]
+-----------------
+APO-TRI: 22-27 ALAVDR
+[    0.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.   28.87 37.37 35.11 11.44  2.48 -0.88  0.  ]
+-----------------
+APO-TRI: 22-31 ALAVDRVIGM
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.   14.41 30.25 38.46 28.2   8.77 -0.53 -4.59  0.  ]
+-----------------
+APO-TRI: 22-26 ALAVD
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.   10.6  30.79 36.83 29.21 14.64  4.28  1.39  0.  ]
+
+
+
+
+

pseudo residue compare

+

pseudo residue compare is a comparison of the average D uptake between two different Proteinstate of all the peptides that cover this residue. D here is the normalized values based on the full-D experiments (0-100)

+
+
[8]:
+
+
+
res_compares = HDXStateResidueCompares([i for i in range(1, 320)], state1_list, state2_list)
+res_compares.add_all_compare()
+
+
+
+
+
[9]:
+
+
+
# check the results
+# deut_diff is the average deuteration difference of all peptides covering the residue
+for i in res_compares.residue_compares[:5]:
+    print('-----------------')
+    print(i.compare_info)
+    print(i.common_timepoints)
+    print(i.deut_diff)
+
+
+
+
+
+
+
+
+-----------------
+APO-TRI: 12
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.   -4.73 -1.3  -0.29  5.06  9.5  18.34 17.01  0.  ]
+-----------------
+APO-TRI: 13
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.    -3.65  -1.87   0.47   4.74  10.475 19.045 17.37   0.   ]
+-----------------
+APO-TRI: 14
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.         -2.79666667 -1.87666667  0.53        4.32666667 11.18
+ 20.85666667 18.83        0.        ]
+-----------------
+APO-TRI: 15
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.         -1.80833333 -3.325       1.38333333  3.50166667 10.61
+ 18.98166667 16.60333333  0.        ]
+-----------------
+APO-TRI: 16
+[    0.    46.   374.   572.  2011.  7772. 30812. 43292.    inf]
+[ 0.         -1.47714286 -2.90428571  1.55857143  3.95571429 11.69571429
+ 20.75428571 18.39142857  0.        ]
+
+
+
+
+

visualization on pymol structure

+

Both comparison objects can be projected to a pdb structure for Visualization

+
+
[10]:
+
+
+
# both of the compare objects can be exported as a pymol pse file for visualization
+pdb_file = 'data/6XG5_TRI.pdb'
+
+create_compare_pymol_plot(pep_compres, colorbar_max=20, pdb_file=pdb_file, path=f'{results_path}')
+create_compare_pymol_plot(res_compares, colorbar_max=20, pdb_file=pdb_file, path=f'{results_path}')
+
+
+
+
+
[11]:
+
+
+
#  it can be visualized as a heatmap
+create_heatmap_compare_tp(pep_compres, 20)
+
+
+
+
+
[11]:
+
+
+
+../_images/tutorials_02_peptide_level_analysis_19_0.png +
+
+
+
[12]:
+
+
+
# make all the plots and save them
+
+from itertools import product
+
+items =[state.state_name for hdxms_data in hdxms_data_list for state in hdxms_data.states]
+combinations = product(['APO'], [x for x in items if x != 'APO'])
+
+for state1_name, state2_name in combinations:
+
+    state1_list = [i.get_state(state1_name) for i in hdxms_data_list]
+    state2_list = [i.get_state(state2_name) for i in hdxms_data_list]
+
+    compare = HDXStatePeptideCompares(state1_list, state2_list)
+    compare.add_all_compare()
+
+    heatmap_compare_tp = create_heatmap_compare_tp(compare, 20)
+    heatmap_compare_tp.savefig(f'{results_path}/{state1}-{state2}-heatmap-tp.png')
+
+    heatmap_compare = create_heatmap_compare(compare, 20)
+    heatmap_compare.savefig(f'{results_path}/{state1}-{state2}-heatmap.png')
+
+    create_compare_pymol_plot(compare, colorbar_max=20, pdb_file=pdb_file, path=results_path)
+
+
+
+    res_compares = HDXStateResidueCompares([i for i in range(1, 320)], state1_list, state2_list)
+    res_compares.add_all_compare()
+
+    create_compare_pymol_plot(res_compares, 20, pdb_file=pdb_file, path=results_path)
+
+
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/tutorials/02_peptide_level_analysis.ipynb b/tutorials/02_peptide_level_analysis.ipynb new file mode 100644 index 0000000..9bd3d0e --- /dev/null +++ b/tutorials/02_peptide_level_analysis.ipynb @@ -0,0 +1,524 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 02_peptide_level_analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Determination of memory status is not supported on this \n", + " platform, measuring for memoryleaks will never fail\n" + ] + } + ], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "# load the pickle file we saved in the previous notebook\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)\n", + "\n", + "\n", + "# back exchange correction for peptides with experimental full deuteration data based its closest match in the database\n", + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "out_path = \"./data/PF_input_20240722\"\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = f\"ecDHFR_results_{today_date}\"\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## uptake plots" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# option 1\n", + "from matplotlib.ticker import MultipleLocator, FormatStrFormatter\n", + "import matplotlib.ticker as ticker\n", + "import matplotlib.lines as mlines\n", + "from pigeon_feather.analysis import get_index_offset\n", + "from matplotlib.ticker import LogLocator\n", + "\n", + "\n", + "font = {\"family\": \"Arial\", \"weight\": \"normal\", \"size\": 36}\n", + "axes = {\"titlesize\": 36, \"titleweight\": \"bold\", \"labelsize\": 36, \"linewidth\": 5}\n", + "plt.rc(\"font\", **font)\n", + "plt.rc(\"axes\", **axes)\n", + "plt.rc(\"lines\", lw=5)\n", + "\n", + "colors = [\"k\", \"red\", \"blue\", \"purple\", \"gray\", \"orange\", \"yellow\", \"green\", \"brown\"]\n", + "\n", + "\n", + "all_peps = [\n", + " peptide\n", + " for hdxms_data in hdxms_data_list\n", + " for state in hdxms_data.states\n", + " for peptide in state.peptides\n", + " if peptide.note is None and state.state_name != \"RAT\"\n", + "]\n", + "all_idfs = [pep for pep in all_peps if pep.unique_num_timepoints > 5]\n", + "all_idfs = list(set([peptide.identifier for peptide in all_peps]))[:]\n", + "all_idfs.sort(key=lambda x: int(re.search(r\"(-?\\d+)\", x).group()))\n", + "\n", + "\n", + "\n", + "def idf_to_pep(idf):\n", + " return [pep for pep in all_peps if pep.identifier == idf][0]\n", + "\n", + "# num_subplots_per_figure = 100\n", + "num_subplots_per_figure = 250\n", + "num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)\n", + "\n", + "\n", + "all_idfs_subset = all_idfs[:]\n", + "\n", + "for fig_index in range(num_figures):\n", + " # Select the subset of errors for the current figure\n", + " selected_idf = all_idfs_subset[\n", + " fig_index * num_subplots_per_figure : (fig_index + 1) * num_subplots_per_figure\n", + " ]\n", + " num_col = math.ceil(len(selected_idf) / 5)\n", + "\n", + " fig, axs = plt.subplots(\n", + " num_col, 5, figsize=(9 * 5, 8 * num_col)\n", + " ) # Adjust subplot size as needed\n", + "\n", + " for i, idf in enumerate(selected_idf):\n", + " ax = axs[i // 5, i % 5]\n", + "\n", + "\n", + " pep = idf_to_pep(idf)\n", + " ax.axhline(y=pep.max_d, color='lightgray', linestyle='--', linewidth=5)\n", + "\n", + "\n", + " uptake = UptakePlot(\n", + " hdxms_data_list,\n", + " idf,\n", + " states_subset=[\"APO\", \"TRI\"],\n", + " if_plot_fit=False,\n", + " figure=fig,\n", + " ax=ax,\n", + " )\n", + "\n", + " ax.set_xlim(1e1, 1e5)\n", + " ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))\n", + "\n", + "\n", + " y_max = pep.theo_max_d/hdxms_data_list[0].saturation\n", + " ax.set_ylim(-0.5, y_max + 0.5)\n", + "\n", + "\n", + " #Custom legend\n", + " handles, labels = ax.get_legend_handles_labels()\n", + " new_labels = [label for label in labels if label in [\"APO\", \"TRI\"]]\n", + " new_handles = [\n", + " handle\n", + " for handle, label in zip(handles, labels)\n", + " if label in [\"APO\", \"TRI\"] \n", + " ]\n", + " ax.legend(new_handles, new_labels, title=\"state\", title_fontsize=\"small\",loc='best')\n", + "\n", + "\n", + " # Layout adjustment and save\n", + " fig.tight_layout()\n", + " fig.savefig(f\"{results_path}/DHFR_exp_uptake_{fig_index}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## pipetide comparison" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Since the peptide-level comparison can only happen at the same time point between different states, let's group timepoints within 50 seconds as the same timepoint.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "all_peptides = [\n", + " peptide\n", + " for hdxms_data in hdxms_data_list\n", + " for state in hdxms_data.states\n", + " for peptide in state.peptides\n", + "]\n", + "\n", + "\n", + "all_tps = [\n", + " tp\n", + " for pep in all_peptides\n", + " for tp in pep.timepoints\n", + " if tp.deut_time != np.inf and tp.deut_time != 0\n", + "]\n", + "\n", + "tps_range = list(set([tp.deut_time for tp in all_tps]))\n", + "\n", + "\n", + "# Step 1: Sort the values\n", + "sorted_values = sorted(tps_range)\n", + "\n", + "# Step 2: Group values with offsets less than 50\n", + "groups = []\n", + "current_group = []\n", + "\n", + "for value in sorted_values:\n", + " if current_group and value - current_group[-1] > 50:\n", + " groups.append(current_group)\n", + " current_group = []\n", + " current_group.append(value)\n", + "\n", + "# Add the last group if not empty\n", + "if current_group:\n", + " groups.append(current_group)\n", + "\n", + "# Step 3: Calculate average and map values to the average integer\n", + "result_mapping = {}\n", + "for group in groups:\n", + " average = int(round(sum(group) / len(group)))\n", + " for value in group:\n", + " result_mapping[value] = average\n", + "\n", + "result_mapping\n", + "\n", + "\n", + "for tp in all_tps:\n", + " tp.deut_time = result_mapping[tp.deut_time]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`HDXStatePeptideCompares` can be created between two different states for comparison. It is a collection of all possible `HDXStatePeptideCompare`, where the same peptides are in both Proteinstate. HDXStatePeptideCompare\n", + "will find all the common timepoints and get the difference in D uptake. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "state1 = 'APO'\n", + "state2 = 'TRI'\n", + "\n", + "# first get the states\n", + "state1_list = [i.get_state(state1) for i in hdxms_data_list]\n", + "state2_list = [i.get_state(state2) for i in hdxms_data_list]\n", + "\n", + "pep_compres = HDXStatePeptideCompares(state1_list, state2_list)\n", + "pep_compres.add_all_compare()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------\n", + "APO-TRI: 12-19 LYFQSISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -4.73 -1.3 -0.29 5.06 9.5 18.34 17.01 0. ]\n", + "-----------------\n", + "APO-TRI: 13-19 YFQSISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -2.57 -2.44 1.23 4.42 11.45 19.75 17.73 0. ]\n", + "-----------------\n", + "APO-TRI: 14-19 FQSISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -1.09 -1.89 0.65 3.5 12.59 24.48 21.75 0. ]\n", + "-----------------\n", + "APO-TRI: 15-19 QSISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -0.61 -1.31 2.52 5.73 16.05 27.09 24.22 0. ]\n", + "-----------------\n", + "APO-TRI: 15-20 QSISLI\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -1.09 -1.89 0.65 3.5 14.26 24.48 21.75 0. ]\n", + "-----------------\n", + "APO-TRI: 15-16 QS\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -0.76 -11.12 3.54 -1.2 -0.19 -0.25 -2.84 0. ]\n", + "-----------------\n", + "APO-TRI: 16-19 SISL\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. 0.51 -0.38 2.61 6.68 18.21 31.39 29.12 0. ]\n", + "-----------------\n", + "APO-TRI: 22-27 ALAVDR\n", + "[ 0. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. 28.87 37.37 35.11 11.44 2.48 -0.88 0. ]\n", + "-----------------\n", + "APO-TRI: 22-31 ALAVDRVIGM\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. 14.41 30.25 38.46 28.2 8.77 -0.53 -4.59 0. ]\n", + "-----------------\n", + "APO-TRI: 22-26 ALAVD\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. 10.6 30.79 36.83 29.21 14.64 4.28 1.39 0. ]\n" + ] + } + ], + "source": [ + "# check the results\n", + "for i in pep_compres.peptide_compares[:10]:\n", + " print('-----------------')\n", + " print(i.compare_info)\n", + " print(i.common_timepoints)\n", + " print(i.deut_diff)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## pseudo residue compare" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "pseudo residue compare is a comparison of the average D uptake between two different `Proteinstate` of all the peptides that cover this residue. D here is the normalized values based on the full-D experiments (0-100)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "res_compares = HDXStateResidueCompares([i for i in range(1, 320)], state1_list, state2_list)\n", + "res_compares.add_all_compare()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "-----------------\n", + "APO-TRI: 12\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -4.73 -1.3 -0.29 5.06 9.5 18.34 17.01 0. ]\n", + "-----------------\n", + "APO-TRI: 13\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -3.65 -1.87 0.47 4.74 10.475 19.045 17.37 0. ]\n", + "-----------------\n", + "APO-TRI: 14\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -2.79666667 -1.87666667 0.53 4.32666667 11.18\n", + " 20.85666667 18.83 0. ]\n", + "-----------------\n", + "APO-TRI: 15\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -1.80833333 -3.325 1.38333333 3.50166667 10.61\n", + " 18.98166667 16.60333333 0. ]\n", + "-----------------\n", + "APO-TRI: 16\n", + "[ 0. 46. 374. 572. 2011. 7772. 30812. 43292. inf]\n", + "[ 0. -1.47714286 -2.90428571 1.55857143 3.95571429 11.69571429\n", + " 20.75428571 18.39142857 0. ]\n" + ] + } + ], + "source": [ + "# check the results\n", + "# deut_diff is the average deuteration difference of all peptides covering the residue\n", + "for i in res_compares.residue_compares[:5]:\n", + " print('-----------------')\n", + " print(i.compare_info)\n", + " print(i.common_timepoints)\n", + " print(i.deut_diff)\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## visualization on pymol structure" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both comparison objects can be projected to a pdb structure for Visualization" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# both of the compare objects can be exported as a pymol pse file for visualization\n", + "pdb_file = 'data/6XG5_TRI.pdb'\n", + "\n", + "create_compare_pymol_plot(pep_compres, colorbar_max=20, pdb_file=pdb_file, path=f'{results_path}')\n", + "create_compare_pymol_plot(res_compares, colorbar_max=20, pdb_file=pdb_file, path=f'{results_path}')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# it can be visualized as a heatmap\n", + "create_heatmap_compare_tp(pep_compres, 20)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# make all the plots and save them\n", + "\n", + "from itertools import product\n", + "\n", + "items =[state.state_name for hdxms_data in hdxms_data_list for state in hdxms_data.states]\n", + "combinations = product(['APO'], [x for x in items if x != 'APO'])\n", + "\n", + "for state1_name, state2_name in combinations:\n", + "\n", + " state1_list = [i.get_state(state1_name) for i in hdxms_data_list]\n", + " state2_list = [i.get_state(state2_name) for i in hdxms_data_list]\n", + "\n", + " compare = HDXStatePeptideCompares(state1_list, state2_list)\n", + " compare.add_all_compare()\n", + "\n", + " heatmap_compare_tp = create_heatmap_compare_tp(compare, 20)\n", + " heatmap_compare_tp.savefig(f'{results_path}/{state1}-{state2}-heatmap-tp.png')\n", + "\n", + " heatmap_compare = create_heatmap_compare(compare, 20)\n", + " heatmap_compare.savefig(f'{results_path}/{state1}-{state2}-heatmap.png')\n", + "\n", + " create_compare_pymol_plot(compare, colorbar_max=20, pdb_file=pdb_file, path=results_path)\n", + "\n", + "\n", + "\n", + " res_compares = HDXStateResidueCompares([i for i in range(1, 320)], state1_list, state2_list)\n", + " res_compares.add_all_compare()\n", + "\n", + " create_compare_pymol_plot(res_compares, 20, pdb_file=pdb_file, path=results_path)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/03_calculate_PFs.html b/tutorials/03_calculate_PFs.html new file mode 100644 index 0000000..aa9fcc5 --- /dev/null +++ b/tutorials/03_calculate_PFs.html @@ -0,0 +1,368 @@ + + + + + + + 03_calculate_PFs — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

03_calculate_PFs

+
+
[1]:
+
+
+
from pigeon_feather.data import *
+from pigeon_feather.plot import *
+from pigeon_feather.hxio import *
+from pigeon_feather.spectra import *
+
+
+import numpy as np
+import pandas as pd
+
+import datetime
+import os
+import pickle
+import datetime
+
+
+
+
+
+
+
+
+Determination of memory status is not supported on this
+ platform, measuring for memoryleaks will never fail
+
+
+
+
[2]:
+
+
+
# load the pickle file we saved in the previous notebook
+
+
+today = datetime.date.today().strftime("%Y%m%d")
+today = "20240722"
+
+with open(f"./data/hdxms_data_raw_{today}.pkl", "rb") as f:
+    hdxms_data_list = pickle.load(f)
+
+
+# back exchange correction for peptides with experimental full deuteration data based its closest match in the database
+tools.backexchange_correction(hdxms_data_list)
+
+
+
+
+
+
+
+
+Number of peptides with experimental max_d: 358
+Number of peptides with no experimental max_d: 12
+
+
+
+
[3]:
+
+
+
# make folders for results
+
+today_date = datetime.date.today().strftime("%Y%m%d")
+# today_date = '20240722'
+results_path = f"ecDHFR_results_{today_date}"
+
+if not os.path.exists(results_path):
+    os.makedirs(results_path)
+
+
+out_path = "./data/PF_input_20240722"
+
+
+
+
+

peptide subtraction

+
+
[4]:
+
+
+
# [state.add_all_subtract() for data in hdxms_data_list for state in data.states]
+# add_new_peptides_by_subtract()
+for i in range(1):
+    [
+        state.add_new_peptides_by_subtract()
+        for data in hdxms_data_list[:]
+        for state in data.states
+    ]
+
+
+
+
+
+
+
+
+117 new peptides added to the APO state.
+127 new peptides added to the TRI state.
+
+
+
+
[9]:
+
+
+
[state.num_subtracted_added for data in hdxms_data_list for state in data.states]
+
+
+
+
+
[9]:
+
+
+
+
+[117, 127]
+
+
+

save the data as a pickle file for later use, and write to files used for bayesian sampling

+
+
[10]:
+
+
+
with open(f"{out_path}/hdxms_data_list.pkl", "wb") as f:
+    pickle.dump(hdxms_data_list, f)
+
+# with open(f"{out_path}/hdxms_data_list.pkl", "rb") as f:
+#     hdxms_data_list = pickle.load(f)
+
+
+
+
+
+

inputs for MCMC sampling

+
+
[11]:
+
+
+
exp_names = [
+    "dhfr_tutorial_dataset",
+]
+
+for i in range(len(hdxms_data_list)):
+    # exp_name = raw_spectra_paths[i].split('/')[-2].split('SpecExport_')[-1]
+    exp_name = exp_names[i]
+    export_iso_files(
+        hdxms_data_list[i], outdir=f"{out_path}/spectra_{exp_name}", overwrite=True
+    )
+    df = revert_hdxmsdata_to_dataframe(hdxms_data_list[i])
+    convert_dataframe_to_bayesianhdx_format(
+        df, protein_name=exp_name, OUTPATH=f"{out_path}"
+    )
+
+    print(exp_name)
+
+
+
+
+
+
+
+
+Isotope files saved to ./data/PF_input_20240722/spectra_dhfr_tutorial_dataset
+Reminder: sequence contains fastamides !!!
+Reminder: sequence contains fastamides !!!
+Data saved to ./data/PF_input_20240722
+dhfr_tutorial_dataset
+
+
+

write ready to run script for each state

+
+
[12]:
+
+
+


protein_sequence = "MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR"
+
+state_names = list(
+    set([state.state_name for data in hdxms_data_list for state in data.states])
+)
+for protein_state in state_names:
+    script = tools.generate_bayesian_hdx_script(
+        exp_names,
+        protein_sequence,
+        protein_state,
+        base_directory=".",
+        making_chunks=True,
+        pH=7.0,
+        temperature=293.0,
+        saturation=0.9,
+        rerun_num=3,
+        extreme_value_prior=False,
+        structural_prior=False,
+    )
+
+    with open(f"{out_path}/run_bayesian_hdx_{protein_state}_chunks.py", "w") as f:
+        f.write(script)
+


+
+
+
+
+

two priors

+

Make sure you generate the priors if you enable twp priors in tools.generate_bayesian_hdx_script.

+
+
[13]:
+
+
+
# uptake prior
+#tools.generate_extreme_value_prior(hdxms_data_list, out_path)
+
+
+# structural prior
+
+# solvated_pdbs = [
+#     "./data/5DFR_APO_relaxed_best_solvated.pdb",
+#     "./data/6XG5_TRI_relaxed_best_solvated.pdb",
+#     "./data/1RG7_MTX_relaxed_best_solvated.pdb",
+# ]
+
+# for i, state_name in enumerate(["APO", "TRI", "MTX"]):
+
+
+#     tools.generate_structural_prior(
+#         protein_sequence, solvated_pdbs[i], out_path, state_name
+#     )
+
+
+
+

You can run the script in the terminal with the following command:

+
cd ./data/bayesian_hdx_input_20240722
+python run_bayesian_hdx_APO_chunks.py
+
+
+

The simulations usually take several hours, but the duration varies based on the size of the dataset (number of peptides, time points, and replicates).

+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/tutorials/03_calculate_PFs.ipynb b/tutorials/03_calculate_PFs.ipynb new file mode 100644 index 0000000..8907aef --- /dev/null +++ b/tutorials/03_calculate_PFs.ipynb @@ -0,0 +1,326 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 03_calculate_PFs" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Determination of memory status is not supported on this \n", + " platform, measuring for memoryleaks will never fail\n" + ] + } + ], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "# load the pickle file we saved in the previous notebook\n", + "\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)\n", + "\n", + "\n", + "# back exchange correction for peptides with experimental full deuteration data based its closest match in the database\n", + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = f\"ecDHFR_results_{today_date}\"\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)\n", + "\n", + "\n", + "out_path = \"./data/PF_input_20240722\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## peptide subtraction" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "117 new peptides added to the APO state.\n", + "127 new peptides added to the TRI state.\n" + ] + } + ], + "source": [ + "# [state.add_all_subtract() for data in hdxms_data_list for state in data.states]\n", + "# add_new_peptides_by_subtract()\n", + "for i in range(1):\n", + " [\n", + " state.add_new_peptides_by_subtract()\n", + " for data in hdxms_data_list[:]\n", + " for state in data.states\n", + " ]" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[117, 127]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[state.num_subtracted_added for data in hdxms_data_list for state in data.states]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "save the data as a pickle file for later use, and write to files used for bayesian sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "with open(f\"{out_path}/hdxms_data_list.pkl\", \"wb\") as f:\n", + " pickle.dump(hdxms_data_list, f)\n", + "\n", + "# with open(f\"{out_path}/hdxms_data_list.pkl\", \"rb\") as f:\n", + "# hdxms_data_list = pickle.load(f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## inputs for MCMC sampling" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Isotope files saved to ./data/PF_input_20240722/spectra_dhfr_tutorial_dataset\n", + "Reminder: sequence contains fastamides !!!\n", + "Reminder: sequence contains fastamides !!!\n", + "Data saved to ./data/PF_input_20240722\n", + "dhfr_tutorial_dataset\n" + ] + } + ], + "source": [ + "exp_names = [\n", + " \"dhfr_tutorial_dataset\",\n", + "]\n", + "\n", + "for i in range(len(hdxms_data_list)):\n", + " # exp_name = raw_spectra_paths[i].split('/')[-2].split('SpecExport_')[-1]\n", + " exp_name = exp_names[i]\n", + " export_iso_files(\n", + " hdxms_data_list[i], outdir=f\"{out_path}/spectra_{exp_name}\", overwrite=True\n", + " )\n", + " df = revert_hdxmsdata_to_dataframe(hdxms_data_list[i])\n", + " convert_dataframe_to_bayesianhdx_format(\n", + " df, protein_name=exp_name, OUTPATH=f\"{out_path}\"\n", + " )\n", + "\n", + " print(exp_name)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "write ready to run script for each state" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "protein_sequence = \"MTGHHHHHHENLYFQSISLIAALAVDRVIGMENAMPWNLPADLAWFKRNTLDKPVIMGRHTWESIGRPLPGRKNIILSSQPGTDDRVTWVKSVDEAIAACGDVPEIMVIGGGRVYEQFLPKAQKLYLTHIDAEVEGDTHFPDYEPDDWESVFSEFHDADAQNSHSYCFEILERR\"\n", + "\n", + "state_names = list(\n", + " set([state.state_name for data in hdxms_data_list for state in data.states])\n", + ")\n", + "for protein_state in state_names:\n", + " script = tools.generate_bayesian_hdx_script(\n", + " exp_names,\n", + " protein_sequence,\n", + " protein_state,\n", + " base_directory=\".\",\n", + " making_chunks=True,\n", + " pH=7.0,\n", + " temperature=293.0,\n", + " saturation=0.9,\n", + " rerun_num=3,\n", + " extreme_value_prior=False,\n", + " structural_prior=False,\n", + " )\n", + "\n", + " with open(f\"{out_path}/run_bayesian_hdx_{protein_state}_chunks.py\", \"w\") as f:\n", + " f.write(script)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## two priors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make sure you generate the priors if you enable twp priors in `tools.generate_bayesian_hdx_script`." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# uptake prior\n", + "#tools.generate_extreme_value_prior(hdxms_data_list, out_path)\n", + "\n", + "\n", + "# structural prior\n", + "\n", + "# solvated_pdbs = [\n", + "# \"./data/5DFR_APO_relaxed_best_solvated.pdb\",\n", + "# \"./data/6XG5_TRI_relaxed_best_solvated.pdb\",\n", + "# \"./data/1RG7_MTX_relaxed_best_solvated.pdb\",\n", + "# ]\n", + "\n", + "# for i, state_name in enumerate([\"APO\", \"TRI\", \"MTX\"]):\n", + "\n", + "\n", + "# tools.generate_structural_prior(\n", + "# protein_sequence, solvated_pdbs[i], out_path, state_name\n", + "# )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can run the script in the terminal with the following command:\n", + "\n", + "```sh\n", + "cd ./data/bayesian_hdx_input_20240722\n", + "python run_bayesian_hdx_APO_chunks.py\n", + "```\n", + "\n", + "The simulations usually take several hours, but the duration varies based on the size of the dataset (number of peptides, time points, and replicates).\n", + "\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pigeon_feather", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/04_check_the_fitting.html b/tutorials/04_check_the_fitting.html new file mode 100644 index 0000000..bfd864c --- /dev/null +++ b/tutorials/04_check_the_fitting.html @@ -0,0 +1,532 @@ + + + + + + + 04_check_the_fitting — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

04_check_the_fitting

+
+
[1]:
+
+
+
from pigeon_feather.data import *
+from pigeon_feather.plot import *
+from pigeon_feather.hxio import *
+from pigeon_feather.spectra import *
+
+
+import numpy as np
+import pandas as pd
+
+import datetime
+import os
+import pickle
+import datetime
+
+
+
+
+
+
+
+
+Determination of memory status is not supported on this
+ platform, measuring for memoryleaks will never fail
+
+
+
+
[2]:
+
+
+
# load the pickle file we saved in the previous notebook
+
+
+today = datetime.date.today().strftime("%Y%m%d")
+today = "20240722"
+
+with open(f"./data/hdxms_data_raw_{today}.pkl", "rb") as f:
+    hdxms_data_list = pickle.load(f)
+
+
+# back exchange correction for peptides with experimental full deuteration data based its closest match in the database
+tools.backexchange_correction(hdxms_data_list)
+
+
+
+
+
+
+
+
+Number of peptides with experimental max_d: 358
+Number of peptides with no experimental max_d: 12
+
+
+
+
[3]:
+
+
+
# make folders for results
+
+today_date = datetime.date.today().strftime("%Y%m%d")
+# today_date = '20240722'
+results_path = f"ecDHFR_results_{today_date}"
+
+if not os.path.exists(results_path):
+    os.makedirs(results_path)
+
+
+out_path = "./data/PF_input_20240722"
+
+
+
+

Create an Analysis object and load the results. Note: The temperature and pH are crucial for calculating the intrinsic exchange rates, so make sure to input the correct values. The chunk size and chunk number can be altered by the user. In this tutorial, they were automatically determined by a helper function.

+
+
[4]:
+
+
+
from pigeon_feather.analysis import Analysis, get_index_offset
+from pigeon_feather.tools import optimal_chunks
+import matplotlib.pyplot as plt
+
+RUN_NUM = 3
+
+apo_states = [
+    state
+    for data in hdxms_data_list
+    for state in data.states
+    if state.state_name == "APO"
+]
+
+tri_states = [
+    state
+    for data in hdxms_data_list
+    for state in data.states
+    if state.state_name == "TRI"
+]
+
+ana_apo_1 = Analysis(apo_states, temperature=293.0, pH=7.0)
+
+chunk_num, chunk_size = optimal_chunks(len(ana_apo_1.protein_sequence))
+ana_apo_1.load_bayesian_hdx_oupt_chunks(
+    chunk_size=chunk_size,
+    chunk_num=chunk_num,
+    state_name="APO",
+    run_num=RUN_NUM,
+    N=200,
+    bayesian_hdx_data_folder=f"{out_path}/bayesian_hdx_output_chunks",
+)
+
+
+ana_tri_1 = Analysis(tri_states, temperature=293.0, pH=7.0)
+
+ana_tri_1.load_bayesian_hdx_oupt_chunks(
+    chunk_size=chunk_size,
+    chunk_num=chunk_num,
+    state_name="TRI",
+    run_num=RUN_NUM,
+    N=200,
+    bayesian_hdx_data_folder=f"{out_path}/bayesian_hdx_output_chunks",
+)
+
+
+
+

two fitting check functions are available: 1. centroid level fitting check 2. isotopic mass envelope fitting check.

+
+
[5]:
+
+
+
from pigeon_feather.analysis import (
+    check_fitted_isotope_envelope,
+    check_fitted_peptide_uptake,
+)
+
+
+
+
+

envelope check

+
+
[6]:
+
+
+
check_state_name = "APO"
+check_ana_obj = ana_apo_1
+
+
+all_peps = [
+    pep
+    for data in hdxms_data_list
+    for state in data.states
+    for pep in state.peptides
+    if state.state_name == check_state_name and pep.note is None
+]
+all_tps = [
+    tp
+    for pep in all_peps
+    for tp in pep.timepoints
+    if pep.get_timepoint(0) is not None and tp.deut_time != np.inf and tp.deut_time != 0
+]
+
+
+
+
+
[7]:
+
+
+
envelope_errors = [(check_fitted_isotope_envelope(ana_apo_1, tp), tp) for tp in all_tps]
+envelope_errors = sorted(envelope_errors, key=lambda x: x[0], reverse=False)
+
+# you can plot the fitted isotope envelope and the experimental data
+check_fitted_isotope_envelope(check_ana_obj, envelope_errors[300][1], if_plot=True)
+
+
+
+
+
[7]:
+
+
+
+
+0.18336607065124264
+
+
+
+
+
+
+../_images/tutorials_04_check_the_fitting_10_1.png +
+
+
+
[8]:
+
+
+
plt.hist(
+    np.array(envelope_errors)[:, 0],
+)
+plt.xlabel("Sum AE")
+plt.ylabel("Count")
+
+
+
+
+
[8]:
+
+
+
+
+Text(0, 0.5, 'Count')
+
+
+
+
+
+
+../_images/tutorials_04_check_the_fitting_11_1.png +
+
+
+
[9]:
+
+
+

print(np.nanmedian(np.array(envelope_errors)[:, 0]))
+print(np.nanmean(np.array(envelope_errors)[:, 0]))
+
+
+
+
+
+
+
+
+0.3669856716168908
+0.39744791298433696
+
+
+
+
+

uptake check

+
+
[10]:
+
+
+
from pigeon_feather.analysis import check_fitted_peptide_uptake
+
+
+all_idfs = list(set([pep.identifier for pep in all_peps]))
+
+
+def extract_numbers(s):
+    numbers = re.findall(r"(-?\d+)-(-?\d+)", s)
+    return tuple(map(int, numbers[0]))
+
+
+all_idfs.sort(key=extract_numbers)
+
+
+
+
+
[11]:
+
+
+
uptake_errors = []
+
+all_peps_grouped = tools.group_by_attributes(
+    all_peps, ["protein_state.state_name", "identifier"]
+)
+
+for idf in all_idfs:
+    try:
+        idf_peps = all_peps_grouped[(check_state_name, idf)]
+        avg_pep = tools.average_peptides(idf_peps)
+
+        result = check_fitted_peptide_uptake(
+            check_ana_obj, hdxms_data_list, avg_pep, state_name=check_state_name
+        )
+        uptake_errors.append((result, avg_pep))
+    except Exception as e:
+        print(idf, e)
+
+
+uptake_errors_array = np.array([i[0] for i in uptake_errors])
+
+
+
+
+
[12]:
+
+
+
import seaborn as sns
+
+
+fig, axes = plt.subplots(1, 2, figsize=(12, 5.5))
+
+# # Plotting with complementary colors
+# sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color="#FF6347")
+# sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color="#4682B4")
+
+
+color_1 = "#53b1b1"  # A standard blue color
+color_2 = "#f6c624"  # A teal color
+
+# Plotting with chosen colors
+sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=color_1)
+sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=color_2)
+
+axes[1].set_ylabel("")
+axes[0].set_xlabel("Sum AE")
+axes[1].set_xlabel("Da/peptide length")
+fig.subplots_adjust(wspace=0.2)
+
+
+
+
+
+
+
+../_images/tutorials_04_check_the_fitting_16_0.png +
+
+
+
[13]:
+
+
+
from pigeon_feather.analysis import get_index_offset
+from matplotlib.ticker import LogLocator
+
+
+check_ana_obj = ana_apo_1
+index_offset = get_index_offset(check_ana_obj, './data/6XG5_TRI.pdb')
+
+uptake_errors = sorted(uptake_errors, key=lambda x: x[1].start, reverse=False)
+
+num_subplots_per_figure = math.ceil(len(uptake_errors) / 2)
+# num_subplots_per_figure = 250
+num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)
+
+
+for fig_index in range(num_figures):
+    # Select the subset of errors for the current figure
+    selected_uptake_errors = uptake_errors[fig_index * num_subplots_per_figure:(fig_index + 1) * num_subplots_per_figure]
+    num_col = math.ceil(len(selected_uptake_errors) / 5)
+
+    fig, axs = plt.subplots(num_col, 5, figsize=(9 * 5, 8 * num_col))  # Adjust subplot size as needed
+
+    for i, error_tuple in enumerate(selected_uptake_errors):
+
+
+        ax = axs[i // 5, i % 5]
+
+
+        # Unpack error information
+        peptide_data = error_tuple[1]
+
+
+        ax.axhline(y=peptide_data.max_d, color='lightgray', linestyle='--', linewidth=5)
+
+        check_fitted_peptide_uptake(
+            check_ana_obj,
+            hdxms_data_list,
+            peptide_data,
+            if_plot=True,
+            state_name=check_state_name,
+            figure=fig,
+            ax=ax
+        )
+
+        #Retrieve and format the peptide identifier
+        idf = peptide_data.identifier
+        idf_start, idf_end = map(int, re.match(r"(-?\d+)-(-?\d+)", idf).groups())
+        idf_seq = idf.split(" ")[1]
+        ax.set_title(f"{idf_start - index_offset}-{idf_end - index_offset} {idf_seq}")
+
+        ax.set_xlim(1e1, 1e5)
+        ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))
+
+        # y_max = ax.get_ylim()[1]
+        # ax.set_ylim(-0.5, y_max + 1)
+        pep = error_tuple[1]
+        y_max = pep.theo_max_d/check_ana_obj.saturation
+        ax.set_ylim(-0.5, y_max + 0.5)
+
+        # light gray dotted line at max deuteration
+
+
+        handles, labels = ax.get_legend_handles_labels()
+        new_labels = [label for label in labels if label.isdigit()]
+        new_handles = [handle for handle, label in zip(handles, labels) if label.isdigit()]
+        ax.legend(new_handles, new_labels, title='replicate', title_fontsize='small')
+
+    # Layout adjustment and save
+    fig.tight_layout()
+    fig.savefig(f"{results_path}/ecDHFR_uptake_errors_{check_state_name}_{fig_index}.pdf")
+
+
+
+

If the fitting is poor, do not proceed. Check the parameters in the sampling to ensure they agree with the experimental conditions. You may also need to remove outlier peptides and rerun the sampling. An outlier might be a peptide that exchanges a lot while its neighbors barely exchange (examples in the tutorial dataset: 78-92 VDEAIAACGDVPEIM, 75-78 VKSV).

+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/tutorials/04_check_the_fitting.ipynb b/tutorials/04_check_the_fitting.ipynb new file mode 100644 index 0000000..7ffabb1 --- /dev/null +++ b/tutorials/04_check_the_fitting.ipynb @@ -0,0 +1,486 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 04_check_the_fitting" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Determination of memory status is not supported on this \n", + " platform, measuring for memoryleaks will never fail\n" + ] + } + ], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "# load the pickle file we saved in the previous notebook\n", + "\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)\n", + "\n", + "\n", + "# back exchange correction for peptides with experimental full deuteration data based its closest match in the database\n", + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = f\"ecDHFR_results_{today_date}\"\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)\n", + "\n", + "\n", + "out_path = \"./data/PF_input_20240722\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create an `Analysis` object and load the results. **Note:** The temperature and pH are crucial for calculating the intrinsic exchange rates, so make sure to input the correct values. The chunk size and chunk number can be altered by the user. In this tutorial, they were automatically determined by a helper function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import Analysis, get_index_offset\n", + "from pigeon_feather.tools import optimal_chunks\n", + "import matplotlib.pyplot as plt\n", + "\n", + "RUN_NUM = 3\n", + "\n", + "apo_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"APO\"\n", + "]\n", + "\n", + "tri_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"TRI\"\n", + "]\n", + "\n", + "ana_apo_1 = Analysis(apo_states, temperature=293.0, pH=7.0)\n", + "\n", + "chunk_num, chunk_size = optimal_chunks(len(ana_apo_1.protein_sequence))\n", + "ana_apo_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"APO\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")\n", + "\n", + "\n", + "ana_tri_1 = Analysis(tri_states, temperature=293.0, pH=7.0)\n", + "\n", + "ana_tri_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"TRI\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "two fitting check functions are available: 1. centroid level fitting check 2. isotopic mass envelope fitting check. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import (\n", + " check_fitted_isotope_envelope,\n", + " check_fitted_peptide_uptake,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## envelope check" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "check_state_name = \"APO\"\n", + "check_ana_obj = ana_apo_1\n", + "\n", + "\n", + "all_peps = [\n", + " pep\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " for pep in state.peptides\n", + " if state.state_name == check_state_name and pep.note is None\n", + "]\n", + "all_tps = [\n", + " tp\n", + " for pep in all_peps\n", + " for tp in pep.timepoints\n", + " if pep.get_timepoint(0) is not None and tp.deut_time != np.inf and tp.deut_time != 0\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.18336607065124264" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "envelope_errors = [(check_fitted_isotope_envelope(ana_apo_1, tp), tp) for tp in all_tps]\n", + "envelope_errors = sorted(envelope_errors, key=lambda x: x[0], reverse=False)\n", + "\n", + "# you can plot the fitted isotope envelope and the experimental data\n", + "check_fitted_isotope_envelope(check_ana_obj, envelope_errors[300][1], if_plot=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Count')" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(\n", + " np.array(envelope_errors)[:, 0],\n", + ")\n", + "plt.xlabel(\"Sum AE\")\n", + "plt.ylabel(\"Count\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.3669856716168908\n", + "0.39744791298433696\n" + ] + } + ], + "source": [ + "\n", + "print(np.nanmedian(np.array(envelope_errors)[:, 0]))\n", + "print(np.nanmean(np.array(envelope_errors)[:, 0]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## uptake check" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import check_fitted_peptide_uptake\n", + "\n", + "\n", + "all_idfs = list(set([pep.identifier for pep in all_peps]))\n", + "\n", + "\n", + "def extract_numbers(s):\n", + " numbers = re.findall(r\"(-?\\d+)-(-?\\d+)\", s)\n", + " return tuple(map(int, numbers[0]))\n", + "\n", + "\n", + "all_idfs.sort(key=extract_numbers)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "uptake_errors = []\n", + "\n", + "all_peps_grouped = tools.group_by_attributes(\n", + " all_peps, [\"protein_state.state_name\", \"identifier\"]\n", + ")\n", + "\n", + "for idf in all_idfs:\n", + " try:\n", + " idf_peps = all_peps_grouped[(check_state_name, idf)]\n", + " avg_pep = tools.average_peptides(idf_peps)\n", + "\n", + " result = check_fitted_peptide_uptake(\n", + " check_ana_obj, hdxms_data_list, avg_pep, state_name=check_state_name\n", + " )\n", + " uptake_errors.append((result, avg_pep))\n", + " except Exception as e:\n", + " print(idf, e)\n", + "\n", + "\n", + "uptake_errors_array = np.array([i[0] for i in uptake_errors])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABEYAAAInCAYAAACVwFzQAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAADWBElEQVR4nOzdeXxU1f0//te5s2Um+wIEAmGVXTbBIuLSutSKola0rcWlfqx1rWvV6qf9oParVkXrUtdfa6tYtYobWrWKCriAAgIKCbKFANn3SSaZ7Z7fH8Aw905CMpOZubO8no9HHnpO7pz7DmJm5j3v8z5CSilBRERERERERJSGFKMDICIiIiIiIiIyChMjRERERERERJS2mBghIiIiIiIiorTFxAgRERERERERpS0mRoiIiIiIiIgobTExQkRERERERERpi4kRIiIiIiIiIkpbZqMDoPSgqiqqqqqQnZ0NIYTR4RARUZqTUsLpdGLIkCFQFH5OFA18riciokTT1+d7JkYoLqqqqjBs2DCjwyAiItLYs2cPhg4danQYKYHP9URElKh6e75nYoTiIjs7G8D+v5A5OTkGR0NEROmura0Nw4YNCzw/Uf/xuZ6IiBJNX5/vmRihuDhYUpuTk8MXS0RElDC45SN6+FxPRESJqrfne26qJSIiIiIiIqK0xcQIEREREREREaUtJkaIiIiIiIiIKG0xMUJEREREREREaYuJESIiIiIiIiJKW0yMEBEREREREVHaYmKEiIiIiIiIiNIWEyNERERERERElLaYGCEiIiIiIiKitMXECBERERERERGlLSZGiIiIiIiIiChtMTFCRERERERERGmLiREiIiIiIiIiSltMjBARERERERFR2mJihIiIiIiIiIjSFhMjRERERERERJS2zEYHQJRKKisr0dDQEJW1ioqKUFpaGpW1iIiIKDqi+VwP8PmeiCgRMDFCFCWVlZUYP2ECOl2uqKxndzhQXlbGF0tEREQJorKyEhMmjIfL1Rm1NR0OO8rKyvl8T0RkICZGiKKkoaEBnS4Xrrn/fpSMGtWvtfbt3InHb7kFDQ0NfKFERESUIBoaGuBydeIfj1yICWMG9Xu9su21uOS6F/h8T0RkMCZGiKKsZNQojJw0yegwiIiIKEYmjBmE6UcOMzoMIiKKEjZfJSIiIiIiIqK0xcQIEREREREREaUtJkaIiIiIiIiIKG0xMUJEREREREREaYuJESIiIiIiIiJKW0yMEBEREREREVHaYmKEiIiIiIiIiNIWEyNERERERERElLaYGCEiIiIiIiKitMXECBERERERERGlLSZGiIiIiIiIiChtMTFCRERERERERGmLiREiIiIiIiIiSltMjBARERERERFR2mJihIiIiIiIiIjSFhMjRERERERERJS2mBghIiIiIiIiorTFxAgRERERERERpS0mRoiIiIiIiIgobTExQkRERERERERpi4kRIiIiIiIiIkpbTIwQERERERERUdpiYoSIiIiIiIiI0hYTI0RERERERESUtpgYISIiIiIiIqK0xcQIEREREREREaUtJkaIiIiIiIiIKG0xMUJEREREREREaYuJESIiIiIiIiJKW0yMEBEREREREVHaYmKEiIiIiIiIiNIWEyNERERERFEkvU1QO3dBqm6jQyEioj4wGx0AEREREVEqkO4aqG1rIN2V+yeEFUr2dIisaRCK1djgiIioR0yMEMWIX1VR6XSioq0Nbr8fgxwODMvORpHdbnRoREREFGWqazvUpvcByEOT0gO1bQ3QuROmAT9lcoSIKEExMUIUA02dnfiiuhqdPl9gzunxYHtLC4ZmZeHo4mKYFO5kIyIiSgXS54TavByapEgwbz3U1i9gyj8xjlEREVFf8Z0ZUZR5AHxWVaVJigTb296OL6ur4VfV+AZGREREUSelhNr8ESA9h7+u41tI9744RUVEROFgYoQoioTZjB0mE9x+/2Gvq+7owJqaGkjZwydLRERElBSkawuke69mTthKYRpwLiC0xdn+5uWQ8vCvEYiIKP6YGCGKognnn48O3RYZm8mEwZmZUITQzO9rb8dupzOe4REREVEUSSmhOr/RTpqyoBSeBmEbAiXnGO33fK2QnTvjFyAREfUJEyNEUeJWVYw54wzNXKbFgtNGjMDckhKcMHQozLqkyYa6uh633BAREVFik+69gK9ZM6fknQih2AAAImsKYBmofUzH5rjFR0REfcPECFGUbOjogCUzUzN3zODBsJpMAIAiux1HFxdrvu9VVayvrY1bjERERBQ9sn2TdsKcD5ExIjAUQoGSNVX7GPceSF9rHKIjIqK+YmKEKAp8qoqv29s1cyVZWcjPyAiZK83O1sxVdXSg3uWKeYxEREQUPdLnhOzapZlTsqZA6LbOCscYQNg0c2rHlpjHR0REfcfECFEUrK6qQpuu4eq4/Pxur502cCBsB6pIDvq2oYGNWImIiJLI/uRG0HO3sEA4xodcJ4QZInOcZk52lEFKnk5HRJQomBghioKPKis148KMDBTa7d1eazOZMLGwUDPX2NWF6o6OmMVHRERE0SW7dmjGwjEeQrF2e63imKSdUDsAT3WsQiMiojAxMULUT06PB1saGzVzR/RQLXLQqNxcZFosmrnvWDVCRESUFCxKB+DVPvcrjiN6vF5YiwCL9kMRtauyh6uJiCjemBgh6qd1tbVQgxIaQkoM1jVh1VOEwCRd1Uirx8OqESIioiSQY6nRTigZgHXwYR8jMoZrxrJrd7TDIiKiCDExQtRPX1VrS2FzpQw5lrc7pdnZyLFqS27LmppYNUJERJTgciza536RMRJCHP65Xwk6rQYA4K2HWXRFOTIiIooEEyNE/eD2+bChvl4zl6f2rZmaEALjCwo0c01dXajr7IxafERERBRd+dkKMs3abTTCPrL3B1qLAaHdRptlqYtmaEREFCEmRoj6YWN9PTxBp9Gofj/ywqj4GJadHdJrpEzXr4SIiIgSx4/nOCBE8HO9CcJW2uvjhDBB2IZp5rIttVGOjoiIIsHECFE/rKvVvqBp2LwZ5jAerwgRcqxvfWcn2oWIQnREREQUbT+c6dCMRUYphGLp4WotfZ+RLHMd+rD7loiIYoy/ion6YbOuuqP666/DXmNETg4yTCbtOnyVRERElJCOm27XjEXGsB6uDKVPjJgVLyaO7P6IXyIiih+++yKKUHNXF2p0p8jUf/tt2OuYFAXjdL1GWhUFuSNG9Cc8IiIiijKzrMeIIdrqEGEr6fPjhTkbMOVo5n4wOSMqsRERUeSYGCGKkL4XiE0ItO6O7Oi9Ubm5sOqqRMadd17EsREREVH0ZapbtBNKBmAuDGsNYS3WjH9wJBMjRERGY2KEKEJlTU2a8VCbDejjiTR6ZkXBEbpeI0PnzEGj1xtxfERERBRdDl1iRFiHQITZF0zYdIkRVowQERmOiRGiCG3RVYwMs/Zvj/CYvDyYg6pGhKLgS6ezX2sSERFR9DjUMs1Y2IaGvYawDtaMjyi1wiTb+hUXERH1DxMjRBFo93hQ2aZ9ETPMZuvXmlaTCWPy8jRz37lcqHe5+rUuERER9Z/qroYV2tPohG1I+AtZCgGhPcPOrm7rT2hERNRPTIwQRaC8qQkyaGxVFAzuZ8UIAByRlwdTUEmuCuCt7dv7vS4RERH1j9r2lXZC2ABLUdjrCGECLAM1c3bJxAgRkZGYGCGKQLmuv8iY/HyYw9xj3J0Msxkjc3M1c8srK9Hc1dXvtYmIiChyavtGzVjYwu8vcuix2j4jdvX7iOMiIqL+Y2KEKAI7W1o04/G643b7Y1x+PoQ8VI/iVVW8s3Nn1NYnIiKi8IUkRnSny4RD32fELrdDSn/E6xERUf8wMUIUJikldra2auZG63qD9IfDYkGhlJq5D3btgtPjido9iIiIqO+k6obs0DZehXVQxOvpkyoK3JBdFRGvR0RE/cPECFGYGjo70a47RneUbvtLfxX7/ZD+Q58cdfn9WLZjR1TvQURERH0jXVsBqX3uF9aBPVzdO2FyAEqmZk7tKI94PSIi6h8mRojCpK8WybJYUGS3R/UeGQD2fPaZZu7tHTtQ3d4e1fsQERFR79T2bzXjLn8WhNK/0+iEVdu4NaQihYiI4oaJEaIw6RMjo3JzI26+djjl//43glf1qSr+9u23kLptNkRERBRb+v4inb78/i+qO9FGdbFihIjIKObeLyGiYPrGqyOj2F8kmHPvXhydlYU1QVUiG+rr8dm+fThu6NCw16usrERDQ0NUYisqKkJpaWlU1iIiIkp0avsmzbjT3//EiLAUIfijDpUVI0REhmFihCgMUsqQxEi0+4sEm5uTg20+H5qCjut9euNGjMrNRUl2dp/XqaysxPgJE9DpckUlLrvDgfKyMiZHiIgo5UmfE7JTezqcKwoVI0JXMQJvHaS3EcJS2O+1iYgoPEyMEIWh2e1Gq+50mFgmRmyKgksmT8ZDa9cG5rr8fjy4di3+NHcuMi2WPq3T0NCATpcL19x/P0pGjepXTPt27sTjt9yChoYGJkaIiCjlqR2bgaDaDo9Xosuf0/+FzXlQpQmKONRsXe0ogylvbv/XJiKisDAxQhQGfbWI3WzGoMzM7i+OkjlDhmBDaSk+rqwMzO1xOrHoiy/wv7NnI9d2+OZvXr8fO7u6MPGXv0T7EUdgq80Gt98Pk6LAYTYjz2bDsOxsFNntMemVQkRElMz2J0YO+Xa7G9ZiU7/XFUJBlz8HDnNz0L2YGCEiMgITI0Rh2KVrvDoyNxdKHJIJ/3PkkdjR0oLdbW2aWH6/ahUunjQJRxcXa5Ia7R4P1tfV4euaGnxTW4suvx8Tzj8fTgA4eNSwqqLT50NjVxd2tLYiy2LB1AEDMCQrK+Y/DxERUbLQnxaz8Xs3ZhVHZ+1Of64mMSLZgJWIyBBMjFDaC6cp6abGRs3Y4XZj/fr1AICystg1TbOZTPjdrFn4388+Q4vbHZivc7nwwNdfI99mw+j8fEBK1Lhc2Od0Ityza9q9XnxeVYWSrCzMHDQIVlP/Pw0jIiJKdvrTYr7d5sGs46OzdpcvFwgq/GQDViIiYzAxQmkt3KakJz/yCHJHjAiMn/nzn/H7//5Xc0170Cky0VScmYm7jz0Wd69ejTpdvM1uN9bW1ETlPvva29Hm8eC4kpI+9zAhIiJKRVJ1Q3bu0Mxt3Obu4erw6XuVyM6dkKoHQrFG7R5ERNQ7JkYorYXTlFQCWG82ayoxfvGb3yD78ssBAN+sXIl/P/ooOoNOkIm2wVlZuPvYY/HQ2rXY2tzc+wOCNJaXY9IRR2B4SQlsZjN8qopWtxt7nE606RrKOj0efFxZiROGDUOOlS/OiIgoPcnO7YD0aea+2xG7xAjgh+zaDeE4Imr3ICKi3jExQgSgZNQojJw06bDXtHk8kBUVmrnx48YFtpzs27mzm0dFX6Hdjj/NnYvPq6rwUlkZanuodrEoCqYMGIBZxcWw1tXhhLPOwo9few2lOYdehJVkZWFCQQEqnU5srK+H23+oM36X349Ve/fipNJSZJj5q4KIiNKPfmuLB4PQ7toevfVhQVW9D0MGHHqelZ3bASZGiIjiiu92iPqoza39hCjDZDKsD4cQAnNLSjBnyBDsa2/H1qYmNHZ2wqwoyLJYMDIvDyNzcmA5EN96XW8U/VrDc3IwwG7Hqn37NNUjLp8Pn+3bhxOHDYNZUWL+cxERESUStUPbX6RLGQ7g86jeo7zCo0mMqJ07wC5fRETxxcQIUR/pt5skwhYTRQgMy87GsOzsfq/lsFjww2HDsHLvXjQHJYGa3W5sqKvDzOIoteAnIiJKEtKlrRhxi+FRv8fWCg9+NMsRdM8dh7maiIhigR8BE/VRSGLEZuvhyuRlNZkwt5umq7va2rDX6TQoKiIioviTUoZWjIgRUb9PeYX29YXaGb2tOkRE1DdMjBD1kX4rTSJUjMRChtmMuSUlMAuhmV9bW4tOr9egqIiIiOJLeqoAf5tmbv9Wmugqr9A+t8rOXZDS38PVREQUC0yMEPWBKiWcuqRAqiZGgP0/2/SBAzVzXlXFhvp6gyIiIiKKL6mrFoEpBz4URf0+W3UVI5BuSPe+qN+HiIh6xsQIUR90eL1QpdTMpeJWmmDDc3JCepfsbW9Hq66ShIiIKBWpnds0Y8UxFojBc2Bdsx8+ZGnmJLfTEBHFFRMjRH3QqttGYzOZYDPoRJp4EUJg+sCBsOpOo6k0maCkcLUMERERAEiXNjEiYniErkeUaMYqG7ASEcUVEyNEfeBMwBNp4sFmMmHKgAGaObcQGHPGGQZFREREFB+qLjGi2GOXGHGLoZoxK0aIiOKLiRGiPtD3F8lOk8QIAIzIyUFhRoZmbty558LlZ2M4IiJKTVL6ITt3aubiWjHSyYoRIqJ4YmKEqA/adRUj6ZQYObilJpg1Kwtf8PheIqKoevTRRyGECHwtWrSoX+stX74cV155JaZNm4aioiJYLBZkZ2dj4sSJuPDCC7F06VL4fL7oBJ9iZNceQGq30SoxTIy4FW1iRHbuhNT1NiMiotgxGx0AUTJo11WMZFksBkVijPyMDAzLzsaeoGTIuvZ21LtcGOBwGBgZEVFqKCsrw2233RaVtdatW4fLLrsMGzZsCPlee3s7ysrKUFZWhiVLlmDkyJF4/PHHcfrpp0fl3qkiZCuLOR/CUghgd0zu5xGDtRN+J+BrAiyFMbkfERFpsWKEqBcevx9u3baRdKoYOWhyYSGCe/H7Aby5nXugiYj6y+v1YuHChejs7Oz3Wi+++CJmz57dbVKkO7t27cK8efNw55139vveqSSkv0gMq0UAwIsiQGg/dFG7YpOEISKiUEyMEPVCXy0iAGSmWcUIAGRZrRidl6eZW15ZicYovJAnIkpn//d//4f169f3e53XX38dF110Ucj2GKvViqOPPhpnnHEGZs6cCWs3yf1FixbhwQcf7HcMqULqjuoVMWy8uv8GJgjbMF0MFbG9JxERBTAxQtQL/Yk0DosFihA9XJ3axufnQwTtefapKt5i1QgRUcQ+++wz/PnPf+73Ort27cKvfvUrqKoamDOZTLjjjjtQXV2NNWvWYNmyZfj666+xd+9e3HrrrVB0x7H//ve/x9q1a/sdSyqId8UIAAj7cM1YdlXE/J5ERLQfe4z0wO12480338SKFSuwZs0a1NTUoKmpCYqioLCwECUlJZg7dy5OPvlknHrqqRD9fKO8fPlyvPbaa/jyyy+xd+9etLa2IiMjA8OGDcNRRx2Fs88+G2eddRbM5v7/J3O73fj3v/+N999/H19//TVqa2vhcrmQnZ2N0aNHY86cOfjZz36GOXPm9PteqSCk8WoaVoscZLdYUKSqqDeZAnP/3bULY7q6kBU0F46ioiKUlpZGK0QioqThdDpx0UUXaZIZkbr55pvR1tYWGCuKgldffRXnnHNOyLUDBgzAfffdhzlz5uDcc88NVJj4fD7ceuutWL58eb/jSWbdnkhjHxPz+yoZI6Hik0NxcCsNEVHcMDGi4/P5sHjxYjz00EOoq6vr9hqXy4U9e/Zg9erVePDBBzFx4kTcddddOPfcc8O+X7wbpL300ku4/vrru/3ZmpubsXbtWqxduxaPPvooTjjhBDz11FMYP358xPdLBfqjerPSsL9IMEdDA9SCAigHEkQ+AFf+5S/Y8q9/RbSe3eFAeVkZkyNElHZ++9vfYteuXf1e55tvvsHrr7+umbvjjju6TYoEmz9/Ph566CH89re/Dcx9/PHH+Pjjj/GjH/2o33ElK9lVCUjthyJxqRjJ0FaMqKwYISKKGyZGguzbtw8LFizA6tWrw3rcli1bsGDBAlxxxRV45JFHut27250XX3wRl1xySZ+PyjvYIG3RokX4v//7v7BilFLimmuuwRNPPNHnx6xYsQKzZs3CK6+8ktbd6lkxouVpacHuTZsw8pRTAnOTzz8fF/z0pwi3ZmTfzp14/JZb0NDQwMQIEaWVN954A//4xz8C4ylTpqChoQFVVVVhr/Xkk09qxvn5+X0+4eaaa67B3/72N2zcuDEw98QTT6R3YqRzh3bCXABhKYj5fYV9hC6O3ZBS9rsqmYiIesfEyAFNTU045ZRTUFZWFvI9i8WCqVOnori4GB6PBxUVFfj+++9DrnvqqafgdDqxZMmSXu93sEGavnzWarVi2rRpGDhwIGpqarBp0yZ4dG/MFy1ahMzMTNx88819/vluuOGGbpMi+fn5mDx5MrKzs7Fr166Qn7+9vR0//elP8dFHH2Hu3Ll9vl+qkFKGHtWb5hUjALDtrbc0iRG/EEBJCUbqmrMSEVGompoaXH755YGx1WrFCy+8gPnz54e9lt/vx6uvvqqZ++UvfwlHH49SF0LgiiuuwJVXXhmYe++99+Byufq8RjKorKxEQ0NDn64t9K3CwKBxh38Qyg40x+3udWK0iIwR2gm1A/A2ANYBMbsnERHtx8TIARdddFHIk92gQYOwaNEiXHjhhcjMzNR8b/fu3bj//vvx5JNPQgY1o3zxxRcxbdq0wyYtemqQdtttt+HGG29EQcGhTyXq6+uxePFiPPDAA5rrf//73+PEE0/EzJkze/3Zli5dikceeUQzl5+fj4cffhi/+MUvNBUuZWVluPXWW7Fs2bLAnNvtxs9//nOUl5cjKyur1/ulErffD68ueZWOR/XqOffsgb2rC50ZGYG575ubMTo3l59sERH14tJLL9W8Sb/rrrswZcqUiNb66quv0NLSopk788wzw1rjzDPP1CRGXC4X3nvvvYi2CCeiyspKTJgwHi5X305Re/qOgbhwXk5g/PIbq3Ht/UdprnG2t0c1RgAQ1mJA2ADpDsypXRUwMTFCRBRzTIwAeP/99/Huu+9q5iZPnoz3338fJSUl3T5m+PDh+Otf/4of//jHWLBgAbxBVQV33XUXLrroIgwcOLDbx8azQVpnZyeuv/76kDW/+OILjBkT2khswoQJePvtt3Hrrbfi/vvvD8zv27cPDz/8MP7whz8c9n6pRl8toggBRxQa4KaCnI4OTWKkw+tFdUcHhqRZ8oyIKBxPPPEE3nvvvcD42GOPxe9+97uI1/vss880Y0VRcMwxx4S1RklJCUpLS1FZWRmY+/TTT1MmMdLQ0ACXqxP/eORCTBgzqNfrR2evANAcGP/k1GOx5oT9r5ne+2QLFj34H3R1dUU9TiEUiIxSzVHBsqsCyJkV9XsREZEWj+sFsHjxYs04Ozsbb7/9do9JkWDz588PebzT6cTTTz/d7fX9bZAW7GCDtMN56qmnsHfvXs3cSy+91G1SJNh9992HBQsWaOYWL16Mpqamwz4u1ej7i2RaLKyIOMDm8SDPZtPMbdd9aklERIds3bpVkwTJysrC888/H3Jsbjg2b96sGY8aNQrZ2dlhr3PkkUdqxuvWrYs4pkQ1YcwgTD9y2GG/pk0eCofFpXnc0GEjA98fOawwpjHqt9PITp5MQ0QUD2mfGKmvr8cnn3yimbvqqqswcuTIPq9x1VVXYdSoUZq54K0owfrbIG3q1Kmaud6aqT711FOa8amnnoqTTjqp13sJIfDoo4/CFvTGt7W1Ff+K8OSRZBXSXyTNG68GEwDG6HqK1LpcIckkIiLaX+m5cOFCuFyH3nQvXrw45PVDuPTbgMeOHRvROvoPTLZv3x5xTElN7dRsZQEAYcmP2+0VO0+mISIyQtonRlauXAm/36+Z+9nPfhbWGiaTKaRh2oYNGzS9R4DoNUgLdrBBWnfWr18f0iQ2uNlbbwYPHoyzzz5bM/faa6/1+fGpoEOXGMlkYkRjWHY2LLpPOne0thoUDRFR4rrrrruwdu3awPj0008P6zm5J/pTbPpS7dqdwYMHa8b19fU9vr5Iab5m3YQJMIVfgROpkIqRLlaMEBHFQ9onRrZs2aIZW63WkKqMvtB/4uP1ekO2nUSrQVqwgw3SuvPBBx9oxhaLBaeddlq/7rdq1SrU1dWFtUYy0ydGWDGiZVYUjMjJ0cxVtLbCr2tYS0SUzlavXo177rknMC4sLMTf/va3qKytf04eNKj3HhrdGTAgtMFnY2NjRGslM+nVJUYseRAifi+XRYa2YkR27Qn5oI2IiKIv7btIzpgxA9deey2qq6tRVVUFv98f0V7fvjThineDNP39pk2bFnK6Tm/mzJmjGauqilWrVqVMQ7besGKkd6Pz8rAtKOHnUVXscToxIjfXuKCIiBJER0cHFi5cqKlOffLJJ1FcXNzvtZ1OJzy67Ys5umR1X3XXl6S5uRnDhg3r8TFutxtu96FtJ8GN5ZOV1FWMCHN8ttEc3BJllq04Ivgbagc2rV8Bv+jbf9eioiKUlpZGP0AiohSX9omRefPmYd68ef1eR9/8zGazobCw8LDX9KdBWnBipKcGafr7RVIJM3LkSGRlZaE96Fi6devWpUVixKeq6NJts2JiJFS21YpBDgdqg0qud7S2MjFCRATg+uuvx44dOwLjX/7ylzjvvPOisnZwUuKgvm7P7cvjevvQ595778Wdd94Z0f0Sln4rTYwTIzV1bRACWLhwIQBAUYCmT0bDajnU6P3XF5+GrzeH/rfujsNhR1lZOZMjRERhSvvESDS43e6Q434nTZoUcl08G6S5XC5N8qQ/9xs9ejQ2btx42PulIn21CMDESE9G5+VpEiNNXV1o7upCftBxvkRE6ebtt9/G//f//X+B8dChQ/H4449Hbf3uEiPmCI+UN5lMIXPebp4Hg/3+97/HjTfeGBi3tbUdtsIkGei30sS68WpLWyekBP5y55k4Zua4/TEoHwLoCFzzwsNno9Xb+59r2fZaXHLdC2hoaGBihIgoTEyMRMFzzz2HhoYGzZy+GSsQ+wZpwZ/2VFdXh+xJ7c/9ghMju3enRyMwfWLEZjLB3I8jFSOhT6YZvU5PBmdmwm42o9PnC8ztaGnBzCiUihMRJaO6ujpcdtllgbEQAs899xzydKd59Ye+eTzQfYKjL7p7nNpLvyibzaY5vS7ZSekD/NrtQPHaSjNmRCGmH7k/+eGvL4R0H0qMjBhigZKT3AknIqJEx8RIP9XX1+MPf/iDZk5RFPziF78IuTbWDdKCEyM1NTUh10TrfvokUKoysvFqS309gEOltdESvCUqmhQhMCo3F5uDGvVVOp2YOmAALBG+SCciSmaXXXYZ6g/8LgeAq6++GieffHJU72Hp5nnJF5SgDkd31SGplPToE19L6Jw5L95RAOZcIKgYSPp42hsRUawxMdIPqqri0ksvDUkUXHDBBSHbVuLdIE1/Ik4079fcrD/KLjUZ2Xi1w+kEACy8/XZMmjGj3+t9s3Il/v3oo+jsQ5PgSI3KzcWWxkYcrFPyS4k9TidGRfHTUSKiZPDMM89g2bJlgfG4ceNw//33R/0+3SUu9K81+oqJEUDqEyOmTAjFGvc4hDkHwTW/TIwQEcUeEyP9cOutt+Kdd97RzBUUFHT74ifeDdJieb++nMCTCp3q2xPgRJqBpaUY2U2/mnDt27kzCtEcXobZjCFZWdgXVJVS0dbGxAgRpZXt27dr+m6YzWY8//zzsNvtUb9XTk4OhBCarbORVgY6DyTkg4V7kl3S82oTEMKIahFgf8VIMH/yvYYiIko28W2YkEL+9Kc/4cEHH9TMCSHw97//PaQHCBD/BmmxvF9vzdiA/Z3qc3NzA1/J2IyNR/WGb4SuKqmxqwttEX56SUSUbPx+PxYuXIiOjkP9IW6//XYcffTRMbmf2WwOqQZtCTo+PRzdPS7SLbjJKqRiRJ+giBNh0lX4+tv39z8hIqKYYcVIBO69996QviIAcOedd+Kss87q9jHxbpAWy/v11owNSP5O9VJKQ3uMJKvizEzYTCa4g/7+VbS2Yko3fXGIiFLN0qVLsWbNGs3cxo0bsWDBgj49PrgnCQD8+9//xnfffaeZu+aaa3DiiScGxkOGDEFr66FKh9ra2jCj7v5xGRkZ3W7dTWX6xEjCVIwAgM8JxPiEHCKidMbESBiklPjd736HxYsXh3zv6quv7jZZclC8G6TF8n592XOc7J3q3X4//LpTfVgx0jtFCAzPycH3QX1odre14ciiIgghDIyMiCj2XEHHlh/01ltvRbxeWVlZyKliZ5xxhmY8evRozTWVlZUR3Ut/4tzo0aMjWiep6Xt5GJQYEYoVUDIA9dDWZelrjfnRwURE6YxbafrI6/Xikksu6TYpcuWVV+Kxxx477OPj3SAtlvdL5oRHX+mrRQQAe4RbkdKNfjtNl9+Pmm7eLBARUf9N0vWh2rp1a0Tr6B+nXzfVSdULqB2aOcMqRoBu+oywASsRUSwxMdIHTU1NOOWUU/D888+HfO+mm27CE0880eun4QcbpAWLZYO03NzQMsxo3S8dmrF111+EFQ99k2uzIV+XPKto5Qs6IqJYmDVrlmZcXV2NqqqqsNbwer3YuHGjZm5GFE5ESyrdHtVrTI8RABAm7b2ljw1YiYhiiYmRXmzbtg2zZ8/GihUrQr533333hTRg7Um8G6QVFhb26XGR3C8dmrG5dNuOHNxGE5YRusRcVUcHPN30vSEiSiWXXHIJpJQRfw0fPlyz3v/93/+FXHPJJZdorjn++OOhKNqXc8uXLw8r7lWrVoU0bT/55JPDWiPZhRyJa8qCEAZWipp1DVh5ZC8RUUwxMXIYn376KWbPno1t27Zp5i0WC/75z3/i1ltvDWu9IUOGaMaxbJCmv1c075cWiRFdxYiD22jCUpqdDSWowkaVEpXdVDoREVH/DBgwIKRq5OWXXw5rjZdeekkzHjx4MKZPn97v2JJKojReDdxfVzHCI3uJiGKKiZEePP/88zj11FPR1NSkmc/Ly8MHH3yAiy66KOw19Y3MYtkgbeDAgSHJkmjdb9SoURGtk0w6WDHSL1aTCUN0W664nYaIKDb0r0nee+89rFu3rk+P3bVrF5YsWaKZu/TSS0OqUFJdSMWIgdtoAAAm3YlAPn64QEQUS+n1rNdHixcvxiWXXBLSdHTkyJH44osv8MMf/jCidePdIG3ixIn9vl9HRwf27t3bp/ulEn3FSCYrRsI2UredptnthjPCBsBERNSzCy+8EAUFBYGxlBI///nP0dDQcNjHuVwunHfeeejqOnT6id1uxxVXXBGzWBNVwhzVG7i/biuN9ECq7u4vJiKifmNiROfee+/FzTffDKk7qnX27NlYs2YNJkyYEPHa8W6Qpr/f2rVrw7oXAKxfvz7kzyLVG7JJKdljJAoGORzIMJk0c5VtLAUmIoq27Oxs3HHHHZq57du34+STT8b27du7fUx1dTV+8pOfhFSW3HDDDRg6dGjMYk1Y+uarBidGYMoKnWMDViKimGFiJMhjjz2G22+/PWT+7LPPxscff4wBAwb0a/14N0g78cQTNeNt27Zhz549Yd3vww8/1Ixzc3Mxc+bMsNZINl5VhU9VNXPsMRI+IQSG6bdzOZ0hiTYiIuq/6667DnPnztXMbdy4EVOnTsUVV1yBZcuWYd26dXjvvfdw8803Y9KkSVi5cqXm+unTp+OPf/xjPMNOCFL1AKr2WHl9j494E8IEmLRbUqWf22mIiGKFiZED3nnnHVx//fUh87/+9a+xdOlS2O32ft8j3g3STjnlFFit1ojvJ6UMuf60006DSVcFkGr01SIAYGdiJCKlusRIu9eLFjdLgYmIos1kMuGtt94KeU3gcrnw9NNPY/78+Zg5cyZOP/10LF68GM3NzZrrRowYgTfeeAM23XHraaG7E1+M7jECACb9yTSsGCEiihUmRrC/KenChQuh6qoErrzySjzzzDNRbUAWzwZpOTk5OOusszRzf/nLX9De3t6n+73yyishJ/JcdtllfXpsMtP3F8kwmWBKsyZ00ZKfkYFM3TYknk5DRBQbBQUF+Oijj3DGGWeE9bg5c+Zg1apVIccFpwt9fxGYso09qvcAoWvAyooRIqLY4bs9AL/5zW/QqjsxY968eXj88cejfq94N0i77rrrNOOqqipcfPHFIUkgvfLyclx11VWauSlTpuCkk0467ONSAfuLRI8QIqRqpLKtjdtpiIhipKCgAMuWLcObb76J44477rAf7kyePBnPPvssVq1alZ59RQ4KabyaANUiAKBvwMqKESKimDE+HW6w999/H++//75mbvDgwXj++edjclTdwQZpN910U2DuYIO01157DWPGjAl5THV1NX7+859H1CDt2GOPxZlnnolly5YF5l5//XVccMEFePbZZ0OO9AWANWvW4Lzzzgsps33ggQcghOjTz5nM9BUj7C/SP6XZ2SgLOva6y+9HfWcnBjocBkZFRJR4KioqorbWWWedhbPOOgt1dXVYvXo1qqur0djYCIfDgcGDB+Poo4/GyJEjo3a/ZBZ6VG+eIXHoCVM2gj9GYMUIEVHspP07vj//+c8hc9XV1SgsLOz32rt27cKIESNC5q+77jq88cYb+OyzzwJzBxukXXjhhZg3bx6GDBmCuro6LF++HH//+99DkhThNEh76qmn8MUXX6CxsTEw98orr2DVqlW4/PLLMWfOHOTn52P37t1YunQpXn31Vfh0VRNXXnklTj311DB++uTFipHoyrHZkGuzoTWot0hlWxsTI0REcTBw4EDMnz/f6DASWuhRvQlaMcLECBFRzKR1YqS6uhqffvpp3O97sEHaySefjG+++SYwf7BB2tNPP33Yx4fbIG3IkCH473//i5NPPlmTYKmqqsKiRYt6ffxpp52Ghx9+uE/3SgUduoqRTFaM9Ftpdja+DUqM7G1vx/RetnMRERHFRQJXjGioXZCqB0Kxdv8AIiKKWFr3GFmxYoVh9453g7QZM2Zg+fLlmDhxYliPu+yyy/DWW2+lVZf6kK00rBjpN32fEa+qotbl6uFqIiKi+Oj+qN48Y4LRM4dud2bVCBFRbKR1YmTv3r2G3j/eDdKmT5+ODRs2YPHixZgwYUKP1wkhcOqpp+Kjjz7Cs88+G3LkbypTpUSX36+ZY2Kk/xwWC4p0R17zdBoiIjKc/kQaIDGO6gX2n4yjaLedSjZgJSKKibTeI3DzzTfj5ptvNjqMuDZIs1gsuPHGG3HjjTdi69at2LRpE2pqauB0OpGbm4vhw4djzpw5mpNz0om+WgRg89VoKc3ORkNnZ2Bc1d6OIgPjISIiCmm8asqGECZjgumOORvwBFW0sGKEiCgm+I4vgcS7Qdq4ceMwbty4uN0vGegbr5oVBZYYnE6UjoZmZWF9XV1g7JcSbWlwyhERESWwkMareYaE0RNhyoFEbWDMihEiotjgOz6iIN0d1ZsORxTHg81sxgDddppmJp2IiMhA+hNpEqXxaoC+ASsrRoiIYoLvSoiC8Kje2Bqqa8LaIgQUblUiIiKD6LfSJMxRvQcI3ZG9rBghIooNJkaIgnRXMULRU5KVpRmrQmDgtGnGBENERMSKESIiAhMjRBr6ipFMVoxEld1sDjmdpmTOHIOiISKidLb/qN5OzVyiV4xA7YRUQxvFExFR/8Tk4/Dnn38+8O8jRozA8ccfH5V1Kyoq8Oyzz2LTpk3YuHEjXnnlFRxzzDFRWZsIADpYMRJzQ7OyNKfTDPnBD+CX0sCIiIgoLelPpAES5qjeAH3FCLC/akRJz9MDiYhiJSbv+i655JJAw8pzzz03aomRvXv34t577w2svW3bNiZGKGqklOwxEgclWVnYUF8fGFuzslDhdmOWgTEREVH6kX5dvw5TVmId1QtAKBZAyQDUrsCc9DshLEyMEBFFU8y20kgpIaP8KXBOTk5gbQCoD3pzRdRfbr8fqu7vLCtGos9hsaAgI0MzV+5yGRQNERGlLX3FiCnBqkUOMum207ABKxFR1MUsMSKEiPoxpxUVFYG1AcDtdkd1fUpv+moRgf09MSj6huqasH7f1QW/qhoUDRERpSP9CS8h/TwShDBrt9NINmAlIoq6pGi+2tXVhXXr1uH2228HcKhi5GAFCVE06E+ksZvNUU/u0X76Y3s7VRWbGxsNioaIiNJSgh/VG8CKESKimAvr4/Curi5MnDgRu3fv7vXag8mLpUuXwmSK3n5NIURg7fHjx0dtXSL2F4mfTIsF+TYbmoOqvlZXVWHKgAEGRkVEROkkpMdIAleMBG/0ZcUIEVH0hVUxkpGRgcceeyzQP6Snr2C9XRvu10EFBQU47rjjovOnQITQihH2F4ktfdXI1zU1IT1eiIiIYkFKNaTyQiRNjxEmRoiIoi3srTTz5s3D2WefDeBQHxH9V7Ceron0S0oJIQQee+wx2Gy2qPwhEAGhFSOZrBiJqSG6PiPNbjd2tLQYEwwREaUXfwcAXW+rRK0Y0R/Zq3ZASl/3FxMRUUQi6jHy6KOPIjMz05CKkeLiYixZsgQ///nPo/IHQHQQK0biK8dqhU33++LrmhqDoiEionQi9SfSCAug2I0Jpje65qsAAF97/OMgIkphEb3zGzp0KN577z3s2LEj5HtSSlx66aWBypGZM2fiqquuiig4IQRMJhNsNhvy8/NRWlqKMWPGsCEmxUQHe4zEXZ6qojaoB9HXNTW4YMIEAyMiIqK00E1/kUR9fSkUGyBsgDzUl0v62yAsecYFRUSUYiL+SHzu3LmYO3dut9+79NJLA/8+fPhwXHzxxZHehigu/AA8fr9mjhUjsZcvJWqDxnucTtR0dKA4M9OwmIiIKPXpK0aEvo9HojFnA95DiRGwASsRUVTF7Lje7rbVECUqTzdzrBiJvUwp0aXrK8LtNEREFHP6I28T9ajeA/R9RiSP7CUiiqqYfCQeXCEya9asWNyCKKq8uvJZq6LArMQsb0gHCADVX3+NkaecEpj7uqYGZ44ebVxQRESU8qRfVzGSoI1XA/TxsWKEiCiqYpIYee6552KxLFHM6CtG7KwWiZvqNWs0iZHyxka0ud3I4alTREQUK/qKi0Q9qvcAYcpGcB225JG9RERRxY/EiQB4dBUj7C8SP7UbN8IS9OevAlhfW9vzA4iIiPpBqh5A7dTMJXzFiP7IXlaMEBFFFRMjRAC8urGdiZG4UT0ejNRVh3zFPiNERBQr3fXnSPDEiNAf2etvh5SqMcEQEaUgJkaIEFoxwsRIfI212zXjjfX1cOtOCSIiIooGfX8RmLIgRII/7+srRiABf4choRARpaKYPwt4PB4sXboUy5Ytw4YNG1BXV4eOjg74fD6oauSZbiEEfD5fFCOldMatNMYak5EBBfu30QCA2+/Ht/X1mFlcbGRYRESUikL6iyR2tQgAQLEDwgzIoNe+fuf+Y3yJiKjfYvru791338U111yDyspKAODxvZSwQpqvMjESVw6TCeMKClDW1BSYW1tby8QIERFFnfTpT6RJ7MarwP4PBGHKAnwtgTnpd0L0/BAiIgpDzLbSvPzyyzjnnHNQWVkJKSWklBBCROWLKJpMViv8+q00PJUm7mbpkiDra2uZTCUioujzaytGEr7x6gFCv52GJ9MQEUVNTBIj1dXV+PWvfx3Y6nIwoXEwQdLfL6JoshcWhsxxK038HTVokGbc1NWFirZuGuQRERH1g75iBElQMQIgZNuM5Mk0RERRE5N3f4sWLUJHR0eguuNgMmP27Nk45phjMGzYMGRlZcHCT+UpAdiLijRji6LArLAvcbwNycrCIIcDtS5XYG5dbS1G5ibJC1YiIkp4UsqQHiMiGXqMYH/FiObjQSZGiIiiJuqJEb/fj9dee02TFCkpKcGSJUtwwgknRPt2RP2mT4ywv4gxhBA4atAg/GfXrsDc+tpaLBg71sCoiIgopfg7cKjV9wHJUjGi20ojuZWGiChqov6x+Jdffonm5mYA+5MiVqsVy5YtY1KEEpZ+Kw230Rhnhm47zbbmZrS63QZFQ0REKUd/VK8w7z/xJQmE9ELxO7nFnIgoSqKeGNm5c2fg34UQOP/88zFt2rRo34YoavSJEVaMGGdSYSEyTKbAWAL4pq7OuICIiCilhPQXMeUmT2N/U5Z2LL2A5IcHRETREPXESE1NDYBDfUXOPvvsaN+CKKpCttKw941hLCYTpgwYoJlbX1trUDRERJRqpL6/SJKcSAMgNDEC8GQaIqIoiXpiRJ91Hz58eLRvQRRV3EqTWPTbaTbU1cGnqj1cTUREFIZkPZEGgBAmwJSpmePJNERE0RH1xMgg3ZsaN/sDUILjVprEok+MuHw+lDc1GRQNERGlEulP4ooRANCfoMOKESKiqIh6YmTKlCkADlWOlJeXR/sWRFHjkxIZeXmaOVaMGKsgIwOjdEf0cjsNERFFRUiPkeRKjAjddhpWjBARRUfUEyPTpk3DkCFDAuO33nor2rcgihqn3x8yx4oR4+mrRtYxMUJERP2kwAeonZo5kURbaQAAZu2RvWBihIgoKqKeGAGAK6+8ElJKSCnx7rvvYsOGDbG4DVG/tekSI2ZFgSXoVBQyxlG6xMi+9nbUdHQYFA0REaUCi9LN80iSbaURugoXya00RERREZPEyI033oiRI0dCCAFVVXHBBRegsbExFrci6hd9xQirRRLD6Lw85FqtmjlWjRARUX9YTS7thJIJIZLseV9/Mg0rRoiIoiImiRG73Y7XX38d2dn7y/3Ky8tx1FFH4fXXX4fK0yUogTh9Ps2Y/UUSgyIEpuuqRthnhIiI+sOqrxhJsmoRoJtmsaoLUvq6v5iIiPosZu8Cp06dik8//RRnn3029uzZg8rKSpx33nkYOHAgZs+ejSlTpqCgoAA5OTkwRbh14aKLLopy1JRu9FtpWDGSOI4aNAif7tkTGG9ubESnz8f/RkREFBF9YiTp+osAgCk7dM7XDljy4h4KEVEqick7jIKCgsC/ezweSCkhhICUErW1tXj77bfx9ttv9/s+TIxQf+m30rBiJHFMGTAAJiHglxIA4FNVfFtfj6MHDzY4MiIiSkb6rTTJmBgRihUQNkC6A3PS3wbBxAgRUb/EZCtNS0tL4Kuz81D3byFEIEHS3y+iaGDFSOLKtFgwobBQM8c+I0REFKmQrTRJdlRvgFnfZ6TdmDiIiFJITBIjwKEkyMF/7+57kX4RRUtI81WLxaBIqDv602nW19YyMUpERGETArAqyV8xAnR3Mk2bQZEQEaWOmCVGolEVwmoRiiWvqqJD1wyYW2kSywxdYqTZ7cau1laDoiEiomQ1uNAERegOAEjC5qsAQvuMsGKEiKjfYvIukCfPUDJo7uoKmeNWmsQyJDMTxZmZqOk4VP68rrYWo/LyjAuKiIiSzogSXUWoMAOKw5hg+kmYs6H5mJBH9hIR9VvMKkaIEl1jUP8bADAJAYvC/yUSiRAiZDsN+4wQEVG4RukTI6ac5N2erasYkT4mRoiI+ovvAiltNeoqRhxmc/K+SEphMwYO1Ix3tLSg1e3u4WoiIqJQI4doEyPJ2l8EAETIVhont5oTEfUTEyOUtvQVI2y8mpgmFhYiw2QKjCWAb1g1QkREYQjZSpOs/UUAwKxLjEAF1I5uLyUior5hYoTSVkhihP1FEpLFZMKUAQM0c2uZGCEiojCMHKJ9jhem5K0Y2d8bRfcS3scGrERE/cHECKWt7rbSUGI6qrhYM95UXw8fmzwTEVEf6bfSJHPFiBAitM+In0f2EhH1R0zeCVZWVsZi2RClpaVxuQ+lJlaMJA99nxGXz4eyxkYcqaskISIi0hOyC4MKdRUjSdxjBDhwMo0/6Ph6fzsAu2HxEBElu5i8ExwxYkTMm1gKIeDz+WJ6D0ptTbqKESZGEld+RgZG5+VhR0tLYG59bS0TI0RE1CurrAud1DcwTTYhJ9O0AeBzIhFRpGK2lUZKGfMvokj5VBXN+q00bL6a0HhsLxERRcKiT4womRBKkj/nh5xMwx4jRET9EbPEiBAi6l9E0dLc1QV9ao0VI4lNnxip6uhAVTtfCBIR0eFZpC6RnsT9RQ4SZvYYISKKppi9E4xWRUdwQmTMmDEoLCyMyrqU3vSNV4WUsCrsRZzIRubmIt9mQ7PbHZhbV1uLIVlZBkZFRESJzgptxYhIgcRISMWIz2lMHEREKSImiZFPPvkkosd5vV50dnairq4O5eXlWLFiBdauXQshBKSUcLlcePnllzFjxowoR0zppknXeNUKsCopwSlCYMagQVge1Nx5XW0tzhw92sCoiIgo0YVspUnmo3oPEPrEiPRAgdeYYIiIUkBMEiMnnHBC1NZau3YtLr30Unz33XeoqqrCKaecghUrVmDy5MlRuwelH33FiJU9a5LCUbrESFljIzq8XmSyPwwREfXAqttKkxIVI+bQakmL4jIgECKi1JDwewdmzpyJzz//HFOmTIEQAs3NzTj33HPhDiqnJwqX/qhevq1ODkcOGABL0JYnv5TYWF9vYERERJTIpFRDKkaS/aheABDCDCgOzZxV6ezhaiIi6k1SdJvMzs7GkiVLMG3aNADA9u3b8fDDD+O2224zNjBKWqwYSSxlZWV9vnaYxYKdQYnRD7dsQUZNDQCgqKgIpaWlUY+PiIiSlLc+dItJCiRGAOzvM6IeqhKxmFgxQkQUqaRIjADA5MmTcdZZZ+GNN94AADz++ONMjFDE9BUjVoPiSHctB6o9Fi5c2OfHjDr9dEz/zW8C47XV1Vj04x8Dqgq7w4HysjImR4iICACgdu3RzZhCKi2SlTBnQ3oPbROysGKEiChiSZMYAaBJjFRXV2PdunU46qijDI6KklFIYoQVI4bocO7vor/w9tsxqY9Nld0Avg0a23Jzccerr6J1xw48fsstaGhoYGKEiIgAANKtS4yYc1On2bquAauVPUaIiCKWVImRCRMmADh0esimTZuYGKGw+VVVc+QrAFiYGDHUwNJSjJw0qc/X766oQJvHE7TAQJTwvyEREelIXcVISjRePUCYsxH8zMeKESKiyCV889VgqqpqxnV1dT1cSdSzFrcbqu5NNLfSJJchmZmacXV7u0GREBFRIpNdldqJVOkvArBihIgoipIqMbJz507N2MIjOikC+sarfq83uUqnCIOztMcUtno84DlVRESkp99KI0wpVDGiS4yYRRcsfEFDRBSRpEqMvPbaawAAeeDT/sGDBxsZDiWpJl1/kc6GBqTIbuO0UZiRAaui/fXVqiTVrzMiIoqDkOarqVQxYtYmRoQAhgxgZoSIKBJJ807ik08+wZtvvqlpmDUpjJ4ERAc16BMjjY0GRUKREkKgWLedpjVVmukREVFUSH8n4K3XzKVSjxEIGyC01dOlxaymJiKKRMInRnw+H/75z3/izDPP1MwPHz4cU6ZMMSgqSmb6rTRMjCSnIbrtNG1CwGSzGRQNERElGuneGzqZSltphAjpMzJsECtGiIgiEZPfnnfddVfEj1VVFR6PB+3t7aipqcGqVatQV1cHKSWEEIF/Lly4MIoRUzrRH9Xb2dBgUCTUH4McDggg0JFfCoGBU6caGRIRESUQfeNVr2qDWUmtigphzob0NQXGpcVMjBARRSImvz0XLVoUtTPiD/YTCV5v0KBBuOmmm6KyPqWfJlaMpASryYQiux31QYmuwTNnGhgRERElEn3jVY+aCbtBscSMvmKEiREioojE9Len1B2JGonghIiUEhkZGXjppZeQm5tCzbMorkIqRpgYSVqDMzM1iZHiWbOi8nuHiIiSn77xqsfvMCiS2BGmbAQ/6w1jjxEioojEtMeIEKJfX8D+ZMjBr+OOOw5ffPEFTjjhhFiGTSlMlTK0YoRbaZKWvs+IvaAANV6vQdEQEVEi6a5iJOXoTqYpZY8RIqKIxOS3Z2lpab+20gghYLFYkJ2djeLiYhx11FGYP38+jjrqqChGSemo1e2GX1dR4GJiJGllWSzIsljQHpQM2drZiXkGxkRERIlB6itGUjAxIrrZSlPBykkiorDFJDFSUVERi2WJ+k2/jUYB4G5tNSYY6jchBEqysrC1uTkw973uvzEREaUfKWU3iZHU20qj7zFitykwoc2gYIiIklfCH9dLFE36o3qzTSaAn6wktRLddpoGnw/V7e0GRUNERAnBWw9It2bK40+9ihGYMgFoq7QtkpWwREThYmKE0oq+YiTbZDIoEoqWgowM2HT/Hb+qqTEoGiIiSgT6xqtdbhU+mWFQNLEjhAKYtB8QMDFCRBQ+JkYorXRbMUJJTQgR0oT1ayZGiIjSmr7xakW1D/rKipSh207DxAgRUfiYGKG0oq8YyWFiJCWUZGrLo7c2NaHV7e7haiIiSnX6/iK79qXuiWVCdzKNBfUGRUJElLzifqbXypUrsWLFCqxatQq7d+9GU1MTmpubYTKZ4HA4MGjQIIwaNQrTpk3DD3/4Q/zoRz+CiW9eKUq4lSY1DXQ4oEgJ9eAx3wDW1tTgpOHDjQ2MiIgMoa8Y2VXlxdCJBgUTa6wYISLqt7gkRlRVxfPPP48///nP+P777wPzMqjppaqqaG1tRWtrK7Zt24YPPvgAf/7zn1FcXIxrr70WN910EywWSzzCpRSm30rDipHUYFIU5EqJ5qBjwr9iYoSIKG3JrkrNuKLKi+MMiiXWhCkbwW3kzUyMEBGFLeZbaWpqanDiiSfif/7nf7B169b9x6cd+BJCdPsVfE11dTXuuOMOTJ06FeXl5bEOl1KYKiWa2GMkZeWpqma8qb4enT6fQdEQEZGR9M1XU3krDfRbaZgYISIKW0wTI+Xl5ZgxYwY+//zzbhMhwQmQwyVMpJQoLy/HMcccg/Xr18cyZEphTo8HPt2b5xxz3HeTUYzkSgk1KBHiVVVsrKszMCIiIjKC9HcCXu3v/11VqZsoF7qtNGY4If0ug6IhIkpOMXtX2NjYiDPOOAM1NTWBBAdwaPvMiBEjMHPmTAwcOBC5ubnw+XxobW1FdXU11q1bh6qqKgDQPLa1tRVnnnkm1q1bh+Li4liFTilK319EEQKZCvsPpwozgPrvvsOgadMCc1/V1GD2kCGGxURERPEn3XtD5lK6YkSXGAEA6a6CcIwxIBgiouQUs8TIr3/9a+zcuVOTEMnOzsY111yDyy+/HMN72fu/bds2PPvss3jyySfR0dERWKempgZXX301li5dGqvQKUXp+4vk22xQRIoe3Zemqtas0SRG1tfWwqeqMDMBRkSUNvT9RXzIQ6db9nB18hOKBVAyAPXQ6xzprgKYGCEi6rOYvFtYvXo13nzzTc12maOPPhobN27E//t//6/XpAgAHHHEEbj//vuxceNGzJo1K7DFRkqJN998E2vWrIlF6JTCGnQVI4V2u0GRUKxUf/WVZtzu9aKssdGgaIiIyAjSrU2MeMQggyKJI1OOZthd1QwREfUsJomR+++/P/DvQghMnToVH374IUaMGBH2WqNGjcKHH36IqVOnauYfeeSR/oZJaaaJiZGU19nQgGLd6VVf1dQYFA0RERlB33jVIwYaFEn8CDMTI0RE/RH1xIjX68VHH30UqO4wmUx44YUXkJ0duv+xr3JycvDCCy/AZDIF1n3nnXfg8XiiGDmlOv1WmsKMDIMioVgaq0t4fV1TozkanIiIUpt+K403DStG9MkhIiI6vKgnRlavXo329nYA+6tFzjnnHEyePLnf606ePBnnnHNO4A1OR0cHT6ihsOibr7JiJDXpEyMNnZ3Y1dpqUDRERBRvMqRiJPUTI6wYISLqn6gnRior92fpDyYwzjzzzKitPX/+fM14y5YtUVubUh8rRtLDALMZxQ6HZo7baYiI0oOUKqRbmxjxpsFWGphzNUN9coiIiA4v6omRujrtufGjRo2K2toH1zp4Qk0jmypSH0kpQ3qMFLBiJCUJITBr8GDN3FfV1QZFQ0RE8SQ9tYDUHs3rEcUGRRM/QreVBv5WSF+bMcEQESWhmPQYCWa1WqO2tkXXVJGor9o8HnhUVTNXxMRIyjq6WPsiuNLpxL4DW/yIiCh16fuLQLHDj9zuL04l5mzo22npK2eIiKhnUU+MFBYWasZ790Zvj+PBtQ5u0ykqKora2pTa9P1FFAD5NpsxwVDMjS0oQJ7uv++XVVUGRUNERPGiTwYI2zDgQKVxKhPCBK/UfuAju9hnhIior6KeGBk6dCiAQ9tdPvzww6itrV+ruDj1SyMpOhp0iZH8jAyYlJicVk0JwCQEZuu20zAxQkSU+vQVIyJjmEGRxJ/Hr+2vpbJihIioz6L+zvCYY46ByWQCsL+y4+WXX0ZTU1O/121sbMRLL70USLgoioJjjjmm3+tSeghpvMptNCnvmCFDNOPdbW2o4nYaIqKUpm86KjJKDYok/jxqpmbMihEior6LemIkJycHs2fPDmx3aWlpwTXXXNPvda+55hq0tLQAONBccdYs5OXl9XtdSg/6ihH2F0l94wsLuZ2GiCjNqG5txYhiS5+KEa+qrRhhjxEior6LyV6Ca6+9FsD+BIaUEq+88gquvvpq+P3+sNfy+/24+uqr8corrwTWA4DLL788qjFTatP3GGHFSOozCYEfcDsNEVFaYcXIIawYISLqu5gkRhYsWICJEycCOJQceeqpp/CDH/wgrJ4jH3zwAY4++mg89dRTgTkhBMaOHYuLL7446nFT6mLFSHrSb6epaGtDNbfTEBGlJOlzAr5mzVw69xiR7r2QUu3haiIiCmaOxaKKouDFF1/ED37wA3i93kByZP369TjttNMwbNgwnHDCCZgxYwaKi4uRm5sLKSXa2tpQU1ODdevWYcWKFdi7d2+gQuTgGjabDX/7298CvUaI+iKkYiQjw6BIKNbKysoC/65KCYeiwBV0VPPStWsxJyen13WKiopQWpo+nzQSESW70K0jAsJWAqDFgGjiT18xAukBPHWAjYcVEBH1JiaJEQCYOnUq/v73v+NXv/oVfD5fILEhpURlZSWWLFmCJUuW9Ph4GXQYe/AWmmeeeQZz5syJVdiUgvxSoknXfJUVI6mnpb4eALBw4ULN/PQrrsCon/wkMH5j/Xpce9NNva5ndzhQXlbG5AgRUZIIOZHGWgyh2Hq4OvX4pA2dbhV226GCcNW9FyYmRoiIehWzxAgAXHDBBSgqKsKCBQvQ3t6uqfIITnx0R39tXl4ennvuOZx11lkxi5dSU6vbDb/u7xt7jKSeDqcTALDw9tsxacaMwHybEPg+6Lr8MWOw6LXXcLiXyvt27sTjt9yChoYGJkaIiJKEGtJfJH220ewnUFHlw4SR1sDM/iqamcaFRESUJGKaGAGAU089FVu2bMFdd92Ff/zjH/D5fADQ61aYg4kTi8WC888/H3fffTdGjBgR63ApBen7i5iFQK4tfT5BSjcDS0sxctKkwFiVEhU7d8IT3Px58GCMLCgwIDoiIooVqTuRRtjSL7G9u9qrTYywASsRUZ/EpPmq3tChQ/HMM89g27ZtWLx4MebNm4esrKzA1hr9V05ODk477TTcc8892LlzJ1544QUmRShi+v4iBXY7FPaoSRuKEBialaWZ23uguoSIiFJH6Ik06VYxAuza59WMeWQvEVHfxLxiJNjw4cNxww034IYbbgAAtLa2orGxEY2NjVBVFQUFBcjPz0dhYSGbq1LU8EQaGpqVhZ2trYFxs9uNDq8XmRaLgVEREVE0pfNRvQdVVPs0Y/2fCRERdS+uiRG93Nxc5ObmYtSoUUaGQSmOJ9LQAIcDVkWBJ+h0mr1OJ8ZxOw0RUUqQ0gfpqdLMKbb0qxipqNJWjKisGCEi6pO4bKXpK6/X2/tFRGFixQgpQqBEt51mD7fTEBGlDOmuBqS2WiItK0Z0iRF46iBVtzHBEBElkagmRurr6/H2229H/Pi//vWvGDVqFG677TZs2rQpipFROmvUHdXLE2nS09DsbM344HYaIiJKfvqjemHKAsx5hsRipJDECCSke58hsRARJZOoJEbKy8uxYMECDB06FJdcckmvR/H25OOPP0ZFRQUeeOABTJ8+HT/96U+ZIKF+02+lYcVIehp4YDtNMDZhJSJKDfomo8I2LC371TldEj5oPwjgyTRERL3rV2LE5/PhhhtuwJQpU/DGG2/A6/WitbUVGzZsCHstVVWxcuVKCCECp9O89dZbOOqoo7Bo0aKIky2U3nyqimZWjBC4nYaIKJXpK0bScRvNQV4xUDPmyTRERL2LODFSV1eHE088EY8++ih8Pp8mcbFixYqw11u3bh3a2toAAEKIQILE7/fj7rvvxkknnYT29vZIw6U01dzVBX1KjRUj6au77TROj8egaIiIKFpU3ekrShoe1XtQSGKEJ9MQEfUqosRIW1sbTj75ZHz55ZeQUgYSGQeTGStXrgx7zYaGBgwdOjRQLQJoEyQrVqzA/Pnz4XazgRT1nb7xqtVkQhaPaE1bAx0O2EwmzRyrRoiIkp90s2LkII8uMcKTaYiIehdRYuS8887Dd999BwCB/ZtSSlitVvzyl7/E9ddfH/aaP/nJT1BZWYnvvvsO1157LbKysjQJkoPJkcsuuyySkClNhfQXychIyz3HtJ8iBIbpqkYqnU5u1SMiSmJSytCtNGl4VO9BoVtp2GOEiKg3YSdGnnvuOXz44YeaN5dSSlxyySXYtm0bXnjhBRx//PERBzRx4kQ88sgj2LVrFy644IKQ5Mi//vUv/Oc//4l4fUov+ooR9hchfWLE6fGglZVoRETJy9cC+LXbrdO5YoRbaYiIwhdWYsTlcuG2227TVInY7XYsXboUf//73zF06NCoBVZQUIAlS5bgySefDMwdTI5ce+21/ISX+oRH9ZJeYUYGHGazZq6S22mIKA7cbjdeeeUVXHXVVTjqqKNQUlICu92OzMxMlJaW4phjjsHvfvc7fPDBB1F5nbN8+XJceeWVmDZtGoqKimCxWJCdnY2JEyfiwgsvxNKlS+Hz+aLwkxkrtLmoCcI62JBYEoF+Kw38TkhfqzHBEBElCXPvlxzy6quvor6+PpCgsFgseOONN3DKKafEKj785je/gdfrxW9/+9tAQqaiogLLli3D/PnzY3ZfSg2sGCE9IQRKs7NR3twcmKt0OnFkURG3WRFRTPh8PixevBgPPfQQ6urqur3G5XJhz549WL16NR588EFMnDgRd911F84999yw77du3Tpcdtll3Z4S2N7ejrKyMpSVlWHJkiUYOXIkHn/8cZx++ulh3ydR6BuvCtsQCCV9+4l5UYT9n32qgTnZVQmRdaRhMRERJbqwKkaee+45AAg0XL3xxhtjmhQ56JprrsG8efMC9wWAZ555Jub3peTXXY8RomE5OZpxp88XUl1ERBQN+/btw3HHHYfbbrutx6RId7Zs2YIFCxbgyiuvhCeM07NefPFFzJ49u9ukSHd27dqFefPm4c477+zzPRJN6FG96dtfBAAgzBC2IZoptWu3QcEQESWHPidGPB4Pvvzyy0BiIjMzE3fccUfMAtO77777NFt4Vq5cadh2mnvuuSdwYs4ll1wSlTXjWe7qdrvxwgsv4Je//CXGjh2L3NxcWCwWFBQUYNasWbjuuuvwxRdfROVeRtMnRlgxQgCQa7Uix2rVzFUeOC6ciChampqacMopp2D16tUh37NYLJg5cybOOOMMnHrqqRg7dmy3azz11FO49NJL+3S/119/HRdddFHI6wWr1Yqjjz4aZ5xxBmbOnAmr7vcfACxatAgPPvhgn+6TaPRbadK58epBImO4ZiyZGCEiOqw+J0a++eYbeL1eAPtL0c8991xkZWXFLDC9SZMm4YQTTggkQzo6Ovr8aUg0bd26Fffcc0/U1lu3bh2mT5+Ok08+GU899RQ2btyIxsZG+Hy+QLnrkiVLsGDBAowdO7bfjWdfeukllJaW4qKLLsK//vUvbNu2DW1tbfD5fGhubsbatWvx6KOP4thjj8WJJ56I8vLyKP2k8ef1+9Gq+5StiIkRwqHtNMH2tLdDZe8iIoqiiy66CGVlZZq5QYMG4cknn0RzczO+/vprLFu2DB988AG2bt2KiooKXHXVVSHb+l588cVekxa7du3Cr371K6jqoe0TJpMJd9xxB6qrq7FmzRosW7YMX3/9Nfbu3Ytbb70ViqJ9Gfj73/8ea9eu7edPHX+hFSPp23j1IJExQjNmYoSI6PD6nBjZvn07AAQSE3Pnzo1NRIdx8skna8bff/99XO/vdDpx3nnnoaOjIyrrxbPcVUqJq6++GhdccEGfS3lXrFiBWbNmJe0pQN1tjWDFCB2kP53G4/ejzuUyKBoiSjXvv/8+3n33Xc3c5MmTsW7dOlxxxRXIzMwMeczw4cPx17/+FW+++SYsFm2PjLvuuuuwz98333wz2oIq3xRFwauvvoo//elPKCgo0Fw7YMAA3HfffXjjjTdgDmpG7fP5cOutt4b1cyYC/akrSrpvpQGg6CtGOiuMCYSIKEn0OTHSHNSoEADGjBkT9WB6M336dAAIfJLS1NQUt3t3dXXhnHPOwbfffhuV9eJd7nrDDTfgiSeeCJnPz8/Hcccdh9NPPx0TJkwI+X57ezt++tOf4rPPPgvrfolA33jVbjYj05K+zdhIK8tqRYGu5wy30xBRtCxevFgzzs7Oxttvv42SkpJeHzt//vyQxzudTjz99NPdXv/NN9/g9ddf18zdcccdOOecc3q9z0MPPaSZ+/jjj/Hxxx/3GmOikKob0lOtmWPFCCDs2sQIe4wQER1enxMjbbo3DHl5edGOpVdFRUWacUtLS1zu297ejnnz5mH58uVRWS/e5a5Lly7FI488opnLz8/HP/7xD9TU1GDlypV49913sWXLFmzZsgVnnnmm5lq3242f//znaG9vj/AnNgb7i1Bv9Ntp9rW3wx/0/yURUSTq6+vxySefaOauuuoqjBw5ss9rXHXVVRg1apRmbtmyZd1e++STT2rG+fn5uO222/p0n2uuuQZTp07VzHX3QUqiku4qANptkMLGxIh+Kw18TZA+Hk1PRNSTPidG7Lo3lV0GnOAQXO4JoNtqimjbvHkzZs2aFdVPT+JZ7trZ2Ynrr78+ZM2vvvoKF198ccif4YQJE/D222/jlltu0czv27cPDz/8cF9/xISgrxjhiTSkN1SXGPFJieoobZUjovS1cuVK+P1+zdzPfvazsNYwmUyYP3++Zm7Dhg0hjef9fj9effVVzdwvf/lLOByOPt1HCIErrrhCM/fee+/BlSRbC/X9RWDOhzBnd39xGhG2odC/zJddFYbEQkSUDPqcGMnNzdWM47mN5aDGxkbNODs7tk98zz//PI4++uioNiCNd7nrU089hb1792rmXnrppV63Qt13331YsGCBZm7x4sWG/HePFCtGqDd2sxkDdX8vKp38RI2I+mfLli2asdVqDanK6At9xYjX6w15Hv7qq69CKmj1lZ+90V/vcrnw3nvvhbWGUXgiTfeEYuWRvUREYehzYuRg+efB/h6bNm2KTUSHcfCeBz8tKSwsjMl9tm7dirPPPhsXX3xx1D8xiXe561NPPaUZn3rqqTjppJN6vZcQAo8++ihsNltgrrW1Ff/617/6FGsiaNBVNfFEGupOaU6OZlzd0YHoHIxNROlqxowZuPbaa7FgwQLMmTMH06dPD9kS2xd9qc7V9wBTFAXHHHNMWPcpKSlBaal2+8mnn34a1hpG0b/ZZ+PVQ0JPpqkwJA4iomTQ52fpKVOmaMaff/551IPpjX6/7sSJE6O6fl1dHa6++mpMnjwZb731Vsj3r7322n6dxhPvctf169eHnNxz+eWX9znewYMH4+yzz9bMvfbaa31+vNEadH8uTIxQd0qyshB8MKYqJVp0R2USEYVj3rx5ePTRR/Hqq6/i888/x+rVqyNaZ/PmzZqxzWYL+VBIf82oUaMiqqg98sgjNeN169aFvYYR9MfQCt1pLOksJDHSyYoRIqKe9DkxUlhYiHHjxgHYX7HxwQcfoL6+PmaB6dXX1+ODDz4IVKzYbLZAPNFyzz334Iknngg5KSY7Oxt///vf8eijj8JkMkW8frzLXT/44APN2GKx4LTTTuvX/VatWtXn436NJKVEvW4rzYA+JqAovVhNJgzWHZvZGMEnu0RE0eR2u0OO+500aVLIdWVlZZrx2LFjI7qffovt9u3bI1on3pgY6Zli11YB6f+siIjokLBe/Z9zzjmBbSw+ny+uzTjvu+++QMJCCIHjjz8+orLUcJ1++unYvHkzfvWrX/V7rXiXu+rvN23aNGTq3gD2Zs6cOZqxqqpYtWpVWGsYocPrRacuwTWAFSPUA/12GqcQsMdoqx4RUV8899xzaGho0Mzpm7ECQFVVlWbcl+OAuzN48GDNuL6+PuEbsErph+zS9RixjzAmmASkrxhRuZWGiKhHYWUWLrjgAgD7ExNSSjz00EMhJZyxsHHjRjzxxBOB+wIIaQwabZMnT8ayZcvw7rvvYtiw6OxXjXe5q/5+kTR+GzlyJLKysvp0v0SirxYRAAqYGKEeDMnMhDk40SoEhh1/vHEBEVFaq6+vxx/+8AfNnKIo+MUvfhFyrb6Kc9CgQRHdc8CAASFz+qb3iUZ6agDp1cwprBgJCD2ytxnS19bttURE6S6sxMjkyZNx2mmnQUoJIQQ8Hg/mz58f0y01dXV1OP/88+F2uwNz+fn5OP/882Nyv5kzZ2LJkiXYuHEjzjjjjKiuHc9yV5fLhcpK7RF2kd5v9OjRvd4v0dTrPuXKz8iAhdsjqAcmRcEwXQJw2AknGBQNEaUzVVVx6aWXhlSLXHDBBSHP406nEx6PRzOXo6uA66vuPqhpbm6OaK14kZ0V2glTJmAuMCSWRCRsJQC0W8Bl5y5jgiEiSnDmcB+waNEi/Pe//w0kR3bt2oVjjz0W77zzTsRvvHuybds2nHnmmdi2bVugWkQIgVtuuSXiJ/7D+eMf/4iCgtg9oca63DW4iWt1dXWguiYa99u4cWNgvHt34u9RDekvwmoR6kVpTg52tR36JC1v5EjU6d5wEBHF2q233op33nlHM1dQUID7778/5NrgD40O6mtD9748rrdTcdxutyaGtrboViNUVlaGJIiC5fk/Q/Aroi51AMq++SbkOv0HU+lCKFaIjGGa02jUrp1QssOvICYiSnVhJ0aOPvpoXHvttXjkkUcghIAQAtu3b8eMGTPwv//7v7j++uuRkZHRr6A6Ojrw2GOP4e6770ZXV1eg4aoQAlOnTsX111/fr/V7EsukCBD7ctfgFzU1NTUh10Trfod7kZIo9CfSsPEq9WaA3Q672azpTfOdy4Xw2hUTEUXuT3/6Ex588EHNnBACf//730M+FAG6T4yYzWG/tAOAbpvLe73ebq485N5778Wdd94Z0f16U1lZiQkTxsPl6uzxmnuuKcT1F+QHxu9+9C0u/MNRPV7vbG+PaozJQNhHaRIjsnOnccEQESWwiJ4977nnHnzxxRf4+uuvA8kRl8uFO+64Aw888AAuvvhinHXWWZg7d26fT3Hxer347LPP8Prrr+Nf//oXWlpaAhUiwP5TRvLz8/Haa6/BarVGErah4lHuGtwLpampKeSaaN2vL6W1sf4UqTesGKFwCSEwPDsb5UF/vzd3dsIvJUw8vpeIYuzee+8N6SsCAHfeeSfOOuusbh/j9/tD5iI9Pa+7x6mqetjH/P73v8eNN94YGLe1tUWtL1tDQwNcrk7845ELMWFM9x/slGauBnDog6Dj5hyFNe9ODLnuvU+2YNGD/+m1AiYVKRkjEfxfUWVihIioWxElRux2O959910ce+yxgW0uB7e6NDc345FHHsEjjzwCu92OqVOnYtKkSSgtLUVhYSHsdju8Xi86OzvR0NCA3bt3o7y8HJs2bQokDg5uAQlOigwYMAAffPABRo0aFaUfPb7iXe4ay/v15YVFLD9F6gt9YqSIFSPUB6U5OZrEiNPvx+aGBkzppkqLiCgapJT43e9+h8WLF4d87+qrr+42WXKQxWIJmfPpTmTrq+6qQ2w222EfY7PZer2mvyaMGYTpR3afbPHVrASCftziIcMwJDP02vLttbEKL+EJu7ZPHCtGiIi6F1m9JYCioiKsXr0a5557Lj799NNAcgQ4lNhwuVxYvXo1Vq9efdi19L0wRNCns1JKHHXUUXjppZdCmo4mk3iXu8byfr2V1gKx/RSpL/TNV1kxQn2Ra7Mhz2ZDS9D/P6v27mVihIhiwuv14rLLLsPzzz8f8r0rr7wSjz322GEf311SQl+dGk4sfVk/UUgpAV+rZk6Ycw2KJnEJu/YDRdm1G1L6IETEbwGIiFJSv47pyM/Px4cffoi7774bGRkZmkqP4CqS3r70jwH2P+FlZmbizjvvxJdffpnUSREg/uWusbxfb6W1wP4XUzk5OZqveHH7fGjTvTBkjxHqq1Ld1rHV1dVwR/gJLBFRT5qamnDKKad0mxS56aab8MQTT2g+KOpOTk5OyDXtEfbRcDqdIXOZmZkRrRUX/nYAutc65jwjIkloin2kdkJ6Ibv2GRMMEVEC6/f5pSaTCXfccQfKysrw61//Gna7vceEx+G+AAQeV1xcjDvuuAMVFRX4wx/+EHGlQyKJd7lrLO+XyJ8gAUBDZ2ijNlaMUF+V5uQAQVVsnT4fvq5N3zJsIoq+bdu2Yfbs2VixYkXI9+67776QBqw9MZvNIR88tLS0RBRTd4+LtGl7PEhdtQiEBVD4IYiesBQA5nzNnOzaYVA0RESJq9+JkYNKS0vx9NNPY+/evXjqqadw1llnISsrq88VI5MmTcI111yDDz74AHv27MHdd98d81Ni4ine5a6xvF+iJ0b0/UWyrVZkpEByjeLDbjYjR7e9b+XevQZFQ0Sp5tNPP8Xs2bOxbds2zbzFYsE///lP3HrrrWGtN2TIEM24NsJErv5xGRkZ3TZ7Txi+Fu3YnNtrhU26UnTbadTOXQZFQkSUuKL+bjEvLw+XX345Lr/8cgBARUUFysvLsW/fPjidTnR0dMBisSArKwtFRUUYM2YMjjjiiMR+8o2Cg+Wuwf1UYlnumpsbus82WvdL6NJasL8I9V+BqqJNOZQ33lBXh1a3G7kJnhQkosT2/PPP47LLLgv5wCEvLw+vv/46fvjDH4a95ujRo1FWVhYYV1ZWRhTb7t27Q9ZNZPqKEfYX6ZnIGAk41wXGbMBKRBQq5h+jjxgxAiNGjIj1bRLewXLX1tZDT+SxLHctLCzs0+MiuV8il9YC3ZxIw8QIhSlfSmzv6oI5IwMAoEqJz/ftw+lJeioWERlv8eLF+N3vfhfScH7kyJF49913MWHChIjWnTRpEt55553AeOvWrRGto3/cpEmTIlonbrqpGKHuhTRgZWKEiChE1LbSUO/iWe6qv1c075fwiRF9xQgbr1KYTACq1qzRzHE7DRFF6t5778XNN98ckhSZPXs21qxZE3FSBABmzZqlGVdXV6OqqiqsNbxeLzZu3KiZmzFjRsQxxYP06ytG8owJJAmEbqVhYoSISI+JkTjSl6XGstx14MCBIcmSaN1vVIJ/aq6vGOFWGopE5aefasbbW1qwL8LtaESUvh577DHcfvvtIfNnn302Pv74Ywzo53Hgxx9/PBRF+3Ju+fLlYa2xatUquIOOKQeAk08+uV9xxVL3R/XmGRNMEtBXjMDXBOltNiYYIqIExcRIHOnLUmNd7jpx4sR+36+jowN7dZ+UJ3p5rf5UGlaMUCTqNmyAQ/dmYxWrRogoDO+88w6uv/76kPlf//rXWLp0KexRSNwPGDAgpGrk5ZdfDmuNl156STMePHgwpk+f3u/YYkbtAKTupD1upemRyBi2/9SeIGrnth6uJiJKT0yMxFG8y13191u7dm1Y9wKA9evXh5T+JnJ5rU9V0cSKEYoCqaqYpEuqrdy7N+T/ByKi7lRWVmLhwoVQVVUzf+WVV+KZZ54JqfLoj4suukgzfu+997Bu3boertbatWsXlixZopm79NJLoxpf1IUc1WsGlMRuDG8kIcyhfUZcTIwQEQVL4Ge91BPvctcTTzxRM962bRv27NkT1v0+/PBDzTg3NxczZ84Ma414aurqgqqbY8UIRWqy7u9OncuFrU1NBkVDRMnkN7/5jabhOgDMmzcPjz/+eNTvdeGFF6KgoCAwllLi5z//ORoaGg77OJfLhfPOOw9dXV2BObvdjiuuuCLqMUaT5FG9YVPsYzRj1bXdoEiIiBITEyNxFO9y11NOOQVWqzXi+0kpQ64/7bTTYDKZ+rxGvOkbr2aYTMiyWHq4mujwii0WDMnK0syxCSsR9eb999/H+++/r5kbPHgwnn/++ZhUYmRnZ+OOO+7QzG3fvh0nn3wytm/v/g1wdXU1fvKTn4RUltxwww0YOnRo1GOMppCjek3cRtMb4ThCM5bcSkNEpMHESJzFs9w1JycHZ511lmbuL3/5C9r72EDylVdewbZt2ifOyy67rE+PNUrIUb0OBz9FoogJIXCC7g3CF1VV8Kr6uiQiokP+/Oc/h8xVV1ejsLAQQoh+fVVUVHR7z+uuuw5z587VzG3cuBFTp07FFVdcgWXLlmHdunV47733cPPNN2PSpElYuXKl5vrp06fjj3/8Y9T+HGJGv5WGjVd7pdi1iRGVW2mIiDSYGImzeJe7XnfddZpxVVUVLr744pA9z3rl5eW46qqrNHNTpkzBSSeddNjHGS3kqF72F6F+mltSohm3e734JsKjr4ko9VVXV+NT3alW8WAymfDWW2+FVJG6XC48/fTTmD9/PmbOnInTTz8dixcvRnOz9lSSESNG4I033oDNZotn2BHRb6URbLzaK+EYq53wNUF6G40JhogoATExEmfxLnc99thjceaZZ2rmXn/9dVxwwQVwOp3dPmbNmjU49dRTQ140PfDAAwlffRFyIg0TI9RPgzIzMT4omQlwOw0R9WzFihWG3bugoAAfffQRzjjjjLAeN2fOHKxatQrDhw+PUWTR091RvawY6d3+k2m0SS/2GSEiOoSJEQPEu9z1qaeeQmFhoWbulVdewfjx43HnnXfiww8/xNq1a7F06VJccMEFmDt3bkiT1iuvvBKnnnpqBD9tfIVUjLDxKkWBfjvN2tpadHi9BkVDRIlMf8R9vBUUFGDZsmV48803cdxxxx22p8nkyZPx7LPPYtWqVQnfVyRAdQFS+/uXFSO9E8IUejIN+4wQEQWYjQ4gHR0sdz355JPxzTffBOYPlrs+/fTTh318uOWuQ4YMwX//+1+cfPLJmiqQqqoqLFq0qNfHn3baaXj44Yf7dC+j6XuMsGKEouGYIUPwt+++g+/AFjSfquKLqiqckgSfrhJRfN188824+eabjQ4DZ511Fs466yzU1dVh9erVqK6uRmNjIxwOBwYPHoyjjz4aI0eONDrM8OmrRWACTFndXkpaiuMI+F1lgbHq+t7AaIiIEgsTIwY5WO568cUX45133unz4+bMmYNXXnkl7E92ZsyYgeXLl2PhwoXYsmVLnx932WWX4a9//WvI6TaJSJUyZCtNEStGKAqyrFbMGDgQX9XUBOZW7d3LxAgRJbyBAwdi/vz5RocRNTyqN3IhJ9OwASsRUQC30hgo3uWu06dPx4YNG7B48WJMmDChx+uEEDj11FPx0Ucf4dlnn02KpAgAtLrdIaeFsGKEouWEYcM04y2Njajt6DAoGiKi9CR92v5ngv1F+izkZJrO7ft7thAREStGwhWLTvPxLHe1WCy48cYbceONN2Lr1q3YtGkTampq4HQ6kZubi+HDh2POnDmak3OShX4bjVkI5GdkGBQNpZoZAwciy2JBe1BvkZV79+K8ceMMjIqIKM14W7RjS54RUSQlfcUIfC2ApxawFRsSDxFRImFiJIHEu9x13LhxGJdCb+oadI1XC+12KCyvpSixmEw4tqQEH1RUBOY+2bMH544dy79nRERxEnpUb74xgSQhYRsKKJmAeqjaUXWVw8TECBEREyOUnCorK9HQ0KCZ26A7fjjD78f69esPu05ZWdlhv08U7MRhwzSJkTqXC+VNTZioO/WJiIiiT0p1f5VDEG6l6TshFCiZ46A6D702Ul3lMOWfaFhMRESJgokRSjqVlZUYP2ECOnUVItN+8xuMPv30wHjFf/6Dhx59tE9rtre3RzVGSk1j8vIwNCsLe4P+vny6Zw8TI0RE8eB3AtD2EgMrRsIiHBOAoMSI7OAHREREABMjlIQaGhrQ6XLhmvvvR8moUYH5700mtAVdN+fEE7Hg+OMPu9Y3K1fi348+is6urhhFS6lECIEThw3DkqBKoy/27cOlkycjw8xfp0REsSS92sarEDZAYS+xcCiZ4+EPGqsd5YbFQkSUSPhKnpJWyahRGDlpUmC8ddcuIKgx5tCSEgzPyTnsGvt27oxZfJSajh82DP8qKwt8Ztnl92NNdXXIqTVERBRl+qN6Lfk8qjdMimO8Ziy7KiD9nRAmnuJHROmNx/VSSpBSosPn08xlWiwGRUOprCAjA1MGDtTMfbJnj0HREBGlDx7V23/CMRZAcDJJhXR9b1Q4REQJg4kRSgmdPh9UKTVzWUyMUIz8UFcdsrmhAfW6njdERBRlbLzab8LkgMgYoZlTXewzQkTExAilhI6gLTQAYBICNpPJoGgo1c0qLoYjqKeIBLBi717jAiIiSgP6ihE2Xo2MkjlBM2afESIi9hihFNGuS4xkWizcd0z9drjjnMfZbPgmaPvWB9u2YaTT2ePfu6KiIpSWlkY9RiKidCBVD+Dv0MwJCxMjkRCO8UDjfwJj6WJihIiIiRFKCfqKEW6jof5oqa8HACxcuLDHa/LHjsWPHnggMG72+/HjCy9EYw/JFLvDgfKyMiZHiIgi4WsNnTPnxj+OFKBkahuwqh3lkFKFECwkJ6L0xcQIpQR9YoSNV6k/OpxOAMDC22/HpBkzur1GAtgsJbqCKkQW3HMPRvj9Idfu27kTj99yCxoaGpgYISKKQMg2GlMOhODL2EgomRO1E2oHZNcuCPtoYwIiIkoAfEahlNDdVhqi/hpYWqo5ElrP09SEbxsaAuMWsxnDxo6FWeGnbkREUcXGq1EjrIMAyyDAWxuYU9u/g8LECBGlMb56p5TArTRkhOHZ2ZqxT1Wxr73doGiIiFKX9OoqRix5hsSRKpSsyZqx2v6tQZEQESUGJkYo6XlVFW7d9oVMq9WgaCid2C0WDHI4NHMVbW0GRUNElLpkSMUIG6/2hz4xIju+MygSIqLEwMQIJT19tQgAZJq5S4ziY0ROjmZc53Kh3eMxKBoiotQjpQRCjurNMySWVKFkTtGM1Y4tkNLXw9VERKmPiRFKevrEiN1shok9HihOSrKyYNH9fdvFqhEiouhRXYDUPtezYqR/lCxd/yy1E9K1w5hgiIgSAN89UtLjiTRkJJOihFSN7GpthSqlQREREaWWkP4iwgyYsowJJkUISyGErUQzp3awzwgRpS8mRijp6bctMDFC8TYyN1czdvv9qGITViKi6ND1F4E5FyLoqHSKjMjUN2BlnxEiSl9MjFDS44k0ZLRcmw2FGRmauZ2trQZFQ0SUWqSuvwi30USHknWkZsyTaYgonTExQkmvnVtpKAGM0lWN1Lpc3TYGJiKiMIVUjDAxEg36xIh0lUGqboOiISIyFhMjlNSklHD5tF3UWTFCRhianR3ahJVVI0RE/RZ6VG+eIXGkGiXzSABBW5Kkl9tpiChtMTFCSa3T5wtpcsmKETKCWVEwnE1YiYiiSkAFfNoks7DkGRNMihHmbAjHOM2c6lxvUDRERMZiYoSSmn6rgkkI2Ewmg6KhdKffTtPl96O6o8OgaIiIkp9V6QCgSzBzK03UKNnTNGO1/RtjAiEiMhgTI5TU9P1FsiwWdqonw+TabCjQNWHd0dJiTDBERCnAZnJqJxQHhGIzJpgUpGTP0IxV5zeQrHQkojTExAglNX3FCLfRkNG6a8LaZVAsRETJTp8YEZYCgyJJTUqWNjECbwOke68xwRARGYiJEUpqPJGGEs2w7GxYdU1Y6xT+qiUiikSGvmLEzMRINImM0pCtSewzQkTpiK/WKanpK0Z4Ig0ZzawoGKmrGmlQFJgdDoMiIiJKXjalTTNmxUh0CSG62U6zwZhgiIgMxMQIJTVupaFENCYvTzNWhcCIH/3ImGCIiJKUogA2U7tmjomR6FOyp2vGqnOtQZEQERmHiRFKWn4Abr9fM5dltRoTDFEQh8WCkqwszdzoM85gQzsiojCMHGKBIlTtJLfSRJ2SfZRmLF1bIXVHJBMRpTomRihpubuZc5jNcY+DqDtH6KpGsgYPxo4utmElIuqrCSN1H3YodgiT3ZhgUpiSdSQggk/6kVDbWDVCROmFiRFKWm7dsbx2sxkmNrmkBFFktyPPpj1S8uv29h6uJiIiPX1ihNtoYkMotpA+I/62NQZFQ0RkDL6LpKSlT4ywvwglEiFESK+RXW439jqd3T+AiIg0xusrRriNJmaUnFmasdr2lUGREBEZg4kRSlr6TQk8kYYSTWl2Nqwmk2bu3Z07DYqGiCi5TBihfV5nxUjsKLk/0IxlxxZIX1sPVxMRpR4mRihp6StGstl4lRKMSVEwSnd07yd79qCZvUaIiA5Pqhg3ghUj8aJkTQVE8J+35Ok0RJRWmBihpNWlS4ywYoQS0Zi8PIig02h8qsqqESKiXlhQB7tN+zKVFSOxs7/PiO7Y3lZupyGi9MHECCUlk80GLytGKAnYzWYU6o7p/W9FBTq8XoMiIiJKfDZ1n3ZCyQAUnkgTS0rO0Zqxv/ULgyIhIoo/JkYoKWUNHhwyx+arlKiK/X5IVQ2MXT4f/ltRYVxAREQJzib3aCfMBRC6D0QoupTcYzRj6SqD9DQYFA0RUXwxMUJJKWvIEM3YbjbDzKN6KUFlANj35ZeauXd37oTH7zcmICKiBGeVezVjbqOJPSVrGmDK1Mz5Wz83JhgiojjjO0lKSvrESDarRSjBbX39dc24xe3Gij17eriaiCi92ZgYiTuhWKDkaKtGVCZGiChNMDFCSUmfGMlifxFKcC3bt2O4zaaZe2vHDvh1/UeIiNKdlCpsUtdjhCfSxIUpb65m7G/5DJLPU0SUBpgYoaQUUjHCxAglgTnZ2ZpxTUcHVldVGRQNEVFiku59UODRzLFiJD6UXG1iBN56SNdWY4IhIoojJkYoKWXrK0a4lYaSwAibDSNzczVzr37/PatGiIiCyM5t2gklA1AcxgSTZkRGKYRtqGbO37LKoGiIiOKHiRFKOp2qCpvuzSUrRigZCCFw7hFHaOb2Op2sGiEiCqK6tmsnzPk8kSZOhBBQdNtp1JaVBkVDRBQ/TIxQ0mn2+TRjAR7VS8nj6MGDUarbUsOqESKiQ2SnNjHCbTTxZco7QTNWnWshfW0GRUNEFB9MjFDSadIlRhwWCxR+kkRJQhEC548bp5nb63TiS1aNEBEBCK0YEeZCgyJJT0ruHEAEVeJKH/ysGiGiFMfECCWdRq9XM+ZRvZRsjh48GMNzcjRzr23dyqoRIkp7UqqQnTu0k5Z8Y4JJU8LkgJKrO7a3+WODoiEiig8mRijpNOoqRnJ0R6ASJTpFCJw3dqxmbm97O77ct6+HRxARpQfpqQZUl2aOW2niz5T/Q83Y37wSUvp6uJqIKPkxMUJJp4EVI5QCjh48GCN0VSPsNUJE6U66tCfS+FULoGQaFE36UvJ/pJ3wt0JtW2dMMEREccDECCUVv6qGNF/liTSUjBQhcJ6u18g+Vo0QUZpTcn4A25FLUWW+Cg8taUaTZzhPpDGAYhsM4ZigmfM3LzcoGiKi2GNihJJKncsFv26OW2koWc0qLmbVCBFREGGyQ8maglbTCfjfJxpR0znZ6JDSlqngJM1YbfwAks9PRJSizEYHQBSOfe3tmrFVUWAzmQyKhig8ZWVlIXNHWSyoCBrva2/Hvz7/HJMcjh7XKSoqQmlpafQDJCIiOsBU8GP49j4eGEtPFWTHtxBZUwyMiogoNpgYoaSiT4ywWoSSQUt9PQBg4cKF3X7/pIcfRt6oUYHxkk2b8N9rrwVUtdvr7Q4HysvKmBwhIqKYEY5xEBkjILsqAnP+xvehMDFCRCmIiRFKKnudTs2YjVcpGXQc+Hu78PbbMWnGjJDvNwuB4MMps4cOxc2vvorCbkqW9+3cicdvuQUNDQ1MjBARUYjuqhMjUVRUhMGFp8G376nAnL/xfZhLf8e+L0SUcpgYoaSirxhh41VKJgNLSzFy0qSQ+RFSorGyEi1ud2Cu3m7HjBEjoPDFJxER9UFNXRuE6Lk6MVwOhx3bNi5DftCcdO+BdG2ByAx9LiMiSmZMjFDSkFKiSr+VhokRSgFCCEwqLMTnVVWBuXavF5VtbRiRm2tgZERElCxa2johJfCXO8/EMTPH9f6AwyjbXotLrnsBNa15KLANg3TvCXzP3/AfKEyMEFGKYWKEkkar2412r1czx4oRShWDMzORb7OhOahqZEtTE0pzclg1QkREfTZmRCGmHzksOosJAVPhafBVPRuY8je8A3PpTRCCh1sSUergbzRKGvptNEJKZLLHCKWIg1UjwTq8XuxuazMoIiIiIsBUdKZmLD1VUJ3rDIqGiCg2mBihpKFPjGQAbP5FKaU4MxMFGRmauS2NjVC7acJKREQUD8IxHsJ+hGbO3/C2QdEQEcUGEyOUNEISI3yzSCmmu6oRl8+HitZWgyIiIqJ0J4SAacB8zZy/8X1I1WNQRERE0cceI5Q0fjF+PE4YOhSff/cd7nvyScw791yjQyKKukEOBwozMtDY1RWY29LUhOE5OTApzGUTEVH8HDz61yJHYEzwN3wt2LbuObSbZvVpnaKiIh4xT0QJjYkRShoZZjNG5eWhxeHAln/9Cxf+9KdGh0QUdUIITCoqwsq9ewNznT4fKtraMDovz7jAiIgobXR39O9HT5ZgzlR7YPzN8kX4+e9r+rSew2FHWVk5kyNElLCYGCEiSjAD7XYU2e1o6OwMzJU1NWFETo6BURERUbro7ujffGsFgA2Ba848Phvr/rMAPpnR7RoHHTz6t6GhgYkRIkpYTIwQESUYIQQmFxbiU13VyM7WVv7SJiKiuAk++leqg+Cv/g6QPgCAEBKThjuhZB9xuCWIiJICN6wTESWgAQ4HBtrtmrnypiaoBsVDRETpTShWCLum0wjUjjJINsMnohTAxAgRUYKaVFSkGXf5/ahnA1YiIjKIkjlRO+FrAjy1xgRDRBRFfIVNRJSgiux2DHI4NHPVigKTzWZQRERElNasQwCTtt+V2vGtQcEQEUUPEyNERAlsUmGhZuwTAqN+8hODoiEionQmhICSOUkzJ13fQ/o7e3gEEVFyYGKEiCiBFdrtKNZVjYw95xx4VHYbISKi+BOZk6B9C6FCdmw2KhwioqhgYoSIKMHpq0Yy8vKwvqPDoGiIiCidCZMdwjFWM6d2fAcpmbAnouTFxAgRUYIrsNsxODNTM/el04kun8+giIiIKJ0pWUdqJ/xOyK4KQ2IhIooGJkaIiJLARF3VSKeq4oOKCmOCISKitCasxYBloGZOtm8yKBoiov5jYoSIKAkUZGSEVI28tX07q0aIiMgQStYUzVi690B6mw2Khoiof5gYISJKEvqqkTaPh1UjRERkCOE4AlAyNHM8upeIkhUTI0RESaIgIwO5utNoWDVCRERGEMIM4ZiomZMdZZCqx6CIiIgix8QIEVESGaJLjLBqhIiIjBLShFV6eHQvESUlJkaIiJJIppSo/uorzRyrRoiIyAjCnAORMUozpzq/gZR+gyIiIooMEyNERElmyyuvaMasGiEiIqMo2UdpJ9QOSFe5McEQEUWIiREioiTTsn07xmRoG96xaoSIiIwgbMUQthLNnOpcDynVHh5BRJR4mBghIkpCx+XkaMasGiEiIqMIfdWIrwWyc6cxwRARRYCJESKiJDTYasVRgwZp5lg1QkRERhC2UsAyQDOnOtdBSmlQRERE4WFihIgoSZ03bpxmzKoRIiIyghAitNeItw7SvceYgIiIwsTECBFRkhqTl8eqESIiSgjCPhow5WrmpHOdQdEQEYWHiREioiTGqhEiIkoEQihQsmdo5qR7LzLNDQZFRETUd0yMEBElMVaNEBFRohCZEwAlUzM3yL7FoGiIiPqOiREioiTHqhEiIkoEQpig5MzSzGWam/DjYxwGRURE1DdMjBARJTlWjRARUaIQmRMBk/ZI+Tt/UwhI1aCIiIh6x8QIEVEK6K5q5L1duwyKhoiI0tX+qpEfaOamjLUhW11tUERERL1jYoSIKAV0VzXy5vbtcHo8BkVERETpSjjGAuYCzdwA/78hJSsZiSgxMTFCRJQiztdVjXR4vXhz2zaDoiEionQlhAIld7Zmziar4a97w6CIiIgOj4kRIqIUMTovD3OGDNHM/WfXLjR0dhoUERERpSuRMQqwDNTMefc8AunvMCgiIqKeMTFCRJRCfjF+PExCBMZeVcUr5eUGRkREROlICAEl9xjtpLcWvr1PGBMQEdFhMDFCRJRCBmdl4dQRIzRzn+7Zg91tbcYEREREaUvYhsHp1VaN+Kqfg9q506CIiIi6ZzY6ACIiCl9ZWVmP3xvr92O5EPBICQCQAJ5cvRrnFxWFXFtUVITS0tJYhUlERGlMCIEq15EY6fgIVsuBakbphXfX3bBO+DtEUIUjEZGRmBghIkoiLfX1AICFCxce9roJP/sZJl5wQWC8vasLp11yCeq//VZznd3hQHlZGZMjREQUEx41G4++3IKbL8wPzKmtn0Ft/gimglMMjIyI6BAmRoiIkkiH0wkAWHj77Zg0Y0aP1/kBfCslfEGfxv347rsxwecL7KHct3MnHr/lFjQ0NDAxQkREMfPnfzThugtHwYLmwJy34h4oucdBmDIMjIyIaD8mRoiIktDA0lKMnDTpsNeIlhasr6sLjDuFgH/IEIzOzz/Mo4iIiKKro1OiznwhSnyPBuakey98VU/DMuw6AyMjItqPzVeJiFLUqNxc5NlsmrnNjY3o9PkMioiIiNJVmzIHSvYszZxv39NQO7YaFBER0SFMjBARpSghBKYP1J0GoKrYdKBPCRERUdwIAcvIPwIwHZqTXnh2/B5SMmFPRMZiYoSIKIUV2e0YkZOjmat0OlHvchkUERERpSslczzMJb/WzMmOb+Hb96xBERER7cfECBFRijuyqAgWRfvrfn1dHVSD4iEiovRlHnoNhH2UZs6391Go7ZsMioiIiIkRIqKUl2E2Y3JhoWauzeNBjcKnACIiii+h2GAZfR80b0OkD55tN0H6OwyLi4jSG18VExGlgVF5eSGNWKsVBTnDhxsUERERpStT9nSYS67QzMmuCnh3/gFSSoOiIqJ0xsQIEVEaUITAUYMGaeakEJj529/CzxehREQUZ+ah10BkTdXM+RuWwV+zxKCIiCidMTFCRJQmCjIyMD4/XzOXP2YMVrW1GRQRERGlK6FYYD1iMWDK0sx7d98Df9tXBkVFROmKiREiojQysbAQ2VarZu4LpxPf8ghfIiKKMyVjOKxjHtBOSh88W6+G2rnLmKCIKC2ZjQ6AiIjix6Qo+EFxMZZXViJ4A82j69fj/hNOQH5GhmGxERFR6iorK+vhOwUYYDobRf43D035WuDccCEqrHfBL/JCHlFUVITS0tJYhElEaYqJESKiNJOfkYEji4qwqaEhMNfsduOhtWvxf3PmwMzTaoiIKEpq6togBLBw4cIer1EU4JV7B2PecZmBOStq4S2/BD+5Zh8aWrQHzDscdpSVlTM5QkRRw8QIEVEaGpufj4q6OrQFJUHKmprwz82b8T9HHmlgZERElEpa2johJfCXO8/EMTPH9XidAh86fatgN7cG5iaNsmHr29NQ0T4HPrm/orFsey0uue4FNDQ0MDFCRFHDxAgRURoSQmCk348vGhqQOXBgYP69XbtQnJmJeaNGGRgdERGlmjEjCjH9yGGHvUb6B8Jf9xrgP9QU3G5uw4TCL2EaMB/CnBfjKIkoXbFemogoTVkArL7vPph08//47jusrqoyIiQiIkpjwpQJ04BzAFO29hv+VvjrXoXaVWlMYESU8pgYISJKYy07dmCe7ghfCeAv69ZhXW2tMUEREVHaEuacA8mRHO031C6oDW9hUMYWWC3GxEZEqYtbaYiI0tzkzEw4Bg3Cy+XlgTmflHjg669xy6xZmDFokIHRERFRuhHmXJgGLoC/4W3A26D53kD791j9z1I41E2QcjqEEAZFGRkpJeBrhvTU7P9y10D6mgDVC0gvpPRBQAHM2RCWQoiMUigZIwFrcdL9rETJhImRNFVWVobnn38en332GbZt24bm5maYTCYMGjQIRx55JH7yk5/gggsuQG5urtGhElEcnHvEEWjs7MSHu3cH5nyqij9/9RWunDYNJw47/L5wIko8fK6nZLZ/W825UJv+C9m1S/O98SOsgPf/wbP5vzAP+RWUvBMhFGPLSKTqAfxOSF874G+D9NQdSHxUH0iCVO9PgnhqAOkJ/waWgVCyp8GUdzxMeSdA2Iqj/0MQpTEmRtJMbW0trrnmGrz22mvdfr+iogIVFRVYtmwZbr31Vvzxj3/EjTfeCIXHdxKlNCEEfj1lCjx+P1bs3RuY90uJx7/5BrUdHThv3DgoSfppVWVlJRoaGnq/sA+Kiop4EgIlND7XU6oQihVK4TzI9m+gtn6B/Zs9D1GdX8Oz9WvAUghT3vFQcudAcYyHsI+EUGwh60kpAbUT8LVB+p2Qfifqq3egvbUaJnRAkS4ocMEkO2CCC8rBf8IFRboBqBDwH/inGhiLwHwMeeugNv0XatN/4YGAS0xAq+l4tCnHQgrrYR/K5y2i3jExkkY2bdqEU089FbV97BvgdDrxu9/9Dp988glee+012O32GEdIREZShMBV06dDAlgZlBwBgFe//x7bW1pw7fTpyLGFvthMZJWVlRg/YQI6Xa6orGd3OFBeVsYXmZSQ+FxPqUYIAZE9A8I2DP7mjwFvXehF3kb469+Av/6NQ3OmLEDJAKQKQO7/p9oBSJ/mobkHvpKJgESm3IJM3xaYmx/Hs6+34ZnXW1Hf3H1yxuGwo6ysnM9bRIfBxEia2LlzJ374wx+iqakp5HuTJ09GaWkpWltbsXnzZrS0tGi+/5///Afnn38+3n77be5tJEpxJiFwzfTpyLVasWznTs33vqmrw/WffILLp0zBDwYPTprfBw0NDeh0uXDN/fejpJ/HEO/buROP33ILGhoa+AKTEg6f6ymVCesAmAaeh93ffw7V+TVKi3vZOuNv3/+VoKQEfDIDXtUOn2qDChOkFJBQUFXTgso91Th6SgHys/0wCV+P6wzMN+OO/ynA7y8tQrOnFPWdY+GVjsD3y7bX4pLrXuDzFlEvmBhJAz6fDwsWLAh5oXT22WfjgQcewJgxYwJzXV1dePHFF3HTTTehtbU1MP/OO+/gkUcewfXXXx+vsInIIIoQuHjyZBQ5HPjn5s1Q5aHS5TaPBw+uXYupAwbgokmTMDwn5zArJZaSUaMwctIko8Mgigk+11M6EEJBs2cEjvvZa9jy+YMYmrEGavs3RofVDQUwOQBTFoQpq9t/wuSARZjQXY3W8k1rcfEt6/HOP3+MUyZMA3wt+/uUdO2G7NrdbY8SRagotFWg0LYHIutIKNkzIUysACPqKyZG0sCTTz6Jb77RPmnccMMNeOihh0KuzcjIwP/8z//gxBNPxHHHHYfq6urA9+6++2786le/YpM2ohRTVlbW7fxgAL8oKsIbjY1wqarmexvr63HTp59inN2O2VlZGGK1YsCAAQn/aZSUEh5VRbvHA4/fD/+BpI9JCNhMJjgsFthMJn5iTkmHz/WUTjxeoNX0Q4w+8iaonRVQW1bC3/oFZEcZpKeqz+v4kYHqWieKigqRYc/c35dEsQHCCii2oLENEGZAKAAExIF/AiIw9+7yclx1+5v4+8MX4KQTjora84gQArDkQ1jygcwJkNIH2VkB2bEZ0l3Z7U8l2zfA37EZSvYMKCiKShxEqY6JkRTndrtx9913a+aOP/54LF68+LCPGz16NN555x3Mnj0bXq8XANDU1ITFixfjrrvuilm8RBQ/LfX1AICFCxce9jpbXh5mXHklhsyeHfK9rZ2d2NrZiZadO1H9xRf4x5/+hJlHHJEQiQW/lNjT1oZ17e2Yed112GIyYeOOHfDqkjx6ZkVBvs2GQrsdgzMzUZiRkRA/D1FP+FxP6Uyxj4BiHwHz4IsAANLfDumphfQ0APBjfwJDAYSAUDL3H4NrygbM2fjmm0046pyjsObd8zB9eP9OX3N2VaKm0Q9Vxja5LoQZwjEGcIyB9DZAdW6AdG0FoHtuk16obWswLteKq87PhZDemMVElAqYGElxS5cuRf2BNz8H3XfffX36hT1jxgxcccUVeOyxxwJzTz/9NBYtWsTO9UQpoMPpBAAsvP12TJox47DXSgBNPh/2mkzwdvP7I2/UKOSNGoU/l5djYGUlZgwciPGFhRidm4tBmZlxOc2mw+vFtuZmlDc1YWtTE7Y1N6PLv78R3fAf/QguAOglKQLsP6a4vrMT9Z2dKG9qglVRMDgzEyXZ2fqXnUQJgc/1RIcIUxaEPQuwjzY6lJgTliKYCk6GzJ0NtW0tZMdm6BMkZsWDB68fAK/nevjqboJpwNkQgm8BifT4f0WKe/nllzXjyZMn45hjjunz46+66irNi6W6ujqsXLkSJ554YrRCJCKDDSwt7VPvjVEApqkqtjY14fuWFvh6SDLUuVx4v6IC71dUAAAcZjNG5OaiJCsLxZmZKM7MxECHAwUZGci2WsNOmkgp0ebxYK/TiX3t7djV2oqtTU3Y43TqDnKMDo+qYrfTid1OJ8xmM4685BI0ePnJGyUOPtdTOuppG2i810gEwpQFU/6JkNnTobatOVBBomVBA7w7fg9f1bMwD/0tTIWnQQhT/IOllFVZWYmGhoaorGXEEdNMjKQwr9eLTz75RDN35plnhrXG+PHjMWbMGGzfvj0wt3TpUr5YIkpTZkXBpKIijM3Px47WVuxoaYHL13O3fABw+XzY0tiILY2NId8zCYE8mw25NhscFgvsZjPsZjMsihJIckgp0eH1wunxwOnxoMXtRns/ExMCQIbZDPOBpIxPSnT5fL0mVnxCYOw55+CZ2lqsWLUKPyotxZySEtjNfDolY/C5ntJNTV0bhOh9G2g4nO2Je3pNOIQ5F6aCUyGzZ0BtXQ3ZtSvkGtm5E95t18O3ZzjMQy6DacA5+3upEPVDZWUlJkwYD5erMyrrGXHENF/JpbANGzagXfeLfu7cuWGvM2fOHM2LpU8//bS/oRFRkrOYTBhfUIBx+fmoc7lQVlmJ3c3NcBSF1+TNLyUau7rQ2NUVo0iBPJMJm5Yvx7HHHYcRpaXIsljgsFhCKlWklOj0+dDidqOhsxPVHR1o84R2/j9oa3MztjY347nvvsMxQ4bgh6WlmFBQwH4kQdw+H5wHklrtHg/8UkI98AUAVpMJGSYTMg4kxHJtNlhN/AQzHHyup3TT0tYJKYG/3Hkmjpk5rl9rvffJFix68D/oiuFzkBGEpQimojMg3VVorfoUWZbQDyZk1254d/4B3j2PwjzoZzAN+CmUjP71WaH01dDQAJerE/945EJMGDMorMcK+GFWuqDADyFUVO6rx+In/ouu2g8gB50JYSuOUdRaTIyksM2bN4fMTZ06Nex1jjzySM14y5Yt6OzshN3OI8CI0p0QAoMyM1FVW4v3rrwSOcOHY/DMmSiaOBF5Y8YgIy8vrvGYFQWjc3MxrqBg/1d+PnZu2YKjHn4YPz32WBRnZvb4WCEEHAeSJkOysjBlwAB0eL2o7uhAZVtbj8mbLr8fn+zZg0/27EGxw4FjSkrwg+JijM7LS/okiV9V0enzodPnQ9eBf7qC/r3d60X7gUoeZ1BVz8FEiKcPPV30MoRApsmELJMJ+WYz8g788+BXycCBCX/6UTzxuZ7S1ZgRhZh+ZP/eyJdvr41SNIlJ2IZgV/tc/O9dT+KVv8xBhqwIvchbD9/ex+Hb+ziUnGNgGnguTPk/hDDnxD1eSn4TxgwK+f9SSgmoXYCvFdLftv+fB77gbwP82uT+ETnASY+VAL774W8bCPOAs+ISOxMjKUy/b9LhcKCkpCTsdcaMGaMZq6qKXbt2YeLEif2Kj4hSx8FGrvN/+ctAI1eJ/WX+LiHQKQTcQqALgFsIeAGgn0kDi6JgSFYWSrKyMDovD+MKCjA6NxeWKFYcZFosGJOXhzF5eWjzeLBhxw7sdjp7TPjUuFx4Y9s2vLFtGwozMjCruBiTioowvqAA+RkZUYsrHH4p0e7xoM3tRqvHg1a3e//XgTl9sqPT50On14tOvx+eA81r46nrwLamRp8Pu93ukO+7y8owdvBgXDZ9OiYUFsY9vkTD53oiOjyBD9e4sMtyL6aOaIB331MHmrSGUtu+hNr2JbwwQcmeDiX/BJhyj4NwjIVQLHGOm5KK9GFkiRlZ5jqo7S2QvjbAfyD54WsDZM8VuIelRvi4CDAxksKqqrTnuEfyQgkABg8eHDK3e/duvlgiohB9beSqSgm3z4dOvx9dPh88fj+8qhr4amlowOfvvovTTjsNhQUFsAoBh8kEu6LAoSjIM5uRazId2g7T1gZXWxu+7eZe0Wqul2O1Ypiq4slLL8WLK1agwmzGN3V1gW0heo1dXZomtAMdDhyRn48hmZkYkpW1/yhgux3ZVivMYZz+4fX7A5Ua7QeqNFrdblTW1aG+vR0dfj9cqhr4pyuCqo1EZsvNxW6XK+mrcaKFz/VE1CdCganwNCgFP4ba+gV8Vc9Abf2ih4v9UJ1roTrXwofFgLBCOMZDyZoIxTEOwjb00JfJmKQ/xY+UPsDXBulthHRXQ3qqD/yzCtJdA+neg/GeKmx+dQSAL6C2RPPmoR+QxAoTIymspqZGMx40KLz9XgcNGDAgZC5aHYeJKD0pQsBuscBu6f4TqG82b8amv/0Nm/72t6jdU9+HIVLS78c4ux2/mDEDzV1dWHFgG82+Xtavc7lQ53J1+z2H2YwsqxVWkwlmIWBSFJiEgC8oWeTx+9Hh9cJtQBVHf0m/H2YhYLVaEZzO8EsJn6rC30Ny6XCKHY7oBZjE+FxPROEQQsCUdyxMecdC7dgMX+1r8De8vX9LQ0+kB7JjE/wdmxDyDGTKgbDkA+Z8CHMehCkTUDIAxb6/qavJDig2AAogTBBQAKEcGOv+HeLAV1g/UZiXx3j9g23cA89r8tBc4HvQzem/HzwXtK7UXad/bGD5br6vj0d6AdUNqboB1b1/q4vqhlQ9gOraX/Hha4H0teD/b+++w6K49j6Af+kIIogoFowFO9jR2MFETayxJdbYot5cjbma3BQ1MbFEcjVq9E2UGBU19hJLbLGXKDaMGMHYC1hQKdL7ef/wwmV2dtmZZXdZ4Pt5nnl0DnPO+c2yzNk9c84ZZCfqPWvj3aqwRrawxvPYNJSvUAV2ZlwYmB0jJVhsbKxkv1w5w+YKuri4yNLi4uIMKouISIncqTnDp03Lm5pjqD9PnsSWJUuQaoLF9co7OqJv3bp4q04d3IqPx9nHj3H+8WM8Tk5WVU7Kf6ezWDprIWANwCZ3EwK2AGz/+69Nvv/npkecOYOtixbho2XL0NrfX2u5Qghk5uQg7b8jiNL++3rkjopJzsyUvD52VlZwdeBTFAC29URkOGtnH9jX9oGo+TmyYw8j+9kO5LwIUTftITvh5boRuK/3yW5U2lkDNi6wsnUFbMv971+bl//Cyh5WVlb4669IvNr7O4SGbkeLSoX7DKgGO0ZKsHSNudlOBt5d05ZP3+rd6enpkvpfvHgBAEhIKKA3WqHcu753IyKQpuPuq1IPb98GAETdvAmXQt59tNSyLDm20lCWJcdmqWXlLy8jPb3Qf+eZ/70WGSO2x/+dFhMaGqp1BEoNAK/Y2iKmbFncSk3Fw/R0PM7MRLoBIyJMwUYI2OX711YI2AB5nR3W/92/Hx6O41u3ouvgwahTv37ezw25I5SVnAwIYdDr7/zfDQByADx8+BB7Nm/GrMBAJCbqv4NVkNz2SFjI78ZQJb2tv3Q1EkkphRtKfe3Wy1E1V/9+gjJOt/Qcbb6yLDk2Sy3LkmOz1LJu3HkKQHe79T8uAEbASgyGU87fcBZX4CSuwkGU7AVqybgysqyRjbLIzHFCeo4TMrOdkZHjhIwcJ2QKR7z8xKHpxX+3l3Lfs0lJSUZpTxS394JKrDp16uSOnxIAxODBgw0qJzU1VVIOADFnzpwC83z11VeyPNy4cePGjZulbZGRkQa1jZaCbT03bty4ceOmf9PX3nPESAmWrTEP3cbAJzVoy5ejZzG/qVOn4qOPPpIcHxsbiwoVKiheMC8hIQHVq1dHZGSkwUODicg8+PdKxY0QAomJiahatWpRh1Ioxa2t57WCiMg8eL19SWl7z46REsxOY1HDLAPnr2dmZsrSHPTM7XZwcJAd46bj8Zb6lCtXrlT/MRMVJ/x7peLE1dW1qEMotOLa1vNaQURkHrzeKmvvlT8fkIodzQ8rGRmGPQfakA9LREREZHps64mIiAqPHSMlmGbPmKGPqtS2wJ2zs7OWI4mIiMic2NYTEREVHjtGSrAKFSpI9uPj4w0qR1s+T09Pg8pSw8HBAV999RXvWBEVA/x7JSoaxa2t57WCiMg8eL1Vh2uMlGCaC8xERxv2uC1t+czVMfL111+bvB4iKjz+vRIVjeLW1vNaQURkHrzeqsMRIyWYt7e3ZP/Ro0cGLcp2//59WVrt2rUNjouIiIiMg209ERFR4bFjpATz8fGR7GdlZeHOnTuqy7l+/bpkv1KlSvDw8ChUbERERFR4bOuJiIgKjx0jJZifn58s7eLFi6rL0czTokULg2MiIiIi42FbT0REVHjsGCnBPDw84OvrK0k7cuSIqjJSUlJw5swZSVqXLl0KHRsRlUxz586FlZUVrKysMGrUqKIOh6jEY1tPRERUeFx8tYTr2bMnrl69mre/c+dO/Pjjj3B0dFSUf8eOHUhLS5Ok9ejRw6gx5rp27RrWrl2LP/74Azdv3kRcXBxsbGzg6emJxo0bo3v37hg6dKjs0YREZBmuX7+OuXPnFnUYRKWOKdr6wMBATJs2zaLa4ezsbPz222/YvXs3zp07h8ePHyMhIQHOzs6oWbMmXn31VQwYMADdunWDlZVVkcRIRKSEJX7vefbsGf75z38Wuhw/Pz98/vnnRojIzASVaOHh4QKAZFu4cKGivJmZmcLHx0eSt3379kaP8cmTJ2LgwIGyOLVtLi4uYv78+SI7O9vocRCR4RISEkTjxo0lf68jR44s6rCISoXCtvX169dX1AYXZTt88OBBUbt2bUUxNm3aVISEhJg1PiIiJSz5e8++ffsUtwUFbT179jRLvMbGqTQlXKNGjWTDYadNm4aQkBC9eSdNmoTw8HBJ2kcffWTU+K5cuYKmTZti27Ztio5PTEzEJ598gt69eyM1NdWosRCRYdLS0tCvXz/89ddfRR0KUalUmLZ+6NChsoVXC1IU7fC3336Lbt26KV5UNiwsDJ06dcLKlStNHBkRkXKW/r3nzz//NHkdlowdI6VAYGAgrK3/96tOS0tDr169cODAAa3HZ2RkYNKkSQgKCpKkt2vXDv379zdaXHfu3EHnzp0RHR0t+5mvry969OiB9u3bw83NTfbzffv24Z133oEQwmjxEJF6SUlJ6Nmzp+o1DYjIuAxp60eMGIGtW7dq/bmltMPff/89pk6dKkt3dnZG27Zt0bNnTzRt2lRy7gCQmZmJcePGYcuWLSaNj4hIieLwvefy5csmLd/iFfGIFTKTzz//XDbMycrKSvTu3Vts2LBBnDt3Thw9elTMnz9f1KlTR3ZsuXLlxM2bN40WT2ZmpmjevLmsnr59+8rqSU1NFStWrBCurq6y4xctWmS0mIhInatXr4oGDRroHErJqTRE5lXYth6A6NKli8W0wyEhIcLW1lZSX5kyZcTChQtFUlKS5Nh79+6JMWPGaB2Kfv/+fZPFSESkT3H53lO3bl1JfevWrTNpfZaGHSOlRHZ2thg1apRB88QcHR3FgQMHjBrPkiVLZPVMmTKlwDy3bt0SVapUkeRxd3cX8fHxRo2NiPRbs2aNcHJyKvDawY4RIvMqTFsPQPTr16/A8s3ZDufk5Ag/Pz9Zp4i+tUN+/PFH2XmNGTPG6PERESlVHL73JCYmCisrK0l94eHhJqnLUnEqTSlhbW2NlStX4rPPPoOtrfKHEXl5eeH333/HG2+8YbRY0tPTMXv2bElap06dsGDBggLzeXt7Y8+ePbCzs8tLi42N1ZuPiIzn+vXr6Nu3L0aOHImUlJSiDoeI8jG0rQeAJk2aYPv27QUeY852eOfOnbh48aIk7YcffkCbNm0KzDdhwgTZemhr1qzBjRs3jB4jEZE+xeV7T1hYmGSqTpkyZVC/fn2T1GWp2DFSilhbW+Pbb7/FpUuXMHDgQDg5Oek81tPTE19++SWuXr2KTp06GTWO7du349mzZ5K0b7/9VtGj9Vq0aIH3339fkvbTTz8hJyfHqDESkdTTp08xceJE+Pr6YteuXbKfT5o0CR06dCiCyIgoPzVtfX5BQUEW1Q4vW7ZMst+gQQOMHj1aUd45c+bA09Mzbz87OxvLly83anxEREoUl+89mguvNmnSBDY2Nkavx5KxY6QUaty4MbZu3Yrnz5/j4MGDWLVqFQIDAzF//nwEBwfj8uXLePToEWbNmmWSZ2dv2rRJsu/r64u2bdsqzj9hwgTJ/tOnT3Hy5EmjxEZE2s2dOxdLly5FVlaWJN3FxQWrVq3CkiVLSl0DSmTJCmrrmzVrJjnW0trh58+f4/Dhw5K0sWPHKvoiAby80zlq1ChJmr7RMEREplBcvvdoLrzavHlzo9dh6dSNs6QSpUyZMujatatZ68zMzMSxY8ckab1791ZVRoMGDVCnTh3cunUrL2379u0ICAgwRohEpFCPHj0QFBSE6tWrF3UoRKSDZlufmZmJmTNnSo6xtHb40KFDsqcvqI2xd+/e+M9//pO3f+/ePYSGhqJly5ZGiZGISJ/i9L1Hc8RIaewY4YgRMqvLly8jKSlJkmbI8Pt27dpJ9o8fP16YsIhIBV9fX/z222/Yu3cvO0WIipni0A7/8ccfkv2KFSuiXr16qsrw8/ODvb29JI2fFYjInIrD9RYAsrKyEB4eLkljxwiRiWn+0QFA06ZNVZfTuHFjyX5ERARSU1MNjouI9PPz88O6desQFhaGXr16FXU4RGSA4tAOa8ZoSHwODg6oW7euJC00NLRQcRERqVEcrre55aWnp+ft29rayuosDdgxQmZ17do1yb6TkxOqVaumupw6depI9nNycnD37t1CxUZEus2YMQMXLlzAsGHDYG3NpoOouCoO7bBmjGpHi+TSjDH/UHQiIlMrDtdbQL6+SIMGDeDo6IiMjAxs3rwZo0aNQsOGDeHm5gZHR0e88sor6NChA2bOnImwsDCjxVHU+OmWzOrRo0eSfUMuDgBQpUoVWdr9+/cNKouI9HN3dy/qEIjICCy9Hc7KypI9wcFYMfJzAhGZk6Vfb3Npdoz4+vpi8eLF8PLywuDBg7FmzRr8/fffePHiBdLT0xEZGYnTp0/j66+/RrNmzTBgwIAS0fHMjhEyqydPnkj28z9OT42KFSvK0p4/f25QWURERKWFpbfD0dHRsoVXjRVjTEyMrGwiIlOx9OttLs2FV7du3YrJkyfLOql1+fXXX9GiRQvs27fPaDEVBXaMkFnFxsZK9suVK2dQOS4uLrK0uLg4g8oiIiIqLSy9HdaMDzBejNnZ2UhMTDSoLCIitSz9eptLczpMdna2ZL9WrVoICAhAjx490LJlS9jZ2cnKSExMRO/evbF582ajxWVu7Bghs8q/sA/wcq6dIbTlS0tLM6gsIiKi0sLS22HN+HTVpQQ/KxBRUbL06y3w8lHm2jpZbGxsMGnSJFy7dg137tzBsWPHsHfvXly8eBExMTH4+eef4eXlJcmTk5ODMWPGFNt1R9gxQmaleYGwtbU1qBwbGxtZWmZmpkFlERERlRaW3g5r6xixtBiJiJSw9OstIF9fBAAqV66MY8eOYcmSJWjQoIHs5y4uLhg7dizCwsLg7+8v+VlKSgrGjBljlNjMjR0jZFaaQ7O0/aEroS1fTk6OQWURERGVFpbeDmvGp6suJfhZgYiKkqVfb4GXC177+fnlLbJfpkwZ7NmzBx07dtSb193dHXv27EH9+vUl6ZcuXcKOHTuMEp85sWOEzEpzTlpWVpZB5WjrJXVwcDCoLCIiotLC0tthbXPXLS1GIiIlLP16CwADBw7EhQsXEBMTg/j4eFy/fh0tW7ZUnL9s2bIICgqSpa9cudIo8ZkTO0bIrDT/iDMyMgwqhx92iIiI1LP0dlhbGZYWIxGREpZ+vdXk6uqK6tWrq84XEBCAZs2aSdKOHz9u8PkWFXaMkFm5urpK9pOSkgwqR9uq8s7OzgaVRUREVFpYejusGR9g3BgNXfyQiEgtS7/eGlO3bt0k+8nJyYiIiCiiaAzDjhEyqwoVKkj24+PjDSpHWz5Dnw1ORERUWlh6O6wZn666lNDM5+7urnWqDhGRKVj69daYmjRpIkuLjo4ugkgMx44RMquqVatK9g39g9GWz9IuEERERJbG0tthNzc32Z1QY8XIzwlEZE6Wfr01Jm2d2jExMUUQieHYMUJm5e3tLdl/9OiRQQsR3b9/X5ZWu3Ztg+MiIiIqDYpDO1yrVi3J/oMHDwwqRzNGfk4gInMqDtdbY9H2RDFLm+6jDztGyKx8fHwk+1lZWbhz547qcq5fvy7Zr1SpEjw8PAoVGxERUUlXHNphzRg161JKM59muUREplQcrrf5CSG0dnAooW10SHH7bsaOETIrPz8/WdrFixdVl6OZp0WLFgbHREREVFoUh3a4VatWkv3Lly+rvssaGRmJp0+fStL4WYGIzMnSr7dXr17F66+/jsaNG6Ny5cqws7PDTz/9ZFBZV65ckaXVq1evsCGaFTtGyKw8PDzg6+srSTty5IiqMlJSUnDmzBlJWpcuXQodGxERUUlXHNrhgIAAyX5qaipCQkJUlXHo0CHJvpWVFV577bXChkZEpJilX2/d3Nxw9OhRXL16FdHR0cjOzpbVpdTRo0cl+w0aNEDFihWNEabZsGOEzK5nz56S/Z07dyItLU1x/h07dsiO79Gjh1FiIyIiKuksvR1u0aIFqlSpIknbtGmTqjI2btwo2W/dunWx+5BORMWfJV9vvby8ZIu47t69GykpKarKOX36NP78809JWu/evQsdn7mxY4TMbsSIEZL92NhYLFu2TFHerKwsBAYGStLat2+Phg0bGi0+IiKikszS22ErKysMHz5ckrZ69WpERUUpyh8SEoLDhw9L0saOHWu0+IiIlLL06+0777wj2U9MTMSSJUsU58/KysLHH38sSbOxscHEiRONEp85sWOEzK5Ro0ayIWDTpk1TNEx20qRJCA8Pl6R99NFHRo2PiIioJCsO7fCECRNgZ2eXt5+SkoK3335b753W6OhoDB06VJLm6emJIUOGGD1GIiJ9LP16O3bsWFhbS7sE5syZg9DQUL15hRCYNGkSzp07J0kfOXIkatSoYdQ4zYEdI1QkAgMDJX+EaWlp6NWrFw4cOKD1+IyMDEyaNAlBQUGS9Hbt2qF///4mjZWIiKikMWc7HBAQACsrK8l2/PjxAvPUrFkT77//viTt7Nmz6NGjB6Kjo7XmuX79Orp06YJ79+5J0mfPnl3sHhtJRCWHJV9vmzRpgvfee0+SlpycjDfeeAO///67znzPnz/H4MGDZTFWrVoVCxYsKDBGS2UlhBBFHQSVTlOnTsW3334rSbOyskKvXr0wZMgQeHt7Izk5GaGhofjpp59w69YtybHlypVDaGgo6tSpY86wiUiHgIAAnDhxIm9/5MiRWL16ddEFREQFMlc7rHltAIBjx47JFlnVlJSUhObNm8vqdXd3x5gxY/Daa6+hUqVKePToEfbs2YN169bJ5sb36NEDe/bsgZWVVYF1ERGZkiVfb+Pj49GuXTtcu3ZN9rMuXbpg0KBBaNSoEezt7fHw4UMcOnQIGzZsQFxcnORYe3t7HDp0CJ06dSowRkvFjhEqMjk5OXjvvfcM+uLk6OiInTt34o033jB+YERkEHaMEBUv5mqHDe0YAYB79+4hICAA9+/fVx1jixYtcPjwYZQvX151XiIiY7L0621UVBT8/f1x584d1fEBQJkyZbBlyxb06tXLoPyWgFNpqMhYW1tj5cqV+Oyzz2Bra6s4n5eXF37//Xd2ihARERVCcWiHa9asiePHj6Nt27aq8vXp0wdHjx5lpwgRWQRLv956eXkhNDQUAwYMUJ3Xx8cHZ86cKdadIgA7RqiIWVtb49tvv8WlS5cwcOBAODk56TzW09MTX375Ja5evVpsh2gRlWTHjx+HECJv42gRIstXHNrhmjVr4vTp01i1ahVatmxZ4LFt27bF1q1bsWvXLri6upopQiIi/Sz9euvm5oZt27bh1KlT6Nu3LxwdHQs83s/PD6tWrUJYWBiaNWtmlhhNiVNpyKKkpqbijz/+QFRUFKKjo2FrawsPDw80b94cjRs3lq2aTERERMZTHNrhBw8e4OLFi3jy5Ani4uLg4uICLy8vtG3bFlWqVCnq8IiIFLH06216ejrOnz+P27dvIyYmBqmpqShXrhxq1aqF1q1bw9PTs0jjMzZ2jBARERERERFRqVX03f5EREREREREREWEHSNEREREREREVGqxY4SIiIiIiIiISi12jBARERERERFRqcWOESIiIiIiIiIqtdgxQkRERERERESlFjtGiIiIiIiIiKjUYscIEREREREREZVa7BghIiIiIiIiolKLHSNEREREREREVGqxY4SIiIiIiIiISi3bog6AiEqvBw8eIDw8HPfu3UNCQgIyMzPh5OSE8uXLo1atWmjcuDEqVKhQ1GESEREREVEJxo4RIjKrsLAwBAcHY8eOHXjw4IHe4xs2bIj+/ftj5MiRqFu3rhkiJENMnz4dc+fOlaS5urri4cOHcHZ2LnT5o0aNwpo1awpdjj7Hjh1DQECAyeshIjLUsmXLEB0dDQCoX78+hgwZUsQREREVf5xKQ0Rm8eDBA/Tt2xfNmjXD4sWLFXWKAMC1a9fwzTffoEGDBhgyZAgePXpk4khJrZycHKxdu1aW/uLFC2zcuLEIIiKi4u7evXuwsrJStVlbW8PBwQHlypWDl5cXWrZsiQEDBmD27NkICQlBTk5OUZ9WoSUlJeFf//oXZs6ciZkzZ+LWrVtFHVKpkpKSoveYUaNGSd6Xpu5s1/w7WL16tUnrM4eSeE7FlZL3/Ndffy35fdWsWdP0gZkAO0aIyOQOHz6Mxo0bY9euXQaXkZOTg02bNsHHxweHDx82YnRUWL///juioqK0/iwoKMjM0RBRaSWEQEZGBhITE/Hw4UNcunQJv/76K2bMmIF27drB29sbixYtQkZGRlGHarCjR48iMzMzb/+NN94owmhKj5SUFEybNg2TJ08u6lCIzGbNmjWlahQtO0aIyKRCQkLQq1cvJCQkSNJdXFwwbNgwLF68GAcOHEBISAguX76MU6dOYfv27fjyyy/RqlUrWXnx8fHo2bMnjhw5Yq5TID1WrVol2be1/d8szdDQUFy8eNHcIRERydy7dw8fffQRfH19ERoaWtThGOT333/P+7+7uzv8/PyKMJrSYc+ePfDx8UFgYGCx7lQjUioiIgL+/v4YNWoUnj59WtThmA3XGCEik0lJScGgQYOQnp6el2ZtbY1PP/0UX3zxRYFrT/Tv3x+zZs3C+fPnMX78eISFheX9LCMjA4MGDUJERAQqVapk0nOggsXGxmL37t15+xUqVEDnzp2xbdu2vLSgoCCsWLHC6HXfvXu32A7XJKKic/PmTbRv3x5bt25F7969izocVQ4ePJj3/y5dusDamvc4Telf//oXlixZUtRhEJnN5s2b8e6770pGppUWvJoSkcksXrwYkZGRkrQVK1YgMDBQ8YKcrVu3RkhICDp16iRJj4mJwVdffWW0WMkw69atk9xB69ChA/r16yc5ZuPGjXjx4oW5QyOiEmbkyJEQQujcsrOzkZKSgmfPniEiIgK7du3C9OnTtS7cnZ6ejgEDBkhGYFi6O3fuSNYU4TQa08t/U4aoNLh27Vqp7BQB2DFCRCa0fPlyyX6/fv0wevRo1eWUKVMGW7ZsgaurqyR97dq1sik6ZF7BwcGS/Y4dO6J3795wdHTMS0tJScEvv/xi7tCIqJSxtrZGmTJl4OHhgYYNG6JPnz6YM2cOrl27hp9//lnWIZ+ZmYkhQ4bg7t27RRSxOpqdON26dSuiSKggq1evlnTYHT9+vKhDIiIF2DFCRCZx48YN3Lt3T5JmSKdILk9PT3z44YeStJSUFBw9etTgMqlwLl26hMuXL0vSunXrBhcXF/To0UOS/tNPP5kxMiKi/7GxscHYsWNx5swZVKhQQfKzuLg4/OMf/yiiyNTJ3zHSqFEjeHl5FWE0REQlCztGiMgkrl27Jkvz9vYuVJmDBw+WpWl+MSfz0Vx0tW7dumjcuDEAYNiwYZKfXb16FX/88YfZYiMi0tSkSRPs2bMHdnZ2kvRDhw7ht99+K6KolMnKypLcCOA0GiIi4+Liq0RkEklJSbK0mJiYQpXZsGFDlC1bNq9sFxcXZGdnF6pMc3vw4AHOnj2LBw8eID09Ha6urqhfvz7at28PJyenAvOmpaXh9OnTiIiIQEJCAlxcXFCtWjW0b98elStXNtMZvJSeno6NGzdK0gYMGJD3/549e8Ld3R2xsbF5aUFBQejQoYPZYiQi0tSmTRt8+eWXmDFjhiR9/vz5Fr0Q65kzZ5CYmJi3z2k0RETGxY4RIjIJzfVAAODXX39Fx44dDS7TysoKly5dgrOzMzw8PGBvb1/g8atXr5ZN3xFCqKozICAAJ06cyNsfOXIkVq9erfXYr7/+GjNnzszbX7ZsGd5//30AwJEjRzBjxgycOXNGa14nJye89957mD17tuy1e/78OWbNmoVVq1YhOTlZa/6uXbti7ty5Znt0486dOyWdHgDw9ttv5/3fwcEBgwcPxtKlS/PStm3bhu+//x4eHh5miZGISJtPP/0US5cuxZMnT/LSTp06hfDwcPj4+Kgu7/Hjx/jzzz8RExODmJgYJCUlwd7eHu7u7qhRowaaN29e6Ote/qfRODo6wt/f36ByEhIScOrUKdy8eRPJyclwcXFBjRo10Lp1a1SpUqVQMWq6ceMG/vrrLzx9+hRxcXFwd3eHp6cnWrZsiVdeecWodeW6efMmzp07h4cPHyInJwfu7u7w9fVFy5YtJWtfWbr09HSEhobir7/+QmxsLFxcXFC9enW8+uqrJrsRkpKSgpCQEDx8+BDR0dGwtrZGpUqVUKNGDbRp00bvZy5L9OLFC4SEhODx48d4+vQpHBwcUKlSJXh7e6NVq1YmeaqTEAKXL1/GlStXEB0dDSEEKleujNq1a6Nt27awtTXO1+9bt24hNDQUjx49Qnp6OipXroxatWqhffv2RqvDmFJTU/HHH38gMjIS0dHRsLOzQ7Vq1dC8eXM0aNCgqMN7SRARmcD9+/cFAMlmb28vjh49arYYgoODZTGo5e/vL8k/cuRIncd+9dVXkmOXLVsm0tPTxZQpU4SVlZUsFm1b7dq1xb179/LKPHLkiPDw8FCU197eXqxdu9aQl0q1bt26Ser29fWVHXPhwgVZjPPmzTOovpEjR8rKunv3biHPgogs1d27d2V/8wVdf9WaO3eurPzZs2crzn/58mUxYcIEUbduXb3XZisrK9GqVSuxYsUKkZmZaVC8fn5+eeV17dpV53H567WxsclLf/bsmRg/frxwcHDQGWNAQIDYu3evQfHliouLE9OnTxd16tQp8DXx9fUV3333nUhLS1Nctmab/t577+X97MSJE+LVV1/VWZ+Li4sYP368ePDggd56lLS3BX2u0Gyv/P39FZ/jw4cPxYQJE4Sbm5vWumxtbUXv3r3Fn3/+qTPe4OBgxfUJIcShQ4dE9+7dhaOjY4Gv39tvvy2p15QKe05btmwRAQEBwtbWVuc5VahQQYwePVrcvn3b4NhcXV3z0pOTk8WcOXNE1apVddZZvnx5MW7cOPHw4UNVdebKzMwUS5cuFT4+PjrrqFixovj4449FQkKCEOLl376+96zmZ11927FjxyT5NT//1qhRI+9nf//9t3jnnXeEk5OTzvLq1q0rfvjhB4Ovj8bCjhEiMplmzZrJLn4ODg5i6tSp4smTJyavv6g7RpYuXSoGDRqk+kNW06ZNRUZGhti3b5+wt7dXldfOzk6cP3++EK+afg8ePBDW1taSer/77jutx/r6+kqOq1OnjsjJyVFdJztGiEoXU3eMREREyMpv166d3nxxcXFi6NChqq/ruZuvr6+4ceOGqlifPXsmuebOnz9f57H568rtGAkNDRVVqlRRHGO/fv3EixcvVMUohBDLly8X7u7uql6PGjVqiIMHDyoqX1fHyDfffKP45kOZMmVEUFBQgfWo/Z1qMrRj5Oeffy7wy2P+zd7ePu99oPkzpZ0IUVFR4s0331R1rtbW1mL06NEiOTlZUR2GMvScwsPDC+wg0/VafvrppyIrK0t1bLkdI5cvXxa1a9dWXKezs7PYsGGDqtfk2rVrss9UBW3Vq1cXJ0+eLNKOka+//lrY2dkpLrdFixYiMjJS1etiTOwYISKT2bBhg86Ln52dnejZs6dYsWKFiIqKMkn9Rd0xUq9ePcm+t7e3mDdvnti/f78IDQ0Vu3btEiNGjJB1MgAQn3zyiShbtmzevqenp5g2bZrYv3+/uHjxoti3b5+YMmWK5JjcrUuXLoV41fSbPXu2pD5bW1udHV0LFiyQxaf0Q3B+7BghKl1M3TEihBDVq1eXlO/o6CgyMjJ0Hh8dHS3q16+v6guEri8sajoeNNvSK1eu6Dw2/3E2NjYiIiJClC9fXnWMvr6+IiYmRlF82dnZYsqUKQa/Hra2tmL58uV669HWMRIYGGhQndOmTVP0GirZNBnSMTJt2jSDzmPevHmyNCWdCFeuXBFeXl4G/85at24toqOj9dZjKEPO6ejRozpH2ijZevbsKZKSklTF5urqKi5duiRcXV1V12djYyN2796t6PU4f/68KFeunOo6nJycxK+//qr3PWvsjhEvLy8xevRog34P9evXN6hj1hgsbwISEZUYQ4YMwaZNm7B7927ZzzIzM7F3717s3bsXAFC/fn106tQJHTt2RMeOHVGzZk0zR2t8N27cyPv/nDlzMHXqVMl81hYtWqBPnz7o3LmzbC2U+fPn5/1/+PDhCAoKgrOzs+SY7t27Y+zYsejSpQseP36cl3748GHcu3fPJK+hEEK2xkr37t3h6emp9fjhw4fjs88+Q1ZWVl5aUFAQunbtavTYiIjU8PX1RWRkZN5+Wloarl+/Dl9fX9mxQggMGjQI169fl6SXLVsWgwYNgr+/P2rXro2yZcsiJSUFjx49wrlz57B+/Xo8evRIkicyMhIzZ87EggULFMWZ/zG9VapUyXv6lz5CCPTv3x9xcXF5aU2bNsWYMWPQrFkzODg44MaNG9i0aRP27dsnyXv16lX069cPx44d07sOwyeffIJFixbJ0lu3bo2BAweiZcuWcHNzQ2xsLK5cuYLNmzfj/PnzecdlZWVh/PjxcHd3lyzirc+ZM2cQHByct29jY4OBAwdiwIABqFmzJhISEnD+/HmsWLECd+7ckeSdO3cuateujffee09Wbv4YTpw4gefPn+ft16hRw+hrea1cuRJz586VpTdu3BijR49G8+bNUbZsWURGRmLv3r3YuHEjUlJSAACfffaZ6vru378Pf39/yfsCAJydnTFs2DB06dIF1atXh5WVFSIjI3Hw4EFs3rwZCQkJeceeP38ePXr0wJkzZyxi7ZGLFy/izTffREZGhiS9QoUKePfddxEQEICqVasiIyMD9+/fx759+7Bt2zakp6fnHbt3714MHToUu3btUlxvRkYG+vbtixcvXgB4uRZez5498dZbb6FBgwZwcHDA/fv3sXPnTmzZsgWZmZl5ebOzs/HBBx+ga9euBa5/8/DhQ3Tv3l3y+gMvH0Dw7rvv4o033kC1atUQHx+PS5cuYe3atbh69SqAl+vGDBkyRO95+Pv7562DFBERIXmypJOTE7p37y45vmLFigWWFxUVJfnb9PDwwIgRI9C5c2dUq1YNKSkpiIiIwLp163Dy5ElJ3uvXr2P27NmSz8FmUyTdMURUaiQlJYmAgADVPcbVq1cXY8aMEZs2bTK457ioR4zkboGBgXrr6dSpk9a8ffv21Zt3/fr1snzr169Xc5qKHTt2TFbX9u3bC8zTp08fyfG2trbi0aNHqurVNmKke/fuYsCAAUbZRowYUZiXhYiMzBwjRj788ENZHXv27NF67KZNm2THtmzZUu+1LC0tTfzrX/+S5a1YsaLiofv51yzQ9xroalOtra3Ff/7zH5Gdna013759+7Te9V60aFGB9e3evVuWx83NTWzbtq3AfJs3bxYuLi6SfK6urgWu96CtTc/datasKc6dO6c1X2pqqtbfddmyZfUO21fzGSCXmhEjUVFRspGfVlZWYu7cuTrfH7dv3xatW7fW+VoUNLoiIyNDtGnTRpanX79+4tmzZzrzPX78WNaWAxCTJk3S+3oYQs05xcfHa53G8v7774vExESd+W7evCnatWsny7dgwQJVseVu9erVExcvXtSZLzQ0VFSrVk2Wb926dQXW1717d1mezp076xxtnZWVJb777juto5GVfBYuaL0QpXnyb0OHDi3w9/DDDz9ovYaoWX/IWNgxQkQml5GRIT755JMCF8EqaLO3txe9e/fW+YFVF0voGKlbt26BQ7Nz/fjjj7K8dnZ2ijoQ0tLSZGuRfPHFF2pOU7F3331XUo+Hh4dIT08vMM+OHTtk5zZr1ixV9WrrGDHmln8BNSIqeuboGNG2AKuu9Sc0v0y6ubmpWkCxa9eusroK+hKV68qVK5I8+tYl0HWNW7lypd66zp8/L8qUKSPJV7FiRZ3TC9LT02ULTbq6uoq//vpLb1259Tk7O0vyDxkyROfxujpGqlevLlm0XJd///vfsrz//Oc/C8xj6o6RiRMnymJauHCh3jpevHghWrZsqfX1KKgT4f/+7/9kx+dfxLYgWVlZsvV1rKysxLVr1xTlV0PNOX388ccGf8ZITk6W3bxzdnYWsbGximPLfQ8qmVqk7ebSoEGDdB5//Phx2fGvvfaaSE1N1VuXtptmuVtBjNkxMnnyZL15hRBap92cOnVKUV5jMv4zioiINNjZ2WHevHkICwvD8OHD4eDgoCp/RkYGfvvtN/Tq1Qtt2rRBaGioiSI1vgkTJsDOzk7vcU2bNpWlde/eXdHjEx0cHGTTZjSHyBpDQkICtm/fLkkbOnSo3mG0PXv2lA27/Pnnn5GdnW30GImIlNKcnggASUlJsrSoqCicPXtWkvbBBx+gatWqiusaM2aM1nL1yT+NxsrKyqBpiCNGjNBav6ZWrVph9uzZkrRnz55h06ZNWo/fuHGjbJrQTz/9pHUqkq76NKeQbN26FQ8ePFCUH3j5mqxevRo1atTQe2xgYCCaNWsmSVu9ejUSExMV12dMycnJsqmpAQEBmDJlit685cqVw9q1a1VNY8nJycH3338vSfP19UVQUJCi/DY2Nli+fDm8vLzy0oQQWLhwoeIYjC0xMRE///yzJO3NN9/El19+qSi/k5MTNmzYILkWJCcnY9myZariWLBgASpVqqT3uICAALRp00aSdvnyZZ3Ha762bm5uWLt2raJHTw8dOhRjx47Ve5ypeHt7IzAwUNGx2t7zYWFhxg5JL3aMEJHZNGrUCL/88guePHmCVatWoW/fvlo/mBbk3LlzaNu2LRYvXmyiKI2rU6dOio7LnduZX7t27RTX4+7uLtlPTk5WnFepzZs3581rzqW5Noo2dnZ2GD58uCQtMjJSNqediMictLU/qampsrS0tDRMmTIFb731Fho3boyyZcvi3XffVVVXo0aNZGnaOmE05e8YadGihda2oiD29vaq5upPmjRJVseGDRu0Hqv55bFp06YYNGiQqvjGjRsHNze3vP2srCysXbtWcf633noLr732mqJjbW1tZV+YU1NTsXPnTsX1GdNvv/0ma6unTp2qOH+jRo0wbNgwxccfPHgQt2/flqTNmjULtrbKl5x0dnbGxIkTJWnr1q2Tre1hLuvXr5etvaFtvZaCVKlSRfYZZdWqVYrzV6pUCf369VN8fNu2bSX7T58+1XpcTEwM9u/fL0kbP348qlWrprgutb9fY5o8ebKiDhzg5Xo6mp9j86//ZC7sGCEis3Nzc8Po0aOxY8cOxMXF4eTJk5g5cyY6d+6MMmXK6M2fmZmJyZMnY968eWaItnAaNGig6Dhto2i8vb0V16N510gIoTivUpofFJo2bSq7+6aLtg4UtXdkNN29exfi5ZTQQm/x8fGFioWIih9to9a0fZCvU6cOFi5ciJ07d+LKlStITExEvXr1VNXl4uIiS9P3ZTI1NRWnTp3K2+/WrZuqOoGXHQdK7mTnsre3x+DBgyVpp0+fRlpamiQtKSkJFy9elKSp7RQBgDJlyuD111+XpGkuxliQcePGqaqvd+/esi9ghw8fVlWGsRw5ckSy7+HhIXst9FHTQXfs2DHJvouLC3r06KGqPgDo1auXZD81NVX2XjAXzXOqV68emjdvrroczXO6ffu2bDSULm3atFHV+VC9enXJvq4bWUePHpUs1gq8HP2lRpUqVWQLp5qL0g7LXK+88opkX7PDyxzYMUJERcrOzg4dO3bEjBkzcPToUcTHx+P48eP48ssv4efnBysrK515p06diuPHj5svWJVcXFzg5ORkcH5XV1fFxxb0OhnD33//LRtKPmrUKMX5GzdujJYtW0rSfv/9d9y7d88I0RERqaf5ZR9Qd91V6s6dO9i4caMsPScnp8B8x48flzw144033lBdtyF52rdvL9lPT0+XDfcPCQmRdSxpXuOV0vwie/bsWb2vDfByBIjaL192dnZo1aqVJO3cuXOqyjCW/E/mAQA/Pz/Y2NioKqNt27aKv5T/8ccfkn1fX1/VU5uBlyNVNPOdPn1adTnGoFmvsd6D2srWpUmTJqrqKlu2rGQ//1P78gsJCZHsu7q6ah15po/m37M5WFtbq+48LleunGRf2/XZ1Pi4XiKyKPb29vD394e/vz9mzZqFqKgorF69GosXL5Y8Mg94+aFy8uTJBc7PLEqajZ9aStYmMZeVK1fK0qZMmaJoLrQuOTk5WL58uephr0RExqDZpgCQTOtQ6+nTp7hz5w5u376NiIgIXL16FRcuXJA8Tj0/fSP7Dh48mPf/smXLqppemcuQR8tqGwl48+ZNydoI4eHhsmPmz5+P5cuXq65Ps4M8MTERz58/1zvSxdfXV/FQ/fyaNWsmmaJ09+5dZGdnq+6UKKxbt25J9pWuzZKfo6Mj6tWrh4iICL3Hav7O7t+/j4EDB6quE4DsEc537941qJzCiI+Px8OHDyVpFy9eNOictP0tKj0nzRFI+mh+ttPVCaj5aHAfHx+DboIpHdlrTBUqVFA9hUfz3JR0jhobO0aIyKJ5eXnhiy++wKRJkzBu3Dhs3bpV8vOwsDCcPn26SHrE9VGzKJoly8rKwrp160xS9qpVqzBz5kyL6gQiotJB21B5pV9y7ty5gx07diA0NBQRERG4ffu2ojVD1Mj/5b1z584GXSc1h6croW0dk+joaMl+bGys7BhjTkmJjY3V2zFiyLkB8vPLyMhAXFyc6vVbCiM+Pl62Zpeh9Xt5eentGMnOzpZNTXj06JFsQXVDaXs/mJq2Om/evImbN2+arHxtNEc6GIvm9UltB0wuc76vcymZFm+JOJWGiIoFV1dXbNq0Sesc6/x31cj49u3bhydPnpik7OjoaOzYscMkZRMRFUTbl8nGjRsXmOfChQt4/fXX4e3tjX//+9/YuHEjwsLC9HaKqJ2yEBkZiWvXruXtGzIlBjDsS5u26USa6yCY+ouwkierGTrtScn5mZq2+rStQ6OEknxxcXEmWXssf/nmZgnvQQAmG2mkeU0xdBSyqTpuCmLq6d2mwhEjRGR0P//8Mw4ePIjo6GhER0fD3t4ef/31V6HLtba2xoIFC2QfXLUN6TUWzYWvSiPNRVfLlStn0CMjgf89ejm/oKAgvPPOOwbHR0SkVmZmJq5cuSJJq1GjRoGjFObOnYsvvvhC0RdMa2trNGjQAB07dkTXrl3RqFEjVesD5B8tAhjWMWJjY2PQlzZtax5oDos39VNI8q+toouhozKVnJ+pGfOLo5LpRJbw+zK2knhO+WmOENP2xCwlivo8ihN2jBCR0YWEhGDbtm2StKdPn6paGV8XX19fVK5cWTKC4cWLF4rz5+TkyObGFsTQhqikePr0qeyxuoMHD8ZPP/1kcJk+Pj6SO7XHjh3D9evXUb9+fYPLJCJS4+zZs7K79q1bt9Z5fGBgIKZPn671Z1WrVoWfnx98fHxQv359NGzYED4+PpLHAatdgyF/x0itWrVQp04dVfmBl9MnUlNTVQ9r19amao5K0FyLxd7eHmlpaWa9U5yYmGhQPiXnZ2raHhWt5rNMfkpeB21r53zzzTeYNm2aQXVaAm3ntH79egwdOtT8wZiA5tQZQ9/vRfF0l+KKU2mIyOi0zfvVXA29MDQfdabrA422D2hq7zDoer58abF27VrZqJkhQ4YUqkxtjxcsTEcLEZFamzZtkqXpelRqWFgYZsyYIUsfMWIErl69iocPH2LXrl2YO3cuRo4cidatW8u++KrpZM/OzpY8ytXQaTSAYdMNNNcTAeTtuuaXtoyMDJNNudTF0KkUmufn6upq9ukGrq6usveIoZ83lDxu3snJSTay5P79+wbVZym0rblR3M8pP09PT8m+oQvcPnjwwBjhlArsGCEio3v11VdlaUuWLDFa+ZoXeW9vb63HaVuoTs3ieImJiYqfY19SBQcHS/arVq2KTp06FarM4cOHy0btrFmzpkgezUZEpc+LFy+wYcMGSZqdnR0GDBig9fglS5bIpl/MnTsXa9asgY+Pj6I61XzpvXDhgmR9A21rayl19epV1Xm0PemtQYMGkv2aNWvKjvnzzz9V11UYhpwbID8/zXMzF83HmRr6+imdTlyjRg2j1GcpKlasKOtcKu7nlJ/mCLa7d+8aNKqoJL0mpsaOESIyus6dO8uGOJ44cQLHjx8vdNknT56U3e3x9/fXeqy2kSRq7midPHnSpIuVWbpz587JFiccNGiQqqlI2nh5eeG1116TpMXGxmLz5s2FKpeISIn58+fL7rIPHDhQ59MbNBeIfuWVV/Dpp5+qqlPbOlu6HkeZfxqNra2t7Hqpxrlz51Tn0RzhWalSJdlUxw4dOsjyaa6LotTJkyexcuVKHDlyBLdv31a8tteTJ09U3w1PS0tDaGioJK2wnf2G0nz8cmhoqOxJNfrcvn0bMTExio7V/J2FhoZqfWS1PllZWfj++++xfft2hIaGKq7f2GxsbCSPkAaAI0eOIDs7W3VZcXFxWLx4MXbt2oWwsDCDpzUZk7anLe7fv191OQcOHDBGOKUCO0aIyOgcHR0xZswYWfqwYcNw69Ytg8tNS0vDlClTJGmenp46hxlXrlxZlpZ/eLI+QUFB6gIsYTQXXQUKP40m14gRI2Rppf31JiLTCw0Nxbx58yRpVlZW+Oyzz7Qen5CQIHs6RatWrVQvaqrt6VvaFgEFpB0Mbdq0MfjpK8DLNRfUSE1NxZYtWyRp3bt3l01N9fLyQq1atSRpv/zyi+p1EIQQmDhxIsaOHYsuXbqgTp06qFSpkuJpr2ofJb99+3ZZjD169NB5vCnXTHnzzTcl+0lJSbL12fRRc/6aHUA5OTkGTWPduXMnpkyZgoEDB8LPzw8eHh6YP3++6nKMQfOcYmNjtU6T02flypWYPHky+vbti2bNmsHNzQ1bt241VpgGadu2Lby8vCRpK1asUFXG2bNnZYtM61NcnyhjDOwYISKTmD59OsqXLy9Je/ToEdq2bYtff/1VdXnPnz9Hnz59cOnSJUn6tGnTtE6ZAV4u8qk5p3bp0qWKVugODg7Gnj17VMdZUqSmpspGcHh7e6NVq1ZGKb9///6yR8+dPXsWYWFhRimfiEjTlStX0KdPH9mIhNGjR6Np06Za82ib4qd2Ue4DBw7g2LFjsnRtX/7j4+Nx/vz5vP3CTKMBgBs3bqj6gjdv3jzZYo2jRo3SeqzmDZC4uDjMnTtXVXwbNmyQTYnp3bu34ifO/Pjjj4rv7qenp+Obb76RpNWsWVPnqFPAdI9iBV52jGjewJkzZ47i91dsbCyWLVumuL7+/fvLRvMuWrRI1ZThrKwsrevt6JqGZmojRoyQ/Y6+/vprVdOmX7x4IessLVOmDLp3726UGA1lY2OD8ePHS9KOHDki67jUJTMzExMmTDCo3tKKHSNEZBLu7u4IDg6W9Tw/f/4cAwYMQMeOHbF161a9HwBu3bqFb775Bg0aNMChQ4ckP3v11Vfxz3/+U2deJycn2WJ6N27cwKBBg3R2jmRmZmLu3LkYO3ZsgXGVdNu3b5d92DTWaBHg5Yr8/fv3l6Vz1AgRGVtKSgqWLFmCtm3byr4Eent7Y8GCBTrzenh4yL6knzhxAs+ePVNU95UrVzB8+HCtP9PW/h0+fFgyFaAwC6/m+uCDDxQt3Hjy5ElZx8Grr76KgIAArcdPmDBBtsbDf/7zH2zfvl1RXHfv3sWHH34oSbOyssLkyZMV5Qde3nD5xz/+oXNaUn6TJ0/GtWvXJGmffvppgXfIHRwcJPtqp7oUxNbWFh9//LEk7ebNm5g4caLeabzZ2dkYP3681oVydSlbtizef/99SVpMTAzefvttxR0Jn376qew17NOnD2rXrq04DmOqWbMm3n77bUnarVu3MGrUKJ0jsvITQmDMmDGyv+dx48bJbt4UhYkTJ6JixYqStLFjx+LEiRMF5svIyMCwYcMMWl/ElO95iyeIiExo4cKFAoDOzcHBQbRr106MHj1afPrpp2L69Oni/fffFwMHDhS1atXSma9mzZriwYMHeus/fPiw1vxVq1YVgYGBYt++feLSpUvi999/FzNmzBA1atSQHNexY0fJ/siRI3XW9dVXX0mOrVGjhuLX6e7du7IYjx07pji/v7+/4jiV6Ny5syye8PDwQpWp6ciRI7I6XFxcRGJiouzYkSNHFvg+MuYWFxdn1PMkIvW0XRP1XddycnJEWlqaePr0qQgLCxObN28WEydOFBUqVND6t+7q6iquXbumN5Zu3brJ8r7++usiISFBZ57MzEyxdOlS4eLiovNa8/nnn8vyjR07Nu/n7u7uIjs7W298+emqy8vLS5w9e1Znvk2bNgknJydJHmtra3Hq1KkC61uwYIGsLhsbGxEYGCgyMjJ05jt79qzw8vKS5R0yZIjOPMHBwTrP7+2339Z57U5ISBCjRo2S5fHx8SkwRiGEGDZsmCyPPprtlb+/v85j09LSRN26dWWxDR06VMTHx2vNExMTI/r376/ztQgODtZZX2xsrOxzDgDRrFkzcfXqVZ35UlNTxaRJk2T57OzsxF9//aX3NVFLzTndvn1buLq6av0bvX//vs58cXFx4u2339Z6XYiOjjZKbNpoex8X5JdffpEdb29vLz7//HNZnNnZ2eLQoUOiadOmBX7OKcjPP/8sOdbKyqrA10OIwn3+zWXsz7GGsAURkQlNmTIFHh4emDBhgtY7Eunp6Thz5gzOnDmjuEw/Pz/8+uuvssf2avP6669j8ODBsjmnjx49wtSpUwvMO3z4cAwdOhSnTp1SHFtJcPfuXdlCuU2aNEGjRo2MWk/nzp1RvXp1REZG5qUlJiZi/fr1+Mc//mHUuoio+FuzZg3WrFljlLI8PT2xc+dORU8kmTRpEg4ePChJO3LkCBo2bIixY8eiXbt2qFixIrKyshAZGYmQkBBs2bJFtjCos7MzkpOT8/a1LQaev54uXboUerHrXFFRUWjXrh369++PAQMGoHbt2sjMzER4eDjWrVuntZ374osvtC6ymt9HH32EkydPYteuXXlp2dnZmDp1KpYvX46hQ4eiffv28PT0REZGBv7++2/s3LkTv/32m2yUR61atbB06VKDzm/r1q04ceIERo8ejc6dO6NixYp4/vw5Tp48ieDgYNlIIWdnZ2zatEnnVNxcmo8pDg8Px9ixYzF69Gg4OTnh6dOn6Nq1q8G/JwcHB2zatAnt27eXTNvasGEDjh49itGjRyMgIAAeHh54+vQpjh49iuDgYMmiqW5ubooe2QsA5cuXx5YtW9ChQwfJlLLLly+jadOmeOutt9CrVy/UrVsXzs7OiI6OxunTp7F69WpERUXJyps/fz58fX0NOndjqV27NoKDg2WjUI8cOYJ69erhnXfeQffu3VGzZk04ODjg4cOHOH78ONasWaN14djVq1ejUqVK5gpfr+HDh+PEiROS9UUyMjLw7bffYv78+WjatCmqVq2K5ORkREREyEYRVapUSfJULH1riGi+54UQGDBgAL744gtUrlwZcXFxaNiwoexxwiWC2btiiKhUunXrlnjnnXeElZWVwXfyy5UrJ+bMmSPS09NV1Z2WlibeffddxfVYWVmJTz75RGRlZYn9+/cr7sEuKSNGvvzyS1ksgYGBBpdXkKlTp2q9c6WJI0aIShdt10RjbQEBAYpGHOY3ePBgg+tzcnISa9asEePGjZOka44+uHbtmuTnK1euVP26adbdt29fYWtrqzrmiRMnKq4zOTlZ9OvXr1C/kxo1aojr168XWI+2O+3a7vjr25ydnRW3r3v37tVb3t9//y3Jo2bESK79+/cLBwcH1efyr3/9S/Ts2VOSpmQEw4EDB0S5cuUK9TvTNuLJWDTrUnJOq1evFvb29gafj7W1tVi6dKlJYstP7YgRIV6OBFHzOTZ3+/DDD2WfTR0dHQusKy4uTu/rGBQUJMlTUkaMcI0RIjILb29vbN68GdevX8eMGTPQvHlzRQs82djYoHXr1li0aBHu3r2L6dOnK16ULZeDgwPWrl2LQ4cO4c0339R5h8ja2hrdu3fHmTNnMG/evFK5AFVOTo7WO7KDBw82SX0jR46UpV2+fNmgR0wSEelibW2NgIAA7NmzB8eOHVM04jC/1atX45133lFdb+fOnfHnn39ixIgRssWrw8PDcf/+/bx9zcfdFnbhVQB46623sGnTJpQrV07R8WXLlsXy5cvxww8/KK7DyckJ27dvx6xZs+Dk5KQ6xp49e+LMmTOoV6+e6rzr16/XuTisNs2bN8eFCxd0rpuiqUePHnp/D2qf+qHNm2++iTNnzqBOnTqK84wdOxbfffedQfW98cYbCAkJQevWrVXnzV1DLjAw0KC6TWXkyJE4cuSIolFgmry8vLB79+4C160rStbW1li7di3WrVunaDRLhQoVEBwcjMWLF8tGZmmuIaLJzc0NX331VYHHGOM9b5HM3hVDRPRfSUlJ4vz582LLli3i//7v/8S3334rZs2aJebNmydWrFghTpw4YZK79/Hx8eK3334TQUFBYs6cOWLhwoVi586d4tmzZ0avi4iI1DN0xIijo6Pw8PAQtWvXFp07dxYffPCBWLlypXjy5IlR4tq8ebNo1apVgTG4uLiIt956Sxw4cECSNyYmRnYn9qOPPsr7effu3fPSGzVqZFB8mrHk3s1+8OCBGDJkiM5RCR4eHuLjjz/Wu5aAPk+ePBH//ve/Re3atQt8jWxtbUXv3r3F/v37FZdd0J32nTt3ihYtWuisr0WLFmL16tWq12wR4uWImNGjRwtra2utZU+fPl1yvCEjRnKlp6eLhQsXijp16ug8l2bNmomtW7fm5TFkxEh+u3btEl27dhWOjo4F/s5q1KghvvrqK/H06VNV5RtC1/tYiaysLLFmzRrRoUMHvaOlGjZsKBYsWKB1bTNTxCaEYSNG8ktKShKbN28WgwYNEj4+PqJChQrC3t5eVK9eXXTp0kUsXbpUxMbG5h3/8ccfS+qqWrWqonoWLlwonJ2dtb5u7du3lxxbUkaMWAmhZ9ljIiIiIiLK8+jRI5w7dw4PHz7Eixcv4OzsjIoVK8Lb2xt+fn6wtVW3jF96ejrc3d3zngAxefJkLFq0SHVcmusHBAcHS0ZUxMXF4dSpU3jw4AESExNRoUIFNGnSBC1bttS73oZat27dwpUrV/Ds2TPExMTA3t4e5cuXR/369dGyZUuUKVNGVXmrV6/G6NGjJWmaX2MiIiJw+fJlREVFwdraGl5eXnj11VdRq1atQp9PVFQUTp06hcjISGRkZMDFxQVeXl5o0aKFUcrXFB4ejosXL+LJkyewtbVFtWrV0LhxY/j4+Bi9LuDlU5LOnj2LqKgoPH/+HKmpqShXrhwqV66Mli1bmuQcTS0hIQEhISF4/Pgxnj9/jszMTLi6uqJatWpo1aoVqlatWtQhmty4ceMk65O0bNkSFy9eVJQ3ISEBJ06cwK1bt5CUlAQnJyd4enqiUaNGaNGihalCLjLsGCEiIiIiKgH0dYwUZ0o6RohIqkePHti/f3/efp8+fSSLJdP/8Kk0RERERERERBYiOzsb7dq1Q506dVC3bl3UrVsXPXr0QPny5RWXkZWVhfPnz0vSmjRpYuxQSwx2jBARERERERFZCBsbG9y6dUvSsfHTTz9h/PjxisvYtm2b7JHEbdq0MVqMJQ2fSkNERERERERkQZo2bSrZX7lypeLpY0+fPsUnn3wiSStfvjy6du1qtPhKGnaMEBEREREREVmQ/v37S/bPnz+P8ePH5y3SrEt4eDj8/f0RFRUlSZ8yZQrs7e2NHmdJwak0RERERERERBbkvffew8KFC3H37t28tBUrVmDv3r0YNmwY2rdvj2rVqsHOzg4vXrzA9evXsX//fuzZswdZWVmSslq0aCEbQUJS7BghIiIiIiIisiBlypTB+vXr8eabbyIhISEv/fHjx/juu+/w3XffKSqnUaNG2L17NxwdHU0VaonAqTREREREREREFqZt27Y4fvw4GjdubFD+ESNG4MyZM6hWrZqRIyt52DFCREREREREZIGaN2+OP//8E6tWrUKHDh1gZWVV4PGurq4YNmwYLly4gDVr1sDV1dVMkRZvVkLp0rZEREREREREVGTi4+Nx6dIl3L59Gy9evEBaWhqcnJzg6emJhg0bokmTJrC15YoZarFjhIiIiIiIiIhKLU6lISIiIiIiIqJSix0jRERERERERFRqsWOEiIiIiIiIiEotdowQERERERERUanFjhEiIiIiIiIiKrXYMUJEREREREREpRY7RoiIiIiIiIio1GLHCBERERERERGVWv8P0abtlj5yCnsAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(12, 5.5))\n", + "\n", + "# # Plotting with complementary colors\n", + "# sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=\"#FF6347\")\n", + "# sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=\"#4682B4\")\n", + "\n", + "\n", + "color_1 = \"#53b1b1\" # A standard blue color\n", + "color_2 = \"#f6c624\" # A teal color\n", + "\n", + "# Plotting with chosen colors\n", + "sns.histplot([x[0] for x in envelope_errors], bins=20, kde=True, ax=axes[0], color=color_1)\n", + "sns.histplot(uptake_errors_array, bins=20, kde=True, ax=axes[1], color=color_2)\n", + "\n", + "axes[1].set_ylabel(\"\")\n", + "axes[0].set_xlabel(\"Sum AE\")\n", + "axes[1].set_xlabel(\"Da/peptide length\")\n", + "fig.subplots_adjust(wspace=0.2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import get_index_offset\n", + "from matplotlib.ticker import LogLocator\n", + "\n", + "\n", + "check_ana_obj = ana_apo_1\n", + "index_offset = get_index_offset(check_ana_obj, './data/6XG5_TRI.pdb')\n", + "\n", + "uptake_errors = sorted(uptake_errors, key=lambda x: x[1].start, reverse=False)\n", + "\n", + "num_subplots_per_figure = math.ceil(len(uptake_errors) / 2)\n", + "# num_subplots_per_figure = 250\n", + "num_figures = math.ceil(len(all_idfs) / num_subplots_per_figure)\n", + "\n", + "\n", + "for fig_index in range(num_figures):\n", + " # Select the subset of errors for the current figure\n", + " selected_uptake_errors = uptake_errors[fig_index * num_subplots_per_figure:(fig_index + 1) * num_subplots_per_figure]\n", + " num_col = math.ceil(len(selected_uptake_errors) / 5)\n", + "\n", + " fig, axs = plt.subplots(num_col, 5, figsize=(9 * 5, 8 * num_col)) # Adjust subplot size as needed\n", + "\n", + " for i, error_tuple in enumerate(selected_uptake_errors):\n", + "\n", + "\n", + " ax = axs[i // 5, i % 5]\n", + "\n", + "\n", + " # Unpack error information\n", + " peptide_data = error_tuple[1]\n", + "\n", + "\n", + " ax.axhline(y=peptide_data.max_d, color='lightgray', linestyle='--', linewidth=5)\n", + "\n", + " check_fitted_peptide_uptake(\n", + " check_ana_obj,\n", + " hdxms_data_list,\n", + " peptide_data,\n", + " if_plot=True,\n", + " state_name=check_state_name,\n", + " figure=fig,\n", + " ax=ax\n", + " )\n", + "\n", + " #Retrieve and format the peptide identifier\n", + " idf = peptide_data.identifier\n", + " idf_start, idf_end = map(int, re.match(r\"(-?\\d+)-(-?\\d+)\", idf).groups())\n", + " idf_seq = idf.split(\" \")[1]\n", + " ax.set_title(f\"{idf_start - index_offset}-{idf_end - index_offset} {idf_seq}\")\n", + "\n", + " ax.set_xlim(1e1, 1e5)\n", + " ax.xaxis.set_major_locator(LogLocator(base=10.0, numticks=5))\n", + "\n", + " # y_max = ax.get_ylim()[1]\n", + " # ax.set_ylim(-0.5, y_max + 1)\n", + " pep = error_tuple[1]\n", + " y_max = pep.theo_max_d/check_ana_obj.saturation\n", + " ax.set_ylim(-0.5, y_max + 0.5)\n", + "\n", + " # light gray dotted line at max deuteration\n", + "\n", + "\n", + " handles, labels = ax.get_legend_handles_labels()\n", + " new_labels = [label for label in labels if label.isdigit()]\n", + " new_handles = [handle for handle, label in zip(handles, labels) if label.isdigit()]\n", + " ax.legend(new_handles, new_labels, title='replicate', title_fontsize='small')\n", + "\n", + " # Layout adjustment and save\n", + " fig.tight_layout()\n", + " fig.savefig(f\"{results_path}/ecDHFR_uptake_errors_{check_state_name}_{fig_index}.pdf\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If the fitting is poor, do not proceed. Check the parameters in the sampling to ensure they agree with the experimental conditions. You may also need to remove outlier peptides and rerun the sampling. An outlier might be a peptide that exchanges a lot while its neighbors barely exchange (examples in the tutorial dataset: 78-92 VDEAIAACGDVPEIM, 75-78 VKSV).\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pigeon_feather", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/tutorials/05_plot_the_results.html b/tutorials/05_plot_the_results.html new file mode 100644 index 0000000..96c091a --- /dev/null +++ b/tutorials/05_plot_the_results.html @@ -0,0 +1,487 @@ + + + + + + + 05_plot_the_results — pigeon_feather 0.9 documentation + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + +
+ +
+
+
+ +
+
+
+
+ +
+

05_plot_the_results

+
+
[1]:
+
+
+
from pigeon_feather.data import *
+from pigeon_feather.plot import *
+from pigeon_feather.hxio import *
+from pigeon_feather.spectra import *
+
+
+import numpy as np
+import pandas as pd
+
+import datetime
+import os
+import pickle
+import datetime
+
+
+
+
+
+
+
+
+Determination of memory status is not supported on this
+ platform, measuring for memoryleaks will never fail
+
+
+
+
[2]:
+
+
+
# load the pickle file we saved in the previous notebook
+
+
+today = datetime.date.today().strftime("%Y%m%d")
+today = "20240722"
+
+with open(f"./data/hdxms_data_raw_{today}.pkl", "rb") as f:
+    hdxms_data_list = pickle.load(f)
+
+
+# back exchange correction for peptides with experimental full deuteration data based its closest match in the database
+tools.backexchange_correction(hdxms_data_list)
+
+
+
+
+
+
+
+
+Number of peptides with experimental max_d: 358
+Number of peptides with no experimental max_d: 12
+
+
+
+
[3]:
+
+
+
# make folders for results
+
+today_date = datetime.date.today().strftime("%Y%m%d")
+# today_date = '20240722'
+results_path = f"ecDHFR_results_{today_date}"
+
+if not os.path.exists(results_path):
+    os.makedirs(results_path)
+
+
+out_path = "./data/PF_input_20240722"
+
+
+
+

Create an Analysis object and load the results. Note: The temperature and pH are crucial for calculating the intrinsic exchange rates, so make sure to input the correct values. The chunk size and chunk number can be altered by the user. In this tutorial, they were automatically determined by a helper function.

+
+
[4]:
+
+
+
from pigeon_feather.analysis import Analysis, get_index_offset
+from pigeon_feather.tools import optimal_chunks
+import matplotlib.pyplot as plt
+
+RUN_NUM = 3
+
+apo_states = [
+    state
+    for data in hdxms_data_list
+    for state in data.states
+    if state.state_name == "APO"
+]
+
+tri_states = [
+    state
+    for data in hdxms_data_list
+    for state in data.states
+    if state.state_name == "TRI"
+]
+
+ana_apo_1 = Analysis(apo_states, temperature=293.0, pH=7.0)
+
+chunk_num, chunk_size = optimal_chunks(len(ana_apo_1.protein_sequence))
+ana_apo_1.load_bayesian_hdx_oupt_chunks(
+    chunk_size=chunk_size,
+    chunk_num=chunk_num,
+    state_name="APO",
+    run_num=RUN_NUM,
+    N=200,
+    bayesian_hdx_data_folder=f"{out_path}/bayesian_hdx_output_chunks",
+)
+
+
+ana_tri_1 = Analysis(tri_states, temperature=293.0, pH=7.0)
+
+ana_tri_1.load_bayesian_hdx_oupt_chunks(
+    chunk_size=chunk_size,
+    chunk_num=chunk_num,
+    state_name="TRI",
+    run_num=RUN_NUM,
+    N=200,
+    bayesian_hdx_data_folder=f"{out_path}/bayesian_hdx_output_chunks",
+)
+
+
+
+
+

barplot of the kex

+

barplot showing the FEATHER derived exchange rates. index_offset is determined by comparison to the sequence in HX/MS and the pdb file provided.

+
+
[5]:
+
+
+
# APO state only
+
+import numpy as np
+
+
+fig, axes = plt.subplots(2, 1, figsize=(40, 10), sharey=True, sharex=True)
+
+ana_apo_1.plot_kex_bar(
+    ax=axes[0], resolution_indicator_pos=15, label="APO", show_seq=False, color="k"
+)
+
+ana_tri_1.plot_kex_bar(
+    ax=axes[1], resolution_indicator_pos=15, label="TRI", show_seq=False, color="red"
+)
+
+from matplotlib.pyplot import step
+from matplotlib.ticker import FuncFormatter, MultipleLocator
+
+from pigeon_feather.analysis import get_index_offset
+
+pdb_file = "./data/6XG5_TRI.pdb"
+index_offset = get_index_offset(ana_apo_1, pdb_file)
+
+# # ax.xaxis.set_major_locator(plt.MultipleLocator(2))
+axes[0].set_xticks(axes[0].get_xticks()[::2])
+axes[0].set_xticklabels(axes[0].get_xticklabels(), fontdict={"fontsize": 24})
+
+
+def format_func(value, tick_number):
+    return f"{int(value - index_offset +1)}"
+
+
+axes[0].xaxis.set_major_formatter(FuncFormatter(format_func))
+
+seq_pos = 17
+for ii in range(0, len(ana_apo_1.protein_sequence[:]), 2):
+    axes[0].text(
+        ii,
+        seq_pos,
+        ana_apo_1.protein_sequence[ii],
+        ha="center",
+        va="center",
+        fontsize=22,
+    )
+
+
+for ax in axes:
+    ax.set_ylabel("-log(k$_{ex}$)")
+    #ax.legend(loc="lower left")
+    ax.yaxis.set_major_locator(plt.MultipleLocator(5))
+
+    ax.plot(
+        [-3, len(ana_apo_1.protein_sequence) + 3],
+        [5, 5],
+        color="gray",
+        lw=1,
+        linestyle="--",
+        alpha=0.5,
+    )
+    ax.plot(
+        [-3, len(ana_apo_1.protein_sequence) + 3],
+        [10, 10],
+        color="gray",
+        lw=1,
+        linestyle="--",
+        alpha=0.5,
+    )
+
+
+plt.subplots_adjust(hspace=0.08)
+fig.savefig(f"{results_path}/ecDHFR_kex_bar_APO_TRI_{today_date}.pdf")
+
+
+
+
+
+
+
+../_images/tutorials_05_plot_the_results_8_0.png +
+
+

logP projection to a pdb structure

+
+
[6]:
+
+
+
from pigeon_feather.analysis import BFactorPlot
+
+
+
+
+
[7]:
+
+
+
bfactor_plot = BFactorPlot(
+    ana_apo_1,
+    pdb_file="./data/6XG5_TRI.pdb",
+    plot_deltaG=True,
+    temperature=293.15,
+    logP_threshold=10,
+)
+bfactor_plot.plot(f"{results_path}/6XG5_APO_deltaG.pdb")
+
+# bfactor_plot = BFactorPlot(
+#     ana_apo_1,
+#     pdb_file="./data/6XG5_APO_relaxed_best_solvated.pdb",
+#     plot_deltaG=True,
+#     temperature=293.15,
+# )
+# bfactor_plot.plot(f"{out_path}/6XG5_APO_deltaG.pdb")
+
+
+
+
+
+

delta log(PF)s

+

if there are mutiple states availble, you can map the difference to the pdb strutcure

+
+
[8]:
+
+
+
bfactor_plot = BFactorPlot(
+    ana_apo_1,
+    ana_tri_1,
+    pdb_file="./data/6XG5_TRI.pdb",
+    plot_deltaG=True,
+    temperature=293.15,
+    logP_threshold=10,
+)
+bfactor_plot.plot(f"{results_path}/6XG5_deltaG_APO-TRI.pdb")
+
+
+
+

You can visualize the results in PyMOL by running the following commands:

+
spectrum b, green_white_magenta, minimum=-20, maximum=20; select nans, not (b=0 or b>0 or b<0); color grey20, nans;
+
+
+

nans are Prolines and residues with no coverage.

+

export logPFs to a csv

+
+
[9]:
+
+
+
import MDAnalysis
+from pigeon_feather.analysis import get_res_avg_logP, get_res_avg_logP_std
+
+pdb_file = "./data/6XG5_TRI.pdb"
+index_offset = get_index_offset(ana_apo_1, pdb_file)
+
+
+def logPF_to_deltaG(ana_obj, logPF):
+    """
+    :param logPF: logP value
+    :return: deltaG in kJ/mol, local unfolding energy
+    """
+
+    return 8.3145 * ana_obj.temperature * np.log(10) * logPF / 1000
+
+
+def create_logP_df(ana_obj, index_offset):
+    df_logPF = pd.DataFrame()
+
+    for res_i, _ in enumerate(ana_obj.results_obj.protein_sequence):
+        res_obj_i = ana_obj.results_obj.get_residue_by_resindex(res_i)
+
+        avg_logP, std_logP = get_res_avg_logP(res_obj_i)
+        #std_logP = get_res_avg_logP_std(res_obj_i)
+
+        df_i = pd.DataFrame(
+            {
+                "resid": [res_obj_i.resid - index_offset],
+                #"resname": [res_obj_i.resname],
+                "resname": [MDAnalysis.lib.util.convert_aa_code(res_obj_i.resname)],
+                'avg_dG': [logPF_to_deltaG(ana_obj, avg_logP)],
+                'std_dG': [logPF_to_deltaG(ana_obj, std_logP)],
+                "avg_logP": [avg_logP],
+                "std_logP": [max(std_logP, 0.35)],
+                "is_nan": [res_obj_i.is_nan()],
+            }
+        )
+
+        if res_obj_i.is_nan():
+            df_i["single resloved"] = [np.nan]
+            df_i["min_pep logPs"] = [np.nan]
+
+        else:
+            df_i["single resloved"] = [res_obj_i.mini_pep.if_single_residue()]
+            df_i["min_pep logPs"] = [res_obj_i.clustering_results_logP]
+
+        df_logPF = pd.concat([df_logPF, df_i])
+
+    df_logPF = df_logPF.reset_index(drop=True)
+
+    return df_logPF
+
+
+df = create_logP_df(ana_apo_1, index_offset)
+df.to_csv(f"{results_path}/logP_APO_{today_date}.csv", index=False)
+
+
+
+
+
[10]:
+
+
+
# fecth two df and merge
+df_apo = create_logP_df(ana_apo_1, index_offset)
+df_tri = create_logP_df(ana_tri_1, index_offset)
+
+df = pd.merge(df_apo, df_tri, on="resid", suffixes=("_APO", "_TRI"))
+
+df.to_csv(f"{results_path}/logP_APO_TRI_{today_date}.csv", index=False)
+
+
+
+
+
[ ]:
+
+
+

+
+
+
+
+
+ + +
+
+ +
+
+
+
+ + + + \ No newline at end of file diff --git a/tutorials/05_plot_the_results.ipynb b/tutorials/05_plot_the_results.ipynb new file mode 100644 index 0000000..791aafb --- /dev/null +++ b/tutorials/05_plot_the_results.ipynb @@ -0,0 +1,448 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 05_plot_the_results" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Determination of memory status is not supported on this \n", + " platform, measuring for memoryleaks will never fail\n" + ] + } + ], + "source": [ + "from pigeon_feather.data import *\n", + "from pigeon_feather.plot import *\n", + "from pigeon_feather.hxio import *\n", + "from pigeon_feather.spectra import *\n", + "\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "\n", + "import datetime\n", + "import os\n", + "import pickle\n", + "import datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Number of peptides with experimental max_d: 358\n", + "Number of peptides with no experimental max_d: 12\n" + ] + } + ], + "source": [ + "# load the pickle file we saved in the previous notebook\n", + "\n", + "\n", + "today = datetime.date.today().strftime(\"%Y%m%d\")\n", + "today = \"20240722\"\n", + "\n", + "with open(f\"./data/hdxms_data_raw_{today}.pkl\", \"rb\") as f:\n", + " hdxms_data_list = pickle.load(f)\n", + "\n", + "\n", + "# back exchange correction for peptides with experimental full deuteration data based its closest match in the database\n", + "tools.backexchange_correction(hdxms_data_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# make folders for results\n", + "\n", + "today_date = datetime.date.today().strftime(\"%Y%m%d\")\n", + "# today_date = '20240722'\n", + "results_path = f\"ecDHFR_results_{today_date}\"\n", + "\n", + "if not os.path.exists(results_path):\n", + " os.makedirs(results_path)\n", + "\n", + "\n", + "out_path = \"./data/PF_input_20240722\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create an `Analysis` object and load the results. **Note:** The temperature and pH are crucial for calculating the intrinsic exchange rates, so make sure to input the correct values. The chunk size and chunk number can be altered by the user. In this tutorial, they were automatically determined by a helper function.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import Analysis, get_index_offset\n", + "from pigeon_feather.tools import optimal_chunks\n", + "import matplotlib.pyplot as plt\n", + "\n", + "RUN_NUM = 3\n", + "\n", + "apo_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"APO\"\n", + "]\n", + "\n", + "tri_states = [\n", + " state\n", + " for data in hdxms_data_list\n", + " for state in data.states\n", + " if state.state_name == \"TRI\"\n", + "]\n", + "\n", + "ana_apo_1 = Analysis(apo_states, temperature=293.0, pH=7.0)\n", + "\n", + "chunk_num, chunk_size = optimal_chunks(len(ana_apo_1.protein_sequence))\n", + "ana_apo_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"APO\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")\n", + "\n", + "\n", + "ana_tri_1 = Analysis(tri_states, temperature=293.0, pH=7.0)\n", + "\n", + "ana_tri_1.load_bayesian_hdx_oupt_chunks(\n", + " chunk_size=chunk_size,\n", + " chunk_num=chunk_num,\n", + " state_name=\"TRI\",\n", + " run_num=RUN_NUM,\n", + " N=200,\n", + " bayesian_hdx_data_folder=f\"{out_path}/bayesian_hdx_output_chunks\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## barplot of the kex" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "barplot showing the FEATHER derived exchange rates. index_offset is determined by comparison to the sequence in HX/MS and the pdb file provided." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# APO state only\n", + "\n", + "import numpy as np\n", + "\n", + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(40, 10), sharey=True, sharex=True)\n", + "\n", + "ana_apo_1.plot_kex_bar(\n", + " ax=axes[0], resolution_indicator_pos=15, label=\"APO\", show_seq=False, color=\"k\"\n", + ")\n", + "\n", + "ana_tri_1.plot_kex_bar(\n", + " ax=axes[1], resolution_indicator_pos=15, label=\"TRI\", show_seq=False, color=\"red\"\n", + ")\n", + "\n", + "from matplotlib.pyplot import step\n", + "from matplotlib.ticker import FuncFormatter, MultipleLocator\n", + "\n", + "from pigeon_feather.analysis import get_index_offset\n", + "\n", + "pdb_file = \"./data/6XG5_TRI.pdb\"\n", + "index_offset = get_index_offset(ana_apo_1, pdb_file)\n", + "\n", + "# # ax.xaxis.set_major_locator(plt.MultipleLocator(2))\n", + "axes[0].set_xticks(axes[0].get_xticks()[::2])\n", + "axes[0].set_xticklabels(axes[0].get_xticklabels(), fontdict={\"fontsize\": 24})\n", + "\n", + "\n", + "def format_func(value, tick_number):\n", + " return f\"{int(value - index_offset +1)}\"\n", + "\n", + "\n", + "axes[0].xaxis.set_major_formatter(FuncFormatter(format_func))\n", + "\n", + "seq_pos = 17\n", + "for ii in range(0, len(ana_apo_1.protein_sequence[:]), 2):\n", + " axes[0].text(\n", + " ii,\n", + " seq_pos,\n", + " ana_apo_1.protein_sequence[ii],\n", + " ha=\"center\",\n", + " va=\"center\",\n", + " fontsize=22,\n", + " )\n", + "\n", + "\n", + "for ax in axes:\n", + " ax.set_ylabel(\"-log(k$_{ex}$)\")\n", + " #ax.legend(loc=\"lower left\")\n", + " ax.yaxis.set_major_locator(plt.MultipleLocator(5))\n", + "\n", + " ax.plot(\n", + " [-3, len(ana_apo_1.protein_sequence) + 3],\n", + " [5, 5],\n", + " color=\"gray\",\n", + " lw=1,\n", + " linestyle=\"--\",\n", + " alpha=0.5,\n", + " )\n", + " ax.plot(\n", + " [-3, len(ana_apo_1.protein_sequence) + 3],\n", + " [10, 10],\n", + " color=\"gray\",\n", + " lw=1,\n", + " linestyle=\"--\",\n", + " alpha=0.5,\n", + " )\n", + "\n", + "\n", + "plt.subplots_adjust(hspace=0.08)\n", + "fig.savefig(f\"{results_path}/ecDHFR_kex_bar_APO_TRI_{today_date}.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "logP projection to a pdb structure" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from pigeon_feather.analysis import BFactorPlot" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "bfactor_plot = BFactorPlot(\n", + " ana_apo_1,\n", + " pdb_file=\"./data/6XG5_TRI.pdb\",\n", + " plot_deltaG=True,\n", + " temperature=293.15,\n", + " logP_threshold=10,\n", + ")\n", + "bfactor_plot.plot(f\"{results_path}/6XG5_APO_deltaG.pdb\")\n", + "\n", + "# bfactor_plot = BFactorPlot(\n", + "# ana_apo_1,\n", + "# pdb_file=\"./data/6XG5_APO_relaxed_best_solvated.pdb\",\n", + "# plot_deltaG=True,\n", + "# temperature=293.15,\n", + "# )\n", + "# bfactor_plot.plot(f\"{out_path}/6XG5_APO_deltaG.pdb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## delta log(PF)s" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "if there are mutiple states availble, you can map the difference to the pdb strutcure" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "bfactor_plot = BFactorPlot(\n", + " ana_apo_1,\n", + " ana_tri_1, \n", + " pdb_file=\"./data/6XG5_TRI.pdb\",\n", + " plot_deltaG=True,\n", + " temperature=293.15,\n", + " logP_threshold=10,\n", + ")\n", + "bfactor_plot.plot(f\"{results_path}/6XG5_deltaG_APO-TRI.pdb\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can visualize the results in PyMOL by running the following commands:\n", + "\n", + "```bash\n", + "spectrum b, green_white_magenta, minimum=-20, maximum=20; select nans, not (b=0 or b>0 or b<0); color grey20, nans;\n", + "```\n", + "\n", + "`nans` are Prolines and residues with no coverage." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "export logPFs to a csv" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "import MDAnalysis\n", + "from pigeon_feather.analysis import get_res_avg_logP, get_res_avg_logP_std\n", + "\n", + "pdb_file = \"./data/6XG5_TRI.pdb\"\n", + "index_offset = get_index_offset(ana_apo_1, pdb_file)\n", + "\n", + "\n", + "def logPF_to_deltaG(ana_obj, logPF):\n", + " \"\"\"\n", + " :param logPF: logP value\n", + " :return: deltaG in kJ/mol, local unfolding energy\n", + " \"\"\"\n", + "\n", + " return 8.3145 * ana_obj.temperature * np.log(10) * logPF / 1000\n", + "\n", + "\n", + "def create_logP_df(ana_obj, index_offset):\n", + " df_logPF = pd.DataFrame()\n", + "\n", + " for res_i, _ in enumerate(ana_obj.results_obj.protein_sequence):\n", + " res_obj_i = ana_obj.results_obj.get_residue_by_resindex(res_i)\n", + "\n", + " avg_logP, std_logP = get_res_avg_logP(res_obj_i)\n", + " #std_logP = get_res_avg_logP_std(res_obj_i)\n", + "\n", + " df_i = pd.DataFrame(\n", + " {\n", + " \"resid\": [res_obj_i.resid - index_offset],\n", + " #\"resname\": [res_obj_i.resname],\n", + " \"resname\": [MDAnalysis.lib.util.convert_aa_code(res_obj_i.resname)],\n", + " 'avg_dG': [logPF_to_deltaG(ana_obj, avg_logP)],\n", + " 'std_dG': [logPF_to_deltaG(ana_obj, std_logP)],\n", + " \"avg_logP\": [avg_logP],\n", + " \"std_logP\": [max(std_logP, 0.35)],\n", + " \"is_nan\": [res_obj_i.is_nan()],\n", + " }\n", + " )\n", + "\n", + " if res_obj_i.is_nan():\n", + " df_i[\"single resloved\"] = [np.nan]\n", + " df_i[\"min_pep logPs\"] = [np.nan]\n", + "\n", + " else:\n", + " df_i[\"single resloved\"] = [res_obj_i.mini_pep.if_single_residue()]\n", + " df_i[\"min_pep logPs\"] = [res_obj_i.clustering_results_logP]\n", + "\n", + " df_logPF = pd.concat([df_logPF, df_i])\n", + "\n", + " df_logPF = df_logPF.reset_index(drop=True)\n", + "\n", + " return df_logPF\n", + "\n", + "\n", + "df = create_logP_df(ana_apo_1, index_offset)\n", + "df.to_csv(f\"{results_path}/logP_APO_{today_date}.csv\", index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# fecth two df and merge\n", + "df_apo = create_logP_df(ana_apo_1, index_offset)\n", + "df_tri = create_logP_df(ana_tri_1, index_offset)\n", + "\n", + "df = pd.merge(df_apo, df_tri, on=\"resid\", suffixes=(\"_APO\", \"_TRI\"))\n", + "\n", + "df.to_csv(f\"{results_path}/logP_APO_TRI_{today_date}.csv\", index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pigeon_feather", + "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.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}